diff --git a/iso/iso.cpp b/iso/iso.cpp
index d166a5d1..39bec5e8 100644
--- a/iso/iso.cpp
+++ b/iso/iso.cpp
@@ -1,526 +1,526 @@
 /*****************************************************************************
  * Copyright (C) 2000 David Faure <faure@kde.org>                            *
  * Copyright (C) 2002 Szombathelyi György <gyurco@users.sourceforge.net>     *
  * Copyright (C) 2003 Leo Savernik <l.savernik@aon.at>                       *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is heavily based on ktar from kdelibs                           *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "iso.h"
 
 #include <zlib.h>
 
 // QtCore
 #include <QByteArray>
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <qplatformdefs.h>
 
 #include "libisofs/iso_fs.h"
 #include "kiso.h"
 #include "kisofile.h"
 #include "kisodirectory.h"
 
 using namespace KIO;
 extern "C"
 {
 
     int Q_DECL_EXPORT kdemain(int argc, char **argv) {
         //qDebug()   << "Starting " << getpid() << endl;
 
         if (argc != 4) {
             fprintf(stderr, "Usage: kio_iso protocol domain-socket1 domain-socket2\n");
             exit(-1);
         }
 
         kio_isoProtocol slave(argv[2], argv[3]);
         slave.dispatchLoop();
 
         //qDebug()   << "Done" << endl;
         return 0;
     }
 
 } // extern "C"
 
 typedef struct {
     char magic[8];
     char uncompressed_len[4];
     unsigned char header_size;
     unsigned char block_size;
     char reserved[2];   /* Reserved for future use, MBZ */
 } compressed_file_header;
 
 static const unsigned char zisofs_magic[8] = {
     0x37, 0xE4, 0x53, 0x96, 0xC9, 0xDB, 0xD6, 0x07
 };
 
 
 kio_isoProtocol::kio_isoProtocol(const QByteArray &pool, const QByteArray &app) : SlaveBase("iso", pool, app)
 {
     //qDebug() << "kio_isoProtocol::kio_isoProtocol" << endl;
-    m_isoFile = 0L;
+    m_isoFile = nullptr;
 }
 
 kio_isoProtocol::~kio_isoProtocol()
 {
     delete m_isoFile;
 }
 
 bool kio_isoProtocol::checkNewFile(QString fullPath, QString & path, int startsec)
 {
     //qDebug()   << "kio_isoProtocol::checkNewFile " << fullPath << " startsec: " <<
     //startsec << endl;
 
     // Are we already looking at that file ?
     if (m_isoFile && startsec == m_isoFile->startSec() &&
             m_isoFile->fileName() == fullPath.left(m_isoFile->fileName().length())) {
         // Has it changed ?
         QT_STATBUF statbuf;
         if (QT_STAT(QFile::encodeName(m_isoFile->fileName()), &statbuf) == 0) {
             if (m_mtime == statbuf.st_mtime) {
                 path = fullPath.mid(m_isoFile->fileName().length());
                 //qDebug()   << "kio_isoProtocol::checkNewFile returning " << path << endl;
                 if(path.endsWith(DIR_SEPARATOR_CHAR)) {
                     path.chop(1);
                 }
                 if(path.isEmpty()) {
                     path = DIR_SEPARATOR_CHAR;
                 }
                 return true;
             }
         }
     }
     //qDebug() << "Need to open a new file" << endl;
 
     // Close previous file
     if (m_isoFile) {
         m_isoFile->close();
         delete m_isoFile;
-        m_isoFile = 0L;
+        m_isoFile = nullptr;
     }
 
     // Find where the iso file is in the full path
     int pos = 0;
     QString isoFile;
     path.clear();
 
     int len = fullPath.length();
     if (len != 0 && fullPath[ len - 1 ] != DIR_SEPARATOR_CHAR)
         fullPath += DIR_SEPARATOR_CHAR;
 
     //qDebug()   << "the full path is " << fullPath << endl;
     while ((pos = fullPath.indexOf(DIR_SEPARATOR_CHAR, pos + 1)) != -1) {
         QString tryPath = fullPath.left(pos);
         //qDebug()   << fullPath << "  trying " << tryPath << endl;
 
         QT_STATBUF statbuf;
         if (QT_LSTAT(QFile::encodeName(tryPath), &statbuf) == 0 && !S_ISDIR(statbuf.st_mode)) {
             bool isFile = true;
             if (S_ISLNK(statbuf.st_mode)) {
                 char symDest[256];
                 memset(symDest, 0, 256);
                 int endOfName = readlink(QFile::encodeName(tryPath), symDest, 256);
                 if (endOfName != -1) {
                     if (QDir(QString::fromLocal8Bit(symDest)).exists())
                         isFile = false;
                 }
             }
 
             if (isFile) {
                 isoFile = tryPath;
                 m_mtime = statbuf.st_mtime;
                 m_mode = statbuf.st_mode;
                 path = fullPath.mid(pos + 1);
                 //qDebug()   << "fullPath=" << fullPath << " path=" << path << endl;
                 if(path.endsWith(DIR_SEPARATOR_CHAR)) {
                     path.chop(1);
                 }
                 if(path.isEmpty()) {
                     path = DIR_SEPARATOR_CHAR;
                 }
                 //qDebug()   << "Found. isoFile=" << isoFile << " path=" << path << endl;
                 break;
             }
         }
     }
     if (isoFile.isEmpty()) {
         //qDebug()   << "kio_isoProtocol::checkNewFile: not found" << endl;
         return false;
     }
 
     // Open new file
     //qDebug() << "Opening KIso on " << isoFile << endl;
     m_isoFile = new KIso(isoFile);
     m_isoFile->setStartSec(startsec);
     if (!m_isoFile->open(QIODevice::ReadOnly)) {
         //qDebug()   << "Opening " << isoFile << " failed." << endl;
         delete m_isoFile;
-        m_isoFile = 0L;
+        m_isoFile = nullptr;
         return false;
     }
 
     return true;
 }
 
 
 void kio_isoProtocol::createUDSEntry(const KArchiveEntry * isoEntry, UDSEntry & entry)
 {
     entry.clear();
     entry.insert(UDSEntry::UDS_NAME, isoEntry->name());
     entry.insert(UDSEntry::UDS_FILE_TYPE, isoEntry->permissions() & S_IFMT);   // keep file type only
     entry.insert(UDSEntry::UDS_ACCESS, isoEntry->permissions() & 07777);   // keep permissions only
 
     if (isoEntry->isFile()) {
         long long si = ((KIsoFile *)isoEntry)->realsize();
         if (!si) si = ((KIsoFile *)isoEntry)->size();
         entry.insert(UDSEntry::UDS_SIZE, si);
     } else {
         entry.insert(UDSEntry::UDS_SIZE, 0L);
     }
 
     entry.insert(UDSEntry::UDS_USER, isoEntry->user());
     entry.insert(UDSEntry::UDS_GROUP, isoEntry->group());
     entry.insert((uint)UDSEntry::UDS_MODIFICATION_TIME, isoEntry->date().toTime_t());
     entry.insert(UDSEntry::UDS_ACCESS_TIME,
                  isoEntry->isFile() ? ((KIsoFile *)isoEntry)->adate() :
                  ((KIsoDirectory *)isoEntry)->adate());
 
     entry.insert(UDSEntry::UDS_CREATION_TIME,
                  isoEntry->isFile() ? ((KIsoFile *)isoEntry)->cdate() :
                  ((KIsoDirectory *)isoEntry)->cdate());
 
     entry.insert(UDSEntry::UDS_LINK_DEST, isoEntry->symLinkTarget());
 }
 
 void kio_isoProtocol::listDir(const QUrl &url)
 {
     //qDebug() << "kio_isoProtocol::listDir " << url.url() << endl;
 
     QString path;
     if (!checkNewFile(getPath(url), path, url.hasFragment() ? url.fragment(QUrl::FullyDecoded).toInt() : -1)) {
         QByteArray _path(QFile::encodeName(getPath(url)));
         //qDebug()  << "Checking (stat) on " << _path << endl;
         QT_STATBUF buff;
         if (QT_STAT(_path.data(), &buff) == -1 || !S_ISDIR(buff.st_mode)) {
             error(KIO::ERR_DOES_NOT_EXIST, getPath(url));
             return;
         }
         // It's a real dir -> redirect
         QUrl redir;
         redir.setPath(getPath(url));
         if (url.hasFragment()) redir.setFragment(url.fragment(QUrl::FullyDecoded));
         //qDebug()  << "Ok, redirection to " << redir.url() << endl;
         redir.setScheme("file");
         redirection(redir);
         finished();
         // And let go of the iso file - for people who want to unmount a cdrom after that
         delete m_isoFile;
-        m_isoFile = 0L;
+        m_isoFile = nullptr;
         return;
     }
 
     if (path.isEmpty()) {
         QUrl redir(QStringLiteral("iso:/"));
         //qDebug() << "url.path()==" << getPath(url) << endl;
         if (url.hasFragment()) redir.setFragment(url.fragment(QUrl::FullyDecoded));
         redir.setPath(getPath(url) + QString::fromLatin1(DIR_SEPARATOR));
         //qDebug() << "kio_isoProtocol::listDir: redirection " << redir.url() << endl;
         redir.setScheme("file");
         redirection(redir);
         finished();
         return;
     }
 
     //qDebug()  << "checkNewFile done" << endl;
     const KArchiveDirectory* root = m_isoFile->directory();
     const KArchiveDirectory* dir;
     if (!path.isEmpty() && path != DIR_SEPARATOR) {
         //qDebug()   << QString("Looking for entry %1").arg(path) << endl;
         const KArchiveEntry* e = root->entry(path);
         if (!e) {
             error(KIO::ERR_DOES_NOT_EXIST, path);
             return;
         }
         if (! e->isDirectory()) {
             error(KIO::ERR_IS_FILE, path);
             return;
         }
         dir = (KArchiveDirectory*)e;
     } else {
         dir = root;
     }
 
     QStringList l = dir->entries();
     totalSize(l.count());
 
     UDSEntry entry;
     QStringList::Iterator it = l.begin();
     for (; it != l.end(); ++it) {
         //qDebug()   << (*it) << endl;
         const KArchiveEntry* isoEntry = dir->entry((*it));
 
         createUDSEntry(isoEntry, entry);
 
         listEntry(entry);
     }
 
     finished();
     //qDebug()  << "kio_isoProtocol::listDir done" << endl;
 }
 
 void kio_isoProtocol::stat(const QUrl &url)
 {
     QString path;
     UDSEntry entry;
 
     //qDebug() << "kio_isoProtocol::stat " << url.url() << endl;
     if (!checkNewFile(getPath(url), path, url.hasFragment() ? url.fragment(QUrl::FullyDecoded).toInt() : -1)) {
         // We may be looking at a real directory - this happens
         // when pressing up after being in the root of an archive
         QByteArray _path(QFile::encodeName(getPath(url)));
         //qDebug()  << "kio_isoProtocol::stat (stat) on " << _path << endl;
         QT_STATBUF buff;
         if (QT_STAT(_path.data(), &buff) == -1 || !S_ISDIR(buff.st_mode)) {
             //qDebug() << "isdir=" << S_ISDIR(buff.st_mode) << "  errno=" << strerror(errno) << endl;
             error(KIO::ERR_DOES_NOT_EXIST, getPath(url));
             return;
         }
         // Real directory. Return just enough information for KRun to work
         entry.insert(UDSEntry::UDS_NAME, url.fileName());
         //qDebug()  << "kio_isoProtocol::stat returning name=" << url.fileName() << endl;
 
         entry.insert(UDSEntry::UDS_FILE_TYPE, buff.st_mode & S_IFMT);
 
         statEntry(entry);
 
         finished();
 
         // And let go of the iso file - for people who want to unmount a cdrom after that
         delete m_isoFile;
-        m_isoFile = 0L;
+        m_isoFile = nullptr;
         return;
     }
 
     const KArchiveDirectory* root = m_isoFile->directory();
     const KArchiveEntry* isoEntry;
     if (path.isEmpty()) {
         path = QString::fromLatin1(DIR_SEPARATOR);
         isoEntry = root;
     } else {
         isoEntry = root->entry(path);
     }
     if (!isoEntry) {
         error(KIO::ERR_DOES_NOT_EXIST, path);
         return;
     }
     createUDSEntry(isoEntry, entry);
     statEntry(entry);
     finished();
 }
 
 void kio_isoProtocol::getFile(const KIsoFile *isoFileEntry, const QString &path)
 {
     unsigned long long size, pos = 0;
     bool mime = false, zlib = false;
     QByteArray fileData, pointer_block, inbuf, outbuf;
-    char *pptr = 0;
+    char *pptr = nullptr;
     compressed_file_header *hdr;
     int block_shift;
     unsigned long nblocks;
     unsigned long fullsize = 0, block_size = 0, block_size2 = 0;
     size_t ptrblock_bytes;
     unsigned long cstart, cend, csize;
     uLong bytes;
 
     size = isoFileEntry->realsize();
     if (size >= sizeof(compressed_file_header)) zlib = true;
     if (!size) size = isoFileEntry->size();
     totalSize(size);
     if (!size) mimeType("application/x-zerosize");
 
     if (size && !m_isoFile->device()->isOpen()) {
         m_isoFile->device()->open(QIODevice::ReadOnly);
 
         // seek(0) ensures integrity with the QIODevice's built-in buffer
         // see bug #372023 for details
         m_isoFile->device()->seek(0);
     }
 
     if (zlib) {
         fileData = isoFileEntry->dataAt(0, sizeof(compressed_file_header));
         if (fileData.size() == sizeof(compressed_file_header) &&
                 !memcmp(fileData.data(), zisofs_magic, sizeof(zisofs_magic))) {
 
             hdr = (compressed_file_header*) fileData.data();
             block_shift = hdr->block_size;
             block_size  = 1UL << block_shift;
             block_size2 = block_size << 1;
             fullsize    = isonum_731(hdr->uncompressed_len);
             nblocks = (fullsize + block_size - 1) >> block_shift;
             ptrblock_bytes = (nblocks + 1) * 4;
             pointer_block = isoFileEntry->dataAt(hdr->header_size << 2, ptrblock_bytes);
             if ((unsigned long)pointer_block.size() == ptrblock_bytes) {
                 inbuf.resize(block_size2);
                 if (inbuf.size()) {
                     outbuf.resize(block_size);
 
                     if (outbuf.size())
                         pptr = pointer_block.data();
                     else {
                         error(KIO::ERR_COULD_NOT_READ, path);
                         return;
                     }
                 } else {
                     error(KIO::ERR_COULD_NOT_READ, path);
                     return;
                 }
             } else {
                 error(KIO::ERR_COULD_NOT_READ, path);
                 return;
             }
         } else {
             zlib = false;
         }
     }
 
     while (pos < size) {
         if (zlib) {
             cstart = isonum_731(pptr);
             pptr += 4;
             cend   = isonum_731(pptr);
 
             csize = cend - cstart;
 
             if (csize == 0) {
                 outbuf.fill(0, -1);
             } else {
                 if (csize > block_size2) {
                     //err = EX_DATAERR;
                     break;
                 }
 
                 inbuf = isoFileEntry->dataAt(cstart, csize);
                 if ((unsigned long)inbuf.size() != csize) {
                     break;
                 }
 
                 bytes = block_size; // Max output buffer size
                 if ((uncompress((Bytef*) outbuf.data(), &bytes, (Bytef*) inbuf.data(), csize)) != Z_OK) {
                     break;
                 }
             }
 
             if (((fullsize > block_size) && (bytes != block_size))
                     || ((fullsize <= block_size) && (bytes < fullsize))) {
 
                 break;
             }
 
             if (bytes > fullsize)
                 bytes = fullsize;
             fileData = outbuf;
             fileData.resize(bytes);
             fullsize -= bytes;
         } else {
             fileData = isoFileEntry->dataAt(pos, 65536);
             if (fileData.size() == 0) break;
         }
         if (!mime) {
             QMimeDatabase db;
             QMimeType mt = db.mimeTypeForFileNameAndData(path, fileData);
             if (mt.isValid()) {
                 //qDebug() << "Emitting mimetype " << mt.name() << endl;
                 mimeType(mt.name());
                 mime = true;
             }
         }
         data(fileData);
         pos += fileData.size();
         processedSize(pos);
     }
 
     if (pos != size) {
         error(KIO::ERR_COULD_NOT_READ, path);
         return;
     }
 
     fileData.resize(0);
     data(fileData);
     processedSize(pos);
     finished();
 
 }
 
 void kio_isoProtocol::get(const QUrl &url)
 {
     //qDebug()  << "kio_isoProtocol::get" << url.url() << endl;
 
     QString path;
     if (!checkNewFile(getPath(url), path, url.hasFragment() ? url.fragment(QUrl::FullyDecoded).toInt() : -1)) {
         error(KIO::ERR_DOES_NOT_EXIST, getPath(url));
         return;
     }
 
     const KArchiveDirectory* root = m_isoFile->directory();
     const KArchiveEntry* isoEntry = root->entry(path);
 
     if (!isoEntry) {
         error(KIO::ERR_DOES_NOT_EXIST, path);
         return;
     }
     if (isoEntry->isDirectory()) {
         error(KIO::ERR_IS_DIRECTORY, path);
         return;
     }
 
-    const KIsoFile* isoFileEntry = static_cast<const KIsoFile *>(isoEntry);
+    const auto* isoFileEntry = dynamic_cast<const KIsoFile *>(isoEntry);
     if (!isoEntry->symLinkTarget().isEmpty()) {
         //qDebug() << "Redirection to " << isoEntry->symLinkTarget() << endl;
         QUrl realURL = QUrl(url).resolved(QUrl(isoEntry->symLinkTarget()));
         //qDebug() << "realURL= " << realURL.url() << endl;
         realURL.setScheme("file");
         redirection(realURL);
         finished();
         return;
     }
     getFile(isoFileEntry, path);
     if (m_isoFile->device()->isOpen()) m_isoFile->device()->close();
 }
 
 QString kio_isoProtocol::getPath(const QUrl &url)
 {
     QString path = url.path();
     REPLACE_DIR_SEP2(path);
 
 #ifdef Q_WS_WIN
     if (path.startsWith(DIR_SEPARATOR)) {
         int p = 1;
         while (p < path.length() && path[ p ] == DIR_SEPARATOR_CHAR)
             p++;
         /* /C:/Folder */
         if (p + 2 <= path.length() && path[ p ].isLetter() && path[ p + 1 ] == ':') {
             path = path.mid(p);
         }
     }
 #endif
     return path;
 }
diff --git a/iso/kiso.cpp b/iso/kiso.cpp
index 5c990225..545c7e44 100644
--- a/iso/kiso.cpp
+++ b/iso/kiso.cpp
@@ -1,521 +1,521 @@
 /*****************************************************************************
  * Copyright (C) 2000 David Faure <faure@kde.org>                            *
  * Copyright (C) 2002 Szombathelyi György <gyurco@users.sourceforge.net>     *
  * Copyright (C) 2003 Leo Savernik <l.savernik@aon.at>                       *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is heavily based on ktar from kdelibs                           *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kiso.h"
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <qplatformdefs.h>
 
 #include <KConfigCore/KConfig>
 #include <KConfigCore/KConfigGroup>
 #include <KArchive/KFilterBase>
 #include <KArchive/KFilterDev>
 
 #include "libisofs/isofs.h"
 #include "qfilehack.h"
 
 #ifdef Q_OS_LINUX
 #undef __STRICT_ANSI__
 #include <linux/cdrom.h>
 #define __STRICT_ANSI__
 #include <sys/ioctl.h>
 #include <fcntl.h>
 #endif
 
 ////////////////////////////////////////////////////////////////////////
 /////////////////////////// KIso ///////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 
 /**
  * puts the track layout of the device 'fname' into 'tracks'
  * tracks structure: start sector, track number, ...
  * tracks should be 100*2 entry long (this is the maximum in the CD-ROM standard)
  * currently it's linux only, porters are welcome
  */
 
 static int getTracks(const char *fname, int *tracks)
 {
     KRFUNC;
     int ret = 0;
     memset(tracks, 0, 200*sizeof(int));
 
 #ifdef Q_OS_LINUX
     int fd, i;
     struct cdrom_tochdr tochead;
     struct cdrom_tocentry tocentry;
 
     //qDebug() << "getTracks open:" << fname << endl;
     fd = QT_OPEN(fname, O_RDONLY | O_NONBLOCK);
     if (fd > 0) {
         if (ioctl(fd, CDROMREADTOCHDR, &tochead) != -1) {
 //            qDebug() << "getTracks first track:" << tochead.cdth_trk0
 //            << " last track " << tochead.cdth_trk1 << endl;
             for (i = tochead.cdth_trk0;i <= tochead.cdth_trk1;++i) {
                 if (ret > 99) break;
                 memset(&tocentry, 0, sizeof(struct cdrom_tocentry));
                 tocentry.cdte_track = i;
                 tocentry.cdte_format = CDROM_LBA;
                 if (ioctl(fd, CDROMREADTOCENTRY, &tocentry) < 0) break;
 //                qDebug() << "getTracks got track " << i << " starting at: " <<
 //                tocentry.cdte_addr.lba << endl;
                 if ((tocentry.cdte_ctrl & 0x4) == 0x4) {
                     tracks[ret<<1] = tocentry.cdte_addr.lba;
                     tracks[(ret<<1)+1] = i;
                     ret++;
                 }
             }
         }
         close(fd);
     }
 
 #endif
 
     return ret;
 }
 
 class KIso::KIsoPrivate
 {
 public:
-    KIsoPrivate() {}
+    KIsoPrivate() = default;
     QStringList dirList;
 };
 
 KIso::KIso(const QString& filename, const QString & _mimetype)
-        : KArchive(0L)
+        : KArchive(nullptr)
 {
     KRFUNC;
     KRDEBUG("Starting KIso: " << filename << " - type: " << _mimetype);
 
     m_startsec = -1;
     m_filename = filename;
     d = new KIsoPrivate;
     QString mimetype(_mimetype);
     bool forced = true;
     if (mimetype.isEmpty()) {
         QMimeDatabase db;
         QMimeType mt = db.mimeTypeForFile(filename, QMimeDatabase::MatchContent);
         if (mt.isValid())
             mimetype = mt.name();
 
         //qDebug() << "KIso::KIso mimetype=" << mimetype << endl;
 
         // Don't move to prepareDevice - the other constructor theoretically allows ANY filter
         if (mimetype == "application/x-tgz" || mimetype == "application/x-targz" ||  // the latter is deprecated but might still be around
                 mimetype == "application/x-webarchive")
             // that's a gzipped tar file, so ask for gzip filter
             mimetype = "application/x-gzip";
         else if (mimetype == "application/x-tbz")   // that's a bzipped2 tar file, so ask for bz2 filter
             mimetype = "application/x-bzip2";
         else {
             // Something else. Check if it's not really gzip though (e.g. for KOffice docs)
             QFile file(filename);
             if (file.open(QIODevice::ReadOnly)) {
                 char firstByte;
                 char secondByte;
                 char thirdByte;
                 file.getChar(&firstByte);
                 file.getChar(&secondByte);
                 file.getChar(&thirdByte);
                 if (firstByte == 0037 && secondByte == (char)0213)
                     mimetype = "application/x-gzip";
                 else if (firstByte == 'B' && secondByte == 'Z' && thirdByte == 'h')
                     mimetype = "application/x-bzip2";
                 else if (firstByte == 'P' && secondByte == 'K' && thirdByte == 3) {
                     char fourthByte;
                     file.getChar(&fourthByte);
                     if (fourthByte == 4)
                         mimetype = "application/x-zip";
                 }
             }
         }
         forced = false;
     }
 
     prepareDevice(filename, mimetype, forced);
 }
 
 void KIso::prepareDevice(const QString & filename,
                          const QString & mimetype, bool forced)
 {
     KRFUNC;
     KRDEBUG("Preparing: " << filename << " - type: " << mimetype << " - using the force: " << forced);
     /* 'hack' for Qt's false assumption that only S_ISREG is seekable */
     if ("inode/blockdevice" == mimetype)
         setDevice(new QFileHack(filename));
     else {
         if ("application/x-gzip" == mimetype
                 || "application/x-bzip2" == mimetype)
             forced = true;
 
 
         KCompressionDevice *device;
         if(mimetype.isEmpty()) {
             device = new KFilterDev(filename);
         } else {
             device = new KCompressionDevice(filename, KFilterDev::compressionTypeForMimeType(mimetype));
         }
         if (device->compressionType() == KCompressionDevice::None && forced) {
             delete device;
         } else {
             setDevice(device);
         }
     }
 
 }
 
 KIso::KIso(QIODevice * dev)
         : KArchive(dev)
 {
     d = new KIsoPrivate;
 }
 
 KIso::~KIso()
 {
     // mjarrett: Closes to prevent ~KArchive from aborting w/o device
     if (isOpen())
         close();
     if (!m_filename.isEmpty())
         delete device(); // we created it ourselves
     delete d;
 }
 
 /* callback function for libisofs */
 static int readf(char *buf, unsigned int start, unsigned int len, void *udata)
 {
     KRFUNC;
 
     QIODevice* dev = (static_cast<KIso*>(udata))->device();
 
     // seek(0) ensures integrity with the QIODevice's built-in buffer
     // see bug #372023 for details
     dev->seek(0);
 
     if (dev->seek((qint64)start << (qint64)11)) {
         if ((dev->read(buf, len << 11u)) != -1) return (len);
     }
     //qDebug() << "KIso::ReadRequest failed start: " << start << " len: " << len << endl;
 
     return -1;
 }
 
 /* callback function for libisofs */
 static int mycallb(struct iso_directory_record *idr, void *udata)
 {
     KRFUNC;
 
-    KIso *iso = static_cast<KIso*>(udata);
+    auto *iso = static_cast<KIso*>(udata);
     QString path, user, group, symlink;
     int i;
     int access;
     int time, cdate, adate;
     rr_entry rr;
     bool special = false;
-    KArchiveEntry *entry = NULL, *oldentry = NULL;
+    KArchiveEntry *entry = nullptr, *oldentry = nullptr;
     char z_algo[2], z_params[2];
     long long z_size = 0;
 
     if ((idr->flags[0] & 1) && !iso->showhidden) return 0;
     if (iso->level) {
         if (isonum_711(idr->name_len) == 1) {
             switch (idr->name[0]) {
             case 0:
                 path += (".");
                 special = true;
                 break;
             case 1:
                 path += ("..");
                 special = true;
                 break;
             }
         }
         if (iso->showrr && ParseRR(idr, &rr) > 0) {
             if (!special) path = rr.name;
             symlink = rr.sl;
             access = rr.mode;
             time = rr.t_mtime;
             adate = rr.t_atime;
             cdate = rr.t_ctime;
             user.setNum(rr.uid);
             group.setNum(rr.gid);
             z_algo[0] = rr.z_algo[0];z_algo[1] = rr.z_algo[1];
             z_params[0] = rr.z_params[0];z_params[1] = rr.z_params[1];
             z_size = rr.z_size;
         } else {
             access = iso->dirent->permissions() & ~S_IFMT;
             adate = cdate = time = isodate_915(idr->date, 0);
             user = iso->dirent->user();
             group = iso->dirent->group();
             if (idr->flags[0] & 2) access |= S_IFDIR; else access |= S_IFREG;
             if (!special) {
                 if (iso->joliet) {
                     for (i = 0;i < (isonum_711(idr->name_len) - 1);i += 2) {
                         void *p = &(idr->name[i]);
                         QChar ch(be2me_16(*(ushort *)p));
                         if (ch == ';') break;
                         path += ch;
                     }
                 } else {
                     for (i = 0;i < isonum_711(idr->name_len);++i) {
                         if (idr->name[i] == ';') break;
                         if (idr->name[i]) path += (idr->name[i]);
                     }
                 }
                 if (path.endsWith('.')) path.resize(path.length() - 1);
             }
         }
         if (iso->showrr) FreeRR(&rr);
         if (idr->flags[0] & 2) {
             entry = new KIsoDirectory(iso, path, access | S_IFDIR, time, adate, cdate,
                                       user, group, symlink);
         } else {
             entry = new KIsoFile(iso, path, access, time, adate, cdate,
                                  user, group, symlink, (long long)(isonum_733(idr->extent)) << (long long)11, isonum_733(idr->size));
-            if (z_size)(static_cast <KIsoFile*>(entry))->setZF(z_algo, z_params, z_size);
+            if (z_size)(dynamic_cast <KIsoFile*>(entry))->setZF(z_algo, z_params, z_size);
 
         }
         iso->dirent->addEntry(entry);
     }
     if ((idr->flags[0] & 2) && (iso->level == 0 || !special)) {
         if (iso->level) {
             oldentry = iso->dirent;
-            iso->dirent = static_cast<KIsoDirectory*>(entry);
+            iso->dirent = dynamic_cast<KIsoDirectory*>(entry);
         }
         iso->level++;
         ProcessDir(&readf, isonum_733(idr->extent), isonum_733(idr->size), &mycallb, udata);
         iso->level--;
-        if (iso->level) iso->dirent = static_cast<KIsoDirectory*>(oldentry);
+        if (iso->level) iso->dirent = dynamic_cast<KIsoDirectory*>(oldentry);
     }
     return 0;
 }
 
 void KIso::addBoot(struct el_torito_boot_descriptor* bootdesc)
 {
     KRFUNC;
 
     int i;
     long long size;
     boot_head boot;
     boot_entry *be;
     QString path;
     KIsoFile *entry;
 
     path = "Catalog";
     entry = new KIsoFile(this, path, dirent->permissions() & ~S_IFDIR,
                          dirent->date(), dirent->adate(), dirent->cdate(),
                          dirent->user(), dirent->group(), QString(),
                          (long long)isonum_731(bootdesc->boot_catalog) << (long long)11, (long long)2048);
     dirent->addEntry(entry);
     if (!ReadBootTable(&readf, isonum_731(bootdesc->boot_catalog), &boot, this)) {
         i = 1;
         be = boot.defentry;
         while (be) {
             size = BootImageSize(isonum_711(be->data.d_e.media),
                                  isonum_721(be->data.d_e.seccount));
             path = "Default Image";
             if (i > 1) path += " (" + QString::number(i) + ')';
             entry = new KIsoFile(this, path, dirent->permissions() & ~S_IFDIR,
                                  dirent->date(), dirent->adate(), dirent->cdate(),
                                  dirent->user(), dirent->group(), QString(),
                                  (long long)isonum_731(be->data.d_e.start) << (long long)11, size << (long long)9);
             dirent->addEntry(entry);
             be = be->next;
             i++;
         }
 
         FreeBootTable(&boot);
     }
 }
 
 void KIso::readParams()
 {
     KRFUNC;
     KConfig *config;
 
     config = new KConfig("kio_isorc");
 
     KConfigGroup group(config, QString());
     showhidden = group.readEntry("showhidden", false);
     showrr = group.readEntry("showrr", true);
     delete config;
 }
 
 bool KIso::openArchive(QIODevice::OpenMode mode)
 {
     KRFUNC;
     iso_vol_desc *desc;
     QString path, uid, gid;
     QT_STATBUF buf;
     int tracks[2*100], trackno = 0, i, access, c_b, c_i, c_j;
     KArchiveDirectory *root;
     struct iso_directory_record* idr;
     struct el_torito_boot_descriptor* bootdesc;
 
     if (mode == QIODevice::WriteOnly)
         return false;
 
     readParams();
     d->dirList.clear();
 
     tracks[0] = 0;
     if (m_startsec > 0) tracks[0] = m_startsec;
     //qDebug() << " m_startsec: " << m_startsec << endl;
     /* We'll use the permission and user/group of the 'host' file except
      * in Rock Ridge, where the permissions are stored on the file system
      */
     if (QT_STAT(m_filename.toLocal8Bit(), &buf) < 0) {
         /* defaults, if stat fails */
         memset(&buf, 0, sizeof(struct stat));
         buf.st_mode = 0777;
     } else {
         /* If it's a block device, try to query the track layout (for multisession) */
         if (m_startsec == -1 && S_ISBLK(buf.st_mode))
             trackno = getTracks(m_filename.toLatin1(), (int*) & tracks);
     }
     uid.setNum(buf.st_uid);
     gid.setNum(buf.st_gid);
     access = buf.st_mode & ~S_IFMT;
 
     //qDebug() << "KIso::openArchive number of tracks: " << trackno << endl;
 
     if (trackno == 0) trackno = 1;
     for (i = 0;i < trackno;++i) {
 
         c_b = 1;c_i = 1;c_j = 1;
         root = rootDir();
         if (trackno > 1) {
             path.clear();
             QTextStream(&path) << "Track " << tracks[(i<<1)+1];
             root = new KIsoDirectory(this, path, access | S_IFDIR,
                                      buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, QString());
             rootDir()->addEntry(root);
         }
 
         desc = ReadISO9660(&readf, tracks[i<<1], this);
         if (!desc) {
             //qDebug() << "KIso::openArchive no volume descriptors" << endl;
             continue;
         }
 
         while (desc) {
             switch (isonum_711(desc->data.type)) {
             case ISO_VD_BOOT:
 
                 bootdesc = (struct el_torito_boot_descriptor*) & (desc->data);
                 if (!memcmp(EL_TORITO_ID, bootdesc->system_id, ISODCL(8, 39))) {
                     path = "El Torito Boot";
                     if (c_b > 1) path += " (" + QString::number(c_b) + ')';
 
                     dirent = new KIsoDirectory(this, path, access | S_IFDIR,
                                                buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, QString());
                     root->addEntry(dirent);
 
                     addBoot(bootdesc);
                     c_b++;
                 }
                 break;
 
             case ISO_VD_PRIMARY:
             case ISO_VD_SUPPLEMENTARY:
                 idr = (struct iso_directory_record*) & (((struct iso_primary_descriptor*) & desc->data)->root_directory_record);
                 joliet = JolietLevel(&desc->data);
                 if (joliet) {
                     QTextStream(&path) << "Joliet level " << joliet;
                     if (c_j > 1) path += " (" + QString::number(c_j) + ')';
                 } else {
                     path = "ISO9660";
                     if (c_i > 1) path += " (" + QString::number(c_i) + ')';
                 }
                 dirent = new KIsoDirectory(this, path, access | S_IFDIR,
                                            buf.st_mtime, buf.st_atime, buf.st_ctime, uid, gid, QString());
                 root->addEntry(dirent);
                 level = 0;
                 mycallb(idr, this);
                 if (joliet) c_j++; else c_i++;
                 break;
             }
             desc = desc->next;
         }
         free(desc);
     }
     device()->close();
     return true;
 }
 
 bool KIso::closeArchive()
 {
     KRFUNC;
     d->dirList.clear();
     return true;
 }
 
 bool KIso::writeDir(const QString&, const QString&, const QString&, mode_t, time_t, time_t, time_t)
 {
     return false;
 }
 
 bool KIso::prepareWriting(const QString&, const QString&, const QString&, qint64, mode_t, time_t, time_t, time_t)
 {
     return false;
 }
 
 bool KIso::finishWriting(qint64)
 {
     return false;
 }
 
 bool KIso::writeSymLink(const QString &, const QString &, const QString &, const QString &, mode_t, time_t, time_t, time_t)
 {
     return false;
 }
 
 bool KIso::doWriteDir(const QString&, const QString&, const QString&, mode_t, const QDateTime&, const QDateTime &, const QDateTime &)
 {
     return false;
 }
 
 bool KIso::doWriteSymLink(const QString &, const QString &, const QString &, const QString &, mode_t, const QDateTime&, const QDateTime&, const QDateTime&)
 {
     return false;
 }
 
 bool KIso::doPrepareWriting(const QString& , const QString& , const QString& , qint64, mode_t, const QDateTime&, const QDateTime&, const QDateTime&)
 {
     return false;
 }
 
 bool KIso::doFinishWriting(qint64)
 {
     return false;
 }
 
 void KIso::virtual_hook(int id, void* data)
 {
     KArchive::virtual_hook(id, data);
 }
 
diff --git a/iso/kisodirectory.cpp b/iso/kisodirectory.cpp
index 3c26f298..37e5fac9 100644
--- a/iso/kisodirectory.cpp
+++ b/iso/kisodirectory.cpp
@@ -1,36 +1,35 @@
 /*****************************************************************************
  * Copyright (C) 2002 Szombathelyi György <gyurco@users.sourceforge.net>     *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kisodirectory.h"
 
 KIsoDirectory::KIsoDirectory(KArchive* archive, const QString& name, int access,
 			     int date, int adate, int cdate, const QString& user, const QString& group,
 			     const QString& symlink) :
 	KArchiveDirectory(archive, name, access, QDateTime::fromTime_t(date), user, group, symlink)
 {
 
 
     m_adate = adate;
     m_cdate = cdate;
 }
 
 KIsoDirectory::~KIsoDirectory()
-{
-}
+= default;
diff --git a/iso/kisofile.cpp b/iso/kisofile.cpp
index bed5afe2..584ea93d 100644
--- a/iso/kisofile.cpp
+++ b/iso/kisofile.cpp
@@ -1,61 +1,60 @@
 /*****************************************************************************
  * Copyright (C) 2002 Szombathelyi György <gyurco@users.sourceforge.net>     *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kisofile.h"
 
 KIsoFile::KIsoFile(KArchive* archive, const QString& name, int access,
 		   int date, int adate, int cdate, const QString& user, const QString& group,
 		   const QString& symlink, long long pos, long long size) :
 	KArchiveFile(archive, name, access, QDateTime::fromTime_t(date), user, group, symlink, pos, size)
 {
 
 
     m_adate = adate;
     m_cdate = cdate;
     m_algo[0] = 0;m_algo[1] = 0;m_parms[0] = 0;m_parms[1] = 0;m_realsize = 0;
 }
 
 KIsoFile::~KIsoFile()
-{
-}
+= default;
 
 void KIsoFile::setZF(char algo[2], char parms[2], long long realsize)
 {
     m_algo[0] = algo[0];m_algo[1] = algo[1];
     m_parms[0] = parms[0];m_parms[1] = parms[1];
     m_realsize = realsize;
 }
 
 QByteArray KIsoFile::dataAt(long long pos, int count) const
 {
     QByteArray r;
     int rlen;
 
     if (archive()->device()->seek(position() + pos)) {
         r.resize(((pos + count) < size()) ? count : size() - pos);
         if (r.size()) {
             rlen = archive()->device()->read(r.data(), r.size());
             if (rlen == - 1) r.resize(0);
             else if (rlen != (int)r.size()) r.resize(rlen);
         }
     }
 
     return r;
 }
diff --git a/iso/qfilehack.cpp b/iso/qfilehack.cpp
index 8fcebbd8..1d6b708b 100644
--- a/iso/qfilehack.cpp
+++ b/iso/qfilehack.cpp
@@ -1,47 +1,45 @@
 /*****************************************************************************
  * Copyright (C) 2002 Szombathelyi György <gyurco@users.sourceforge.net>     *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "qfilehack.h"
 
 QFileHack::QFileHack()
-{
-}
+= default;
 
 QFileHack::QFileHack(const QString & name) : QFile(name)
 {
 }
 
 QFileHack::~QFileHack()
-{
-}
+= default;
 
 bool QFileHack::open(QFile::OpenMode m)
 {
     bool ret;
 
 #ifdef Q_OS_UNIX
 //    m |= IO_Async; // On linux, set O_NONBLOCK, opens CD-ROMs faster
 #endif
     ret = QFile::open(m);
 //    if (ret && isSequential() ) {
 //        setOpenMode(m | (QFile::OpenMode)IO_Direct);
 //    }
     return ret;
 }
diff --git a/krArc/krarc.cpp b/krArc/krarc.cpp
index 5846c16d..747dddd4 100644
--- a/krArc/krarc.cpp
+++ b/krArc/krarc.cpp
@@ -1,1932 +1,1932 @@
 /*****************************************************************************
  * Copyright (C) 2003 Rafi Yanai <krusader@users.sf.net>                     *
  * Copyright (C) 2003 Shie Erlich <krusader@users.sf.net>                    *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krarc.h"
 #include "../krusader/defaults.h"
 
 // QtCore
 #include <QByteArray>
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <QRegExp>
 #include <QTemporaryFile>
 #include <QTextCodec>
 #include <qplatformdefs.h>
 
 #include <KArchive/KTar>
 #include <KCoreAddons/KProcess>
 #include <KI18n/KLocalizedString>
 #include <KIO/Job>
 #include <KIOCore/KFileItem>
 
 #include <kio_version.h>
 
 #include <errno.h>
 
 #define MAX_IPC_SIZE           (1024*32)
 #define TRIES_WITH_PASSWORDS   3
 
 using namespace KIO;
 extern "C"
 {
 
 #ifdef KRARC_ENABLED
     /* This codec is for being able to handle files which encoding differs from the current locale.
      *
      * Unfortunately QProcess requires QString parameters for arguments which are encoded to Local8Bit
      * If we want to use unzip with ISO-8852-2 when the current locale is UTF-8, it will cause problems.
      *
      * Workaround:
      *  1. encode the QString to QByteArray ( according to the selected remote encoding, ISO-8852-2 )
      *  2. encode QByteArray to QString again
      *     unicode 0xE000-0xF7FF is for private use
      *     the byte array is mapped to 0xE000-0xE0FF unicodes
      *  3. KrArcCodec maps 0xE000-0xE0FF to 0x0000-0x00FF, while calls the default encoding routine
      *     for other unicodes.
      */
 
     class KrArcCodec : public QTextCodec
     {
     public:
         KrArcCodec(QTextCodec * codec) : originalCodec(codec) {}
-        virtual ~KrArcCodec() {}
+        ~KrArcCodec() override = default;
 
-        virtual QByteArray name() const Q_DECL_OVERRIDE {
+        QByteArray name() const Q_DECL_OVERRIDE {
             return  originalCodec->name();
         }
-        virtual QList<QByteArray> aliases() const Q_DECL_OVERRIDE {
+        QList<QByteArray> aliases() const Q_DECL_OVERRIDE {
             return originalCodec->aliases();
         }
-        virtual int mibEnum() const Q_DECL_OVERRIDE {
+        int mibEnum() const Q_DECL_OVERRIDE {
             return  originalCodec->mibEnum();
         }
 
     protected:
-        virtual QString convertToUnicode(const char *in, int length, ConverterState *state) const Q_DECL_OVERRIDE {
+        QString convertToUnicode(const char *in, int length, ConverterState *state) const Q_DECL_OVERRIDE {
             return originalCodec->toUnicode(in, length, state);
         }
-        virtual QByteArray convertFromUnicode(const QChar *in, int length, ConverterState *state) const Q_DECL_OVERRIDE {
+        QByteArray convertFromUnicode(const QChar *in, int length, ConverterState *state) const Q_DECL_OVERRIDE {
             // the QByteArray is embedded into the unicode charset (QProcess hell)
             QByteArray result;
             for (int i = 0; i != length; i++) {
                 if (((in[ i ].unicode()) & 0xFF00) == 0xE000)    // map 0xE000-0xE0FF to 0x0000-0x00FF
                     result.append((char)(in[ i ].unicode() & 0xFF));
                 else
                     result.append(originalCodec->fromUnicode(in + i, 1, state));
             }
             return result;
         }
 
     private:
         QTextCodec * originalCodec;
     } *krArcCodec;
 
 #define SET_KRCODEC    QTextCodec *origCodec = QTextCodec::codecForLocale(); \
     QTextCodec::setCodecForLocale( krArcCodec );
 #define RESET_KRCODEC  QTextCodec::setCodecForLocale( origCodec );
 
 #endif // KRARC_ENABLED
 
     class DummySlave : public KIO::SlaveBase
     {
     public:
         DummySlave(const QByteArray &pool_socket, const QByteArray &app_socket) :
                 SlaveBase("kio_krarc", pool_socket, app_socket) {
             error((int)ERR_SLAVE_DEFINED, QString("krarc is disabled."));
         }
     };
 
     int Q_DECL_EXPORT kdemain(int argc, char **argv) {
         if (argc != 4) {
             qWarning() << "Usage: kio_krarc  protocol domain-socket1 domain-socket2" << endl;
             exit(-1);
         }
 
 #ifdef KRARC_ENABLED
         kio_krarcProtocol slave(argv[2], argv[3]);
 #else
         DummySlave slave(argv[2], argv[3]);
 #endif
 
         slave.dispatchLoop();
 
         return 0;
     }
 
 } // extern "C"
 
 #ifdef KRARC_ENABLED
 kio_krarcProtocol::kio_krarcProtocol(const QByteArray &pool_socket, const QByteArray &app_socket)
-        : SlaveBase("kio_krarc", pool_socket, app_socket), archiveChanged(true), arcFile(0L), extArcReady(false),
-        password(QString()), krConf("krusaderrc"), codec(0)
+        : SlaveBase("kio_krarc", pool_socket, app_socket), archiveChanged(true), arcFile(nullptr), extArcReady(false),
+        password(QString()), krConf("krusaderrc"), codec(nullptr)
 {
     KRFUNC;
     confGrp = KConfigGroup(&krConf, "Dependencies");
 
     KConfigGroup group(&krConf, "General");
     QString tmpDirPath = group.readEntry("Temp Directory", _TempDirectory);
     QDir tmpDir(tmpDirPath);
     if(!tmpDir.exists()) {
         for (int i = 1 ; i != -1 ; i = tmpDirPath.indexOf('/', i + 1))
             QDir().mkdir(tmpDirPath.left(i));
         QDir().mkdir(tmpDirPath);
     }
 
     arcTempDir = tmpDirPath + DIR_SEPARATOR;
     QString dirName = "krArc" + QDateTime::currentDateTime().toString(Qt::ISODate);
     dirName.replace(QRegExp(":"), "_");
     tmpDir.mkdir(dirName);
     arcTempDir = arcTempDir + dirName + DIR_SEPARATOR;
 
     krArcCodec = new KrArcCodec(QTextCodec::codecForLocale());
 }
 
 /* ---------------------------------------------------------------------------------- */
 kio_krarcProtocol::~kio_krarcProtocol()
 {
     KRFUNC;
     // delete the temp directory
     KProcess proc;
     proc << fullPathName("rm") << "-rf" << arcTempDir;
     proc.start();
     proc.waitForFinished();
 }
 
 /* ---------------------------------------------------------------------------------- */
 
 bool kio_krarcProtocol::checkWriteSupport()
 {
     KRFUNC;
     krConf.reparseConfiguration();
     if (KConfigGroup(&krConf, "kio_krarc").readEntry("EnableWrite", false))
         return true;
     else {
         error(ERR_UNSUPPORTED_ACTION,
               i18n("krarc: write support is disabled.\n"
                    "You can enable it on the 'Archives' page in Konfigurator."));
         return false;
     }
 }
 
 void kio_krarcProtocol::receivedData(KProcess *, QByteArray &d)
 {
     KRFUNC;
-    QByteArray buf(d);
+    const QByteArray& buf(d);
     data(buf);
     processedSize(d.length());
     decompressedLen += d.length();
 }
 
 void kio_krarcProtocol::mkdir(const QUrl &url, int permissions)
 {
     KRFUNC;
     const QString path = getPath(url);
     KRDEBUG(path);
 
     if (!checkWriteSupport())
         return;
 
     // In case of KIO::mkpath call there is a mkdir call for every path element.
     // Therefore the path all the way up to our archive needs to be checked for existence
     // and reported as success.
     if (QDir().exists(path)) {
         finished();
         return;
     }
 
     if (!setArcFile(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, path);
         return;
     }
 
     if (newArchiveURL && !initDirDict(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, path);
         return;
     }
 
     if (putCmd.isEmpty()) {
         error(ERR_UNSUPPORTED_ACTION,
               i18n("Creating directories is not supported with %1 archives", arcType));
         return;
     }
 
     const QString arcFilePath = getPath(arcFile->url());
 
     if (arcType == "arj" || arcType == "lha") {
         QString arcDir = path.mid(arcFilePath.length());
         if (arcDir.right(1) != DIR_SEPARATOR) arcDir = arcDir + DIR_SEPARATOR;
 
         if (dirDict.find(arcDir) == dirDict.end())
             addNewDir(arcDir);
         finished();
         return;
     }
 
     QString arcDir  = findArcDirectory(url);
     QString tempDir = arcDir.mid(1) + path.mid(path.lastIndexOf(DIR_SEPARATOR) + 1);
     if (tempDir.right(1) != DIR_SEPARATOR) tempDir = tempDir + DIR_SEPARATOR;
 
     if (permissions == -1) permissions = 0777;  //set default permissions
 
     QByteArray arcTempDirEnc = arcTempDir.toLocal8Bit();
     for (int i = 0;i < tempDir.length() && i >= 0; i = tempDir.indexOf(DIR_SEPARATOR, i + 1)) {
         QByteArray newDirs = encodeString(tempDir.left(i));
         newDirs.prepend(arcTempDirEnc);
         QT_MKDIR(newDirs, permissions);
     }
 
     if (tempDir.endsWith(DIR_SEPARATOR))
         tempDir.truncate(tempDir.length() - 1);
 
     // pack the directory
     KrLinecountingProcess proc;
     proc << putCmd << arcFilePath << localeEncodedString(tempDir);
     infoMessage(i18n("Creating %1...", url.fileName()));
     QDir::setCurrent(arcTempDir);
 
     SET_KRCODEC
     proc.start();
     RESET_KRCODEC
 
     proc.waitForFinished();
 
     // delete the temp directory
     QDir().rmdir(arcTempDir);
 
     if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(proc.exitCode()))  {
         error(ERR_COULD_NOT_WRITE, path + "\n\n" + proc.getErrorMsg());
         return;
     }
 
     //  force a refresh of archive information
     initDirDict(url, true);
     finished();
 }
 
 void kio_krarcProtocol::put(const QUrl &url, int permissions, KIO::JobFlags flags)
 {
     KRFUNC;
     KRDEBUG(getPath(url));
 
     if (!checkWriteSupport())
         return;
 
     bool overwrite = !!(flags & KIO::Overwrite);
     bool resume = !!(flags & KIO::Resume);
 
     if (!setArcFile(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
     if (newArchiveURL && !initDirDict(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
 
     if (putCmd.isEmpty()) {
         error(ERR_UNSUPPORTED_ACTION,
               i18n("Writing to %1 archives is not supported", arcType));
         return;
     }
     if (!overwrite && findFileEntry(url)) {
         error(ERR_FILE_ALREADY_EXIST, getPath(url));
         return;
     }
 
     QString arcDir  = findArcDirectory(url);
     if (arcDir.isEmpty())
         KRDEBUG("arcDir is empty.");
 
     QString tempFile = arcDir.mid(1) + getPath(url).mid(getPath(url).lastIndexOf(DIR_SEPARATOR) + 1);
     QString tempDir  = arcDir.mid(1);
     if (tempDir.right(1) != DIR_SEPARATOR) tempDir = tempDir + DIR_SEPARATOR;
 
     if (permissions == -1) permissions = 0777;  //set default permissions
 
     QByteArray arcTempDirEnc = arcTempDir.toLocal8Bit();
     for (int i = 0;i < tempDir.length() && i >= 0; i = tempDir.indexOf(DIR_SEPARATOR, i + 1)) {
         QByteArray newDirs = encodeString(tempDir.left(i));
         newDirs.prepend(arcTempDirEnc);
         QT_MKDIR(newDirs, 0755);
     }
 
     int fd;
     if (resume) {
         QByteArray ba = encodeString(tempFile);
         ba.prepend(arcTempDirEnc);
         fd = QT_OPEN(ba, O_RDWR);    // append if resuming
         QT_LSEEK(fd, 0, SEEK_END); // Seek to end
     } else {
         // WABA: Make sure that we keep writing permissions ourselves,
         // otherwise we can be in for a surprise on NFS.
         mode_t initialMode;
         if (permissions != -1)
             initialMode = permissions | S_IWUSR | S_IRUSR;
         else
             initialMode = 0666;
 
         QByteArray ba = encodeString(tempFile);
         ba.prepend(arcTempDirEnc);
         fd = QT_OPEN(ba, O_CREAT | O_TRUNC | O_WRONLY, initialMode);
     }
 
     QByteArray buffer;
     int readResult;
     bool isIncomplete = false;
     do {
         dataReq();
         readResult = readData(buffer);
         auto bytesWritten = ::write(fd, buffer.data(), buffer.size());
         if (bytesWritten < buffer.size()) {
             isIncomplete = true;
             break;
         }
     } while (readResult > 0);
     ::close(fd);
 
     if (isIncomplete) {
         error(ERR_COULD_NOT_WRITE, getPath(url));
         return;
     }
 
     // pack the file
     KrLinecountingProcess proc;
     proc << putCmd << getPath(arcFile->url()) << localeEncodedString(tempFile);
     infoMessage(i18n("Packing %1...", url.fileName()));
     QDir::setCurrent(arcTempDir);
 
     SET_KRCODEC
     proc.start();
     RESET_KRCODEC
 
     proc.waitForFinished();
 
     // remove the files
     QDir().rmdir(arcTempDir);
 
     if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(proc.exitCode()))  {
         error(ERR_COULD_NOT_WRITE, getPath(url) + "\n\n" + proc.getErrorMsg());
         return;
     }
     //  force a refresh of archive information
     initDirDict(url, true);
     finished();
 }
 
 void kio_krarcProtocol::get(const QUrl &url)
 {
     KRFUNC;
     get(url, TRIES_WITH_PASSWORDS);
 }
 
 void kio_krarcProtocol::get(const QUrl &url, int tries)
 {
     KRFUNC;
     KRDEBUG(getPath(url));
     bool decompressToFile = false;
 
     if (!setArcFile(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
     if (newArchiveURL && !initDirDict(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
 
     if (getCmd.isEmpty()) {
         error(ERR_UNSUPPORTED_ACTION,
               i18n("Retrieving data from %1 archives is not supported", arcType));
         return;
     }
     UDSEntry* entry = findFileEntry(url);
     if (!entry) {
         error(KIO::ERR_DOES_NOT_EXIST, getPath(url));
         return;
     }
     if (KFileItem(*entry, url).isDir()) {
         error(KIO::ERR_IS_DIRECTORY, getPath(url));
         return;
     }
     KIO::filesize_t expectedSize = KFileItem(*entry, url).size();
     // for RPM files extract the cpio file first
     if (!extArcReady && arcType == "rpm") {
         KrLinecountingProcess cpio;
         cpio << "rpm2cpio" << getPath(arcFile->url(), QUrl::StripTrailingSlash);
         cpio.setStandardOutputFile(arcTempDir + "contents.cpio");
 
         cpio.start();
         cpio.waitForFinished();
 
         if (cpio.exitStatus() != QProcess::NormalExit || !checkStatus(cpio.exitCode())) {
             error(ERR_COULD_NOT_READ, getPath(url) + "\n\n" + cpio.getErrorMsg());
             return;
         }
         extArcReady = true;
     }
     // for DEB files extract the tar file first
     if (!extArcReady && arcType == "deb") {
         KrLinecountingProcess dpkg;
         dpkg << cmd << "--fsys-tarfile" << getPath(arcFile->url(), QUrl::StripTrailingSlash);
         dpkg.setStandardOutputFile(arcTempDir + "contents.cpio");
 
         dpkg.start();
         dpkg.waitForFinished();
 
         if (dpkg.exitStatus() != QProcess::NormalExit || !checkStatus(dpkg.exitCode())) {
             error(ERR_COULD_NOT_READ, getPath(url) + "\n\n" + dpkg.getErrorMsg());
             return;
         }
         extArcReady = true;
     }
 
     // Use the external unpacker to unpack the file
     QString file = getPath(url).mid(getPath(arcFile->url()).length() + 1);
     KrLinecountingProcess proc;
     if (extArcReady) {
         proc << getCmd << arcTempDir + "contents.cpio" << '*' + localeEncodedString(file);
     } else if (arcType == "arj" || arcType == "ace" || arcType == "7z") {
         proc << getCmd << getPath(arcFile->url(), QUrl::StripTrailingSlash) << localeEncodedString(file);
         if (arcType == "ace" && QFile("/dev/ptmx").exists())    // Don't remove, unace crashes if missing!!!
             proc.setStandardInputFile("/dev/ptmx");
         file = url.fileName();
         decompressToFile = true;
     } else {
         decompressedLen = 0;
         // Determine the mimetype of the file to be retrieved, and emit it.
         // This is mandatory in all slaves (for KRun/BrowserRun to work).
         QMimeDatabase db;
         QMimeType mt = db.mimeTypeForFile(arcTempDir + file);
         if (mt.isValid())
             emit mimeType(mt.name());
 
         QString escapedFilename = file;
         if(arcType == "zip") // left bracket needs to be escaped
             escapedFilename.replace('[', "[[]");
         proc << getCmd << getPath(arcFile->url());
         if (arcType != "gzip" && arcType != "bzip2" && arcType != "lzma" && arcType != "xz") proc << localeEncodedString(escapedFilename);
         connect(&proc, &KrLinecountingProcess::newOutputData, this, &kio_krarcProtocol::receivedData);
         proc.setMerge(false);
     }
     infoMessage(i18n("Unpacking %1...", url.fileName()));
     // change the working directory to our arcTempDir
     QDir::setCurrent(arcTempDir);
 
     SET_KRCODEC
     proc.setTextModeEnabled(false);
     proc.start();
     RESET_KRCODEC
 
     proc.waitForFinished();
 
     if (!extArcReady && !decompressToFile) {
         if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(proc.exitCode()) || (arcType != "bzip2" && arcType != "lzma" && arcType != "xz" && expectedSize != decompressedLen)) {
             if (encrypted && tries) {
                 invalidatePassword();
                 get(url, tries - 1);
                 return;
             }
             error(KIO::ERR_ACCESS_DENIED, getPath(url) + "\n\n" + proc.getErrorMsg());
             return;
         }
     } else {
         if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(proc.exitCode()) || !QFileInfo(arcTempDir + file).exists()) {
             if (decompressToFile)
                 QFile(arcTempDir + file).remove();
             if (encrypted && tries) {
                 invalidatePassword();
                 get(url, tries - 1);
                 return;
             }
             error(KIO::ERR_ACCESS_DENIED, getPath(url));
             return;
         }
         // the following block is ripped from KDE file KIO::Slave
         // $Id: krarc.cpp,v 1.43 2007/01/13 13:39:51 ckarai Exp $
         QByteArray _path(QFile::encodeName(arcTempDir + file));
         QT_STATBUF buff;
         if (QT_LSTAT(_path.data(), &buff) == -1) {
             if (errno == EACCES)
                 error(KIO::ERR_ACCESS_DENIED, getPath(url));
             else
                 error(KIO::ERR_DOES_NOT_EXIST, getPath(url));
             return;
         }
         if (S_ISDIR(buff.st_mode)) {
             error(KIO::ERR_IS_DIRECTORY, getPath(url));
             return;
         }
         if (!S_ISREG(buff.st_mode)) {
             error(KIO::ERR_CANNOT_OPEN_FOR_READING, getPath(url));
             return;
         }
         int fd = QT_OPEN(_path.data(), O_RDONLY);
         if (fd < 0) {
             error(KIO::ERR_CANNOT_OPEN_FOR_READING, getPath(url));
             return;
         }
         // Determine the mimetype of the file to be retrieved, and emit it.
         // This is mandatory in all slaves (for KRun/BrowserRun to work).
         QMimeDatabase db;
         QMimeType mt = db.mimeTypeForFile(arcTempDir + file);
         if (mt.isValid())
             emit mimeType(mt.name());
 
         KIO::filesize_t processed_size = 0;
 
         QString resumeOffset = metaData("resume");
         if (!resumeOffset.isEmpty()) {
             bool ok;
             KIO::fileoffset_t offset = resumeOffset.toLongLong(&ok);
             if (ok && (offset > 0) && (offset < buff.st_size)) {
                 if (QT_LSEEK(fd, offset, SEEK_SET) == offset) {
                     canResume();
                     processed_size = offset;
                 }
             }
         }
 
         totalSize(buff.st_size);
 
         char buffer[ MAX_IPC_SIZE ];
         while (1) {
             int n = ::read(fd, buffer, MAX_IPC_SIZE);
             if (n == -1) {
                 if (errno == EINTR)
                     continue;
                 error(KIO::ERR_COULD_NOT_READ, getPath(url));
                 ::close(fd);
                 return;
             }
             if (n == 0)
                 break; // Finished
 
             {
                 QByteArray array = QByteArray::fromRawData(buffer, n);
                 data(array);
             }
 
             processed_size += n;
         }
 
         data(QByteArray());
         ::close(fd);
         processedSize(buff.st_size);
         finished();
 
         if (decompressToFile)
             QFile(arcTempDir + file).remove();
         return;
     }
     // send empty buffer to mark EOF
     data(QByteArray());
     finished();
 }
 
 void kio_krarcProtocol::del(QUrl const & url, bool isFile)
 {
     KRFUNC;
     KRDEBUG(getPath(url));
 
     if (!checkWriteSupport())
         return;
 
     if (!setArcFile(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
     if (newArchiveURL && !initDirDict(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
 
     if (delCmd.isEmpty()) {
         error(ERR_UNSUPPORTED_ACTION,
               i18n("Deleting files from %1 archives is not supported", arcType));
         return;
     }
     if (!findFileEntry(url)) {
         if ((arcType != "arj" && arcType != "lha") || isFile) {
             error(KIO::ERR_DOES_NOT_EXIST, getPath(url));
             return;
         }
     }
 
     QString file = getPath(url).mid(getPath(arcFile->url()).length() + 1);
     if (!isFile && file.right(1) != DIR_SEPARATOR) {
         if (arcType == "zip") file = file + DIR_SEPARATOR;
     }
     KrLinecountingProcess proc;
     proc << delCmd << getPath(arcFile->url()) << localeEncodedString(file);
     infoMessage(i18n("Deleting %1...", url.fileName()));
 
     SET_KRCODEC
     proc.start();
     RESET_KRCODEC
 
     proc.waitForFinished();
     if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(proc.exitCode()))  {
         error(ERR_COULD_NOT_WRITE, getPath(url) + "\n\n" + proc.getErrorMsg());
         return;
     }
     //  force a refresh of archive information
     initDirDict(url, true);
     finished();
 }
 
 void kio_krarcProtocol::stat(const QUrl &url)
 {
     KRFUNC;
     KRDEBUG(getPath(url));
     if (!setArcFile(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
     if (newArchiveURL && !initDirDict(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
 
     if (listCmd.isEmpty()) {
         error(ERR_UNSUPPORTED_ACTION,
               i18n("Accessing files is not supported with %1 archives", arcType));
         return;
     }
     QString path = getPath(url, QUrl::StripTrailingSlash);
     QUrl newUrl = url;
 
     // but treat the archive itself as the archive root
     if (path == getPath(arcFile->url(), QUrl::StripTrailingSlash)) {
         newUrl.setPath(path + DIR_SEPARATOR);
         path = getPath(newUrl);
     }
     // we might be stating a real file
     if (QFileInfo(path).exists()) {
         QT_STATBUF buff;
         QT_STAT(path.toLocal8Bit(), &buff);
         QString mime;
         QMimeDatabase db;
         QMimeType result = db.mimeTypeForFile(path);
         if (result.isValid())
             mime = result.name();
         statEntry(KFileItem(QUrl::fromLocalFile(path), mime, buff.st_mode).entry());
         finished();
         return;
     }
     UDSEntry* entry = findFileEntry(newUrl);
     if (entry) {
         statEntry(*entry);
         finished();
     } else error(KIO::ERR_DOES_NOT_EXIST, path);
 }
 
 void kio_krarcProtocol::copy(const QUrl &url, const QUrl &dest, int, KIO::JobFlags flags)
 {
     KRDEBUG("source: " << url.path() << " dest: " << dest.path());
 
     if (!checkWriteSupport())
         return;
 
     bool overwrite = !!(flags & KIO::Overwrite);
 
     // KDE HACK: opening the password dlg in copy causes error for the COPY, and further problems
     // that's why encrypted files are not allowed to copy
     if (!encrypted && dest.isLocalFile())
         do {
             if (url.fileName() != dest.fileName())
                 break;
 
             if (QTextCodec::codecForLocale()->name() != codec->name())
                 break;
 
             //the file exists and we don't want to overwrite
             if ((!overwrite) && (QFile(getPath(dest)).exists())) {
                 error((int)ERR_FILE_ALREADY_EXIST, QString(QFile::encodeName(getPath(dest))));
                 return;
             };
 
             if (!setArcFile(url)) {
                 error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
                 return;
             }
             if (newArchiveURL && !initDirDict(url)) {
                 error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
                 return;
             }
 
             UDSEntry* entry = findFileEntry(url);
             if (copyCmd.isEmpty() || !entry)
                 break;
 
             QString file = getPath(url).mid(getPath(arcFile->url()).length() + 1);
 
             QString destDir = getPath(dest, QUrl::StripTrailingSlash);
             if (!QDir(destDir).exists()) {
                 int ndx = destDir.lastIndexOf(DIR_SEPARATOR_CHAR);
                 if (ndx != -1)
                     destDir.truncate(ndx + 1);
             }
 
             QDir::setCurrent(destDir);
 
             QString escapedFilename = file;
             if(arcType == "zip") {
                 // left bracket needs to be escaped
                 escapedFilename.replace('[', "[[]");
             }
 
             KrLinecountingProcess proc;
             proc << copyCmd << getPath(arcFile->url(), QUrl::StripTrailingSlash) << escapedFilename;
             if (arcType == "ace" && QFile("/dev/ptmx").exists())    // Don't remove, unace crashes if missing!!!
                 proc.setStandardInputFile("/dev/ptmx");
             proc.setOutputChannelMode(KProcess::SeparateChannels); // without this output redirection has no effect
 
             infoMessage(i18n("Unpacking %1...", url.fileName()));
             proc.start();
             proc.waitForFinished();
             if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(proc.exitCode()))  {
                 error(KIO::ERR_COULD_NOT_WRITE, getPath(dest, QUrl::StripTrailingSlash) + "\n\n" + proc.getErrorMsg());
                 return;
             }
             if (!QFileInfo(getPath(dest, QUrl::StripTrailingSlash)).exists()) {
                 error(KIO::ERR_COULD_NOT_WRITE, getPath(dest, QUrl::StripTrailingSlash));
                 return;
             }
 
             processedSize(KFileItem(*entry, url).size());
             finished();
             QDir::setCurrent(QDir::rootPath());   /* for being able to umount devices after copying*/
             return;
         } while (0);
 
     if (encrypted)
         KRDEBUG("ERROR: " << url.path() << " is encrypted.");
     if (!dest.isLocalFile())
         KRDEBUG("ERROR: " << url.path() << " is not a local file.");
 
     // CMD_COPY is no more in KF5 - replaced with 74 value (as stated in kio/src/core/commands_p.h, which could be found in cgit.kde.org/kio.git/tree)
     error(ERR_UNSUPPORTED_ACTION, unsupportedActionErrorString(mProtocol, 74));
 }
 
 void kio_krarcProtocol::rename(const QUrl& src, const QUrl& dest, KIO::JobFlags flags)
 {
     Q_UNUSED(flags);
 
     KRDEBUG("renaming from: " << src.path() << " to: " << dest.path());
     KRDEBUG("command: " << arcPath);
 
     if (!checkWriteSupport()) {
         return;
     }
 
     if (renCmd.isEmpty()) {
         error(KIO::ERR_CANNOT_RENAME, src.fileName());
         return;
     }
 
     if (src.fileName() == dest.fileName()) {
         return;
     }
 
     KrLinecountingProcess proc;
     proc << renCmd << arcPath << src.path().remove(arcPath + '/') << dest.path().remove(arcPath + '/');
     proc.start();
     proc.waitForFinished();
 
     if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(proc.exitCode()))  {
         error(KIO::ERR_CANNOT_RENAME, src.fileName());
         return;
     }
 
     finished();
 }
 
 void kio_krarcProtocol::listDir(const QUrl &url)
 {
     KRFUNC;
     KRDEBUG(getPath(url));
     if (!setArcFile(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
     if (listCmd.isEmpty()) {
         error(ERR_UNSUPPORTED_ACTION,
               i18n("Listing directories is not supported for %1 archives", arcType));
         return;
     }
     QString path = getPath(url);
     if (path.right(1) != DIR_SEPARATOR) path = path + DIR_SEPARATOR;
 
     // it might be a real dir !
     if (QFileInfo(path).exists()) {
         if (QFileInfo(path).isDir()) {
             QUrl redir;
             redir.setPath(getPath(url));
             redirection(redir);
             finished();
         } else { // maybe it's an archive !
             error(ERR_IS_FILE, path);
         }
         return;
     }
     if (!initDirDict(url)) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
     QString arcDir = path.mid(getPath(arcFile->url()).length());
     arcDir.truncate(arcDir.lastIndexOf(DIR_SEPARATOR));
     if (arcDir.right(1) != DIR_SEPARATOR) arcDir = arcDir + DIR_SEPARATOR;
 
     if (dirDict.find(arcDir) == dirDict.end()) {
         error(ERR_CANNOT_ENTER_DIRECTORY, getPath(url));
         return;
     }
     UDSEntryList* dirList = dirDict[ arcDir ];
     totalSize(dirList->size());
     listEntries(*dirList);
     finished();
 }
 
 bool kio_krarcProtocol::setArcFile(const QUrl &url)
 {
     KRFUNC;
     KRDEBUG(url.fileName());
     QString path = getPath(url);
-    time_t currTime = time(0);
+    time_t currTime = time(nullptr);
     archiveChanged = true;
     newArchiveURL = true;
     // is the file already set ?
     if (arcFile && getPath(arcFile->url(), QUrl::StripTrailingSlash) == path.left(getPath(arcFile->url(), QUrl::StripTrailingSlash).length())) {
         newArchiveURL = false;
         // Has it changed ?
         KFileItem* newArcFile = new KFileItem(arcFile->url(), QString(), arcFile->mode());
         if (metaData("Charset") != currentCharset || !newArcFile->cmp(*arcFile)) {
             currentCharset = metaData("Charset");
 
             codec = QTextCodec::codecForName(currentCharset.toLatin1());
-            if (codec == 0)
+            if (codec == nullptr)
                 codec = QTextCodec::codecForMib(4 /* latin-1 */);
 
             delete arcFile;
             password.clear();
             extArcReady = false;
             arcFile = newArcFile;
         } else { // same old file
             delete newArcFile;
             archiveChanged = false;
             if (encrypted && password.isNull())
                 initArcParameters();
         }
     } else { // it's a new file...
         extArcReady = false;
 
         // new archive file means new dirDict, too
         dirDict.clear();
 
         if (arcFile) {
             delete arcFile;
             password.clear();
-            arcFile = 0L;
+            arcFile = nullptr;
         }
         QString newPath = path;
         if (newPath.right(1) != DIR_SEPARATOR) newPath = newPath + DIR_SEPARATOR;
         for (int pos = 0; pos >= 0; pos = newPath.indexOf(DIR_SEPARATOR, pos + 1)) {
             QFileInfo qfi(newPath.left(pos));
             if (qfi.exists() && !qfi.isDir()) {
                 QT_STATBUF stat_p;
                 QT_LSTAT(newPath.left(pos).toLocal8Bit(), &stat_p);
                 arcFile = new KFileItem(QUrl::fromLocalFile(newPath.left(pos)), QString(), stat_p.st_mode);
                 break;
             }
         }
         if (!arcFile) {
             // KRDEBUG("ERROR: " << path << " does not exist.");
             error(ERR_DOES_NOT_EXIST, path);
             return false; // file not found
         }
         currentCharset = metaData("Charset");
 
         codec = QTextCodec::codecForName(currentCharset.toLatin1());
-        if (codec == 0)
+        if (codec == nullptr)
             codec = QTextCodec::codecForMib(4 /* latin-1 */);
     }
 
     /* FIX: file change can only be detected if the timestamp between the two consequent
        changes is more than 1s. If the archive is continuously changing (check: move files
        inside the archive), krarc may errorneusly think, that the archive file is unchanged,
        because the timestamp is the same as the previous one. This situation can only occur
        if the modification time equals with the current time. While this condition is true,
        we can say, that the archive is changing, so content reread is always necessary
        during that period. */
     if (archiveChanging)
         archiveChanged = true;
     archiveChanging = (currTime == (time_t)arcFile->time(KFileItem::ModificationTime).toTime_t());
 
     arcPath = getPath(arcFile->url(), QUrl::StripTrailingSlash);
     arcType = detectArchive(encrypted, arcPath);
 
     if (arcType == "tbz")
         arcType = "bzip2";
     else if (arcType == "tgz")
         arcType = "gzip";
     else if (arcType == "tlz")
         arcType = "lzma";
     else if (arcType == "txz")
         arcType = "xz";
 
     if (arcType.isEmpty()) {
         arcType = arcFile->mimetype();
         arcType = getShortTypeFromMime(arcType);
         if (arcType == "jar")
             arcType = "zip";
     }
 
     return initArcParameters();
 }
 
 bool kio_krarcProtocol::initDirDict(const QUrl &url, bool forced)
 {
     KRFUNC;
     KRDEBUG(getPath(url));
     // set the archive location
     //if( !setArcFile(getPath(url)) ) return false;
     // no need to rescan the archive if it's not changed
         // KRDEBUG("achiveChanged: " << archiveChanged << " forced: " << forced);
     if (!archiveChanged && !forced) {
         // KRDEBUG("doing nothing.");
         return true;
     }
 
     extArcReady = false;
 
     if (!setArcFile(url))
         return false;   /* if the archive was changed refresh the file information */
 
     // write the temp file
     KrLinecountingProcess proc;
     QTemporaryFile temp;
 
     // parse the temp file
     if (!temp.open()) {
         error(ERR_COULD_NOT_READ, temp.fileName());
         return false;
     }
 
     if (arcType != "bzip2" && arcType != "lzma" && arcType != "xz") {
         if (arcType == "rpm") {
             proc << listCmd << arcPath;
             proc.setStandardOutputFile(temp.fileName());
         } else {
             proc << listCmd << getPath(arcFile->url(), QUrl::StripTrailingSlash);
             proc.setStandardOutputFile(temp.fileName());
         }
         if (arcType == "ace" && QFile("/dev/ptmx").exists())    // Don't remove, unace crashes if missing!!!
             proc.setStandardInputFile("/dev/ptmx");
 
         proc.setOutputChannelMode(KProcess::SeparateChannels); // without this output redirection has no effect
         proc.start();
         proc.waitForFinished();
         if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(proc.exitCode())) return false;
     }
     // clear the dir dictionary
 
     QHashIterator< QString, KIO::UDSEntryList *> lit(dirDict);
     while (lit.hasNext())
         delete lit.next().value();
     dirDict.clear();
 
     // add the "/" directory
-    UDSEntryList* root = new UDSEntryList();
+    auto* root = new UDSEntryList();
     dirDict.insert(DIR_SEPARATOR, root);
     // and the "/" UDSEntry
     UDSEntry entry;
     entry.insert(KIO::UDSEntry::UDS_NAME, ".");
     mode_t mode = parsePermString("drwxr-xr-x");
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, mode & S_IFMT);   // keep file type only
     entry.insert(KIO::UDSEntry::UDS_ACCESS, mode & 07777);   // keep permissions only
 
     root->append(entry);
 
     if (arcType == "bzip2" || arcType == "lzma" || arcType == "xz")
         abort();
 
     char buf[1000];
     QString line;
 
     int lineNo = 0;
     bool invalidLine = false;
     // the rar list is started with a ------ line.
     if (arcType == "rar" || arcType == "arj" || arcType == "lha" || arcType == "7z") {
         while (temp.readLine(buf, 1000) != -1) {
             line = decodeString(buf);
             if (line.startsWith(QLatin1String("----------"))) break;
         }
     }
     while (temp.readLine(buf, 1000) != -1) {
         line = decodeString(buf);
         if (arcType == "rar") {
             // the rar list is ended with a ------ line.
             if (line.startsWith(QLatin1String("----------"))) {
                 invalidLine = !invalidLine;
                 break;
             }
             if (invalidLine)
                 continue;
             else {
                 if (line[0] == '*') // encrypted archives starts with '*'
                     line[0] = ' ';
             }
         }
         if (arcType == "ace") {
             // the ace list begins with a number.
             if (!line[0].isDigit()) continue;
         }
         if (arcType == "arj") {
             // the arj list is ended with a ------ line.
             if (line.startsWith(QLatin1String("----------"))) {
                 invalidLine = !invalidLine;
                 continue;
             }
             if (invalidLine)
                 continue;
             else {
                 temp.readLine(buf, 1000);
                 line = line + decodeString(buf);
                 temp.readLine(buf, 1000);
                 line = line + decodeString(buf);
                 temp.readLine(buf, 1000);
                 line = line + decodeString(buf);
             }
         }
         if (arcType == "lha" || arcType == "7z") {
             // the arj list is ended with a ------ line.
             if (line.startsWith(QLatin1String("----------"))) break;
         }
         parseLine(lineNo++, line.trimmed());
     }
     // close and delete our file
     temp.close();
 
     archiveChanged = false;
     // KRDEBUG("done.");
     return true;
 }
 
 QString kio_krarcProtocol::findArcDirectory(const QUrl &url)
 {
     KRFUNC;
     KRDEBUG(url.fileName());
 
     QString path = getPath(url);
     if (path.right(1) == DIR_SEPARATOR) path.truncate(path.length() - 1);
 
     if (!initDirDict(url)) {
         return QString();
     }
     QString arcDir = path.mid(getPath(arcFile->url()).length());
     arcDir.truncate(arcDir.lastIndexOf(DIR_SEPARATOR));
     if (arcDir.right(1) != DIR_SEPARATOR) arcDir = arcDir + DIR_SEPARATOR;
 
     return arcDir;
 }
 
 UDSEntry* kio_krarcProtocol::findFileEntry(const QUrl &url)
 {
     KRFUNC;
     QString arcDir = findArcDirectory(url);
-    if (arcDir.isEmpty()) return 0;
+    if (arcDir.isEmpty()) return nullptr;
 
     QHash<QString, KIO::UDSEntryList *>::iterator itef = dirDict.find(arcDir);
     if (itef == dirDict.end())
-        return 0;
+        return nullptr;
     UDSEntryList* dirList = itef.value();
 
     QString name = getPath(url);
     if (getPath(arcFile->url(), QUrl::StripTrailingSlash) == getPath(url, QUrl::StripTrailingSlash)) name = '.'; // the '/' case
     else {
         if (name.right(1) == DIR_SEPARATOR) name.truncate(name.length() - 1);
         name = name.mid(name.lastIndexOf(DIR_SEPARATOR) + 1);
     }
 
     UDSEntryList::iterator entry;
 
     for (entry = dirList->begin(); entry != dirList->end(); ++entry) {
         if ((entry->contains(KIO::UDSEntry::UDS_NAME)) &&
                 (entry->stringValue(KIO::UDSEntry::UDS_NAME) == name))
             return &(*entry);
     }
-    return 0;
+    return nullptr;
 }
 
 QString kio_krarcProtocol::nextWord(QString &s, char d)
 {
     // Note: KRFUNC was not used here in order to avoid filling the log with too much information
     s = s.trimmed();
     int j = s.indexOf(d, 0);
     QString temp = s.left(j); // find the leftmost word.
     s.remove(0, j);
     return temp;
 }
 
 mode_t kio_krarcProtocol::parsePermString(QString perm)
 {
     KRFUNC;
     mode_t mode = 0;
     // file type
     if (perm[0] == 'd') mode |= S_IFDIR;
 #ifndef Q_WS_WIN
     if (perm[0] == 'l') mode |= S_IFLNK;
 #endif
     if (perm[0] == '-') mode |= S_IFREG;
     // owner permissions
     if (perm[1] != '-') mode |= S_IRUSR;
     if (perm[2] != '-') mode |= S_IWUSR;
     if (perm[3] != '-') mode |= S_IXUSR;
 #ifndef Q_WS_WIN
     // group permissions
     if (perm[4] != '-') mode |= S_IRGRP;
     if (perm[5] != '-') mode |= S_IWGRP;
     if (perm[6] != '-') mode |= S_IXGRP;
     // other permissions
     if (perm[7] != '-') mode |= S_IROTH;
     if (perm[8] != '-') mode |= S_IWOTH;
     if (perm[9] != '-') mode |= S_IXOTH;
 #endif
     return mode;
 }
 
-UDSEntryList* kio_krarcProtocol::addNewDir(QString path)
+UDSEntryList* kio_krarcProtocol::addNewDir(const QString& path)
 {
     KRFUNC;
     UDSEntryList* dir;
 
     // check if the current dir exists
     QHash<QString, KIO::UDSEntryList *>::iterator itef = dirDict.find(path);
     if (itef != dirDict.end())
         return itef.value();
 
     // set dir to the parent dir
     dir = addNewDir(path.left(path.lastIndexOf(DIR_SEPARATOR, -2) + 1));
 
     // add a new entry in the parent dir
     QString name = path.mid(path.lastIndexOf(DIR_SEPARATOR, -2) + 1);
     name = name.left(name.length() - 1);
 
     if (name == "." || name == "..") { // entries with these names wouldn't be displayed
         // don't translate since this is an internal error
         QString err = QString("Cannot handle path: ") + path;
         // KRDEBUG("ERROR: " << err);
         error(KIO::ERR_INTERNAL, err);
         exit();
     }
 
     UDSEntry entry;
     entry.insert(KIO::UDSEntry::UDS_NAME, name);
     mode_t mode = parsePermString("drwxr-xr-x");
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, mode & S_IFMT);   // keep file type only
     entry.insert(KIO::UDSEntry::UDS_ACCESS, mode & 07777);   // keep permissions only
     entry.insert(KIO::UDSEntry::UDS_SIZE, 0);
     entry.insert(KIO::UDSEntry::UDS_MODIFICATION_TIME, arcFile->time(KFileItem::ModificationTime).toTime_t());
 
     dir->append(entry);
 
     // create a new directory entry and add it..
     dir = new UDSEntryList();
     dirDict.insert(path, dir);
 
     return dir;
 }
 
 void kio_krarcProtocol::parseLine(int lineNo, QString line)
 {
     KRFUNC;
     UDSEntryList* dir;
     UDSEntry entry;
 
     QString owner;
     QString group;
     QString symlinkDest;
     QString perm;
     mode_t mode          = 0666;
     size_t size          = 0;
-    time_t time          = ::time(0);
+    time_t time          = ::time(nullptr);
     QString fullName;
 
     if (arcType == "zip") {
         // permissions
         perm = nextWord(line);
         // ignore the next 2 fields
         nextWord(line); nextWord(line);
         // size
         size = nextWord(line).toLong();
         // ignore the next 2 fields
         nextWord(line);nextWord(line);
         // date & time
         QString d = nextWord(line);
         QDate qdate(d.mid(0, 4).toInt(), d.mid(4, 2).toInt(), d.mid(6, 2).toInt());
         QTime qtime(d.mid(9, 2).toInt(), d.mid(11, 2).toInt(), d.mid(13, 2).toInt());
         time = QDateTime(qdate, qtime).toTime_t();
         // full name
         fullName = nextWord(line, '\n');
 
         if (perm.length() != 10)
             perm = (perm.at(0) == 'd' || fullName.endsWith(DIR_SEPARATOR)) ? "drwxr-xr-x" : "-rw-r--r--" ;
         mode = parsePermString(perm);
     }
     if (arcType == "rar") {
         // permissions
         perm = nextWord(line);
         // size
         size = nextWord(line).toLong();
         // ignore the next 2 fields : packed size and compression ration
         nextWord(line); nextWord(line);
         // date & time
         QString d = nextWord(line);
         int year = 1900 + d.mid(6, 2).toInt();
         if (year < 1930)
             year += 100;
         QDate qdate(year, d.mid(3, 2).toInt(), d.mid(0, 2).toInt());
         QString t = nextWord(line);
         QTime qtime(t.mid(0, 2).toInt(), t.mid(3, 2).toInt(), 0);
         time = QDateTime(qdate, qtime).toTime_t();
         // checksum : ignored
         nextWord(line);
         // full name
         fullName = nextWord(line, '\n');
 
         if (perm.length() == 7) { // windows rar permission format
             bool isDir  = (perm.at(1).toLower() == 'd');
             bool isReadOnly = (perm.at(2).toLower() == 'r');
 
             perm = isDir ? "drwxr-xr-x" : "-rw-r--r--";
 
             if (isReadOnly)
                 perm[ 2 ] = '-';
         }
 
         if (perm.length() != 10) perm = (perm.at(0) == 'd') ? "drwxr-xr-x" : "-rw-r--r--" ;
         mode = parsePermString(perm);
     }
     if (arcType == "arj") {
         nextWord(line);
         // full name
         fullName = nextWord(line, '\n');
         // ignore the next 2 fields
         nextWord(line); nextWord(line);
         // size
         size = nextWord(line).toLong();
         // ignore the next 2 fields
         nextWord(line); nextWord(line);
         // date & time
         QString d = nextWord(line);
         int year = 1900 + d.mid(0, 2).toInt();
         if (year < 1930) year += 100;
         QDate qdate(year, d.mid(3, 2).toInt(), d.mid(6, 2).toInt());
         QString t = nextWord(line);
         QTime qtime(t.mid(0, 2).toInt(), t.mid(3, 2).toInt(), 0);
         time = QDateTime(qdate, qtime).toTime_t();
         // permissions
         perm = nextWord(line);
         if (perm.length() != 10) perm = (perm.at(0) == 'd') ? "drwxr-xr-x" : "-rw-r--r--" ;
         mode = parsePermString(perm);
     }
     if (arcType == "rpm") {
         // full name
         fullName = nextWord(line);
         // size
         size = nextWord(line).toULong();
         // date & time
         time = nextWord(line).toULong();
         // next field is md5sum, ignore it
         nextWord(line);
         // permissions
-        mode = nextWord(line).toULong(0, 8);
+        mode = nextWord(line).toULong(nullptr, 8);
         // Owner & Group
         owner = nextWord(line);
         group = nextWord(line);
         // symlink destination
 #ifndef Q_WS_WIN
         if (S_ISLNK(mode)) {
             // ignore the next 3 fields
             nextWord(line); nextWord(line); nextWord(line);
             symlinkDest = nextWord(line);
         }
 #endif
     }
     if (arcType == "gzip") {
         if (!lineNo) return;  //ignore the first line
         // first field is uncompressed size - ignore it
         nextWord(line);
         // size
         size = nextWord(line).toULong();
         // ignore the next field
         nextWord(line);
         // full name
         fullName = nextWord(line);
         fullName = fullName.mid(fullName.lastIndexOf(DIR_SEPARATOR) + 1);
     }
     if (arcType == "lzma") {
         fullName = arcFile->name();
         if (fullName.endsWith(QLatin1String("lzma"))) {
             fullName.truncate(fullName.length() - 5);
         }
         mode = arcFile->mode();
         size = arcFile->size();
     }
     if (arcType == "xz") {
         fullName = arcFile->name();
         if (fullName.endsWith(QLatin1String("xz"))) {
             fullName.truncate(fullName.length() - 3);
         }
         mode = arcFile->mode();
         size = arcFile->size();
     }
     if (arcType == "bzip2") {
         // There is no way to list bzip2 files, so we take our information from
         // the archive itself...
         fullName = arcFile->name();
         if (fullName.endsWith(QLatin1String("bz2"))) {
             fullName.truncate(fullName.length() - 4);
         }
         mode = arcFile->mode();
         size = arcFile->size();
     }
     if (arcType == "lha") {
         // permissions
         perm = nextWord(line);
         if (perm.length() != 10) perm = (perm.at(0) == 'd') ? "drwxr-xr-x" : "-rw-r--r--" ;
         mode = parsePermString(perm);
         // ignore the next field
         nextWord(line);
         // size
         size = nextWord(line).toLong();
         // ignore the next field
         nextWord(line);
         // date & time
         int month = (QString("Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec").split(',')).indexOf(nextWord(line)) + 1;
         int day = nextWord(line).toInt();
         int year = QDate::currentDate().year();
         QString third = nextWord(line);
         QTime qtime;
 
         if (third.contains(":"))
             qtime = QTime::fromString(third);
         else
             year = third.toInt();
 
         QDate qdate(year, month, day);
 
         time = QDateTime(qdate, qtime).toTime_t();
         // full name
         fullName = nextWord(line, '\n');
     }
     if (arcType == "ace") {
         // date & time
         QString d = nextWord(line);
         int year = 1900 + d.mid(6, 2).toInt();
         if (year < 1930) year += 100;
         QDate qdate(year, d.mid(3, 2).toInt(), d.mid(0, 2).toInt());
         QString t = nextWord(line);
         QTime qtime(t.mid(0, 2).toInt(), t.mid(3, 2).toInt(), 0);
         time = QDateTime(qdate, qtime).toTime_t();
         // ignore the next field
         nextWord(line);
         // size
         size = nextWord(line).toLong();
         // ignore the next field
         nextWord(line);
         // full name
         fullName = nextWord(line, '\n');
         if (fullName[ 0 ] == '*')  // encrypted archives starts with '*'
             fullName = fullName.mid(1);
     }
     if (arcType == "deb") {
         // permissions
         perm = nextWord(line);
         mode = parsePermString(perm);
         // Owner & Group
         owner = nextWord(line, DIR_SEPARATOR_CHAR);
         group = nextWord(line).mid(1);
         // size
         size = nextWord(line).toLong();
         // date & time
         QString d = nextWord(line);
         QDate qdate(d.mid(0, 4).toInt(), d.mid(5, 2).toInt(), d.mid(8, 2).toInt());
         QString t = nextWord(line);
         QTime qtime(t.mid(0, 2).toInt(), t.mid(3, 2).toInt(), 0);
         time = QDateTime(qdate, qtime).toTime_t();
         // full name
         fullName = nextWord(line, '\n').mid(1);
         //if ( fullName.right( 1 ) == "/" ) return;
         if (fullName.contains("->")) {
             symlinkDest = fullName.mid(fullName.indexOf("->") + 2);
             fullName = fullName.left(fullName.indexOf("->") - 1);
         }
     }
     if (arcType == "7z") {
         // date & time
         QString d = nextWord(line);
         QDate qdate(d.mid(0, 4).toInt(), d.mid(5, 2).toInt(), d.mid(8, 2).toInt());
         QString t = nextWord(line);
         QTime qtime(t.mid(0, 2).toInt(), t.mid(3, 2).toInt(), t.mid(6, 2).toInt());
         time = QDateTime(qdate, qtime).toTime_t();
 
         // permissions
         perm = nextWord(line);
         bool isDir  = (perm.at(0).toLower() == 'd');
         bool isReadOnly = (perm.at(1).toLower() == 'r');
         perm = isDir ? "drwxr-xr-x" : "-rw-r--r--";
         if (isReadOnly)
             perm[ 2 ] = '-';
 
         mode = parsePermString(perm);
 
         // size
         size = nextWord(line).toLong();
 
         // ignore the next 15 characters
         line = line.mid(15);
 
         // full name
         fullName = nextWord(line, '\n');
     }
 
     if (fullName.right(1) == DIR_SEPARATOR) fullName = fullName.left(fullName.length() - 1);
     if (!fullName.startsWith(DIR_SEPARATOR)) fullName = DIR_SEPARATOR + fullName;
     QString path = fullName.left(fullName.lastIndexOf(DIR_SEPARATOR) + 1);
     // set/create the directory UDSEntryList
     QHash<QString, KIO::UDSEntryList *>::iterator itef = dirDict.find(path);
     if (itef == dirDict.end())
         dir = addNewDir(path);
     else
         dir = itef.value();
 
     QString name = fullName.mid(fullName.lastIndexOf(DIR_SEPARATOR) + 1);
     // file name
     entry.insert(KIO::UDSEntry::UDS_NAME, name);
     // file type
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, mode & S_IFMT);   // keep file type only
     // file permissions
     entry.insert(KIO::UDSEntry::UDS_ACCESS, mode & 07777);   // keep permissions only
     // file size
     entry.insert(KIO::UDSEntry::UDS_SIZE, size);
     // modification time
     entry.insert(KIO::UDSEntry::UDS_MODIFICATION_TIME, time);
     // link destination
     if (!symlinkDest.isEmpty()) {
         entry.insert(KIO::UDSEntry::UDS_LINK_DEST, symlinkDest);
     }
     if (S_ISDIR(mode)) {
         fullName = fullName + DIR_SEPARATOR;
         if (dirDict.find(fullName) == dirDict.end())
             dirDict.insert(fullName, new UDSEntryList());
         else {
             // try to overwrite an existing entry
             UDSEntryList::iterator entryIt;
 
             for (entryIt = dir->begin(); entryIt != dir->end(); ++entryIt) {
                 if (entryIt->contains(KIO::UDSEntry::UDS_NAME) &&
                         entryIt->stringValue(KIO::UDSEntry::UDS_NAME) == name) {
                     entryIt->insert(KIO::UDSEntry::UDS_MODIFICATION_TIME, time);
                     entryIt->insert(KIO::UDSEntry::UDS_ACCESS, mode);
                     return;
                 }
             }
             return; // there is already an entry for this directory
         }
     }
 
     // multi volume archives can add a file twice, use only one
     UDSEntryList::iterator dirEntryIt;
 
     for (dirEntryIt = dir->begin(); dirEntryIt != dir->end(); ++dirEntryIt)
         if (dirEntryIt->contains(KIO::UDSEntry::UDS_NAME) &&
                 dirEntryIt->stringValue(KIO::UDSEntry::UDS_NAME) == name)
             return;
 
     dir->append(entry);
 }
 
 bool kio_krarcProtocol::initArcParameters()
 {
     KRFUNC;
     KRDEBUG("arcType: " << arcType);
 
     noencoding = false;
 
     cmd.clear();
     listCmd = QStringList();
     getCmd  = QStringList();
     copyCmd = QStringList();
     delCmd  = QStringList();
     putCmd  = QStringList();
     renCmd  = QStringList();
 
     if (arcType == "zip") {
         noencoding = true;
         cmd     = fullPathName("unzip");
         listCmd << fullPathName("unzip") << "-ZTs-z-t-h";
         getCmd  << fullPathName("unzip") << "-p";
         copyCmd << fullPathName("unzip") << "-jo";
 
         if (QStandardPaths::findExecutable(QStringLiteral("zip")).isEmpty()) {
             delCmd  = QStringList();
             putCmd  = QStringList();
         } else {
             delCmd  << fullPathName("zip") << "-d";
             putCmd  << fullPathName("zip") << "-ry";
         }
 
         if (!QStandardPaths::findExecutable(QStringLiteral("7za")).isEmpty()) {
             renCmd  << fullPathName("7za") << "rn";
         }
 
         if (!getPassword().isEmpty()) {
             getCmd  << "-P" << password;
             copyCmd << "-P" << password;
             putCmd  << "-P" << password;
         }
     } else if (arcType == "rar") {
         noencoding = true;
         if (QStandardPaths::findExecutable(QStringLiteral("rar")).isEmpty()) {
             cmd     = fullPathName("unrar");
             listCmd << fullPathName("unrar") << "-c-" << "-v" << "v";
             getCmd  << fullPathName("unrar") << "p" << "-ierr" << "-idp" << "-c-" << "-y";
             copyCmd << fullPathName("unrar") << "e" << "-y";
             delCmd  = QStringList();
             putCmd  = QStringList();
         } else {
             cmd     = fullPathName("rar");
             listCmd << fullPathName("rar") << "-c-" << "-v" << "v";
             getCmd  << fullPathName("rar") << "p" << "-ierr" << "-idp" << "-c-" << "-y";
             copyCmd << fullPathName("rar") << "e" << "-y";
             delCmd  << fullPathName("rar") << "d";
             putCmd  << fullPathName("rar") << "-r" << "a";
         }
         if (!getPassword().isEmpty()) {
             getCmd  << QString("-p%1").arg(password);
             listCmd << QString("-p%1").arg(password);
             copyCmd << QString("-p%1").arg(password);
             if (!putCmd.isEmpty()) {
                 putCmd << QString("-p%1").arg(password);
                 delCmd << QString("-p%1").arg(password);
             }
         }
     } else if (arcType == "rpm") {
         cmd     = fullPathName("rpm");
         listCmd << fullPathName("rpm") << "--dump" << "-lpq";
         getCmd  << fullPathName("cpio") << "--force-local" << "--no-absolute-filenames" << "-iuvdF";
         delCmd  = QStringList();
         putCmd  = QStringList();
         copyCmd = QStringList();
     } else if (arcType == "gzip") {
         cmd     = fullPathName("gzip");
         listCmd << fullPathName("gzip") << "-l";
         getCmd  << fullPathName("gzip") << "-dc";
         copyCmd = QStringList();
         delCmd  = QStringList();
         putCmd  = QStringList();
     } else if (arcType == "bzip2") {
         cmd     = fullPathName("bzip2");
         listCmd << fullPathName("bzip2");
         getCmd  << fullPathName("bzip2") << "-dc";
         copyCmd = QStringList();
         delCmd  = QStringList();
         putCmd  = QStringList();
     } else if (arcType == "lzma") {
         cmd     = fullPathName("lzma");
         listCmd << fullPathName("lzma");
         getCmd  << fullPathName("lzma") << "-dc";
         copyCmd = QStringList();
         delCmd  = QStringList();
         putCmd  = QStringList();
     } else if (arcType == "xz") {
         cmd     = fullPathName("xz");
         listCmd << fullPathName("xz");
         getCmd  << fullPathName("xz") << "-dc";
         copyCmd = QStringList();
         delCmd  = QStringList();
         putCmd  = QStringList();
     } else if (arcType == "arj") {
         cmd     = fullPathName("arj");
         listCmd << fullPathName("arj") << "v" << "-y" << "-v";
         getCmd  << fullPathName("arj") << "-jyov" << "-v" << "e";
         copyCmd << fullPathName("arj") << "-jyov" << "-v" << "e";
         delCmd  << fullPathName("arj") << "d";
         putCmd  << fullPathName("arj") << "-r" << "a";
         if (!getPassword().isEmpty()) {
             getCmd  << QString("-g%1").arg(password);
             copyCmd << QString("-g%1").arg(password);
             putCmd  << QString("-g%1").arg(password);
         }
     } else if (arcType == "lha") {
         cmd     = fullPathName("lha");
         listCmd << fullPathName("lha") << "l";
         getCmd  << fullPathName("lha") << "pq";
         copyCmd << fullPathName("lha") << "eif";
         delCmd  << fullPathName("lha") << "d";
         putCmd  << fullPathName("lha") << "a";
     } else if (arcType == "ace") {
         cmd     = fullPathName("unace");
         listCmd << fullPathName("unace") << "v";
         getCmd  << fullPathName("unace") << "e" << "-o";
         copyCmd << fullPathName("unace") << "e" << "-o";
         delCmd  = QStringList();
         putCmd  = QStringList();
         if (!getPassword().isEmpty()) {
             getCmd  << QString("-p%1").arg(password);
             copyCmd << QString("-p%1").arg(password);
         }
     } else if (arcType == "deb") {
         cmd = fullPathName("dpkg");
         listCmd << fullPathName("dpkg") << "-c";
         getCmd  << fullPathName("tar") << "xvf";
         copyCmd = QStringList();
         delCmd  = QStringList();
         putCmd  = QStringList();
     } else if (arcType == "7z") {
         noencoding = true;
         cmd = fullPathName("7z");
         if (QStandardPaths::findExecutable(cmd).isEmpty())
             cmd = fullPathName("7za");
 
         listCmd << cmd << "l" << "-y";
         getCmd  << cmd << "e" << "-y";
         copyCmd << cmd << "e" << "-y";
         delCmd  << cmd << "d" << "-y";
         putCmd  << cmd << "a" << "-y";
         renCmd  << cmd << "rn";
         if (!getPassword().isEmpty()) {
             getCmd  << QString("-p%1").arg(password);
             listCmd << QString("-p%1").arg(password);
             copyCmd << QString("-p%1").arg(password);
             if (!putCmd.isEmpty()) {
                 putCmd << QString("-p%1").arg(password);
                 delCmd << QString("-p%1").arg(password);
             }
         }
     }
     // checking if it's an absolute path
 #ifdef Q_WS_WIN
     if (cmd.length() > 2 && cmd[ 0 ].isLetter() && cmd[ 1 ] == ':')
         return true;
 #else
     if (cmd.startsWith(DIR_SEPARATOR))
         return true;
 #endif
     if (QStandardPaths::findExecutable(cmd).isEmpty()) {
         error(KIO::ERR_CANNOT_LAUNCH_PROCESS,
               cmd +
               i18n("\nMake sure that the %1 binary is installed properly on your system.", cmd));
         KRDEBUG("Failed to find cmd: " << cmd);
         return false;
     }
     return true;
 }
 
 bool kio_krarcProtocol::checkStatus(int exitCode)
 {
     KRFUNC;
     KRDEBUG(exitCode);
     return KrArcBaseManager::checkStatus(arcType, exitCode);
 }
 
 void kio_krarcProtocol::checkIf7zIsEncrypted(bool &encrypted, QString fileName)
 {
     KRFUNC;
     if (encryptedArchPath == fileName)
         encrypted = true;
     else {  // we try to find whether the 7z archive is encrypted
         // this is hard as the headers are also compressed
         QString tester = fullPathName("7z");
         if (QStandardPaths::findExecutable(tester).isEmpty()) {
             KRDEBUG("A 7z program was not found");
             tester = fullPathName("7za");
             if (QStandardPaths::findExecutable(tester).isEmpty()) {
                 KRDEBUG("A 7za program was not found");
                 return;
             }
         }
 
         QString testCmd = tester + " t -y ";
         lastData = encryptedArchPath = "";
 
         KrLinecountingProcess proc;
         proc << testCmd << fileName;
         connect(&proc, &KrLinecountingProcess::newOutputData, this, &kio_krarcProtocol::checkOutputForPassword);
         proc.start();
         proc.waitForFinished();
         encrypted = this->encrypted;
 
         if (encrypted)
             encryptedArchPath = fileName;
     }
 }
 
 void kio_krarcProtocol::checkOutputForPassword(KProcess * proc, QByteArray & buf)
 {
     KRFUNC;
     QString data =  QString(buf);
 
     QString checkable = lastData + data;
 
     QStringList lines = checkable.split('\n');
     lastData = lines[ lines.count() - 1 ];
     for (int i = 0; i != lines.count(); i++) {
         QString line = lines[ i ].trimmed().toLower();
         int ndx = line.indexOf("testing");
         if (ndx >= 0)
             line.truncate(ndx);
         if (line.isEmpty())
             continue;
 
         if (line.contains("password") && line.contains("enter")) {
             KRDEBUG("Encrypted 7z archive found!");
             encrypted = true;
             proc->kill();
             return;
         }
     }
 }
 
 void kio_krarcProtocol::invalidatePassword()
 {
     KRFUNC;
     KRDEBUG(getPath(arcFile->url(), QUrl::StripTrailingSlash) + DIR_SEPARATOR);
 
     if (!encrypted)
         return;
 
     KIO::AuthInfo authInfo;
     authInfo.caption = i18n("Krarc Password Dialog");
     authInfo.username = "archive";
     authInfo.readOnly = true;
     authInfo.keepPassword = true;
     authInfo.verifyPath = true;
     QString fileName = getPath(arcFile->url(), QUrl::StripTrailingSlash);
     authInfo.url = QUrl::fromLocalFile(ROOT_DIR);
     authInfo.url.setHost(fileName /*.replace('/','_')*/);
     authInfo.url.setScheme("krarc");
 
     password.clear();
 
     cacheAuthentication(authInfo);
 }
 
 QString kio_krarcProtocol::getPassword()
 {
     KRFUNC;
     KRDEBUG("Encrypted: " << encrypted);
 
     if (!password.isNull())
         return password;
     if (!encrypted)
         return (password = "");
 
     KIO::AuthInfo authInfo;
     authInfo.caption = i18n("Krarc Password Dialog");
     authInfo.username = "archive";
     authInfo.readOnly = true;
     authInfo.keepPassword = true;
     authInfo.verifyPath = true;
     QString fileName = getPath(arcFile->url(), QUrl::StripTrailingSlash);
     authInfo.url = QUrl::fromLocalFile(ROOT_DIR);
     authInfo.url.setHost(fileName /*.replace('/','_')*/);
     authInfo.url.setScheme("krarc");
 
     if (checkCachedAuthentication(authInfo) && !authInfo.password.isNull()) {
         KRDEBUG(authInfo.password);
         return (password = authInfo.password);
     }
 
     authInfo.password.clear();
 
 #if KIO_VERSION_MINOR >= 24
     int errCode = openPasswordDialogV2(authInfo, i18n("Accessing the file requires a password."));
     if (!errCode && !authInfo.password.isNull()) {
 #else
     if (openPasswordDialog(authInfo, i18n("Accessing the file requires a password.")) && !authInfo.password.isNull()) {
 #endif
         KRDEBUG(authInfo.password);
         return (password = authInfo.password);
 #if KIO_VERSION_MINOR >= 24
     } else {
         error(errCode, QString());
 #endif
     }
 
     KRDEBUG(password);
     return password;
 }
 
 QString kio_krarcProtocol::detectFullPathName(QString name)
 {
     // Note: KRFUNC was not used here in order to avoid filling the log with too much information
     KRDEBUG(name);
 
     name = name + EXEC_SUFFIX;
     QStringList path = QString::fromLocal8Bit(qgetenv("PATH")).split(':');
 
-    for (QStringList::Iterator it = path.begin(); it != path.end(); ++it) {
-        if (QDir(*it).exists(name)) {
-            QString dir = *it;
+    for (auto & it : path) {
+        if (QDir(it).exists(name)) {
+            QString dir = it;
             if (!dir.endsWith(DIR_SEPARATOR))
                 dir += DIR_SEPARATOR;
 
             return dir + name;
         }
     }
     return name;
 }
 
-QString kio_krarcProtocol::fullPathName(QString name)
+QString kio_krarcProtocol::fullPathName(const QString& name)
 {
     // Note: KRFUNC was not used here in order to avoid filling the log with too much information
     KRDEBUG(name);
 
     QString supposedName = confGrp.readEntry(name, QString());
     if (supposedName.isEmpty())
         supposedName = detectFullPathName(name);
     return supposedName;
 }
 
 QString kio_krarcProtocol::localeEncodedString(QString str)
 {
     // Note: KRFUNC was not used here in order to avoid filling the log with too much information
     if (noencoding)
         return str;
 
     QByteArray array = codec->fromUnicode(str);
 
     // encoding the byte array to QString, mapping 0x0000-0x00FF to 0xE000-0xE0FF
     // see KrArcCodec for more explanation
     int size = array.size();
     QString result;
 
     const char *data = array.data();
     for (int i = 0; i != size; i++) {
         unsigned short ch = (((int)data[ i ]) & 0xFF) + 0xE000;   // user defined character
         result.append(QChar(ch));
     }
     return result;
 }
 
-QByteArray kio_krarcProtocol::encodeString(QString str)
+QByteArray kio_krarcProtocol::encodeString(const QString& str)
 {
     // Note: KRFUNC was not used here in order to avoid filling the log with too much information
     if (noencoding)
         return QTextCodec::codecForLocale()->fromUnicode(str);
     return codec->fromUnicode(str);
 }
 
 QString kio_krarcProtocol::decodeString(char * buf)
 {
     // Note: KRFUNC was not used here in order to avoid filling the log with too much information
     if (noencoding)
         return QTextCodec::codecForLocale()->toUnicode(buf);
     return codec->toUnicode(buf);
 }
 
 QString kio_krarcProtocol::getPath(const QUrl &url, QUrl::FormattingOptions options)
 {
     // Note: KRFUNC was not used here in order to avoid filling the log with too much information
     QString path = url.adjusted(options).path();
     REPLACE_DIR_SEP2(path);
 
 #ifdef Q_WS_WIN
     if (path.startsWith(DIR_SEPARATOR)) {
         int p = 1;
         while (p < path.length() && path[ p ] == DIR_SEPARATOR_CHAR)
             p++;
         /* /C:/Folder */
         if (p + 2 <= path.length() && path[ p ].isLetter() && path[ p + 1 ] == ':') {
             path = path.mid(p);
         }
     }
 #endif
     return path;
 }
 
 #endif // KRARC_ENABLED
diff --git a/krArc/krarc.h b/krArc/krarc.h
index b1cb811f..db5faa96 100644
--- a/krArc/krarc.h
+++ b/krArc/krarc.h
@@ -1,145 +1,145 @@
 /*****************************************************************************
  * Copyright (C) 2003 Rafi Yanai <yanai@users.sf.net>                        *
  * Copyright (C) 2003 Shie Erlich <yanai@users.sf.net>                       *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #ifndef KRARC_H
 #define KRARC_H
 
 // QtCore
 #include <QString>
 #include <QHash>
 #include <QFile>
 #include <QUrl>
 
 #include <KIO/Global>
 #include <KIO/SlaveBase>
 #include <KCoreAddons/KProcess>
 #include <KConfigCore/KConfig>
 #include <KConfigCore/KConfigGroup>
 
 #include "krarcbasemanager.h"
 #include "krlinecountingprocess.h"
 #include "../krusader/krdebuglogger.h"
 
 class KFileItem;
 class QByteArray;
 class QTextCodec;
 
 class kio_krarcProtocol : public QObject, public KIO::SlaveBase, public KrArcBaseManager
 {
     Q_OBJECT
 public:
     kio_krarcProtocol(const QByteArray &pool_socket, const QByteArray &app_socket);
-    virtual ~kio_krarcProtocol();
-    virtual void stat(const QUrl &url) Q_DECL_OVERRIDE;
-    virtual void get(const QUrl &url) Q_DECL_OVERRIDE;
-    virtual void put(const QUrl &url, int permissions, KIO::JobFlags flags) Q_DECL_OVERRIDE;
-    virtual void mkdir(const QUrl &url, int permissions) Q_DECL_OVERRIDE;
-    virtual void listDir(const QUrl &url) Q_DECL_OVERRIDE;
-    virtual void del(QUrl const & url, bool isFile) Q_DECL_OVERRIDE;
-    virtual void copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags) Q_DECL_OVERRIDE;
-    virtual void rename(const QUrl &src, const QUrl & dest, KIO::JobFlags flags) Q_DECL_OVERRIDE;
+    ~kio_krarcProtocol() override;
+    void stat(const QUrl &url) Q_DECL_OVERRIDE;
+    void get(const QUrl &url) Q_DECL_OVERRIDE;
+    void put(const QUrl &url, int permissions, KIO::JobFlags flags) Q_DECL_OVERRIDE;
+    void mkdir(const QUrl &url, int permissions) Q_DECL_OVERRIDE;
+    void listDir(const QUrl &url) Q_DECL_OVERRIDE;
+    void del(QUrl const & url, bool isFile) Q_DECL_OVERRIDE;
+    void copy(const QUrl &src, const QUrl &dest, int permissions, KIO::JobFlags flags) Q_DECL_OVERRIDE;
+    void rename(const QUrl &src, const QUrl & dest, KIO::JobFlags flags) Q_DECL_OVERRIDE;
 
 public slots:
     void receivedData(KProcess *, QByteArray &);
     void checkOutputForPassword(KProcess *, QByteArray &);
 
 protected:
     virtual bool   initDirDict(const QUrl &url, bool forced = false);
     virtual bool   initArcParameters();
     void checkIf7zIsEncrypted(bool &, QString) Q_DECL_OVERRIDE;
     virtual void parseLine(int lineNo, QString line);
     virtual bool setArcFile(const QUrl &url);
     virtual QString getPassword();
     virtual void invalidatePassword();
-    QString getPath(const QUrl &url, QUrl::FormattingOptions options = 0);
+    QString getPath(const QUrl &url, QUrl::FormattingOptions options = nullptr);
 
     QString localeEncodedString(QString str);
-    QByteArray encodeString(QString);
+    QByteArray encodeString(const QString&);
     QString decodeString(char *);
 
     // archive specific commands
     QString     cmd;     ///< the archiver name.
     QStringList listCmd; ///< list files.
     QStringList getCmd;  ///< unpack files command.
     QStringList delCmd;  ///< delete files command.
     QStringList putCmd;  ///< add file command.
     QStringList copyCmd; ///< copy to file command.
     QStringList renCmd;  ///< rename file command.
 
 private:
     void get(const QUrl &url, int tries);
     /** checks if a returned status ("exit code") of an archiving-related process is OK. */
     bool checkStatus(int exitCode);
     /** service function for parseLine. */
     QString nextWord(QString &s, char d = ' ');
     /** translate permission string to mode_t. */
     mode_t parsePermString(QString perm);
     /** return the name of the directory inside the archive. */
     QString findArcDirectory(const QUrl &url);
     /** find the UDSEntry of a file in a directory. */
     KIO::UDSEntry* findFileEntry(const QUrl &url);
     /** add a new directory (file list container). */
-    KIO::UDSEntryList* addNewDir(QString path);
-    QString fullPathName(QString name);
+    KIO::UDSEntryList* addNewDir(const QString& path);
+    QString fullPathName(const QString& name);
     static QString detectFullPathName(QString name);
     bool checkWriteSupport();
 
     QHash<QString, KIO::UDSEntryList *> dirDict; //< the directories data structure.
     bool encrypted;                   //< tells whether the archive is encrypted
     bool archiveChanged;              //< true if the archive was changed.
     bool archiveChanging;             //< true if the archive is currently changing.
     bool newArchiveURL;               //< true if new archive was entered for the protocol
     bool noencoding;                  //< 7z files use UTF-16, so encoding is unnecessary
     KIO::filesize_t decompressedLen;  //< the number of the decompressed bytes
     KFileItem* arcFile;               //< the archive file item.
     QString arcPath;                  //< the archive location
     QString arcTempDir;               //< the currently used temp directory.
     QString arcType;                  //< the archive type.
     bool extArcReady;                 //< Used for RPM & DEB files.
     QString password;                 //< Password for the archives
     KConfig krConf;                   //< The configuration file for krusader
     KConfigGroup confGrp;             //< the 'Dependencies' config group
 
     QString lastData;
     QString encryptedArchPath;
 
     QString currentCharset;
     QTextCodec * codec;
 };
 
 #ifdef Q_WS_WIN
 #define DIR_SEPARATOR       "/"
 #define DIR_SEPARATOR2      "\\"
 #define DIR_SEPARATOR_CHAR  '/'
 #define DIR_SEPARATOR_CHAR2 '\\'
 #define REPLACE_DIR_SEP2(x) x = x.replace( DIR_SEPARATOR2, DIR_SEPARATOR );
 #define ROOT_DIR            "C:\\"
 #define EXEC_SUFFIX         ".exe"
 #else
 #define DIR_SEPARATOR       "/"
 #define DIR_SEPARATOR2      "/"
 #define DIR_SEPARATOR_CHAR  '/'
 #define DIR_SEPARATOR_CHAR2 '/'
 #define REPLACE_DIR_SEP2(x)
 #define ROOT_DIR            "/"
 #define EXEC_SUFFIX         ""
 #endif
 
 #endif
diff --git a/krArc/krarcbasemanager.cpp b/krArc/krarcbasemanager.cpp
index 21a27aaa..8bec551f 100644
--- a/krArc/krarcbasemanager.cpp
+++ b/krArc/krarcbasemanager.cpp
@@ -1,234 +1,234 @@
 /*****************************************************************************
  * Copyright (C) 2003 Rafi Yanai <krusader@users.sf.net>                     *
  * Copyright (C) 2003 Shie Erlich <krusader@users.sf.net>                    *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krarcbasemanager.h"
 
 #include <KArchive/KTar>
 
 KrArcBaseManager::AutoDetectParams KrArcBaseManager::autoDetectParams[] = {{"zip",  0, "PK\x03\x04"},
     {"rar",  0, "Rar!\x1a" },
     {"arj",  0, "\x60\xea" },
     {"rpm",  0, "\xed\xab\xee\xdb"},
     {"ace",  7, "**ACE**" },
     {"bzip2", 0, "\x42\x5a\x68\x39\x31" },
     {"gzip", 0, "\x1f\x8b"},
     {"deb",  0, "!<arch>\ndebian-binary   " },
     {"7z",   0, "7z\xbc\xaf\x27\x1c" }/*,
     {"xz",   0, "\xfd\x37\x7a\x58\x5a\x00"}*/
 };
 
 int KrArcBaseManager::autoDetectElems = sizeof(autoDetectParams) / sizeof(AutoDetectParams);
 const int KrArcBaseManager::maxLenType = 5;
 
 //! Checks if a returned status ("exit code") of an archiving-related process is OK
 /*!
     \param arcType A short QString which contains an identifier of the type of the archive.
     \param exitCode The returned status ("exit code") of an archiving-related process.
     \return If the exit code means that the archiving-related process ended without errors.
 */
 bool KrArcBaseManager::checkStatus(const QString &arcType, int exitCode)
 {
     if (arcType == "zip" || arcType == "rar" || arcType == "7z")
         return exitCode == 0 || exitCode == 1;
     else if (arcType == "ace" || arcType == "bzip2" || arcType == "lha" || arcType == "rpm" || arcType == "cpio" ||
              arcType == "tar" || arcType == "tarz" || arcType == "tbz" || arcType == "tgz" || arcType == "arj" ||
              arcType == "deb" || arcType == "tlz" || arcType == "txz")
         return exitCode == 0;
     else if (arcType == "gzip" || arcType == "lzma" || arcType == "xz")
         return exitCode == 0 || exitCode == 2;
     else
         return exitCode == 0;
 }
 
-QString KrArcBaseManager::detectArchive(bool &encrypted, QString fileName, bool checkEncrypted, bool fast)
+QString KrArcBaseManager::detectArchive(bool &encrypted, const QString& fileName, bool checkEncrypted, bool fast)
 {
     encrypted = false;
 
     QFile arcFile(fileName);
     if (arcFile.open(QIODevice::ReadOnly)) {
         char buffer[ 1024 ];
         long sizeMax = arcFile.read(buffer, sizeof(buffer));
         arcFile.close();
 
         for (int i = 0; i < autoDetectElems; i++) {
             QByteArray detectionString = autoDetectParams[ i ].detectionString;
             int location = autoDetectParams[ i ].location;
 
             int endPtr = detectionString.length() + location;
             if (endPtr > sizeMax)
                 continue;
 
             int j = 0;
             for (; j != detectionString.length(); j++) {
                 if (detectionString[ j ] == '?')
                     continue;
                 if (buffer[ location + j ] != detectionString[ j ])
                     break;
             }
 
             if (j == detectionString.length()) {
                 QString type = autoDetectParams[ i ].type;
                 if (type == "bzip2" || type == "gzip") {
                     if (fast) {
                         if (fileName.endsWith(QLatin1String(".tar.gz")))
                             type = "tgz";
                         else if (fileName.endsWith(QLatin1String(".tar.bz2")))
                             type = "tbz";
                     } else {
                         KTar tapeArchive(fileName);
                         if (tapeArchive.open(QIODevice::ReadOnly)) {
                             tapeArchive.close();
                             if (type == "gzip")
                                 type = "tgz";
                             else if (type == "bzip2")
                                 type = "tbz";
                         }
                     }
                 } else if (type == "zip")
                     encrypted = (buffer[6] & 1);
                 else if (type == "arj") {
                     if (sizeMax > 4) {
                         long headerSize = ((unsigned char *)buffer)[ 2 ] + 256 * ((unsigned char *)buffer)[ 3 ];
                         long fileHeader = headerSize + 10;
                         if (fileHeader + 9 < sizeMax && buffer[ fileHeader ] == (char)0x60 && buffer[ fileHeader + 1 ] == (char)0xea)
                             encrypted = (buffer[ fileHeader + 8 ] & 1);
                     }
                 } else if (type == "rar") {
                     if (sizeMax > 13 && buffer[ 9 ] == (char)0x73) {
                         if (buffer[ 10 ] & 0x80) {  // the header is encrypted?
                             encrypted = true;
                         } else {
                             long offset = 7;
                             long mainHeaderSize = ((unsigned char *)buffer)[ offset+5 ] + 256 * ((unsigned char *)buffer)[ offset+6 ];
                             offset += mainHeaderSize;
                             while (offset + 10 < sizeMax) {
                                 long headerSize = ((unsigned char *)buffer)[ offset+5 ] + 256 * ((unsigned char *)buffer)[ offset+6 ];
                                 bool isDir = (buffer[ offset+7 ] == '\0') && (buffer[ offset+8 ] == '\0') &&
                                              (buffer[ offset+9 ] == '\0') && (buffer[ offset+10 ] == '\0');
 
                                 if (buffer[ offset + 2 ] != (char)0x74)
                                     break;
                                 if (!isDir) {
                                     encrypted = (buffer[ offset + 3 ] & 4) != 0;
                                     break;
                                 }
                                 offset += headerSize;
                             }
                         }
                     }
                 } else if (type == "ace") {
                     long offset = 0;
                     long mainHeaderSize = ((unsigned char *)buffer)[ offset+2 ] + 256 * ((unsigned char *)buffer)[ offset+3 ] + 4;
                     offset += mainHeaderSize;
                     while (offset + 10 < sizeMax) {
                         long headerSize = ((unsigned char *)buffer)[ offset+2 ] + 256 * ((unsigned char *)buffer)[ offset+3 ] + 4;
                         bool isDir = (buffer[ offset+11 ] == '\0') && (buffer[ offset+12 ] == '\0') &&
                                      (buffer[ offset+13 ] == '\0') && (buffer[ offset+14 ] == '\0');
 
                         if (buffer[ offset + 4 ] != (char)0x01)
                             break;
                         if (!isDir) {
                             encrypted = (buffer[ offset + 6 ] & 64) != 0;
                             break;
                         }
                         offset += headerSize;
                     }
                 } else if (type == "7z") {
                     // encryption check is expensive, check only if it's necessary
                     if (checkEncrypted)
                         checkIf7zIsEncrypted(encrypted, fileName);
                 }
                 return type;
             }
         }
 
         if (sizeMax >= 512) {
             /* checking if it's a tar file */
             unsigned checksum = 32 * 8;
             char chksum[ 9 ];
             for (int i = 0; i != 512; i++)
                 checksum += ((unsigned char *)buffer)[ i ];
             for (int i = 148; i != 156; i++)
                 checksum -= ((unsigned char *)buffer)[ i ];
             sprintf(chksum, "0%o", checksum);
             if (!memcmp(buffer + 148, chksum, strlen(chksum))) {
                 int k = strlen(chksum);
                 for (; k < 8; k++)
                     if (buffer[148+k] != 0 && buffer[148+k] != 32)
                         break;
                 if (k == 8)
                     return "tar";
             }
         }
     }
 
     if (fileName.endsWith(QLatin1String(".tar.lzma")) ||
             fileName.endsWith(QLatin1String(".tlz"))) {
         return "tlz";
     }
     if (fileName.endsWith(QLatin1String(".lzma"))) {
         return "lzma";
     }
 
     if (fileName.endsWith(QLatin1String(".tar.xz")) ||
             fileName.endsWith(QLatin1String(".txz"))) {
         return "txz";
     }
     if (fileName.endsWith(QLatin1String(".xz"))) {
         return "xz";
     }
 
     return QString();
 }
 
 //! Returns a short identifier of the type of a file, obtained from the mime type of the file
 /*!
     \param mime The mime type of the file.
     \return A short QString which contains an identifier of the type of the file.
 */
 QString KrArcBaseManager::getShortTypeFromMime(const QString &mime)
 {
     // 7zip files are a not a normal case because their mimetype does not
     // follow the norm of other types: zip, tar, lha, ace, arj, etc.
     if (mime == "application/x-7z-compressed")
         return "7z";
 
     // If it's a rar file but its mimetype isn't "application/x-rar"
     if (mime == "application/x-rar-compressed")
         return "rar";
 
     // The short type that will be returned
     QString sType = mime;
 
     int lastHyphen = sType.lastIndexOf('-');
     if (lastHyphen != -1)
         sType = sType.mid(lastHyphen + 1);
     else {
         int lastSlash = sType.lastIndexOf('/');
         if (lastSlash != -1)
             sType = sType.mid(lastSlash + 1);
     }
     // The identifier kept short
     if (sType.length() > maxLenType)
         sType = sType.right(maxLenType);
 
     return sType;
 }
diff --git a/krArc/krarcbasemanager.h b/krArc/krarcbasemanager.h
index b5a137f7..833f1cf3 100644
--- a/krArc/krarcbasemanager.h
+++ b/krArc/krarcbasemanager.h
@@ -1,59 +1,59 @@
 /*****************************************************************************
  * Copyright (C) 2003 Rafi Yanai <krusader@users.sf.net>                     *
  * Copyright (C) 2003 Shie Erlich <krusader@users.sf.net>                    *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRARCBASEMANAGER_H
 #define KRARCBASEMANAGER_H
 
 // QtCore
 #include <QFile>
 
 /*!
  * \brief An abstract base class for managing archives.
  */
 class KrArcBaseManager
 {
 private:
     //! Information about a type of archive and the bytes that are used to detect it.
     struct AutoDetectParams {
         QString type;
         int location;
         QByteArray detectionString;
     };
 
     static AutoDetectParams autoDetectParams[]; //! Information used to detect if a file is an archive
     static int autoDetectElems; //!< The size of autoDetectParams[]
 
 protected:
     //! The maximum length of a short QString that represents the type of a file
     static const int maxLenType;
 
     static bool checkStatus(const QString &, int);
 
 public:
     KrArcBaseManager() {}
-    QString detectArchive(bool &, QString, bool = true, bool = false);
+    QString detectArchive(bool &, const QString&, bool = true, bool = false);
     virtual void checkIf7zIsEncrypted(bool &, QString) = 0;
     static QString getShortTypeFromMime(const QString &);
     virtual ~KrArcBaseManager() {}
 };
 
 #endif // KRARCBASEMANAGER_H
 
diff --git a/krArc/krlinecountingprocess.cpp b/krArc/krlinecountingprocess.cpp
index 8f4951cc..4a94c649 100644
--- a/krArc/krlinecountingprocess.cpp
+++ b/krArc/krlinecountingprocess.cpp
@@ -1,66 +1,66 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krlinecountingprocess.h"
 
-KrLinecountingProcess::KrLinecountingProcess() : KProcess()
+KrLinecountingProcess::KrLinecountingProcess()
 {
     setOutputChannelMode(KProcess::SeparateChannels); // without this output redirection has no effect!
     connect(this, &KrLinecountingProcess::readyReadStandardError, this, &KrLinecountingProcess::receivedError);
     connect(this, &KrLinecountingProcess::readyReadStandardOutput, [=]() { receivedOutput(); });
     mergedOutput = true;
 }
 
 void KrLinecountingProcess::setMerge(bool value)
 {
     mergedOutput = value;
 }
 
 QString KrLinecountingProcess::getErrorMsg()
 {
     if (errorData.trimmed().isEmpty())
         return QString::fromLocal8Bit(outputData);
     else
         return QString::fromLocal8Bit(errorData);
 }
 
 void KrLinecountingProcess::receivedError()
 {
     QByteArray newData(this->readAllStandardError());
     emit newErrorLines(newData.count('\n'));
     errorData += newData;
     if (errorData.length() > 500)
         errorData = errorData.right(500);
     if (mergedOutput)
         receivedOutput(newData);
 }
 
 void KrLinecountingProcess::receivedOutput(QByteArray newData)
 {
     if (newData.isEmpty())
         newData = this->readAllStandardOutput();
     emit newOutputLines(newData.count('\n'));
     emit newOutputData(this, newData);
     outputData += newData;
     if (outputData.length() > 500)
         outputData = outputData.right(500);
 }
 
diff --git a/krusader/ActionMan/actionman.cpp b/krusader/ActionMan/actionman.cpp
index 76f22d09..5e97c9f4 100644
--- a/krusader/ActionMan/actionman.cpp
+++ b/krusader/ActionMan/actionman.cpp
@@ -1,87 +1,86 @@
 /*****************************************************************************
  * Copyright (C) 2006 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "actionman.h"
 
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "useractionpage.h"
 #include "../krusader.h"
 #include "../UserAction/useraction.h"
 
 ActionMan::ActionMan(QWidget * parent)
     : QDialog(parent)
 {
     setWindowModality(Qt::WindowModal);
     setWindowTitle(i18n("ActionMan - Manage Your Useractions"));
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     userActionPage = new UserActionPage(this);
     mainLayout->addWidget(userActionPage);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close|QDialogButtonBox::Apply);
     mainLayout->addWidget(buttonBox);
 
     applyButton = buttonBox->button(QDialogButtonBox::Apply);
     applyButton->setEnabled(false);
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &ActionMan::slotClose);
     connect(applyButton, &QPushButton::clicked, this, &ActionMan::slotApply);
     connect(userActionPage, &UserActionPage::changed, this, &ActionMan::slotEnableApplyButton);
     connect(userActionPage, &UserActionPage::applied, this, &ActionMan::slotDisableApplyButton);
 
     exec();
 
     krApp->updateUserActions();
 }
 
 ActionMan::~ActionMan()
-{
-}
+= default;
 
 void ActionMan::slotClose()
 {
     if (userActionPage->readyToQuit())
         reject();
 }
 
 void ActionMan::slotApply()
 {
     userActionPage->applyChanges();
 }
 
 void ActionMan::slotEnableApplyButton()
 {
     applyButton->setEnabled(true);
 }
 
 void ActionMan::slotDisableApplyButton()
 {
     applyButton->setEnabled(false);
 }
 
diff --git a/krusader/ActionMan/actionman.h b/krusader/ActionMan/actionman.h
index 3ae9891a..8aeaab0a 100644
--- a/krusader/ActionMan/actionman.h
+++ b/krusader/ActionMan/actionman.h
@@ -1,50 +1,50 @@
 /*****************************************************************************
  * Copyright (C) 2006 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef ACTIONMAN_H
 #define ACTIONMAN_H
 
 // QtWidgets
 #include <QDialog>
 
 class UserActionPage;
 
 /**
  * This manages all useractions
  */
 class ActionMan : public QDialog
 {
     Q_OBJECT
 public:
-    explicit ActionMan(QWidget* parent = 0);
-    ~ActionMan();
+    explicit ActionMan(QWidget* parent = nullptr);
+    ~ActionMan() override;
 
 protected slots:
     void slotClose();
     void slotApply();
     void slotEnableApplyButton();
     void slotDisableApplyButton();
 
 private:
     UserActionPage* userActionPage;
     QPushButton *applyButton;
 };
 
 #endif // ifndef ACTIONMAN_H
diff --git a/krusader/ActionMan/actionproperty.cpp b/krusader/ActionMan/actionproperty.cpp
index e7bc16dc..a38469fb 100644
--- a/krusader/ActionMan/actionproperty.cpp
+++ b/krusader/ActionMan/actionproperty.cpp
@@ -1,518 +1,517 @@
 /*****************************************************************************
  * Copyright (C) 2004-2007 Jonas Bähr <jonas.baehr@web.de>                   *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "actionproperty.h"
 #include "addplaceholderpopup.h"
 
 #include "../UserAction/useraction.h"
 #include "../UserAction/kraction.h"
 #include "../krusader.h"
 #include "../krglobal.h"
 #include "../icon.h"
 
 // QtWidgets
 #include <QFileDialog>
 #include <QInputDialog>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 #include <KXmlGui/KActionCollection>
 
 
 ActionProperty::ActionProperty(QWidget *parent, KrAction *action)
         : QWidget(parent), _modified(false)
 {
 
     setupUi(this);
 
     if (action) {
         _action = action;
         updateGUI(_action);
     }
 
     ButtonAddPlaceholder->setIcon(Icon("list-add"));
     ButtonAddStartpath->setIcon(Icon("document-open"));
 
     // fill with all existing categories
     cbCategory->addItems(krUserAction->allCategories());
 
     connect(ButtonAddPlaceholder, &QToolButton::clicked, this, &ActionProperty::addPlaceholder);
     connect(ButtonAddStartpath, &QToolButton::clicked, this, &ActionProperty::addStartpath);
     connect(ButtonNewProtocol, &QToolButton::clicked, this, &ActionProperty::newProtocol);
     connect(ButtonEditProtocol, &QToolButton::clicked, this, &ActionProperty::editProtocol);
     connect(ButtonRemoveProtocol, &QToolButton::clicked, this, &ActionProperty::removeProtocol);
     connect(ButtonAddPath, &QToolButton::clicked, this, &ActionProperty::addPath);
     connect(ButtonEditPath, &QToolButton::clicked, this, &ActionProperty::editPath);
     connect(ButtonRemovePath, &QToolButton::clicked, this, &ActionProperty::removePath);
     connect(ButtonAddMime, &QToolButton::clicked, this, &ActionProperty::addMime);
     connect(ButtonEditMime, &QToolButton::clicked, this, &ActionProperty::editMime);
     connect(ButtonRemoveMime, &QToolButton::clicked, this, &ActionProperty::removeMime);
     connect(ButtonNewFile, &QToolButton::clicked, this, &ActionProperty::newFile);
     connect(ButtonEditFile, &QToolButton::clicked, this, &ActionProperty::editFile);
     connect(ButtonRemoveFile, &QToolButton::clicked, this, &ActionProperty::removeFile);
     connect(KeyButtonShortcut, &KKeySequenceWidget::keySequenceChanged, this, &ActionProperty::changedShortcut);
     // track modifications:
     connect(leDistinctName, &KLineEdit::textChanged, this, [=]() { setModified(true); });
     connect(leTitle, &KLineEdit::textChanged, this, [=]() {setModified(true); });
     connect(ButtonIcon, &KIconButton::iconChanged, this, [=]() {setModified(true); });
     connect(cbCategory, &KComboBox::currentTextChanged, this, [=]() {setModified(true); });
     connect(leTooltip, &KLineEdit::textChanged, this, [=]() {setModified(true); });
     connect(textDescription, &KTextEdit::textChanged, this, [=]() {setModified(true); });
     connect(leCommandline, &KLineEdit::textChanged, this, [=]() {setModified(true); });
     connect(leStartpath, &KLineEdit::textChanged, this, [=]() {setModified(true); });
     connect(chkSeparateStdError, &QCheckBox::clicked, this, &ActionProperty::setModified);
     connect(radioCollectOutput, &QRadioButton::clicked, this, &ActionProperty::setModified);
     connect(radioNormal, &QRadioButton::clicked, this, &ActionProperty::setModified);
     connect(radioTE, &QRadioButton::clicked, this, &ActionProperty::setModified);
     connect(radioTerminal, &QRadioButton::clicked, this, &ActionProperty::setModified);
     connect(radioLocal, &QRadioButton::clicked, this, &ActionProperty::setModified);
     connect(radioUrl, &QRadioButton::clicked, this, &ActionProperty::setModified);
     connect(KeyButtonShortcut, &KKeySequenceWidget::keySequenceChanged, this, [=]() {setModified(true); });
     connect(chkEnabled, &QCheckBox::clicked, this, &ActionProperty::setModified);
     connect(leDifferentUser, &KLineEdit::textChanged, this, [=]() {setModified(true); });
     connect(chkDifferentUser, &QCheckBox::clicked, this, &ActionProperty::setModified);
     connect(chkConfirmExecution, &QCheckBox::clicked, this, &ActionProperty::setModified);
     connect(chkSeparateStdError, &QCheckBox::clicked, this, &ActionProperty::setModified);
     // The modified-state of the ShowOnly-lists is tracked in the access-functions below
 }
 
 ActionProperty::~ActionProperty()
-{
-}
+= default;
 
 void ActionProperty::changedShortcut(const QKeySequence& shortcut)
 {
     KeyButtonShortcut->setKeySequence(shortcut);
 }
 
 
 void ActionProperty::clear()
 {
-    _action = 0;
+    _action = nullptr;
 
     // This prevents the changed-signal from being emitted during the GUI-update
     _modified = true; // The real state is set at the end of this function.
 
     leDistinctName->clear();
     cbCategory->clearEditText();
     leTitle->clear();
     leTooltip->clear();
     textDescription->clear();
     leCommandline->clear();
     leStartpath->clear();
     KeyButtonShortcut->clearKeySequence();
 
     lbShowonlyProtocol->clear();
     lbShowonlyPath->clear();
     lbShowonlyMime->clear();
     lbShowonlyFile->clear();
 
     chkSeparateStdError->setChecked(false);
     radioNormal->setChecked(true);
 
     radioLocal->setChecked(true);
 
     chkEnabled->setChecked(true);
 
     chkConfirmExecution->setChecked(false);
 
     ButtonIcon->resetIcon();
 
     leDifferentUser->clear();
     chkDifferentUser->setChecked(false);
 
     setModified(false);
 }
 
 void ActionProperty::updateGUI(KrAction *action)
 {
     if (action)
         _action = action;
     if (! _action)
         return;
 
     // This prevents the changed-signal from being emitted during the GUI-update.
     _modified = true; // The real state is set at the end of this function.
 
     leDistinctName->setText(_action->objectName());
     cbCategory->lineEdit()->setText(_action->category());
     leTitle->setText(_action->text());
     leTooltip->setText(_action->toolTip());
     textDescription->setText(_action->whatsThis());
     leCommandline->setText(_action->command());
     leCommandline->home(false);
     leStartpath->setText(_action->startpath());
     KeyButtonShortcut->setKeySequence(_action->shortcut());
 
     lbShowonlyProtocol->clear();
     lbShowonlyProtocol->addItems(_action->showonlyProtocol());
     lbShowonlyPath->clear();
     lbShowonlyPath->addItems(_action->showonlyPath());
     lbShowonlyMime->clear();
     lbShowonlyMime->addItems(_action->showonlyMime());
     lbShowonlyFile->clear();
     lbShowonlyFile->addItems(_action->showonlyFile());
 
     chkSeparateStdError->setChecked(false);
     switch (_action->execType()) {
     case KrAction::CollectOutputSeparateStderr:
         chkSeparateStdError->setChecked(true);
         radioCollectOutput->setChecked(true);
         break;
     case KrAction::CollectOutput:
         radioCollectOutput->setChecked(true);
         break;
     case KrAction::Terminal:
         radioTerminal->setChecked(true);
         break;
     case KrAction::RunInTE:
         radioTE->setChecked(true);
         break;
     default: // case KrAction::Normal:
         radioNormal->setChecked(true);
         break;
     }
 
     if (_action->acceptURLs())
         radioUrl->setChecked(true);
     else
         radioLocal->setChecked(true);
 
     chkEnabled->setChecked(_action->isVisible());
 
     chkConfirmExecution->setChecked(_action->confirmExecution());
 
     if (! _action->icon().isNull())
         ButtonIcon->setIcon(_action->icon());
     else
         ButtonIcon->resetIcon();
 
     leDifferentUser->setText(_action->user());
     if (_action->user().isEmpty())
         chkDifferentUser->setChecked(false);
     else
         chkDifferentUser->setChecked(true);
 
     setModified(false);
 }
 
 void ActionProperty::updateAction(KrAction *action)
 {
     if (action)
         _action = action;
     if (! _action)
         return;
 
     if (_action->category() != cbCategory->currentText()) {
         _action->setCategory(cbCategory->currentText());
         // Update the category-list
         cbCategory->clear();
         cbCategory->addItems(krUserAction->allCategories());
         cbCategory->lineEdit()->setText(_action->category());
     }
 
     _action->setObjectName(leDistinctName->text());
     _action->setText(leTitle->text());
     _action->setToolTip(leTooltip->text());
     _action->setWhatsThis(textDescription->toPlainText());
     _action->setCommand(leCommandline->text());
     _action->setStartpath(leStartpath->text());
     _action->setShortcut(KeyButtonShortcut->keySequence());
 
     QStringList list;
 
     for (int i1 = 0; i1 != lbShowonlyProtocol->count(); i1++) {
         QListWidgetItem* lbi = lbShowonlyProtocol->item(i1);
 
         list << lbi->text();
     }
     _action->setShowonlyProtocol(list);
 
     list = QStringList();
     for (int i1 = 0; i1 != lbShowonlyPath->count(); i1++) {
         QListWidgetItem* lbi = lbShowonlyPath->item(i1);
 
         list << lbi->text();
     }
     _action->setShowonlyPath(list);
 
     list = QStringList();
     for (int i1 = 0; i1 != lbShowonlyMime->count(); i1++) {
         QListWidgetItem* lbi = lbShowonlyMime->item(i1);
 
         list << lbi->text();
     }
     _action->setShowonlyMime(list);
 
     list = QStringList();
     for (int i1 = 0; i1 != lbShowonlyFile->count(); i1++) {
         QListWidgetItem* lbi = lbShowonlyFile->item(i1);
 
         list << lbi->text();
     }
     _action->setShowonlyFile(list);
 
     if (radioCollectOutput->isChecked() && chkSeparateStdError->isChecked())
         _action->setExecType(KrAction::CollectOutputSeparateStderr);
     else if (radioCollectOutput->isChecked() && ! chkSeparateStdError->isChecked())
         _action->setExecType(KrAction::CollectOutput);
     else if (radioTerminal->isChecked())
         _action->setExecType(KrAction::Terminal);
     else if (radioTE->isChecked())
         _action->setExecType(KrAction::RunInTE);
     else
         _action->setExecType(KrAction::Normal);
 
     if (radioUrl->isChecked())
         _action->setAcceptURLs(true);
     else
         _action->setAcceptURLs(false);
 
     _action->setEnabled(chkEnabled->isChecked());
     _action->setVisible(chkEnabled->isChecked());
 
     _action->setConfirmExecution(chkConfirmExecution->isChecked());
 
     _action->setIcon(Icon(ButtonIcon->icon()));
     _action->setIconName(ButtonIcon->icon());
 
     _action->setUser(leDifferentUser->text());
 
     setModified(false);
 }
 
 void ActionProperty::addPlaceholder()
 {
     AddPlaceholderPopup popup(this);
     QString exp = popup.getPlaceholder(mapToGlobal(
                                            QPoint(
                                                ButtonAddPlaceholder->pos().x() + ButtonAddPlaceholder->width() + 6, // 6 is the default margin
                                                ButtonAddPlaceholder->pos().y()
                                            )
                                        ));
     leCommandline->insert(exp);
 }
 
 
 void ActionProperty::addStartpath()
 {
     QString folder = QFileDialog::getExistingDirectory(this);
     if (!folder.isEmpty()) {
         leStartpath->setText(folder);
     }
 }
 
 
 void ActionProperty::newProtocol()
 {
     bool ok;
 
     QString currentText;
     if (lbShowonlyProtocol->currentItem())
         currentText = lbShowonlyProtocol->currentItem()->text();
 
     QString text = QInputDialog::getText(this, i18n("New protocol"), i18n("Set a protocol:"),
                                          QLineEdit::Normal, currentText, &ok);
     if (ok && !text.isEmpty()) {
         lbShowonlyProtocol->addItems(text.split(';'));
         setModified();
     }
 }
 
 void ActionProperty::editProtocol()
 {
-    if (lbShowonlyProtocol->currentItem() == 0)
+    if (lbShowonlyProtocol->currentItem() == nullptr)
         return;
 
     bool ok;
 
     QString currentText = lbShowonlyProtocol->currentItem()->text();
 
     QString text = QInputDialog::getText(this, i18n("Edit Protocol"), i18n("Set another protocol:"),
                                          QLineEdit::Normal, currentText, &ok);
     if (ok && !text.isEmpty()) {
         lbShowonlyProtocol->currentItem()->setText(text);
         setModified();
     }
 }
 
 void ActionProperty::removeProtocol()
 {
-    if (lbShowonlyProtocol->currentItem() != 0) {
+    if (lbShowonlyProtocol->currentItem() != nullptr) {
         delete lbShowonlyProtocol->currentItem();
         setModified();
     }
 }
 
 void ActionProperty::addPath()
 {
     QString folder = QFileDialog::getExistingDirectory(this);
     if (!folder.isEmpty()) {
         lbShowonlyPath->addItem(folder);
         setModified();
     }
 }
 
 void ActionProperty::editPath()
 {
-    if (lbShowonlyPath->currentItem() == 0)
+    if (lbShowonlyPath->currentItem() == nullptr)
         return;
 
     bool ok;
 
     QString currentText = lbShowonlyPath->currentItem()->text();
 
     QString text = QInputDialog::getText(this, i18n("Edit Path"), i18n("Set another path:"),
                                          QLineEdit::Normal, currentText, &ok);
     if (ok && !text.isEmpty()) {
         lbShowonlyPath->currentItem()->setText(text);
         setModified();
     }
 }
 
 void ActionProperty::removePath()
 {
-    if (lbShowonlyPath->currentItem() != 0) {
+    if (lbShowonlyPath->currentItem() != nullptr) {
         delete lbShowonlyPath->currentItem();
         setModified();
     }
 }
 
 void ActionProperty::addMime()
 {
     bool ok;
 
     QString currentText;
     if (lbShowonlyMime->currentItem())
         currentText = lbShowonlyMime->currentItem()->text();
 
     QString text = QInputDialog::getText(this, i18n("New MIME Type"), i18n("Set a MIME type:"),
                                          QLineEdit::Normal, currentText, &ok);
     if (ok && !text.isEmpty()) {
         lbShowonlyMime->addItems(text.split(';'));
         setModified();
     }
 }
 
 void ActionProperty::editMime()
 {
-    if (lbShowonlyMime->currentItem() == 0)
+    if (lbShowonlyMime->currentItem() == nullptr)
         return;
 
     bool ok;
 
     QString currentText = lbShowonlyMime->currentItem()->text();
 
     QString text = QInputDialog::getText(this, i18n("Edit MIME Type"), i18n("Set another MIME type:"),
                                          QLineEdit::Normal, currentText, &ok);
     if (ok && !text.isEmpty()) {
         lbShowonlyMime->currentItem()->setText(text);
         setModified();
     }
 }
 
 void ActionProperty::removeMime()
 {
-    if (lbShowonlyMime->currentItem() != 0) {
+    if (lbShowonlyMime->currentItem() != nullptr) {
         delete lbShowonlyMime->currentItem();
         setModified();
     }
 }
 
 void ActionProperty::newFile()
 {
     bool ok;
 
     QString currentText;
     if (lbShowonlyFile->currentItem())
         currentText = lbShowonlyFile->currentItem()->text();
 
     QString text = QInputDialog::getText(this, i18n("New File Name"), i18n("Set a file name:"),
                                          QLineEdit::Normal, currentText, &ok);
     if (ok && !text.isEmpty()) {
         lbShowonlyFile->addItems(text.split(';'));
         setModified();
     }
 }
 
 void ActionProperty::editFile()
 {
-    if (lbShowonlyFile->currentItem() == 0)
+    if (lbShowonlyFile->currentItem() == nullptr)
         return;
 
     bool ok;
 
     QString currentText = lbShowonlyFile->currentItem()->text();
 
     QString text = QInputDialog::getText(this, i18n("Edit File Name"), i18n("Set another file name:"),
                                          QLineEdit::Normal, currentText, &ok);
     if (ok && !text.isEmpty()) {
         lbShowonlyFile->currentItem()->setText(text);
         setModified();
     }
 }
 
 void ActionProperty::removeFile()
 {
-    if (lbShowonlyFile->currentItem() != 0) {
+    if (lbShowonlyFile->currentItem() != nullptr) {
         delete lbShowonlyFile->currentItem();
         setModified();
     }
 }
 
 
 bool ActionProperty::validProperties()
 {
     if (leDistinctName->text().simplified().isEmpty()) {
         KMessageBox::error(this, i18n("Please set a unique name for the useraction"));
         leDistinctName->setFocus();
         return false;
     }
     if (leTitle->text().simplified().isEmpty()) {
         KMessageBox::error(this, i18n("Please set a title for the menu entry"));
         leTitle->setFocus();
         return false;
     }
     if (leCommandline->text().simplified().isEmpty()) {
         KMessageBox::error(this, i18n("Command line is empty"));
         leCommandline->setFocus();
         return false;
     }
     if (leDistinctName->isEnabled())
         if (krApp->actionCollection()->action(leDistinctName->text())) {
             KMessageBox::error(this,
                                i18n("There already is an action with this name.\n"
                                     "If you do not have such a useraction the name is used by Krusader for an internal action.")
                               );
             leDistinctName->setFocus();
             return false;
         }
 
     return true;
 }
 
 void ActionProperty::setModified(bool m)
 {
     if (m && !_modified) {   // emit only when the state _changes_to_true_,
         emit changed();
     }
     _modified = m;
 }
 
diff --git a/krusader/ActionMan/actionproperty.h b/krusader/ActionMan/actionproperty.h
index 08caf115..612ead87 100644
--- a/krusader/ActionMan/actionproperty.h
+++ b/krusader/ActionMan/actionproperty.h
@@ -1,157 +1,157 @@
 /*****************************************************************************
  * Copyright (C) 2004-2007 Jonas Bähr <jonas.baehr@web.de>                   *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef ACTIONPROPERTY_H
 #define ACTIONPROPERTY_H
 
 #include "ui_actionproperty.h"
 
 class KrAction;
 
 /**
  * Use this widget where ever you need to manipulate a UserAction
  */
 class ActionProperty : public QWidget, public Ui::ActionProperty
 {
     Q_OBJECT
 public:
-    explicit ActionProperty(QWidget *parent = 0, KrAction *action = 0);
-    ~ActionProperty();
+    explicit ActionProperty(QWidget *parent = nullptr, KrAction *action = nullptr);
+    ~ActionProperty() override;
 
     /**
      * @return the currently displayed action
      */
     KrAction* action() {
         return _action;
     };
 
     /**
      * This inits the widget with the actions properties.
      * If no action is provided, the last used will be taken!
      * It also resets the changed() state.
      * @param action the action which should be displayd
      */
-    void updateGUI(KrAction *action = 0);
+    void updateGUI(KrAction *action = nullptr);
 
     /**
      * This writes the displayed properties back into the action.
      * If no action is provided, the last used will be taken!
      * It also resets the changed() state.
      * @param action the action which should be manipulated
      */
-    void updateAction(KrAction *action = 0);
+    void updateAction(KrAction *action = nullptr);
 
     /**
      * clears everything
      */
     void clear();
 
     /**
      * @return true if all properties got valid values
      */
     bool validProperties();
 
     /**
      * @return true if any property got changed
      */
     bool isModified() {
         return _modified;
     };
 
 signals:
     /**
      * emitted when any actionproperty changed. This signal is only emitted when
      * the _modified attribute changes to true. If there are changes made and
      * _modified is already true, no signal is emitted!
      */
     void changed();
 
 protected slots:
     void setModified(bool m = true);
     /**
      * executes the AddPlaceholderPopup
      */
     void addPlaceholder();
     /**
      * asks for an existing path
      */
     void addStartpath();
     /**
      * (availability) asks for a new protocol
      */
     void newProtocol();
     /**
      * (availability) changes a protocol of the list
      */
     void editProtocol();
     /**
      * (availability) removes a protocol from the list
      */
     void removeProtocol();
     /**
      * (availability) asks for a new path
      */
     void addPath();
     /**
      * (availability) edits a path of the list
      */
     void editPath();
     /**
      * (availability) removes a path from the list
      */
     void removePath();
     /**
      * (availability) asks for a new mime-type
      */
     void addMime();
     /**
      * (availability) changes a mime-type of the list
      */
     void editMime();
     /**
      * (availability) removes a mime-type from the list
      */
     void removeMime();
     /**
      * (availability) asks for a new file-filter
      */
     void newFile();
     /**
      * (availability) edits a file-filter of the list
      */
     void editFile();
     /**
      * (availability) removes a file-filter from the lsit
      */
     void removeFile();
 
 private:
     KrAction *_action;
     bool _modified;
 
 private slots:
     /**
      * This updates the ShortcutButton
      * @internal
      */
     void changedShortcut(const QKeySequence& shortcut);
 };
 
 #endif
diff --git a/krusader/ActionMan/addplaceholderpopup.cpp b/krusader/ActionMan/addplaceholderpopup.cpp
index 845ceb9f..406b5c51 100644
--- a/krusader/ActionMan/addplaceholderpopup.cpp
+++ b/krusader/ActionMan/addplaceholderpopup.cpp
@@ -1,703 +1,703 @@
 /*****************************************************************************
  * Copyright (C) 2004 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2004 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "addplaceholderpopup.h"
 
 // for ParameterDialog
 #include "../krglobal.h" // for konfig-access
 #include "../icon.h"
 #include "../BookMan/krbookmarkbutton.h"
 #include "../GUI/profilemanager.h"
 
 // QtWidgets
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QFileDialog>
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QSpinBox>
 #include <QToolButton>
 #include <QVBoxLayout>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KCompletion/KLineEdit>
 #include <KCompletion/KComboBox>
 #include <KIOWidgets/KUrlCompletion>
 
 #define ACTIVE_MASK  0x0100
 #define OTHER_MASK  0x0200
 #define LEFT_MASK   0x0400
 #define RIGHT_MASK   0x0800
 #define INDEPENDENT_MASK 0x1000
 #define EXECUTABLE_ID  0xFFFF
 
 AddPlaceholderPopup::AddPlaceholderPopup(QWidget *parent) : QMenu(parent)
 {
 
     _activeSub = new QMenu(i18n("Active panel"), this);
     _otherSub = new QMenu(i18n("Other panel"), this);
     _leftSub = new QMenu(i18n("Left panel"), this);
     _rightSub = new QMenu(i18n("Right panel"), this);
     _independentSub = new QMenu(i18n("Panel independent"), this);
 
     addMenu(_activeSub);
     addMenu(_otherSub);
     addMenu(_leftSub);
     addMenu(_rightSub);
     addMenu(_independentSub);
 
     QAction *chooseExecAct = _independentSub->addAction(i18n("Choose executable..."));
     chooseExecAct->setData(QVariant(EXECUTABLE_ID));
 
     _independentSub->addSeparator();
 
     // read the expressions array from the user menu and populate menus
     Expander expander;
     for (int i = 0; i < expander.placeholderCount(); ++i) {
         if (expander.placeholder(i)->expression().isEmpty()) {
             if (expander.placeholder(i)->needPanel()) {
                 _activeSub->addSeparator();
                 _otherSub->addSeparator();
                 _leftSub->addSeparator();
                 _rightSub->addSeparator();
             } else
                 _independentSub->addSeparator();
         } else {
             QAction * action;
 
             if (expander.placeholder(i)->needPanel()) {
                 action = _activeSub->addAction(i18n(expander.placeholder(i)->description().toUtf8()));
                 action->setData(QVariant(i | ACTIVE_MASK));
                 action = _otherSub->addAction(i18n(expander.placeholder(i)->description().toUtf8()));
                 action->setData(QVariant(i | OTHER_MASK));
                 action = _leftSub->addAction(i18n(expander.placeholder(i)->description().toUtf8()));
                 action->setData(QVariant(i | LEFT_MASK));
                 action = _rightSub->addAction(i18n(expander.placeholder(i)->description().toUtf8()));
                 action->setData(QVariant(i | RIGHT_MASK));
             } else {
                 action = _independentSub->addAction(i18n(expander.placeholder(i)->description().toUtf8()));
                 action->setData(QVariant(i | INDEPENDENT_MASK));
             }
         }
     }
 
 }
 
 
 QString AddPlaceholderPopup::getPlaceholder(const QPoint& pos)
 {
     QAction *res = exec(pos);
-    if (res == 0)
+    if (res == nullptr)
         return QString();
 
     // add the selected flag to the command line
     if (res->data().toInt() == EXECUTABLE_ID) {   // did the user need an executable ?
         // select an executable
         QString filename = QFileDialog::getOpenFileName(this);
         if (!filename.isEmpty()) {
             return filename + ' '; // with extra space
             // return filename; // without extra space
         }
     } else { // user selected something from the menus
         Expander expander;
         const exp_placeholder* currentPlaceholder = expander.placeholder(res->data().toInt() & ~(ACTIVE_MASK | OTHER_MASK | LEFT_MASK | RIGHT_MASK | INDEPENDENT_MASK));
 //       if ( &currentPlaceholder->expFunc == 0 ) {
 //          KMessageBox::sorry( this, "BOFH Excuse #93:\nFeature not yet implemented" );
 //          return QString();
 //       }
-        ParameterDialog* parameterDialog = new ParameterDialog(currentPlaceholder, this);
+        auto* parameterDialog = new ParameterDialog(currentPlaceholder, this);
         QString panel, parameter = parameterDialog->getParameter();
         delete parameterDialog;
         // indicate the panel with 'a' 'o', 'l', 'r' or '_'.
         if (res->data().toInt() & ACTIVE_MASK)
             panel = 'a';
         else if (res->data().toInt() & OTHER_MASK)
             panel = 'o';
         else if (res->data().toInt() & LEFT_MASK)
             panel = 'l';
         else if (res->data().toInt() & RIGHT_MASK)
             panel = 'r';
         else if (res->data().toInt() & INDEPENDENT_MASK)
             panel = '_';
         //return '%' + panel + currentPlaceholder->expression() + parameter + "% "; // with extra space
         return '%' + panel + currentPlaceholder->expression() + parameter + '%'; // without extra space
     }
     return QString();
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////// ParameterDialog ////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////
 
 ParameterDialog::ParameterDialog(const exp_placeholder* currentPlaceholder, QWidget *parent) : QDialog(parent)
 {
     setWindowTitle(i18n("User Action Parameter Dialog"));
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     _parameter.clear();
     _parameterCount = currentPlaceholder->parameterCount();
 
     QWidget *page = new QWidget(this);
     mainLayout->addWidget(page);
-    QVBoxLayout* layout = new QVBoxLayout(page);
+    auto* layout = new QVBoxLayout(page);
     layout->setSpacing(11);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n("This placeholder allows some parameter:"), page));
 
     for (int i = 0; i < _parameterCount; ++i) {
         if (currentPlaceholder->parameter(i).preset() == "__placeholder")
             _parameter.append(new ParameterPlaceholder(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset() == "__yes")
             _parameter.append(new ParameterYes(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset() == "__no")
             _parameter.append(new ParameterNo(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset() == "__file")
             _parameter.append(new ParameterFile(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset().indexOf("__choose") != -1)
             _parameter.append(new ParameterChoose(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset() == "__select")
             _parameter.append(new ParameterSelect(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset() == "__goto")
             _parameter.append(new ParameterGoto(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset() == "__syncprofile")
             _parameter.append(new ParameterSyncprofile(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset() == "__searchprofile")
             _parameter.append(new ParameterSearch(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset() == "__panelprofile")
             _parameter.append(new ParameterPanelprofile(currentPlaceholder->parameter(i), page));
         else if (currentPlaceholder->parameter(i).preset().indexOf("__int") != -1)
             _parameter.append(new ParameterInt(currentPlaceholder->parameter(i), page));
         else
             _parameter.append(new ParameterText(currentPlaceholder->parameter(i), page));
 
         layout->addWidget(_parameter.last());
     }
 
     QFrame * line = new QFrame(page);
     line->setFrameShape(QFrame::HLine);
     line->setFrameShadow(QFrame::Sunken);
     layout->addWidget(line);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::RestoreDefaults);
     mainLayout->addWidget(buttonBox);
 
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(okButton, &QPushButton:: clicked, this, &ParameterDialog::slotOk);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &ParameterDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &ParameterDialog::reject);
     connect(buttonBox->button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked, this, &ParameterDialog::reset);
 }
 
 QString ParameterDialog::getParameter()
 {
     if (_parameterCount == 0)   // meaning no parameters
         return QString();
 
     if (exec() == -1)
         return QString();
 
     int lastParameter = _parameterCount;
     while (--lastParameter > -1) {
         if (_parameter[ lastParameter ]->text() != _parameter[ lastParameter ]->preset()  ||  _parameter[ lastParameter ]->necessary())
             break;
     }
 
     if (lastParameter < 0)  // all parameters have default-values
         return QString();
 
     QString parameter;
     for (int i = 0; i <= lastParameter; ++i) {
         if (i > 0)
             parameter += ", ";
         parameter += '\"' + _parameter[ i ]->text().replace('\"', "\\\"") + '\"';
     }
     return '(' + parameter + ')';
 }
 
 void ParameterDialog::reset()
 {
     for (int i = 0; i < _parameterCount; ++i)
         _parameter[ i ]->reset();
 }
 
 void ParameterDialog::slotOk()
 {
     bool valid = true;
     for (int i = 0; i < _parameterCount; ++i) {
         if (_parameter[ i ]->necessary() && ! _parameter[ i ]->valid())
             valid = false;
     }
 
     if (valid)
         accept();
 }
 
 ///////////// ParameterText
 ParameterText::ParameterText(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
     layout->addWidget(_lineEdit = new KLineEdit(parameter.preset(), this));
     _preset = parameter.preset();
 }
 
 QString ParameterText::text()
 {
     return _lineEdit->text();
 }
 QString ParameterText::preset()
 {
     return _preset;
 }
 void ParameterText::reset()
 {
     _lineEdit->setText(_preset);
 }
 bool ParameterText::valid()
 {
     if (_lineEdit->text().isEmpty())
         return false;
     else
         return true;
 }
 
 ///////////// ParameterPlaceholder
 ParameterPlaceholder::ParameterPlaceholder(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
     QWidget * hboxWidget = new QWidget(this);
     layout->addWidget(hboxWidget);
-    QHBoxLayout * hbox = new QHBoxLayout(hboxWidget);
+    auto * hbox = new QHBoxLayout(hboxWidget);
 
     hbox->setContentsMargins(0, 0, 0, 0);
     hbox->setSpacing(6);
     _lineEdit = new KLineEdit(hboxWidget);
     hbox->addWidget(_lineEdit);
     _button = new QToolButton(hboxWidget);
     _button->setIcon(Icon("list-add"));
     hbox->addWidget(_button);
     connect(_button, &QToolButton::clicked, this, &ParameterPlaceholder::addPlaceholder);
 }
 
 QString ParameterPlaceholder::text()
 {
     return _lineEdit->text();
 }
 QString ParameterPlaceholder::preset()
 {
     return QString();
 }
 void ParameterPlaceholder::reset()
 {
     _lineEdit->setText(QString());
 }
 bool ParameterPlaceholder::valid()
 {
     if (_lineEdit->text().isEmpty())
         return false;
     else
         return true;
 }
 void ParameterPlaceholder::addPlaceholder()
 {
-    AddPlaceholderPopup* popup = new AddPlaceholderPopup(this);
+    auto* popup = new AddPlaceholderPopup(this);
     QString exp = popup->getPlaceholder(mapToGlobal(QPoint(_button->pos().x() + _button->width() + 6, _button->pos().y() + _button->height() / 2)));
     _lineEdit->insert(exp);
     delete popup;
 }
 
 ///////////// ParameterYes
 ParameterYes::ParameterYes(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(_checkBox = new QCheckBox(i18n(parameter.description().toUtf8()), this));
     _checkBox->setChecked(true);
 }
 
 QString ParameterYes::text()
 {
     if (_checkBox->isChecked())
         return QString();
     else
         return "No";
 }
 QString ParameterYes::preset()
 {
     return QString();
 }
 void ParameterYes::reset()
 {
     _checkBox->setChecked(true);
 }
 bool ParameterYes::valid()
 {
     return true;
 }
 
 ///////////// ParameterNo
 ParameterNo::ParameterNo(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(_checkBox = new QCheckBox(i18n(parameter.description().toUtf8()), this));
     _checkBox->setChecked(false);
 }
 
 QString ParameterNo::text()
 {
     if (_checkBox->isChecked())
         return "Yes";
     else
         return QString();
 }
 QString ParameterNo::preset()
 {
     return QString();
 }
 void ParameterNo::reset()
 {
     _checkBox->setChecked(false);
 }
 bool ParameterNo::valid()
 {
     return true;
 }
 
 ///////////// ParameterFile
 ParameterFile::ParameterFile(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
 
     QWidget * hboxWidget = new QWidget(this);
     layout->addWidget(hboxWidget);
-    QHBoxLayout * hbox = new QHBoxLayout(hboxWidget);
+    auto * hbox = new QHBoxLayout(hboxWidget);
 
     hbox->setContentsMargins(0, 0, 0, 0);
     hbox->setSpacing(6);
     _lineEdit = new KLineEdit(hboxWidget);
     hbox->addWidget(_lineEdit);
     _button = new QToolButton(hboxWidget);
     hbox->addWidget(_button);
     _button->setIcon(Icon("document-open"));
     connect(_button, &QToolButton::clicked, this, &ParameterFile::addFile);
 }
 
 QString ParameterFile::text()
 {
     return _lineEdit->text();
 }
 QString ParameterFile::preset()
 {
     return QString();
 }
 void ParameterFile::reset()
 {
     _lineEdit->setText(QString());
 }
 bool ParameterFile::valid()
 {
     if (_lineEdit->text().isEmpty())
         return false;
     else
         return true;
 }
 void ParameterFile::addFile()
 {
     QString filename = QFileDialog::getOpenFileName(this);
     _lineEdit->insert(filename);
 }
 
 ///////////// ParameterChoose
 ParameterChoose::ParameterChoose(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
     layout->addWidget(_combobox = new KComboBox(this));
     _combobox->addItems(parameter.preset().section(':', 1).split(';'));
 }
 
 QString ParameterChoose::text()
 {
     return _combobox->currentText();
 }
 QString ParameterChoose::preset()
 {
     return _combobox->itemText(0);
 }
 void ParameterChoose::reset()
 {
     _combobox->setCurrentIndex(0);
 }
 bool ParameterChoose::valid()
 {
     return true;
 }
 
 ///////////// ParameterSelect
 ParameterSelect::ParameterSelect(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
     layout->addWidget(_combobox = new KComboBox(this));
     _combobox->setEditable(true);
 
     KConfigGroup group(krConfig, "Private");
     QStringList lst = group.readEntry("Predefined Selections", QStringList());
     if (lst.size() > 0)
         _combobox->addItems(lst);
 
     _combobox->lineEdit()->setText("*");
 }
 
 QString ParameterSelect::text()
 {
     return _combobox->currentText();
 }
 QString ParameterSelect::preset()
 {
     return "*";
 }
 void ParameterSelect::reset()
 {
     _combobox->lineEdit()->setText("*");
 }
 bool ParameterSelect::valid()
 {
     return true;
 }
 
 ///////////// ParameterGoto
 ParameterGoto::ParameterGoto(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
 
     QWidget * hboxWidget = new QWidget(this);
-    QHBoxLayout * hbox = new QHBoxLayout(hboxWidget);
+    auto * hbox = new QHBoxLayout(hboxWidget);
 
     hbox->setContentsMargins(0, 0, 0, 0);
     hbox->setSpacing(6);
     _lineEdit = new KLineEdit(hboxWidget);
     _lineEdit->setCompletionObject(new KUrlCompletion(KUrlCompletion::DirCompletion));
     hbox->addWidget(_lineEdit);
     _dirButton = new QToolButton(hboxWidget);
     hbox->addWidget(_dirButton);
     _dirButton->setIcon(Icon("document-open"));
     connect(_dirButton, &QToolButton::clicked, this, &ParameterGoto::setDir);
     _placeholderButton = new QToolButton(hboxWidget);
     _placeholderButton->setIcon(Icon("list-add"));
     hbox->addWidget(_placeholderButton);
     connect(_placeholderButton, &QToolButton::clicked, this, &ParameterGoto::addPlaceholder);
 
     layout->addWidget(hboxWidget);
 }
 
 QString ParameterGoto::text()
 {
     return _lineEdit->text();
 }
 QString ParameterGoto::preset()
 {
     return QString();
 }
 void ParameterGoto::reset()
 {
     _lineEdit->setText(QString());
 }
 bool ParameterGoto::valid()
 {
     if (_lineEdit->text().isEmpty())
         return false;
     else
         return true;
 }
 void ParameterGoto::setDir()
 {
     QString folder = QFileDialog::getExistingDirectory(this);
     _lineEdit->setText(folder);
 }
 void ParameterGoto::addPlaceholder()
 {
-    AddPlaceholderPopup* popup = new AddPlaceholderPopup(this);
+    auto* popup = new AddPlaceholderPopup(this);
     QString exp = popup->getPlaceholder(mapToGlobal(QPoint(_placeholderButton->pos().x() + _placeholderButton->width() + 6, _placeholderButton->pos().y() + _placeholderButton->height() / 2)));
     _lineEdit->insert(exp);
     delete popup;
 }
 
 ///////////// ParameterSyncprofile
 ParameterSyncprofile::ParameterSyncprofile(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
     layout->addWidget(_combobox = new KComboBox(this));
 
     _combobox->addItems(ProfileManager::availableProfiles("SynchronizerProfile"));
 }
 
 QString ParameterSyncprofile::text()
 {
     return _combobox->currentText();
 }
 QString ParameterSyncprofile::preset()
 {
     return _combobox->itemText(0);
 }
 void ParameterSyncprofile::reset()
 {
     _combobox->setCurrentIndex(0);
 }
 bool ParameterSyncprofile::valid()
 {
     return true;
 }
 
 ///////////// ParameterSearch
 ParameterSearch::ParameterSearch(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
     layout->addWidget(_combobox = new KComboBox(this));
 
     _combobox->addItems(ProfileManager::availableProfiles("SearcherProfile"));
 }
 
 QString ParameterSearch::text()
 {
     return _combobox->currentText();
 }
 QString ParameterSearch::preset()
 {
     return _combobox->itemText(0);
 }
 void ParameterSearch::reset()
 {
     _combobox->setCurrentIndex(0);
 }
 bool ParameterSearch::valid()
 {
     return true;
 }
 
 ///////////// ParameterPanelprofile
 ParameterPanelprofile::ParameterPanelprofile(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
     layout->addWidget(_combobox = new KComboBox(this));
 
     _combobox->addItems(ProfileManager::availableProfiles("Panel"));
 }
 
 QString ParameterPanelprofile::text()
 {
     return _combobox->currentText();
 }
 QString ParameterPanelprofile::preset()
 {
     return _combobox->itemText(0);
 }
 void ParameterPanelprofile::reset()
 {
     _combobox->setCurrentIndex(0);
 }
 bool ParameterPanelprofile::valid()
 {
     return true;
 }
 
 ///////////// ParameterInt
 ParameterInt::ParameterInt(const exp_parameter& parameter, QWidget* parent) : ParameterBase(parameter, parent)
 {
-    QHBoxLayout* layout = new QHBoxLayout(this);
+    auto* layout = new QHBoxLayout(this);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     layout->addWidget(new QLabel(i18n(parameter.description().toUtf8()), this));
     layout->addWidget(_spinbox = new QSpinBox(this));
     QStringList para = parameter.preset().section(':', 1).split(';');
 
     _spinbox->setMinimum(para[0].toInt());
     _spinbox->setMaximum(para[1].toInt());
     _spinbox->setSingleStep(para[2].toInt());
     _spinbox->setValue(para[3].toInt());
 
     _default = _spinbox->value();
 }
 
 QString ParameterInt::text()
 {
     return _spinbox->text();
 }
 QString ParameterInt::preset()
 {
     return QString("%1").arg(_default);
 }
 void ParameterInt::reset()
 {
     return _spinbox->setValue(_default);
 }
 bool ParameterInt::valid()
 {
     return true;
 }
 
diff --git a/krusader/ActionMan/useractionlistview.cpp b/krusader/ActionMan/useractionlistview.cpp
index e58634b5..3e3a3216 100644
--- a/krusader/ActionMan/useractionlistview.cpp
+++ b/krusader/ActionMan/useractionlistview.cpp
@@ -1,255 +1,251 @@
 /*****************************************************************************
  * Copyright (C) 2006 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "useractionlistview.h"
 
 // QtCore
 #include <QDebug>
 // QtXml
 #include <QDomEntity>
 
 #include <KI18n/KLocalizedString>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../UserAction/kraction.h"
 #include "../UserAction/useraction.h"
 
 #define COL_TITLE 0
 
 // UserActionListView
 
 UserActionListView::UserActionListView(QWidget * parent)
         : KrTreeWidget(parent)
 {
     setHeaderLabel(i18n("Title"));
 
     setRootIsDecorated(true);
     setSelectionMode(QAbstractItemView::ExtendedSelection);   // normally select single items but one may use Ctrl or Shift to select multiple
 
     setSortingEnabled(true);
     sortItems(COL_TITLE, Qt::AscendingOrder);
 
     connect(this, &UserActionListView::currentItemChanged, this, &UserActionListView::slotCurrentItemChanged);
 
     update();
 }
 
 UserActionListView::~UserActionListView()
-{
-}
+= default;
 
 QSize UserActionListView::sizeHint() const
 {
     return QSize(200, 400);
 }
 
 void UserActionListView::update()
 {
     clear();
     UserAction::KrActionList list = krUserAction->actionList();
 
     QListIterator<KrAction *> it(list);
     while (it.hasNext())
         insertAction(it.next());
 }
 
 void UserActionListView::update(KrAction* action)
 {
     UserActionListViewItem* item = findActionItem(action);
     if (item) {
         // deleting & re-inserting is _much_easier then tracking all possible cases of category changes!
         bool current = (item == currentItem());
         bool selected = item->isSelected();
         delete item;
         item = insertAction(action);
         if (current)
             setCurrentItem(item);
         if (selected)
             item->setSelected(true);
     }
 }
 
 UserActionListViewItem* UserActionListView::insertAction(KrAction* action)
 {
     if (! action)
-        return 0;
+        return nullptr;
 
     UserActionListViewItem* item;
 
     if (action->category().isEmpty())
         item = new UserActionListViewItem(this, action);
     else {
         QTreeWidgetItem* categoryItem = findCategoryItem(action->category());
         if (! categoryItem) {
             categoryItem = new QTreeWidgetItem(this);   // create the new category item it not already present
             categoryItem->setText(0, action->category());
             categoryItem->setFlags(Qt::ItemIsEnabled);
         }
         item = new UserActionListViewItem(categoryItem, action);
     }
 
     item->setAction(action);
     return item;
 }
 
 QTreeWidgetItem* UserActionListView::findCategoryItem(const QString& category)
 {
     QTreeWidgetItemIterator it(this);
     while (*it) {
         if ((*it)->text(COL_TITLE) == category && !((*it)->flags() & Qt::ItemIsSelectable))
             return *it;
         it++;
     }
-    return 0;
+    return nullptr;
 }
 
 UserActionListViewItem* UserActionListView::findActionItem(const KrAction* action)
 {
     QTreeWidgetItemIterator it(this);
     while (*it) {
-        if (UserActionListViewItem* item = dynamic_cast<UserActionListViewItem*>(*it)) {
+        if (auto* item = dynamic_cast<UserActionListViewItem*>(*it)) {
             if (item->action() == action)
                 return item;
         }
         it++;
     }
-    return 0;
+    return nullptr;
 }
 
 KrAction * UserActionListView::currentAction() const
 {
-    if (UserActionListViewItem* item = dynamic_cast<UserActionListViewItem*>(currentItem()))
+    if (auto* item = dynamic_cast<UserActionListViewItem*>(currentItem()))
         return item->action();
     else
-        return 0;
+        return nullptr;
 }
 
 void UserActionListView::setCurrentAction(const KrAction* action)
 {
     UserActionListViewItem* item = findActionItem(action);
     if (item) {
         setCurrentItem(item);
     }
 }
 
 void UserActionListView::setFirstActionCurrent()
 {
     QTreeWidgetItemIterator it(this);
     while (*it) {
-        if (UserActionListViewItem* item = dynamic_cast<UserActionListViewItem*>(*it)) {
+        if (auto* item = dynamic_cast<UserActionListViewItem*>(*it)) {
             setCurrentItem(item);
             break;
         }
         it++;
     }
 }
 
 void UserActionListView::slotCurrentItemChanged(QTreeWidgetItem* item)
 {
     if (! item)
         return;
     scrollTo(indexOf(item));
 }
 
 QDomDocument UserActionListView::dumpSelectedActions(QDomDocument* mergeDoc) const
 {
     QList<QTreeWidgetItem*> list = selectedItems();
     QDomDocument doc;
     if (mergeDoc)
         doc = *mergeDoc;
     else
         doc = UserAction::createEmptyDoc();
     QDomElement root = doc.documentElement();
 
-    for (int i = 0; i < list.size(); ++i) {
-        QTreeWidgetItem* item = list.at(i);
-        if (UserActionListViewItem* actionItem = dynamic_cast<UserActionListViewItem*>(item))
+    for (auto item : list) {
+        if (auto* actionItem = dynamic_cast<UserActionListViewItem*>(item))
             root.appendChild(actionItem->action()->xmlDump(doc));
     }
 
     return doc;
 }
 
 void UserActionListView::removeSelectedActions()
 {
     QList<QTreeWidgetItem*> list = selectedItems();
 
-    for (int i = 0; i < list.size(); ++i) {
-        QTreeWidgetItem* item = list.at(i);
-        if (UserActionListViewItem* actionItem = dynamic_cast<UserActionListViewItem*>(item)) {
+    for (auto item : list) {
+        if (auto* actionItem = dynamic_cast<UserActionListViewItem*>(item)) {
             delete actionItem->action(); // remove the action itself
             delete actionItem; // remove the action from the list
         } // if
     }
 }
 
 // UserActionListViewItem
 
 UserActionListViewItem::UserActionListViewItem(QTreeWidget* view, KrAction* action)
         : QTreeWidgetItem(view)
 {
     setAction(action);
 }
 
 UserActionListViewItem::UserActionListViewItem(QTreeWidgetItem* item, KrAction * action)
         : QTreeWidgetItem(item)
 {
     setAction(action);
 }
 
 UserActionListViewItem::~UserActionListViewItem()
-{
-}
+= default;
 
 void UserActionListViewItem::setAction(KrAction * action)
 {
     if (! action)
         return;
 
     _action = action;
     update();
 }
 
 KrAction * UserActionListViewItem::action() const
 {
     return _action;
 }
 
 void UserActionListViewItem::update()
 {
     if (! _action)
         return;
 
     if (! _action->icon().isNull())
         setIcon(COL_TITLE, Icon(_action->iconName()));
     setText(COL_TITLE, _action->text());
 }
 
 bool UserActionListViewItem::operator<(const QTreeWidgetItem &other) const
 {
 // FIXME some how this only produces bullshit :-/
 //   if ( i->text( COL_NAME ).isEmpty() ) { // categories only have titles
 //      //qDebug() << "this->title: " << text(COL_TITLE) << " |=|   i->title: " << i->text(COL_TITLE);
 //       return ( ascending ? -1 : 1 ); // <0 means this is smaller then i
 //    }
 //    else
     return QTreeWidgetItem::operator<(other);
 }
diff --git a/krusader/ActionMan/useractionlistview.h b/krusader/ActionMan/useractionlistview.h
index b66461a5..1f79339f 100644
--- a/krusader/ActionMan/useractionlistview.h
+++ b/krusader/ActionMan/useractionlistview.h
@@ -1,87 +1,87 @@
 /*****************************************************************************
  * Copyright (C) 2006 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef USERACTIONLISTVIEW_H
 #define USERACTIONLISTVIEW_H
 
 #include "../GUI/krtreewidget.h"
 
 class KrAction;
 class QString;
 class UserActionListViewItem;
 class QDomDocument;
 
 class UserActionListView : public KrTreeWidget
 {
     Q_OBJECT
 
 public:
-    explicit UserActionListView(QWidget* parent = 0);
-    ~UserActionListView();
-    virtual QSize sizeHint() const Q_DECL_OVERRIDE;
+    explicit UserActionListView(QWidget* parent = nullptr);
+    ~UserActionListView() override;
+    QSize sizeHint() const Q_DECL_OVERRIDE;
 
     void update();
     void update(KrAction* action);
     UserActionListViewItem* insertAction(KrAction* action);
 
     KrAction* currentAction() const;
     void setCurrentAction(const KrAction*);
 
-    QDomDocument dumpSelectedActions(QDomDocument* mergeDoc = 0) const;
+    QDomDocument dumpSelectedActions(QDomDocument* mergeDoc = nullptr) const;
 
     void removeSelectedActions();
 
     /**
      * makes the first action in the list current
      */
     void setFirstActionCurrent();
 
     /**
      * makes @e item current and ensures its visibility
      */
 protected slots:
     void slotCurrentItemChanged(QTreeWidgetItem*);
 
 protected:
     QTreeWidgetItem* findCategoryItem(const QString& category);
     UserActionListViewItem* findActionItem(const KrAction* action);
 };
 
 class UserActionListViewItem : public QTreeWidgetItem
 {
 public:
     UserActionListViewItem(QTreeWidget* view, KrAction* action);
     UserActionListViewItem(QTreeWidgetItem* item, KrAction* action);
-    ~UserActionListViewItem();
+    ~UserActionListViewItem() override;
 
     void setAction(KrAction* action);
     KrAction* action() const;
     void update();
 
     /**
      * This reimplements qt's compare-function in order to have categories on the top of the list
      */
-    virtual bool operator<(const QTreeWidgetItem &other) const Q_DECL_OVERRIDE;
+    bool operator<(const QTreeWidgetItem &other) const Q_DECL_OVERRIDE;
 
 private:
     KrAction* _action;
 };
 
 #endif
diff --git a/krusader/ActionMan/useractionpage.cpp b/krusader/ActionMan/useractionpage.cpp
index aecb2410..e0c9000e 100644
--- a/krusader/ActionMan/useractionpage.cpp
+++ b/krusader/ActionMan/useractionpage.cpp
@@ -1,356 +1,355 @@
 /*****************************************************************************
  * Copyright (C) 2006 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2006 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "useractionpage.h"
 
 // QtWidgets
 #include <QFileDialog>
 #include <QSplitter>
 #include <QLayout>
 #include <QToolButton>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 // QtGui
 #include <QClipboard>
 // QtXml
 #include <QDomDocumentType>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KStandardGuiItem>
 #include <KCompletion/KLineEdit>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "actionproperty.h"
 #include "useractionlistview.h"
 #include "../UserAction/useraction.h"
 #include "../UserAction/kraction.h"
 #include "../krusader.h"
 #include "../krglobal.h"
 #include "../icon.h"
 
 
 //This is the filter in the QFileDialog of Import/Export:
 static const char* FILE_FILTER = I18N_NOOP("*.xml|XML files\n*|All files");
 
 
 UserActionPage::UserActionPage(QWidget* parent)
         : QWidget(parent)
 {
-    QVBoxLayout* layout = new QVBoxLayout(this);
+    auto* layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->setSpacing(6);   // 0px margin, 6px item-spacing
 
     // ======== pseudo-toolbar start ========
-    QHBoxLayout* toolbarLayout = new QHBoxLayout; // neither margin nor spacing for the toolbar with autoRaise
+    auto* toolbarLayout = new QHBoxLayout; // neither margin nor spacing for the toolbar with autoRaise
     toolbarLayout->setSpacing(0);
     toolbarLayout->setContentsMargins(0, 0, 0, 0);
 
     newButton = new QToolButton(this);
     newButton->setIcon(Icon("document-new"));
     newButton->setAutoRaise(true);
     newButton->setToolTip(i18n("Create new useraction"));
 
     importButton = new QToolButton(this);
     importButton->setIcon(Icon("document-import"));
     importButton->setAutoRaise(true);
     importButton->setToolTip(i18n("Import useractions"));
 
     exportButton = new QToolButton(this);
     exportButton->setIcon(Icon("document-export"));
     exportButton->setAutoRaise(true);
     exportButton->setToolTip(i18n("Export useractions"));
 
     copyButton = new QToolButton(this);
     copyButton->setIcon(Icon("edit-copy"));
     copyButton->setAutoRaise(true);
     copyButton->setToolTip(i18n("Copy useractions to clipboard"));
 
     pasteButton = new QToolButton(this);
     pasteButton->setIcon(Icon("edit-paste"));
     pasteButton->setAutoRaise(true);
     pasteButton->setToolTip(i18n("Paste useractions from clipboard"));
 
     removeButton = new QToolButton(this);
     removeButton->setIcon(Icon("edit-delete"));
     removeButton->setAutoRaise(true);
     removeButton->setToolTip(i18n("Delete selected useractions"));
 
     toolbarLayout->addWidget(newButton);
     toolbarLayout->addWidget(importButton);
     toolbarLayout->addWidget(exportButton);
     toolbarLayout->addWidget(copyButton);
     toolbarLayout->addWidget(pasteButton);
     toolbarLayout->addSpacing(6);   // 6 pixel nothing
     toolbarLayout->addWidget(removeButton);
     toolbarLayout->addStretch(1000);   // some very large stretch-factor
     // ======== pseudo-toolbar end ========
     /* This seems obsolete now!
        // Display some help
        KMessageBox::information( this, // parent
          i18n( "When you apply changes to an action, the modifications "
           "become available in the current session immediately.\n"
           "When closing ActionMan, you will be asked to save the changes permanently."
          ),
         QString(), // caption
         "show UserAction help" //dontShowAgainName for the config
        );
     */
     layout->addLayout(toolbarLayout);
-    QSplitter *split = new QSplitter(this);
+    auto *split = new QSplitter(this);
     layout->addWidget(split, 1000);   // again a very large stretch-factor to fix the height of the toolbar
 
     actionTree = new UserActionListView(split);
     actionTree->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     actionProperties = new ActionProperty(split);
     actionProperties->setEnabled(false);   // if there are any actions in the list, the first is displayed and this widget is enabled
 
     connect(actionTree, &UserActionListView::currentItemChanged, this, &UserActionPage::slotChangeCurrent);
     connect(newButton, &QToolButton::clicked, this, &UserActionPage::slotNewAction);
     connect(removeButton, &QToolButton::clicked, this, &UserActionPage::slotRemoveAction);
     connect(importButton, &QToolButton::clicked, this, &UserActionPage::slotImport);
     connect(exportButton, &QToolButton::clicked, this, &UserActionPage::slotExport);
     connect(copyButton, &QToolButton::clicked, this, &UserActionPage::slotToClip);
     connect(pasteButton, &QToolButton::clicked, this, &UserActionPage::slotFromClip);
 
     // forwards the changed signal of the properties
     connect(actionProperties, SIGNAL(changed()), SIGNAL(changed()));
 
     actionTree->setFirstActionCurrent();
     actionTree->setFocus();
 }
 
 UserActionPage::~UserActionPage()
-{
-}
+= default;
 
 bool UserActionPage::continueInSpiteOfChanges()
 {
     if (! actionProperties->isModified())
         return true;
 
     int answer = KMessageBox::questionYesNoCancel(this,
                  i18n("The current action has been modified. Do you want to apply these changes?")
                                                  );
     if (answer == KMessageBox::Cancel) {
         disconnect(actionTree, &UserActionListView::currentItemChanged, this, &UserActionPage::slotChangeCurrent);
         actionTree->setCurrentAction(actionProperties->action());
         connect(actionTree, &UserActionListView::currentItemChanged, this, &UserActionPage::slotChangeCurrent);
         return false;
     }
     if (answer == KMessageBox::Yes) {
         if (! actionProperties->validProperties()) {
             disconnect(actionTree, &UserActionListView::currentItemChanged, this, &UserActionPage::slotChangeCurrent);
             actionTree->setCurrentAction(actionProperties->action());
             connect(actionTree, &UserActionListView::currentItemChanged, this, &UserActionPage::slotChangeCurrent);
             return false;
         }
         slotUpdateAction();
     } // if Yes
     return true;
 }
 
 void UserActionPage::slotChangeCurrent()
 {
     if (! continueInSpiteOfChanges())
         return;
 
     KrAction* action = actionTree->currentAction();
     if (action) {
         actionProperties->setEnabled(true);
         // the distinct name is used as ID it is not allowed to change it afterwards because it is may referenced anywhere else
         actionProperties->leDistinctName->setEnabled(false);
         actionProperties->updateGUI(action);
     } else {
         // If the current item in the tree is no action (i.e. a category), disable the properties
         actionProperties->clear();
         actionProperties->setEnabled(false);
     }
     emit applied(); // to disable the apply-button
 }
 
 
 void UserActionPage::slotUpdateAction()
 {
     // check that we have a command line, title and a name
     if (! actionProperties->validProperties())
         return;
 
     if (actionProperties->leDistinctName->isEnabled()) {
         // := new entry
         KrAction* action = new KrAction(krApp->actionCollection(), actionProperties->leDistinctName->text());
         krUserAction->addKrAction(action);
         actionProperties->updateAction(action);
         UserActionListViewItem* item = actionTree->insertAction(action);
         actionTree->setCurrentItem(item);
     } else { // := edit an existing
         actionProperties->updateAction();
         actionTree->update(actionProperties->action());   // update the listviewitem as well...
     }
     apply();
 }
 
 
 void UserActionPage::slotNewAction()
 {
     if (continueInSpiteOfChanges()) {
         actionTree->clearSelection();  // else the user may think that he is overwriting the selected action
         actionProperties->clear();
         actionProperties->setEnabled(true);   // it may be disabled because the tree has the focus on a category
         actionProperties->leDistinctName->setEnabled(true);
         actionProperties->leDistinctName->setFocus();
     }
 }
 
 void UserActionPage::slotRemoveAction()
 {
     if (! dynamic_cast<UserActionListViewItem*>(actionTree->currentItem()))
         return;
 
     int messageDelete = KMessageBox::warningContinueCancel(this,   //parent
                         i18n("Are you sure that you want to remove all selected actions?"), //text
                         i18n("Remove Selected Actions?"),  //caption
                         KStandardGuiItem::remove(), //Label for the continue-button
                         KStandardGuiItem::cancel(),
                         "Confirm Remove UserAction", //dontAskAgainName (for the config-file)
                         KMessageBox::Dangerous | KMessageBox::Notify);
 
     if (messageDelete != KMessageBox::Continue)
         return;
 
     actionProperties->clear();
     actionProperties->setEnabled(false);
 
     actionTree->removeSelectedActions();
 
     apply();
 }
 
 void UserActionPage::slotImport()
 {
     QString filename = QFileDialog::getOpenFileName(this, QString(), QString(), i18n(FILE_FILTER));
     if (filename.isEmpty())
         return;
 
     UserAction::KrActionList newActions;
     krUserAction->readFromFile(filename, UserAction::renameDoublicated, &newActions);
 
     QListIterator<KrAction *> it(newActions);
     while (it.hasNext())
         actionTree->insertAction(it.next());
 
     if (newActions.count() > 0) {
         apply();
     }
 }
 
 void UserActionPage::slotExport()
 {
     if (! dynamic_cast<UserActionListViewItem*>(actionTree->currentItem()))
         return;
 
     QString filename = QFileDialog::getSaveFileName(this, QString(), QString(), i18n(FILE_FILTER));
     if (filename.isEmpty())
         return;
 
     QDomDocument doc = QDomDocument(ACTION_DOCTYPE);
     QFile file(filename);
     int answer = 0;
     if (file.open(QIODevice::ReadOnly)) {    // getting here, means the file already exists an can be read
         if (doc.setContent(&file))    // getting here means the file exists and already contains an UserAction-XML-tree
             answer = KMessageBox::warningYesNoCancel(this,  //parent
                      i18n("This file already contains some useractions.\nDo you want to overwrite it or should it be merged with the selected actions?"), //text
                      i18n("Overwrite or Merge?"), //caption
                      KStandardGuiItem::overwrite(), //label for Yes-Button
                      KGuiItem(i18n("Merge")) //label for No-Button
                                                     );
         file.close();
     }
     if (answer == 0 && file.exists())
         answer = KMessageBox::warningContinueCancel(this,  //parent
                  i18n("This file already exists. Do you want to overwrite it?"), //text
                  i18n("Overwrite Existing File?"), //caption
                  KStandardGuiItem::overwrite() //label for Continue-Button
                                                    );
 
     if (answer == KMessageBox::Cancel)
         return;
 
     if (answer == KMessageBox::No)   // that means the merge-button
         doc = actionTree->dumpSelectedActions(&doc);   // merge
     else // Yes or Continue means overwrite
         doc = actionTree->dumpSelectedActions();
 
     bool success = UserAction::writeToFile(doc, filename);
     if (! success)
         KMessageBox::error(this,
                            i18n("Cannot open %1 for writing.\nNothing exported.", filename),
                            i18n("Export Failed")
                           );
 }
 
 void UserActionPage::slotToClip()
 {
     if (! dynamic_cast<UserActionListViewItem*>(actionTree->currentItem()))
         return;
 
     QDomDocument doc = actionTree->dumpSelectedActions();
     QApplication::clipboard()->setText(doc.toString());
 }
 
 void UserActionPage::slotFromClip()
 {
     QDomDocument doc(ACTION_DOCTYPE);
     if (doc.setContent(QApplication::clipboard()->text())) {
         QDomElement root = doc.documentElement();
         UserAction::KrActionList newActions;
         krUserAction->readFromElement(root, UserAction::renameDoublicated, &newActions);
 
         QListIterator<KrAction *> it(newActions);
         while (it.hasNext())
             actionTree->insertAction(it.next());
 
         if (newActions.count() > 0) {
             apply();
         }
     } // if ( doc.setContent )
 }
 
 bool UserActionPage::readyToQuit()
 {
     // Check if the current UserAction has changed
     if (! continueInSpiteOfChanges())
         return false;
 
     krUserAction->writeActionFile();
     return true;
 }
 
 void UserActionPage::apply()
 {
     krUserAction->writeActionFile();
     emit applied();
 }
 
 void UserActionPage::applyChanges()
 {
     slotUpdateAction();
 }
 
diff --git a/krusader/ActionMan/useractionpage.h b/krusader/ActionMan/useractionpage.h
index 1f3b833c..57a598e3 100644
--- a/krusader/ActionMan/useractionpage.h
+++ b/krusader/ActionMan/useractionpage.h
@@ -1,82 +1,82 @@
 /*****************************************************************************
  * Copyright (C) 2006 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2006 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef USERACTIONPAGE_H
 #define USERACTIONPAGE_H
 
 // QtWidgets
 #include <QWidget>
 
 class UserActionListView;
 class ActionProperty;
 class QToolButton;
 
 class UserActionPage : public QWidget
 {
     Q_OBJECT
 public:
     explicit UserActionPage(QWidget* parent);
-    ~UserActionPage();
+    ~UserActionPage() override;
 
     /**
      * Be sure to call this function before you delete this page!!
      * @return true if this page can be closed
      */
     bool readyToQuit();
 
     void applyChanges();
 
 signals:
     void changed(); ///< emitted on changes to an action (used to enable the apply-button)
     void applied(); ///< emitted when changes are applied to an action (used to disable the apply-button)
 
 private:
     /**
      * If there are modifications in the property-widget, the user is asked
      * what to do. Apply, discard or continue editing. In the first case,
      * saving is done in this function.
      * @return true if a new action can be loaded in the property-widget.
      */
     bool continueInSpiteOfChanges();
     /**
      * applies all changes by writing the actionfile and emits "applied"
      */
     void apply();
 
     //bool _modified; ///< true if the action-tree was changed (= changes were applied to an action)
     UserActionListView *actionTree;
     ActionProperty *actionProperties;
     QToolButton *importButton, *exportButton;
     QToolButton *copyButton, *pasteButton;
     QToolButton *removeButton, *newButton;
 
 private slots:
     void slotChangeCurrent(); //loads a new action into the detail-view
     void slotUpdateAction(); //updates the action to the xml-file
     void slotNewAction();
     void slotRemoveAction();
     void slotImport();
     void slotExport();
     void slotToClip();
     void slotFromClip();
 };
 
 #endif
diff --git a/krusader/Archive/abstractthreadedjob.cpp b/krusader/Archive/abstractthreadedjob.cpp
index f8fc6945..1e22ec8e 100644
--- a/krusader/Archive/abstractthreadedjob.cpp
+++ b/krusader/Archive/abstractthreadedjob.cpp
@@ -1,664 +1,664 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "abstractthreadedjob.h"
 
 // QtCore
 #include <QTimer>
 #include <QDir>
 #include <QPointer>
 #include <QEventLoop>
 #include <QTemporaryDir>
 #include <QTemporaryFile>
 // QtWidgets
 #include <QApplication>
 
 #include <KI18n/KLocalizedString>
 #include <KIO/JobUiDelegate>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "krarchandler.h"
 #include "../krglobal.h"
 #include "../krservices.h"
 #include "../FileSystem/filesystemprovider.h"
 
 extern KRarcHandler arcHandler;
 
-AbstractThreadedJob::AbstractThreadedJob() : KIO::Job(), _locker(), _waiter(), _stack(), _maxProgressValue(0),
-        _currentProgress(0), _exiting(false), _jobThread(0)
+AbstractThreadedJob::AbstractThreadedJob() : _maxProgressValue(0),
+        _currentProgress(0), _exiting(false), _jobThread(nullptr)
 {
 }
 
 void AbstractThreadedJob::startAbstractJobThread(AbstractJobThread * jobThread)
 {
     _jobThread = jobThread;
     _jobThread->setJob(this);
     _jobThread->moveToThread(_jobThread);
     _jobThread->start();
 }
 
 AbstractThreadedJob::~AbstractThreadedJob()
 {
     _exiting = true;
     if (_jobThread) {
         _jobThread->abort();
 
         _locker.lock();
         _waiter.wakeAll();
         _locker.unlock();
 
         _jobThread->wait();
         delete _jobThread;
     }
 }
 
 bool AbstractThreadedJob::event(QEvent *e)
 {
     if (e->type() == QEvent::User) {
-        UserEvent *event = (UserEvent*) e;
+        auto *event = (UserEvent*) e;
         switch (event->command()) {
         case CMD_SUCCESS: {
             emitResult();
         }
         break;
         case CMD_ERROR: {
-            int error = event->args()[ 0 ].value<int>();
+            auto error = event->args()[ 0 ].value<int>();
             QString errorText = event->args()[ 1 ].value<QString>();
 
             setError(error);
             setErrorText(errorText);
             emitResult();
         }
         break;
         case CMD_INFO: {
             QString info = event->args()[ 0 ].value<QString>();
             QString arg1 = event->args()[ 1 ].value<QString>();
             QString arg2 = event->args()[ 2 ].value<QString>();
             QString arg3 = event->args()[ 3 ].value<QString>();
             QString arg4 = event->args()[ 4 ].value<QString>();
 
             _title = info;
             emit description(this, info,
                              qMakePair(arg1, arg2),
                              qMakePair(arg3, arg4));
 
         }
         break;
         case CMD_RESET: {
             QString info = event->args()[ 0 ].value<QString>();
             QString arg1 = event->args()[ 1 ].value<QString>();
             QString arg2 = event->args()[ 2 ].value<QString>();
             QString arg3 = event->args()[ 3 ].value<QString>();
             QString arg4 = event->args()[ 4 ].value<QString>();
 
             _title = info;
             setProcessedAmount(KJob::Bytes, 0);
             setTotalAmount(KJob::Bytes, 0);
             emitSpeed(0);
 
             emit description(this, info,
                              qMakePair(arg1, arg2),
                              qMakePair(arg3, arg4));
 
         }
         break;
         case CMD_UPLOAD_FILES:
         case CMD_DOWNLOAD_FILES: {
             QList<QUrl> sources = KrServices::toUrlList(event->args()[ 0 ].value<QStringList>());
             QUrl dest = event->args()[ 1 ].value<QUrl>();
             KIO::Job *job = KIO::copy(sources, dest, KIO::HideProgressInfo);
             addSubjob(job);
             job->setUiDelegate(new KIO::JobUiDelegate());
 
             connect(job, &KIO::Job::result, this, &AbstractThreadedJob::slotDownloadResult);
             connect(job, SIGNAL(processedAmount(KJob*,KJob::Unit,qulonglong)),
                                this, SLOT(slotProcessedAmount(KJob*,KJob::Unit,qulonglong)));
             connect(job, SIGNAL(totalAmount(KJob*,KJob::Unit,qulonglong)),
                                this, SLOT(slotTotalAmount(KJob*,KJob::Unit,qulonglong)));
             connect(job, SIGNAL(speed(KJob*,ulong)),
                                this, SLOT(slotSpeed(KJob*,ulong)));
             connect(job, SIGNAL(description(KJob*,QString,QPair<QString,QString>,QPair<QString,QString>)),
                                this, SLOT(slotDescription(KJob*,QString,QPair<QString,QString>,QPair<QString,QString>)));
         }
         break;
         case CMD_MAXPROGRESSVALUE: {
-            qulonglong maxValue = event->args()[ 0 ].value<qulonglong>();
+            auto maxValue = event->args()[ 0 ].value<qulonglong>();
             _maxProgressValue = maxValue;
             _currentProgress = 0;
         }
         break;
         case CMD_ADD_PROGRESS: {
-            qulonglong progress = event->args()[ 0 ].value<qulonglong>();
+            auto progress = event->args()[ 0 ].value<qulonglong>();
             _currentProgress += progress;
             if (_maxProgressValue != 0) {
                 setPercent(100 * _currentProgress / _maxProgressValue);
 
                 int elapsed = _time.isNull() ? 1 : _time.secsTo(QTime::currentTime());
 
                 if (elapsed != 0 && event->args().count() > 1) {
                     _time = QTime::currentTime();
                     QString progressString = (event->args()[ 1 ].value<QString>());
                     emit description(this, _title,
                                      qMakePair(progressString, QString("%1/%2").arg(_currentProgress).arg(_maxProgressValue)),
                                      qMakePair(QString(), QString())
                                     );
                 }
             }
         }
         break;
         case CMD_GET_PASSWORD: {
             QString path = event->args()[ 0 ].value<QString>();
             QString password = KRarcHandler::getPassword(path);
 
-            QList<QVariant> *resultResp = new QList<QVariant> ();
+            auto *resultResp = new QList<QVariant> ();
             (*resultResp) << password;
             addEventResponse(resultResp);
         }
         break;
         case CMD_MESSAGE: {
             QString message = event->args()[ 0 ].value<QString>();
-            KIO::JobUiDelegate *ui = static_cast<KIO::JobUiDelegate*>(uiDelegate());
-            KMessageBox::information(ui ? ui->window() : 0, message);
-            QList<QVariant> *resultResp = new QList<QVariant> ();
+            auto *ui = dynamic_cast<KIO::JobUiDelegate*>(uiDelegate());
+            KMessageBox::information(ui ? ui->window() : nullptr, message);
+            auto *resultResp = new QList<QVariant> ();
             addEventResponse(resultResp);
         }
         break;
         }
         return true;
     } else {
         return KIO::Job::event(e);
     }
 }
 
 void AbstractThreadedJob::addEventResponse(QList<QVariant> * obj)
 {
     _locker.lock();
     _stack.push(obj);
     _waiter.wakeOne();
     _locker.unlock();
 }
 
 QList<QVariant> * AbstractThreadedJob::getEventResponse(UserEvent * event)
 {
     _locker.lock();
     QApplication::postEvent(this, event);
     _waiter.wait(&_locker);
     if (_exiting)
-        return 0;
+        return nullptr;
     QList<QVariant> *resp = _stack.pop();
     _locker.unlock();
     return resp;
 }
 
 void AbstractThreadedJob::sendEvent(UserEvent * event)
 {
     QApplication::postEvent(this, event);
 }
 
 void AbstractThreadedJob::slotDownloadResult(KJob* job)
 {
-    QList<QVariant> *resultResp = new QList<QVariant> ();
+    auto *resultResp = new QList<QVariant> ();
     if (job) {
         (*resultResp) << QVariant(job->error());
         (*resultResp) << QVariant(job->errorText());
     } else {
         (*resultResp) << QVariant(KJob::UserDefinedError);
         (*resultResp) << QVariant(QString(i18n("Internal error, undefined <job> in result signal")));
     }
 
     addEventResponse(resultResp);
 }
 
 void AbstractThreadedJob::slotProcessedAmount(KJob *, KJob::Unit unit, qulonglong xu)
 {
     setProcessedAmount(unit, xu);
 }
 
 void AbstractThreadedJob::slotTotalAmount(KJob *, KJob::Unit unit, qulonglong xu)
 {
     setTotalAmount(unit, xu);
 }
 
 void AbstractThreadedJob::slotSpeed(KJob *, unsigned long spd)
 {
     emitSpeed(spd);
 }
 
 void AbstractThreadedJob::slotDescription(KJob *, const QString &title, const QPair<QString, QString> &field1,
         const QPair<QString, QString> &field2)
 {
     QString mytitle = title;
     if (!_title.isNull())
         mytitle = _title;
     emit description(this, mytitle, field1, field2);
 }
 
 class AbstractJobObserver : public KRarcObserver
 {
 protected:
     AbstractJobThread * _jobThread;
 public:
     explicit AbstractJobObserver(AbstractJobThread * thread): _jobThread(thread) {}
-    virtual ~AbstractJobObserver() {}
+    ~AbstractJobObserver() override = default;
 
-    virtual void processEvents() Q_DECL_OVERRIDE {
+    void processEvents() Q_DECL_OVERRIDE {
         usleep(1000);
         qApp->processEvents();
     }
 
-    virtual void subJobStarted(const QString & jobTitle, int count) Q_DECL_OVERRIDE {
+    void subJobStarted(const QString & jobTitle, int count) Q_DECL_OVERRIDE {
         _jobThread->sendReset(jobTitle);
         _jobThread->sendMaxProgressValue(count);
     }
 
-    virtual void subJobStopped() Q_DECL_OVERRIDE {
+    void subJobStopped() Q_DECL_OVERRIDE {
     }
 
-    virtual bool wasCancelled() Q_DECL_OVERRIDE {
+    bool wasCancelled() Q_DECL_OVERRIDE {
         return _jobThread->_exited;
     }
 
-    virtual void error(const QString & error) Q_DECL_OVERRIDE {
+    void error(const QString & error) Q_DECL_OVERRIDE {
         _jobThread->sendError(KIO::ERR_NO_CONTENT, error);
     }
 
-    virtual void detailedError(const QString & error, const QString & details) Q_DECL_OVERRIDE {
+    void detailedError(const QString & error, const QString & details) Q_DECL_OVERRIDE {
         _jobThread->sendError(KIO::ERR_NO_CONTENT, error + '\n' + details);
     }
 
-    virtual void incrementProgress(int c) Q_DECL_OVERRIDE {
+    void incrementProgress(int c) Q_DECL_OVERRIDE {
         _jobThread->sendAddProgress(c, _jobThread->_progressTitle);
     }
 };
 
 
-AbstractJobThread::AbstractJobThread() : _job(0), _downloadTempDir(0), _observer(0), _tempFile(0),
-        _tempDir(0), _exited(false)
+AbstractJobThread::AbstractJobThread() : _job(nullptr), _downloadTempDir(nullptr), _observer(nullptr), _tempFile(nullptr),
+        _tempDir(nullptr), _exited(false)
 {
 }
 
 AbstractJobThread::~AbstractJobThread()
 {
     if (_downloadTempDir) {
         delete _downloadTempDir;
-        _downloadTempDir = 0;
+        _downloadTempDir = nullptr;
     }
     if (_observer) {
         delete _observer;
-        _observer = 0;
+        _observer = nullptr;
     }
     if (_tempFile) {
         delete _tempFile;
-        _tempFile = 0;
+        _tempFile = nullptr;
     }
 }
 
 void AbstractJobThread::run()
 {
     QTimer::singleShot(0, this, &AbstractJobThread::slotStart);
 
     QPointer<QEventLoop> threadLoop = new QEventLoop(this);
     _loop = threadLoop;
     threadLoop->exec();
 
-    _loop = 0;
+    _loop = nullptr;
     delete threadLoop;
 }
 
 void AbstractJobThread::terminate()
 {
     if (_loop && !_exited) {
         _loop->quit();
         _exited = true;
     }
 }
 
 void AbstractJobThread::abort()
 {
     terminate();
 }
 
 QList<QUrl> AbstractJobThread::remoteUrls(const QUrl &baseUrl, const QStringList & files)
 {
     QList<QUrl> urlList;
     foreach(const QString &name, files) {
         QUrl url = baseUrl;
         url = url.adjusted(QUrl::StripTrailingSlash);
         url.setPath(url.path() + '/' + (name));
         urlList << url;
     }
     return urlList;
 }
 
 QUrl AbstractJobThread::downloadIfRemote(const QUrl &baseUrl, const QStringList & files)
 {
     // download remote URL-s if necessary
 
     if (!baseUrl.isLocalFile()) {
         sendInfo(i18n("Downloading remote files"));
 
         _downloadTempDir = new QTemporaryDir();
         QList<QUrl> urlList = remoteUrls(baseUrl, files);
 
         QUrl dest(_downloadTempDir->path());
 
         QList<QVariant> args;
         args << KrServices::toStringList(urlList);
         args << dest;
 
-        UserEvent * downloadEvent = new UserEvent(CMD_DOWNLOAD_FILES, args);
+        auto * downloadEvent = new UserEvent(CMD_DOWNLOAD_FILES, args);
         QList<QVariant> * result = _job->getEventResponse(downloadEvent);
-        if (result == 0)
+        if (result == nullptr)
             return QUrl();
 
-        int errorCode = (*result)[ 0 ].value<int>();
+        auto errorCode = (*result)[ 0 ].value<int>();
         QString errorText = (*result)[ 1 ].value<QString>();
 
         delete result;
 
         if (errorCode) {
             sendError(errorCode, errorText);
             return QUrl();
         } else {
             return dest;
         }
     } else {
         return baseUrl;
     }
 }
 
 
 QString AbstractJobThread::tempFileIfRemote(const QUrl &kurl, const QString &type)
 {
     if (kurl.isLocalFile()) {
         return kurl.path();
     }
 
     _tempFile = new QTemporaryFile(QDir::tempPath() + QLatin1String("/krusader_XXXXXX.") + type);
     _tempFile->open();
     _tempFileName = _tempFile->fileName();
     _tempFile->close(); // necessary to create the filename
     QFile::remove(_tempFileName);
 
     _tempFileTarget = kurl;
     return _tempFileName;
 }
 
 QString AbstractJobThread::tempDirIfRemote(const QUrl &kurl)
 {
     if (kurl.isLocalFile()) {
         return kurl.adjusted(QUrl::StripTrailingSlash).path();
     }
 
     _tempDir = new QTemporaryDir();
     _tempDirTarget = kurl;
     return _tempDirName = _tempDir->path();
 }
 
 void AbstractJobThread::sendSuccess()
 {
     terminate();
 
     QList<QVariant> args;
 
-    UserEvent * errorEvent = new UserEvent(CMD_SUCCESS, args);
+    auto * errorEvent = new UserEvent(CMD_SUCCESS, args);
     _job->sendEvent(errorEvent);
 }
 
-void AbstractJobThread::sendError(int errorCode, QString message)
+void AbstractJobThread::sendError(int errorCode, const QString& message)
 {
     terminate();
 
     QList<QVariant> args;
     args << errorCode;
     args << message;
 
-    UserEvent * errorEvent = new UserEvent(CMD_ERROR, args);
+    auto * errorEvent = new UserEvent(CMD_ERROR, args);
     _job->sendEvent(errorEvent);
 }
 
-void AbstractJobThread::sendInfo(QString message, QString a1, QString a2, QString a3, QString a4)
+void AbstractJobThread::sendInfo(const QString& message, const QString& a1, const QString& a2, const QString& a3, const QString& a4)
 {
     QList<QVariant> args;
     args << message;
     args << a1;
     args << a2;
     args << a3;
     args << a4;
 
-    UserEvent * infoEvent = new UserEvent(CMD_INFO, args);
+    auto * infoEvent = new UserEvent(CMD_INFO, args);
     _job->sendEvent(infoEvent);
 }
 
-void AbstractJobThread::sendReset(QString message, QString a1, QString a2, QString a3, QString a4)
+void AbstractJobThread::sendReset(const QString& message, const QString& a1, const QString& a2, const QString& a3, const QString& a4)
 {
     QList<QVariant> args;
     args << message;
     args << a1;
     args << a2;
     args << a3;
     args << a4;
 
-    UserEvent * infoEvent = new UserEvent(CMD_RESET, args);
+    auto * infoEvent = new UserEvent(CMD_RESET, args);
     _job->sendEvent(infoEvent);
 }
 
 void AbstractJobThread::sendMaxProgressValue(qulonglong value)
 {
     QList<QVariant> args;
     args << value;
 
-    UserEvent * infoEvent = new UserEvent(CMD_MAXPROGRESSVALUE, args);
+    auto * infoEvent = new UserEvent(CMD_MAXPROGRESSVALUE, args);
     _job->sendEvent(infoEvent);
 }
 
 void AbstractJobThread::sendAddProgress(qulonglong value, const QString &progress)
 {
     QList<QVariant> args;
     args << value;
 
     if (!progress.isNull())
         args << progress;
 
-    UserEvent * infoEvent = new UserEvent(CMD_ADD_PROGRESS, args);
+    auto * infoEvent = new UserEvent(CMD_ADD_PROGRESS, args);
     _job->sendEvent(infoEvent);
 }
 
 void countFiles(const QString &path, unsigned long &totalFiles, bool &stop)
 {
     const QDir dir(path);
     if (!dir.exists()) {
         totalFiles++; // assume it's a file
         return;
     }
 
-    for (const QString name : dir.entryList()) {
+    for (const QString& name : dir.entryList()) {
         if (stop)
             return;
 
         if (name == QStringLiteral(".") || name == QStringLiteral(".."))
             continue;
 
         countFiles(dir.absoluteFilePath(name), totalFiles, stop);
     }
 }
 
 void AbstractJobThread::countLocalFiles(const QUrl &baseUrl, const QStringList &names,
                                        unsigned long &totalFiles)
 {
     sendReset(i18n("Counting files"));
 
     FileSystem *calcSpaceFileSystem = FileSystemProvider::instance().getFilesystem(baseUrl);
     calcSpaceFileSystem->scanDir(baseUrl);
-    for (const QString name : names) {
+    for (const QString& name : names) {
         if (_exited)
             return;
 
         const QString path = calcSpaceFileSystem->getUrl(name).toLocalFile();
         if (!QFileInfo(path).exists())
             return;
 
         countFiles(path, totalFiles, _exited);
     }
 
     delete calcSpaceFileSystem;
 }
 
 KRarcObserver * AbstractJobThread::observer()
 {
     if (_observer)
         return _observer;
     _observer = new AbstractJobObserver(this);
     return _observer;
 }
 
 bool AbstractJobThread::uploadTempFiles()
 {
-    if (_tempFile != 0 || _tempDir != 0) {
+    if (_tempFile != nullptr || _tempDir != nullptr) {
         sendInfo(i18n("Uploading to remote destination"));
 
         if (_tempFile) {
             QList<QUrl> urlList;
             urlList << QUrl::fromLocalFile(_tempFileName);
 
             QList<QVariant> args;
             args << KrServices::toStringList(urlList);
             args << _tempFileTarget;
 
-            UserEvent * uploadEvent = new UserEvent(CMD_UPLOAD_FILES, args);
+            auto * uploadEvent = new UserEvent(CMD_UPLOAD_FILES, args);
             QList<QVariant> * result = _job->getEventResponse(uploadEvent);
-            if (result == 0)
+            if (result == nullptr)
                 return false;
 
-            int errorCode = (*result)[ 0 ].value<int>();
+            auto errorCode = (*result)[ 0 ].value<int>();
             QString errorText = (*result)[ 1 ].value<QString>();
 
             delete result;
 
             if (errorCode) {
                 sendError(errorCode, errorText);
                 return false;
             }
         }
 
         if (_tempDir) {
             QList<QUrl> urlList;
             QDir tempDir(_tempDirName);
             QStringList list = tempDir.entryList();
             foreach(const QString &name, list) {
                 if (name == "." || name == "..")
                     continue;
                 QUrl url = QUrl::fromLocalFile(_tempDirName).adjusted(QUrl::StripTrailingSlash);
                 url.setPath(url.path() + '/' + (name));
                 urlList << url;
             }
 
             QList<QVariant> args;
             args << KrServices::toStringList(urlList);
             args << _tempDirTarget;
 
-            UserEvent * uploadEvent = new UserEvent(CMD_UPLOAD_FILES, args);
+            auto * uploadEvent = new UserEvent(CMD_UPLOAD_FILES, args);
             QList<QVariant> * result = _job->getEventResponse(uploadEvent);
-            if (result == 0)
+            if (result == nullptr)
                 return false;
 
-            int errorCode = (*result)[ 0 ].value<int>();
+            auto errorCode = (*result)[ 0 ].value<int>();
             QString errorText = (*result)[ 1 ].value<QString>();
 
             delete result;
 
             if (errorCode) {
                 sendError(errorCode, errorText);
                 return false;
             }
         }
     }
     return true;
 }
 
 QString AbstractJobThread::getPassword(const QString &path)
 {
     QList<QVariant> args;
     args << path;
 
-    UserEvent * getPasswdEvent = new UserEvent(CMD_GET_PASSWORD, args);
+    auto * getPasswdEvent = new UserEvent(CMD_GET_PASSWORD, args);
     QList<QVariant> * result = _job->getEventResponse(getPasswdEvent);
-    if (result == 0)
+    if (result == nullptr)
         return QString();
 
     QString password = (*result)[ 0 ].value<QString>();
     if (password.isNull())
         password = QString("");
 
     delete result;
     return password;
 }
 
 void AbstractJobThread::sendMessage(const QString &message)
 {
     QList<QVariant> args;
     args << message;
 
-    UserEvent * getPasswdEvent = new UserEvent(CMD_MESSAGE, args);
+    auto * getPasswdEvent = new UserEvent(CMD_MESSAGE, args);
     QList<QVariant> * result = _job->getEventResponse(getPasswdEvent);
-    if (result == 0)
+    if (result == nullptr)
         return;
     delete result;
 }
 
 //! Gets some archive information that is needed in several cases.
 /*!
     \param path A path to the archive.
     \param type The type of the archive.
     \param password The password of the archive.
     \param arcName The name of the archive.
     \param sourceFolder A QUrl, which may be remote, of the folder where the archive is.
     \return If the archive information has been obtained.
 */
 bool AbstractJobThread::getArchiveInformation(QString &path, QString &type, QString &password,
                                               QString &arcName, const QUrl &sourceFolder)
 {
     // Safety checks (though the user shouldn't have been able to select something named "" or "..")
     if (arcName.isEmpty())
         return false;
     if (arcName == "..")
         return false;
 
     QUrl url = sourceFolder.adjusted(QUrl::StripTrailingSlash);
     url.setPath(url.path() + '/' + arcName);
 
     path = url.adjusted(QUrl::StripTrailingSlash).path();
 
     QMimeDatabase db;
     QMimeType mt = db.mimeTypeForUrl(url);
     QString mime = mt.isValid() ? mt.name() : QString();
     bool encrypted = false;
     type = arcHandler.getType(encrypted, path, mime);
 
     // Check that the archive is supported
     if (!KRarcHandler::arcSupported(type)) {
         sendError(KIO::ERR_NO_CONTENT, i18nc("%1=archive filename", "%1, unsupported archive type.", arcName));
         return false;
     }
 
     password = encrypted ? getPassword(path) : QString();
 
     return true;
 }
diff --git a/krusader/Archive/abstractthreadedjob.h b/krusader/Archive/abstractthreadedjob.h
index 4ea06ad0..85af4e5c 100644
--- a/krusader/Archive/abstractthreadedjob.h
+++ b/krusader/Archive/abstractthreadedjob.h
@@ -1,188 +1,188 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef ABSTRACTTHREADEDJOB_H
 #define ABSTRACTTHREADEDJOB_H
 
 // QtCore
 #include <QThread>
 #include <QEvent>
 #include <QMimeDatabase>
 #include <QMutex>
 #include <QWaitCondition>
 #include <QStack>
 #include <QVariant>
 #include <QList>
 #include <QEventLoop>
 #include <QTime>
 #include <QUrl>
 
 #include <KIO/Job>
 
 class AbstractJobThread;
 class QTemporaryDir;
 class UserEvent;
 class KRarcObserver;
 class QTemporaryFile;
 
 class AbstractThreadedJob : public KIO::Job
 {
     friend class AbstractJobThread;
 
     Q_OBJECT
 
 protected:
     AbstractThreadedJob();
 
     void addEventResponse(QList<QVariant> * obj);
     QList<QVariant> * getEventResponse(UserEvent * event);
     void  sendEvent(UserEvent * event);
 
     virtual ~AbstractThreadedJob();
     virtual bool event(QEvent *) Q_DECL_OVERRIDE;
     virtual void startAbstractJobThread(AbstractJobThread*);
     virtual bool doSuspend() Q_DECL_OVERRIDE {
         return false;
     }
 
 protected slots:
     void slotDownloadResult(KJob*);
     void slotProcessedAmount(KJob *, KJob::Unit, qulonglong);
     void slotTotalAmount(KJob *, KJob::Unit, qulonglong);
     void slotSpeed(KJob *, unsigned long);
     void slotDescription(KJob *job, const QString &title, const QPair<QString, QString> &field1,
                          const QPair<QString, QString> &field2);
 
 public:
     QMutex                    _locker;
     QWaitCondition            _waiter;
     QStack<QList<QVariant> *> _stack;
     QString                   _title;
     qulonglong                _maxProgressValue;
     qulonglong                _currentProgress;
     QTime                     _time;
     bool                      _exiting;
 
 private:
     AbstractJobThread *       _jobThread;
 };
 
 
 
 class AbstractJobThread : public QThread
 {
     friend class AbstractThreadedJob;
     friend class AbstractJobObserver;
     Q_OBJECT
 
 public:
     AbstractJobThread();
     virtual ~AbstractJobThread();
 
     void abort();
     KRarcObserver * observer();
 
 protected slots:
     virtual void slotStart() = 0;
 
 protected:
     virtual void run() Q_DECL_OVERRIDE;
     void setJob(AbstractThreadedJob * job) {
         _job = job;
     }
 
     QList<QUrl> remoteUrls(const QUrl &baseUrl, const QStringList & files);
     QUrl downloadIfRemote(const QUrl &baseUrl, const QStringList & files);
     void countLocalFiles(const QUrl &baseUrl, const QStringList &names, unsigned long &totalFiles);
 
-    void sendError(int errorCode, QString message);
-    void sendInfo(QString message, QString a1 = QString(), QString a2 = QString(), QString a3 = QString(), QString a4 = QString());
-    void sendReset(QString message, QString a1 = QString(""), QString a2 = QString(""), QString a3 = QString(""), QString a4 = QString(""));
+    void sendError(int errorCode, const QString& message);
+    void sendInfo(const QString& message, const QString& a1 = QString(), const QString& a2 = QString(), const QString& a3 = QString(), const QString& a4 = QString());
+    void sendReset(const QString& message, const QString& a1 = QString(""), const QString& a2 = QString(""), const QString& a3 = QString(""), const QString& a4 = QString(""));
     void sendSuccess();
     void sendMessage(const QString &message);
     void sendMaxProgressValue(qulonglong value);
     void sendAddProgress(qulonglong value, const QString &progress = QString());
 
     void setProgressTitle(const QString &title) {
         _progressTitle = title;
     }
 
     QString tempFileIfRemote(const QUrl &kurl, const QString &type);
     QString tempDirIfRemote(const QUrl &kurl);
     bool uploadTempFiles();
 
     bool isExited() {
         return _exited;
     }
     void terminate();
 
     QString getPassword(const QString &path);
     bool getArchiveInformation(QString &, QString &, QString &, QString &, const QUrl &);
 
     AbstractThreadedJob *_job;
     QEventLoop          *_loop;
 
     QTemporaryDir       *_downloadTempDir;
     KRarcObserver       *_observer;
 
     QTemporaryFile      *_tempFile;
     QString              _tempFileName;
     QUrl                 _tempFileTarget;
     QTemporaryDir       *_tempDir;
     QString              _tempDirName;
     QUrl                 _tempDirTarget;
 
     bool                 _exited;
 
     QString              _progressTitle;
 };
 
 enum PossibleCommands {
     CMD_ERROR                =  1,
     CMD_INFO                 =  2,
     CMD_RESET                =  3,
     CMD_DOWNLOAD_FILES       =  4,
     CMD_UPLOAD_FILES         =  5,
     CMD_SUCCESS              =  6,
     CMD_MAXPROGRESSVALUE     =  7,
     CMD_ADD_PROGRESS         =  8,
     CMD_GET_PASSWORD         =  9,
     CMD_MESSAGE              = 10
 };
 
 class UserEvent : public QEvent
 {
 public:
     UserEvent(int command, const QList<QVariant> &args) : QEvent(QEvent::User), _command(command), _args(args) {}
 
     inline int                     command() {
         return _command;
     }
     inline const QList<QVariant> & args()    {
         return _args;
     }
 
 protected:
     int             _command;
     QList<QVariant> _args;
 };
 
 #endif // __ABSTRACTTHREADED_JOB_H__
 
diff --git a/krusader/Archive/kr7zencryptionchecker.cpp b/krusader/Archive/kr7zencryptionchecker.cpp
index 2c4eb37b..27c72a6a 100644
--- a/krusader/Archive/kr7zencryptionchecker.cpp
+++ b/krusader/Archive/kr7zencryptionchecker.cpp
@@ -1,63 +1,63 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kr7zencryptionchecker.h"
 
-Kr7zEncryptionChecker::Kr7zEncryptionChecker() : KProcess(), encrypted(false), lastData()
+Kr7zEncryptionChecker::Kr7zEncryptionChecker() : encrypted(false), lastData()
 {
     setOutputChannelMode(KProcess::SeparateChannels); // without this output redirection has no effect!
     connect(this, &Kr7zEncryptionChecker::readyReadStandardOutput, this, [=]() {receivedOutput(); });
 }
 
 void Kr7zEncryptionChecker::setupChildProcess()
 {
     // This function is called after the fork but for the exec. We create a process group
     // to work around a broken wrapper script of 7z. Without this only the wrapper is killed.
     setsid(); // make this process leader of a new process group
 }
 
 void Kr7zEncryptionChecker::receivedOutput()
 {
     QString data = QString::fromLocal8Bit(this->readAllStandardOutput());
 
     QString checkable = lastData + data;
 
     QStringList lines = checkable.split('\n');
     lastData = lines[ lines.count() - 1 ];
     for (int i = 0; i != lines.count(); i++) {
         QString line = lines[ i ].trimmed().toLower();
         int ndx = line.indexOf("testing");
         if (ndx >= 0)
             line.truncate(ndx);
         if (line.isEmpty())
             continue;
 
         if (line.contains("password") && line.contains("enter")) {
             encrypted = true;
             ::kill(- pid(), SIGKILL); // kill the whole process group by giving the negative PID
         }
     }
 }
 
 bool Kr7zEncryptionChecker::isEncrypted()
 {
     return encrypted;
 }
diff --git a/krusader/Archive/kr7zencryptionchecker.h b/krusader/Archive/kr7zencryptionchecker.h
index ae48553b..160ec3da 100644
--- a/krusader/Archive/kr7zencryptionchecker.h
+++ b/krusader/Archive/kr7zencryptionchecker.h
@@ -1,53 +1,53 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KR7ZENCRYPTIONCHECKER_H
 #define KR7ZENCRYPTIONCHECKER_H
 
 #include <unistd.h> // for setsid, see Kr7zEncryptionChecker::setupChildProcess
 #include <signal.h> // for kill
 
 #include <KCoreAddons/KProcess>
 
 /**
  * Used by ArcHandler.
  */
 class Kr7zEncryptionChecker : public KProcess
 {
     Q_OBJECT
 
 public:
     Kr7zEncryptionChecker();
 
 protected:
-    virtual void setupChildProcess() Q_DECL_OVERRIDE;
+    void setupChildProcess() Q_DECL_OVERRIDE;
 
 public slots:
     void receivedOutput();
     bool isEncrypted();
 
 private:
     QString fileName;
     bool encrypted;
     QString lastData;
 };
 
 #endif // KR7ZENCRYPTIONCHECKER_H
diff --git a/krusader/Archive/krarchandler.cpp b/krusader/Archive/krarchandler.cpp
index 6e409be3..3648e57e 100644
--- a/krusader/Archive/krarchandler.cpp
+++ b/krusader/Archive/krarchandler.cpp
@@ -1,668 +1,669 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krarchandler.h"
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 // QtWidgets
 #include <QApplication>
 
 #include <KArchive/KTar>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIO/Global>
 #include <KWallet/KWallet>
 #include <KWidgetsAddons/KMessageBox>
 #include <KWidgetsAddons/KPasswordDialog>
+#include <utility>
 
 #include "kr7zencryptionchecker.h"
 #include "../krglobal.h"
 #include "../defaults.h"
 #include "../krservices.h"
 #include "../Dialogs/krpleasewait.h"
 #include "../../krArc/krlinecountingprocess.h"
 
 #if 0
 class DefaultKRarcObserver : public KRarcObserver
 {
 public:
     DefaultKRarcObserver() {}
     virtual ~DefaultKRarcObserver() {}
 
     virtual void processEvents() Q_DECL_OVERRIDE {
         usleep(1000);
         qApp->processEvents();
     }
 
     virtual void subJobStarted(const QString & jobTitle, int count) Q_DECL_OVERRIDE {
         krApp->startWaiting(jobTitle, count, true);
     }
 
     virtual void subJobStopped() Q_DECL_OVERRIDE {
         krApp->stopWait();
     }
 
     virtual bool wasCancelled() Q_DECL_OVERRIDE {
         return krApp->wasWaitingCancelled();
     }
 
     virtual void error(const QString & error) Q_DECL_OVERRIDE {
         KMessageBox::error(krApp, error, i18n("Error"));
     }
 
     virtual void detailedError(const QString & error, const QString & details) Q_DECL_OVERRIDE {
         KMessageBox::detailedError(krApp, error, details, i18n("Error"));
     }
 
     virtual void incrementProgress(int c) Q_DECL_OVERRIDE {
         krApp->plzWait->incProgress(c);
     }
 };
 #endif
 
 static QStringList arcProtocols = QString("tar;bzip;bzip2;lzma;xz;gzip;krarc;zip").split(';');
 
-KWallet::Wallet * KRarcHandler::wallet = 0;
+KWallet::Wallet * KRarcHandler::wallet = nullptr;
 
 QStringList KRarcHandler::supportedPackers()
 {
     QStringList packers;
 
     // we will simply try to find the packers here..
     if (KrServices::cmdExist("tar")) packers.append("tar");
     if (KrServices::cmdExist("gzip")) packers.append("gzip");
     if (KrServices::cmdExist("bzip2")) packers.append("bzip2");
     if (KrServices::cmdExist("lzma")) packers.append("lzma");
     if (KrServices::cmdExist("xz")) packers.append("xz");
     if (KrServices::cmdExist("unzip")) packers.append("unzip");
     if (KrServices::cmdExist("zip")) packers.append("zip");
     if (KrServices::cmdExist("zip")) packers.append("cbz");
     if (KrServices::cmdExist("lha")) packers.append("lha");
     if (KrServices::cmdExist("cpio")) packers.append("cpio");
     if (KrServices::cmdExist("unrar")) packers.append("unrar");
     if (KrServices::cmdExist("rar")) packers.append("rar");
     if (KrServices::cmdExist("rar")) packers.append("cbr");
     if (KrServices::cmdExist("arj")) packers.append("arj");
     if (KrServices::cmdExist("unarj")) packers.append("unarj");
     if (KrServices::cmdExist("unace")) packers.append("unace");
     if (KrServices::cmdExist("dpkg")) packers.append("dpkg");
     if (KrServices::cmdExist("7z") || KrServices::cmdExist("7za")) packers.append("7z");
     if (KrServices::cmdExist("rpm") && KrServices::cmdExist("rpm2cpio")) packers.append("rpm");
     // qDebug() << "Supported Packers:";
     //QStringList::Iterator it;
     //for( it = packers.begin(); it != packers.end(); ++it )
     // qDebug() << *it;
 
     return packers;
 }
 
 bool KRarcHandler::arcSupported(QString type)
 {
     // lst will contain the supported unpacker list...
     const KConfigGroup group(krConfig, "Archives");
     const QStringList lst = group.readEntry("Supported Packers", QStringList());
 
     // Let's notice that in some cases the QString `type` that arrives here
     // represents a mimetype, and in some other cases it represents
     // a short identifier.
     // If `type` is not a short identifier then it's supposed that `type` is a mime type
     if (type.length() > maxLenType) {
         type = getShortTypeFromMime(type);
     }
 
     return (type == "zip" && lst.contains("unzip"))
            || (type == "tar" && lst.contains("tar"))
            || (type == "tbz" && lst.contains("tar"))
            || (type == "tgz" && lst.contains("tar"))
            || (type == "tlz" && lst.contains("tar"))
            || (type == "txz" && lst.contains("tar"))
            || (type == "tarz" && lst.contains("tar"))
            || (type == "gzip" && lst.contains("gzip"))
            || (type == "bzip2" && lst.contains("bzip2"))
            || (type == "lzma" && lst.contains("lzma"))
            || (type == "xz" && lst.contains("xz"))
            || (type == "lha" && lst.contains("lha"))
            || (type == "ace" && lst.contains("unace"))
            || (type == "rpm" && lst.contains("cpio"))
            || (type == "cpio" && lst.contains("cpio"))
            || (type == "rar" && (lst.contains("unrar") || lst.contains("rar")))
            || (type == "arj" && (lst.contains("unarj") || lst.contains("arj")))
            || (type == "deb" && (lst.contains("dpkg") && lst.contains("tar")))
            || (type == "7z" && lst.contains("7z"));
 }
 
-long KRarcHandler::arcFileCount(QString archive, QString type, QString password, KRarcObserver *observer)
+long KRarcHandler::arcFileCount(const QString& archive, const QString& type, const QString& password, KRarcObserver *observer)
 {
     int divideWith = 1;
 
     // first check if supported
     if (!arcSupported(type))
         return 0;
 
     // bzip2, gzip, etc. archives contain only one file
     if (type == "bzip2" || type == "gzip" || type == "lzma" || type == "xz")
         return 1L;
 
     // set the right lister to do the job
     QStringList lister;
 
     if (type == "zip") lister << KrServices::fullPathName("unzip") << "-ZTs";
     else if (type == "tar") lister << KrServices::fullPathName("tar") << "-tvf";
     else if (type == "tgz") lister << KrServices::fullPathName("tar") << "-tvzf";
     else if (type == "tarz") lister << KrServices::fullPathName("tar") << "-tvzf";
     else if (type == "tbz") lister << KrServices::fullPathName("tar") << "-tjvf";
     else if (type == "tlz") lister << KrServices::fullPathName("tar") << "--lzma" << "-tvf";
     else if (type == "txz") lister << KrServices::fullPathName("tar") << "--xz" << "-tvf";
     else if (type == "lha") lister << KrServices::fullPathName("lha") << "l";
     else if (type == "rar") lister << KrServices::fullPathName(KrServices::cmdExist("rar") ? "rar" : "unrar") << "l" << "-v";
     else if (type == "ace") lister << KrServices::fullPathName("unace") << "l";
     else if (type == "arj") {
         if (KrServices::cmdExist("arj"))
             lister << KrServices::fullPathName("arj") << "v" << "-y" << "-v",
             divideWith = 4;
         else
             lister << KrServices::fullPathName("unarj") << "l";
     } else if (type == "rpm") lister << KrServices::fullPathName("rpm") << "--dump" << "-lpq";
     else if (type == "deb") lister << KrServices::fullPathName("dpkg") << "-c";
     else if (type == "7z")  lister << KrServices::fullPathName("7z") << "-y" << "l";
     else return 0L;
 
     if (!password.isNull()) {
         if (type == "arj")
             lister << QString("-g%1").arg(password);
         if (type == "ace" || type == "rar" || type == "7z")
             lister << QString("-p%1").arg(password);
     }
 
     // tell the user to wait
     observer->subJobStarted(i18n("Counting files in archive"), 0);
 
     // count the number of files in the archive
     long count = 1;
     KProcess list;
     list << lister << archive;
     if (type == "ace" && QFile("/dev/ptmx").exists())     // Don't remove, unace crashes if missing!!!
         list.setStandardInputFile("/dev/ptmx");
     list.setOutputChannelMode(KProcess::SeparateChannels); // without this output redirection has no effect
     list.start();
     // TODO make use of asynchronous process starting. waitForStarted(int msec = 30000) is blocking
     // it would be better to connect to started(), error() and finished()
     if (list.waitForStarted()) while (list.state() == QProcess::Running) {
             observer->processEvents();
             if (observer->wasCancelled())
                 list.kill();
         }
     ; // busy wait - need to find something better...
 
     observer->subJobStopped();
 
     if (list.exitStatus() != QProcess::NormalExit || !checkStatus(type, list.exitCode())) {
         observer->detailedError(i18n("Failed to list the content of the archive (%1).", archive),
                                 QString::fromLocal8Bit(list.readAllStandardError()));
         return 0;
     }
 
     count = list.readAllStandardOutput().count('\n');
 
     //make sure you call stopWait after this function return...
     //  observer->subJobStopped();
 
     return count / divideWith;
 }
 
-bool KRarcHandler::unpack(QString archive, QString type, QString password, QString dest, KRarcObserver *observer)
+bool KRarcHandler::unpack(QString archive, const QString& type, const QString& password, const QString& dest, KRarcObserver *observer)
 {
     KConfigGroup group(krConfig, "Archives");
     if (group.readEntry("Test Before Unpack", _TestBeforeUnpack)) {
         // test first - or be sorry later...
         if (type != "rpm" && type != "deb" && !test(archive, type, password, observer, 0)) {
             observer->error(i18n("Failed to unpack %1.", archive));
             return false;
         }
     }
 
     // count the files in the archive
     long count = arcFileCount(archive, type, password, observer);
     if (count == 0)
         return false;   // not supported
     if (count == 1)
         count = 0;
 
     // choose the right packer for the job
     QString cpioName;
     QStringList packer;
 
     // set the right packer to do the job
     if (type == "zip") packer << KrServices::fullPathName("unzip") << "-o";
     else if (type == "tar") packer << KrServices::fullPathName("tar") << "-xvf";
     else if (type == "tgz") packer << KrServices::fullPathName("tar") << "-xvzf";
     else if (type == "tarz") packer << KrServices::fullPathName("tar") << "-xvzf";
     else if (type == "tbz") packer << KrServices::fullPathName("tar") << "-xjvf";
     else if (type == "tlz") packer << KrServices::fullPathName("tar") << "--lzma" << "-xvf";
     else if (type == "txz") packer << KrServices::fullPathName("tar") << "--xz" << "-xvf";
     else if (type == "gzip") packer << KrServices::fullPathName("gzip") << "-cd";
     else if (type == "bzip2") packer << KrServices::fullPathName("bzip2") << "-cdk";
     else if (type == "lzma") packer << KrServices::fullPathName("lzma") << "-cdk";
     else if (type == "xz")  packer << KrServices::fullPathName("xz") << "-cdk";
     else if (type == "lha") packer << KrServices::fullPathName("lha") << "xf";
     else if (type == "rar") packer << KrServices::fullPathName(KrServices::cmdExist("rar") ? "rar" : "unrar") << "-y" << "x";
     else if (type == "ace") packer << KrServices::fullPathName("unace") << "x";
     else if (type == "arj") {
         if (KrServices::cmdExist("arj"))
             packer << KrServices::fullPathName("arj") << "-y" << "-v" << "x";
         else
             packer << KrServices::fullPathName("unarj") << "x";
     } else if (type == "7z")  packer << KrServices::fullPathName("7z") << "-y" << "x";
     else if (type == "rpm") {
         // TODO use QTemporaryFile (setAutoRemove(false) when asynchrone)
         cpioName = QDir::tempPath() + QStringLiteral("/contents.cpio");
 
         KrLinecountingProcess cpio;
         cpio << KrServices::fullPathName("rpm2cpio") << archive;
         cpio.setStandardOutputFile(cpioName); // TODO maybe no tmpfile but a pipe (setStandardOutputProcess(packer))
         cpio.start();
         if (!cpio.waitForFinished() || cpio.exitStatus() != QProcess::NormalExit || !checkStatus("cpio", cpio.exitCode())) {
             observer->detailedError(i18n("Failed to convert rpm (%1) to cpio.", archive), cpio.getErrorMsg());
             return 0;
         }
 
         archive = cpioName;
         packer << KrServices::fullPathName("cpio") << "--force-local" << "--no-absolute-filenames" <<  "-iuvdF";
     } else if (type == "deb") {
         // TODO use QTemporaryFile (setAutoRemove(false) when asynchrone)
         cpioName = QDir::tempPath() + QStringLiteral("/contents.tar");
 
         KrLinecountingProcess dpkg;
         dpkg << KrServices::fullPathName("dpkg") << "--fsys-tarfile" << archive;
         dpkg.setStandardOutputFile(cpioName); // TODO maybe no tmpfile but a pipe (setStandardOutputProcess(packer))
         dpkg.start();
         if (!dpkg.waitForFinished() || dpkg.exitStatus() != QProcess::NormalExit || !checkStatus("deb", dpkg.exitCode())) {
             observer->detailedError(i18n("Failed to convert deb (%1) to tar.", archive), dpkg.getErrorMsg());
             return 0;
         }
 
         archive = cpioName;
         packer << KrServices::fullPathName("tar") << "xvf";
     } else return false;
 
     if (!password.isNull()) {
         if (type == "zip")
             packer << "-P" << password;
         if (type == "arj")
             packer << QString("-g%1").arg(password);
         if (type == "ace" || type == "rar" || type == "7z")
             packer << QString("-p%1").arg(password);
     }
 
     // unpack the files
     KrLinecountingProcess proc;
     proc << packer << archive;
     if (type == "bzip2" || type == "gzip" || type == "lzma" || type == "xz") {
         QString arcname = archive.mid(archive.lastIndexOf("/") + 1);
         if (arcname.contains(".")) arcname = arcname.left(arcname.lastIndexOf("."));
             proc.setStandardOutputFile(dest + '/' + arcname);
     }
     if (type == "ace" && QFile("/dev/ptmx").exists())    // Don't remove, unace crashes if missing!!!
         proc.setStandardInputFile("/dev/ptmx");
 
     proc.setWorkingDirectory(dest);
 
     // tell the user to wait
     observer->subJobStarted(i18n("Unpacking File(s)"), count);
     if (count != 0) {
         connect(&proc, &KrLinecountingProcess::newOutputLines, observer, &KRarcObserver::incrementProgress);
         if (type == "rpm")
             connect(&proc, &KrLinecountingProcess::newErrorLines, observer, &KRarcObserver::incrementProgress);
     }
 
     // start the unpacking process
     proc.start();
     // TODO make use of asynchronous process starting. waitForStarted(int msec = 30000) is blocking
     // it would be better to connect to started(), error() and finished()
     if (proc.waitForStarted())
         while (proc.state() == QProcess::Running) {
             observer->processEvents();
             if (observer->wasCancelled())
                 proc.kill();
         }
     ; // busy wait - need to find something better...
     observer->subJobStopped();
 
     if (!cpioName.isEmpty())
         QFile(cpioName).remove();      /* remove the cpio file */
 
     // check the return value
     if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(type, proc.exitCode())) {
         observer->detailedError(i18n("Failed to unpack %1.", archive),
                                 observer->wasCancelled() ? i18n("User cancelled.") : proc.getErrorMsg());
         return false;
     }
     return true; // SUCCESS
 }
 
-bool KRarcHandler::test(QString archive, QString type, QString password, KRarcObserver *observer, long count)
+bool KRarcHandler::test(const QString& archive, const QString& type, const QString& password, KRarcObserver *observer, long count)
 {
     // choose the right packer for the job
     QStringList packer;
 
     // set the right packer to do the job
     if (type == "zip") packer << KrServices::fullPathName("unzip") << "-t";
     else if (type == "tar") packer << KrServices::fullPathName("tar") << "-tvf";
     else if (type == "tgz") packer << KrServices::fullPathName("tar") << "-tvzf";
     else if (type == "tarz") packer << KrServices::fullPathName("tar") << "-tvzf";
     else if (type == "tbz") packer << KrServices::fullPathName("tar") << "-tjvf";
     else if (type == "tlz") packer << KrServices::fullPathName("tar") << "--lzma" << "-tvf";
     else if (type == "txz") packer << KrServices::fullPathName("tar") << "--xz" << "-tvf";
     else if (type == "gzip") packer << KrServices::fullPathName("gzip") << "-tv";
     else if (type == "bzip2") packer << KrServices::fullPathName("bzip2") << "-tv";
     else if (type == "lzma") packer << KrServices::fullPathName("lzma") << "-tv";
     else if (type == "xz")  packer << KrServices::fullPathName("xz") << "-tv";
     else if (type == "rar") packer << KrServices::fullPathName(KrServices::cmdExist("rar") ? "rar" : "unrar") << "t";
     else if (type == "ace") packer << KrServices::fullPathName("unace") << "t";
     else if (type == "lha") packer << KrServices::fullPathName("lha") << "t";
     else if (type == "arj") packer << KrServices::fullPathName(KrServices::cmdExist("arj") ? "arj" : "unarj") << "t";
     else if (type == "cpio") packer << KrServices::fullPathName("cpio") << "--only-verify-crc" << "-tvF";
     else if (type == "7z")  packer << KrServices::fullPathName("7z") << "-y" << "t";
     else return false;
 
     if (!password.isNull()) {
         if (type == "zip")
             packer << "-P" << password;
         if (type == "arj")
             packer << QString("-g%1").arg(password);
         if (type == "ace" || type == "rar" || type == "7z")
             packer << QString("-p%1").arg(password);
     }
 
     // unpack the files
     KrLinecountingProcess proc;
     proc << packer << archive;
 
     if (type == "ace" && QFile("/dev/ptmx").exists())    // Don't remove, unace crashes if missing!!!
         proc.setStandardInputFile("/dev/ptmx");
 
     // tell the user to wait
     observer->subJobStarted(i18n("Testing Archive"), count);
     if (count != 0)
         connect(&proc, &KrLinecountingProcess::newOutputLines, observer, &KRarcObserver::incrementProgress);
 
     // start the unpacking process
     proc.start();
     // TODO make use of asynchronous process starting. waitForStarted(int msec = 30000) is blocking
     // it would be better to connect to started(), error() and finished()
     if (proc.waitForStarted())
         while (proc.state() == QProcess::Running) {
             observer->processEvents();
             if (observer->wasCancelled())
                 proc.kill();
         }
     ; // busy wait - need to find something better...
     observer->subJobStopped();
 
     // check the return value
     if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(type, proc.exitCode()))
         return false;
 
     return true; // SUCCESS
 }
 
-bool KRarcHandler::pack(QStringList fileNames, QString type, QString dest, long count, QMap<QString, QString> extraProps, KRarcObserver *observer)
+bool KRarcHandler::pack(QStringList fileNames, QString type, const QString& dest, long count, QMap<QString, QString> extraProps, KRarcObserver *observer)
 {
     // set the right packer to do the job
     QStringList packer;
 
     if (type == "zip") {
         packer << KrServices::fullPathName("zip") << "-ry";
     } else if (type == "cbz") {
         packer << KrServices::fullPathName("zip") << "-ry";
         type = "zip";
     } else if (type == "tar") {
         packer << KrServices::fullPathName("tar") << "-cvf";
     } else if (type == "tar.gz") {
         packer << KrServices::fullPathName("tar") << "-cvzf";
         type = "tgz";
     } else if (type == "tar.bz2") {
         packer << KrServices::fullPathName("tar") << "-cvjf";
         type = "tbz";
     } else if (type == "tar.lzma") {
         packer << KrServices::fullPathName("tar") << "--lzma" << "-cvf";
         type = "tlz";
     } else if (type == "tar.xz") {
         packer << KrServices::fullPathName("tar") << "--xz" << "-cvf";
         type = "txz";
     } else if (type == "rar") {
         packer << KrServices::fullPathName("rar") << "-r" << "a";
     } else if (type == "cbr") {
         packer << KrServices::fullPathName("rar") << "-r" << "a";
         type = "rar";
     } else if (type == "lha") {
         packer << KrServices::fullPathName("lha") << "a";
     } else if (type == "arj") {
         packer << KrServices::fullPathName("arj") << "-r" << "-y" << "a";
     } else if (type == "7z") {
         packer << KrServices::fullPathName("7z") << "-y" << "a";
     } else return false;
 
     QString password;
 
     if (extraProps.count("Password") > 0) {
         password = extraProps[ "Password" ];
 
         if (!password.isNull()) {
             if (type == "zip")
                 packer << "-P" << password;
             else if (type == "arj")
                 packer << QString("-g%1").arg(password);
             else if (type == "ace" || type == "7z")
                 packer << QString("-p%1").arg(password);
             else if (type == "rar") {
                 if (extraProps.count("EncryptHeaders") > 0)
                     packer << QString("-hp%1").arg(password);
                 else
                     packer << QString("-p%1").arg(password);
             } else
                 password.clear();
         }
     }
 
     if (extraProps.count("VolumeSize") > 0) {
         QString sizeStr = extraProps[ "VolumeSize" ];
         KIO::filesize_t size = sizeStr.toLongLong();
 
         if (size >= 10000) {
             if (type == "arj" || type == "rar")
                 packer << QString("-v%1b").arg(sizeStr);
         }
     }
 
     if (extraProps.count("CompressionLevel") > 0) {
         int level = extraProps[ "CompressionLevel" ].toInt() - 1;
         if (level < 0)
             level = 0;
         if (level > 8)
             level = 8;
 
         if (type == "rar") {
             static const int rarLevels[] = { 0, 1, 2, 2, 3, 3, 4, 4, 5 };
             packer << QString("-m%1").arg(rarLevels[ level ]);
         } else if (type == "arj") {
             static const int arjLevels[] = { 0, 4, 4, 3, 3, 2, 2, 1, 1 };
             packer << QString("-m%1").arg(arjLevels[ level ]);
         } else if (type == "zip") {
             static const int zipLevels[] = { 0, 1, 2, 4, 5, 6, 7, 8, 9 };
             packer << QString("-%1").arg(zipLevels[ level ]);
         } else if (type == "7z") {
             static const int sevenZipLevels[] = { 0, 1, 2, 4, 5, 6, 7, 8, 9 };
             packer << QString("-mx%1").arg(sevenZipLevels[ level ]);
         }
     }
 
     if (extraProps.count("CommandLineSwitches") > 0)
         packer << QString("%1").arg(extraProps[ "CommandLineSwitches" ]);
 
     // prepare to pack
     KrLinecountingProcess proc;
     proc << packer << dest;
 
-    for (QStringList::Iterator file = fileNames.begin(); file != fileNames.end(); ++file) {
-        proc << *file;
+    for (auto & fileName : fileNames) {
+        proc << fileName;
     }
 
     // tell the user to wait
     observer->subJobStarted(i18n("Packing File(s)"), count);
     if (count != 0)
         connect(&proc, &KrLinecountingProcess::newOutputLines, observer, &KRarcObserver::incrementProgress);
 
     // start the packing process
     proc.start();
     // TODO make use of asynchronous process starting. waitForStarted(int msec = 30000) is blocking
     // it would be better to connect to started(), error() and finished()
     if (proc.waitForStarted())
         while (proc.state() == QProcess::Running) {
             observer->processEvents();
             if (observer->wasCancelled())
                 proc.kill();
         }
     ; // busy wait - need to find something better...
     observer->subJobStopped();
 
     // check the return value
     if (proc.exitStatus() != QProcess::NormalExit || !checkStatus(type, proc.exitCode())) {
         observer->detailedError(i18n("Failed to pack %1.", dest),
                                 observer->wasCancelled() ? i18n("User cancelled.") : proc.getErrorMsg());
         return false;
     }
 
     KConfigGroup group(krConfig, "Archives");
     if (group.readEntry("Test Archives", _TestArchives) &&
             !test(dest, type, password, observer, count)) {
         observer->error(i18n("Failed to pack %1.", dest));
         return false;
     }
     return true; // SUCCESS
 }
 
 bool KRarcHandler::openWallet()
 {
     if (!wallet) {
         // find a suitable parent window
         QWidget *actWindow = QApplication::activeWindow();
         if (!actWindow)
             actWindow = (QWidget*) QApplication::desktop();
 
         wallet = KWallet::Wallet::openWallet(KWallet::Wallet::NetworkWallet(), actWindow->effectiveWinId());
     }
-    return (wallet != 0);
+    return (wallet != nullptr);
 }
 
-QString KRarcHandler::getPassword(QString path)
+QString KRarcHandler::getPassword(const QString& path)
 {
     QString password;
 
     QString key = "krarc-" + path;
 
     if (!KWallet::Wallet::keyDoesNotExist(KWallet::Wallet::NetworkWallet(), KWallet::Wallet::PasswordFolder(), key)) {
-        if (!KWallet::Wallet::isOpen(KWallet::Wallet::NetworkWallet())  && wallet != 0) {
+        if (!KWallet::Wallet::isOpen(KWallet::Wallet::NetworkWallet())  && wallet != nullptr) {
             delete wallet;
-            wallet = 0;
+            wallet = nullptr;
         }
         if (openWallet() && wallet->hasFolder(KWallet::Wallet::PasswordFolder())) {
             wallet->setFolder(KWallet::Wallet::PasswordFolder());
             QMap<QString, QString> map;
             if (wallet->readMap(key, map) == 0) {
                 QMap<QString, QString>::const_iterator it = map.constFind("password");
                 if (it != map.constEnd())
                     password = it.value();
             }
         }
     }
 
     bool keep = true;
     QString user = "archive";
-    QPointer<KPasswordDialog> passDlg = new KPasswordDialog(0L, KPasswordDialog::ShowKeepPassword);
+    QPointer<KPasswordDialog> passDlg = new KPasswordDialog(nullptr, KPasswordDialog::ShowKeepPassword);
             passDlg->setPrompt(i18n("This archive is encrypted, please supply the password:") ),
             passDlg->setUsername(user);
     passDlg->setPassword(password);
     if (passDlg->exec() == KPasswordDialog::Accepted) {
         password = passDlg->password();
         if (keep) {
-            if (!KWallet::Wallet::isOpen(KWallet::Wallet::NetworkWallet()) && wallet != 0) {
+            if (!KWallet::Wallet::isOpen(KWallet::Wallet::NetworkWallet()) && wallet != nullptr) {
                 delete wallet;
-                wallet = 0;
+                wallet = nullptr;
             }
             if (openWallet()) {
                 bool ok = true;
                 if (!wallet->hasFolder(KWallet::Wallet::PasswordFolder()))
                     ok = wallet->createFolder(KWallet::Wallet::PasswordFolder());
                 if (ok) {
                     wallet->setFolder(KWallet::Wallet::PasswordFolder());
                     QMap<QString, QString> map;
                     map.insert("login", "archive");
                     map.insert("password", password);
                     wallet->writeMap(key, map);
                 }
             }
         }
         delete passDlg;
         return password;
     }
     delete passDlg;
 
     return "";
 }
 
 bool KRarcHandler::isArchive(const QUrl &url)
 {
     QString protocol = url.scheme();
     if (arcProtocols.indexOf(protocol) != -1)
         return true;
     else return false;
 }
 
-QString KRarcHandler::getType(bool &encrypted, QString fileName, QString mime, bool checkEncrypted, bool fast)
+QString KRarcHandler::getType(bool &encrypted, QString fileName, const QString& mime, bool checkEncrypted, bool fast)
 {
-    QString result = detectArchive(encrypted, fileName, checkEncrypted, fast);
+    QString result = detectArchive(encrypted, std::move(fileName), checkEncrypted, fast);
     if (result.isNull()) {
         // Then the type is based on the mime type
         return getShortTypeFromMime(mime);
     }
     return result;
 }
 
-bool KRarcHandler::checkStatus(QString type, int exitCode)
+bool KRarcHandler::checkStatus(const QString& type, int exitCode)
 {
     return KrArcBaseManager::checkStatus(type, exitCode);
 }
 
 void KRarcHandler::checkIf7zIsEncrypted(bool &encrypted, QString fileName)
 {
     Kr7zEncryptionChecker proc;
     // TODO incorporate all this in Kr7zEncryptionChecker
     proc << KrServices::fullPathName("7z") << "-y" << "t";
     proc << fileName;
     proc.start();
     proc.waitForFinished();
     encrypted = proc.isEncrypted();
 }
 
diff --git a/krusader/Archive/krarchandler.h b/krusader/Archive/krarchandler.h
index a5bbd6e8..7e641bd6 100644
--- a/krusader/Archive/krarchandler.h
+++ b/krusader/Archive/krarchandler.h
@@ -1,87 +1,87 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #ifndef KRARCHANDLER_H
 #define KRARCHANDLER_H
 
 // QtCore
 #include <QStringList>
 #include <QObject>
 #include <QUrl>
 
 #include <KCoreAddons/KProcess>
 
 #include "../../krArc/krarcbasemanager.h"
 
 namespace KWallet {
 class Wallet;
 }
 
 class KRarcObserver : public QObject
 {
     Q_OBJECT
 public:
-    virtual ~KRarcObserver() {}
+    ~KRarcObserver() override = default;
 
     virtual void processEvents() = 0;
     virtual void subJobStarted(const QString & jobTitle, int count) = 0;
     virtual void subJobStopped() = 0;
     virtual bool wasCancelled() = 0;
     virtual void error(const QString & error) = 0;
     virtual void detailedError(const QString & error, const QString & details) = 0;
 
 public slots:
     virtual void incrementProgress(int) = 0;
 };
 
 class KRarcHandler: public QObject, public KrArcBaseManager
 {
     Q_OBJECT
 public:
     // return the number of files in the archive
-    static long arcFileCount(QString archive, QString type, QString password, KRarcObserver *observer);
+    static long arcFileCount(const QString& archive, const QString& type, const QString& password, KRarcObserver *observer);
     // unpack an archive to destination directory
-    static bool unpack(QString archive, QString type, QString password, QString dest, KRarcObserver *observer );
+    static bool unpack(QString archive, const QString& type, const QString& password, const QString& dest, KRarcObserver *observer );
     // pack an archive to destination directory
-    static bool pack(QStringList fileNames, QString type, QString dest, long count, QMap<QString, QString> extraProps, KRarcObserver *observer );
+    static bool pack(QStringList fileNames, QString type, const QString& dest, long count, QMap<QString, QString> extraProps, KRarcObserver *observer );
     // test an archive
-    static bool test(QString archive, QString type, QString password, KRarcObserver *observer, long count = 0L );
+    static bool test(const QString& archive, const QString& type, const QString& password, KRarcObserver *observer, long count = 0L );
     // returns `true` if the right unpacker exist in the system
     static bool arcSupported(QString type);
     // return the list of supported packers
     static QStringList supportedPackers();
     // returns `true` if the url is an archive (ie: tar:/home/test/file.tar.bz2)
     static bool isArchive(const QUrl &url);
     // used to determine the type of the archive
-    QString getType(bool &encrypted, QString fileName, QString mime, bool checkEncrypted = true, bool fast = false);
+    QString getType(bool &encrypted, QString fileName, const QString& mime, bool checkEncrypted = true, bool fast = false);
     // queries the password from the user
-    static QString getPassword(QString path);
+    static QString getPassword(const QString& path);
     // detects the archive type
     void checkIf7zIsEncrypted(bool &, QString) Q_DECL_OVERRIDE;
 private:
     //! checks if a returned status ("exit code") of an archiving-related process is OK
-    static bool checkStatus(QString type, int exitCode);
+    static bool checkStatus(const QString& type, int exitCode);
 
     static bool openWallet();
 
     static KWallet::Wallet * wallet;
 };
 
 #endif
diff --git a/krusader/Archive/packjob.cpp b/krusader/Archive/packjob.cpp
index 8409238e..4e4f413a 100644
--- a/krusader/Archive/packjob.cpp
+++ b/krusader/Archive/packjob.cpp
@@ -1,169 +1,169 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "packjob.h"
 #include "krarchandler.h"
 
 // QtCore
 #include <QDir>
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <QTimer>
 
 #include <KI18n/KLocalizedString>
 
 extern KRarcHandler arcHandler;
 
-PackJob::PackJob(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames, const QString &type, const QMap<QString, QString> &packProps) : AbstractThreadedJob()
+PackJob::PackJob(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames, const QString &type, const QMap<QString, QString> &packProps)
 {
     startAbstractJobThread(new PackThread(srcUrl, destUrl, fileNames, type, packProps));
 }
 
 PackJob * PackJob::createPacker(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames, const QString &type, const QMap<QString, QString> &packProps)
 {
     return new PackJob(srcUrl, destUrl, fileNames, type, packProps);
 }
 
 PackThread::PackThread(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames,
                        const QString &type, const QMap<QString, QString> &packProps) :
-        AbstractJobThread(), _sourceUrl(srcUrl), _destUrl(destUrl), _fileNames(fileNames),
+        _sourceUrl(srcUrl), _destUrl(destUrl), _fileNames(fileNames),
         _type(type), _packProperties(packProps)
 {
 }
 
 
 void PackThread::slotStart()
 {
     QUrl newSource = downloadIfRemote(_sourceUrl, _fileNames);
     if (newSource.isEmpty())
         return;
 
     unsigned long totalFiles = 0;
 
     countLocalFiles(newSource, _fileNames, totalFiles);
 
     QString arcFile = tempFileIfRemote(_destUrl, _type);
     QString arcDir = newSource.adjusted(QUrl::StripTrailingSlash).path();
 
     setProgressTitle(i18n("Processed files"));
 
     QString save = QDir::currentPath();
     QDir::setCurrent(arcDir);
     bool result = KRarcHandler::pack(_fileNames, _type, arcFile, totalFiles, _packProperties, observer());
     QDir::setCurrent(save);
 
     if (isExited())
         return;
     if (!result) {
         sendError(KIO::ERR_INTERNAL, i18n("Error while packing"));
         return;
     }
 
     if (!uploadTempFiles())
         return;
 
     sendSuccess();
 }
 
-TestArchiveJob::TestArchiveJob(const QUrl &srcUrl, const QStringList & fileNames) : AbstractThreadedJob()
+TestArchiveJob::TestArchiveJob(const QUrl &srcUrl, const QStringList & fileNames)
 {
     startAbstractJobThread(new TestArchiveThread(srcUrl, fileNames));
 }
 
 TestArchiveJob * TestArchiveJob::testArchives(const QUrl &srcUrl, const QStringList & fileNames)
 {
     return new TestArchiveJob(srcUrl, fileNames);
 }
 
-TestArchiveThread::TestArchiveThread(const QUrl &srcUrl, const QStringList & fileNames) : AbstractJobThread(),
+TestArchiveThread::TestArchiveThread(const QUrl &srcUrl, const QStringList & fileNames) :
         _sourceUrl(srcUrl), _fileNames(fileNames)
 {
 }
 
 void TestArchiveThread::slotStart()
 {
     // Gets a QUrl of the source folder, which may be remote
     QUrl newSource = downloadIfRemote(_sourceUrl, _fileNames);
     if (newSource.isEmpty())
         return;
 
     for (int i = 0; i < _fileNames.count(); ++i) {
         QString path, type, password, arcName = _fileNames[i];
         if (!getArchiveInformation(path, type, password, arcName, newSource))
             return;
 
         // test the archive
         if (!KRarcHandler::test(path, type, password, observer(), 0)) {
             sendError(KIO::ERR_NO_CONTENT, i18nc("%1=archive filename", "%1, test failed.", arcName));
             return;
         }
     }
 
     sendMessage(i18n("Archive tests passed."));
     sendSuccess();
 }
 
 
-UnpackJob::UnpackJob(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames) : AbstractThreadedJob()
+UnpackJob::UnpackJob(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames)
 {
     startAbstractJobThread(new UnpackThread(srcUrl, destUrl, fileNames));
 }
 
 UnpackJob * UnpackJob::createUnpacker(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames)
 {
     return new UnpackJob(srcUrl, destUrl, fileNames);
 }
 
 UnpackThread::UnpackThread(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames) :
-        AbstractJobThread(), _sourceUrl(srcUrl), _destUrl(destUrl), _fileNames(fileNames)
+        _sourceUrl(srcUrl), _destUrl(destUrl), _fileNames(fileNames)
 {
 }
 
 void UnpackThread::slotStart()
 {
     // Gets a QUrl of the source folder, which may be remote
     QUrl newSource = downloadIfRemote(_sourceUrl, _fileNames);
     if (newSource.isEmpty())
         return;
 
     QString localDest = tempDirIfRemote(_destUrl);
 
     for (int i = 0; i < _fileNames.count(); ++i) {
         QString path, type, password, arcName = _fileNames[i];
         if (!getArchiveInformation(path, type, password, arcName, newSource))
             return;
 
         setProgressTitle(i18n("Processed files"));
         // unpack the files
         bool result = KRarcHandler::unpack(path, type, password, localDest, observer());
 
         if (isExited())
             return;
         if (!result) {
             sendError(KIO::ERR_INTERNAL, i18n("Error while unpacking"));
             return;
         }
     }
 
     if (!uploadTempFiles())
         return;
 
     sendSuccess();
 }
diff --git a/krusader/Archive/packjob.h b/krusader/Archive/packjob.h
index 4d7cab5a..4c40e4be 100644
--- a/krusader/Archive/packjob.h
+++ b/krusader/Archive/packjob.h
@@ -1,125 +1,125 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef PACKJOB_H
 #define PACKJOB_H
 
 // QtCore
 #include <QMap>
 
 #include "abstractthreadedjob.h"
 
 class PackThread;
 class TestArchiveThread;
 class UnpackThread;
 
 class PackJob : public AbstractThreadedJob
 {
     Q_OBJECT
 
 private:
     PackJob(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames, const QString &type, const QMap<QString, QString> &packProps);
 
 public:
     static PackJob * createPacker(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames, const QString &type, const QMap<QString, QString> &packProps);
 };
 
 
 class PackThread : public AbstractJobThread
 {
     Q_OBJECT
 
 public:
     PackThread(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames, const QString &type, const QMap<QString, QString> &packProps);
-    virtual ~PackThread() {}
+    ~PackThread() override = default;
 
 protected slots:
-    virtual void slotStart() Q_DECL_OVERRIDE;
+    void slotStart() Q_DECL_OVERRIDE;
 
 private:
     QUrl                   _sourceUrl;
     QUrl                   _destUrl;
     QStringList            _fileNames;
     QString                _type;
     QMap<QString, QString> _packProperties;
 };
 
 
 class TestArchiveJob : public AbstractThreadedJob
 {
     Q_OBJECT
 
 private:
     TestArchiveJob(const QUrl &srcUrl, const QStringList & fileNames);
 
 public:
     static TestArchiveJob * testArchives(const QUrl &srcUrl, const QStringList & fileNames);
 };
 
 
 class TestArchiveThread : public AbstractJobThread
 {
     Q_OBJECT
 
 public:
     TestArchiveThread(const QUrl &srcUrl, const QStringList & fileNames);
-    virtual ~TestArchiveThread() {}
+    ~TestArchiveThread() override = default;
 
 protected slots:
-    virtual void slotStart() Q_DECL_OVERRIDE;
+    void slotStart() Q_DECL_OVERRIDE;
 
 private:
     QUrl                   _sourceUrl;
     QStringList            _fileNames;
 };
 
 
 
 class UnpackJob : public AbstractThreadedJob
 {
     Q_OBJECT
 
 private:
     UnpackJob(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames);
 
 public:
     static UnpackJob * createUnpacker(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames);
 };
 
 
 class UnpackThread : public AbstractJobThread
 {
     Q_OBJECT
 
 public:
     UnpackThread(const QUrl &srcUrl, const QUrl &destUrl, const QStringList & fileNames);
-    virtual ~UnpackThread() {}
+    ~UnpackThread() override = default;
 
 protected slots:
-    virtual void slotStart() Q_DECL_OVERRIDE;
+    void slotStart() Q_DECL_OVERRIDE;
 
 private:
     QUrl                   _sourceUrl;
     QUrl                   _destUrl;
     QStringList            _fileNames;
 };
 
 #endif // __PACK_JOB_H__
 
diff --git a/krusader/BookMan/kraddbookmarkdlg.cpp b/krusader/BookMan/kraddbookmarkdlg.cpp
index 99adaed5..21b69c60 100644
--- a/krusader/BookMan/kraddbookmarkdlg.cpp
+++ b/krusader/BookMan/kraddbookmarkdlg.cpp
@@ -1,186 +1,186 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kraddbookmarkdlg.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "krbookmarkhandler.h"
 
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QHeaderView>
 #include <QGridLayout>
 #include <QInputDialog>
 #include <QLabel>
 #include <QPushButton>
 
 #include <KI18n/KLocalizedString>
 
 
-KrAddBookmarkDlg::KrAddBookmarkDlg(QWidget *parent, QUrl url):
+KrAddBookmarkDlg::KrAddBookmarkDlg(QWidget *parent, const QUrl& url):
         QDialog(parent)
 {
     setWindowModality(Qt::WindowModal);
     setWindowTitle(i18n("Add Bookmark"));
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
-    QGridLayout *layout = new QGridLayout; // expanding
+    auto *layout = new QGridLayout; // expanding
     // name and url
     QLabel *lb1 = new QLabel(i18n("Name:"), this);
     _name = new KLineEdit(this);
     _name->setText(url.toDisplayString()); // default name is the url
     _name->selectAll(); // make the text selected
     layout->addWidget(lb1, 0, 0);
     layout->addWidget(_name, 0, 1);
 
     QLabel *lb2 = new QLabel(i18n("URL:"), this);
     _url = new KLineEdit(this);
     layout->addWidget(lb2, 1, 0);
     layout->addWidget(_url, 1, 1);
     _url->setText(url.toDisplayString()); // set the url in the field
 
     // create in linedit and button
     QLabel *lb3 = new QLabel(i18n("Create in:"), this);
     _folder = new KLineEdit(this);
     layout->addWidget(lb3, 2, 0);
     layout->addWidget(_folder, 2, 1);
     _folder->setReadOnly(true);
 
     _createInBtn = new QToolButton(this);
     _createInBtn->setIcon(Icon("go-down"));
     _createInBtn->setCheckable(true);
     connect(_createInBtn, &QToolButton::toggled, this, &KrAddBookmarkDlg::toggleCreateIn);
     layout->addWidget(_createInBtn, 2, 2);
 
     mainLayout->addLayout(layout);
 
     detailsWidget = createInWidget();
     detailsWidget->setVisible(false);
     mainLayout->addWidget(detailsWidget);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     mainLayout->addWidget(buttonBox);
 
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     newFolderButton = new QPushButton(i18n("New Folder"));
     buttonBox->addButton(newFolderButton, QDialogButtonBox::ActionRole);
     newFolderButton->setVisible(false);// hide it until _createIn is shown
     connect(newFolderButton, &QPushButton::clicked, this, &KrAddBookmarkDlg::newFolder);
 
     connect(buttonBox, &QDialogButtonBox::accepted, this, &KrAddBookmarkDlg::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KrAddBookmarkDlg::reject);
 
     _name->setFocus();
     resize(sizeHint().width() * 2, sizeHint().height());
 }
 
 void KrAddBookmarkDlg::toggleCreateIn(bool show)
 {
     _createInBtn->setIcon(Icon(show ? "go-up" : "go-down"));
     newFolderButton->setVisible(show);
     detailsWidget->setVisible(show);
 }
 
 // creates the widget that lets you decide where to put the new bookmark
 QWidget *KrAddBookmarkDlg::createInWidget()
 {
     _createIn = new KrTreeWidget(this);
     _createIn->setHeaderLabel(i18n("Folders"));
     _createIn->header()->hide();
     _createIn->setRootIsDecorated(true);
     _createIn->setAlternatingRowColors(false);   // disable alternate coloring
 
-    QTreeWidgetItem *item = new QTreeWidgetItem(_createIn);
+    auto *item = new QTreeWidgetItem(_createIn);
     item->setText(0, i18n("Bookmarks"));
     _createIn->expandItem(item);
     item->setSelected(true);
     _xr[item] = krBookMan->_root;
 
     populateCreateInWidget(krBookMan->_root, item);
     _createIn->setCurrentItem(item);
     slotSelectionChanged();
     connect(_createIn, &KrTreeWidget::itemSelectionChanged, this, &KrAddBookmarkDlg::slotSelectionChanged);
 
     return _createIn;
 }
 
 void KrAddBookmarkDlg::slotSelectionChanged()
 {
     QList<QTreeWidgetItem *> items = _createIn->selectedItems();
 
     if (items.count() > 0) {
         _folder->setText(_xr[ items[ 0 ] ]->text());
     }
 }
 
 void KrAddBookmarkDlg::populateCreateInWidget(KrBookmark *root, QTreeWidgetItem *parent)
 {
     QListIterator<KrBookmark *> it(root->children());
     while (it.hasNext()) {
         KrBookmark *bm = it.next();
         if (bm->isFolder()) {
-            QTreeWidgetItem *item = new QTreeWidgetItem(parent);
+            auto *item = new QTreeWidgetItem(parent);
             item->setText(0, bm->text());
             item->treeWidget()->expandItem(item);
             _xr[item] = bm;
             populateCreateInWidget(bm, item);
         }
     }
 }
 
 void KrAddBookmarkDlg::newFolder()
 {
     // get the name
     QString newFolder = QInputDialog::getText(this, i18n("New Folder"), i18n("Folder name:"));
     if (newFolder.isEmpty()) {
         return;
     }
 
     QList<QTreeWidgetItem *> items = _createIn->selectedItems();
     if (items.count() == 0)
         return;
 
     // add to the list in bookman
     KrBookmark *bm = new KrBookmark(newFolder);
 
     krBookMan->addBookmark(bm, _xr[ items[ 0 ]]);
     // fix the gui
-    QTreeWidgetItem *item = new QTreeWidgetItem(items[ 0 ]);
+    auto *item = new QTreeWidgetItem(items[ 0 ]);
     item->setText(0, bm->text());
     _xr[item] = bm;
 
     _createIn->setCurrentItem(item);
     item->setSelected(true);
 }
 
 KrBookmark * KrAddBookmarkDlg::folder() const
 {
     QList<QTreeWidgetItem *> items = _createIn->selectedItems();
     if (items.count() == 0)
-        return 0;
+        return nullptr;
 
     return _xr[ items[ 0 ] ];
 }
 
diff --git a/krusader/BookMan/kraddbookmarkdlg.h b/krusader/BookMan/kraddbookmarkdlg.h
index 7997cae6..730eebe9 100644
--- a/krusader/BookMan/kraddbookmarkdlg.h
+++ b/krusader/BookMan/kraddbookmarkdlg.h
@@ -1,70 +1,70 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRADDBOOKMARKDLG_H
 #define KRADDBOOKMARKDLG_H
 
 #include "krbookmark.h"
 #include "../GUI/krtreewidget.h"
 
 // QtCore
 #include <QMap>
 #include <QUrl>
 // QtWidgets
 #include <QDialog>
 #include <QToolButton>
 
 #include <KCompletion/KLineEdit>
 
 class KrAddBookmarkDlg: public QDialog
 {
     Q_OBJECT
 public:
-    explicit KrAddBookmarkDlg(QWidget *parent, QUrl url = QUrl());
+    explicit KrAddBookmarkDlg(QWidget *parent, const QUrl& url = QUrl());
     QUrl url() const {
         return QUrl::fromUserInput(_url->text(), QString(), QUrl::AssumeLocalFile);
     }
     QString name() const {
         return _name->text();
     }
     KrBookmark *folder() const;
 
 protected:
     QWidget *createInWidget();
     void populateCreateInWidget(KrBookmark *root, QTreeWidgetItem *parent);
 
 protected slots:
     void toggleCreateIn(bool show);
     void slotSelectionChanged();
     void newFolder();
 
 private:
     KLineEdit *_name;
     KLineEdit *_url;
     KLineEdit *_folder;
     KrTreeWidget *_createIn;
     QMap<QTreeWidgetItem*, KrBookmark*> _xr;
     QToolButton *_createInBtn;
     QPushButton *newFolderButton;
     QWidget *detailsWidget;
 };
 
 #endif // KRADDBOOKMARKDLG_H
diff --git a/krusader/BookMan/krbookmark.cpp b/krusader/BookMan/krbookmark.cpp
index 7fe631c2..5575927f 100644
--- a/krusader/BookMan/krbookmark.cpp
+++ b/krusader/BookMan/krbookmark.cpp
@@ -1,151 +1,152 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krbookmark.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../Archive/krarchandler.h"
 #include "../FileSystem/krtrashhandler.h"
 #include "../Panel/listpanelactions.h"
 
 #include <KI18n/KLocalizedString>
 #include <KXmlGui/KActionCollection>
+#include <utility>
 
 #define BM_NAME(X)  (QString("Bookmark:")+X)
 
 static const char* NAME_TRASH = I18N_NOOP("Trash bin");
 static const char* NAME_VIRTUAL = I18N_NOOP("Virtual Filesystem");
 static const char* NAME_LAN = I18N_NOOP("Local Network");
 
-KrBookmark::KrBookmark(QString name, QUrl url, KActionCollection *parent, QString iconName, QString actionName) :
-        QAction(parent), _url(url), _iconName(iconName), _folder(false), _separator(false), _autoDelete(true)
+KrBookmark::KrBookmark(const QString& name, QUrl url, KActionCollection *parent, const QString& iconName, const QString& actionName) :
+        QAction(parent), _url(std::move(url)), _iconName(iconName), _folder(false), _separator(false), _autoDelete(true)
 {
     QString actName = actionName.isNull() ? BM_NAME(name) : BM_NAME(actionName);
     setText(name);
     parent->addAction(actName, this);
     connect(this, &KrBookmark::triggered, this, &KrBookmark::activatedProxy);
 
     setIconName(iconName);
 }
 
-KrBookmark::KrBookmark(QString name, QString iconName) :
-        QAction(Icon(iconName), name, 0), _iconName(iconName), _folder(true), _separator(false), _autoDelete(false)
+KrBookmark::KrBookmark(const QString& name, const QString& iconName) :
+        QAction(Icon(iconName), name, nullptr), _iconName(iconName), _folder(true), _separator(false), _autoDelete(false)
 {
     setIcon(Icon(iconName == "" ? "folder" : iconName));
 }
 
 KrBookmark::~KrBookmark()
 {
     if (_autoDelete) {
         QListIterator<KrBookmark *> it(_children);
         while (it.hasNext())
             delete it.next();
         _children.clear();
     }
 }
 
-void KrBookmark::setIconName(QString iconName)
+void KrBookmark::setIconName(const QString& iconName)
 {
     if (!iconName.isEmpty()) {
         setIcon(Icon(iconName));
     } else if (_url.isLocalFile()) {
         setIcon(Icon("folder"));
     } else if (KRarcHandler::isArchive(_url)) {
         setIcon(Icon("application-x-tar"));
     } else {
         setIcon(Icon("folder-html"));
     }
 }
 
-KrBookmark * KrBookmark::getExistingBookmark(QString actionName, KActionCollection *collection)
+KrBookmark * KrBookmark::getExistingBookmark(const QString& actionName, KActionCollection *collection)
 {
-    return static_cast<KrBookmark*>(collection->action(BM_NAME(actionName)));
+    return dynamic_cast<KrBookmark*>(collection->action(BM_NAME(actionName)));
 }
 
 KrBookmark * KrBookmark::trash(KActionCollection *collection)
 {
     KrBookmark *bm = getExistingBookmark(i18n(NAME_TRASH), collection);
     if (!bm)
         bm = new KrBookmark(i18n(NAME_TRASH), QUrl("trash:/"), collection);
 
     bm->setIcon(Icon(KrTrashHandler::trashIconName()));
     return bm;
 }
 
 KrBookmark * KrBookmark::virt(KActionCollection *collection)
 {
     KrBookmark *bm = getExistingBookmark(i18n(NAME_VIRTUAL), collection);
     if (!bm) {
         bm = new KrBookmark(i18n(NAME_VIRTUAL), QUrl("virt:/"), collection);
         bm->setIcon(Icon("document-open-remote"));
     }
     return bm;
 }
 
 KrBookmark * KrBookmark::lan(KActionCollection *collection)
 {
     KrBookmark *bm = getExistingBookmark(i18n(NAME_LAN), collection);
     if (!bm) {
         bm = new KrBookmark(i18n(NAME_LAN), QUrl("remote:/"), collection);
         bm->setIcon(Icon("network-workgroup"));
     }
     return bm;
 }
 
 QAction * KrBookmark::jumpBackAction(KActionCollection *collection, bool isSetter, ListPanelActions *sourceActions)
 {
     auto actionName = isSetter ? QString("setJumpBack") : QString("jumpBack");
     auto action = collection->action(actionName);
     if (action) {
         return action;
     }
 
     if (!sourceActions) {
         return nullptr;
     }
 
     // copy essential part of source action
     auto sourceAction = isSetter ? sourceActions->actSetJumpBack : sourceActions->actJumpBack;
     action = new QAction(sourceAction->icon(), sourceAction->text(), sourceAction);
     action->setShortcut(sourceAction->shortcut());
     action->setShortcutContext(Qt::WidgetShortcut);
     connect(action, &QAction::triggered, sourceAction, &QAction::trigger);
     // ensure there are no accelerator keys coming from another menu
     action->setText(KLocalizedString::removeAcceleratorMarker(action->text()));
 
     collection->addAction(actionName, action);
     return action;
 }
 
 KrBookmark * KrBookmark::separator()
 {
     KrBookmark *bm = new KrBookmark("");
     bm->_separator = true;
     bm->_folder = false;
     return bm;
 }
 
 
 void KrBookmark::activatedProxy()
 {
     emit activated(url());
 }
 
diff --git a/krusader/BookMan/krbookmark.h b/krusader/BookMan/krbookmark.h
index 58353bfb..561c68f2 100644
--- a/krusader/BookMan/krbookmark.h
+++ b/krusader/BookMan/krbookmark.h
@@ -1,93 +1,93 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRBOOKMARK_H
 #define KRBOOKMARK_H
 
 // QtCore
 #include <QList>
 #include <QUrl>
 // QtWidgets
 #include <QAction>
 
 class KActionCollection;
 class ListPanelActions;
 
 
 class KrBookmark: public QAction
 {
     Q_OBJECT
 public:
-    KrBookmark(QString name, QUrl url, KActionCollection *parent, QString iconName = "", QString actionName = QString());
-    explicit KrBookmark(QString name, QString iconName = ""); // creates a folder
-    ~KrBookmark();
+    KrBookmark(const QString& name, QUrl url, KActionCollection *parent, const QString& iconName = "", const QString& actionName = QString());
+    explicit KrBookmark(const QString& name, const QString& iconName = ""); // creates a folder
+    ~KrBookmark() override;
 
     // text() and setText() to change the name of the bookmark
     // icon() and setIcon() to change icons
 
-    void setIconName(QString iconName);
+    void setIconName(const QString& iconName);
 
     inline const QString& iconName() const {
         return _iconName;
     }
 
     inline const QUrl &url() const {
         return _url;
     }
     inline void setURL(const QUrl &url) {
         _url = url;
     }
     inline bool isFolder() const {
         return _folder;
     }
     inline bool isSeparator() const {
         return _separator;
     }
     QList<KrBookmark *>& children() {
         return _children;
     }
 
-    static KrBookmark * getExistingBookmark(QString actionName, KActionCollection *collection);
+    static KrBookmark * getExistingBookmark(const QString& actionName, KActionCollection *collection);
 
     // ----- special bookmarks
     static KrBookmark * trash(KActionCollection *collection);
     static KrBookmark * virt(KActionCollection *collection);
     static KrBookmark * lan(KActionCollection *collection);
-    static QAction * jumpBackAction(KActionCollection *collection, bool isSetter = false, ListPanelActions *sourceActions = 0);
+    static QAction * jumpBackAction(KActionCollection *collection, bool isSetter = false, ListPanelActions *sourceActions = nullptr);
     static KrBookmark * separator();
 
 signals:
     void activated(const QUrl &url);
 
 protected slots:
     void activatedProxy();
 
 
 private:
     QUrl _url;
     QString _iconName;
     bool _folder;
     bool _separator;
     bool _autoDelete;
     QList<KrBookmark *> _children;
 };
 
 #endif // KRBOOKMARK_H
diff --git a/krusader/BookMan/krbookmarkhandler.cpp b/krusader/BookMan/krbookmarkhandler.cpp
index 5b34d673..d7bfad17 100644
--- a/krusader/BookMan/krbookmarkhandler.cpp
+++ b/krusader/BookMan/krbookmarkhandler.cpp
@@ -1,881 +1,881 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krbookmarkhandler.h"
 #include "kraddbookmarkdlg.h"
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../krslots.h"
 #include "../kractions.h"
 #include "../krmainwindow.h"
 #include "../Dialogs/popularurls.h"
 #include "../FileSystem/filesystem.h"
 #include "../Panel/krpanel.h"
 #include "../Panel/listpanelactions.h"
 
 // QtCore
 #include <QTextStream>
 #include <QFile>
 #include <QEvent>
 #include <QStandardPaths>
 #include <QDebug>
 #include <QTimer>
 // QtGui
 #include <QMouseEvent>
 #include <QCursor>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 #include <KXmlGui/KActionCollection>
 #include <KBookmarks/KBookmarkManager>
+#include <utility>
 
 #define SPECIAL_BOOKMARKS true
 
 // ------------------------ for internal use
 #define BOOKMARKS_FILE "krusader/krbookmarks.xml"
 #define CONNECT_BM(X) { disconnect(X, SIGNAL(activated(QUrl)), 0, 0); connect(X, SIGNAL(activated(QUrl)), this, SLOT(slotActivated(QUrl))); }
 
 KrBookmarkHandler::KrBookmarkHandler(KrMainWindow *mainWindow) :
     QObject(mainWindow->widget()),
     _mainWindow(mainWindow),
     _middleClick(false),
-    _mainBookmarkPopup(0),
-    _specialBookmarks(),
+    _mainBookmarkPopup(nullptr),
     _quickSearchAction(nullptr),
     _quickSearchBar(nullptr),
     _quickSearchMenu(nullptr)
 {
     // create our own action collection and make the shortcuts apply only to parent
     _privateCollection = new KActionCollection(this);
     _collection = _mainWindow->actions();
 
     // create _root: father of all bookmarks. it is a dummy bookmark and never shown
     _root = new KrBookmark(i18n("Bookmarks"));
     _root->setParent(this);
 
     // load bookmarks
     importFromFile();
 
     // create bookmark manager
     QString filename = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + BOOKMARKS_FILE;
     manager = KBookmarkManager::managerForFile(filename, QStringLiteral("krusader"));
     connect(manager, &KBookmarkManager::changed, this, &KrBookmarkHandler::bookmarksChanged);
 
     // create the quick search bar and action
     _quickSearchAction = new QWidgetAction(this);
     _quickSearchBar = new QLineEdit();
     _quickSearchBar->setPlaceholderText(i18n("Type to search..."));
     _quickSearchAction->setDefaultWidget(_quickSearchBar);  // ownership of the bar is transferred to the action
     _quickSearchAction->setEnabled(false);
     _setQuickSearchText("");
 
     // fill a dummy menu to properly init actions (allows toolbar bookmark buttons to work properly)
     auto menu = new QMenu(mainWindow->widget());
     populate(menu);
     menu->deleteLater();
 }
 
 KrBookmarkHandler::~KrBookmarkHandler()
 {
     delete manager;
     delete _privateCollection;
 }
 
 void KrBookmarkHandler::bookmarkCurrent(QUrl url)
 {
-    QPointer<KrAddBookmarkDlg> dlg = new KrAddBookmarkDlg(_mainWindow->widget(), url);
+    QPointer<KrAddBookmarkDlg> dlg = new KrAddBookmarkDlg(_mainWindow->widget(), std::move(url));
     if (dlg->exec() == QDialog::Accepted) {
         KrBookmark *bm = new KrBookmark(dlg->name(), dlg->url(), _collection);
         addBookmark(bm, dlg->folder());
     }
     delete dlg;
 }
 
 void KrBookmarkHandler::addBookmark(KrBookmark *bm, KrBookmark *folder)
 {
-    if (folder == 0)
+    if (folder == nullptr)
         folder = _root;
 
     // add to the list (bottom)
     folder->children().append(bm);
 
     exportToFile();
 }
 
 void KrBookmarkHandler::deleteBookmark(KrBookmark *bm)
 {
     if (bm->isFolder())
         clearBookmarks(bm);   // remove the child bookmarks
     removeReferences(_root, bm);
     foreach(QWidget *w, bm->associatedWidgets())
     w->removeAction(bm);
     delete bm;
 
     exportToFile();
 }
 
 void KrBookmarkHandler::removeReferences(KrBookmark *root, KrBookmark *bmToRemove)
 {
     int index = root->children().indexOf(bmToRemove);
     if (index >= 0)
         root->children().removeAt(index);
 
     QListIterator<KrBookmark *> it(root->children());
     while (it.hasNext()) {
         KrBookmark *bm = it.next();
         if (bm->isFolder())
             removeReferences(bm, bmToRemove);
     }
 }
 
 void KrBookmarkHandler::exportToFileBookmark(QDomDocument &doc, QDomElement &where, KrBookmark *bm)
 {
     if (bm->isSeparator()) {
         QDomElement bookmark = doc.createElement("separator");
         where.appendChild(bookmark);
     } else {
         QDomElement bookmark = doc.createElement("bookmark");
         // url
         bookmark.setAttribute("href", bm->url().toDisplayString());
         // icon
         bookmark.setAttribute("icon", bm->iconName());
         // title
         QDomElement title = doc.createElement("title");
         title.appendChild(doc.createTextNode(bm->text()));
         bookmark.appendChild(title);
 
         where.appendChild(bookmark);
     }
 }
 
 void KrBookmarkHandler::exportToFileFolder(QDomDocument &doc, QDomElement &parent, KrBookmark *folder)
 {
     QListIterator<KrBookmark *> it(folder->children());
     while (it.hasNext()) {
         KrBookmark *bm = it.next();
 
         if (bm->isFolder()) {
             QDomElement newFolder = doc.createElement("folder");
             newFolder.setAttribute("icon", bm->iconName());
             parent.appendChild(newFolder);
             QDomElement title = doc.createElement("title");
             title.appendChild(doc.createTextNode(bm->text()));
             newFolder.appendChild(title);
             exportToFileFolder(doc, newFolder, bm);
         } else {
             exportToFileBookmark(doc, parent, bm);
         }
     }
 }
 
 // export to file using the xbel standard
 //
 //  <xbel>
 //    <bookmark href="http://developer.kde.org"><title>Developer Web Site</title></bookmark>
 //    <folder folded="no">
 //      <title>Title of this folder</title>
 //      <bookmark icon="kde" href="http://www.kde.org"><title>KDE Web Site</title></bookmark>
 //      <folder toolbar="yes">
 //        <title>My own bookmarks</title>
 //        <bookmark href="http://www.koffice.org"><title>KOffice Web Site</title></bookmark>
 //        <separator/>
 //        <bookmark href="http://www.kdevelop.org"><title>KDevelop Web Site</title></bookmark>
 //      </folder>
 //    </folder>
 //  </xbel>
 void KrBookmarkHandler::exportToFile()
 {
     QDomDocument doc("xbel");
     QDomElement root = doc.createElement("xbel");
     doc.appendChild(root);
 
     exportToFileFolder(doc, root, _root);
     if (!doc.firstChild().isProcessingInstruction()) {
         // adding: <?xml version="1.0" encoding="UTF-8" ?> if not already present
         QDomProcessingInstruction instr = doc.createProcessingInstruction("xml",
                                           "version=\"1.0\" encoding=\"UTF-8\" ");
         doc.insertBefore(instr, doc.firstChild());
     }
 
 
     QString filename = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + BOOKMARKS_FILE;
     QFile file(filename);
     if (file.open(QIODevice::WriteOnly)) {
         QTextStream stream(&file);
         stream.setCodec("UTF-8");
         stream << doc.toString();
         file.close();
     } else {
         KMessageBox::error(_mainWindow->widget(), i18n("Unable to write to %1", filename), i18n("Error"));
     }
 }
 
-bool KrBookmarkHandler::importFromFileBookmark(QDomElement &e, KrBookmark *parent, QString path, QString *errorMsg)
+bool KrBookmarkHandler::importFromFileBookmark(QDomElement &e, KrBookmark *parent, const QString& path, QString *errorMsg)
 {
     QString url, name, iconName;
     // verify tag
     if (e.tagName() != "bookmark") {
         *errorMsg = i18n("%1 instead of %2", e.tagName(), QLatin1String("bookmark"));
         return false;
     }
     // verify href
     if (!e.hasAttribute("href")) {
         *errorMsg = i18n("missing tag %1", QLatin1String("href"));
         return false;
     } else url = e.attribute("href");
     // verify title
     QDomElement te = e.firstChild().toElement();
     if (te.tagName() != "title") {
         *errorMsg = i18n("missing tag %1", QLatin1String("title"));
         return false;
     } else name = te.text();
     // do we have an icon?
     if (e.hasAttribute("icon")) {
         iconName = e.attribute("icon");
     }
     // ok: got name and url, let's add a bookmark
     KrBookmark *bm = KrBookmark::getExistingBookmark(path + name, _collection);
     if (!bm) {
         bm = new KrBookmark(name, QUrl(url), _collection, iconName, path + name);
     } else {
         bm->setURL(QUrl(url));
         bm->setIconName(iconName);
     }
     parent->children().append(bm);
 
     return true;
 }
 
-bool KrBookmarkHandler::importFromFileFolder(QDomNode &first, KrBookmark *parent, QString path, QString *errorMsg)
+bool KrBookmarkHandler::importFromFileFolder(QDomNode &first, KrBookmark *parent, const QString& path, QString *errorMsg)
 {
     QString name;
     QDomNode n = first;
     while (!n.isNull()) {
         QDomElement e = n.toElement();
         if (e.tagName() == "bookmark") {
             if (!importFromFileBookmark(e, parent, path, errorMsg))
                 return false;
         } else if (e.tagName() == "folder") {
             QString iconName = "";
             if (e.hasAttribute("icon")) iconName = e.attribute("icon");
             // the title is the first child of the folder
             QDomElement tmp = e.firstChild().toElement();
             if (tmp.tagName() != "title") {
                 *errorMsg = i18n("missing tag %1", QLatin1String("title"));
                 return false;
             } else name = tmp.text();
             KrBookmark *folder = new KrBookmark(name, iconName);
             parent->children().append(folder);
 
             QDomNode nextOne = tmp.nextSibling();
             if (!importFromFileFolder(nextOne, folder, path + name + '/', errorMsg))
                 return false;
         } else if (e.tagName() == "separator") {
             parent->children().append(KrBookmark::separator());
         }
         n = n.nextSibling();
     }
     return true;
 }
 
 
 void KrBookmarkHandler::importFromFile()
 {
     clearBookmarks(_root, false);
 
     QString filename = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + BOOKMARKS_FILE;
     QFile file(filename);
     if (!file.open(QIODevice::ReadOnly))
         return; // no bookmarks file
 
     QString errorMsg;
     QDomNode n;
     QDomElement e;
     QDomDocument doc("xbel");
     if (!doc.setContent(&file, &errorMsg)) {
         goto BM_ERROR;
     }
     // iterate through the document: first child should be "xbel" (skip all until we find it)
     n = doc.firstChild();
     while (!n.isNull() && n.toElement().tagName() != "xbel")
         n = n.nextSibling();
 
     if (n.isNull() || n.toElement().tagName() != "xbel") {
         errorMsg = i18n("%1 does not seem to be a valid bookmarks file", filename);
         goto BM_ERROR;
     } else n = n.firstChild(); // skip the xbel part
     importFromFileFolder(n, _root, "", &errorMsg);
     goto BM_SUCCESS;
 
 BM_ERROR:
     KMessageBox::error(_mainWindow->widget(), i18n("Error reading bookmarks file: %1", errorMsg), i18n("Error"));
 
 BM_SUCCESS:
     file.close();
 }
 
 void KrBookmarkHandler::_setQuickSearchText(const QString &text)
 {
     bool isEmptyQuickSearchBarVisible = KConfigGroup(krConfig, "Look&Feel").readEntry("Always show search bar", true);
 
     _quickSearchBar->setText(text);
 
     auto length = text.length();
     bool isVisible = isEmptyQuickSearchBarVisible || length > 0;
     _quickSearchAction->setVisible(isVisible);
     _quickSearchBar->setVisible(isVisible);
 
     if (length == 0) {
         qDebug() << "Bookmark search: reset";
         _resetActionTextAndHighlighting();
     } else {
         qDebug() << "Bookmark search: query =" << text;
     }
 }
 
 QString KrBookmarkHandler::_quickSearchText() const
 {
     return _quickSearchBar->text();
 }
 
 void KrBookmarkHandler::_highlightAction(QAction *action, bool isMatched)
 {
     auto font = action->font();
     font.setBold(isMatched);
     action->setFont(font);
 }
 
 void KrBookmarkHandler::populate(QMenu *menu)
 {
     // removing action from previous menu is necessary
     // otherwise it won't be displayed in the currently populating menu
     if (_mainBookmarkPopup) {
         _mainBookmarkPopup->removeAction(_quickSearchAction);
     }
     _mainBookmarkPopup = menu;
     menu->clear();
     _specialBookmarks.clear();
     buildMenu(_root, menu);
 }
 
 void KrBookmarkHandler::buildMenu(KrBookmark *parent, QMenu *menu, int depth)
 {
     // add search bar widget to the top of the menu
     if (depth == 0) {
         menu->addAction(_quickSearchAction);
     }
 
     // run the loop twice, in order to put the folders on top. stupid but easy :-)
     // note: this code drops the separators put there by the user
     QListIterator<KrBookmark *> it(parent->children());
     while (it.hasNext()) {
         KrBookmark *bm = it.next();
 
         if (!bm->isFolder()) continue;
-        QMenu *newMenu = new QMenu(menu);
+        auto *newMenu = new QMenu(menu);
         newMenu->setIcon(Icon(bm->iconName()));
         newMenu->setTitle(bm->text());
         QAction *menuAction = menu->addMenu(newMenu);
         QVariant v;
         v.setValue<KrBookmark *>(bm);
         menuAction->setData(v);
 
         buildMenu(bm, newMenu, depth + 1);
     }
 
     it.toFront();
     while (it.hasNext()) {
         KrBookmark *bm = it.next();
         if (bm->isFolder()) continue;
         if (bm->isSeparator()) {
             menu->addSeparator();
             continue;
         }
         menu->addAction(bm);
         CONNECT_BM(bm);
     }
 
     if (depth == 0) {
         KConfigGroup group(krConfig, "Private");
         bool hasPopularURLs = group.readEntry("BM Popular URLs", true);
         bool hasTrash       = group.readEntry("BM Trash",        true);
         bool hasLan         = group.readEntry("BM Lan",          true);
         bool hasVirtualFS   = group.readEntry("BM Virtual FS",   true);
         bool hasJumpback    = group.readEntry("BM Jumpback",     true);
 
         if (hasPopularURLs) {
             menu->addSeparator();
 
             // add the popular links submenu
-            QMenu *newMenu = new QMenu(menu);
+            auto *newMenu = new QMenu(menu);
             newMenu->setTitle(i18n("Popular URLs"));
             newMenu->setIcon(Icon("folder-bookmark"));
             QAction *bmfAct  = menu->addMenu(newMenu);
             _specialBookmarks.append(bmfAct);
             // add the top 15 urls
 #define MAX 15
             QList<QUrl> list = _mainWindow->popularUrls()->getMostPopularUrls(MAX);
             QList<QUrl>::Iterator it;
             for (it = list.begin(); it != list.end(); ++it) {
                 QString name;
                 if ((*it).isLocalFile()) name = (*it).path();
                 else name = (*it).toDisplayString();
                 // note: these bookmark are put into the private collection
                 // as to not spam the general collection
                 KrBookmark *bm = KrBookmark::getExistingBookmark(name, _privateCollection);
                 if (!bm)
                     bm = new KrBookmark(name, *it, _privateCollection);
                 newMenu->addAction(bm);
                 CONNECT_BM(bm);
             }
 
             newMenu->addSeparator();
             newMenu->addAction(krPopularUrls);
             newMenu->installEventFilter(this);
         }
 
         // do we need to add special bookmarks?
         if (SPECIAL_BOOKMARKS) {
             if (hasTrash || hasLan || hasVirtualFS)
                 menu->addSeparator();
 
             KrBookmark *bm;
 
             // note: special bookmarks are not kept inside the _bookmarks list and added ad-hoc
             if (hasTrash) {
                 bm = KrBookmark::trash(_collection);
                 menu->addAction(bm);
                 _specialBookmarks.append(bm);
                 CONNECT_BM(bm);
             }
 
             if (hasLan) {
                 bm = KrBookmark::lan(_collection);
                 menu->addAction(bm);
                 _specialBookmarks.append(bm);
                 CONNECT_BM(bm);
             }
 
             if (hasVirtualFS) {
                 bm = KrBookmark::virt(_collection);
                 menu->addAction(bm);
                 _specialBookmarks.append(bm);
                 CONNECT_BM(bm);
             }
 
             if (hasJumpback) {
                 menu->addSeparator();
 
                 ListPanelActions *actions = _mainWindow->listPanelActions();
 
                 auto slotTriggered = [=] {
                     if (_mainBookmarkPopup && !_mainBookmarkPopup->isHidden()) {
                         _mainBookmarkPopup->close();
                     }
                 };
                 auto addJumpBackAction = [=](bool isSetter) {
                     auto action = KrBookmark::jumpBackAction(_privateCollection, isSetter, actions);
                     if (action) {
                         menu->addAction(action);
                         _specialBookmarks.append(action);
 
                         // disconnecting from this as a receiver is important:
                         // we don't want to break connections established by KrBookmark::jumpBackAction
                         disconnect(action, &QAction::triggered, this, nullptr);
                         connect(action, &QAction::triggered, this, slotTriggered);
                     }
                 };
 
                 addJumpBackAction(true);
                 addJumpBackAction(false);
             }
         }
 
         menu->addSeparator();
         menu->addAction(KrActions::actAddBookmark);
         _specialBookmarks.append(KrActions::actAddBookmark);
         QAction *bmAct = menu->addAction(Icon("bookmarks"),
                                          i18n("Manage Bookmarks"), manager, SLOT(slotEditBookmarks()));
         _specialBookmarks.append(bmAct);
 
         // make sure the menu is connected to us
-        disconnect(menu, SIGNAL(triggered(QAction*)), 0, 0);
+        disconnect(menu, SIGNAL(triggered(QAction*)), nullptr, nullptr);
     }
 
     menu->installEventFilter(this);
 }
 
 void KrBookmarkHandler::clearBookmarks(KrBookmark *root, bool removeBookmarks)
 {
     for (auto it = root->children().begin(); it != root->children().end(); it = root->children().erase(it)) {
         KrBookmark *bm = *it;
 
         if (bm->isFolder()) {
             clearBookmarks(bm, removeBookmarks);
             delete bm;
         } else if (bm->isSeparator()) {
             delete bm;
         } else if (removeBookmarks) {
             foreach (QWidget *w, bm->associatedWidgets()) {
                 w->removeAction(bm);
             }
             delete bm;
         }
     }
 }
 
 void KrBookmarkHandler::bookmarksChanged(const QString&, const QString&)
 {
     importFromFile();
 }
 
 bool KrBookmarkHandler::eventFilter(QObject *obj, QEvent *ev)
 {
     auto eventType = ev->type();
-    QMenu *menu = qobject_cast<QMenu *>(obj);
+    auto *menu = qobject_cast<QMenu *>(obj);
 
     if (eventType == QEvent::Show && menu) {
         _setQuickSearchText("");
         _quickSearchMenu = menu;
         qDebug() << "Bookmark search: menu" << menu << "is shown";
 
         return QObject::eventFilter(obj, ev);
     }
 
     if (eventType == QEvent::Close && menu && _quickSearchMenu) {
         if (_quickSearchMenu == menu) {
             qDebug() << "Bookmark search: stopped on menu" << menu;
             _setQuickSearchText("");
             _quickSearchMenu = nullptr;
         } else {
             qDebug() << "Bookmark search: active action =" << _quickSearchMenu->activeAction();
 
             // fix automatic deactivation of current action due to spurious close event from submenu
             auto quickSearchMenu = _quickSearchMenu;
             auto activeAction = _quickSearchMenu->activeAction();
             QTimer::singleShot(0, this, [=]() {
                 qDebug() << "Bookmark search: active action =" << quickSearchMenu->activeAction();
                 if (!quickSearchMenu->activeAction() && activeAction) {
                     quickSearchMenu->setActiveAction(activeAction);
                     qDebug() << "Bookmark search: restored active action =" << quickSearchMenu->activeAction();
                 }
             });
         }
 
         return QObject::eventFilter(obj, ev);
     }
 
     // Having it occur on keypress is consistent with other shortcuts,
     // such as Ctrl+W and accelerator keys
     if (eventType == QEvent::KeyPress && menu) {
-        QKeyEvent *kev = static_cast<QKeyEvent *>(ev);
+        auto *kev = dynamic_cast<QKeyEvent *>(ev);
         QList<QAction *> acts = menu->actions();
         bool quickSearchStarted = false;
         bool searchInSpecialItems = KConfigGroup(krConfig, "Look&Feel").readEntry("Search in special items", false);
 
         if (kev->key() == Qt::Key_Left && kev->modifiers() == Qt::NoModifier) {
             menu->close();
             return true;
         }
 
         if ((kev->modifiers() != Qt::ShiftModifier &&
              kev->modifiers() != Qt::NoModifier) ||
             kev->text().isEmpty()                ||
             kev->key() == Qt::Key_Delete         ||
             kev->key() == Qt::Key_Return         ||
             kev->key() == Qt::Key_Escape) {
             return QObject::eventFilter(obj, ev);
         }
 
         // update quick search text
         if (kev->key() == Qt::Key_Backspace) {
             auto newSearchText = _quickSearchText();
             newSearchText.chop(1);
             _setQuickSearchText(newSearchText);
 
             if (_quickSearchText().length() == 0) {
                 return QObject::eventFilter(obj, ev);
             }
         } else {
             quickSearchStarted = _quickSearchText().length() == 0;
             _setQuickSearchText(_quickSearchText().append(kev->text()));
         }
 
         if (quickSearchStarted) {
             _quickSearchMenu = menu;
             qDebug() << "Bookmark search: started on menu" << menu;
         }
 
         // match actions
         QAction *matchedAction = nullptr;
         int nMatches = 0;
         const Qt::CaseSensitivity matchCase =
             _quickSearchText() == _quickSearchText().toLower() ? Qt::CaseInsensitive : Qt::CaseSensitive;
         for (auto act : acts) {
             if (act->isSeparator() || act->text().isEmpty()) {
                 continue;
             }
 
             if (!searchInSpecialItems && _specialBookmarks.contains(act)) {
                 continue;
             }
 
             if (quickSearchStarted) {
                 // if the first key press is an accelerator key, let the accelerator handler process this event
                 if (act->text().contains('&' + kev->text(), Qt::CaseInsensitive)) {
                     qDebug() << "Bookmark search: hit accelerator key of" << act;
                     _setQuickSearchText("");
                     return QObject::eventFilter(obj, ev);
                 }
 
                 // strip accelerator keys from actions so they don't interfere with the search key press events
                 auto text = act->text();
                 _quickSearchOriginalActionTitles.insert(act, text);
                 act->setText(KLocalizedString::removeAcceleratorMarker(text));
             }
 
             // match prefix of the action text to the query
             if (act->text().left(_quickSearchText().length()).compare(_quickSearchText(), matchCase) == 0) {
                 _highlightAction(act);
                 if (!matchedAction || matchedAction->menu()) {
                     // Can't highlight menus (see comment below), hopefully pick something we can
                     matchedAction = act;
                 }
                 nMatches++;
             } else {
                 _highlightAction(act, false);
             }
         }
 
         if (matchedAction) {
             qDebug() << "Bookmark search: primary match =" << matchedAction->text() << ", number of matches =" << nMatches;
         } else {
             qDebug() << "Bookmark search: no matches";
         }
 
         // trigger the matched menu item or set an active item accordingly
         if (nMatches == 1) {
             _setQuickSearchText("");
             if ((bool) matchedAction->menu()) {
                 menu->setActiveAction(matchedAction);
             } else {
                 matchedAction->activate(QAction::Trigger);
             }
         } else if (nMatches > 1) {
             // Because of a bug submenus cannot be highlighted
             // https://bugreports.qt.io/browse/QTBUG-939
             if (!matchedAction->menu()) {
                 menu->setActiveAction(matchedAction);
             } else {
                 menu->setActiveAction(nullptr);
             }
         } else {
             menu->setActiveAction(nullptr);
         }
         return true;
     }
 
     if (eventType == QEvent::MouseButtonRelease) {
-        switch (static_cast<QMouseEvent *>(ev)->button()) {
+        switch (dynamic_cast<QMouseEvent *>(ev)->button()) {
         case Qt::RightButton:
             _middleClick = false;
             if (obj->inherits("QMenu")) {
-                QMenu *menu = static_cast<QMenu *>(obj);
-                QAction *act = menu->actionAt(static_cast<QMouseEvent *>(ev)->pos());
+                auto *menu = dynamic_cast<QMenu *>(obj);
+                QAction *act = menu->actionAt(dynamic_cast<QMouseEvent *>(ev)->pos());
 
                 if (obj == _mainBookmarkPopup && _specialBookmarks.contains(act)) {
                     rightClickOnSpecialBookmark();
                     return true;
                 }
 
-                KrBookmark *bm = qobject_cast<KrBookmark *>(act);
-                if (bm != 0) {
+                auto *bm = qobject_cast<KrBookmark *>(act);
+                if (bm != nullptr) {
                     rightClicked(menu, bm);
                     return true;
                 } else if (act && act->data().canConvert<KrBookmark *>()) {
-                    KrBookmark *bm = act->data().value<KrBookmark *>();
+                    auto *bm = act->data().value<KrBookmark *>();
                     rightClicked(menu, bm);
                 }
             }
             break;
         case Qt::LeftButton:
             _middleClick = false;
             break;
         case Qt::MidButton:
             _middleClick = true;
             break;
         default:
             break;
         }
     }
     return QObject::eventFilter(obj, ev);
 }
 
 void KrBookmarkHandler::_resetActionTextAndHighlighting()
 {
     for (QHash<QAction *, QString>::const_iterator i = _quickSearchOriginalActionTitles.begin();
          i != _quickSearchOriginalActionTitles.end(); ++i) {
         QAction *action = i.key();
         action->setText(i.value());
         _highlightAction(action, false);
     }
 
     _quickSearchOriginalActionTitles.clear();
 }
 
 #define POPULAR_URLS_ID        100100
 #define TRASH_ID               100101
 #define LAN_ID                 100103
 #define VIRTUAL_FS_ID          100102
 #define JUMP_BACK_ID           100104
 
 void KrBookmarkHandler::rightClickOnSpecialBookmark()
 {
     KConfigGroup group(krConfig, "Private");
     bool hasPopularURLs = group.readEntry("BM Popular URLs", true);
     bool hasTrash       = group.readEntry("BM Trash",      true);
     bool hasLan         = group.readEntry("BM Lan",          true);
     bool hasVirtualFS   = group.readEntry("BM Virtual FS",   true);
     bool hasJumpback    = group.readEntry("BM Jumpback",     true);
 
     QMenu menu(_mainBookmarkPopup);
     menu.setTitle(i18n("Enable special bookmarks"));
 
     QAction *act;
 
     act = menu.addAction(i18n("Popular URLs"));
     act->setData(QVariant(POPULAR_URLS_ID));
     act->setCheckable(true);
     act->setChecked(hasPopularURLs);
     act = menu.addAction(i18n("Trash bin"));
     act->setData(QVariant(TRASH_ID));
     act->setCheckable(true);
     act->setChecked(hasTrash);
     act = menu.addAction(i18n("Local Network"));
     act->setData(QVariant(LAN_ID));
     act->setCheckable(true);
     act->setChecked(hasLan);
     act = menu.addAction(i18n("Virtual Filesystem"));
     act->setData(QVariant(VIRTUAL_FS_ID));
     act->setCheckable(true);
     act->setChecked(hasVirtualFS);
     act = menu.addAction(i18n("Jump back"));
     act->setData(QVariant(JUMP_BACK_ID));
     act->setCheckable(true);
     act->setChecked(hasJumpback);
 
     connect(_mainBookmarkPopup, SIGNAL(highlighted(int)), &menu, SLOT(close()));
     connect(_mainBookmarkPopup, SIGNAL(activated(int)), &menu, SLOT(close()));
 
     int result = -1;
     QAction *res = menu.exec(QCursor::pos());
     if (res && res->data().canConvert<int>())
         result = res->data().toInt();
 
     bool doCloseMain = true;
 
     switch (result) {
     case POPULAR_URLS_ID:
         group.writeEntry("BM Popular URLs", !hasPopularURLs);
         break;
     case TRASH_ID:
         group.writeEntry("BM Trash", !hasTrash);
         break;
     case LAN_ID:
         group.writeEntry("BM Lan", !hasLan);
         break;
     case VIRTUAL_FS_ID:
         group.writeEntry("BM Virtual FS", !hasVirtualFS);
         break;
     case JUMP_BACK_ID:
         group.writeEntry("BM Jumpback", !hasJumpback);
         break;
     default:
         doCloseMain = false;
         break;
     }
 
     menu.close();
 
     if (doCloseMain && _mainBookmarkPopup)
         _mainBookmarkPopup->close();
 }
 
 #define OPEN_ID           100200
 #define OPEN_NEW_TAB_ID   100201
 #define DELETE_ID         100202
 
 void KrBookmarkHandler::rightClicked(QMenu *menu, KrBookmark * bm)
 {
     QMenu popup(_mainBookmarkPopup);
     QAction * act;
 
     if (!bm->isFolder()) {
         act = popup.addAction(Icon("document-open"), i18n("Open"));
         act->setData(QVariant(OPEN_ID));
         act = popup.addAction(Icon("tab-new"), i18n("Open in a new tab"));
         act->setData(QVariant(OPEN_NEW_TAB_ID));
         popup.addSeparator();
     }
     act = popup.addAction(Icon("edit-delete"), i18n("Delete"));
     act->setData(QVariant(DELETE_ID));
 
     connect(menu, SIGNAL(highlighted(int)), &popup, SLOT(close()));
     connect(menu, SIGNAL(activated(int)), &popup, SLOT(close()));
 
     int result = -1;
     QAction *res = popup.exec(QCursor::pos());
     if (res && res->data().canConvert<int> ())
         result = res->data().toInt();
 
     popup.close();
     if (_mainBookmarkPopup && result >= OPEN_ID && result <= DELETE_ID) {
         _mainBookmarkPopup->close();
     }
 
     switch (result) {
     case OPEN_ID:
         SLOTS->refresh(bm->url());
         break;
     case OPEN_NEW_TAB_ID:
         _mainWindow->activeManager()->newTab(bm->url());
         break;
     case DELETE_ID:
         deleteBookmark(bm);
         break;
     }
 }
 
 // used to monitor middle clicks. if mid is found, then the
 // bookmark is opened in a new tab. ugly, but easier than overloading
 // KAction and KActionCollection.
 void KrBookmarkHandler::slotActivated(const QUrl &url)
 {
     if (_mainBookmarkPopup && !_mainBookmarkPopup->isHidden())
         _mainBookmarkPopup->close();
     if (_middleClick)
         _mainWindow->activeManager()->newTab(url);
     else
         SLOTS->refresh(url);
 }
 
diff --git a/krusader/BookMan/krbookmarkhandler.h b/krusader/BookMan/krbookmarkhandler.h
index b664507a..657e21d7 100644
--- a/krusader/BookMan/krbookmarkhandler.h
+++ b/krusader/BookMan/krbookmarkhandler.h
@@ -1,101 +1,101 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRBOOKMARKHANDLER_H
 #define KRBOOKMARKHANDLER_H
 
 // QtCore
 #include <QObject>
 #include <QPointer>
 #include <QEvent>
 #include <QMap>
 #include <QUrl>
 // QtXml
 #include <QDomEntity>
 // QtWidgets
 #include <QMenu>
 #include <QWidgetAction>
 #include <QLineEdit>
 
 #include "krbookmark.h"
 
 class KActionCollection;
 class KBookmarkManager;
 class KrMainWindow;
 
 class KrBookmarkHandler: public QObject
 {
     Q_OBJECT
     friend class KrAddBookmarkDlg;
     enum Actions { BookmarkCurrent = 0, ManageBookmarks };
 public:
     explicit KrBookmarkHandler(KrMainWindow *mainWindow);
-    ~KrBookmarkHandler();
+    ~KrBookmarkHandler() override;
     void populate(QMenu *menu);
-    void addBookmark(KrBookmark *bm, KrBookmark *parent = 0);
+    void addBookmark(KrBookmark *bm, KrBookmark *parent = nullptr);
     void bookmarkCurrent(QUrl url);
 
 protected:
     void deleteBookmark(KrBookmark *bm);
     void importFromFile();
-    bool importFromFileBookmark(QDomElement &e, KrBookmark *parent, QString path, QString *errorMsg);
-    bool importFromFileFolder(QDomNode &first, KrBookmark *parent, QString path, QString *errorMsg);
+    bool importFromFileBookmark(QDomElement &e, KrBookmark *parent, const QString& path, QString *errorMsg);
+    bool importFromFileFolder(QDomNode &first, KrBookmark *parent, const QString& path, QString *errorMsg);
     void exportToFile();
     void exportToFileFolder(QDomDocument &doc, QDomElement &parent, KrBookmark *folder);
     void exportToFileBookmark(QDomDocument &doc, QDomElement &where, KrBookmark *bm);
     void clearBookmarks(KrBookmark *root, bool removeBookmarks = true);
     void buildMenu(KrBookmark *parent, QMenu *menu, int depth = 0);
 
     bool eventFilter(QObject *obj, QEvent *ev) Q_DECL_OVERRIDE;
     void rightClicked(QMenu *menu, KrBookmark *bm);
     void rightClickOnSpecialBookmark();
 
     void removeReferences(KrBookmark *root, KrBookmark *bmToRemove);
 
 protected slots:
     void bookmarksChanged(const QString&, const QString&);
     void slotActivated(const QUrl &url);
 
 private:
     KrMainWindow *_mainWindow;
     KActionCollection *_collection, *_privateCollection;
     KrBookmark *_root;
     // the whole KBookmarkManager is an ugly hack. use it until we have our own
     KBookmarkManager *manager;
     bool _middleClick; // if true, the user clicked the middle button to open the bookmark
 
     QPointer<QMenu>            _mainBookmarkPopup; // main bookmark popup menu
     QList<QAction *>           _specialBookmarks; // the action list of the special bookmarks
 
     QWidgetAction *_quickSearchAction; ///< Search bar container action
     QLineEdit *_quickSearchBar; ///< Search bar containing current query
     QMenu *_quickSearchMenu; ///< The menu where the search is performed
     QHash<QAction *, QString> _quickSearchOriginalActionTitles; ///< Saved original action text values to restore after search
 
     void _setQuickSearchText(const QString &text);
     QString _quickSearchText() const;
     static void _highlightAction(QAction *action, bool isMatched = true);
     void _resetActionTextAndHighlighting();
 };
 
 Q_DECLARE_METATYPE(KrBookmark *)
 
 #endif // KRBOOKMARK_HANDLER_H
diff --git a/krusader/Dialogs/checksumdlg.cpp b/krusader/Dialogs/checksumdlg.cpp
index 95b5a9ca..a5431de0 100644
--- a/krusader/Dialogs/checksumdlg.cpp
+++ b/krusader/Dialogs/checksumdlg.cpp
@@ -1,576 +1,576 @@
 /*****************************************************************************
  * Copyright (C) 2005 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2007-2008 Csaba Karai <cskarai@freemail.hu>                 *
  * Copyright (C) 2008 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "checksumdlg.h"
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../krservices.h"
 #include "../krusader.h"
 #include "../GUI/krlistwidget.h"
 #include "../GUI/krtreewidget.h"
 
 // QtCore
 #include <QDirIterator>
 #include <QFile>
 #include <QFileInfo>
 #include <QList>
 #include <QMap>
 #include <QTextStream>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QFileDialog>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QProgressBar>
 
 #include <QtConcurrent/QtConcurrentRun> // krazy:exclude=includes
 
 #include <KI18n/KLocalizedString>
 #include <KIOWidgets/KUrlRequester>
 #include <KWidgetsAddons/KMessageBox>
 
 void Checksum::startCreationWizard(const QString &path, const QStringList &files)
 {
     if (files.isEmpty())
         return;
 
     QDialog *dialog = new CHECKSUM_::CreateWizard(path, files);
     dialog->show();
 }
 
 void Checksum::startVerifyWizard(const QString &path, const QString &checksumFile)
 {
     QDialog *dialog = new CHECKSUM_::VerifyWizard(path, checksumFile);
     dialog->show();
 }
 
 namespace CHECKSUM_ {
 
 bool stopListFiles;
 // async operation invoked by QtConcurrent::run in creation wizard
 QStringList listFiles(const QString &path, const QStringList &fileNames)
 {
     const QDir baseDir(path);
     QStringList allFiles;
-    for (const QString fileName : fileNames) {
+    for (const QString& fileName : fileNames) {
         if (stopListFiles)
             return QStringList();
 
         QDir subDir = QDir(baseDir.filePath(fileName));
         if (subDir.exists()) {
             subDir.setFilter(QDir::Files);
             QDirIterator it(subDir, QDirIterator::Subdirectories | QDirIterator::FollowSymlinks);
             while (it.hasNext()) {
                 if (stopListFiles)
                     return QStringList();
 
                 allFiles << baseDir.relativeFilePath(it.next());
             }
         } else {
             // assume this is a file
             allFiles << fileName;
         }
     }
     return allFiles;
 }
 
 // ------------- Checksum Process
 
 ChecksumProcess::ChecksumProcess(QObject *parent, const QString &path) : KProcess(parent),
     m_tmpOutFile(QDir::tempPath() + QLatin1String("/krusader_XXXXXX.stdout")),
     m_tmpErrFile(QDir::tempPath() + QLatin1String("/krusader_XXXXXX.stderr"))
 {
     m_tmpOutFile.open(); // necessary to create the filename
     m_tmpErrFile.open(); // necessary to create the filename
 
     setOutputChannelMode(KProcess::SeparateChannels); // without this the next 2 lines have no effect!
     setStandardOutputFile(m_tmpOutFile.fileName());
     setStandardErrorFile(m_tmpErrFile.fileName());
     setWorkingDirectory(path);
 #if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)
     connect(this, &ChecksumProcess::errorOccurred, this, &ChecksumProcess::slotError);
 #endif
     connect(this, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
             this, &ChecksumProcess::slotFinished);
 }
 
 ChecksumProcess::~ChecksumProcess()
 {
-    disconnect(this, 0, this, 0); // QProcess emits finished() on destruction
+    disconnect(this, nullptr, this, nullptr); // QProcess emits finished() on destruction
     close();
 }
 
 void ChecksumProcess::slotError(QProcess::ProcessError error)
 {
     if (error == QProcess::FailedToStart) {
-        KMessageBox::error(0, i18n("<qt>Could not start <b>%1</b>.</qt>", program().join(" ")));
+        KMessageBox::error(nullptr, i18n("<qt>Could not start <b>%1</b>.</qt>", program().join(" ")));
     }
 }
 
 void ChecksumProcess::slotFinished(int, QProcess::ExitStatus exitStatus)
 {
     if (exitStatus != QProcess::NormalExit) {
-        KMessageBox::error(0, i18n("<qt>There was an error while running <b>%1</b>.</qt>",
+        KMessageBox::error(nullptr, i18n("<qt>There was an error while running <b>%1</b>.</qt>",
                                    program().join(" ")));
         return;
     }
 
     // parse result files
     if (!KrServices::fileToStringList(&m_tmpOutFile, m_outputLines) ||
         !KrServices::fileToStringList(&m_tmpErrFile, m_errorLines)) {
-        KMessageBox::error(0, i18n("Error reading stdout or stderr"));
+        KMessageBox::error(nullptr, i18n("Error reading stdout or stderr"));
         return;
     }
     emit resultReady();
 }
 
 // ------------- Generic Checksum Wizard
 
-ChecksumWizard::ChecksumWizard(const QString &path) : QWizard(krApp), m_path(path), m_process(0)
+ChecksumWizard::ChecksumWizard(const QString &path) : QWizard(krApp), m_path(path), m_process(nullptr)
 {
     setAttribute(Qt::WA_DeleteOnClose);
 
     // init the dictionary - pity it has to be manually
     m_checksumTools.insert("md5", "md5sum");
     m_checksumTools.insert("sha1", "sha1sum");
     m_checksumTools.insert("sha256", "sha256sum");
     m_checksumTools.insert("sha224", "sha224sum");
     m_checksumTools.insert("sha384", "sha384sum");
     m_checksumTools.insert("sha512", "sha512sum");
 
     connect(this, &QWizard::currentIdChanged, this, &ChecksumWizard::slotCurrentIdChanged);
 }
 
 ChecksumWizard::~ChecksumWizard()
 {
     if (m_process) {
         delete m_process;
     }
 }
 
 void ChecksumWizard::slotCurrentIdChanged(int id)
 {
     if (id == m_introId) {
         onIntroPage();
     } else if (id == m_progressId) {
         if (m_process) {
             // we are coming from the result page;
             delete m_process;
-            m_process = 0;
+            m_process = nullptr;
             restart();
         } else {
             button(QWizard::BackButton)->hide();
             button(QWizard::NextButton)->hide();
             onProgressPage();
         }
     } else if (id == m_resultId) {
         onResultPage();
     }
 }
 
 QWizardPage *ChecksumWizard::createProgressPage(const QString &title)
 {
-    QWizardPage *page = new QWizardPage;
+    auto *page = new QWizardPage;
 
     page->setTitle(title);
     page->setPixmap(QWizard::LogoPixmap,
                     Icon("process-working").pixmap(32));
     page->setSubTitle(i18n("Please wait..."));
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     page->setLayout(mainLayout);
 
     // "busy" indicator
-    QProgressBar *bar = new QProgressBar();
+    auto *bar = new QProgressBar();
     bar->setRange(0,0);
 
     mainLayout->addWidget(bar);
 
     return page;
 }
 
-bool ChecksumWizard::checkExists(const QString type)
+bool ChecksumWizard::checkExists(const QString& type)
 {
     if (!KrServices::cmdExist(m_checksumTools[type])) {
         KMessageBox::error(
             this, i18n("<qt>Krusader cannot find a checksum tool that handles %1 on your system. "
                         "Please check the <b>Dependencies</b> page in Krusader's settings.</qt>",
                         type));
         return false;
     }
     return true;
 }
 
 void ChecksumWizard::runProcess(const QString &type, const QStringList &args)
 {
-    Q_ASSERT(m_process == 0);
+    Q_ASSERT(m_process == nullptr);
 
     m_process = new ChecksumProcess(this, m_path);
     m_process->setProgram(KrServices::fullPathName(m_checksumTools[type]), args);
     // show next page (with results) (only) when process is done
     connect(m_process, &ChecksumProcess::resultReady, this, &QWizard::next);
     // run the process
     m_process->start();
 }
 
 void ChecksumWizard::addChecksumLine(KrTreeWidget *tree, const QString &line)
 {
-    QTreeWidgetItem *item = new QTreeWidgetItem(tree);
+    auto *item = new QTreeWidgetItem(tree);
     const int hashLength = line.indexOf(' '); // delimiter is either "  " or " *"
     item->setText(0, line.left(hashLength));
     QString fileName = line.mid(hashLength + 2);
     if (fileName.endsWith('\n'))
         fileName.chop(1);
     item->setText(1, fileName);
 }
 
 // ------------- Create Wizard
 
 CreateWizard::CreateWizard(const QString &path, const QStringList &_files) : ChecksumWizard(path),
-    m_fileNames(_files), m_listFilesWatcher()
+    m_fileNames(_files)
 {
 
     m_introId = addPage(createIntroPage());
     m_progressId = addPage(createProgressPage(i18n("Creating Checksums")));
     m_resultId = addPage(createResultPage());
 
     setButton(QWizard::FinishButton,
               QDialogButtonBox(QDialogButtonBox::Save).button(QDialogButtonBox::Save));
 
     connect(&m_listFilesWatcher, &QFutureWatcher<QStringList>::resultReadyAt,
             this, &CreateWizard::createChecksums);
 }
 
 QWizardPage *CreateWizard::createIntroPage()
 {
-    QWizardPage *page = new QWizardPage;
+    auto *page = new QWizardPage;
 
     page->setTitle(i18n("Create Checksums"));
     page->setPixmap(QWizard::LogoPixmap,
                     Icon("document-edit-sign").pixmap(32));
     page->setSubTitle(i18n("About to calculate checksum for the following files or directories:"));
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     page->setLayout(mainLayout);
 
     // file list
-    KrListWidget *listWidget = new KrListWidget;
+    auto *listWidget = new KrListWidget;
     listWidget->addItems(m_fileNames);
     mainLayout->addWidget(listWidget);
 
     // checksum method
-    QHBoxLayout *hLayout = new QHBoxLayout;
+    auto *hLayout = new QHBoxLayout;
 
     QLabel *methodLabel = new QLabel(i18n("Select the checksum method:"));
     hLayout->addWidget(methodLabel);
 
     m_methodBox = new KComboBox;
     // -- fill the combo with available methods
-    for (const QString type: m_checksumTools.keys())
+    for (const QString& type: m_checksumTools.keys())
         m_methodBox->addItem(type);
     m_methodBox->setFocus();
     hLayout->addWidget(m_methodBox);
 
     mainLayout->addLayout(hLayout);
 
     return page;
 }
 
 QWizardPage *CreateWizard::createResultPage()
 {
-    QWizardPage *page = new QWizardPage;
+    auto *page = new QWizardPage;
 
     page->setTitle(i18n("Checksum Results"));
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     page->setLayout(mainLayout);
 
     m_hashesTreeWidget = new KrTreeWidget(this);
     m_hashesTreeWidget->setAllColumnsShowFocus(true);
     m_hashesTreeWidget->setHeaderLabels(QStringList() << i18n("Hash") << i18n("File"));
     mainLayout->addWidget(m_hashesTreeWidget);
 
     m_errorLabel = new QLabel(i18n("Errors received:"));
     mainLayout->addWidget(m_errorLabel);
 
     m_errorListWidget = new KrListWidget;
     mainLayout->addWidget(m_errorListWidget);
 
     m_onePerFileBox = new QCheckBox(i18n("Save one checksum file for each source file"));
     m_onePerFileBox->setChecked(false);
     mainLayout->addWidget(m_onePerFileBox);
 
     return page;
 }
 
 void CreateWizard::onIntroPage() { button(QWizard::NextButton)->show(); }
 
 void CreateWizard::onProgressPage()
 {
     // first, get all files (recurse in directories) - async
     stopListFiles = false; // QFuture cannot cancel QtConcurrent::run
     connect(this, &CreateWizard::finished, this, [=]() { stopListFiles = true; });
     QFuture<QStringList> listFuture = QtConcurrent::run(listFiles, m_path, m_fileNames);
     m_listFilesWatcher.setFuture(listFuture);
 }
 
 void CreateWizard::createChecksums() {
     const QString type = m_methodBox->currentText();
     if (!checkExists(type)) {
         button(QWizard::BackButton)->show();
         return;
     }
 
     const QStringList &allFiles = m_listFilesWatcher.result();
     if (allFiles.isEmpty()) {
         KMessageBox::error(this, i18n("No files found"));
         button(QWizard::BackButton)->show();
         return;
     }
 
     runProcess(type, allFiles);
 
     // set suggested filename
     m_suggestedFilePath = QDir(m_path).filePath(
         (m_fileNames.count() > 1 ? "checksum." : (m_fileNames[0] + '.')) + type);
 }
 
 void CreateWizard::onResultPage()
 {
     // hash tools display errors into stderr, so we'll use that to determine the result of the job
     const QStringList outputLines = m_process->stdOutput();
     const QStringList errorLines = m_process->errOutput();
     bool errors = !errorLines.isEmpty();
     bool successes = !outputLines.isEmpty();
 
     QWizardPage *page = currentPage();
     page->setPixmap(QWizard::LogoPixmap,
         Icon(errors || !successes ? "dialog-error" : "dialog-information").pixmap(32));
     page->setSubTitle(errors || !successes ?
                           i18n("Errors were detected while creating the checksums") :
                           i18n("Checksums were created successfully"));
 
     m_hashesTreeWidget->clear();
     m_hashesTreeWidget->setVisible(successes);
     if (successes) {
-        for (const QString line : outputLines)
+        for (const QString& line : outputLines)
             addChecksumLine(m_hashesTreeWidget, line);
         //m_hashesTreeWidget->sortItems(1, Qt::AscendingOrder);
     }
 
     m_errorLabel->setVisible(errors);
     m_errorListWidget->setVisible(errors);
     m_errorListWidget->clear();
     m_errorListWidget->addItems(errorLines);
 
     m_onePerFileBox->setEnabled(outputLines.size() > 1);
 
     button(QWizard::FinishButton)->setEnabled(successes);
 }
 
 bool CreateWizard::savePerFile()
 {
     const QString type = m_suggestedFilePath.mid(m_suggestedFilePath.lastIndexOf('.'));
 
     krApp->startWaiting(i18n("Saving checksum files..."), 0);
-    for (const QString line : m_process->stdOutput()) {
+    for (const QString& line : m_process->stdOutput()) {
         const QString filename = line.mid(line.indexOf(' ') + 2) + type;
         if (!saveChecksumFile(QStringList() << line, filename)) {
             KMessageBox::error(this, i18n("Errors occurred while saving multiple checksums. Stopping"));
             krApp->stopWait();
             return false;
         }
     }
     krApp->stopWait();
 
     return true;
 }
 
 bool CreateWizard::saveChecksumFile(const QStringList &data, const QString &filename)
 {
     QString filePath = filename.isEmpty() ? m_suggestedFilePath : filename;
     if (filename.isEmpty() || QFile::exists(filePath)) {
         filePath = QFileDialog::getSaveFileName(this, QString(), filePath);
         if (filePath.isEmpty())
             return false; // user pressed cancel
     }
 
     QFile file(filePath);
     if (file.open(QIODevice::WriteOnly)) {
         QTextStream stream(&file);
-        for (const QString line : data)
+        for (const QString& line : data)
             stream << line << "\n";
         file.close();
     }
 
     if (file.error() != QFile::NoError) {
         KMessageBox::detailedError(this, i18n("Error saving file %1", filePath), file.errorString());
         return false;
     }
 
     return true;
 }
 
 void CreateWizard::accept()
 {
     const bool saved = m_onePerFileBox->isChecked() ? savePerFile() :
                                                   saveChecksumFile(m_process->stdOutput());
     if (saved)
         QWizard::accept();
 }
 
 // ------------- Verify Wizard
 
 VerifyWizard::VerifyWizard(const QString &path, const QString &inputFile) : ChecksumWizard(path)
 {
   m_checksumFile = isSupported(inputFile) ? inputFile : path;
 
   m_introId = addPage(createIntroPage()); // m_checksumFile must already be set
   m_progressId = addPage(createProgressPage(i18n("Verifying Checksums")));
   m_resultId = addPage(createResultPage());
 }
 
 void VerifyWizard::slotChecksumPathChanged(const QString &path)
 {
     m_hashesTreeWidget->clear();
     button(QWizard::NextButton)->setEnabled(false);
 
     if (!isSupported(path))
         return;
 
     m_checksumFile = path;
 
     // parse and display checksum file content; only for the user, parsed values are not used
     m_hashesTreeWidget->clear();
     QFile file(m_checksumFile);
     if (file.open(QFile::ReadOnly)) {
         QTextStream inStream(&file);
         while (!inStream.atEnd()) {
             addChecksumLine(m_hashesTreeWidget, file.readLine());
         }
     }
     file.close();
 
     button(QWizard::NextButton)->setEnabled(true);
 }
 
 QWizardPage *VerifyWizard::createIntroPage()
 {
-    QWizardPage *page = new QWizardPage;
+    auto *page = new QWizardPage;
 
     page->setTitle(i18n("Verify Checksum File"));
     page->setPixmap(QWizard::LogoPixmap,
                     Icon("document-edit-verify").pixmap(32));
     page->setSubTitle(i18n("About to verify the following checksum file"));
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     page->setLayout(mainLayout);
 
     // checksum file
-    QHBoxLayout *hLayout = new QHBoxLayout;
+    auto *hLayout = new QHBoxLayout;
     QLabel *checksumFileLabel = new QLabel(i18n("Checksum file:"));
     hLayout->addWidget(checksumFileLabel);
 
-    KUrlRequester *checksumFileReq = new KUrlRequester;
+    auto *checksumFileReq = new KUrlRequester;
     QString typesFilter;
-    for (const QString ext: m_checksumTools.keys())
+    for (const QString& ext: m_checksumTools.keys())
         typesFilter += ("*." + ext + ' ');
     checksumFileReq->setFilter(typesFilter);
     checksumFileReq->setText(m_checksumFile);
     checksumFileReq->setFocus();
     connect(checksumFileReq, &KUrlRequester::textChanged, this,
             &VerifyWizard::slotChecksumPathChanged);
     hLayout->addWidget(checksumFileReq);
 
     mainLayout->addLayout(hLayout);
 
     // content of checksum file
     m_hashesTreeWidget = new KrTreeWidget(page);
     m_hashesTreeWidget->setAllColumnsShowFocus(true);
     m_hashesTreeWidget->setHeaderLabels(QStringList() << i18n("Hash") << i18n("File"));
     mainLayout->addWidget(m_hashesTreeWidget);
 
     return page;
 }
 
 QWizardPage *VerifyWizard::createResultPage()
 {
-    QWizardPage *page = new QWizardPage;
+    auto *page = new QWizardPage;
 
     page->setTitle(i18n("Verify Result"));
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     page->setLayout(mainLayout);
 
     m_outputLabel = new QLabel(i18n("Result output:"));
     mainLayout->addWidget(m_outputLabel);
 
     m_outputListWidget = new KrListWidget;
     mainLayout->addWidget(m_outputListWidget);
 
     return page;
 }
 
 void VerifyWizard::onIntroPage()
 {
     // cannot do this in constructor: NextButton->hide() is overridden
     slotChecksumPathChanged(m_checksumFile);
 }
 
 void VerifyWizard::onProgressPage()
 {
     // verify checksum file...
     const QString extension = QFileInfo(m_checksumFile).suffix();
     if (!checkExists(extension)) {
         button(QWizard::BackButton)->show();
         return;
     }
 
     runProcess(extension, QStringList() << "--strict" << "-c" << m_checksumFile);
 }
 
 void VerifyWizard::onResultPage()
 {
     // better not only trust error output
     const bool errors = m_process->exitCode() != 0 || !m_process->errOutput().isEmpty();
 
     QWizardPage *page = currentPage();
     page->setPixmap(QWizard::LogoPixmap,
                     Icon(errors ? "dialog-error" : "dialog-information").pixmap(32));
     page->setSubTitle(errors ? i18n("Errors were detected while verifying the checksums") :
                                i18n("Checksums were verified successfully"));
 
     // print everything, errors first
     m_outputListWidget->clear();
     m_outputListWidget->addItems(m_process->errOutput() + m_process->stdOutput());
 
     button(QWizard::FinishButton)->setEnabled(!errors);
 }
 
 bool VerifyWizard::isSupported(const QString &path)
 {
     const QFileInfo fileInfo(path);
     return fileInfo.isFile() && m_checksumTools.keys().contains(fileInfo.suffix());
 }
 
 } // NAMESPACE CHECKSUM_
diff --git a/krusader/Dialogs/checksumdlg.h b/krusader/Dialogs/checksumdlg.h
index 07d7c376..095c1a0e 100644
--- a/krusader/Dialogs/checksumdlg.h
+++ b/krusader/Dialogs/checksumdlg.h
@@ -1,180 +1,180 @@
 /*****************************************************************************
  * Copyright (C) 2005 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2007-2008 Csaba Karai <cskarai@freemail.hu>                 *
  * Copyright (C) 2008 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef CHECKSUMDLG_H
 #define CHECKSUMDLG_H
 
 // QtCore
 #include <QFutureWatcher>
 #include <QString>
 #include <QTemporaryFile>
 // QtWidgets
 #include <QCheckBox>
 #include <QLabel>
 #include <QWizard>
 
 #include <KCompletion/KComboBox>
 #include <KCoreAddons/KProcess>
 
 class KrListWidget;
 class KrTreeWidget;
 
 /**
  * Perform checksum operations: Creation of checksums or verifying files with a checksum file.
  *
  * The dialogs are not modal. The used checksum tools only support local files which are expected to
  * be in one directory (specified by 'path').
  */
 class Checksum
 {
   public:
     static void startCreationWizard(const QString &path, const QStringList &fileNames);
     static void startVerifyWizard(const QString &path, const QString &checksumFile = QString());
 };
 
 namespace  CHECKSUM_ { // private namespace
 
 /** Wrapper for KProcess to handle errors and output. */
 class ChecksumProcess : public KProcess
 {
 Q_OBJECT
   public:
     ChecksumProcess(QObject *parent, const QString &path);
-    ~ChecksumProcess();
+    ~ChecksumProcess() override;
 
     QStringList stdOutput() const { return m_outputLines; }
     QStringList errOutput() const { return m_errorLines; }
 
   signals:
     void resultReady();
 
   private slots:
     void slotError(QProcess::ProcessError error);
     void slotFinished(int, QProcess::ExitStatus exitStatus);
 
   private:
     QStringList m_outputLines;
     QStringList m_errorLines;
     QTemporaryFile m_tmpOutFile;
     QTemporaryFile m_tmpErrFile;
 };
 
 /** Base class for common code in creation and verify wizard. */
 class ChecksumWizard : public QWizard
 {
     Q_OBJECT
 public:
     explicit ChecksumWizard(const QString &path);
-    virtual ~ChecksumWizard();
+    ~ChecksumWizard() override;
 
 private slots:
     void slotCurrentIdChanged(int id);
 
 protected:
     virtual QWizardPage *createIntroPage() = 0;
     virtual QWizardPage *createResultPage() = 0;
 
     virtual void onIntroPage() = 0;
     virtual void onProgressPage() = 0;
     virtual void onResultPage() = 0;
 
     QWizardPage *createProgressPage(const QString &title);
 
-    bool checkExists(const QString type);
+    bool checkExists(const QString& type);
     void runProcess(const QString &type, const QStringList &args);
     void addChecksumLine(KrTreeWidget *tree, const QString &line);
 
     const QString m_path;
     ChecksumProcess *m_process;
 
     QMap<QString, QString> m_checksumTools; // extension/typ-name -> binary name
 
     int m_introId, m_progressId, m_resultId;
 };
 
 class CreateWizard : public ChecksumWizard
 {
 Q_OBJECT
 public:
     CreateWizard(const QString &path, const QStringList &_files);
 
 public slots:
     void accept() Q_DECL_OVERRIDE;
 
 private:
     QWizardPage *createIntroPage() Q_DECL_OVERRIDE;
     QWizardPage *createResultPage() Q_DECL_OVERRIDE;
 
     void onIntroPage() Q_DECL_OVERRIDE;
     void onProgressPage() Q_DECL_OVERRIDE;
     void onResultPage() Q_DECL_OVERRIDE;
 
     void createChecksums();
     bool savePerFile();
     bool saveChecksumFile(const QStringList &data, const QString &filename = QString());
 
     const QStringList m_fileNames;
 
     QFutureWatcher<QStringList> m_listFilesWatcher;
 
     QString m_suggestedFilePath;
 
     // intro page
     KComboBox *m_methodBox;
     // result page
     KrTreeWidget *m_hashesTreeWidget;
     QLabel *m_errorLabel;
     KrListWidget *m_errorListWidget;
     QCheckBox *m_onePerFileBox;
 };
 
 class VerifyWizard : public ChecksumWizard
 {
 Q_OBJECT
 public:
   VerifyWizard(const QString &path, const QString &inputFile);
 
 private slots:
     void slotChecksumPathChanged(const QString &path);
 
 private:
     QWizardPage *createIntroPage() Q_DECL_OVERRIDE;
     QWizardPage *createResultPage() Q_DECL_OVERRIDE;
 
     void onIntroPage() Q_DECL_OVERRIDE;
     void onProgressPage() Q_DECL_OVERRIDE;
     void onResultPage() Q_DECL_OVERRIDE;
 
     bool isSupported(const QString &path);
 
     QString m_checksumFile;
 
     // intro page
     KrTreeWidget *m_hashesTreeWidget;
     // result page
     QLabel *m_outputLabel;
     KrListWidget *m_outputListWidget;
 };
 
 } // NAMESPACE CHECKSUM_
 
 #endif // CHECKSUMDLG_H
diff --git a/krusader/Dialogs/krdialogs.cpp b/krusader/Dialogs/krdialogs.cpp
index 5f24fe97..b293d90e 100644
--- a/krusader/Dialogs/krdialogs.cpp
+++ b/krusader/Dialogs/krdialogs.cpp
@@ -1,203 +1,203 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2000 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krdialogs.h"
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 // QtGui
 #include <QFontMetrics>
 #include <QKeyEvent>
 // QtWidgets
 #include <QApplication>
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QLabel>
 #include <QVBoxLayout>
 
 #include <KI18n/KLocalizedString>
 #include <KIOWidgets/KUrlCompletion>
 #include <KCompletion/KLineEdit>
 #include <KIOWidgets/KUrlRequester>
 #include <KIOCore/KRecentDocument>
 #include <KWidgetsAddons/KGuiItem>
 
 #include "../krglobal.h"
 #include "../FileSystem/filesystem.h"
 #include "../defaults.h"
 #include "../JobMan/jobman.h"
 
 
 QUrl KChooseDir::getFile(const QString &text, const QUrl& url, const QUrl& cwd)
 {
     return get(text, url, cwd, KFile::File);
 }
 
 QUrl KChooseDir::getDir(const QString &text, const QUrl& url, const QUrl& cwd)
 {
     return get(text, url, cwd, KFile::Directory);
 }
 
 QUrl KChooseDir::get(const QString &text, const QUrl &url, const QUrl &cwd, KFile::Modes mode)
 {
     QScopedPointer<KUrlRequesterDialog> dlg(new KUrlRequesterDialog(url, text, krMainWindow));
     dlg->urlRequester()->setStartDir(cwd);
     dlg->urlRequester()->setMode(mode);
     dlg->exec();
     QUrl u = dlg->selectedUrl(); // empty if cancelled
     if (u.scheme() == "zip" || u.scheme() == "krarc" || u.scheme() == "tar" || u.scheme() == "iso") {
         if (QDir(u.path()).exists()) {
             u.setScheme("file");
         }
     }
     return u;
 }
 
 KChooseDir::ChooseResult KChooseDir::getCopyDir(const QString &text, const QUrl &url,
                                                 const QUrl &cwd)
 {
     QScopedPointer<KUrlRequesterDlgForCopy> dlg(new KUrlRequesterDlgForCopy(url, text, krMainWindow, true));
 
     dlg->urlRequester()->setStartDir(cwd);
     dlg->urlRequester()->setMode(KFile::Directory);
     dlg->exec();
     QUrl u = dlg->selectedURL();
     if (u.scheme() == "zip" || u.scheme() == "krarc" || u.scheme() == "tar" || u.scheme() == "iso") {
         if (QDir(u.path()).exists()) {
             u.setScheme("file");
         }
     }
 
     ChooseResult result;
     result.url = u;
     result.enqueue = dlg->isQueued();
     return result;
 }
 
 KUrlRequesterDlgForCopy::KUrlRequesterDlgForCopy(const QUrl &urlName, const QString &_text,
                                                  QWidget *parent, bool modal)
     : QDialog(parent)
 {
     setWindowModality(modal ? Qt::WindowModal : Qt::NonModal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     mainLayout->addWidget(new QLabel(_text));
 
     urlRequester_ = new KUrlRequester(urlName, this);
     urlRequester_->setMinimumWidth(urlRequester_->sizeHint().width() * 3);
     mainLayout->addWidget(urlRequester_);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     mainLayout->addWidget(buttonBox);
     okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
 
     QPushButton *queueButton = new QPushButton(
         krJobMan->isQueueModeEnabled() ? i18n("F2 Delay Job Start") : i18n("F2 Queue"), this);
     queueButton->setToolTip(krJobMan->isQueueModeEnabled() ?
             i18n("Do not start the job now.") :
             i18n("Enqueue the job if another job is running. Otherwise start immediately."));
     buttonBox->addButton(queueButton, QDialogButtonBox::ActionRole);
 
     connect(buttonBox, &QDialogButtonBox::accepted, this, &KUrlRequesterDlgForCopy::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KUrlRequesterDlgForCopy::reject);
     connect(queueButton, &QPushButton::clicked, this, &KUrlRequesterDlgForCopy::slotQueueButtonClicked);
     connect(urlRequester_, &KUrlRequester::textChanged, this, &KUrlRequesterDlgForCopy::slotTextChanged);
 
     urlRequester_->setFocus();
     bool state = !urlName.isEmpty();
     okButton->setEnabled(state);
 }
 
 void KUrlRequesterDlgForCopy::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_F2:
         slotQueueButtonClicked();
         return;
     default:
         QDialog::keyPressEvent(e);
     }
 }
 
 void KUrlRequesterDlgForCopy::slotQueueButtonClicked()
 {
     queueStart = true;
     accept();
 }
 
 void KUrlRequesterDlgForCopy::slotTextChanged(const QString & text)
 {
     bool state = !text.trimmed().isEmpty();
     okButton->setEnabled(state);
 }
 
 QUrl KUrlRequesterDlgForCopy::selectedURL() const
 {
     if (result() == QDialog::Accepted) {
         QUrl url = urlRequester_->url();
         qDebug() << "requester returned URL=" << url.toDisplayString();
         if (url.isValid())
             KRecentDocument::add(url);
         return url;
     } else
         return QUrl();
 }
 
 KUrlRequester * KUrlRequesterDlgForCopy::urlRequester()
 {
     return urlRequester_;
 }
 
 KRGetDate::KRGetDate(QDate date, QWidget *parent) : QDialog(parent, Qt::MSWindowsFixedSizeDialogHint)
 {
     setWindowModality(Qt::WindowModal);
     dateWidget = new KDatePicker(this);
     dateWidget->setDate(date);
     dateWidget->resize(dateWidget->sizeHint());
     setMinimumSize(dateWidget->sizeHint());
     setMaximumSize(dateWidget->sizeHint());
     resize(minimumSize());
     connect(dateWidget, &KDatePicker::dateSelected, this, &KRGetDate::setDate);
     connect(dateWidget, &KDatePicker::dateEntered, this, &KRGetDate::setDate);
 
     // keep the original date - incase ESC is pressed
     originalDate  = date;
 }
 
 QDate KRGetDate::getDate()
 {
     if (exec() == QDialog::Rejected) chosenDate = QDate();
     hide();
     return chosenDate;
 }
 
 void KRGetDate::setDate(QDate date)
 {
     chosenDate = date;
     accept();
 }
 
diff --git a/krusader/Dialogs/krdialogs.h b/krusader/Dialogs/krdialogs.h
index f78b3357..d9c89b41 100644
--- a/krusader/Dialogs/krdialogs.h
+++ b/krusader/Dialogs/krdialogs.h
@@ -1,119 +1,119 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2000 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRDIALOGS_H
 #define KRDIALOGS_H
 
 // QtCore
 #include <QDateTime>
 #include <QUrl>
 // QtWidgets
 #include <QLineEdit>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QPushButton>
 // QtGui
 #include <QPixmap>
 
 #include <KWidgetsAddons/KAnimatedButton>
 #include <KIOWidgets/KFile>
 #include <KIOWidgets/KUrlRequesterDialog>
 #include <KWidgetsAddons/KDatePicker>
 
 /** \class KChooseDir
  * Used for asking the user for a folder.
  * example:
  * \code
  * QUrl u = KChooseDir::getDir("target folder", "/suggested/path", ACTIVE_PANEL->virtualPath());
  * if (u.isEmpty()) {
  *   // user canceled (either by pressing cancel, or esc
  * } else {
  *   // do you thing here: you've got a safe url to use
  * }
  * \endcode
  */
 class KChooseDir
 {
 public:
     struct ChooseResult {
         QUrl url;
         bool enqueue;
     };
 
     /**
      * \param text - description of the info requested from the user
      * \param url - a suggested url to appear in the box as a default choice
      * \param cwd - a path which is the current working directory (usually ACTIVE_PANEL->virtualPath()).
      *              this is used for completion of partial urls
      */
     static QUrl getFile(const QString &text, const QUrl &url, const QUrl &cwd);
     static QUrl getDir(const QString &text, const QUrl &url, const QUrl &cwd);
     static ChooseResult getCopyDir(const QString &text, const QUrl &url, const QUrl &cwd);
 
 
   private:
     static QUrl get(const QString &text, const QUrl &url, const QUrl &cwd, KFile::Modes mode);
 };
 
 class KUrlRequesterDlgForCopy : public QDialog
 {
     Q_OBJECT
 public:
     KUrlRequesterDlgForCopy(const QUrl& url, const QString& text, QWidget *parent,
                             bool modal = true);
 
     QUrl selectedURL() const;
     bool isQueued() { return queueStart; }
 
     KUrlRequester *urlRequester();
 
 protected:
-    virtual void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
+    void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
 
 private slots:
     void slotQueueButtonClicked();
     void slotTextChanged(const QString &);
 
 private:
     KUrlRequester *urlRequester_;
     QPushButton *okButton;
     bool queueStart = false;
 };
 
 class KRGetDate : public QDialog
 {
     Q_OBJECT
 public:
-    explicit KRGetDate(QDate date = QDate::currentDate(), QWidget *parent = 0);
+    explicit KRGetDate(QDate date = QDate::currentDate(), QWidget *parent = nullptr);
     QDate getDate();
 
 private slots:
     void setDate(QDate);
 
 private:
     KDatePicker *dateWidget;
     QDate chosenDate, originalDate;
 };
 
 #endif
diff --git a/krusader/Dialogs/krmaskchoice.cpp b/krusader/Dialogs/krmaskchoice.cpp
index 9c2e451b..1c5bf590 100644
--- a/krusader/Dialogs/krmaskchoice.cpp
+++ b/krusader/Dialogs/krmaskchoice.cpp
@@ -1,151 +1,151 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #include "krmaskchoice.h"
 
 // QtCore
 #include <QVariant>
 // QtWidgets
 #include <QGroupBox>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 
 #include <KCompletion/KComboBox>
 #include <KI18n/KLocalizedString>
 
 #include "../GUI/krlistwidget.h"
 
 /**
  * Constructs a KRMaskChoice which is a child of 'parent', with the
  * name 'name' and widget flags set to 'f'
  *
  * The dialog will by default be modeless, unless you set 'modal' to
  * TRUE to construct a modal dialog.
  */
 KRMaskChoice::KRMaskChoice(QWidget* parent)
         : QDialog(parent)
 {
     setModal(true);
     resize(401, 314);
     setWindowTitle(i18n("Choose Files"));
 
-    QVBoxLayout* MainLayout = new QVBoxLayout(this);
+    auto* MainLayout = new QVBoxLayout(this);
 
-    QHBoxLayout* HeaderLayout = new QHBoxLayout();
+    auto* HeaderLayout = new QHBoxLayout();
     MainLayout->addLayout(HeaderLayout);
 
     PixmapLabel1 = new QLabel(this);
     PixmapLabel1->setScaledContents(true);
     PixmapLabel1->setMaximumSize(QSize(31, 31));
     HeaderLayout->addWidget(PixmapLabel1);
 
     label = new QLabel(this);
     label->setText(i18n("Select the following files:"));
     HeaderLayout->addWidget(label);
 
     selection = new KComboBox(this);
     selection->setEditable(true);
     selection->setInsertPolicy(QComboBox::InsertAtTop);
     selection->setAutoCompletion(true);
     MainLayout->addWidget(selection);
 
-    QGroupBox* GroupBox1 = new QGroupBox(this);
+    auto* GroupBox1 = new QGroupBox(this);
     GroupBox1->setTitle(i18n("Predefined Selections"));
     MainLayout->addWidget(GroupBox1);
 
-    QHBoxLayout* gbLayout = new QHBoxLayout(GroupBox1);
+    auto* gbLayout = new QHBoxLayout(GroupBox1);
 
     preSelections = new KrListWidget(GroupBox1);
     preSelections->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
     preSelections->setWhatsThis(i18n("A predefined selection is a file-mask which you often use.\nSome examples are: \"*.c, *.h\", \"*.c, *.o\", etc.\nYou can add these masks to the list by typing them and pressing the Add button.\nDelete removes a predefined selection and Clear removes all of them.\nNotice that the line in which you edit the mask has its own history, you can scroll it, if needed."));
     gbLayout->addWidget(preSelections);
 
-    QVBoxLayout* vbox = new QVBoxLayout();
+    auto* vbox = new QVBoxLayout();
     gbLayout->addLayout(vbox);
 
     PushButton7 = new QPushButton(GroupBox1);
     PushButton7->setText(i18n("Add"));
     PushButton7->setToolTip(i18n("Adds the selection in the line-edit to the list"));
     vbox->addWidget(PushButton7);
 
     PushButton7_2 = new QPushButton(GroupBox1);
     PushButton7_2->setText(i18n("Delete"));
     PushButton7_2->setToolTip(i18n("Delete the marked selection from the list"));
     vbox->addWidget(PushButton7_2);
 
     PushButton7_3 = new QPushButton(GroupBox1);
     PushButton7_3->setText(i18n("Clear"));
     PushButton7_3->setToolTip(i18n("Clears the entire list of selections"));
     vbox->addWidget(PushButton7_3);
     vbox->addItem(new QSpacerItem(5, 5, QSizePolicy::Fixed, QSizePolicy::Expanding));
 
     QDialogButtonBox* ButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     MainLayout->addWidget(ButtonBox);
 
     // signals and slots connections
     connect(ButtonBox, &QDialogButtonBox::rejected, this, &KRMaskChoice::reject);
     connect(ButtonBox, &QDialogButtonBox::accepted, this, &KRMaskChoice::accept);
     connect(PushButton7, &QPushButton::clicked, this, &KRMaskChoice::addSelection);
     connect(PushButton7_2, &QPushButton::clicked, this, &KRMaskChoice::deleteSelection);
     connect(PushButton7_3, &QPushButton::clicked, this, &KRMaskChoice::clearSelections);
     connect(selection, QOverload<const QString &>::of(&KComboBox::activated), selection, &KComboBox::setEditText);
     connect(selection->lineEdit(), &QLineEdit::returnPressed, this, &KRMaskChoice::accept);
     connect(preSelections, &KrListWidget::currentItemChanged, this, &KRMaskChoice::currentItemChanged);
     connect(preSelections, &KrListWidget::itemActivated, this, &KRMaskChoice::acceptFromList);
 }
 
 /*
  *  Destroys the object and frees any allocated resources
  */
 KRMaskChoice::~KRMaskChoice()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 void KRMaskChoice::addSelection()
 {
     qWarning("KRMaskChoice::addSelection(): Not implemented yet!");
 }
 
 void KRMaskChoice::clearSelections()
 {
     qWarning("KRMaskChoice::clearSelections(): Not implemented yet!");
 }
 
 void KRMaskChoice::deleteSelection()
 {
     qWarning("KRMaskChoice::deleteSelection(): Not implemented yet!");
 }
 
 void KRMaskChoice::acceptFromList(QListWidgetItem *)
 {
     qWarning("KRMaskChoice::acceptFromList(QListWidgetItem *): Not implemented yet!");
 }
 
 void KRMaskChoice::currentItemChanged(QListWidgetItem *)
 {
     qWarning("KRMaskChoice::currentItemChanged(QListWidgetItem *): Not implemented yet!");
 }
 
diff --git a/krusader/Dialogs/krmaskchoice.h b/krusader/Dialogs/krmaskchoice.h
index e4a730c1..7b52778a 100644
--- a/krusader/Dialogs/krmaskchoice.h
+++ b/krusader/Dialogs/krmaskchoice.h
@@ -1,57 +1,57 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #ifndef KRMASKCHOICE_H
 #define KRMASKCHOICE_H
 
 // QtWidgets
 #include <QDialog>
 
 class QLabel;
 class QListWidgetItem;
 class QPushButton;
 class KComboBox;
 class KrListWidget;
 
 class KRMaskChoice : public QDialog
 {
     Q_OBJECT
 
 public:
-    explicit KRMaskChoice(QWidget* parent = 0);
-    ~KRMaskChoice();
+    explicit KRMaskChoice(QWidget* parent = nullptr);
+    ~KRMaskChoice() override;
 
     KComboBox* selection;
     QLabel* PixmapLabel1;
     QLabel* label;
     KrListWidget* preSelections;
     QPushButton* PushButton7;
     QPushButton* PushButton7_2;
     QPushButton* PushButton7_3;
 
 public slots:
     virtual void addSelection();
     virtual void clearSelections();
     virtual void deleteSelection();
     virtual void acceptFromList(QListWidgetItem *);
     virtual void currentItemChanged(QListWidgetItem *);
 };
 
 #endif // KRMASKCHOICE_H
diff --git a/krusader/Dialogs/krpleasewait.cpp b/krusader/Dialogs/krpleasewait.cpp
index 13a9ef9f..48479731 100644
--- a/krusader/Dialogs/krpleasewait.cpp
+++ b/krusader/Dialogs/krpleasewait.cpp
@@ -1,156 +1,156 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krpleasewait.h"
 
 // QtCore
 #include <QTimer>
 #include <QDateTime>
 // QtGui
 #include <QCloseEvent>
 // QtWidgets
 #include <QApplication>
 #include <QPushButton>
 #include <QLabel>
 #include <QProgressBar>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KCursor>
 
 #include "../krglobal.h"
 
-KRPleaseWait::KRPleaseWait(QString msg, QWidget *parent, int count, bool cancel):
-        QProgressDialog(cancel ? 0 : parent) , inc(true)
+KRPleaseWait::KRPleaseWait(const QString& msg, QWidget *parent, int count, bool cancel):
+        QProgressDialog(cancel ? nullptr : parent) , inc(true)
 {
     setModal(!cancel);
 
     timer = new QTimer(this);
     setWindowTitle(i18n("Krusader::Wait"));
 
     setMinimumDuration(500);
     setAutoClose(false);
     setAutoReset(false);
 
     connect(timer, &QTimer::timeout, this, &KRPleaseWait::cycleProgress);
 
-    QProgressBar* progress = new QProgressBar(this);
+    auto* progress = new QProgressBar(this);
     progress->setMaximum(count);
     progress->setMinimum(0);
     setBar(progress);
 
     QLabel* label = new QLabel(this);
     setLabel(label);
 
     QPushButton* btn = new QPushButton(i18n("&Cancel"), this);
     setCancelButton(btn);
 
     btn->setEnabled(canClose = cancel);
     setLabelText(msg);
 
     show();
 }
 
 void KRPleaseWait::closeEvent(QCloseEvent * e)
 {
     if (canClose) {
         emit canceled();
         e->accept();
     } else              /* if cancel is not allowed, we disable */
         e->ignore();         /* the window closing [x] also */
 }
 
 void KRPleaseWait::incProgress(int howMuch)
 {
     setValue(value() + howMuch);
 }
 
 void KRPleaseWait::cycleProgress()
 {
     if (inc) setValue(value() + 1);
     else     setValue(value() - 1);
     if (value() >= 9) inc = false;
     if (value() <= 0) inc = true;
 }
 
 KRPleaseWaitHandler::KRPleaseWaitHandler(QWidget *parentWindow)
-    : QObject(parentWindow), _parentWindow(parentWindow), job(), dlg(0)
+    : QObject(parentWindow), _parentWindow(parentWindow), dlg(nullptr)
 {
 }
 
 void KRPleaseWaitHandler::stopWait()
 {
-    if (dlg != 0) delete dlg;
-    dlg = 0;
+    if (dlg != nullptr) delete dlg;
+    dlg = nullptr;
     cycleMutex = incMutex = false;
     // return cursor to normal arrow
     _parentWindow->setCursor(Qt::ArrowCursor);
 }
 
 
-void KRPleaseWaitHandler::startWaiting(QString msg, int count , bool cancel)
+void KRPleaseWaitHandler::startWaiting(const QString& msg, int count , bool cancel)
 {
-    if (dlg == 0) {
+    if (dlg == nullptr) {
         dlg = new KRPleaseWait(msg , _parentWindow, count, cancel);
         connect(dlg, &KRPleaseWait::canceled, this, &KRPleaseWaitHandler::killJob);
     }
     incMutex = cycleMutex = _wasCancelled = false;
     dlg->setValue(0);
 
     dlg->setLabelText(msg);
     if (count == 0) {
         dlg->setMaximum(10);
         cycle = true;
         cycleProgress();
     } else {
         dlg->setMaximum(count);
         cycle = false;
     }
 }
 
 void KRPleaseWaitHandler::cycleProgress()
 {
     if (cycleMutex) return;
     cycleMutex = true;
     if (dlg) dlg->cycleProgress();
     if (cycle) QTimer::singleShot(2000, this, &KRPleaseWaitHandler::cycleProgress);
     cycleMutex = false;
 }
 
 void KRPleaseWaitHandler::killJob()
 {
     if (!job.isNull()) job->kill(KJob::EmitResult);
     stopWait();
     _wasCancelled = true;
 }
 
 void KRPleaseWaitHandler::setJob(KIO::Job* j)
 {
     job = j;
 }
 
 void KRPleaseWaitHandler::incProgress(int i)
 {
     if (incMutex) return;
     incMutex = true;
     if (dlg) dlg->incProgress(i);
     incMutex = false;
 }
 
diff --git a/krusader/Dialogs/krpleasewait.h b/krusader/Dialogs/krpleasewait.h
index 3d11e2ca..febceda4 100644
--- a/krusader/Dialogs/krpleasewait.h
+++ b/krusader/Dialogs/krpleasewait.h
@@ -1,81 +1,81 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRPLEASEWAIT_H
 #define KRPLEASEWAIT_H
 
 // QtCore
 #include <QTimer>
 #include <QPointer>
 // QtGui
 #include <QCloseEvent>
 // QtWidgets
 #include <QProgressDialog>
 
 #include <KIO/Job>
 
 class KRPleaseWait;
 
 class KRPleaseWaitHandler : public QObject
 {
     Q_OBJECT
 
 public:
     explicit KRPleaseWaitHandler(QWidget *parentWindow);
 
 public slots:
 
-    void startWaiting(QString msg, int count = 0, bool cancel = false);
+    void startWaiting(const QString& msg, int count = 0, bool cancel = false);
     void stopWait();
     void cycleProgress();
     void incProgress(int i);
     void killJob();
     void setJob(KIO::Job* j);
     bool wasCancelled() const {
         return _wasCancelled;
     }
 
 private:
     QWidget *_parentWindow;
     QPointer<KIO::Job> job;
     KRPleaseWait * dlg;
     bool cycle, cycleMutex, incMutex, _wasCancelled;
 };
 
 
 class KRPleaseWait : public QProgressDialog
 {
     Q_OBJECT
 public:
-    KRPleaseWait(QString msg, QWidget *parent, int count = 0 , bool cancel = false);
+    KRPleaseWait(const QString& msg, QWidget *parent, int count = 0 , bool cancel = false);
 
 public slots:
     void incProgress(int howMuch);
     void cycleProgress();
 
 protected:
     bool inc;
     QTimer* timer;
-    virtual void closeEvent(QCloseEvent * e) Q_DECL_OVERRIDE;
+    void closeEvent(QCloseEvent * e) Q_DECL_OVERRIDE;
     bool canClose;
 };
 
 #endif
diff --git a/krusader/Dialogs/krspecialwidgets.cpp b/krusader/Dialogs/krspecialwidgets.cpp
index 8ed7936b..a4cd2e04 100644
--- a/krusader/Dialogs/krspecialwidgets.cpp
+++ b/krusader/Dialogs/krspecialwidgets.cpp
@@ -1,218 +1,219 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 
 #include "krspecialwidgets.h"
 #include "krmaskchoice.h"
 #include "newftpgui.h"
 #include "../krglobal.h"
 
 // QtGui
 #include <QPaintEvent>
 
 #include <KI18n/KLocalizedString>
+#include <utility>
 
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////// Pie related widgets /////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////
 // The pie-related widgets use hard-coded coordinates to create the look.
 // This is ok since the whole widget is fitted into an existing view and thus
 // no re-alignments are needed.
 
 #define LEFT       10
 #define BOTTOM     150
 #define WIDTH      120
 #define HEIGHT     40
 #define Z_HEIGHT   10
 #define STARTANGLE 0
 #define DEG(x)     (16*(x))
 
 QColor KRPie::colors[ 12 ] = {Qt::red, Qt::blue, Qt::green, Qt::cyan, Qt::magenta, Qt::gray,
                               Qt::black, Qt::white, Qt::darkRed, Qt::darkBlue, Qt::darkMagenta,
                               Qt::darkCyan
                              };
 
 //////////////////////////////////////////////////////////////////////////////
 /////////////// KRFSDisplay - Filesystem / Freespace Display /////////////////
 //////////////////////////////////////////////////////////////////////////////
 // This is the full constructor: use it for a mounted filesystem
 KRFSDisplay::KRFSDisplay(QWidget *parent, QString _alias, QString _realName,
                          KIO::filesize_t _total, KIO::filesize_t _free) : QWidget(parent), totalSpace(_total),
-        freeSpace(_free), alias(_alias), realName(_realName), mounted(true),
+        freeSpace(_free), alias(std::move(_alias)), realName(std::move(_realName)), mounted(true),
         empty(false), supermount(false)
 {
 
     int leftMargin, topMargin, rightMargin, bottomMargin;
     getContentsMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin);
     resize(150 + leftMargin + rightMargin, 200 + topMargin + bottomMargin);
     setMinimumSize(150 + leftMargin + rightMargin, 200 + topMargin + bottomMargin);
     show();
 }
 
 // Use this one for an unmounted filesystem
 KRFSDisplay::KRFSDisplay(QWidget *parent, QString _alias, QString _realName, bool sm) :
-        QWidget(parent), alias(_alias), realName(_realName), mounted(false),
+        QWidget(parent), alias(std::move(_alias)), realName(std::move(_realName)), mounted(false),
         empty(false), supermount(sm)
 {
 
     int leftMargin, topMargin, rightMargin, bottomMargin;
     getContentsMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin);
     resize(150 + leftMargin + rightMargin, 200 + topMargin + bottomMargin);
     setMinimumSize(150 + leftMargin + rightMargin, 200 + topMargin + bottomMargin);
     show();
 }
 
 // This is used only when an empty widget needs to be displayed (for example:
 // when filesystem statistics haven't been calculated yet)
 KRFSDisplay::KRFSDisplay(QWidget *parent) : QWidget(parent), empty(true)
 {
 
     int leftMargin, topMargin, rightMargin, bottomMargin;
     getContentsMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin);
     resize(150 + leftMargin + rightMargin, 200 + topMargin + bottomMargin);
     setMinimumSize(150 + leftMargin + rightMargin, 200 + topMargin + bottomMargin);
     show();
 }
 
 
 // The main painter!
 void KRFSDisplay::paintEvent(QPaintEvent *)
 {
     QPainter paint(this);
     if (!empty) {
         int leftMargin, topMargin, rightMargin, bottomMargin;
         getContentsMargins(&leftMargin, &topMargin, &rightMargin, &bottomMargin);
         // create the text
         // first, name and location
         QFont font = paint.font();
         font.setWeight(QFont::Bold);
         paint.setFont(font);
         paint.drawText(leftMargin + 10, topMargin + 20, alias);
 
         font.setWeight(QFont::Normal);
         paint.setFont(font);
         paint.drawText(leftMargin + 10, topMargin + 37, '(' + realName + ')');
 
         if (mounted) {    // incase the filesystem is already mounted
             // second, the capacity
             paint.drawText(leftMargin + 10, topMargin + 70, i18n("Capacity: %1", KIO::convertSizeFromKiB(totalSpace)));
             // third, the 2 boxes (used, free)
             QPen systemPen = paint.pen();
             paint.setPen(Qt::black);
             paint.drawRect(leftMargin + 10, topMargin + 90, 10, 10);
             paint.fillRect(leftMargin + 11, topMargin + 91, 8, 8, QBrush(Qt::gray));
             paint.drawRect(leftMargin + 10, topMargin + 110, 10, 10);
             paint.fillRect(leftMargin + 11, topMargin + 111, 8, 8, QBrush(Qt::white));
             // now, the text for the boxes
             paint.setPen(systemPen);
             paint.drawText(leftMargin + 25, topMargin + 100, i18n("Used: %1", KIO::convertSizeFromKiB(totalSpace - freeSpace)));
             paint.drawText(leftMargin + 25, topMargin + 120, i18n("Free: %1", KIO::convertSizeFromKiB(freeSpace)));
             // first, create the empty pie
             // bottom...
             paint.setPen(Qt::black);
             paint.setBrush(Qt::white);
             paint.drawPie(leftMargin + LEFT, topMargin + BOTTOM, WIDTH, HEIGHT, STARTANGLE, DEG(360));
             // body...
             paint.setPen(Qt::lightGray);
             for (int i = 1; i < Z_HEIGHT; ++i)
                 paint.drawPie(leftMargin + LEFT, topMargin + BOTTOM - i, WIDTH, HEIGHT, STARTANGLE, DEG(360));
             // side lines...
             paint.setPen(Qt::black);
             paint.drawLine(leftMargin + LEFT, topMargin + BOTTOM + HEIGHT / 2, LEFT, BOTTOM + HEIGHT / 2 - Z_HEIGHT);
             paint.drawLine(leftMargin + LEFT + WIDTH, topMargin + BOTTOM + HEIGHT / 2, LEFT + WIDTH, BOTTOM + HEIGHT / 2 - Z_HEIGHT);
             // top of the pie
             paint.drawPie(leftMargin + LEFT, topMargin + BOTTOM - Z_HEIGHT, WIDTH, HEIGHT, STARTANGLE, DEG(360));
             // the "used space" slice
             float i = ((float)(totalSpace - freeSpace) / (totalSpace)) * 360.0;
             paint.setBrush(Qt::gray);
             paint.drawPie(leftMargin + LEFT, topMargin + BOTTOM - Z_HEIGHT, WIDTH, HEIGHT, STARTANGLE, (int) DEG(i));
             // if we need to draw a 3d stripe ...
             if (i > 180.0) {
                 for (int j = 1; j < Z_HEIGHT; ++j)
                     paint.drawArc(leftMargin + LEFT, topMargin + BOTTOM - j, WIDTH, HEIGHT, STARTANGLE - 16 * 180, (int)(DEG(i - 180.0)));
             }
         } else {  // if the filesystem is unmounted...
             font.setWeight(QFont::Bold);
             paint.setFont(font);
             paint.drawText(leftMargin + 10, topMargin + 60, i18n("Not mounted."));
         }
     } else {  // if the widget is in empty situation...
 
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 KRPie::KRPie(KIO::filesize_t _totalSize, QWidget *parent) : QWidget(parent), totalSize(_totalSize)
 {
     slices.push_back(KRPieSlice(100, Qt::yellow, "DEFAULT"));
     sizeLeft = totalSize;
     resize(300, 300);
 }
 
 void KRPie::paintEvent(QPaintEvent *)
 {
     QPainter paint(this);
     // now create the slices
     float sAngle = STARTANGLE;
     for (int ndx = 0; ndx != slices.count(); ndx++) {
         paint.setBrush(slices[ndx].getColor());
         paint.setPen(slices[ndx].getColor());
         // angles are negative to create a clock-wise drawing of slices
         float angle = -(slices[ndx].getPerct() / 100 * 360) * 16;
         for (int i = 1; i < Z_HEIGHT; ++i)
             paint.drawPie(LEFT, BOTTOM + i, WIDTH, HEIGHT, (int) sAngle, (int) angle);
         sAngle += angle;
     }
     paint.setPen(Qt::yellow);     // pen
     paint.setBrush(Qt::yellow);   // fill
     // for (int i=1; i<Z_HEIGHT; ++i)
     //  paint.drawPie(LEFT,BOTTOM+i,WIDTH,HEIGHT,sAngle,360*16-(STARTANGLE-sAngle));
     sAngle = STARTANGLE;
     for (int ndx = 0; ndx != slices.count(); ndx++) {
         paint.setBrush(slices[ndx].getColor());
         paint.setPen(slices[ndx].getColor());
         // angles are negative to create a clock-wise drawing of slices
         float angle = -(slices[ndx].getPerct() / 100 * 360) * 16;
         paint.drawPie(LEFT, BOTTOM, WIDTH, HEIGHT, (int) sAngle, (int) angle);
         sAngle += angle;
     }
 
 
     paint.setPen(Qt::black);
     // the pie
     //  paint.drawPie(LEFT,BOTTOM,WIDTH,HEIGHT,STARTANGLE,360*16);
     ///////////////////////// end of empty pie /////////////////////////
     // now, the pie is ready to draw slices on...
     // to make a good look on the perimeter, draw another black circle
     paint.setPen(Qt::black);
     paint.drawArc(LEFT, BOTTOM, WIDTH, HEIGHT, STARTANGLE, 360 * 16);
 
 }
 
 void KRPie::addSlice(KIO::filesize_t size, QString label)
 {
     int i = (slices.count() % 12);
     slices.removeLast();
-    slices.push_back(KRPieSlice(size * 100 / totalSize, colors[ i ], label));
+    slices.push_back(KRPieSlice(size * 100 / totalSize, colors[ i ], std::move(label)));
     sizeLeft -= size;
     slices.push_back(KRPieSlice(sizeLeft * 100 / totalSize, Qt::yellow, "DEFAULT"));
 }
diff --git a/krusader/Dialogs/krspecialwidgets.h b/krusader/Dialogs/krspecialwidgets.h
index 71d16e49..825c3cfb 100644
--- a/krusader/Dialogs/krspecialwidgets.h
+++ b/krusader/Dialogs/krspecialwidgets.h
@@ -1,126 +1,127 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 #ifndef KRSPECIALWIDGETS_H
 #define KRSPECIALWIDGETS_H
 
 // QtCore
 #include <QEvent>
 // QtGui
 #include <QPainter>
 #include <QKeyEvent>
 #include <QPaintEvent>
 #include <QColor>
 // QtWidgets
 #include <QWidget>
 
 #include <KCompletion/KLineEdit>
 #include <KIO/Global>
+#include <utility>
 
 class KRPieSlice;
 
 class KRPie : public QWidget
 {
     Q_OBJECT
 public:
-    explicit KRPie(KIO::filesize_t _totalSize, QWidget *parent = 0);
+    explicit KRPie(KIO::filesize_t _totalSize, QWidget *parent = nullptr);
     void addSlice(KIO::filesize_t size, QString label);
 
 protected:
     void paintEvent(QPaintEvent *) Q_DECL_OVERRIDE;
 
 private:
     QList<KRPieSlice> slices;
     KIO::filesize_t totalSize, sizeLeft;
     static QColor colors[ 12 ];
 };
 
 class KRFSDisplay : public QWidget
 {
     Q_OBJECT
 public:
     // this constructor is used for a mounted filesystem
     KRFSDisplay(QWidget *parent, QString _alias, QString _realName,
                 KIO::filesize_t _total, KIO::filesize_t _free);
     // this one is for an unmounted/supermount file system
     KRFSDisplay(QWidget *parent, QString _alias, QString _realName, bool sm = false);
     // the last one is used inside MountMan(R), when no filesystem is selected
     explicit KRFSDisplay(QWidget *parent);
     inline void setTotalSpace(KIO::filesize_t t) {
         totalSpace = t;
     }
     inline void setFreeSpace(KIO::filesize_t t) {
         freeSpace = t;
     }
     inline void setAlias(QString a) {
-        alias = a;
+        alias = std::move(a);
     }
     inline void setRealName(QString r) {
-        realName = r;
+        realName = std::move(r);
     }
     inline void setMounted(bool m) {
         mounted = m;
     }
     inline void setEmpty(bool e) {
         empty = e;
     }
     inline void setSupermount(bool s) {
         supermount = s;
     }
 
 protected:
     void paintEvent(QPaintEvent *) Q_DECL_OVERRIDE;
 
 private:
     KIO::filesize_t totalSpace, freeSpace;
     QString alias, realName;
     bool mounted, empty, supermount;
 };
 
 class KRPieSlice
 {
 public:
     KRPieSlice(float _perct, QColor _color, QString _label) :
-            perct(_perct), color(_color), label(_label) {}
+            perct(_perct), color(std::move(_color)), label(std::move(_label)) {}
     inline QColor getColor() {
         return color;
     }
     inline float getPerct() {
         return perct;
     }
     inline QString getLabel() {
         return label;
     }
     inline void setPerct(float _perct) {
         perct = _perct;
     }
     inline void setLabel(QString _label) {
-        label = _label;
+        label = std::move(_label);
     }
 
 private:
     float perct;
     QColor color;
     QString label;
 };
 
 #endif
diff --git a/krusader/Dialogs/krspwidgets.cpp b/krusader/Dialogs/krspwidgets.cpp
index 0eed58ef..9017ad0a 100644
--- a/krusader/Dialogs/krspwidgets.cpp
+++ b/krusader/Dialogs/krspwidgets.cpp
@@ -1,259 +1,258 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krspwidgets.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../Filter/filtertabs.h"
 #include "../GUI/krlistwidget.h"
 
 // QtCore
 #include <QEvent>
 // QtGui
 #include <QBitmap>
 // QtWidgets
 #include <QComboBox>
 #include <QLabel>
 #include <QLineEdit>
 #include <QCheckBox>
 #include <QSpinBox>
 #include <qnamespace.h>		// missing ?
 
 #include <KCompletion/KComboBox>
 #include <KCompletion/KHistoryComboBox>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KCursor>
 
 ///////////////////// initiation of the static members ////////////////////////
 QStringList KRSpWidgets::maskList;
 
 ///////////////////////////////////////////////////////////////////////////////
 
 KRSpWidgets::KRSpWidgets()
-{
-}
+= default;
 
-KRQuery KRSpWidgets::getMask(QString caption, bool nameOnly, QWidget * parent)
+KRQuery KRSpWidgets::getMask(const QString& caption, bool nameOnly, QWidget * parent)
 {
     if (!nameOnly) {
         return FilterTabs::getQuery(parent);
     } else {
         QPointer<KRMaskChoiceSub> p = new KRMaskChoiceSub(parent);
         p->setWindowTitle(caption);
         p->exec();
         QString selection = p->selection->currentText();
         delete p;
         if (selection.isEmpty()) {
             return KRQuery();
         } else {
             return KRQuery(selection);
         }
     }
 }
 
 /////////////////////////// newFTP ////////////////////////////////////////
 QUrl KRSpWidgets::newFTP()
 {
     QPointer<newFTPSub> p = new newFTPSub();
     p->exec();
     QString uri = p->url->currentText();
     if (uri.isEmpty()) {
         delete p;
         return QUrl(); // empty url
     }
 
     QString protocol = p->prefix->currentText();
     protocol.truncate(protocol.length() - 3); // remove the trailing ://
 
     QString username = p->username->text().simplified();
     QString password = p->password->text().simplified();
 
     int uriStart = uri.lastIndexOf('@'); /* lets the user enter user and password in the URI field */
     if (uriStart != -1) {
         QString uriUser = uri.left(uriStart);
         QString uriPsw;
         uri = uri.mid(uriStart + 1);
 
         int pswStart = uriUser.indexOf(':'); /* getting the password name from the URL */
         if (pswStart != -1) {
             uriPsw = uriUser.mid(pswStart + 1);
             uriUser = uriUser.left(pswStart);
         }
 
         if (!uriUser.isEmpty()) { /* handling the ftp proxy username and password also */
             username = username.isEmpty() ? uriUser : username + '@' + uriUser;
         }
 
         if (!uriPsw.isEmpty()) { /* handling the ftp proxy username and password also */
             password = password.isEmpty() ? uriPsw : password + '@' + uriPsw;
         }
     }
 
     QString host = uri; /* separating the hostname and path from the uri */
     QString path;
     int pathStart = uri.indexOf("/");
     if (pathStart != -1) {
         path = host.mid(pathStart);
         host = host.left(pathStart);
     }
 
     /* setting the parameters of the URL */
     QUrl url;
     url.setScheme(protocol);
     url.setHost(host);
     url.setPath(path);
     if (protocol == "ftp" || protocol == "fish" || protocol == "sftp") {
         url.setPort(p->port->cleanText().toInt());
     }
     if (!username.isEmpty()) {
         url.setUserName(username);
     }
     if (!password.isEmpty()) {
         url.setPassword(password);
     }
 
     delete p;
     return url;
 }
 
-newFTPSub::newFTPSub() : newFTPGUI(0)
+newFTPSub::newFTPSub() : newFTPGUI(nullptr)
 {
     url->setFocus();
     setGeometry(krMainWindow->x() + krMainWindow->width() / 2 - width() / 2,
                 krMainWindow->y() + krMainWindow->height() / 2 - height() / 2, width(), height());
 }
 
 void newFTPSub::accept()
 {
     url->addToHistory(url->currentText());
     // save the history and completion list when the history combo is
     // destroyed
     KConfigGroup group(krConfig, "Private");
     QStringList list = url->completionObject()->items();
     group.writeEntry("newFTP Completion list", list);
     list = url->historyItems();
     group.writeEntry("newFTP History list", list);
     QString protocol = prefix->currentText();
     group.writeEntry("newFTP Protocol", protocol);
 
     newFTPGUI::accept();
 }
 
 void newFTPSub::reject()
 {
     url->lineEdit()->setText("");
     newFTPGUI::reject();
 }
 
 /////////////////////////// KRMaskChoiceSub ///////////////////////////////
 KRMaskChoiceSub::KRMaskChoiceSub(QWidget * parent) : KRMaskChoice(parent)
 {
     PixmapLabel1->setPixmap(Icon("edit-select").pixmap(32));
     label->setText(i18n("Enter a selection:"));
     // the predefined selections list
     KConfigGroup group(krConfig, "Private");
     QStringList lst = group.readEntry("Predefined Selections", QStringList());
     if (lst.size() > 0) preSelections->addItems(lst);
     // the combo-box tweaks
     selection->setDuplicatesEnabled(false);
     selection->addItems(KRSpWidgets::maskList);
     selection->lineEdit()->setText("*");
     selection->lineEdit()->selectAll();
     selection->setFocus();
 }
 
 void KRMaskChoiceSub::reject()
 {
     selection->clear();
     KRMaskChoice::reject();
 }
 
 void KRMaskChoiceSub::accept()
 {
     bool add = true;
     // make sure we don't have that already
     for (int i = 0; i != KRSpWidgets::maskList.count(); i++)
         if (KRSpWidgets::maskList[ i ].simplified() == selection->currentText().simplified()) {
             // break if we found one such as this
             add = false;
             break;
         }
 
     if (add)
         KRSpWidgets::maskList.insert(0, selection->currentText().toLocal8Bit());
     // write down the predefined selections list
     QStringList list;
 
     for (int j = 0; j != preSelections->count(); j++) {
         QListWidgetItem *i = preSelections->item(j);
         list.append(i->text());
     }
 
     KConfigGroup group(krConfig, "Private");
     group.writeEntry("Predefined Selections", list);
     KRMaskChoice::accept();
 }
 
 void KRMaskChoiceSub::addSelection()
 {
     QString temp = selection->currentText();
     bool itemExists = false;
 
     // check if the selection already exists
     for (int j = 0; j != preSelections->count(); j++) {
         QListWidgetItem *i = preSelections->item(j);
 
         if (i->text() == temp) {
             itemExists = true;
             break;
         }
     }
 
     if (!temp.isEmpty() && !itemExists) {
         preSelections->addItem(selection->currentText());
         preSelections->update();
     }
 }
 
 void KRMaskChoiceSub::deleteSelection()
 {
     delete preSelections->currentItem();
     preSelections->update();
 }
 
 void KRMaskChoiceSub::clearSelections()
 {
     preSelections->clear();
     preSelections->update();
 }
 
 void KRMaskChoiceSub::acceptFromList(QListWidgetItem *i)
 {
     selection->addItem(i->text(), 0);
     accept();
 }
 
 void KRMaskChoiceSub::currentItemChanged(QListWidgetItem *i)
 {
     if (i)
         selection->setEditText(i->text());
 }
diff --git a/krusader/Dialogs/krspwidgets.h b/krusader/Dialogs/krspwidgets.h
index bd277e55..3de8cd38 100644
--- a/krusader/Dialogs/krspwidgets.h
+++ b/krusader/Dialogs/krspwidgets.h
@@ -1,83 +1,83 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #ifndef KRSPWIDGETS_H
 #define KRSPWIDGETS_H
 
 // QtCore
 #include <QEvent>
 // QtGui
 #include <QMouseEvent>
 
 #include <KCompletion/KLineEdit>
 #include <KNotifications/KPassivePopup>
 
 #include "krmaskchoice.h"
 #include "newftpgui.h"
 #include "../FileSystem/krquery.h"
 
 class KRMaskChoiceSub;
 
 class KRSpWidgets
 {
     friend class KRMaskChoiceSub;
 
 public:
     KRSpWidgets();
 
-    static KRQuery getMask(QString caption, bool nameOnly = false, QWidget * parent = 0); // get file-mask for (un)selecting files
+    static KRQuery getMask(const QString& caption, bool nameOnly = false, QWidget * parent = 0); // get file-mask for (un)selecting files
     static QUrl newFTP();
 
 private:
     static QStringList maskList;  // used by KRMaskChoiceSub
 };
 
 /////////////////////////// newFTPSub ///////////////////////////////////////
 class newFTPSub : public newFTPGUI
 {
 public:
     newFTPSub();
 
 protected:
     void reject() Q_DECL_OVERRIDE;
     void accept() Q_DECL_OVERRIDE;
 };
 
 /////////////////////////// KRMaskChoiceSub /////////////////////////////////
 // Inherits KRMaskChoice's generated code to fully implement the functions //
 /////////////////////////////////////////////////////////////////////////////
 class KRMaskChoiceSub : public KRMaskChoice
 {
 public:
     explicit KRMaskChoiceSub(QWidget * parent = 0);
 
 public slots:
     void addSelection() Q_DECL_OVERRIDE;
     void deleteSelection() Q_DECL_OVERRIDE;
     void clearSelections() Q_DECL_OVERRIDE;
     void acceptFromList(QListWidgetItem *i) Q_DECL_OVERRIDE;
     void currentItemChanged(QListWidgetItem *i) Q_DECL_OVERRIDE;
 
 protected:
     void reject() Q_DECL_OVERRIDE;
     void accept() Q_DECL_OVERRIDE;
 };
 
 #endif
diff --git a/krusader/Dialogs/krsqueezedtextlabel.cpp b/krusader/Dialogs/krsqueezedtextlabel.cpp
index 4dc16881..100f9bf6 100644
--- a/krusader/Dialogs/krsqueezedtextlabel.cpp
+++ b/krusader/Dialogs/krsqueezedtextlabel.cpp
@@ -1,103 +1,102 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krsqueezedtextlabel.h"
 
 // QtGui
 #include <QDragEnterEvent>
 #include <QPainter>
 // QtWidgets
 #include <QToolTip>
 #include <QLabel>
 
 #include <KCoreAddons/KUrlMimeData>
 #include <KCoreAddons/KStringHandler>
 
 KrSqueezedTextLabel::KrSqueezedTextLabel(QWidget *parent):
         KSqueezedTextLabel(parent), _index(-1), _length(-1)
 {
     setAutoFillBackground(true);
 }
 
 
 KrSqueezedTextLabel::~KrSqueezedTextLabel()
-{
-}
+= default;
 
 void KrSqueezedTextLabel::mousePressEvent(QMouseEvent *e)
 {
     e->ignore();
     emit clicked(e);
 }
 
 void KrSqueezedTextLabel::squeezeTextToLabel(int index, int length)
 {
     if (index == -1 || length == -1)
         KSqueezedTextLabel::squeezeTextToLabel();
     else {
         QString sqtext = fullText;
         QFontMetrics fm(fontMetrics());
         int labelWidth = size().width();
         int textWidth = fm.width(sqtext);
         if (textWidth > labelWidth) {
             int avgCharSize = textWidth / sqtext.length();
             int numOfExtraChars = (textWidth - labelWidth) / avgCharSize;
             int delta;
 
             // remove as much as possible from the left, and then from the right
             if (index > 3) {
                 delta = qMin(index, numOfExtraChars);
                 numOfExtraChars -= delta;
                 sqtext.replace(0, delta, "...");
             }
 
             if (numOfExtraChars > 0 && ((int)sqtext.length() > length + 3)) {
                 delta = qMin(numOfExtraChars, (int)sqtext.length() - (length + 3));
                 sqtext.replace(sqtext.length() - delta, delta, "...");
             }
             QLabel::setText(sqtext);
 
             setToolTip(QString());
             setToolTip(fullText);
         } else {
             QLabel::setText(fullText);
 
             setToolTip(QString());
             QToolTip::hideText();
         }
     }
 }
 
 void KrSqueezedTextLabel::setText(const QString &text, int index, int length)
 {
     _index = index;
     _length = length;
     fullText = text;
     KSqueezedTextLabel::setText(fullText);
     squeezeTextToLabel(_index, _length);
 }
 
 void KrSqueezedTextLabel::paintEvent(QPaintEvent * e)
 {
     KSqueezedTextLabel::paintEvent(e);
 }
 
 
diff --git a/krusader/Dialogs/krsqueezedtextlabel.h b/krusader/Dialogs/krsqueezedtextlabel.h
index 14426857..a55a2970 100644
--- a/krusader/Dialogs/krsqueezedtextlabel.h
+++ b/krusader/Dialogs/krsqueezedtextlabel.h
@@ -1,70 +1,70 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRSQUEEZEDTEXTLABEL_H
 #define KRSQUEEZEDTEXTLABEL_H
 
 // QtGui
 #include <QMouseEvent>
 #include <QDragEnterEvent>
 #include <QResizeEvent>
 
 #include <KWidgetsAddons/KSqueezedTextLabel>
 
 class QMouseEvent;
 class QDragEnterEvent;
 class QPaintEvent;
 
 /**
 This class overloads KSqueezedTextLabel and simply adds a clicked signal,
 so that users will be able to click the label and switch focus between panels.
 
 NEW: a special setText() method allows to choose which part of the string should
      be displayed (example: make sure that search results won't be cut out)
 */
 class KrSqueezedTextLabel : public KSqueezedTextLabel
 {
     Q_OBJECT
 public:
-    explicit KrSqueezedTextLabel(QWidget *parent = 0);
-    ~KrSqueezedTextLabel();
+    explicit KrSqueezedTextLabel(QWidget *parent = nullptr);
+    ~KrSqueezedTextLabel() override;
 
 public slots:
     void setText(const QString &text, int index = -1, int length = -1);
 
 signals:
     void clicked(QMouseEvent *); /**< emitted when someone clicks on the label */
 
 protected:
     void resizeEvent(QResizeEvent *) Q_DECL_OVERRIDE {
         squeezeTextToLabel(_index, _length);
     }
-    virtual void mousePressEvent(QMouseEvent *e) Q_DECL_OVERRIDE;
-    virtual void paintEvent(QPaintEvent * e) Q_DECL_OVERRIDE;
+    void mousePressEvent(QMouseEvent *e) Q_DECL_OVERRIDE;
+    void paintEvent(QPaintEvent * e) Q_DECL_OVERRIDE;
     void squeezeTextToLabel(int index = -1, int length = -1);
 
     QString fullText;
 
 private:
     int _index, _length;
 };
 
 #endif
diff --git a/krusader/Dialogs/kurllistrequester.cpp b/krusader/Dialogs/kurllistrequester.cpp
index 9b0c5642..f5dfacbe 100644
--- a/krusader/Dialogs/kurllistrequester.cpp
+++ b/krusader/Dialogs/kurllistrequester.cpp
@@ -1,187 +1,187 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kurllistrequester.h"
 #include "../FileSystem/filesystem.h"
 #include "../icon.h"
 
 // QtGui
 #include <QPixmap>
 #include <QCursor>
 #include <QKeyEvent>
 // QtWidgets
 #include <QFileDialog>
 #include <QLayout>
 #include <QGridLayout>
 #include <QMenu>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #define DELETE_ITEM_ID    100
 
 KURLListRequester::KURLListRequester(Mode requestMode, QWidget *parent)
     : QWidget(parent), mode(requestMode)
 {
     // Creating the widget
 
-    QGridLayout *urlListRequesterGrid = new QGridLayout(this);
+    auto *urlListRequesterGrid = new QGridLayout(this);
     urlListRequesterGrid->setSpacing(0);
     urlListRequesterGrid->setContentsMargins(0, 0, 0, 0);
 
     urlLineEdit = new KLineEdit(this);
     urlListRequesterGrid->addWidget(urlLineEdit, 0, 0);
 
     urlAddBtn = new QToolButton(this);
     urlAddBtn->setText("");
     urlAddBtn->setIcon(Icon("arrow-down"));
     urlListRequesterGrid->addWidget(urlAddBtn, 0, 1);
 
     urlBrowseBtn = new QToolButton(this);
     urlBrowseBtn->setText("");
     urlBrowseBtn->setIcon(Icon("folder"));
     urlListRequesterGrid->addWidget(urlBrowseBtn, 0, 2);
 
     urlListBox = new KrListWidget(this);
     urlListBox->setSelectionMode(QAbstractItemView::ExtendedSelection);
     urlListRequesterGrid->addWidget(urlListBox, 1, 0, 1, 3);
 
     // add shell completion
 
     completion.setMode(KUrlCompletion::FileCompletion);
     urlLineEdit->setCompletionObject(&completion);
 
     // connection table
 
     connect(urlAddBtn, &QToolButton::clicked, this, &KURLListRequester::slotAdd);
     connect(urlBrowseBtn, &QToolButton::clicked, this, &KURLListRequester::slotBrowse);
     connect(urlLineEdit, &KLineEdit::returnPressed, this, &KURLListRequester::slotAdd);
     connect(urlListBox, &KrListWidget::itemRightClicked, this, &KURLListRequester::slotRightClicked);
     connect(urlLineEdit, &KLineEdit::textChanged, this, &KURLListRequester::changed);
 }
 
 void KURLListRequester::slotAdd()
 {
     QString text = urlLineEdit->text().simplified();
     if (text.length()) {
         QString error;
         emit checkValidity(text, error);
 
         if (!error.isNull())
             KMessageBox::error(this, error);
         else {
             urlListBox->addItem(text);
             urlLineEdit->clear();
             emit changed();
         }
     }
 }
 
 void KURLListRequester::slotBrowse()
 {
     QUrl url;
     switch (mode) {
         case RequestFiles:
             url = QFileDialog::getOpenFileUrl(this);
             break;
         case RequestDirs:
             url = QFileDialog::getExistingDirectoryUrl(this);
             break;
     }
     if (!url.isEmpty())
         urlLineEdit->setText(url.toDisplayString(QUrl::PreferLocalFile));
     urlLineEdit->setFocus();
 }
 
 void KURLListRequester::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Delete) {
         if (urlListBox->hasFocus()) {
             deleteSelectedItems();
             return;
         }
     }
 
     QWidget::keyPressEvent(e);
 }
 
 void KURLListRequester::deleteSelectedItems()
 {
     QList<QListWidgetItem *> selectedItems = urlListBox->selectedItems();
     for (QListWidgetItem *item : selectedItems)
         delete item;
     emit changed();
 }
 
 void KURLListRequester::slotRightClicked(QListWidgetItem *item, const QPoint &pos)
 {
-    if (item == 0)
+    if (item == nullptr)
         return;
 
     QMenu popupMenu(this);
     QAction * menuAction = popupMenu.addAction(i18n("Delete"));
 
     if (menuAction == popupMenu.exec(pos)) {
         if (item->isSelected())
             deleteSelectedItems();
         else {
             delete item;
             emit changed();
         }
     }
 }
 
 QList<QUrl> KURLListRequester::urlList()
 {
     QStringList lines;
 
     const QString lineEditText = urlLineEdit->text().simplified();
     if (!lineEditText.isEmpty()) {
         lines.append(lineEditText);
     }
 
     for (int i = 0; i != urlListBox->count(); i++) {
         QListWidgetItem *item = urlListBox->item(i);
         lines.append(item->text().simplified());
     }
 
     QList<QUrl> urls;
     for (QString text : lines) {
         QString error;
         emit checkValidity(text, error);
         if (error.isNull())
             urls.append(QUrl::fromUserInput(text, QString(), QUrl::AssumeLocalFile));
     }
 
     return urls;
 }
 
 void KURLListRequester::setUrlList(const QList<QUrl> &urlList)
 {
     urlLineEdit->clear();
     urlListBox->clear();
 
-    for (const QUrl url : urlList) {
+    for (const QUrl& url : urlList) {
         urlListBox->addItem(url.toDisplayString(QUrl::PreferLocalFile));
     }
 
     emit changed();
 }
 
diff --git a/krusader/Dialogs/kurllistrequester.h b/krusader/Dialogs/kurllistrequester.h
index 3e778b16..5499e413 100644
--- a/krusader/Dialogs/kurllistrequester.h
+++ b/krusader/Dialogs/kurllistrequester.h
@@ -1,78 +1,78 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KURLLISTREQUESTER_H
 #define KURLLISTREQUESTER_H
 
 // QtGui
 #include <QKeyEvent>
 // QtWidgets
 #include <QWidget>
 #include <QToolButton>
 
 #include <KCompletion/KLineEdit>
 #include <KIOWidgets/KUrlCompletion>
 
 #include "../GUI/krlistwidget.h"
 
 /**
  * Widget for letting the user define a list of URLs.
  */
 class KURLListRequester : public QWidget
 {
     Q_OBJECT
 
 public:
     enum Mode { RequestFiles, RequestDirs };
 
-    explicit KURLListRequester(Mode requestMode, QWidget *parent = 0);
+    explicit KURLListRequester(Mode requestMode, QWidget *parent = nullptr);
 
     QList<QUrl> urlList();
     void setUrlList(const QList<QUrl> &);
 
     KLineEdit *lineEdit() { return urlLineEdit; }
     KrListWidget *listBox() { return urlListBox; }
 
     void setCompletionDir(const QUrl &dir) { completion.setDir(dir); }
 
 signals:
     void checkValidity(QString &text, QString &error);
     void changed();
 
 protected slots:
     void slotAdd();
     void slotBrowse();
     void slotRightClicked(QListWidgetItem *, const QPoint &);
 
 protected:
-    virtual void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
+    void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
     void deleteSelectedItems();
 
     Mode mode;
 
     KLineEdit *urlLineEdit;
     KrListWidget *urlListBox;
     QToolButton *urlAddBtn;
     QToolButton *urlBrowseBtn;
 
     KUrlCompletion completion;
 };
 
 #endif /* __KURLLISTREQUESTER_H__ */
diff --git a/krusader/Dialogs/newftpgui.cpp b/krusader/Dialogs/newftpgui.cpp
index 2bf5fc9d..24a306d6 100644
--- a/krusader/Dialogs/newftpgui.cpp
+++ b/krusader/Dialogs/newftpgui.cpp
@@ -1,203 +1,203 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2009 Fathi Boudra <fboudra@gmail.com>                       *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "newftpgui.h"
 
 // QtCore
 #include <QStringList>
 #include <QEvent>
 // QtGui
 #include <QFont>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QSizePolicy>
 
 #include <KConfigCore/KConfigGroup>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIOCore/KProtocolInfo>
 
 #include "../krglobal.h"
 #include "../icon.h"
 
 #define SIZE_MINIMUM QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed)
 
 const QStringList sProtocols = QStringList()
                                << QStringLiteral("ftp") << QStringLiteral("ftps")
                                << QStringLiteral("sftp")
                                << QStringLiteral("fish") << QStringLiteral("nfs")
                                << QStringLiteral("smb") << QStringLiteral("webdav")
                                << QStringLiteral("svn") << QStringLiteral("svn+file")
                                << QStringLiteral("svn+http") << QStringLiteral("svn+https")
                                << QStringLiteral("svn+ssh");
 
 /**
  * Constructs a newFTPGUI which is a child of 'parent',
  * with the name 'name' and widget flags set to 'f'
  */
 newFTPGUI::newFTPGUI(QWidget* parent) : QDialog(parent)
 {
     setModal(true);
     setWindowTitle(i18n("New Network Connection"));
     resize(500, 240);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     QSizePolicy policy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     policy.setHeightForWidth(sizePolicy().hasHeightForWidth());
     setSizePolicy(policy);
 
     iconLabel = new QLabel(this);
     iconLabel->setPixmap(Icon("network-wired").pixmap(32));
     iconLabel->setSizePolicy(SIZE_MINIMUM);
 
     aboutLabel = new QLabel(i18n("About to connect to..."), this);
     QFont font(aboutLabel->font());
     font.setBold(true);
     aboutLabel->setFont(font);
 
     protocolLabel = new QLabel(i18n("Protocol:"), this);
     hostLabel = new QLabel(i18n("Host:"), this);
     portLabel = new QLabel(i18n("Port:"), this);
 
     prefix = new KComboBox(this);
     prefix->setObjectName(QString::fromUtf8("protocol"));
     prefix->setSizePolicy(SIZE_MINIMUM);
 
     url = new KHistoryComboBox(this);
     url->setMaxCount(50);
     url->setMinimumContentsLength(10);
 
     const QStringList availableProtocols = KProtocolInfo::protocols();
-    for (const QString protocol : sProtocols) {
+    for (const QString& protocol : sProtocols) {
         if (availableProtocols.contains(protocol))
             prefix->addItem(protocol + QStringLiteral("://"));
     }
 
     // load the history and completion list after creating the history combo
     KConfigGroup group(krConfig, "Private");
     QStringList list = group.readEntry("newFTP Completion list", QStringList());
     url->completionObject()->setItems(list);
     list = group.readEntry("newFTP History list", QStringList());
     url->setHistoryItems(list);
 
     // Select last used protocol
     const QString lastUsedProtocol = group.readEntry("newFTP Protocol", QString());
     if(!lastUsedProtocol.isEmpty()) {
         prefix->setCurrentItem(lastUsedProtocol);
     }
 
     port = new QSpinBox(this);
     port->setMaximum(65535);
     port->setValue(21);
     port->setSizePolicy(SIZE_MINIMUM);
 
     usernameLabel = new QLabel(i18n("Username:"), this);
     username = new KLineEdit(this);
     passwordLabel = new QLabel(i18n("Password:"), this);
     password = new KLineEdit(this);
     password->setEchoMode(QLineEdit::Password);
 
-    QHBoxLayout *horizontalLayout = new QHBoxLayout();
+    auto *horizontalLayout = new QHBoxLayout();
     horizontalLayout->addWidget(iconLabel);
     horizontalLayout->addWidget(aboutLabel);
 
-    QGridLayout *gridLayout = new QGridLayout();
+    auto *gridLayout = new QGridLayout();
     gridLayout->addWidget(protocolLabel, 0, 0, 1, 1);
     gridLayout->addWidget(hostLabel, 0, 1, 1, 1);
     gridLayout->addWidget(portLabel, 0, 2, 1, 1);
     gridLayout->addWidget(prefix, 1, 0, 1, 1);
     gridLayout->addWidget(url, 1, 1, 1, 1);
     gridLayout->addWidget(port, 1, 2, 1, 1);
     gridLayout->addWidget(usernameLabel, 2, 0, 1, 1);
     gridLayout->addWidget(username, 3, 0, 1, 3);
     gridLayout->addWidget(passwordLabel, 4, 0, 1, 1);
     gridLayout->addWidget(password, 5, 0, 1, 3);
 
-    QGridLayout *widgetLayout = new QGridLayout();
+    auto *widgetLayout = new QGridLayout();
     widgetLayout->addLayout(horizontalLayout, 0, 0, 1, 1);
     widgetLayout->addLayout(gridLayout, 1, 0, 1, 1);
     mainLayout->addLayout(widgetLayout);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     mainLayout->addWidget(buttonBox);
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setText(i18n("&Connect"));
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
 
     connect(buttonBox, &QDialogButtonBox::accepted, this, &newFTPGUI::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &newFTPGUI::reject);
 
     connect(prefix, QOverload<const QString &>::of(&KComboBox::activated), this, &newFTPGUI::slotTextChanged);
     connect(url, QOverload<const QString &>::of(&KHistoryComboBox::activated), url, &KHistoryComboBox::addToHistory);
 
     if(!lastUsedProtocol.isEmpty()) {
         // update the port field
         slotTextChanged(lastUsedProtocol);
     }
 
     setTabOrder(url, username);
     setTabOrder(username, password);
     setTabOrder(password, prefix);
 }
 
 /**
  * Destroys the object and frees any allocated resources
  */
 newFTPGUI::~newFTPGUI()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 void newFTPGUI::slotTextChanged(const QString &string)
 {
     if (string.startsWith(QLatin1String("ftp")) ||
             string.startsWith(QLatin1String("sftp")) ||
             string.startsWith(QLatin1String("fish"))) {
         if (port->value() == 21 || port->value() == 22) {
             port->setValue(string.startsWith(QLatin1String("ftp")) ? 21 : 22);
         }
         port->setEnabled(true);
     } else {
         port->setEnabled(false);
     }
 }
 
 /**
  * Main event handler. Reimplemented to handle application font changes
  */
 bool newFTPGUI::event(QEvent *ev)
 {
     bool ret = QDialog::event(ev);
     if (ev->type() == QEvent::ApplicationFontChange) {
         QFont font(aboutLabel->font());
         font.setBold(true);
         aboutLabel->setFont(font);
     }
     return ret;
 }
 
diff --git a/krusader/Dialogs/newftpgui.h b/krusader/Dialogs/newftpgui.h
index 40b1532f..4e20c40e 100644
--- a/krusader/Dialogs/newftpgui.h
+++ b/krusader/Dialogs/newftpgui.h
@@ -1,68 +1,68 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2009 Fathi Boudra <fboudra@gmail.com>                       *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef NEWFTPGUI_H
 #define NEWFTPGUI_H
 
 // QtWidgets
 #include <QDialog>
 #include <QLabel>
 #include <QSpinBox>
 
 #include <KCompletion/KComboBox>
 #include <KCompletion/KHistoryComboBox>
 #include <KCompletion/KLineEdit>
 
 /**
  * The "New Network Connection" dialog
  */
 class newFTPGUI : public QDialog
 {
     Q_OBJECT
 
 public:
-    explicit newFTPGUI(QWidget *parent = 0);
-    ~newFTPGUI();
+    explicit newFTPGUI(QWidget *parent = nullptr);
+    ~newFTPGUI() override;
 
     KComboBox* prefix;
     KHistoryComboBox* url;
     QSpinBox* port;
     KLineEdit* username;
     KLineEdit* password;
 
 protected:
     bool event(QEvent *) Q_DECL_OVERRIDE;
 
 private slots:
     void slotTextChanged(const QString &);
 
 private:
     QLabel* iconLabel;
     QLabel* aboutLabel;
     QLabel* protocolLabel;
     QLabel* passwordLabel;
     QLabel* hostLabel;
     QLabel* usernameLabel;
     QLabel* portLabel;
 };
 
 #endif
diff --git a/krusader/Dialogs/packgui.cpp b/krusader/Dialogs/packgui.cpp
index b6bf1794..61c2ea51 100644
--- a/krusader/Dialogs/packgui.cpp
+++ b/krusader/Dialogs/packgui.cpp
@@ -1,127 +1,127 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "packgui.h"
 #include "../krglobal.h"
 #include "../defaults.h"
 
 // QtCore
 #include <QStringList>
 // QtWidgets
 #include <QLineEdit>
 #include <QCheckBox>
 #include <QFileDialog>
 #include <QLabel>
 #include <QPushButton>
 #include <QComboBox>
 
 #include <KCompletion/KHistoryComboBox>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 #define PS(x) lst.contains(x)>0
 
 // clear the statics first
-QString PackGUI::filename = 0;
-QString PackGUI::destination = 0;
-QString PackGUI::type = 0;
+QString PackGUI::filename = nullptr;
+QString PackGUI::destination = nullptr;
+QString PackGUI::type = nullptr;
 QMap<QString, QString> PackGUI::extraProps;
 
-PackGUI::PackGUI(QString defaultName, QString defaultPath, int noOfFiles, QString filename) :
-        PackGUIBase(0)
+PackGUI::PackGUI(const QString& defaultName, const QString& defaultPath, int noOfFiles, const QString& filename) :
+        PackGUIBase(nullptr)
 {
     // first, fill the WhatToPack textfield with information
     if (noOfFiles == 1)
         TextLabel1->setText(i18n("Pack %1", filename));
     else
         TextLabel1->setText(i18np("Pack %1 file", "Pack %1 files", noOfFiles));
 
     // now, according to the Konfigurator, fill the combobox with the information
     // about what kind of packing we can do
     KConfigGroup group(krConfig, "Archives");
     QStringList lst = group.readEntry("Supported Packers", QStringList());
     // now, clear the type combo and begin...
     typeData->clear();
     if (PS("tar")) typeData->addItem("tar");
     if (PS("tar") && PS("gzip")) typeData->addItem("tar.gz");
     if (PS("tar") && PS("bzip2")) typeData->addItem("tar.bz2");
     if (PS("tar") && PS("lzma")) typeData->addItem("tar.lzma");
     if (PS("tar") && PS("xz")) typeData->addItem("tar.xz");
     if (PS("zip")) typeData->addItem("zip");
     if (PS("zip")) typeData->addItem("cbz");
     if (PS("rar")) typeData->addItem("rar");
     if (PS("rar")) typeData->addItem("cbr");
     if (PS("lha")) typeData->addItem("lha");
     if (PS("arj")) typeData->addItem("arj");
     if (PS("7z")) typeData->addItem("7z");
     // set the last used packer as the top one
     QString tmp = group.readEntry("lastUsedPacker", QString());
     if (!tmp.isEmpty()) {
         for (int i = 0; i < typeData->count(); ++i)
             if (typeData->itemText(i) == tmp) {
                 typeData->removeItem(i);
                 typeData->insertItem(0, tmp);
                 typeData->setCurrentIndex(0);
                 break;
             }
     }
     checkConsistency();
 
     // and go on with the normal stuff
     dirData->setText(defaultPath);
     nameData->setText(defaultName);
     nameData->setFocus();
     if (typeData->count() == 0) // if no packers are available
         okButton->setEnabled(false);
     setGeometry(krMainWindow->x() + krMainWindow->width() / 2 - width() / 2, krMainWindow->y() + krMainWindow->height() / 2 - height() / 2, width(), height());
     exec();
 }
 
 void PackGUI::browse()
 {
-    QString temp = QFileDialog::getExistingDirectory(0, i18n("Please select a folder"), dirData->text());
+    QString temp = QFileDialog::getExistingDirectory(nullptr, i18n("Please select a folder"), dirData->text());
     if (!temp.isEmpty()) {
         dirData->setText(temp);
     }
 }
 
 void PackGUI::accept()
 {
     if (!extraProperties(extraProps))
         return;
 
     filename = nameData->text();
     destination = dirData->text();
     type = typeData->currentText();
     // write down the packer chosen, to be lastUsedPacker
     KConfigGroup group(krConfig, "Archives");
     group.writeEntry("lastUsedPacker", type);
     krConfig->sync();
     PackGUIBase::accept();
 }
 
 void PackGUI::reject()
 {
     filename.clear();
     destination.clear();
     type.clear();
     PackGUIBase::reject();
 }
diff --git a/krusader/Dialogs/packgui.h b/krusader/Dialogs/packgui.h
index caea6ec6..ed4ef376 100644
--- a/krusader/Dialogs/packgui.h
+++ b/krusader/Dialogs/packgui.h
@@ -1,45 +1,45 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef PACKGUI_H
 #define PACKGUI_H
 
 #include "packguibase.h"
 
 class PackGUI : public PackGUIBase
 {
     Q_OBJECT
 public:
-    PackGUI(QString defaultName, QString defaultPath, int noOfFiles, QString filename = "");
+    PackGUI(const QString& defaultName, const QString& defaultPath, int noOfFiles, const QString& filename = "");
 
 public slots:
     void browse() Q_DECL_OVERRIDE;
 
 protected slots:
     void accept() Q_DECL_OVERRIDE;
     void reject() Q_DECL_OVERRIDE;
 
 public:
     static QString filename, destination, type;
     static QMap<QString, QString> extraProps;
 };
 
 #endif
diff --git a/krusader/Dialogs/packguibase.cpp b/krusader/Dialogs/packguibase.cpp
index f7e67a75..8535484e 100644
--- a/krusader/Dialogs/packguibase.cpp
+++ b/krusader/Dialogs/packguibase.cpp
@@ -1,496 +1,496 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "packguibase.h"
 
 // QtCore
 #include <QVariant>
 // QtGui
 #include <QGuiApplication>
 #include <QImage>
 #include <QPixmap>
 #include <QKeyEvent>
 // QtWidgets
 #include <QSlider>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QLabel>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QToolButton>
 #include <QLayout>
 #include <QSpinBox>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QFrame>
 #include <QVBoxLayout>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KCompletion/KComboBox>
 #include <KWidgetsAddons/KMessageBox>
 #include <KIO/Global>
 #include <KCompletion/KHistoryComboBox>
 #include <KWidgetsAddons/KStandardGuiItem>
 
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../icon.h"
 
 /*
  *  Constructs a PackGUIBase which is a child of 'parent', with the
  *  name 'name' and widget flags set to 'f'
  *
  *  The dialog will by default be modeless, unless you set 'modal' to
  *  TRUE to construct a modal dialog.
  */
 PackGUIBase::PackGUIBase(QWidget* parent)
         : QDialog(parent), expanded(false)
 {
     KConfigGroup group(krConfig, "Archives");
 
     setModal(true);
     resize(430, 140);
     setWindowTitle(i18n("Pack"));
     grid = new QGridLayout(this);
     grid->setSpacing(6);
     grid->setContentsMargins(11, 11, 11, 11);
 
     hbox = new QHBoxLayout;
     hbox->setSpacing(6);
     hbox->setContentsMargins(0, 0, 0, 0);
 
     TextLabel3 = new QLabel(this);
     TextLabel3->setText(i18n("To archive"));
     hbox->addWidget(TextLabel3);
 
     nameData = new QLineEdit(this);
     hbox->addWidget(nameData);
 
     typeData = new QComboBox(this);
     typeData->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed));
     connect(typeData, QOverload<const QString &>::of(&QComboBox::activated), this,  &PackGUIBase::checkConsistency);
     connect(typeData, QOverload<const QString &>::of(&QComboBox::highlighted), this,  &PackGUIBase::checkConsistency);
     hbox->addWidget(typeData);
 
     grid->addLayout(hbox, 1, 0);
 
     hbox_2 = new QHBoxLayout;
     hbox_2->setSpacing(6);
     hbox_2->setContentsMargins(0, 0, 0, 0);
 
     TextLabel5 = new QLabel(this);
     TextLabel5->setText(i18n("In folder"));
     hbox_2->addWidget(TextLabel5);
 
     dirData = new QLineEdit(this);
     hbox_2->addWidget(dirData);
 
     browseButton = new QToolButton(this);
     browseButton->setIcon(Icon("document-open"));
     hbox_2->addWidget(browseButton);
-    QSpacerItem* spacer = new QSpacerItem(48, 20, QSizePolicy::Fixed, QSizePolicy::Fixed);
+    auto* spacer = new QSpacerItem(48, 20, QSizePolicy::Fixed, QSizePolicy::Fixed);
     hbox_2->addItem(spacer);
 
     grid->addLayout(hbox_2, 2, 0);
 
     hbox_3 = new QHBoxLayout;
     hbox_3->setSpacing(6);
     hbox_3->setContentsMargins(0, 0, 0, 0);
 
     PixmapLabel1 = new QLabel(this);
     PixmapLabel1->setPixmap(Icon("package-x-generic").pixmap(32));
     PixmapLabel1->setScaledContents(true);
     PixmapLabel1->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     hbox_3->addWidget(PixmapLabel1);
 
     TextLabel1 = new QLabel(this);
     TextLabel1->setText(i18n("Pack"));
     hbox_3->addWidget(TextLabel1);
 
     grid->addLayout(hbox_3, 0, 0);
 
 
     hbox_4 = new QHBoxLayout;
     hbox_4->setSpacing(6);
     hbox_4->setContentsMargins(0, 0, 0, 0);
 
-    QSpacerItem* spacer_3 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Expanding);
+    auto* spacer_3 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Expanding);
     hbox_4->addItem(spacer_3);
     grid->addLayout(hbox_4, 3, 0);
 
     advancedWidget = new QWidget(this);
 
     hbox_5 = new QGridLayout(advancedWidget);
     hbox_5->setSpacing(6);
     hbox_5->setContentsMargins(0, 0, 0, 0);
 
 
-    QVBoxLayout *compressLayout = new QVBoxLayout;
+    auto *compressLayout = new QVBoxLayout;
     compressLayout->setSpacing(6);
     compressLayout->setContentsMargins(0, 0, 0, 0);
 
     multipleVolume = new QCheckBox(i18n("Multiple volume archive"), advancedWidget);
     connect(multipleVolume, &QCheckBox::toggled, this, &PackGUIBase::checkConsistency);
-    compressLayout->addWidget(multipleVolume, 0, 0);
+    compressLayout->addWidget(multipleVolume, 0, nullptr);
 
-    QHBoxLayout * volumeHbox = new QHBoxLayout;
+    auto * volumeHbox = new QHBoxLayout;
 
-    QSpacerItem* spacer_5 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Fixed);
+    auto* spacer_5 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Fixed);
     volumeHbox->addItem(spacer_5);
 
     TextLabel7 = new QLabel(i18n("Size:"), advancedWidget);
     volumeHbox->addWidget(TextLabel7);
 
     volumeSpinBox = new QSpinBox(advancedWidget);
     volumeSpinBox->setMinimum(1);
     volumeSpinBox->setMaximum(9999);
     volumeSpinBox->setValue(1440);
     volumeHbox->addWidget(volumeSpinBox);
 
     volumeUnitCombo = new QComboBox(advancedWidget);
     volumeUnitCombo->addItem("B");
     volumeUnitCombo->addItem("KB");
     volumeUnitCombo->addItem("MB");
     volumeUnitCombo->setCurrentIndex(1);
     volumeHbox->addWidget(volumeUnitCombo);
 
     compressLayout->addLayout(volumeHbox);
 
     int level = group.readEntry("Compression level", _defaultCompressionLevel);
     setCompressionLevel = new QCheckBox(i18n("Set compression level"), advancedWidget);
     if (level != _defaultCompressionLevel)
         setCompressionLevel->setChecked(true);
     connect(setCompressionLevel, &QCheckBox::toggled, this, &PackGUIBase::checkConsistency);
-    compressLayout->addWidget(setCompressionLevel, 0, 0);
+    compressLayout->addWidget(setCompressionLevel, 0, nullptr);
 
-    QHBoxLayout * sliderHbox = new QHBoxLayout;
+    auto * sliderHbox = new QHBoxLayout;
 
-    QSpacerItem* spacer_6 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Fixed);
+    auto* spacer_6 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Fixed);
     sliderHbox->addItem(spacer_6);
 
     QWidget * sliderVBoxWidget = new QWidget(advancedWidget);
-    QVBoxLayout *sliderVBox = new QVBoxLayout(sliderVBoxWidget);
+    auto *sliderVBox = new QVBoxLayout(sliderVBoxWidget);
 
     compressionSlider = new QSlider(Qt::Horizontal, sliderVBoxWidget);
     compressionSlider->setMinimum(1);
     compressionSlider->setMaximum(9);
     compressionSlider->setPageStep(1);
     compressionSlider->setValue(level);
     compressionSlider->setTickPosition(QSlider::TicksBelow);
     sliderVBox->addWidget(compressionSlider);
 
     QWidget * minmaxWidget = new QWidget(sliderVBoxWidget);
     sliderVBox->addWidget(minmaxWidget);
 
-    QHBoxLayout * minmaxHbox = new QHBoxLayout(minmaxWidget);
+    auto * minmaxHbox = new QHBoxLayout(minmaxWidget);
 
     minLabel = new QLabel(i18n("MIN"), minmaxWidget);
     maxLabel = new QLabel(i18n("MAX"), minmaxWidget);
     maxLabel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     minmaxHbox->addWidget(minLabel);
     minmaxHbox->addWidget(maxLabel);
 
     sliderHbox->addWidget(sliderVBoxWidget);
 
     compressLayout->addLayout(sliderHbox);
 
     compressLayout->addStretch(0);
     hbox_5->addLayout(compressLayout, 0, 0);
 
     QFrame *vline = new QFrame(advancedWidget);
     vline->setFrameStyle(QFrame::VLine | QFrame::Sunken);
     vline->setMinimumWidth(20);
     hbox_5->addWidget(vline, 0, 1);
 
 
-    QGridLayout * passwordGrid = new QGridLayout;
+    auto * passwordGrid = new QGridLayout;
     passwordGrid->setSpacing(6);
     passwordGrid->setContentsMargins(0, 0, 0, 0);
 
     TextLabel4 = new QLabel(advancedWidget);
     TextLabel4->setText(i18n("Password"));
     passwordGrid->addWidget(TextLabel4, 0, 0);
 
     password = new QLineEdit(advancedWidget);
     password->setEchoMode(QLineEdit::Password);
     connect(password, &QLineEdit::textChanged, this, &PackGUIBase::checkConsistency);
 
     passwordGrid->addWidget(password, 0, 1);
 
     TextLabel6 = new QLabel(advancedWidget);
     TextLabel6->setText(i18n("Again"));
     passwordGrid->addWidget(TextLabel6, 1, 0);
 
     passwordAgain = new QLineEdit(advancedWidget);
     passwordAgain->setEchoMode(QLineEdit::Password);
     connect(passwordAgain, &QLineEdit::textChanged, this, &PackGUIBase::checkConsistency);
 
     passwordGrid->addWidget(passwordAgain, 1, 1);
 
-    QHBoxLayout *consistencyHbox = new QHBoxLayout;
+    auto *consistencyHbox = new QHBoxLayout;
 
-    QSpacerItem* spacer_cons = new QSpacerItem(48, 20, QSizePolicy::Expanding, QSizePolicy::Fixed);
+    auto* spacer_cons = new QSpacerItem(48, 20, QSizePolicy::Expanding, QSizePolicy::Fixed);
     consistencyHbox->addItem(spacer_cons);
 
     passwordConsistencyLabel = new QLabel(advancedWidget);
     consistencyHbox->addWidget(passwordConsistencyLabel);
     passwordGrid->addLayout(consistencyHbox, 2, 0, 1, 2);
 
     encryptHeaders = new QCheckBox(i18n("Encrypt headers"), advancedWidget);
     passwordGrid->addWidget(encryptHeaders, 3, 0, 1, 2);
 
-    QSpacerItem* spacer_psw = new QSpacerItem(20, 20, QSizePolicy::Fixed, QSizePolicy::Expanding);
+    auto* spacer_psw = new QSpacerItem(20, 20, QSizePolicy::Fixed, QSizePolicy::Expanding);
     passwordGrid->addItem(spacer_psw, 4, 0);
 
     hbox_5->addLayout(passwordGrid, 0, 2);
 
     hbox_7 = new QHBoxLayout;
     hbox_7->setSpacing(6);
     hbox_7->setContentsMargins(0, 0, 0, 0);
 
     TextLabel8 = new QLabel(i18n("Command line switches:"), advancedWidget);
     TextLabel8->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     hbox_7->addWidget(TextLabel8);
 
     commandLineSwitches = new KHistoryComboBox(advancedWidget);
     commandLineSwitches->setMaxCount(25);  // remember 25 items
     commandLineSwitches->setDuplicatesEnabled(false);
     commandLineSwitches->setMinimumContentsLength(10);
 
     QStringList list = group.readEntry("Command Line Switches", QStringList());
     commandLineSwitches->setHistoryItems(list);
 
     hbox_7->addWidget(commandLineSwitches);
 
     hbox_5->addLayout(hbox_7, 1, 0, 1, 3);
 
 
     advancedWidget->hide();
     checkConsistency();
 
     grid->addWidget(advancedWidget, 4, 0);
 
     hbox_6 = new QHBoxLayout;
     hbox_6->setSpacing(6);
     hbox_6->setContentsMargins(0, 0, 0, 0);
 
     advancedButton = new QPushButton(this);
     advancedButton->setText(i18n("&Advanced >>"));
     hbox_6->addWidget(advancedButton);
 
-    QSpacerItem* spacer_2 = new QSpacerItem(140, 20, QSizePolicy::Expanding, QSizePolicy::Fixed);
+    auto* spacer_2 = new QSpacerItem(140, 20, QSizePolicy::Expanding, QSizePolicy::Fixed);
     hbox_6->addItem(spacer_2);
 
     okButton = new QPushButton(this);
     KStandardGuiItem::assign(okButton, KStandardGuiItem::Ok);
     okButton->setDefault(true);
     hbox_6->addWidget(okButton);
 
     cancelButton = new QPushButton(this);
     KStandardGuiItem::assign(cancelButton, KStandardGuiItem::Cancel);
     hbox_6->addWidget(cancelButton);
 
     grid->addLayout(hbox_6, 6, 0);
 
     // signals and slots connections
     connect(okButton, &QPushButton::clicked, this, &PackGUIBase::accept);
     connect(advancedButton, &QPushButton::clicked, this, &PackGUIBase::expand);
     connect(cancelButton, &QPushButton::clicked, this, &PackGUIBase::reject);
     connect(browseButton, &QToolButton::clicked, this, &PackGUIBase::browse);
 }
 
 /*
  *  Destroys the object and frees any allocated resources
  */
 PackGUIBase::~PackGUIBase()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 void PackGUIBase::browse()
 {
     qWarning("PackGUIBase::browse(): Not implemented yet!");
 }
 
 void PackGUIBase::expand()
 {
     expanded = !expanded;
 
     advancedButton->setText(expanded ? i18n("&Advanced <<") : i18n("&Advanced >>"));
 
     if (expanded)
         advancedWidget->show();
     else {
         advancedWidget->hide();
         layout()->activate();
         QSize minSize = minimumSize();
         resize(width(), minSize.height());
     }
     show();
 }
 
 void PackGUIBase::checkConsistency()
 {
     QPalette p = QGuiApplication::palette();
     QPalette pal = passwordConsistencyLabel->palette();
     if (password->text().isEmpty() && passwordAgain->text().isEmpty()) {
         pal.setColor(passwordConsistencyLabel->foregroundRole(), p.color(QPalette::Active, QPalette::Text));
         passwordConsistencyLabel->setText(i18n("No password specified"));
     } else if (password->text() == passwordAgain->text()) {
         pal.setColor(passwordConsistencyLabel->foregroundRole(), p.color(QPalette::Active, QPalette::Text));
         passwordConsistencyLabel->setText(i18n("The passwords are equal"));
     } else {
         pal.setColor(passwordConsistencyLabel->foregroundRole(), Qt::red);
         passwordConsistencyLabel->setText(i18n("The passwords are different"));
     }
     passwordConsistencyLabel->setPalette(pal);
 
     QString packer = typeData->currentText();
 
     bool passworded = false;
     if (packer == "7z" || packer == "rar" || packer == "zip" || packer == "arj")
         passworded = true;
 
     passwordConsistencyLabel->setEnabled(passworded);
     password->setEnabled(passworded);
     passwordAgain->setEnabled(passworded);
     TextLabel4->setEnabled(passworded);
     TextLabel6->setEnabled(passworded);
 
     encryptHeaders->setEnabled(packer == "rar");
 
     multipleVolume->setEnabled(packer == "rar" || packer == "arj");
     bool volumeEnabled = multipleVolume->isEnabled() && multipleVolume->isChecked();
     volumeSpinBox->setEnabled(volumeEnabled);
     volumeUnitCombo->setEnabled(volumeEnabled);
     TextLabel7->setEnabled(volumeEnabled);
 
     /* TODO */
     setCompressionLevel->setEnabled(packer == "rar" || packer == "arj" || packer == "zip" ||
                                     packer == "7z");
     bool sliderEnabled = setCompressionLevel->isEnabled() && setCompressionLevel->isChecked();
     compressionSlider->setEnabled(sliderEnabled);
     minLabel->setEnabled(sliderEnabled);
     maxLabel->setEnabled(sliderEnabled);
 }
 
 bool PackGUIBase::extraProperties(QMap<QString, QString> & inMap)
 {
     inMap.clear();
 
     KConfigGroup group(krConfig, "Archives");
 
     if (password->isEnabled() && passwordAgain->isEnabled()) {
         if (password->text() != passwordAgain->text()) {
             KMessageBox::error(this, i18n("Cannot pack, the passwords are different."));
             return false;
         }
 
         if (!password->text().isEmpty()) {
             inMap[ "Password" ] = password->text();
 
             if (encryptHeaders->isEnabled() && encryptHeaders->isChecked())
                 inMap[ "EncryptHeaders" ] = '1';
         }
     }
 
     if (multipleVolume->isEnabled() && multipleVolume->isChecked()) {
         KIO::filesize_t size = volumeSpinBox->value();
 
         switch (volumeUnitCombo->currentIndex()) {
         case 2:
             size *= 1000;
 #if __GNUC__ >= 7
             [[gnu::fallthrough]];
 #endif
         case 1:
             size *= 1000;
         default:
             break;
         }
 
         if (size < 10000) {
             KMessageBox::error(this, i18n("Invalid volume size."));
             return false;
         }
 
         QString sbuffer;
         sbuffer.sprintf("%llu", size);
 
         inMap[ "VolumeSize" ] = sbuffer;
     }
 
     if (setCompressionLevel->isEnabled() && setCompressionLevel->isChecked()) {
         inMap[ "CompressionLevel" ] = QString("%1").arg(compressionSlider->value());
         int level = compressionSlider->value();
         group.writeEntry("Compression level", level);
     }
 
     QString cmdArgs = commandLineSwitches->currentText().trimmed();
     if (!cmdArgs.isEmpty()) {
         bool firstChar = true;
         QChar quote = QChar::Null;
 
         for (int i = 0; i < cmdArgs.length(); i++) {
             QChar ch(cmdArgs[ i ]);
             if (ch.isSpace())
                 continue;
 
             if (ch == quote) {
                 quote = QChar::Null;
                 continue;
             }
 
             if (firstChar && ch != QLatin1Char('-')) {
                 KMessageBox::error(this, i18n("Invalid command line switch.\nA switch must start with '-'."));
                 return false;
             }
 
             firstChar = false;
 
             if (quote == QLatin1Char('"'))
                 continue;
             if (quote == QChar::Null && (ch == QLatin1Char('\'') || ch == QLatin1Char('"')))
                 quote = ch;
             if (ch == QLatin1Char('\\')) {
                 if (i == cmdArgs.length() - 1) {
                     KMessageBox::error(this, i18n("Invalid command line switch.\nBackslashes cannot be the last character."));
                     return false;
                 }
                 i++;
             }
         }
 
         if (quote != QChar::Null) {
             KMessageBox::error(this, i18n("Invalid command line switch.\nUnclosed quotation mark."));
             return false;
         }
 
         commandLineSwitches->addToHistory(cmdArgs);
         QStringList list = commandLineSwitches->historyItems();
         group.writeEntry("Command Line Switches", list);
 
         inMap[ "CommandLineSwitches" ] = cmdArgs;
     }
     return true;
 }
diff --git a/krusader/Dialogs/packguibase.h b/krusader/Dialogs/packguibase.h
index 6538eedb..daa297c8 100644
--- a/krusader/Dialogs/packguibase.h
+++ b/krusader/Dialogs/packguibase.h
@@ -1,103 +1,103 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #ifndef PACKGUIBASE_H
 #define PACKGUIBASE_H
 
 // QtCore
 #include <QMap>
 // QtWidgets
 #include <QDialog>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 #include <QLabel>
 
 class QHBoxLayout;
 class QGridLayout;
 class QCheckBox;
 class QComboBox;
 class QLabel;
 class QLineEdit;
 class QPushButton;
 class QToolButton;
 class QSpinBox;
 class QSlider;
 class KHistoryComboBox;
 
 class PackGUIBase : public QDialog
 {
     Q_OBJECT
 
 public:
-    explicit PackGUIBase(QWidget* parent = 0);
-    ~PackGUIBase();
+    explicit PackGUIBase(QWidget* parent = nullptr);
+    ~PackGUIBase() override;
 
     QLabel* TextLabel3;
     QLineEdit* nameData;
     QComboBox* typeData;
     QLabel* TextLabel5;
     QLineEdit* dirData;
     QToolButton* browseButton;
     QWidget* advancedWidget;
     QLabel* PixmapLabel1;
     QLabel* TextLabel1;
     QLabel* TextLabel4;
     QLabel* TextLabel6;
     QLabel* TextLabel7;
     QLabel* TextLabel8;
     QLabel* minLabel;
     QLabel* maxLabel;
     QLineEdit* password;
     QLineEdit* passwordAgain;
     QLabel* passwordConsistencyLabel;
     QPushButton* okButton;
     QPushButton* cancelButton;
     QPushButton* advancedButton;
     QCheckBox* encryptHeaders;
     QCheckBox* multipleVolume;
     QSpinBox* volumeSpinBox;
     QComboBox* volumeUnitCombo;
     QCheckBox* setCompressionLevel;
     QSlider*   compressionSlider;
     KHistoryComboBox *commandLineSwitches;
 
 public slots:
     virtual void browse();
     virtual bool extraProperties(QMap<QString, QString> &);
 
     void expand();
     void checkConsistency();
 
 protected:
     QHBoxLayout* hbox;
     QHBoxLayout* hbox_2;
     QHBoxLayout* hbox_3;
     QHBoxLayout* hbox_4;
     QGridLayout* hbox_5;
     QHBoxLayout* hbox_6;
     QHBoxLayout* hbox_7;
     QGridLayout* grid;
 
 private:
     bool expanded;
 };
 
 #endif // PACKGUIBASE_H
diff --git a/krusader/Dialogs/percentalsplitter.cpp b/krusader/Dialogs/percentalsplitter.cpp
index ddd02434..c4e40f59 100644
--- a/krusader/Dialogs/percentalsplitter.cpp
+++ b/krusader/Dialogs/percentalsplitter.cpp
@@ -1,83 +1,82 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "percentalsplitter.h"
 
 // QtCore
 #include <QList>
 // QtGui
 #include <QPainter>
 #include <QCursor>
 // QtWidgets
 #include <QApplication>
 #include <QLabel>
 #include <QFrame>
 #include <QToolTip>
 
-PercentalSplitter::PercentalSplitter(QWidget * parent) : QSplitter(parent), label(0), opaqueOldPos(-1)
+PercentalSplitter::PercentalSplitter(QWidget * parent) : QSplitter(parent), label(nullptr), opaqueOldPos(-1)
 {
     connect(this, &PercentalSplitter::splitterMoved, this, &PercentalSplitter::slotSplitterMoved);
 }
 
 PercentalSplitter::~PercentalSplitter()
-{
-}
+= default;
 
 QString PercentalSplitter::toolTipString(int p)
 {
     QList<int> values = sizes();
     if (values.count() != 0) {
         int sum = 0;
 
         QListIterator<int> it(values);
         while (it.hasNext())
             sum += it.next();
 
         if (sum == 0)
             sum++;
 
-        int percent = (int)(((double)p / (double)(sum)) * 10000. + 0.5);
+        auto percent = (int)(((double)p / (double)(sum)) * 10000. + 0.5);
         return QString("%1.%2%3").arg(percent / 100).arg((percent / 10) % 10).arg(percent % 10) + '%';
     }
     return QString();
 }
 
 void PercentalSplitter::slotSplitterMoved(int p, int index)
 {
     handle(index) -> setToolTip(toolTipString(p));
 
     QToolTip::showText(QCursor::pos(), toolTipString(p) , this);
 }
 
 void PercentalSplitter::showEvent(QShowEvent * event)
 {
     QList<int> values = sizes();
 
     for (int i = 0; i != count(); i++) {
         int p = 0;
         for (int j = 0; j < i; j++)
             p += values[ j ];
 
         handle(i) -> setToolTip(toolTipString(p));
     }
 
     QSplitter::showEvent(event);
 }
 
diff --git a/krusader/Dialogs/percentalsplitter.h b/krusader/Dialogs/percentalsplitter.h
index 5e81235a..1bbe6bba 100644
--- a/krusader/Dialogs/percentalsplitter.h
+++ b/krusader/Dialogs/percentalsplitter.h
@@ -1,50 +1,50 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef PERCENTALSPLITTER_H
 #define PERCENTALSPLITTER_H
 
 // QtWidgets
 #include <QSplitter>
 #include <QLabel>
 
 class PercentalSplitter : public QSplitter
 {
     Q_OBJECT
 
 public:
-    explicit PercentalSplitter(QWidget * parent = 0);
-    virtual ~PercentalSplitter();
+    explicit PercentalSplitter(QWidget * parent = nullptr);
+    ~PercentalSplitter() override;
 
     QString toolTipString(int p);
 
 protected:
-    virtual void showEvent(QShowEvent * event) Q_DECL_OVERRIDE;
+    void showEvent(QShowEvent * event) Q_DECL_OVERRIDE;
 
 protected slots:
     void slotSplitterMoved(int pos, int index);
 
 private:
     QLabel * label;
     int opaqueOldPos;
     QPoint labelLocation;
 };
 
 #endif /* __PERCENTAL_SPLITTER__ */
diff --git a/krusader/Dialogs/popularurls.cpp b/krusader/Dialogs/popularurls.cpp
index 7457b69d..26ab7299 100644
--- a/krusader/Dialogs/popularurls.cpp
+++ b/krusader/Dialogs/popularurls.cpp
@@ -1,373 +1,373 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "popularurls.h"
 
 #include <stdio.h>
 
 // QtCore
 #include <QList>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QGridLayout>
 #include <QHeaderView>
 #include <QLayout>
 #include <QLabel>
 #include <QToolButton>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 #include <KItemViews/KTreeWidgetSearchLine>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../krslots.h"
 #include "../GUI/krtreewidget.h"
 
 #define STARTING_RANK 20
 #define INCREASE   2
 #define DECREASE   1
 
 PopularUrls::PopularUrls(QObject *parent) : QObject(parent),
-        head(0), tail(0), count(0)
+        head(nullptr), tail(nullptr), count(0)
 {
     dlg = new PopularUrlsDlg();
 }
 
 PopularUrls::~PopularUrls()
 {
     clearList();
     delete dlg;
 }
 
 void PopularUrls::clearList()
 {
     if (head) {
         UrlNodeP p = head, tmp;
         while (p) {
             tmp = p;
             p = p->next;
             delete tmp;
         }
     }
     ranks.clear();
-    head = tail = 0;
+    head = tail = nullptr;
 }
 
 void PopularUrls::save()
 {
     KConfigGroup svr(krConfig, "Private");
     // prepare the string list containing urls and int list with ranks
     QStringList urlList;
     QList<int> rankList;
     UrlNodeP p = head;
     while (p) {
         urlList << p->url.toDisplayString();
         rankList << p->rank;
         p = p->next;
     }
     svr.writeEntry("PopularUrls", urlList);
     svr.writeEntry("PopularUrlsRank", rankList);
 }
 
 void PopularUrls::load()
 {
     KConfigGroup svr(krConfig, "Private");
     QStringList urlList = svr.readEntry("PopularUrls", QStringList());
     QList<int> rankList = svr.readEntry("PopularUrlsRank", QList<int>());
     if (urlList.count() != rankList.count()) {
         KMessageBox::error(krMainWindow, i18n("The saved 'Popular URLs' are invalid. The list will be cleared."));
         return;
     }
     clearList();
     count = 0;
     // iterate through both lists and
     QStringList::Iterator uit;
     QList<int>::Iterator rit;
     for (uit = urlList.begin(), rit = rankList.begin(); uit != urlList.end() && rit != rankList.end(); ++uit, ++rit) {
-        UrlNodeP node = new UrlNode;
+        auto node = new UrlNode;
         node->url = QUrl(*uit);
         node->rank = *rit;
         appendNode(node);
         ranks.insert(*uit, node);
     }
 }
 
 
 // returns a url list with the 'max' top popular urls
 QList<QUrl> PopularUrls::getMostPopularUrls(int max)
 {
     // get at most 'max' urls
     QList<QUrl> list;
     UrlNodeP p = head;
     int tmp = 0;
     if (maxUrls < max) max = maxUrls; // don't give more than maxUrls
     while (p && tmp < max) {
         list << p->url;
         p = p->next;
         ++tmp;
     }
 
     return list;
 }
 
 // adds a url to the list, or increase rank of an existing url, making
 // sure to bump it up the list if needed
 void PopularUrls::addUrl(const QUrl& url)
 {
     QUrl tmpurl = url;
     tmpurl.setPassword(QString()); // make sure no passwords are permanently stored
     if (!tmpurl.path().endsWith('/')) // make a uniform trailing slash policy
         tmpurl.setPath(tmpurl.path() + '/');
     UrlNodeP pnode;
 
     decreaseRanks();
     if (!head) { // if the list is empty ... (assumes dict to be empty as well)
         pnode = new UrlNode;
         pnode->rank = STARTING_RANK;
         pnode->url = tmpurl;
         appendNode(pnode);
         ranks.insert(tmpurl.url(), head);
     } else {
         if (ranks.find(tmpurl.url()) == ranks.end()) {  // is the added url new? if so, append it
             pnode = new UrlNode;
             pnode->rank = STARTING_RANK;
             pnode->url = tmpurl;
             appendNode(pnode);
             ranks.insert(tmpurl.url(), pnode);
         } else {
             pnode = ranks[ tmpurl.url()];
             pnode->rank += INCREASE;
         }
     }
 
     // do we need to change location for this one?
     relocateIfNeeded(pnode);
 
     // too many urls?
     if (count > maxUrls) removeNode(tail);
 
     //dumpList();
 }
 
 // checks if 'node' needs to be bumped-up the ranking list and does it if needed
 void PopularUrls::relocateIfNeeded(UrlNodeP node)
 {
     if (node->prev && (node->prev->rank < node->rank)) {
         // iterate until we find the correct place to put it
         UrlNodeP tmp = node->prev->prev;
         while (tmp) {
             if (tmp->rank >= node->rank)
                 break; // found it!
             else tmp = tmp->prev;
         }
         // now, if tmp isn't null, we need to move node to tmp->next
         // else move it to become head
         removeNode(node);
         insertNode(node, tmp);
     }
 }
 
 
 // iterate over the list, decreasing each url's rank
 // this is very naive, but a 1..30 for loop is acceptable (i hope)
 void PopularUrls::decreaseRanks()
 {
     if (head) {
         UrlNodeP p = head;
         while (p) {
             if (p->rank - DECREASE >= 0)
                 p->rank -= DECREASE;
             else p->rank = 0;
             p = p->next;
         }
     }
 }
 
 // removes a node from the list, but doesn't free memory!
 // note: this will be buggy in case the list becomes empty (which should never happen)
 void PopularUrls::removeNode(UrlNodeP node)
 {
     if (node->prev) {
         if (tail == node) tail = node->prev;
         node->prev->next = node->next;
     }
     if (node->next) {
         if (head == node) head = node->next;
         node->next->prev = node->prev;
     }
     --count;
 }
 
 void PopularUrls::insertNode(UrlNodeP node, UrlNodeP after)
 {
     if (!after) { // make node head
         node->next = head;
-        node->prev = 0;
+        node->prev = nullptr;
         head->prev = node;
         head = node;
     } else {
         if (tail == after) tail = node;
         node->prev = after;
         node->next = after->next;
         if (node->next) {
             after->next->prev = node;
             after->next = node;
         }
     }
     ++count;
 }
 
 // appends 'node' to the end of the list, collecting garbage if needed
 void PopularUrls::appendNode(UrlNodeP node)
 {
     if (!tail) { // creating the first element
         head = tail = node;
-        node->prev = node->next = 0;
+        node->prev = node->next = nullptr;
     } else {
-        node->next = 0;
+        node->next = nullptr;
         node->prev = tail;
         tail->next = node;
         tail = node;
     }
     ++count;
 }
 
 void PopularUrls::dumpList()
 {
     UrlNodeP p = head;
     printf("====start %d====\n", count);
     while (p) {
         printf("%d : %s\n", p->rank, p->url.url().toLatin1().data());
         p = p->next;
     }
     fflush(stdout);
 }
 
 void PopularUrls::showDialog()
 {
     QList<QUrl> list = getMostPopularUrls(maxUrls);
     dlg->run(list);
     if (dlg->result() == -1) return;
     SLOTS->refresh(list[dlg->result()]);
     //printf("running %s\n", list[dlg->result()].url().toLatin1());fflush(stdout);
 }
 
 // ===================================== PopularUrlsDlg ======================================
 PopularUrlsDlg::PopularUrlsDlg():
         QDialog(krMainWindow)
 {
     setWindowTitle(i18n("Popular URLs"));
     setWindowModality(Qt::WindowModal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
-    QGridLayout *layout = new QGridLayout;
+    auto *layout = new QGridLayout;
     layout->setContentsMargins(0, 0, 0, 0);
 
     // listview to contain the urls
     urls = new KrTreeWidget(this);
     urls->header()->hide();
     urls->setSortingEnabled(false);
     urls->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 
     // quick search
     search = new KTreeWidgetSearchLine(this, urls);
     QLabel *lbl = new QLabel(i18n("&Search:"), this);
     lbl->setBuddy(search);
 
     layout->addWidget(lbl, 0, 0);
     layout->addWidget(search, 0, 1);
     layout->addWidget(urls, 1, 0, 1, 2);
 
     mainLayout->addLayout(layout);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     setTabOrder(search, urls);
     setTabOrder((QWidget *)urls, buttonBox->button(QDialogButtonBox::Close));
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &PopularUrlsDlg::reject);
     connect(urls, &KrTreeWidget::activated, this, &PopularUrlsDlg::slotItemSelected);
     connect(search, &KTreeWidgetSearchLine::hiddenChanged, this, &PopularUrlsDlg::slotVisibilityChanged);
 }
 
 void PopularUrlsDlg::slotItemSelected(const QModelIndex & ndx)
 {
     selection = ndx.row();
     accept();
 }
 
 void PopularUrlsDlg::slotVisibilityChanged()
 {
     // select the first visible item
     QList<QTreeWidgetItem *> list = urls->selectedItems();
     if (list.count() > 0 && !list[0]->isHidden())
         return;
 
     urls->clearSelection();
-    urls->setCurrentItem(0);
+    urls->setCurrentItem(nullptr);
 
     QTreeWidgetItemIterator it(urls);
     while (*it) {
         if (!(*it)->isHidden()) {
             (*it)->setSelected(true);
             urls->setCurrentItem(*it);
             break;
         }
         it++;
     }
 }
 
 PopularUrlsDlg::~PopularUrlsDlg()
 {
     delete search;
     delete urls;
 }
 
 void PopularUrlsDlg::run(QList<QUrl> list)
 {
     // populate the listview
     urls->clear();
     QList<QUrl>::Iterator it;
 
-    QTreeWidgetItem * lastItem = 0;
+    QTreeWidgetItem * lastItem = nullptr;
 
     for (it = list.begin(); it != list.end(); ++it) {
-        QTreeWidgetItem *item = new QTreeWidgetItem(urls, lastItem);
+        auto *item = new QTreeWidgetItem(urls, lastItem);
         lastItem = item;
         item->setText(0, (*it).isLocalFile() ? (*it).path() : (*it).toDisplayString());
         item->setIcon(0, (*it).isLocalFile() ? Icon("folder") : Icon("folder-html"));
     }
 
     setMinimumSize(urls->sizeHint().width() + 45, 400);
 
     search->clear();
     search->setFocus();
     selection = -1;
     slotVisibilityChanged();
     exec();
 }
 
diff --git a/krusader/Dialogs/popularurls.h b/krusader/Dialogs/popularurls.h
index 7f028711..67149375 100644
--- a/krusader/Dialogs/popularurls.h
+++ b/krusader/Dialogs/popularurls.h
@@ -1,111 +1,111 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef POPULARURLS_H
 #define POPULARURLS_H
 
 // QtCore
 #include <QObject>
 #include <QHash>
 #include <QUrl>
 // QtWidgets
 #include <QDialog>
 
 // the class holds a list of most popular links in a dual data structure
 // * linked list, with head and tail: for fast append/prepend support
 // * dictionary that maps urls to list nodes: to save the need to iterate
 //   over the list in order to find the correct node for each new url
 //
 // also, the class holds a maximum number of urls. two variables affect this:
 // * maxUrls - the num. of urls the user can see
 // * hardLimit - the actual number of urls kept.
 // when the number of urls reaches hardLimit, a garbage collection is done and
 // the bottom (hardLimit-maxUrls) entries are removed from the list
 typedef struct _UrlNode* UrlNodeP;
 typedef struct _UrlNode {
     UrlNodeP prev;
     QUrl url;
     int rank;
     UrlNodeP next;
 } UrlNode;
 
 class PopularUrlsDlg;
 
 class PopularUrls : public QObject
 {
     Q_OBJECT
 public:
-    explicit PopularUrls(QObject *parent = 0);
-    ~PopularUrls();
+    explicit PopularUrls(QObject *parent = nullptr);
+    ~PopularUrls() override;
     void save();
     void load();
     void addUrl(const QUrl& url);
     QList<QUrl> getMostPopularUrls(int max);
 
 public slots:
     void showDialog();
 
 protected:
     // NOTE: the following methods append/insert/remove a node to the list
     // but NEVER free memory or allocate memory!
     void appendNode(UrlNodeP node);
     void insertNode(UrlNodeP node, UrlNodeP after);
     void removeNode(UrlNodeP node);
     void relocateIfNeeded(UrlNodeP node);
     void clearList();
     void dumpList();
     void decreaseRanks();
 
 private:
     UrlNodeP head, tail;
     QHash<QString, UrlNode *> ranks; // actually holds UrlNode*
     int count;
     static const int maxUrls = 30;
     PopularUrlsDlg *dlg;
 };
 
 class KrTreeWidget;
 class KTreeWidgetSearchLine;
 class QModelIndex;
 
 class PopularUrlsDlg: public QDialog
 {
     Q_OBJECT
 public:
     PopularUrlsDlg();
-    ~PopularUrlsDlg();
+    ~PopularUrlsDlg() override;
     void run(QList<QUrl> list); // use this to open the dialog
     inline int result() const {
         return selection;
     } // returns index 0 - topmost, or -1
 
 
 protected slots:
     void slotVisibilityChanged();
     void slotItemSelected(const QModelIndex &);
 
 private:
     KrTreeWidget *urls;
     KTreeWidgetSearchLine *search;
     int selection;
 };
 
 #endif
diff --git a/krusader/DiskUsage/diskusage.cpp b/krusader/DiskUsage/diskusage.cpp
index 95a2e66e..27a972ee 100644
--- a/krusader/DiskUsage/diskusage.cpp
+++ b/krusader/DiskUsage/diskusage.cpp
@@ -1,1133 +1,1134 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "diskusage.h"
 
 // QtCore
 #include <QDebug>
 #include <QEvent>
 #include <QHash>
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <QPointer>
 // QtGui
 #include <QKeyEvent>
 #include <QPixmap>
 #include <QResizeEvent>
 #include <QCursor>
 #include <QPixmapCache>
 // QtWidgets
 #include <QLayout>
 #include <QLabel>
 #include <QGridLayout>
 #include <QFrame>
 #include <QPushButton>
 #include <QApplication>
 #include <QGroupBox>
 #include <QMenu>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 #include <KWidgetsAddons/KStandardGuiItem>
 #include <KIO/Job>
 #include <KIO/DeleteJob>
+#include <utility>
 
 #include "dufilelight.h"
 #include "dulines.h"
 #include "dulistview.h"
 #include "filelightParts/Config.h"
 #include "../FileSystem/fileitem.h"
 #include "../FileSystem/filesystemprovider.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../Panel/krpanel.h"
 #include "../Panel/panelfunc.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../filelisticon.h"
 
 // these are the values that will exist in the menu
 #define DELETE_ID            90
 #define EXCLUDE_ID           91
 #define PARENT_DIR_ID        92
 #define NEW_SEARCH_ID        93
 #define REFRESH_ID           94
 #define STEP_INTO_ID         95
 #define INCLUDE_ALL_ID       96
 #define VIEW_POPUP_ID        97
 #define LINES_VIEW_ID        98
 #define DETAILED_VIEW_ID     99
 #define FILELIGHT_VIEW_ID   100
 #define NEXT_VIEW_ID        101
 #define PREVIOUS_VIEW_ID    102
 #define ADDITIONAL_POPUP_ID 103
 
 #define MAX_FILENUM         100
 
 LoaderWidget::LoaderWidget(QWidget *parent) : QScrollArea(parent), cancelled(false)
 {
     QPalette palette = viewport()->palette();
     palette.setColor(viewport()->backgroundRole(), Qt::white);
     viewport()->setPalette(palette);
 
     widget = new QWidget(parent);
 
-    QGridLayout *loaderLayout = new QGridLayout(widget);
+    auto *loaderLayout = new QGridLayout(widget);
     loaderLayout->setSpacing(0);
     loaderLayout->setContentsMargins(0, 0, 0, 0);
 
     QFrame *loaderBox = new QFrame(widget);
     loaderBox->setFrameShape(QFrame::Box);
     loaderBox->setFrameShadow(QFrame::Sunken);
     loaderBox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     loaderBox->setFrameStyle(QFrame::Panel + QFrame::Raised);
     loaderBox->setLineWidth(2);
 
-    QGridLayout *synchGrid = new QGridLayout(loaderBox);
+    auto *synchGrid = new QGridLayout(loaderBox);
     synchGrid->setSpacing(6);
     synchGrid->setContentsMargins(11, 11, 11, 11);
 
     QLabel *titleLabel = new QLabel(i18n("Loading Usage Information"), loaderBox);
     titleLabel->setAlignment(Qt::AlignHCenter);
     synchGrid->addWidget(titleLabel, 0, 0, 1, 2);
 
     QLabel *filesLabel = new QLabel(i18n("Files:"), loaderBox);
     filesLabel->setFrameShape(QLabel::StyledPanel);
     filesLabel->setFrameShadow(QLabel::Sunken);
     synchGrid->addWidget(filesLabel, 1, 0);
 
     QLabel *directoriesLabel = new QLabel(i18n("Directories:"), loaderBox);
     directoriesLabel->setFrameShape(QLabel::StyledPanel);
     directoriesLabel->setFrameShadow(QLabel::Sunken);
     synchGrid->addWidget(directoriesLabel, 2, 0);
 
     QLabel *totalSizeLabel = new QLabel(i18n("Total Size:"), loaderBox);
     totalSizeLabel->setFrameShape(QLabel::StyledPanel);
     totalSizeLabel->setFrameShadow(QLabel::Sunken);
     synchGrid->addWidget(totalSizeLabel, 3, 0);
 
     files = new QLabel(loaderBox);
     files->setFrameShape(QLabel::StyledPanel);
     files->setFrameShadow(QLabel::Sunken);
     files->setAlignment(Qt::AlignRight);
     synchGrid->addWidget(files, 1, 1);
 
     directories = new QLabel(loaderBox);
     directories->setFrameShape(QLabel::StyledPanel);
     directories->setFrameShadow(QLabel::Sunken);
     directories->setAlignment(Qt::AlignRight);
     synchGrid->addWidget(directories, 2, 1);
 
     totalSize = new QLabel(loaderBox);
     totalSize->setFrameShape(QLabel::StyledPanel);
     totalSize->setFrameShadow(QLabel::Sunken);
     totalSize->setAlignment(Qt::AlignRight);
     synchGrid->addWidget(totalSize, 3, 1);
 
     int width;
     searchedDirectory = new KSqueezedTextLabel(loaderBox);
     searchedDirectory->setFrameShape(QLabel::StyledPanel);
     searchedDirectory->setFrameShadow(QLabel::Sunken);
     searchedDirectory->setMinimumWidth(width = QFontMetrics(searchedDirectory->font()).width("W") * 30);
     searchedDirectory->setMaximumWidth(width);
     synchGrid->addWidget(searchedDirectory, 4, 0, 1, 2);
 
     QFrame *line = new QFrame(loaderBox);
     line->setFrameStyle(QFrame::HLine | QFrame::Sunken);
     synchGrid->addWidget(line, 5, 0, 1, 2);
 
     QWidget *hboxWidget = new QWidget(loaderBox);
-    QHBoxLayout * hbox = new QHBoxLayout(hboxWidget);
+    auto * hbox = new QHBoxLayout(hboxWidget);
 
-    QSpacerItem* spacer = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
+    auto* spacer = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
     hbox->addItem(spacer);
-    QPushButton *cancelButton = new QPushButton(hboxWidget);
+    auto *cancelButton = new QPushButton(hboxWidget);
     KStandardGuiItem::assign(cancelButton, KStandardGuiItem::Cancel);
     hbox->addWidget(cancelButton);
 
     synchGrid->addWidget(hboxWidget, 6, 1);
 
     loaderLayout->addWidget(loaderBox, 0, 0);
 
     setWidget(widget);
     setAlignment(Qt::AlignCenter);
 
     connect(cancelButton, &QPushButton::clicked, this, &LoaderWidget::slotCancelled);
 }
 
 void LoaderWidget::init()
 {
     cancelled = false;
 }
 
 void LoaderWidget::setCurrentURL(const QUrl &url)
 {
     searchedDirectory->setText(FileSystem::ensureTrailingSlash(url).toDisplayString(QUrl::PreferLocalFile));
 }
 
 void LoaderWidget::setValues(int fileNum, int dirNum, KIO::filesize_t total)
 {
     files->setText(QString("%1").arg(fileNum));
     directories->setText(QString("%1").arg(dirNum));
     totalSize->setText(QString("%1").arg(KRpermHandler::parseSize(total).trimmed()));
 }
 
 void LoaderWidget::slotCancelled()
 {
     cancelled = true;
 }
 
 DiskUsage::DiskUsage(QString confGroup, QWidget *parent) : QStackedWidget(parent),
-        currentDirectory(0), root(0), configGroup(confGroup), loading(false),
-        abortLoading(false), clearAfterAbort(false), deleting(false), searchFileSystem(0)
+        currentDirectory(nullptr), root(nullptr), configGroup(std::move(confGroup)), loading(false),
+        abortLoading(false), clearAfterAbort(false), deleting(false), searchFileSystem(nullptr)
 {
     listView = new DUListView(this);
     lineView = new DULines(this);
     filelightView = new DUFilelight(this);
     loaderView = new LoaderWidget(this);
 
     addWidget(listView);
     addWidget(lineView);
     addWidget(filelightView);
     addWidget(loaderView);
 
     setView(VIEW_LINES);
 
     Filelight::Config::read();
 
     connect(&loadingTimer, &QTimer::timeout, this, &DiskUsage::slotLoadDirectory);
 }
 
 DiskUsage::~DiskUsage()
 {
     if (listView)          // don't remove these lines. The module will crash at exit if removed
         delete listView;
     if (lineView)
         delete lineView;
     if (filelightView)
         delete filelightView;
 
     if (root)
         delete root;
 
     QHashIterator< File *, Properties * > lit(propertyMap);
     while (lit.hasNext())
         delete lit.next().value();
 }
 
 void DiskUsage::load(const QUrl &baseDir)
 {
 
     fileNum = dirNum = 0;
     currentSize = 0;
 
     emit status(i18n("Loading the disk usage information..."));
 
     clear();
 
     baseURL = baseDir.adjusted(QUrl::StripTrailingSlash);
 
     root = new Directory(baseURL.fileName(), baseDir.toDisplayString(QUrl::PreferLocalFile));
 
     directoryStack.clear();
     parentStack.clear();
 
     directoryStack.push("");
     parentStack.push(root);
 
     if (searchFileSystem) {
         delete searchFileSystem;
-        searchFileSystem = 0;
+        searchFileSystem = nullptr;
     }
     searchFileSystem = FileSystemProvider::instance().getFilesystem(baseDir);
-    if (searchFileSystem == 0) {
+    if (searchFileSystem == nullptr) {
         qWarning() << "could not get filesystem for directory=" << baseDir;
         loading = abortLoading = clearAfterAbort = false;
         emit loadFinished(false);
         return;
     }
 
-    currentFileItem = 0;
+    currentFileItem = nullptr;
 
     if (!loading) {
         viewBeforeLoad = activeView;
         setView(VIEW_LOADER);
     }
 
     loading = true;
 
     loaderView->init();
     loaderView->setCurrentURL(baseURL);
     loaderView->setValues(fileNum, dirNum, currentSize);
 
     loadingTimer.setSingleShot(true);
     loadingTimer.start(0);
 }
 
 void DiskUsage::slotLoadDirectory()
 {
-    if ((currentFileItem == 0 && directoryStack.isEmpty()) || loaderView->wasCancelled() || abortLoading) {
+    if ((currentFileItem == nullptr && directoryStack.isEmpty()) || loaderView->wasCancelled() || abortLoading) {
         if (searchFileSystem)
             delete searchFileSystem;
 
-        searchFileSystem = 0;
-        currentFileItem = 0;
+        searchFileSystem = nullptr;
+        currentFileItem = nullptr;
 
         setView(viewBeforeLoad);
 
         if (clearAfterAbort)
             clear();
         else {
             calculateSizes();
             changeDirectory(root);
         }
 
         emit loadFinished(!(loaderView->wasCancelled() || abortLoading));
 
         loading = abortLoading = clearAfterAbort = false;
     } else if (loading) {
         for (int counter = 0; counter != MAX_FILENUM; counter ++) {
-            if (currentFileItem == 0) {
+            if (currentFileItem == nullptr) {
                 if (directoryStack.isEmpty())
                     break;
 
                 dirToCheck = directoryStack.pop();
                 currentParent = parentStack.pop();
 
                 contentMap.insert(dirToCheck, currentParent);
 
                 QUrl url = baseURL;
 
                 if (!dirToCheck.isEmpty()) {
                     url = url.adjusted(QUrl::StripTrailingSlash);
                     url.setPath(url.path() + '/' + (dirToCheck));
                 }
 
 #ifdef BSD
                 if (url.isLocalFile() && url.path().left(7) == "/procfs")
                     break;
 #else
                 if (url.isLocalFile() && url.path().left(5) == "/proc")
                     break;
 #endif
 
                 loaderView->setCurrentURL(url);
 
                 if (!searchFileSystem->scanDir(url))
                     break;
                 fileItems = searchFileSystem->fileItems();
 
                 dirNum++;
 
                 currentFileItem = fileItems.isEmpty() ? 0 : fileItems.takeFirst();
             } else {
                 fileNum++;
-                File *newItem = 0;
+                File *newItem = nullptr;
 
                 QString mime = currentFileItem->getMime(); // fast == not using mimetype magic
 
                 if (currentFileItem->isDir() && !currentFileItem->isSymLink()) {
                     newItem = new Directory(currentParent, currentFileItem->getName(), dirToCheck, currentFileItem->getSize(),
                                             currentFileItem->getMode(), currentFileItem->getOwner(), currentFileItem->getGroup(),
                                             currentFileItem->getPerm(), currentFileItem->getTime_t(), currentFileItem->isSymLink(),
                                             mime);
                     directoryStack.push((dirToCheck.isEmpty() ? "" : dirToCheck + '/') + currentFileItem->getName());
                     parentStack.push(dynamic_cast<Directory *>(newItem));
                 } else {
                     newItem = new File(currentParent, currentFileItem->getName(), dirToCheck, currentFileItem->getSize(),
                                        currentFileItem->getMode(), currentFileItem->getOwner(), currentFileItem->getGroup(),
                                        currentFileItem->getPerm(), currentFileItem->getTime_t(), currentFileItem->isSymLink(),
                                        mime);
                     currentSize += currentFileItem->getSize();
                 }
                 currentParent->append(newItem);
 
                 currentFileItem = fileItems.isEmpty() ? 0 : fileItems.takeFirst();
             }
         }
 
         loaderView->setValues(fileNum, dirNum, currentSize);
         loadingTimer.setSingleShot(true);
         loadingTimer.start(0);
     }
 }
 
 void DiskUsage::stopLoad()
 {
     abortLoading = true;
 }
 
 void DiskUsage::close()
 {
     if (loading) {
         abortLoading = true;
         clearAfterAbort = true;
     }
 }
 
 void DiskUsage::dirUp()
 {
-    if (currentDirectory != 0) {
-        if (currentDirectory->parent() != 0)
+    if (currentDirectory != nullptr) {
+        if (currentDirectory->parent() != nullptr)
             changeDirectory((Directory *)(currentDirectory->parent()));
         else {
             QUrl up = KIO::upUrl(baseURL);
 
             if (KMessageBox::questionYesNo(this, i18n("Stepping into the parent folder requires "
                                            "loading the content of the \"%1\" URL. Do you wish "
                                            "to continue?", up.toDisplayString(QUrl::PreferLocalFile)),
                                            i18n("Krusader::DiskUsage"), KStandardGuiItem::yes(),
                                            KStandardGuiItem::no(), "DiskUsageLoadParentDir"
                                           ) == KMessageBox::Yes)
                 load(up);
         }
     }
 }
 
 Directory * DiskUsage::getDirectory(QString dir)
 {
     while (dir.endsWith('/'))
         dir.truncate(dir.length() - 1);
 
     if (dir.isEmpty())
         return root;
 
     if (contentMap.find(dir) == contentMap.end())
-        return 0;
+        return nullptr;
     return contentMap[ dir ];
 }
 
-File * DiskUsage::getFile(QString path)
+File * DiskUsage::getFile(const QString& path)
 {
     if (path.isEmpty())
         return root;
 
     QString dir = path;
 
     int ndx = path.lastIndexOf('/');
     QString file = path.mid(ndx + 1);
 
     if (ndx == -1)
         dir = "";
     else
         dir.truncate(ndx);
 
     Directory *dirEntry = getDirectory(dir);
-    if (dirEntry == 0)
-        return 0;
+    if (dirEntry == nullptr)
+        return nullptr;
 
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it)
         if ((*it)->name() == file)
             return *it;
 
-    return 0;
+    return nullptr;
 }
 
 void DiskUsage::clear()
 {
     baseURL = QUrl();
     emit clearing();
 
     QHashIterator< File *, Properties * > lit(propertyMap);
     while (lit.hasNext())
         delete lit.next().value();
 
     propertyMap.clear();
     contentMap.clear();
     if (root)
         delete root;
-    root = currentDirectory = 0;
+    root = currentDirectory = nullptr;
 }
 
 int DiskUsage::calculateSizes(Directory *dirEntry, bool emitSig, int depth)
 {
     int changeNr = 0;
 
-    if (dirEntry == 0)
+    if (dirEntry == nullptr)
         dirEntry = root;
 
     KIO::filesize_t own = 0, total = 0;
 
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it) {
         File * item = *it;
 
         if (!item->isExcluded()) {
             if (item->isDir())
                 changeNr += calculateSizes(dynamic_cast<Directory *>(item), emitSig, depth + 1);
             else
                 own += item->size();
 
             total += item->size();
         }
     }
 
     KIO::filesize_t oldOwn = dirEntry->ownSize(), oldTotal = dirEntry->size();
     dirEntry->setSizes(total, own);
 
     if (dirEntry == currentDirectory)
         currentSize = total;
 
     if (emitSig && (own != oldOwn || total != oldTotal)) {
         emit changed(dirEntry);
         changeNr++;
     }
 
     if (depth == 0 && changeNr != 0)
         emit changeFinished();
     return changeNr;
 }
 
 int DiskUsage::exclude(File *file, bool calcPercents, int depth)
 {
     int changeNr = 0;
 
     if (!file->isExcluded()) {
         file->exclude(true);
         emit changed(file);
         changeNr++;
 
         if (file->isDir()) {
-            Directory *dir = dynamic_cast<Directory *>(file);
+            auto *dir = dynamic_cast<Directory *>(file);
             for (Iterator<File> it = dir->iterator(); it != dir->end(); ++it)
                 changeNr += exclude(*it, false, depth + 1);
         }
     }
 
     if (calcPercents) {
         calculateSizes(root, true);
         calculatePercents(true);
         createStatus();
     }
 
     if (depth == 0 && changeNr != 0)
         emit changeFinished();
 
     return changeNr;
 }
 
 int DiskUsage::include(Directory *dir, int depth)
 {
     int changeNr = 0;
 
-    if (dir == 0)
+    if (dir == nullptr)
         return 0;
 
     for (Iterator<File> it = dir->iterator(); it != dir->end(); ++it) {
         File *item = *it;
 
         if (item->isDir())
             changeNr += include(dynamic_cast<Directory *>(item), depth + 1);
 
         if (item->isExcluded()) {
             item->exclude(false);
             emit changed(item);
             changeNr++;
         }
     }
 
     if (depth == 0 && changeNr != 0)
         emit changeFinished();
 
     return changeNr;
 }
 
 void DiskUsage::includeAll()
 {
     include(root);
     calculateSizes(root, true);
     calculatePercents(true);
     createStatus();
 }
 
 int DiskUsage::del(File *file, bool calcPercents, int depth)
 {
     int deleteNr = 0;
 
     if (file == root)
         return 0;
 
     KConfigGroup gg(krConfig, "General");
     bool trash = gg.readEntry("Move To Trash", _MoveToTrash);
     QUrl url = QUrl::fromLocalFile(file->fullPath());
 
     if (calcPercents) {
         // now ask the user if he want to delete:
         KConfigGroup ga(krConfig, "Advanced");
         if (ga.readEntry("Confirm Delete", _ConfirmDelete)) {
             QString s;
             KGuiItem b;
             if (trash && url.isLocalFile()) {
                 s = i18nc("singularOnly", "Do you really want to move this item to the trash?");
                 b = KGuiItem(i18n("&Trash"));
             } else {
                 s = i18nc("singularOnly", "Do you really want to delete this item?");
                 b = KStandardGuiItem::del();
             }
 
             QStringList name;
             name.append(file->fullPath());
             // show message
             // note: i'm using continue and not yes/no because the yes/no has cancel as default button
             if (KMessageBox::warningContinueCancelList(krMainWindow, s, name, i18n("Warning"), b) != KMessageBox::Continue)
                 return 0;
         }
 
         emit status(i18n("Deleting %1...", file->name()));
     }
 
     if (file == currentDirectory)
         dirUp();
 
     if (file->isDir()) {
-        Directory *dir = dynamic_cast<Directory *>(file);
+        auto *dir = dynamic_cast<Directory *>(file);
 
         Iterator<File> it;
         while ((it = dir->iterator()) != dir->end())
             deleteNr += del(*it, false, depth + 1);
 
         QString path;
-        for (const Directory *d = (Directory*)file; d != root && d && d->parent() != 0; d = d->parent()) {
+        for (const Directory *d = (Directory*)file; d != root && d && d->parent() != nullptr; d = d->parent()) {
             if (!path.isEmpty())
                 path = '/' + path;
 
             path = d->name() + path;
         }
 
         contentMap.remove(path);
     }
 
     emit deleted(file);
     deleteNr++;
 
     KIO::Job *job;
 
     if (trash) {
         job = KIO::trash(url);
     } else {
         job = KIO::del(QUrl::fromLocalFile(file->fullPath()), KIO::HideProgressInfo);
     }
 
     deleting = true;    // during qApp->processEvent strange things can occur
     grabMouse();        // that's why we disable the mouse and keyboard events
     grabKeyboard();
 
     job->exec();
     delete job;
 
     releaseMouse();
     releaseKeyboard();
     deleting = false;
 
     ((Directory *)(file->parent()))->remove(file);
     delete file;
 
     if (depth == 0)
         createStatus();
 
     if (calcPercents) {
         calculateSizes(root, true);
         calculatePercents(true);
         createStatus();
         emit enteringDirectory(currentDirectory);
     }
 
     if (depth == 0 && deleteNr != 0)
         emit deleteFinished();
 
     return deleteNr;
 }
 
-void * DiskUsage::getProperty(File *item, QString key)
+void * DiskUsage::getProperty(File *item, const QString& key)
 {
     QHash< File *, Properties *>::iterator itr = propertyMap.find(item);
     if (itr == propertyMap.end())
-        return 0;
+        return nullptr;
 
     QHash<QString, void *>::iterator it = (*itr)->find(key);
     if (it == (*itr)->end())
-        return 0;
+        return nullptr;
 
     return it.value();
 }
 
-void DiskUsage::addProperty(File *item, QString key, void * prop)
+void DiskUsage::addProperty(File *item, const QString& key, void * prop)
 {
     Properties *props;
     QHash< File *, Properties *>::iterator itr = propertyMap.find(item);
     if (itr == propertyMap.end()) {
         props = new Properties();
         propertyMap.insert(item, props);
     } else
         props = *itr;
 
     props->insert(key, prop);
 }
 
-void DiskUsage::removeProperty(File *item, QString key)
+void DiskUsage::removeProperty(File *item, const QString& key)
 {
     QHash< File *, Properties *>::iterator itr = propertyMap.find(item);
     if (itr == propertyMap.end())
         return;
     (*itr)->remove(key);
     if ((*itr)->count() == 0)
         propertyMap.remove(item);
 }
 
 void DiskUsage::createStatus()
 {
     Directory *dirEntry = currentDirectory;
 
-    if (dirEntry == 0)
+    if (dirEntry == nullptr)
         return;
 
     QUrl url = baseURL;
     if (dirEntry != root) {
         url = url.adjusted(QUrl::StripTrailingSlash);
         url.setPath(url.path() + '/' + (dirEntry->directory()));
     }
 
     emit status(i18n("Current folder:%1,  Total size:%2,  Own size:%3",
                      url.toDisplayString(QUrl::PreferLocalFile | QUrl::StripTrailingSlash),
                      ' ' + KRpermHandler::parseSize(dirEntry->size()),
                      ' ' + KRpermHandler::parseSize(dirEntry->ownSize())));
 }
 
 void DiskUsage::changeDirectory(Directory *dir)
 {
     currentDirectory = dir;
 
     currentSize = dir->size();
     calculatePercents(true, dir);
 
     createStatus();
     emit enteringDirectory(dir);
 }
 
 Directory* DiskUsage::getCurrentDir()
 {
     return currentDirectory;
 }
 
-void DiskUsage::rightClickMenu(const QPoint & pos, File *fileItem, QMenu *addPopup, QString addPopupName)
+void DiskUsage::rightClickMenu(const QPoint & pos, File *fileItem, QMenu *addPopup, const QString& addPopupName)
 {
     QMenu popup(this);
 
     popup.setTitle(i18n("Disk Usage"));
 
     QHash<void *, int> actionHash;
 
-    if (fileItem != 0) {
+    if (fileItem != nullptr) {
         QAction * actDelete = popup.addAction(i18n("Delete"));
         actionHash[ actDelete ] = DELETE_ID;
         actDelete->setShortcut(Qt::Key_Delete);
         QAction * actExclude = popup.addAction(i18n("Exclude"));
         actionHash[ actExclude ] = EXCLUDE_ID;
         actExclude->setShortcut(Qt::CTRL + Qt::Key_E);
         popup.addSeparator();
     }
 
     QAction * myAct = popup.addAction(i18n("Up one folder"));
     actionHash[ myAct ] = PARENT_DIR_ID;
     myAct->setShortcut(Qt::SHIFT + Qt::Key_Up);
 
     myAct = popup.addAction(i18n("New search"));
     actionHash[ myAct ] = NEW_SEARCH_ID;
     myAct->setShortcut(Qt::CTRL + Qt::Key_N);
 
     myAct = popup.addAction(i18n("Refresh"));
     actionHash[ myAct ] = REFRESH_ID;
     myAct->setShortcut(Qt::CTRL + Qt::Key_R);
 
     myAct = popup.addAction(i18n("Include all"));
     actionHash[ myAct ] = INCLUDE_ALL_ID;
     myAct->setShortcut(Qt::CTRL + Qt::Key_I);
 
     myAct = popup.addAction(i18n("Step into"));
     actionHash[ myAct ] = STEP_INTO_ID;
     myAct->setShortcut(Qt::SHIFT + Qt::Key_Down);
 
     popup.addSeparator();
 
 
-    if (addPopup != 0) {
+    if (addPopup != nullptr) {
         QAction * menu = popup.addMenu(addPopup);
         menu->setText(addPopupName);
     }
 
     QMenu viewPopup;
 
     myAct = viewPopup.addAction(i18n("Lines"));
     actionHash[ myAct ] = LINES_VIEW_ID;
     myAct->setShortcut(Qt::CTRL + Qt::Key_L);
 
     myAct = viewPopup.addAction(i18n("Detailed"));
     actionHash[ myAct ] = DETAILED_VIEW_ID;
     myAct->setShortcut(Qt::CTRL + Qt::Key_D);
 
     myAct = viewPopup.addAction(i18n("Filelight"));
     actionHash[ myAct ] = FILELIGHT_VIEW_ID;
     myAct->setShortcut(Qt::CTRL + Qt::Key_F);
 
     viewPopup.addSeparator();
 
     myAct = viewPopup.addAction(i18n("Next"));
     actionHash[ myAct ] = NEXT_VIEW_ID;
     myAct->setShortcut(Qt::SHIFT + Qt::Key_Right);
 
     myAct = viewPopup.addAction(i18n("Previous"));
     actionHash[ myAct ] = PREVIOUS_VIEW_ID;
     myAct->setShortcut(Qt::SHIFT + Qt::Key_Left);
 
     QAction * menu = popup.addMenu(&viewPopup);
     menu->setText(i18n("View"));
 
     QAction * res = popup.exec(pos);
 
     if (actionHash.contains(res))
         executeAction(actionHash[ res ], fileItem);
 }
 
 void DiskUsage::executeAction(int action, File * fileItem)
 {
     // check out the user's option
     switch (action) {
     case DELETE_ID:
         if (fileItem)
             del(fileItem);
         break;
     case EXCLUDE_ID:
         if (fileItem)
             exclude(fileItem);
         break;
     case PARENT_DIR_ID:
         dirUp();
         break;
     case NEW_SEARCH_ID:
         emit newSearch();
         break;
     case REFRESH_ID:
         load(baseURL);
         break;
     case INCLUDE_ALL_ID:
         includeAll();
         break;
     case STEP_INTO_ID: {
         QString uri;
         if (fileItem && fileItem->isDir())
             uri = fileItem->fullPath();
         else
             uri = currentDirectory->fullPath();
         ACTIVE_FUNC->openUrl(QUrl::fromLocalFile(uri));
     }
     break;
     case LINES_VIEW_ID:
         setView(VIEW_LINES);
         break;
     case DETAILED_VIEW_ID:
         setView(VIEW_DETAILED);
         break;
     case FILELIGHT_VIEW_ID:
         setView(VIEW_FILELIGHT);
         break;
     case NEXT_VIEW_ID:
         setView((activeView + 1) % 3);
         break;
     case PREVIOUS_VIEW_ID:
         setView((activeView + 2) % 3);
         break;
     }
 //     currentWidget()->setFocus();
 }
 
 void DiskUsage::keyPressEvent(QKeyEvent *e)
 {
     if (activeView != VIEW_LOADER) {
         switch (e->key()) {
         case Qt::Key_E:
             if (e->modifiers() == Qt::ControlModifier) {
                 executeAction(EXCLUDE_ID, getCurrentFile());
                 return;
             }
             break;
         case Qt::Key_D:
             if (e->modifiers() == Qt::ControlModifier) {
                 executeAction(DETAILED_VIEW_ID);
                 return;
             }
             break;
         case Qt::Key_F:
             if (e->modifiers() == Qt::ControlModifier) {
                 executeAction(FILELIGHT_VIEW_ID);
                 return;
             }
             break;
         case Qt::Key_I:
             if (e->modifiers() == Qt::ControlModifier) {
                 executeAction(INCLUDE_ALL_ID);
                 return;
             }
             break;
         case Qt::Key_L:
             if (e->modifiers() == Qt::ControlModifier) {
                 executeAction(LINES_VIEW_ID);
                 return;
             }
             break;
         case Qt::Key_N:
             if (e->modifiers() == Qt::ControlModifier) {
                 executeAction(NEW_SEARCH_ID);
                 return;
             }
             break;
         case Qt::Key_R:
             if (e->modifiers() == Qt::ControlModifier) {
                 executeAction(REFRESH_ID);
                 return;
             }
             break;
         case Qt::Key_Up:
             if (e->modifiers() == Qt::ShiftModifier) {
                 executeAction(PARENT_DIR_ID);
                 return;
             }
             break;
         case Qt::Key_Down:
             if (e->modifiers() == Qt::ShiftModifier) {
                 executeAction(STEP_INTO_ID);
                 return;
             }
             break;
         case Qt::Key_Left:
             if (e->modifiers() == Qt::ShiftModifier) {
                 executeAction(PREVIOUS_VIEW_ID);
                 return;
             }
             break;
         case Qt::Key_Right:
             if (e->modifiers() == Qt::ShiftModifier) {
                 executeAction(NEXT_VIEW_ID);
                 return;
             }
             break;
         case Qt::Key_Delete:
             if (!e->modifiers()) {
                 executeAction(DELETE_ID, getCurrentFile());
                 return;
             }
             break;
         case Qt::Key_Plus:
             if (activeView == VIEW_FILELIGHT) {
                 filelightView->zoomIn();
                 return;
             }
             break;
         case Qt::Key_Minus:
             if (activeView == VIEW_FILELIGHT) {
                 filelightView->zoomOut();
                 return;
             }
             break;
         }
     }
     QStackedWidget::keyPressEvent(e);
 }
 
-QPixmap DiskUsage::getIcon(QString mime)
+QPixmap DiskUsage::getIcon(const QString& mime)
 {
     QPixmap icon;
 
     if (!QPixmapCache::find(mime, icon)) {
         // get the icon.
         if (mime == "Broken Link !") // FIXME: this doesn't work anymore - the reported mimetype for a broken link is now "unknown"
             icon = FileListIcon("file-broken").pixmap();
         else {
             QMimeDatabase db;
             QMimeType mt = db.mimeTypeForName(mime);
             if (mt.isValid())
                 icon = FileListIcon(mt.iconName()).pixmap();
             else
                 icon = FileListIcon("file-broken").pixmap();
         }
 
         // insert it into the cache
         QPixmapCache::insert(mime, icon);
     }
     return icon;
 }
 
 int DiskUsage::calculatePercents(bool emitSig, Directory *dirEntry, int depth)
 {
     int changeNr = 0;
 
-    if (dirEntry == 0)
+    if (dirEntry == nullptr)
         dirEntry = root;
 
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it) {
         File *item = *it;
 
         if (!item->isExcluded()) {
             int newPerc;
 
             if (dirEntry->size() == 0 && item->size() == 0)
                 newPerc = 0;
             else if (dirEntry->size() == 0)
                 newPerc = -1;
             else
                 newPerc = (int)((double)item->size() / (double)currentSize * 10000. + 0.5);
 
             int oldPerc = item->intPercent();
             item->setPercent(newPerc);
 
             if (emitSig && newPerc != oldPerc) {
                 emit changed(item);
                 changeNr++;
             }
 
             if (item->isDir())
                 changeNr += calculatePercents(emitSig, dynamic_cast<Directory *>(item), depth + 1);
         }
     }
 
     if (depth == 0 && changeNr != 0)
         emit changeFinished();
     return changeNr;
 }
 
 QString DiskUsage::getToolTip(File *item)
 {
     QMimeDatabase db;
     QMimeType mt = db.mimeTypeForName(item->mime());
     QString mime;
     if (mt.isValid())
         mime = mt.comment();
 
     time_t tma = item->time();
     struct tm* t = localtime((time_t *) & tma);
     QDateTime tmp(QDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday), QTime(t->tm_hour, t->tm_min));
     QString date = QLocale().toString(tmp, QLocale::ShortFormat);
 
     QString str = "<qt><h5><table><tr><td>" + i18n("Name:") +  "</td><td>" + item->name() + "</td></tr>" +
                   "<tr><td>" + i18n("Type:") +  "</td><td>" + mime + "</td></tr>" +
                   "<tr><td>" + i18n("Size:") +  "</td><td>" + KRpermHandler::parseSize(item->size()) + "</td></tr>";
 
     if (item->isDir())
         str +=      "<tr><td>" + i18n("Own size:") +  "</td><td>" + KRpermHandler::parseSize(item->ownSize()) + "</td></tr>";
 
     str +=        "<tr><td>" + i18n("Last modified:") +  "</td><td>" + date + "</td></tr>" +
                   "<tr><td>" + i18n("Permissions:") +  "</td><td>" + item->perm() + "</td></tr>" +
                   "<tr><td>" + i18n("Owner:") +  "</td><td>" + item->owner() + " - " + item->group() + "</td></tr>" +
                   "</table></h5></qt>";
     str.replace(' ', "&nbsp;");
     return str;
 }
 
 void DiskUsage::setView(int view)
 {
     switch (view) {
     case VIEW_LINES:
         setCurrentWidget(lineView);
         break;
     case VIEW_DETAILED:
         setCurrentWidget(listView);
         break;
     case VIEW_FILELIGHT:
         setCurrentWidget(filelightView);
         break;
     case VIEW_LOADER:
         setCurrentWidget(loaderView);
         break;
     }
 
 //     currentWidget()->setFocus();
     emit viewChanged(activeView = view);
 }
 
 File * DiskUsage::getCurrentFile()
 {
-    File * file = 0;
+    File * file = nullptr;
 
     switch (activeView) {
     case VIEW_LINES:
         file = lineView->getCurrentFile();
         break;
     case VIEW_DETAILED:
         file = listView->getCurrentFile();
         break;
     case VIEW_FILELIGHT:
         file = filelightView->getCurrentFile();
         break;
     }
 
     return file;
 }
 
 bool DiskUsage::event(QEvent * e)
 {
     if (deleting) {                        // if we are deleting, disable the mouse and
         switch (e->type()) {                 // keyboard events
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease:
         case QEvent::MouseButtonDblClick:
         case QEvent::MouseMove:
         case QEvent::KeyPress:
         case QEvent::KeyRelease:
             return true;
         default:
             break;
         }
     }
 
     if (e->type() == QEvent::ShortcutOverride) {
-        QKeyEvent* ke = (QKeyEvent*) e;
+        auto* ke = (QKeyEvent*) e;
 
         if (ke->modifiers() == Qt::NoModifier || ke->modifiers() == Qt::KeypadModifier) {
             switch (ke->key()) {
             case Qt::Key_Delete:
             case Qt::Key_Plus:
             case Qt::Key_Minus:
                 ke->accept();
                 break;
             }
         } else if (ke->modifiers() == Qt::ShiftModifier) {
             switch (ke->key()) {
             case Qt::Key_Left:
             case Qt::Key_Right:
             case Qt::Key_Up:
             case Qt::Key_Down:
                 ke->accept();
                 break;
             }
         } else if (ke->modifiers() & Qt::ControlModifier) {
             switch (ke->key()) {
             case Qt::Key_D:
             case Qt::Key_E:
             case Qt::Key_F:
             case Qt::Key_I:
             case Qt::Key_L:
             case Qt::Key_N:
             case Qt::Key_R:
                 ke->accept();
                 break;
             }
         }
     }
     return QStackedWidget::event(e);
 }
 
diff --git a/krusader/DiskUsage/diskusage.h b/krusader/DiskUsage/diskusage.h
index 14e1b279..3e7696db 100644
--- a/krusader/DiskUsage/diskusage.h
+++ b/krusader/DiskUsage/diskusage.h
@@ -1,209 +1,209 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DISKUSAGE_H
 #define DISKUSAGE_H
 
 // QtCore
 #include <QHash>
 #include <QEvent>
 #include <QTimer>
 #include <QStack>
 #include <QUrl>
 // QtGui
 #include <QResizeEvent>
 #include <QKeyEvent>
 #include <QPixmap>
 // QtWidgets
 #include <QDialog>
 #include <QLabel>
 #include <QStackedWidget>
 #include <QScrollArea>
 
 #include <KWidgetsAddons/KSqueezedTextLabel>
 
 #include "filelightParts/fileTree.h"
 
 #define VIEW_LINES      0
 #define VIEW_DETAILED   1
 #define VIEW_FILELIGHT  2
 #define VIEW_LOADER     3
 
 typedef QHash<QString, void *> Properties;
 
 class DUListView;
 class DULines;
 class DUFilelight;
 class QMenu;
 class LoaderWidget;
 class FileItem;
 class FileSystem;
 
 class DiskUsage : public QStackedWidget
 {
     Q_OBJECT
 
 public:
     explicit DiskUsage(QString confGroup, QWidget *parent = 0);
     ~DiskUsage();
 
     void       load(const QUrl &dirName);
     void       close();
     void       stopLoad();
     bool       isLoading()     {
         return loading;
     }
 
     void       setView(int view);
     int        getActiveView() {
         return activeView;
     }
 
     Directory* getDirectory(QString path);
-    File *     getFile(QString path);
+    File *     getFile(const QString& path);
 
     QString    getConfigGroup() {
         return configGroup;
     }
 
-    void *     getProperty(File *, QString);
-    void       addProperty(File *, QString, void *);
-    void       removeProperty(File *, QString);
+    void *     getProperty(File *, const QString&);
+    void       addProperty(File *, const QString&, void *);
+    void       removeProperty(File *, const QString&);
 
     int        exclude(File *file, bool calcPercents = true, int depth = 0);
     void       includeAll();
 
     int        del(File *file, bool calcPercents = true, int depth = 0);
 
     QString    getToolTip(File *);
 
-    void       rightClickMenu(const QPoint &, File *, QMenu * = 0, QString = QString());
+    void       rightClickMenu(const QPoint &, File *, QMenu * = 0, const QString& = QString());
 
     void       changeDirectory(Directory *dir);
 
     Directory* getCurrentDir();
     File*      getCurrentFile();
 
-    QPixmap    getIcon(QString mime);
+    QPixmap    getIcon(const QString& mime);
 
     QUrl       getBaseURL() {
         return baseURL;
     }
 
 public slots:
     void       dirUp();
     void       clear();
 
 signals:
     void       enteringDirectory(Directory *);
     void       clearing();
     void       changed(File *);
     void       changeFinished();
     void       deleted(File *);
     void       deleteFinished();
     void       status(QString);
     void       viewChanged(int);
     void       loadFinished(bool);
     void       newSearch();
 
 protected slots:
     void       slotLoadDirectory();
 
 protected:
     QHash< QString, Directory * > contentMap;
     QHash< File *, Properties *> propertyMap;
 
     Directory* currentDirectory;
     KIO::filesize_t currentSize;
 
     virtual void keyPressEvent(QKeyEvent *) Q_DECL_OVERRIDE;
     virtual bool event(QEvent *) Q_DECL_OVERRIDE;
 
     int        calculateSizes(Directory *dir = 0, bool emitSig = false, int depth = 0);
     int        calculatePercents(bool emitSig = false, Directory *dir = 0 , int depth = 0);
     int        include(Directory *dir, int depth = 0);
     void       createStatus();
     void       executeAction(int, File * = 0);
 
     QUrl       baseURL;             //< the base URL of loading
 
     DUListView                *listView;
     DULines                   *lineView;
     DUFilelight               *filelightView;
     LoaderWidget              *loaderView;
 
     Directory *root;
 
     int        activeView;
 
     QString    configGroup;
 
     bool       first;
     bool       loading;
     bool       abortLoading;
     bool       clearAfterAbort;
     bool       deleting;
 
     QStack<QString> directoryStack;
     QStack<Directory *> parentStack;
 
     FileSystem *searchFileSystem;
     FileItem *currentFileItem;
     QList<FileItem *> fileItems;
     Directory *currentParent;
     QString dirToCheck;
 
     int   fileNum;
     int   dirNum;
     int   viewBeforeLoad;
 
     QTimer loadingTimer;
 };
 
 
 class LoaderWidget : public QScrollArea
 {
     Q_OBJECT
 
 public:
     explicit LoaderWidget(QWidget *parent = 0);
 
     void init();
     void setCurrentURL(const QUrl &url);
     void setValues(int fileNum, int dirNum, KIO::filesize_t total);
     bool wasCancelled()  {
         return cancelled;
     }
 
 public slots:
     void slotCancelled();
 
 protected:
     QLabel *totalSize;
     QLabel *files;
     QLabel *directories;
 
     KSqueezedTextLabel *searchedDirectory;
     QWidget *widget;
 
     bool   cancelled;
 };
 
 #endif /* __DISK_USAGE_GUI_H__ */
diff --git a/krusader/DiskUsage/diskusagegui.cpp b/krusader/DiskUsage/diskusagegui.cpp
index 36ba3bc8..9a38de44 100644
--- a/krusader/DiskUsage/diskusagegui.cpp
+++ b/krusader/DiskUsage/diskusagegui.cpp
@@ -1,242 +1,242 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "diskusagegui.h"
 
 // QtCore
 #include <QTimer>
 // QtGui
 #include <QResizeEvent>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QLabel>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../FileSystem/filesystem.h"
 #include "../Dialogs/krdialogs.h"
 
 DiskUsageGUI::DiskUsageGUI(const QUrl &openDir)
         : QDialog(nullptr), exitAtFailure(true)
 {
     setWindowTitle(i18n("Krusader::Disk Usage"));
     setAttribute(Qt::WA_DeleteOnClose);
 
     baseDirectory = openDir;
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
-    QGridLayout *duGrid = new QGridLayout();
+    auto *duGrid = new QGridLayout();
     duGrid->setSpacing(6);
     duGrid->setContentsMargins(11, 11, 11, 11);
 
     QWidget *duTools = new QWidget(this);
-    QHBoxLayout *duHBox = new QHBoxLayout(duTools);
+    auto *duHBox = new QHBoxLayout(duTools);
     duHBox->setContentsMargins(0, 0, 0, 0);
     duTools->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     btnNewSearch = new QToolButton(duTools);
     btnNewSearch->setIcon(Icon("document-open"));
     duHBox->addWidget(btnNewSearch);
     btnNewSearch->setToolTip(i18n("Start new disk usage search"));
 
     btnRefresh = new QToolButton(duTools);
     btnRefresh->setIcon(Icon("view-refresh"));
     duHBox->addWidget(btnRefresh);
     btnRefresh->setToolTip(i18n("Refresh"));
 
     btnDirUp = new QToolButton(duTools);
     btnDirUp->setIcon(Icon("go-up"));
     duHBox->addWidget(btnDirUp);
     btnDirUp->setToolTip(i18n("Parent folder"));
 
     QWidget *separatorWidget = new QWidget(duTools);
     separatorWidget->setMinimumWidth(10);
     duHBox->addWidget(separatorWidget);
 
     btnLines = new QToolButton(duTools);
     btnLines->setIcon(Icon("view-list-details"));
     btnLines->setCheckable(true);
     duHBox->addWidget(btnLines);
     btnLines->setToolTip(i18n("Line view"));
 
     btnDetailed = new QToolButton(duTools);
     btnDetailed->setIcon(Icon("view-list-tree"));
     btnDetailed->setCheckable(true);
     duHBox->addWidget(btnDetailed);
     btnDetailed->setToolTip(i18n("Detailed view"));
 
     btnFilelight = new QToolButton(duTools);
     btnFilelight->setIcon(Icon("kr_diskusage"));
     btnFilelight->setCheckable(true);
     duHBox->addWidget(btnFilelight);
     btnFilelight->setToolTip(i18n("Filelight view"));
 
     QWidget *spacerWidget = new QWidget(duTools);
     duHBox->addWidget(spacerWidget);
-    QHBoxLayout *hboxlayout = new QHBoxLayout(spacerWidget);
-    QSpacerItem* spacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed);
+    auto *hboxlayout = new QHBoxLayout(spacerWidget);
+    auto* spacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed);
     hboxlayout->addItem(spacer);
 
     duGrid->addWidget(duTools, 0, 0);
 
     diskUsage = new DiskUsage("DiskUsage", this);
     duGrid->addWidget(diskUsage, 1, 0);
 
     status = new KSqueezedTextLabel(this);
     duGrid->addWidget(status, 2, 0);
 
     mainLayout->addLayout(duGrid);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &DiskUsageGUI::close);
     connect(diskUsage, &DiskUsage::status, this, &DiskUsageGUI::slotStatus);
     connect(diskUsage, &DiskUsage::viewChanged, this, &DiskUsageGUI::slotViewChanged);
     connect(diskUsage, &DiskUsage::newSearch, this, &DiskUsageGUI::askDir);
     connect(diskUsage, &DiskUsage::loadFinished, this, &DiskUsageGUI::slotLoadFinished);
     connect(btnNewSearch, &QToolButton::clicked, this, &DiskUsageGUI::askDir);
     connect(btnRefresh, &QToolButton::clicked, this, &DiskUsageGUI::slotLoadUsageInfo);
     connect(btnDirUp, &QToolButton::clicked, diskUsage, &DiskUsage::dirUp);
     connect(btnLines, &QToolButton::clicked, this, &DiskUsageGUI::slotSelectLinesView);
     connect(btnDetailed, &QToolButton::clicked, this, &DiskUsageGUI::slotSelectListView);
     connect(btnFilelight, &QToolButton::clicked, this, &DiskUsageGUI::slotSelectFilelightView);
 
     KConfigGroup group(krConfig, "DiskUsage");
 
     int view = group.readEntry("View",  VIEW_LINES);
     if (view < VIEW_LINES || view > VIEW_FILELIGHT)
         view = VIEW_LINES;
 
     diskUsage->setView(view);
 
     sizeX = group.readEntry("Window Width",  QFontMetrics(font()).width("W") * 70);
     sizeY = group.readEntry("Window Height", QFontMetrics(font()).height() * 25);
     resize(sizeX, sizeY);
 
     if (group.readEntry("Window Maximized",  false)) {
         setWindowState(windowState() | Qt::WindowMaximized);
     }
 }
 
 void DiskUsageGUI::askDirAndShow()
 {
     if (askDir()) {
         show();
     }
 }
 
 void DiskUsageGUI::slotLoadFinished(bool result)
 {
     if (exitAtFailure && !result) {
         close();
     } else {
         exitAtFailure = false;
     }
 }
 
 void DiskUsageGUI::enableButtons(bool isOn)
 {
     btnNewSearch->setEnabled(isOn);
     btnRefresh->setEnabled(isOn);
     btnDirUp->setEnabled(isOn);
     btnLines->setEnabled(isOn);
     btnDetailed->setEnabled(isOn);
     btnFilelight->setEnabled(isOn);
 }
 
 void DiskUsageGUI::resizeEvent(QResizeEvent *e)
 {
     if (!isMaximized()) {
         sizeX = e->size().width();
         sizeY = e->size().height();
     }
     QDialog::resizeEvent(e);
 }
 
 void DiskUsageGUI::closeEvent(QCloseEvent *event)
 {
     KConfigGroup group(krConfig, "DiskUsage");
     group.writeEntry("Window Width", sizeX);
     group.writeEntry("Window Height", sizeY);
     group.writeEntry("Window Maximized", isMaximized());
     group.writeEntry("View", diskUsage->getActiveView());
 
     event->accept();
 }
 
 void DiskUsageGUI::slotLoadUsageInfo()
 {
     diskUsage->load(baseDirectory);
 }
 
-void DiskUsageGUI::slotStatus(QString stat)
+void DiskUsageGUI::slotStatus(const QString& stat)
 {
     status->setText(stat);
 }
 
 void DiskUsageGUI::slotViewChanged(int view)
 {
     if (view == VIEW_LOADER) {
         enableButtons(false);
         return;
     }
     enableButtons(true);
 
     btnLines->setChecked(false);
     btnDetailed->setChecked(false);
     btnFilelight->setChecked(false);
 
     switch (view) {
     case VIEW_LINES:
         btnLines->setChecked(true);
         break;
     case VIEW_DETAILED:
         btnDetailed->setChecked(true);
         break;
     case VIEW_FILELIGHT:
         btnFilelight->setChecked(true);
         break;
     case VIEW_LOADER:
         break;
     }
 }
 
 bool DiskUsageGUI::askDir()
 {
     // ask the user for the copy destX
     const QUrl newDir =
         KChooseDir::getDir(i18n("Viewing the usage of folder:"), baseDirectory, baseDirectory);
 
     if (newDir.isEmpty())
         return false;
 
     baseDirectory = newDir;
 
     QTimer::singleShot(0, this, &DiskUsageGUI::slotLoadUsageInfo);
     return true;
 }
diff --git a/krusader/DiskUsage/diskusagegui.h b/krusader/DiskUsage/diskusagegui.h
index 268f77e4..8313bc94 100644
--- a/krusader/DiskUsage/diskusagegui.h
+++ b/krusader/DiskUsage/diskusagegui.h
@@ -1,87 +1,87 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DISKUSAGEGUI_H
 #define DISKUSAGEGUI_H
 
 // QtCore
 #include <QUrl>
 // QtGui
 #include <QResizeEvent>
 // QtWidgets
 #include <QDialog>
 #include <QLayout>
 #include <QToolButton>
 
 #include <KWidgetsAddons/KSqueezedTextLabel>
 
 #include "diskusage.h"
 
 class DiskUsageGUI : public QDialog
 {
     Q_OBJECT
 
 public:
     explicit DiskUsageGUI(const QUrl &openDir);
-    ~DiskUsageGUI() {}
+    ~DiskUsageGUI() override = default;
     void askDirAndShow();
 
 protected slots:
-    virtual void closeEvent(QCloseEvent *event) Q_DECL_OVERRIDE;
+    void closeEvent(QCloseEvent *event) Q_DECL_OVERRIDE;
 
 protected:
-    virtual void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
+    void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
 
 private slots:
     bool askDir();
     void slotLoadUsageInfo();
-    void slotStatus(QString);
+    void slotStatus(const QString&);
 
     void slotSelectLinesView() { diskUsage->setView(VIEW_LINES); }
     void slotSelectListView() { diskUsage->setView(VIEW_DETAILED); }
     void slotSelectFilelightView() { diskUsage->setView(VIEW_FILELIGHT); }
 
     void slotViewChanged(int view);
     void slotLoadFinished(bool);
 
 private:
     void enableButtons(bool);
 
     DiskUsage *diskUsage;
     QUrl baseDirectory;
 
     KSqueezedTextLabel *status;
 
     QToolButton *btnNewSearch;
     QToolButton *btnRefresh;
     QToolButton *btnDirUp;
 
     QToolButton *btnLines;
     QToolButton *btnDetailed;
     QToolButton *btnFilelight;
 
     int sizeX;
     int sizeY;
 
     bool exitAtFailure;
 };
 
 #endif /* __DISK_USAGE_GUI_H__ */
 
diff --git a/krusader/DiskUsage/dufilelight.cpp b/krusader/DiskUsage/dufilelight.cpp
index 2aa18b36..249bf6b9 100644
--- a/krusader/DiskUsage/dufilelight.cpp
+++ b/krusader/DiskUsage/dufilelight.cpp
@@ -1,225 +1,225 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "dufilelight.h"
 #include "radialMap/radialMap.h"
 
 // QtGui
 #include <QMouseEvent>
 #include <QPixmap>
 // QtWidgets
 #include <QInputDialog>
 #include <QMenu>
 
 #include <KI18n/KLocalizedString>
 
 #define SCHEME_POPUP_ID    6730
 
 DUFilelight::DUFilelight(DiskUsage *usage)
-        : RadialMap::Widget(usage), diskUsage(usage), currentDir(0), refreshNeeded(true)
+        : RadialMap::Widget(usage), diskUsage(usage), currentDir(nullptr), refreshNeeded(true)
 {
 //     setFocusPolicy(Qt::StrongFocus);
 
     connect(diskUsage, &DiskUsage::enteringDirectory, this, &DUFilelight::slotDirChanged);
     connect(diskUsage, &DiskUsage::clearing, this, &DUFilelight::clear);
     connect(diskUsage, &DiskUsage::changed, this, &DUFilelight::slotChanged);
     connect(diskUsage, &DiskUsage::deleted, this, &DUFilelight::slotChanged);
     connect(diskUsage, &DiskUsage::changeFinished, this, &DUFilelight::slotRefresh);
     connect(diskUsage, &DiskUsage::deleteFinished, this, &DUFilelight::slotRefresh);
     connect(diskUsage, &DiskUsage::currentChanged, this, &DUFilelight::slotAboutToShow);
 }
 
 void DUFilelight::slotDirChanged(Directory *dir)
 {
     if (diskUsage->currentWidget() != this)
         return;
 
     if (currentDir != dir) {
         currentDir = dir;
 
         invalidate(false);
         create(dir);
         refreshNeeded = false;
     }
 }
 
 void DUFilelight::clear()
 {
     invalidate(false);
-    currentDir = 0;
+    currentDir = nullptr;
 }
 
 File * DUFilelight::getCurrentFile()
 {
     const RadialMap::Segment * focus = focusSegment();
 
     if (!focus || focus->isFake() || focus->file() == currentDir)
-        return 0;
+        return nullptr;
 
     return (File *)focus->file();
 }
 
 void DUFilelight::mousePressEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::RightButton) {
-        File * file = 0;
+        File * file = nullptr;
 
         const RadialMap::Segment * focus = focusSegment();
 
         if (focus && !focus->isFake() && focus->file() != currentDir)
             file = (File *)focus->file();
 
         QMenu filelightPopup;
         filelightPopup.addAction(i18n("Zoom In"),  this, SLOT(zoomIn()), Qt::Key_Plus);
         filelightPopup.addAction(i18n("Zoom Out"), this, SLOT(zoomOut()), Qt::Key_Minus);
 
         QMenu schemePopup;
         schemePopup.addAction(i18n("Rainbow"),       this, SLOT(schemeRainbow()));
         schemePopup.addAction(i18n("High Contrast"), this, SLOT(schemeHighContrast()));
         schemePopup.addAction(i18n("KDE"),           this, SLOT(schemeKDE()));
 
         filelightPopup.addMenu(&schemePopup);
         schemePopup.setTitle(i18n("Scheme"));
 
         filelightPopup.addAction(i18n("Increase contrast"), this, SLOT(increaseContrast()));
         filelightPopup.addAction(i18n("Decrease contrast"), this, SLOT(decreaseContrast()));
 
         QAction * act = filelightPopup.addAction(i18n("Use anti-aliasing"), this, SLOT(changeAntiAlias()));
         act->setCheckable(true);
         act->setChecked(Filelight::Config::antiAliasFactor > 1);
 
         act = filelightPopup.addAction(i18n("Show small files"), this, SLOT(showSmallFiles()));
         act->setCheckable(true);
         act->setChecked(Filelight::Config::showSmallFiles);
 
         act = filelightPopup.addAction(i18n("Vary label font sizes"), this, SLOT(varyLabelFontSizes()));
         act->setCheckable(true);
         act->setChecked(Filelight::Config::varyLabelFontSizes);
 
         filelightPopup.addAction(i18n("Minimum font size"), this, SLOT(minFontSize()));
 
         diskUsage->rightClickMenu(event->globalPos(), file, &filelightPopup, i18n("Filelight"));
         return;
     } else if (event->button() == Qt::LeftButton) {
         const RadialMap::Segment * focus = focusSegment();
 
         if (focus && !focus->isFake() && focus->file() == currentDir) {
             diskUsage->dirUp();
             return;
         } else if (focus && !focus->isFake() && focus->file()->isDir()) {
             diskUsage->changeDirectory((Directory *)focus->file());
             return;
         }
     }
 
     RadialMap::Widget::mousePressEvent(event);
 }
 
 void DUFilelight::setScheme(Filelight::MapScheme scheme)
 {
     Filelight::Config::scheme = scheme;
     Filelight::Config::write();
     slotRefresh();
 }
 
 void DUFilelight::increaseContrast()
 {
     if ((Filelight::Config::contrast += 10) > 100)
         Filelight::Config::contrast = 100;
 
     Filelight::Config::write();
     slotRefresh();
 }
 
 void DUFilelight::decreaseContrast()
 {
     if ((Filelight::Config::contrast -= 10) > 100)
         Filelight::Config::contrast = 0;
 
     Filelight::Config::write();
     slotRefresh();
 }
 
 void DUFilelight::changeAntiAlias()
 {
     Filelight::Config::antiAliasFactor = 1 + (Filelight::Config::antiAliasFactor == 1);
     Filelight::Config::write();
     slotRefresh();
 }
 
 void DUFilelight::showSmallFiles()
 {
     Filelight::Config::showSmallFiles = !Filelight::Config::showSmallFiles;
     Filelight::Config::write();
     slotRefresh();
 }
 
 void DUFilelight::varyLabelFontSizes()
 {
     Filelight::Config::varyLabelFontSizes = !Filelight::Config::varyLabelFontSizes;
     Filelight::Config::write();
     slotRefresh();
 }
 
 void DUFilelight::minFontSize()
 {
     bool ok = false;
 
     int result = QInputDialog::getInt(this, i18n("Krusader::Filelight"), i18n("Minimum font size"),
                                       (int)Filelight::Config::minFontPitch, 1, 100, 1, &ok);
 
     if (ok) {
         Filelight::Config::minFontPitch = (uint)result;
 
         Filelight::Config::write();
         slotRefresh();
     }
 }
 
 void DUFilelight::slotAboutToShow(int ndx)
 {
     QWidget *widget = diskUsage->widget(ndx);
     if (widget == this && (diskUsage->getCurrentDir() != currentDir || refreshNeeded)) {
         refreshNeeded = false;
-        if ((currentDir = diskUsage->getCurrentDir()) != 0) {
+        if ((currentDir = diskUsage->getCurrentDir()) != nullptr) {
             invalidate(false);
             create(currentDir);
         }
     }
 }
 
 void DUFilelight::slotRefresh()
 {
     if (diskUsage->currentWidget() != this)
         return;
 
     refreshNeeded = false;
     if (currentDir && currentDir == diskUsage->getCurrentDir()) {
         invalidate(false);
         create(currentDir);
     }
 }
 
 void DUFilelight::slotChanged(File *)
 {
     if (!refreshNeeded)
         refreshNeeded = true;
 }
 
diff --git a/krusader/DiskUsage/dufilelight.h b/krusader/DiskUsage/dufilelight.h
index c3cb7068..bc5eef0c 100644
--- a/krusader/DiskUsage/dufilelight.h
+++ b/krusader/DiskUsage/dufilelight.h
@@ -1,79 +1,79 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DUFILELIGHT_H
 #define DUFILELIGHT_H
 
 // QtGui
 #include <QMouseEvent>
 
 #include "diskusage.h"
 #include "radialMap/widget.h"
 #include "filelightParts/Config.h"
 
 class DUFilelight : public RadialMap::Widget
 {
     Q_OBJECT
 
 public:
     explicit DUFilelight(DiskUsage *usage);
 
     File * getCurrentFile();
 
 public slots:
     void slotDirChanged(Directory *);
     void clear();
     void slotChanged(File *);
     void slotRefresh();
 
 protected slots:
     void slotAboutToShow(int);
 
     void schemeRainbow()        {
         setScheme(Filelight::Rainbow);
     }
     void schemeHighContrast()   {
         setScheme(Filelight::HighContrast);
     }
     void schemeKDE()            {
         setScheme(Filelight::KDE);
     }
 
     void increaseContrast();
     void decreaseContrast();
     void changeAntiAlias();
     void showSmallFiles();
     void varyLabelFontSizes();
     void minFontSize();
 
 protected:
-    virtual void mousePressEvent(QMouseEvent*) Q_DECL_OVERRIDE;
+    void mousePressEvent(QMouseEvent*) Q_DECL_OVERRIDE;
 
     void setScheme(Filelight::MapScheme);
 
     DiskUsage *diskUsage;
     Directory *currentDir;
 
 private:
     bool refreshNeeded;
 };
 
 #endif /* __DU_FILELIGHT_H__ */
 
diff --git a/krusader/DiskUsage/dulines.cpp b/krusader/DiskUsage/dulines.cpp
index 62e80978..b40b2f70 100644
--- a/krusader/DiskUsage/dulines.cpp
+++ b/krusader/DiskUsage/dulines.cpp
@@ -1,534 +1,534 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "dulines.h"
 
 #include "../icon.h"
 #include "../krglobal.h"
 #include "../FileSystem/krpermhandler.h"
 
 // QtCore
 #include <QTimer>
 // QtGui
 #include <QMouseEvent>
 #include <QPixmap>
 #include <QKeyEvent>
 #include <QPen>
 #include <QPainter>
 #include <QFontMetrics>
 // QtWidgets
 #include <QToolTip>
 #include <QApplication>
 #include <QHeaderView>
 #include <QItemDelegate>
 #include <QMenu>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 
 class DULinesItemDelegate : public QItemDelegate
 {
 public:
 
-    explicit DULinesItemDelegate(QObject *parent = 0) : QItemDelegate(parent) {}
+    explicit DULinesItemDelegate(QObject *parent = nullptr) : QItemDelegate(parent) {}
 
-    virtual void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const Q_DECL_OVERRIDE {
+    void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const Q_DECL_OVERRIDE {
         QItemDelegate::paint(painter, option, index);
 
         QVariant value = index.data(Qt::UserRole);
         if (value.isValid()) {
             QString text = value.toString();
 
             value = index.data(Qt::DisplayRole);
             QString display;
             if (value.isValid())
                 display = value.toString();
 
             QSize iconSize;
             value = index.data(Qt::DecorationRole);
             if (value.isValid())
                 iconSize = qvariant_cast<QIcon>(value).actualSize(option.decorationSize);
 
             painter->save();
             painter->setClipRect(option.rect);
 
             QPalette::ColorGroup cg = option.state & QStyle::State_Enabled
                                       ? QPalette::Normal : QPalette::Disabled;
             if (cg == QPalette::Normal && !(option.state & QStyle::State_Active))
                 cg = QPalette::Inactive;
             if (option.state & QStyle::State_Selected) {
                 painter->setPen(option.palette.color(cg, QPalette::HighlightedText));
             } else {
                 painter->setPen(option.palette.color(cg, QPalette::Text));
             }
 
             QFont fnt = option.font;
             fnt.setItalic(true);
             painter->setFont(fnt);
 
             QFontMetrics fm(fnt);
             QString renderedText = text;
 
             int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin);
             int pos = 3 * textMargin + option.fontMetrics.width(display) + iconSize.width();
 
             bool truncd = false;
 
             QRect rct = option.rect;
             if (rct.width() > pos) {
                 rct.setX(rct.x() + pos);
 
                 if (fm.width(renderedText) > rct.width()) {
                     truncd = true;
 
                     int points = fm.width("...");
 
                     while (!renderedText.isEmpty() && (fm.width(renderedText) + points > rct.width()))
                         renderedText.truncate(renderedText.length() - 1);
 
                     renderedText += "...";
                 }
 
                 painter->drawText(rct, Qt::AlignLeft, renderedText);
             } else
                 truncd = true;
 
             if (truncd)
                 ((QAbstractItemModel *)index.model())->setData(index, QVariant(display + "  " + text), Qt::ToolTipRole);
             else
                 ((QAbstractItemModel *)index.model())->setData(index, QVariant(), Qt::ToolTipRole);
 
             painter->restore();
         }
     }
 };
 
 class DULinesItem : public QTreeWidgetItem
 {
 public:
-    DULinesItem(DiskUsage *diskUsageIn, File *fileItem, QTreeWidget * parent, QString label1,
-                QString label2, QString label3) : QTreeWidgetItem(parent),
+    DULinesItem(DiskUsage *diskUsageIn, File *fileItem, QTreeWidget * parent, const QString& label1,
+                const QString& label2, const QString& label3) : QTreeWidgetItem(parent),
             diskUsage(diskUsageIn), file(fileItem) {
         setText(0, label1);
         setText(1, label2);
         setText(2, label3);
 
         setTextAlignment(1, Qt::AlignRight);
     }
     DULinesItem(DiskUsage *diskUsageIn, File *fileItem, QTreeWidget * parent, QTreeWidgetItem * after,
-                QString label1, QString label2, QString label3) : QTreeWidgetItem(parent, after),
+                const QString& label1, const QString& label2, const QString& label3) : QTreeWidgetItem(parent, after),
             diskUsage(diskUsageIn), file(fileItem) {
         setText(0, label1);
         setText(1, label2);
         setText(2, label3);
 
         setTextAlignment(1, Qt::AlignRight);
     }
 
-    virtual bool operator<(const QTreeWidgetItem &other) const Q_DECL_OVERRIDE {
+    bool operator<(const QTreeWidgetItem &other) const Q_DECL_OVERRIDE {
         int column = treeWidget() ? treeWidget()->sortColumn() : 0;
 
         if (text(0) == "..")
             return true;
 
-        const DULinesItem *compWith = dynamic_cast< const DULinesItem * >(&other);
-        if (compWith == 0)
+        const auto *compWith = dynamic_cast< const DULinesItem * >(&other);
+        if (compWith == nullptr)
             return false;
 
         switch (column) {
         case 0:
         case 1:
             return file->size() > compWith->file->size();
         default:
             return text(column) < other.text(column);
         }
     }
 
     inline File * getFile() {
         return file;
     }
 
 private:
     DiskUsage *diskUsage;
     File *file;
 };
 
 DULines::DULines(DiskUsage *usage)
         : KrTreeWidget(usage), diskUsage(usage), refreshNeeded(false), started(false)
 {
     setItemDelegate(itemDelegate = new DULinesItemDelegate());
 
     setAllColumnsShowFocus(true);
     setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setIndentation(10);
 
     int defaultSize = QFontMetrics(font()).width("W");
 
     QStringList labels;
     labels << i18n("Line View");
     labels << i18n("Percent");
     labels << i18n("Name");
     setHeaderLabels(labels);
 
     header()->setSectionResizeMode(QHeaderView::Interactive);
 
     KConfigGroup group(krConfig, diskUsage->getConfigGroup());
 
     showFileSize = group.readEntry("L Show File Size", true);
 
     if (group.hasKey("L State"))
         header()->restoreState(group.readEntry("L State", QByteArray()));
     else {
         setColumnWidth(0, defaultSize * 20);
         setColumnWidth(1, defaultSize * 6);
         setColumnWidth(2, defaultSize * 20);
     }
 
     setStretchingColumn(0);
 
     header()->setSortIndicatorShown(true);
     sortItems(1, Qt::AscendingOrder);
 
 //  toolTip = new DULinesToolTip( diskUsage, viewport(), this );
 
     connect(diskUsage, &DiskUsage::enteringDirectory, this, &DULines::slotDirChanged);
     connect(diskUsage, &DiskUsage::clearing, this, &DULines::clear);
 
     connect(header(), &QHeaderView::sectionResized, this, &DULines::sectionResized);
 
     connect(this, &DULines::itemRightClicked, this, &DULines::slotRightClicked);
     connect(diskUsage, &DiskUsage::changed, this, &DULines::slotChanged);
     connect(diskUsage, &DiskUsage::deleted, this, &DULines::slotDeleted);
 
     started = true;
 }
 
 DULines::~DULines()
 {
     KConfigGroup group(krConfig, diskUsage->getConfigGroup());
     group.writeEntry("L State", header()->saveState());
 
     delete itemDelegate;
 }
 
 bool DULines::event(QEvent * event)
 {
     switch (event->type()) {
     case QEvent::ToolTip: {
-        QHelpEvent *he = static_cast<QHelpEvent*>(event);
+        auto *he = dynamic_cast<QHelpEvent*>(event);
 
         if (viewport()) {
             QPoint pos = viewport()->mapFromGlobal(he->globalPos());
 
             QTreeWidgetItem * item = itemAt(pos);
 
             int column = columnAt(pos.x());
 
             if (item && column == 1) {
                 File *fileItem = ((DULinesItem *)item)->getFile();
                 QToolTip::showText(he->globalPos(), diskUsage->getToolTip(fileItem), this);
                 return true;
             }
         }
     }
     break;
     default:
         break;
     }
     return KrTreeWidget::event(event);
 }
 
 void DULines::slotDirChanged(Directory *dirEntry)
 {
     clear();
 
-    QTreeWidgetItem * lastItem = 0;
+    QTreeWidgetItem * lastItem = nullptr;
 
-    if (!(dirEntry->parent() == 0)) {
+    if (!(dirEntry->parent() == nullptr)) {
         lastItem = new QTreeWidgetItem(this);
         lastItem->setText(0, "..");
         lastItem->setIcon(0, Icon("go-up"));
         lastItem->setFlags(lastItem->flags() & (~Qt::ItemIsSelectable));
     }
 
     int maxPercent = -1;
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it) {
         File *item = *it;
         if (!item->isExcluded() && item->intPercent() > maxPercent)
             maxPercent = item->intPercent();
     }
 
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it) {
         File *item = *it;
 
         QString fileName = item->name();
 
-        if (lastItem == 0)
+        if (lastItem == nullptr)
             lastItem = new DULinesItem(diskUsage, item, this, "", item->percent() + "  ", fileName);
         else
             lastItem = new DULinesItem(diskUsage, item, this, lastItem, "", item->percent() + "  ", fileName);
 
         if (item->isExcluded())
             lastItem->setHidden(true);
 
         int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
 
         lastItem->setIcon(2, diskUsage->getIcon(item->mime()));
         lastItem->setData(0, Qt::DecorationRole, createPixmap(item->intPercent(), maxPercent, header()->sectionSize(0) - 2 * textMargin));
 
         if (showFileSize)
             lastItem->setData(2, Qt::UserRole, "  [" + KIO::convertSize(item->size()) + ']');
 
         QSize size = lastItem->sizeHint(0);
         size.setWidth(16);
         lastItem->setSizeHint(0, size);
     }
 
     if (topLevelItemCount() > 0) {
         setCurrentItem(topLevelItem(0));
     }
 }
 
 QPixmap DULines::createPixmap(int percent, int maxPercent, int maxWidth)
 {
     if (percent < 0 || percent > maxPercent || maxWidth < 2 || maxPercent == 0)
         return QPixmap();
     maxWidth -= 2;
 
     int actualWidth = maxWidth * percent / maxPercent;
     if (actualWidth == 0)
         return QPixmap();
 
     QPen pen;
     pen.setColor(Qt::black);
     QPainter painter;
 
     int size = QFontMetrics(font()).height() - 2;
     QRect rect(0, 0, actualWidth, size);
     QRect frameRect(0, 0, actualWidth - 1, size - 1);
     QPixmap pixmap(rect.width(), rect.height());
 
     painter.begin(&pixmap);
     painter.setPen(pen);
 
     for (int i = 1; i < actualWidth - 1; i++) {
         int color = (511 * i / (maxWidth - 1));
         if (color < 256)
             pen.setColor(QColor(255 - color, 255, 0));
         else
             pen.setColor(QColor(color - 256, 511 - color, 0));
 
         painter.setPen(pen);
         painter.drawLine(i, 1, i, size - 1);
     }
 
     pen.setColor(Qt::black);
     painter.setPen(pen);
 
     if (actualWidth != 1)
         painter.drawRect(frameRect);
     else
         painter.drawLine(0, 0, 0, size);
 
     painter.end();
     pixmap.detach();
     return pixmap;
 }
 
 void DULines::resizeEvent(QResizeEvent * re)
 {
     KrTreeWidget::resizeEvent(re);
 
     if (started && (re->oldSize() != re->size()))
         sectionResized(0);
 }
 
 void DULines::sectionResized(int column)
 {
     if (topLevelItemCount() == 0 || column != 0)
         return;
 
     Directory * currentDir = diskUsage->getCurrentDir();
-    if (currentDir == 0)
+    if (currentDir == nullptr)
         return;
 
     int maxPercent = -1;
     for (Iterator<File> it = currentDir->iterator(); it != currentDir->end(); ++it) {
         File *item = *it;
 
         if (!item->isExcluded() && item->intPercent() > maxPercent)
             maxPercent = item->intPercent();
     }
 
     QTreeWidgetItemIterator it2(this);
     while (*it2) {
         QTreeWidgetItem *lvitem = *it2;
         if (lvitem->text(0) != "..") {
-            DULinesItem *duItem = dynamic_cast< DULinesItem *>(lvitem);
+            auto *duItem = dynamic_cast< DULinesItem *>(lvitem);
             if (duItem) {
                 int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
                 duItem->setData(0, Qt::DecorationRole, createPixmap(duItem->getFile()->intPercent(), maxPercent, header()->sectionSize(0) - 2 * textMargin));
                 QSize size = duItem->sizeHint(0);
                 size.setWidth(16);
                 duItem->setSizeHint(0, size);
             }
         }
         it2++;
     }
 }
 
 bool DULines::doubleClicked(QTreeWidgetItem * item)
 {
     if (item) {
         if (item->text(0) != "..") {
             File *fileItem = ((DULinesItem *)item)->getFile();
             if (fileItem->isDir())
                 diskUsage->changeDirectory(dynamic_cast<Directory *>(fileItem));
             return true;
         } else {
-            Directory *upDir = (Directory *)diskUsage->getCurrentDir()->parent();
+            auto *upDir = (Directory *)diskUsage->getCurrentDir()->parent();
 
             if (upDir)
                 diskUsage->changeDirectory(upDir);
             return true;
         }
     }
     return false;
 }
 
 void DULines::mouseDoubleClickEvent(QMouseEvent * e)
 {
     if (e || e->button() == Qt::LeftButton) {
         QPoint vp = viewport()->mapFromGlobal(e->globalPos());
         QTreeWidgetItem * item = itemAt(vp);
 
         if (doubleClicked(item))
             return;
 
     }
     KrTreeWidget::mouseDoubleClickEvent(e);
 }
 
 
 void DULines::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Return :
     case Qt::Key_Enter :
         if (doubleClicked(currentItem()))
             return;
         break;
     case Qt::Key_Left :
     case Qt::Key_Right :
     case Qt::Key_Up :
     case Qt::Key_Down :
         if (e->modifiers() == Qt::ShiftModifier) {
             e->ignore();
             return;
         }
         break;
     case Qt::Key_Delete :
         e->ignore();
         return;
     }
     KrTreeWidget::keyPressEvent(e);
 }
 
 void DULines::slotRightClicked(QTreeWidgetItem *item, const QPoint &pos)
 {
-    File * file = 0;
+    File * file = nullptr;
 
     if (item && item->text(0) != "..")
         file = ((DULinesItem *)item)->getFile();
 
     QMenu linesPopup;
     QAction *act = linesPopup.addAction(i18n("Show file sizes"), this, SLOT(slotShowFileSizes()));
     act->setChecked(showFileSize);
 
     diskUsage->rightClickMenu(pos, file, &linesPopup, i18n("Lines"));
 }
 
 void DULines::slotShowFileSizes()
 {
     showFileSize = !showFileSize;
     slotDirChanged(diskUsage->getCurrentDir());
 }
 
 File * DULines::getCurrentFile()
 {
     QTreeWidgetItem *item = currentItem();
 
-    if (item == 0 || item->text(0) == "..")
-        return 0;
+    if (item == nullptr || item->text(0) == "..")
+        return nullptr;
 
     return ((DULinesItem *)item)->getFile();
 }
 
 void DULines::slotChanged(File * item)
 {
     QTreeWidgetItemIterator it(this);
     while (*it) {
         QTreeWidgetItem *lvitem = *it;
         it++;
 
         if (lvitem->text(0) != "..") {
-            DULinesItem *duItem = (DULinesItem *)(lvitem);
+            auto *duItem = (DULinesItem *)(lvitem);
             if (duItem->getFile() == item) {
                 setSortingEnabled(false);
                 duItem->setHidden(item->isExcluded());
                 duItem->setText(1, item->percent());
                 if (!refreshNeeded) {
                     refreshNeeded = true;
                     QTimer::singleShot(0, this, &DULines::slotRefresh);
                 }
                 break;
             }
         }
     }
 }
 
 void DULines::slotDeleted(File * item)
 {
     QTreeWidgetItemIterator it(this);
     while (*it) {
         QTreeWidgetItem *lvitem = *it;
         it++;
 
         if (lvitem->text(0) != "..") {
-            DULinesItem *duItem = (DULinesItem *)(lvitem);
+            auto *duItem = (DULinesItem *)(lvitem);
             if (duItem->getFile() == item) {
                 delete duItem;
                 break;
             }
         }
     }
 }
 
 void DULines::slotRefresh()
 {
     if (refreshNeeded) {
         refreshNeeded = false;
         setSortingEnabled(true);
         sortItems(1, Qt::AscendingOrder);
     }
 }
 
diff --git a/krusader/DiskUsage/dulines.h b/krusader/DiskUsage/dulines.h
index f5df71e8..73440996 100644
--- a/krusader/DiskUsage/dulines.h
+++ b/krusader/DiskUsage/dulines.h
@@ -1,78 +1,78 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DULINES_H
 #define DULINES_H
 
 // QtGui
 #include <QMouseEvent>
 #include <QPixmap>
 #include <QKeyEvent>
 #include <QResizeEvent>
 
 #include "diskusage.h"
 #include "../GUI/krtreewidget.h"
 
 class DULinesToolTip;
 class DULinesItemDelegate;
 
 class DULines : public KrTreeWidget
 {
     Q_OBJECT
 
 public:
     explicit DULines(DiskUsage *usage);
-    ~DULines();
+    ~DULines() override;
 
     File * getCurrentFile();
 
 public slots:
     void slotDirChanged(Directory *dirEntry);
     void sectionResized(int);
     void slotRightClicked(QTreeWidgetItem *, const QPoint &);
     void slotChanged(File *);
     void slotDeleted(File *);
     void slotShowFileSizes();
     void slotRefresh();
 
 protected:
     DiskUsage *diskUsage;
 
-    virtual bool event(QEvent * event) Q_DECL_OVERRIDE;
-    virtual void mouseDoubleClickEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
-    virtual void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
-    virtual void resizeEvent(QResizeEvent *) Q_DECL_OVERRIDE;
+    bool event(QEvent * event) Q_DECL_OVERRIDE;
+    void mouseDoubleClickEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
+    void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
+    void resizeEvent(QResizeEvent *) Q_DECL_OVERRIDE;
 
 private:
     QPixmap createPixmap(int percent, int maxPercent, int maxWidth);
 
     bool doubleClicked(QTreeWidgetItem * item);
 
     bool refreshNeeded;
     bool started;
 
     bool showFileSize;
 
     DULinesToolTip *toolTip;
     DULinesItemDelegate *itemDelegate;
 };
 
 #endif /* __DU_LINES_H__ */
 
diff --git a/krusader/DiskUsage/dulistview.cpp b/krusader/DiskUsage/dulistview.cpp
index f1dd37a5..b779969f 100644
--- a/krusader/DiskUsage/dulistview.cpp
+++ b/krusader/DiskUsage/dulistview.cpp
@@ -1,271 +1,271 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "dulistview.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../FileSystem/krpermhandler.h"
 
 // QtCore
 #include <QMimeDatabase>
 #include <QMimeType>
 // QtGui
 #include <QMouseEvent>
 #include <QFontMetrics>
 #include <QKeyEvent>
 // QtWidgets
 #include <QHeaderView>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 DUListView::DUListView(DiskUsage *usage)
         : KrTreeWidget(usage), diskUsage(usage)
 {
     setAllColumnsShowFocus(true);
     setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setRootIsDecorated(true);
     setIndentation(10);
     setItemsExpandable(true);
 
     QStringList labels;
     labels << i18n("Name");
     labels << i18n("Percent");
     labels << i18n("Total size");
     labels << i18n("Own size");
     labels << i18n("Type");
     labels << i18n("Date");
     labels << i18n("Permissions");
     labels << i18n("Owner");
     labels << i18n("Group");
     setHeaderLabels(labels);
 
     header()->setSectionResizeMode(QHeaderView::Interactive);
 
     KConfigGroup group(krConfig, diskUsage->getConfigGroup());
 
     if (group.hasKey("D State"))
         header()->restoreState(group.readEntry("D State", QByteArray()));
     else {
         int defaultSize = QFontMetrics(font()).width("W");
 
         setColumnWidth(0, defaultSize * 20);
         setColumnWidth(1, defaultSize * 5);
         setColumnWidth(2, defaultSize * 10);
         setColumnWidth(3, defaultSize * 10);
         setColumnWidth(4, defaultSize * 10);
         setColumnWidth(5, defaultSize * 10);
         setColumnWidth(6, defaultSize * 6);
         setColumnWidth(7, defaultSize * 5);
         setColumnWidth(8, defaultSize * 5);
     }
 
     header()->setSortIndicatorShown(true);
     sortItems(2, Qt::AscendingOrder);
 
     connect(diskUsage, &DiskUsage::enteringDirectory, this, &DUListView::slotDirChanged);
     connect(diskUsage, &DiskUsage::clearing, this, &DUListView::clear);
     connect(diskUsage, &DiskUsage::changed, this, &DUListView::slotChanged);
     connect(diskUsage, &DiskUsage::deleted, this, &DUListView::slotDeleted);
 
     connect(this, &DUListView::itemRightClicked, this, &DUListView::slotRightClicked);
     connect(this, &DUListView::itemExpanded, this, &DUListView::slotExpanded);
 }
 
 DUListView::~ DUListView()
 {
     KConfigGroup group(krConfig, diskUsage->getConfigGroup());
     group.writeEntry("D State", header()->saveState());
 }
 
 void DUListView::addDirectory(Directory *dirEntry, QTreeWidgetItem *parent)
 {
-    QTreeWidgetItem * lastItem = 0;
+    QTreeWidgetItem * lastItem = nullptr;
 
-    if (parent == 0 && !(dirEntry->parent() == 0)) {
+    if (parent == nullptr && !(dirEntry->parent() == nullptr)) {
         lastItem = new QTreeWidgetItem(this);
         lastItem->setText(0, "..");
         lastItem->setIcon(0, Icon("go-up"));
         lastItem->setFlags(Qt::ItemIsEnabled);
     }
 
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it) {
         File *item = *it;
 
         QMimeDatabase db;
         QMimeType mt = db.mimeTypeForName(item->mime());
         QString mime;
         if (mt.isValid())
             mime = mt.comment();
 
         time_t tma = item->time();
         struct tm* t = localtime((time_t *) & tma);
         QDateTime tmp(QDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday), QTime(t->tm_hour, t->tm_min));
         QString date = QLocale().toString(tmp, QLocale::ShortFormat);
 
         QString totalSize = KRpermHandler::parseSize(item->size()) + ' ';
         QString ownSize = KRpermHandler::parseSize(item->ownSize()) + ' ';
         QString percent = item->percent();
 
-        if (lastItem == 0 && parent == 0)
+        if (lastItem == nullptr && parent == nullptr)
             lastItem = new DUListViewItem(diskUsage, item, this, item->name(), percent, totalSize, ownSize,
                                           mime, date, item->perm(), item->owner(), item->group());
-        else if (lastItem == 0)
+        else if (lastItem == nullptr)
             lastItem = new DUListViewItem(diskUsage, item, parent, item->name(), percent, totalSize, ownSize,
                                           mime, date, item->perm(), item->owner(), item->group());
-        else if (parent == 0)
+        else if (parent == nullptr)
             lastItem = new DUListViewItem(diskUsage, item, this, lastItem, item->name(), percent, totalSize,
                                           ownSize, mime, date, item->perm(), item->owner(), item->group());
         else
             lastItem = new DUListViewItem(diskUsage, item, parent, lastItem, item->name(), percent, totalSize,
                                           ownSize, mime, date, item->perm(), item->owner(), item->group());
 
         if (item->isExcluded())
             lastItem->setHidden(true);
 
         lastItem->setIcon(0, diskUsage->getIcon(item->mime()));
 
         if (item->isDir() && !item->isSymLink())
             lastItem->setChildIndicatorPolicy(QTreeWidgetItem::ShowIndicator);
     }
 
     if (topLevelItemCount() > 0) {
         setCurrentItem(topLevelItem(0));
     }
 }
 
 void DUListView::slotDirChanged(Directory *dirEntry)
 {
     clear();
-    addDirectory(dirEntry, 0);
+    addDirectory(dirEntry, nullptr);
 }
 
 File * DUListView::getCurrentFile()
 {
     QTreeWidgetItem *item = currentItem();
 
-    if (item == 0 || item->text(0) == "..")
-        return 0;
+    if (item == nullptr || item->text(0) == "..")
+        return nullptr;
 
     return ((DUListViewItem *)item)->getFile();
 }
 
 void DUListView::slotChanged(File * item)
 {
     void * itemPtr = diskUsage->getProperty(item, "ListView-Ref");
-    if (itemPtr == 0)
+    if (itemPtr == nullptr)
         return;
 
-    DUListViewItem *duItem = (DUListViewItem *)itemPtr;
+    auto *duItem = (DUListViewItem *)itemPtr;
     duItem->setHidden(item->isExcluded());
     duItem->setText(1, item->percent());
     duItem->setText(2, KRpermHandler::parseSize(item->size()) + ' ');
     duItem->setText(3, KRpermHandler::parseSize(item->ownSize()) + ' ');
 }
 
 void DUListView::slotDeleted(File * item)
 {
     void * itemPtr = diskUsage->getProperty(item, "ListView-Ref");
-    if (itemPtr == 0)
+    if (itemPtr == nullptr)
         return;
 
-    DUListViewItem *duItem = (DUListViewItem *)itemPtr;
+    auto *duItem = (DUListViewItem *)itemPtr;
     delete duItem;
 }
 
 void DUListView::slotRightClicked(QTreeWidgetItem *item, const QPoint & pos)
 {
-    File * file = 0;
+    File * file = nullptr;
 
     if (item && item->text(0) != "..")
         file = ((DUListViewItem *)item)->getFile();
 
     diskUsage->rightClickMenu(pos, file);
 }
 
 bool DUListView::doubleClicked(QTreeWidgetItem * item)
 {
     if (item) {
         if (item->text(0) != "..") {
             File *fileItem = ((DUListViewItem *)item)->getFile();
             if (fileItem->isDir())
                 diskUsage->changeDirectory(dynamic_cast<Directory *>(fileItem));
             return true;
         } else {
-            Directory *upDir = (Directory *)diskUsage->getCurrentDir()->parent();
+            auto *upDir = (Directory *)diskUsage->getCurrentDir()->parent();
 
             if (upDir)
                 diskUsage->changeDirectory(upDir);
             return true;
         }
     }
     return false;
 }
 
 void DUListView::mouseDoubleClickEvent(QMouseEvent * e)
 {
     if (e || e->button() == Qt::LeftButton) {
         QPoint vp = viewport()->mapFromGlobal(e->globalPos());
         QTreeWidgetItem * item = itemAt(vp);
 
         if (doubleClicked(item))
             return;
 
     }
     KrTreeWidget::mouseDoubleClickEvent(e);
 }
 
 void DUListView::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Return :
     case Qt::Key_Enter :
         if (doubleClicked(currentItem()))
             return;
         break;
     case Qt::Key_Left :
     case Qt::Key_Right :
     case Qt::Key_Up :
     case Qt::Key_Down :
         if (e->modifiers() == Qt::ShiftModifier) {
             e->ignore();
             return;
         }
         break;
     case Qt::Key_Delete :
         e->ignore();
         return;
     }
     KrTreeWidget::keyPressEvent(e);
 }
 
 void DUListView::slotExpanded(QTreeWidgetItem * item)
 {
-    if (item == 0 || item->text(0) == "..")
+    if (item == nullptr || item->text(0) == "..")
         return;
 
     if (item->childCount() == 0) {
         File *fileItem = ((DUListViewItem *)item)->getFile();
         if (fileItem->isDir())
             addDirectory(dynamic_cast<Directory *>(fileItem), item);
     }
 }
 
diff --git a/krusader/DiskUsage/dulistview.h b/krusader/DiskUsage/dulistview.h
index 16691a6e..60c6cd2f 100644
--- a/krusader/DiskUsage/dulistview.h
+++ b/krusader/DiskUsage/dulistview.h
@@ -1,184 +1,184 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DULISTVIEW_H
 #define DULISTVIEW_H
 
 // QtGui
 #include <QMouseEvent>
 #include <QKeyEvent>
 
 #include "../GUI/krtreewidget.h"
 #include "diskusage.h"
 
 class DUListViewItem : public QTreeWidgetItem
 {
 public:
-    DUListViewItem(DiskUsage *diskUsageIn, File *fileIn, QTreeWidget * parent, QString label1,
-                   QString label2, QString label3, QString label4, QString label5, QString label6,
-                   QString label7, QString label8, QString label9)
+    DUListViewItem(DiskUsage *diskUsageIn, File *fileIn, QTreeWidget * parent, const QString& label1,
+                   const QString& label2, const QString& label3, const QString& label4, const QString& label5, const QString& label6,
+                   const QString& label7, const QString& label8, const QString& label9)
             : QTreeWidgetItem(parent), diskUsage(diskUsageIn), file(fileIn) {
         setText(0, label1);
         setText(1, label2);
         setText(2, label3);
         setText(3, label4);
         setText(4, label5);
         setText(5, label6);
         setText(6, label7);
         setText(7, label8);
         setText(8, label9);
 
         setTextAlignment(1, Qt::AlignRight);
         setTextAlignment(2, Qt::AlignRight);
         setTextAlignment(3, Qt::AlignRight);
 
         setChildIndicatorPolicy(QTreeWidgetItem::DontShowIndicatorWhenChildless);
         diskUsage->addProperty(file, "ListView-Ref", this);
     }
-    DUListViewItem(DiskUsage *diskUsageIn, File *fileIn, QTreeWidgetItem * parent, QString label1,
-                   QString label2, QString label3, QString label4, QString label5, QString label6,
-                   QString label7, QString label8, QString label9)
+    DUListViewItem(DiskUsage *diskUsageIn, File *fileIn, QTreeWidgetItem * parent, const QString& label1,
+                   const QString& label2, const QString& label3, const QString& label4, const QString& label5, const QString& label6,
+                   const QString& label7, const QString& label8, const QString& label9)
             : QTreeWidgetItem(parent), diskUsage(diskUsageIn), file(fileIn) {
         setText(0, label1);
         setText(1, label2);
         setText(2, label3);
         setText(3, label4);
         setText(4, label5);
         setText(5, label6);
         setText(6, label7);
         setText(7, label8);
         setText(8, label9);
 
         setTextAlignment(1, Qt::AlignRight);
         setTextAlignment(2, Qt::AlignRight);
         setTextAlignment(3, Qt::AlignRight);
 
         setChildIndicatorPolicy(QTreeWidgetItem::DontShowIndicatorWhenChildless);
         diskUsage->addProperty(file, "ListView-Ref", this);
     }
     DUListViewItem(DiskUsage *diskUsageIn, File *fileIn, QTreeWidget * parent, QTreeWidgetItem * after,
-                   QString label1, QString label2, QString label3, QString label4, QString label5,
-                   QString label6, QString label7, QString label8, QString label9)
+                   const QString& label1, const QString& label2, const QString& label3, const QString& label4, const QString& label5,
+                   const QString& label6, const QString& label7, const QString& label8, const QString& label9)
             : QTreeWidgetItem(parent, after), diskUsage(diskUsageIn), file(fileIn) {
         setText(0, label1);
         setText(1, label2);
         setText(2, label3);
         setText(3, label4);
         setText(4, label5);
         setText(5, label6);
         setText(6, label7);
         setText(7, label8);
         setText(8, label9);
 
         setTextAlignment(1, Qt::AlignRight);
         setTextAlignment(2, Qt::AlignRight);
         setTextAlignment(3, Qt::AlignRight);
 
         setChildIndicatorPolicy(QTreeWidgetItem::DontShowIndicatorWhenChildless);
         diskUsage->addProperty(file, "ListView-Ref", this);
     }
     DUListViewItem(DiskUsage *diskUsageIn, File *fileIn, QTreeWidgetItem * parent, QTreeWidgetItem * after,
-                   QString label1, QString label2, QString label3, QString label4, QString label5,
-                   QString label6, QString label7, QString label8, QString label9)
+                   const QString& label1, const QString& label2, const QString& label3, const QString& label4, const QString& label5,
+                   const QString& label6, const QString& label7, const QString& label8, const QString& label9)
             : QTreeWidgetItem(parent, after),
             diskUsage(diskUsageIn), file(fileIn) {
         setText(0, label1);
         setText(1, label2);
         setText(2, label3);
         setText(3, label4);
         setText(4, label5);
         setText(5, label6);
         setText(6, label7);
         setText(7, label8);
         setText(8, label9);
 
         setTextAlignment(1, Qt::AlignRight);
         setTextAlignment(2, Qt::AlignRight);
         setTextAlignment(3, Qt::AlignRight);
 
         setChildIndicatorPolicy(QTreeWidgetItem::DontShowIndicatorWhenChildless);
         diskUsage->addProperty(file, "ListView-Ref", this);
     }
-    ~DUListViewItem() {
+    ~DUListViewItem() override {
         diskUsage->removeProperty(file, "ListView-Ref");
     }
 
-    virtual bool operator<(const QTreeWidgetItem &other) const Q_DECL_OVERRIDE {
+    bool operator<(const QTreeWidgetItem &other) const Q_DECL_OVERRIDE {
         int column = treeWidget() ? treeWidget()->sortColumn() : 0;
 
         if (text(0) == "..")
             return true;
 
-        const DUListViewItem *compWith = dynamic_cast< const DUListViewItem * >(&other);
-        if (compWith == 0)
+        const auto *compWith = dynamic_cast< const DUListViewItem * >(&other);
+        if (compWith == nullptr)
             return false;
 
         switch (column) {
         case 1:
         case 2:
             return file->size() > compWith->file->size();
         case 3:
             return file->ownSize() > compWith->file->ownSize();
         case 5:
             return file->time() < compWith->file->time();
         default:
             return text(column) < other.text(column);
         }
     }
 
     inline File * getFile() {
         return file;
     }
 
 private:
     DiskUsage *diskUsage;
     File *file;
 };
 
 class DUListView : public KrTreeWidget
 {
     Q_OBJECT
 
 public:
     explicit DUListView(DiskUsage *usage);
-    ~DUListView();
+    ~DUListView() override;
 
     File * getCurrentFile();
 
 public slots:
     void slotDirChanged(Directory *);
     void slotChanged(File *);
     void slotDeleted(File *);
     void slotRightClicked(QTreeWidgetItem *, const QPoint &);
     void slotExpanded(QTreeWidgetItem *);
 
 protected:
     DiskUsage *diskUsage;
 
-    virtual void mouseDoubleClickEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
-    virtual void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
+    void mouseDoubleClickEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
+    void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
 
 private:
     void addDirectory(Directory *dirEntry, QTreeWidgetItem *parent);
     bool doubleClicked(QTreeWidgetItem * item);
 };
 
 #endif /* __DU_LISTVIEW_H__ */
 
diff --git a/krusader/DiskUsage/filelightParts/fileTree.cpp b/krusader/DiskUsage/filelightParts/fileTree.cpp
index 0cc03e52..36934814 100644
--- a/krusader/DiskUsage/filelightParts/fileTree.cpp
+++ b/krusader/DiskUsage/filelightParts/fileTree.cpp
@@ -1,91 +1,91 @@
 /*****************************************************************************
  * Copyright (C) 2004 Max Howell <max.howell@methylblue.com>                 *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "fileTree.h"
 
 // QtCore
 #include <QLocale>
 #include <QString>
 
 //static definitions
 const FileSize File::DENOMINATOR[4] = { 1ull, 1ull << 10, 1ull << 20, 1ull << 30 };
 const char File::PREFIX[5][2]   = { "", "K", "M", "G", "T" };
 
 QString
 File::fullPath(const Directory *root /*= 0*/) const
 {
     QString path;
 
-    if (root == this) root = 0;  //prevent returning empty string when there is something we could return
+    if (root == this) root = nullptr;  //prevent returning empty string when there is something we could return
 
     const File *d;
 
-    for (d = this; d != root && d && d->parent() != 0; d = d->parent()) {
+    for (d = this; d != root && d && d->parent() != nullptr; d = d->parent()) {
         if (!path.isEmpty())
             path = '/' + path;
 
         path = d->name() + path;
     }
 
     if (d) {
         while (d->parent())
             d = d->parent();
 
         if (d->directory().endsWith('/'))
             return d->directory() + path;
         else
             return d->directory() + '/' + path;
     } else
         return path;
 }
 
 QString
 File::humanReadableSize(UnitPrefix key /*= mega*/) const   //FIXME inline
 {
     return humanReadableSize(m_size, key);
 }
 
 QString
 File::humanReadableSize(FileSize size, UnitPrefix key /*= mega*/)   //static
 {
     QString s;
     double prettySize = (double)size / (double)DENOMINATOR[key];
     const QLocale locale;
 
     if (prettySize >= 0.01) {
         if (prettySize < 1)        s = locale.toString(prettySize, 'f', 2);
         else if (prettySize < 100) s = locale.toString(prettySize, 'f', 1);
         else                        s = locale.toString(prettySize, 'f', 0);
 
         s += ' ';
         s += PREFIX[key];
         s += 'B';
     }
 
     if (prettySize < 0.1) {
         s += " (";
         s += locale.toString(size / DENOMINATOR[ key ? key - 1 : 0 ]);
         s += ' ';
         s += PREFIX[key];
         s += "B)";
     }
 
     return s;
 }
diff --git a/krusader/DiskUsage/radialMap/builder.cpp b/krusader/DiskUsage/radialMap/builder.cpp
index 983a73ef..a12ba42d 100644
--- a/krusader/DiskUsage/radialMap/builder.cpp
+++ b/krusader/DiskUsage/radialMap/builder.cpp
@@ -1,149 +1,149 @@
 /*****************************************************************************
  * Copyright (C) 2003-2004 Max Howell <max.howell@methylblue.com>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "builder.h"
 #include "Config.h"
 #include "widget.h"
 
 // QtCore
 #include <QLocale>
 
 #include <KI18n/KLocalizedString>
 
 //**** REMOVE NEED FOR the +1 with MAX_RING_DEPTH uses
 //**** add some angle bounds checking (possibly in Segment ctor? can I delete in a ctor?)
 //**** this class is a mess
 
 RadialMap::Builder::Builder(RadialMap::Map *m, const Directory* const d, bool fast)
         : m_map(m)
         , m_root(d)
         , m_minSize(static_cast<FileSize>((d->size() * 3) / (PI * m->height() - m->MAP_2MARGIN)))
         , m_depth(&m->m_visibleDepth)
 {
     m_signature = new Chain<Segment> [*m_depth + 1];
 
     if (!fast) { //|| *m_depth == 0 ) //depth 0 is special case usability-wise //**** WHY?!
         //determine depth rather than use old one
         findVisibleDepth(d);   //sets m_depth
     }
 
     m_map->setRingBreadth();
     setLimits(m_map->m_ringBreadth);
     build(d);
 
     m_map->m_signature = m_signature;
 
     delete []m_limits;
 }
 
 
 void
 RadialMap::Builder::findVisibleDepth(const Directory* const dir, const unsigned int depth)
 {
     //**** because I don't use the same minimumSize criteria as in the visual function
     //     this can lead to incorrect visual representation
     //**** BUT, you can't set those limits until you know m_depth!
 
     //**** also this function doesn't check to see if anything is actually visible
     //     it just assumes that when it reaches a new level everything in it is visible
     //     automatically. This isn't right especially as there might be no files in the
     //     dir provided to this function!
 
     static uint stopDepth = 0;
 
     if (dir == m_root) {
         stopDepth = *m_depth;
         *m_depth = 0;
     }
 
     if (*m_depth < depth) *m_depth = depth;
     if (*m_depth >= stopDepth) return;
 
     for (ConstIterator<File> it = dir->constIterator(); it != dir->end(); ++it)
         if ((*it)->isDir() && (*it)->size() > m_minSize)
             findVisibleDepth((Directory *)*it, depth + 1);   //if no files greater than min size the depth is still recorded
 }
 
 void
 RadialMap::Builder::setLimits(const uint &b)   //b = breadth?
 {
     double size3 = m_root->size() * 3;
     double pi2B   = PI * 2 * b;
 
     m_limits = new FileSize [*m_depth + 1]; //FIXME delete!
 
     for (unsigned int d = 0; d <= *m_depth; ++d)
         m_limits[d] = (FileSize)(size3 / (double)(pi2B * (d + 1))); //min is angle that gives 3px outer diameter for that depth
 }
 
 
 //**** segments currently overlap at edges (i.e. end of first is start of next)
 bool
 RadialMap::Builder::build(const Directory* const dir, const unsigned int depth, unsigned int a_start, const unsigned int a_end)
 {
     //first iteration: dir == m_root
 
     if (dir->fileCount() == 0)  //we do fileCount rather than size to avoid chance of divide by zero later
         return false;
 
     FileSize hiddenSize = 0;
     uint hiddenFileCount = 0;
 
     for (ConstIterator<File> it = dir->constIterator(); it != dir->end(); ++it) {
         if ((*it)->size() > m_limits[depth]) {
-            unsigned int a_len = (unsigned int)(5760 * ((double)(*it)->size() / (double)m_root->size()));
+            auto a_len = (unsigned int)(5760 * ((double)(*it)->size() / (double)m_root->size()));
 
-            Segment *s = new Segment(*it, a_start, a_len);
+            auto *s = new Segment(*it, a_start, a_len);
 
             (m_signature + depth)->append(s);
 
             if ((*it)->isDir()) {
                 if (depth != *m_depth) {
                     //recurse
                     s->m_hasHiddenChildren = build((Directory*) * it, depth + 1, a_start, a_start + a_len);
                 } else s->m_hasHiddenChildren = true;
             }
 
             a_start += a_len; //**** should we add 1?
 
         } else {
 
             hiddenSize += (*it)->size();
 
             if ((*it)->isDir())  //**** considered virtual, but dir wouldn't count itself!
-                hiddenFileCount += static_cast<const Directory*>(*it)->fileCount(); //need to add one to count the dir as well
+                hiddenFileCount += dynamic_cast<const Directory*>(*it)->fileCount(); //need to add one to count the dir as well
 
             ++hiddenFileCount;
         }
     }
 
     if (hiddenFileCount == dir->fileCount() && !Config::showSmallFiles)
 
         return true;
 
     else if ((Config::showSmallFiles && hiddenSize > m_limits[depth]) || (depth == 0 && (hiddenSize > dir->size() / 8)) /*|| > size() * 0.75*/) {
         //append a segment for unrepresented space - a "fake" segment
 
         const QString s = i18np("%1 file: ~ %2", "%1 files: ~ %2", QLocale().toString(hiddenFileCount), File::humanReadableSize(hiddenSize / hiddenFileCount));
         (m_signature + depth)->append(new Segment(new File(s, hiddenSize), a_start, a_end - a_start, true));
     }
 
     return false;
 }
diff --git a/krusader/DiskUsage/radialMap/labels.cpp b/krusader/DiskUsage/radialMap/labels.cpp
index 765e8a9e..fb1237bb 100644
--- a/krusader/DiskUsage/radialMap/labels.cpp
+++ b/krusader/DiskUsage/radialMap/labels.cpp
@@ -1,366 +1,366 @@
 /*****************************************************************************
  * Copyright (C) 2003-2004 Max Howell <max.howell@methylblue.com>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 // QtCore
 #include <QList>
 // QtGui
 #include <QFont>
 #include <QFontMetrics>
 #include <QPainter>
 
 #include <KCoreAddons/KStringHandler>
 
 #include "Config.h"
 #include "fileTree.h"
 #include "radialMap.h"
 #include "sincos.h"
 #include "widget.h"
 
 namespace RadialMap
 {
 struct Label {
     Label(const RadialMap::Segment *s, int l) : segment(s), lvl(l), a(segment->start() + (segment->length() / 2)) { }
 
     bool tooClose(const int &aa) const {
         return (a > aa - LABEL_ANGLE_MARGIN && a < aa + LABEL_ANGLE_MARGIN);
     }
 
     const RadialMap::Segment *segment;
     const unsigned int lvl;
     const int a;
 
     int x1, y1, x2, y2, x3;
     int tx, ty;
 
     QString qs;
 };
 
 class LabelList : public QList<Label *>
 {
 
 public:
     ~LabelList() {
         QListIterator<Label *> it(*this);
         while (it.hasNext())
             delete it.next();
     }
 
     void inSort(Label * label1) {
         for (QList<Label *>::iterator it(begin()); it != end(); ++it) {
             Label * label2 = *it;
             bool ins = false;
 
             //you add 1440 to work round the fact that later you want the circle split vertically
             //and as it is you start at 3 o' clock. It's to do with rightPrevY, stops annoying bug
 
             int a1 = label1->a + 1440;
             int a2 = label2->a + 1440;
 
             if (a1 == a2)
                 ins = true;
 
             if (a1 > 5760) a1 -= 5760;
             if (a2 > 5760) a2 -= 5760;
 
             if (a1 < a2)
                 ins = true;
 
             if (ins) {
                 insert(it, label1);
                 return;
             }
         }
 
         append(label1);
     }
 };
 }
 
 
 void
 RadialMap::Widget::paintExplodedLabels(QPainter &paint) const
 {
     //we are a friend of RadialMap::Map
 
     LabelList list;
     unsigned int startLevel = 0;
 
 
     //1. Create list of labels  sorted in the order they will be rendered
 
-    if (m_focus != NULL && m_focus->file() != m_tree) { //separate behavior for selected vs unselected segments
+    if (m_focus != nullptr && m_focus->file() != m_tree) { //separate behavior for selected vs unselected segments
         //don't bother with files
-        if (m_focus->file() == 0 || !m_focus->file()->isDir()) return;
+        if (m_focus->file() == nullptr || !m_focus->file()->isDir()) return;
 
         //find the range of levels we will be potentially drawing labels for
-        for (const Directory *p = (const Directory *)m_focus->file();
+        for (const auto *p = (const Directory *)m_focus->file();
                 p != m_tree;
                 ++startLevel) { //startLevel is the level above whatever m_focus is in
             p = p->parent();
         }
 
         //range=2 means 2 levels to draw labels for
 
         unsigned int a1, a2, minAngle;
 
         a1 = m_focus->start();
         a2 = m_focus->end();  // boundary angles
         minAngle = int(m_focus->length() * LABEL_MIN_ANGLE_FACTOR);
 
 
 #define segment (*it)
 #define ring (m_map.m_signature + i)
 
         //**** Levels should be on a scale starting with 0
         //**** range is a useless parameter
         //**** keep a topblock var which is the lowestLevel OR startLevel for indentation purposes
         for (unsigned int i = startLevel; i <= m_map.m_visibleDepth; ++i) {
             for (Iterator<Segment> it = ring->iterator(); it != ring->end(); ++it)
                 if (segment->start() >= a1 && segment->end() <= a2)
                     if (segment->length() > minAngle)
                         list.inSort(new Label(segment, i));
         }
 
 #undef ring
 #undef segment
 
     } else {
 
 #define ring m_map.m_signature
 
         for (Iterator<Segment> it = ring->iterator(); it != ring->end(); ++it)
             if ((*it)->length() > 288)
                 list.inSort(new Label((*it), 0));
 
 #undef ring
 
     }
 
     //2. Check to see if any adjacent labels are too close together
     //   if so, remove the least significant labels
 
     int itn = 0;
     int jtn = 1;
 
     while (jtn < list.count()) {
         //this method is fairly efficient
 
         if (list[ itn ]->tooClose(list[ jtn ]->a)) {
             if (list[ itn ]->lvl > list[ jtn ]->lvl) {
                 delete list[ itn ];
                 list.removeAt(itn);
                 jtn--;
                 itn = jtn;
             } else {
                 delete list[ jtn ];
                 list.removeAt(jtn);
             }
         } else
             ++itn;
 
         jtn = itn;
         ++jtn;
     }
 
     LabelList::iterator it = list.begin();
 
     //used in next two steps
     bool varySizes;
     //**** should perhaps use doubles
-    int  *sizes = new int [ m_map.m_visibleDepth + 1 ]; //**** make sizes an array of floats I think instead (or doubles)
+    auto  *sizes = new int [ m_map.m_visibleDepth + 1 ]; //**** make sizes an array of floats I think instead (or doubles)
 
     do {
         //3. Calculate font sizes
 
         {
             //determine current range of levels to draw for
             unsigned int range = 0;
 
             for (it = list.begin(); it != list.end(); ++it) {
                 unsigned int lvl = (*it)->lvl;
                 if (lvl > range)
                     range = lvl;
 
                 //**** better way would just be to assign if nothing is range
             }
 
             range -= startLevel; //range 0 means 1 level of labels
 
             varySizes = Config::varyLabelFontSizes && (range != 0);
 
             if (varySizes) {
                 //create an array of font sizes for various levels
                 //will exceed normal font pitch automatically if necessary, but not minPitch
                 //**** this needs to be checked lots
 
                 //**** what if this is negative (min size gtr than default size)
                 unsigned int step = (paint.font().pointSize() - Config::minFontPitch) / range;
                 if (step == 0) step = 1;
 
                 for (unsigned int x = range + startLevel, y = Config::minFontPitch;
                         x >= startLevel;
                         y += step, --x) {
                     sizes[x] = y;
                 }
             }
         }
 
         //4. determine label co-ordinates
 
         int x1, y1, x2, y2, x3, tx, ty; //coords
         double sinra, cosra, ra;  //angles
 
         int cx = m_map.width()  / 2 + m_offset.x();  //centre relative to canvas
         int cy = m_map.height() / 2 + m_offset.y();
 
         int spacer, preSpacer = int(m_map.m_ringBreadth * 0.5) + m_map.m_innerRadius;
         int fullStrutLength = (m_map.width() - m_map.MAP_2MARGIN) / 2 + LABEL_MAP_SPACER;   //full length of a strut from map center
 
         int prevLeftY  = 0;
         int prevRightY = height();
 
         bool rightSide;
 
         QFont font;
 
         for (it = list.begin(); it != list.end(); ++it) {
             //** bear in mind that text is drawn with QPoint param as BOTTOM left corner of text box
             if (varySizes) font.setPointSize(sizes[(*it)->lvl]);
             QFontMetrics fm(font);
             int fmh  = fm.height(); //used to ensure label texts don't overlap
             int fmhD4 = fmh / 4;
 
             fmh += LABEL_TEXT_VMARGIN;
 
             rightSide = ((*it)->a < 1440 || (*it)->a > 4320);
 
             ra = M_PI / 2880 * (*it)->a; //convert to radians
 #if 0
             sincos(ra, &sinra, &cosra);
 #endif
             sinra = sin(ra); cosra = cos(ra);
 
             spacer = preSpacer + m_map.m_ringBreadth * (*it)->lvl;
 
             x1 = cx + (int)(cosra * spacer);
             y1 = cy - (int)(sinra * spacer);
             y2 = y1 - (int)(sinra * (fullStrutLength - spacer));
 
             if (rightSide) {  //righthand side, going upwards
 
                 if (y2 > prevRightY /*- fmh*/)  //then it is too low, needs to be drawn higher
                     y2 = prevRightY /*- fmh*/;
 
             } else { //lefthand side, going downwards
 
                 if (y2 < prevLeftY/* + fmh*/)  //then we're too high, need to be drawn lower
                     y2 = prevLeftY /*+ fmh*/;
             }
 
             x2 = x1 - int(double(y2 - y1) / tan(ra));
             ty = y2 + fmhD4;
 
             QString qs;
             if (rightSide) {
 
                 if (x2 > width() || ty < fmh || x2 < x1) {
                     //skip this strut
                     //**** don't duplicate this code
                     delete *it;
                     it = list.erase(it);   //will delete the label and set it to list.current() which _should_ be the next ptr
                     break;
                 }
 
                 prevRightY = ty - fmh - fmhD4; //must be after above's "continue"
 
                 qs = fm.elidedText((*it)->segment->file()->name(), Qt::ElideMiddle, width() - x2);
 
                 x3 = width() - fm.width(qs)
                      - LABEL_HMARGIN //outer margin
                      - LABEL_TEXT_HMARGIN //margin between strut and text
                      //- ((*it)->lvl - startLevel) * LABEL_HMARGIN //indentation
                      ;
                 if (x3 < x2) x3 = x2;
                 tx = x3 + LABEL_TEXT_HMARGIN;
 
             } else {
 
                 if (x2 < 0 || ty > height() || x2 > x1) {
                     //skip this strut
                     delete *it;
                     it = list.erase(it);   //will delete the label and set it to list.current() which _should_ be the next ptr
                     break;
                 }
 
                 prevLeftY = ty + fmh - fmhD4;
 
                 qs = fm.elidedText((*it)->segment->file()->name(), Qt::ElideMiddle, x2);
 
                 //**** needs a little tweaking:
 
                 tx = fm.width(qs) + LABEL_HMARGIN/* + ((*it)->lvl - startLevel) * LABEL_HMARGIN*/;
                 if (tx > x2) {  //text is too long
                     tx = LABEL_HMARGIN + x2 - tx; //some text will be lost from sight
                     x3 = x2; //no text margin (right side of text here)
                 } else {
                     x3 = tx + LABEL_TEXT_HMARGIN;
                     tx = LABEL_HMARGIN /* + ((*it)->lvl - startLevel) * LABEL_HMARGIN*/;
                 }
             }
 
             (*it)->x1 = x1;
             (*it)->y1 = y1;
             (*it)->x2 = x2;
             (*it)->y2 = y2;
             (*it)->x3 = x3;
             (*it)->tx = tx;
             (*it)->ty = ty;
             (*it)->qs = qs;
         }
 
         //if an element is deleted at this stage, we need to do this whole
         //iteration again, thus the following loop
         //**** in rare case that deleted label was last label in top level
         //     and last in labelList too, this will not work as expected (not critical)
 
     } while (it != list.end());
 
 
     //5. Render labels
 
     paint.setPen(QPen(Qt::black, 1));
 
     for (it = list.begin(); it != list.end(); ++it) {
         if (varySizes) {
             //**** how much overhead in making new QFont each time?
             //     (implicate sharing remember)
             QFont font = paint.font();
             font.setPointSize(sizes[(*it)->lvl]);
             paint.setFont(font);
         }
 
         paint.drawEllipse((*it)->x1 - 3, (*it)->y1 - 3, 7, 7);   //**** CPU intensive! better to use a pixmap
         paint.drawLine((*it)->x1, (*it)->y1, (*it)->x2, (*it)->y2);
         paint.drawLine((*it)->x2, (*it)->y2, (*it)->x3, (*it)->y2);
         paint.drawText((*it)->tx, (*it)->ty, (*it)->qs);
     }
 
     delete [] sizes;
 }
diff --git a/krusader/DiskUsage/radialMap/map.cpp b/krusader/DiskUsage/radialMap/map.cpp
index 47eb1713..675a9b90 100644
--- a/krusader/DiskUsage/radialMap/map.cpp
+++ b/krusader/DiskUsage/radialMap/map.cpp
@@ -1,407 +1,407 @@
 /*****************************************************************************
  * Copyright (C) 2003-2004 Max Howell <max.howell@methylblue.com>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 // QtGui
 #include <QImage>          //make() & paint()
 #include <QFont>                                    //ctor
 #include <QFontMetrics>                               //ctor
 #include <QPainter>
 #include <QPolygon>
 // QtWidgets
 #include <QApplication>    //make()
 
 #include <KIconThemes/KIconEffect>                        //desaturate()
 #include <KWidgetsAddons/KCursor>         //make()
 #include <KConfigWidgets/KColorScheme>
 
 #include "builder.h"
 #include "Config.h"
 #include "fileTree.h"
 #include "sincos.h"
 #include "widget.h"
 
 #define COLOR_GREY QColor::fromHsv( 0, 0, 140 )
 
 RadialMap::Map::Map()
-        : m_signature(0)
+        : m_signature(nullptr)
         , m_ringBreadth(MIN_RING_BREADTH)
         , m_innerRadius(0)
         , m_visibleDepth(DEFAULT_RING_DEPTH)
 {
     //FIXME this is all broken. No longer is a maximum depth!
     const int fmh   = QFontMetrics(QFont()).height();
     const int fmhD4 = fmh / 4;
     MAP_2MARGIN = 2 * (fmh - (fmhD4 - LABEL_MAP_SPACER));   //margin is dependent on fitting in labels at top and bottom
 }
 
 RadialMap::Map::~Map()
 {
     delete [] m_signature;
 }
 
 void
 RadialMap::Map::invalidate(const bool desaturateTheImage)
 {
     delete [] m_signature;
-    m_signature = 0;
+    m_signature = nullptr;
 
     if (desaturateTheImage) {
         QImage img = this->toImage();
 
         KIconEffect::deSaturate(img, 0.7);
         KIconEffect::toGray(img, true);
 
         this->QPixmap::operator=(fromImage(img, Qt::AutoColor));
     }
 
     m_visibleDepth = Config::defaultRingDepth;
 }
 
 void
 RadialMap::Map::make(const Directory *tree, bool refresh)
 {
     //**** determineText seems pointless optimization
     //   but is it good to keep the text consistent?
     //   even if it makes it a lie?
 
     //slow operation so set the wait cursor
     QApplication::setOverrideCursor(Qt::WaitCursor);
 
     {
         //build a signature of visible components
         delete [] m_signature;
         Builder builder(this, tree, refresh);
     }
 
     //colour the segments
     colorise();
 
     //determine centerText
     if (!refresh) {
         int i;
 
         for (i = 3; i > 0; --i)
             if (tree->size() > File::DENOMINATOR[i])
                 break;
 
         m_centerText = tree->humanReadableSize((File::UnitPrefix)i);
     }
 
     //paint the pixmap
     aaPaint();
 
     QApplication::restoreOverrideCursor();
 }
 
 void
 RadialMap::Map::setRingBreadth()
 {
     m_ringBreadth = (height() - MAP_2MARGIN) / (2 * m_visibleDepth + 4);
 
     if (m_ringBreadth < MIN_RING_BREADTH) m_ringBreadth = MIN_RING_BREADTH;
     else if (m_ringBreadth > MAX_RING_BREADTH) m_ringBreadth = MAX_RING_BREADTH;
 }
 
 bool
 RadialMap::Map::resize(const QRect &rect)
 {
     //there's a MAP_2MARGIN border
 
 #define mw width()
 #define mh height()
 #define cw rect.width()
 #define ch rect.height()
 
     if (cw < mw || ch < mh || (cw > mw && ch > mh)) {
         uint size = ((cw < ch) ? cw : ch) - MAP_2MARGIN;
 
         //this also causes uneven sizes to always resize when resizing but map is small in that dimension
         //size -= size % 2; //even sizes mean less staggered non-antialiased resizing
 
         {
             const uint minSize = MIN_RING_BREADTH * 2 * (m_visibleDepth + 2);
             const uint mD2 = MAP_2MARGIN / 2;
 
             if (size < minSize) size = minSize;
 
             //this QRect is used by paint()
             m_rect.setRect(mD2, mD2, size, size);
         }
 
         //resize the pixmap
         size += MAP_2MARGIN;
         this->QPixmap::operator=(QPixmap(size, size));
 
-        if (m_signature != NULL) {
+        if (m_signature != nullptr) {
             setRingBreadth();
             paint();
         } else fill(); //FIXME I don't like having to do this..
 
         return true;
     }
 
 #undef mw
 #undef mh
 #undef cw
 #undef ch
 
     return false;
 }
 
 void
 RadialMap::Map::colorise()
 {
     QColor cp, cb;
     double darkness = 1;
     double contrast = (double)Config::contrast / (double)100;
     int h, s1, s2, v1, v2;
 
     QColor kdeColour[2] = { KColorScheme(QPalette::Inactive, KColorScheme::Window).background().color(),
                             KColorScheme(QPalette::Active, KColorScheme::Window).background(KColorScheme::ActiveBackground).color() };
 
     double deltaRed   = (double)(kdeColour[0].red()   - kdeColour[1].red())   / 2880; //2880 for semicircle
     double deltaGreen = (double)(kdeColour[0].green() - kdeColour[1].green()) / 2880;
     double deltaBlue  = (double)(kdeColour[0].blue()  - kdeColour[1].blue())  / 2880;
 
     for (uint i = 0; i <= m_visibleDepth; ++i, darkness += 0.04) {
         for (Iterator<Segment> it = m_signature[i].iterator(); it != m_signature[i].end(); ++it) {
             switch (Config::scheme) {
             case Filelight::KDE: {
                 //gradient will work by figuring out rgb delta values for 360 degrees
                 //then each component is angle*delta
 
                 int a = (*it)->start();
 
                 if (a > 2880) a = 2880 - (a - 2880);
 
                 h  = (int)(deltaRed   * a) + kdeColour[1].red();
                 s1 = (int)(deltaGreen * a) + kdeColour[1].green();
                 v1 = (int)(deltaBlue  * a) + kdeColour[1].blue();
 
                 cb.setRgb(h, s1, v1);
                 cb.getHsv(&h, &s1, &v1);
 
                 break;
             }
 
             case Filelight::HighContrast:
 
                 cp.setHsv(0, 0, 0);   //values of h, s and v are irrelevant
                 cb.setHsv(180, 0, int(255.0 * contrast));
                 (*it)->setPalette(cp, cb);
                 continue;
 
             default:
                 h  = int((*it)->start() / 16);
                 s1 = 160;
                 v1 = (int)(255.0 / darkness); //****doing this more often than once seems daft!
             }
 
             v2 = v1 - int(contrast * v1);
             s2 = s1 + int(contrast * (255 - s1));
 
             if (s1 < 80) s1 = 80;  //can fall too low and makes contrast between the files hard to discern
 
             if ((*it)->isFake()) { //multi-file
                 cb.setHsv(h, s2, (v2 < 90) ? 90 : v2);   //too dark if < 100
                 cp.setHsv(h, 17, v1);
             } else if (!(*it)->file()->isDir()) { //file
                 cb.setHsv(h, 17, v1);
                 cp.setHsv(h, 17, v2);
             } else { //directory
                 cb.setHsv(h, s1, v1);   //v was 225
                 cp.setHsv(h, s2, v2);   //v was 225 - delta
             }
 
             (*it)->setPalette(cp, cb);
 
             //**** may be better to store KDE colours as H and S and vary V as others
             //**** perhaps make saturation difference for s2 dependent on contrast too
             //**** fake segments don't work with highContrast
             //**** may work better with cp = cb rather than Qt::white
             //**** you have to ensure the grey of files is sufficient, currently it works only with rainbow (perhaps use contrast there too)
             //**** change v1,v2 to vp, vb etc.
             //**** using percentages is not strictly correct as the eye doesn't work like that
             //**** darkness factor is not done for kde_colour scheme, and also value for files is incorrect really for files in this scheme as it is not set like rainbow one is
         }
     }
 }
 
 void
 RadialMap::Map::aaPaint()
 {
     //paint() is called during continuous processes
     //aaPaint() is not and is slower so set overidecursor (make sets it too)
     QApplication::setOverrideCursor(Qt::WaitCursor);
     paint(Config::antiAliasFactor);
     QApplication::restoreOverrideCursor();
 }
 
 void
 RadialMap::Map::paint(unsigned int scaleFactor)
 {
     if (scaleFactor == 0)  //just in case
         scaleFactor = 1;
 
     QPainter paint;
     QRect rect = m_rect;
     int step = m_ringBreadth;
     int excess = -1;
 
     //scale the pixmap, or do intelligent distribution of excess to prevent nasty resizing
     if (scaleFactor > 1) {
         int x1, y1, x2, y2;
         rect.getCoords(&x1, &y1, &x2, &y2);
         x1 *= scaleFactor;
         y1 *= scaleFactor;
         x2 *= scaleFactor;
         y2 *= scaleFactor;
         rect.setCoords(x1, y1, x2, y2);
 
         step *= scaleFactor;
         QPixmap::operator=(QPixmap(this->size() * (int)scaleFactor));
     } else if (m_ringBreadth != MAX_RING_BREADTH && m_ringBreadth != MIN_RING_BREADTH) {
         excess = rect.width() % m_ringBreadth;
         ++step;
     }
 
     //**** best option you can think of is to make the circles slightly less perfect,
     //  ** i.e. slightly eliptic when resizing inbetween
 
 
     paint.begin(this);
 
     fill(); //erase background
 
     for (int x = m_visibleDepth; x >= 0; --x) {
         int width = rect.width() / 2;
         //clever geometric trick to find largest angle that will give biggest arrow head
-        int a_max = int(acos((double)width / double((width + 5) * scaleFactor)) * (180 * 16 / M_PI));
+        auto a_max = int(acos((double)width / double((width + 5) * scaleFactor)) * (180 * 16 / M_PI));
 
         for (ConstIterator<Segment> it = m_signature[x].constIterator(); it != m_signature[x].end(); ++it) {
             //draw the pie segments, most of this code is concerned with drawing the little
             //arrows on the ends of segments when they have hidden files
 
             paint.setPen((*it)->pen());
 
             if ((*it)->hasHiddenChildren()) {
                 //draw arrow head to indicate undisplayed files/directories
                 QPolygon pts(3);
                 QPoint pos, cpos = rect.center();
                 int a[3] = {static_cast<int>((*it)->start()), static_cast<int>((*it)->length()), 0 };
 
                 a[2] = a[0] + (a[1] / 2); //assign to halfway between
                 if (a[1] > a_max) {
                     a[1] = a_max;
                     a[0] = a[2] - a_max / 2;
                 }
 
                 a[1] += a[0];
 
                 for (int i = 0, radius = width; i < 3; ++i) {
                     double ra = M_PI / (180 * 16) * a[i], sinra, cosra;
 
                     if (i == 2)
                         radius += 5 * scaleFactor;
 #if 0
                     sincos(ra, &sinra, &cosra);
 #endif
                     sinra = sin(ra); cosra = cos(ra);
                     pos.rx() = cpos.x() + static_cast<int>(cosra * radius);
                     pos.ry() = cpos.y() - static_cast<int>(sinra * radius);
                     pts.setPoint(i, pos);
                 }
 
                 paint.setBrush((*it)->pen());
                 paint.drawPolygon(pts);
             }
 
             paint.setBrush((*it)->brush());
             paint.drawPie(rect, (*it)->start(), (*it)->length());
 
             if ((*it)->hasHiddenChildren()) {
                 //**** code is bloated!
                 paint.save();
                 QPen pen = paint.pen();
                 int width = 2 * scaleFactor;
                 pen.setWidth(width);
                 paint.setPen(pen);
                 QRect rect2 = rect;
                 width /= 2;
                 rect2.adjust(width, width, -width, -width);
                 paint.drawArc(rect2, (*it)->start(), (*it)->length());
                 paint.restore();
             }
         }
 
         if (excess >= 0) {  //excess allows us to resize more smoothly (still crud tho)
             if (excess < 2)  //only decrease rect by more if even number of excesses left
                 --step;
             excess -= 2;
         }
 
         rect.adjust(step, step, -step, -step);
     }
 
     //  if( excess > 0 ) rect.adjust( excess, excess, 0, 0 ); //ugly
 
     paint.setPen(COLOR_GREY);
     paint.setBrush(Qt::white);
     paint.drawEllipse(rect);
 
     if (scaleFactor > 1) {
         //have to end in order to smoothscale()
         paint.end();
 
         int x1, y1, x2, y2;
         rect.getCoords(&x1, &y1, &x2, &y2);
         x1 /= scaleFactor;
         y1 /= scaleFactor;
         x2 /= scaleFactor;
         y2 /= scaleFactor;
         rect.setCoords(x1, y1, x2, y2);
 
         QImage img = this->toImage();
         img = img.scaled(this->size() / (int)scaleFactor, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
         this->QPixmap::operator=(fromImage(img, Qt::AutoColor));
 
         paint.begin(this);
         paint.setPen(COLOR_GREY);
         paint.setBrush(Qt::white);
     }
 
     paint.drawText(rect, Qt::AlignCenter, m_centerText);
 
     m_innerRadius = rect.width() / 2; //rect.width should be multiple of 2
 
     paint.end();
 }
 #if 0
 #if __GLIBC__ < 2 ||  __GLIBC__ == 2 && __GLIBC_MINOR__ < 1
 
 void
 sincos(double angleRadians, double *Sin, double *Cos)
 {
     *Sin = sin(angleRadians);
     *Cos = cos(angleRadians);
 }
 
 #endif
 #endif
diff --git a/krusader/DiskUsage/radialMap/segmentTip.cpp b/krusader/DiskUsage/radialMap/segmentTip.cpp
index 56e6101c..38e67b9d 100644
--- a/krusader/DiskUsage/radialMap/segmentTip.cpp
+++ b/krusader/DiskUsage/radialMap/segmentTip.cpp
@@ -1,187 +1,187 @@
 /*****************************************************************************
  * Copyright (C) 2003-2004 Max Howell <max.howell@methylblue.com>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "segmentTip.h"
 
 // QtCore
 #include <QEvent>
 // QtGui
 #include <QPainter>
 // QtWidgets
 #include <QApplication>                           //installing eventFilters
 #include <QDesktopWidget>
 #include <QToolTip>                               //for its palette
 
 #include <KI18n/KLocalizedString>
 
 #include "fileTree.h"
 
 namespace RadialMap
 {
 
 SegmentTip::SegmentTip(uint h)
-        : QWidget(0, Qt::FramelessWindowHint | Qt::Tool | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint)
+        : QWidget(nullptr, Qt::FramelessWindowHint | Qt::Tool | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint)
         , m_cursorHeight(-h)
 {
     setAttribute(Qt::WA_NoSystemBackground, true);
 }
 
 void
 SegmentTip::moveto(QPoint p, QWidget &canvas, bool placeAbove)
 {
     //**** this function is very slow and seems to be visibly influenced by operations like mapFromGlobal() (who knows why!)
     //  ** so any improvements are much desired
 
     //TODO uints could improve the class
     p.rx() -= rect().center().x();
     p.ry() -= (placeAbove ? 8 + height() : m_cursorHeight - 8);
 
     const QRect screen = QApplication::desktop()->screenGeometry(parentWidget());
 
     const int x  = p.x();
     const int y  = p.y();
     const int x2 = x + width();
     const int y2 = y + height(); //how's it ever gunna get below screen height?! (well you never know I spose)
     const int sw = screen.width();
     const int sh = screen.height();
 
     if (x  < 0) p.setX(0);
     if (y  < 0) p.setY(0);
     if (x2 > sw) p.rx() -= x2 - sw;
     if (y2 > sh) p.ry() -= y2 - sh;
 
 
     //I'm using this QPoint to determine where to offset the bitBlt in m_pixmap
     QPoint offset = canvas.mapToGlobal(QPoint()) - p;
     if (offset.x() < 0) offset.setX(0);
     if (offset.y() < 0) offset.setY(0);
 
 
     const QRect alphaMaskRect(canvas.mapFromGlobal(p), size());
     const QRect intersection(alphaMaskRect.intersected(canvas.rect()));
 
     m_pixmap = QPixmap(size());   //move to updateTip once you are sure it can never be null
     //bitBlt( &m_pixmap, offset, &canvas, intersection, Qt::CopyROP );
     QPainter(&m_pixmap).drawPixmap(offset, QPixmap::grabWidget(&canvas, intersection));
 
     QColor col = QToolTip::palette().color(QPalette::Active, QPalette::Window);
     col.setAlpha(153);   // 0.6
 
     QRect rct = rect();
     if (rct.width())
         rct.setWidth(rct.width() - 1);
     if (rct.height())
         rct.setHeight(rct.height() - 1);
 
     QPainter paint(&m_pixmap);
     paint.setPen(Qt::black);
     paint.setBrush(col);
     paint.drawRect(rct);
     paint.end();
 
     paint.begin(&m_pixmap);
     paint.drawText(rect(), Qt::AlignCenter, m_text);
     paint.end();
 
     p += screen.topLeft(); //for Xinerama users
 
     move(x, y);
     show();
     repaint();
 }
 
 void
 SegmentTip::updateTip(const File* const file, const Directory* const root)
 {
     const QString s1  = file->fullPath(root);
     QString s2        = file->humanReadableSize();
     QLocale loc;
     const uint MARGIN = 3;
     const uint pc     = 100 * file->size() / root->size();
     uint maxw         = 0;
     uint h            = fontMetrics().height() * 2 + 2 * MARGIN;
 
     if (pc > 0) s2 += QString(" (%1%)").arg(loc.toString(pc));
 
     m_text  = s1;
     m_text += '\n';
     m_text += s2;
 
     if (file->isDir()) {
-        double files  = static_cast<const Directory*>(file)->fileCount();
-        const uint pc = uint((100 * files) / (double)root->fileCount());
+        double files  = dynamic_cast<const Directory*>(file)->fileCount();
+        const auto pc = uint((100 * files) / (double)root->fileCount());
         QString s3    = i18n("Files: %1", loc.toString(files, 'f', 0));
 
         if (pc > 0) s3 += QString(" (%1%)").arg(loc.toString(pc));
 
         maxw    = fontMetrics().width(s3);
         h      += fontMetrics().height();
         m_text += '\n';
         m_text += s3;
     }
 
     uint
     w = fontMetrics().width(s1); if (w > maxw) maxw = w;
     w = fontMetrics().width(s2); if (w > maxw) maxw = w;
 
     resize(maxw + 2 * MARGIN, h);
 }
 
 bool
 SegmentTip::event(QEvent *e)
 {
     switch (e->type()) {
     case QEvent::Show:
         qApp->installEventFilter(this);
         break;
     case QEvent::Hide:
         qApp->removeEventFilter(this);
         break;
     case QEvent::Paint: {
         // bitBlt( this, 0, 0, &m_pixmap );
         QPainter(this).drawPixmap(0, 0, m_pixmap);
         return true;
     }
     default:
         ;
     }
 
     return false/*QWidget::event( e )*/;
 }
 
 bool
 SegmentTip::eventFilter(QObject*, QEvent *e)
 {
     switch (e->type()) {
     case QEvent::Leave:
 //    case QEvent::MouseButtonPress:
 //    case QEvent::MouseButtonRelease:
     case QEvent::KeyPress:
     case QEvent::KeyRelease:
     case QEvent::FocusIn:
     case QEvent::FocusOut:
     case QEvent::Wheel:
         hide(); //FALL THROUGH
     default:
         return false; //allow this event to passed to target
     }
 }
 
 } //namespace RadialMap
diff --git a/krusader/DiskUsage/radialMap/widget.cpp b/krusader/DiskUsage/radialMap/widget.cpp
index 9dee06b0..5242dd20 100644
--- a/krusader/DiskUsage/radialMap/widget.cpp
+++ b/krusader/DiskUsage/radialMap/widget.cpp
@@ -1,216 +1,216 @@
 /*****************************************************************************
  * Copyright (C) 2003-2004 Max Howell <max.howell@methylblue.com>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "widget.h"
 
 // QtCore
 #include <QEvent>
 #include <QTimer>                                    //member
 #include <QUrl>
 // QtGui
 #include <QMouseEvent>
 #include <QBitmap>                                    //ctor - finding cursor size
 #include <QCursor>                                    //slotPostMouseEvent()
 #include <QPalette>
 // QtWidgets
 #include <QApplication>                           //sendEvent
 
 #include <KWidgetsAddons/KCursor>        //ctor
 
 #include "fileTree.h"
 #include "Config.h"
 #include "radialMap.h" //constants
 
 RadialMap::Widget::Widget(QWidget *parent)
         : QWidget(parent)
-        , m_tree(0)
-        , m_focus(0)
+        , m_tree(nullptr)
+        , m_focus(nullptr)
         , m_tip(QFontMetrics(font()).height())     //needs to know cursor height
-        , m_rootSegment(0)   //TODO we don't delete it, *shrug*
+        , m_rootSegment(nullptr)   //TODO we don't delete it, *shrug*
 {
     QPalette pal = palette();
     pal.setColor(backgroundRole(), Qt::white);
     setPalette(pal);
 
     connect(this, &Widget::created, this, &Widget::sendFakeMouseEvent);
     connect(this, &Widget::created, this, QOverload<>::of(&Widget::update));
     connect(&m_timer, &QTimer::timeout, this, &Widget::resizeTimeout);
 }
 
 QString
 RadialMap::Widget::path() const
 {
-    if (m_tree == 0)
+    if (m_tree == nullptr)
         return QString();
     return m_tree->fullPath();
 }
 
 QUrl
 RadialMap::Widget::url(File const * const file) const
 {
-    if (file == 0 && m_tree == 0)
+    if (file == nullptr && m_tree == nullptr)
         return QUrl();
 
     return QUrl::fromLocalFile(file ? file->fullPath() : m_tree->fullPath());
 }
 
 void
 RadialMap::Widget::invalidate(const bool b)
 {
     if (isValid()) {
         //**** have to check that only way to invalidate is this function frankly
         //**** otherwise you may get bugs..
 
         //disable mouse tracking
         setMouseTracking(false);
 
         QUrl urlInv = url();
 
         //ensure this class won't think we have a map still
-        m_tree  = 0;
-        m_focus = 0;
+        m_tree  = nullptr;
+        m_focus = nullptr;
 
         delete m_rootSegment;
-        m_rootSegment = 0;
+        m_rootSegment = nullptr;
 
         //FIXME move this disablement thing no?
         //      it is confusing in other areas, like the whole createFromCache() thing
         m_map.invalidate(b);   //b signifies whether the pixmap is made to look disabled or not
         if (b)
             update();
 
         //tell rest of Filelight
         emit invalidated(urlInv);
     }
 }
 
 void
 RadialMap::Widget::create(const Directory *tree)
 {
     //it is not the responsibility of create() to invalidate first
     //skip invalidation at your own risk
 
     //FIXME make it the responsibility of create to invalidate first
 
     if (tree) {
-        m_focus = 0;
+        m_focus = nullptr;
         //generate the filemap image
         m_map.make(tree);
 
         //this is the inner circle in the center
         m_rootSegment = new Segment(tree, 0, 16*360);
 
         setMouseTracking(true);
     }
 
     m_tree = tree;
 
     //tell rest of Filelight
     emit created(tree);
 }
 
 void
 RadialMap::Widget::createFromCache(const Directory *tree)
 {
     //no scan was necessary, use cached tree, however we MUST still emit invalidate
     invalidate(false);
     create(tree);
 }
 
 void
 RadialMap::Widget::sendFakeMouseEvent() //slot
 {
     QMouseEvent me(QEvent::MouseMove, mapFromGlobal(QCursor::pos()), Qt::NoButton, Qt::NoButton, Qt::NoModifier);
     QApplication::sendEvent(this, &me);
 }
 
 void
 RadialMap::Widget::resizeTimeout() //slot
 {
     // the segments are about to erased!
     // this was a horrid bug, and proves the OO programming should be obeyed always!
-    m_focus = 0;
+    m_focus = nullptr;
     if (m_tree)
         m_map.make(m_tree, true);
     update();
 }
 
 void
 RadialMap::Widget::refresh(int filth)
 {
     //TODO consider a more direct connection
 
     if (!m_map.isNull()) {
         switch (filth) {
         case 1:
-            m_focus = 0;
+            m_focus = nullptr;
             if (m_tree)
                 m_map.make(m_tree, true);   //true means refresh only
             break;
 
         case 2:
             m_map.aaPaint();
             break;
 
         case 3:
             m_map.colorise(); //FALL THROUGH!
         case 4:
             m_map.paint();
 
         default:
             break;
         }
 
         update();
     }
 }
 
 void
 RadialMap::Widget::zoomIn() //slot
 {
     if (m_map.m_visibleDepth > MIN_RING_DEPTH) {
-        m_focus = 0;
+        m_focus = nullptr;
         --m_map.m_visibleDepth;
         if (m_tree)
             m_map.make(m_tree);
         Config::defaultRingDepth = m_map.m_visibleDepth;
         update();
     }
 }
 
 void
 RadialMap::Widget::zoomOut() //slot
 {
-    m_focus = 0;
+    m_focus = nullptr;
     ++m_map.m_visibleDepth;
     if (m_tree)
         m_map.make(m_tree);
     if (m_map.m_visibleDepth > Config::defaultRingDepth)
         Config::defaultRingDepth = m_map.m_visibleDepth;
     update();
 }
 
 
 RadialMap::Segment::~Segment()
 {
     if (isFake())
         delete m_file; //created by us in Builder::build()
 }
 
diff --git a/krusader/DiskUsage/radialMap/widget.h b/krusader/DiskUsage/radialMap/widget.h
index 31d4c609..a32bae39 100644
--- a/krusader/DiskUsage/radialMap/widget.h
+++ b/krusader/DiskUsage/radialMap/widget.h
@@ -1,140 +1,140 @@
 /*****************************************************************************
  * Copyright (C) 2004 Max Howell <max.howell@methylblue.com>                 *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef WIDGET_H
 #define WIDGET_H
 
 // QtCore
 #include <QTimer>
 #include <QUrl>
 // QtGui
 #include <QMouseEvent>
 #include <QResizeEvent>
 #include <QPaintEvent>
 
 #include "segmentTip.h"
 
 template <class T> class Chain;
 class Directory;
 class File;
 class KJob;
 
 namespace RadialMap
 {
 class Segment;
 
 class Map : public QPixmap
 {
 public:
     Map();
-    ~Map();
+    ~Map() override;
 
     void make(const Directory *, bool = false);
     bool resize(const QRect&);
 
     bool isNull() const {
-        return (m_signature == 0);
+        return (m_signature == nullptr);
     }
     void invalidate(const bool);
 
     friend class Builder;
     friend class Widget;
 
 private:
     void paint(uint = 1);
     void aaPaint();
     void colorise();
     void setRingBreadth();
 
     Chain<Segment> *m_signature;
 
     QRect   m_rect;
     uint    m_ringBreadth;  ///ring breadth
     uint    m_innerRadius;  ///radius of inner circle
     uint    m_visibleDepth; ///visible level depth of system
     QString m_centerText;
 
     uint MAP_2MARGIN;
 };
 
 class Widget : public QWidget
 {
     Q_OBJECT
 
 public:
-    explicit Widget(QWidget* = 0);
+    explicit Widget(QWidget* = nullptr);
 
     QString path() const;
-    QUrl url(File const * const = 0) const;
+    QUrl url(File const * const = nullptr) const;
 
     bool isValid() const {
-        return m_tree != 0;
+        return m_tree != nullptr;
     }
 
-    friend class Label; //FIXME badness
+    friend struct Label; //FIXME badness
 
 public slots:
     void zoomIn();
     void zoomOut();
     void create(const Directory*);
     void invalidate(const bool = true);
     void refresh(int);
 
 private slots:
     void resizeTimeout();
     void sendFakeMouseEvent();
     void deleteJobFinished(KJob*);
     void createFromCache(const Directory*);
 
 signals:
     void activated(const QUrl&);
     void invalidated(const QUrl&);
     void created(const Directory*);
     void mouseHover(const QString&);
 
 protected:
-    virtual void paintEvent(QPaintEvent*) Q_DECL_OVERRIDE;
-    virtual void resizeEvent(QResizeEvent*) Q_DECL_OVERRIDE;
-    virtual void mouseMoveEvent(QMouseEvent*) Q_DECL_OVERRIDE;
-    virtual void mousePressEvent(QMouseEvent*) Q_DECL_OVERRIDE;
+    void paintEvent(QPaintEvent*) Q_DECL_OVERRIDE;
+    void resizeEvent(QResizeEvent*) Q_DECL_OVERRIDE;
+    void mouseMoveEvent(QMouseEvent*) Q_DECL_OVERRIDE;
+    void mousePressEvent(QMouseEvent*) Q_DECL_OVERRIDE;
 
 protected:
     const Segment *segmentAt(QPoint&) const;   //FIXME const reference for a library others can use
     const Segment *rootSegment() const {
         return m_rootSegment;
     } ///never == 0
     const Segment *focusSegment() const {
         return m_focus;
     } ///0 == nothing in focus
 
 private:
     void paintExplodedLabels(QPainter&) const;
 
     const Directory *m_tree;
     const Segment   *m_focus;
     QPoint           m_offset;
     QTimer           m_timer;
     Map              m_map;
     SegmentTip       m_tip;
     Segment         *m_rootSegment;
 };
 }
 
 #endif
diff --git a/krusader/DiskUsage/radialMap/widgetEvents.cpp b/krusader/DiskUsage/radialMap/widgetEvents.cpp
index 18a7efb0..5d111304 100644
--- a/krusader/DiskUsage/radialMap/widgetEvents.cpp
+++ b/krusader/DiskUsage/radialMap/widgetEvents.cpp
@@ -1,252 +1,252 @@
 /*****************************************************************************
  * Copyright (C) 2003-2004 Max Howell <max.howell@methylblue.com>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "fileTree.h"
 #include "radialMap.h"   //class Segment
 #include "widget.h"
 #include "../../icon.h"
 
 #include <cmath>
 
 // QtCore
 #include <QTimer>                                    //::resizeEvent()
 // QtGui
 #include <QMouseEvent>
 #include <QPainter>
 #include <QPaintEvent>
 #include <QResizeEvent>
 // QtWidgets
 #include <QApplication>          //QApplication::setOverrideCursor()
 #include <QMenu>
 
 #include <KI18n/KLocalizedString>
 #include <KIconThemes/KIconEffect>
 #include <KIO/DeleteJob>
 #include <KIO/JobUiDelegate>
 #include <KIOWidgets/KRun>
 #include <KWidgetsAddons/KCursor>
 #include <KWidgetsAddons/KMessageBox>
 
 
 void
 RadialMap::Widget::resizeEvent(QResizeEvent*)
 {
     if (m_map.resize(rect())) {
         m_timer.setSingleShot(true);
         m_timer.start(500);   //will cause signature to rebuild for new size
     }
 
     //always do these as they need to be initialised on creation
     m_offset.rx() = (width() - m_map.width()) / 2;
     m_offset.ry() = (height() - m_map.height()) / 2;
 }
 
 void
 RadialMap::Widget::paintEvent(QPaintEvent*)
 {
     //bltBit for some Qt setups will bitBlt _after_ the labels are painted. Which buggers things up!
     //shame as bitBlt is faster, possibly Qt bug? Should report the bug? - seems to be race condition
     //bitBlt( this, m_offset, &m_map );
 
     QPainter paint(this);
 
     paint.drawPixmap(m_offset, m_map);
 
     //vertical strips
     if (m_map.width() < width()) {
         paint.eraseRect(0, 0, m_offset.x(), height());
         paint.eraseRect(m_map.width() + m_offset.x(), 0, m_offset.x() + 1, height());
     }
     //horizontal strips
     if (m_map.height() < height()) {
         paint.eraseRect(0, 0, width(), m_offset.y());
         paint.eraseRect(0, m_map.height() + m_offset.y(), width(), m_offset.y() + 1);
     }
 
     //exploded labels
     if (!m_map.isNull() && !m_timer.isActive())
         paintExplodedLabels(paint);
 }
 
 const RadialMap::Segment*
 RadialMap::Widget::segmentAt(QPoint &e) const
 {
     //determine which segment QPoint e is above
 
     e -= m_offset;
 
     if (e.x() <= m_map.width() && e.y() <= m_map.height()) {
         //transform to cartesian coords
         e.rx() -= m_map.width() / 2; //should be an int
         e.ry()  = m_map.height() / 2 - e.y();
 
         double length = std::hypot(e.x(), e.y());
 
         if (length >= m_map.m_innerRadius) { //not hovering over inner circle
             uint depth  = ((int)length - m_map.m_innerRadius) / m_map.m_ringBreadth;
 
             if (depth <= m_map.m_visibleDepth) { //**** do earlier since you can //** check not outside of range
                 //vector calculation, reduces to simple trigonometry
                 //cos angle = (aibi + ajbj) / albl
                 //ai = x, bi=1, aj=y, bj=0
                 //cos angle = x / (length)
 
-                uint a  = (uint)(acos((double)e.x() / length) * 916.736);    //916.7324722 = #radians in circle * 16
+                auto a  = (uint)(acos((double)e.x() / length) * 916.736);    //916.7324722 = #radians in circle * 16
 
                 //acos only understands 0-180 degrees
                 if (e.y() < 0) a = 5760 - a;
 
 #define ring (m_map.m_signature + depth)
                 for (ConstIterator<Segment> it = ring->constIterator(); it != ring->end(); ++it)
                     if ((*it)->intersects(a))
                         return *it;
 #undef ring
             }
         } else return m_rootSegment; //hovering over inner circle
     }
 
-    return 0;
+    return nullptr;
 }
 
 void
 RadialMap::Widget::mouseMoveEvent(QMouseEvent *e)
 {
     //set m_focus to what we hover over, update UI if it's a new segment
 
     Segment const * const oldFocus = m_focus;
     QPoint p = e->pos();
 
     m_focus = segmentAt(p);   //NOTE p is passed by non-const reference
 
     if (m_focus && m_focus->file() != m_tree) {
         if (m_focus != oldFocus) { //if not same as last time
             setCursor(QCursor(Qt::PointingHandCursor));
             m_tip.updateTip(m_focus->file(), m_tree);
             emit mouseHover(m_focus->file()->fullPath());
 
             //repaint required to update labels now before transparency is generated
             repaint();
         }
 
         // updates tooltip pseudo-transparent background
         m_tip.moveto(e->globalPos(), *this, (p.y() < 0));
     } else if (oldFocus && oldFocus->file() != m_tree) {
         unsetCursor();
         m_tip.hide();
         update();
 
         emit mouseHover(QString());
     }
 }
 
 void
 RadialMap::Widget::mousePressEvent(QMouseEvent *e)
 {
     //m_tip is hidden already by event filter
     //m_focus is set correctly (I've been strict, I assure you it is correct!)
 
     if (m_focus && !m_focus->isFake()) {
         const QUrl url   = Widget::url(m_focus->file());
         const bool isDir = m_focus->file()->isDir();
 
         if (e->button() == Qt::RightButton) {
             QMenu popup;
             popup.setTitle(m_focus->file()->fullPath(m_tree));
 
-            QAction * actKonq = 0, * actKonsole = 0, *actViewMag = 0, * actFileOpen = 0, * actEditDel = 0;
+            QAction * actKonq = nullptr, * actKonsole = nullptr, *actViewMag = nullptr, * actFileOpen = nullptr, * actEditDel = nullptr;
 
             if (isDir) {
                 actKonq = popup.addAction(Icon("system-file-manager"), i18n("Open File Manager Here"));
                 if (url.scheme() == "file")
                     actKonsole = popup.addAction(Icon("utilities-terminal"), i18n("Open Terminal Here"));
 
                 if (m_focus->file() != m_tree) {
                     popup.addSeparator();
                     actViewMag = popup.addAction(Icon("zoom-original"), i18n("&Center Map Here"));
                 }
             } else
                 actFileOpen = popup.addAction(Icon("document-open"), i18n("&Open"));
 
             popup.addSeparator();
             actEditDel = popup.addAction(Icon("edit-delete"), i18n("&Delete"));
 
             QAction * result = popup.exec(e->globalPos());
-            if (result == 0)
+            if (result == nullptr)
                 result = (QAction *) - 1;  // sanity
 
             if (result == actKonq)
                 //KRun::runCommand will show an error message if there was trouble
                 KRun::runCommand(QString("kfmclient openURL '%1'").arg(url.url()), this);
             else if (result == actKonsole)
                 KRun::runCommand(QString("konsole --workdir '%1'").arg(url.url()), this);
             else if (result == actViewMag || result == actFileOpen)
                 goto sectionTwo;
             else if (result == actEditDel) {
                 const QUrl url = Widget::url(m_focus->file());
                 const QString message = (m_focus->file()->isDir()
                                          ? i18n("<qt>The folder at <i>'%1'</i> will be <b>recursively</b> and <b>permanently</b> deleted.</qt>", url.toDisplayString())
                                          : i18n("<qt><i>'%1'</i> will be <b>permanently</b> deleted.</qt>", url.toDisplayString()));
                 const int userIntention = KMessageBox::warningContinueCancel(this, message, QString(), KStandardGuiItem::del());
 
                 if (userIntention == KMessageBox::Continue) {
                     KIO::Job *job = KIO::del(url);
-                    KIO::JobUiDelegate *ui = static_cast<KIO::JobUiDelegate*>(job->uiDelegate());
+                    auto *ui = dynamic_cast<KIO::JobUiDelegate*>(job->uiDelegate());
                     ui->setWindow(this);
                     connect(job, &KIO::Job::result, this, &Widget::deleteJobFinished);
                     QApplication::setOverrideCursor(Qt::BusyCursor);
                 }
             } else
                 //ensure m_focus is set for new mouse position
                 sendFakeMouseEvent();
 
         } else {
 
         sectionTwo:
 
             const QRect rect(e->x() - 20, e->y() - 20, 40, 40);
 
             m_tip.hide(); //user expects this
 
             if (!isDir || e->button() == Qt::MidButton) {
 #if 0 // TODO: PORTME
                 KIconEffect::visualActivate(this, rect);
 #endif
                 new KRun(url, this, true);   //FIXME see above
             } else if (m_focus->file() != m_tree) { //is left mouse button
 #if 0 // TODO: PORTME
                 KIconEffect::visualActivate(this, rect);
 #endif
                 emit activated(url);   //activate first, this will cause UI to prepare itself
                 if (m_focus)
                     createFromCache((Directory *)m_focus->file());
             }
         }
     }
 }
 
 void
 RadialMap::Widget::deleteJobFinished(KJob *job)
 {
     QApplication::restoreOverrideCursor();
     if (!job->error())
         invalidate();
     else
         job->uiDelegate()->showErrorMessage();
 }
diff --git a/krusader/FileSystem/defaultfilesystem.cpp b/krusader/FileSystem/defaultfilesystem.cpp
index 6af35acc..5aa6a7a8 100644
--- a/krusader/FileSystem/defaultfilesystem.cpp
+++ b/krusader/FileSystem/defaultfilesystem.cpp
@@ -1,412 +1,412 @@
 /*****************************************************************************
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "defaultfilesystem.h"
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 #include <QEventLoop>
 
 #include <KConfigCore/KSharedConfig>
 #include <KCoreAddons/KUrlMimeData>
 #include <KI18n/KLocalizedString>
 #include <KIO/DropJob>
 #include <KIO/MkpathJob>
 #include <KIO/FileUndoManager>
 #include <KIO/JobUiDelegate>
 #include <KIO/ListJob>
 #include <KIOCore/KDiskFreeSpaceInfo>
 #include <KIOCore/KFileItem>
 #include <KIOCore/KMountPoint>
 #include <KIOCore/KProtocolManager>
 #include <kio_version.h>
 
 #include "fileitem.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../krservices.h"
 #include "../JobMan/krjob.h"
 
-DefaultFileSystem::DefaultFileSystem(): FileSystem(), _watcher()
+DefaultFileSystem::DefaultFileSystem()
 {
     _type = FS_DEFAULT;
 }
 
 void DefaultFileSystem::copyFiles(const QList<QUrl> &urls, const QUrl &destination,
                             KIO::CopyJob::CopyMode mode, bool showProgressInfo,
                             JobMan::StartMode startMode)
 {
     // resolve relative path before resolving symlinks
     const QUrl dest = resolveRelativePath(destination);
 
     KIO::JobFlags flags = showProgressInfo ? KIO::DefaultFlags : KIO::HideProgressInfo;
 
     KrJob *krJob = KrJob::createCopyJob(mode, urls, dest, flags);
     // destination can be a full path with filename when copying/moving a single file
     const QUrl destDir = dest.adjusted(QUrl::RemoveFilename);
     connect(krJob, &KrJob::started, this, [=](KIO::Job *job) { connectJobToDestination(job, destDir); });
     if (mode == KIO::CopyJob::Move) { // notify source about removed files
         connect(krJob, &KrJob::started, this, [=](KIO::Job *job) { connectJobToSources(job, urls); });
     }
 
     krJobMan->manageJob(krJob, startMode);
 }
 
 void DefaultFileSystem::dropFiles(const QUrl &destination, QDropEvent *event)
 {
     qDebug() << "destination=" << destination;
 
     // resolve relative path before resolving symlinks
     const QUrl dest = resolveRelativePath(destination);
 
     KIO::DropJob *job = KIO::drop(event, dest);
 #if KIO_VERSION >= QT_VERSION_CHECK(5, 30, 0)
     // NOTE: a DropJob "starts" with showing a menu. If the operation is chosen (copy/move/link)
     // the actual CopyJob starts automatically - we cannot manage the start of the CopyJob (see
     // documentation for KrJob)
     connect(job, &KIO::DropJob::copyJobStarted, this, [=](KIO::CopyJob *kJob) {
         connectJobToDestination(job, dest); // now we have to refresh the destination
 
         KrJob *krJob = KrJob::createDropJob(job, kJob);
         krJobMan->manageStartedJob(krJob, kJob);
         if (kJob->operationMode() == KIO::CopyJob::Move) { // notify source about removed files
             connectJobToSources(kJob, kJob->srcUrls());
         }
     });
 #else
     // NOTE: DropJob does not provide information about the actual user choice
     // (move/copy/link/abort). We have to assume the worst (move)
     connectJobToDestination(job, dest);
     connectJobToSources(job, KUrlMimeData::urlsFromMimeData(event->mimeData()));
 #endif
 }
 
 void DefaultFileSystem::addFiles(const QList<QUrl> &fileUrls, KIO::CopyJob::CopyMode mode,
                                  const QString &dir)
 {
     QUrl destination(_currentDirectory);
     if (!dir.isEmpty()) {
         destination.setPath(QDir::cleanPath(destination.path() + '/' + dir));
         const QString scheme = destination.scheme();
         if (scheme == "tar" || scheme == "zip" || scheme == "krarc") {
             if (QDir(destination.path()).exists())
                 // if we get out from the archive change the protocol
                 destination.setScheme("file");
         }
     }
 
     destination = ensureTrailingSlash(destination); // destination is always a directory
     copyFiles(fileUrls, destination, mode);
 }
 
 void DefaultFileSystem::mkDir(const QString &name)
 {
     KJob *job;
     if (name.contains('/')) {
         job = KIO::mkpath(getUrl(name));
     } else {
         job = KIO::mkdir(getUrl(name));
     }
     connectJobToDestination(job, currentDirectory());
 }
 
 void DefaultFileSystem::rename(const QString &oldName, const QString &newName)
 {
     const QUrl oldUrl = getUrl(oldName);
     const QUrl newUrl = getUrl(newName);
     KIO::Job *job = KIO::moveAs(oldUrl, newUrl, KIO::HideProgressInfo);
     connectJobToDestination(job, currentDirectory());
 
     KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Rename, {oldUrl}, newUrl, job);
 }
 
 QUrl DefaultFileSystem::getUrl(const QString& name) const
 {
     // NOTE: on non-local fs file URL does not have to be path + name!
     FileItem *fileItem = getFileItem(name);
     if (fileItem)
         return fileItem->getUrl();
 
     QUrl absoluteUrl(_currentDirectory);
     if (name.startsWith('/')) {
         absoluteUrl.setPath(name);
     } else {
         absoluteUrl.setPath(absoluteUrl.path() + '/' + name);
     }
     return absoluteUrl;
 }
 
 void DefaultFileSystem::updateFilesystemInfo()
 {
     if (!KConfigGroup(krConfig, "Look&Feel").readEntry("ShowSpaceInformation", true)) {
         _mountPoint = "";
         emit fileSystemInfoChanged(i18n("Space information disabled"), "", 0, 0);
         return;
     }
 
     // TODO get space info for trash:/ with KIO spaceInfo job
     if (!_currentDirectory.isLocalFile()) {
         _mountPoint = "";
         emit fileSystemInfoChanged(i18n("No space information on non-local filesystems"), "", 0, 0);
         return;
     }
 
     const QString path = _currentDirectory.path();
     const KDiskFreeSpaceInfo info = KDiskFreeSpaceInfo::freeSpaceInfo(path);
     if (!info.isValid()) {
         _mountPoint = "";
         emit fileSystemInfoChanged(i18n("Space information unavailable"), "", 0, 0);
         return;
     }
     _mountPoint = info.mountPoint();
 
     const KMountPoint::Ptr mountPoint = KMountPoint::currentMountPoints().findByPath(path);
     const QString fsType = mountPoint ? mountPoint->mountType() : "";
 
     emit fileSystemInfoChanged("", fsType, info.size(), info.available());
 }
 
 // ==== protected ====
 
 bool DefaultFileSystem::refreshInternal(const QUrl &directory, bool onlyScan)
 {
     qDebug() << "refresh internal to URL=" << directory.toDisplayString();
     if (!KProtocolManager::supportsListing(directory)) {
         emit error(i18n("Protocol not supported by Krusader:\n%1", directory.url()));
         return false;
     }
 
     delete _watcher; // stop watching the old dir
 
     if (directory.isLocalFile()) {
         qDebug() << "start local refresh to URL=" << directory.toDisplayString();
         // we could read local directories with KIO but using Qt is a lot faster!
         return refreshLocal(directory, onlyScan);
     }
 
     _currentDirectory = cleanUrl(directory);
 
     // start the listing job
     KIO::ListJob *job = KIO::listDir(_currentDirectory, KIO::HideProgressInfo, showHiddenFiles());
     connect(job, &KIO::ListJob::entries, this, &DefaultFileSystem::slotAddFiles);
     connect(job, &KIO::ListJob::redirection, this, &DefaultFileSystem::slotRedirection);
     connect(job, &KIO::ListJob::permanentRedirection, this, &DefaultFileSystem::slotRedirection);
     connect(job, &KIO::Job::result, this, &DefaultFileSystem::slotListResult);
 
     // ensure connection credentials are asked only once
     if(!parentWindow.isNull()) {
-        KIO::JobUiDelegate *ui = static_cast<KIO::JobUiDelegate*>(job->uiDelegate());
+        auto *ui = dynamic_cast<KIO::JobUiDelegate*>(job->uiDelegate());
         ui->setWindow(parentWindow);
     }
 
     emit refreshJobStarted(job);
 
     _listError = false;
     // ugly: we have to wait here until the list job is finished
     QEventLoop eventLoop;
     connect(job, &KJob::finished, &eventLoop, &QEventLoop::quit);
     eventLoop.exec(); // blocking until quit()
 
     return !_listError;
 }
 
 // ==== protected slots ====
 
 void DefaultFileSystem::slotListResult(KJob *job)
 {
     qDebug() << "got list result";
     if (job && job->error()) {
         // we failed to refresh
         _listError = true;
         qDebug() << "error=" << job->errorString() << "; text=" << job->errorText();
         emit error(job->errorString()); // display error message (in panel)
     }
 }
 
 void DefaultFileSystem::slotAddFiles(KIO::Job *, const KIO::UDSEntryList& entries)
 {
-    for (const KIO::UDSEntry entry : entries) {
+    for (const KIO::UDSEntry& entry : entries) {
         FileItem *fileItem = FileSystem::createFileItemFromKIO(entry, _currentDirectory);
         if (fileItem) {
             addFileItem(fileItem);
         }
     }
 }
 
 void DefaultFileSystem::slotRedirection(KIO::Job *job, const QUrl &url)
 {
    qDebug() << "redirection to URL=" << url.toDisplayString();
 
    // some protocols (zip, tar) send redirect to local URL without scheme
    const QUrl newUrl = preferLocalUrl(url);
 
    if (newUrl.scheme() != _currentDirectory.scheme()) {
        // abort and start over again,
        // some protocols (iso, zip, tar) do this on transition to local fs
        job->kill();
        _isRefreshing = false;
        refresh(newUrl);
        return;
    }
 
     _currentDirectory = cleanUrl(newUrl);
 }
 
 void DefaultFileSystem::slotWatcherCreated(const QString& path)
 {
     qDebug() << "path created (doing nothing): " << path;
 }
 
 void DefaultFileSystem::slotWatcherDirty(const QString& path)
 {
     qDebug() << "path dirty: " << path;
     if (path == realPath()) {
         // this happens
         //   1. if a directory was created/deleted/renamed inside this directory.
         //   2. during and after a file operation (create/delete/rename/touch) inside this directory
         // KDirWatcher doesn't reveal the name of changed directories and we have to refresh.
         // (QFileSystemWatcher in Qt5.7 can't help here either)
         refresh();
         return;
     }
 
     const QString name = QUrl::fromLocalFile(path).fileName();
 
     FileItem *fileItem = getFileItem(name);
     if (!fileItem) {
         qWarning() << "file not found (unexpected), path=" << path;
         // this happens at least for cifs mounted filesystems: when a new file is created, a dirty
         // signal with its file path but no other signals are sent (buggy behaviour of KDirWatch)
         refresh();
         return;
     }
 
     // we have an updated file..
     FileItem *newFileItem = createLocalFileItem(name);
     addFileItem(newFileItem);
     emit updatedFileItem(newFileItem);
 
     delete fileItem;
 }
 
 void DefaultFileSystem::slotWatcherDeleted(const QString& path)
 {
     qDebug() << "path deleted: " << path;
     if (path != _currentDirectory.toLocalFile()) {
         // ignore deletion of files here, a 'dirty' signal will be send anyway
         return;
     }
 
     // the current directory was deleted. Try a refresh, which will fail. An error message will
     // be emitted and the empty (non-existing) directory remains.
     refresh();
 }
 
 bool DefaultFileSystem::refreshLocal(const QUrl &directory, bool onlyScan) {
     const QString path = KrServices::urlToLocalPath(directory);
 
 #ifdef Q_WS_WIN
     if (!path.contains("/")) { // change C: to C:/
         path = path + QString("/");
     }
 #endif
 
     // check if the new directory exists
     if (!QDir(path).exists()) {
         emit error(i18n("The folder %1 does not exist.", path));
         return false;
     }
 
     // mount if needed
     emit aboutToOpenDir(path);
 
     // set the current directory...
     _currentDirectory = directory;
     _currentDirectory.setPath(QDir::cleanPath(_currentDirectory.path()));
 
     // Note: we are using low-level Qt functions here.
     // It's around twice as fast as using the QDir class.
 
     QT_DIR* dir = QT_OPENDIR(path.toLocal8Bit());
     if (!dir) {
         emit error(i18n("Cannot open the folder %1.", path));
         return false;
     }
 
     // change directory to the new directory
     const QString savedDir = QDir::currentPath();
     if (!QDir::setCurrent(path)) {
         emit error(i18nc("%1=folder path", "Access to %1 denied", path));
         QT_CLOSEDIR(dir);
         return false;
     }
 
     QT_DIRENT* dirEnt;
     QString name;
     const bool showHidden = showHiddenFiles();
-    while ((dirEnt = QT_READDIR(dir)) != NULL) {
+    while ((dirEnt = QT_READDIR(dir)) != nullptr) {
         name = QString::fromLocal8Bit(dirEnt->d_name);
 
         // show hidden files?
         if (!showHidden && name.left(1) == ".") continue;
         // we don't need the "." and ".." entries
         if (name == "." || name == "..") continue;
 
         FileItem* temp = createLocalFileItem(name);
         addFileItem(temp);
     }
     // clean up
     QT_CLOSEDIR(dir);
     QDir::setCurrent(savedDir);
 
     if (!onlyScan) {
         // start watching the new dir for file changes
         _watcher = new KDirWatch(this);
         // if the current dir is a link path the watcher needs to watch the real path - and signal
         // parameters will be the real path
         _watcher->addDir(realPath(), KDirWatch::WatchFiles);
         connect(_watcher.data(), &KDirWatch::dirty, this, &DefaultFileSystem::slotWatcherDirty);
         // NOTE: not connecting 'created' signal. A 'dirty' is send after that anyway
         //connect(_watcher.data(), &KDirWatch::created, this, &DefaultFileSystem::slotWatcherCreated);
         connect(_watcher.data(), &KDirWatch::deleted, this, &DefaultFileSystem::slotWatcherDeleted);
         _watcher->startScan(false);
     }
 
     return true;
 }
 
 FileItem *DefaultFileSystem::createLocalFileItem(const QString &name)
 {
     return FileSystem::createLocalFileItem(name, _currentDirectory.path());
 }
 
 QString DefaultFileSystem::realPath()
 {
     // NOTE: current dir must exist
     return QDir(_currentDirectory.toLocalFile()).canonicalPath();
 }
 
 QUrl DefaultFileSystem::resolveRelativePath(const QUrl &url)
 {
     // if e.g. "/tmp/bin" is a link to "/bin",
     // resolve "/tmp/bin/.." to "/tmp" and not "/"
     return url.adjusted(QUrl::NormalizePathSegments);
 }
diff --git a/krusader/FileSystem/dirlisterinterface.h b/krusader/FileSystem/dirlisterinterface.h
index 540567b5..debbfe2b 100644
--- a/krusader/FileSystem/dirlisterinterface.h
+++ b/krusader/FileSystem/dirlisterinterface.h
@@ -1,77 +1,77 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DIRLISTERINTERFACE_H
 #define DIRLISTERINTERFACE_H
 
 // QtCore
 #include <QObject>
 #include <QUrl>
 
 class FileItem;
 
 /**
  * A minimal interface representing a list of files in a directory.
  */
 class DirListerInterface : public QObject
 {
     Q_OBJECT
 public:
     explicit DirListerInterface(QObject *parent) : QObject(parent) {}
-    virtual ~DirListerInterface() {}
+    ~DirListerInterface() override = default;
 
     /**
      * Return the file items of all files and directories. Without current (".") and parent ("..")
      * directory.
      */
     virtual QList<FileItem *> fileItems() const = 0;
     /**
      * Return the number of all file items.
      */
     virtual unsigned long numFileItems() const = 0;
     /**
      * Return true if the directory does not have a parent, else false.
      */
     virtual bool isRoot() const = 0;
 
 signals:
     /**
      * Emitted when scanning the directory for file items finished. The list of file items should
      * now be updated by the view.
      * @param dirChange true if changed to another directory.
      */
     void scanDone(bool dirChange);
     /**
      * Emitted when all file items were removed. The file items may be deleted after this signal and
      * should not be used anymore.
      */
     void cleared();
     /**
      * Emitted when a file was added to the list of file items (not by scan).
      */
     void addedFileItem(FileItem *fileItem);
     /**
      * Emitted when a file item (with the same name) was replaced.
      * The old file item will be deleted after this signal.
      */
     void updatedFileItem(FileItem *newFileItem);
 };
 
 #endif // DIRLISTERINTERFACE_H
diff --git a/krusader/FileSystem/fileitem.cpp b/krusader/FileSystem/fileitem.cpp
index 71843a0c..673d9ef5 100644
--- a/krusader/FileSystem/fileitem.cpp
+++ b/krusader/FileSystem/fileitem.cpp
@@ -1,230 +1,230 @@
 /*****************************************************************************
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "fileitem.h"
 
 // QtCore
 #include <QCache>
 #include <QDateTime>
 #include <QMimeDatabase>
 #include <QMimeType>
 
 #include <KConfigCore/KDesktopFile>
 
 #include "krpermhandler.h"
 #include "filesystemprovider.h"
 
 bool FileItem::userDefinedFolderIcons = true;
 
 // wrapper class; QCache needs objects
 class FileSize
 {
 public:
     const KIO::filesize_t m_size;
     FileSize(KIO::filesize_t size) : m_size(size) {}
 };
 
 // cache for calculated directory sizes;
 static QCache<const QUrl, FileSize> s_fileSizeCache(1000);
 
 FileItem::FileItem(const QString &name, const QUrl &url, bool isDir,
              KIO::filesize_t size, mode_t mode,
              time_t mtime, time_t ctime, time_t atime,
              uid_t uid, gid_t gid, const QString &owner, const QString &group,
              bool isLink, const QString &linkDest, bool isBrokenLink,
              const QString &acl, const QString &defaultAcl)
     : m_name(name), m_url(url), m_isDir(isDir),
       m_size(size), m_mode(mode),
       m_mtime(mtime), m_ctime(ctime), m_atime(atime),
       m_uid(uid), m_gid(gid), m_owner(owner), m_group(group),
       m_isLink(isLink), m_linkDest(linkDest), m_isBrokenLink(isBrokenLink),
       m_acl(acl), m_defaulfAcl(defaultAcl), m_AclLoaded(false),
       m_mimeType(), m_iconName()
 {
     m_permissions = KRpermHandler::mode2QString(mode);
 
     if (m_owner.isEmpty())
         m_owner = KRpermHandler::uid2user(m_uid);
 
     if (m_group.isEmpty())
         m_group = KRpermHandler::gid2group(m_gid);
 
     if (m_isDir && !m_isLink) {
         m_size = s_fileSizeCache.contains(m_url) ? s_fileSizeCache[m_url]->m_size : -1;
     }
 }
 
 FileItem *FileItem::createDummy()
 {
     FileItem *file = new FileItem("..", QUrl(), true,
                             0, 0,
                             0, 0, 0);
     file->setIconName("go-up");
     return file;
 }
 
 FileItem *FileItem::createBroken(const QString &name, const QUrl &url)
 {
     FileItem *file = new FileItem(name, url, false,
                                   0, 0, 0, 0, 0);
     file->setIconName("file-broken");
     return file;
 }
 
 FileItem *FileItem::createVirtualDir(const QString &name, const QUrl &url)
 {
     return new FileItem(name, url, true,
                      0, 0700,
-                     time(0), time(0), time(0),
+                     time(nullptr), time(nullptr), time(nullptr),
                      getuid(), getgid());
 }
 
 FileItem *FileItem::createCopy(const FileItem &file, const QString &newName)
 {
     return new FileItem(newName, file.getUrl(), file.isDir(),
                      file.getSize(), file.getMode(),
                      file.getTime_t(), file.getChangedTime(), file.getAccessTime(),
                      file.m_uid, file.m_gid, file.getOwner(), file.getGroup(),
                      file.isSymLink(), file.getSymDest(), file.isBrokenLink());
 }
 
 char FileItem::isReadable() const
 {
     if (m_uid != (uid_t)-1 && m_gid != (gid_t)-1)
         return KRpermHandler::readable(m_permissions, m_gid, m_uid);
     else
         return KRpermHandler::ftpReadable(m_owner, m_url.userName(), m_permissions);
 }
 
 char FileItem::isWriteable() const
 {
     if (m_uid != (uid_t)-1 && m_gid != (gid_t)-1)
         return KRpermHandler::writeable(m_permissions, m_gid, m_uid);
     else
         return KRpermHandler::ftpWriteable(m_owner, m_url.userName(), m_permissions);
 }
 
 char FileItem::isExecutable() const
 {
     if (m_uid != (uid_t)-1 && m_gid != (gid_t)-1)
         return KRpermHandler::executable(m_permissions, m_gid, m_uid);
     else
         return KRpermHandler::ftpExecutable(m_owner, m_url.userName(), m_permissions);
 }
 
 void FileItem::setSize(KIO::filesize_t size)
 {
     m_size = size;
     s_fileSizeCache.insert(m_url, new FileSize(size));
 }
 
 const QString &FileItem::getMime()
 {
     if (m_mimeType.isEmpty()) {
         if (m_isDir) {
             m_mimeType = "inode/directory";
             m_iconName = "inode-directory";
         } else if (isBrokenLink()) {
             m_mimeType = "unknown";
             m_iconName = "file-broken";
         } else {
             const QMimeDatabase db;
             const QMimeType mt = db.mimeTypeForUrl(getUrl());
             m_mimeType = mt.isValid() ? mt.name() : "unknown";
             m_iconName = mt.isValid() ? mt.iconName() : "file-broken";
 
             if (m_mimeType == "inode/directory") {
                 // TODO view update needed? and does this ever happen?
                 m_isDir = true;
             }
         }
 
         if (m_isDir && userDefinedFolderIcons) {
             const QUrl url = getUrl();
             if (url.isLocalFile()) {
                 const QString file = url.toLocalFile() + "/.directory";
                 const KDesktopFile cfg(file);
                 const QString iconName = cfg.readIcon();
                 if (!iconName.isEmpty())
                     m_iconName = iconName.startsWith(QLatin1String("./")) ?
                                      // relative path
                                      url.toLocalFile() + '/' + iconName :
                                      iconName;
             }
         }
     }
     return m_mimeType;
 }
 
 const QString &FileItem::getIcon()
 {
     if (m_iconName.isEmpty()) {
         getMime(); // sets the icon
     }
     return m_iconName;
 }
 
 const QString &FileItem::getACL()
 {
     if (!m_AclLoaded)
         loadACL();
     return m_acl;
 }
 
 void FileItem::loadACL()
 {
     if (m_url.isLocalFile()) {
         FileSystemProvider::getACL(this, m_acl, m_defaulfAcl);
     }
     m_AclLoaded = true;
 }
 
 const KIO::UDSEntry FileItem::getEntry()
 {
     KIO::UDSEntry entry;
 
     entry.insert(KIO::UDSEntry::UDS_NAME, getName());
     entry.insert(KIO::UDSEntry::UDS_SIZE, getSize());
     entry.insert(KIO::UDSEntry::UDS_MODIFICATION_TIME, getTime_t());
     entry.insert(KIO::UDSEntry::UDS_CREATION_TIME, getChangedTime());
     entry.insert(KIO::UDSEntry::UDS_ACCESS_TIME, getAccessTime());
     entry.insert(KIO::UDSEntry::UDS_USER, getOwner());
     entry.insert(KIO::UDSEntry::UDS_GROUP, getGroup());
     entry.insert(KIO::UDSEntry::UDS_MIME_TYPE, getMime());
     entry.insert(KIO::UDSEntry::UDS_FILE_TYPE, getMode() & S_IFMT);
     entry.insert(KIO::UDSEntry::UDS_ACCESS, getMode() & 07777);
 
     if (isSymLink())
         entry.insert(KIO::UDSEntry::UDS_LINK_DEST, getSymDest());
 
     if (!m_AclLoaded)
         loadACL();
     if (!m_acl.isNull() || !m_defaulfAcl.isNull()) {
         entry.insert(KIO::UDSEntry::UDS_EXTENDED_ACL, 1);
 
         if (!m_acl.isNull())
             entry.insert(KIO::UDSEntry::UDS_ACL_STRING, m_acl);
 
         if (!m_defaulfAcl.isNull())
             entry.insert(KIO::UDSEntry::UDS_DEFAULT_ACL_STRING, m_defaulfAcl);
     }
 
     return entry;
 }
diff --git a/krusader/FileSystem/filesystem.cpp b/krusader/FileSystem/filesystem.cpp
index 281aa587..890bd799 100644
--- a/krusader/FileSystem/filesystem.cpp
+++ b/krusader/FileSystem/filesystem.cpp
@@ -1,334 +1,334 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "filesystem.h"
 
 #include <memory>
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 #include <QList>
 // QtWidgets
 #include <qplatformdefs.h>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIO/JobUiDelegate>
 
 #include "fileitem.h"
 #include "krpermhandler.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../JobMan/jobman.h"
 #include "../JobMan/krjob.h"
 
-FileSystem::FileSystem() : DirListerInterface(0), _isRefreshing(false) {}
+FileSystem::FileSystem() : DirListerInterface(nullptr), _isRefreshing(false) {}
 
 FileSystem::~FileSystem()
 {
     clear(_fileItems);
     // please don't remove this line. This informs the view about deleting the file items.
     emit cleared();
 }
 
 QList<QUrl> FileSystem::getUrls(const QStringList &names) const
 {
     QList<QUrl> urls;
-    for (const QString name : names) {
+    for (const QString& name : names) {
         urls.append(getUrl(name));
     }
     return urls;
 }
 
 FileItem *FileSystem::getFileItem(const QString &name) const
 {
     return _fileItems.contains(name) ? _fileItems.value(name) : 0;
 }
 
 KIO::filesize_t FileSystem::totalSize() const
 {
     KIO::filesize_t temp = 0;
     for (FileItem *item : _fileItems.values()) {
         if (!item->isDir() && item->getName() != "." && item->getName() != "..") {
             temp += item->getSize();
         }
     }
 
     return temp;
 }
 
 QUrl FileSystem::ensureTrailingSlash(const QUrl &url)
 {
     if (url.path().endsWith('/')) {
         return url;
     }
 
     QUrl adjustedUrl(url);
     adjustedUrl.setPath(adjustedUrl.path() + '/');
     return adjustedUrl;
 }
 
 QUrl FileSystem::preferLocalUrl(const QUrl &url){
     if (url.isEmpty() || !url.scheme().isEmpty())
         return url;
 
     QUrl adjustedUrl = url;
     adjustedUrl.setScheme("file");
     return adjustedUrl;
 }
 
 bool FileSystem::scanOrRefresh(const QUrl &directory, bool onlyScan)
 {
     qDebug() << "from current dir=" << _currentDirectory.toDisplayString()
              << "; to=" << directory.toDisplayString();
     if (_isRefreshing) {
         // NOTE: this does not happen (unless async)";
         return false;
     }
 
     // workaround for krarc: find out if transition to local fs is wanted and adjust URL manually
     QUrl url = directory;
     if (_currentDirectory.scheme() == "krarc" && url.scheme() == "krarc" &&
         QDir(url.path()).exists()) {
         url.setScheme("file");
     }
 
     const bool dirChange = !url.isEmpty() && cleanUrl(url) != _currentDirectory;
 
     const QUrl toRefresh =
             dirChange ? url.adjusted(QUrl::NormalizePathSegments) : _currentDirectory;
     if (!toRefresh.isValid()) {
         emit error(i18n("Malformed URL:\n%1", toRefresh.toDisplayString()));
         return false;
     }
 
     _isRefreshing = true;
 
     FileItemDict tempFileItems(_fileItems); // old file items are still used during refresh
     _fileItems.clear();
     if (dirChange)
         // show an empty directory while loading the new one and clear selection
         emit cleared();
 
     const bool refreshed = refreshInternal(toRefresh, onlyScan);
     _isRefreshing = false;
 
     if (!refreshed) {
         // cleanup and abort
         if (!dirChange)
             emit cleared();
         clear(tempFileItems);
         return false;
     }
 
     emit scanDone(dirChange);
 
     clear(tempFileItems);
 
     updateFilesystemInfo();
 
     return true;
 }
 
 void FileSystem::deleteFiles(const QList<QUrl> &urls, bool moveToTrash)
 {
     KrJob *krJob = KrJob::createDeleteJob(urls, moveToTrash);
     connect(krJob, &KrJob::started, this, [=](KIO::Job *job) {
         connectJobToSources(job, urls);
     });
 
     if (moveToTrash) {
         // update destination: the trash bin (in case a panel/tab is showing it)
         connect(krJob, &KrJob::started, this, [=](KIO::Job *job) {
             // Note: the "trash" protocol should always have only one "/" after the "scheme:" part
             connect(job, &KIO::Job::result, this, [=]() { emit fileSystemChanged(QUrl("trash:/"), false); });
         });
     }
 
     krJobMan->manageJob(krJob);
 }
 
-void FileSystem::connectJobToSources(KJob *job, const QList<QUrl> urls)
+void FileSystem::connectJobToSources(KJob *job, const QList<QUrl>& urls)
 {
     if (!urls.isEmpty()) {
         // TODO we assume that all files were in the same directory and only emit one signal for
         // the directory of the first file URL (all subdirectories of parent are notified)
         const QUrl url = urls.first().adjusted(QUrl::RemoveFilename);
         connect(job, &KIO::Job::result, this, [=]() { emit fileSystemChanged(url, true); });
     }
 }
 
 void FileSystem::connectJobToDestination(KJob *job, const QUrl &destination)
 {
     connect(job, &KIO::Job::result, this, [=]() { emit fileSystemChanged(destination, false); });
     // (additional) direct refresh if on local fs because watcher is too slow
     const bool refresh = cleanUrl(destination) == _currentDirectory && isLocal();
     connect(job, &KIO::Job::result, this, [=](KJob* job) { slotJobResult(job, refresh); });
 }
 
 bool FileSystem::showHiddenFiles()
 {
     const KConfigGroup gl(krConfig, "Look&Feel");
     return gl.readEntry("Show Hidden", _ShowHidden);
 }
 
 void FileSystem::addFileItem(FileItem *item)
 {
     _fileItems.insert(item->getName(), item);
 }
 
 FileItem *FileSystem::createLocalFileItem(const QString &name, const QString &directory, bool virt)
 {
     const QDir dir = QDir(directory);
     const QString path = dir.filePath(name);
     const QByteArray pathByteArray = path.toLocal8Bit();
     const QString fileItemName = virt ? path : name;
     const QUrl fileItemUrl = QUrl::fromLocalFile(path);
 
     // read file status; in case of error create a "broken" file item
     QT_STATBUF stat_p;
     memset(&stat_p, 0, sizeof(stat_p));
     if (QT_LSTAT(pathByteArray.data(), &stat_p) < 0)
         return FileItem::createBroken(fileItemName, fileItemUrl);
 
     const KIO::filesize_t size = stat_p.st_size;
     bool isDir = S_ISDIR(stat_p.st_mode);
     const bool isLink = S_ISLNK(stat_p.st_mode);
 
     // for links, read link destination and determine whether it's broken or not
     QString linkDestination;
     bool brokenLink = false;
     if (isLink) {
         linkDestination = readLinkSafely(pathByteArray.data());
 
         if (linkDestination.isNull()) {
             brokenLink = true;
         }
         else {
             const QFileInfo linkFile(dir, linkDestination);
             if (!linkFile.exists())
                 brokenLink = true;
             else if (linkFile.isDir())
                 isDir = true;
         }
     }
 
     // create normal file item
     return new FileItem(fileItemName, fileItemUrl, isDir,
                         size, stat_p.st_mode,
                         stat_p.st_mtime, stat_p.st_ctime, stat_p.st_atime,
                         stat_p.st_uid, stat_p.st_gid, QString(), QString(),
                         isLink, linkDestination, brokenLink);
 }
 
 QString FileSystem::readLinkSafely(const char *path)
 {
     // inspired by the areadlink_with_size function from gnulib, which is used for coreutils
     // idea: start with a small buffer and gradually increase it as we discover it wasn't enough
 
     QT_OFF_T bufferSize = 1024; // start with 1 KiB
     QT_OFF_T maxBufferSize = std::numeric_limits<QT_OFF_T>::max();
 
     while (true) {
         // try to read the link
         std::unique_ptr<char[]> buffer(new char[bufferSize]);
         auto nBytesRead = readlink(path, buffer.get(), bufferSize);
 
         // should never happen, asserted by the readlink
         if (nBytesRead > bufferSize) {
             return QString();
         }
 
         // read failure
         if (nBytesRead < 0) {
             qDebug() << "Failed to read the link " << path;
             return QString();
         }
 
         // read success
         if (nBytesRead < bufferSize || nBytesRead == maxBufferSize) {
             return QString::fromLocal8Bit(buffer.get(), nBytesRead);
         }
 
         // increase the buffer and retry again
         // bufferSize < maxBufferSize is implied from previous checks
         if (bufferSize <= maxBufferSize / 2) {
             bufferSize *= 2;
         }
         else {
             bufferSize = maxBufferSize;
         }
     }
 }
 
 FileItem *FileSystem::createFileItemFromKIO(const KIO::UDSEntry &entry, const QUrl &directory, bool virt)
 {
     const KFileItem kfi(entry, directory, true, true);
 
     const QString name = kfi.text();
     // ignore un-needed entries
     if (name.isEmpty() || name == "." || name == "..") {
-        return 0;
+        return nullptr;
     }
 
     const QString localPath = kfi.localPath();
     const QUrl url = !localPath.isEmpty() ? QUrl::fromLocalFile(localPath) : kfi.url();
     const QString fname = virt ? url.toDisplayString() : name;
 
     // get file statistics...
     const time_t mtime = kfi.time(KFileItem::ModificationTime).toTime_t();
     const time_t ctime = kfi.time(KFileItem::CreationTime).toTime_t(); // "Creation"? its "Changed"
     const time_t atime = kfi.time(KFileItem::AccessTime).toTime_t();
     const mode_t mode = kfi.mode() | kfi.permissions();
     // NOTE: we could get the mimetype (and file icon) from the kfileitem here but this is very
     // slow. Instead, the file item class has it's own (faster) way to determine the file type.
 
     // NOTE: "broken link" flag is always false, checking link destination existence is
     // considered to be too expensive
     return new FileItem(fname, url, kfi.isDir(),
                      kfi.size(), mode,
                      mtime, ctime, atime,
                      (uid_t) -1, (gid_t) -1, kfi.user(), kfi.group(),
                      kfi.isLink(), kfi.linkDest(), false,
                      kfi.ACL().asString(), kfi.defaultACL().asString());
 }
 
 void FileSystem::slotJobResult(KJob *job, bool refresh)
 {
     if (job->error() && job->uiDelegate()) {
         // show errors for modifying operations as popup (works always)
         job->uiDelegate()->showErrorMessage();
     }
 
     if (refresh) {
         FileSystem::refresh();
     }
 }
 
 void FileSystem::clear(FileItemDict &fileItems)
 {
     QHashIterator<QString, FileItem *> lit(fileItems);
     while (lit.hasNext()) {
         delete lit.next().value();
     }
     fileItems.clear();
 }
diff --git a/krusader/FileSystem/filesystem.h b/krusader/FileSystem/filesystem.h
index 9a43fb13..7fce0ee4 100644
--- a/krusader/FileSystem/filesystem.h
+++ b/krusader/FileSystem/filesystem.h
@@ -1,221 +1,221 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef FILESYSTEM_H
 #define FILESYSTEM_H
 
 #include "dirlisterinterface.h"
 
 // QtCore
 #include <QHash>
 #include <QList>
 #include <QString>
 #include <QPointer>
 // QtGui
 #include <QDropEvent>
 // QtWidgets
 #include <QWidget>
 
 #include <KIO/CopyJob>
 #include <KIO/DirectorySizeJob>
 
 #include "../JobMan/jobman.h"
 
 class FileItem;
 
 /**
  * An abstract filesystem. Use the implementations of this class for all file operations.
  *
  * It represents a directory and gives access to its files. All common file operations
  * are supported. Methods with absolute URL as argument can be used independently from the current
  * directory. Otherwise - if the methods argument is a file name - the operation is performed inside
  * the current directory.
  *
  * Notification signals are emitted if the directory content may have been changed.
  */
 class FileSystem : public DirListerInterface
 {
     Q_OBJECT
 public:
 
     enum FS_TYPE {
         /// Virtual filesystem. Krusaders custom virt:/ protocol
         FS_VIRTUAL,
         /// Filesystem supporting all KIO protocols (file:/, ftp:/, smb:/, etc.)
         FS_DEFAULT
     };
 
     FileSystem();
-    virtual ~FileSystem();
+    ~FileSystem() override;
 
     // DirListerInterface implementation
     inline QList<FileItem *> fileItems() const Q_DECL_OVERRIDE { return _fileItems.values(); }
     inline unsigned long numFileItems() const Q_DECL_OVERRIDE { return _fileItems.count(); }
     inline bool isRoot() const Q_DECL_OVERRIDE {
         const QString path = _currentDirectory.path();
         return path.isEmpty() || path == "/";
     }
 
     /// Copy (copy, move or link) files in this filesystem.
     /// Destination is absolute URL. May implemented async.
     virtual void copyFiles(const QList<QUrl> &urls, const QUrl &destination,
                            KIO::CopyJob::CopyMode mode = KIO::CopyJob::Copy,
                            bool showProgressInfo = true,
                            JobMan::StartMode startMode = JobMan::Default) = 0;
     /// Handle file dropping in this filesystem. Destination is absolute URL. May implemented async.
     virtual void dropFiles(const QUrl &destination, QDropEvent *event) = 0;
 
     /// Copy (copy, move or link) files to the current filesystem directory or to "dir", the
     /// directory name relative to the current dir. May implemented async.
     virtual void addFiles(const QList<QUrl> &fileUrls, KIO::CopyJob::CopyMode mode,
                           const QString &dir = "") = 0;
     /// Create a new directory in the current directory. May implemented async.
     virtual void mkDir(const QString &name) = 0;
     /// Rename file/directory in the current directory. May implemented async.
     virtual void rename(const QString &fileName, const QString &newName) = 0;
 
     /// Return an absolute URL for a single file/directory name in the current directory - with no
     /// trailing slash.
     virtual QUrl getUrl(const QString &name) const = 0;
     /// Return a list of URLs for multiple files/directories in the current directory.
     QList<QUrl> getUrls(const QStringList &names) const;
     /// Return true if all files can be moved to trash, else false.
     virtual bool canMoveToTrash(const QStringList &fileNames) const = 0;
 
     /// Return the filesystem mount point of the current directory. Empty string by default.
     virtual QString mountPoint() const { return QString(); }
     /// Returns true if this filesystem implementation does not need to be notified about changes in the
     /// current directory. Else false.
     virtual bool hasAutoUpdate() const { return false; }
     /// Notify this filesystem that the filesystem info of the current directory may have changed.
     virtual void updateFilesystemInfo() {}
 
     /**
      * Scan all files and directories in a directory and create the file items for them. Blocking.
      *
      * @param directory if given, the lister tries to change to this directory, else the old
      * directory is refreshed
      * @return true if scan was successful, else (not implemented, scan failed or refresh job
      * was killed) false.
      */
     bool scanDir(const QUrl &directory = QUrl()) { return scanOrRefresh(directory, false); }
 
     /// Change or refresh the current directory and scan it. Blocking.
     /// Returns true if directory was scanned. Returns false if failed or scan job was killed.
     bool refresh(const QUrl &directory = QUrl()) { return scanOrRefresh(directory, false); }
 
     /// Returns the current directory path of this filesystem.
     inline QUrl currentDirectory() const { return _currentDirectory; }
     /// Return the file item for a file name in the current directory. Or 0 if not found.
     FileItem *getFileItem(const QString &name) const;
     /// The total size of all files in the current directory (only valid after scan).
     // TODO unused
     KIO::filesize_t totalSize() const;
     /// Return the filesystem type.
     inline FS_TYPE type() const { return _type; }
     /// Return true if the current directory is local (without recognizing mount points).
     inline bool isLocal() const { return _currentDirectory.isLocalFile(); }
     /// Return true if the current directory is a remote (network) location.
     inline bool isRemote() const {
         const QString sc = _currentDirectory.scheme();
         return (sc == "fish" || sc == "ftp" || sc == "sftp" || sc == "nfs" || sc == "smb"
                 || sc == "webdav");
     }
     /// Returns true if this filesystem is currently refreshing the current directory.
     inline bool isRefreshing() const { return _isRefreshing; }
 
     /// Delete or trash arbitrary files. Implemented async. Universal refresh not fully implemented.
     void deleteFiles(const QList<QUrl> &urls, bool moveToTrash);
 
     /// Return the input URL with a trailing slash if absent.
     static QUrl ensureTrailingSlash(const QUrl &url);
     /// Return the input URL without trailing slash.
     static QUrl cleanUrl(const QUrl &url) {
         return url.adjusted(QUrl::StripTrailingSlash);
     }
     /// Add 'file' scheme to non-empty URL without scheme
     static QUrl preferLocalUrl(const QUrl &url);
 
     /// Return a file item for a local file inside a directory
     static FileItem *createLocalFileItem(const QString &name, const QString &directory,
                                    bool virt = false);
     /// Return a file item for a KIO result. Returns 0 if entry is not needed
     static FileItem *createFileItemFromKIO(const KIO::UDSEntry &entry, const QUrl &directory,
                                      bool virt = false);
 
     /// Read a symlink with an extra precaution
     static QString readLinkSafely(const char *path);
 
     /// Set the parent window to be used for dialogs
     void setParentWindow(QWidget *widget) { parentWindow = widget; }
 
 signals:
     /// Emitted when this filesystem is currently refreshing the filesystem directory.
     void refreshJobStarted(KIO::Job *job);
     /// Emitted when an error occurred in this filesystem during refresh.
     void error(const QString &msg);
     /// Emitted when the content of a directory was changed by this filesystem.
     void fileSystemChanged(const QUrl &directory, bool removed);
     /// Emitted when the information for the filesystem of the current directory changed.
     /// Information is either
     /// * 'metaInfo': a displayable string about the fs, empty by default, OR
     /// * 'fsType', 'total' and 'free': filesystem type, size and free space,
     ///   empty string or 0 by default
     void fileSystemInfoChanged(const QString &metaInfo,  const QString &fsType,
                                KIO::filesize_t total, KIO::filesize_t free);
     /// Emitted before a directory path is opened for reading. Used for automounting.
     void aboutToOpenDir(const QString &path);
 
 protected:
     /// Fill the filesystem dictionary with file items, must be implemented for each filesystem.
     virtual bool refreshInternal(const QUrl &origin, bool stayInDir) = 0;
 
     /// Connect the result signal of a file operation job - source URLs.
-    void connectJobToSources(KJob *job, const QList<QUrl> urls);
+    void connectJobToSources(KJob *job, const QList<QUrl>& urls);
     /// Connect the result signal of a file operation job - destination URL.
     void connectJobToDestination(KJob *job, const QUrl &destination);
     /// Returns true if showing hidden files is set in config.
     bool showHiddenFiles();
     /// Add a new file item to the internal dictionary (while refreshing).
     void addFileItem(FileItem *item);
 
     FS_TYPE _type;          // the filesystem type.
     QUrl _currentDirectory; // the path or file the filesystem originates from.
     bool _isRefreshing;     // true if filesystem is busy with refreshing
     QPointer<QWidget> parentWindow;
 
 protected slots:
     /// Handle result after job (except when refreshing!) finished
     void slotJobResult(KJob *job, bool refresh);
 
 private:
     typedef QHash<QString, FileItem *> FileItemDict;
 
     // optional TODO: add an async version of this
     bool scanOrRefresh(const QUrl &directory, bool onlyScan);
 
     /// Delete and clear file items.
     void clear(FileItemDict &fileItems);
 
     FileItemDict _fileItems;  // the list of files in the current dictionary
 };
 
 #endif
diff --git a/krusader/FileSystem/filesystemprovider.cpp b/krusader/FileSystem/filesystemprovider.cpp
index e824f765..ac5b960e 100644
--- a/krusader/FileSystem/filesystemprovider.cpp
+++ b/krusader/FileSystem/filesystemprovider.cpp
@@ -1,220 +1,220 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2003 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "filesystemprovider.h"
 
 #ifdef HAVE_POSIX_ACL
 #include <sys/acl.h>
 #ifdef HAVE_NON_POSIX_ACL_EXTENSIONS
 #include <acl/libacl.h>
 #endif
 #endif
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 
 #include <KIOCore/KMountPoint>
 
 #include "defaultfilesystem.h"
 #include "fileitem.h"
 #include "virtualfilesystem.h"
 #include "../krservices.h"
 #include "../JobMan/jobman.h"
 
 
-FileSystemProvider::FileSystemProvider() : _defaultFileSystem(0), _virtFileSystem(0) {}
+FileSystemProvider::FileSystemProvider() : _defaultFileSystem(nullptr), _virtFileSystem(nullptr) {}
 
 FileSystem *FileSystemProvider::getFilesystem(const QUrl &url, FileSystem *oldFilesystem)
 {
     const FileSystem::FS_TYPE type = getFilesystemType(url);
     return oldFilesystem && oldFilesystem->type() == type ? oldFilesystem : createFilesystem(type);
 }
 
 void FileSystemProvider::startCopyFiles(const QList<QUrl> &urls, const QUrl &destination,
                                   KIO::CopyJob::CopyMode mode, bool showProgressInfo,
                                   JobMan::StartMode startMode)
 {
     FileSystem *fs = getFilesystemInstance(destination);
     fs->copyFiles(urls, destination, mode, showProgressInfo, startMode);
 }
 
 void FileSystemProvider::startDropFiles(QDropEvent *event, const QUrl &destination)
 {
     FileSystem *fs = getFilesystemInstance(destination);
     fs->dropFiles(destination, event);
 }
 
 void FileSystemProvider::startDeleteFiles(const QList<QUrl> &urls, bool moveToTrash)
 {
     if (urls.isEmpty())
         return;
 
     // assume all URLs use the same filesystem
     FileSystem *fs = getFilesystemInstance(urls.first());
     fs->deleteFiles(urls, moveToTrash);
 }
 
 void FileSystemProvider::refreshFilesystems(const QUrl &directory, bool removed)
 {
     qDebug() << "changed=" << directory.toDisplayString();
 
     QMutableListIterator<QPointer<FileSystem>> it(_fileSystems);
     while (it.hasNext()) {
         if (it.next().isNull()) {
             it.remove();
         }
     }
 
     QString mountPoint = "";
     if (directory.isLocalFile()) {
         KMountPoint::Ptr kMountPoint = KMountPoint::currentMountPoints().findByPath(directory.path());
         if (kMountPoint)
             mountPoint = kMountPoint->mountPoint();
     }
 
-    for(QPointer<FileSystem> fileSystemPointer: _fileSystems) {
+    for(const QPointer<FileSystem>& fileSystemPointer: _fileSystems) {
         FileSystem *fs = fileSystemPointer.data();
         // refresh all filesystems currently showing this directory
         // and always refresh filesystems showing a virtual directory; it can contain files from
         // various places, we don't know if they were (re)moved. Refreshing is also fast enough.
         const QUrl fileSystemDir = fs->currentDirectory();
         if ((!fs->hasAutoUpdate() && (fileSystemDir == FileSystem::cleanUrl(directory) ||
                                       (fs->type() == FileSystem::FS_VIRTUAL && !fs->isRoot())))
             // also refresh if a parent directory was (re)moved (not detected by file watcher)
             || (removed && directory.isParentOf(fileSystemDir))) {
             fs->refresh();
             // ..or refresh filesystem info if mount point is the same (for free space update)
         } else if (!mountPoint.isEmpty() && mountPoint == fs->mountPoint()) {
             fs->updateFilesystemInfo();
         }
     }
 }
 
 FileSystem *FileSystemProvider::getFilesystemInstance(const QUrl &directory)
 {
     const FileSystem::FS_TYPE type = getFilesystemType(directory);
     switch (type) {
     case FileSystem::FS_VIRTUAL:
         if (!_virtFileSystem)
             _virtFileSystem = createFilesystem(type);
         return _virtFileSystem;
         break;
     default:
         if (!_defaultFileSystem)
             _defaultFileSystem = createFilesystem(type);
         return _defaultFileSystem;
     }
 }
 
 FileSystem *FileSystemProvider::createFilesystem(FileSystem::FS_TYPE type)
 {
     FileSystem *newFilesystem;
     switch (type) {
     case (FileSystem::FS_VIRTUAL): newFilesystem = new VirtualFileSystem(); break;
     default: newFilesystem = new DefaultFileSystem();
     }
 
     QPointer<FileSystem> fileSystemPointer(newFilesystem);
     _fileSystems.append(fileSystemPointer);
     connect(newFilesystem, &FileSystem::fileSystemChanged, this, &FileSystemProvider::refreshFilesystems);
     return newFilesystem;
 }
 
 // ==== static ====
 
 FileSystemProvider &FileSystemProvider::instance()
 {
     static FileSystemProvider instance;
     return instance;
 }
 
 FileSystem::FS_TYPE FileSystemProvider::getFilesystemType(const QUrl &url)
 {
     return url.scheme() == QStringLiteral("virt") ? FileSystem::FS_VIRTUAL : FileSystem::FS_DEFAULT;
 }
 
 void FileSystemProvider::getACL(FileItem *file, QString &acl, QString &defAcl)
 {
     Q_UNUSED(file);
     acl.clear();
     defAcl.clear();
 #ifdef HAVE_POSIX_ACL
     QString fileName = FileSystem::cleanUrl(file->getUrl()).path();
 #ifdef HAVE_NON_POSIX_ACL_EXTENSIONS
     if (acl_extended_file(fileName)) {
 #endif
         acl = getACL(fileName, ACL_TYPE_ACCESS);
         if (file->isDir())
             defAcl = getACL(fileName, ACL_TYPE_DEFAULT);
 #ifdef HAVE_NON_POSIX_ACL_EXTENSIONS
     }
 #endif
 #endif
 }
 
 QString FileSystemProvider::getACL(const QString & path, int type)
 {
     Q_UNUSED(path);
     Q_UNUSED(type);
 #ifdef HAVE_POSIX_ACL
-    acl_t acl = 0;
+    acl_t acl = nullptr;
     // do we have an acl for the file, and/or a default acl for the dir, if it is one?
-    if ((acl = acl_get_file(path.toLocal8Bit(), type)) != 0) {
+    if ((acl = acl_get_file(path.toLocal8Bit(), type)) != nullptr) {
         bool aclExtended = false;
 
 #ifdef HAVE_NON_POSIX_ACL_EXTENSIONS
         aclExtended = acl_equiv_mode(acl, 0);
 #else
         acl_entry_t entry;
         int ret = acl_get_entry(acl, ACL_FIRST_ENTRY, &entry);
         while (ret == 1) {
             acl_tag_t currentTag;
             acl_get_tag_type(entry, &currentTag);
             if (currentTag != ACL_USER_OBJ &&
                     currentTag != ACL_GROUP_OBJ &&
                     currentTag != ACL_OTHER) {
                 aclExtended = true;
                 break;
             }
             ret = acl_get_entry(acl, ACL_NEXT_ENTRY, &entry);
         }
 #endif
 
         if (!aclExtended) {
             acl_free(acl);
-            acl = 0;
+            acl = nullptr;
         }
     }
 
-    if (acl == 0)
+    if (acl == nullptr)
         return QString();
 
-    char *aclString = acl_to_text(acl, 0);
+    char *aclString = acl_to_text(acl, nullptr);
     QString ret = QString::fromLatin1(aclString);
     acl_free((void*)aclString);
     acl_free(acl);
 
     return ret;
 #else
     return QString();
 #endif
 }
diff --git a/krusader/FileSystem/filesystemprovider.h b/krusader/FileSystem/filesystemprovider.h
index 237bfd4a..834e0d90 100644
--- a/krusader/FileSystem/filesystemprovider.h
+++ b/krusader/FileSystem/filesystemprovider.h
@@ -1,106 +1,106 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2003 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef FILESYSTEMPROVIDER_H
 #define FILESYSTEMPROVIDER_H
 
 // QtCore
 #include <QObject>
 #include <QUrl>
 
 #include <KIO/Job>
 
 #include "filesystem.h"
 
 /**
  * @brief Provider for virtual file systems.
  *
  * This is a singleton.
  */
 class FileSystemProvider : public QObject {
     Q_OBJECT
 
 public:
     /**
      * Get a filesystem implementation for the filesystem target specified by URL. oldFilesystem is returned if
      * the filesystem did not change.
      *
      * The filesystem instances returned by this method are already connected with this handler and will
      * notify each other about filesystem changes.
      */
-    FileSystem *getFilesystem(const QUrl &url, FileSystem *oldFilesystem = 0);
+    FileSystem *getFilesystem(const QUrl &url, FileSystem *oldFilesystem = nullptr);
 
     /**
      * Start a copy job for copying, moving or linking files to a destination directory.
      * Operation may be implemented async depending on destination filesystem.
      */
     void startCopyFiles(const QList<QUrl> &urls, const QUrl &destination,
                         KIO::CopyJob::CopyMode mode = KIO::CopyJob::Copy,
                         bool showProgressInfo = true,
                         JobMan::StartMode startMode = JobMan::Default);
 
     /**
      * Handle file dropping. Starts a copy job for copying, moving or linking files to a destination
      * directory after user choose the action in a context menu.
      *
      * Operation may implemented async depending on destination filesystem.
      */
     void startDropFiles(QDropEvent *event, const QUrl &destination);
 
     /**
      * Start a delete job for trashing or deleting files.
      *
      * Operation implemented async.
      */
     void startDeleteFiles(const QList<QUrl> &urls, bool moveToTrash = true);
 
     static FileSystemProvider &instance();
     static FileSystem::FS_TYPE getFilesystemType(const QUrl &url);
     /** Get ACL permissions for a file */
     static void getACL(FileItem *file, QString &acl, QString &defAcl);
 
 public slots:
     /**
      * Notify filesystems if they are affected by changes made by another filesystem.
      *
      * Only works if filesystem is connected to this provider.
      *
      * @param directory the directory that was changed (deleted, moved, content changed,...)
      * @param removed whether the directory was removed
      */
     void refreshFilesystems(const QUrl &directory, bool removed);
 
 private:
     FileSystem *getFilesystemInstance(const QUrl &directory);
     FileSystem *createFilesystem(const FileSystem::FS_TYPE type);
     FileSystemProvider();
 
     // filesystem instances for directory independent file operations, lazy initialized
     FileSystem *_defaultFileSystem;
     FileSystem *_virtFileSystem;
 
     QList<QPointer<FileSystem>> _fileSystems;
 
     static QString getACL(const QString & path, int type);
 };
 
 #endif
 
diff --git a/krusader/FileSystem/krpermhandler.cpp b/krusader/FileSystem/krpermhandler.cpp
index 644b3bb5..8da41535 100644
--- a/krusader/FileSystem/krpermhandler.cpp
+++ b/krusader/FileSystem/krpermhandler.cpp
@@ -1,179 +1,179 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krpermhandler.h"
 
 // QtCore
 #include <QLocale>
 
 #include <grp.h>
 #include <pwd.h>
 #include <sys/stat.h>
 
 QSet<int> KRpermHandler::currentGroups;
 QHash<int, QString> KRpermHandler::uidCache;
 QHash<int, QString> KRpermHandler::gidCache;
 
 QString KRpermHandler::mode2QString(mode_t m)
 {
     char perm[ 11 ];
     for (int i = 0; i != 10; i++)
         perm[ i ] = '-';
     perm[ 10 ] = 0;
 
     if (S_ISLNK(m)) perm[ 0 ] = 'l';      // check for symLink
     if (S_ISDIR(m)) perm[ 0 ] = 'd';      // check for directory
 
     //ReadUser = 0400, WriteUser = 0200, ExeUser = 0100, Suid = 04000
     if (m & 0400) perm[ 1 ] = 'r';
     if (m & 0200) perm[ 2 ] = 'w';
     if (m & 0100) perm[ 3 ] = 'x';
     if (m & 04000) perm[ 3 ] = 's';
     //ReadGroup = 0040, WriteGroup = 0020, ExeGroup = 0010, Gid = 02000
     if (m & 0040) perm[ 4 ] = 'r';
     if (m & 0020) perm[ 5 ] = 'w';
     if (m & 0010) perm[ 6 ] = 'x';
     if (m & 02000) perm[ 6 ] = 's';
     //ReadOther = 0004, WriteOther = 0002, ExeOther = 0001, Sticky = 01000
     if (m & 0004) perm[ 7 ] = 'r';
     if (m & 0002) perm[ 8 ] = 'w';
     if (m & 0001) perm[ 9 ] = 'x';
     if (m & 01000) perm[ 9 ] = 't';
 
     return QString(perm);
 }
 
 void KRpermHandler::init()
 {
     // set the umask to 022
     //umask( 022 );
 
     // 200 groups should be enough
     gid_t groupList[200];
     int groupNo = getgroups(200, groupList);
 
 // In kdewin32 implementation as of 4.1.2, getpwent always returns the same struct
 #ifndef Q_WS_WIN
     // fill the UID cache
     struct passwd *pass;
-    while ((pass = getpwent()) != 0L) {
+    while ((pass = getpwent()) != nullptr) {
         uidCache.insert(pass->pw_uid, pass->pw_name);
     }
     delete pass;
     endpwent();
 
     // fill the GID cache
     struct group *gr;
-    while ((gr = getgrent()) != 0L) {
+    while ((gr = getgrent()) != nullptr) {
         gidCache.insert(gr->gr_gid, QString(gr->gr_name));
     }
     delete gr;
     endgrent();
 #endif
 
     // fill the groups for the current user
     for (int i = 0; i < groupNo; ++i) {
         currentGroups.insert(groupList[i]);
     }
     // just to be sure add the effective gid...
     currentGroups.insert(getegid());
 }
 
 char KRpermHandler::readable(const QString &perm, gid_t gid, uid_t uid)
 {
     return getLocalPermission(perm, gid, uid, 0);
 }
 
 char KRpermHandler::writeable(const QString &perm, gid_t gid, uid_t uid)
 {
     return getLocalPermission(perm, gid, uid, 1);
 }
 
 char KRpermHandler::executable(const QString &perm, gid_t gid, uid_t uid)
 {
     return getLocalPermission(perm, gid, uid, 2, true);
 }
 
 char KRpermHandler::getLocalPermission(const QString &perm, gid_t gid, uid_t uid, int permOffset,
                                        bool ignoreRoot)
 {
     // root override
     if (!ignoreRoot && getuid() == 0)
         return ALLOWED_PERM;
     // first check other permissions.
     if (perm[7 + permOffset] != '-')
         return ALLOWED_PERM;
     // now check group permission
     if ((perm[4 + permOffset] != '-') && currentGroups.contains(gid))
         return ALLOWED_PERM;
     // the last chance - user permissions
     if ((perm[1 + permOffset] != '-') && (uid == getuid()))
         return ALLOWED_PERM;
     // sorry !
     return NO_PERM;
 }
 
 char KRpermHandler::ftpReadable(const QString &fileOwner, const QString &userName, const QString &perm)
 {
     return getFtpPermission(fileOwner, userName, perm, 0);
 }
 
 char KRpermHandler::ftpWriteable(const QString &fileOwner, const QString &userName, const QString &perm)
 {
     return getFtpPermission(fileOwner, userName, perm, 1);
 }
 
 char KRpermHandler::ftpExecutable(const QString &fileOwner, const QString &userName, const QString &perm)
 {
     return getFtpPermission(fileOwner, userName, perm, 2);
 }
 
 char KRpermHandler::getFtpPermission(const QString &fileOwner, const QString &userName,
                                      const QString &perm, int permOffset)
 {
     // first check other permissions.
     if (perm[7 + permOffset] != '-')
         return ALLOWED_PERM;
     // can't check group permission !
     // so check the user permissions
     if ((perm[1 + permOffset] != '-') && (fileOwner == userName))
         return ALLOWED_PERM;
     if ((perm[1 + permOffset] != '-') && (userName.isEmpty()))
         return UNKNOWN_PERM;
     if (perm[4 + permOffset] != '-')
         return UNKNOWN_PERM;
     return NO_PERM;
 }
 
 QString KRpermHandler::parseSize(KIO::filesize_t val)
 {
     return QLocale().toString(val);
 }
 
 QString KRpermHandler::gid2group(gid_t groupId)
 {
    return gidCache.value(groupId, QStringLiteral("???"));
 }
 
 QString KRpermHandler::uid2user(uid_t userId)
 {
     return uidCache.value(userId, QStringLiteral("???"));
 }
diff --git a/krusader/FileSystem/krquery.cpp b/krusader/FileSystem/krquery.cpp
index 2a6ceb53..7c3374e4 100644
--- a/krusader/FileSystem/krquery.cpp
+++ b/krusader/FileSystem/krquery.cpp
@@ -1,777 +1,778 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krquery.h"
 
 // QtCore
 #include <QFile>
 #include <QMetaMethod>
 #include <QRegExp>
 #include <QTextCodec>
 
 #include <KI18n/KLocalizedString>
 #include <KIO/Job>
 #include <KIOCore/KFileItem>
 #include <KIOWidgets/KUrlCompletion>
+#include <utility>
 
 #include "../Archive/krarchandler.h"
 #include "fileitem.h"
 #include "filesystem.h"
 #include "krpermhandler.h"
 
 #define STATUS_SEND_DELAY 250
 #define MAX_LINE_LEN 1000
 
 // set the defaults
 KRQuery::KRQuery()
-    : QObject(), matchesCaseSensitive(true), bNull(true), contain(QString()),
+    : matchesCaseSensitive(true), bNull(true), contain(QString()),
       containCaseSensetive(true), containWholeWord(false), containRegExp(false), minSize(0),
       maxSize(0), newerThen(0), olderThen(0), owner(QString()), group(QString()), perm(QString()),
-      type(QString()), inArchive(false), recurse(true), followLinksP(true), receivedBuffer(0),
+      type(QString()), inArchive(false), recurse(true), followLinksP(true), receivedBuffer(nullptr),
       receivedBufferLen(0), processEventsConnected(0), codec(QTextCodec::codecForLocale())
 {
     QChar ch = '\n';
     QTextCodec::ConverterState state(QTextCodec::IgnoreHeader);
     encodedEnterArray = codec->fromUnicode(&ch, 1, &state);
     encodedEnter = encodedEnterArray.data();
     encodedEnterLen = encodedEnterArray.size();
 }
 
 // set the defaults
 KRQuery::KRQuery(const QString &name, bool matchCase)
-    : QObject(), bNull(true), contain(QString()), containCaseSensetive(true),
+    : bNull(true), contain(QString()), containCaseSensetive(true),
       containWholeWord(false), containRegExp(false), minSize(0), maxSize(0), newerThen(0),
       olderThen(0), owner(QString()), group(QString()), perm(QString()), type(QString()),
-      inArchive(false), recurse(true), followLinksP(true), receivedBuffer(0), receivedBufferLen(0),
+      inArchive(false), recurse(true), followLinksP(true), receivedBuffer(nullptr), receivedBufferLen(0),
       processEventsConnected(0), codec(QTextCodec::codecForLocale())
 {
     QChar ch = '\n';
     QTextCodec::ConverterState state(QTextCodec::IgnoreHeader);
     encodedEnterArray = codec->fromUnicode(&ch, 1, &state);
     encodedEnter = encodedEnterArray.data();
     encodedEnterLen = encodedEnterArray.size();
 
     setNameFilter(name, matchCase);
 }
 
 KRQuery::KRQuery(const KRQuery &that)
-    : QObject(), receivedBuffer(0), receivedBufferLen(0), processEventsConnected(0)
+    : QObject(), receivedBuffer(nullptr), receivedBufferLen(0), processEventsConnected(0)
 {
     *this = that;
 }
 
 KRQuery::~KRQuery()
 {
     if (receivedBuffer)
         delete[] receivedBuffer;
-    receivedBuffer = 0;
+    receivedBuffer = nullptr;
 }
 
 KRQuery &KRQuery::operator=(const KRQuery &old)
 {
     matches = old.matches;
     excludes = old.excludes;
     includedDirs = old.includedDirs;
     excludedDirs = old.excludedDirs;
     matchesCaseSensitive = old.matchesCaseSensitive;
     bNull = old.bNull;
     contain = old.contain;
     containCaseSensetive = old.containCaseSensetive;
     containWholeWord = old.containWholeWord;
     containRegExp = old.containRegExp;
     minSize = old.minSize;
     maxSize = old.maxSize;
     newerThen = old.newerThen;
     olderThen = old.olderThen;
     owner = old.owner;
     group = old.group;
     perm = old.perm;
     type = old.type;
     customType = old.customType;
     inArchive = old.inArchive;
     recurse = old.recurse;
     followLinksP = old.followLinksP;
     whereToSearch = old.whereToSearch;
     excludedFolderNames = old.excludedFolderNames;
     whereNotToSearch = old.whereNotToSearch;
     origFilter = old.origFilter;
 
     codec = old.codec;
 
     encodedEnterArray = old.encodedEnterArray;
     encodedEnter = encodedEnterArray.data();
     encodedEnterLen = encodedEnterArray.size();
 
     return *this;
 }
 
-void KRQuery::load(KConfigGroup cfg)
+void KRQuery::load(const KConfigGroup& cfg)
 {
     *this = KRQuery(); // reset parameters first
 
     if (cfg.readEntry("IsNull", true))
         return;
 
 #define LOAD(key, var) (var = cfg.readEntry(key, var))
     LOAD("Matches", matches);
     LOAD("Excludes", excludes);
     LOAD("IncludedDirs", includedDirs);
     LOAD("ExcludedDirs", excludedDirs);
     LOAD("MatchesCaseSensitive", matchesCaseSensitive);
     LOAD("Contain", contain);
     LOAD("ContainCaseSensetive", containCaseSensetive);
     LOAD("ContainWholeWord", containWholeWord);
     LOAD("ContainRegExp", containRegExp);
     LOAD("MinSize", minSize);
     LOAD("MaxSize", maxSize);
     newerThen = QDateTime::fromString(
                     cfg.readEntry("NewerThan", QDateTime::fromTime_t(newerThen).toString()))
                     .toTime_t();
     olderThen = QDateTime::fromString(
                     cfg.readEntry("OlderThan", QDateTime::fromTime_t(olderThen).toString()))
                     .toTime_t();
     LOAD("Owner", owner);
     LOAD("Group", group);
     LOAD("Perm", perm);
     LOAD("Type", type);
     LOAD("CustomType", customType);
     LOAD("InArchive", inArchive);
     LOAD("Recurse", recurse);
     LOAD("FollowLinks", followLinksP);
     // KF5 TODO?
     // LOAD("WhereToSearch", whereToSearch);
     // LOAD("WhereNotToSearch", whereNotToSearch);
     LOAD("OrigFilter", origFilter);
 
     codec = QTextCodec::codecForName(cfg.readEntry("Codec", codec->name()));
     if (!codec)
         codec = QTextCodec::codecForLocale();
 
     LOAD("EncodedEnterArray", encodedEnterArray);
     encodedEnter = encodedEnterArray.data();
     encodedEnterLen = encodedEnterArray.size();
 #undef LOAD
 
     bNull = false;
 }
 
 void KRQuery::save(KConfigGroup cfg)
 {
     cfg.writeEntry("IsNull", bNull);
 
     if (bNull)
         return;
 
     cfg.writeEntry("Matches", matches);
     cfg.writeEntry("Excludes", excludes);
     cfg.writeEntry("IncludedDirs", includedDirs);
     cfg.writeEntry("ExcludedDirs", excludedDirs);
     cfg.writeEntry("MatchesCaseSensitive", matchesCaseSensitive);
     cfg.writeEntry("Contain", contain);
     cfg.writeEntry("ContainCaseSensetive", containCaseSensetive);
     cfg.writeEntry("ContainWholeWord", containWholeWord);
     cfg.writeEntry("ContainRegExp", containRegExp);
     cfg.writeEntry("MinSize", minSize);
     cfg.writeEntry("MaxSize", maxSize);
     cfg.writeEntry("NewerThan", QDateTime::fromTime_t(newerThen).toString());
     cfg.writeEntry("OlderThan", QDateTime::fromTime_t(olderThen).toString());
     cfg.writeEntry("Owner", owner);
     cfg.writeEntry("Group", group);
     cfg.writeEntry("Perm", perm);
     cfg.writeEntry("Type", type);
     cfg.writeEntry("CustomType", customType);
     cfg.writeEntry("InArchive", inArchive);
     cfg.writeEntry("Recurse", recurse);
     cfg.writeEntry("FollowLinks", followLinksP);
     // KF5 TODO?
     // cfg.writeEntry("WhereToSearch", whereToSearch);
     // cfg.writeEntry("WhereNotToSearch", whereNotToSearch);
     cfg.writeEntry("OrigFilter", origFilter);
 
     cfg.writeEntry("Codec", codec->name());
     cfg.writeEntry("EncodedEnterArray", encodedEnterArray);
     cfg.writeEntry("EncodedEnter", encodedEnter);
     cfg.writeEntry("EncodedEnterLen", encodedEnterLen);
 }
 
 void KRQuery::connectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&KRQuery::processEvents))
         processEventsConnected++;
 }
 
 void KRQuery::disconnectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&KRQuery::processEvents))
         processEventsConnected--;
 }
 
 bool KRQuery::checkPerm(QString filePerm) const
 {
     for (int i = 0; i < 9; ++i)
         if (perm[i] != '?' && perm[i] != filePerm[i + 1])
             return false;
     return true;
 }
 
-bool KRQuery::checkType(QString mime) const
+bool KRQuery::checkType(const QString& mime) const
 {
     if (type == mime)
         return true;
     if (type == i18n("Archives"))
         return KRarcHandler::arcSupported(mime);
     if (type == i18n("Folders"))
         return mime.contains("directory");
     if (type == i18n("Image Files"))
         return mime.contains("image/");
     if (type == i18n("Text Files"))
         return mime.contains("text/");
     if (type == i18n("Video Files"))
         return mime.contains("video/");
     if (type == i18n("Audio Files"))
         return mime.contains("audio/");
     if (type == i18n("Custom"))
         return customType.contains(mime);
     return false;
 }
 
 bool KRQuery::match(const QString &name) const { return matchCommon(name, matches, excludes); }
 
 bool KRQuery::matchDirName(const QString &name) const
 {
     return matchCommon(name, includedDirs, excludedDirs);
 }
 
 bool KRQuery::matchCommon(const QString &nameIn, const QStringList &matchList,
                           const QStringList &excludeList) const
 {
     if (excludeList.count() == 0 && matchList.count() == 0) /* true if there's no match condition */
         return true;
 
     QString name(nameIn);
     int ndx = nameIn.lastIndexOf('/'); // virtual filenames may contain '/'
     if (ndx != -1)                     // but the end of the filename is OK
         name = nameIn.mid(ndx + 1);
 
     for (int i = 0; i < excludeList.count(); ++i) {
         if (QRegExp(excludeList[i], matchesCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive,
                     QRegExp::Wildcard)
                 .exactMatch(name))
             return false;
     }
 
     if (matchList.count() == 0)
         return true;
 
     for (int i = 0; i < matchList.count(); ++i) {
         if (QRegExp(matchList[i], matchesCaseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive,
                     QRegExp::Wildcard)
                 .exactMatch(name))
             return true;
     }
     return false;
 }
 
 bool KRQuery::match(FileItem *item) const
 {
     if (item->isDir() && !matchDirName(item->getName()))
         return false;
     // see if the name matches
     if (!match(item->getName()))
         return false;
     // checking the mime
     if (!type.isEmpty() && !checkType(item->getMime()))
         return false;
     // check that the size fit
     KIO::filesize_t size = item->getSize();
     if (minSize && size < minSize)
         return false;
     if (maxSize && size > maxSize)
         return false;
     // check the time frame
     time_t mtime = item->getTime_t();
     if (olderThen && mtime > olderThen)
         return false;
     if (newerThen && mtime < newerThen)
         return false;
     // check owner name
     if (!owner.isEmpty() && item->getOwner() != owner)
         return false;
     // check group name
     if (!group.isEmpty() && item->getGroup() != group)
         return false;
     // check permission
     if (!perm.isEmpty() && !checkPerm(item->getPerm()))
         return false;
 
     if (!contain.isEmpty()) {
         if ((totalBytes = item->getSize()) == 0)
             totalBytes++; // sanity
         receivedBytes = 0;
         if (receivedBuffer)
             delete receivedBuffer;
-        receivedBuffer = 0;
+        receivedBuffer = nullptr;
         receivedBufferLen = 0;
         fileName = item->getName();
         timer.start();
 
         // search locally
         if (item->getUrl().isLocalFile()) {
             return containsContent(item->getUrl().path());
         }
 
         // search remotely
         if (processEventsConnected == 0) {
             return false;
         }
         return containsContent(item->getUrl());
     }
 
     return true;
 }
 
 // takes the string and adds BOLD to it, so that when it is displayed,
 // the grepped text will be bold
 void fixFoundTextForDisplay(QString &haystack, int start, int length)
 {
     QString before = haystack.left(start);
     QString text = haystack.mid(start, length);
     QString after = haystack.mid(start + length);
 
     before.replace('&', "&amp;");
     before.replace('<', "&lt;");
     before.replace('>', "&gt;");
 
     text.replace('&', "&amp;");
     text.replace('<', "&lt;");
     text.replace('>', "&gt;");
 
     after.replace('&', "&amp;");
     after.replace('<', "&lt;");
     after.replace('>', "&gt;");
 
     haystack = ("<qt>" + before + "<b>" + text + "</b>" + after + "</qt>");
 }
 
 bool KRQuery::checkBuffer(const char *data, int len) const
 {
     bool result = false;
 
-    char *mergedBuffer = new char[len + receivedBufferLen];
+    auto *mergedBuffer = new char[len + receivedBufferLen];
     if (receivedBufferLen)
         memcpy(mergedBuffer, receivedBuffer, receivedBufferLen);
     if (len)
         memcpy(mergedBuffer + receivedBufferLen, data, len);
 
     int maxLen = len + receivedBufferLen;
     int maxBuffer = maxLen - encodedEnterLen;
     int lastLinePosition = 0;
 
     for (int enterIndex = 0; enterIndex < maxBuffer; enterIndex++) {
         if (memcmp(mergedBuffer + enterIndex, encodedEnter, encodedEnterLen) == 0) {
             QString str = codec->toUnicode(mergedBuffer + lastLinePosition,
                                            enterIndex + encodedEnterLen - lastLinePosition);
             if (str.endsWith('\n')) {
                 str.chop(1);
                 result = result || checkLine(str);
                 lastLinePosition = enterIndex + encodedEnterLen;
                 enterIndex = lastLinePosition;
                 continue;
             }
         }
     }
 
     if (maxLen - lastLinePosition > MAX_LINE_LEN || len == 0) {
         QString str = codec->toUnicode(mergedBuffer + lastLinePosition, maxLen - lastLinePosition);
         result = result || checkLine(str);
         lastLinePosition = maxLen;
     }
 
     delete[] receivedBuffer;
-    receivedBuffer = 0;
+    receivedBuffer = nullptr;
     receivedBufferLen = maxLen - lastLinePosition;
 
     if (receivedBufferLen) {
         receivedBuffer = new char[receivedBufferLen];
         memcpy(receivedBuffer, mergedBuffer + lastLinePosition, receivedBufferLen);
     }
 
     delete[] mergedBuffer;
     return result;
 }
 
 bool KRQuery::checkLine(const QString &line, bool backwards) const
 {
     if (containRegExp) {
         QRegExp rexp(contain, containCaseSensetive ? Qt::CaseSensitive : Qt::CaseInsensitive,
                      QRegExp::RegExp);
         int ndx = backwards ? rexp.lastIndexIn(line) : rexp.indexIn(line);
         bool result = ndx >= 0;
         if (result)
             fixFoundTextForDisplay(lastSuccessfulGrep = line, lastSuccessfulGrepMatchIndex = ndx,
                                    lastSuccessfulGrepMatchLength = rexp.matchedLength());
         return result;
     }
 
     int ndx = backwards ? -1 : 0;
 
     if (line.isNull())
         return false;
     if (containWholeWord) {
         while ((ndx = (backwards) ?
                           line.lastIndexOf(contain, ndx,
                                            containCaseSensetive ? Qt::CaseSensitive :
                                                                   Qt::CaseInsensitive) :
                           line.indexOf(contain, ndx,
                                        containCaseSensetive ? Qt::CaseSensitive :
                                                               Qt::CaseInsensitive)) != -1) {
             QChar before = '\n';
             QChar after = '\n';
 
             if (ndx > 0)
                 before = line.at(ndx - 1);
             if (ndx + contain.length() < line.length())
                 after = line.at(ndx + contain.length());
 
             if (!before.isLetterOrNumber() && !after.isLetterOrNumber() && after != '_' &&
                 before != '_') {
                 lastSuccessfulGrep = line;
                 fixFoundTextForDisplay(lastSuccessfulGrep, lastSuccessfulGrepMatchIndex = ndx,
                                        lastSuccessfulGrepMatchLength = contain.length());
                 return true;
             }
 
             if (backwards)
                 ndx -= line.length() + 1;
             else
                 ndx++;
         }
     } else if ((ndx = (backwards) ?
                           line.lastIndexOf(contain, -1,
                                            containCaseSensetive ? Qt::CaseSensitive :
                                                                   Qt::CaseInsensitive) :
                           line.indexOf(contain, 0,
                                        containCaseSensetive ? Qt::CaseSensitive :
                                                               Qt::CaseInsensitive)) != -1) {
         lastSuccessfulGrep = line;
         fixFoundTextForDisplay(lastSuccessfulGrep, lastSuccessfulGrepMatchIndex = ndx,
                                lastSuccessfulGrepMatchLength = contain.length());
         return true;
     }
     return false;
 }
 
-bool KRQuery::containsContent(QString file) const
+bool KRQuery::containsContent(const QString& file) const
 {
     QFile qf(file);
     if (!qf.open(QIODevice::ReadOnly))
         return false;
 
     char buffer[1440]; // 2k buffer
 
     while (!qf.atEnd()) {
         int bytes = qf.read(buffer, sizeof(buffer));
         if (bytes <= 0)
             break;
 
         receivedBytes += bytes;
 
         if (checkBuffer(buffer, bytes))
             return true;
 
         if (checkTimer()) {
             bool stopped = false;
             emit((KRQuery *)this)->processEvents(stopped);
             if (stopped)
                 return false;
         }
     }
     if (checkBuffer(buffer, 0))
         return true;
 
     lastSuccessfulGrep.clear(); // nothing was found
     return false;
 }
 
-bool KRQuery::containsContent(QUrl url) const
+bool KRQuery::containsContent(const QUrl& url) const
 {
     KIO::TransferJob *contentReader = KIO::get(url, KIO::NoReload, KIO::HideProgressInfo);
     connect(contentReader, &KIO::TransferJob::data, this, &KRQuery::containsContentData);
     connect(contentReader, &KIO::Job::result, this, &KRQuery::containsContentFinished);
 
     busy = true;
     containsContentResult = false;
     bool stopped = false;
 
     while (busy && !stopped) {
         checkTimer();
         emit((KRQuery *)this)->processEvents(stopped);
     }
 
     if (busy) {
         contentReader->kill(KJob::EmitResult);
         busy = false;
     }
 
     return containsContentResult;
 }
 
 void KRQuery::containsContentData(KIO::Job *job, const QByteArray &array)
 {
     receivedBytes += array.size();
     if (checkBuffer(array.data(), array.size())) {
         containsContentResult = true;
         containsContentFinished(job);
         job->kill(KJob::EmitResult);
         return;
     }
     checkTimer();
 }
 
 void KRQuery::containsContentFinished(KJob *) { busy = false; }
 
 bool KRQuery::checkTimer() const
 {
     if (timer.elapsed() >= STATUS_SEND_DELAY) {
-        int pcnt = (int)(100. * (double)receivedBytes / (double)totalBytes + .5);
+        auto pcnt = (int)(100. * (double)receivedBytes / (double)totalBytes + .5);
         QString message =
             i18nc("%1=filename, %2=percentage", "Searching content of '%1' (%2%)", fileName, pcnt);
         timer.start();
         emit((KRQuery *)this)->status(message);
         return true;
     }
     return false;
 }
 
 QStringList KRQuery::split(QString str)
 {
     QStringList list;
     int splitNdx = 0;
     int startNdx = 0;
     bool quotation = false;
 
     while (splitNdx < str.length()) {
         if (str[splitNdx] == '"')
             quotation = !quotation;
 
         if (!quotation && str[splitNdx] == ' ') {
             QString section = str.mid(startNdx, splitNdx - startNdx);
             startNdx = splitNdx + 1;
             if (section.startsWith('\"') && section.endsWith('\"') && section.length() >= 2)
                 section = section.mid(1, section.length() - 2);
             if (!section.isEmpty())
                 list.append(section);
         }
         splitNdx++;
     }
 
     if (startNdx < splitNdx) {
         QString section = str.mid(startNdx, splitNdx - startNdx);
         if (section.startsWith('\"') && section.endsWith('\"') && section.length() >= 2)
             section = section.mid(1, section.length() - 2);
         if (!section.isEmpty())
             list.append(section);
     }
 
     return list;
 }
 
 void KRQuery::setNameFilter(const QString &text, bool cs)
 {
     bNull = false;
     matchesCaseSensitive = cs;
     origFilter = text;
 
     QString matchText = text;
     QString excludeText;
 
     int excludeNdx = 0;
     bool quotationMark = 0;
     while (excludeNdx < matchText.length()) {
         if (matchText[excludeNdx] == '"')
             quotationMark = !quotationMark;
         if (!quotationMark) {
             if (matchText[excludeNdx] == '|')
                 break;
         }
         excludeNdx++;
     }
 
     if (excludeNdx < matchText.length()) {
         excludeText = matchText.mid(excludeNdx + 1).trimmed();
         matchText.truncate(excludeNdx);
         matchText = matchText.trimmed();
         if (matchText.isEmpty())
             matchText = '*';
     }
 
     int i;
 
     matches = split(matchText);
     includedDirs.clear();
 
     for (i = 0; i < matches.count();) {
         if (matches[i].endsWith('/')) {
             includedDirs.push_back(matches[i].left(matches[i].length() - 1));
             matches.removeAll(matches.at(i));
             continue;
         }
 
         if (!matches[i].contains("*") && !matches[i].contains("?"))
             matches[i] = '*' + matches[i] + '*';
 
         i++;
     }
 
     excludes = split(excludeText);
     excludedDirs.clear();
 
     for (i = 0; i < excludes.count();) {
         if (excludes[i].endsWith('/')) {
             excludedDirs.push_back(excludes[i].left(excludes[i].length() - 1));
             excludes.removeAll(excludes.at(i));
             continue;
         }
 
         if (!excludes[i].contains("*") && !excludes[i].contains("?"))
             excludes[i] = '*' + excludes[i] + '*';
 
         i++;
     }
 }
 
-void KRQuery::setContent(const QString &content, bool cs, bool wholeWord, QString encoding,
+void KRQuery::setContent(const QString &content, bool cs, bool wholeWord, const QString& encoding,
                          bool regExp)
 {
     bNull = false;
     contain = content;
     containCaseSensetive = cs;
     containWholeWord = wholeWord;
     containRegExp = regExp;
 
     if (encoding.isEmpty())
         codec = QTextCodec::codecForLocale();
     else {
         codec = QTextCodec::codecForName(encoding.toLatin1());
-        if (codec == 0)
+        if (codec == nullptr)
             codec = QTextCodec::codecForLocale();
     }
 
     QChar ch = '\n';
     QTextCodec::ConverterState state(QTextCodec::IgnoreHeader);
     encodedEnterArray = codec->fromUnicode(&ch, 1, &state);
     encodedEnter = encodedEnterArray.data();
     encodedEnterLen = encodedEnterArray.size();
 }
 
 void KRQuery::setMinimumFileSize(KIO::filesize_t minimumSize)
 {
     bNull = false;
     minSize = minimumSize;
 }
 
 void KRQuery::setMaximumFileSize(KIO::filesize_t maximumSize)
 {
     bNull = false;
     maxSize = maximumSize;
 }
 
 void KRQuery::setNewerThan(time_t time)
 {
     bNull = false;
     newerThen = time;
 }
 
 void KRQuery::setOlderThan(time_t time)
 {
     bNull = false;
     olderThen = time;
 }
 
 void KRQuery::setOwner(const QString &ownerIn)
 {
     bNull = false;
     owner = ownerIn;
 }
 
 void KRQuery::setGroup(const QString &groupIn)
 {
     bNull = false;
     group = groupIn;
 }
 
 void KRQuery::setPermissions(const QString &permIn)
 {
     bNull = false;
     perm = permIn;
 }
 
 void KRQuery::setMimeType(const QString &typeIn, QStringList customList)
 {
     bNull = false;
     type = typeIn;
-    customType = customList;
+    customType = std::move(customList);
 }
 
 bool KRQuery::isExcluded(const QUrl &url)
 {
     for (QUrl &item : whereNotToSearch)
         if (item.isParentOf(url) || url.matches(item, QUrl::StripTrailingSlash))
             return true;
 
     // Exclude folder names that are configured in settings
     QString filename = url.fileName();
     for (QString &item : excludedFolderNames)
         if (filename == item)
             return true;
 
     if (!matchDirName(filename))
         return true;
 
     return false;
 }
 
 void KRQuery::setSearchInDirs(const QList<QUrl> &urls)
 {
     whereToSearch.clear();
     for (int i = 0; i < urls.count(); ++i) {
         QString url = urls[i].url();
         QUrl completed = QUrl::fromUserInput(KUrlCompletion::replacedPath(url, true, true),
                                              QString(), QUrl::AssumeLocalFile);
         whereToSearch.append(completed);
     }
 }
 
 void KRQuery::setDontSearchInDirs(const QList<QUrl> &urls)
 {
     whereNotToSearch.clear();
     for (int i = 0; i < urls.count(); ++i) {
         QString url = urls[i].url();
         QUrl completed = QUrl::fromUserInput(KUrlCompletion::replacedPath(url, true, true),
                                              QString(), QUrl::AssumeLocalFile);
         whereNotToSearch.append(completed);
     }
 }
 void KRQuery::setExcludeFolderNames(const QStringList &paths)
 {
     excludedFolderNames.clear();
     excludedFolderNames.append(paths);
 }
diff --git a/krusader/FileSystem/krquery.h b/krusader/FileSystem/krquery.h
index 8bf93b70..1509547d 100644
--- a/krusader/FileSystem/krquery.h
+++ b/krusader/FileSystem/krquery.h
@@ -1,228 +1,228 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #ifndef KRQUERY_H
 #define KRQUERY_H
 
 // QtCore
 #include <QDateTime>
 #include <QStringList>
 #include <QUrl>
 
 #include <KConfigCore/KConfigGroup>
 #include <KIO/Job>
 
 class QTextCodec;
 
 class FileItem;
 
 /**
  * @brief A search query for files
  *
  * Can be used for finding or selecting files and folders by multiple limiting search criteria
  */
 class KRQuery : public QObject
 {
     Q_OBJECT
 
 public:
     // null query
     KRQuery();
     // query only with name filter
     explicit KRQuery(const QString &name, bool matchCase = true);
     // copy constructor
     KRQuery(const KRQuery &);
     // let operator
     KRQuery &operator=(const KRQuery &);
     // destructor
-    virtual ~KRQuery();
+    ~KRQuery() override;
 
     // load parameters from config
-    void load(KConfigGroup cfg);
+    void load(const KConfigGroup& cfg);
     // save parameters to config
     void save(KConfigGroup cfg);
 
     // matching a file with the query
     bool match(FileItem *file) const; // checks if the given fileItem object matches the conditions
     // matching a name with the query
     bool match(const QString &name) const; // matching the filename only
     // matching the name of the directory
     bool matchDirName(const QString &name) const;
 
     // sets the text for name filtering
     void setNameFilter(const QString &text, bool cs = true);
     // returns the current filter mask
     const QString &nameFilter() const { return origFilter; }
     // returns whether the filter is case sensitive
     bool isCaseSensitive() { return matchesCaseSensitive; }
 
     // returns if the filter is null (was cancelled)
     bool isNull() { return bNull; }
 
     // sets the content part of the query
     void setContent(const QString &content, bool cs = true, bool wholeWord = false,
-                    QString encoding = QString(), bool regExp = false);
+                    const QString& encoding = QString(), bool regExp = false);
     const QString content() { return contain; }
 
     // sets the minimum file size limit
     void setMinimumFileSize(KIO::filesize_t);
     // sets the maximum file size limit
     void setMaximumFileSize(KIO::filesize_t);
 
     // sets the time the file newer than
     void setNewerThan(time_t time);
     // sets the time the file older than
     void setOlderThan(time_t time);
 
     // sets the owner
     void setOwner(const QString &ownerIn);
     // sets the group
     void setGroup(const QString &groupIn);
     // sets the permissions
     void setPermissions(const QString &permIn);
 
     // sets the mimetype for the query
     // type, must be one of the following:
     // 1. a valid mime type name
     // 2. one of: i18n("Archives"),   i18n("Folders"), i18n("Image Files")
     //            i18n("Text Files"), i18n("Video Files"), i18n("Audio Files")
     // 3. i18n("Custom") in which case you must supply a list of valid mime-types
     //    in the member QStringList customType
     void setMimeType(const QString &typeIn, QStringList customList = QStringList());
     // true if setMimeType was called
     bool hasMimeType() { return type.isEmpty(); }
 
     // sets the search in archive flag
     void setSearchInArchives(bool flag) { inArchive = flag; }
     // gets the search in archive flag
     bool searchInArchives() { return inArchive; }
     // sets the recursive flag
     void setRecursive(bool flag) { recurse = flag; }
     // gets the recursive flag
     bool isRecursive() { return recurse; }
     // sets whether to follow symbolic links
     void setFollowLinks(bool flag) { followLinksP = flag; }
     // gets whether to follow symbolic links
     bool followLinks() { return followLinksP; }
 
     // sets the folder names which the searcher will exclude from traversing
     void setExcludeFolderNames(const QStringList &urls);
     // gets the folder names which the searcher excludes
     const QStringList excludeFolderNames() { return excludedFolderNames; }
     // sets the folders where the searcher will search
     void setSearchInDirs(const QList<QUrl> &urls);
     // gets the folders where the searcher searches
     const QList<QUrl> &searchInDirs() { return whereToSearch; }
     // sets the folders where search is not permitted
     void setDontSearchInDirs(const QList<QUrl> &urls);
     // gets the folders where search is not permitted
     const QList<QUrl> &dontSearchInDirs() { return whereNotToSearch; }
     // checks if a URL is excluded
     bool isExcluded(const QUrl &url);
     // gives whether we search for content
     bool isContentSearched() const { return !contain.isEmpty(); }
 
     bool checkLine(const QString &line, bool backwards = false) const;
     const QString &foundText() const { return lastSuccessfulGrep; }
     int matchIndex() const { return lastSuccessfulGrepMatchIndex; }
     int matchLength() const { return lastSuccessfulGrepMatchLength; }
 
 protected:
     // important to know whether the event processor is connected
-    virtual void connectNotify(const QMetaMethod &signal) Q_DECL_OVERRIDE;
+    void connectNotify(const QMetaMethod &signal) Q_DECL_OVERRIDE;
     // important to know whether the event processor is connected
-    virtual void disconnectNotify(const QMetaMethod &signal) Q_DECL_OVERRIDE;
+    void disconnectNotify(const QMetaMethod &signal) Q_DECL_OVERRIDE;
 
 protected:
     QStringList matches;      // what to search
     QStringList excludes;     // what to exclude
     QStringList includedDirs; // what dirs to include
     QStringList excludedDirs; // what dirs to exclude
     bool matchesCaseSensitive;
 
     bool bNull; // flag if the query is null
 
     QString contain; // file must contain this string
     bool containCaseSensetive;
     bool containWholeWord;
     bool containRegExp;
 
     KIO::filesize_t minSize;
     KIO::filesize_t maxSize;
 
     time_t newerThen;
     time_t olderThen;
 
     QString owner;
     QString group;
     QString perm;
 
     QString type;
     QStringList customType;
 
     bool inArchive; // if true- search in archive.
     bool recurse;   // if true recurse ob sub-dirs...
     bool followLinksP;
 
     QStringList excludedFolderNames;      // substrings of paths where not to search
     QList<QUrl> whereToSearch;    // directories to search
     QList<QUrl> whereNotToSearch; // directories NOT to search
 
 signals:
     void status(const QString &name);
     void processEvents(bool &stopped);
 
 private:
     bool matchCommon(const QString &, const QStringList &, const QStringList &) const;
     bool checkPerm(QString perm) const;
-    bool checkType(QString mime) const;
-    bool containsContent(QString file) const;
-    bool containsContent(QUrl url) const;
+    bool checkType(const QString& mime) const;
+    bool containsContent(const QString& file) const;
+    bool containsContent(const QUrl& url) const;
     bool checkBuffer(const char *data, int len) const;
     bool checkTimer() const;
     QStringList split(QString);
 
 private slots:
     void containsContentData(KIO::Job *, const QByteArray &);
     void containsContentFinished(KJob *);
 
 private:
     QString origFilter;
     mutable bool busy;
     mutable bool containsContentResult;
     mutable char *receivedBuffer;
     mutable int receivedBufferLen;
     mutable QString lastSuccessfulGrep;
     mutable int lastSuccessfulGrepMatchIndex;
     mutable int lastSuccessfulGrepMatchLength;
     mutable QString fileName;
     mutable KIO::filesize_t receivedBytes;
     mutable KIO::filesize_t totalBytes;
     mutable int processEventsConnected;
     mutable QTime timer;
 
     QTextCodec *codec;
 
     const char *encodedEnter;
     int encodedEnterLen;
     QByteArray encodedEnterArray;
 };
 
 #endif
diff --git a/krusader/FileSystem/krtrashhandler.cpp b/krusader/FileSystem/krtrashhandler.cpp
index 708a9334..bc061cb5 100644
--- a/krusader/FileSystem/krtrashhandler.cpp
+++ b/krusader/FileSystem/krtrashhandler.cpp
@@ -1,117 +1,117 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krtrashhandler.h"
 
 // QtCore
 #include <QDir>
 #include <QStandardPaths>
 
 #include <KConfigCore/KConfig>
 #include <KConfigCore/KConfigGroup>
 #include <KIO/EmptyTrashJob>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KIO/RestoreJob>
 #include <KJobWidgets/KJobWidgets>
 
 #include "filesystemprovider.h"
 #include "../kractions.h"
 #include "../krglobal.h"
 #include "../icon.h"
 
 
-KrTrashWatcher * KrTrashHandler::_trashWatcher = 0;
+KrTrashWatcher * KrTrashHandler::_trashWatcher = nullptr;
 
 bool KrTrashHandler::isTrashEmpty()
 {
     KConfig trashConfig("trashrc");
     KConfigGroup cfg(&trashConfig, "Status");
     return cfg.readEntry("Empty", false);
 }
 
 QString KrTrashHandler::trashIconName()
 {
     return isTrashEmpty() ? "user-trash" : "user-trash-full";
 }
 
 void KrTrashHandler::emptyTrash()
 {
     KIO::JobUiDelegate uiDelegate;
     uiDelegate.setWindow(krMainWindow);
     if (!uiDelegate.askDeleteConfirmation(QList<QUrl>(), KIO::JobUiDelegate::EmptyTrash,
                                           KIO::JobUiDelegate::DefaultConfirmation))
         return;
 
     KIO::Job *job = KIO::emptyTrash();
     KJobWidgets::setWindow(job, krMainWindow);
     job->uiDelegate()->setAutoErrorHandlingEnabled(true);
     const QUrl url = QUrl("trash:/");
     QObject::connect(job, &KIO::Job::result,
                      [=]() { FileSystemProvider::instance().refreshFilesystems(url, false); });
 }
 
 void KrTrashHandler::restoreTrashedFiles(const QList<QUrl> &urls)
 {
     if (urls.isEmpty())
         return;
 
     KIO::RestoreJob *job = KIO::restoreFromTrash(urls);
     KJobWidgets::setWindow(job, krMainWindow);
     job->uiDelegate()->setAutoErrorHandlingEnabled(true);
     const QUrl url = urls.first().adjusted(QUrl::RemoveFilename);
     QObject::connect(job, &KIO::Job::result,
                      [=]() { FileSystemProvider::instance().refreshFilesystems(url, false); });
 }
 
 void KrTrashHandler::startWatcher()
 {
     if (!_trashWatcher)
         _trashWatcher = new KrTrashWatcher();
 }
 
 void KrTrashHandler::stopWatcher()
 {
     delete _trashWatcher;
-    _trashWatcher = 0;
+    _trashWatcher = nullptr;
 }
 
 
 KrTrashWatcher::KrTrashWatcher()
 {
     _watcher = new KDirWatch();
     connect(_watcher, &KDirWatch::created, this, &KrTrashWatcher::slotTrashChanged);
     connect(_watcher, &KDirWatch::dirty, this, &KrTrashWatcher::slotTrashChanged);
     const QString trashrcFile =
         QDir(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation)).filePath("trashrc");
     _watcher->addFile(trashrcFile);
     _watcher->startScan(true);
 }
 
 KrTrashWatcher::~KrTrashWatcher()
 {
     delete _watcher;
-    _watcher = 0;
+    _watcher = nullptr;
 }
 
 void KrTrashWatcher::slotTrashChanged()
 {
     KrActions::actTrashBin->setIcon(Icon(KrTrashHandler::trashIconName()));
 }
diff --git a/krusader/FileSystem/krtrashhandler.h b/krusader/FileSystem/krtrashhandler.h
index 8c200ca4..0ded1175 100644
--- a/krusader/FileSystem/krtrashhandler.h
+++ b/krusader/FileSystem/krtrashhandler.h
@@ -1,63 +1,63 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRTRASHHANDLER_H
 #define KRTRASHHANDLER_H
 
 // QtCore
 #include <QString>
 #include <QUrl>
 
 #include <KCoreAddons/KDirWatch>
 
 class KrTrashWatcher;
 
 class KrTrashHandler
 {
 public:
     static bool    isTrashEmpty();
     static QString trashIconName();
     static void    emptyTrash();
     static void    restoreTrashedFiles(const QList<QUrl> &url);
     static void    startWatcher();
     static void    stopWatcher();
 
 private:
     static KrTrashWatcher * _trashWatcher;
 };
 
 
 /** Watches the trashrc config file for changes and updates the trash icon. */
 class KrTrashWatcher : public QObject
 {
     Q_OBJECT
 
 public:
     KrTrashWatcher();
-    virtual ~KrTrashWatcher();
+    ~KrTrashWatcher() override;
 
 public slots:
     void slotTrashChanged();
 
 private:
     KDirWatch * _watcher;
 };
 
 #endif /* __KR_TRASH_HANDLER__ */
diff --git a/krusader/FileSystem/sizecalculator.cpp b/krusader/FileSystem/sizecalculator.cpp
index 611e7823..9abfe9e1 100644
--- a/krusader/FileSystem/sizecalculator.cpp
+++ b/krusader/FileSystem/sizecalculator.cpp
@@ -1,184 +1,184 @@
 /*****************************************************************************
  * Copyright (C) 2017-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "sizecalculator.h"
 
 // QtCore
 #include <QDebug>
 #include <QTimer>
 
 #include <KIO/StatJob>
 
 #include "fileitem.h"
 #include "virtualfilesystem.h"
 
 SizeCalculator::SizeCalculator(const QList<QUrl> &urls)
     : QObject(nullptr), m_urls(urls), m_nextUrls(urls), m_totalSize(0), m_totalFiles(0),
       m_totalDirs(0), m_canceled(false), m_directorySizeJob(nullptr)
 {
     QTimer::singleShot(0, this, &SizeCalculator::start);
 }
 
 SizeCalculator::~SizeCalculator()
 {
     if (m_directorySizeJob)
         m_directorySizeJob->kill();
 }
 
 void SizeCalculator::start()
 {
     emit started();
     nextUrl();
 }
 
 void SizeCalculator::add(const QUrl &url)
 {
     m_urls.append(url);
     m_nextUrls.append(url);
     emitProgress();
 }
 
 KIO::filesize_t SizeCalculator::totalSize() const
 {
     return m_totalSize + (m_directorySizeJob ? m_directorySizeJob->totalSize() : 0);
 }
 
 unsigned long SizeCalculator::totalFiles() const
 {
     return m_totalFiles + (m_directorySizeJob ? m_directorySizeJob->totalFiles() : 0);
 }
 
 unsigned long SizeCalculator::totalDirs() const
 {
     return m_totalDirs + (m_directorySizeJob ? m_directorySizeJob->totalSubdirs() : 0);
 }
 
 void SizeCalculator::cancel()
 {
     m_canceled = true;
     if (m_directorySizeJob)
         m_directorySizeJob->kill();
 
     done();
 }
 
 void SizeCalculator::nextUrl()
 {
     if (m_canceled)
         return;
 
     emitProgress();
 
     if (!m_currentUrl.isEmpty())
         emit calculated(m_currentUrl, m_currentUrlSize);
     m_currentUrlSize = 0;
 
     if (m_nextUrls.isEmpty()) {
         done();
         return;
     }
     m_currentUrl = m_nextUrls.takeFirst();
 
     if (m_currentUrl.scheme() == "virt") {
         // calculate size of all files/directories in this virtual directory
-        VirtualFileSystem *fs = new VirtualFileSystem();
+        auto *fs = new VirtualFileSystem();
         if (!fs->scanDir(m_currentUrl)) {
             qWarning() << "cannot scan virtual FS, URL=" << m_currentUrl.toDisplayString();
             nextUrl();
             return;
         }
         for (FileItem *file : fs->fileItems())
             m_nextSubUrls << file->getUrl();
         delete fs;
     } else {
         m_nextSubUrls << m_currentUrl;
     }
 
     nextSubUrl();
 }
 
 void SizeCalculator::nextSubUrl()
 {
     if (m_canceled)
         return;
 
     if (m_nextSubUrls.isEmpty()) {
         nextUrl();
         return;
     }
 
     const QUrl url = m_nextSubUrls.takeFirst();
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     connect(statJob, &KIO::Job::result, this, &SizeCalculator::slotStatResult);
 }
 
 void SizeCalculator::slotStatResult(KJob *job)
 {
     if (m_canceled)
         return;
 
     if (job->error()) {
         qWarning() << "stat job failed, error=" << job->error() << "; error string=" << job->errorString();
         nextSubUrl();
         return;
     }
 
-    const KIO::StatJob *statJob = static_cast<KIO::StatJob *>(job);
-    const QUrl url = statJob->url();
+    const KIO::StatJob *statJob = dynamic_cast<KIO::StatJob *>(job);
+    const QUrl& url = statJob->url();
 
     const KFileItem kfi(statJob->statResult(), url, true);
     if (kfi.isFile() || kfi.isLink()) {
         m_totalFiles++;
         m_totalSize += kfi.size();
         m_currentUrlSize += kfi.size();
         nextSubUrl();
         return;
     }
 
     // URL should be a directory, we are always counting the directory itself
     m_totalDirs++;
 
     m_directorySizeJob = KIO::directorySize(url);
     connect(m_directorySizeJob.data(), &KIO::Job::result, this, &SizeCalculator::slotDirectorySizeResult);
 }
 
 void SizeCalculator::slotDirectorySizeResult(KJob *)
 {
     if (!m_directorySizeJob->error()) {
         m_totalSize += m_directorySizeJob->totalSize();
         // do not count filesystem size of empty directories for this current directory
         m_currentUrlSize +=
             m_directorySizeJob->totalFiles() == 0 ? 0 : m_directorySizeJob->totalSize();
         m_totalFiles += m_directorySizeJob->totalFiles();
         m_totalDirs += m_directorySizeJob->totalSubdirs();
     }
-    m_directorySizeJob = 0;
+    m_directorySizeJob = nullptr;
     nextSubUrl();
 }
 
 void SizeCalculator::done()
 {
     emit finished(m_canceled);
     deleteLater();
 }
 
 void SizeCalculator::emitProgress()
 {
     emit progressChanged((m_urls.length() - (float)m_nextUrls.length()) / m_urls.length() * 100);
 }
diff --git a/krusader/FileSystem/sizecalculator.h b/krusader/FileSystem/sizecalculator.h
index f2105323..05c833ec 100644
--- a/krusader/FileSystem/sizecalculator.h
+++ b/krusader/FileSystem/sizecalculator.h
@@ -1,101 +1,101 @@
 /*****************************************************************************
  * Copyright (C) 2017-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SIZECALCULATOR_H
 #define SIZECALCULATOR_H
 
 // QtCore
 #include <QPointer>
 #include <QUrl>
 
 #include <KIO/DirectorySizeJob>
 
 /**
  * Calculate the size of files and directories (recursive).
  *
  * Krusader's virtual filesystem and all KIO protocols are supported.
  *
  * This calculator will delete itself when its finished (like KJob).
  */
 class SizeCalculator : public QObject
 {
     Q_OBJECT
 public:
     /**
      * Calculate the size of files and directories defined by URLs.
      *
      * The calculation is automatically started (like KJob).
      */
     explicit SizeCalculator(const QList<QUrl> &urls);
-    ~SizeCalculator();
+    ~SizeCalculator() override;
 
     /** Return all URLs (queued and progressed). */
     QList<QUrl> urls() const { return m_urls; }
     /** Add a URL to the running calculation. */
     void add(const QUrl &url);
     /** Return the current total size calculation result. */
     KIO::filesize_t totalSize() const;
     /** Return the current total number of files counted. */
     unsigned long totalFiles() const;
     /** Return the current number of directories counted. */
     unsigned long totalDirs() const;
 
 public slots:
     /** Cancel the calculation and mark for deletion. finished() will be emitted.*/
     void cancel();
 
 signals:
     /** Emitted when the calculation starts. */
     void started();
     /** Emitted when an intermediate size for one of the URLs was calculated. */
     void calculated(const QUrl &url, KIO::filesize_t size);
     /** Emitted when calculation is finished or was canceled. Calculator will be deleted afterwards. */
     void finished(bool canceled);
     /** Emitted when the progress changes. */
     void progressChanged(int percentage);
 
 private:
     void nextSubUrl();
     void done();
     void emitProgress();
 
 private slots:
     void start();
     void nextUrl();
     void slotStatResult(KJob *job);
     void slotDirectorySizeResult(KJob *job);
 
 private:
     QList<QUrl> m_urls; // all URLs
 
     QList<QUrl> m_nextUrls; // URLs not calculated yet
     QUrl m_currentUrl;
     QList<QUrl> m_nextSubUrls;
 
     KIO::filesize_t m_currentUrlSize;
     KIO::filesize_t m_totalSize;
     unsigned long m_totalFiles;
     unsigned long m_totalDirs;
 
     bool m_canceled;
 
     QPointer<KIO::DirectorySizeJob> m_directorySizeJob;
 };
 
 #endif // SIZECALCULATOR_H
diff --git a/krusader/FileSystem/virtualfilesystem.cpp b/krusader/FileSystem/virtualfilesystem.cpp
index 348dc514..c32d022b 100644
--- a/krusader/FileSystem/virtualfilesystem.cpp
+++ b/krusader/FileSystem/virtualfilesystem.cpp
@@ -1,355 +1,355 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2003 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "virtualfilesystem.h"
 
 // QtCore
 #include <QDir>
 #include <QEventLoop>
 #include <QUrl>
 // QtWidgets
 #include <QApplication>
 
 #include <KCoreAddons/KUrlMimeData>
 #include <KI18n/KLocalizedString>
 #include <KIO/CopyJob>
 #include <KIO/DeleteJob>
 #include <KIO/DirectorySizeJob>
 #include <KIO/StatJob>
 #include <KIOCore/KFileItem>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "fileitem.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../krservices.h"
 
 #define VIRTUALFILESYSTEM_DB "virtualfilesystem.db"
 
 QHash<QString, QList<QUrl> *> VirtualFileSystem::_virtFilesystemDict;
 QHash<QString, QString> VirtualFileSystem::_metaInfoDict;
 
-VirtualFileSystem::VirtualFileSystem() : FileSystem()
+VirtualFileSystem::VirtualFileSystem()
 {
     if (_virtFilesystemDict.isEmpty()) {
         restore();
     }
 
     _type = FS_VIRTUAL;
 }
 
 void VirtualFileSystem::copyFiles(const QList<QUrl> &urls, const QUrl &destination,
                          KIO::CopyJob::CopyMode /*mode*/, bool /*showProgressInfo*/,
                          JobMan::StartMode /*startMode*/)
 {
     const QString dir = QDir(destination.path()).absolutePath().remove('/');
 
     if (dir.isEmpty()) {
         showError(i18n("You cannot copy files directly to the 'virt:/' folder.\n"
                        "You can create a sub folder and copy your files into it."));
         return;
     }
 
     if (!_virtFilesystemDict.contains(dir)) {
         mkDirInternal(dir);
     }
 
     QList<QUrl> *urlList = _virtFilesystemDict[dir];
     for (const QUrl &fileUrl : urls) {
         if (!urlList->contains(fileUrl)) {
             urlList->push_back(fileUrl);
         }
     }
 
     emit fileSystemChanged(QUrl("virt:///" + dir), false); // may call refresh()
 }
 
 void VirtualFileSystem::dropFiles(const QUrl &destination, QDropEvent *event)
 {
     const QList<QUrl> &urls = KUrlMimeData::urlsFromMimeData(event->mimeData());
     // dropping on virtual filesystem is always copy operation
     copyFiles(urls, destination);
 }
 
 void VirtualFileSystem::addFiles(const QList<QUrl> &fileUrls, KIO::CopyJob::CopyMode /*mode*/,
                                  const QString &dir)
 {
     QUrl destination(_currentDirectory);
     if (!dir.isEmpty()) {
         destination.setPath(QDir::cleanPath(destination.path() + '/' + dir));
     }
     copyFiles(fileUrls, destination);
 }
 
 void VirtualFileSystem::remove(const QStringList &fileNames)
 {
     const QString parentDir = currentDir();
     if (parentDir == "/") { // remove virtual directory
         for (const QString &filename : fileNames) {
             _virtFilesystemDict["/"]->removeAll(QUrl(QStringLiteral("virt:/") + filename));
             delete _virtFilesystemDict[filename];
             _virtFilesystemDict.remove(filename);
             _metaInfoDict.remove(filename);
         }
     } else {
         // remove the URLs from the collection
-        for (const QString name : fileNames) {
+        for (const QString& name : fileNames) {
             if (_virtFilesystemDict.find(parentDir) != _virtFilesystemDict.end()) {
                 QList<QUrl> *urlList = _virtFilesystemDict[parentDir];
                 urlList->removeAll(getUrl(name));
             }
         }
     }
 
     emit fileSystemChanged(currentDirectory(), true); // will call refresh()
 }
 
 QUrl VirtualFileSystem::getUrl(const QString &name) const
 {
     FileItem *item = getFileItem(name);
     if (!item) {
         return QUrl(); // not found
     }
 
     return item->getUrl();
 }
 
 void VirtualFileSystem::mkDir(const QString &name)
 {
     if (currentDir() != "/") {
         showError(i18n("Creating new folders is allowed only in the 'virt:/' folder."));
         return;
     }
 
     mkDirInternal(name);
 
     emit fileSystemChanged(currentDirectory(), false); // will call refresh()
 }
 
 void VirtualFileSystem::rename(const QString &fileName, const QString &newName)
 {
     FileItem *item = getFileItem(fileName);
     if (!item)
         return; // not found
 
     if (currentDir() == "/") { // rename virtual directory
         _virtFilesystemDict["/"]->append(QUrl(QStringLiteral("virt:/") + newName));
         _virtFilesystemDict["/"]->removeAll(QUrl(QStringLiteral("virt:/") + fileName));
         _virtFilesystemDict.insert(newName, _virtFilesystemDict.take(fileName));
         refresh();
         return;
     }
 
     // newName can be a (local) path or a full url
     QUrl dest(newName);
     if (dest.scheme().isEmpty())
         dest.setScheme("file");
 
     // add the new url to the list
     // the list is refreshed, only existing files remain -
     // so we don't have to worry if the job was successful
     _virtFilesystemDict[currentDir()]->append(dest);
 
     KIO::Job *job = KIO::moveAs(item->getUrl(), dest, KIO::HideProgressInfo);
     connect(job, &KIO::Job::result, this, [=](KJob* job) { slotJobResult(job, false); });
     connect(job, &KIO::Job::result, this, [=]() { emit fileSystemChanged(currentDirectory(), false); });
 }
 
 bool VirtualFileSystem::canMoveToTrash(const QStringList &fileNames) const
 {
     if (isRoot())
         return false;
 
-    for (const QString fileName : fileNames) {
+    for (const QString& fileName : fileNames) {
         if (!getUrl(fileName).isLocalFile()) {
             return false;
         }
     }
     return true;
 }
 
 void VirtualFileSystem::setMetaInformation(const QString &info)
 {
     _metaInfoDict[currentDir()] = info;
 }
 
 // ==== protected ====
 
 bool VirtualFileSystem::refreshInternal(const QUrl &directory, bool onlyScan)
 {
     _currentDirectory = cleanUrl(directory);
     _currentDirectory.setHost("");
     // remove invalid subdirectories
     _currentDirectory.setPath('/' + _currentDirectory.path().remove('/'));
 
     if (!_virtFilesystemDict.contains(currentDir())) {
         if (onlyScan) {
             return false; // virtual dir does not exist
         } else {
             // Silently creating non-existing directories here. The search and locate tools
             // expect this. And the user can enter some directory and it will be created.
             mkDirInternal(currentDir());
             save();
             // infinite loop possible
             // emit fileSystemChanged(currentDirectory());
             return true;
         }
     }
 
     QList<QUrl> *urlList = _virtFilesystemDict[currentDir()];
 
     if (!onlyScan) {
         const QString metaInfo = _metaInfoDict[currentDir()];
         emit fileSystemInfoChanged(metaInfo.isEmpty() ? i18n("Virtual filesystem") : metaInfo,
                                    "", 0, 0);
     }
 
     QMutableListIterator<QUrl> it(*urlList);
     while (it.hasNext()) {
         const QUrl url = it.next();
         FileItem *item = createFileItem(url);
         if (!item) { // remove URL from the list for a file that no longer exists
             it.remove();
         } else {
             addFileItem(item);
         }
     }
 
     save();
     return true;
 }
 
 // ==== private ====
 
 void VirtualFileSystem::mkDirInternal(const QString &name)
 {
     // clean path, consistent with currentDir()
     QString dirName = name;
     dirName = dirName.remove('/');
     if (dirName.isEmpty())
         dirName = '/';
 
     _virtFilesystemDict.insert(dirName, new QList<QUrl>());
     _virtFilesystemDict["/"]->append(QUrl(QStringLiteral("virt:/") + dirName));
 }
 
 void VirtualFileSystem::save()
 {
     KConfig *db = &VirtualFileSystem::getVirtDB();
     db->deleteGroup("virt_db");
     KConfigGroup group(db, "virt_db");
 
     QHashIterator<QString, QList<QUrl> *> it(_virtFilesystemDict);
     while (it.hasNext()) {
         it.next();
         QList<QUrl> *urlList = it.value();
 
         QList<QUrl>::iterator url;
         QStringList entry;
         for (url = urlList->begin(); url != urlList->end(); ++url) {
             entry.append((*url).toDisplayString());
         }
         // KDE 4.0 workaround: 'Item_' prefix is added as KConfig fails on 1 char names (such as /)
         group.writeEntry("Item_" + it.key(), entry);
         group.writeEntry("MetaInfo_" + it.key(), _metaInfoDict[it.key()]);
     }
 
     db->sync();
 }
 
 void VirtualFileSystem::restore()
 {
     KConfig *db = &VirtualFileSystem::getVirtDB();
     const KConfigGroup dbGrp(db, "virt_db");
 
     const QMap<QString, QString> map = db->entryMap("virt_db");
     QMapIterator<QString, QString> it(map);
     while (it.hasNext()) {
         it.next();
 
         // KDE 4.0 workaround: check and remove 'Item_' prefix
         if (!it.key().startsWith(QLatin1String("Item_")))
             continue;
         const QString key = it.key().mid(5);
 
         const QList<QUrl> urlList = KrServices::toUrlList(dbGrp.readEntry(it.key(), QStringList()));
         _virtFilesystemDict.insert(key, new QList<QUrl>(urlList));
         _metaInfoDict.insert(key, dbGrp.readEntry("MetaInfo_" + key, QString()));
     }
 
     if (!_virtFilesystemDict["/"]) { // insert root element if missing for some reason
         _virtFilesystemDict.insert("/", new QList<QUrl>());
     }
 }
 
 FileItem *VirtualFileSystem::createFileItem(const QUrl &url)
 {
     if (url.scheme() == "virt") { // return a virtual directory in root
         QString path = url.path().mid(1);
         if (path.isEmpty())
             path = '/';
         return FileItem::createVirtualDir(path, url);
     }
 
     const QUrl directory = url.adjusted(QUrl::RemoveFilename);
 
     if (url.isLocalFile()) {
         QFileInfo file(url.path());
-        return file.exists() ? FileSystem::createLocalFileItem(url.fileName(), directory.path(), true) : 0;
+        return file.exists() ? FileSystem::createLocalFileItem(url.fileName(), directory.path(), true) : nullptr;
     }
 
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     connect(statJob, &KIO::Job::result, this, &VirtualFileSystem::slotStatResult);
 
     // ugly: we have to wait here until the stat job is finished
     QEventLoop eventLoop;
     connect(statJob, &KJob::finished, &eventLoop, &QEventLoop::quit);
     eventLoop.exec(); // blocking until quit()
 
     if (_fileEntry.count() == 0) {
-        return 0; // stat job failed
+        return nullptr; // stat job failed
     }
 
     if (!_fileEntry.contains(KIO::UDSEntry::UDS_MODIFICATION_TIME)) {
         // TODO this also happens for FTP directories
-        return 0; // file not found
+        return nullptr; // file not found
     }
 
     return FileSystem::createFileItemFromKIO(_fileEntry, directory, true);
 }
 
 KConfig &VirtualFileSystem::getVirtDB()
 {
     //virtualfilesystem_db = new KConfig("data",VIRTUALFILESYSTEM_DB,KConfig::NoGlobals);
     static KConfig db(VIRTUALFILESYSTEM_DB, KConfig::CascadeConfig, QStandardPaths::AppDataLocation);
     return db;
 }
 
 void VirtualFileSystem::slotStatResult(KJob *job)
 {
-    _fileEntry = job->error() ? KIO::UDSEntry() : static_cast<KIO::StatJob *>(job)->statResult();
+    _fileEntry = job->error() ? KIO::UDSEntry() : dynamic_cast<KIO::StatJob *>(job)->statResult();
 }
 
 void VirtualFileSystem::showError(const QString &error)
 {
     QWidget *window = QApplication::activeWindow();
     KMessageBox::sorry(window, error); // window can be null, is allowed
 }
diff --git a/krusader/Filter/advancedfilter.cpp b/krusader/Filter/advancedfilter.cpp
index b37be22b..5b5d1761 100644
--- a/krusader/Filter/advancedfilter.cpp
+++ b/krusader/Filter/advancedfilter.cpp
@@ -1,612 +1,612 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2003 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "advancedfilter.h"
 
 // QtCore
 #include <QDebug>
 #include <QFile>
 #include <QTextStream>
 // QtGui
 #include <QPixmap>
 // QtWidgets
 #include <QSpinBox>
 #include <QButtonGroup>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QGroupBox>
 #include <QLayout>
 #include <QLabel>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../Dialogs/krdialogs.h"
 
 #define USERSFILE  QString("/etc/passwd")
 #define GROUPSFILE QString("/etc/group")
 
 AdvancedFilter::AdvancedFilter(FilterTabs *tabs, QWidget *parent) : QWidget(parent), fltTabs(tabs)
 {
-    QGridLayout *filterLayout = new QGridLayout(this);
+    auto *filterLayout = new QGridLayout(this);
     filterLayout->setSpacing(6);
     filterLayout->setContentsMargins(11, 11, 11, 11);
 
     // Options for size
 
-    QGroupBox *sizeGroup = new QGroupBox(this);
+    auto *sizeGroup = new QGroupBox(this);
     QSizePolicy sizeGroupPolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
     sizeGroupPolicy.setHeightForWidth(sizeGroup->sizePolicy().hasHeightForWidth());
     sizeGroup->setSizePolicy(sizeGroupPolicy);
     sizeGroup->setTitle(i18n("Size"));
-    QGridLayout *sizeLayout = new QGridLayout(sizeGroup);
+    auto *sizeLayout = new QGridLayout(sizeGroup);
     sizeLayout->setAlignment(Qt::AlignTop);
     sizeLayout->setSpacing(6);
     sizeLayout->setContentsMargins(11, 11, 11, 11);
 
     minSizeEnabled = new QCheckBox(sizeGroup);
     minSizeEnabled->setText(i18n("At Least"));
     minSizeEnabled->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     sizeLayout->addWidget(minSizeEnabled, 0, 0);
 
     minSizeAmount = new QSpinBox(sizeGroup);
     minSizeAmount->setRange(0, 999999999);
     minSizeAmount->setEnabled(false);
     sizeLayout->addWidget(minSizeAmount, 0, 1);
 
     minSizeType = new KComboBox(false, sizeGroup);
     // i18n: @item:inlistbox next to a text field containing the amount
     minSizeType->addItem(i18n("Byte"));
     // i18n: @item:inlistbox next to a text field containing the amount
     minSizeType->addItem(i18n("KiB"));
     // i18n: @item:inlistbox next to a text field containing the amount
     minSizeType->addItem(i18n("MiB"));
     // i18n: @item:inlistbox next to a text field containing the amount
     minSizeType->addItem(i18n("GiB"));
     minSizeType->setEnabled(false);
     sizeLayout->addWidget(minSizeType, 0, 2);
 
     maxSizeEnabled = new QCheckBox(sizeGroup);
     maxSizeEnabled->setText(i18n("At Most"));
     maxSizeEnabled->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     sizeLayout->addWidget(maxSizeEnabled, 0, 3);
 
     maxSizeAmount = new QSpinBox(sizeGroup);
     maxSizeAmount->setRange(0, 999999999);
     maxSizeAmount->setEnabled(false);
     sizeLayout->addWidget(maxSizeAmount, 0, 4);
 
     maxSizeType = new KComboBox(false, sizeGroup);
     // i18n: @item:inlistbox next to a text field containing the amount
     maxSizeType->addItem(i18n("Byte"));
     // i18n: @item:inlistbox next to a text field containing the amount
     maxSizeType->addItem(i18n("KiB"));
     // i18n: @item:inlistbox next to a text field containing the amount
     maxSizeType->addItem(i18n("MiB"));
     // i18n: @item:inlistbox next to a text field containing the amount
     maxSizeType->addItem(i18n("GiB"));
     maxSizeType->setEnabled(false);
     sizeLayout->addWidget(maxSizeType, 0, 5);
 
     filterLayout->addWidget(sizeGroup, 0, 0);
 
     // Options for date
 
     Icon iconDate("view-calendar");
 
-    QGroupBox *dateGroup = new QGroupBox(this);
-    QButtonGroup *btnGroup = new QButtonGroup(dateGroup);
+    auto *dateGroup = new QGroupBox(this);
+    auto *btnGroup = new QButtonGroup(dateGroup);
     dateGroup->setTitle(i18n("Date"));
     btnGroup->setExclusive(true);
-    QGridLayout *dateLayout = new QGridLayout(dateGroup);
+    auto *dateLayout = new QGridLayout(dateGroup);
     dateLayout->setAlignment(Qt::AlignTop);
     dateLayout->setSpacing(6);
     dateLayout->setContentsMargins(11, 11, 11, 11);
 
     anyDateEnabled = new QRadioButton(dateGroup);
     anyDateEnabled->setText(i18n("Any date"));
     btnGroup->addButton(anyDateEnabled);
     anyDateEnabled->setChecked(true);
 
     modifiedBetweenEnabled = new QRadioButton(dateGroup);
     modifiedBetweenEnabled->setText(i18n("&Modified between"));
     btnGroup->addButton(modifiedBetweenEnabled);
 
     modifiedBetweenData1 = new KLineEdit(dateGroup);
     modifiedBetweenData1->setEnabled(false);
     modifiedBetweenData1->setText("");
 
     modifiedBetweenBtn1 = new QToolButton(dateGroup);
     modifiedBetweenBtn1->setEnabled(false);
     modifiedBetweenBtn1->setText("");
     modifiedBetweenBtn1->setIcon(iconDate);
 
     QLabel *andLabel = new QLabel(dateGroup);
     andLabel->setText(i18n("an&d"));
 
     modifiedBetweenData2 = new KLineEdit(dateGroup);
     modifiedBetweenData2->setEnabled(false);
     modifiedBetweenData2->setText("");
     andLabel->setBuddy(modifiedBetweenData2);
 
     modifiedBetweenBtn2 = new QToolButton(dateGroup);
     modifiedBetweenBtn2->setEnabled(false);
     modifiedBetweenBtn2->setText("");
     modifiedBetweenBtn2->setIcon(iconDate);
 
     notModifiedAfterEnabled = new QRadioButton(dateGroup);
     notModifiedAfterEnabled->setText(i18n("&Not modified after"));
     btnGroup->addButton(notModifiedAfterEnabled);
 
     notModifiedAfterData = new KLineEdit(dateGroup);
     notModifiedAfterData->setEnabled(false);
     notModifiedAfterData->setText("");
 
     notModifiedAfterBtn = new QToolButton(dateGroup);
     notModifiedAfterBtn->setEnabled(false);
     notModifiedAfterBtn->setText("");
     notModifiedAfterBtn->setIcon(iconDate);
 
     modifiedInTheLastEnabled = new QRadioButton(dateGroup);
     modifiedInTheLastEnabled->setText(i18n("Mod&ified in the last"));
     btnGroup->addButton(modifiedInTheLastEnabled);
 
     modifiedInTheLastData = new QSpinBox(dateGroup);
     modifiedInTheLastData->setRange(0, 99999);
     modifiedInTheLastData->setEnabled(false);
 
     modifiedInTheLastType = new KComboBox(dateGroup);
     modifiedInTheLastType->addItem(i18n("days"));
     modifiedInTheLastType->addItem(i18n("weeks"));
     modifiedInTheLastType->addItem(i18n("months"));
     modifiedInTheLastType->addItem(i18n("years"));
     modifiedInTheLastType->setEnabled(false);
 
     notModifiedInTheLastData = new QSpinBox(dateGroup);
     notModifiedInTheLastData->setRange(0, 99999);
     notModifiedInTheLastData->setEnabled(false);
 
     QLabel *notModifiedInTheLastLbl = new QLabel(dateGroup);
     notModifiedInTheLastLbl->setText(i18n("No&t modified in the last"));
     notModifiedInTheLastLbl->setBuddy(notModifiedInTheLastData);
 
     notModifiedInTheLastType = new KComboBox(dateGroup);
     notModifiedInTheLastType->addItem(i18n("days"));
     notModifiedInTheLastType->addItem(i18n("weeks"));
     notModifiedInTheLastType->addItem(i18n("months"));
     notModifiedInTheLastType->addItem(i18n("years"));
     notModifiedInTheLastType->setEnabled(false);
 
     // Date options layout
 
     dateLayout->addWidget(anyDateEnabled, 0, 0);
 
     dateLayout->addWidget(modifiedBetweenEnabled, 1, 0);
     dateLayout->addWidget(modifiedBetweenData1, 1, 1);
     dateLayout->addWidget(modifiedBetweenBtn1, 1, 2);
     dateLayout->addWidget(andLabel, 1, 3);
     dateLayout->addWidget(modifiedBetweenData2, 1, 4);
     dateLayout->addWidget(modifiedBetweenBtn2, 1, 5);
 
     dateLayout->addWidget(notModifiedAfterEnabled, 2, 0);
     dateLayout->addWidget(notModifiedAfterData, 2, 1);
     dateLayout->addWidget(notModifiedAfterBtn, 2, 2);
 
     dateLayout->addWidget(modifiedInTheLastEnabled, 3, 0);
-    QHBoxLayout *modifiedInTheLastLayout = new QHBoxLayout();
+    auto *modifiedInTheLastLayout = new QHBoxLayout();
     modifiedInTheLastLayout->addWidget(modifiedInTheLastData);
     modifiedInTheLastLayout->addWidget(modifiedInTheLastType);
     dateLayout->addLayout(modifiedInTheLastLayout, 3, 1);
 
     dateLayout->addWidget(notModifiedInTheLastLbl, 4, 0);
     modifiedInTheLastLayout = new QHBoxLayout();
     modifiedInTheLastLayout->addWidget(notModifiedInTheLastData);
     modifiedInTheLastLayout->addWidget(notModifiedInTheLastType);
     dateLayout->addLayout(modifiedInTheLastLayout, 4, 1);
 
     filterLayout->addWidget(dateGroup, 1, 0);
 
     // Options for ownership
 
-    QGroupBox *ownershipGroup = new QGroupBox(this);
+    auto *ownershipGroup = new QGroupBox(this);
     ownershipGroup->setTitle(i18n("Ownership"));
-    QGridLayout *ownershipLayout = new QGridLayout(ownershipGroup);
+    auto *ownershipLayout = new QGridLayout(ownershipGroup);
     ownershipLayout->setAlignment(Qt::AlignTop);
     ownershipLayout->setSpacing(6);
     ownershipLayout->setContentsMargins(11, 11, 11, 11);
 
-    QHBoxLayout *hboxLayout = new QHBoxLayout();
+    auto *hboxLayout = new QHBoxLayout();
     hboxLayout->setSpacing(6);
     hboxLayout->setContentsMargins(0, 0, 0, 0);
 
     belongsToUserEnabled = new QCheckBox(ownershipGroup);
     belongsToUserEnabled->setText(i18n("Belongs to &user"));
     hboxLayout->addWidget(belongsToUserEnabled);
 
     belongsToUserData = new KComboBox(ownershipGroup);
     belongsToUserData->setEnabled(false);
     belongsToUserData->setEditable(false);
     hboxLayout->addWidget(belongsToUserData);
 
     belongsToGroupEnabled = new QCheckBox(ownershipGroup);
     belongsToGroupEnabled->setText(i18n("Belongs to gr&oup"));
     hboxLayout->addWidget(belongsToGroupEnabled);
 
     belongsToGroupData = new KComboBox(ownershipGroup);
     belongsToGroupData->setEnabled(false);
     belongsToGroupData->setEditable(false);
     hboxLayout->addWidget(belongsToGroupData);
 
     ownershipLayout->addLayout(hboxLayout, 0, 0, 1, 4);
 
     permissionsEnabled = new QCheckBox(ownershipGroup);
     permissionsEnabled->setText(i18n("P&ermissions"));
     ownershipLayout->addWidget(permissionsEnabled, 1, 0);
 
-    QGroupBox *ownerGroup = new QGroupBox(ownershipGroup);
-    QHBoxLayout *ownerHBox = new QHBoxLayout(ownerGroup);
+    auto *ownerGroup = new QGroupBox(ownershipGroup);
+    auto *ownerHBox = new QHBoxLayout(ownerGroup);
     ownerGroup->setTitle(i18n("O&wner"));
 
     ownerR = new KComboBox(ownerGroup);
     ownerR->addItem(i18n("?"));
     ownerR->addItem(i18n("r"));
     ownerR->addItem(i18n("-"));
     ownerR->setEnabled(false);
     ownerHBox->addWidget(ownerR);
 
     ownerW = new KComboBox(ownerGroup);
     ownerW->addItem(i18n("?"));
     ownerW->addItem(i18n("w"));
     ownerW->addItem(i18n("-"));
     ownerW->setEnabled(false);
     ownerHBox->addWidget(ownerW);
 
     ownerX = new KComboBox(ownerGroup);
     ownerX->addItem(i18n("?"));
     ownerX->addItem(i18n("x"));
     ownerX->addItem(i18n("-"));
     ownerX->setEnabled(false);
     ownerHBox->addWidget(ownerX);
 
     ownershipLayout->addWidget(ownerGroup, 1, 1);
 
-    QGroupBox *groupGroup = new QGroupBox(ownershipGroup);
-    QHBoxLayout *groupHBox = new QHBoxLayout(groupGroup);
+    auto *groupGroup = new QGroupBox(ownershipGroup);
+    auto *groupHBox = new QHBoxLayout(groupGroup);
     groupGroup->setTitle(i18n("Grou&p"));
 
     groupR = new KComboBox(groupGroup);
     groupR->addItem(i18n("?"));
     groupR->addItem(i18n("r"));
     groupR->addItem(i18n("-"));
     groupR->setEnabled(false);
     groupHBox->addWidget(groupR);
 
     groupW = new KComboBox(groupGroup);
     groupW->addItem(i18n("?"));
     groupW->addItem(i18n("w"));
     groupW->addItem(i18n("-"));
     groupW->setEnabled(false);
     groupHBox->addWidget(groupW);
 
     groupX = new KComboBox(groupGroup);
     groupX->addItem(i18n("?"));
     groupX->addItem(i18n("x"));
     groupX->addItem(i18n("-"));
     groupX->setEnabled(false);
     groupHBox->addWidget(groupX);
 
     ownershipLayout->addWidget(groupGroup, 1, 2);
 
-    QGroupBox *allGroup = new QGroupBox(ownershipGroup);
-    QHBoxLayout *allHBox = new QHBoxLayout(allGroup);
+    auto *allGroup = new QGroupBox(ownershipGroup);
+    auto *allHBox = new QHBoxLayout(allGroup);
     allGroup->setTitle(i18n("A&ll"));
 
     allR = new KComboBox(allGroup);
     allR->addItem(i18n("?"));
     allR->addItem(i18n("r"));
     allR->addItem(i18n("-"));
     allR->setEnabled(false);
     allHBox->addWidget(allR);
 
     allW = new KComboBox(allGroup);
     allW->addItem(i18n("?"));
     allW->addItem(i18n("w"));
     allW->addItem(i18n("-"));
     allW->setEnabled(false);
     allHBox->addWidget(allW);
 
     allX = new KComboBox(allGroup);
     allX->addItem(i18n("?"));
     allX->addItem(i18n("x"));
     allX->addItem(i18n("-"));
     allX->setEnabled(false);
     allHBox->addWidget(allX);
 
     ownershipLayout->addWidget(allGroup, 1, 3);
 
     QLabel *infoLabel = new QLabel(ownershipGroup);
     QFont infoLabel_font(infoLabel->font());
     infoLabel_font.setFamily("adobe-helvetica");
     infoLabel_font.setItalic(true);
     infoLabel->setFont(infoLabel_font);
     infoLabel->setText(i18n("Note: a '?' is a wildcard"));
 
     ownershipLayout->addWidget(infoLabel, 2, 0, 1, 4, Qt::AlignRight);
 
     filterLayout->addWidget(ownershipGroup, 2, 0);
 
     // Connection table
 
     connect(minSizeEnabled, &QCheckBox::toggled, minSizeAmount, &QSpinBox::setEnabled);
     connect(minSizeEnabled, &QCheckBox::toggled, minSizeType, &KComboBox::setEnabled);
     connect(maxSizeEnabled, &QCheckBox::toggled, maxSizeAmount, &QSpinBox::setEnabled);
     connect(maxSizeEnabled, &QCheckBox::toggled, maxSizeType, &KComboBox::setEnabled);
     connect(modifiedBetweenEnabled, &QRadioButton::toggled, modifiedBetweenData1, &KLineEdit::setEnabled);
     connect(modifiedBetweenEnabled, &QRadioButton::toggled, modifiedBetweenBtn1, &QToolButton::setEnabled);
     connect(modifiedBetweenEnabled, &QRadioButton::toggled, modifiedBetweenData2, &KLineEdit::setEnabled);
     connect(modifiedBetweenEnabled, &QRadioButton::toggled, modifiedBetweenBtn2, &QToolButton::setEnabled);
     connect(notModifiedAfterEnabled, &QRadioButton::toggled, notModifiedAfterData, &KLineEdit::setEnabled);
     connect(notModifiedAfterEnabled, &QRadioButton::toggled, notModifiedAfterBtn, &QToolButton::setEnabled);
     connect(modifiedInTheLastEnabled, &QRadioButton::toggled, modifiedInTheLastData, &QSpinBox::setEnabled);
     connect(modifiedInTheLastEnabled, &QRadioButton::toggled, modifiedInTheLastType, &KComboBox::setEnabled);
     connect(modifiedInTheLastEnabled, &QRadioButton::toggled, notModifiedInTheLastData, &QSpinBox::setEnabled);
     connect(modifiedInTheLastEnabled, &QRadioButton::toggled, notModifiedInTheLastType, &KComboBox::setEnabled);
     connect(belongsToUserEnabled, &QCheckBox::toggled, belongsToUserData, &KComboBox::setEnabled);
     connect(belongsToGroupEnabled, &QCheckBox::toggled, belongsToGroupData, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, ownerR, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, ownerW, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, ownerX, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, groupR, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, groupW, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, groupX, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, allR, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, allW, &KComboBox::setEnabled);
     connect(permissionsEnabled, &QCheckBox::toggled, allX, &KComboBox::setEnabled);
     connect(modifiedBetweenBtn1, &QToolButton::clicked, this, &AdvancedFilter::modifiedBetweenSetDate1);
     connect(modifiedBetweenBtn2, &QToolButton::clicked, this, &AdvancedFilter::modifiedBetweenSetDate2);
     connect(notModifiedAfterBtn, &QToolButton::clicked, this, &AdvancedFilter::notModifiedAfterSetDate);
 
     // fill the users and groups list
 
     fillList(belongsToUserData, USERSFILE);
     fillList(belongsToGroupData, GROUPSFILE);
 
     // tab order
     setTabOrder(minSizeEnabled, minSizeAmount);
     setTabOrder(minSizeAmount, maxSizeEnabled);
     setTabOrder(maxSizeEnabled, maxSizeAmount);
     setTabOrder(maxSizeAmount, modifiedBetweenEnabled);
     setTabOrder(modifiedBetweenEnabled, modifiedBetweenData1);
     setTabOrder(modifiedBetweenData1, modifiedBetweenData2);
     setTabOrder(modifiedBetweenData2, notModifiedAfterEnabled);
     setTabOrder(notModifiedAfterEnabled, notModifiedAfterData);
     setTabOrder(notModifiedAfterData, modifiedInTheLastEnabled);
     setTabOrder(modifiedInTheLastEnabled, modifiedInTheLastData);
     setTabOrder(modifiedInTheLastData, notModifiedInTheLastData);
     setTabOrder(notModifiedInTheLastData, belongsToUserEnabled);
     setTabOrder(belongsToUserEnabled, belongsToUserData);
     setTabOrder(belongsToUserData, belongsToGroupEnabled);
     setTabOrder(belongsToGroupEnabled, belongsToGroupData);
     setTabOrder(belongsToGroupData, permissionsEnabled);
     setTabOrder(permissionsEnabled, ownerR);
     setTabOrder(ownerR, ownerW);
     setTabOrder(ownerW, ownerX);
     setTabOrder(ownerX, groupR);
     setTabOrder(groupR, groupW);
     setTabOrder(groupW, groupX);
     setTabOrder(groupX, allR);
     setTabOrder(allR, allW);
     setTabOrder(allW, allX);
     setTabOrder(allX, minSizeType);
     setTabOrder(minSizeType, maxSizeType);
     setTabOrder(maxSizeType, modifiedInTheLastType);
     setTabOrder(modifiedInTheLastType, notModifiedInTheLastType);
 }
 
 void AdvancedFilter::modifiedBetweenSetDate1()
 {
     changeDate(modifiedBetweenData1);
 }
 
 void AdvancedFilter::modifiedBetweenSetDate2()
 {
     changeDate(modifiedBetweenData2);
 }
 
 void AdvancedFilter::notModifiedAfterSetDate()
 {
     changeDate(notModifiedAfterData);
 }
 
 void AdvancedFilter::changeDate(KLineEdit *p)
 {
     // check if the current date is valid
     QDate d = stringToDate(p->text());
     if (!d.isValid()) d = QDate::currentDate();
 
-    KRGetDate *gd = new KRGetDate(d, this);
+    auto *gd = new KRGetDate(d, this);
     d = gd->getDate();
     // if a user pressed ESC or closed the dialog, we'll return an invalid date
     if (d.isValid())
         p->setText(dateToString(d));
     delete gd;
 }
 
-void AdvancedFilter::fillList(KComboBox *list, QString filename)
+void AdvancedFilter::fillList(KComboBox *list, const QString& filename)
 {
     QFile data(filename);
     if (!data.open(QIODevice::ReadOnly)) {
         qWarning() << "Search: Unable to read " << filename << " !!!";
         return;
     }
     // and read it into the temporary array
     QTextStream t(&data);
     while (!t.atEnd()) {
         QString s = t.readLine();
         QString name = s.left(s.indexOf(':'));
         if (!name.startsWith('#'))
             list->addItem(name);
     }
 }
 
 void AdvancedFilter::invalidDateMessage(KLineEdit *p)
 {
     // FIXME p->text() is empty sometimes (to reproduce, set date to "13.09.005")
     KMessageBox::detailedError(this, i18n("Invalid date entered."),
                                i18n("The date %1 is not valid according to your locale. Please re-enter a valid date (use the date button for easy access).", p->text()));
     p->setFocus();
 }
 
 bool AdvancedFilter::getSettings(FilterSettings &s)
 {
     s.minSizeEnabled =  minSizeEnabled->isChecked();
     s.minSize.amount = minSizeAmount->value();
     s.minSize.unit = static_cast<FilterSettings::SizeUnit>(minSizeType->currentIndex());
 
     s.maxSizeEnabled = maxSizeEnabled->isChecked();
     s.maxSize.amount = maxSizeAmount->value();
     s.maxSize.unit = static_cast<FilterSettings::SizeUnit>(maxSizeType->currentIndex());
 
     if (s.minSizeEnabled && s.maxSizeEnabled && (s.maxSize.size() < s.minSize.size())) {
         KMessageBox::detailedError(this, i18n("Specified sizes are inconsistent."),
                             i18n("Please re-enter the values, so that the left side size "
                                  "will be smaller than (or equal to) the right side size."));
         minSizeAmount->setFocus();
         return false;
     }
 
     s.modifiedBetweenEnabled = modifiedBetweenEnabled->isChecked();
     s.modifiedBetween1 = stringToDate(modifiedBetweenData1->text());
     s.modifiedBetween2 = stringToDate(modifiedBetweenData2->text());
 
     if (s.modifiedBetweenEnabled) {
         // check if date is valid
         if (!s.modifiedBetween1.isValid()) {
             invalidDateMessage(modifiedBetweenData1);
             return false;
         } else if (!s.modifiedBetween2.isValid()) {
             invalidDateMessage(modifiedBetweenData2);
             return false;
         } else if (s.modifiedBetween1 > s.modifiedBetween2) {
             KMessageBox::detailedError(this, i18n("Dates are inconsistent."),
                                 i18n("The date on the left is later than the date on the right. "
                                      "Please re-enter the dates, so that the left side date "
                                      "will be earlier than the right side date."));
             modifiedBetweenData1->setFocus();
             return false;
         }
     }
 
     s.notModifiedAfterEnabled = notModifiedAfterEnabled->isChecked();
     s.notModifiedAfter = stringToDate(notModifiedAfterData->text());
 
     if(s.notModifiedAfterEnabled && !s.notModifiedAfter.isValid()) {
         invalidDateMessage(notModifiedAfterData);
         return false;
     }
 
     s.modifiedInTheLastEnabled = modifiedInTheLastEnabled->isChecked();
     s.modifiedInTheLast.amount = modifiedInTheLastData->value();
     s.modifiedInTheLast.unit =
         static_cast<FilterSettings::TimeUnit>(modifiedInTheLastType->currentIndex());
     s.notModifiedInTheLast.amount = notModifiedInTheLastData->value();
     s.notModifiedInTheLast.unit =
         static_cast<FilterSettings::TimeUnit>(notModifiedInTheLastType->currentIndex());
 
     if (s.modifiedInTheLastEnabled  &&
             s.modifiedInTheLast.amount && s.notModifiedInTheLast.amount) {
         if (s.modifiedInTheLast.days() < s.notModifiedInTheLast.days()) {
             KMessageBox::detailedError(this, i18n("Dates are inconsistent."),
                                 i18n("The date on top is later than the date on the bottom. "
                                      "Please re-enter the dates, so that the top date "
                                      "will be earlier than the bottom date."));
             modifiedInTheLastData->setFocus();
             return false;
         }
     }
 
     s.ownerEnabled = belongsToUserEnabled->isChecked();
     s.owner = belongsToUserData->currentText();
 
     s.groupEnabled = belongsToGroupEnabled->isChecked();
     s.group = belongsToGroupData->currentText();
 
     s.permissionsEnabled = permissionsEnabled->isChecked();
     s.permissions = ownerR->currentText() + ownerW->currentText() + ownerX->currentText() +
                     groupR->currentText() + groupW->currentText() + groupX->currentText() +
                     allR->currentText()   + allW->currentText()   + allX->currentText();
 
     return true;
 }
 
 void AdvancedFilter::applySettings(const FilterSettings &s)
 {
     minSizeEnabled->setChecked(s.minSizeEnabled);
     minSizeAmount->setValue(s.minSize.amount);
     minSizeType->setCurrentIndex(s.minSize.unit);
 
     maxSizeEnabled->setChecked(s.maxSizeEnabled);
     maxSizeAmount->setValue(s.maxSize.amount);
     maxSizeType->setCurrentIndex(s.maxSize.unit);
 
     if (s.modifiedBetweenEnabled)
         modifiedBetweenEnabled->setChecked(true);
     else if (s.notModifiedAfterEnabled)
         notModifiedAfterEnabled->setChecked(true);
     else if (s.modifiedInTheLastEnabled)
         modifiedInTheLastEnabled->setChecked(true);
     else
         anyDateEnabled->setChecked(true);
 
     modifiedBetweenData1->setText(dateToString(s.modifiedBetween1));
     modifiedBetweenData2->setText(dateToString(s.modifiedBetween2));
 
     notModifiedAfterData->setText(dateToString(s.notModifiedAfter));
 
     modifiedInTheLastData->setValue(s.modifiedInTheLast.amount);
     modifiedInTheLastType->setCurrentIndex(s.modifiedInTheLast.unit);
     notModifiedInTheLastData->setValue(s.notModifiedInTheLast.amount);
     notModifiedInTheLastType->setCurrentIndex(s.notModifiedInTheLast.unit);
 
     belongsToUserEnabled->setChecked(s.ownerEnabled);
     setComboBoxValue(belongsToUserData, s.owner);
 
     belongsToGroupEnabled->setChecked(s.groupEnabled);
     setComboBoxValue(belongsToGroupData, s.group);
 
     permissionsEnabled->setChecked(s.permissionsEnabled);
     QString perm = s.permissions;
     if (perm.length() != 9)
         perm = "?????????";
     setComboBoxValue(ownerR, QString(perm[0]));
     setComboBoxValue(ownerW, QString(perm[1]));
     setComboBoxValue(ownerX, QString(perm[2]));
     setComboBoxValue(groupR, QString(perm[3]));
     setComboBoxValue(groupW, QString(perm[4]));
     setComboBoxValue(groupX, QString(perm[5]));
     setComboBoxValue(allR, QString(perm[6]));
     setComboBoxValue(allW, QString(perm[7]));
     setComboBoxValue(allX, QString(perm[8]));
 }
 
diff --git a/krusader/Filter/advancedfilter.h b/krusader/Filter/advancedfilter.h
index 5b8a0171..5e4f2d65 100644
--- a/krusader/Filter/advancedfilter.h
+++ b/krusader/Filter/advancedfilter.h
@@ -1,120 +1,120 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2003 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef ADVANCEDFILTER_H
 #define ADVANCEDFILTER_H
 
 #include "filterbase.h"
 
 // QtWidgets
 #include <QWidget>
 #include <QCheckBox>
 #include <QRadioButton>
 #include <QToolButton>
 
 #include <KCompletion/KComboBox>
 #include <KCompletion/KLineEdit>
 
 class QSpinBox;
 
 class AdvancedFilter : public QWidget, public FilterBase
 {
     Q_OBJECT
 
 public:
-    explicit AdvancedFilter(FilterTabs *tabs, QWidget *parent = 0);
+    explicit AdvancedFilter(FilterTabs *tabs, QWidget *parent = nullptr);
 
-    virtual void          queryAccepted() Q_DECL_OVERRIDE {}
-    virtual QString       name() Q_DECL_OVERRIDE {
+    void          queryAccepted() Q_DECL_OVERRIDE {}
+    QString       name() Q_DECL_OVERRIDE {
         return "AdvancedFilter";
     }
-    virtual FilterTabs *  filterTabs() Q_DECL_OVERRIDE {
+    FilterTabs *  filterTabs() Q_DECL_OVERRIDE {
         return fltTabs;
     }
-    virtual bool getSettings(FilterSettings&) Q_DECL_OVERRIDE;
-    virtual void applySettings(const FilterSettings&) Q_DECL_OVERRIDE;
+    bool getSettings(FilterSettings&) Q_DECL_OVERRIDE;
+    void applySettings(const FilterSettings&) Q_DECL_OVERRIDE;
 
 public slots:
     void modifiedBetweenSetDate1();
     void modifiedBetweenSetDate2();
     void notModifiedAfterSetDate();
 
 public:
     QCheckBox* minSizeEnabled;
     QSpinBox* minSizeAmount;
     KComboBox* minSizeType;
 
     QCheckBox* maxSizeEnabled;
     QSpinBox* maxSizeAmount;
     KComboBox* maxSizeType;
 
     QRadioButton* anyDateEnabled;
     QRadioButton* modifiedBetweenEnabled;
     QRadioButton* notModifiedAfterEnabled;
     QRadioButton* modifiedInTheLastEnabled;
 
     KLineEdit* modifiedBetweenData1;
     KLineEdit* modifiedBetweenData2;
 
     QToolButton* modifiedBetweenBtn1;
     QToolButton* modifiedBetweenBtn2;
     QToolButton* notModifiedAfterBtn;
 
     KLineEdit* notModifiedAfterData;
     QSpinBox* modifiedInTheLastData;
     QSpinBox* notModifiedInTheLastData;
     KComboBox* modifiedInTheLastType;
     KComboBox* notModifiedInTheLastType;
 
     QCheckBox* belongsToUserEnabled;
     KComboBox* belongsToUserData;
     QCheckBox* belongsToGroupEnabled;
     KComboBox* belongsToGroupData;
 
     QCheckBox* permissionsEnabled;
 
     KComboBox* ownerW;
     KComboBox* ownerR;
     KComboBox* ownerX;
     KComboBox* groupW;
     KComboBox* groupR;
     KComboBox* groupX;
     KComboBox* allW;
     KComboBox* allX;
     KComboBox* allR;
 
     FilterTabs *fltTabs;
 
 private:
     void changeDate(KLineEdit *p);
-    void fillList(KComboBox *list, QString filename);
+    void fillList(KComboBox *list, const QString& filename);
     void invalidDateMessage(KLineEdit *p);
     static QDate stringToDate(const QString& text) {
         // 30.12.16 is interpreted as 1916-12-30
         return QLocale().toDate(text, QLocale::ShortFormat).addYears(100);
     }
     static QString dateToString(const QDate& date) {
         return QLocale().toString(date, QLocale::ShortFormat);
     }
 };
 
 #endif /* ADVANCEDFILTER_H */
diff --git a/krusader/Filter/filterdialog.cpp b/krusader/Filter/filterdialog.cpp
index 7486eb59..10c1360d 100644
--- a/krusader/Filter/filterdialog.cpp
+++ b/krusader/Filter/filterdialog.cpp
@@ -1,106 +1,107 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "filterdialog.h"
 #include "filtertabs.h"
 #include "generalfilter.h"
 
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QGridLayout>
 #include <QPushButton>
 
 #include <KI18n/KLocalizedString>
+#include <utility>
 
-FilterDialog::FilterDialog(QWidget *parent, QString caption, QStringList extraOptions, bool modal)
+FilterDialog::FilterDialog(QWidget *parent, const QString& caption, QStringList extraOptions, bool modal)
         : QDialog(parent)
 {
     setWindowTitle(caption.isNull() ? i18n("Krusader::Choose Files") : caption);
     setModal(modal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
-    QTabWidget *filterWidget = new QTabWidget;
+    auto *filterWidget = new QTabWidget;
 
-    filterTabs = FilterTabs::addTo(filterWidget, FilterTabs::HasProfileHandler, extraOptions);
-    generalFilter = static_cast<GeneralFilter*> (filterTabs->get("GeneralFilter"));
+    filterTabs = FilterTabs::addTo(filterWidget, FilterTabs::HasProfileHandler, std::move(extraOptions));
+    generalFilter = dynamic_cast<GeneralFilter*> (filterTabs->get("GeneralFilter"));
 
     mainLayout->addWidget(filterWidget);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel|QDialogButtonBox::Reset);
     mainLayout->addWidget(buttonBox);
 
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &FilterDialog::slotOk);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &FilterDialog::reject);
     connect(buttonBox->button(QDialogButtonBox::Reset), &QPushButton::clicked, this, &FilterDialog::slotReset);
     connect(filterTabs, &FilterTabs::closeRequest, this, &FilterDialog::slotCloseRequest);
 
     generalFilter->searchFor->setFocus();
 
     if(modal)
         exec();
 }
 
 void FilterDialog::applySettings(const FilterSettings &s)
 {
     filterTabs->applySettings(s);
 }
 
 KRQuery FilterDialog::getQuery()
 {
     return settings.toQuery();
 }
 
 bool FilterDialog::isExtraOptionChecked(QString name)
 {
-    return filterTabs->isExtraOptionChecked(name);
+    return filterTabs->isExtraOptionChecked(std::move(name));
 }
 
 void FilterDialog::checkExtraOption(QString name, bool check)
 {
-    filterTabs->checkExtraOption(name, check);
+    filterTabs->checkExtraOption(std::move(name), check);
 }
 
 void FilterDialog::slotCloseRequest(bool doAccept)
 {
     if (doAccept) {
         slotOk();
         accept();
     } else
         reject();
 }
 
 void FilterDialog::slotReset()
 {
     filterTabs->reset();
     generalFilter->searchFor->setFocus();
 }
 
 void FilterDialog::slotOk()
 {
     settings = filterTabs->getSettings();
     if(settings.isValid())
         accept();
 }
 
diff --git a/krusader/Filter/filterdialog.h b/krusader/Filter/filterdialog.h
index 1b8a6c74..a62f0279 100644
--- a/krusader/Filter/filterdialog.h
+++ b/krusader/Filter/filterdialog.h
@@ -1,59 +1,59 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef FILTERDIALOG_H
 #define FILTERDIALOG_H
 
 #include "filtersettings.h"
 #include "../FileSystem/krquery.h"
 
 // QtWidgets
 #include <QDialog>
 
 class FilterTabs;
 class GeneralFilter;
 
 class FilterDialog : public QDialog
 {
     Q_OBJECT
 
 public:
-    explicit FilterDialog(QWidget *parent = 0, QString caption = QString(),
+    explicit FilterDialog(QWidget *parent = nullptr, const QString& caption = QString(),
                  QStringList extraOptions = QStringList(), bool modal = true);
     KRQuery getQuery();
     const FilterSettings& getSettings() {
         return settings;
     }
     void applySettings(const FilterSettings &s);
     bool isExtraOptionChecked(QString name);
     void checkExtraOption(QString name, bool check);
 
 public slots:
     void slotCloseRequest(bool doAccept);
     void slotReset();
     void slotOk();
 
 private:
     FilterTabs * filterTabs;
     GeneralFilter * generalFilter;
     FilterSettings settings;
 };
 
 #endif /* FILTERDIALOG_H */
diff --git a/krusader/Filter/filtersettings.cpp b/krusader/Filter/filtersettings.cpp
index 96f8ce34..d5789902 100644
--- a/krusader/Filter/filtersettings.cpp
+++ b/krusader/Filter/filtersettings.cpp
@@ -1,329 +1,321 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2003 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2011 by Jan Lepper <jan_lepper@gmx.de>                      *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "filtersettings.h"
 
 #include "../krservices.h"
 
 #include <QDebug>
 
 #include <KCodecs/KCharsets>
 
 FilterSettings::FileSize& FilterSettings::FileSize::operator=(const FileSize &other)
-{
-    amount = other.amount;
-    unit = other.unit;
-    return *this;
-}
+= default;
 
 KIO::filesize_t FilterSettings::FileSize::size() const
 {
     switch (unit) {
     case Byte:
         return amount;
     case KiloByte:
         return amount * 1024;
     case MegaByte:
         return amount * 1024 * 1024;
     case GigaByte:
         return amount * 1024 * 1024 * 1024;
     default:
         qWarning() << "invalid size unit: " << unit;
         return amount;
     }
 }
 
 
 FilterSettings::TimeSpan& FilterSettings::TimeSpan::operator=(const TimeSpan &other)
-{
-    amount = other.amount;
-    unit = other.unit;
-    return *this;
-}
+= default;
 
 int FilterSettings::TimeSpan::days() const
 {
     switch (unit) {
     case Day:
         return amount;
     case Week:
         return amount * 7;
     case Month:
         return amount * 30;
     case Year:
         return amount * 365;
     default:
         qWarning() << "invalid time unit: " << unit;
         return amount;
     }
 }
 
 
 FilterSettings::FilterSettings() :
     valid(false),
     searchFor("*"),
     searchForCase(false),
     searchInArchives(false),
     recursive(false),
     followLinks(false),
     containsTextCase(false),
     containsWholeWord(false),
     containsRegExp(false),
     minSizeEnabled(false),
     maxSizeEnabled(false),
     modifiedBetweenEnabled(false),
     notModifiedAfterEnabled(false),
     modifiedInTheLastEnabled(false),
     ownerEnabled(false),
     groupEnabled(false),
     permissionsEnabled(false)
 {
 }
 
 FilterSettings& FilterSettings::operator=(const FilterSettings& other)
 {
 #define COPY(var) { var = other.var; }
     COPY(valid);
     COPY(searchFor);
     COPY(searchForCase);
     COPY(mimeType);
     COPY(searchInArchives);
     COPY(recursive);
     COPY(followLinks);
     COPY(searchIn);
     COPY(dontSearchIn);
     COPY(excludeFolderNames);
     COPY(contentEncoding);
     COPY(containsText);
     COPY(containsTextCase);
     COPY(containsWholeWord);
     COPY(containsRegExp);
     COPY(minSizeEnabled);
     COPY(minSize);
     COPY(maxSizeEnabled);
     COPY(maxSize);
     COPY(modifiedBetweenEnabled);
     COPY(modifiedBetween1);
     COPY(modifiedBetween2);
     COPY(notModifiedAfterEnabled);
     COPY(notModifiedAfter);
     COPY(modifiedInTheLastEnabled);
     COPY(modifiedInTheLast);
     COPY(notModifiedInTheLast);
     COPY(ownerEnabled);
     COPY(owner);
     COPY(groupEnabled);
     COPY(group);
     COPY(permissionsEnabled);
     COPY(permissions);
 #undef COPY
     return *this;
 }
 
-void FilterSettings::load(KConfigGroup cfg) {
+void FilterSettings::load(const KConfigGroup& cfg) {
     *this = FilterSettings();
 #define LOAD(key, var) { var = cfg.readEntry(key, var); }
     LOAD("IsValid", valid);
     if(!isValid())
         return;
     LOAD("SearchFor", searchFor);
     LOAD("MimeType", mimeType);
     LOAD("SearchInArchives", searchInArchives);
     LOAD("Recursive", recursive);
     LOAD("FollowLinks", followLinks);
     searchIn = KrServices::toUrlList(cfg.readEntry("SearchIn", QStringList()));
     dontSearchIn = KrServices::toUrlList(cfg.readEntry("DontSearchIn", QStringList()));
     excludeFolderNames = QStringList();
     LOAD("ContentEncoding", contentEncoding);
     LOAD("ContainsText", containsText);
     LOAD("ContainsTextCase", containsTextCase);
     LOAD("ContainsWholeWord", containsWholeWord);
     LOAD("ContainsRegExp", containsRegExp);
     LOAD("MinSizeEnabled", minSizeEnabled);
     LOAD("MinSizeAmount", minSize.amount);
     minSize.unit = static_cast<SizeUnit>(cfg.readEntry("MinSizeUnit", 0));
     LOAD("MaxSizeEnabled", maxSizeEnabled);
     LOAD("MaxSizeAmount", maxSize.amount);
     maxSize.unit = static_cast<SizeUnit>(cfg.readEntry("MaxSizeUnit", 0));
     LOAD("ModifiedBetweenEnabled", modifiedBetweenEnabled);
     LOAD("ModifiedBetween1", modifiedBetween1);
     LOAD("ModifiedBetween2", modifiedBetween2);
     LOAD("NotModifiedAfterEnabled", notModifiedAfterEnabled);
     LOAD("NotModifiedAfter", notModifiedAfter);
     LOAD("ModifiedInTheLastEnabled", modifiedInTheLastEnabled);
     LOAD("ModifiedInTheLastAmount", modifiedInTheLast.amount);
     modifiedInTheLast.unit =
             static_cast<TimeUnit>(cfg.readEntry("ModifiedInTheLastUnit", 0));
     LOAD("NotModifiedInTheLastAmount", notModifiedInTheLast.amount);
     notModifiedInTheLast.unit =
             static_cast<TimeUnit>(cfg.readEntry("NotModifiedInTheLastUnit", 0));
     LOAD("OwnerEnabled", ownerEnabled);
     LOAD("Owner", owner);
     LOAD("GroupEnabled", groupEnabled);
     LOAD("Group", group);
     LOAD("PermissionsEnabled", permissionsEnabled);
     LOAD("Permissions", permissions);
 #undef LOAD
 }
 
-void FilterSettings::saveDate(QString key, const QDate &date, KConfigGroup &cfg)
+void FilterSettings::saveDate(const QString& key, const QDate &date, KConfigGroup &cfg)
 {
     if(date.isValid())
         cfg.writeEntry(key, date);
     else
         cfg.deleteEntry(key);
 }
 
 void FilterSettings::save(KConfigGroup cfg) const
 {
     cfg.writeEntry("IsValid", valid);
     if(!isValid())
         return;
     cfg.writeEntry("SearchFor", searchFor);
     cfg.writeEntry("MimeType", mimeType);
     cfg.writeEntry("SearchInArchives", searchInArchives);
     cfg.writeEntry("Recursive", recursive);
     cfg.writeEntry("FollowLinks", followLinks);
     cfg.writeEntry("SearchIn", KrServices::toStringList(searchIn));
     cfg.writeEntry("DontSearchIn", KrServices::toStringList(dontSearchIn));
     cfg.writeEntry("ContentEncoding", contentEncoding);
     cfg.writeEntry("ContainsText", containsText);
     cfg.writeEntry("ContainsTextCase", containsTextCase);
     cfg.writeEntry("ContainsWholeWord", containsWholeWord);
     cfg.writeEntry("ContainsRegExp", containsRegExp);
     cfg.writeEntry("MinSizeEnabled", minSizeEnabled);
     cfg.writeEntry("MinSizeAmount", minSize.amount);
     cfg.writeEntry("MinSizeUnit", static_cast<int>(minSize.unit));
     cfg.writeEntry("MaxSizeEnabled", maxSizeEnabled);
     cfg.writeEntry("MaxSizeAmount", maxSize.amount);
     cfg.writeEntry("MaxSizeUnit", static_cast<int>(maxSize.unit));
     cfg.writeEntry("ModifiedBetweenEnabled", modifiedBetweenEnabled);
     saveDate("ModifiedBetween1", modifiedBetween1, cfg);
     saveDate("ModifiedBetween2", modifiedBetween2, cfg);
     cfg.writeEntry("NotModifiedAfterEnabled", notModifiedAfterEnabled);
     saveDate("NotModifiedAfter", notModifiedAfter, cfg);
     cfg.writeEntry("ModifiedInTheLastEnabled", modifiedInTheLastEnabled);
     cfg.writeEntry("ModifiedInTheLastAmount", modifiedInTheLast.amount);
     cfg.writeEntry("ModifiedInTheLastUnit",
                         static_cast<int>(modifiedInTheLast.unit));
     cfg.writeEntry("NotModifiedInTheLastAmount", notModifiedInTheLast.amount);
     cfg.writeEntry("NotModifiedInTheLastUnit",
                         static_cast<int>(notModifiedInTheLast.unit));
     cfg.writeEntry("OwnerEnabled", ownerEnabled);
     cfg.writeEntry("Owner", owner);
     cfg.writeEntry("GroupEnabled", groupEnabled);
     cfg.writeEntry("Group", group);
     cfg.writeEntry("PermissionsEnabled", permissionsEnabled);
     cfg.writeEntry("Permissions", permissions);
 }
 
 // bool start: set it to true if this date is the beginning of the search,
 // if it's the end, set it to false
 time_t FilterSettings::qdate2time_t (QDate d, bool start)
 {
     struct tm t;
     t.tm_sec   = (start ? 0 : 59);
     t.tm_min   = (start ? 0 : 59);
     t.tm_hour  = (start ? 0 : 23);
     t.tm_mday  = d.day();
     t.tm_mon   = d.month() - 1;
     t.tm_year  = d.year() - 1900;
     t.tm_wday  = d.dayOfWeek() - 1; // actually ignored by mktime
     t.tm_yday  = d.dayOfYear() - 1; // actually ignored by mktime
     t.tm_isdst = -1; // daylight saving time information isn't available
 
     return mktime(&t);
 }
 
 KRQuery FilterSettings::toQuery() const
 {
     if(!isValid())
         return KRQuery();
 
     KRQuery query;
 
     ////////////// General Options //////////////
 
     query.setNameFilter(searchFor, searchForCase);
 
     query.setMimeType(mimeType);
 
     QString charset;
     if (!contentEncoding.isEmpty())
         charset = KCharsets::charsets()->encodingForName(contentEncoding);
 
     if (!containsText.isEmpty()) {
         query.setContent(containsText,
                         containsTextCase,
                         containsWholeWord,
                         charset,
                         containsRegExp);
     }
 
     query.setRecursive(recursive);
     query.setSearchInArchives(searchInArchives);
     query.setFollowLinks(followLinks);
 
     if (!searchIn.isEmpty())
         query.setSearchInDirs(searchIn);
 
     if (!dontSearchIn.isEmpty())
         query.setDontSearchInDirs(dontSearchIn);
 
     query.setExcludeFolderNames(excludeFolderNames);
 
     ////////////// Advanced Options //////////////
 
     if (minSizeEnabled)
         query.setMinimumFileSize(minSize.size());
 
     if (maxSizeEnabled)
         query.setMaximumFileSize(maxSize.size());
 
     if (modifiedBetweenEnabled) {
         if(modifiedBetween1.isValid())
             query.setNewerThan(qdate2time_t(modifiedBetween1, true));
         if(modifiedBetween2.isValid())
             query.setOlderThan(qdate2time_t(modifiedBetween2, false));
     } else if (notModifiedAfterEnabled && notModifiedAfter.isValid()) {
         query.setOlderThan(qdate2time_t(notModifiedAfter, false));
     } else if (modifiedInTheLastEnabled) {
         if (modifiedInTheLast.amount) {
             QDate d = QDate::currentDate().addDays((-1) * modifiedInTheLast.days());
             query.setNewerThan(qdate2time_t(d, true));
         }
         if (notModifiedInTheLast.amount) {
             QDate d = QDate::currentDate().addDays((-1) * notModifiedInTheLast.days());
             query.setOlderThan(qdate2time_t(d, true));
         }
     }
 
     if (ownerEnabled && !owner.isEmpty())
         query.setOwner(owner);
     if (groupEnabled && !group.isEmpty())
         query.setGroup(group);
     if (permissionsEnabled && !permissions.isEmpty())
         query.setPermissions(permissions);
 
     return query;
 }
diff --git a/krusader/Filter/filtersettings.h b/krusader/Filter/filtersettings.h
index 3732940f..a40d1ca2 100644
--- a/krusader/Filter/filtersettings.h
+++ b/krusader/Filter/filtersettings.h
@@ -1,117 +1,117 @@
 /*****************************************************************************
  * Copyright (C) 2011 Jan Lepper <jan_lepper@gmx.de>                         *
  * Copyright (C) 2011-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef FILTERSETTINGS_H
 #define FILTERSETTINGS_H
 
 #include "../FileSystem/krquery.h"
 
 #include <KConfigCore/KConfigGroup>
 
 
 class FilterSettings
 {
     friend class FilterTabs;
     friend class GeneralFilter;
     friend class AdvancedFilter;
 
 public:
     FilterSettings();
     FilterSettings& operator=(const FilterSettings& other);
 
     bool isValid() const {
         return valid;
     }
-    void load(KConfigGroup cfg);
+    void load(const KConfigGroup& cfg);
     void save(KConfigGroup cfg) const;
     KRQuery toQuery() const;
 
 private:
     enum SizeUnit {
         Byte = 0, KiloByte, MegaByte, GigaByte
     };
 
     enum TimeUnit {
         Day = 0, Week, Month, Year
     };
 
     class FileSize
     {
     public:
         FileSize() : amount(0), unit(Byte) {}
         FileSize& operator=(const FileSize &other);
 
         KIO::filesize_t size() const;
 
         KIO::filesize_t amount;
         SizeUnit unit;
     };
 
     class TimeSpan
     {
     public:
         TimeSpan() : amount(0), unit(Day) {}
         TimeSpan& operator=(const TimeSpan &other);
 
         int days() const;
 
         int amount;
         TimeUnit unit;
     };
 
-    static void saveDate(QString key, const QDate &date, KConfigGroup &cfg);
+    static void saveDate(const QString& key, const QDate &date, KConfigGroup &cfg);
     static time_t qdate2time_t(QDate d, bool start);
 
     bool valid;
     QString searchFor;
     bool searchForCase;
     QString mimeType;
     bool searchInArchives;
     bool recursive;
     bool followLinks;
     QList<QUrl> searchIn;
     QList<QUrl> dontSearchIn;
     QStringList excludeFolderNames;
     QString contentEncoding;
     QString containsText;
     bool containsTextCase;
     bool containsWholeWord;
     bool containsRegExp;
     bool minSizeEnabled;
     FileSize minSize;
     bool maxSizeEnabled;
     FileSize maxSize;
     bool modifiedBetweenEnabled;
     QDate modifiedBetween1;
     QDate modifiedBetween2;
     bool notModifiedAfterEnabled;
     QDate notModifiedAfter;
     bool modifiedInTheLastEnabled;
     TimeSpan modifiedInTheLast;
     TimeSpan notModifiedInTheLast;
     bool ownerEnabled;
     QString owner;
     bool groupEnabled;
     QString group;
     bool permissionsEnabled;
     QString permissions;
 };
 
 #endif //FILTERSETTINGS_H
diff --git a/krusader/Filter/filtertabs.cpp b/krusader/Filter/filtertabs.cpp
index 585a3dde..0c5dc88e 100644
--- a/krusader/Filter/filtertabs.cpp
+++ b/krusader/Filter/filtertabs.cpp
@@ -1,155 +1,156 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "filtertabs.h"
 #include "filterdialog.h"
 #include "generalfilter.h"
 #include "advancedfilter.h"
 #include "../krglobal.h"
 
 // QtWidgets
 #include <QTabWidget>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
+#include <utility>
 
 
 FilterTabs::FilterTabs(int properties, QTabWidget *tabWidget,
                        QObject *parent, QStringList extraOptions) :
         QObject(parent)
 {
     this->tabWidget = tabWidget;
 
-    GeneralFilter *generalFilter = new GeneralFilter(this, properties, tabWidget, extraOptions);
+    GeneralFilter *generalFilter = new GeneralFilter(this, properties, tabWidget, std::move(extraOptions));
     tabWidget->addTab(generalFilter, i18n("&General"));
     filterList.append(generalFilter);
     pageNumbers.append(tabWidget->indexOf(generalFilter));
 
-    AdvancedFilter *advancedFilter = new AdvancedFilter(this, tabWidget);
+    auto *advancedFilter = new AdvancedFilter(this, tabWidget);
     tabWidget->addTab(advancedFilter, i18n("&Advanced"));
     filterList.append(advancedFilter);
     pageNumbers.append(tabWidget->indexOf(advancedFilter));
 
     reset(); // apply defaults
 }
 
 bool FilterTabs::isExtraOptionChecked(QString name)
 {
-    return static_cast<GeneralFilter*>(get("GeneralFilter"))->isExtraOptionChecked(name);
+    return dynamic_cast<GeneralFilter*>(get("GeneralFilter"))->isExtraOptionChecked(std::move(name));
 }
 
 void FilterTabs::checkExtraOption(QString name, bool check)
 {
-    static_cast<GeneralFilter*>(get("GeneralFilter"))->checkExtraOption(name, check);
+    dynamic_cast<GeneralFilter*>(get("GeneralFilter"))->checkExtraOption(std::move(name), check);
 }
 
 FilterTabs * FilterTabs::addTo(QTabWidget *tabWidget, int props, QStringList extraOptions)
 {
-    return new FilterTabs(props, tabWidget, tabWidget, extraOptions);
+    return new FilterTabs(props, tabWidget, tabWidget, std::move(extraOptions));
 }
 
 FilterSettings FilterTabs::getSettings()
 {
     FilterSettings s;
 
     for (int i = 0; i != filterList.count(); i++) {
         if(!filterList[i]->getSettings(s)) {
             tabWidget->setCurrentIndex(pageNumbers[i]);
             return FilterSettings();
         }
     }
 
     s.valid = true;
     acceptQuery();
 
     return s;
 }
 
 void FilterTabs::applySettings(const FilterSettings &s)
 {
     if(s.isValid()) {
         QListIterator<FilterBase*> it(filterList);
         while (it.hasNext())
             it.next()->applySettings(s);
     }
 }
 
 void FilterTabs::reset()
 {
     FilterSettings s; // default settings
     s.valid = true;
     applySettings(s);
 }
 
-void FilterTabs::saveToProfile(QString name)
+void FilterTabs::saveToProfile(const QString& name)
 {
     FilterSettings s(getSettings());
     if(s.isValid())
         s.save(KConfigGroup(krConfig, name));
     krConfig->sync();
 }
 
-void FilterTabs::loadFromProfile(QString name)
+void FilterTabs::loadFromProfile(const QString& name)
 {
     FilterSettings s;
     s.load(KConfigGroup(krConfig, name));
     if(!s.isValid())
         KMessageBox::error(tabWidget, i18n("Could not load profile."));
     else
         applySettings(s);
 }
 
 void FilterTabs::acceptQuery()
 {
     QListIterator<FilterBase *> it(filterList);
     while (it.hasNext()) {
         FilterBase *filter = it.next();
 
         filter->queryAccepted();
     }
 }
 
 bool FilterTabs::fillQuery(KRQuery *query)
 {
     *query = getSettings().toQuery();
 
     return !query->isNull();
 }
 
-FilterBase * FilterTabs::get(QString name)
+FilterBase * FilterTabs::get(const QString& name)
 {
     QListIterator<FilterBase *> it(filterList);
     while (it.hasNext()) {
         FilterBase *filter = it.next();
 
         if (filter->name() == name)
             return filter;
     }
 
-    return 0;
+    return nullptr;
 }
 
 KRQuery FilterTabs::getQuery(QWidget *parent)
 {
     FilterDialog dialog(parent);
     return dialog.getQuery();
 }
 
diff --git a/krusader/Filter/filtertabs.h b/krusader/Filter/filtertabs.h
index 4774a22d..7cc9312c 100644
--- a/krusader/Filter/filtertabs.h
+++ b/krusader/Filter/filtertabs.h
@@ -1,78 +1,78 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef FILTERTABS_H
 #define FILTERTABS_H
 
 // QtCore
 #include <QList>
 
 #include "filterbase.h"
 
 class QTabWidget;
 
 class FilterTabs : public QObject
 {
     Q_OBJECT
 
 public:
 
     enum {
         HasProfileHandler       =   0x1000,
         HasRecurseOptions       =   0x2000,
         HasSearchIn             =   0x4000,
         HasDontSearchIn         =   0x8000,
 
         Default                 =   0xe000
     };
 
     static FilterTabs * addTo(QTabWidget *tabWidget, int props = FilterTabs::Default,
                               QStringList extraOptions = QStringList());
-    static KRQuery      getQuery(QWidget *parent = 0);
+    static KRQuery      getQuery(QWidget *parent = nullptr);
 
-    FilterBase *get(QString name);
+    FilterBase *get(const QString& name);
     bool isExtraOptionChecked(QString name);
     void checkExtraOption(QString name, bool check);
     FilterSettings getSettings();
     void applySettings(const FilterSettings &s);
     void reset();
 
 public slots:
-    void  loadFromProfile(QString);
-    void  saveToProfile(QString);
+    void  loadFromProfile(const QString&);
+    void  saveToProfile(const QString&);
     bool  fillQuery(KRQuery *query);
     void  close(bool accept = true) {
         emit closeRequest(accept);
     }
 
 signals:
     void  closeRequest(bool accept = true);
 
 private:
     FilterTabs(int properties, QTabWidget *tabWidget, QObject *parent, QStringList extraOptions);
     void  acceptQuery();
 
     QList<FilterBase *> filterList;
     QList<int>      pageNumbers;
 
     QTabWidget * tabWidget;
 };
 
 #endif /* FILTERTABS_H */
diff --git a/krusader/Filter/generalfilter.cpp b/krusader/Filter/generalfilter.cpp
index 3afcb6ef..4cd0b0ab 100644
--- a/krusader/Filter/generalfilter.cpp
+++ b/krusader/Filter/generalfilter.cpp
@@ -1,666 +1,666 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2003 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "generalfilter.h"
 #include "filtertabs.h"
 #include "../krglobal.h"
 #include "../krservices.h"
 #include "../FileSystem/filesystem.h"
 
 // QtWidgets
 #include <QPushButton>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QLabel>
 #include <QMenu>
 
 #include <KCodecs/KCharsets>
 #include <KConfigCore/KSharedConfig>
 #include <KCoreAddons/KShell>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 typedef struct {
     const char *description;
     const char *regExp;
     int cursorAdjustment;
 } term;
 
 static const term items[] = {
     { I18N_NOOP("Any Character"),                 ".",        0 },
     { I18N_NOOP("Start of Line"),                 "^",        0 },
     { I18N_NOOP("End of Line"),                   "$",        0 },
     { I18N_NOOP("Set of Characters"),             "[]",       -1 },
     { I18N_NOOP("Repeats, Zero or More Times"),   "*",        0 },
     { I18N_NOOP("Repeats, One or More Times"),    "+",        0 },
     { I18N_NOOP("Optional"),                      "?",        0 },
     { I18N_NOOP("Escape"),                        "\\",       0 },
     { I18N_NOOP("TAB"),                           "\\t",      0 },
     { I18N_NOOP("Newline"),                       "\\n",      0 },
     { I18N_NOOP("Carriage Return"),               "\\r",      0 },
     { I18N_NOOP("White Space"),                   "\\s",      0 },
     { I18N_NOOP("Digit"),                         "\\d",      0 },
 };
 
 class RegExpAction : public QAction
 {
 public:
     RegExpAction(QObject *parent, const QString &text, const QString &regExp, int cursor)
             : QAction(text, parent), mText(text), mRegExp(regExp), mCursor(cursor) {
     }
 
     QString text() const {
         return mText;
     }
     QString regExp() const {
         return mRegExp;
     }
     int cursor() const {
         return mCursor;
     }
 
 private:
     QString mText;
     QString mRegExp;
     int mCursor;
 };
 
 GeneralFilter::GeneralFilter(FilterTabs *tabs, int properties, QWidget *parent,
                              QStringList extraOptions) :
         QWidget(parent),
-        profileManager(0), fltTabs(tabs)
+        profileManager(nullptr), fltTabs(tabs)
 {
-    QGridLayout *filterLayout = new QGridLayout(this);
+    auto *filterLayout = new QGridLayout(this);
     filterLayout->setSpacing(6);
     filterLayout->setContentsMargins(11, 11, 11, 11);
 
     this->properties = properties;
 
     // Options for name filtering
 
-    QGroupBox *nameGroup = new QGroupBox(this);
+    auto *nameGroup = new QGroupBox(this);
     nameGroup->setTitle(i18n("File Name"));
-    QGridLayout *nameGroupLayout = new QGridLayout(nameGroup);
+    auto *nameGroupLayout = new QGridLayout(nameGroup);
     nameGroupLayout->setAlignment(Qt::AlignTop);
     nameGroupLayout->setSpacing(6);
     nameGroupLayout->setContentsMargins(11, 11, 11, 11);
 
     searchForCase = new QCheckBox(nameGroup);
     searchForCase->setText(i18n("&Case sensitive"));
     searchForCase->setChecked(false);
     nameGroupLayout->addWidget(searchForCase, 1, 2);
 
     QLabel *searchForLabel = new QLabel(nameGroup);
     searchForLabel->setText(i18n("Search &for:"));
     nameGroupLayout->addWidget(searchForLabel, 0, 0);
 
     searchFor = new KHistoryComboBox(false, nameGroup/*, "searchFor"*/);
     QSizePolicy searchForPolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     searchForPolicy.setHeightForWidth(searchFor->sizePolicy().hasHeightForWidth());
     searchFor->setSizePolicy(searchForPolicy);
     searchFor->setEditable(true);
     searchFor->setDuplicatesEnabled(false);
     searchFor->setMaxCount(25);
     searchFor->setMinimumContentsLength(10);
     searchForLabel->setBuddy(searchFor);
     nameGroupLayout->addWidget(searchFor, 0, 1, 1, 2);
 
     const QString s = "<p><img src='toolbar|find'></p>"
                       + i18n("<p>The filename filtering criteria is defined here.</p>"
                              "<p>You can make use of wildcards. Multiple patterns are separated by "
                              "space (means logical OR) and patterns are excluded from the search "
                              "using the pipe symbol.</p>"
                              "<p>If the pattern is ended with a slash (<code>*pattern*/</code>), "
                              "that means that pattern relates to recursive search of folders."
                              "<ul><li><code>pattern</code> - means to search those files/folders "
                              "that name is <code>pattern</code>, recursive search goes through all "
                              "subfolders independently of the value of <code>pattern</code></li>"
                              "<li><code>pattern/</code> - means to search all files/folders, but "
                              "recursive search goes through/excludes the folders that name is "
                              "<code>pattern</code></li></ul></p>"
                              "<p>It is allowed to use quotation marks for names that contain space."
                              " Filter <code>\"Program&nbsp;Files\"</code> searches out those "
                              "files/folders that name is <code>Program&nbsp;Files</code>.</p>"
                              "<p>Examples:</p><ul>"
                              "<li><code>*.o</code></li>"
                              "<li><code>*.h *.c\?\?</code></li>"
                              "<li><code>*.cpp *.h | *.moc.cpp</code></li>"
                              "<li><code>* | .svn/ .git/</code></li></ul><p>"
                              "<b>Note</b>: the search term '<code>text</code>' is equivalent to "
                              "'<code>*text*</code>'.</p>");
     searchFor->setWhatsThis(s);
     searchForLabel->setWhatsThis(s);
 
     QLabel *searchType = new QLabel(nameGroup);
     searchType->setText(i18n("&Of type:"));
     nameGroupLayout->addWidget(searchType, 1, 0);
 
     ofType = new KComboBox(false, nameGroup);
     ofType->setObjectName("ofType");
     QSizePolicy ofTypePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     ofTypePolicy.setHeightForWidth(ofType->sizePolicy().hasHeightForWidth());
     ofType->setSizePolicy(ofTypePolicy);
     ofType->setEditable(false);
     searchType->setBuddy(ofType);
     ofType->addItem(i18n("All Files"));
     ofType->addItem(i18n("Archives"));
     ofType->addItem(i18n("Folders"));
     ofType->addItem(i18n("Image Files"));
     ofType->addItem(i18n("Text Files"));
     ofType->addItem(i18n("Video Files"));
     ofType->addItem(i18n("Audio Files"));
     connect(ofType, QOverload<int>::of(&KComboBox::currentIndexChanged), this, &GeneralFilter::slotDisable);
 
     nameGroupLayout->addWidget(ofType, 1, 1);
     filterLayout->addWidget(nameGroup, 0, 0);
 
     middleLayout = new QHBoxLayout();
     middleLayout->setSpacing(6);
     middleLayout->setContentsMargins(0, 0, 0, 0);
 
     if (properties & FilterTabs::HasProfileHandler) {
         // The profile handler
 
-        QGroupBox *profileHandler = new QGroupBox(this);
+        auto *profileHandler = new QGroupBox(this);
         profileHandler->setTitle(i18n("&Profile handler"));
-        QGridLayout *profileLayout = new QGridLayout(profileHandler);
+        auto *profileLayout = new QGridLayout(profileHandler);
         profileLayout->setAlignment(Qt::AlignTop);
         profileLayout->setSpacing(6);
         profileLayout->setContentsMargins(11, 11, 11, 11);
 
         profileListBox = new KrListWidget(profileHandler);
         profileLayout->addWidget(profileListBox, 0, 0, 4, 1);
 
         profileAddBtn = new QPushButton(profileHandler);
         KStandardGuiItem::assign(profileAddBtn, KStandardGuiItem::Add);
         profileLayout->addWidget(profileAddBtn, 0, 1);
 
         profileLoadBtn = new QPushButton(i18n("&Load"), profileHandler);
         profileLoadBtn->setEnabled(false);
         profileLayout->addWidget(profileLoadBtn, 1, 1);
 
         profileOverwriteBtn = new QPushButton(profileHandler);
         profileOverwriteBtn->setEnabled(false);
         KStandardGuiItem::assign(profileOverwriteBtn, KStandardGuiItem::Overwrite);
         profileLayout->addWidget(profileOverwriteBtn, 2, 1);
 
         profileRemoveBtn = new QPushButton(profileHandler);
         profileRemoveBtn->setEnabled(false);
         KStandardGuiItem::assign(profileRemoveBtn, KStandardGuiItem::Remove);
         profileLayout->addWidget(profileRemoveBtn, 3, 1);
 
         profileManager = new ProfileManager("SelectionProfile", this);
         profileManager->hide();
 
         middleLayout->addWidget(profileHandler);
 
         refreshProfileListBox();
     }
 
     if (properties & FilterTabs::HasSearchIn) {
         // Options for search in
         QGroupBox *searchGroupBox = new QGroupBox(i18n("Searc&h in"), this);
-        QGridLayout *searchLayout = new QGridLayout(searchGroupBox);
+        auto *searchLayout = new QGridLayout(searchGroupBox);
         searchLayout->setAlignment(Qt::AlignTop);
         searchLayout->setSpacing(6);
         searchLayout->setContentsMargins(11, 11, 11, 11);
 
         searchIn = new KURLListRequester(KURLListRequester::RequestDirs, searchGroupBox);
         searchLayout->addWidget(searchIn, 0, 0);
         connect(searchIn, &KURLListRequester::changed, this, &GeneralFilter::slotDisable);
 
         middleLayout->addWidget(searchGroupBox);
     }
 
     if (properties & FilterTabs::HasDontSearchIn) {
         // Options for don't search in
         QGroupBox *searchGroupBox = new QGroupBox(i18n("&Do not search in"), this);
-        QGridLayout *searchLayout = new QGridLayout(searchGroupBox);
+        auto *searchLayout = new QGridLayout(searchGroupBox);
         searchLayout->setAlignment(Qt::AlignTop);
         searchLayout->setSpacing(6);
         searchLayout->setContentsMargins(11, 11, 11, 11);
 
         dontSearchIn = new KURLListRequester(KURLListRequester::RequestDirs, searchGroupBox);
         searchLayout->addWidget(dontSearchIn, 0, 0, 1, 2);
 
         if (properties & FilterTabs::HasRecurseOptions) {
             KConfigGroup group(krConfig, "Search");
 
             useExcludeFolderNames = createExcludeCheckBox(group);
             searchLayout->addWidget(useExcludeFolderNames, 1, 0, 1, 1);
 
             excludeFolderNames = createExcludeComboBox(group);
             searchLayout->addWidget(excludeFolderNames, 1, 1, 1, 1);
 
             if (!useExcludeFolderNames->isChecked()) {
                 excludeFolderNames->setDisabled(true);
             }
 
             connect(useExcludeFolderNames, &QCheckBox::toggled, excludeFolderNames, &KHistoryComboBox::setEnabled);
         }
 
         middleLayout->addWidget(searchGroupBox);
     }
 
     filterLayout->addLayout(middleLayout, 1, 0);
 
     // Options for containing text
 
-    QGroupBox *containsGroup = new QGroupBox(this);
+    auto *containsGroup = new QGroupBox(this);
     containsGroup->setTitle(i18n("Containing text"));
-    QGridLayout *containsLayout = new QGridLayout(containsGroup);
+    auto *containsLayout = new QGridLayout(containsGroup);
     containsLayout->setAlignment(Qt::AlignTop);
     containsLayout->setSpacing(6);
     containsLayout->setContentsMargins(11, 11, 11, 11);
 
-    QHBoxLayout *containsTextLayout = new QHBoxLayout();
+    auto *containsTextLayout = new QHBoxLayout();
     containsTextLayout->setSpacing(6);
     containsTextLayout->setContentsMargins(0, 0, 0, 0);
 
     containsLabel = new QLabel(containsGroup);
     QSizePolicy containsLabelPolicy(QSizePolicy::Fixed, QSizePolicy::Minimum);
     containsLabelPolicy.setHeightForWidth(containsLabel->sizePolicy().hasHeightForWidth());
     containsLabel->setSizePolicy(containsLabelPolicy);
     containsLabel->setText(i18n("&Text:"));
     containsTextLayout->addWidget(containsLabel);
 
     containsText = new KHistoryComboBox(false, containsGroup/*, "containsText"*/);
     QSizePolicy containsTextPolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     containsTextPolicy.setHeightForWidth(containsText->sizePolicy().hasHeightForWidth());
     containsText->setSizePolicy(containsTextPolicy);
     containsText->setDuplicatesEnabled(false);
     containsText->setMaxCount(25);
     containsText->setMinimumContentsLength(10);
     containsTextLayout->addWidget(containsText);
     containsLabel->setBuddy(containsText);
 
     containsRegExp = new QToolButton(containsGroup);
     containsRegExp->setPopupMode(QToolButton::MenuButtonPopup);
     containsRegExp->setCheckable(true);
     containsRegExp->setText(i18n("RegExp"));
     // Populate the popup menu.
-    QMenu *patterns = new QMenu(containsRegExp);
+    auto *patterns = new QMenu(containsRegExp);
     for (int i = 0; (unsigned)i < sizeof(items) / sizeof(items[0]); i++) {
         patterns->addAction(new RegExpAction(patterns, i18n(items[i].description),
                                              items[i].regExp, items[i].cursorAdjustment));
     }
     connect(containsRegExp, &QToolButton::toggled, this, &GeneralFilter::slotDisable);
     connect(containsRegExp, &QToolButton::triggered, this, &GeneralFilter::slotRegExpTriggered);
     containsRegExp->setMenu(patterns);
     patterns->setEnabled(false);
 
     containsTextLayout->addWidget(containsRegExp);
 
     containsLayout->addLayout(containsTextLayout, 0, 0);
 
-    QHBoxLayout *containsCbsLayout = new QHBoxLayout();
+    auto *containsCbsLayout = new QHBoxLayout();
     containsCbsLayout->setSpacing(6);
     containsCbsLayout->setContentsMargins(0, 0, 0, 0);
 
     encLabel = new QLabel(i18n("Encoding:"), containsGroup);
     containsCbsLayout->addWidget(encLabel);
     contentEncoding = new KComboBox(containsGroup);
     contentEncoding->setEditable(false);
     contentEncoding->addItem(i18nc("Default encoding", "Default"));
     contentEncoding->addItems(KCharsets::charsets()->descriptiveEncodingNames());
     containsCbsLayout->addWidget(contentEncoding);
 
-    QSpacerItem* cbSpacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+    auto* cbSpacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     containsCbsLayout->addItem(cbSpacer);
 
     containsWholeWord = new QCheckBox(containsGroup);
     QSizePolicy containsWholeWordPolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
     containsWholeWordPolicy.setHeightForWidth(containsWholeWord->sizePolicy().hasHeightForWidth());
     containsWholeWord->setSizePolicy(containsWholeWordPolicy);
     containsWholeWord->setText(i18n("&Match whole word only"));
     containsWholeWord->setChecked(false);
     containsCbsLayout->addWidget(containsWholeWord);
 
     containsTextCase = new QCheckBox(containsGroup);
     QSizePolicy containsTextCasePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
     containsTextCasePolicy.setHeightForWidth(containsTextCase->sizePolicy().hasHeightForWidth());
     containsTextCase->setSizePolicy(containsTextCasePolicy);
     containsTextCase->setText(i18n("Cas&e sensitive"));
     containsTextCase->setChecked(true);
     containsCbsLayout->addWidget(containsTextCase);
 
     containsLayout->addLayout(containsCbsLayout, 1, 0);
 
     filterLayout->addWidget(containsGroup, 2, 0);
 
-    QHBoxLayout *recurseLayout = new QHBoxLayout();
+    auto *recurseLayout = new QHBoxLayout();
     recurseLayout->setSpacing(6);
     recurseLayout->setContentsMargins(0, 0, 0, 0);
-    QSpacerItem* recurseSpacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+    auto* recurseSpacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     recurseLayout->addItem(recurseSpacer);
 
     if (properties & FilterTabs::HasRecurseOptions) {
         // Options for recursive searching
         searchInDirs = new QCheckBox(this);
         searchInDirs->setText(i18n("Search in s&ub folders"));
         searchInDirs->setChecked(true);
         recurseLayout->addWidget(searchInDirs);
 
         searchInArchives = new QCheckBox(this);
         searchInArchives->setText(i18n("Search in arch&ives"));
         recurseLayout->addWidget(searchInArchives);
 
         followLinks = new QCheckBox(this);
         followLinks->setText(i18n("Follow &links"));
         recurseLayout->addWidget(followLinks);
 
     }
     filterLayout->addLayout(recurseLayout, 3, 0);
 
     for(int i = 0; i < extraOptions.length(); i++) {
-        QCheckBox *option = new QCheckBox(this);
+        auto *option = new QCheckBox(this);
         option->setText(extraOptions[i]);
         recurseLayout->addWidget(option);
         this->extraOptions.insert(extraOptions[i], option);
     }
 
     // Connection table
 
     if (properties & FilterTabs::HasProfileHandler) {
         connect(profileAddBtn, &QPushButton::clicked, this, &GeneralFilter::slotAddBtnClicked);
         connect(profileLoadBtn, &QPushButton::clicked, this, &GeneralFilter::slotLoadBtnClicked);
         connect(profileOverwriteBtn, &QPushButton::clicked, this, &GeneralFilter::slotOverwriteBtnClicked);
         connect(profileRemoveBtn, &QPushButton::clicked, this, &GeneralFilter::slotRemoveBtnClicked);
         connect(profileListBox, &KrListWidget::itemDoubleClicked, this, &GeneralFilter::slotProfileDoubleClicked);
         connect(profileManager, &ProfileManager::loadFromProfile, fltTabs, &FilterTabs::loadFromProfile);
         connect(profileManager, &ProfileManager::saveToProfile, fltTabs, &FilterTabs::saveToProfile);
     }
 
     connect(searchFor, QOverload<const QString &>::of(&KHistoryComboBox::activated), searchFor, &KHistoryComboBox::addToHistory);
     connect(containsText, QOverload<const QString &>::of(&KHistoryComboBox::activated), containsText, &KHistoryComboBox::addToHistory);
 
     // load the completion and history lists
     // ==> search for
     KConfigGroup group(krConfig, "Search");
     QStringList list = group.readEntry("SearchFor Completion", QStringList());
     searchFor->completionObject()->setItems(list);
     list = group.readEntry("SearchFor History", QStringList());
     searchFor->setHistoryItems(list);
     // ==> grep
     list = group.readEntry("ContainsText Completion", QStringList());
     containsText->completionObject()->setItems(list);
     list = group.readEntry("ContainsText History", QStringList());
     containsText->setHistoryItems(list);
 
     setTabOrder(searchFor, containsText);    // search for -> content
     setTabOrder(containsText, searchType);    // content -> search type
 
     slotDisable();
 }
 
 GeneralFilter::~GeneralFilter()
 {
     // save the history combos
     // ==> search for
     QStringList list = searchFor->completionObject()->items();
     KConfigGroup group(krConfig, "Search");
     group.writeEntry("SearchFor Completion", list);
     list = searchFor->historyItems();
     group.writeEntry("SearchFor History", list);
     // ==> grep text
     list = containsText->completionObject()->items();
     group.writeEntry("ContainsText Completion", list);
     list = containsText->historyItems();
     group.writeEntry("ContainsText History", list);
     if ((properties & FilterTabs::HasDontSearchIn) && (properties & FilterTabs::HasRecurseOptions)) {
         list = excludeFolderNames->historyItems();
         group.writeEntry("ExcludeFolderNamesHistory", list);
         group.writeEntry("ExcludeFolderNames", excludeFolderNames->currentText());
         group.writeEntry("ExcludeFolderNamesUse", static_cast<int>(useExcludeFolderNames->checkState()));
     }
     krConfig->sync();
 }
 
-bool GeneralFilter::isExtraOptionChecked(QString name)
+bool GeneralFilter::isExtraOptionChecked(const QString& name)
 {
     QCheckBox *option = extraOptions[name];
     return option ? option->isChecked() : false;
 }
 
-void GeneralFilter::checkExtraOption(QString name, bool check)
+void GeneralFilter::checkExtraOption(const QString& name, bool check)
 {
     QCheckBox *option = extraOptions[name];
     if (option)
         option->setChecked(check);
 }
 
 void GeneralFilter::queryAccepted()
 {
     searchFor->addToHistory(searchFor->currentText());
     containsText->addToHistory(containsText->currentText());
     if ((properties & FilterTabs::HasDontSearchIn) && (properties & FilterTabs::HasRecurseOptions)) {
         excludeFolderNames->addToHistory(excludeFolderNames->currentText());
     }
 }
 
 void GeneralFilter::refreshProfileListBox()
 {
     profileListBox->clear();
     profileListBox->addItems(ProfileManager::availableProfiles("SelectionProfile"));
 
     if (profileListBox->count() != 0) {
         profileLoadBtn->setEnabled(true);
         profileOverwriteBtn->setEnabled(true);
         profileRemoveBtn->setEnabled(true);
     } else {
         profileLoadBtn->setEnabled(false);
         profileOverwriteBtn->setEnabled(false);
         profileRemoveBtn->setEnabled(false);
     }
 }
 
 QCheckBox *GeneralFilter::createExcludeCheckBox(const KConfigGroup &group)
 {
-    QCheckBox *excludeCheckBox = new QCheckBox(this);
+    auto *excludeCheckBox = new QCheckBox(this);
     excludeCheckBox->setText(i18n("Exclude Folder Names"));
     excludeCheckBox->setToolTip(i18n("Filters out specified directory names from the results."));
     excludeCheckBox->setChecked(static_cast<Qt::CheckState>(group.readEntry("ExcludeFolderNamesUse", 0)));
     return excludeCheckBox;
 }
 
 KHistoryComboBox *GeneralFilter::createExcludeComboBox(const KConfigGroup &group)
 {
-    KHistoryComboBox *excludeComboBox = new KHistoryComboBox(false, this);
+    auto *excludeComboBox = new KHistoryComboBox(false, this);
     QSizePolicy excludeFolderNamesPolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     excludeFolderNamesPolicy.setHeightForWidth(excludeComboBox->sizePolicy().hasHeightForWidth());
     excludeComboBox->setSizePolicy(excludeFolderNamesPolicy);
     excludeComboBox->setEditable(true);
     excludeComboBox->setDuplicatesEnabled(false);
     excludeComboBox->setMaxCount(25);
     excludeComboBox->setMinimumContentsLength(10);
     excludeComboBox->lineEdit()->setPlaceholderText(i18n("Enter space-separated folder names"));
     excludeComboBox->lineEdit()->setWhatsThis(
         i18n("You can insert names with escaped spaces or quoted.\nExample: .git \"target "
              "build\" build\\ krusader"));
     excludeComboBox->setHistoryItems(group.readEntry("ExcludeFolderNamesHistory", QStringList()));
     excludeComboBox->setEditText(group.readEntry("ExcludeFolderNames", ""));
     return excludeComboBox;
 }
 
 void GeneralFilter::slotAddBtnClicked()
 {
     profileManager->newProfile(searchFor->currentText().simplified());
     refreshProfileListBox();
 }
 
 void GeneralFilter::slotOverwriteBtnClicked()
 {
     QListWidgetItem *item = profileListBox->currentItem();
-    if (item != 0)
+    if (item != nullptr)
         profileManager->overwriteProfile(item->text());
 }
 
 void GeneralFilter::slotRemoveBtnClicked()
 {
     QListWidgetItem *item = profileListBox->currentItem();
-    if (item != 0) {
+    if (item != nullptr) {
         profileManager->deleteProfile(item->text());
         refreshProfileListBox();
     }
 }
 
 void GeneralFilter::slotProfileDoubleClicked(QListWidgetItem *item)
 {
-    if (item != 0) {
+    if (item != nullptr) {
         QString profileName = item->text();
         profileManager->loadProfile(profileName);
         fltTabs->close(true);
     }
 }
 
 void GeneralFilter::slotLoadBtnClicked()
 {
     QListWidgetItem *item = profileListBox->currentItem();
-    if (item != 0)
+    if (item != nullptr)
         profileManager->loadProfile(item->text());
 }
 
 void GeneralFilter::slotDisable()
 {
     bool state = containsRegExp->isChecked();
     bool global = ofType->currentText() != i18n("Folders");
     bool remoteOnly = false;
     if (properties & FilterTabs::HasSearchIn) {
         QList<QUrl> urlList = searchIn->urlList();
         remoteOnly = urlList.count() != 0;
         foreach(const QUrl &url, urlList)
         if (url.scheme() == "file")
             remoteOnly = false;
     }
 
     containsWholeWord->setEnabled(!state && global);
     containsRegExp->menu()->setEnabled(state && global);
     encLabel->setEnabled(global);
     contentEncoding->setEnabled(global);
     containsTextCase->setEnabled(global);
     containsRegExp->setEnabled(global);
     if (properties & FilterTabs::HasRecurseOptions)
         searchInArchives->setEnabled(global && !remoteOnly);
     containsLabel->setEnabled(global);
     containsText->setEnabled(global);
 }
 
 void GeneralFilter::slotRegExpTriggered(QAction * act)
 {
-    if (act == 0)
+    if (act == nullptr)
         return;
-    RegExpAction *regAct = dynamic_cast<RegExpAction *>(act);
-    if (regAct == 0)
+    auto *regAct = dynamic_cast<RegExpAction *>(act);
+    if (regAct == nullptr)
         return;
     containsText->lineEdit()->insert(regAct->regExp());
     containsText->lineEdit()->setCursorPosition(containsText->lineEdit()->cursorPosition() + regAct->cursor());
     containsText->lineEdit()->setFocus();
 }
 
 bool GeneralFilter::getSettings(FilterSettings &s)
 {
     // check that we have (at least) what to search, and where to search in
     if (searchFor->currentText().simplified().isEmpty()) {
         KMessageBox::error(this , i18n("No search criteria entered."));
         searchFor->setFocus();
         return false;
     }
 
     s.searchFor = searchFor->currentText().trimmed();
     s.searchForCase = searchForCase->isChecked();
 
     if (ofType->currentText() != i18n("All Files"))
         s.mimeType = ofType->currentText();
 
     if (containsText->isEnabled()) {
         s.containsText = containsText->currentText();
         s.containsTextCase = containsTextCase->isChecked();
         s.containsWholeWord = containsWholeWord->isChecked();
         s.containsRegExp = containsRegExp->isChecked();
     }
 
     if (contentEncoding->currentIndex() != 0)
         s.contentEncoding =
             KCharsets::charsets()->encodingForName(contentEncoding->currentText());
 
     if (properties & FilterTabs::HasRecurseOptions) {
         s.recursive = searchInDirs->isChecked();
         s.searchInArchives = searchInArchives->isChecked();
         s.followLinks = followLinks->isChecked();
     }
 
     if (properties & FilterTabs::HasSearchIn) {
         s.searchIn = searchIn->urlList();
         if (s.searchIn.isEmpty()) { // we need a place to search in
             KMessageBox::error(this , i18n("Please specify a location to search in."));
             searchIn->lineEdit()->setFocus();
             return false;
         }
     }
 
     if (properties & FilterTabs::HasDontSearchIn) {
         s.dontSearchIn = dontSearchIn->urlList();
         if (properties & FilterTabs::HasRecurseOptions) {
             if (useExcludeFolderNames->isChecked()) {
                 s.excludeFolderNames = KShell::splitArgs(excludeFolderNames->currentText());
             } else {
                 s.excludeFolderNames = QStringList();
             }
         }
     }
     return true;
 }
 
 void GeneralFilter::applySettings(const FilterSettings &s)
 {
     searchFor->setEditText(s.searchFor);
     searchForCase->setChecked(s.searchForCase);
 
     setComboBoxValue(ofType, s.mimeType);
 
     containsText->setEditText(s.containsText);
     containsTextCase->setChecked(s.containsTextCase);
     containsWholeWord->setChecked(s.containsWholeWord);
     containsRegExp->setChecked(s.containsRegExp);
 
     setComboBoxValue(contentEncoding,
             KCharsets::charsets()->descriptionForEncoding(s.contentEncoding));
 
     if (properties & FilterTabs::HasRecurseOptions) {
         searchInDirs->setChecked(s.recursive);
         searchInArchives->setChecked(s.searchInArchives);
         followLinks->setChecked(s.followLinks);
     }
 
     if (properties & FilterTabs::HasSearchIn) {
         searchIn->lineEdit()->clear();
         searchIn->listBox()->clear();
         searchIn->listBox()->addItems(KrServices::toStringList(s.searchIn));
     }
 
     if (properties & FilterTabs::HasDontSearchIn) {
         dontSearchIn->lineEdit()->clear();
         dontSearchIn->listBox()->clear();
         dontSearchIn->listBox()->addItems(KrServices::toStringList(s.dontSearchIn));
     }
 }
 
diff --git a/krusader/Filter/generalfilter.h b/krusader/Filter/generalfilter.h
index e557eb30..b6117062 100644
--- a/krusader/Filter/generalfilter.h
+++ b/krusader/Filter/generalfilter.h
@@ -1,118 +1,118 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef GENERALFILTER_H
 #define GENERALFILTER_H
 
 // QtWidgets
 #include <QWidget>
 #include <QLayout>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QLabel>
 #include <QHBoxLayout>
 
 #include <KCompletion/KComboBox>
 #include <KShellCompletion>
 #include <KCompletion/KHistoryComboBox>
 
 #include "filterbase.h"
 #include "../Dialogs/kurllistrequester.h"
 #include "../GUI/profilemanager.h"
 #include "../GUI/krlistwidget.h"
 
 class GeneralFilter : public QWidget, public FilterBase
 {
     Q_OBJECT
 
 public:
-    GeneralFilter(FilterTabs *tabs, int properties, QWidget *parent = 0,
+    GeneralFilter(FilterTabs *tabs, int properties, QWidget *parent = nullptr,
                   QStringList extraOptions = QStringList());
-    ~GeneralFilter();
+    ~GeneralFilter() override;
 
-    virtual void          queryAccepted() Q_DECL_OVERRIDE;
-    virtual QString       name() Q_DECL_OVERRIDE {
+    void          queryAccepted() Q_DECL_OVERRIDE;
+    QString       name() Q_DECL_OVERRIDE {
         return "GeneralFilter";
     }
-    virtual FilterTabs *  filterTabs() Q_DECL_OVERRIDE {
+    FilterTabs *  filterTabs() Q_DECL_OVERRIDE {
         return fltTabs;
     }
-    virtual bool getSettings(FilterSettings&) Q_DECL_OVERRIDE;
-    virtual void applySettings(const FilterSettings&) Q_DECL_OVERRIDE;
+    bool getSettings(FilterSettings&) Q_DECL_OVERRIDE;
+    void applySettings(const FilterSettings&) Q_DECL_OVERRIDE;
 
-    bool isExtraOptionChecked(QString name);
-    void checkExtraOption(QString name, bool check);
+    bool isExtraOptionChecked(const QString& name);
+    void checkExtraOption(const QString& name, bool check);
 
 public slots:
     void    slotAddBtnClicked();
     void    slotLoadBtnClicked();
     void    slotOverwriteBtnClicked();
     void    slotRemoveBtnClicked();
     void    slotDisable();
     void    slotRegExpTriggered(QAction * act);
     void    slotProfileDoubleClicked(QListWidgetItem *);
     void    refreshProfileListBox();
 
 public:
     KComboBox* contentEncoding;
     QCheckBox* searchForCase;
     QCheckBox* containsTextCase;
     QCheckBox* containsWholeWord;
     QCheckBox* useExcludeFolderNames;
     QCheckBox* searchInDirs;
     QCheckBox* searchInArchives;
     QCheckBox* followLinks;
     QHash<QString, QCheckBox*> extraOptions;
 
     KURLListRequester *searchIn;
     KURLListRequester *dontSearchIn;
     QLayout *middleLayout;
 
     KHistoryComboBox* searchFor;
     KHistoryComboBox* containsText;
     KHistoryComboBox* excludeFolderNames;
     QToolButton*      containsRegExp;
 
     KComboBox* ofType;
 
     QLabel *encLabel;
     QLabel *containsLabel;
 
     KShellCompletion completion;
 
     KrListWidget *profileListBox;
 
     QPushButton *profileAddBtn;
     QPushButton *profileLoadBtn;
     QPushButton *profileOverwriteBtn;
     QPushButton *profileRemoveBtn;
 
     ProfileManager *profileManager;
 
     int properties;
 
     FilterTabs *fltTabs;
 
 private:
     QCheckBox *createExcludeCheckBox(const KConfigGroup &group);
     KHistoryComboBox *createExcludeComboBox(const KConfigGroup &group);
 };
 
 #endif /* GENERALFILTER_H */
diff --git a/krusader/GUI/dirhistorybutton.cpp b/krusader/GUI/dirhistorybutton.cpp
index d2e61775..0451ccd1 100644
--- a/krusader/GUI/dirhistorybutton.cpp
+++ b/krusader/GUI/dirhistorybutton.cpp
@@ -1,96 +1,96 @@
 /*****************************************************************************
  * Copyright (C) 2004 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2004 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "dirhistorybutton.h"
 #include "../icon.h"
 #include "../Panel/dirhistoryqueue.h"
 
 #include "../FileSystem/filesystem.h"
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 // QtGui
 #include <QPixmap>
 // QtWidgets
 #include <QMenu>
 
 #include <KI18n/KLocalizedString>
 
 DirHistoryButton::DirHistoryButton(DirHistoryQueue* hQ, QWidget *parent) : QToolButton(parent)
 {
     setAutoRaise(true);
     setIcon(Icon("chronometer"));
     setText(i18n("Open the folder history list"));
     setToolTip(i18n("Open the folder history list"));
     setPopupMode(QToolButton::InstantPopup);
     setAcceptDrops(false);
 
     popupMenu = new QMenu(this);
     Q_CHECK_PTR(popupMenu);
 
     setMenu(popupMenu);
 
     historyQueue = hQ;
 
     connect(popupMenu, &QMenu::aboutToShow, this, &DirHistoryButton::slotAboutToShow);
     connect(popupMenu, &QMenu::triggered, this, &DirHistoryButton::slotPopupActivated);
 }
 
-DirHistoryButton::~DirHistoryButton() {}
+DirHistoryButton::~DirHistoryButton() = default;
 
 void DirHistoryButton::showMenu()
 {
     QMenu * pP = menu();
     if (pP) {
         menu() ->exec(mapToGlobal(QPoint(0, height())));
     }
 }
 /** No descriptions */
 void DirHistoryButton::slotPopup()
 {
 //    qDebug() << "History slot";
 }
 /** No descriptions */
 void DirHistoryButton::slotAboutToShow()
 {
     emit aboutToShow();
 //    qDebug() << "about to show";
     popupMenu->clear();
 
     for (int i = 0; i < historyQueue->count(); i++) {
         QAction *act = popupMenu->addAction(historyQueue->get(i).toDisplayString());
         act->setData(QVariant(i));
         if(historyQueue->currentPos() == i) {
             act->setCheckable(true);
             act->setChecked(true);
         }
     }
 }
 /** No descriptions */
 void DirHistoryButton::slotPopupActivated(QAction * action)
 {
     if (action && action->data().canConvert<int>()) {
         int id = action->data().toInt();
         emit gotoPos(id);
     }
 }
 
diff --git a/krusader/GUI/dirhistorybutton.h b/krusader/GUI/dirhistorybutton.h
index 0e6bf9cb..3f0f31c0 100644
--- a/krusader/GUI/dirhistorybutton.h
+++ b/krusader/GUI/dirhistorybutton.h
@@ -1,61 +1,61 @@
 /*****************************************************************************
  * Copyright (C) 2004 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2004 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DIRHISTORYBUTTON_H
 #define DIRHISTORYBUTTON_H
 
 // QtWidgets
 #include <QWidget>
 #include <QToolButton>
 
 class QMenu;
 class QAction;
 class DirHistoryQueue;
 
 class DirHistoryButton : public QToolButton
 {
     Q_OBJECT
 public:
-    explicit DirHistoryButton(DirHistoryQueue* hQ, QWidget *parent = 0);
-    ~DirHistoryButton();
+    explicit DirHistoryButton(DirHistoryQueue* hQ, QWidget *parent = nullptr);
+    ~DirHistoryButton() override;
 
     void showMenu();
 
 signals:
     void aboutToShow();
 
 private:
     QMenu* popupMenu;
     DirHistoryQueue* historyQueue;
 
 public slots: // Public slots
     /** No descriptions */
     void slotPopup();
     /** No descriptions */
     void slotAboutToShow();
     /** No descriptions */
     void slotPopupActivated(QAction *);
 signals: // Signals
     /** No descriptions */
     void gotoPos(int pos);
 };
 
 #endif
diff --git a/krusader/GUI/kcmdline.cpp b/krusader/GUI/kcmdline.cpp
index 81bad6ae..4ad4f6f1 100644
--- a/krusader/GUI/kcmdline.cpp
+++ b/krusader/GUI/kcmdline.cpp
@@ -1,315 +1,316 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kcmdline.h"
 
 // QtCore
 #include <QDir>
 #include <QStringList>
 #include <QUrl>
 // QtGui
 #include <QKeyEvent>
 #include <QIcon>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QImage>
 // QtWidgets
 #include <QSizePolicy>
 #include <QGridLayout>
 #include <QFrame>
 #include <QLabel>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
+#include <utility>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../krslots.h"
 #include "../defaults.h"
 #include "../krusaderview.h"
 #include "../krservices.h"
 #include "../ActionMan/addplaceholderpopup.h"
 #include "kcmdmodebutton.h"
 
 
 CmdLineCombo::CmdLineCombo(QWidget *parent) : KHistoryComboBox(parent), _handlingLineEditResize(false)
 {
     lineEdit()->installEventFilter(this);
     _pathLabel = new QLabel(this);
     _pathLabel->setWhatsThis(i18n("Name of folder where command will be processed."));
     _pathLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
 }
 
 bool CmdLineCombo::eventFilter(QObject *watched, QEvent *e)
 {
     if(watched == lineEdit() && (e->type() == QEvent::Move || e->type() == QEvent::Resize)) {
         if(!_handlingLineEditResize) { // avoid infinite recursion
             _handlingLineEditResize = true;
             updateLineEditGeometry();
             _handlingLineEditResize = false;
         }
     }
     return false;
 }
 
 void CmdLineCombo::setPath(QString path)
 {
-    _path = path;
+    _path = std::move(path);
     doLayout();
 }
 
 void CmdLineCombo::updateLineEditGeometry()
 {
     QRect r = lineEdit()->geometry();
     r.setLeft(_pathLabel->geometry().right());
     lineEdit()->setGeometry(r);
 }
 
 void CmdLineCombo::doLayout()
 {
     QString pathNameLabel = _path;
     QFontMetrics fm(_pathLabel->fontMetrics());
     int textWidth = fm.width(_path);
     int maxWidth = (width() + _pathLabel->width()) * 2 / 5;
     int letters = _path.length() / 2;
 
     while (letters && textWidth > maxWidth) {
         pathNameLabel = _path.left(letters) + "..." + _path.right(letters);
         letters--;
         textWidth = fm.width(pathNameLabel);
     }
 
     _pathLabel->setText(pathNameLabel + "> ");
     _pathLabel->adjustSize();
 
     QStyleOptionComboBox opt;
     initStyleOption(&opt);
     QRect labelRect = style()->subControlRect(QStyle::CC_ComboBox, &opt,
                                             QStyle::SC_ComboBoxEditField, this);
     labelRect.adjust(2, 0, 0, 0);
     labelRect.setWidth(_pathLabel->width());
     _pathLabel->setGeometry(labelRect);
 
     updateLineEditGeometry();
 }
 
 void CmdLineCombo::resizeEvent(QResizeEvent *e)
 {
     KHistoryComboBox::resizeEvent(e);
     doLayout();
 }
 
 void CmdLineCombo::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Enter:
     case Qt::Key_Return:
         if (e->modifiers() & Qt::ControlModifier) {
             SLOTS->insertFileName((e->modifiers()&Qt::ShiftModifier)!=0);
             break;
         }
         KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Down:
         if (e->modifiers()  == (Qt::ControlModifier | Qt::ShiftModifier)) {
             MAIN_VIEW->focusTerminalEmulator();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Up:
         if (e->modifiers() == Qt::ControlModifier || e->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {
             emit returnToPanel();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Escape:
         if (e->modifiers() == 0) {
             emit returnToPanel();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     default:
         KHistoryComboBox::keyPressEvent(e);
     }
 }
 
 
 KCMDLine::KCMDLine(QWidget *parent) : QWidget(parent)
 {
-    QGridLayout * layout = new QGridLayout(this);
+    auto * layout = new QGridLayout(this);
     layout->setSpacing(0);
     layout->setContentsMargins(0, 0, 0, 0);
 
     int height = QFontMetrics(QFontDatabase::systemFont(QFontDatabase::GeneralFont)).height();
     height =  height + 5 * (height > 14) + 6;
 
     // and editable command line
     completion.setMode(KUrlCompletion::FileCompletion);
     cmdLine = new CmdLineCombo(this);
     cmdLine->setMaxCount(100);  // remember 100 commands
     cmdLine->setMinimumContentsLength(10);
     cmdLine->setDuplicatesEnabled(false);
     cmdLine->setMaximumHeight(height);
     cmdLine->setCompletionObject(&completion);
     cmdLine->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
     // load the history
     KConfigGroup grpSvr(krConfig, "Private");
     QStringList list = grpSvr.readEntry("cmdline history", QStringList());
     cmdLine->setHistoryItems(list);
 
     connect(cmdLine, QOverload<const QString &>::of(&CmdLineCombo::returnPressed), this, &KCMDLine::slotRun);
     connect(cmdLine, QOverload<const QString &>::of(&CmdLineCombo::returnPressed), cmdLine->lineEdit(), &QLineEdit::clear);
     connect(cmdLine, &CmdLineCombo::returnToPanel, this, &KCMDLine::slotReturnFocus);
 
     cmdLine->setWhatsThis(i18n("<qt><p>Well, it is actually quite simple: you type your command here and Krusader obeys.</p><p><b>Tip</b>: move within command line history with &lt;Up&gt; and &lt;Down&gt; arrows.</p></qt>"));
     layout->addWidget(cmdLine, 0, 1);
 
     buttonAddPlaceholder = new QToolButton(this);
     buttonAddPlaceholder->setAutoRaise(true);
     buttonAddPlaceholder->setIcon(Icon("list-add"));
     connect(buttonAddPlaceholder, &QToolButton::clicked, this, &KCMDLine::addPlaceholder);
     buttonAddPlaceholder->setWhatsThis(i18n("Add <b>Placeholders</b> for the selected files in the panel."));
 
     layout->addWidget(buttonAddPlaceholder, 0, 2);
 
     // a run in terminal button
     terminal = new KCMDModeButton(this);
     terminal->setAutoRaise(true);
     layout->addWidget(terminal, 0, 3);
 
     layout->activate();
 }
 
 KCMDLine::~KCMDLine()
 {
     KConfigGroup grpSvr(krConfig, "Private");
     QStringList list = cmdLine->historyItems();
     //qWarning() << list[0];
     grpSvr.writeEntry("cmdline history", list);
     krConfig->sync();
 }
 
 void KCMDLine::addPlaceholder()
 {
     AddPlaceholderPopup popup(this);
     QString exp = popup.getPlaceholder(
                       buttonAddPlaceholder->mapToGlobal(QPoint(0, 0))
                   );
     this->addText(exp);
 }
 
 void KCMDLine::setCurrent(const QString &path)
 {
     cmdLine->setPath(path);
 
     completion.setDir(QUrl::fromLocalFile(path));
     // make sure our command is executed in the right directory
     // This line is important for Krusader overall functions -> do not remove !
     QDir::setCurrent(path);
 }
 
 void KCMDLine::slotRun()
 {
     const QString command1(cmdLine->currentText());
     if (command1.isEmpty())
         return;
 
     cmdLine->addToHistory(command1);
     // bugfix by aardvark: current editline is destroyed by addToHistory() in some cases
     cmdLine->setEditText(command1);
 
     if (command1.simplified().left(3) == "cd ") {     // cd command effect the active panel
         QString dir = command1.right(command1.length() - command1.indexOf(" ")).trimmed();
         if (dir == "~")
             dir = QDir::homePath();
         else if (dir.left(1) != "/" && !dir.contains(":/"))
             dir = cmdLine->path() + (cmdLine->path() == "/" ? "" : "/") + dir;
         SLOTS->refresh(QUrl::fromUserInput(dir,QDir::currentPath(),QUrl::AssumeLocalFile));
     } else {
         exec();
         cmdLine->clearEditText();
     }
 }
 
 
 void KCMDLine::slotReturnFocus()
 {
     MAIN_VIEW->cmdLineUnFocus();
 }
 
 static const KrActionBase::ExecType execModesMenu[] = {
     KrActionBase::Normal,
     KrActionBase::CollectOutputSeparateStderr,
     KrActionBase::CollectOutput,
     KrActionBase::Terminal,
     KrActionBase::RunInTE,
 };
 
 QString KCMDLine::command() const
 {
     return cmdLine->currentText();
 }
 
 KrActionBase::ExecType KCMDLine::execType() const
 {
     KConfigGroup grp(krConfig, "Private");
     int i = grp.readEntry("Command Execution Mode", (int)0);
     return execModesMenu[i];
 }
 
 QString KCMDLine::startpath() const
 {
     return cmdLine->path();
 //     return path->text().left(path->text().length() - 1);
 }
 
 QString KCMDLine::user() const
 {
     return QString();
 }
 
 QString KCMDLine::text() const
 {
     return cmdLine->currentText();
 }
 
 bool KCMDLine::acceptURLs() const
 {
     return false;
 }
 
 bool KCMDLine::confirmExecution() const
 {
     return false;
 }
 
 bool KCMDLine::doSubstitution() const
 {
     return true;
 }
 
-void KCMDLine::setText(QString text)
+void KCMDLine::setText(const QString& text)
 {
     cmdLine->lineEdit()->setText(text);
 }
diff --git a/krusader/GUI/kcmdline.h b/krusader/GUI/kcmdline.h
index 0cc40757..05c68f3c 100644
--- a/krusader/GUI/kcmdline.h
+++ b/krusader/GUI/kcmdline.h
@@ -1,119 +1,119 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 #ifndef KCMDLINE_H
 #define KCMDLINE_H
 
 // QtGui
 #include <QKeyEvent>
 // QtWidgets
 #include <QWidget>
 #include <QLabel>
 #include <QLayout>
 #include <QToolButton>
 
 #include <KCompletion/KLineEdit>
 #include <KIOWidgets/KShellCompletion>
 #include <KCompletion/KHistoryComboBox>
 
 #include "../UserAction/kractionbase.h"
 
 class KCMDModeButton;
 
 class CmdLineCombo : public KHistoryComboBox
 {
     Q_OBJECT
 public:
     explicit CmdLineCombo(QWidget *parent);
 
-    virtual bool eventFilter(QObject *watched, QEvent *e) Q_DECL_OVERRIDE;
+    bool eventFilter(QObject *watched, QEvent *e) Q_DECL_OVERRIDE;
 
     QString path() {
         return _path;
     }
     void setPath(QString path);
 
 signals:
     void returnToPanel();
 
 protected slots:
     void doLayout();
 
 protected:
-    virtual void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
-    virtual void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
+    void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
+    void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
 
     void updateLineEditGeometry();
 
     QLabel *_pathLabel;
     QString _path;
     bool _handlingLineEditResize;
 };
 
 
 class KCMDLine : public QWidget, KrActionBase
 {
     Q_OBJECT
 public:
-    explicit KCMDLine(QWidget *parent = 0);
-    ~KCMDLine();
+    explicit KCMDLine(QWidget *parent = nullptr);
+    ~KCMDLine() override;
     void setCurrent(const QString &path);
     //virtual methods from KrActionBase
-    void setText(QString text);
+    void setText(const QString& text);
     QString command() const Q_DECL_OVERRIDE;
     ExecType execType() const Q_DECL_OVERRIDE;
     QString startpath() const Q_DECL_OVERRIDE;
     QString user() const Q_DECL_OVERRIDE;
     QString text() const Q_DECL_OVERRIDE;
     bool acceptURLs() const Q_DECL_OVERRIDE;
     bool confirmExecution() const Q_DECL_OVERRIDE;
     bool doSubstitution() const Q_DECL_OVERRIDE;
 
 signals:
     void signalRun();
 
 public slots:
     void slotReturnFocus(); // returns keyboard focus to panel
     void slotRun();
     void addPlaceholder();
-    void addText(QString text) {
+    void addText(const QString& text) {
         cmdLine->lineEdit()->setText(cmdLine->lineEdit()->text() + text);
     }
     void popup() {
         cmdLine->showPopup();
     }
 
 protected:
-    virtual void focusInEvent(QFocusEvent*) Q_DECL_OVERRIDE {
+    void focusInEvent(QFocusEvent*) Q_DECL_OVERRIDE {
         cmdLine->setFocus();
     }
 
     void calcLabelSize();
 
 private:
     CmdLineCombo *cmdLine;
     KCMDModeButton *terminal;
     QToolButton *buttonAddPlaceholder;
     KShellCompletion completion;
 };
 
 #endif
diff --git a/krusader/GUI/kcmdmodebutton.cpp b/krusader/GUI/kcmdmodebutton.cpp
index 32d12b33..561721eb 100644
--- a/krusader/GUI/kcmdmodebutton.cpp
+++ b/krusader/GUI/kcmdmodebutton.cpp
@@ -1,74 +1,74 @@
 /*****************************************************************************
  * Copyright (C) 2006 Václav Juza <vaclavjuza@gmail.com>                     *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kcmdmodebutton.h"
 
 #include "../kractions.h"
 #include "../icon.h"
 
 // QtWidgets
 #include <QMenu>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KActionMenu>
 
 /**
  * KCMDModeButton class, which represents a button with popup menu to switch
  * the mode of the krusader built-in command-line
  */
 KCMDModeButton::KCMDModeButton(QWidget *parent) : QToolButton(parent)
 {
     /* // from the old terminal-button:
       setText( i18n( "If pressed, Krusader executes command line in a terminal." ) );
       setToolTip( i18n( "If pressed, Krusader executes command line in a terminal." ) );
       QWhatsThis::add( terminal, i18n(
                             "The 'run in terminal' button allows Krusader "
                             "to run console (or otherwise non-graphical) "
                             "programs in a terminal of your choice. If it's "
                             "pressed, terminal mode is active." ) );
     */
     setIcon(Icon("utilities-terminal"));
     adjustSize();
     action = new KActionMenu(i18n("Execution mode"), this);
     Q_CHECK_PTR(action);
-    for (int i = 0; KrActions::execTypeArray[i] != 0; i++) {
+    for (int i = 0; KrActions::execTypeArray[i] != nullptr; i++) {
         action->addAction(*KrActions::execTypeArray[i]);
     }
     QMenu *pP = action->menu();
     Q_CHECK_PTR(pP);
     setMenu(pP);
     setPopupMode(QToolButton::InstantPopup);
     setAcceptDrops(false);
 }
 
 KCMDModeButton::~KCMDModeButton()
 {
     delete action;
 }
 
 /** called when clicked to the button */
 void KCMDModeButton::showMenu()
 {
     QMenu * pP = menu();
     if (pP) {
         menu() ->exec(mapToGlobal(QPoint(0, 0)));
     }
 }
 
diff --git a/krusader/GUI/kcmdmodebutton.h b/krusader/GUI/kcmdmodebutton.h
index 3447ee50..6c25a3d1 100644
--- a/krusader/GUI/kcmdmodebutton.h
+++ b/krusader/GUI/kcmdmodebutton.h
@@ -1,50 +1,50 @@
 /*****************************************************************************
  * Copyright (C) 2006 Václav Juza <vaclavjuza@gmail.com>                     *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KCMDMODEBUTTON_H
 #define KCMDMODEBUTTON_H
 
 // QtWidgets
 #include <QToolButton>
 
 class KActionMenu;
 
 /**
  * represents a button for switching the command-line execution mode
  * It extends QToolButton, set the icon etc., and creates a popup menu
  * containing the actions to actually switch the mode.
  */
 class KCMDModeButton : public QToolButton
 {
     Q_OBJECT
 public:
     /** Constructor. Sets up the menu, and the icon */
-    explicit KCMDModeButton(QWidget *parent = 0);
-    ~KCMDModeButton();
+    explicit KCMDModeButton(QWidget *parent = nullptr);
+    ~KCMDModeButton() override;
 
     /** Shows the popup menu. Called when clicked to the button */
     void showMenu();
 
 private:
     /** The menu containing the actions for switching the mode */
     KActionMenu *action;
 };
 
 #endif
diff --git a/krusader/GUI/kfnkeys.cpp b/krusader/GUI/kfnkeys.cpp
index ccc4153a..58e45069 100644
--- a/krusader/GUI/kfnkeys.cpp
+++ b/krusader/GUI/kfnkeys.cpp
@@ -1,75 +1,75 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kfnkeys.h"
 
 // QtWidgets
 #include <QGridLayout>
 
 #include <KI18n/KLocalizedString>
 
 #include "../defaults.h"
 #include "../krmainwindow.h"
 #include "../kractions.h"
 #include "../Panel/listpanelactions.h"
 
 KFnKeys::KFnKeys(QWidget *parent, KrMainWindow *mainWindow) :
-        QWidget(parent), mainWindow(mainWindow), buttonList()
+        QWidget(parent), mainWindow(mainWindow)
 {
     buttonList << setup(mainWindow->listPanelActions()->actRenameF2, i18n("Rename"))
                << setup(mainWindow->listPanelActions()->actViewFileF3, i18n("View"))
                << setup(mainWindow->listPanelActions()->actEditFileF4, i18n("Edit"))
                << setup(mainWindow->listPanelActions()->actCopyF5, i18n("Copy"))
                << setup(mainWindow->listPanelActions()->actMoveF6, i18n("Move"))
                << setup(mainWindow->listPanelActions()->actNewFolderF7, i18n("Mkdir"))
                << setup(mainWindow->listPanelActions()->actDeleteF8, i18n("Delete"))
                << setup(mainWindow->listPanelActions()->actTerminalF9, i18n("Term"))
                << setup(mainWindow->krActions()->actF10Quit, i18n("Quit"));
 
     updateShortcuts();
 
-    QGridLayout *layout = new QGridLayout(this);
+    auto *layout = new QGridLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->setSpacing(0);
 
     int pos = 0;
     for(QPair<QPushButton *, QPair<QAction *, const QString&>> entry : buttonList) {
         layout->addWidget(entry.first, 0, pos++);
     }
     layout->activate();
 }
 
 void KFnKeys::updateShortcuts()
 {
     for(ButtonEntry entry : buttonList) {
         entry.first->setText(entry.second.first->shortcut().toString() + ' ' + entry.second.second);
     }
 }
 
 KFnKeys::ButtonEntry KFnKeys::setup(QAction *action, const QString &text)
 {
-    QPushButton *button = new QPushButton(this);
+    auto *button = new QPushButton(this);
     button->setMinimumWidth(45);
     button->setToolTip(action->toolTip());
     connect(button, &QPushButton::clicked, action, &QAction::trigger);
     return QPair<QPushButton *, QPair<QAction *, QString>>(button,
                                                            QPair<QAction *, QString>(action, text));
 }
diff --git a/krusader/GUI/krlistwidget.cpp b/krusader/GUI/krlistwidget.cpp
index 09c9cb3a..7634e780 100644
--- a/krusader/GUI/krlistwidget.cpp
+++ b/krusader/GUI/krlistwidget.cpp
@@ -1,38 +1,38 @@
 /*****************************************************************************
  * Copyright (C) 2008 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2008-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krlistwidget.h"
 #include "krstyleproxy.h"
 
 // QtGui
 #include <QContextMenuEvent>
 
 KrListWidget::KrListWidget(QWidget *parent) : QListWidget(parent)
 {
-    KrStyleProxy *style = new KrStyleProxy();
+    auto *style = new KrStyleProxy();
     style->setParent(this);
     setStyle(style);
 
     setContextMenuPolicy(Qt::CustomContextMenu);
     connect(this, &QListWidget::customContextMenuRequested, [=](const QPoint &pos) {
         QListWidgetItem *item = itemAt(pos);
         emit itemRightClicked(item, viewport()->mapToGlobal(pos));
     });
 }
diff --git a/krusader/GUI/krlistwidget.h b/krusader/GUI/krlistwidget.h
index 4fec604e..63660434 100644
--- a/krusader/GUI/krlistwidget.h
+++ b/krusader/GUI/krlistwidget.h
@@ -1,38 +1,38 @@
 /*****************************************************************************
  * Copyright (C) 2008 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2008-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRLISTWIDGET_H
 #define KRLISTWIDGET_H
 
 // QtWidgets
 #include <QListWidget>
 
 class KrListWidget : public QListWidget
 {
     Q_OBJECT
 
 public:
-    explicit KrListWidget(QWidget * parent = 0);
+    explicit KrListWidget(QWidget * parent = nullptr);
 
 signals:
     void itemRightClicked(QListWidgetItem * it, const QPoint & pos);
 };
 
 #endif /* KRLISTVIEW_H */
diff --git a/krusader/GUI/krremoteencodingmenu.cpp b/krusader/GUI/krremoteencodingmenu.cpp
index 878067ee..bc992172 100644
--- a/krusader/GUI/krremoteencodingmenu.cpp
+++ b/krusader/GUI/krremoteencodingmenu.cpp
@@ -1,226 +1,226 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * Based on KRemoteEncodingPlugin from Dawit Alemayehu <adawit@kde.org>      *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krremoteencodingmenu.h"
 
 // QtCore
 #include <QDebug>
 // QtWidgets
 #include <QMenu>
 
 #include <KXmlGui/KActionCollection>
 #include <KCodecs/KCharsets>
 #include <KConfigCore/KConfig>
 #include <KConfigCore/KConfigGroup>
 #include <KI18n/KLocalizedString>
 #include <KIO/Scheduler>
 #include <KIOCore/KProtocolManager>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../Panel/krpanel.h"
 #include "../Panel/panelfunc.h"
 
 #define DATA_KEY    QString::fromLatin1("Charset")
 
 KrRemoteEncodingMenu::KrRemoteEncodingMenu(const QString &text, const QString &iconName, KActionCollection *parent) :
         KActionMenu(Icon(iconName), text, parent), settingsLoaded(false)
 {
     connect(menu(), &QMenu::aboutToShow, this, &KrRemoteEncodingMenu::slotAboutToShow);
 
     parent->addAction("changeremoteencoding", this);
 }
 
 void KrRemoteEncodingMenu::slotAboutToShow()
 {
     if (!settingsLoaded)
         loadSettings();
 
     // uncheck everything
     QList<QAction *> acts = menu()->actions();
     foreach(QAction *act, acts)
     act->setChecked(false);
 
     QString charset = currentCharacterSet();
     if (!charset.isEmpty()) {
         int id = 1;
         QStringList::Iterator it;
         for (it = encodingNames.begin(); it != encodingNames.end(); ++it, ++id)
             if ((*it).indexOf(charset) != -1)
                 break;
 
         bool found = false;
 
         foreach(QAction *act, acts) {
             if (act->data().canConvert<int> ()) {
                 int idr = act->data().toInt();
 
                 if (idr == id) {
                     act->setChecked(found = true);
                     break;
                 }
             }
         }
 
         if (!found)
             qWarning() << Q_FUNC_INFO << "could not find entry for charset=" << charset;
     } else {
         foreach(QAction *act, acts) {
             if (act->data().canConvert<int> ()) {
                 int idr = act->data().toInt();
 
                 if (idr == -2) {
                     act->setChecked(true);
                     break;
                 }
             }
         }
     }
 }
 
 QString KrRemoteEncodingMenu::currentCharacterSet()
 {
     QUrl currentURL = ACTIVE_PANEL->virtualPath();
     return KProtocolManager::charsetFor(currentURL);
 }
 
 void KrRemoteEncodingMenu::loadSettings()
 {
     settingsLoaded = true;
     encodingNames = KCharsets::charsets()->descriptiveEncodingNames();
 
     QMenu *qmenu = menu();
     disconnect(qmenu, &QMenu::triggered, this, &KrRemoteEncodingMenu::slotTriggered);
     connect(qmenu, &QMenu::triggered, this, &KrRemoteEncodingMenu::slotTriggered);
     qmenu->clear();
 
     QStringList::ConstIterator it;
     int count = 0;
     QAction *act;
 
     for (it = encodingNames.constBegin(); it != encodingNames.constEnd(); ++it) {
         act = qmenu->addAction(*it);
         act->setData(QVariant(++count));
         act->setCheckable(true);
     }
     qmenu->addSeparator();
 
     act = qmenu->addAction(i18n("Reload"));
     act->setCheckable(true);
     act->setData(QVariant(-1));
 
     act = qmenu->addAction(i18nc("Default encoding", "Default"));
     act->setCheckable(true);
     act->setData(QVariant(-2));
 }
 
 void KrRemoteEncodingMenu::slotTriggered(QAction * act)
 {
     if (!act || !act->data().canConvert<int> ())
         return;
 
     int id = act->data().toInt();
 
     switch (id) {
     case -1:
         slotReload();
         return;
     case -2:
         chooseDefault();
         return;
     default:
         chooseEncoding(encodingNames[id - 1]);
     }
 }
 
 void KrRemoteEncodingMenu::chooseEncoding(QString encoding)
 {
     QUrl currentURL = ACTIVE_PANEL->virtualPath();
 
     KConfig config(("kio_" + currentURL.scheme() + "rc").toLatin1());
     QString host = currentURL.host();
 
     QString charset = KCharsets::charsets()->encodingForName(encoding);
 
     KConfigGroup group(&config, host);
     group.writeEntry(DATA_KEY, charset);
     config.sync();
 
     // Update the io-slaves...
     updateKIOSlaves();
 }
 
 void KrRemoteEncodingMenu::slotReload()
 {
     loadSettings();
 }
 
 void KrRemoteEncodingMenu::chooseDefault()
 {
     QUrl currentURL = ACTIVE_PANEL->virtualPath();
 
     // We have no choice but delete all higher domain level
     // settings here since it affects what will be matched.
     KConfig config(("kio_" + currentURL.scheme() + "rc").toLatin1());
 
     QStringList partList = currentURL.host().split('.', QString::SkipEmptyParts);
     if (!partList.isEmpty()) {
         partList.erase(partList.begin());
 
         QStringList domains;
         // Remove the exact name match...
         domains << currentURL.host();
 
         while (partList.count()) {
             if (partList.count() == 2)
                 if (partList[0].length() <= 2 && partList[1].length() == 2)
                     break;
 
             if (partList.count() == 1)
                 break;
 
             domains << partList.join(".");
             partList.erase(partList.begin());
         }
 
-        for (QStringList::Iterator it = domains.begin(); it != domains.end(); ++it) {
+        for (auto & domain : domains) {
             //qDebug() << "Domain to remove: " << *it;
-            if (config.hasGroup(*it))
-                config.deleteGroup(*it);
-            else if (config.group("").hasKey(*it))
-                config.group("").deleteEntry(*it);       //don't know what group name is supposed to be XXX
+            if (config.hasGroup(domain))
+                config.deleteGroup(domain);
+            else if (config.group("").hasKey(domain))
+                config.group("").deleteEntry(domain);       //don't know what group name is supposed to be XXX
         }
     }
     config.sync();
 
     updateKIOSlaves();
 }
 
 
 void KrRemoteEncodingMenu::updateKIOSlaves()
 {
     KIO::Scheduler::emitReparseSlaveConfiguration();
 
     // Reload the page with the new charset
     QTimer::singleShot(500, ACTIVE_FUNC, SLOT(refresh()));
 }
 
diff --git a/krusader/GUI/krremoteencodingmenu.h b/krusader/GUI/krremoteencodingmenu.h
index b6d8629b..c6c15aff 100644
--- a/krusader/GUI/krremoteencodingmenu.h
+++ b/krusader/GUI/krremoteencodingmenu.h
@@ -1,63 +1,63 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * Based on KRemoteEncodingPlugin from Dawit Alemayehu <adawit@kde.org>      *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRREMOTEENCODINGMENU_H
 #define KRREMOTEENCODINGMENU_H
 
 // QtCore
 #include <QStringList>
 // QtWidgets
 #include <QAction>
 
 # include <KWidgetsAddons/KActionMenu>
 
 class KActionCollection;
 
 class KrRemoteEncodingMenu: public KActionMenu
 {
     Q_OBJECT
 public:
-    KrRemoteEncodingMenu(const QString &text, const QString &iconName, KActionCollection *parent = 0);
+    KrRemoteEncodingMenu(const QString &text, const QString &iconName, KActionCollection *parent = nullptr);
 
 protected slots:
 
     void slotAboutToShow();
 
     void slotReload();
     void slotTriggered(QAction *);
 
     virtual void chooseDefault();
     virtual void chooseEncoding(QString encoding);
 
 protected:
     virtual QString currentCharacterSet();
 
 private:
 
     void loadSettings();
     void updateKIOSlaves();
 
     QStringList encodingNames;
     bool        settingsLoaded;
 };
 
 #endif /* REMOTEENCODING_MENU_H */
diff --git a/krusader/GUI/krstyleproxy.cpp b/krusader/GUI/krstyleproxy.cpp
index dfc5851c..4ccc507b 100644
--- a/krusader/GUI/krstyleproxy.cpp
+++ b/krusader/GUI/krstyleproxy.cpp
@@ -1,77 +1,77 @@
 /*****************************************************************************
  * Copyright (C) 2008 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2008-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krstyleproxy.h"
 
 // QtGui
 #include <QPen>
 #include <QPainter>
 // QtWidgets
 #include <QStyleOptionViewItem>
 
 #include <KConfigCore/KSharedConfig>
 
 #include "../krglobal.h"
 
 void KrStyleProxy::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                                  QPainter *painter, const QWidget *widget) const
 {
     if (element == QStyle::PE_FrameFocusRect) {
-        if (const QStyleOptionFocusRect *fropt = qstyleoption_cast<const QStyleOptionFocusRect *>(option)) {
+        if (const auto *fropt = qstyleoption_cast<const QStyleOptionFocusRect *>(option)) {
             QColor bg = fropt->backgroundColor;
             QPen oldPen = painter->pen();
             QPen newPen;
             if (bg.isValid()) {
                 int h, s, v;
                 bg.getHsv(&h, &s, &v);
                 if (v >= 128)
                     newPen.setColor(Qt::black);
                 else
                     newPen.setColor(Qt::white);
             } else {
                 newPen.setColor(option->palette.foreground().color());
             }
             newPen.setWidth(0);
             newPen.setStyle(Qt::DotLine);
             painter->setPen(newPen);
             QRect focusRect = option->rect /*.adjusted(1, 1, -1, -1) */;
             painter->drawRect(focusRect.adjusted(0, 0, -1, -1)); //draw pen inclusive
             painter->setPen(oldPen);
         }
     } else
         QProxyStyle::drawPrimitive(element, option, painter, widget);
 }
 
 int KrStyleProxy::styleHint(QStyle::StyleHint hint, const QStyleOption *option,
                             const QWidget *widget, QStyleHintReturn *returnData) const
 {
     if (hint == QStyle::SH_ToolTip_WakeUpDelay) {
         KConfigGroup group(krConfig, "Look&Feel");
         const int delay = group.readEntry("Panel Tooltip Delay", 1000);
         return delay < 0 ? INT_MAX : delay;
     }
 
     // disable instant consecutive tooltips
     if (hint == QStyle::SH_ToolTip_FallAsleepDelay) {
         return 0;
     }
 
     return QProxyStyle::styleHint(hint, option, widget, returnData);
 }
diff --git a/krusader/GUI/krtreewidget.cpp b/krusader/GUI/krtreewidget.cpp
index 0357f8cb..21d7bcc4 100644
--- a/krusader/GUI/krtreewidget.cpp
+++ b/krusader/GUI/krtreewidget.cpp
@@ -1,202 +1,202 @@
 /*****************************************************************************
  * Copyright (C) 2008 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2008-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krtreewidget.h"
 #include "krstyleproxy.h"
 
 // QtGui
 #include <QContextMenuEvent>
 // QtWidgets
 #include <QStyleOptionViewItem>
 #include <QToolTip>
 #include <QHeaderView>
 #include <QApplication>
 
 KrTreeWidget::KrTreeWidget(QWidget * parent) : QTreeWidget(parent), _inResize(false)
 {
     setRootIsDecorated(false);
     setSortingEnabled(true);
     setAllColumnsShowFocus(true);
 
     _stretchingColumn = -1;
 
-    KrStyleProxy *krstyle = new KrStyleProxy();
+    auto *krstyle = new KrStyleProxy();
     krstyle->setParent(this);
     setStyle(krstyle);
 }
 
 bool KrTreeWidget::event(QEvent * event)
 {
     switch (event->type()) {
         // HACK: QT 4 Context menu key isn't handled properly
     case QEvent::ContextMenu: {
-        QContextMenuEvent* ce = (QContextMenuEvent*) event;
+        auto* ce = (QContextMenuEvent*) event;
 
         if (ce->reason() == QContextMenuEvent::Mouse) {
             QPoint pos = viewport()->mapFromGlobal(ce->globalPos());
 
             QTreeWidgetItem * item = itemAt(pos);
             int column = columnAt(pos.x());
 
             emit itemRightClicked(item, ce->globalPos(), column);
             return true;
         } else {
             if (currentItem()) {
                 QRect r = visualItemRect(currentItem());
                 QPoint p = viewport()->mapToGlobal(QPoint(r.x() + 5, r.y() + 5));
 
                 emit itemRightClicked(currentItem(), p, currentColumn());
                 return true;
             }
         }
     }
     break;
     case QEvent::KeyPress: {
         // HACK: QT 4 Ctrl+A bug fix: Ctrl+A doesn't work if QTreeWidget contains parent / child items
         //       Insert doesn't change the selections for multi selection modes
-        QKeyEvent* ke = (QKeyEvent*) event;
+        auto* ke = (QKeyEvent*) event;
         switch (ke->key()) {
         case Qt::Key_Insert: {
             if (ke->modifiers() != 0)
                 break;
 
             QAbstractItemView::SelectionMode mode = selectionMode();
 
             if (mode != QAbstractItemView::ContiguousSelection && mode != QAbstractItemView::ExtendedSelection &&
                     mode != QAbstractItemView::MultiSelection)
                 break;
 
             ke->accept();
 
-            if (currentItem() == 0)
+            if (currentItem() == nullptr)
                 return true;
 
             currentItem()->setSelected(!currentItem()->isSelected());
             return true;
         }
         case Qt::Key_A:
             if (ke->modifiers() == Qt::ControlModifier) {
                 QAbstractItemView::SelectionMode mode = selectionMode();
 
                 if (mode == QAbstractItemView::ContiguousSelection || mode == QAbstractItemView::ExtendedSelection ||
                         mode == QAbstractItemView::MultiSelection) {
                     selectAll();
                     ke->accept();
                     return true;
                 }
             }
             break;
         default:
             break;
         }
     }
     break;
     case QEvent::Resize: {
-        QResizeEvent * re = (QResizeEvent *)event;
+        auto * re = (QResizeEvent *)event;
         if (!_inResize && re->oldSize() != re->size()) {
             if (_stretchingColumn != -1 && columnCount()) {
                 QList< int > columnsSizes;
                 int oldSize = 0;
 
                 for (int i = 0; i != header()->count(); i++) {
                     columnsSizes.append(header()->sectionSize(i));
                     oldSize += header()->sectionSize(i);
                 }
 
                 bool res = QTreeWidget::event(event);
 
                 int newSize = viewport()->width();
                 int delta = newSize - oldSize;
 
                 if (delta) {
                     _inResize = true;
 
                     for (int i = 0; i != header()->count(); i++) {
                         if (i == _stretchingColumn) {
                             int newNs = columnsSizes[ i ] + delta;
                             if (newNs < 8)
                                 newNs = 8;
                             header()->resizeSection(i, newNs);
                         } else if (header()->sectionSize(i) != columnsSizes[ i ]) {
                             header()->resizeSection(i, columnsSizes[ i ]);
                         }
                     }
                     _inResize = false;
                 }
                 return res;
             }
         }
         break;
     }
     case QEvent::ToolTip: {
-        QHelpEvent *he = static_cast<QHelpEvent*>(event);
+        auto *he = dynamic_cast<QHelpEvent*>(event);
 
         if (viewport()) {
             QPoint pos = viewport()->mapFromGlobal(he->globalPos());
 
             QTreeWidgetItem * item = itemAt(pos);
 
             int column = columnAt(pos.x());
 
             if (item) {
                 if (!item->toolTip(column).isEmpty())
                     break;
 
                 QString tip = item->text(column);
 
                 int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
                 int requiredWidth = QFontMetrics(font()).width(tip) + 2 * textMargin;
 
                 if (column == 0 && indentation()) {
                     int level = 0;
 
                     QTreeWidgetItem *parent = item;
 
                     while ((parent = parent->parent()))
                         level++;
 
                     if (rootIsDecorated())
                         level++;
 
                     requiredWidth += level * indentation();
                 }
 
                 QIcon icon = item->icon(column);
                 if (!icon.isNull()) {
                     QStyleOptionViewItem opts = viewOptions();
                     QSize iconSize = icon.actualSize(opts.decorationSize);
                     requiredWidth += iconSize.width();
 
-                    int pixmapMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin, 0, this) + 1;
+                    int pixmapMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin, nullptr, this) + 1;
                     requiredWidth += 2 * pixmapMargin;
                 }
 
                 if (!tip.isEmpty() && (columnWidth(column) < requiredWidth))
                     QToolTip::showText(he->globalPos(), tip, this);
                 return true;
             }
         }
     }
     break;
     default:
         break;
     }
     return QTreeWidget::event(event);
 }
diff --git a/krusader/GUI/krtreewidget.h b/krusader/GUI/krtreewidget.h
index e1287293..22b7a1fe 100644
--- a/krusader/GUI/krtreewidget.h
+++ b/krusader/GUI/krtreewidget.h
@@ -1,56 +1,56 @@
 /*****************************************************************************
  * Copyright (C) 2008 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2008-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRTREEWIDGET_H
 #define KRTREEWIDGET_H
 
 // QtWidgets
 #include <QAbstractScrollArea>
 #include <QTreeWidget>
 
 class KrTreeWidget : public QTreeWidget
 {
     Q_OBJECT
 
 public:
     explicit KrTreeWidget(QWidget * parent);
     void setStretchingColumn(int col)                {
         _stretchingColumn = col;
     }
 
     QModelIndex indexOf(QTreeWidgetItem * item, int col = 0) {
         return indexFromItem(item, col);
     }
     QTreeWidgetItem * item(const QModelIndex & ndx)          {
         return itemFromIndex(ndx);
     }
 
 signals:
     void itemRightClicked(QTreeWidgetItem * it, const QPoint & pos, int column);
 
 protected:
-    virtual bool event(QEvent * event) Q_DECL_OVERRIDE;
+    bool event(QEvent * event) Q_DECL_OVERRIDE;
 
 private:
     int  _stretchingColumn;
     bool _inResize;
 };
 
 #endif /* KRTREEWIDGET_H */
diff --git a/krusader/GUI/krusaderstatus.cpp b/krusader/GUI/krusaderstatus.cpp
index 2c466948..91601598 100644
--- a/krusader/GUI/krusaderstatus.cpp
+++ b/krusader/GUI/krusaderstatus.cpp
@@ -1,39 +1,38 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krusaderstatus.h"
 
 // QtGui
 #include <QFontMetrics>
 
 #include <KI18n/KLocalizedString>
 
 KrusaderStatus::KrusaderStatus(QWidget *parent):
     QStatusBar(parent)
 {
     showMessage(i18n("Ready."), 5000);
     setMaximumHeight(QFontMetrics(font()).height() + 2);
 }
 
 KrusaderStatus::~KrusaderStatus()
-{
-}
+= default;
 
diff --git a/krusader/GUI/krusaderstatus.h b/krusader/GUI/krusaderstatus.h
index 0e2650f3..c039c8e7 100644
--- a/krusader/GUI/krusaderstatus.h
+++ b/krusader/GUI/krusaderstatus.h
@@ -1,43 +1,43 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 #ifndef KRUSADERSTATUS_H
 #define KRUSADERSTATUS_H
 
 // QtWidgets
 #include <QLabel>
 #include <QStatusBar>
 #include <QWidget>
 
 class KrusaderStatus : public QStatusBar
 {
     Q_OBJECT
 public:
-    explicit KrusaderStatus(QWidget *parent = 0);
-    ~KrusaderStatus();
+    explicit KrusaderStatus(QWidget *parent = nullptr);
+    ~KrusaderStatus() override;
 
 private:
     QLabel *mess;
 
 };
 
 #endif
diff --git a/krusader/GUI/mediabutton.cpp b/krusader/GUI/mediabutton.cpp
index ecffc132..4e8f46de 100644
--- a/krusader/GUI/mediabutton.cpp
+++ b/krusader/GUI/mediabutton.cpp
@@ -1,630 +1,630 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "mediabutton.h"
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../MountMan/kmountman.h"
 
 // QtCore
 #include <QEvent>
 // QtGui
 #include <QMouseEvent>
 #include <QCursor>
 
 #include <KConfigCore/KConfigGroup>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIO/Global>
 #include <KIOCore/KMountPoint>
 #include <KWidgetsAddons/KMessageBox>
 
 #include <Solid/DeviceInterface>
 #include <Solid/StorageAccess>
 #include <Solid/StorageVolume>
 #include <Solid/OpticalDisc>
 #include <Solid/OpticalDrive>
 #include <Solid/DeviceNotifier>
+#include <utility>
 
 QString MediaButton::remotePrefix = QLatin1String("remote:");
 
 
 MediaButton::MediaButton(QWidget *parent) : QToolButton(parent),
-        popupMenu(0), rightMenu(0), openInNewTab(false)
+        popupMenu(nullptr), rightMenu(nullptr), openInNewTab(false)
 {
     setAutoRaise(true);
     setIcon(Icon("system-file-manager"));
     setText(i18n("Open the available media list"));
     setToolTip(i18n("Open the available media list"));
     setPopupMode(QToolButton::InstantPopup);
     setAcceptDrops(false);
 
     popupMenu = new QMenu(this);
     popupMenu->installEventFilter(this);
     Q_CHECK_PTR(popupMenu);
 
     setMenu(popupMenu);
 
     connect(popupMenu, &QMenu::aboutToShow, this, &MediaButton::slotAboutToShow);
     connect(popupMenu, &QMenu::aboutToHide, this, &MediaButton::slotAboutToHide);
     connect(popupMenu, &QMenu::triggered, this, &MediaButton::slotPopupActivated);
 
     Solid::DeviceNotifier *notifier = Solid::DeviceNotifier::instance();
     connect(notifier, &Solid::DeviceNotifier::deviceAdded, this, &MediaButton::slotDeviceAdded);
     connect(notifier, &Solid::DeviceNotifier::deviceRemoved, this, &MediaButton::slotDeviceRemoved);
 
     connect(&mountCheckerTimer, &QTimer::timeout, this, &MediaButton::slotCheckMounts);
 }
 
 MediaButton::~MediaButton()
-{
-}
+= default;
 
 void MediaButton::updateIcon(const QString &mountPoint)
 {
     if(!mountPoint.isEmpty() && mountPoint == currentMountPoint)
         return;
 
     currentMountPoint = mountPoint;
 
     QString iconName("system-file-manager");
     QStringList overlays;
 
     if(!mountPoint.isEmpty()) {
         Solid::Device device(krMtMan.findUdiForPath(mountPoint, Solid::DeviceInterface::StorageAccess));;
-        Solid::StorageVolume *vol = device.as<Solid::StorageVolume> ();
+        auto *vol = device.as<Solid::StorageVolume> ();
 
         if(device.isValid())
             iconName = device.icon();
         if (vol && vol->usage() == Solid::StorageVolume::Encrypted)
             overlays << "security-high";
     }
     setIcon(Icon(iconName, overlays));
 }
 
 void MediaButton::slotAboutToShow()
 {
     emit aboutToShow();
 
     popupMenu->clear();
     udiNameMap.clear();
 
     createMediaList();
 }
 
 void MediaButton::slotAboutToHide()
 {
     if (rightMenu)
         rightMenu->close();
     mountCheckerTimer.stop();
 }
 
 void MediaButton::createMediaList()
 {
     // devices detected by solid
     storageDevices = Solid::Device::listFromType(Solid::DeviceInterface::StorageAccess);
 
     for (int p = storageDevices.count() - 1 ; p >= 0; p--) {
         Solid::Device device = storageDevices[ p ];
         QString udi     = device.udi();
 
         QString name;
         QIcon kdeIcon;
         if (!getNameAndIcon(device, name, kdeIcon))
             continue;
 
         QAction * act = popupMenu->addAction(kdeIcon, name);
         act->setData(QVariant(udi));
         udiNameMap[ udi ] = name;
 
         connect(device.as<Solid::StorageAccess>(), &Solid::StorageAccess::accessibilityChanged,
                 this, &MediaButton::slotAccessibilityChanged);
     }
 
     KMountPoint::List possibleMountList = KMountPoint::possibleMountPoints();
     KMountPoint::List currentMountList = KMountPoint::currentMountPoints();
 
-    for (KMountPoint::List::iterator it = possibleMountList.begin(); it != possibleMountList.end(); ++it) {
-        if (krMtMan.networkFilesystem((*it)->mountType())) {
-            QString path = (*it)->mountPoint();
+    for (auto & it : possibleMountList) {
+        if (krMtMan.networkFilesystem(it->mountType())) {
+            QString path = it->mountPoint();
             bool mounted = false;
 
-            for (KMountPoint::List::iterator it2 = currentMountList.begin(); it2 != currentMountList.end(); ++it2) {
-                if (krMtMan.networkFilesystem((*it2)->mountType()) &&
-                        (*it)->mountPoint() == (*it2)->mountPoint()) {
+            for (auto & it2 : currentMountList) {
+                if (krMtMan.networkFilesystem(it2->mountType()) &&
+                        it->mountPoint() == it2->mountPoint()) {
                     mounted = true;
                     break;
                 }
             }
 
-            QString name = i18nc("%1 is the mount point of the remote share", "Remote Share [%1]", (*it)->mountPoint());
+            QString name = i18nc("%1 is the mount point of the remote share", "Remote Share [%1]", it->mountPoint());
             QStringList overlays;
             if (mounted)
                 overlays << "emblem-mounted";
             QAction * act = popupMenu->addAction(Icon("network-wired", overlays), name);
-            QString udi = remotePrefix + (*it)->mountPoint();
+            QString udi = remotePrefix + it->mountPoint();
             act->setData(QVariant(udi));
         }
     }
 
     mountCheckerTimer.setSingleShot(true);
     mountCheckerTimer.start(1000);
 }
 
 bool MediaButton::getNameAndIcon(Solid::Device & device, QString &name, QIcon &iconOut)
 {
-    Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
-    if (access == 0)
+    auto *access = device.as<Solid::StorageAccess>();
+    if (access == nullptr)
         return false;
 
     QString udi     = device.udi();
     QString label   = i18nc("Unknown label", "Unknown");
     bool    mounted = access->isAccessible();
     QString path    = access->filePath();
     QString type    = i18nc("Unknown media type", "Unknown");
     QString iconName = device.icon();
     QString fstype;
     QString size;
 
-    Solid::StorageVolume * vol = device.as<Solid::StorageVolume> ();
+    auto * vol = device.as<Solid::StorageVolume> ();
     if (vol) {
         label = vol->label();
         fstype = vol->fsType();
         size = KIO::convertSize(vol->size());
     }
 
     bool printSize = false;
 
     if (iconName == "media-floppy")
         type = i18n("Floppy");
     else if (iconName == "drive-optical")
         type = i18n("CD/DVD-ROM");
     else if (iconName == "drive-removable-media-usb-pendrive")
         type = i18n("USB pen drive"), printSize = true;
     else if (iconName == "drive-removable-media-usb")
         type = i18n("USB device"), printSize = true;
     else if (iconName == "drive-removable-media")
         type = i18n("Removable media"), printSize = true;
     else if (iconName == "drive-harddisk")
         type = i18n("Hard Disk"), printSize = true;
     else if (iconName == "camera-photo")
         type = i18n("Camera");
     else if (iconName == "media-optical-video")
         type = i18n("Video CD/DVD-ROM");
     else if (iconName == "media-optical-audio")
         type = i18n("Audio CD/DVD-ROM");
     else if (iconName == "media-optical")
         type = i18n("Recordable CD/DVD-ROM");
 
     KConfigGroup cfg(KSharedConfig::openConfig(), QStringLiteral("MediaMenu"));
 
     if (printSize) {
         QString showSizeSetting = cfg.readEntry("ShowSize", "Always");
         if (showSizeSetting == "WhenNoLabel")
             printSize = label.isEmpty();
         else if (showSizeSetting == "Never")
             printSize = false;
     }
 
     if (printSize && !size.isEmpty())
         name += size + ' ';
     if (!label.isEmpty())
         name += label + ' ';
     else
         name += type + ' ';
     if (!fstype.isEmpty() && cfg.readEntry("ShowFSType", true))
         name += '(' + fstype + ") ";
     if (!path.isEmpty() && cfg.readEntry("ShowPath", true))
         name += '[' + path + "] ";
 
     name = name.trimmed();
 
     QStringList overlays;
     if (mounted) {
         overlays << "emblem-mounted";
     } else {
         overlays << QString(); // We have to guarantee the placement of the next emblem
     }
     if (vol && vol->usage() == Solid::StorageVolume::Encrypted) {
         overlays << "security-high";
     }
     iconOut = Icon(iconName, overlays);
     return true;
 }
 
 void MediaButton::slotPopupActivated(QAction *action)
 {
     if (action && action->data().canConvert<QString>()) {
         QString udi = action->data().toString();
         if (!udi.isEmpty()) {
             bool mounted = false;
             QString mountPoint;
             getStatus(udi, mounted, &mountPoint);
 
             if (mounted)
                 emit openUrl(QUrl::fromLocalFile(mountPoint));
             else
                 mount(udi, true);
         }
     }
 }
 
 void MediaButton::showMenu()
 {
     QMenu * pP = menu();
     if (pP) {
         menu() ->exec(mapToGlobal(QPoint(0, height())));
     }
 }
 
 bool MediaButton::eventFilter(QObject *o, QEvent *e)
 {
     if (o == popupMenu) {
         if (e->type() == QEvent::ContextMenu) {
             QAction *act = popupMenu->activeAction();
             if (act && act->data().canConvert<QString>()) {
                 QString id = act->data().toString();
                 if (!id.isEmpty()) {
                     QPoint globalPos = popupMenu->mapToGlobal(popupMenu->actionGeometry(act).topRight());
                     rightClickMenu(id, globalPos);
                     return true;
                 }
             }
         } else if (e->type() == QEvent::KeyPress) {
-            QKeyEvent *ke = static_cast<QKeyEvent*>(e);
+            auto *ke = dynamic_cast<QKeyEvent*>(e);
             if (ke->key() == Qt::Key_Return && ke->modifiers() == Qt::ControlModifier) {
                 if (QAction *act = popupMenu->activeAction()) {
                     QString id = act->data().toString();
                     if (!id.isEmpty()) {
                         toggleMount(id);
                         return true;
                     }
                 }
             }
         } else if (e->type() == QEvent::MouseButtonPress || e->type() == QEvent::MouseButtonRelease) {
-            QMouseEvent *m = static_cast<QMouseEvent*>(e);
+            auto *m = dynamic_cast<QMouseEvent*>(e);
             if (m->button() == Qt::RightButton) {
                 if (e->type() == QEvent::MouseButtonPress) {
                     QAction * act = popupMenu->actionAt(m->pos());
                     if (act && act->data().canConvert<QString>()) {
                         QString id = act->data().toString();
                         if (!id.isEmpty())
                             rightClickMenu(id, m->globalPos());
                     }
                 }
                 m->accept();
                 return true;
             }
         }
     }
     return false;
 }
 
-void MediaButton::rightClickMenu(QString udi, QPoint pos)
+void MediaButton::rightClickMenu(const QString& udi, QPoint pos)
 {
     if (rightMenu)
         rightMenu->close();
 
     bool ejectable = false;
     bool mounted = false;
     QString mountPoint;
 
     getStatus(udi, mounted, &mountPoint, &ejectable);
 
     QUrl openURL = QUrl::fromLocalFile(mountPoint);
 
     QMenu * myMenu = rightMenu = new QMenu(popupMenu);
     QAction * actOpen = myMenu->addAction(i18n("Open"));
     actOpen->setData(QVariant(1));
     QAction * actOpenNewTab = myMenu->addAction(i18n("Open in a new tab"));
     actOpenNewTab->setData(QVariant(2));
 
     myMenu->addSeparator();
     if (!mounted) {
         QAction * actMount = myMenu->addAction(i18n("Mount"));
         actMount->setData(QVariant(3));
     } else {
         QAction * actUnmount = myMenu->addAction(i18n("Unmount"));
         actUnmount->setData(QVariant(4));
     }
     if (ejectable) {
         QAction * actEject = myMenu->addAction(i18n("Eject"));
         actEject->setData(QVariant(5));
     }
 
     QAction *act = myMenu->exec(pos);
     int result = -1;
-    if (act != 0 && act->data().canConvert<int>())
+    if (act != nullptr && act->data().canConvert<int>())
         result = act->data().toInt();
 
     delete myMenu;
     if (rightMenu == myMenu)
-        rightMenu = 0;
+        rightMenu = nullptr;
     else
         return;
 
     switch (result) {
     case 1:
     case 2:
         popupMenu->close();
         if (mounted) {
             if (result == 1)
                 emit openUrl(openURL);
             else
                 emit newTab(openURL);
         } else {
             mount(udi, true, result == 2);   // mount first, when mounted open the tab
         }
         break;
     case 3:
         mount(udi);
         break;
     case 4:
         umount(udi);
         break;
     case 5:
         eject(udi);
         break;
     default:
         break;
     }
 }
 
-void MediaButton::toggleMount(QString udi)
+void MediaButton::toggleMount(const QString& udi)
 {
     bool mounted = false;
     getStatus(udi, mounted);
 
     if (mounted)
         umount(udi);
     else
         mount(udi);
 }
 
-void MediaButton::getStatus(QString udi, bool &mounted, QString *mountPointOut, bool *ejectableOut)
+void MediaButton::getStatus(const QString& udi, bool &mounted, QString *mountPointOut, bool *ejectableOut)
 {
     mounted = false;
     bool network = udi.startsWith(remotePrefix);
     bool ejectable = false;
     QString mountPoint;
 
     if (network) {
          mountPoint = udi.mid(remotePrefix.length());
 
         KMountPoint::List currentMountList = KMountPoint::currentMountPoints();
-        for (KMountPoint::List::iterator it = currentMountList.begin(); it != currentMountList.end(); ++it) {
-            if (krMtMan.networkFilesystem((*it)->mountType()) &&
-                    (*it)->mountPoint() == mountPoint) {
+        for (auto & it : currentMountList) {
+            if (krMtMan.networkFilesystem(it->mountType()) &&
+                    it->mountPoint() == mountPoint) {
                 mounted = true;
                 break;
             }
         }
     } else {
         Solid::Device device(udi);
 
-        Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
-        Solid::OpticalDisc  *optdisc = device.as<Solid::OpticalDisc>();
+        auto *access = device.as<Solid::StorageAccess>();
+        auto  *optdisc = device.as<Solid::OpticalDisc>();
         if (access)
             mountPoint = access->filePath();
         if (access && access->isAccessible())
             mounted = true;
         if (optdisc)
             ejectable = true;
     }
 
     if (mountPointOut)
         *mountPointOut = mountPoint;
     if (ejectableOut)
         *ejectableOut = ejectable;
 }
 
-void MediaButton::mount(QString udi, bool open, bool newtab)
+void MediaButton::mount(const QString& udi, bool open, bool newtab)
 {
     if (udi.startsWith(remotePrefix)) {
         QString mp = udi.mid(remotePrefix.length());
         krMtMan.mount(mp, true);
         if (newtab)
             emit newTab(QUrl::fromLocalFile(mp));
         else
             emit openUrl(QUrl::fromLocalFile(mp));
         return;
     }
     Solid::Device device(udi);
-    Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
+    auto *access = device.as<Solid::StorageAccess>();
     if (access && !access->isAccessible()) {
         if (open)
             udiToOpen = device.udi(), openInNewTab = newtab;
         connect(access, &Solid::StorageAccess::setupDone, this, &MediaButton::slotSetupDone);
         access->setup();
     }
 }
 
-void MediaButton::slotSetupDone(Solid::ErrorType error, QVariant errorData, const QString &udi)
+void MediaButton::slotSetupDone(Solid::ErrorType error, const QVariant& errorData, const QString &udi)
 {
     if (error == Solid::NoError) {
         if (udi == udiToOpen) {
-            Solid::StorageAccess *access = Solid::Device(udi).as<Solid::StorageAccess>();
+            auto *access = Solid::Device(udi).as<Solid::StorageAccess>();
             if (access && access->isAccessible()) {
                 if (openInNewTab)
                     emit newTab(QUrl::fromLocalFile(access->filePath()));
                 else
                     emit openUrl(QUrl::fromLocalFile(access->filePath()));
             }
             udiToOpen = QString(), openInNewTab = false;
         }
     } else {
         if (udi == udiToOpen)
             udiToOpen = QString(), openInNewTab = false;
         QString name;
         if (udiNameMap.contains(udi))
             name = udiNameMap[ udi ];
 
         if (errorData.isValid()) {
             KMessageBox::sorry(this, i18n("An error occurred while accessing '%1', the system responded: %2",
                                           name, errorData.toString()));
         } else {
             KMessageBox::sorry(this, i18n("An error occurred while accessing '%1'", name));
         }
     }
 }
 
-void MediaButton::umount(QString udi)
+void MediaButton::umount(const QString& udi)
 {
     if (udi.startsWith(remotePrefix)) {
         krMtMan.unmount(udi.mid(remotePrefix.length()), false);
         return;
     }
     krMtMan.unmount(krMtMan.pathForUdi(udi), false);
 }
 
 void MediaButton::eject(QString udi)
 {
-    krMtMan.eject(krMtMan.pathForUdi(udi));
+    krMtMan.eject(krMtMan.pathForUdi(std::move(udi)));
 }
 
 void MediaButton::slotAccessibilityChanged(bool /*accessible*/, const QString & udi)
 {
     QList<QAction *> actionList = popupMenu->actions();
     foreach(QAction * act, actionList) {
         if (act && act->data().canConvert<QString>() && act->data().toString() == udi) {
             Solid::Device device(udi);
 
             QString name;
             QIcon kdeIcon;
             if (getNameAndIcon(device, name, kdeIcon)) {
                 act->setText(name);
                 act->setIcon(kdeIcon);
             }
             break;
         }
     }
 }
 
 void MediaButton::slotDeviceAdded(const QString& udi)
 {
     if (popupMenu->isHidden())
         return;
 
     Solid::Device device(udi);
-    Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
-    if (access == 0)
+    auto *access = device.as<Solid::StorageAccess>();
+    if (access == nullptr)
         return;
 
     QString name;
     QIcon kdeIcon;
     if (!getNameAndIcon(device, name, kdeIcon))
         return;
 
     QAction * act = popupMenu->addAction(kdeIcon, name);
     act->setData(QVariant(udi));
     udiNameMap[ udi ] = name;
 
     connect(device.as<Solid::StorageAccess>(), &Solid::StorageAccess::accessibilityChanged,
             this, &MediaButton::slotAccessibilityChanged);
 }
 
 void MediaButton::slotDeviceRemoved(const QString& udi)
 {
     if (popupMenu->isHidden())
         return;
 
     QList<QAction *> actionList = popupMenu->actions();
     foreach(QAction * act, actionList) {
         if (act && act->data().canConvert<QString>() && act->data().toString() == udi) {
             popupMenu->removeAction(act);
             delete act;
             break;
         }
     }
 }
 
 void MediaButton::slotCheckMounts()
 {
     if (isHidden())
         return;
 
     KMountPoint::List possibleMountList = KMountPoint::possibleMountPoints();
     KMountPoint::List currentMountList = KMountPoint::currentMountPoints();
     QList<QAction *> actionList = popupMenu->actions();
 
     foreach(QAction * act, actionList) {
         if (act &&
                 act->data().canConvert<QString>() &&
                 act->data().toString().startsWith(remotePrefix)) {
             QString mountPoint = act->data().toString().mid(remotePrefix.length());
             bool available = false;
 
-            for (KMountPoint::List::iterator it = possibleMountList.begin(); it != possibleMountList.end(); ++it) {
-                if (krMtMan.networkFilesystem((*it)->mountType()) &&
-                        (*it)->mountPoint() == mountPoint) {
+            for (auto & it : possibleMountList) {
+                if (krMtMan.networkFilesystem(it->mountType()) &&
+                        it->mountPoint() == mountPoint) {
                     available = true;
                     break;
                 }
             }
 
             if (!available) {
                 popupMenu->removeAction(act);
                 delete act;
             }
         }
     }
 
-    for (KMountPoint::List::iterator it = possibleMountList.begin(); it != possibleMountList.end(); ++it) {
-        if (krMtMan.networkFilesystem((*it)->mountType())) {
-            QString path = (*it)->mountPoint();
+    for (auto & it : possibleMountList) {
+        if (krMtMan.networkFilesystem(it->mountType())) {
+            QString path = it->mountPoint();
             bool mounted = false;
             QString udi = remotePrefix + path;
 
-            QAction * correspondingAct = 0;
+            QAction * correspondingAct = nullptr;
             foreach(QAction * act, actionList) {
                 if (act && act->data().canConvert<QString>() && act->data().toString() == udi) {
                     correspondingAct = act;
                     break;
                 }
             }
-            for (KMountPoint::List::iterator it2 = currentMountList.begin(); it2 != currentMountList.end(); ++it2) {
-                if (krMtMan.networkFilesystem((*it2)->mountType()) &&
-                        path == (*it2)->mountPoint()) {
+            for (auto & it2 : currentMountList) {
+                if (krMtMan.networkFilesystem(it2->mountType()) &&
+                        path == it2->mountPoint()) {
                     mounted = true;
                     break;
                 }
             }
 
-            QString name = i18nc("%1 is the mount point of the remote share", "Remote Share [%1]", (*it)->mountPoint());
+            QString name = i18nc("%1 is the mount point of the remote share", "Remote Share [%1]", it->mountPoint());
             QStringList overlays;
             if (mounted)
                 overlays << "emblem-mounted";
             QIcon kdeIcon = Icon("network-wired", overlays);
 
             if (!correspondingAct) {
                 QAction * act = popupMenu->addAction(kdeIcon, name);
                 act->setData(QVariant(udi));
             } else {
                 correspondingAct->setText(name);
                 correspondingAct->setIcon(kdeIcon);
             }
         }
     }
 
     mountCheckerTimer.setSingleShot(true);
     mountCheckerTimer.start(1000);
 }
 
diff --git a/krusader/GUI/mediabutton.h b/krusader/GUI/mediabutton.h
index 752aefe6..a37daa18 100644
--- a/krusader/GUI/mediabutton.h
+++ b/krusader/GUI/mediabutton.h
@@ -1,93 +1,93 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef MEDIABUTTON_H
 #define MEDIABUTTON_H
 
 // QtCore
 #include <QEvent>
 #include <QList>
 #include <QMap>
 #include <QTimer>
 #include <QUrl>
 // QtWidgets
 #include <QWidget>
 #include <QToolButton>
 #include <QMenu>
 
 #include <Solid/Device>
 #include <Solid/SolidNamespace>
 
 class QMenu;
 
 class MediaButton : public QToolButton
 {
     Q_OBJECT
 public:
-    explicit MediaButton(QWidget *parent = 0);
-    ~MediaButton();
+    explicit MediaButton(QWidget *parent = nullptr);
+    ~MediaButton() override;
 
 public slots:
     void slotAboutToShow();
     void slotAboutToHide();
     void slotPopupActivated(QAction *);
     void slotAccessibilityChanged(bool, const QString &);
     void slotDeviceAdded(const QString&);
     void slotDeviceRemoved(const QString&);
     void showMenu();
     void slotCheckMounts();
     void updateIcon(const QString &mountPoint);
 
 signals:
     void openUrl(const QUrl&);
     void newTab(const QUrl&);
     void aboutToShow();
 
 protected:
     bool eventFilter(QObject *o, QEvent *e) Q_DECL_OVERRIDE;
     bool getNameAndIcon(Solid::Device &, QString &, QIcon &);
 
 private:
     void createMediaList();
-    void toggleMount(QString udi);
-    void getStatus(QString udi, bool &mounted, QString *mountPointOut = 0, bool *ejectableOut = 0);
-    void mount(QString, bool open = false, bool newtab = false);
-    void umount(QString);
+    void toggleMount(const QString& udi);
+    void getStatus(const QString& udi, bool &mounted, QString *mountPointOut = nullptr, bool *ejectableOut = nullptr);
+    void mount(const QString&, bool open = false, bool newtab = false);
+    void umount(const QString&);
     void eject(QString);
-    void rightClickMenu(QString udi, QPoint pos);
+    void rightClickMenu(const QString& udi, QPoint pos);
 
     QList<Solid::Device> storageDevices;
 
 private slots:
-    void slotSetupDone(Solid::ErrorType error, QVariant errorData, const QString &udi);
+    void slotSetupDone(Solid::ErrorType error, const QVariant& errorData, const QString &udi);
 
 private:
     static QString remotePrefix;
 
     QMenu  *popupMenu;
     QMenu  *rightMenu;
     QString udiToOpen;
     bool    openInNewTab;
     QMap<QString, QString> udiNameMap;
     QTimer      mountCheckerTimer;
     QString currentMountPoint; // for performance optimization
 };
 
 #endif /* MEDIABUTTON_H */
diff --git a/krusader/GUI/profilemanager.cpp b/krusader/GUI/profilemanager.cpp
index 8c6f58ba..c563e401 100644
--- a/krusader/GUI/profilemanager.cpp
+++ b/krusader/GUI/profilemanager.cpp
@@ -1,184 +1,184 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "profilemanager.h"
 
 // QtGui
 #include <QCursor>
 // QtWidgets
 #include <QInputDialog>
 #include <QMenu>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 #include "../krglobal.h"
 #include "../icon.h"
 
-ProfileManager::ProfileManager(QString profileType, QWidget * parent)
+ProfileManager::ProfileManager(const QString& profileType, QWidget * parent)
         : QPushButton(parent)
 {
     setText("");
     setIcon(Icon("user-identity"));
     setFixedWidth(16 + 15);
     setToolTip(i18n("Profiles"));
 
     this->profileType = profileType;
 
     connect(this, &ProfileManager::clicked, this, &ProfileManager::profilePopup);
 
     KConfigGroup group(krConfig, "Private");
     profileList = group.readEntry(profileType, QStringList());
 }
 
 void ProfileManager::profilePopup()
 {
     // profile menu identifiers
 #define ADD_NEW_ENTRY_ID    1000
 #define LOAD_ENTRY_ID       2000
 #define REMOVE_ENTRY_ID     3000
 #define OVERWRITE_ENTRY_ID  4000
 
     // create the menu
     QMenu popup, removePopup, overwritePopup;
     popup.setTitle(i18n("Profiles"));
 
     for (int i = 0; i != profileList.count() ; i++) {
         KConfigGroup group(krConfig, profileType + " - " + profileList[i]);
         QString name = group.readEntry("Name");
         popup.addAction(name)->setData(QVariant((int)(LOAD_ENTRY_ID + i)));
         removePopup.addAction(name)->setData(QVariant((int)(REMOVE_ENTRY_ID + i)));
         overwritePopup.addAction(name)->setData(QVariant((int)(OVERWRITE_ENTRY_ID + i)));
     }
 
     popup.addSeparator();
 
     if (profileList.count()) {
         popup.addMenu(&removePopup)->setText(i18n("Remove entry"));
         popup.addMenu(&overwritePopup)->setText(i18n("Overwrite entry"));
     }
 
     popup.addAction(i18n("Add new entry"))->setData(QVariant((int)(ADD_NEW_ENTRY_ID)));
 
 
     int result = 0;
     QAction * res = popup.exec(QCursor::pos());
     if (res && res->data().canConvert<int>())
         result = res->data().toInt();
 
     // check out the user's selection
     if (result == ADD_NEW_ENTRY_ID)
         newProfile();
     else if (result >= LOAD_ENTRY_ID && result < LOAD_ENTRY_ID + profileList.count()) {
         emit loadFromProfile(profileType + " - " + profileList[ result - LOAD_ENTRY_ID ]);
     } else if (result >= REMOVE_ENTRY_ID && result < REMOVE_ENTRY_ID + profileList.count()) {
         krConfig->deleteGroup(profileType + " - " + profileList[ result - REMOVE_ENTRY_ID ]);
         profileList.removeAll(profileList[ result - REMOVE_ENTRY_ID ]);
 
         KConfigGroup group(krConfig, "Private");
         group.writeEntry(profileType, profileList);
         krConfig->sync();
     } else if (result >= OVERWRITE_ENTRY_ID && result < OVERWRITE_ENTRY_ID + profileList.count()) {
         emit saveToProfile(profileType + " - " + profileList[ result - OVERWRITE_ENTRY_ID ]);
     }
 }
 
-void ProfileManager::newProfile(QString defaultName)
+void ProfileManager::newProfile(const QString& defaultName)
 {
     QString profile = QInputDialog::getText(this, i18n("Krusader::ProfileManager"), i18n("Enter the profile name:"),
                                             QLineEdit::Normal, defaultName);
     if (!profile.isEmpty()) {
         int profileNum = 1;
         while (profileList.contains(QString("%1").arg(profileNum)))
             profileNum++;
 
         QString profileString = QString("%1").arg(profileNum);
         QString profileName = profileType + " - " + profileString;
         profileList.append(QString("%1").arg(profileString));
 
         KConfigGroup group(krConfig, "Private");
         group.writeEntry(profileType, profileList);
 
         KConfigGroup pg(krConfig, profileName);
         pg.writeEntry("Name", profile);
         emit saveToProfile(profileName);
         krConfig->sync();
     }
 }
 
-void ProfileManager::deleteProfile(QString name)
+void ProfileManager::deleteProfile(const QString& name)
 {
     for (int i = 0; i != profileList.count() ; i++) {
         KConfigGroup group(krConfig, profileType + " - " + profileList[ i ]);
         QString currentName = group.readEntry("Name");
 
         if (name == currentName) {
             krConfig->deleteGroup(profileType + " - " + profileList[ i ]);
             profileList.removeAll(profileList[ i ]);
 
             KConfigGroup pg(krConfig, "Private");
             pg.writeEntry(profileType, profileList);
             krConfig->sync();
             return;
         }
     }
 }
 
-void ProfileManager::overwriteProfile(QString name)
+void ProfileManager::overwriteProfile(const QString& name)
 {
     for (int i = 0; i != profileList.count() ; i++) {
         KConfigGroup group(krConfig, profileType + " - " + profileList[ i ]);
         QString currentName = group.readEntry("Name");
 
         if (name == currentName) {
             emit saveToProfile(profileType + " - " + profileList[ i ]);
             return;
         }
     }
 }
 
-bool ProfileManager::loadProfile(QString name)
+bool ProfileManager::loadProfile(const QString& name)
 {
     for (int i = 0; i != profileList.count() ; i++) {
         KConfigGroup group(krConfig, profileType + " - " + profileList[i]);
         QString currentName = group.readEntry("Name");
 
         if (name == currentName) {
             emit loadFromProfile(profileType + " - " + profileList[ i ]);
             return true;
         }
     }
     return false;
 }
 
-QStringList ProfileManager::availableProfiles(QString profileType)
+QStringList ProfileManager::availableProfiles(const QString& profileType)
 {
     KConfigGroup group(krConfig, "Private");
     QStringList profiles = group.readEntry(profileType, QStringList());
     QStringList profileNames;
 
     for (int i = 0; i != profiles.count() ; i++) {
         KConfigGroup pg(krConfig, profileType + " - " + profiles[ i ]);
         profileNames.append(pg.readEntry("Name"));
     }
 
     return profileNames;
 }
 
diff --git a/krusader/GUI/profilemanager.h b/krusader/GUI/profilemanager.h
index 8c4c3331..aef239e3 100644
--- a/krusader/GUI/profilemanager.h
+++ b/krusader/GUI/profilemanager.h
@@ -1,77 +1,77 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef PROFILEMANAGER_H
 #define PROFILEMANAGER_H
 
 // QtCore
 #include <QString>
 // QtWidgets
 #include <QPushButton>
 
 /**
  * A generic profile manager: Profiles are arbitrary configurations groups and the manager handles
  * saving/loading multiple groups to/from the configuration.
  *
  * A manager instance is responsible for a profile type specified by a type name:
  * "Panel", "SelectionProfile", "SearcherProfile", "SynchronizerProfile", ...
  *
  * Profiles are numbered in the configuration group name and have an additional name property. E.g.
  *
  * [Panel - 2]
  * Name=Media Profile
  * ...
  *
  * This class is view and model at the same time :/
  * The GUI button opens a popup menu for selecting, creating, overwriting and removing profiles.
  */
 class ProfileManager : public QPushButton
 {
     Q_OBJECT
 
 public:
-    explicit ProfileManager(QString profileType, QWidget * parent = 0);
+    explicit ProfileManager(const QString& profileType, QWidget * parent = nullptr);
 
     /**
      * @param profileType Type of the profile (sync, search, ...)
      * @return A list of all available profile-names
      */
-    static QStringList availableProfiles(QString profileType);
+    static QStringList availableProfiles(const QString& profileType);
 
     QStringList getNames();
 
 public slots:
     void profilePopup();
 
-    void newProfile(QString defaultName = QString());
-    void deleteProfile(QString name);
-    void overwriteProfile(QString name);
-    bool loadProfile(QString name);
+    void newProfile(const QString& defaultName = QString());
+    void deleteProfile(const QString& name);
+    void overwriteProfile(const QString& name);
+    bool loadProfile(const QString& name);
 
 signals:
     void saveToProfile(QString profileName);
     void loadFromProfile(QString profileName);
 
 private:
     QString profileType;
     QStringList profileList;
 };
 
 #endif /* PROFILEMANAGER_H */
diff --git a/krusader/GUI/terminaldock.cpp b/krusader/GUI/terminaldock.cpp
index e0a07f20..7e9e3be7 100644
--- a/krusader/GUI/terminaldock.cpp
+++ b/krusader/GUI/terminaldock.cpp
@@ -1,289 +1,288 @@
 /*****************************************************************************
  * Copyright (C) 2008 Václav Juza <vaclavjuza@gmail.com>                     *
  * Copyright (C) 2008-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "terminaldock.h"
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 #include <QEvent>
 #include <QObject>
 #include <QString>
 #include <QUrl>
 // QtGui
 #include <QKeyEvent>
 #include <QClipboard>
 // QtWidgets
 #include <QHBoxLayout>
 #include <QApplication>
 #include <QWidget>
 
 #include <kde_terminal_interface.h>
 #include <KCoreAddons/KPluginLoader>
 #include <KCoreAddons/KPluginFactory>
 #include <KI18n/KLocalizedString>
 #include <KService/KService>
 #include <KWidgetsAddons/KToggleAction>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "kcmdline.h"
 #include "../kractions.h"
 #include "../krmainwindow.h"
 #include "../krservices.h"
 #include "../krslots.h"
 #include "../krusaderview.h"
 #include "../FileSystem/filesystem.h"
 #include "../Panel/PanelView/krview.h"
 #include "../Panel/listpanel.h"
 #include "../Panel/listpanelactions.h"
 #include "../Panel/panelfunc.h"
 
 /**
  * A widget containing the konsolepart for the Embedded terminal emulator
  */
 TerminalDock::TerminalDock(QWidget* parent, KrMainWindow *mainWindow) : QWidget(parent),
-    _mainWindow(mainWindow), konsole_part(0), t(0), initialised(false), firstInput(true)
+    _mainWindow(mainWindow), konsole_part(nullptr), t(nullptr), initialised(false), firstInput(true)
 {
     terminal_hbox = new QHBoxLayout(this);
 }
 
 TerminalDock::~TerminalDock()
-{
-}
+= default;
 
 bool TerminalDock::initialise()
 {
     if (! initialised) { // konsole part is not yet loaded or it has already failed
         KService::Ptr service = KService::serviceByDesktopName("konsolepart");
 
         if (service) {
             QWidget *focusW = qApp->focusWidget();
             // Create the part
             QString error;
             konsole_part = service->createInstance<KParts::ReadOnlyPart>(this, this, QVariantList(), &error);
 
             if (konsole_part) { //loaded successfully
                 terminal_hbox->addWidget(konsole_part->widget());
                 setFocusProxy(konsole_part->widget());
                 connect(konsole_part, &KParts::ReadOnlyPart::destroyed, this,
                         &TerminalDock::killTerminalEmulator);
                 // must filter app events, because some of them are processed
                 // by child widgets of konsole_part->widget()
                 // and would not be received on konsole_part->widget()
                 qApp->installEventFilter(this);
                 t = qobject_cast<TerminalInterface*>(konsole_part);
                 if (t) {
                     lastPath = QDir::currentPath();
                     t->showShellInDir(lastPath);
                 }
                 initialised = true;
                 firstInput = true;
             } else
-                KMessageBox::error(0, i18n("<b>Cannot create embedded terminal.</b><br/>"
+                KMessageBox::error(nullptr, i18n("<b>Cannot create embedded terminal.</b><br/>"
                                            "The reported error was: %1", error));
             // the Terminal Emulator may be hidden (if we are creating it only
             // to send command there and see the results later)
             if (focusW) {
                 focusW->setFocus();
             } else {
                 ACTIVE_PANEL->gui->slotFocusOnMe();
             }
         } else
-            KMessageBox::sorry(0, i18nc("missing program - arg1 is a URL",
+            KMessageBox::sorry(nullptr, i18nc("missing program - arg1 is a URL",
                                         "<b>Cannot create embedded terminal.</b><br>"
                                         "You can fix this by installing Konsole:<br/>%1",
                                         QString("<a href='%1'>%1</a>").arg(
                                             "https://www.kde.org/applications/system/konsole")),
-                               0, KMessageBox::AllowLink);
+                               nullptr, KMessageBox::AllowLink);
     }
     return isInitialised();
 }
 
 void TerminalDock::killTerminalEmulator()
 {
     qDebug() << "killed";
 
     initialised = false;
-    konsole_part = NULL;
-    t = NULL;
+    konsole_part = nullptr;
+    t = nullptr;
     qApp->removeEventFilter(this);
     MAIN_VIEW->setTerminalEmulator(false);
 }
 
 void TerminalDock::sendInput(const QString& input, bool clearCommand)
 {
     if (!t)
         return;
 
     if (clearCommand) {
         // send SIGINT before input command to avoid unwanted behaviour when current line is not empty
         // and command is appended to current input (e.g. "rm -rf x " concatenated with 'cd /usr');
         // code "borrowed" from Dolphin, Copyright (C) 2007-2010 by Peter Penz <peter.penz19@gmail.com>
         const int processId = t->terminalProcessId();
         // workaround (firstInput): kill is sent to terminal if shell is not initialized yet
         if (processId > 0 && !firstInput) {
             kill(processId, SIGINT);
         }
     }
     firstInput = false;
 
     t->sendInput(input);
 }
 
 /*! Sends a `cd` command to the embedded terminal emulator so as to synchronize the directory of the actual panel and
     the directory of the embedded terminal emulator.
 
     To avoid that Krusader's embedded terminal adds a lot of `cd` messages to the shell history: the user has to use
     bash and have set `HISTCONTROL=ignorespace` or `HISTCONTROL=ignoreboth` (which is the default in a lot of Linux
     distributions so in that case the user hasn't got to do anything), or the user has to use an equivalent method.
 */
 void TerminalDock::sendCd(const QString& path)
 {
     if (path.compare(lastPath) != 0) {
         // A space exists in front of the `cd` so as to avoid that Krusader's embedded terminal adds a lot of `cd`
         // messages to the shell history, in Dolphin it's done the same way: https://bugs.kde.org/show_bug.cgi?id=204039
         sendInput(QString(" cd ") + KrServices::quote(path) + QString("\n"));
         lastPath = path;
     }
 }
 
 bool TerminalDock::applyShortcuts(QKeyEvent * ke)
 {
     int pressedKey = (ke->key() | ke->modifiers());
 
     // TODO KF5 removed
     if (KrActions::actToggleTerminal->shortcut().matches(pressedKey)) {
         KrActions::actToggleTerminal->activate(QAction::Trigger);
         return true;
     }
 
     if (!krSwitchFullScreenTE->shortcut().isEmpty() && krSwitchFullScreenTE->shortcut().matches(pressedKey)) {
         krSwitchFullScreenTE->activate(QAction::Trigger);
         return true;
     }
 
     if (_mainWindow->listPanelActions()->actPaste->shortcut().matches(pressedKey)) {
         QString text = QApplication::clipboard()->text();
         if (! text.isEmpty()) {
             text.replace('\n', '\r');
             sendInput(text, false);
         }
         return true;
     }
 
     //insert current to the terminal
     if ((ke->key() == Qt::Key_Enter || ke->key() == Qt::Key_Return) &&
         (ke->modifiers() & Qt::ControlModifier)) {
         SLOTS->insertFileName((ke->modifiers()&Qt::ShiftModifier)!=0);
         return true;
     }
 
     //navigation
     if ((ke->key() ==  Qt::Key_Down) && (ke->modifiers() == Qt::ControlModifier)) {
         if (MAIN_VIEW->cmdLine()->isVisible()) {
             MAIN_VIEW->cmdLine()->setFocus();
         }
         return true;
     } else if ((ke->key() ==  Qt::Key_Up)
                && ((ke->modifiers()  == Qt::ControlModifier)
                    || (ke->modifiers()  == (Qt::ControlModifier | Qt::ShiftModifier)))) {
         ACTIVE_PANEL->gui->slotFocusOnMe();
         return true;
     }
 
     return false;
 }
 
 bool TerminalDock::eventFilter(QObject * watched, QEvent * e)
 {
-    if (konsole_part == NULL || konsole_part->widget() == NULL)
+    if (konsole_part == nullptr || konsole_part->widget() == nullptr)
         return false;
 
     // we must watch for child widgets as well,
     // otherwise some shortcuts are "eaten" by them before
     // being processed in konsole_part->widget() context
     // examples are Ctrl+F, Ctrl+Enter
     QObject *w;
-    for (w = watched; w != NULL; w = w->parent())
+    for (w = watched; w != nullptr; w = w->parent())
         if (w == konsole_part->widget())
             break;
-    if (w == NULL)    // is not a child of konsole_part
+    if (w == nullptr)    // is not a child of konsole_part
         return false;
 
     switch (e->type()) {
     case QEvent::ShortcutOverride: {
-        QKeyEvent *ke = (QKeyEvent *)e;
+        auto *ke = (QKeyEvent *)e;
         // If not present, some keys would be considered a shortcut, for example "a"
         if ((ke->key() ==  Qt::Key_Insert) && (ke->modifiers()  == Qt::ShiftModifier)) {
             ke->accept();
             return true;
         }
         if ((ke->modifiers() == Qt::NoModifier || ke->modifiers() == Qt::ShiftModifier) &&
                 (ke->key() >= 32) && (ke->key() <= 127)) {
             ke->accept();
             return true;
         }
         break;
     }
     case QEvent::KeyPress: {
-        QKeyEvent *ke = (QKeyEvent *)e;
+        auto *ke = (QKeyEvent *)e;
         if (applyShortcuts(ke)) {
             ke->accept();
             return true;
         }
         break;
     }
     default:
         return false;
     }
     return false;
 }
 
 bool TerminalDock::isTerminalVisible() const
 {
-    return isVisible() && konsole_part != NULL && konsole_part->widget() != NULL
+    return isVisible() && konsole_part != nullptr && konsole_part->widget() != nullptr
            && konsole_part->widget()->isVisible();
 }
 
 bool TerminalDock::isInitialised() const
 {
-    return konsole_part != NULL && konsole_part->widget() != NULL;
+    return konsole_part != nullptr && konsole_part->widget() != nullptr;
 }
 
 void TerminalDock::hideEvent(QHideEvent * /*e*/)
 {
     // BUGFIX: when the terminal emulator is toggled on, first it is shown in minimum size
     //         then QSplitter resizes it to the desired size.
     //         this minimum resize scrolls up the content of the konsole widget
     // SOLUTION:
     //         we hide the console widget while the resize ceremony happens, then reenable it
     if (konsole_part && konsole_part->widget())
         konsole_part->widget()->hide(); // hide the widget to prevent from resize
 }
 
 void TerminalDock::showEvent(QShowEvent * /*e*/)
 {
     if (konsole_part && konsole_part->widget()) {
         // BUGFIX: TE scrolling bug (see upper)
         //         show the Konsole part delayed
         QTimer::singleShot(0, konsole_part->widget(), &QWidget::show);
     }
 }
 
diff --git a/krusader/GUI/terminaldock.h b/krusader/GUI/terminaldock.h
index 9d57a5c3..7390b834 100644
--- a/krusader/GUI/terminaldock.h
+++ b/krusader/GUI/terminaldock.h
@@ -1,74 +1,74 @@
 /*****************************************************************************
  * Copyright (C) 2008 Václav Juza <vaclavjuza@gmail.com>                     *
  * Copyright (C) 2008-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef TERMINALDOCK_H
 #define TERMINALDOCK_H
 
 // QtCore
 #include <QEvent>
 #include <QString>
 #include <QObject>
 // QtWidgets
 #include <QHBoxLayout>
 #include <QWidget>
 
 #include <kde_terminal_interface.h>
 #include <KParts/ReadOnlyPart>
 
 class KrMainWindow;
 
 /**
  * This is a class to make the work with the embedded terminal emulator easier.
  * It takes care of loading the library and initialising when necessary.
  * A big advantage is that the code which uses this class does not need to
  * check if the part was loaded successfully.
  *
  */
 class TerminalDock : public QWidget
 {
     Q_OBJECT
 public:
     TerminalDock(QWidget* parent, KrMainWindow *mainWindow);
-    virtual ~TerminalDock();
+    ~TerminalDock() override;
     void sendInput(const QString& input, bool clearCommand=true);
     void sendCd(const QString& path);
-    virtual bool eventFilter(QObject * watched, QEvent * e) Q_DECL_OVERRIDE;
+    bool eventFilter(QObject * watched, QEvent * e) Q_DECL_OVERRIDE;
     bool isTerminalVisible() const;
     bool isInitialised() const;
     bool initialise();
-    virtual void hideEvent(QHideEvent * e) Q_DECL_OVERRIDE;
-    virtual void showEvent(QShowEvent * e) Q_DECL_OVERRIDE;
+    void hideEvent(QHideEvent * e) Q_DECL_OVERRIDE;
+    void showEvent(QShowEvent * e) Q_DECL_OVERRIDE;
     inline KParts::Part* part() {
         return konsole_part;
     }
 private slots:
     void killTerminalEmulator();
 private:
     KrMainWindow *_mainWindow;
     QString lastPath;                       // path of the last sendCd
     QHBoxLayout *terminal_hbox;             // hbox for terminal_dock
     KParts::ReadOnlyPart* konsole_part;     // the actual part pointer
     TerminalInterface* t;                   // TerminalInterface of the konsole part
     bool initialised;
     bool firstInput;
     bool applyShortcuts(QKeyEvent * ke);
 };
 
 #endif /* TERMINALDOCK_H */
diff --git a/krusader/JobMan/jobman.cpp b/krusader/JobMan/jobman.cpp
index 06aedb34..a86ee994 100644
--- a/krusader/JobMan/jobman.cpp
+++ b/krusader/JobMan/jobman.cpp
@@ -1,459 +1,459 @@
 /*****************************************************************************
  * Copyright (C) 2016-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "jobman.h"
 
 // QtCore
 #include <QDebug>
 #include <QUrl>
 // QtWidgets
 #include <QComboBox>
 #include <QLabel>
 #include <QMenu>
 #include <QPushButton>
 #include <QVBoxLayout>
 #include <QWidgetAction>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIOWidgets/KIO/FileUndoManager>
 
 #include "krjob.h"
 #include "../krglobal.h"
 #include "../icon.h"
 
 const int MAX_OLD_MENU_ACTIONS = 10;
 
 /** The menu action entry for a job in the popup menu.*/
 class JobMenuAction : public QWidgetAction
 {
     Q_OBJECT
 public:
     JobMenuAction(KrJob *krJob, QObject *parent, KJob *kJob = nullptr)
         : QWidgetAction(parent), m_krJob(krJob)
     {
         QWidget *container = new QWidget();
-        QGridLayout *layout = new QGridLayout(container);
+        auto *layout = new QGridLayout(container);
         m_description = new QLabel(krJob->description());
         m_progressBar = new QProgressBar();
         layout->addWidget(m_description, 0, 0, 1, 3);
         layout->addWidget(m_progressBar, 1, 0);
 
         m_pauseResumeButton = new QPushButton();
         updatePauseResumeButton();
         connect(m_pauseResumeButton, &QPushButton::clicked, this,
               &JobMenuAction::slotPauseResumeButtonClicked);
         layout->addWidget(m_pauseResumeButton, 1, 1);
 
         m_cancelButton = new QPushButton();
         m_cancelButton->setIcon(Icon("remove"));
         m_cancelButton->setToolTip(i18n("Cancel Job"));
         connect(m_cancelButton, &QPushButton::clicked,
                 this, &JobMenuAction::slotCancelButtonClicked);
         layout->addWidget(m_cancelButton, 1, 2);
 
         setDefaultWidget(container);
 
         if (kJob) {
             slotStarted(kJob);
         } else {
             connect(krJob, &KrJob::started, this, &JobMenuAction::slotStarted);
         }
 
         connect(krJob, &KrJob::terminated, this, &JobMenuAction::slotTerminated);
     }
 
     bool isDone() { return !m_krJob; }
 
 protected slots:
     void slotDescription(KJob *, const QString &description,
                        const QPair<QString, QString> &field1,
                        const QPair<QString, QString> &field2)
     {
         const QPair<QString, QString> textField = !field2.first.isEmpty() ? field2 : field1;
         QString text = description;
         if (!textField.first.isEmpty()) {
             text += QString(" - %1: %2").arg(textField.first, textField.second);
         }
         m_description->setText(text);
 
         if (!field2.first.isEmpty() && !field1.first.isEmpty()) {
             // NOTE: tooltips for QAction items in menu are not shown
             m_progressBar->setToolTip(QString("%1: %2").arg(field1.first, field1.second));
         }
     }
 
     void slotPercent(KJob *, unsigned long percent) { m_progressBar->setValue(percent); }
 
     void updatePauseResumeButton()
     {
         m_pauseResumeButton->setIcon(Icon(
             m_krJob->isRunning() ? "media-playback-pause" :
             m_krJob->isPaused() ? "media-playback-start" : "chronometer-start"));
         m_pauseResumeButton->setToolTip(m_krJob->isRunning() ? i18n("Pause Job") :
                                        m_krJob->isPaused() ? i18n("Resume Job") :
                                                                     i18n("Start Job"));
     }
 
     void slotResult(KJob *job)
     {
         // NOTE: m_job may already set to NULL now
         if(!job->error()) {
             // percent signal is not reliable, set manually
             m_progressBar->setValue(100);
         }
     }
 
     void slotTerminated()
     {
         qDebug() << "job description=" << m_krJob->description();
         m_pauseResumeButton->setEnabled(false);
         m_cancelButton->setIcon(Icon("edit-clear"));
         m_cancelButton->setToolTip(i18n("Clear"));
 
         m_krJob = nullptr;
     }
 
     void slotPauseResumeButtonClicked()
     {
         if (!m_krJob)
           return;
 
         if (m_krJob->isRunning())
             m_krJob->pause();
         else
             m_krJob->start();
     }
 
     void slotCancelButtonClicked()
     {
         if (m_krJob) {
             m_krJob->cancel();
         } else {
             deleteLater();
         }
     }
 
 private slots:
     void slotStarted(KJob *job)
     {
         connect(job, &KJob::description, this, &JobMenuAction::slotDescription);
         connect(job, SIGNAL(percent(KJob*,ulong)), this, SLOT(slotPercent(KJob*,ulong)));
         connect(job, &KJob::suspended, this, &JobMenuAction::updatePauseResumeButton);
         connect(job, &KJob::resumed, this, &JobMenuAction::updatePauseResumeButton);
         connect(job, &KJob::result, this, &JobMenuAction::slotResult);
         connect(job, &KJob::warning, this, [](KJob *, const QString &plain, const QString &) {
             qWarning() << "unexpected job warning: " << plain;
         });
 
         updatePauseResumeButton();
     }
 
 private:
     KrJob *m_krJob;
 
     QLabel *m_description;
     QProgressBar *m_progressBar;
     QPushButton *m_pauseResumeButton;
     QPushButton *m_cancelButton;
 };
 
 #include "jobman.moc" // required for class definitions with Q_OBJECT macro in implementation files
 
 
 const QString JobMan::sDefaultToolTip = i18n("No jobs");
 
-JobMan::JobMan(QObject *parent) : QObject(parent), m_messageBox(0)
+JobMan::JobMan(QObject *parent) : QObject(parent), m_messageBox(nullptr)
 {
     // job control action
     m_controlAction = new KToolBarPopupAction(Icon("media-playback-pause"),
                                           i18n("Play/Pause &Job"), this);
     m_controlAction->setEnabled(false);
     connect(m_controlAction, &QAction::triggered, this, &JobMan::slotControlActionTriggered);
 
-    QMenu *menu = new QMenu(krMainWindow);
+    auto *menu = new QMenu(krMainWindow);
     menu->setMinimumWidth(300);
     // make scrollable if menu is too long
     menu->setStyleSheet("QMenu { menu-scrollable: 1; }");
     m_controlAction->setMenu(menu);
 
     // progress bar action
     m_progressBar = new QProgressBar();
     m_progressBar->setToolTip(sDefaultToolTip);
     m_progressBar->setEnabled(false);
     // listen to clicks on progress bar
     m_progressBar->installEventFilter(this);
 
-    QWidgetAction *progressAction = new QWidgetAction(krMainWindow);
+    auto *progressAction = new QWidgetAction(krMainWindow);
     progressAction->setText(i18n("Job Progress Bar"));
     progressAction->setDefaultWidget(m_progressBar);
     m_progressAction = progressAction;
 
     // job queue mode action
     KConfigGroup cfg(krConfig, "JobManager");
     m_queueMode = cfg.readEntry("Queue Mode", false);
     m_modeAction = new QAction(Icon("media-playlist-repeat"), i18n("Job Queue Mode"),
                               krMainWindow);
     m_modeAction->setToolTip(i18n("Run only one job in parallel"));
     m_modeAction->setCheckable(true);
     m_modeAction->setChecked(m_queueMode);
     connect(m_modeAction, &QAction::toggled, this, [=](bool checked) mutable {
         m_queueMode = checked;
         cfg.writeEntry("Queue Mode", m_queueMode);
     });
 
     // undo action
     KIO::FileUndoManager *undoManager = KIO::FileUndoManager::self();
     undoManager->uiInterface()->setParentWidget(krMainWindow);
 
     m_undoAction = new QAction(Icon("edit-undo"), i18n("Undo Last Job"), krMainWindow);
     m_undoAction->setEnabled(false);
     connect(m_undoAction, &QAction::triggered, undoManager, &KIO::FileUndoManager::undo);
     connect(undoManager, static_cast<void(KIO::FileUndoManager::*)(bool)>(&KIO::FileUndoManager::undoAvailable),
             m_undoAction, &QAction::setEnabled);
     connect(undoManager, &KIO::FileUndoManager::undoTextChanged, this, &JobMan::slotUndoTextChange);
 }
 
 bool JobMan::waitForJobs(bool waitForUserInput)
 {
     if (m_jobs.isEmpty() && !waitForUserInput)
         return true;
 
     // attempt to get all job threads does not work
     //QList<QThread *> threads = krMainWindow->findChildren<QThread *>();
 
     m_autoCloseMessageBox = !waitForUserInput;
 
     m_messageBox = new QMessageBox(krMainWindow);
     m_messageBox->setWindowTitle(i18n("Warning"));
     m_messageBox->setIconPixmap(Icon("dialog-warning")
                              .pixmap(QMessageBox::standardIcon(QMessageBox::Information).size()));
     m_messageBox->setText(i18n("Are you sure you want to quit?"));
     m_messageBox->addButton(QMessageBox::Abort);
     m_messageBox->addButton(QMessageBox::Cancel);
     m_messageBox->setDefaultButton(QMessageBox::Cancel);
     for (KrJob *job: m_jobs)
         connect(job, &KrJob::terminated, this, &JobMan::slotUpdateMessageBox);
     slotUpdateMessageBox();
 
     int result = m_messageBox->exec(); // blocking
     m_messageBox->deleteLater();
-    m_messageBox = 0;
+    m_messageBox = nullptr;
 
     // accepted -> cancel all jobs
     if (result == QMessageBox::Abort) {
         for (KrJob *job: m_jobs) {
             job->cancel();
         }
         return true;
     }
     // else:
     return false;
 }
 
 void JobMan::manageJob(KrJob *job, StartMode startMode)
 {
     qDebug() << "new job, startMode=" << startMode;
     managePrivate(job);
 
     connect(job, &KrJob::started, this, &JobMan::slotKJobStarted);
 
     const bool enqueue = startMode == Enqueue || (startMode == Default && m_queueMode);
     if (startMode == Start || (startMode == Default && !m_queueMode) ||
         (enqueue && !jobsAreRunning())) {
         job->start();
     }
 
     updateUI();
 }
 
 void JobMan::manageStartedJob(KrJob *krJob, KJob *kJob)
 {
     managePrivate(krJob, kJob);
     slotKJobStarted(kJob);
     updateUI();
 }
 
 // #### protected slots
 
 void JobMan::slotKJobStarted(KJob *job)
 {
     // KJob has two percent() functions
     connect(job, SIGNAL(percent(KJob*,ulong)), this,
             SLOT(slotPercent(KJob*,ulong)));
     connect(job, &KJob::description, this, &JobMan::slotDescription);
     connect(job, &KJob::suspended, this, &JobMan::updateUI);
     connect(job, &KJob::resumed, this, &JobMan::updateUI);
 }
 
 void JobMan::slotControlActionTriggered()
 {
     if (m_jobs.isEmpty()) {
         m_controlAction->menu()->clear();
         m_controlAction->setEnabled(false);
         return;
     }
 
     const bool anyRunning = jobsAreRunning();
     if (!anyRunning && m_queueMode) {
         m_jobs.first()->start();
     } else {
         for (KrJob *job : m_jobs) {
             if (anyRunning)
                 job->pause();
             else
                 job->start();
         }
     }
 }
 
 void JobMan::slotPercent(KJob *, unsigned long)
 {
     updateUI();
 }
 
 void JobMan::slotDescription(KJob*,const QString &description, const QPair<QString,QString> &field1,
                      const QPair<QString,QString> &field2)
 {
     // TODO cache all descriptions
     if (m_jobs.length() > 1)
         return;
 
     m_progressBar->setToolTip(
         QString("%1\n%2: %3\n%4: %5")
             .arg(description, field1.first, field1.second, field2.first, field2.second));
 }
 
 void JobMan::slotTerminated(KrJob *krJob)
 {
     qDebug() << "terminated, job description: " << krJob->description();
 
     m_jobs.removeAll(krJob);
 
     // NOTE: ignoring queue mode here. We assume that if queue mode is turned off, the user created
     // jobs which were not already started with a "queue" option and still wants queue behaviour.
     if (!m_jobs.isEmpty() && !jobsAreRunning()) {
         foreach (KrJob *job, m_jobs) {
             if (!job->isPaused()) {
                 // start next job
                 job->start();
                 break;
             }
         }
     }
 
     updateUI();
     cleanupMenu();
 }
 
 void JobMan::slotUpdateControlAction()
 {
     m_controlAction->setEnabled(!m_controlAction->menu()->isEmpty());
 }
 
 void JobMan::slotUndoTextChange(const QString &text)
 {
     m_undoAction->setToolTip(KIO::FileUndoManager::self()->undoAvailable() ? text :
                                                                             i18n("Undo Last Job"));
 }
 
 void JobMan::slotUpdateMessageBox()
 {
     if (!m_messageBox)
         return;
 
     if (m_jobs.isEmpty() && m_autoCloseMessageBox) {
         m_messageBox->done(QMessageBox::Abort);
         return;
     }
 
     if (m_jobs.isEmpty()) {
         m_messageBox->setInformativeText("");
         m_messageBox->setButtonText(QMessageBox::Abort, "Quit");
         return;
     }
 
     m_messageBox->setInformativeText(i18np("There is one job operation left.",
                                           "There are %1 job operations left.", m_jobs.length()));
     m_messageBox->setButtonText(QMessageBox::Abort, "Abort Jobs and Quit");
 }
 
 // #### private
 
 void JobMan::managePrivate(KrJob *job, KJob *kJob)
 {
-    JobMenuAction *menuAction = new JobMenuAction(job, m_controlAction, kJob);
+    auto *menuAction = new JobMenuAction(job, m_controlAction, kJob);
     connect(menuAction, &QObject::destroyed, this, &JobMan::slotUpdateControlAction);
     m_controlAction->menu()->addAction(menuAction);
     cleanupMenu();
 
     slotUpdateControlAction();
 
     connect(job, &KrJob::terminated, this, &JobMan::slotTerminated);
 
     m_jobs.append(job);
 }
 
 void JobMan::cleanupMenu() {
     const QList<QAction *> actions = m_controlAction->menu()->actions();
     for (QAction *action : actions) {
         if (m_controlAction->menu()->actions().count() <= MAX_OLD_MENU_ACTIONS)
             break;
-        JobMenuAction *jobAction = static_cast<JobMenuAction *>(action);
+        auto *jobAction = dynamic_cast<JobMenuAction *>(action);
         if (jobAction->isDone()) {
             m_controlAction->menu()->removeAction(action);
             action->deleteLater();
         }
     }
 }
 
 void JobMan::updateUI()
 {
     int totalPercent = 0;
     for (KrJob *job: m_jobs) {
         totalPercent += job->percent();
     }
     const bool hasJobs = !m_jobs.isEmpty();
     m_progressBar->setEnabled(hasJobs);
     if (hasJobs) {
         m_progressBar->setValue(totalPercent / m_jobs.length());
     } else {
         m_progressBar->reset();
     }
     if (!hasJobs)
         m_progressBar->setToolTip(i18n("No Jobs"));
     if (m_jobs.length() > 1)
         m_progressBar->setToolTip(i18np("%1 Job", "%1 Jobs", m_jobs.length()));
 
     const bool running = jobsAreRunning();
     m_controlAction->setIcon(Icon(
         !hasJobs ? "edit-clear" : running ? "media-playback-pause" : "media-playback-start"));
     m_controlAction->setToolTip(!hasJobs ? i18n("Clear Job List") : running ?
                                           i18n("Pause All Jobs") :
                                           i18n("Resume Job List"));
 }
 
 bool JobMan::jobsAreRunning()
 {
     for (KrJob *job: m_jobs)
         if (job->isRunning())
             return true;
 
     return false;
 }
diff --git a/krusader/JobMan/jobman.h b/krusader/JobMan/jobman.h
index 7afac307..971a5fc4 100644
--- a/krusader/JobMan/jobman.h
+++ b/krusader/JobMan/jobman.h
@@ -1,139 +1,139 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef JOBMAN_H
 #define JOBMAN_H
 
 // QtCore
 #include <QAction>
 // QtWidgets
 #include <QMessageBox>
 #include <QPushButton>
 #include <QProgressBar>
 
 #include <KCoreAddons/KJob>
 #include <KWidgetsAddons/KToolBarPopupAction>
 
 class KrJob;
 
 /**
  * @brief The job manager provides a progress dialog and control over (KIO) file operation jobs.
  *
  * Job manager does not have a window (or dialog). All functions are provided via toolbar actions.
  * Icon, text and tooltip are already set but shortcuts are not set here.
  *
  * If job managers queue mode is activated, only the first job (incoming via manageJob()) is started
  * and more incoming jobs are delayed: If the running job finishes, the next job in line is
  * started.
  *
  * NOTE: The desktop system (e.g. KDE Plasma Shell) may also can control the jobs.
  * Reference: plasma-workspace/kuiserver/progresslistdelegate.h
  *
  * NOTE: If a job still exists, Krusader does not exit on quit() and waits until the job is
  * finished. If the job is paused, this takes forever. Call waitForJobs() before exit to prevent
  * this.
  *
  * About undoing jobs: If jobs are recorded (all KrJobs are, some in FileSystem) we can undo them
  * with FileUndoManager (which is a singleton) here.
  * It would be great if each job in the job list could be undone individually but FileUndoManager
  * is currently (Frameworks 5.27) only able to undo the last recorded job.
  */
 class JobMan : public QObject
 {
     Q_OBJECT
 
 public:
     /** Job start mode for new jobs. */
     enum StartMode {
         /** Enqueue or start job - depending on QueueMode. */
         Default,
         /** Enqueue job. I.e. start if no other jobs are running. */
         Enqueue,
         /** Job is always started. */
         Start,
         /** Job is always not started now. */
         Delay
     };
 
-    explicit JobMan(QObject *parent = 0);
+    explicit JobMan(QObject *parent = nullptr);
     /** Toolbar action icon for pausing/starting all jobs with drop down menu showing all jobs.*/
     QAction *controlAction() const { return m_controlAction; }
     /** Toolbar action progress bar showing the average job progress percentage of all jobs.*/
     QAction *progressAction() const { return m_progressAction; }
     /** Toolbar action combo box for changing the .*/
     QAction *modeAction() const { return m_modeAction; }
     QAction *undoAction() const { return m_undoAction; }
 
     /** Wait for all jobs to terminate (blocking!).
      *
      * Returns true immediately if there are no jobs and user input is not required. Otherwise a
      * modal UI dialog is shown and the user can abort all jobs or cancel the dialog.
      *
      * @param waitForUserInput if true dialog is only closed after user interaction (button click)
      * @return true if no jobs are running (anymore) and user wants to quit. Else false
      */
     bool waitForJobs(bool waitForUserInput);
 
     /** Return if queue mode is enabled or not. */
     bool isQueueModeEnabled() const { return m_queueMode; }
 
     /** Display, monitor and give user ability to control a job.
      *
      * Whether the job is started now or delayed depends on startMode (and current queue mode flag).
      */
     void manageJob(KrJob *krJob, StartMode startMode = Default);
     /**
      * Like manageJob(), but for already started jobs.
      */
     void manageStartedJob(KrJob *krJob, KJob *job);
 
 protected slots:
     void slotKJobStarted(KJob *krJob);
     void slotControlActionTriggered();
     void slotPercent(KJob *, unsigned long);
     void slotDescription(KJob*,const QString &description, const QPair<QString,QString> &field1,
                          const QPair<QString,QString> &field2);
     void slotTerminated(KrJob *krJob);
     void slotUpdateControlAction();
     void slotUndoTextChange(const QString &text);
     void slotUpdateMessageBox();
 
 private:
     void managePrivate(KrJob *job, KJob *kJob = nullptr);
     void cleanupMenu(); // remove old entries if menu is too long
     void updateUI();
     bool jobsAreRunning();
 
     QList<KrJob *> m_jobs; // all jobs not terminated (finished or canceled) yet
     bool m_queueMode;
 
     KToolBarPopupAction *m_controlAction;
     QProgressBar *m_progressBar;
     QAction *m_progressAction;
     QAction *m_modeAction;
     QAction *m_undoAction;
 
     QMessageBox *m_messageBox;
     bool m_autoCloseMessageBox;
 
     static const QString sDefaultToolTip;
 };
 
 #endif // JOBMAN_H
diff --git a/krusader/KViewer/diskusageviewer.cpp b/krusader/KViewer/diskusageviewer.cpp
index 74c8a481..981b6fb7 100644
--- a/krusader/KViewer/diskusageviewer.cpp
+++ b/krusader/KViewer/diskusageviewer.cpp
@@ -1,121 +1,122 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "diskusageviewer.h"
 
 // QtWidgets
 #include <QGridLayout>
 #include <QLabel>
 
 #include <KConfigCore/KSharedConfig>
+#include <utility>
 
 #include "../FileSystem/filesystem.h"
 #include "../Panel/krpanel.h"
 #include "../Panel/panelfunc.h"
 #include "../krglobal.h"
 
 DiskUsageViewer::DiskUsageViewer(QWidget *parent)
-        : QWidget(parent), diskUsage(0), statusLabel(0)
+        : QWidget(parent), diskUsage(nullptr), statusLabel(nullptr)
 {
     layout = new QGridLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
 }
 
 DiskUsageViewer::~ DiskUsageViewer()
 {
     if (diskUsage) {
         KConfigGroup group(krConfig, "DiskUsageViewer");
         group.writeEntry("View", diskUsage->getActiveView());
         delete diskUsage;
     }
 }
 
 void DiskUsageViewer::openUrl(QUrl url)
 {
-    if (diskUsage == 0) {
+    if (diskUsage == nullptr) {
         diskUsage = new DiskUsage("DiskUsageViewer", this);
 
         connect(diskUsage, &DiskUsage::enteringDirectory, this, [=]() { slotUpdateStatus(); });
         connect(diskUsage, &DiskUsage::status, this, &DiskUsageViewer::slotUpdateStatus);
         connect(diskUsage, &DiskUsage::newSearch, this, &DiskUsageViewer::slotNewSearch);
         layout->addWidget(diskUsage, 0, 0);
         this->show();
         diskUsage->show();
 
         KConfigGroup group(krConfig, "DiskUsageViewer");
         int view = group.readEntry("View",  VIEW_FILELIGHT);
         if (view < VIEW_LINES || view > VIEW_FILELIGHT)
             view = VIEW_FILELIGHT;
         diskUsage->setView(view);
     }
 
     url.setPath(url.adjusted(QUrl::StripTrailingSlash).path());
 
     QUrl baseURL = diskUsage->getBaseURL();
     if (!diskUsage->isLoading() && !baseURL.isEmpty()) {
         if (url.scheme() == baseURL.scheme() && (url.host().isEmpty() || url.host() == baseURL.host())) {
             QString baseStr = FileSystem::ensureTrailingSlash(baseURL).path();
             QString urlStr = FileSystem::ensureTrailingSlash(url).path();
 
             if (urlStr.startsWith(baseStr)) {
                 QString relURL = urlStr.mid(baseStr.length());
                 if (relURL.endsWith('/'))
                     relURL.truncate(relURL.length() - 1);
 
                 Directory *dir = diskUsage->getDirectory(relURL);
                 if (dir) {
                     diskUsage->changeDirectory(dir);
                     return;
                 }
             }
         }
     }
     diskUsage->load(url);
 }
 
 void DiskUsageViewer::closeUrl()
 {
     if (diskUsage)
         diskUsage->close();
 }
 
 void DiskUsageViewer::setStatusLabel(QLabel *statLabel, QString pref)
 {
     statusLabel = statLabel;
-    prefix = pref;
+    prefix = std::move(pref);
 }
 
 void DiskUsageViewer::slotUpdateStatus(QString status)
 {
     if (statusLabel) {
         if (status.isEmpty()) {
             Directory * dir = diskUsage->getCurrentDir();
             if (dir)
                 status = prefix + dir->name() + "  [" + KIO::convertSize(dir->size()) + ']';
         }
         statusLabel->setText(status);
     }
 }
 
 void DiskUsageViewer::slotNewSearch()
 {
     diskUsage->load(ACTIVE_PANEL->virtualPath());
 }
 
diff --git a/krusader/KViewer/diskusageviewer.h b/krusader/KViewer/diskusageviewer.h
index ee2edc24..3ff07b09 100644
--- a/krusader/KViewer/diskusageviewer.h
+++ b/krusader/KViewer/diskusageviewer.h
@@ -1,64 +1,64 @@
 /*****************************************************************************
  * Copyright (C) 2005 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DISKUSAGEVIEWER_H
 #define DISKUSAGEVIEWER_H
 
 #include "../DiskUsage/diskusage.h"
 
 // QtCore
 #include <QUrl>
 // QtWidgets
 #include <QLayout>
 #include <QLabel>
 #include <QGridLayout>
 
 class DiskUsageViewer : public QWidget
 {
     Q_OBJECT
 
 public:
-    explicit DiskUsageViewer(QWidget *parent = 0);
-    ~DiskUsageViewer();
+    explicit DiskUsageViewer(QWidget *parent = nullptr);
+    ~DiskUsageViewer() override;
 
     void openUrl(QUrl url);
     void closeUrl();
     void setStatusLabel(QLabel *statLabel, QString pref);
 
     inline DiskUsage * getWidget() {
         return diskUsage;
     }
 
 signals:
     void openUrlRequest(const QUrl &);
 
 protected slots:
     void slotUpdateStatus(QString status = QString());
     void slotNewSearch();
 
 protected:
     DiskUsage *diskUsage;
     QGridLayout *layout;
 
     QLabel *statusLabel;
     QString prefix;
 };
 
 #endif /* DISKUSAGEVIEWER_H */
diff --git a/krusader/KViewer/krviewer.cpp b/krusader/KViewer/krviewer.cpp
index b9efbbb5..04821413 100644
--- a/krusader/KViewer/krviewer.cpp
+++ b/krusader/KViewer/krviewer.cpp
@@ -1,711 +1,712 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krviewer.h"
 
 // QtCore
 #include <QDataStream>
 #include <QDebug>
 #include <QFile>
 #include <QTimer>
 #include <QEvent>
 // QtGui
 #include <QKeyEvent>
 // QtWidgets
 #include <QMenuBar>
 #include <QStatusBar>
 
 #include <KCoreAddons/KProcess>
 #include <KCoreAddons/KShell>
 #include <KConfigCore/KSharedConfig>
 #include <KConfigWidgets/KStandardAction>
 #include <KI18n/KLocalizedString>
 #include <KIOCore/KFileItem>
 #include <KParts/Part>
 #include <KWidgetsAddons/KMessageBox>
 #include <KXmlGui/KActionCollection>
 #include <KXmlGui/KShortcutsDialog>
 #include <KXmlGui/KToolBar>
+#include <utility>
 
 #include "../defaults.h"
 #include "../icon.h"
 #include "panelviewer.h"
 
 #define VIEW_ICON     "document-preview"
 #define EDIT_ICON     "document-edit"
 #define MODIFIED_ICON "document-save-as"
 
 #define CHECK_MODFIED_INTERVAL 500
 
 /*
 NOTE: Currently the code expects PanelViewer::openUrl() to be called only once
       in the panel viewer's life time - otherwise unexpected things might happen.
 */
 
 QList<KrViewer *> KrViewer::viewers;
 
-KrViewer::KrViewer(QWidget *parent) :
-        KParts::MainWindow(parent, (Qt::WindowFlags)KDE_DEFAULT_WINDOWFLAGS), manager(this, this), tabBar(this),
-        reservedKeys(), reservedKeyActions(), sizeX(-1), sizeY(-1)
+KrViewer::KrViewer(QWidget *parent)
+    : KParts::MainWindow(parent, (Qt::WindowFlags)KDE_DEFAULT_WINDOWFLAGS), manager(this, this),
+      tabBar(this), sizeX(-1), sizeY(-1)
 {
     //setWFlags(Qt::WType_TopLevel | WDestructiveClose);
     setXMLFile("krviewer.rc");   // kpart-related xml file
     setHelpMenuEnabled(false);
 
     connect(&manager, &KParts::PartManager::activePartChanged, this, &KrViewer::createGUI);
     connect(&tabBar, &QTabWidget::currentChanged, this, &KrViewer::tabChanged);
     connect(&tabBar, &QTabWidget::tabCloseRequested, this, [=](int index) { tabCloseRequest(index, false); });
 
     tabBar.setDocumentMode(true);
     tabBar.setMovable(true);
     setCentralWidget(&tabBar);
 
-    printAction = KStandardAction::print(this, SLOT(print()), 0);
-    copyAction = KStandardAction::copy(this, SLOT(copy()), 0);
+    printAction = KStandardAction::print(this, SLOT(print()), nullptr);
+    copyAction = KStandardAction::copy(this, SLOT(copy()), nullptr);
 
     viewerMenu = new QMenu(this);
     QAction *tempAction;
     KActionCollection *ac = actionCollection();
 
 #define addCustomMenuAction(name, text, slot, shortcut)\
     tempAction = ac->addAction(name, this, slot);\
     tempAction->setText(text);\
     ac->setDefaultShortcut(tempAction, shortcut);\
     viewerMenu->addAction(tempAction);
 
     addCustomMenuAction("genericViewer", i18n("&Generic Viewer"), SLOT(viewGeneric()), Qt::CTRL + Qt::SHIFT + Qt::Key_G);
     addCustomMenuAction("textViewer", i18n("&Text Viewer"), SLOT(viewText()), Qt::CTRL + Qt::SHIFT + Qt::Key_T);
     addCustomMenuAction("hexViewer", i18n("&Hex Viewer"), SLOT(viewHex()), Qt::CTRL + Qt::SHIFT + Qt::Key_H);
     addCustomMenuAction("lister", i18n("&Lister"), SLOT(viewLister()), Qt::CTRL + Qt::SHIFT + Qt::Key_L);
     viewerMenu->addSeparator();
 
     addCustomMenuAction("textEditor", i18n("Text &Editor"), SLOT(editText()), Qt::CTRL + Qt::SHIFT + Qt::Key_E);
     viewerMenu->addSeparator();
 
     QList<QAction *> actList = menuBar()->actions();
     bool hasPrint = false, hasCopy = false;
     foreach(QAction *a, actList) {
         if (a->shortcut().matches(printAction->shortcut()) != QKeySequence::NoMatch)
             hasPrint = true;
         if (a->shortcut().matches(copyAction->shortcut()) != QKeySequence::NoMatch)
             hasCopy = true;
     }
     QAction *printAct = viewerMenu->addAction(printAction->icon(), printAction->text(), this, SLOT(print()));
     if (hasPrint)
         printAct->setShortcut(printAction->shortcut());
     QAction *copyAct = viewerMenu->addAction(copyAction->icon(), copyAction->text(), this, SLOT(copy()));
     if (hasCopy)
         copyAct->setShortcut(copyAction->shortcut());
     viewerMenu->addSeparator();
 
     configKeysAction = ac->addAction(KStandardAction::KeyBindings, this, SLOT(configureShortcuts()));
     viewerMenu->addAction(configKeysAction);
     viewerMenu->addSeparator();
 
     detachAction = ac->addAction("detachTab", this, SLOT(detachTab()));
     detachAction->setText(i18n("&Detach Tab"));
     //no point in detaching only one tab..
     detachAction->setEnabled(false);
     ac->setDefaultShortcut(detachAction, Qt::META + Qt::Key_D);
     viewerMenu->addAction(detachAction);
 
     quitAction = ac->addAction(KStandardAction::Quit, this, SLOT(close()));
     viewerMenu->addAction(quitAction);
 
     QList<QKeySequence> shortcuts;
 
     tabCloseAction = ac->addAction("closeTab", this, SLOT(tabCloseRequest()));
     tabCloseAction->setText(i18n("&Close Current Tab"));
     shortcuts = KStandardShortcut::close();
     shortcuts.append(Qt::Key_Escape);
     ac->setDefaultShortcuts(tabCloseAction, shortcuts);
 
     tabNextAction = ac->addAction("nextTab", this, SLOT(nextTab()));
     tabNextAction->setText(i18n("&Next Tab"));
     shortcuts = KStandardShortcut::tabNext();
     shortcuts.append(Qt::CTRL + Qt::Key_Tab);  // reenforce QTabWidget shortcut
     ac->setDefaultShortcuts(tabNextAction, shortcuts);
 
     tabPrevAction = ac->addAction("prevTab", this, SLOT(prevTab()));
     tabPrevAction->setText(i18n("&Previous Tab"));
     shortcuts = KStandardShortcut::tabPrev();
     shortcuts.append(Qt::CTRL + Qt::SHIFT + Qt::Key_Tab);  // reenforce QTabWidget shortcut
     ac->setDefaultShortcuts(tabPrevAction, shortcuts);
 
 
     tabBar.setTabsClosable(true);
 
     checkModified();
 
     KConfigGroup group(krConfig, "KrViewerWindow");
     int sx = group.readEntry("Window Width", -1);
     int sy = group.readEntry("Window Height", -1);
 
     if (sx != -1 && sy != -1)
         resize(sx, sy);
     else
         resize(900, 700);
 
     if (group.readEntry("Window Maximized",  false)) {
         setWindowState(windowState() | Qt::WindowMaximized);
     }
 
     // filtering out the key events
     menuBar() ->installEventFilter(this);
 }
 
 KrViewer::~KrViewer()
 {
     disconnect(&manager, SIGNAL(activePartChanged(KParts::Part*)),
                this, SLOT(createGUI(KParts::Part*)));
 
     viewers.removeAll(this);
 
     // close tabs before deleting tab bar - this avoids Qt bug 26115
     // https://bugreports.qt-project.org/browse/QTBUG-26115
     while(tabBar.count())
         tabCloseRequest(tabBar.currentIndex(), true);
 
     delete printAction;
     delete copyAction;
 }
 
 void KrViewer::configureDeps()
 {
     PanelEditor::configureDeps();
 }
 
 void KrViewer::createGUI(KParts::Part* part)
 {
     KParts::MainWindow::createGUI(part);
 
     updateActions();
 
     toolBar() ->show();
     statusBar() ->show();
 
     // the KParts part may override the viewer shortcuts. We prevent it
     // by installing an event filter on the menuBar() and the part
     reservedKeys.clear();
     reservedKeyActions.clear();
 
     QList<QAction *> list = viewerMenu->actions();
     // also add the actions that are not in the menu...
     list << tabCloseAction << tabNextAction << tabPrevAction;
     // getting the key sequences of the viewer menu
     for (int w = 0; w != list.count(); w++) {
         QAction *act = list[ w ];
         QList<QKeySequence> sequences = act->shortcuts();
         foreach(QKeySequence keySeq, sequences) {
             for(int i = 0; i < keySeq.count(); ++i) {
                 reservedKeys.push_back(keySeq[i]);
                 reservedKeyActions.push_back(act); //the same action many times in case of multiple shortcuts
             }
         }
     }
 
     // and "fix" the menubar
     QList<QAction *> actList = menuBar()->actions();
     viewerMenu->setTitle(i18n("&KrViewer"));
     QAction * act = menuBar() ->addMenu(viewerMenu);
     act->setData(QVariant(70));
     menuBar() ->show();
 }
 
 void KrViewer::configureShortcuts()
 {
     KShortcutsDialog::configure(actionCollection(), KShortcutsEditor::LetterShortcutsAllowed, this);
 }
 
 bool KrViewer::eventFilter(QObject * /* watched */, QEvent * e)
 {
     // TODO: after porting to Qt5/KF5 we never catch *ANY* KeyPress or ShortcutOverride events here anymore.
     // Should look into if there is any way to fix it. Currently if a KPart has same shortcut as KrViewer then
     // it causes a conflict, messagebox shown to user and no action triggered.
     if (e->type() == QEvent::ShortcutOverride) {
-        QKeyEvent* ke = (QKeyEvent*) e;
+        auto* ke = (QKeyEvent*) e;
         if (reservedKeys.contains(ke->key())) {
             ke->accept();
 
             QAction *act = reservedKeyActions[ reservedKeys.indexOf(ke->key())];
-            if (act != 0) {
+            if (act != nullptr) {
                 // don't activate the close functions immediately!
                 // it can cause crash
                 if (act == tabCloseAction || act == quitAction) {
                     QTimer::singleShot(0, act, &QAction::trigger);
                 } else {
                     act->activate(QAction::Trigger);
                 }
             }
             return true;
         }
     } else if (e->type() == QEvent::KeyPress) {
-        QKeyEvent* ke = (QKeyEvent*) e;
+        auto* ke = (QKeyEvent*) e;
         if (reservedKeys.contains(ke->key())) {
             ke->accept();
             return true;
         }
     }
     return false;
 }
 
 KrViewer* KrViewer::getViewer(bool new_window)
 {
     if (!new_window) {
         if (viewers.isEmpty()) {
             viewers.prepend(new KrViewer());   // add to first (active)
         } else {
             if (viewers.first()->isMinimized()) { // minimized? -> show it again
                 viewers.first()->setWindowState((viewers.first()->windowState() & ~Qt::WindowMinimized) | Qt::WindowActive);
                 viewers.first()->show();
             }
             viewers.first()->raise();
             viewers.first()->activateWindow();
         }
         return viewers.first();
     } else {
-        KrViewer *newViewer = new KrViewer();
+        auto *newViewer = new KrViewer();
         viewers.prepend(newViewer);
         return newViewer;
     }
 }
 
 void KrViewer::view(QUrl url, QWidget * parent)
 {
     KConfigGroup group(krConfig, "General");
     bool defaultWindow = group.readEntry("View In Separate Window", _ViewInSeparateWindow);
 
-    view(url, Default, defaultWindow, parent);
+    view(std::move(url), Default, defaultWindow, parent);
 }
 
 void KrViewer::view(QUrl url, Mode mode,  bool new_window, QWidget * parent)
 {
     KrViewer* viewer = getViewer(new_window);
-    viewer->viewInternal(url, mode, parent);
+    viewer->viewInternal(std::move(url), mode, parent);
     viewer->show();
 }
 
 void KrViewer::edit(QUrl url, QWidget * parent)
 {
-    edit(url, Text, -1, parent);
+    edit(std::move(url), Text, -1, parent);
 }
 
-void KrViewer::edit(QUrl url, Mode mode, int new_window, QWidget * parent)
+void KrViewer::edit(const QUrl& url, Mode mode, int new_window, QWidget * parent)
 {
     KConfigGroup group(krConfig, "General");
     QString editor = group.readEntry("Editor", _Editor);
 
     if (new_window == -1)
         new_window = group.readEntry("View In Separate Window", _ViewInSeparateWindow);
 
     if (editor != "internal editor" && !editor.isEmpty()) {
         KProcess proc;
         QStringList cmdArgs = KShell::splitArgs(editor, KShell::TildeExpand);
         if (cmdArgs.isEmpty()) {
             KMessageBox::error(krMainWindow,
                                i18nc("Arg is a string containing the bad quoting.",
                                      "Bad quoting in editor command:\n%1", editor));
             return;
         }
         // if the file is local, pass a normal path and not a url. this solves
         // the problem for editors that aren't url-aware
         proc << cmdArgs << url.toDisplayString(QUrl::PreferLocalFile);
         if (!proc.startDetached())
             KMessageBox::sorry(krMainWindow, i18n("Can not open \"%1\"", editor));
         return;
     }
 
     KrViewer* viewer = getViewer(new_window);
     viewer->editInternal(url, mode, parent);
     viewer->show();
 }
 
 void KrViewer::addTab(PanelViewerBase *pvb)
 {
     int tabIndex = tabBar.addTab(pvb, makeTabIcon(pvb), makeTabText(pvb));
     tabBar.setCurrentIndex(tabIndex);
     tabBar.setTabToolTip(tabIndex, makeTabToolTip(pvb));
 
     updateActions();
 
     // now we can offer the option to detach tabs (we have more than one)
     if (tabBar.count() > 1) {
         detachAction->setEnabled(true);
     }
 
     tabBar.show();
 
     connect(pvb, &PanelViewerBase::openUrlFinished, this, &KrViewer::openUrlFinished);
 
     connect(pvb, &PanelViewerBase::urlChanged, this, &KrViewer::tabURLChanged);
 }
 
 void KrViewer::tabURLChanged(PanelViewerBase *pvb, const QUrl &url)
 {
     Q_UNUSED(url)
     refreshTab(pvb);
 }
 
 void KrViewer::openUrlFinished(PanelViewerBase *pvb, bool success)
 {
     if (success) {
         KParts::ReadOnlyPart *part = pvb->part();
         if (part) {
             if (!isPartAdded(part))
                 addPart(part);
             if (tabBar.currentWidget() == pvb) {
                 manager.setActivePart(part);
                 if (part->widget())
                     part->widget()->setFocus();
             }
         }
     } else {
         tabCloseRequest(tabBar.currentIndex(), false);
       }
 }
 
 void KrViewer::tabChanged(int index)
 {
     QWidget *w = tabBar.widget(index);
     if(!w) return;
-    KParts::ReadOnlyPart *part = static_cast<PanelViewerBase*>(w)->part();
+    KParts::ReadOnlyPart *part = dynamic_cast<PanelViewerBase*>(w)->part();
     if (part && isPartAdded(part)) {
         manager.setActivePart(part);
         if (part->widget())
             part->widget()->setFocus();
     } else
-        manager.setActivePart(0);
+        manager.setActivePart(nullptr);
 
 
     // set this viewer to be the main viewer
     if (viewers.removeAll(this)) viewers.prepend(this);      // move to first
 }
 
 void KrViewer::tabCloseRequest(int index, bool force)
 {
     // important to save as returnFocusTo will be cleared at removePart
     QWidget *returnFocusToThisWidget = returnFocusTo;
 
-    PanelViewerBase *pvb = static_cast<PanelViewerBase *>(tabBar.widget(index));
+    auto *pvb = dynamic_cast<PanelViewerBase *>(tabBar.widget(index));
     if (!pvb)
         return;
 
     if (!force && !pvb->queryClose())
         return;
 
     if (pvb->part() && isPartAdded(pvb->part()))
         removePart(pvb->part());
 
-    disconnect(pvb, 0, this, 0);
+    disconnect(pvb, nullptr, this, nullptr);
 
     pvb->closeUrl();
 
     tabBar.removeTab(index);
 
     delete pvb;
-    pvb = 0;
+    pvb = nullptr;
 
     if (tabBar.count() <= 0) {
         if (returnFocusToThisWidget) {
             returnFocusToThisWidget->raise();
             returnFocusToThisWidget->activateWindow();
         } else {
             krMainWindow->raise();
             krMainWindow->activateWindow();
         }
 
         QTimer::singleShot(0, this, &KrViewer::close);
     } else if (tabBar.count() == 1) {
         // no point in detaching only one tab..
         detachAction->setEnabled(false);
     }
 }
 
 void KrViewer::tabCloseRequest()
 {
     tabCloseRequest(tabBar.currentIndex());
 }
 
 bool KrViewer::queryClose()
 {
     KConfigGroup group(krConfig, "KrViewerWindow");
 
     group.writeEntry("Window Width", sizeX);
     group.writeEntry("Window Height", sizeY);
     group.writeEntry("Window Maximized", isMaximized());
 
     for (int i = 0; i != tabBar.count(); i++) {
-        PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.widget(i));
+        auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.widget(i));
         if (!pvb)
             continue;
 
         tabBar.setCurrentIndex(i);
 
         if (!pvb->queryClose())
             return false;
     }
     return true;
 }
 
 void KrViewer::viewGeneric()
 {
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (pvb)
         viewInternal(pvb->url(), Generic);
 }
 
 void KrViewer::viewText()
 {
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (pvb)
         viewInternal(pvb->url(), Text);
 }
 
 void KrViewer::viewLister()
 {
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (pvb)
         viewInternal(pvb->url(), Lister);
 }
 
 void KrViewer::viewHex()
 {
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (pvb)
         viewInternal(pvb->url(), Hex);
 }
 
 void KrViewer::editText()
 {
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (pvb)
         editInternal(pvb->url(), Text);
 }
 
 void KrViewer::checkModified()
 {
     QTimer::singleShot(CHECK_MODFIED_INTERVAL, this, &KrViewer::checkModified);
 
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (pvb)
         refreshTab(pvb);
 }
 
 void KrViewer::refreshTab(PanelViewerBase* pvb)
 {
     int ndx = tabBar.indexOf(pvb);
     tabBar.setTabText(ndx, makeTabText(pvb));
     tabBar.setTabIcon(ndx, makeTabIcon(pvb));
     tabBar.setTabToolTip(ndx, makeTabToolTip(pvb));
 }
 
 void KrViewer::nextTab()
 {
     int index = (tabBar.currentIndex() + 1) % tabBar.count();
     tabBar.setCurrentIndex(index);
 }
 
 void KrViewer::prevTab()
 {
     int index = (tabBar.currentIndex() - 1) % tabBar.count();
     while (index < 0) index += tabBar.count();
     tabBar.setCurrentIndex(index);
 }
 
 void KrViewer::detachTab()
 {
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (!pvb) return;
 
     KrViewer* viewer = getViewer(true);
 
     bool wasPartAdded = false;
     KParts::ReadOnlyPart *part = pvb->part();
 
     if (part && isPartAdded(part)) {
         wasPartAdded = true;
         removePart(part);
     }
 
-    disconnect(pvb, 0, this, 0);
+    disconnect(pvb, nullptr, this, nullptr);
 
     tabBar.removeTab(tabBar.indexOf(pvb));
 
     if (tabBar.count() == 1) {
         //no point in detaching only one tab..
         detachAction->setEnabled(false);
     }
 
     pvb->setParent(&viewer->tabBar);
     pvb->move(QPoint(0, 0));
 
     viewer->addTab(pvb);
 
     if (wasPartAdded) {
         viewer->addPart(part);
         if (part->widget())
             part->widget()->setFocus();
     }
 
     viewer->show();
 }
 
 void KrViewer::changeEvent(QEvent *e)
 {
     if (e->type() == QEvent::ActivationChange && isActiveWindow())
         if (viewers.removeAll(this)) viewers.prepend(this);      // move to first
 }
 
 void KrViewer::print()
 {
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (!pvb || !pvb->part() || !isPartAdded(pvb->part()))
         return;
 
     KParts::BrowserExtension * ext = KParts::BrowserExtension::childObject(pvb->part());
     if (ext && ext->isActionEnabled("print"))
         Invoker(ext, SLOT(print())).invoke();
 }
 
 void KrViewer::copy()
 {
-    PanelViewerBase* pvb = static_cast<PanelViewerBase*>(tabBar.currentWidget());
+    auto* pvb = dynamic_cast<PanelViewerBase*>(tabBar.currentWidget());
     if (!pvb || !pvb->part() || !isPartAdded(pvb->part()))
         return;
 
     KParts::BrowserExtension * ext = KParts::BrowserExtension::childObject(pvb->part());
     if (ext && ext->isActionEnabled("copy"))
         Invoker(ext, SLOT(copy())).invoke();
 }
 
 void KrViewer::updateActions()
 {
     QList<QAction *> actList = toolBar()->actions();
     bool hasPrint = false, hasCopy = false;
     foreach(QAction *a, actList) {
         if (a->text() == printAction->text())
             hasPrint = true;
         if (a->text() == copyAction->text())
             hasCopy = true;
     }
     if (!hasPrint)
         toolBar()->addAction(printAction->icon(), printAction->text(), this, SLOT(print()));
     if (!hasCopy)
         toolBar()->addAction(copyAction->icon(), copyAction->text(), this, SLOT(copy()));
 }
 
 bool KrViewer::isPartAdded(KParts::Part* part)
 {
     return manager.parts().contains(part);
 }
 
 void KrViewer::resizeEvent(QResizeEvent *e)
 {
     if (!isMaximized()) {
         sizeX = e->size().width();
         sizeY = e->size().height();
     }
 
     KParts::MainWindow::resizeEvent(e);
 }
 
 QString KrViewer::makeTabText(PanelViewerBase *pvb)
 {
     QString fileName = pvb->url().fileName();
     if (pvb->isModified())
         fileName.prepend("*");
 
     return pvb->isEditor() ?
             i18nc("filename (filestate)", "%1 (Editing)", fileName) :
             i18nc("filename (filestate)", "%1 (Viewing)", fileName);
 }
 
 QString KrViewer::makeTabToolTip(PanelViewerBase *pvb)
 {
     QString url = pvb->url().toDisplayString(QUrl::PreferLocalFile);
     return pvb->isEditor() ?
             i18nc("filestate: filename", "Editing: %1", url) :
             i18nc("filestate: filename", "Viewing: %1", url);
 }
 
 QIcon KrViewer::makeTabIcon(PanelViewerBase *pvb)
 {
     QString iconName;
     if (pvb->isModified())
         iconName = MODIFIED_ICON;
     else if (pvb->isEditor())
         iconName = EDIT_ICON;
     else
         iconName = VIEW_ICON;
 
     return Icon(iconName);
 }
 
 void KrViewer::addPart(KParts::ReadOnlyPart *part)
 {
     Q_ASSERT(part);
     Q_ASSERT(!isPartAdded(part));
 
     if (isPartAdded(part)) {
         qDebug()<<"part already added:"<<part;
         return;
     }
 
     connect(part, SIGNAL(setStatusBarText(QString)),
             this, SLOT(slotSetStatusBarText(QString)));
     // filtering out the key events
     part->installEventFilter(this);
 
     manager.addPart(part, false); // don't automatically set active part
 }
 
 void KrViewer::removePart(KParts::ReadOnlyPart *part)
 {
     Q_ASSERT(part);
     Q_ASSERT(isPartAdded(part));
 
     if (isPartAdded(part)) {
-        disconnect(part, 0, this, 0);
+        disconnect(part, nullptr, this, nullptr);
         part->removeEventFilter(this);
         manager.removePart(part);
     } else
         qDebug()<<"part hasn't been added:"<<part;
 }
 
 void KrViewer::viewInternal(QUrl url, Mode mode, QWidget *parent)
 {
     returnFocusTo = parent;
 
     PanelViewerBase* viewWidget = new PanelViewer(&tabBar, mode);
 
     addTab(viewWidget);
-    viewWidget->openUrl(url);
+    viewWidget->openUrl(std::move(url));
 }
 
 void KrViewer::editInternal(QUrl url, Mode mode, QWidget * parent)
 {
     returnFocusTo = parent;
 
     PanelViewerBase* editWidget = new PanelEditor(&tabBar, mode);
 
     addTab(editWidget);
-    editWidget->openUrl(url);
+    editWidget->openUrl(std::move(url));
 }
diff --git a/krusader/KViewer/krviewer.h b/krusader/KViewer/krviewer.h
index c1256a1d..52e42bf9 100644
--- a/krusader/KViewer/krviewer.h
+++ b/krusader/KViewer/krviewer.h
@@ -1,154 +1,154 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRVIEWER_H
 #define KRVIEWER_H
 
 // QtCore
 #include <QEvent>
 #include <QList>
 #include <QPointer>
 #include <QUrl>
 // QtGui
 #include <QKeyEvent>
 #include <QFocusEvent>
 // QtWidgets
 #include <QAction>
 #include <QMenu>
 #include <QTabWidget>
 
 #include <KParts/MainWindow>
 #include <KParts/PartManager>
 #include <KParts/BrowserExtension>
 
 #include "../krglobal.h"
 
 class PanelViewerBase;
 
 class KrViewer : public KParts::MainWindow
 {
     Q_OBJECT
 public:
     virtual ~KrViewer();
 
     enum Mode {Generic, Text, Hex, Lister, Default};
 
     static void view(QUrl url, QWidget * parent = krMainWindow);
     static void view(QUrl url, Mode mode, bool new_window, QWidget * parent = krMainWindow);
     static void edit(QUrl url, QWidget * parent);
-    static void edit(QUrl url, Mode mode = Text, int new_window = -1, QWidget * parent = krMainWindow);
+    static void edit(const QUrl& url, Mode mode = Text, int new_window = -1, QWidget * parent = krMainWindow);
     static void configureDeps();
 
     virtual bool eventFilter(QObject * watched, QEvent * e) Q_DECL_OVERRIDE;
 
 public slots:
     void createGUI(KParts::Part*);
     void configureShortcuts();
 
     void viewGeneric();
     void viewText();
     void viewHex();
     void viewLister();
     void editText();
 
     void print();
     void copy();
 
     void tabChanged(int index);
     void tabURLChanged(PanelViewerBase * pvb, const QUrl &url);
     void tabCloseRequest(int index, bool force = false);
     void tabCloseRequest();
 
     void nextTab();
     void prevTab();
     void detachTab();
 
     void checkModified();
 
 protected:
     virtual bool queryClose() Q_DECL_OVERRIDE;
     virtual void changeEvent(QEvent *e) Q_DECL_OVERRIDE;
     virtual void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
     virtual void focusInEvent(QFocusEvent *) Q_DECL_OVERRIDE {
         if (viewers.removeAll(this)) viewers.prepend(this);
     } // move to first
 
 
 private slots:
     void openUrlFinished(PanelViewerBase *pvb, bool success);
 
 private:
     explicit KrViewer(QWidget *parent = 0);
     void addTab(PanelViewerBase* pvb);
     void updateActions();
     void refreshTab(PanelViewerBase* pvb);
     void viewInternal(QUrl url, Mode mode, QWidget * parent = krMainWindow);
     void editInternal(QUrl url, Mode mode, QWidget * parent = krMainWindow);
     void addPart(KParts::ReadOnlyPart *part);
     void removePart(KParts::ReadOnlyPart *part);
     bool isPartAdded(KParts::Part* part);
 
     static KrViewer* getViewer(bool new_window);
     static QString makeTabText(PanelViewerBase *pvb);
     static QString makeTabToolTip(PanelViewerBase *pvb);
     static QIcon makeTabIcon(PanelViewerBase *pvb);
 
     KParts::PartManager manager;
     QMenu* viewerMenu;
     QTabWidget tabBar;
     QPointer<QWidget> returnFocusTo;
 
     QAction *detachAction;
     QAction *printAction;
     QAction *copyAction;
     QAction *quitAction;
 
     QAction *configKeysAction;
     QAction *tabCloseAction;
     QAction *tabNextAction;
     QAction *tabPrevAction;
 
     static QList<KrViewer *> viewers; // the first viewer is the active one
     QList<int>    reservedKeys;   // the reserved key sequences
     QList<QAction *> reservedKeyActions; // the IDs of the reserved keys
 
     int sizeX;
     int sizeY;
 };
 
 class Invoker : public QObject
 {
     Q_OBJECT
 
 public:
     Invoker(QObject *recv, const char * slot) {
         connect(this, SIGNAL(invokeSignal()), recv, slot);
     }
 
     void invoke() {
         emit invokeSignal();
     }
 
 signals:
     void invokeSignal();
 };
 
 #endif
diff --git a/krusader/KViewer/lister.cpp b/krusader/KViewer/lister.cpp
index a5b55dc1..9eacf139 100644
--- a/krusader/KViewer/lister.cpp
+++ b/krusader/KViewer/lister.cpp
@@ -1,2276 +1,2276 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "lister.h"
 
 // QtCore
 #include <QFile>
 #include <QRect>
 #include <QDate>
 #include <QTemporaryFile>
 #include <QTextStream>
 // QtGui
 #include <QPainter>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QClipboard>
 #include <QKeyEvent>
 // QtWidgets
 #include <QApplication>
 #include <QFileDialog>
 #include <QHBoxLayout>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QSpacerItem>
 #include <QScrollBar>
 #include <QToolButton>
 // QtPrintSupport
 #include <QPrintDialog>
 #include <QPrinter>
 
 #include <KCodecs/KCharsets>
 #include <KConfigCore/KSharedConfig>
 #include <KCoreAddons/KJobTrackerInterface>
 #include <KI18n/KLocalizedString>
 #include <KIO/CopyJob>
 #include <KIO/TransferJob>
 #include <KIO/JobUiDelegate>
 #include <KParts/GUIActivateEvent>
 #include <KWidgetsAddons/KMessageBox>
 #include <KXmlGui/KActionCollection>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../kractions.h"
 #include "../GUI/krremoteencodingmenu.h"
 
 #define  SEARCH_CACHE_CHARS 100000
 #define  SEARCH_MAX_ROW_LEN 4000
 #define  CONTROL_CHAR       752
 #define  CACHE_SIZE         1048576 // cache size set to 1MiB
 
 
 ListerTextArea::ListerTextArea(Lister *lister, QWidget *parent) : KTextEdit(parent), _lister(lister)
 {
     connect(this, &QTextEdit::cursorPositionChanged, this, &ListerTextArea::slotCursorPositionChanged);
     _tabWidth = 4;
     setWordWrapMode(QTextOption::NoWrap);
     setLineWrapMode(QTextEdit::NoWrap);
 
     // zoom shortcuts
     connect(new QShortcut(QKeySequence("Ctrl++"), this), &QShortcut::activated, this, [=]() { zoomIn(); });
     connect(new QShortcut(QKeySequence("Ctrl+-"), this), &QShortcut::activated, this, [=]() { zoomOut(); });
 
     // start cursor blinking
     connect(&_blinkTimer, &QTimer::timeout, this, [=] {
         if (!_cursorBlinkMutex.tryLock()) {
             return;
         }
         setCursorWidth(cursorWidth() == 0 ? 2 : 0);
         _cursorBlinkMutex.unlock();
     });
     _blinkTimer.start(500);
 }
 
 void ListerTextArea::reset()
 {
     _screenStartPos = 0;
     _cursorPos = 0;
     _cursorAnchorPos = -1;
     _cursorAtFirstColumn = true;
     calculateText();
 }
 
 void ListerTextArea::sizeChanged()
 {
     if (_cursorAnchorPos > _lister->fileSize())
         _cursorAnchorPos = -1;
     if (_cursorPos > _lister->fileSize())
         _cursorPos = _lister->fileSize();
 
     redrawTextArea(true);
 }
 
 void ListerTextArea::resizeEvent(QResizeEvent * event)
 {
     KTextEdit::resizeEvent(event);
     redrawTextArea();
 }
 
 void ListerTextArea::calculateText(const bool forcedUpdate)
 {
     const QRect contentRect = viewport()->contentsRect();
     const QFontMetrics fm(font());
 
     const int fontHeight = std::max(fm.height(), 1);
 
     // This is quite accurate (although not perfect) way of getting
     // a single character width along with its surrounding space.
     const float fontWidth = (fm.width("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW") - fm.width("W")) / 99.0;
 
     const int sizeY = contentRect.height() / fontHeight;
     _pageSize = sizeY;
 
     const int textViewportWidth = std::max(contentRect.width() - (int) fontWidth, 0);
 
     setTabStopWidth(fontWidth * _tabWidth);
 
     const int sizeX = textViewportWidth / fontWidth;
 
     _sizeChanged = (_sizeY != sizeY) || (_sizeX != sizeX) || forcedUpdate;
     _sizeY = sizeY;
     _sizeX = sizeX;
 
     QList<qint64> rowStarts;
 
     QStringList list = readLines(_screenStartPos, _screenEndPos, _sizeY, &rowStarts);
 
     if (_sizeChanged) {
         _averagePageSize = _screenEndPos - _screenStartPos;
         setUpScrollBar();
     }
 
     const QStringList listRemn = readLines(_screenEndPos, _screenEndPos, 1);
     list << listRemn;
 
     if (list != _rowContent) {
 
         _cursorBlinkMutex.lock();
         _blinkTimer.stop();
         setCursorWidth(0);
 
         setPlainText(list.join("\n"));
 
         if (_cursorAnchorPos == -1 || _cursorAnchorPos == _cursorPos) {
             clearSelection();
             _blinkTimer.start(500);
         }
 
         _cursorBlinkMutex.unlock();
 
         _rowContent = list;
         _rowStarts = rowStarts;
         if (_rowStarts.size() < _sizeY) {
             _rowStarts << _screenEndPos;
         }
     }
 }
 
 qint64 ListerTextArea::textToFilePositionOnScreen(const int x, const int y, bool &isfirst)
 {
     isfirst = (x == 0);
     if (y >= _rowStarts.count()) {
         return 0;
     }
     const qint64 rowStart = _rowStarts[ y ];
     if (x == 0) {
         return rowStart;
     }
 
     if (_hexMode) {
         const qint64 pos = rowStart + _lister->hexPositionToIndex(_sizeX, x);
         if (pos > _lister->fileSize()) {
             return _lister->fileSize();
         }
         return pos;
     }
 
     // we can't use fromUnicode because of the invalid encoded chars
     const int maxBytes = 2 * _sizeX * MAX_CHAR_LENGTH;
     QByteArray chunk = _lister->cacheChunk(rowStart, maxBytes);
 
     QTextStream stream(&chunk);
     stream.setCodec(_lister->codec());
     stream.read(x);
     return rowStart + stream.pos();
 }
 
 void ListerTextArea::fileToTextPositionOnScreen(const qint64 p, const bool isfirst, int &x, int &y)
 {
     // check if cursor is outside of visible area
     if (p < _screenStartPos || p > _screenEndPos || _rowStarts.count() < 1) {
         x = -1;
         y = (p > _screenEndPos) ? -2 : -1;
         return;
     }
 
     // find row
     y = 0;
     while (y < _rowStarts.count() && _rowStarts[ y ] <= p) {
         y++;
     }
     y--;
     if (y < 0) {
         x = y = -1;
         return;
     }
 
     const qint64 rowStart = _rowStarts[ y ];
     if (_hexMode) {
         x = _lister->hexIndexToPosition(_sizeX, (int)(p - rowStart));
         return;
     }
 
     // find column
     const int maxBytes = 2 * _sizeX * MAX_CHAR_LENGTH;
     x = 0;
     if (rowStart >= p) {
         if ((rowStart == p) && !isfirst && y > 0) {
             const qint64 previousRow = _rowStarts[ y - 1 ];
             const QByteArray chunk = _lister->cacheChunk(previousRow, maxBytes);
             QByteArray cachedBuffer = chunk.left(p - previousRow);
 
             QTextStream stream(&cachedBuffer);
             stream.setCodec(_lister->codec());
             stream.read(_rowContent[ y - 1].length());
             if (previousRow + stream.pos() == p) {
                 y--;
                 x = _rowContent[ y ].length();
             }
         }
         return;
     }
 
     const QByteArray chunk = _lister->cacheChunk(rowStart, maxBytes);
     const QByteArray cachedBuffer = chunk.left(p - rowStart);
 
     x = _lister->codec()->toUnicode(cachedBuffer).length();
 }
 
 void ListerTextArea::getCursorPosition(int &x, int &y)
 {
     getScreenPosition(textCursor().position(), x, y);
 }
 
 void ListerTextArea::getScreenPosition(const int position, int &x, int &y)
 {
     x = position;
     y = 0;
     foreach (const QString &row, _rowContent) {
         const int rowLen = row.length() + 1;
         if (x < rowLen) {
             return;
         }
         x -= rowLen;
         y++;
     }
 }
 
 void ListerTextArea::setCursorPositionOnScreen(const int x, const int y, const int anchorX, const int anchorY)
 {
     setCursorWidth(0);
 
     int finalX = x;
     int finalY = y;
 
     if (finalX == -1 || finalY < 0) {
         if (anchorY == -1) {
             return;
         }
 
         if (finalY == -2) {
             finalY = _sizeY;
             finalX = (_rowContent.count() > _sizeY) ? _rowContent[ _sizeY ].length() : 0;
         } else
             finalX = finalY = 0;
     }
 
     const int realSizeY = std::min(_sizeY + 1, _rowContent.count());
 
     const auto setUpCursor = [&] (const int cursorX, const int cursorY, const QTextCursor::MoveMode mode) -> bool {
         if (cursorY > realSizeY) {
             return false;
         }
 
         _skipCursorChangedListener = true;
 
         moveCursor(QTextCursor::Start, mode);
         for (int i = 0; i < cursorY; i++) {
             moveCursor(QTextCursor::Down, mode);
         }
 
         int finalCursorX = cursorX;
         if (_rowContent.count() > cursorY && finalCursorX > _rowContent[ cursorY ].length()) {
             finalCursorX = _rowContent[ cursorY ].length();
         }
 
         for (int i = 0; i < finalCursorX; i++) {
             moveCursor(QTextCursor::Right, mode);
         }
 
         _skipCursorChangedListener = false;
 
         return true;
     };
 
     QTextCursor::MoveMode mode = QTextCursor::MoveAnchor;
 
     // set cursor anchor
     if (anchorX != -1 && anchorY != -1) {
 
         const bool canContinue = setUpCursor(anchorX, anchorY, mode);
         if (!canContinue) {
             return;
         }
 
         mode = QTextCursor::KeepAnchor;
     }
 
     // set cursor position
     setUpCursor(finalX, finalY, mode);
 }
 
 qint64 ListerTextArea::getCursorPosition(bool &isfirst)
 {
     if (cursorWidth() == 0) {
         isfirst = _cursorAtFirstColumn;
         return _cursorPos;
     }
 
     int x, y;
     getCursorPosition(x, y);
     return textToFilePositionOnScreen(x, y, isfirst);
 }
 
 void ListerTextArea::setCursorPositionInDocument(const qint64 p, const bool isfirst)
 {
     _cursorPos = p;
     int x, y;
     fileToTextPositionOnScreen(p, isfirst, x, y);
 
     bool startBlinkTimer = _screenStartPos <= _cursorPos && _cursorPos <= _screenEndPos;
     int anchorX = -1, anchorY = -1;
     if (_cursorAnchorPos != -1 && _cursorAnchorPos != p) {
         int anchPos = _cursorAnchorPos;
         bool anchorBelow = false, anchorAbove = false;
         if (anchPos < _screenStartPos) {
             anchPos = _screenStartPos;
             anchorY = -2;
             anchorAbove = true;
         }
         if (anchPos > _screenEndPos) {
             anchPos = _screenEndPos;
             anchorY = -3;
             anchorBelow = true;
         }
 
         fileToTextPositionOnScreen(anchPos, isfirst, anchorX, anchorY);
 
         if (_hexMode) {
             if (anchorAbove) {
                 anchorX = 0;
             }
             if (anchorBelow && _rowContent.count() > 0) {
                 anchorX = _rowContent[ 0 ].length();
             }
         }
 
         startBlinkTimer = startBlinkTimer && !anchorAbove && !anchorBelow;
     }
     if (startBlinkTimer) {
         _blinkTimer.start(500);
     }
     setCursorPositionOnScreen(x, y, anchorX, anchorY);
     _lister->slotUpdate();
 }
 
 void ListerTextArea::slotCursorPositionChanged()
 {
     if (_skipCursorChangedListener) {
         return;
     }
     int cursorX, cursorY;
     getCursorPosition(cursorX, cursorY);
     _cursorAtFirstColumn = (cursorX == 0);
     _cursorPos = textToFilePositionOnScreen(cursorX, cursorY, _cursorAtFirstColumn);
     _lister->slotUpdate();
 }
 
 QString ListerTextArea::readSection(const qint64 p1, const qint64 p2)
 {
     if (p1 == p2)
         return QString();
 
     qint64 sel1 = p1;
     qint64 sel2 = p2;
     if (sel1 > sel2) {
         std::swap(sel1, sel2);
     }
 
     QString section;
 
     if (_hexMode) {
         while (sel1 != sel2) {
             const QStringList list = _lister->readHexLines(sel1, sel2, _sizeX, 1);
             if (list.isEmpty()) {
                 break;
             }
             if (!section.isEmpty()) {
                 section += QChar('\n');
             }
             section += list.at(0);
         }
         return section;
     }
 
     qint64 pos = sel1;
 
     QScopedPointer<QTextDecoder> decoder(_lister->codec()->makeDecoder());
 
     do {
         const int maxBytes = std::min(_sizeX * _sizeY * MAX_CHAR_LENGTH, (int) (sel2 - pos));
         const QByteArray chunk = _lister->cacheChunk(pos, maxBytes);
         if (chunk.isEmpty())
             break;
         section += decoder->toUnicode(chunk);
         pos += chunk.size();
     } while (pos < sel2);
 
     return section;
 }
 
 QStringList ListerTextArea::readLines(qint64 filePos, qint64 &endPos, const int lines, QList<qint64> * locs)
 {
     QStringList list;
 
     if (_hexMode) {
         endPos = _lister->fileSize();
         if (filePos >= endPos) {
             return list;
         }
         const int bytes = _lister->hexBytesPerLine(_sizeX);
         qint64 startPos = (filePos / bytes) * bytes;
         qint64 shiftPos = startPos;
         list = _lister->readHexLines(shiftPos, endPos, _sizeX, lines);
         endPos = shiftPos;
         if (locs) {
             for (int i = 0; i < list.count(); i++) {
                 (*locs) << startPos;
                 startPos += bytes;
             }
         }
         return list;
     }
 
     endPos = filePos;
     const int maxBytes = _sizeX * _sizeY * MAX_CHAR_LENGTH;
     const QByteArray chunk = _lister->cacheChunk(filePos, maxBytes);
     if (chunk.isEmpty())
         return list;
 
     int byteCounter = 0;
     QString row = "";
     int effLength = 0;
     if (locs)
         (*locs) << filePos;
     bool skipImmediateNewline = false;
 
     const auto performNewline = [&] (qint64 nextRowStartOffset) {
         list << row;
         effLength = 0;
         row = "";
         if (locs) {
             (*locs) << (filePos + nextRowStartOffset);
         }
     };
 
     QScopedPointer<QTextDecoder> decoder(_lister->codec()->makeDecoder());
 
     while (byteCounter < chunk.size() && list.size() < lines) {
         const int lastCnt = byteCounter;
         QString chr = decoder->toUnicode(chunk.mid(byteCounter++, 1));
         if (chr.isEmpty()) {
             continue;
         }
 
         if ((chr[ 0 ] < 32) && (chr[ 0 ] != '\n') && (chr[ 0 ] != '\t')) {
             chr = QChar(CONTROL_CHAR);
         }
 
         if (chr == "\n") {
             if (!skipImmediateNewline) {
                 performNewline(byteCounter);
             }
             skipImmediateNewline = false;
             continue;
         }
 
         skipImmediateNewline = false;
 
         if (chr == "\t") {
             effLength += _tabWidth - (effLength % _tabWidth) - 1;
             if (effLength > _sizeX) {
                 performNewline(lastCnt);
             }
         }
         row += chr;
         effLength++;
         if (effLength >= _sizeX) {
             performNewline(byteCounter);
             skipImmediateNewline = true;
         }
     }
 
     if (list.size() < lines)
         list << row;
 
     endPos = filePos + byteCounter;
 
     return list;
 }
 
 void ListerTextArea::setUpScrollBar()
 {
     if (_averagePageSize == _lister->fileSize()) {
         _lister->scrollBar()->setPageStep(0);
         _lister->scrollBar()->setMaximum(0);
         _lister->scrollBar()->hide();
         _lastPageStartPos = 0;
     } else {
         const int maxPage = MAX_CHAR_LENGTH * _sizeX * _sizeY;
         qint64 pageStartPos = _lister->fileSize() - maxPage;
         qint64 endPos;
         if (pageStartPos < 0)
             pageStartPos = 0;
         QStringList list = readLines(pageStartPos, endPos, maxPage);
         if (list.count() <= _sizeY) {
             _lastPageStartPos = 0;
         } else {
             readLines(pageStartPos, _lastPageStartPos, list.count() - _sizeY);
         }
 
         const int maximum = (_lastPageStartPos > SLIDER_MAX) ? SLIDER_MAX : _lastPageStartPos;
         int pageSize = (_lastPageStartPos > SLIDER_MAX) ? SLIDER_MAX * _averagePageSize / _lastPageStartPos : _averagePageSize;
         if (pageSize == 0)
             pageSize++;
 
         _lister->scrollBar()->setPageStep(pageSize);
         _lister->scrollBar()->setMaximum(maximum);
         _lister->scrollBar()->show();
     }
 }
 
 void ListerTextArea::keyPressEvent(QKeyEvent * ke)
 {
     if (KrGlobal::copyShortcut == QKeySequence(ke->key() | ke->modifiers())) {
         copySelectedToClipboard();
         ke->accept();
         return;
     }
 
     if (ke->modifiers() == Qt::NoModifier || ke->modifiers() & Qt::ShiftModifier) {
         qint64 newAnchor = -1;
         if (ke->modifiers() & Qt::ShiftModifier) {
             newAnchor = _cursorAnchorPos;
             if (_cursorAnchorPos == -1)
                 newAnchor = _cursorPos;
         }
 
         switch (ke->key()) {
         case Qt::Key_F3:
             ke->accept();
             if (ke->modifiers() == Qt::ShiftModifier)
                 _lister->searchPrev();
             else
                 _lister->searchNext();
             return;
         case Qt::Key_Home:
         case Qt::Key_End:
             _cursorAnchorPos = newAnchor;
             break;
         case Qt::Key_Left: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             int x, y;
             getCursorPosition(x, y);
             if (y == 0 && x == 0)
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
         }
         break;
         case Qt::Key_Right: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             if (textCursor().position() == toPlainText().length())
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
         }
         break;
         case Qt::Key_Up: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             int x, y;
             getCursorPosition(x, y);
             if (y == 0)
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
         }
         break;
         case Qt::Key_Down: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             int x, y;
             getCursorPosition(x, y);
             if (y >= _sizeY-1)
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
         }
         break;
         case Qt::Key_PageDown: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             ke->accept();
             int x, y;
             getCursorPosition(x, y);
             slotActionTriggered(QAbstractSlider::SliderPageStepAdd);
             y += _sizeY - _skippedLines;
             if (y > _rowContent.count()) {
                 y = _rowContent.count() - 1;
                 if (y > 0)
                     x = _rowContent[ y - 1 ].length();
                 else
                     x = 0;
             }
             _cursorPos = textToFilePositionOnScreen(x, y, _cursorAtFirstColumn);
             setCursorPositionInDocument(_cursorPos, _cursorAtFirstColumn);
         }
         return;
         case Qt::Key_PageUp: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             ke->accept();
             int x, y;
             getCursorPosition(x, y);
             slotActionTriggered(QAbstractSlider::SliderPageStepSub);
             y -= _sizeY - _skippedLines;
             if (y < 0) {
                 y = 0;
                 x = 0;
             }
             _cursorPos = textToFilePositionOnScreen(x, y, _cursorAtFirstColumn);
             setCursorPositionInDocument(_cursorPos, _cursorAtFirstColumn);
         }
         return;
         }
     }
     if (ke->modifiers() == Qt::ControlModifier) {
         switch (ke->key()) {
         case Qt::Key_G:
             ke->accept();
             _lister->jumpToPosition();
             return;
         case Qt::Key_F:
             ke->accept();
             _lister->enableSearch(true);
             return;
         case Qt::Key_Home:
             _cursorAnchorPos = -1;
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderToMinimum);
             setCursorPositionInDocument((qint64)0, true);
             return;
         case Qt::Key_A:
         case Qt::Key_End: {
             _cursorAnchorPos = (ke->key() == Qt::Key_A) ? 0 : -1;
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderToMaximum);
             const qint64 endPos = _lister->fileSize();
             setCursorPositionInDocument(endPos, false);
             return;
         }
         case Qt::Key_Down:
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
             return;
         case Qt::Key_Up:
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
             return;
         case Qt::Key_PageDown:
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderPageStepAdd);
             return;
         case Qt::Key_PageUp:
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderPageStepSub);
             return;
         }
     }
     const int oldAnchor = textCursor().anchor();
     KTextEdit::keyPressEvent(ke);
     handleAnchorChange(oldAnchor);
 }
 
 void ListerTextArea::mousePressEvent(QMouseEvent * e)
 {
     KTextEdit::mousePressEvent(e);
     // do change anchor only when shift is not pressed
     if (!(QGuiApplication::keyboardModifiers() & Qt::ShiftModifier)) {
         performAnchorChange(textCursor().anchor());
     }
 }
 
 void ListerTextArea::mouseDoubleClickEvent(QMouseEvent * e)
 {
     _cursorAnchorPos = -1;
     const int oldAnchor = textCursor().anchor();
     KTextEdit::mouseDoubleClickEvent(e);
     handleAnchorChange(oldAnchor);
 }
 
 void ListerTextArea::mouseMoveEvent(QMouseEvent * e)
 {
     if (e->pos().y() < 0) {
         slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
     } else if (e->pos().y() > height()) {
         slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
     }
     KTextEdit::mouseMoveEvent(e);
 }
 
 void ListerTextArea::wheelEvent(QWheelEvent * e)
 {
     int delta = e->delta();
     if (delta) {
 
         // zooming
         if (e->modifiers() & Qt::ControlModifier) {
             e->accept();
             if (delta > 0) {
                 zoomIn();
             } else {
                 zoomOut();
             }
             return;
         }
 
         if (delta > 0) {
             e->accept();
             while (delta > 0) {
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
                 delta -= 120;
             }
         } else {
             e->accept();
             while (delta < 0) {
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
                 delta += 120;
             }
         }
 
         setCursorPositionInDocument(_cursorPos, false);
     }
 }
 
 void ListerTextArea::slotActionTriggered(int action)
 {
     switch (action) {
     case QAbstractSlider::SliderSingleStepAdd: {
         qint64 endPos;
         readLines(_screenStartPos, endPos, 1);
         if (endPos <= _lastPageStartPos) {
             _screenStartPos = endPos;
         }
     }
     break;
     case QAbstractSlider::SliderSingleStepSub: {
         if (_screenStartPos == 0) {
             break;
         }
 
         if (_hexMode) {
             int bytesPerRow = _lister->hexBytesPerLine(_sizeX);
             _screenStartPos = (_screenStartPos / bytesPerRow) * bytesPerRow;
             _screenStartPos -= bytesPerRow;
             if (_screenStartPos < 0) {
                 _screenStartPos = 0;
             }
             break;
         }
 
         int maxSize = _sizeX * _sizeY * MAX_CHAR_LENGTH;
         const QByteArray encodedEnter = _lister->codec()->fromUnicode(QString("\n"));
 
         qint64 readPos = _screenStartPos - maxSize;
         if (readPos < 0) {
             readPos = 0;
         }
         maxSize = _screenStartPos - readPos;
 
         const QByteArray chunk = _lister->cacheChunk(readPos, maxSize);
 
         int from = chunk.size();
         while (from > 0) {
             from--;
             from = chunk.lastIndexOf(encodedEnter, from);
             if (from == -1) {
                 from = 0;
                 break;
             }
             const int backRef = std::max(from - 20, 0);
             const int size = from - backRef + encodedEnter.size();
             const QString decoded = _lister->codec()->toUnicode(chunk.mid(backRef, size));
             if (decoded.endsWith(QLatin1String("\n"))) {
                 if (from < (chunk.size() - encodedEnter.size())) {
                     from += encodedEnter.size();
                     break;
                 }
             }
         }
 
         readPos += from;
         qint64 previousPos = readPos;
         while (readPos < _screenStartPos) {
             previousPos = readPos;
             readLines(readPos, readPos, 1);
         }
         _screenStartPos = previousPos;
     }
     break;
     case QAbstractSlider::SliderPageStepAdd: {
         _skippedLines = 0;
 
         qint64 endPos;
         for (int i = 0; i < _sizeY; i++) {
             readLines(_screenStartPos, endPos, 1);
             if (endPos <= _lastPageStartPos) {
                 _screenStartPos = endPos;
                 _skippedLines++;
             } else {
                 break;
             }
         }
     }
     break;
     case QAbstractSlider::SliderPageStepSub: {
         _skippedLines = 0;
 
         if (_screenStartPos == 0) {
             break;
         }
 
         if (_hexMode) {
             const int bytesPerRow = _lister->hexBytesPerLine(_sizeX);
             _screenStartPos = (_screenStartPos / bytesPerRow) * bytesPerRow;
             _screenStartPos -= _sizeY * bytesPerRow;
             if (_screenStartPos < 0) {
                 _screenStartPos = 0;
             }
             break;
         }
 
         // text lister mode
         int maxSize = 2 * _sizeX * _sizeY * MAX_CHAR_LENGTH;
         const QByteArray encodedEnter = _lister->codec()->fromUnicode(QString("\n"));
 
         qint64 readPos = _screenStartPos - maxSize;
         if (readPos < 0)
             readPos = 0;
         maxSize = _screenStartPos - readPos;
 
         const QByteArray chunk = _lister->cacheChunk(readPos, maxSize);
         maxSize = chunk.size();
 
         int sizeY = _sizeY + 1;
         int origSizeY = sizeY;
         int from = maxSize;
         int lastEnter = maxSize;
 
         bool readNext = true;
         while (readNext) {
             readNext = false;
             while (from > 0) {
                 from--;
                 from = chunk.lastIndexOf(encodedEnter, from);
                 if (from == -1) {
                     from = 0;
                     break;
                 }
                 const int backRef = std::max(from - 20, 0);
                 const int size = from - backRef + encodedEnter.size();
                 QString decoded = _lister->codec()->toUnicode(chunk.mid(backRef, size));
                 if (decoded.endsWith(QLatin1String("\n"))) {
                     if (from < (maxSize - encodedEnter.size())) {
                         int arrayStart = from + encodedEnter.size();
                         decoded = _lister->codec()->toUnicode(chunk.mid(arrayStart, lastEnter - arrayStart));
                         sizeY -= ((decoded.length() / (_sizeX + 1)) + 1);
                         if (sizeY < 0) {
                             from = arrayStart;
                             break;
                         }
                     }
                     lastEnter = from;
                 }
             }
 
             qint64 searchPos = readPos + from;
             QList<qint64> locs;
             while (searchPos < _screenStartPos) {
                 locs << searchPos;
                 readLines(searchPos, searchPos, 1);
             }
 
             if (locs.count() >= _sizeY) {
                 _screenStartPos = locs[ locs.count() - _sizeY ];
             } else if (from != 0) {
                 origSizeY += locs.count() + 1;
                 sizeY = origSizeY;
                 readNext = true;
             } else if (readPos == 0) {
                 _screenStartPos = 0;
             }
         }
 
     }
     break;
     case QAbstractSlider::SliderToMinimum:
         _screenStartPos = 0;
         break;
     case QAbstractSlider::SliderToMaximum:
         _screenStartPos = _lastPageStartPos;
         break;
     case QAbstractSlider::SliderMove: {
         if (_inSliderOp)  // self created call?
             return;
         qint64 pos = _lister->scrollBar()->sliderPosition();
 
         if (pos == SLIDER_MAX) {
             _screenStartPos = _lastPageStartPos;
             break;
         } else if (pos == 0) {
             _screenStartPos = 0;
             break;
         }
 
         if (_lastPageStartPos > SLIDER_MAX)
             pos = _lastPageStartPos * pos / SLIDER_MAX;
 
         if (pos != 0) {
             if (_hexMode) {
                 const int bytesPerRow = _lister->hexBytesPerLine(_sizeX);
                 pos = (pos / bytesPerRow) * bytesPerRow;
             } else {
                 const int maxSize = _sizeX * _sizeY * MAX_CHAR_LENGTH;
                 qint64 readPos = pos - maxSize;
                 if (readPos < 0)
                     readPos = 0;
                 qint64 previousPos = readPos;
 
                 while (readPos <= pos) {
                     previousPos = readPos;
                     readLines(readPos, readPos, 1);
                 }
 
                 pos = previousPos;
             }
         }
 
         _screenStartPos = pos;
     }
     break;
     case QAbstractSlider::SliderNoAction:
         break;
     };
 
     _inSliderOp = true;
     const int value = (_lastPageStartPos > SLIDER_MAX) ? SLIDER_MAX * _screenStartPos / _lastPageStartPos : _screenStartPos;
     _lister->scrollBar()->setSliderPosition(value);
     _inSliderOp = false;
 
     redrawTextArea();
 }
 
 void ListerTextArea::redrawTextArea(bool forcedUpdate)
 {
     if (_redrawing) {
         return;
     }
     _redrawing = true;
     bool isfirst;
     const qint64 pos = getCursorPosition(isfirst);
     calculateText(forcedUpdate);
     setCursorPositionInDocument(pos, isfirst);
     _redrawing = false;
 }
 
 void ListerTextArea::ensureVisibleCursor()
 {
     if (_screenStartPos <= _cursorPos && _cursorPos <= _screenEndPos) {
         return;
     }
 
     int delta = _sizeY / 2;
     if (delta == 0)
         delta++;
 
     qint64 newScreenStart = _cursorPos;
     while (delta) {
         const int maxSize = _sizeX * MAX_CHAR_LENGTH;
         qint64 readPos = newScreenStart - maxSize;
         if (readPos < 0)
             readPos = 0;
 
         qint64 previousPos = readPos;
 
         while (readPos < newScreenStart) {
             previousPos = readPos;
             readLines(readPos, readPos, 1);
             if (readPos == previousPos)
                 break;
         }
 
         newScreenStart = previousPos;
         delta--;
     }
     if (newScreenStart > _lastPageStartPos) {
         newScreenStart = _lastPageStartPos;
     }
 
     _screenStartPos = newScreenStart;
     slotActionTriggered(QAbstractSlider::SliderNoAction);
 }
 
 void ListerTextArea::setAnchorAndCursor(qint64 anchor, qint64 cursor)
 {
     _cursorPos = cursor;
     _cursorAnchorPos = anchor;
     ensureVisibleCursor();
     setCursorPositionInDocument(cursor, false);
 }
 
 QString ListerTextArea::getSelectedText()
 {
     if (_cursorAnchorPos != -1 && _cursorAnchorPos != _cursorPos) {
         return readSection(_cursorAnchorPos, _cursorPos);
     }
     return QString();
 }
 
 void ListerTextArea::copySelectedToClipboard()
 {
     const QString selection = getSelectedText();
     if (!selection.isEmpty()) {
         QApplication::clipboard()->setText(selection);
     }
 }
 
 void ListerTextArea::clearSelection()
 {
     QTextCursor cursor = textCursor();
     cursor.clearSelection();
     setTextCursor(cursor);
     _cursorAnchorPos = -1;
 }
 
 void ListerTextArea::performAnchorChange(int anchor)
 {
     int x, y;
     bool isfirst;
     getScreenPosition(anchor, x, y);
     _cursorAnchorPos = textToFilePositionOnScreen(x, y, isfirst);
 }
 
 void ListerTextArea::handleAnchorChange(int oldAnchor)
 {
     const int anchor = textCursor().anchor();
 
     if (oldAnchor != anchor) {
         performAnchorChange(anchor);
     }
 }
 
 void ListerTextArea::setHexMode(bool hexMode)
 {
     bool isfirst;
     const qint64 pos = getCursorPosition(isfirst);
     _hexMode = hexMode;
     _screenStartPos = 0;
     calculateText(true);
     setCursorPositionInDocument(pos, isfirst);
     ensureVisibleCursor();
 }
 
 void ListerTextArea::zoomIn(int range)
 {
     KTextEdit::zoomIn(range);
     redrawTextArea();
 }
 
 void ListerTextArea::zoomOut(int range)
 {
     KTextEdit::zoomOut(range);
     redrawTextArea();
 }
 
 ListerPane::ListerPane(Lister *lister, QWidget *parent) : QWidget(parent), _lister(lister)
 {
 }
 
 bool ListerPane::event(QEvent *e)
 {
     const bool handled = ListerPane::handleCloseEvent(e);
     if (!handled) {
         return QWidget::event(e);
     }
     return true;
 }
 
 bool ListerPane::handleCloseEvent(QEvent *e)
 {
     if (e->type() == QEvent::ShortcutOverride) {
-        QKeyEvent *ke = static_cast<QKeyEvent *>(e);
+        auto *ke = dynamic_cast<QKeyEvent *>(e);
         if (ke->key() == Qt::Key_Escape) {
             if (_lister->isSearchEnabled()) {
                 _lister->searchDelete();
                 _lister->enableSearch(false);
                 ke->accept();
                 return true;
             }
             if (!_lister->textArea()->getSelectedText().isEmpty()) {
                 _lister->textArea()->clearSelection();
                 ke->accept();
                 return true;
             }
         }
     }
     return false;
 }
 
 ListerBrowserExtension::ListerBrowserExtension(Lister * lister) : KParts::BrowserExtension(lister)
 {
     _lister = lister;
 
     emit enableAction("copy", true);
     emit enableAction("print", true);
 }
 
 void ListerBrowserExtension::copy()
 {
     _lister->textArea()->copySelectedToClipboard();
 }
 
 void ListerBrowserExtension::print()
 {
     _lister->print();
 }
 
 class ListerEncodingMenu : public KrRemoteEncodingMenu
 {
 public:
     ListerEncodingMenu(Lister *lister, const QString &text, const QString &icon, KActionCollection *parent) :
             KrRemoteEncodingMenu(text, icon, parent), _lister(lister) {
     }
 
 protected:
-    virtual QString currentCharacterSet() Q_DECL_OVERRIDE {
+    QString currentCharacterSet() Q_DECL_OVERRIDE {
         return _lister->characterSet();
     }
 
-    virtual void chooseDefault() Q_DECL_OVERRIDE {
+    void chooseDefault() Q_DECL_OVERRIDE {
         _lister->setCharacterSet(QString());
     }
 
-    virtual void chooseEncoding(QString encodingName) Q_DECL_OVERRIDE {
+    void chooseEncoding(QString encodingName) Q_DECL_OVERRIDE {
         QString charset = KCharsets::charsets()->encodingForName(encodingName);
         _lister->setCharacterSet(charset);
     }
 
     Lister * _lister;
 };
 
 Lister::Lister(QWidget *parent) : KParts::ReadOnlyPart(parent)
 {
     setXMLFile("krusaderlisterui.rc");
 
     _actionSaveSelected = new QAction(Icon("document-save"), i18n("Save selection..."), this);
     connect(_actionSaveSelected, &QAction::triggered, this, &Lister::saveSelected);
     actionCollection()->addAction("save_selected", _actionSaveSelected);
 
     _actionSaveAs = new QAction(Icon("document-save-as"), i18n("Save as..."), this);
     connect(_actionSaveAs, &QAction::triggered, this, &Lister::saveAs);
     actionCollection()->addAction("save_as", _actionSaveAs);
 
     _actionPrint = new QAction(Icon("document-print"), i18n("Print..."), this);
     connect(_actionPrint, &QAction::triggered, this, &Lister::print);
     actionCollection()->addAction("print", _actionPrint);
     actionCollection()->setDefaultShortcut(_actionPrint, Qt::CTRL + Qt::Key_P);
 
     _actionSearch = new QAction(Icon("system-search"), i18n("Search"), this);
     connect(_actionSearch, &QAction::triggered, this, &Lister::searchAction);
     actionCollection()->addAction("search", _actionSearch);
     actionCollection()->setDefaultShortcut(_actionSearch, Qt::CTRL + Qt::Key_F);
 
     _actionSearchNext = new QAction(Icon("go-down"), i18n("Search next"), this);
     connect(_actionSearchNext, &QAction::triggered, this, &Lister::searchNext);
     actionCollection()->addAction("search_next", _actionSearchNext);
     actionCollection()->setDefaultShortcut(_actionSearchNext, Qt::Key_F3);
 
     _actionSearchPrev = new QAction(Icon("go-up"), i18n("Search previous"), this);
     connect(_actionSearchPrev, &QAction::triggered, this, &Lister::searchPrev);
     actionCollection()->addAction("search_prev", _actionSearchPrev);
     actionCollection()->setDefaultShortcut(_actionSearchPrev, Qt::SHIFT + Qt::Key_F3);
 
     _actionJumpToPosition = new QAction(Icon("go-jump"), i18n("Jump to position"), this);
     connect(_actionJumpToPosition, &QAction::triggered, this, &Lister::jumpToPosition);
     actionCollection()->addAction("jump_to_position", _actionJumpToPosition);
     actionCollection()->setDefaultShortcut(_actionJumpToPosition, Qt::CTRL + Qt::Key_G);
 
     _actionHexMode = new QAction(Icon("document-preview"), i18n("Hex mode"), this);
     connect(_actionHexMode, &QAction::triggered, this, &Lister::toggleHexMode);
     actionCollection()->addAction("hex_mode", _actionHexMode);
     actionCollection()->setDefaultShortcut(_actionHexMode, Qt::CTRL + Qt::Key_H);
 
     new ListerEncodingMenu(this, i18n("Select charset"), "character-set", actionCollection());
 
     QWidget * widget = new ListerPane(this, parent);
     widget->setFocusPolicy(Qt::StrongFocus);
-    QGridLayout *grid = new QGridLayout(widget);
+    auto *grid = new QGridLayout(widget);
     _textArea = new ListerTextArea(this, widget);
     _textArea->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
     _textArea->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
     _textArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     _textArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     widget->setFocusProxy(_textArea);
     grid->addWidget(_textArea, 0, 0);
     _scrollBar = new QScrollBar(Qt::Vertical, widget);
     grid->addWidget(_scrollBar, 0, 1);
     _scrollBar->hide();
 
     QWidget * statusWidget = new QWidget(widget);
-    QHBoxLayout *hbox = new QHBoxLayout(statusWidget);
+    auto *hbox = new QHBoxLayout(statusWidget);
 
     _listerLabel = new QLabel(i18n("Lister:"), statusWidget);
     hbox->addWidget(_listerLabel);
     _searchProgressBar = new QProgressBar(statusWidget);
     _searchProgressBar->setMinimum(0);
     _searchProgressBar->setMaximum(1000);
     _searchProgressBar->setValue(0);
     _searchProgressBar->hide();
     hbox->addWidget(_searchProgressBar);
 
     _searchStopButton = new QToolButton(statusWidget);
     _searchStopButton->setIcon(Icon("process-stop"));
     _searchStopButton->setToolTip(i18n("Stop search"));
     _searchStopButton->hide();
     connect(_searchStopButton, &QToolButton::clicked, this, &Lister::searchDelete);
     hbox->addWidget(_searchStopButton);
 
     _searchLineEdit = new KLineEdit(statusWidget);
     _searchLineEdit->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     _originalBackground = _searchLineEdit->palette().color(QPalette::Base);
     _originalForeground = _searchLineEdit->palette().color(QPalette::Text);
 
     connect(_searchLineEdit, &KLineEdit::returnPressed, this, &Lister::searchNext);
     connect(_searchLineEdit, &KLineEdit::textChanged, this, &Lister::searchTextChanged);
 
     hbox->addWidget(_searchLineEdit);
     _searchNextButton = new QPushButton(Icon("go-down"), i18n("Next"), statusWidget);
     _searchNextButton->setToolTip(i18n("Jump to next match"));
     connect(_searchNextButton, &QPushButton::clicked, this, &Lister::searchNext);
     hbox->addWidget(_searchNextButton);
     _searchPrevButton = new QPushButton(Icon("go-up"), i18n("Previous"), statusWidget);
     _searchPrevButton->setToolTip(i18n("Jump to previous match"));
     connect(_searchPrevButton, &QPushButton::clicked, this, &Lister::searchPrev);
     hbox->addWidget(_searchPrevButton);
     _searchOptions = new QPushButton(i18n("Options"), statusWidget);
     _searchOptions->setToolTip(i18n("Modify search behavior"));
-    QMenu * menu = new QMenu();
+    auto * menu = new QMenu();
     _fromCursorAction = menu->addAction(i18n("From cursor"));
     _fromCursorAction->setCheckable(true);
     _fromCursorAction->setChecked(true);
     _caseSensitiveAction = menu->addAction(i18n("Case sensitive"));
     _caseSensitiveAction->setCheckable(true);
     _matchWholeWordsOnlyAction = menu->addAction(i18n("Match whole words only"));
     _matchWholeWordsOnlyAction->setCheckable(true);
     _regExpAction = menu->addAction(i18n("RegExp"));
     _regExpAction->setCheckable(true);
     _hexAction = menu->addAction(i18n("Hexadecimal"));
     _hexAction->setCheckable(true);
     _searchOptions->setMenu(menu);
 
     hbox->addWidget(_searchOptions);
 
     hbox->addItem(new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum));
 
     _statusLabel = new QLabel(statusWidget);
     hbox->addWidget(_statusLabel);
 
     grid->addWidget(statusWidget, 1, 0, 1, 2);
     setWidget(widget);
 
     connect(_scrollBar, &QScrollBar::actionTriggered, _textArea, &ListerTextArea::slotActionTriggered);
     connect(&_searchUpdateTimer, &QTimer::timeout, this, &Lister::slotUpdate);
 
     new ListerBrowserExtension(this);
     enableSearch(false);
 
     _tempFile = new QTemporaryFile(this);
     _tempFile->setFileTemplate(QDir::tempPath() + QLatin1String("/krusader_lister.XXXXXX"));
 }
 
 bool Lister::openUrl(const QUrl &listerUrl)
 {
     _downloading = false;
     setUrl(listerUrl);
 
     _fileSize = 0;
 
     if (listerUrl.isLocalFile()) {
         _filePath = listerUrl.path();
         if (!QFile::exists(_filePath))
             return false;
         _fileSize = getFileSize();
     } else {
         if (_tempFile->isOpen()) {
             _tempFile->close();
         }
         _tempFile->open();
 
         _filePath = _tempFile->fileName();
 
         KIO::TransferJob *downloadJob = KIO::get(listerUrl, KIO::NoReload, KIO::HideProgressInfo);
 
         connect(downloadJob, &KIO::TransferJob::data, this, [=](KIO::Job*, QByteArray array) {
             if (array.size() != 0) {
                 _tempFile->write(array);
             } });
         connect(downloadJob, &KIO::TransferJob::result, this, [=](KJob *job) {
             _tempFile->flush();
             if (job->error()) {   /* any error occurred? */
-                KIO::TransferJob *kioJob = (KIO::TransferJob *)job;
+                auto *kioJob = (KIO::TransferJob *)job;
                 KMessageBox::error(_textArea, i18n("Error reading file %1.", kioJob->url().toDisplayString(QUrl::PreferLocalFile)));
             }
             _downloading = false;
             _downloadUpdateTimer.stop();
             slotUpdate();
         });
         connect(&_downloadUpdateTimer, &QTimer::timeout, this, [&]() {
             slotUpdate();
         });
         _downloadUpdateTimer.start(500);
         _downloading = true;
     }
 
     // invalidate cache
     _cache.clear();
 
     _textArea->reset();
-    emit started(0);
+    emit started(nullptr);
     emit setWindowCaption(listerUrl.toDisplayString());
     emit completed();
     return true;
 }
 
 QByteArray Lister::cacheChunk(const qint64 filePos, const int maxSize)
 {
     if (filePos >= _fileSize) {
         return QByteArray();
     }
 
     int size = maxSize;
     if (_fileSize - filePos < size) {
         size = _fileSize - filePos;
     }
 
     if (!_cache.isEmpty() && (filePos >= _cachePos) && (filePos + size <= _cachePos + _cache.size())) {
         return _cache.mid(filePos - _cachePos, size);
     }
 
     const int negativeOffset = CACHE_SIZE * 2 / 5;
     qint64 cachePos = filePos - negativeOffset;
     if (cachePos < 0)
         cachePos = 0;
 
     QFile sourceFile(_filePath);
     if (!sourceFile.open(QIODevice::ReadOnly)) {
         return QByteArray();
     }
 
     if (!sourceFile.seek(cachePos)) {
         return QByteArray();
     }
 
     const QByteArray bytes = sourceFile.read(CACHE_SIZE);
     if (bytes.isEmpty()) {
         return bytes;
     }
 
     _cache = bytes;
     _cachePos = cachePos;
     const qint64 cacheRefIndex = filePos - _cachePos;
     int newSize = bytes.size() - cacheRefIndex;
     if (newSize < size)
         size = newSize;
 
     return _cache.mid(cacheRefIndex, size);
 }
 
 qint64 Lister::getFileSize()
 {
     return QFile(_filePath).size();
 }
 
 void Lister::guiActivateEvent(KParts::GUIActivateEvent * event)
 {
     if (event->activated()) {
         slotUpdate();
         _textArea->redrawTextArea(true);
     } else {
         enableSearch(false);
     }
     KParts::ReadOnlyPart::guiActivateEvent(event);
 }
 
 void Lister::slotUpdate()
 {
     const qint64 oldSize = _fileSize;
     _fileSize = getFileSize();
     if (oldSize != _fileSize)
         _textArea->sizeChanged();
 
     int cursorX = 0, cursorY = 0;
     _textArea->getCursorPosition(cursorX, cursorY);
     bool isfirst = false;
     const qint64 cursor = _textArea->getCursorPosition(isfirst);
 
     const int percent = (_fileSize == 0) ? 0 : (int)((201 * cursor) / _fileSize / 2);
 
     const QString status = i18n("Column: %1, Position: %2 (%3, %4%)", cursorX, cursor, _fileSize, percent);
     _statusLabel->setText(status);
 
     if (_searchProgressCounter)
         _searchProgressCounter--;
 }
 
 bool Lister::isSearchEnabled()
 {
     return !_searchLineEdit->isHidden() || !_searchProgressBar->isHidden();
 }
 
 void Lister::enableSearch(const bool enable)
 {
     if (enable) {
         _listerLabel->setText(i18n("Search:"));
         _searchLineEdit->show();
         _searchNextButton->show();
         _searchPrevButton->show();
         _searchOptions->show();
         if (!_searchLineEdit->hasFocus()) {
             _searchLineEdit->setFocus();
             const QString selection = _textArea->getSelectedText();
             if (!selection.isEmpty()) {
                 _searchLineEdit->setText(selection);
             }
             _searchLineEdit->selectAll();
         }
     } else {
         _listerLabel->setText(i18n("Lister:"));
         _searchLineEdit->hide();
         _searchNextButton->hide();
         _searchPrevButton->hide();
         _searchOptions->hide();
         _textArea->setFocus();
     }
 }
 
 void Lister::searchNext()
 {
     search(true);
 }
 
 void Lister::searchPrev()
 {
     search(false);
 }
 
 void Lister::search(const bool forward, const bool restart)
 {
     _restartFromBeginning = restart;
     if (_searchInProgress || _searchLineEdit->text().isEmpty())
         return;
     if (_searchLineEdit->isHidden())
         enableSearch(true);
 
     _searchPosition = forward ? 0 : _fileSize;
     if (_fromCursorAction->isChecked()) {
         bool isfirst;
         qint64 cursor = _textArea->getCursorPosition(isfirst);
         if (cursor != 0 && !forward)
             cursor--;
         if (_searchLastFailedPosition == -1 || _searchLastFailedPosition != cursor)
             _searchPosition = cursor;
     }
     const bool caseSensitive = _caseSensitiveAction->isChecked();
     const bool matchWholeWord = _matchWholeWordsOnlyAction->isChecked();
     const bool regExp = _regExpAction->isChecked();
     const bool hex = _hexAction->isChecked();
 
     if (hex) {
         QString hexcontent = _searchLineEdit->text();
         hexcontent.remove(QLatin1String("0x"));
         hexcontent.remove(' ');
         hexcontent.remove('\t');
         hexcontent.remove('\n');
         hexcontent.remove('\r');
 
         _searchHexQuery = QByteArray();
 
         if (hexcontent.length() & 1) {
             setColor(false, false);
             return;
         }
 
         while (!hexcontent.isEmpty()) {
             const QString hexData = hexcontent.left(2);
             hexcontent = hexcontent.mid(2);
             bool ok = true;
             const int c = hexData.toUInt(&ok, 16);
             if (!ok) {
                 setColor(false, false);
                 return;
             }
             _searchHexQuery.push_back((char) c);
         }
     } else {
         _searchQuery.setContent(_searchLineEdit->text(), caseSensitive, matchWholeWord, codec()->name(), regExp);
     }
     _searchIsForward = forward;
     _searchHexadecimal = hex;
 
     QTimer::singleShot(0, this, &Lister::slotSearchMore);
     _searchInProgress = true;
     _searchProgressCounter = 3;
 
     enableActions(false);
 }
 
 void Lister::enableActions(const bool state)
 {
     _actionSearch->setEnabled(state);
     _actionSearchNext->setEnabled(state);
     _actionSearchPrev->setEnabled(state);
     _actionJumpToPosition->setEnabled(state);
     if (state) {
         _searchUpdateTimer.stop();
     } else {
         slotUpdate();
     }
 }
 
 void Lister::slotSearchMore()
 {
     if (!_searchInProgress)
         return;
 
     if (!_searchUpdateTimer.isActive()) {
         _searchUpdateTimer.start(200);
     }
 
     updateProgressBar();
     if (!_searchIsForward)
         _searchPosition--;
 
     if (_searchPosition < 0 || _searchPosition >= _fileSize) {
         if (_restartFromBeginning)
             resetSearchPosition();
         else {
             searchFailed();
             return;
         }
     }
 
     int maxCacheSize = SEARCH_CACHE_CHARS;
     qint64 searchPos = _searchPosition;
     bool setPosition = true;
     if (!_searchIsForward) {
         qint64 origSearchPos = _searchPosition;
         searchPos -= maxCacheSize;
         if (searchPos <= 0) {
             searchPos = 0;
             _searchPosition = 0;
             setPosition = false;
         }
         qint64 diff = origSearchPos - searchPos;
         if (diff < maxCacheSize)
             maxCacheSize = diff;
     }
 
     const QByteArray chunk = cacheChunk(searchPos, maxCacheSize);
     if (chunk.isEmpty()) {
         searchFailed();
         return;
     }
 
     const int chunkSize = chunk.size();
 
     qint64 foundAnchor = -1;
     qint64 foundCursor = -1;
     int byteCounter = 0;
 
     if (_searchHexadecimal) {
         const int ndx = _searchIsForward ? chunk.indexOf(_searchHexQuery) : chunk.lastIndexOf(_searchHexQuery);
         if (chunkSize > _searchHexQuery.length()) {
             if (_searchIsForward) {
                 _searchPosition = searchPos + chunkSize;
                 if ((_searchPosition < _fileSize) && (chunkSize > _searchHexQuery.length()))
                     _searchPosition -= _searchHexQuery.length();
                 byteCounter = _searchPosition - searchPos;
             } else {
                 if (_searchPosition > 0)
                     _searchPosition += _searchHexQuery.length();
             }
         }
         if (ndx != -1) {
             foundAnchor = searchPos + ndx;
             foundCursor = foundAnchor + _searchHexQuery.length();
         }
     } else {
         int rowStart = 0;
         QString row = "";
 
         QScopedPointer<QTextDecoder> decoder(_codec->makeDecoder());
 
         while (byteCounter < chunkSize) {
             const QString chr = decoder->toUnicode(chunk.mid(byteCounter++, 1));
             if (chr.isEmpty() && byteCounter < chunkSize) {
                 continue;
             }
 
             if (chr != "\n")
                 row += chr;
 
             if (chr == "\n" || row.length() >= SEARCH_MAX_ROW_LEN || byteCounter >= chunkSize) {
                 if (setPosition) {
                     _searchPosition = searchPos + byteCounter;
                     if (!_searchIsForward) {
                         _searchPosition++;
                         setPosition = false;
                     }
                 }
 
                 if (_searchQuery.checkLine(row, !_searchIsForward)) {
                     QByteArray cachedBuffer = chunk.mid(rowStart, chunkSize - rowStart);
 
                     QTextStream stream(&cachedBuffer);
                     stream.setCodec(_codec);
 
                     stream.read(_searchQuery.matchIndex());
                     foundAnchor = searchPos + rowStart + stream.pos();
 
                     stream.read(_searchQuery.matchLength());
                     foundCursor = searchPos + rowStart + stream.pos();
 
                     if (_searchIsForward)
                         break;
                 }
 
                 row = "";
                 rowStart = byteCounter;
             }
         }
     }
 
     if (foundAnchor != -1 && foundCursor != -1) {
         _textArea->setAnchorAndCursor(foundAnchor, foundCursor);
         searchSucceeded();
         return;
     }
 
     if (_searchIsForward && searchPos + byteCounter >= _fileSize) {
         if (_restartFromBeginning)
             resetSearchPosition();
         else {
             searchFailed();
             return;
         }
     } else if (_searchPosition <= 0 || _searchPosition >= _fileSize) {
         if (_restartFromBeginning)
             resetSearchPosition();
         else {
             searchFailed();
             return;
         }
     }
 
     QTimer::singleShot(0, this, &Lister::slotSearchMore);
 }
 
 void Lister::resetSearchPosition()
 {
     _restartFromBeginning = false;
     _searchPosition = _searchIsForward ? 0 : _fileSize - 1;
 }
 
 void Lister::searchSucceeded()
 {
     _searchInProgress = false;
     setColor(true, false);
     hideProgressBar();
     _searchLastFailedPosition = -1;
 
     enableActions(true);
 }
 
 void Lister::searchFailed()
 {
     _searchInProgress = false;
     setColor(false, false);
     hideProgressBar();
     bool isfirst;
     _searchLastFailedPosition = _textArea->getCursorPosition(isfirst);
     if (!_searchIsForward)
         _searchLastFailedPosition--;
 
     enableActions(true);
 }
 
 void Lister::searchDelete()
 {
     _searchInProgress = false;
     setColor(false, true);
     hideProgressBar();
     _searchLastFailedPosition = -1;
 
     enableActions(true);
 }
 
 void Lister::searchTextChanged()
 {
     searchDelete();
     if (_fileSize < 0x10000) { // autosearch files less than 64k
         if (!_searchLineEdit->text().isEmpty()) {
             bool isfirst;
             const qint64 anchor = _textArea->getCursorAnchor();
             const qint64 cursor = _textArea->getCursorPosition(isfirst);
             if (cursor > anchor && anchor != -1) {
                 _textArea->setCursorPositionInDocument(anchor, true);
             }
             search(true, true);
         }
     }
 }
 
 void Lister::setColor(const bool match, const bool restore)
 {
     QColor fore, back;
 
     if (!restore) {
         const KConfigGroup gc(krConfig, "Colors");
 
         QString foreground, background;
         const QPalette p = QGuiApplication::palette();
 
         if (match) {
             foreground = "Quicksearch Match Foreground";
             background = "Quicksearch Match Background";
             fore = Qt::black;
             back = QColor(192, 255, 192);
         } else {
             foreground = "Quicksearch Non-match Foreground";
             background = "Quicksearch Non-match Background";
             fore = Qt::black;
             back = QColor(255, 192, 192);
         }
 
         if (gc.readEntry(foreground, QString()) == "KDE default")
             fore = p.color(QPalette::Active, QPalette::Text);
         else if (!gc.readEntry(foreground, QString()).isEmpty())
             fore = gc.readEntry(foreground, fore);
 
         if (gc.readEntry(background, QString()) == "KDE default")
             back = p.color(QPalette::Active, QPalette::Base);
         else if (!gc.readEntry(background, QString()).isEmpty())
             back = gc.readEntry(background, back);
     } else {
         back = _originalBackground;
         fore = _originalForeground;
     }
 
     QPalette pal = _searchLineEdit->palette();
     pal.setColor(QPalette::Base, back);
     pal.setColor(QPalette::Text, fore);
     _searchLineEdit->setPalette(pal);
 }
 
 void Lister::hideProgressBar()
 {
     if (!_searchProgressBar->isHidden()) {
         _searchProgressBar->hide();
         _searchStopButton->hide();
         _searchLineEdit->show();
         _searchNextButton->show();
         _searchPrevButton->show();
         _searchOptions->show();
         _listerLabel->setText(i18n("Search:"));
     }
 }
 
 void Lister::updateProgressBar()
 {
     if (_searchProgressCounter)
         return;
 
     if (_searchProgressBar->isHidden()) {
         _searchProgressBar->show();
         _searchStopButton->show();
         _searchOptions->hide();
         _searchLineEdit->hide();
         _searchNextButton->hide();
         _searchPrevButton->hide();
         _listerLabel->setText(i18n("Search position:"));
 
         // otherwise focus is set to document tab
         _textArea->setFocus();
     }
 
     const qint64 pcnt = (_fileSize == 0) ? 1000 : (2001 * _searchPosition) / _fileSize / 2;
-    const int pctInt = (int) pcnt;
+    const auto pctInt = (int) pcnt;
     if (_searchProgressBar->value() != pctInt)
         _searchProgressBar->setValue(pctInt);
 }
 
 void Lister::jumpToPosition()
 {
     bool ok = true;
     QString res = QInputDialog::getText(_textArea, i18n("Jump to position"), i18n("Text position:"),
                                         QLineEdit::Normal, "0", &ok);
     if (!ok)
         return;
 
     res = res.trimmed();
     qint64 pos = -1;
     if (res.startsWith(QLatin1String("0x"))) {
         res = res.mid(2);
         bool ok;
         const qulonglong upos = res.toULongLong(&ok, 16);
         if (!ok) {
             KMessageBox::error(_textArea, i18n("Invalid number."), i18n("Jump to position"));
             return;
         }
         pos = (qint64)upos;
     } else {
         bool ok;
         const qulonglong upos = res.toULongLong(&ok);
         if (!ok) {
             KMessageBox::error(_textArea, i18n("Invalid number."), i18n("Jump to position"));
             return;
         }
         pos = (qint64)upos;
     }
 
     if (pos < 0 || pos > _fileSize) {
         KMessageBox::error(_textArea, i18n("Number out of range."), i18n("Jump to position"));
         return;
     }
 
     _textArea->deleteAnchor();
     _textArea->setCursorPositionInDocument(pos, true);
     _textArea->ensureVisibleCursor();
 }
 
 void Lister::saveAs()
 {
     const QUrl url = QFileDialog::getSaveFileUrl(_textArea, i18n("Lister"));
     if (url.isEmpty())
         return;
     QUrl sourceUrl;
     if (!_downloading)
         sourceUrl = QUrl::fromLocalFile(_filePath);
     else
         sourceUrl = this->url();
 
     QList<QUrl> urlList;
     urlList << sourceUrl;
 
     KIO::Job *job = KIO::copy(urlList, url);
     job->setUiDelegate(new KIO::JobUiDelegate());
     KIO::getJobTracker()->registerJob(job);
     job->uiDelegate()->setAutoErrorHandlingEnabled(true);
 }
 
 void Lister::saveSelected()
 {
     bool isfirst;
     const qint64 start = _textArea->getCursorAnchor();
     const qint64 end = _textArea->getCursorPosition(isfirst);
     if (start == -1 || start == end) {
         KMessageBox::error(_textArea, i18n("Nothing is selected."), i18n("Save selection..."));
         return;
     }
     if (start > end) {
         _savePosition = end;
         _saveEnd = start;
     } else {
         _savePosition = start;
         _saveEnd = end;
     }
 
     const QUrl url = QFileDialog::getSaveFileUrl(_textArea, i18n("Lister"));
     if (url.isEmpty())
         return;
 
     KIO::TransferJob *saveJob = KIO::put(url, -1, KIO::Overwrite);
     connect(saveJob, &KIO::TransferJob::dataReq, this, &Lister::slotDataSend);
     connect(saveJob, &KIO::TransferJob::result, this, &Lister::slotSendFinished);
 
     saveJob->setUiDelegate(new KIO::JobUiDelegate());
     KIO::getJobTracker()->registerJob(saveJob);
     saveJob->uiDelegate()->setAutoErrorHandlingEnabled(true);
 
     _actionSaveSelected->setEnabled(false);
 }
 
 void Lister::slotDataSend(KIO::Job *, QByteArray &array)
 {
     if (_savePosition >= _saveEnd) {
         array = QByteArray();
         return;
     }
     qint64 max = _saveEnd - _savePosition;
     if (max > 1000)
         max = 1000;
     array = cacheChunk(_savePosition, (int) max);
     _savePosition += array.size();
 }
 
 void Lister::slotSendFinished(KJob *)
 {
     _actionSaveSelected->setEnabled(true);
 }
 
-void Lister::setCharacterSet(const QString set)
+void Lister::setCharacterSet(const QString& set)
 {
     _characterSet = set;
     if (_characterSet.isEmpty()) {
         _codec = QTextCodec::codecForLocale();
     } else {
         _codec = KCharsets::charsets()->codecForName(_characterSet);
     }
     _textArea->redrawTextArea(true);
 }
 
 void Lister::print()
 {
     bool isfirst;
     const qint64 anchor = _textArea->getCursorAnchor();
     const qint64 cursor = _textArea->getCursorPosition(isfirst);
     const bool hasSelection = (anchor != -1 && anchor != cursor);
 
     const QString docName = url().fileName();
     QPrinter printer;
     printer.setDocName(docName);
 
     QScopedPointer<QPrintDialog> printDialog(new QPrintDialog(&printer, _textArea));
 
     if (hasSelection) {
         printDialog->addEnabledOption(QAbstractPrintDialog::PrintSelection);
     }
 
     if (!printDialog->exec()) {
         return;
     }
 
     if (printer.pageOrder() == QPrinter::LastPageFirst) {
         switch (KMessageBox::warningContinueCancel(_textArea,
                 i18n("Reverse printing is not supported. Continue with normal printing?"))) {
         case KMessageBox::Continue :
             break;
         default:
             return;
         }
     }
     QPainter painter;
     painter.begin(&printer);
 
     const QString dateString = QDate::currentDate().toString(Qt::SystemLocaleShortDate);
 
     const QRect pageRect = printer.pageRect();
     const QRect drawingRect(0, 0, pageRect.width(), pageRect.height());
 
     const QFont normalFont = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
     const QFont fixedFont  = QFontDatabase::systemFont(QFontDatabase::FixedFont);
 
     const QFontMetrics fmNormal(normalFont);
     const int normalFontHeight = fmNormal.height();
 
     const QFontMetrics fmFixed(fixedFont);
     const int fixedFontHeight = std::max(fmFixed.height(), 1);
     const int fixedFontWidth = std::max(fmFixed.width("W"), 1);
 
     const int effPageSize = drawingRect.height() - normalFontHeight - 1;
     const int rowsPerPage = std::max(effPageSize / fixedFontHeight, 1);
     const int columnsPerPage = std::max(drawingRect.width() / fixedFontWidth, 1);
 
     bool firstPage = true;
 
     qint64 startPos = 0;
     qint64 endPos = _fileSize;
     if (printer.printRange() == QPrinter::Selection) {
         if (anchor > cursor)
             startPos = cursor, endPos = anchor;
         else
             startPos = anchor, endPos = cursor;
     }
 
     int page = 0;
     while (startPos < endPos) {
         page++;
 
         QStringList rows = readLines(startPos, endPos, columnsPerPage, rowsPerPage);
 
         // print since set-up fromPage number
         if (printer.fromPage() && page < printer.fromPage()) {
             continue;
         }
 
         // print until set-up toPage number
         if (printer.toPage() && printer.toPage() >= printer.fromPage() && page > printer.toPage())
             break;
 
         if (!firstPage) {
             printer.newPage();
         }
         firstPage = false;
         // Use the painter to draw on the page.
         painter.setFont(normalFont);
 
         painter.drawText(drawingRect, Qt::AlignLeft, dateString);
         painter.drawText(drawingRect, Qt::AlignHCenter, docName);
         painter.drawText(drawingRect, Qt::AlignRight, QString("%1").arg(page));
 
         painter.drawLine(0, normalFontHeight, drawingRect.width(), normalFontHeight);
 
         painter.setFont(fixedFont);
         int yOffset = normalFontHeight + 1;
         foreach (const QString &row, rows) {
             painter.drawText(0, yOffset + fixedFontHeight, row);
             yOffset += fixedFontHeight;
         }
     }
 }
 
 QStringList Lister::readLines(qint64 &filePos, const qint64 endPos, const int columns, const int lines)
 {
     if (_textArea->hexMode()) {
         return readHexLines(filePos, endPos, columns, lines);
     }
     QStringList list;
     const int maxBytes = std::min(columns * lines * MAX_CHAR_LENGTH, (int) (endPos - filePos));
     if (maxBytes <= 0) {
         return list;
     }
     const QByteArray chunk = cacheChunk(filePos, maxBytes);
     if (chunk.isEmpty()) {
         return list;
     }
 
     QScopedPointer<QTextDecoder> decoder(_codec->makeDecoder());
 
     int byteCounter = 0;
     QString row = "";
     bool skipImmediateNewline = false;
     while (byteCounter < chunk.size() && list.size() < lines) {
         QString chr = decoder->toUnicode(chunk.mid(byteCounter++, 1));
         if (chr.isEmpty()) {
             continue;
         }
 
         // replace unreadable characters
         if ((chr[ 0 ] < 32) && (chr[ 0 ] != '\n') && (chr[ 0 ] != '\t')) {
             chr = QChar(' ');
         }
 
         // handle newline
         if (chr == "\n") {
             if (!skipImmediateNewline) {
                 list << row;
                 row = "";
             }
             skipImmediateNewline = false;
             continue;
         }
 
         skipImmediateNewline = false;
 
         // handle tab
         if (chr == "\t") {
             const int tabLength = _textArea->tabWidth() - (row.length() % _textArea->tabWidth());
             if (row.length() + tabLength > columns) {
                 list << row;
                 row = "";
             }
             row += QString(tabLength, QChar(' '));
         } else {
             // normal printable character
             row += chr;
         }
 
         if (row.length() >= columns) {
             list << row;
             row = "";
             skipImmediateNewline = true;
         }
     }
 
     if (list.size() < lines) {
         list << row;
     }
 
     filePos += byteCounter;
 
     return list;
 }
 
 int Lister::hexPositionDigits()
 {
     int positionDigits = 0;
     qint64 checker = _fileSize;
     while (checker) {
         positionDigits++;
         checker /= 16;
     }
     if (positionDigits < 8) {
         return 8;
     }
     return positionDigits;
 }
 
 int Lister::hexBytesPerLine(const int columns)
 {
     const int positionDigits = hexPositionDigits();
     if (columns >= positionDigits + 5 + 128) {
         return 32;
     }
     if (columns >= positionDigits + 5 + 64) {
         return 16;
     }
     return 8;
 }
 
 QStringList Lister::readHexLines(qint64 &filePos, const qint64 endPos, const int columns, const int lines)
 {
     const int positionDigits = hexPositionDigits();
     const int bytesPerRow = hexBytesPerLine(columns);
 
     QStringList list;
 
     const qint64 choppedPos = (filePos / bytesPerRow) * bytesPerRow;
     const int maxBytes = std::min(bytesPerRow * lines, (int) (endPos - choppedPos));
     if (maxBytes <= 0)
         return list;
 
     const QByteArray chunk = cacheChunk(choppedPos, maxBytes);
     if (chunk.isEmpty())
         return list;
 
     int cnt = 0;
     for (int l = 0; l < lines; l++) {
         if (filePos >= endPos) {
             break;
         }
 
         const qint64 printPos = (filePos / bytesPerRow) * bytesPerRow;
         QString pos;
         pos.setNum(printPos, 16);
         while (pos.length() < positionDigits)
             pos = QString("0") + pos;
         pos = QString("0x") + pos;
         pos += QString(": ");
 
         QString charData;
 
         for (int i = 0; i != bytesPerRow; ++i, ++cnt) {
             const qint64 currentPos = printPos + i;
             if (currentPos < filePos || currentPos >= endPos) {
                 pos += QString("   ");
                 charData += QString(" ");
             } else {
                 char c = chunk.at(cnt);
-                int charCode = (int)c;
+                auto charCode = (int)c;
                 if (charCode < 0)
                     charCode += 256;
                 QString hex;
                 hex.setNum(charCode, 16);
                 if (hex.length() < 2)
                     hex = QString("0") + hex;
                 pos += hex + QString(" ");
                 if (c < 32)
                     c = '.';
                 charData += QChar(c);
             }
         }
 
         pos += QString(" ") + charData;
         list << pos;
         filePos = printPos + bytesPerRow;
     }
 
     if (filePos > endPos) {
         filePos = endPos;
     }
 
     return list;
 }
 
 int Lister::hexIndexToPosition(const int columns, const int index)
 {
     const int positionDigits = hexPositionDigits();
     const int bytesPerRow = hexBytesPerLine(columns);
     const int finalIndex = std::min(index, bytesPerRow);
 
     return positionDigits + 4 + (3*finalIndex);
 }
 
 int Lister::hexPositionToIndex(const int columns, const int position)
 {
     const int positionDigits = hexPositionDigits();
     const int bytesPerRow = hexBytesPerLine(columns);
 
     int finalPosition = position;
     finalPosition -= 4 + positionDigits;
     if (finalPosition <= 0)
         return 0;
 
     finalPosition /= 3;
     if (finalPosition >= bytesPerRow)
         return bytesPerRow;
     return finalPosition;
 }
 
 void Lister::toggleHexMode()
 {
     setHexMode(!_textArea->hexMode());
 }
 
 void Lister::setHexMode(const bool mode)
 {
     if (mode) {
         _textArea->setHexMode(true);
         _actionHexMode->setText(i18n("Text mode"));
     } else {
         _textArea->setHexMode(false);
         _actionHexMode->setText(i18n("Hex mode"));
     }
 }
diff --git a/krusader/KViewer/lister.h b/krusader/KViewer/lister.h
index baca7989..1586abd9 100644
--- a/krusader/KViewer/lister.h
+++ b/krusader/KViewer/lister.h
@@ -1,320 +1,320 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef LISTER_H
 #define LISTER_H
 
 // QtCore
 #include <QList>
 #include <QTimer>
 #include <QTextCodec>
 #include <QMutex>
 // QtGui
 #include <QColor>
 // QtWidgets
 #include <QWidget>
 #include <QShortcut>
 
 #include <KCompletion/KLineEdit>
 #include <KParts/BrowserExtension>
 #include <KParts/Part>
 #include <KTextWidgets/KTextEdit>
 
 #include "../FileSystem/krquery.h"
 
 #define  SLIDER_MAX          10000
 #define  MAX_CHAR_LENGTH     4
 
 class Lister;
 class QLabel;
 class QProgressBar;
 class QPushButton;
 class QToolButton;
 class QAction;
 class QTemporaryFile;
 class ListerEncodingMenu;
 
 class ListerTextArea : public KTextEdit
 {
     Q_OBJECT
 
 public:
     ListerTextArea(Lister *lister, QWidget *parent);
     void           reset();
     void           calculateText(const bool forcedUpdate = false);
     void           redrawTextArea(const bool forcedUpdate = false);
 
     qint64         textToFilePositionOnScreen(const int x, const int y, bool &isfirst);
     void           fileToTextPositionOnScreen(const qint64 p, const bool isfirst, int &x, int &y);
 
     int            tabWidth() {
         return _tabWidth;
     }
     bool           hexMode() {
         return _hexMode;
     }
     void           setHexMode(const bool hexMode);
 
     void           copySelectedToClipboard();
     QString        getSelectedText();
     void           clearSelection();
 
     void           getCursorPosition(int &x, int &y);
     qint64         getCursorPosition(bool &isfirst);
     qint64         getCursorAnchor() {
         return _cursorAnchorPos;
     }
     void           setCursorPositionInDocument(const qint64 p, const bool isfirst);
     void           ensureVisibleCursor();
     void           deleteAnchor() {
         _cursorAnchorPos = -1;
     }
 
     void           setAnchorAndCursor(const qint64 anchor, const qint64 cursor);
     void           sizeChanged();
 
 protected:
-    virtual void   resizeEvent(QResizeEvent * event) Q_DECL_OVERRIDE;
-    virtual void   keyPressEvent(QKeyEvent * e) Q_DECL_OVERRIDE;
-    virtual void   mousePressEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
-    virtual void   mouseDoubleClickEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
-    virtual void   mouseMoveEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
-    virtual void   wheelEvent(QWheelEvent * event) Q_DECL_OVERRIDE;
-
-    QStringList    readLines(const qint64 filePos, qint64 &endPos, const int lines, QList<qint64> * locs = 0);
+    void   resizeEvent(QResizeEvent * event) Q_DECL_OVERRIDE;
+    void   keyPressEvent(QKeyEvent * e) Q_DECL_OVERRIDE;
+    void   mousePressEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
+    void   mouseDoubleClickEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
+    void   mouseMoveEvent(QMouseEvent * e) Q_DECL_OVERRIDE;
+    void   wheelEvent(QWheelEvent * event) Q_DECL_OVERRIDE;
+
+    QStringList    readLines(const qint64 filePos, qint64 &endPos, const int lines, QList<qint64> * locs = nullptr);
     QString        readSection(qint64 p1, qint64 p2);
     void           setUpScrollBar();
     void           setCursorPositionOnScreen(const int x, const int y, const int anchorX = -1, const int anchorY = -1);
     void           handleAnchorChange(const int oldAnchor);
     void           performAnchorChange(const int anchor);
     void           getScreenPosition(const int position, int &x, int &y);
 
 public slots:
     void           slotActionTriggered(const int action);
 
 protected slots:
     void           slotCursorPositionChanged();
     void           zoomIn(const int range = 1);
     void           zoomOut(const int range = 1);
 
 protected:
     Lister        *_lister;
 
     qint64         _screenStartPos = 0;
     qint64         _screenEndPos = 0;
     qint64         _averagePageSize = 0;
 
     qint64         _lastPageStartPos = 0;
 
     int            _sizeX = -1;
     int            _sizeY = -1;
     int            _pageSize = 0;
 
     int            _tabWidth = 4;
 
     bool           _sizeChanged = false;
 
     QStringList    _rowContent;
     QList<qint64>  _rowStarts;
 
     qint64         _cursorPos = -1;
     bool           _cursorAtFirstColumn = true;
     bool           _skipCursorChangedListener = false;
 
     qint64         _cursorAnchorPos = -1;
 
     int            _skippedLines = 0;
 
     bool           _inSliderOp = false;
     bool           _hexMode = false;
     bool           _redrawing = false;
 
     QMutex         _cursorBlinkMutex;
     QTimer         _blinkTimer;
 };
 
 class ListerBrowserExtension : public KParts::BrowserExtension
 {
     Q_OBJECT
 
 public:
     explicit ListerBrowserExtension(Lister * lister);
 
 public slots:
     void copy();
     void print();
 
 protected:
     Lister   *_lister;
 };
 
 
 class ListerPane : public QWidget
 {
     Q_OBJECT
 
 public:
     ListerPane(Lister *lister, QWidget *parent);
 
 protected:
-    virtual bool   event(QEvent *event) Q_DECL_OVERRIDE;
+    bool   event(QEvent *event) Q_DECL_OVERRIDE;
 
 protected:
     bool     handleCloseEvent(QEvent *e);
     Lister        *_lister;
 };
 
 
 class Lister : public KParts::ReadOnlyPart
 {
     Q_OBJECT
 
 public:
     explicit Lister(QWidget *parent);
 
     QScrollBar     *scrollBar() {
         return _scrollBar;
     }
     ListerTextArea *textArea() {
         return _textArea;
     }
 
     inline qint64   fileSize() {
         return _fileSize;
     }
     QByteArray      cacheChunk(const qint64 filePos, const int maxSize);
 
     bool            isSearchEnabled();
     void            enableSearch(const bool);
     void            enableActions(const bool);
 
     QString         characterSet() { return _characterSet; }
     QTextCodec     *codec() { return _codec; }
-    void            setCharacterSet(const QString set);
+    void            setCharacterSet(const QString& set);
     void            setHexMode(const bool);
 
     QStringList     readHexLines(qint64 &filePos, const qint64 endPos, const int columns, const int lines);
     int             hexBytesPerLine(const int columns);
     int             hexPositionDigits();
     int             hexIndexToPosition(const int columns, const int index);
     int             hexPositionToIndex(const int columns, const int position);
 
 
 public slots:
     void            searchAction() {
         enableSearch(true);
     }
     void            searchNext();
     void            searchPrev();
     void            searchDelete();
     void            jumpToPosition();
     void            saveAs();
     void            saveSelected();
     void            print();
     void            toggleHexMode();
     void            slotUpdate();
 
 protected slots:
     void            slotSearchMore();
 
     void            searchSucceeded();
     void            searchFailed();
     void            searchTextChanged();
 
     void            slotDataSend(KIO::Job *, QByteArray &);
     void            slotSendFinished(KJob *);
 
 protected:
-    virtual bool    openUrl(const QUrl &url) Q_DECL_OVERRIDE;
-    virtual bool    closeUrl() Q_DECL_OVERRIDE {
+    bool    openUrl(const QUrl &url) Q_DECL_OVERRIDE;
+    bool    closeUrl() Q_DECL_OVERRIDE {
         return true;
     }
-    virtual bool    openFile() Q_DECL_OVERRIDE {
+    bool    openFile() Q_DECL_OVERRIDE {
         return true;
     }
-    virtual void    guiActivateEvent(KParts::GUIActivateEvent * event) Q_DECL_OVERRIDE;
+    void    guiActivateEvent(KParts::GUIActivateEvent * event) Q_DECL_OVERRIDE;
     void            setColor(const bool match, const bool restore);
     void            hideProgressBar();
     void            updateProgressBar();
     void            resetSearchPosition();
 
     qint64          getFileSize();
     void            search(const bool forward, const bool restart = false);
     QStringList     readLines(qint64 &filePos, const qint64 endPos, const int columns, const int lines);
 
     QTimer          _searchUpdateTimer;
     ListerTextArea *_textArea;
     QScrollBar     *_scrollBar;
     QLabel         *_listerLabel;
     KLineEdit      *_searchLineEdit;
     QProgressBar   *_searchProgressBar;
     QToolButton    *_searchStopButton;
     QPushButton    *_searchNextButton;
     QPushButton    *_searchPrevButton;
     bool            _searchInProgress = false;
     bool            _searchHexadecimal = false;
     QPushButton    *_searchOptions;
     QLabel         *_statusLabel;
 
     QAction        *_fromCursorAction;
     QAction        *_caseSensitiveAction;
     QAction        *_matchWholeWordsOnlyAction;
     QAction        *_regExpAction;
     QAction        *_hexAction;
 
     QAction        *_actionSaveSelected;
     QAction        *_actionSaveAs;
     QAction        *_actionPrint;
     QAction        *_actionSearch;
     QAction        *_actionSearchNext;
     QAction        *_actionSearchPrev;
     QAction        *_actionJumpToPosition;
     QAction        *_actionHexMode;
 
     QString         _filePath;
     qint64          _fileSize = 0;
 
     QByteArray      _cache;
     qint64          _cachePos = 0;
 
     KRQuery         _searchQuery;
     QByteArray      _searchHexQuery;
     qint64          _searchPosition = 0;
     bool            _searchIsForward = true;
     qint64          _searchLastFailedPosition = -1;
     int             _searchProgressCounter = 0;
 
     QColor          _originalBackground;
     QColor          _originalForeground;
 
     QString         _characterSet;
     QTextCodec     *_codec = QTextCodec::codecForLocale();
 
-    QTemporaryFile *_tempFile = 0;
+    QTemporaryFile *_tempFile = nullptr;
 
     bool            _downloading = false;
     bool            _restartFromBeginning = false;
     QTimer          _downloadUpdateTimer;
 
     qint64          _savePosition = 0;
     qint64          _saveEnd = 0;
 };
 
 #endif // __LISTER_H__
diff --git a/krusader/KViewer/panelviewer.cpp b/krusader/KViewer/panelviewer.cpp
index 80e69d8a..9cb57ca9 100644
--- a/krusader/KViewer/panelviewer.cpp
+++ b/krusader/KViewer/panelviewer.cpp
@@ -1,432 +1,430 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "panelviewer.h"
 
 // QtCore
 #include <QFile>
 // QtWidgets
 #include <QApplication>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KParts/BrowserExtension>
 #include <KParts/ReadWritePart>
 #include <KWidgetsAddons/KMessageBox>
 #include <KService/KServiceTypeProfile>
 #include <KService/KMimeTypeTrader>
 #include <KIOCore/KFileItem>
 
 #include "lister.h"
 #include "../defaults.h"
 
 #define DICTSIZE 211
 
 PanelViewerBase::PanelViewerBase(QWidget *parent, KrViewer::Mode mode) :
-        QStackedWidget(parent), mimes(0), cpart(0), mode(mode)
+        QStackedWidget(parent), mimes(nullptr), cpart(nullptr), mode(mode)
 {
     setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Ignored));
 
     mimes = new QHash<QString, QPointer<KParts::ReadOnlyPart> >();
-    cpart = 0;
+    cpart = nullptr;
     // NOTE: the fallback should be never visible. The viewer is not opened without a file and the
     // tab is closed if a file cannot be opened.
     fallback = new QLabel(i18n("No file selected or selected file cannot be displayed."), this);
     fallback->setAlignment(Qt::Alignment(QFlag(Qt::AlignCenter | Qt::TextExpandTabs)));
     fallback->setWordWrap(true);
     addWidget(fallback);
     setCurrentWidget(fallback);
 }
 
 PanelViewerBase::~PanelViewerBase()
 {
 // cpart->queryClose();
     closeUrl();
     QHashIterator< QString, QPointer<KParts::ReadOnlyPart> > lit(*mimes);
     while (lit.hasNext()) {
         QPointer<KParts::ReadOnlyPart> p = lit.next().value();
         if (p)
             delete p;
     }
     mimes->clear();
     delete mimes;
     delete fallback;
 }
 
 void PanelViewerBase::slotStatResult(KJob* job)
 {
     if (job->error()) {
         KMessageBox::error(this, job->errorString());
         emit openUrlFinished(this, false);
     } else {
-        KIO::UDSEntry entry = static_cast<KIO::StatJob*>(job)->statResult();
+        KIO::UDSEntry entry = dynamic_cast<KIO::StatJob*>(job)->statResult();
         openFile(KFileItem(entry, curl));
     }
 }
 
-KParts::ReadOnlyPart* PanelViewerBase::getPart(QString mimetype)
+KParts::ReadOnlyPart* PanelViewerBase::getPart(const QString& mimetype)
 {
-    KParts::ReadOnlyPart* part = 0;
+    KParts::ReadOnlyPart* part = nullptr;
 
     if (mimes->find(mimetype) == mimes->end()) {
         part = createPart(mimetype);
         if(part)
             mimes->insert(mimetype, part);
     } else
         part = (*mimes)[mimetype];
 
     return part;
 }
 
-void PanelViewerBase::openUrl(QUrl url)
+void PanelViewerBase::openUrl(const QUrl& url)
 {
     closeUrl();
     curl = url;
     emit urlChanged(this, url);
 
     if (url.isLocalFile())
         openFile(KFileItem(url));
     else {
         KIO::StatJob* statJob = KIO::stat(url, KIO::HideProgressInfo);
         connect(statJob, &KIO::StatJob::result, this, &PanelViewerBase::slotStatResult);
     }
 }
 
 
 /* ----==={ PanelViewer }===---- */
 
 PanelViewer::PanelViewer(QWidget *parent, KrViewer::Mode mode) :
         PanelViewerBase(parent, mode)
 {
 }
 
 PanelViewer::~PanelViewer()
-{
-}
+= default;
 
 KParts::ReadOnlyPart* PanelViewer::getListerPart(bool hexMode)
 {
-    KParts::ReadOnlyPart* part = 0;
+    KParts::ReadOnlyPart* part = nullptr;
 
     if (mimes->find(QLatin1String("krusader_lister")) == mimes->end()) {
         part = new Lister(this);
         mimes->insert(QLatin1String("krusader_lister"), part);
     } else
         part = (*mimes)[ QLatin1String("krusader_lister")];
 
     if (part) {
-        Lister *lister = qobject_cast<Lister *>((KParts::ReadOnlyPart *)part);
+        auto *lister = qobject_cast<Lister *>((KParts::ReadOnlyPart *)part);
         if (lister)
             lister->setHexMode(hexMode);
     }
     return part;
 }
 
 KParts::ReadOnlyPart* PanelViewer::getHexPart()
 {
-    KParts::ReadOnlyPart* part = 0;
+    KParts::ReadOnlyPart* part = nullptr;
 
     if (KConfigGroup(krConfig, "General").readEntry("UseOktetaViewer", _UseOktetaViewer)) {
         if (mimes->find("oktetapart") == mimes->end()) {
             KPluginFactory* factory = nullptr;
             // Okteta >= 0.26 provides a desktop file, prefer that as the binary changes name
             KService::Ptr service = KService::serviceByDesktopName("oktetapart");
             if (service) {
                 factory = KPluginLoader(*service.data()).factory();
             } else {
                 // fallback to search for desktopfile-less old variant
                 factory = KPluginLoader("oktetapart").factory();
             }
             if (factory) {
                 if ((part = factory->create<KParts::ReadOnlyPart>(this, this)))
                     mimes->insert("oktetapart", part);
             }
         } else
             part = (*mimes)["oktetapart"];
     }
 
     return part ? part : getListerPart(true);
 }
 
 KParts::ReadOnlyPart* PanelViewer::getTextPart()
 {
     KParts::ReadOnlyPart* part = getPart("text/plain");
     if(!part)
         part = getPart("all/allfiles");
     return part ? part : getListerPart();
 }
 
-KParts::ReadOnlyPart* PanelViewer::getDefaultPart(KFileItem fi)
+KParts::ReadOnlyPart* PanelViewer::getDefaultPart(const KFileItem& fi)
 {
     KConfigGroup group(krConfig, "General");
     QString modeString = group.readEntry("Default Viewer Mode", QString("generic"));
 
     KrViewer::Mode mode = KrViewer::Generic;
 
     if (modeString == "generic") mode = KrViewer::Generic;
     else if (modeString == "text") mode = KrViewer::Text;
     else if (modeString == "hex") mode = KrViewer::Hex;
     else if (modeString == "lister") mode = KrViewer::Lister;
 
     QMimeType mimeType = fi.determineMimeType();
     bool isBinary = false;
     if (mode == KrViewer::Generic || mode == KrViewer::Lister) {
         isBinary = !mimeType.inherits(QStringLiteral("text/plain"));
     }
 
     KIO::filesize_t fileSize = fi.size();
     KIO::filesize_t limit = (KIO::filesize_t)group.readEntry("Lister Limit", _ListerLimit) * 0x100000;
 
     QString mimetype = fi.mimetype();
 
-    KParts::ReadOnlyPart* part = 0;
+    KParts::ReadOnlyPart* part = nullptr;
 
     switch(mode) {
     case KrViewer::Generic:
         if ((mimetype.startsWith(QLatin1String("text/")) ||
              mimetype.startsWith(QLatin1String("all/"))) &&
             fileSize > limit) {
             part = getListerPart(isBinary);
             break;
         } else if ((part = getPart(mimetype))) {
             break;
         }
 #if __GNUC__ >= 7
         [[gnu::fallthrough]];
 #endif
     case KrViewer::Text:
         part = fileSize > limit ? getListerPart(false) : getTextPart();
         break;
     case KrViewer::Lister:
         part = getListerPart(isBinary);
         break;
     case KrViewer::Hex:
         part = fileSize > limit ? getListerPart(true) : getHexPart();
         break;
     default:
         abort();
     }
 
     return part;
 }
 
 void PanelViewer::openFile(KFileItem fi)
 {
     switch(mode) {
     case KrViewer::Generic:
         cpart = getPart(fi.mimetype());
         break;
     case KrViewer::Text:
         cpart = getTextPart();
         break;
     case KrViewer::Lister:
         cpart = getListerPart();
         break;
     case KrViewer::Hex:
         cpart = getHexPart();
         break;
     case KrViewer::Default:
         cpart = getDefaultPart(fi);
         break;
     default:
         abort();
     }
 
     if(cpart) {
         addWidget(cpart->widget());
         setCurrentWidget(cpart->widget());
 
         if (cpart->inherits("KParts::ReadWritePart"))
-            static_cast<KParts::ReadWritePart*>(cpart.data())->setReadWrite(false);
+            dynamic_cast<KParts::ReadWritePart*>(cpart.data())->setReadWrite(false);
         KParts::OpenUrlArguments args;
         args.setReload(true);
         cpart->setArguments(args);
         if (cpart->openUrl(curl)) {
             connect(cpart.data(), &KParts::ReadOnlyPart::destroyed, this, &PanelViewer::slotCPartDestroyed);
             emit openUrlFinished(this, true);
             return;
         }
     }
 
     setCurrentWidget(fallback);
     emit openUrlFinished(this, false);
 }
 
 bool PanelViewer::closeUrl()
 {
     setCurrentWidget(fallback);
     if (cpart && cpart->closeUrl()) {
-        cpart = 0;
+        cpart = nullptr;
         return true;
     }
     return false;
 }
 
 KParts::ReadOnlyPart* PanelViewer::createPart(QString mimetype)
 {
-    KParts::ReadOnlyPart * part = 0;
+    KParts::ReadOnlyPart * part = nullptr;
     KService::Ptr ptr = KMimeTypeTrader::self()->preferredService(mimetype, "KParts/ReadOnlyPart");
     if (ptr) {
         QVariantList args;
         QVariant argsProp = ptr->property("X-KDE-BrowserView-Args");
         if (argsProp.isValid())
             args << argsProp;
         QVariant prop = ptr->property("X-KDE-BrowserView-AllowAsDefault");
         if (!prop.isValid() || prop.toBool()) // defaults to true
             part = ptr->createInstance<KParts::ReadOnlyPart>(this, this, args);
     }
     if (part) {
         KParts::BrowserExtension * ext = KParts::BrowserExtension::childObject(part);
         if (ext) {
             connect(ext, &KParts::BrowserExtension::openUrlRequestDelayed, this, &PanelViewer::openUrl);
             connect(ext, &KParts::BrowserExtension::openUrlRequestDelayed, this, &PanelViewer::openUrlRequest);
         }
     }
     return part;
 }
 
 
 /* ----==={ PanelEditor }===---- */
 
 PanelEditor::PanelEditor(QWidget *parent, KrViewer::Mode mode) :
         PanelViewerBase(parent, mode)
 {
 }
 
 PanelEditor::~PanelEditor()
-{
-}
+= default;
 
 void PanelEditor::configureDeps()
 {
     KService::Ptr ptr = KMimeTypeTrader::self()->preferredService("text/plain", "KParts/ReadWritePart");
     if (!ptr)
         ptr = KMimeTypeTrader::self()->preferredService("all/allfiles", "KParts/ReadWritePart");
     if (!ptr)
-        KMessageBox::sorry(0, missingKPartMsg(), i18n("Missing Plugin"), KMessageBox::AllowLink);
+        KMessageBox::sorry(nullptr, missingKPartMsg(), i18n("Missing Plugin"), KMessageBox::AllowLink);
 
 }
 
 QString PanelEditor::missingKPartMsg()
 {
     return i18nc("missing kpart - arg1 is a URL",
                  "<b>No text editor plugin available.</b><br/>"
                     "Internal editor will not work without this.<br/>"
                     "You can fix this by installing Kate:<br/>%1",
                  QString("<a href='%1'>%1</a>").arg(
                     "http://www.kde.org/applications/utilities/kate"));
 }
 
 void PanelEditor::openFile(KFileItem fi)
 {
     KIO::filesize_t fileSize = fi.size();
     KConfigGroup group(krConfig, "General");
     KIO::filesize_t limitMB = (KIO::filesize_t)group.readEntry("Lister Limit", _ListerLimit);
     QString mimetype = fi.mimetype();
 
     if (mode == KrViewer::Generic)
         cpart = getPart(mimetype);
 
     if(fileSize > limitMB * 0x100000) {
         if(!cpart || mimetype.startsWith(QLatin1String("text/")) ||
                 mimetype.startsWith(QLatin1String("all/"))) {
             if(KMessageBox::Cancel == KMessageBox::warningContinueCancel(this,
                   i18n("%1 is bigger than %2 MB" , curl.toDisplayString(QUrl::PreferLocalFile), limitMB))) {
                 setCurrentWidget(fallback);
                 emit openUrlFinished(this, false);
                 return;
             }
         }
     }
 
     if (!cpart)
         cpart = getPart("text/plain");
     if (!cpart)
         cpart = getPart("all/allfiles");
 
     if (cpart) {
         addWidget(cpart->widget());
         setCurrentWidget(cpart->widget());
 
         KParts::OpenUrlArguments args;
         args.setReload(true);
         cpart->setArguments(args);
         if (cpart->openUrl(curl)) {
             connect(cpart.data(), &KParts::ReadOnlyPart::destroyed, this, &PanelEditor::slotCPartDestroyed);
             emit openUrlFinished(this, true);
             return;
         } // else: don't show error message - assume this has been done by the editor part
     } else
         KMessageBox::sorry(this, missingKPartMsg(), i18n("Cannot edit %1", curl.toDisplayString(QUrl::PreferLocalFile)),
                            KMessageBox::AllowLink);
 
     setCurrentWidget(fallback);
     emit openUrlFinished(this, false);
 }
 
 bool PanelEditor::queryClose()
 {
     if (!cpart) return true;
-    return static_cast<KParts::ReadWritePart *>((KParts::ReadOnlyPart *)cpart)->queryClose();
+    return dynamic_cast<KParts::ReadWritePart *>((KParts::ReadOnlyPart *)cpart)->queryClose();
 }
 
 bool PanelEditor::closeUrl()
 {
     if (!cpart) return false;
 
-    static_cast<KParts::ReadWritePart *>((KParts::ReadOnlyPart *)cpart)->closeUrl(false);
+    dynamic_cast<KParts::ReadWritePart *>((KParts::ReadOnlyPart *)cpart)->closeUrl(false);
 
     setCurrentWidget(fallback);
-    cpart = 0;
+    cpart = nullptr;
     return true;
 }
 
 KParts::ReadOnlyPart* PanelEditor::createPart(QString mimetype)
 {
-    KParts::ReadWritePart * part = 0L;
+    KParts::ReadWritePart * part = nullptr;
     KService::Ptr ptr = KMimeTypeTrader::self()->preferredService(mimetype, "KParts/ReadWritePart");
     if (ptr) {
         QVariantList args;
         QVariant argsProp = ptr->property("X-KDE-BrowserView-Args");
         if (argsProp.isValid())
             args << argsProp;
         QVariant prop = ptr->property("X-KDE-BrowserView-AllowAsDefault");
         if (!prop.isValid() || prop.toBool()) // defaults to true
             part = ptr->createInstance<KParts::ReadWritePart>(this, this, args);
     }
     if (part) {
         KParts::BrowserExtension * ext = KParts::BrowserExtension::childObject(part);
         if (ext) {
             connect(ext, &KParts::BrowserExtension::openUrlRequestDelayed, this, &PanelEditor::openUrl);
             connect(ext, &KParts::BrowserExtension::openUrlRequestDelayed, this, &PanelEditor::openUrlRequest);
         }
     }
     return part;
 }
 
 bool PanelEditor::isModified()
 {
     if (cpart)
-        return static_cast<KParts::ReadWritePart *>((KParts::ReadOnlyPart *)cpart)->isModified();
+        return dynamic_cast<KParts::ReadWritePart *>((KParts::ReadOnlyPart *)cpart)->isModified();
     else
         return false;
 }
 
diff --git a/krusader/KViewer/panelviewer.h b/krusader/KViewer/panelviewer.h
index 369ee871..f10204ae 100644
--- a/krusader/KViewer/panelviewer.h
+++ b/krusader/KViewer/panelviewer.h
@@ -1,140 +1,140 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef PANELVIEWER_H
 #define PANELVIEWER_H
 
 // QtCore
 #include <QHash>
 #include <QString>
 #include <QUrl>
 // QtWidgets
 #include <QStackedWidget>
 #include <QLabel>
 
 # include <KParts/Part>
 
 #include "krviewer.h"
 
 
 class PanelViewerBase: public QStackedWidget
 {
     Q_OBJECT
 
 public:
     explicit PanelViewerBase(QWidget *parent, KrViewer::Mode mode = KrViewer::Default);
-    virtual ~PanelViewerBase();
+    ~PanelViewerBase() override;
     inline QUrl url() const {
         return curl;
     }
     inline KParts::ReadOnlyPart* part() const {
         return cpart;
     }
     virtual bool isModified() {
         return false;
     }
     virtual bool isEditor() = 0;
 
 public slots:
     virtual bool closeUrl() {
         return false;
     }
     virtual bool queryClose() {
         return true;
     }
 
-    void openUrl(QUrl url);
+    void openUrl(const QUrl& url);
 
 signals:
     void openUrlRequest(const QUrl &url);
     void urlChanged(PanelViewerBase *, const QUrl &);
     void partDestroyed(PanelViewerBase *);
     void openUrlFinished(PanelViewerBase *viewWidget, bool success);
 
 protected slots:
     void slotCPartDestroyed() {
         emit partDestroyed(this);
     }
     void slotStatResult(KJob* job);
 
 protected:
     virtual void openFile(KFileItem fi) = 0;
     virtual KParts::ReadOnlyPart* createPart(QString mimetype) = 0;
-    KParts::ReadOnlyPart* getPart(QString mimetype);
+    KParts::ReadOnlyPart* getPart(const QString& mimetype);
 
 
     QHash<QString, QPointer<KParts::ReadOnlyPart> > *mimes;
     QPointer<KParts::ReadOnlyPart> cpart;
 
     QUrl curl;
     QLabel *fallback;
     KrViewer::Mode mode;
 };
 
 class PanelViewer: public PanelViewerBase
 {
     Q_OBJECT
 public slots:
-    virtual bool closeUrl() Q_DECL_OVERRIDE;
+    bool closeUrl() Q_DECL_OVERRIDE;
 
 public:
     explicit PanelViewer(QWidget *parent, KrViewer::Mode mode = KrViewer::Default);
-    ~PanelViewer();
+    ~PanelViewer() override;
 
-    virtual bool isEditor() Q_DECL_OVERRIDE {
+    bool isEditor() Q_DECL_OVERRIDE {
         return false;
     }
 
 protected:
-    virtual void openFile(KFileItem fi) Q_DECL_OVERRIDE;
-    virtual KParts::ReadOnlyPart* createPart(QString mimetype) Q_DECL_OVERRIDE;
-    KParts::ReadOnlyPart* getDefaultPart(KFileItem fi);
+    void openFile(KFileItem fi) Q_DECL_OVERRIDE;
+    KParts::ReadOnlyPart* createPart(QString mimetype) Q_DECL_OVERRIDE;
+    KParts::ReadOnlyPart* getDefaultPart(const KFileItem& fi);
     KParts::ReadOnlyPart* getHexPart();
     KParts::ReadOnlyPart* getListerPart(bool hexMode = false);
     KParts::ReadOnlyPart* getTextPart();
 };
 
 class PanelEditor: public PanelViewerBase
 {
     Q_OBJECT
 public:
-    virtual bool isModified() Q_DECL_OVERRIDE;
-    virtual bool isEditor() Q_DECL_OVERRIDE {
+    bool isModified() Q_DECL_OVERRIDE;
+    bool isEditor() Q_DECL_OVERRIDE {
         return true;
     }
 
     static void configureDeps();
 
 public slots:
-    virtual bool closeUrl() Q_DECL_OVERRIDE;
-    virtual bool queryClose() Q_DECL_OVERRIDE;
+    bool closeUrl() Q_DECL_OVERRIDE;
+    bool queryClose() Q_DECL_OVERRIDE;
 
 public:
     explicit PanelEditor(QWidget *parent, KrViewer::Mode mode = KrViewer::Default);
-    ~PanelEditor();
+    ~PanelEditor() override;
 
 protected:
-    virtual void openFile(KFileItem fi) Q_DECL_OVERRIDE;
-    virtual KParts::ReadOnlyPart* createPart(QString mimetype) Q_DECL_OVERRIDE;
+    void openFile(KFileItem fi) Q_DECL_OVERRIDE;
+    KParts::ReadOnlyPart* createPart(QString mimetype) Q_DECL_OVERRIDE;
     static QString missingKPartMsg();
 };
 
 #endif
diff --git a/krusader/Konfigurator/kgadvanced.cpp b/krusader/Konfigurator/kgadvanced.cpp
index 784a7484..85fdcf93 100644
--- a/krusader/Konfigurator/kgadvanced.cpp
+++ b/krusader/Konfigurator/kgadvanced.cpp
@@ -1,114 +1,114 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kgadvanced.h"
 #include "../defaults.h"
 
 // QtWidgets
 #include <QGridLayout>
 #include <QLabel>
 
 #include <KI18n/KLocalizedString>
 #include <KIOCore/KProtocolInfo>
 
 KgAdvanced::KgAdvanced(bool first, QWidget* parent) :
         KonfiguratorPage(first, parent)
 {
     QWidget *innerWidget = new QFrame(this);
     setWidget(innerWidget);
     setWidgetResizable(true);
-    QGridLayout *kgAdvancedLayout = new QGridLayout(innerWidget);
+    auto *kgAdvancedLayout = new QGridLayout(innerWidget);
     kgAdvancedLayout->setSpacing(6);
 
     //  -------------------------- GENERAL GROUPBOX ----------------------------------
 
     QGroupBox *generalGrp = createFrame(i18n("General"), innerWidget);
     QGridLayout *generalGrid = createGridLayout(generalGrp);
 
     KONFIGURATOR_CHECKBOX_PARAM generalSettings[] =
         //   cfg_class  cfg_name             default              text                                                        restart tooltip
     {
         {"Advanced", "AutoMount",          _AutoMount,          i18n("Automount filesystems"),                            false,  i18n("When stepping into a folder which is defined as a mount point in the <b>fstab</b>, try mounting it with the defined parameters.")}
     };
 
     KonfiguratorCheckBoxGroup *generals = createCheckBoxGroup(1, 0, generalSettings, 1, generalGrp);
 
     generalGrid->addWidget(generals, 1, 0);
 
     addLabel(generalGrid, 2, 0, i18n("MountMan will not (un)mount the following mount-points:"),
              generalGrp);
     KonfiguratorEditBox *nonMountPoints = createEditBox("Advanced", "Nonmount Points", _NonMountPoints, generalGrp, false);
     generalGrid->addWidget(nonMountPoints, 2, 1);
 
 
 #ifdef BSD
     generals->find("AutoMount")->setEnabled(false);     /* disable AutoMount on BSD */
 #endif
 
     kgAdvancedLayout->addWidget(generalGrp, 0 , 0);
 
     //  ----------------------- CONFIRMATIONS GROUPBOX -------------------------------
 
     QGroupBox *confirmGrp = createFrame(i18n("Confirmations"), innerWidget);
     QGridLayout *confirmGrid = createGridLayout(confirmGrp);
 
     addLabel(confirmGrid, 0, 0, i18n("\nRequest user confirmation for the following operations:\n"),
              confirmGrp);
 
     KONFIGURATOR_CHECKBOX_PARAM confirmations[] =
         //   cfg_class  cfg_name                default             text                                          restart ToolTip
     {{"Advanced", "Confirm Unempty Dir",   _ConfirmUnemptyDir, i18n("Deleting non-empty folders"),       false,  ""},
         {"Advanced", "Confirm Delete",        _ConfirmDelete,     i18n("Deleting files"),                   false,  ""},
         {"Advanced", "Confirm Copy",          _ConfirmCopy,       i18n("Copying files"),                    false,  ""},
         {"Advanced", "Confirm Move",          _ConfirmMove,       i18n("Moving files"),                     false,  ""},
         {"Advanced", "Confirm Feed to Listbox",  _ConfirmFeedToListbox, i18n("Confirm feed to listbox"), false, i18n("Ask for a result name when feeding items to the listbox. By default the standard value is used.")},
         {"Notification Messages", "Confirm Remove UserAction", true, i18n("Removing Useractions"), false,  ""}
     };
 
     KonfiguratorCheckBoxGroup *confWnd = createCheckBoxGroup(2, 0, confirmations, 6, confirmGrp);
 
     confirmGrid->addWidget(confWnd, 1, 0);
 
     kgAdvancedLayout->addWidget(confirmGrp, 1 , 0);
 
 
     //  ------------------------ FINE-TUNING GROUPBOX --------------------------------
 
     QGroupBox *fineTuneGrp = createFrame(i18n("Fine-Tuning"), innerWidget);
     QGridLayout *fineTuneGrid = createGridLayout(fineTuneGrp);
     fineTuneGrid->setAlignment(Qt::AlignLeft | Qt::AlignTop);
 
     QLabel *label = new QLabel(i18n("Icon cache size (KB):"), fineTuneGrp);
     label->setWhatsThis(i18n("The icon cache size influences how fast the contents of a panel can be displayed. However, too large a cache might consume your memory."));
     fineTuneGrid->addWidget(label, 0, 0);
     KonfiguratorSpinBox *spinBox = createSpinBox("Advanced", "Icon Cache Size", _IconCacheSize,
                                    1, 8192, fineTuneGrp, false);
     spinBox->setWhatsThis(i18n("The icon cache size influences how fast the contents of a panel can be displayed. However, too large a cache might consume your memory."));
     spinBox->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     fineTuneGrid->addWidget(spinBox, 0, 1);
 
     addLabel(fineTuneGrid, 1, 0, i18n("Arguments of updatedb:"),
              fineTuneGrp);
     KonfiguratorEditBox *updatedbArgs = createEditBox("Locate", "UpdateDB Arguments", "", fineTuneGrp, false);
     fineTuneGrid->addWidget(updatedbArgs, 1, 1);
 
     kgAdvancedLayout->addWidget(fineTuneGrp, 2 , 0);
 }
 
diff --git a/krusader/Konfigurator/kgadvanced.h b/krusader/Konfigurator/kgadvanced.h
index 6cbab0d5..52157e53 100644
--- a/krusader/Konfigurator/kgadvanced.h
+++ b/krusader/Konfigurator/kgadvanced.h
@@ -1,34 +1,34 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGADVANCED_H
 #define KGADVANCED_H
 
 #include "konfiguratorpage.h"
 
 class KgAdvanced : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgAdvanced(bool first, QWidget* parent = 0);
+    explicit KgAdvanced(bool first, QWidget* parent = nullptr);
 };
 
 #endif /* __KGADVANCED_H__ */
diff --git a/krusader/Konfigurator/kgarchives.cpp b/krusader/Konfigurator/kgarchives.cpp
index f4842103..a896ef76 100644
--- a/krusader/Konfigurator/kgarchives.cpp
+++ b/krusader/Konfigurator/kgarchives.cpp
@@ -1,133 +1,133 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kgarchives.h"
 
 // QtCore
 #include <QPointer>
 // QtWidgets
 #include <QPushButton>
 #include <QGridLayout>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 #include "krresulttable.h"
 #include "krresulttabledialog.h"
 #include "searchobject.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../Archive/krarchandler.h"
 
 KgArchives::KgArchives(bool first, QWidget* parent) :
         KonfiguratorPage(first, parent)
 {
     QWidget *innerWidget = new QFrame(this);
     setWidget(innerWidget);
     setWidgetResizable(true);
-    QGridLayout *kgArchivesLayout = new QGridLayout(innerWidget);
+    auto *kgArchivesLayout = new QGridLayout(innerWidget);
     kgArchivesLayout->setSpacing(6);
 
     //  ------------------------ KRARC GROUPBOX --------------------------------
 
     QGroupBox *krarcGrp = createFrame(i18n("krarc ioslave"), innerWidget);
     QGridLayout *krarcGrid = createGridLayout(krarcGrp);
 
     KONFIGURATOR_CHECKBOX_PARAM krarcOptions[] =
         //   cfg_class  cfg_name                  default           text                                          restart ToolTip
     {
         {"kio_krarc", "EnableWrite", false, i18n("Enable Write Support"), false, i18n("Enable writing to archives using the krarc ioslave.")}
     };
 
     KonfiguratorCheckBoxGroup *krarcCheckBoxes = createCheckBoxGroup(1, 0, krarcOptions, 1, krarcGrp);
 
     krarcGrid->addWidget(krarcCheckBoxes, 1, 0);
     krarcGrid->addWidget(
             new QLabel(i18n("<b>Caution when moving into archives:</b><br/>"
                             "<b>Failure during the process might result in data loss.</b><br/>"
                             "<b>Moving archives into themselves will delete them.</b>"), krarcGrp),
             2, 0);
 
     kgArchivesLayout->addWidget(krarcGrp, 1 , 0);
 
     //  ------------------------ BROWSE GROUPBOX --------------------------------
 
     QGroupBox *browseGrp = createFrame(i18n("Archives handling"), innerWidget);
     QGridLayout *browseGrid = createGridLayout(browseGrp);
 
     KONFIGURATOR_CHECKBOX_PARAM browseOptions[] =
         //   cfg_class  cfg_name                  default           text                                          restart ToolTip
     {
         {"Archives", "ArchivesAsDirectories", _ArchivesAsDirectories, i18n("Browse Archives As Folders"), false, i18n("Krusader will browse archives as folders.")}
     };
 
     KonfiguratorCheckBoxGroup *browseCheckBoxes = createCheckBoxGroup(1, 0, browseOptions, 1, browseGrp);
 
     browseGrid->addWidget(browseCheckBoxes, 1, 0);
 
     kgArchivesLayout->addWidget(browseGrp, 2 , 0);
 
     //  ------------------------ FINE-TUNING GROUPBOX --------------------------------
 
     QGroupBox *fineTuneGrp = createFrame(i18n("Fine-Tuning"), innerWidget);
     QGridLayout *fineTuneGrid = createGridLayout(fineTuneGrp);
 
     KONFIGURATOR_CHECKBOX_PARAM finetuners[] =
         //   cfg_class  cfg_name                  default           text                                          restart ToolTip
     {
         {"Archives", "Test Archives",           _TestArchives,    i18n("Test archive after packing"), false,  i18n("Check the archive's integrity after packing it.")},
         {"Archives", "Test Before Unpack",      _TestBeforeUnpack, i18n("Test archive before unpacking"), false,  i18n("Some corrupted archives might cause a crash; therefore, testing is suggested.")}
     };
 
     KonfiguratorCheckBoxGroup *finetunes = createCheckBoxGroup(1, 0, finetuners, 2, fineTuneGrp);
 
     disableNonExistingPackers();
     fineTuneGrid->addWidget(finetunes, 1, 0);
 
     kgArchivesLayout->addWidget(fineTuneGrp, 3 , 0);
 
     if (first)
         slotAutoConfigure();
 
 }
 
 
 void KgArchives::slotAutoConfigure()
 {
     QPointer<KrResultTableDialog> dlg = new KrResultTableDialog(this,
             KrResultTableDialog::Archiver,
             i18n("Search results"),
             i18n("Searching for packers..."),
             "utilities-file-archiver",
             i18n("Make sure to install new packers in your <code>$PATH</code> (e.g. /usr/bin)"));
     dlg->exec();
 
     disableNonExistingPackers();
 
     delete dlg;
 }
 
 void KgArchives::disableNonExistingPackers()
 {
     KConfigGroup group(krConfig, "Archives");
     group.writeEntry("Supported Packers", KRarcHandler::supportedPackers());
 }
 
 
diff --git a/krusader/Konfigurator/kgarchives.h b/krusader/Konfigurator/kgarchives.h
index c6292e08..91f564ba 100644
--- a/krusader/Konfigurator/kgarchives.h
+++ b/krusader/Konfigurator/kgarchives.h
@@ -1,40 +1,40 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGARCHIVES_H
 #define KGARCHIVES_H
 
 #include "konfiguratorpage.h"
 
 class KgArchives : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgArchives(bool first, QWidget* parent = 0);
+    explicit KgArchives(bool first, QWidget* parent = nullptr);
 
 public slots:
     void slotAutoConfigure();
 
 protected:
     void disableNonExistingPackers();
 };
 
 #endif /* __KGARCHIVES_H__ */
diff --git a/krusader/Konfigurator/kgcolors.cpp b/krusader/Konfigurator/kgcolors.cpp
index 1d713005..92c7a33b 100644
--- a/krusader/Konfigurator/kgcolors.cpp
+++ b/krusader/Konfigurator/kgcolors.cpp
@@ -1,705 +1,706 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kgcolors.h"
 #include "../defaults.h"
 #include "../Panel/krcolorcache.h"
 #include "../Synchronizer/synchronizercolors.h"
 
 // QtCore
 #include <QList>
 #include <QStandardPaths>
 // QtGui
 #include <QGuiApplication>
 // QtWidgets
 #include <QFileDialog>
 #include <QTabWidget>
 #include <QHeaderView>
 #include <QLabel>
 #include <QGridLayout>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
+#include <utility>
 
 KgColors::KgColors(bool first, QWidget* parent) :
         KonfiguratorPage(first, parent), offset(0),
         activeTabIdx(-1), inactiveTabIdx(-1),
 #ifdef SYNCHRONIZER_ENABLED
         synchronizerTabIdx(-1),
 #endif
         otherTabIdx(-1)
 {
     QWidget *innerWidget = new QFrame(this);
     setWidget(innerWidget);
     setWidgetResizable(true);
-    QGridLayout *kgColorsLayout = new QGridLayout(innerWidget);
+    auto *kgColorsLayout = new QGridLayout(innerWidget);
     kgColorsLayout->setSpacing(6);
 
     //  -------------------------- GENERAL GROUPBOX ----------------------------------
 
     QGroupBox *generalGrp = createFrame(i18n("General"), innerWidget);
     QGridLayout *generalGrid = createGridLayout(generalGrp);
 
     generalGrid->setSpacing(0);
     generalGrid->setContentsMargins(5, 5, 5, 5);
 
     KONFIGURATOR_CHECKBOX_PARAM generalSettings[] =
         //  cfg_class  cfg_name                     default                 text                                              restart tooltip
     {{"Colors", "KDE Default",                 _KDEDefaultColors,      i18n("Use the default KDE colors"),             false,  "<p><img src='toolbar|kcontrol'></p>" + i18n("<p>Use KDE's global color configuration.</p><p><i>KDE System Settings -> Application Appearance  -> Colors</i></p>") },
         {"Colors", "Enable Alternate Background", _AlternateBackground,   i18n("Use alternate background color"),         false, i18n("<p>The <b>background color</b> and the <b>alternate background</b> color alternates line by line.</p><p>When you don't use the <i>KDE default colors</i>, you can configure the alternate colors in the <i>colors</i> box.</p>") },
         {"Colors", "Show Current Item Always",    _ShowCurrentItemAlways, i18n("Show current item even if not focused"),  false, i18n("<p>Shows the last cursor position in the non active list panel.</p><p>This option is only available when you don't use the <i>KDE default colors</i>.</p>") },
         {"Colors", "Dim Inactive Colors",         _DimInactiveColors,     i18n("Dim the colors of the inactive panel"),   false, i18n("<p>The colors of the inactive panel are calculated by a dim color and a dim factor.</p>") }
     };
 
     generals = createCheckBoxGroup(0, 2, generalSettings, sizeof(generalSettings) / sizeof(generalSettings[0]), generalGrp);
     generalGrid->addWidget(generals, 1, 0);
 
     generals->layout()->setSpacing(5);
 
     connect(generals->find("KDE Default"), &KonfiguratorCheckBox::stateChanged, this, &KgColors::slotDisable);
     connect(generals->find("Show Current Item Always"), &KonfiguratorCheckBox::stateChanged, this, &KgColors::slotDisable);
     connect(generals->find("Dim Inactive Colors"), &KonfiguratorCheckBox::stateChanged, this, &KgColors::slotDisable);
 
     kgColorsLayout->addWidget(generalGrp, 0 , 0, 1, 3);
     QWidget *hboxWidget = new QWidget(innerWidget);
-    QHBoxLayout *hbox = new QHBoxLayout(hboxWidget);
+    auto *hbox = new QHBoxLayout(hboxWidget);
 
     //  -------------------------- COLORS GROUPBOX ----------------------------------
 
     QGroupBox *colorsFrameGrp = createFrame(i18n("Colors"), hboxWidget);
     QGridLayout *colorsFrameGrid = createGridLayout(colorsFrameGrp);
     colorsFrameGrid->setSpacing(0);
     colorsFrameGrid->setContentsMargins(3, 3, 3, 3);
 
     colorTabWidget = new QTabWidget(colorsFrameGrp);
 
     colorsGrp = new QWidget(colorTabWidget);
     activeTabIdx = colorTabWidget->addTab(colorsGrp, i18n("Active"));
 
     colorsGrid = new QGridLayout(colorsGrp);
     colorsGrid->setSpacing(0);
     colorsGrid->setContentsMargins(2, 2, 2, 2);
 
     ADDITIONAL_COLOR transparent  = { i18n("Transparent"),       Qt::white, "transparent" };
 
     QPalette p = QGuiApplication::palette();
 
     addColorSelector("Foreground",                 i18n("Foreground:"),                  p.color(QPalette::Active, QPalette::Text));
     addColorSelector("Directory Foreground",       i18n("Folder foreground:"),           getColorSelector("Foreground")->getColor(), i18n("Same as foreground"));
     addColorSelector("Executable Foreground",      i18n("Executable foreground:"),       getColorSelector("Foreground")->getColor(), i18n("Same as foreground"));
     addColorSelector("Symlink Foreground",         i18n("Symbolic link foreground:"),    getColorSelector("Foreground")->getColor(), i18n("Same as foreground"));
     addColorSelector("Invalid Symlink Foreground", i18n("Invalid symlink foreground:"),  getColorSelector("Foreground")->getColor(), i18n("Same as foreground"));
     addColorSelector("Background",                 i18n("Background:"),                  p.color(QPalette::Active, QPalette::Base));
     ADDITIONAL_COLOR sameAsBckgnd = { i18n("Same as background"), getColorSelector("Background")->getColor(), "Background" };
     addColorSelector("Alternate Background",       i18n("Alternate background:"),        p.color(QPalette::Active, QPalette::AlternateBase), "", &sameAsBckgnd, 1);
     addColorSelector("Marked Foreground",          i18n("Selected foreground:"),         p.color(QPalette::Active, QPalette::HighlightedText), "", &transparent, 1);
     addColorSelector("Marked Background",          i18n("Selected background:"),         p.color(QPalette::Active, QPalette::Highlight), "", &sameAsBckgnd, 1);
     ADDITIONAL_COLOR sameAsAltern = { i18n("Same as alt. background"), getColorSelector("Alternate Background")->getColor(), "Alternate Background" };
     addColorSelector("Alternate Marked Background", i18n("Alternate selected background:"), getColorSelector("Marked Background")->getColor(), i18n("Same as selected background"), &sameAsAltern, 1);
     addColorSelector("Current Foreground",         i18n("Current foreground:"),          Qt::white,                                    i18n("Not used"));
     ADDITIONAL_COLOR sameAsMarkedForegnd = { i18n("Same as selected foreground"), getColorSelector("Marked Foreground")->getColor(), "Marked Foreground" };
     addColorSelector("Marked Current Foreground",         i18n("Selected current foreground:"),          Qt::white,                                    i18n("Not used"), &sameAsMarkedForegnd, 1);
     addColorSelector("Current Background",         i18n("Current background:"),          Qt::white, i18n("Not used"), &sameAsBckgnd, 1);
 
     colorsGrid->addWidget(createSpacer(colorsGrp), itemList.count() - offset, 1);
 
     connect(getColorSelector("Foreground"), &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotForegroundChanged);
     connect(getColorSelector("Background"), &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotBackgroundChanged);
     connect(getColorSelector("Alternate Background"), &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotAltBackgroundChanged);
     connect(getColorSelector("Marked Background"), &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotMarkedBackgroundChanged);
 
     inactiveColorStack = new QStackedWidget(colorTabWidget);
     inactiveTabIdx = colorTabWidget->addTab(inactiveColorStack, i18n("Inactive"));
 
     colorsGrp = normalInactiveWidget = new QWidget(inactiveColorStack);
 
     colorsGrid = new QGridLayout(normalInactiveWidget);
     colorsGrid->setSpacing(0);
     colorsGrid->setContentsMargins(2, 2, 2, 2);
 
     offset = endOfActiveColors = itemList.count();
 
     addColorSelector("Inactive Foreground",                  i18n("Foreground:"),                  getColorSelector("Foreground")->getColor(), i18n("Same as active"));
     ADDITIONAL_COLOR sameAsInactForegnd = { i18n("Same as foreground"), getColorSelector("Inactive Foreground")->getColor(), "Inactive Foreground" };
     addColorSelector("Inactive Directory Foreground",        i18n("Folder foreground:"),           getColorSelector("Directory Foreground")->getColor(), i18n("Same as active"), &sameAsInactForegnd, 1);
     addColorSelector("Inactive Executable Foreground",       i18n("Executable foreground:"),       getColorSelector("Executable Foreground")->getColor(), i18n("Same as active"), &sameAsInactForegnd, 1);
     addColorSelector("Inactive Symlink Foreground",          i18n("Symbolic link foreground:"),    getColorSelector("Symlink Foreground")->getColor(), i18n("Same as active"), &sameAsInactForegnd, 1);
     addColorSelector("Inactive Invalid Symlink Foreground",  i18n("Invalid symlink foreground:"),  getColorSelector("Invalid Symlink Foreground")->getColor(), i18n("Same as active"), &sameAsInactForegnd, 1);
     addColorSelector("Inactive Background",                  i18n("Background:"),                  getColorSelector("Background")->getColor(), i18n("Same as active"));
     ADDITIONAL_COLOR sameAsInactBckgnd = { i18n("Same as background"), getColorSelector("Inactive Background")->getColor(), "Inactive Background" };
     addColorSelector("Inactive Alternate Background",        i18n("Alternate background:"),        getColorSelector("Alternate Background")->getColor(), i18n("Same as active"), &sameAsInactBckgnd, 1);
     addColorSelector("Inactive Marked Foreground",           i18n("Selected foreground:"),           getColorSelector("Marked Foreground")->getColor(), i18n("Same as active"), &transparent, 1);
     addColorSelector("Inactive Marked Background",           i18n("Selected background:"),           getColorSelector("Marked Background")->getColor(), i18n("Same as active"), &sameAsInactBckgnd, 1);
     ADDITIONAL_COLOR sameAsInactAltern[] = {{ i18n("Same as alt. background"), getColorSelector("Inactive Alternate Background")->getColor(), "Inactive Alternate Background" },
         { i18n("Same as selected background"), getColorSelector("Inactive Marked Background")->getColor(), "Inactive Marked Background" }
     };
     addColorSelector("Inactive Alternate Marked Background", i18n("Alternate selected background:"), getColorSelector("Alternate Marked Background")->getColor(), i18n("Same as active"), sameAsInactAltern, 2);
     addColorSelector("Inactive Current Foreground",          i18n("Current foreground:"),          getColorSelector("Current Foreground")->getColor(), i18n("Same as active"));
     ADDITIONAL_COLOR sameAsInactMarkedForegnd = { i18n("Same as selected foreground"), getColorSelector("Inactive Marked Foreground")->getColor(), "Inactive Marked Foreground" };
     addColorSelector("Inactive Marked Current Foreground",          i18n("Selected current foreground:"),          getColorSelector("Marked Current Foreground")->getColor(), i18n("Same as active"), &sameAsInactMarkedForegnd, 1);
     addColorSelector("Inactive Current Background",          i18n("Current background:"),          getColorSelector("Current Background")->getColor(), i18n("Same as active"), &sameAsInactBckgnd, 1);
 
     colorsGrid->addWidget(createSpacer(normalInactiveWidget), itemList.count() - offset, 1);
 
     connect(getColorSelector("Inactive Foreground"), &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotInactiveForegroundChanged);
     connect(getColorSelector("Inactive Background"), &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotInactiveBackgroundChanged);
     connect(getColorSelector("Inactive Alternate Background"), &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotInactiveAltBackgroundChanged);
     connect(getColorSelector("Inactive Marked Background"), &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotInactiveMarkedBackgroundChanged);
 
     offset = endOfPanelColors = itemList.count();
 
     inactiveColorStack->addWidget(normalInactiveWidget);
 
     colorsGrp = dimmedInactiveWidget = new QWidget(inactiveColorStack);
 
     colorsGrid = new QGridLayout(dimmedInactiveWidget);
     colorsGrid->setSpacing(0);
     colorsGrid->setContentsMargins(2, 2, 2, 2);
 
     addColorSelector("Dim Target Color", i18n("Dim target color:"), Qt::black);
 
     int index = itemList.count() - offset;
     labelList.append(addLabel(colorsGrid, index, 0, i18n("Dim factor:"), colorsGrp));
     dimFactor = createSpinBox("Colors", "Dim Factor", 80, 0, 100, colorsGrp);
     dimFactor->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     colorsGrid->addWidget(dimFactor, index++, 1);
 
     colorsGrid->addWidget(createSpacer(dimmedInactiveWidget), itemList.count() + 1 - offset, 1);
 
     inactiveColorStack->addWidget(dimmedInactiveWidget);
 
     inactiveColorStack->setCurrentWidget(normalInactiveWidget);
 
     ADDITIONAL_COLOR KDEDefaultBase = { i18n("KDE default"), p.color(QPalette::Active, QPalette::Base), "KDE default" };
     ADDITIONAL_COLOR KDEDefaultFore = { i18n("KDE default"), p.color(QPalette::Active, QPalette::Text), "KDE default" };
 
 #ifdef SYNCHRONIZER_ENABLED
     colorsGrp = new QWidget(colorTabWidget);
     synchronizerTabIdx = colorTabWidget->addTab(colorsGrp, i18n("Synchronizer"));
 
     colorsGrid = new QGridLayout(colorsGrp);
     colorsGrid->setSpacing(0);
     colorsGrid->setContentsMargins(2, 2, 2, 2);
 
     offset = endOfPanelColors = itemList.count();
 
     DECLARE_SYNCHRONIZER_BACKGROUND_DEFAULTS;
     DECLARE_SYNCHRONIZER_FOREGROUND_DEFAULTS;
 
     addColorSelector("Synchronizer Equals Foreground", i18n("Equals foreground:"), SYNCHRONIZER_FOREGROUND_DEFAULTS[0], QString(), &KDEDefaultFore, 1);
     addColorSelector("Synchronizer Equals Background", i18n("Equals background:"), SYNCHRONIZER_BACKGROUND_DEFAULTS[0], QString(), &KDEDefaultBase, 1);
     addColorSelector("Synchronizer Differs Foreground", i18n("Differing foreground:"), SYNCHRONIZER_FOREGROUND_DEFAULTS[1], QString(), &KDEDefaultFore, 1);
     addColorSelector("Synchronizer Differs Background", i18n("Differing background:"), SYNCHRONIZER_BACKGROUND_DEFAULTS[1], QString(), &KDEDefaultBase, 1);
     addColorSelector("Synchronizer LeftCopy Foreground", i18n("Copy to left foreground:"), SYNCHRONIZER_FOREGROUND_DEFAULTS[2], QString(), &KDEDefaultFore, 1);
     addColorSelector("Synchronizer LeftCopy Background", i18n("Copy to left background:"), SYNCHRONIZER_BACKGROUND_DEFAULTS[2], QString(), &KDEDefaultBase, 1);
     addColorSelector("Synchronizer RightCopy Foreground", i18n("Copy to right foreground:"), SYNCHRONIZER_FOREGROUND_DEFAULTS[3], QString(), &KDEDefaultFore, 1);
     addColorSelector("Synchronizer RightCopy Background", i18n("Copy to right background:"), SYNCHRONIZER_BACKGROUND_DEFAULTS[3], QString(), &KDEDefaultBase, 1);
     addColorSelector("Synchronizer Delete Foreground", i18n("Delete foreground:"), SYNCHRONIZER_FOREGROUND_DEFAULTS[4], QString(), &KDEDefaultFore, 1);
     addColorSelector("Synchronizer Delete Background", i18n("Delete background:"), SYNCHRONIZER_BACKGROUND_DEFAULTS[4], QString(), &KDEDefaultBase, 1);
 
     colorsGrid->addWidget(createSpacer(colorsGrp), itemList.count() - offset, 1);
 #endif
 
     colorsGrp = new QWidget(colorTabWidget);
     otherTabIdx = colorTabWidget->addTab(colorsGrp, i18n("Other"));
 
     colorsGrid = new QGridLayout(colorsGrp);
     colorsGrid->setSpacing(0);
     colorsGrid->setContentsMargins(2, 2, 2, 2);
 
     offset = endOfPanelColors = itemList.count();
 
     addColorSelector("Quicksearch Match Foreground", i18n("Quicksearch, match foreground:"), Qt::black, QString(), &KDEDefaultFore, 1);
     addColorSelector("Quicksearch Match Background", i18n("Quicksearch, match background:"), QColor(192, 255, 192), QString(), &KDEDefaultBase, 1);
     addColorSelector("Quicksearch Non-match Foreground", i18n("Quicksearch, non-match foreground:"), Qt::black, QString(), &KDEDefaultFore, 1);
     addColorSelector("Quicksearch Non-match Background", i18n("Quicksearch, non-match background:"), QColor(255, 192, 192), QString(), &KDEDefaultBase, 1);
     ADDITIONAL_COLOR KDEDefaultWindowFore = { i18n("KDE default"), p.color(QPalette::Active, QPalette::WindowText), "KDE default" };
     ADDITIONAL_COLOR KDEDefaultWindowBack = { i18n("KDE default"), p.color(QPalette::Active, QPalette::Window), "KDE default" };
     addColorSelector("Statusbar Foreground Active", i18n("Statusbar, active foreground:"), p.color(QPalette::Active, QPalette::HighlightedText), QString(), &KDEDefaultWindowFore, 1);
     addColorSelector("Statusbar Background Active", i18n("Statusbar, active background:"), p.color(QPalette::Active, QPalette::Highlight), QString(), &KDEDefaultWindowBack, 1);
     addColorSelector("Statusbar Foreground Inactive", i18n("Statusbar, inactive foreground:"), p.color(QPalette::Inactive, QPalette::Text), QString(), &KDEDefaultWindowFore, 1);
     addColorSelector("Statusbar Background Inactive", i18n("Statusbar, inactive background:"), p.color(QPalette::Inactive, QPalette::Base), QString(), &KDEDefaultWindowBack, 1);
 
     colorsGrid->addWidget(createSpacer(colorsGrp), itemList.count() - offset, 1);
 
     colorsFrameGrid->addWidget(colorTabWidget, 0, 0);
     hbox->addWidget(colorsFrameGrp);
 
     //  -------------------------- PREVIEW GROUPBOX ----------------------------------
 
     previewGrp = createFrame(i18n("Preview"), hboxWidget);
     previewGrid = createGridLayout(previewGrp);
 
     preview = new KrTreeWidget(previewGrp);
     preview->setBackgroundRole(QPalette::Window);
     preview->setAutoFillBackground(true);
 
     QStringList labels;
     labels << i18n("Colors");
     preview->setHeaderLabels(labels);
 
     preview->header()->setSortIndicatorShown(false);
     preview->setSortingEnabled(false);
     preview->setEnabled(false);
 
     previewGrid->addWidget(preview, 0 , 0);
     hbox->addWidget(previewGrp);
 
     connect(generals->find("Enable Alternate Background"), &KonfiguratorCheckBox::stateChanged, this, &KgColors::generatePreview);
     connect(colorTabWidget, &QTabWidget::currentChanged, this, &KgColors::generatePreview);
     connect(dimFactor, QOverload<int>::of(&KonfiguratorSpinBox::valueChanged), this, &KgColors::generatePreview);
 
     kgColorsLayout->addWidget(hboxWidget, 1 , 0, 1,  3);
 
     importBtn = new QPushButton(i18n("Import color-scheme"), innerWidget);
     kgColorsLayout->addWidget(importBtn, 2, 0);
     exportBtn = new QPushButton(i18n("Export color-scheme"), innerWidget);
     kgColorsLayout->addWidget(exportBtn, 2, 1);
     kgColorsLayout->addWidget(createSpacer(innerWidget), 2, 2);
     connect(importBtn, &QPushButton::clicked, this, &KgColors::slotImportColors);
     connect(exportBtn, &QPushButton::clicked, this, &KgColors::slotExportColors);
 
     slotDisable();
 }
 
-int KgColors::addColorSelector(QString cfgName, QString name, QColor defaultValue, QString dfltName,
+int KgColors::addColorSelector(const QString& cfgName, QString name, QColor defaultValue, const QString& dfltName,
                                ADDITIONAL_COLOR *addColor, int addColNum)
 {
     int index = itemList.count() - offset;
 
-    labelList.append(addLabel(colorsGrid, index, 0, name, colorsGrp));
-    KonfiguratorColorChooser *chooser = createColorChooser("Colors", cfgName, defaultValue, colorsGrp, false, addColor, addColNum);
+    labelList.append(addLabel(colorsGrid, index, 0, std::move(name), colorsGrp));
+    KonfiguratorColorChooser *chooser = createColorChooser("Colors", cfgName, std::move(defaultValue), colorsGrp, false, addColor, addColNum);
     chooser->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
     if (!dfltName.isEmpty())
         chooser->setDefaultText(dfltName);
 
     colorsGrid->addWidget(chooser, index, 1);
 
     connect(chooser, &KonfiguratorColorChooser::colorChanged, this, &KgColors::generatePreview);
     if (!offset)
         connect(chooser, &KonfiguratorColorChooser::colorChanged, this, &KgColors::slotActiveChanged);
 
     itemList.append(chooser);
     itemNames.append(cfgName);
 
     return index;
 }
 
-KonfiguratorColorChooser *KgColors::getColorSelector(QString name)
+KonfiguratorColorChooser *KgColors::getColorSelector(const QString& name)
 {
     QList<QString>::iterator it;
     int position = 0;
 
     for (it = itemNames.begin(); it != itemNames.end(); it++, position++)
         if (*it == name)
             return itemList.at(position);
 
-    return 0;
+    return nullptr;
 }
 
-QLabel *KgColors::getSelectorLabel(QString name)
+QLabel *KgColors::getSelectorLabel(const QString& name)
 {
     QList<QString>::iterator it;
     int position = 0;
 
     for (it = itemNames.begin(); it != itemNames.end(); it++, position++)
         if (*it == name)
             return labelList.at(position);
 
-    return 0;
+    return nullptr;
 }
 
 void KgColors::slotDisable()
 {
     bool enabled = generals->find("KDE Default")->isChecked();
 
     importBtn->setEnabled(!enabled);
     exportBtn->setEnabled(!enabled);
 
     for (int i = 0; i < labelList.count() && i < endOfPanelColors ; i++)
         labelList.at(i)->setEnabled(!enabled);
 
     for (int j = 0; j < itemList.count() && j < endOfPanelColors ; j++)
         itemList.at(j)->setEnabled(!enabled);
 
     generals->find("Enable Alternate Background")->setEnabled(enabled);
     generals->find("Show Current Item Always")->setEnabled(!enabled);
     generals->find("Dim Inactive Colors")->setEnabled(!enabled);
 
     bool dimmed = !enabled && generals->find("Dim Inactive Colors")->isChecked();
     if (dimmed)
         inactiveColorStack->setCurrentWidget(dimmedInactiveWidget);
     else
         inactiveColorStack->setCurrentWidget(normalInactiveWidget);
 
     enabled = enabled || !generals->find("Show Current Item Always")->isChecked();
 
     getColorSelector("Inactive Current Foreground")->setEnabled(!enabled);
     getColorSelector("Inactive Current Background")->setEnabled(!enabled);
 
     generatePreview();
 }
 
 void KgColors::slotActiveChanged()
 {
     for (int i = 0; i != endOfActiveColors; i++)
         itemList.at(endOfActiveColors + i)->setDefaultColor(itemList.at(i)->getColor());
 }
 
 void KgColors::slotForegroundChanged()
 {
     QColor color = getColorSelector("Foreground")->getColor();
 
     getColorSelector("Directory Foreground")->setDefaultColor(color);
     getColorSelector("Executable Foreground")->setDefaultColor(color);
     getColorSelector("Symlink Foreground")->setDefaultColor(color);
     getColorSelector("Invalid Symlink Foreground")->setDefaultColor(color);
 }
 
 void KgColors::slotBackgroundChanged()
 {
     QColor color = getColorSelector("Background")->getColor();
 
     getColorSelector("Alternate Background")->changeAdditionalColor(0, color);
     getColorSelector("Marked Background")->changeAdditionalColor(0, color);
     getColorSelector("Current Background")->changeAdditionalColor(0, color);
 }
 
 void KgColors::slotAltBackgroundChanged()
 {
     QColor color = getColorSelector("Alternate Background")->getColor();
     getColorSelector("Alternate Marked Background")->changeAdditionalColor(0, color);
 }
 
 void KgColors::slotMarkedBackgroundChanged()
 {
     QColor color = getColorSelector("Marked Background")->getColor();
     getColorSelector("Alternate Marked Background")->setDefaultColor(color);
 }
 
 void KgColors::slotInactiveForegroundChanged()
 {
     QColor color = getColorSelector("Inactive Foreground")->getColor();
 
     getColorSelector("Inactive Directory Foreground")->changeAdditionalColor(0, color);
     getColorSelector("Inactive Executable Foreground")->changeAdditionalColor(0, color);
     getColorSelector("Inactive Symlink Foreground")->changeAdditionalColor(0, color);
     getColorSelector("Inactive Invalid Symlink Foreground")->changeAdditionalColor(0, color);
 }
 
 void KgColors::slotInactiveBackgroundChanged()
 {
     QColor color = getColorSelector("Inactive Background")->getColor();
 
     getColorSelector("Inactive Alternate Background")->changeAdditionalColor(0, color);
     getColorSelector("Inactive Marked Background")->changeAdditionalColor(0, color);
     getColorSelector("Inactive Current Background")->changeAdditionalColor(0, color);
 }
 
 void KgColors::slotInactiveAltBackgroundChanged()
 {
     QColor color = getColorSelector("Inactive Alternate Background")->getColor();
     getColorSelector("Inactive Alternate Marked Background")->changeAdditionalColor(0, color);
 }
 
 void KgColors::slotInactiveMarkedBackgroundChanged()
 {
     QColor color = getColorSelector("Inactive Marked Background")->getColor();
     getColorSelector("Inactive Alternate Marked Background")->changeAdditionalColor(1, color);
 }
 
 void KgColors::setColorWithDimming(PreviewItem * item, QColor foreground, QColor background, bool dimmed)
 {
     if (dimmed && dimFactor->value() < 100) {
         int dim = dimFactor->value();
         QColor dimColor = getColorSelector("Dim Target Color")->getColor();
 
         foreground = QColor((dimColor.red() * (100 - dim) + foreground.red() * dim) / 100,
                             (dimColor.green() * (100 - dim) + foreground.green() * dim) / 100,
                             (dimColor.blue() * (100 - dim) + foreground.blue() * dim) / 100);
         background = QColor((dimColor.red() * (100 - dim) + background.red() * dim) / 100,
                             (dimColor.green() * (100 - dim) + background.green() * dim) / 100,
                             (dimColor.blue() * (100 - dim) + background.blue() * dim) / 100);
     }
     item->setColor(foreground, background);
 }
 
 void KgColors::generatePreview()
 {
     const int currentPage = colorTabWidget->currentIndex();
 
     preview->clear();
 
     if (currentPage == activeTabIdx || currentPage == inactiveTabIdx) {
         PreviewItem *pwMarkCur = new PreviewItem(preview, i18n("Selected + Current"));
         PreviewItem *pwMark2   = new PreviewItem(preview, i18n("Selected 2"));
         PreviewItem *pwMark1   = new PreviewItem(preview, i18n("Selected 1"));
         PreviewItem *pwCurrent = new PreviewItem(preview, i18n("Current"));
         PreviewItem *pwInvLink = new PreviewItem(preview, i18n("Invalid symlink"));
         PreviewItem *pwSymLink = new PreviewItem(preview, i18n("Symbolic link"));
         PreviewItem *pwApp     = new PreviewItem(preview, i18n("Application"));
         PreviewItem *pwFile    = new PreviewItem(preview, i18n("File"));
         PreviewItem *pwDir     = new PreviewItem(preview, i18n("Folder"));
 
         bool isActive = currentPage == 0;
 
         // create local color cache instance, which does NOT affect the color cache instance using to paint the panels
         KrColorCache colCache;
 
         // create local color settings instance, which initially contains the settings from krConfig
         KrColorSettings colorSettings;
 
         // copy over local settings to color settings instance, which does not affect the persisted krConfig settings
         QList<QString> names = KrColorSettings::getColorNames();
-        for (QList<QString>::Iterator it = names.begin(); it != names.end(); ++it) {
-            KonfiguratorColorChooser * chooser = getColorSelector(*it);
+        for (auto & name : names) {
+            KonfiguratorColorChooser * chooser = getColorSelector(name);
             if (!chooser)
                 continue;
-            colorSettings.setColorTextValue(*it, chooser->getValue());
+            colorSettings.setColorTextValue(name, chooser->getValue());
             if (chooser->isValueRGB())
-                colorSettings.setColorValue(*it, chooser->getColor());
+                colorSettings.setColorValue(name, chooser->getColor());
             else
-                colorSettings.setColorValue(*it, QColor());
+                colorSettings.setColorValue(name, QColor());
         }
 
         colorSettings.setBoolValue("KDE Default", generals->find("KDE Default")->isChecked());
         colorSettings.setBoolValue("Enable Alternate Background", generals->find("Enable Alternate Background")->isChecked());
         colorSettings.setBoolValue("Show Current Item Always", generals->find("Show Current Item Always")->isChecked());
         colorSettings.setBoolValue("Dim Inactive Colors", generals->find("Dim Inactive Colors")->isChecked());
         colorSettings.setNumValue("Dim Factor", dimFactor->value());
 
         // let the color cache use the local color settings
         colCache.setColors(colorSettings);
 
         // ask the local color cache for certain color groups and use them to color the preview
         KrColorGroup cg;
 
         // setting the background color
         colCache.getColors(cg, KrColorItemType(KrColorItemType::File, false, isActive, false, false));
         QPalette pal = preview->palette();
         pal.setColor(QPalette::Base, cg.background());
         preview->setPalette(pal);
 
         colCache.getColors(cg, KrColorItemType(KrColorItemType::Directory, false, isActive, false, false));
         pwDir->setColor(cg.text(), cg.background());
         colCache.getColors(cg, KrColorItemType(KrColorItemType::File, true, isActive, false, false));
         pwFile->setColor(cg.text(), cg.background());
         colCache.getColors(cg, KrColorItemType(KrColorItemType::Executable, false, isActive, false, false));
         pwApp->setColor(cg.text(), cg.background());
         colCache.getColors(cg, KrColorItemType(KrColorItemType::Symlink, true, isActive, false, false));
         pwSymLink->setColor(cg.text(), cg.background());
         colCache.getColors(cg, KrColorItemType(KrColorItemType::InvalidSymlink, false, isActive, false, false));
         pwInvLink->setColor(cg.text(), cg.background());
         colCache.getColors(cg, KrColorItemType(KrColorItemType::File, true, isActive, true, false));
         pwCurrent->setColor(cg.text(), cg.background());
         colCache.getColors(cg, KrColorItemType(KrColorItemType::File, false, isActive, false, true));
         pwMark1->setColor(cg.highlightedText(), cg.highlight());
         colCache.getColors(cg, KrColorItemType(KrColorItemType::File, true, isActive, false, true));
         pwMark2->setColor(cg.highlightedText(), cg.highlight());
         colCache.getColors(cg, KrColorItemType(KrColorItemType::File, false, isActive, true, true));
         pwMarkCur->setColor(cg.highlightedText(), cg.highlight());
     }
 #ifdef SYNCHRONIZER_ENABLED
     else if (currentPage == synchronizerTabIdx) {
         PreviewItem *pwDelete    = new PreviewItem(preview, i18n("Delete"));
         PreviewItem *pwRightCopy = new PreviewItem(preview, i18n("Copy to right"));
         PreviewItem *pwLeftCopy  = new PreviewItem(preview, i18n("Copy to left"));
         PreviewItem *pwDiffers   = new PreviewItem(preview, i18n("Differing"));
         PreviewItem *pwEquals    = new PreviewItem(preview, i18n("Equals"));
 
         pwEquals->setColor(getColorSelector("Synchronizer Equals Foreground")->getColor(),
                            getColorSelector("Synchronizer Equals Background")->getColor());
         pwDiffers->setColor(getColorSelector("Synchronizer Differs Foreground")->getColor(),
                             getColorSelector("Synchronizer Differs Background")->getColor());
         pwLeftCopy->setColor(getColorSelector("Synchronizer LeftCopy Foreground")->getColor(),
                              getColorSelector("Synchronizer LeftCopy Background")->getColor());
         pwRightCopy->setColor(getColorSelector("Synchronizer RightCopy Foreground")->getColor(),
                               getColorSelector("Synchronizer RightCopy Background")->getColor());
         pwDelete->setColor(getColorSelector("Synchronizer Delete Foreground")->getColor(),
                            getColorSelector("Synchronizer Delete Background")->getColor());
     }
 #endif
     else if (currentPage == otherTabIdx) {
         PreviewItem *pwNonMatch = new PreviewItem(preview, i18n("Quicksearch non-match"));
         PreviewItem *pwMatch    = new PreviewItem(preview, i18n("Quicksearch match"));
         pwMatch->setColor(getColorSelector("Quicksearch Match Foreground")->getColor(),
                           getColorSelector("Quicksearch Match Background")->getColor());
         pwNonMatch->setColor(getColorSelector("Quicksearch Non-match Foreground")->getColor(),
                              getColorSelector("Quicksearch Non-match Background")->getColor());
         PreviewItem *pwStatusActive = new PreviewItem(preview, i18n("Statusbar active"));
         PreviewItem *pwStatusInactive = new PreviewItem(preview, i18n("Statusbar inactive"));
         pwStatusActive->setColor(getColorSelector("Statusbar Foreground Active")->getColor(),
                                  getColorSelector("Statusbar Background Active")->getColor());
         pwStatusInactive->setColor(getColorSelector("Statusbar Foreground Inactive")->getColor(),
                                    getColorSelector("Statusbar Background Inactive")->getColor());
     }
 }
 
 bool KgColors::apply()
 {
     bool result = KonfiguratorPage::apply();
     KrColorCache::getColorCache().refreshColors();
     return result;
 }
 
 void KgColors::slotImportColors()
 {
     // find $KDEDIR/share/apps/krusader
     QString basedir= QStandardPaths::locate(QStandardPaths::DataLocation, QStringLiteral("total_commander.keymap"));
     basedir = QFileInfo(basedir).absolutePath();
     // let the user select a file to load
-    QString file = QFileDialog::getOpenFileName(0, i18n("Select a color-scheme file"), basedir, QStringLiteral("*.color"));
+    QString file = QFileDialog::getOpenFileName(nullptr, i18n("Select a color-scheme file"), basedir, QStringLiteral("*.color"));
     if (file.isEmpty()) {
         return;
     }
     QFile f(file);
     if (!f.open(QIODevice::ReadOnly)) {
         KMessageBox::error(this, i18n("Error: unable to read from file"), i18n("Error"));
         return;
     }
     QDataStream stream(&f);
     // ok, import away
     deserialize(stream);
     generatePreview();
 }
 
 void KgColors::slotExportColors()
 {
-    QString file = QFileDialog::getSaveFileName(0, i18n("Select a color scheme file"), QString(), QStringLiteral("*"));
+    QString file = QFileDialog::getSaveFileName(nullptr, i18n("Select a color scheme file"), QString(), QStringLiteral("*"));
     if (file.isEmpty()) {
         return;
     }
     QFile f(file);
     if (f.exists() && KMessageBox::warningContinueCancel(this,
             i18n("File %1 already exists. Are you sure you want to overwrite it?", file),
             i18n("Warning"), KStandardGuiItem::overwrite()) != KMessageBox::Continue) return;
     if (!f.open(QIODevice::WriteOnly)) {
         KMessageBox::error(this, i18n("Error: unable to write to file"), i18n("Error"));
         return;
     }
     QDataStream stream(&f);
     serialize(stream);
 }
 
 void KgColors::serialize(QDataStream & stream)
 {
     serializeItem(stream, "Alternate Background");
     serializeItem(stream, "Alternate Marked Background");
     serializeItem(stream, "Background");
     serializeItem(stream, "Current Background");
     serializeItem(stream, "Current Foreground");
     serializeItem(stream, "Enable Alternate Background");
     serializeItem(stream, "Foreground");
     serializeItem(stream, "Directory Foreground");
     serializeItem(stream, "Executable Foreground");
     serializeItem(stream, "Symlink Foreground");
     serializeItem(stream, "Invalid Symlink Foreground");
     serializeItem(stream, "Inactive Alternate Background");
     serializeItem(stream, "Inactive Alternate Marked Background");
     serializeItem(stream, "Inactive Background");
     serializeItem(stream, "Inactive Current Foreground");
     serializeItem(stream, "Inactive Current Background");
     serializeItem(stream, "Inactive Marked Background");
     serializeItem(stream, "Inactive Marked Current Foreground");
     serializeItem(stream, "Inactive Marked Foreground");
     serializeItem(stream, "Inactive Foreground");
     serializeItem(stream, "Inactive Directory Foreground");
     serializeItem(stream, "Inactive Executable Foreground");
     serializeItem(stream, "Inactive Symlink Foreground");
     serializeItem(stream, "Inactive Invalid Symlink Foreground");
     serializeItem(stream, "Dim Inactive Colors");
     serializeItem(stream, "Dim Target Color");
     serializeItem(stream, "Dim Factor");
     serializeItem(stream, "KDE Default");
     serializeItem(stream, "Marked Background");
     serializeItem(stream, "Marked Current Foreground");
     serializeItem(stream, "Marked Foreground");
     serializeItem(stream, "Show Current Item Always");
 #ifdef SYNCHRONIZER_ENABLED
     serializeItem(stream, "Synchronizer Equals Foreground");
     serializeItem(stream, "Synchronizer Equals Background");
     serializeItem(stream, "Synchronizer Differs Foreground");
     serializeItem(stream, "Synchronizer Differs Background");
     serializeItem(stream, "Synchronizer LeftCopy Foreground");
     serializeItem(stream, "Synchronizer LeftCopy Background");
     serializeItem(stream, "Synchronizer RightCopy Foreground");
     serializeItem(stream, "Synchronizer RightCopy Background");
     serializeItem(stream, "Synchronizer Delete Foreground");
     serializeItem(stream, "Synchronizer Delete Background");
 #endif
     serializeItem(stream, "Quicksearch Match Foreground");
     serializeItem(stream, "Quicksearch Match Background");
     serializeItem(stream, "Quicksearch Non-match Foreground");
     serializeItem(stream, "Quicksearch Non-match Background");
     serializeItem(stream, "Statusbar Foreground Active");
     serializeItem(stream, "Statusbar Background Active");
     serializeItem(stream, "Statusbar Foreground Inactive");
     serializeItem(stream, "Statusbar Background Inactive");
     stream << QString("") << QString("");
 }
 
 void KgColors::deserialize(QDataStream & stream)
 {
     for (;;) {
         QString name;
         QString value;
         stream >> name >> value;
         if (name.isEmpty())
             break;
 
         if (name == "KDE Default" || name == "Enable Alternate Background" ||
                 name == "Show Current Item Always" || name == "Dim Inactive Colors") {
             bool bValue = false;
             value = value.toLower();
             if (value == "true" || value == "yes" || value == "on" || value == "1")
                 bValue = true;
 
             generals->find(name)->setChecked(bValue);
             continue;
         }
 
         if (name == "Dim Factor") {
             dimFactor->setValue(value.toInt());
             continue;
         }
 
         KonfiguratorColorChooser *selector = getColorSelector(name);
-        if (selector == 0)
+        if (selector == nullptr)
             break;
         selector->setValue(value);
     }
 }
 
 void KgColors::serializeItem(class QDataStream & stream, const char * name)
 {
     stream << QString(name);
     if (strcmp(name, "KDE Default") == 0 || strcmp(name, "Enable Alternate Background") == 0 ||
             strcmp(name, "Show Current Item Always") == 0 || strcmp(name, "Dim Inactive Colors") == 0) {
         bool bValue = generals->find(name)->isChecked();
         stream << QString(bValue ? "true" : "false");
     } else if (strcmp(name, "Dim Factor") == 0)
         stream << QString::number(dimFactor->value());
     else {
         KonfiguratorColorChooser *selector = getColorSelector(name);
         stream << selector->getValue();
     }
 }
 
diff --git a/krusader/Konfigurator/kgcolors.h b/krusader/Konfigurator/kgcolors.h
index 7dc8b3de..a7614568 100644
--- a/krusader/Konfigurator/kgcolors.h
+++ b/krusader/Konfigurator/kgcolors.h
@@ -1,140 +1,141 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGCOLORS_H
 #define KGCOLORS_H
 
 // QtCore
 #include <QList>
 // QtWidgets
 #include <QStackedWidget>
 #include <QGridLayout>
 #include <QLabel>
 #include <QPushButton>
 
 #include "konfiguratorpage.h"
 #include "../GUI/krtreewidget.h"
 
 class KgColors : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgColors(bool first, QWidget* parent = 0);
+    explicit KgColors(bool first, QWidget* parent = nullptr);
 
-    virtual bool apply() Q_DECL_OVERRIDE;
+    bool apply() Q_DECL_OVERRIDE;
 
 public slots:
     void slotDisable();
     void slotForegroundChanged();
     void slotBackgroundChanged();
     void slotAltBackgroundChanged();
     void slotActiveChanged();
     void slotMarkedBackgroundChanged();
     void slotInactiveForegroundChanged();
     void slotInactiveBackgroundChanged();
     void slotInactiveAltBackgroundChanged();
     void slotInactiveMarkedBackgroundChanged();
     void generatePreview();
 
 protected slots:
     void slotImportColors();
     void slotExportColors();
 
 private:
     class PreviewItem;
 
-    int                        addColorSelector(QString cfgName, QString name, QColor defaultValue, QString dfltName = QString(),
-            ADDITIONAL_COLOR *addColor = 0, int addColNum = 0);
-    KonfiguratorColorChooser  *getColorSelector(QString name);
-    QLabel                    *getSelectorLabel(QString name);
+    int                        addColorSelector(const QString& cfgName, QString name, QColor defaultValue, const QString& dfltName = QString(),
+            ADDITIONAL_COLOR *addColor = nullptr, int addColNum = 0);
+    KonfiguratorColorChooser  *getColorSelector(const QString& name);
+    QLabel                    *getSelectorLabel(const QString& name);
     void                       serialize(class QDataStream &);
     void                       deserialize(class QDataStream &);
     void                       serializeItem(class QDataStream &, const char * name);
     void                       setColorWithDimming(PreviewItem * item, QColor foreground, QColor background, bool dimmed);
 
 private:
     QWidget                            *colorsGrp;
     QGridLayout                        *colorsGrid;
     int                                 offset;
     int                                 endOfActiveColors;
     int                                 endOfPanelColors;
     int                                 activeTabIdx, inactiveTabIdx;
 #ifdef SYNCHRONIZER_ENABLED
     int                                 synchronizerTabIdx;
 #endif
     int                                 otherTabIdx;
 
     QGroupBox                          *previewGrp;
     QGridLayout                        *previewGrid;
     QTabWidget                         *colorTabWidget;
 
     QStackedWidget                     *inactiveColorStack;
     QWidget                            *normalInactiveWidget;
     QWidget                            *dimmedInactiveWidget;
     KonfiguratorSpinBox                *dimFactor;
 
     KonfiguratorCheckBoxGroup          *generals;
 
     QList<QLabel *>                     labelList;
     QList<KonfiguratorColorChooser *>   itemList;
     QList<QString>                      itemNames;
 
     KrTreeWidget                       *preview;
     QPushButton *importBtn, *exportBtn;
 
     class PreviewItem : public QTreeWidgetItem
     {
     private:
         QColor  defaultBackground;
         QColor  defaultForeground;
         QString label;
 
     public:
-        PreviewItem(QTreeWidget * parent, QString name) : QTreeWidgetItem() {
+        PreviewItem(QTreeWidget * parent, const QString& name)
+        {
             setText(0, name);
             defaultBackground = QColor(255, 255, 255);
             defaultForeground = QColor(0, 0, 0);
             label = name;
             parent->insertTopLevelItem(0, this);
         }
 
-        void setColor(QColor foregnd, QColor backgnd) {
+        void setColor(const QColor& foregnd, const QColor& backgnd) {
             defaultForeground = foregnd;
             defaultBackground = backgnd;
 
 
             QBrush textColor(foregnd);
             QBrush baseColor(backgnd);
 
             for (int i = 0; i != columnCount(); i++) {
                 if (backgnd.isValid())
                     setBackground(i, baseColor);
                 if (foregnd.isValid())
                     setForeground(i, textColor);
             }
         }
 
         QString text() {
             return label;
         }
     };
 };
 #endif /* __KGCOLORS_H__ */
diff --git a/krusader/Konfigurator/kgdependencies.cpp b/krusader/Konfigurator/kgdependencies.cpp
index ab83db83..55ef4b1a 100644
--- a/krusader/Konfigurator/kgdependencies.cpp
+++ b/krusader/Konfigurator/kgdependencies.cpp
@@ -1,172 +1,172 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kgdependencies.h"
 #include "../krservices.h"
 #include "../krglobal.h"
 
 // QtCore
 #include <QUrl>
 // QtWidgets
 #include <QTabWidget>
 #include <QGridLayout>
 #include <QScrollArea>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #define PAGE_GENERAL   0
 #define PAGE_PACKERS   1
 #define PAGE_CHECKSUM  2
 
 KgDependencies::KgDependencies(bool first, QWidget* parent) :
         KonfiguratorPage(first, parent)
 {
-    QGridLayout *kgDependenciesLayout = new QGridLayout(this);
+    auto *kgDependenciesLayout = new QGridLayout(this);
     kgDependenciesLayout->setSpacing(6);
 
     //  ---------------------------- GENERAL TAB -------------------------------------
     tabWidget = new QTabWidget(this);
 
     QWidget *general_tab = new QWidget(tabWidget);
-    QScrollArea* general_scroll = new QScrollArea(tabWidget);
+    auto* general_scroll = new QScrollArea(tabWidget);
     general_scroll->setFrameStyle(QFrame::NoFrame);
     general_scroll->setWidget(general_tab);   // this also sets scrollacrea as the new parent for widget
     general_scroll->setWidgetResizable(true);   // let the widget use every space available
     tabWidget->addTab(general_scroll, i18n("General"));
 
-    QGridLayout *pathsGrid = new QGridLayout(general_tab);
+    auto *pathsGrid = new QGridLayout(general_tab);
     pathsGrid->setSpacing(6);
     pathsGrid->setContentsMargins(11, 11, 11, 11);
     pathsGrid->setAlignment(Qt::AlignTop);
 
     addApplication("kget",     pathsGrid, 0, general_tab, PAGE_GENERAL);
     addApplication("mailer",   pathsGrid, 1, general_tab, PAGE_GENERAL);
     addApplication("diff utility",  pathsGrid, 2, general_tab, PAGE_GENERAL);
     addApplication("krename",  pathsGrid, 3, general_tab, PAGE_GENERAL);
     addApplication("locate",   pathsGrid, 4, general_tab, PAGE_GENERAL);
     addApplication("mount",    pathsGrid, 5, general_tab, PAGE_GENERAL);
     addApplication("umount",   pathsGrid, 6, general_tab, PAGE_GENERAL);
     addApplication("updatedb", pathsGrid, 7, general_tab, PAGE_GENERAL);
 
     //  ---------------------------- PACKERS TAB -------------------------------------
     QWidget *packers_tab = new QWidget(tabWidget);
-    QScrollArea* packers_scroll = new QScrollArea(tabWidget);
+    auto* packers_scroll = new QScrollArea(tabWidget);
     packers_scroll->setFrameStyle(QFrame::NoFrame);
     packers_scroll->setWidget(packers_tab);   // this also sets scrollacrea as the new parent for widget
     packers_scroll->setWidgetResizable(true);   // let the widget use every space available
     tabWidget->addTab(packers_scroll, i18n("Packers"));
 
-    QGridLayout *archGrid1 = new QGridLayout(packers_tab);
+    auto *archGrid1 = new QGridLayout(packers_tab);
     archGrid1->setSpacing(6);
     archGrid1->setContentsMargins(11, 11, 11, 11);
     archGrid1->setAlignment(Qt::AlignTop);
 
     addApplication("7z",    archGrid1, 0, packers_tab, PAGE_PACKERS, "7za");
     addApplication("arj",   archGrid1, 1, packers_tab, PAGE_PACKERS);
     addApplication("bzip2", archGrid1, 2, packers_tab, PAGE_PACKERS);
     addApplication("cpio",  archGrid1, 3, packers_tab, PAGE_PACKERS);
     addApplication("dpkg",  archGrid1, 4, packers_tab, PAGE_PACKERS);
     addApplication("gzip",  archGrid1, 5, packers_tab, PAGE_PACKERS);
     addApplication("lha",   archGrid1, 6, packers_tab, PAGE_PACKERS);
     addApplication("lzma",  archGrid1, 7, packers_tab, PAGE_PACKERS);
     addApplication("rar",   archGrid1, 8, packers_tab, PAGE_PACKERS);
     addApplication("tar",   archGrid1, 9, packers_tab, PAGE_PACKERS);
     addApplication("unace", archGrid1, 10, packers_tab, PAGE_PACKERS);
     addApplication("unarj", archGrid1, 11, packers_tab, PAGE_PACKERS);
     addApplication("unrar", archGrid1, 12, packers_tab, PAGE_PACKERS);
     addApplication("unzip", archGrid1, 13, packers_tab, PAGE_PACKERS);
     addApplication("zip",   archGrid1, 14, packers_tab, PAGE_PACKERS);
     addApplication("xz",    archGrid1, 15, packers_tab, PAGE_PACKERS);
 
     //  ---------------------------- CHECKSUM TAB -------------------------------------
     QWidget *checksum_tab = new QWidget(tabWidget);
-    QScrollArea* checksum_scroll = new QScrollArea(tabWidget);
+    auto* checksum_scroll = new QScrollArea(tabWidget);
     checksum_scroll->setFrameStyle(QFrame::NoFrame);
     checksum_scroll->setWidget(checksum_tab);   // this also sets scrollacrea as the new parent for widget
     checksum_scroll->setWidgetResizable(true);   // let the widget use every space available
     tabWidget->addTab(checksum_scroll, i18n("Checksum Utilities"));
 
-    QGridLayout *archGrid2 = new QGridLayout(checksum_tab);
+    auto *archGrid2 = new QGridLayout(checksum_tab);
     archGrid2->setSpacing(6);
     archGrid2->setContentsMargins(11, 11, 11, 11);
     archGrid2->setAlignment(Qt::AlignTop);
 
     addApplication("md5sum",         archGrid2, 0, checksum_tab, PAGE_CHECKSUM);
     addApplication("sha1sum",        archGrid2, 1, checksum_tab, PAGE_CHECKSUM);
     addApplication("sha224sum",      archGrid2, 2, checksum_tab, PAGE_CHECKSUM);
     addApplication("sha256sum",      archGrid2, 3, checksum_tab, PAGE_CHECKSUM);
     addApplication("sha384sum",      archGrid2, 4, checksum_tab, PAGE_CHECKSUM);
     addApplication("sha512sum",      archGrid2, 5, checksum_tab, PAGE_CHECKSUM);
 
     kgDependenciesLayout->addWidget(tabWidget, 0, 0);
 }
 
-void KgDependencies::addApplication(QString name, QGridLayout *grid, int row, QWidget *parent,
-                                    int page, QString additionalList)
+void KgDependencies::addApplication(const QString& name, QGridLayout *grid, int row, QWidget *parent,
+                                    int page, const QString& additionalList)
 {
     // try to autodetect the full path name
     QString defaultValue = KrServices::fullPathName(name);
 
     if (defaultValue.isEmpty()) {
         QStringList list = additionalList.split(',', QString::SkipEmptyParts);
         for (int i = 0; i != list.count(); i++)
             if (!KrServices::fullPathName(list[ i ]).isEmpty()) {
                 defaultValue = KrServices::fullPathName(list[ i ]);
                 break;
             }
     }
 
     addLabel(grid, row, 0, name, parent);
 
     KonfiguratorURLRequester *fullPath =
         createURLRequester("Dependencies", name, defaultValue, parent, false, page);
     connect(fullPath->extension(), &KonfiguratorExtension::applyManually, this, &KgDependencies::slotApply);
     grid->addWidget(fullPath, row, 1);
 }
 
-void KgDependencies::slotApply(QObject *obj, QString configGroup, QString name)
+void KgDependencies::slotApply(QObject *obj, const QString& configGroup, const QString& name)
 {
-    KonfiguratorURLRequester *urlRequester = (KonfiguratorURLRequester *) obj;
+    auto *urlRequester = (KonfiguratorURLRequester *) obj;
 
     KConfigGroup group(krConfig, configGroup);
     group.writeEntry(name, urlRequester->url().toDisplayString(QUrl::PreferLocalFile));
 
     QString usedPath = KrServices::fullPathName(name);
 
     if (urlRequester->url().toDisplayString(QUrl::PreferLocalFile) != usedPath) {
         group.writeEntry(name, usedPath);
         if (usedPath.isEmpty())
             KMessageBox::error(this,
                                i18n("The %1 path is incorrect, no valid path found.",
                                     urlRequester->url().toDisplayString(QUrl::PreferLocalFile)));
         else
             KMessageBox::error(
                 this, i18n("The %1 path is incorrect, %2 used instead.",
                            urlRequester->url().toDisplayString(QUrl::PreferLocalFile), usedPath));
         urlRequester->setUrl(QUrl::fromLocalFile(usedPath));
     }
 }
 
 int KgDependencies::activeSubPage()
 {
     return tabWidget->currentIndex();
 }
diff --git a/krusader/Konfigurator/kgdependencies.h b/krusader/Konfigurator/kgdependencies.h
index 7768ef2f..412d3463 100644
--- a/krusader/Konfigurator/kgdependencies.h
+++ b/krusader/Konfigurator/kgdependencies.h
@@ -1,51 +1,51 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGDEPENDENCIES_H
 #define KGDEPENDENCIES_H
 
 // QtWidgets
 #include <QGridLayout>
 
 #include "konfiguratorpage.h"
 
 class QTabWidget;
 
 
 class KgDependencies : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgDependencies(bool first, QWidget* parent = 0);
+    explicit KgDependencies(bool first, QWidget* parent = nullptr);
 
-    virtual int activeSubPage() Q_DECL_OVERRIDE;
+    int activeSubPage() Q_DECL_OVERRIDE;
 
 private:
-    void addApplication(QString name, QGridLayout *grid, int row, QWidget *parent, int page, QString additionalList = QString());
+    void addApplication(const QString& name, QGridLayout *grid, int row, QWidget *parent, int page, const QString& additionalList = QString());
 
 public slots:
-    void slotApply(QObject *obj, QString configGroup, QString name);
+    void slotApply(QObject *obj, const QString& configGroup, const QString& name);
 
 private:
     QTabWidget *tabWidget;
 };
 
 #endif /* __KGDEPENDENCIES_H__ */
diff --git a/krusader/Konfigurator/kggeneral.cpp b/krusader/Konfigurator/kggeneral.cpp
index c110766e..ce221309 100644
--- a/krusader/Konfigurator/kggeneral.cpp
+++ b/krusader/Konfigurator/kggeneral.cpp
@@ -1,329 +1,329 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kggeneral.h"
 
 // QtCore
 #include <QPointer>
 // QtGui
 #include <QPixmap>
 #include <QFontMetrics>
 // QtWidgets
 #include <QFrame>
 #include <QGridLayout>
 #include <QInputDialog>
 #include <QLabel>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "krresulttabledialog.h"
 #include "../defaults.h"
 #include "../icon.h"
 #include "../krglobal.h"
 
 #define PAGE_GENERAL        0
 #define PAGE_VIEWER         1
 #define PAGE_EXTENSIONS     2
 
 KgGeneral::KgGeneral(bool first, QWidget* parent) :
         KonfiguratorPage(first, parent)
 {
     if (first)
         slotFindTools();
 
     tabWidget = new QTabWidget(this);
     setWidget(tabWidget);
     setWidgetResizable(true);
 
     createGeneralTab();
     createViewerTab();
     createExtensionsTab();
 }
 
-QWidget* KgGeneral::createTab(QString name)
+QWidget* KgGeneral::createTab(const QString& name)
 {
-    QScrollArea *scrollArea = new QScrollArea(tabWidget);
+    auto *scrollArea = new QScrollArea(tabWidget);
     tabWidget->addTab(scrollArea, name);
     scrollArea->setFrameStyle(QFrame::NoFrame);
     scrollArea->setWidgetResizable(true);
 
     QWidget *tab = new QWidget(scrollArea);
     scrollArea->setWidget(tab);
 
     return tab;
 }
 
 void KgGeneral::createViewerTab()
 {
     QWidget *tab = createTab(i18n("Viewer/Editor"));
-    QGridLayout *tabLayout = new QGridLayout(tab);
+    auto *tabLayout = new QGridLayout(tab);
     tabLayout->setSpacing(6);
     tabLayout->setContentsMargins(11, 11, 11, 11);
 
     tabLayout->addWidget(createCheckBox("General", "View In Separate Window", _ViewInSeparateWindow,
                                    i18n("Internal editor and viewer opens each file in a separate window"), tab, false,
                                    i18n("If checked, each file will open in a separate window, otherwise, the viewer will work in a single, tabbed mode"), PAGE_VIEWER));
 
     // ------------------------- viewer ----------------------------------
 
     QGroupBox *viewerGrp = createFrame(i18n("Viewer"), tab);
     tabLayout->addWidget(viewerGrp, 1, 0);
 
     QGridLayout *viewerGrid = createGridLayout(viewerGrp);
 
     QWidget * hboxWidget2 = new QWidget(viewerGrp);
-    QHBoxLayout * hbox2 = new QHBoxLayout(hboxWidget2);
+    auto * hbox2 = new QHBoxLayout(hboxWidget2);
 
     QWidget * vboxWidget = new QWidget(hboxWidget2);
-    QVBoxLayout * vbox = new QVBoxLayout(vboxWidget);
+    auto * vbox = new QVBoxLayout(vboxWidget);
 
     vbox->addWidget(new QLabel(i18n("Default viewer mode:"), vboxWidget));
 
     KONFIGURATOR_NAME_VALUE_TIP viewMode[] =
         //            name            value    tooltip
     {{ i18n("Generic mode"),  "generic", i18n("Use the system's default viewer") },
         { i18n("Text mode"), "text",  i18n("View the file in text-only mode") },
         { i18n("Hex mode"), "hex",  i18n("View the file in hex-mode (better for binary files)") },
         { i18n("Lister mode"), "lister",  i18n("View the file with lister (for huge text files)") }
     };
 
     vbox->addWidget(createRadioButtonGroup("General", "Default Viewer Mode",
                                            "generic", 0, 4, viewMode, 4, vboxWidget, false, PAGE_VIEWER));
 
 
     vbox->addWidget(
         createCheckBox("General", "UseOktetaViewer", _UseOktetaViewer, i18n("Use Okteta as Hex viewer"), vboxWidget, false,
                        i18n("If available, use Okteta as Hex viewer instead of the internal viewer"), PAGE_VIEWER)
                    );
 
     QWidget * hboxWidget4 = new QWidget(vboxWidget);
-    QHBoxLayout * hbox4 = new QHBoxLayout(hboxWidget4);
+    auto * hbox4 = new QHBoxLayout(hboxWidget4);
 
     QLabel *label5 = new QLabel(i18n("Use lister if the text file is bigger than:"), hboxWidget4);
     hbox4->addWidget(label5);
     KonfiguratorSpinBox *spinBox = createSpinBox("General", "Lister Limit", _ListerLimit,
                                    0, 0x7FFFFFFF, hboxWidget4, false, PAGE_VIEWER);
     hbox4->addWidget(spinBox);
     QLabel *label6 = new QLabel(i18n("MB"), hboxWidget4);
     hbox4->addWidget(label6);
 
     vbox->addWidget(hboxWidget4);
 
     hbox2->addWidget(vboxWidget);
 
     viewerGrid->addWidget(hboxWidget2, 0, 0);
 
 
     // ------------------------- editor ----------------------------------
 
     QGroupBox *editorGrp = createFrame(i18n("Editor"), tab);
     tabLayout->addWidget(editorGrp, 2, 0);
     QGridLayout *editorGrid = createGridLayout(editorGrp);
 
     QLabel *label1 = new QLabel(i18n("Editor:"), editorGrp);
     editorGrid->addWidget(label1, 0, 0);
     KonfiguratorURLRequester *urlReq = createURLRequester("General", "Editor", "internal editor",
                                        editorGrp, false, PAGE_VIEWER, false);
     editorGrid->addWidget(urlReq, 0, 1);
 
     QLabel *label2 = new QLabel(i18n("Hint: use 'internal editor' if you want to use Krusader's fast built-in editor"), editorGrp);
     editorGrid->addWidget(label2, 1, 0, 1, 2);
 }
 
 void KgGeneral::createExtensionsTab()
 {
     // ------------------------- atomic extensions ----------------------------------
 
     QWidget *tab = createTab(i18n("Atomic extensions"));
-    QGridLayout *tabLayout = new QGridLayout(tab);
+    auto *tabLayout = new QGridLayout(tab);
     tabLayout->setSpacing(6);
     tabLayout->setContentsMargins(11, 11, 11, 11);
 
     QWidget * vboxWidget2 = new QWidget(tab);
     tabLayout->addWidget(vboxWidget2);
 
-    QVBoxLayout * vbox2 = new QVBoxLayout(vboxWidget2);
+    auto * vbox2 = new QVBoxLayout(vboxWidget2);
 
     QWidget * hboxWidget3 = new QWidget(vboxWidget2);
     vbox2->addWidget(hboxWidget3);
 
-    QHBoxLayout * hbox3 = new QHBoxLayout(hboxWidget3);
+    auto * hbox3 = new QHBoxLayout(hboxWidget3);
 
     QLabel * atomLabel = new QLabel(i18n("Atomic extensions:"), hboxWidget3);
     hbox3->addWidget(atomLabel);
 
     int size = QFontMetrics(atomLabel->font()).height();
 
-    QToolButton *addButton = new QToolButton(hboxWidget3);
+    auto *addButton = new QToolButton(hboxWidget3);
     hbox3->addWidget(addButton);
 
     QPixmap iconPixmap = Icon("list-add").pixmap(size);
     addButton->setFixedSize(iconPixmap.width() + 4, iconPixmap.height() + 4);
     addButton->setIcon(QIcon(iconPixmap));
     connect(addButton, &QToolButton::clicked, this, &KgGeneral::slotAddExtension);
 
-    QToolButton *removeButton = new QToolButton(hboxWidget3);
+    auto *removeButton = new QToolButton(hboxWidget3);
     hbox3->addWidget(removeButton);
 
     iconPixmap = Icon("list-remove").pixmap(size);
     removeButton->setFixedSize(iconPixmap.width() + 4, iconPixmap.height() + 4);
     removeButton->setIcon(QIcon(iconPixmap));
     connect(removeButton, &QToolButton::clicked, this, &KgGeneral::slotRemoveExtension);
 
     QStringList defaultAtomicExtensions;
     defaultAtomicExtensions += ".tar.gz";
     defaultAtomicExtensions += ".tar.bz2";
     defaultAtomicExtensions += ".tar.lzma";
     defaultAtomicExtensions += ".tar.xz";
     defaultAtomicExtensions += ".moc.cpp";
 
     listBox = createListBox("Look&Feel", "Atomic Extensions",
                             defaultAtomicExtensions, vboxWidget2, true, PAGE_EXTENSIONS);
     vbox2->addWidget(listBox);
 }
 
 
 void KgGeneral::createGeneralTab()
 {
     QWidget *tab = createTab(i18n("General"));
-    QGridLayout *kgGeneralLayout = new QGridLayout(tab);
+    auto *kgGeneralLayout = new QGridLayout(tab);
     kgGeneralLayout->setSpacing(6);
     kgGeneralLayout->setContentsMargins(11, 11, 11, 11);
 
 
     //  -------------------------- GENERAL GROUPBOX ----------------------------------
 
     QGroupBox *generalGrp = createFrame(i18n("General"), tab);
     QGridLayout *generalGrid = createGridLayout(generalGrp);
 
 
 
     KONFIGURATOR_CHECKBOX_PARAM settings[] = { //   cfg_class  cfg_name                default             text                              restart tooltip
         {"Look&Feel", "Warn On Exit",         _WarnOnExit,        i18n("Warn on exit"),           false,  i18n("Display a warning when trying to close the main window.") },    // KDE4: move warn on exit to the other confirmations
         {"Look&Feel", "Minimize To Tray",     _ShowTrayIcon,      i18n("Show and close to tray"), false,  i18n("Show an icon in the system tray and keep running in the background when the window is closed.") },
     };
     KonfiguratorCheckBoxGroup *cbs = createCheckBoxGroup(2, 0, settings, 2 /*count*/, generalGrp, PAGE_GENERAL);
     generalGrid->addWidget(cbs, 0, 0);
 
     // temp dir
 
-    QHBoxLayout *hbox = new QHBoxLayout();
+    auto *hbox = new QHBoxLayout();
 
     hbox->addWidget(new QLabel(i18n("Temp Folder:"), generalGrp));
     KonfiguratorURLRequester *urlReq3 = createURLRequester("General", "Temp Directory", _TempDirectory,
                                         generalGrp, false, PAGE_GENERAL);
     urlReq3->setMode(KFile::Directory);
     connect(urlReq3->extension(), &KonfiguratorExtension::applyManually, this, &KgGeneral::applyTempDir);
     hbox->addWidget(urlReq3);
     generalGrid->addLayout(hbox, 13, 0, 1, 1);
 
     QLabel *label4 = new QLabel(i18n("Note: you must have full permissions for the temporary folder."),
                                 generalGrp);
     generalGrid->addWidget(label4, 14, 0, 1, 1);
 
 
     kgGeneralLayout->addWidget(generalGrp, 0 , 0);
 
 
     // ----------------------- delete mode --------------------------------------
 
     QGroupBox *delGrp = createFrame(i18n("Delete mode"), tab);
     QGridLayout *delGrid = createGridLayout(delGrp);
 
     KONFIGURATOR_NAME_VALUE_TIP deleteMode[] =
         //            name            value    tooltip
         {{i18n("Move to trash"), "true", i18n("Files will be moved to trash when deleted.")},
          {i18n("Delete files"), "false", i18n("Files will be permanently deleted.")}
         };
     KonfiguratorRadioButtons *trashRadio = createRadioButtonGroup("General", "Move To Trash",
                                            _MoveToTrash ? "true" : "false", 2, 0, deleteMode, 2, delGrp, false, PAGE_GENERAL);
     delGrid->addWidget(trashRadio);
 
     kgGeneralLayout->addWidget(delGrp, 1 , 0);
 
 
     // ----------------------- terminal -----------------------------------------
 
     QGroupBox *terminalGrp = createFrame(i18n("Terminal"), tab);
     QGridLayout *terminalGrid = createGridLayout(terminalGrp);
 
     QLabel *label3 = new QLabel(i18n("External Terminal:"), generalGrp);
     terminalGrid->addWidget(label3, 0, 0);
     KonfiguratorURLRequester *urlReq2 = createURLRequester("General", "Terminal", _Terminal,
                                         generalGrp, false, PAGE_GENERAL, false);
     terminalGrid->addWidget(urlReq2, 0, 1);
     QLabel *terminalLabel = new QLabel(i18n("%d will be replaced by the workdir."),
                                        terminalGrp);
     terminalGrid->addWidget(terminalLabel, 1, 1);
 
     KONFIGURATOR_CHECKBOX_PARAM terminal_settings[] = { //   cfg_class  cfg_name     default        text            restart tooltip
         {"General", "Send CDs", _SendCDs, i18n("Embedded Terminal sends Chdir on panel change"), false, i18n("When checked, whenever the panel is changed (for example, by pressing Tab), Krusader changes the current folder in the embedded terminal.") },
     };
     cbs = createCheckBoxGroup(1, 0, terminal_settings, 1 /*count*/, terminalGrp, PAGE_GENERAL);
     terminalGrid->addWidget(cbs, 2, 0, 1, 2);
 
 
     kgGeneralLayout->addWidget(terminalGrp, 2 , 0);
 }
 
-void KgGeneral::applyTempDir(QObject *obj, QString configGroup, QString name)
+void KgGeneral::applyTempDir(QObject *obj, const QString& configGroup, const QString& name)
 {
-    KonfiguratorURLRequester *urlReq = (KonfiguratorURLRequester *)obj;
+    auto *urlReq = (KonfiguratorURLRequester *)obj;
     QString value = urlReq->url().toDisplayString(QUrl::PreferLocalFile);
 
     KConfigGroup(krConfig, configGroup).writeEntry(name, value);
 }
 
 void KgGeneral::slotFindTools()
 {
     QPointer<KrResultTableDialog> dlg = new KrResultTableDialog(this,
             KrResultTableDialog::Tool,
             i18n("Search results"),
             i18n("Searching for tools..."),
             "tools-wizard",
             i18n("Make sure to install new tools in your <code>$PATH</code> (e.g. /usr/bin)"));
     dlg->exec();
     delete dlg;
 }
 
 void KgGeneral::slotAddExtension()
 {
     bool ok;
     QString atomExt = QInputDialog::getText(this, i18n("Add new atomic extension"), i18n("Extension:"),
                                             QLineEdit::Normal, QString(), &ok);
 
     if (ok) {
         if (!atomExt.startsWith('.') || atomExt.indexOf('.', 1) == -1)
             KMessageBox::error(krMainWindow, i18n("Atomic extensions must start with '.' and must contain at least one more '.' character."), i18n("Error"));
         else
             listBox->addItem(atomExt);
     }
 }
 
 void KgGeneral::slotRemoveExtension()
 {
     QList<QListWidgetItem *> list = listBox->selectedItems();
 
     for (int i = 0; i != list.count(); i++)
         listBox->removeItem(list[ i ]->text());
 }
 
diff --git a/krusader/Konfigurator/kggeneral.h b/krusader/Konfigurator/kggeneral.h
index 674c05b9..2a366f19 100644
--- a/krusader/Konfigurator/kggeneral.h
+++ b/krusader/Konfigurator/kggeneral.h
@@ -1,50 +1,50 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGGENERAL_H
 #define KGGENERAL_H
 
 #include "konfiguratorpage.h"
 
 class KgGeneral : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgGeneral(bool first, QWidget* parent = 0);
+    explicit KgGeneral(bool first, QWidget* parent = nullptr);
 
 public slots:
-    void  applyTempDir(QObject *, QString, QString);
+    void  applyTempDir(QObject *, const QString&, const QString&);
     void  slotFindTools();
 
     void  slotAddExtension();
     void  slotRemoveExtension();
 
 private:
     void createGeneralTab();
     void createViewerTab();
     void createExtensionsTab();
-    QWidget* createTab(QString name);
+    QWidget* createTab(const QString& name);
 
     QTabWidget *tabWidget;
     KonfiguratorListBox *listBox;
 };
 
 #endif /* __KGGENERAL_H__ */
diff --git a/krusader/Konfigurator/kgpanel.cpp b/krusader/Konfigurator/kgpanel.cpp
index 93b1c6de..103eed27 100644
--- a/krusader/Konfigurator/kgpanel.cpp
+++ b/krusader/Konfigurator/kgpanel.cpp
@@ -1,745 +1,745 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kgpanel.h"
 #include "../defaults.h"
 #include "../Dialogs/krdialogs.h"
 
 // QtGui
 #include <QValidator>
 // QtWidgets
 #include <QTabWidget>
 #include <QFrame>
 #include <QGridLayout>
 #include <QLabel>
 #include <QVBoxLayout>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "../GUI/krtreewidget.h"
 #include "../Panel/krsearchbar.h"
 #include "../Panel/PanelView/krselectionmode.h"
 #include "../Panel/PanelView/krview.h"
 #include "../Panel/PanelView/krviewfactory.h"
 #include "../Panel/krlayoutfactory.h"
 
 enum {
     PAGE_GENERAL = 0,
     PAGE_VIEW,
     PAGE_PANELTOOLBAR,
     PAGE_MOUSE,
     PAGE_MEDIA_MENU,
     PAGE_LAYOUT
 };
 
 
 KgPanel::KgPanel(bool first, QWidget* parent) :
         KonfiguratorPage(first, parent)
 {
     tabWidget = new QTabWidget(this);
     setWidget(tabWidget);
     setWidgetResizable(true);
 
     setupGeneralTab();
     setupPanelTab();
     setupButtonsTab();
     setupMouseModeTab();
     setupMediaMenuTab();
     setupLayoutTab();
 }
 
 // ---------------------------------------------------------------------------------------
 // ---------------------------- General TAB ----------------------------------------------
 // ---------------------------------------------------------------------------------------
 void KgPanel::setupGeneralTab()
 {
-    QScrollArea *scrollArea = new QScrollArea(tabWidget);
+    auto *scrollArea = new QScrollArea(tabWidget);
     QWidget *tab = new QWidget(scrollArea);
     scrollArea->setFrameStyle(QFrame::NoFrame);
     scrollArea->setWidget(tab);
     scrollArea->setWidgetResizable(true);
     tabWidget->addTab(scrollArea, i18n("General"));
 
-    QVBoxLayout *layout = new QVBoxLayout(tab);
+    auto *layout = new QVBoxLayout(tab);
     layout->setSpacing(6);
     layout->setContentsMargins(11, 11, 11, 11);
 
 // ---------------------------------------------------------------------------------------
 // ------------------------------- Navigator bar -------------------------------------
 // ---------------------------------------------------------------------------------------
         QGroupBox *groupBox = createFrame(i18n("Navigator bar"), tab);
         QGridLayout *gridLayout = createGridLayout(groupBox);
 
         KONFIGURATOR_CHECKBOX_PARAM navigatorbar_settings[] = {
             // cfg_class, cfg_name, default, text, restart, tooltip
             {"Look&Feel", "Navigator Edit Mode", false, i18n("Edit Mode by default"),       true, i18n("Show editable path in Navigator bar by default") },
             {"Look&Feel", "Navigator Full Path", false, i18n("Show full path by default"),  true, i18n("Always show full path in Navigator bar by default.") },
         };
         KonfiguratorCheckBoxGroup* cbs = createCheckBoxGroup(2, 0, navigatorbar_settings, 2 /*count*/, groupBox, PAGE_GENERAL);
         gridLayout->addWidget(cbs, 0, 0);
 
         layout->addWidget(groupBox);
 
 // ---------------------------------------------------------------------------------------
 // ------------------------------- Operation ---------------------------------------------
 // ---------------------------------------------------------------------------------------
     groupBox = createFrame(i18n("Operation"), tab);
     gridLayout = createGridLayout(groupBox);
 
     KONFIGURATOR_CHECKBOX_PARAM operation_settings[] = { // cfg_class, cfg_name, default, text, restart, tooltip
         {"Look&Feel", "Mark Dirs",            _MarkDirs,          i18n("Autoselect folders"),   false,  i18n("When matching the select criteria, not only files will be selected, but also folders.") },
         {"Look&Feel", "Rename Selects Extension", true,          i18n("Rename selects extension"),   false,  i18n("When renaming a file, the whole text is selected. If you want Total-Commander like renaming of just the name, without extension, uncheck this option.") },
         {"Look&Feel", "UnselectBeforeOperation", _UnselectBeforeOperation, i18n("Unselect files before copy/move"), false, i18n("Unselect files, which are to be copied/moved, before the operation starts.") },
         {"Look&Feel", "FilterDialogRemembersSettings", _FilterDialogRemembersSettings, i18n("Filter dialog remembers settings"), false, i18n("The filter dialog is opened with the last filter settings that where applied to the panel.") },
     };
     cbs = createCheckBoxGroup(2, 0, operation_settings, 4 /*count*/, groupBox, PAGE_GENERAL);
     gridLayout->addWidget(cbs, 0, 0);
 
     layout->addWidget(groupBox);
 
 // ---------------------------------------------------------------------------------------
 // ------------------------------ Tabs ---------------------------------------------------
 // ---------------------------------------------------------------------------------------
     groupBox = createFrame(i18n("Tabs"), tab);
     gridLayout = createGridLayout(groupBox);
 
     KONFIGURATOR_CHECKBOX_PARAM tabbar_settings[] = { //   cfg_class  cfg_name                default             text                              restart tooltip
         {"Look&Feel", "Fullpath Tab Names",   _FullPathTabNames,  i18n("Use full path tab names"), true ,  i18n("Display the full path in the folder tabs. By default only the last part of the path is displayed.") },
         {"Look&Feel", "Show Tab Buttons",   true,  i18n("Show new/close tab buttons"), true ,  i18n("Show the new/close tab buttons.") },
     };
     cbs = createCheckBoxGroup(2, 0, tabbar_settings, 2 /*count*/, groupBox, PAGE_GENERAL);
     gridLayout->addWidget(cbs, 0, 0, 1, 2);
 
 // -----------------  Tab Bar position ----------------------------------
-    QHBoxLayout *hbox = new QHBoxLayout();
+    auto *hbox = new QHBoxLayout();
 
     hbox->addWidget(new QLabel(i18n("Tab Bar position:"), groupBox));
 
     KONFIGURATOR_NAME_VALUE_PAIR positions[] = {
         { i18n("Top"),      "top" },
         { i18n("Bottom"),   "bottom" }
     };
 
     KonfiguratorComboBox *cmb = createComboBox("Look&Feel", "Tab Bar Position",
                                 "bottom", positions, 2, groupBox, true, false, PAGE_GENERAL);
 
     hbox->addWidget(cmb);
     gridLayout->addLayout(hbox, 1, 0, Qt::AlignLeft);
 
 // -----------------  Show Tab bar ----------------------------------
     KonfiguratorCheckBox *checkBox = createCheckBox("Look&Feel", "Show Tab Bar On Single Tab", true,
                                                     i18n("Show Tab Bar on single tab"), groupBox,
                                                     true, i18n("Show the tab bar with only one tab."));
     gridLayout->addWidget(checkBox, 1, 1, Qt::AlignLeft);
 
     layout->addWidget(groupBox);
 
 // ---------------------------------------------------------------------------------------
 // -----------------------------  Search bar  --------------------------------------------
 // ---------------------------------------------------------------------------------------
     groupBox = createFrame(i18n("Search bar"), tab);
     gridLayout = createGridLayout(groupBox);
 
     KONFIGURATOR_CHECKBOX_PARAM quicksearch[] = { //   cfg_class  cfg_name                default             text                              restart tooltip
         {"Look&Feel", "New Style Quicksearch",  _NewStyleQuicksearch, i18n("Start by typing"), false,  i18n("Open search bar and start searching by typing in panel.") },
         {"Look&Feel", "Case Sensitive Quicksearch",  _CaseSensitiveQuicksearch, i18n("Case sensitive"), false,  i18n("Search must match case.") },
         {"Look&Feel", "Up/Down Cancels Quicksearch",  false, i18n("Up/Down cancels search"), false,  i18n("Pressing the Up/Down buttons closes the search bar (only in search mode).") },
         {"Look&Feel", "Navigation with Right Arrow Quicksearch", _NavigationWithRightArrowQuicksearch, i18n("Directory navigation with Right Arrow"), false, i18n("Pressing the Right button enters directory if no search text editing intention is captured.") },
     };
 
     cbs = createCheckBoxGroup(2, 0, quicksearch, 4 /*count*/, groupBox, PAGE_GENERAL);
     gridLayout->addWidget(cbs, 0, 0, 1, -1);
 
     // -------------- Search bar position -----------------------
 
     hbox = new QHBoxLayout();
     hbox->addWidget(new QLabel(i18n("Position:"), groupBox));
     cmb = createComboBox("Look&Feel", "Quicksearch Position",
                             "bottom", positions, 2, groupBox, true, false, PAGE_GENERAL);
     hbox->addWidget(cmb);
     hbox->addWidget(createSpacer(groupBox));
     gridLayout->addLayout(hbox, 1, 0);
 
     // -------------- Default search mode -----------------------
 
     hbox = new QHBoxLayout();
     hbox->addWidget(new QLabel(i18n("Default mode:"), groupBox));
     KONFIGURATOR_NAME_VALUE_PAIR modes[] = {
         {i18n("Search"), QString::number(KrSearchBar::MODE_SEARCH)},
         {i18n("Select"), QString::number(KrSearchBar::MODE_SELECT)},
         {i18n("Filter"), QString::number(KrSearchBar::MODE_FILTER)}};
     cmb = createComboBox("Look&Feel", "Default Search Mode",
                          QString::number(KrSearchBar::MODE_SEARCH), modes, 3, groupBox, true, false,
                          PAGE_GENERAL);
     cmb->setToolTip(i18n("Set the default mode on first usage"));
     hbox->addWidget(cmb);
     hbox->addWidget(createSpacer(groupBox));
     gridLayout->addLayout(hbox, 1, 1);
 
     layout->addWidget(groupBox);
 
 // --------------------------------------------------------------------------------------------
 // ------------------------------- Bookmark search settings ----------------------------------
 // --------------------------------------------------------------------------------------------
     groupBox = createFrame(i18n("Bookmark Search"), tab);
     gridLayout = createGridLayout(groupBox);
 
     KONFIGURATOR_CHECKBOX_PARAM bookmarkSearchSettings[] =
     {
         {"Look&Feel", "Always show search bar", true, i18n("Always show search bar"), false, i18n("Make bookmark search bar always visible") },
         {"Look&Feel", "Search in special items", false, i18n("Search in special items"), false, i18n("Bookmark search is also applied to special items in bookmark menu like Trash, Popular URLs, Jump Back, etc.") },
     };
     KonfiguratorCheckBoxGroup *bookmarkSearchSettingsGroup = createCheckBoxGroup(2, 0, bookmarkSearchSettings,
                                                                                  2 /*count*/, groupBox, PAGE_GENERAL);
     gridLayout->addWidget(bookmarkSearchSettingsGroup, 1, 0, 1, 2);
     layout->addWidget(groupBox);
 
 // --------------------------------------------------------------------------------------------
 // ------------------------------- Status/Totalsbar settings ----------------------------------
 // --------------------------------------------------------------------------------------------
     groupBox = createFrame(i18n("Status/Totalsbar"), tab);
     gridLayout = createGridLayout(groupBox);
 
     KONFIGURATOR_CHECKBOX_PARAM barSettings[] =
     {
         {"Look&Feel", "Show Size In Bytes", false, i18n("Show size in bytes too"), true,  i18n("Show size in bytes too") },
         {"Look&Feel", "ShowSpaceInformation", true, i18n("Show space information"), true,  i18n("Show free/total space on the device") },
     };
     KonfiguratorCheckBoxGroup *barSett = createCheckBoxGroup(2, 0, barSettings,
                                           2 /*count*/, groupBox, PAGE_GENERAL);
     gridLayout->addWidget(barSett, 1, 0, 1, 2);
 
     layout->addWidget(groupBox);
 }
 
 // --------------------------------------------------------------------------------------------
 // ------------------------------------ Layout Tab --------------------------------------------
 // --------------------------------------------------------------------------------------------
 void KgPanel::setupLayoutTab()
 {
-    QScrollArea *scrollArea = new QScrollArea(tabWidget);
+    auto *scrollArea = new QScrollArea(tabWidget);
     QWidget *tab = new QWidget(scrollArea);
     scrollArea->setFrameStyle(QFrame::NoFrame);
     scrollArea->setWidget(tab);
     scrollArea->setWidgetResizable(true);
     tabWidget->addTab(scrollArea, i18n("Layout"));
 
     QGridLayout *grid = createGridLayout(tab);
 
     QStringList layoutNames = KrLayoutFactory::layoutNames();
     int numLayouts = layoutNames.count();
 
     grid->addWidget(createSpacer(tab), 0, 2);
 
     QLabel *l = new QLabel(i18n("Layout:"), tab);
     l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     grid->addWidget(l, 0, 0);
-    KONFIGURATOR_NAME_VALUE_PAIR *layouts = new KONFIGURATOR_NAME_VALUE_PAIR[numLayouts];
+    auto *layouts = new KONFIGURATOR_NAME_VALUE_PAIR[numLayouts];
     for (int i = 0; i != numLayouts; i++) {
         layouts[ i ].text = KrLayoutFactory::layoutDescription(layoutNames[i]);
         layouts[ i ].value = layoutNames[i];
     }
     KonfiguratorComboBox *cmb = createComboBox("PanelLayout", "Layout", "default",
                          layouts, numLayouts, tab, true, false, PAGE_LAYOUT);
     grid->addWidget(cmb, 0, 1);
     delete [] layouts;
 
     l = new QLabel(i18n("Frame Color:"), tab);
     l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     grid->addWidget(l, 1, 0);
     KONFIGURATOR_NAME_VALUE_PAIR frameColor[] = {
         { i18nc("Frame color", "Defined by Layout"), "default" },
         { i18nc("Frame color", "None"), "none" },
         { i18nc("Frame color", "Statusbar"), "Statusbar" }
     };
     cmb = createComboBox("PanelLayout", "FrameColor",
                             "default", frameColor, 3, tab, true, false, PAGE_LAYOUT);
     grid->addWidget(cmb, 1, 1);
 
 
     l = new QLabel(i18n("Frame Shape:"), tab);
     l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     grid->addWidget(l, 2, 0);
     KONFIGURATOR_NAME_VALUE_PAIR frameShape[] = {
         { i18nc("Frame shape", "Defined by Layout"), "default" },
         { i18nc("Frame shape", "None"), "NoFrame" },
         { i18nc("Frame shape", "Box"), "Box" },
         { i18nc("Frame shape", "Panel"), "Panel" },
     };
     cmb = createComboBox("PanelLayout", "FrameShape",
                             "default", frameShape, 4, tab, true, false, PAGE_LAYOUT);
     grid->addWidget(cmb, 2, 1);
 
 
     l = new QLabel(i18n("Frame Shadow:"), tab);
     l->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     grid->addWidget(l, 3, 0);
     KONFIGURATOR_NAME_VALUE_PAIR frameShadow[] = {
         { i18nc("Frame shadow", "Defined by Layout"), "default" },
         { i18nc("Frame shadow", "None"), "Plain" },
         { i18nc("Frame shadow", "Raised"), "Raised" },
         { i18nc("Frame shadow", "Sunken"), "Sunken" },
     };
     cmb = createComboBox("PanelLayout", "FrameShadow",
                             "default", frameShadow, 4, tab, true, false, PAGE_LAYOUT);
     grid->addWidget(cmb, 3, 1);
 }
 
 void KgPanel::setupView(KrViewInstance *instance, QWidget *parent)
 {
     QGridLayout *grid = createGridLayout(parent);
 
 // -------------------- Filelist icon size ----------------------------------
-    QHBoxLayout *hbox = new QHBoxLayout();
+    auto *hbox = new QHBoxLayout();
 
     hbox->addWidget(new QLabel(i18n("Default icon size:"), parent));
 
-    KONFIGURATOR_NAME_VALUE_PAIR *iconSizes = new KONFIGURATOR_NAME_VALUE_PAIR[KrView::iconSizes.count()];
+    auto *iconSizes = new KONFIGURATOR_NAME_VALUE_PAIR[KrView::iconSizes.count()];
     for(int i = 0; i < KrView::iconSizes.count(); i++)
         iconSizes[i].text =  iconSizes[i].value = QString::number(KrView::iconSizes[i]);
     KonfiguratorComboBox *cmb = createComboBox(instance->name(), "IconSize", _FilelistIconSize, iconSizes, KrView::iconSizes.count(), parent, true, true, PAGE_VIEW);
     delete [] iconSizes;
     cmb->lineEdit()->setValidator(new QRegExpValidator(QRegExp("[1-9]\\d{0,1}"), cmb));
     hbox->addWidget(cmb);
 
     hbox->addWidget(createSpacer(parent));
 
     grid->addLayout(hbox, 1, 0);
 
 //--------------------------------------------------------------------
     KONFIGURATOR_CHECKBOX_PARAM iconSettings[] =
         //   cfg_class             cfg_name        default       text            restart        tooltip
     {
         {instance->name(), "With Icons",      _WithIcons,   i18n("Use icons in the filenames"), true,  i18n("Show the icons for filenames and folders.") },
         {instance->name(), "ShowPreviews", false, i18n("Show previews by default"), false, i18n("Show previews of files and folders.") },
     };
 
     KonfiguratorCheckBoxGroup *iconSett = createCheckBoxGroup(2, 0, iconSettings, 2 /*count*/, parent, PAGE_VIEW);
 
     grid->addWidget(iconSett, 2, 0, 1, 2);
 }
 
 // ----------------------------------------------------------------------------------
 //  ---------------------------- VIEW TAB -------------------------------------------
 // ----------------------------------------------------------------------------------
 void KgPanel::setupPanelTab()
 {
-    QScrollArea *scrollArea = new QScrollArea(tabWidget);
+    auto *scrollArea = new QScrollArea(tabWidget);
     QWidget *tab_panel = new QWidget(scrollArea);
     scrollArea->setFrameStyle(QFrame::NoFrame);
     scrollArea->setWidget(tab_panel);
     scrollArea->setWidgetResizable(true);
     tabWidget->addTab(scrollArea, i18n("View"));
 
-    QGridLayout *panelLayout = new QGridLayout(tab_panel);
+    auto *panelLayout = new QGridLayout(tab_panel);
     panelLayout->setSpacing(6);
     panelLayout->setContentsMargins(11, 11, 11, 11);
     QGroupBox *panelGrp = createFrame(i18n("General"), tab_panel);
     panelLayout->addWidget(panelGrp, 0, 0);
     QGridLayout *panelGrid = createGridLayout(panelGrp);
 
     // ----------------------------------------------------------------------------------
     //  ---------------------------- General settings -----------------------------------
     // ----------------------------------------------------------------------------------
 
     // -------------------- Panel Font ----------------------------------
-    QHBoxLayout *hbox = new QHBoxLayout();
+    auto *hbox = new QHBoxLayout();
 
-    QHBoxLayout *fontLayout = new QHBoxLayout();
+    auto *fontLayout = new QHBoxLayout();
     fontLayout->addWidget(new QLabel(i18n("View font:"), panelGrp));
     KonfiguratorFontChooser *chsr =
         createFontChooser("Look&Feel", "Filelist Font", _FilelistFont, panelGrp, true, PAGE_VIEW);
     fontLayout->addWidget(chsr);
     fontLayout->addStretch(1);
     hbox->addLayout(fontLayout, 1);
 
     // -------------------- Panel Tooltip ----------------------------------
-    QHBoxLayout *tooltipLayout = new QHBoxLayout();
+    auto *tooltipLayout = new QHBoxLayout();
     QLabel *tooltipLabel = new QLabel(i18n("Tooltip delay (msec):"));
     tooltipLabel->setWhatsThis(i18n("The duration after a tooltip is shown for a file item, in "
                                     "milliseconds. Set a negative value to disable tooltips."));
     tooltipLayout->addWidget(tooltipLabel);
     KonfiguratorSpinBox *tooltipSpinBox = createSpinBox("Look&Feel", "Panel Tooltip Delay", 1000,
                                                         -100, 5000, panelGrp, false, PAGE_VIEW);
     tooltipSpinBox->setSingleStep(100);
     tooltipLayout->addWidget(tooltipSpinBox);
     tooltipLayout->addStretch(1);
     hbox->addLayout(tooltipLayout, 1);
 
     panelGrid->addLayout(hbox, 1, 0);
 
 
     // -------------------- General options ----------------------------------
     KONFIGURATOR_CHECKBOX_PARAM panelSettings[] =
         //   cfg_class  cfg_name                default text                                  restart tooltip
     {
         {"Look&Feel", "Human Readable Size",            _HumanReadableSize,      i18n("Use human-readable file size"), true ,  i18n("File sizes are displayed in B, KB, MB and GB, not just in bytes.") },
         {"Look&Feel", "Show Hidden",                    _ShowHidden,             i18n("Show hidden files"),      false,  i18n("Display files beginning with a dot.") },
         {"Look&Feel", "Numeric permissions",            _NumericPermissions,     i18n("Numeric Permissions"), true,  i18n("Show octal numbers (0755) instead of the standard permissions (rwxr-xr-x) in the permission column.") },
         {"Look&Feel", "Load User Defined Folder Icons", _UserDefinedFolderIcons, i18n("Load the user defined folder icons"), true ,  i18n("Load the user defined folder icons (can cause decrease in performance).") },
         {"Look&Feel", "Always Show Current Item",       _AlwaysShowCurrentItem,  i18n("Always show current item"), false,  i18n("Show current item border decoration in inactive panel.") },
     };
 
     KonfiguratorCheckBoxGroup *panelSett = createCheckBoxGroup(2, 0, panelSettings, 5 /*count*/, panelGrp, PAGE_VIEW);
 
     panelGrid->addWidget(panelSett, 3, 0, 1, 2);
 
     // =========================================================
     panelGrid->addWidget(createLine(panelGrp), 4, 0);
 
     // ------------------------ Sort Method ----------------------------------
 
     hbox = new QHBoxLayout();
 
     hbox->addWidget(new QLabel(i18n("Sort method:"), panelGrp));
 
     KONFIGURATOR_NAME_VALUE_PAIR sortMethods[] = {{ i18n("Alphabetical"),                QString::number(KrViewProperties::Alphabetical) },
         { i18n("Alphabetical and numbers"),    QString::number(KrViewProperties::AlphabeticalNumbers) },
         { i18n("Character code"),              QString::number(KrViewProperties::CharacterCode) },
         { i18n("Character code and numbers"),  QString::number(KrViewProperties::CharacterCodeNumbers) },
         { i18nc("Krusader sort", "Krusader"),  QString::number(KrViewProperties::Krusader) }
     };
     KonfiguratorComboBox *cmb = createComboBox("Look&Feel", "Sort method", QString::number(_DefaultSortMethod),
                             sortMethods, 5, panelGrp, true, false, PAGE_VIEW);
     hbox->addWidget(cmb);
     hbox->addWidget(createSpacer(panelGrp));
 
     panelGrid->addLayout(hbox, 5, 0);
 
     // ------------------------ Sort Options ----------------------------------
     KONFIGURATOR_CHECKBOX_PARAM sortSettings[] =
         // cfg_class, cfg_name, default, text, restart, tooltip
     {
         {"Look&Feel", "Case Sensative Sort", _CaseSensativeSort, i18n("Case sensitive sorting"), true,
             i18n("All files beginning with capital letters appear before files beginning with non-capital letters (UNIX default).") },
-        {"Look&Feel", "Show Directories First", true, i18n("Show folders first"), true, 0 },
+        {"Look&Feel", "Show Directories First", true, i18n("Show folders first"), true, nullptr },
         {"Look&Feel", "Always sort dirs by name", false, i18n("Always sort dirs by name"), true,
             i18n("Folders are sorted by name, regardless of the sort column.") },
         {"Look&Feel", "Locale Aware Sort", true, i18n("Locale aware sorting"), true,
             i18n("The sorting is performed in a locale- and also platform-dependent manner. Can be slow.") },
     };
 
     KonfiguratorCheckBoxGroup *sortSett = createCheckBoxGroup(2, 0, sortSettings,
                                           4 /*count*/, panelGrp, PAGE_VIEW);
     sortSett->find("Show Directories First")->addDep(sortSett->find("Always sort dirs by name"));
 
     panelGrid->addWidget(sortSett, 6, 0, 1, 2);
 
 
     // ----------------------------------------------------------------------------------
     //  ---------------------------- View modes -----------------------------------------
     // ----------------------------------------------------------------------------------
 
     panelGrp = createFrame(i18n("View modes"), tab_panel);
     panelLayout->addWidget(panelGrp, 1, 0);
     panelGrid = createGridLayout(panelGrp);
 
     // -------------------- Default Panel Type ----------------------------------
     hbox = new QHBoxLayout();
 
     hbox->addWidget(new QLabel(i18n("Default view mode:"), panelGrp));
 
     QList<KrViewInstance *> views = KrViewFactory::registeredViews();
     const int viewsSize = views.size();
-    KONFIGURATOR_NAME_VALUE_PAIR *panelTypes = new KONFIGURATOR_NAME_VALUE_PAIR[ viewsSize ];
+    auto *panelTypes = new KONFIGURATOR_NAME_VALUE_PAIR[ viewsSize ];
 
     QString defType = QString('0');
 
     for (int i = 0; i != viewsSize; i++) {
         KrViewInstance * inst = views[ i ];
         panelTypes[ i ].text = inst->description();
         panelTypes[ i ].text.remove('&');
         panelTypes[ i ].value = QString("%1").arg(inst->id());
         if (inst->id() == KrViewFactory::defaultViewId())
             defType = QString("%1").arg(inst->id());
     }
 
     cmb = createComboBox("Look&Feel", "Default Panel Type", defType, panelTypes, viewsSize, panelGrp, false, false, PAGE_VIEW);
     hbox->addWidget(cmb);
     hbox->addWidget(createSpacer(panelGrp));
 
     delete [] panelTypes;
 
     panelGrid->addLayout(hbox, 0, 0);
 
     // ----- Individual Settings Per View Type ------------------------
-    QTabWidget *tabs_view = new QTabWidget(panelGrp);
+    auto *tabs_view = new QTabWidget(panelGrp);
     panelGrid->addWidget(tabs_view, 11, 0);
 
     for(int i = 0; i < views.count(); i++) {
         QWidget *tab = new QWidget(tabs_view);
         tabs_view->addTab(tab, views[i]->description());
         setupView(views[i], tab);
     }
 }
 
 // -----------------------------------------------------------------------------------
 //  -------------------------- Panel Toolbar TAB ----------------------------------
 // -----------------------------------------------------------------------------------
 void KgPanel::setupButtonsTab()
 {
-    QScrollArea *scrollArea = new QScrollArea(tabWidget);
+    auto *scrollArea = new QScrollArea(tabWidget);
     QWidget *tab = new QWidget(scrollArea);
     scrollArea->setFrameStyle(QFrame::NoFrame);
     scrollArea->setWidget(tab);
     scrollArea->setWidgetResizable(true);
     tabWidget->addTab(scrollArea, i18n("Buttons"));
 
     QBoxLayout * tabLayout = new QVBoxLayout(tab);
     tabLayout->setSpacing(6);
     tabLayout->setContentsMargins(11, 11, 11, 11);
 
     KONFIGURATOR_CHECKBOX_PARAM buttonsParams[] =
         //   cfg_class    cfg_name                default        text                          restart tooltip
     {
         {"ListPanelButtons", "Icons", false, i18n("Toolbar buttons have icons"), true,   "" },
         {"Look&Feel",  "Media Button Visible",  true,    i18n("Show Media Button"), true ,  i18n("The media button will be visible.") },
         {"Look&Feel",  "Back Button Visible",  false,      i18n("Show Back Button"),     true ,  "Goes back in history." },
         {"Look&Feel",  "Forward Button Visible",  false,   i18n("Show Forward Button"),     true ,  "Goes forward in history." },
         {"Look&Feel",  "History Button Visible",  true,    i18n("Show History Button"), true ,  i18n("The history button will be visible.") },
         {"Look&Feel",  "Bookmarks Button Visible",  true,    i18n("Show Bookmarks Button"), true ,  i18n("The bookmarks button will be visible.") },
         {"Look&Feel", "Panel Toolbar visible", _PanelToolBar, i18n("Show Panel Toolbar"), true,   i18n("The panel toolbar will be visible.") },
     };
     buttonsCheckboxes = createCheckBoxGroup(1, 0, buttonsParams, 7/*count*/, tab, PAGE_PANELTOOLBAR);
     connect(buttonsCheckboxes->find("Panel Toolbar visible"), &KonfiguratorCheckBox::stateChanged, this, &KgPanel::slotEnablePanelToolbar);
-    tabLayout->addWidget(buttonsCheckboxes, 0, 0);
+    tabLayout->addWidget(buttonsCheckboxes, 0, nullptr);
 
     QGroupBox * panelToolbarGrp = createFrame(i18n("Visible Panel Toolbar buttons"), tab);
     QGridLayout * panelToolbarGrid = createGridLayout(panelToolbarGrp);
     KONFIGURATOR_CHECKBOX_PARAM panelToolbarButtonsParams[] = {
         //   cfg_class    cfg_name                default             text                       restart tooltip
         {"Look&Feel",  "Equal Button Visible", _cdOther,   i18n("Equal button (=)"), true ,  i18n("Changes the panel folder to the other panel folder.") },
         {"Look&Feel",  "Up Button Visible",    _cdUp,      i18n("Up button (..)"),  true ,  i18n("Changes the panel folder to the parent folder.") },
         {"Look&Feel",  "Home Button Visible",  _cdHome,    i18n("Home button (~)"), true ,  i18n("Changes the panel folder to the home folder.") },
         {"Look&Feel",  "Root Button Visible",  _cdRoot,    i18n("Root button (/)"), true ,  i18n("Changes the panel folder to the root folder.") },
         {"Look&Feel",  "SyncBrowse Button Visible",  _syncBrowseButton,    i18n("Toggle-button for sync-browsing"), true ,  i18n("Each folder change in the panel is also performed in the other panel.") },
     };
     panelToolbarButtonsCheckboxes = createCheckBoxGroup(1, 0, panelToolbarButtonsParams,
                                  sizeof(panelToolbarButtonsParams) / sizeof(*panelToolbarButtonsParams),
                                  panelToolbarGrp, PAGE_PANELTOOLBAR);
     panelToolbarGrid->addWidget(panelToolbarButtonsCheckboxes, 0, 0);
-    tabLayout->addWidget(panelToolbarGrp, 1, 0);
+    tabLayout->addWidget(panelToolbarGrp, 1, nullptr);
 
     // Enable panel toolbar checkboxes
     slotEnablePanelToolbar();
 }
 
 // ---------------------------------------------------------------------------
 //  -------------------------- Mouse TAB ----------------------------------
 // ---------------------------------------------------------------------------
 void KgPanel::setupMouseModeTab()
 {
-    QScrollArea *scrollArea = new QScrollArea(tabWidget);
+    auto *scrollArea = new QScrollArea(tabWidget);
     QWidget *tab_mouse = new QWidget(scrollArea);
     scrollArea->setFrameStyle(QFrame::NoFrame);
     scrollArea->setWidget(tab_mouse);
     scrollArea->setWidgetResizable(true);
     tabWidget->addTab(scrollArea, i18n("Selection Mode"));
-    QGridLayout *mouseLayout = new QGridLayout(tab_mouse);
+    auto *mouseLayout = new QGridLayout(tab_mouse);
     mouseLayout->setSpacing(6);
     mouseLayout->setContentsMargins(11, 11, 11, 11);
 
     // -------------- General -----------------
     QGroupBox *mouseGeneralGroup = createFrame(i18n("General"), tab_mouse);
     QGridLayout *mouseGeneralGrid = createGridLayout(mouseGeneralGroup);
     mouseGeneralGrid->setSpacing(0);
     mouseGeneralGrid->setContentsMargins(5, 5, 5, 5);
 
     KONFIGURATOR_NAME_VALUE_TIP mouseSelection[] = {
         //     name           value          tooltip
         { i18n("Krusader Mode"), "0", i18n("Both keys allow selecting files. To select more than one file, hold the Ctrl key and click the left mouse button. Right-click menu is invoked using a short click on the right mouse button.") },
         { i18n("Konqueror Mode"), "1", i18n("Pressing the left mouse button selects files - you can click and select multiple files. Right-click menu is invoked using a short click on the right mouse button.") },
         { i18n("Total-Commander Mode"), "2", i18n("The left mouse button does not select, but sets the current file without affecting the current selection. The right mouse button selects multiple files and the right-click menu is invoked by pressing and holding the right mouse button.") },
         { i18n("Ergonomic Mode"), "4", i18n("The left mouse button does not select, but sets the current file without affecting the current selection. The right mouse button invokes the context-menu. You can select with Ctrl key and the left button.") },
         { i18n("Custom Selection Mode"), "3", i18n("Design your own selection mode.") }
     };
     mouseRadio = createRadioButtonGroup("Look&Feel", "Mouse Selection", "0", 1, 5, mouseSelection, 5, mouseGeneralGroup, true, PAGE_MOUSE);
     mouseRadio->layout()->setContentsMargins(0, 0, 0, 0);
     mouseGeneralGrid->addWidget(mouseRadio, 0, 0);
 
     for (int i = 0; i != mouseRadio->count(); i++)
         connect(mouseRadio->find(i), &QRadioButton::clicked, this, &KgPanel::slotSelectionModeChanged);
 
     mouseLayout->addWidget(mouseGeneralGroup, 0, 0);
 
     // -------------- Details -----------------
     QGroupBox *mouseDetailGroup = createFrame(i18n("Details"), tab_mouse);
     QGridLayout *mouseDetailGrid = createGridLayout(mouseDetailGroup);
     mouseDetailGrid->setSpacing(0);
     mouseDetailGrid->setContentsMargins(5, 5, 5, 5);
 
     KONFIGURATOR_NAME_VALUE_TIP singleOrDoubleClick[] = {
         //          name            value            tooltip
         { i18n("Double-click selects (classic)"), "0", i18n("A single click on a file will select and focus, a double click opens the file or steps into the folder.") },
         { i18n("Obey global selection policy"), "1", i18n("<p>Use global setting:</p><p><i>Plasma System Settings -> Input Devices -> Mouse</i></p>") }
     };
     KonfiguratorRadioButtons *clickRadio = createRadioButtonGroup("Look&Feel", "Single Click Selects", "0", 1, 0, singleOrDoubleClick, 2, mouseDetailGroup, true, PAGE_MOUSE);
     clickRadio->layout()->setContentsMargins(0, 0, 0, 0);
     mouseDetailGrid->addWidget(clickRadio, 0, 0);
 
     KONFIGURATOR_CHECKBOX_PARAM mouseCheckboxesParam[] = {
         // {cfg_class,   cfg_name,   default
         //  text,  restart,
         //  tooltip }
         {"Custom Selection Mode",  "QT Selection",  _QtSelection,
             i18n("Based on KDE's selection mode"), true,
             i18n("If checked, use a mode based on KDE's style.") },
         {"Custom Selection Mode",  "Left Selects",  _LeftSelects,
          i18n("Left mouse button selects"), true,
          i18n("If checked, left clicking an item will select it.") },
         {"Custom Selection Mode",  "Left Preserves", _LeftPreserves,
          i18n("Left mouse button preserves selection"), true,
          i18n("If checked, left clicking an item will select it, but will not unselect other, already selected items.") },
         {"Custom Selection Mode",  "ShiftCtrl Left Selects",  _ShiftCtrlLeft,
          i18n("Shift/Ctrl-Left mouse button selects"), true,
          i18n("If checked, Shift/Ctrl left clicking will select items.\nNote: this is meaningless if 'Left Button Selects' is checked.") },
         {"Custom Selection Mode",  "Right Selects",  _RightSelects,
          i18n("Right mouse button selects"), true,
          i18n("If checked, right clicking an item will select it.") },
         {"Custom Selection Mode",  "Right Preserves",  _RightPreserves,
          i18n("Right mouse button preserves selection"), true,
          i18n("If checked, right clicking an item will select it, but will not unselect other, already selected items.") },
         {"Custom Selection Mode",  "ShiftCtrl Right Selects",  _ShiftCtrlRight,
          i18n("Shift/Ctrl-Right mouse button selects"), true,
          i18n("If checked, Shift/Ctrl right clicking will select items.\nNote: this is meaningless if 'Right Button Selects' is checked.") },
         {"Custom Selection Mode",  "Space Moves Down",  _SpaceMovesDown,
          i18n("Spacebar moves down"), true,
          i18n("If checked, pressing the spacebar will select the current item and move down.\nOtherwise, current item is selected, but remains the current item.") },
         {"Custom Selection Mode",  "Space Calc Space",  _SpaceCalcSpace,
          i18n("Spacebar calculates disk space"), true,
          i18n("If checked, pressing the spacebar while the current item is a folder, will (except from selecting the folder)\ncalculate space occupied of the folder (recursively).") },
         {"Custom Selection Mode",  "Insert Moves Down",  _InsertMovesDown,
          i18n("Insert moves down"), true,
          i18n("If checked, pressing Insert will select the current item, and move down to the next item.\nOtherwise, current item is not changed.") },
         {"Custom Selection Mode",  "Immediate Context Menu",  _ImmediateContextMenu,
          i18n("Right clicking pops context menu immediately"), true,
          i18n("If checked, right clicking will result in an immediate showing of the context menu.\nOtherwise, user needs to click and hold the right mouse button for 500ms.") },
     };
 
 
     mouseCheckboxes = createCheckBoxGroup(1, 0, mouseCheckboxesParam, 11 /*count*/, mouseDetailGroup, PAGE_MOUSE);
     mouseDetailGrid->addWidget(mouseCheckboxes, 1, 0);
 
     for (int i = 0; i < mouseCheckboxes->count(); i++)
         connect(mouseCheckboxes->find(i), &KonfiguratorCheckBox::clicked, this, &KgPanel::slotMouseCheckBoxChanged);
 
     mouseLayout->addWidget(mouseDetailGroup, 0, 1, 2, 1);
 
     // Disable the details-button if not in custom-mode
     slotSelectionModeChanged();
 
     // -------------- Preview -----------------
     QGroupBox *mousePreviewGroup = createFrame(i18n("Preview"), tab_mouse);
     QGridLayout *mousePreviewGrid = createGridLayout(mousePreviewGroup);
     // TODO preview
     mousePreview = new KrTreeWidget(mousePreviewGroup);
     mousePreviewGrid->addWidget(mousePreview, 0 , 0);
     mousePreviewGroup->setEnabled(false); // TODO re-enable once the preview is implemented
     // ------------------------------------------
     mouseLayout->addWidget(mousePreviewGroup, 1, 0);
 }
 
 // ---------------------------------------------------------------------------
 //  -------------------------- Media Menu TAB ----------------------------------
 // ---------------------------------------------------------------------------
 void KgPanel::setupMediaMenuTab()
 {
-    QScrollArea *scrollArea = new QScrollArea(tabWidget);
+    auto *scrollArea = new QScrollArea(tabWidget);
     QWidget *tab = new QWidget(scrollArea);
     scrollArea->setFrameStyle(QFrame::NoFrame);
     scrollArea->setWidget(tab);
     scrollArea->setWidgetResizable(true);
     tabWidget->addTab(scrollArea, i18n("Media Menu"));
 
     QBoxLayout * tabLayout = new QVBoxLayout(tab);
     tabLayout->setSpacing(6);
     tabLayout->setContentsMargins(11, 11, 11, 11);
 
 
     KONFIGURATOR_CHECKBOX_PARAM mediaMenuParams[] = {
         //   cfg_class    cfg_name    default    text   restart tooltip
-        {"MediaMenu", "ShowPath",   true, i18n("Show Mount Path"),       false, 0 },
-        {"MediaMenu", "ShowFSType", true, i18n("Show File System Type"), false, 0 },
+        {"MediaMenu", "ShowPath",   true, i18n("Show Mount Path"),       false, nullptr },
+        {"MediaMenu", "ShowFSType", true, i18n("Show File System Type"), false, nullptr },
     };
     KonfiguratorCheckBoxGroup *mediaMenuCheckBoxes =
         createCheckBoxGroup(1, 0, mediaMenuParams,
                             sizeof(mediaMenuParams) / sizeof(*mediaMenuParams),
                             tab, PAGE_MEDIA_MENU);
-    tabLayout->addWidget(mediaMenuCheckBoxes, 0, 0);
+    tabLayout->addWidget(mediaMenuCheckBoxes, 0, nullptr);
 
-    QHBoxLayout *showSizeHBox = new QHBoxLayout();
+    auto *showSizeHBox = new QHBoxLayout();
     showSizeHBox->addWidget(new QLabel(i18n("Show Size:"), tab));
     KONFIGURATOR_NAME_VALUE_PAIR showSizeValues[] = {
         { i18nc("setting 'show size'", "Always"), "Always" },
         { i18nc("setting 'show size'", "When Device has no Label"), "WhenNoLabel" },
         { i18nc("setting 'show size'", "Never"), "Never" },
     };
     KonfiguratorComboBox *showSizeCmb =
         createComboBox("MediaMenu", "ShowSize",
                        "Always", showSizeValues,
                        sizeof(showSizeValues) / sizeof(*showSizeValues),
                        tab, false, false, PAGE_MEDIA_MENU);
     showSizeHBox->addWidget(showSizeCmb);
     showSizeHBox->addStretch();
     tabLayout->addLayout(showSizeHBox);
 
     tabLayout->addStretch();
 }
 
 void KgPanel::slotEnablePanelToolbar()
 {
     bool enableTB = buttonsCheckboxes->find("Panel Toolbar visible")->isChecked();
     panelToolbarButtonsCheckboxes->find("Root Button Visible")->setEnabled(enableTB);
     panelToolbarButtonsCheckboxes->find("Home Button Visible")->setEnabled(enableTB);
     panelToolbarButtonsCheckboxes->find("Up Button Visible")->setEnabled(enableTB);
     panelToolbarButtonsCheckboxes->find("Equal Button Visible")->setEnabled(enableTB);
     panelToolbarButtonsCheckboxes->find("SyncBrowse Button Visible")->setEnabled(enableTB);
 }
 
 void KgPanel::slotSelectionModeChanged()
 {
     KrSelectionMode *selectionMode =
         KrSelectionMode::getSelectionHandlerForMode(mouseRadio->selectedValue());
-    if (selectionMode == NULL)   //User mode
+    if (selectionMode == nullptr)   //User mode
         return;
     selectionMode->init();
     mouseCheckboxes->find("QT Selection")->setChecked(selectionMode->useQTSelection());
     mouseCheckboxes->find("Left Selects")->setChecked(selectionMode->leftButtonSelects());
     mouseCheckboxes->find("Left Preserves")->setChecked(selectionMode->leftButtonPreservesSelection());
     mouseCheckboxes->find("ShiftCtrl Left Selects")->setChecked(selectionMode->shiftCtrlLeftButtonSelects());
     mouseCheckboxes->find("Right Selects")->setChecked(selectionMode->rightButtonSelects());
     mouseCheckboxes->find("Right Preserves")->setChecked(selectionMode->rightButtonPreservesSelection());
     mouseCheckboxes->find("ShiftCtrl Right Selects")->setChecked(selectionMode->shiftCtrlRightButtonSelects());
     mouseCheckboxes->find("Space Moves Down")->setChecked(selectionMode->spaceMovesDown());
     mouseCheckboxes->find("Space Calc Space")->setChecked(selectionMode->spaceCalculatesDiskSpace());
     mouseCheckboxes->find("Insert Moves Down")->setChecked(selectionMode->insertMovesDown());
     mouseCheckboxes->find("Immediate Context Menu")->setChecked(selectionMode->showContextMenu() == -1);
 }
 
 void KgPanel::slotMouseCheckBoxChanged()
 {
     mouseRadio->selectButton("3");    //custom selection mode
 }
 
 int KgPanel::activeSubPage()
 {
     return tabWidget->currentIndex();
 }
diff --git a/krusader/Konfigurator/kgpanel.h b/krusader/Konfigurator/kgpanel.h
index 7372cd55..93837453 100644
--- a/krusader/Konfigurator/kgpanel.h
+++ b/krusader/Konfigurator/kgpanel.h
@@ -1,61 +1,61 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGPANEL_H
 #define KGPANEL_H
 
 #include "konfiguratorpage.h"
 
 class KrTreeWidget;
 class KrViewInstance;
 
 class KgPanel : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgPanel(bool first, QWidget* parent = 0);
+    explicit KgPanel(bool first, QWidget* parent = nullptr);
 
-    virtual int activeSubPage() Q_DECL_OVERRIDE;
+    int activeSubPage() Q_DECL_OVERRIDE;
 
 protected:
     KonfiguratorCheckBoxGroup *panelToolbarButtonsCheckboxes;
     KonfiguratorCheckBoxGroup *buttonsCheckboxes;
     KonfiguratorRadioButtons  *mouseRadio;
     KonfiguratorCheckBoxGroup *mouseCheckboxes;
     KrTreeWidget* mousePreview;
 
 protected slots:
     void slotEnablePanelToolbar();
     void slotSelectionModeChanged();
     void slotMouseCheckBoxChanged();
 
 private:
     void setupGeneralTab();
     void setupPanelTab();
     void setupButtonsTab();
     void setupMouseModeTab();
     void setupMediaMenuTab();
     void setupLayoutTab();
     void setupView(KrViewInstance *instance, QWidget *parent);
     QTabWidget *tabWidget;
 };
 
 #endif /* __KGPANEL_H__ */
diff --git a/krusader/Konfigurator/kgprotocols.cpp b/krusader/Konfigurator/kgprotocols.cpp
index bd4abd58..41adaf17 100644
--- a/krusader/Konfigurator/kgprotocols.cpp
+++ b/krusader/Konfigurator/kgprotocols.cpp
@@ -1,389 +1,389 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kgprotocols.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../krservices.h"
 
 // QtCore
 #include <QMimeDatabase>
 #include <QMimeType>
 // QtWidgets
 #include <QHeaderView>
 #include <QGridLayout>
 #include <QVBoxLayout>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIOCore/KProtocolManager>
 
 
 KgProtocols::KgProtocols(bool first, QWidget* parent) :
         KonfiguratorPage(first, parent)
 {
-    QGridLayout *KgProtocolsLayout = new QGridLayout(this);
+    auto *KgProtocolsLayout = new QGridLayout(this);
     KgProtocolsLayout->setSpacing(6);
 
     //  -------------------------- LINK VIEW ----------------------------------
 
     QGroupBox *linkGrp = createFrame(i18n("Links"), this);
     QGridLayout *linkGrid = createGridLayout(linkGrp);
 
     QStringList labels;
     labels << i18n("Defined Links");
 
     linkList = new KrTreeWidget(linkGrp);
     linkList->setHeaderLabels(labels);
     linkList->setRootIsDecorated(true);
 
     linkGrid->addWidget(linkList, 0, 0);
     KgProtocolsLayout->addWidget(linkGrp, 0, 0, 2, 1);
 
     //  -------------------------- BUTTONS ----------------------------------
 
     QWidget *vbox1Widget = new QWidget(this);
-    QVBoxLayout *vbox1 = new QVBoxLayout(vbox1Widget);
+    auto *vbox1 = new QVBoxLayout(vbox1Widget);
 
     addSpacer(vbox1);
     btnAddProtocol = new QPushButton(vbox1Widget);
     btnAddProtocol->setIcon(Icon("arrow-left"));
     btnAddProtocol->setWhatsThis(i18n("Add protocol to the link list."));
     vbox1->addWidget(btnAddProtocol);
 
     btnRemoveProtocol = new QPushButton(vbox1Widget);
     btnRemoveProtocol->setIcon(Icon("arrow-right"));
     btnRemoveProtocol->setWhatsThis(i18n("Remove protocol from the link list."));
     vbox1->addWidget(btnRemoveProtocol);
     addSpacer(vbox1);
 
     KgProtocolsLayout->addWidget(vbox1Widget, 0 , 1);
 
     QWidget *vbox2Widget = new QWidget(this);
-    QVBoxLayout *vbox2 = new QVBoxLayout(vbox2Widget);
+    auto *vbox2 = new QVBoxLayout(vbox2Widget);
 
     addSpacer(vbox2);
     btnAddMime = new QPushButton(vbox2Widget);
     btnAddMime->setIcon(Icon("arrow-left"));
     btnAddMime->setWhatsThis(i18n("Add MIME to the selected protocol on the link list."));
     vbox2->addWidget(btnAddMime);
 
     btnRemoveMime = new QPushButton(vbox2Widget);
     btnRemoveMime->setIcon(Icon("arrow-right"));
     btnRemoveMime->setWhatsThis(i18n("Remove MIME from the link list."));
     vbox2->addWidget(btnRemoveMime);
     addSpacer(vbox2);
 
     KgProtocolsLayout->addWidget(vbox2Widget, 1 , 1);
 
     //  -------------------------- PROTOCOLS LISTBOX ----------------------------------
 
     QGroupBox *protocolGrp = createFrame(i18n("Protocols"), this);
     QGridLayout *protocolGrid = createGridLayout(protocolGrp);
 
     protocolList = new KrListWidget(protocolGrp);
     loadProtocols();
     protocolGrid->addWidget(protocolList, 0, 0);
 
     KgProtocolsLayout->addWidget(protocolGrp, 0 , 2);
 
     //  -------------------------- MIMES LISTBOX ----------------------------------
 
     QGroupBox *mimeGrp = createFrame(i18n("MIMEs"), this);
     QGridLayout *mimeGrid = createGridLayout(mimeGrp);
 
     mimeList = new KrListWidget(mimeGrp);
     loadMimes();
     mimeGrid->addWidget(mimeList, 0, 0);
 
     KgProtocolsLayout->addWidget(mimeGrp, 1 , 2);
 
     //  -------------------------- CONNECT TABLE ----------------------------------
 
     connect(protocolList,      &KrListWidget::itemSelectionChanged, this, &KgProtocols::slotDisableButtons);
     connect(linkList,          &KrTreeWidget::itemSelectionChanged, this, &KgProtocols::slotDisableButtons);
     connect(mimeList,          &KrListWidget::itemSelectionChanged, this, &KgProtocols::slotDisableButtons);
     connect(linkList,          &KrTreeWidget::currentItemChanged  , this, &KgProtocols::slotDisableButtons);
     connect(btnAddProtocol,    &QPushButton::clicked              , this, &KgProtocols::slotAddProtocol);
     connect(btnRemoveProtocol, &QPushButton::clicked              , this, &KgProtocols::slotRemoveProtocol);
     connect(btnAddMime,        &QPushButton::clicked              , this, &KgProtocols::slotAddMime);
     connect(btnRemoveMime,     &QPushButton::clicked              , this, &KgProtocols::slotRemoveMime);
 
     loadInitialValues();
     slotDisableButtons();
 }
 
 void KgProtocols::addSpacer(QBoxLayout *layout)
 {
     layout->addItem(new QSpacerItem(20, 20, QSizePolicy::Minimum, QSizePolicy::Expanding));
 }
 
 void KgProtocols::loadProtocols()
 {
     QStringList protocols = KProtocolInfo::protocols();
     protocols.sort();
 
     foreach(const QString &protocol, protocols) {
         QUrl u;
         u.setScheme(protocol);
         if(KProtocolManager::inputType(u) == KProtocolInfo::T_FILESYSTEM) {
             protocolList->addItem(protocol);
         }
     }
 }
 
 void KgProtocols::loadMimes()
 {
     QMimeDatabase db;
     QList<QMimeType> mimes = db.allMimeTypes();
 
     for (QList<QMimeType>::const_iterator it = mimes.constBegin(); it != mimes.constEnd(); ++it)
         mimeList->addItem((*it).name());
 
     mimeList->sortItems();
 }
 
 void KgProtocols::slotDisableButtons()
 {
     btnAddProtocol->setEnabled(protocolList->selectedItems().count() != 0);
     QTreeWidgetItem *listViewItem = linkList->currentItem();
-    bool isProtocolSelected = (listViewItem == 0 ? false : listViewItem->parent() == 0);
+    bool isProtocolSelected = (listViewItem == nullptr ? false : listViewItem->parent() == nullptr);
     btnRemoveProtocol->setEnabled(isProtocolSelected);
-    btnAddMime->setEnabled(listViewItem != 0 && mimeList->selectedItems().count() != 0);
-    btnRemoveMime->setEnabled(listViewItem == 0 ? false : listViewItem->parent() != 0);
+    btnAddMime->setEnabled(listViewItem != nullptr && mimeList->selectedItems().count() != 0);
+    btnRemoveMime->setEnabled(listViewItem == nullptr ? false : listViewItem->parent() != nullptr);
 
-    if (linkList->currentItem() == 0 && linkList->topLevelItemCount() != 0)
+    if (linkList->currentItem() == nullptr && linkList->topLevelItemCount() != 0)
         linkList->setCurrentItem(linkList->topLevelItem(0));
 
     QList<QTreeWidgetItem *> list = linkList->selectedItems();
-    if (list.count() == 0 && linkList->currentItem() != 0)
+    if (list.count() == 0 && linkList->currentItem() != nullptr)
         linkList->currentItem()->setSelected(true);
 }
 
 void KgProtocols::slotAddProtocol()
 {
     QList<QListWidgetItem *> list = protocolList->selectedItems();
 
     if (list.count() > 0) {
         addProtocol(list[ 0 ]->text(), true);
         slotDisableButtons();
         emit sigChanged();
     }
 }
 
-void KgProtocols::addProtocol(QString name, bool changeCurrent)
+void KgProtocols::addProtocol(const QString& name, bool changeCurrent)
 {
     QList<QListWidgetItem *> list = protocolList->findItems(name, Qt::MatchExactly);
     if (list.count() > 0) {
         delete list[ 0 ];
-        QTreeWidgetItem *listViewItem = new QTreeWidgetItem(linkList);
+        auto *listViewItem = new QTreeWidgetItem(linkList);
         listViewItem->setText(0, name);
         QString iconName = KProtocolInfo::icon(name);
         if (iconName.isEmpty())
             iconName = "go-next-view";
         listViewItem->setIcon(0, Icon(iconName));
 
         if (changeCurrent)
             linkList->setCurrentItem(listViewItem);
     }
 }
 
 void KgProtocols::slotRemoveProtocol()
 {
     QTreeWidgetItem *item = linkList->currentItem();
     if (item) {
         removeProtocol(item->text(0));
         slotDisableButtons();
         emit sigChanged();
     }
 }
 
-void KgProtocols::removeProtocol(QString name)
+void KgProtocols::removeProtocol(const QString& name)
 {
     QList<QTreeWidgetItem *> itemList = linkList->findItems(name, Qt::MatchExactly, 0);
 
     if (itemList.count()) {
         QTreeWidgetItem *item = itemList[ 0 ];
 
         while (item->childCount() != 0)
             removeMime(item->child(0)->text(0));
 
         linkList->takeTopLevelItem(linkList->indexOfTopLevelItem(item));
         protocolList->addItem(name);
         protocolList->sortItems();
     }
 }
 
 void KgProtocols::slotAddMime()
 {
     QList<QListWidgetItem *> list = mimeList->selectedItems();
-    if (list.count() > 0 && linkList->currentItem() != 0) {
+    if (list.count() > 0 && linkList->currentItem() != nullptr) {
         QTreeWidgetItem *itemToAdd = linkList->currentItem();
         if (itemToAdd->parent())
             itemToAdd = itemToAdd->parent();
 
         addMime(list[ 0 ]->text(), itemToAdd->text(0));
         slotDisableButtons();
         emit sigChanged();
     }
 }
 
-void KgProtocols::addMime(QString name, QString protocol)
+void KgProtocols::addMime(QString name, const QString& protocol)
 {
     QList<QListWidgetItem *> list = mimeList->findItems(name, Qt::MatchExactly);
 
     QList<QTreeWidgetItem *> itemList = linkList->findItems(protocol, Qt::MatchExactly | Qt::MatchRecursive, 0);
 
-    QTreeWidgetItem *currentListItem = 0;
+    QTreeWidgetItem *currentListItem = nullptr;
     if (itemList.count() != 0)
         currentListItem = itemList[ 0 ];
 
-    if (list.count() > 0 && currentListItem && currentListItem->parent() == 0) {
+    if (list.count() > 0 && currentListItem && currentListItem->parent() == nullptr) {
         delete list[ 0 ];
-        QTreeWidgetItem *listViewItem = new QTreeWidgetItem(currentListItem);
+        auto *listViewItem = new QTreeWidgetItem(currentListItem);
         listViewItem->setText(0, name);
         listViewItem->setIcon(0, Icon(name.replace(QLatin1Char('/'), QLatin1Char('-')), Icon("unknown")));
         linkList->expandItem( currentListItem );
     }
 }
 
 void KgProtocols::slotRemoveMime()
 {
     QTreeWidgetItem *item = linkList->currentItem();
     if (item) {
         removeMime(item->text(0));
         slotDisableButtons();
         emit sigChanged();
     }
 }
 
-void KgProtocols::removeMime(QString name)
+void KgProtocols::removeMime(const QString& name)
 {
     QList<QTreeWidgetItem *> itemList = linkList->findItems(name, Qt::MatchExactly | Qt::MatchRecursive, 0);
 
-    QTreeWidgetItem *currentMimeItem = 0;
+    QTreeWidgetItem *currentMimeItem = nullptr;
     if (itemList.count() != 0)
         currentMimeItem = itemList[ 0 ];
 
-    if (currentMimeItem && currentMimeItem->parent() != 0) {
+    if (currentMimeItem && currentMimeItem->parent() != nullptr) {
         mimeList->addItem(currentMimeItem->text(0));
         mimeList->sortItems();
         currentMimeItem->parent()->removeChild(currentMimeItem);
     }
 }
 
 void KgProtocols::loadInitialValues()
 {
     if (linkList->model()->rowCount() > 0)
         while (linkList->topLevelItemCount() != 0)
             removeProtocol(linkList->topLevelItem(0)->text(0));
 
     KConfigGroup group(krConfig, "Protocols");
     QStringList protList = group.readEntry("Handled Protocols", QStringList());
 
-    for (QStringList::Iterator it = protList.begin(); it != protList.end(); ++it) {
-        addProtocol(*it);
+    for (auto & it : protList) {
+        addProtocol(it);
 
-        QStringList mimes = group.readEntry(QString("Mimes For %1").arg(*it), QStringList());
+        QStringList mimes = group.readEntry(QString("Mimes For %1").arg(it), QStringList());
 
-        for (QStringList::Iterator it2 = mimes.begin(); it2 != mimes.end(); ++it2)
-            addMime(*it2, *it);
+        for (auto & mime : mimes)
+            addMime(mime, it);
     }
 
     if (linkList->topLevelItemCount() != 0)
         linkList->setCurrentItem(linkList->topLevelItem(0));
     slotDisableButtons();
     linkList->expandAll();
     emit sigChanged();
 }
 
 void KgProtocols::setDefaults()
 {
     while (linkList->topLevelItemCount() != 0)
         removeProtocol(linkList->topLevelItem(0)->text(0));
 
     slotDisableButtons();
 
     if (isChanged())
         emit sigChanged();
 }
 
 bool KgProtocols::isChanged()
 {
     KConfigGroup group(krConfig, "Protocols");
     QStringList protList = group.readEntry("Handled Protocols", QStringList());
 
     if ((int)protList.count() != linkList->topLevelItemCount())
         return true;
 
     for (int i = 0; i != linkList->topLevelItemCount(); i++) {
         QTreeWidgetItem *item = linkList->topLevelItem(i);
 
         if (!protList.contains(item->text(0)))
             return true;
 
         QStringList mimes = group.readEntry(QString("Mimes For %1").arg(item->text(0)), QStringList());
 
         if ((int)mimes.count() != item->childCount())
             return true;
 
         for (int j = 0; j != item->childCount(); j++) {
             QTreeWidgetItem *children = item->child(j);
 
             if (!mimes.contains(children->text(0)))
                 return true;
         }
     }
 
     return false;
 }
 
 bool KgProtocols::apply()
 {
     KConfigGroup group(krConfig, "Protocols");
 
     QStringList protocolList;
 
     for (int i = 0; i != linkList->topLevelItemCount(); i++) {
         QTreeWidgetItem *item = linkList->topLevelItem(i);
 
         protocolList.append(item->text(0));
 
         QStringList mimes;
 
         for (int j = 0; j != item->childCount(); j++) {
             QTreeWidgetItem *children = item->child(j);
 
             mimes.append(children->text(0));
         }
         group.writeEntry(QString("Mimes For %1").arg(item->text(0)), mimes);
     }
     group.writeEntry("Handled Protocols", protocolList);
     krConfig->sync();
 
     KrServices::clearProtocolCache();
 
     emit sigChanged();
     return false;
 }
 
 void KgProtocols::init()
 {
 }
diff --git a/krusader/Konfigurator/kgprotocols.h b/krusader/Konfigurator/kgprotocols.h
index 35d05602..5237bcd5 100644
--- a/krusader/Konfigurator/kgprotocols.h
+++ b/krusader/Konfigurator/kgprotocols.h
@@ -1,73 +1,73 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGPROTOCOLS_H
 #define KGPROTOCOLS_H
 
 // QtWidgets
 #include <QPushButton>
 
 #include "konfiguratorpage.h"
 #include "../GUI/krtreewidget.h"
 #include "../GUI/krlistwidget.h"
 
 class KgProtocols : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgProtocols(bool first, QWidget* parent = 0);
+    explicit KgProtocols(bool first, QWidget* parent = nullptr);
 
-    virtual void loadInitialValues() Q_DECL_OVERRIDE;
-    virtual void setDefaults() Q_DECL_OVERRIDE;
-    virtual bool apply() Q_DECL_OVERRIDE;
-    virtual bool isChanged() Q_DECL_OVERRIDE;
+    void loadInitialValues() Q_DECL_OVERRIDE;
+    void setDefaults() Q_DECL_OVERRIDE;
+    bool apply() Q_DECL_OVERRIDE;
+    bool isChanged() Q_DECL_OVERRIDE;
 
     static  void init();
 
 public slots:
     void         slotDisableButtons();
     void         slotAddProtocol();
     void         slotRemoveProtocol();
     void         slotAddMime();
     void         slotRemoveMime();
 
 protected:
     void         loadProtocols();
     void         loadMimes();
     void         addSpacer(QBoxLayout *parent);
 
-    void         addProtocol(QString name, bool changeCurrent = false);
-    void         removeProtocol(QString name);
-    void         addMime(QString name, QString protocol);
-    void         removeMime(QString name);
+    void         addProtocol(const QString& name, bool changeCurrent = false);
+    void         removeProtocol(const QString& name);
+    void         addMime(QString name, const QString& protocol);
+    void         removeMime(const QString& name);
 
     KrTreeWidget *linkList;
 
     KrListWidget *protocolList;
     KrListWidget *mimeList;
 
     QPushButton *btnAddProtocol;
     QPushButton *btnRemoveProtocol;
     QPushButton *btnAddMime;
     QPushButton *btnRemoveMime;
 };
 
 #endif /* __KgProtocols_H__ */
diff --git a/krusader/Konfigurator/kgstartup.cpp b/krusader/Konfigurator/kgstartup.cpp
index d5905e61..ea9027a5 100644
--- a/krusader/Konfigurator/kgstartup.cpp
+++ b/krusader/Konfigurator/kgstartup.cpp
@@ -1,140 +1,140 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kgstartup.h"
 #include "../defaults.h"
 #include "../GUI/profilemanager.h"
 
 // QtWidgets
 #include <QGridLayout>
 #include <QLabel>
 
 #include <KCompletion/KLineEdit>
 #include <KI18n/KLocalizedString>
 
 KgStartup::KgStartup(bool first, QWidget* parent) :
-        KonfiguratorPage(first, parent), profileCombo(0)
+        KonfiguratorPage(first, parent), profileCombo(nullptr)
 {
     QWidget *innerWidget = new QFrame(this);
     setWidget(innerWidget);
     setWidgetResizable(true);
-    QGridLayout *kgStartupLayout = new QGridLayout(innerWidget);
+    auto *kgStartupLayout = new QGridLayout(innerWidget);
     kgStartupLayout->setSpacing(6);
 
     //  --------------------------- PANELS GROUPBOX ----------------------------------
 
     QGroupBox *panelsGrp = createFrame(i18n("General"), innerWidget);
     QGridLayout *panelsGrid = createGridLayout(panelsGrp);
 
     QString s = "<p><img src='toolbar|user-identity'></p>" + i18n("Defines the panel profile used at startup. A panel profile contains:<ul><li>all the tabs paths</li><li>the current tab</li><li>the active panel</li></ul><b>&lt;Last session&gt;</b> is a special panel profile which is saved automatically when Krusader is closed.");
     QLabel *label = addLabel(panelsGrid, 0, 0, i18n("Startup profile:"), panelsGrp);
     label->setWhatsThis(s);
     panelsGrp->setWhatsThis(s);
 
     QStringList profileList = ProfileManager::availableProfiles("Panel");
     profileList.push_front(i18n("<Last session>"));
 
     const int profileListSize = profileList.size();
-    KONFIGURATOR_NAME_VALUE_PAIR *comboItems = new KONFIGURATOR_NAME_VALUE_PAIR[ profileListSize ];
+    auto *comboItems = new KONFIGURATOR_NAME_VALUE_PAIR[ profileListSize ];
     for (int i = 0; i != profileListSize; i++)
         comboItems[ i ].text = comboItems[ i ].value = profileList [ i ];
     comboItems[ 0 ].value = "";
 
     profileCombo = createComboBox("Startup", "Starter Profile Name", comboItems[ 0 ].value, comboItems, profileListSize, panelsGrp, false, false);
     profileCombo->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     panelsGrid->addWidget(profileCombo, 0, 1);
 
     delete [] comboItems;
 
     //------------------------------------------------
     panelsGrid->addWidget(createLine(panelsGrp), 1, 0, 1, 2);
 
     KONFIGURATOR_CHECKBOX_PARAM settings[] = { //   cfg_class  cfg_name                default             text                              restart tooltip
         {"Look&Feel", "Show splashscreen",  _ShowSplashScreen, i18n("Show splashscreen"), false,  i18n("Display a splashscreen when starting Krusader.") },
         {"Look&Feel", "Single Instance Mode", _SingleInstanceMode, i18n("Single instance mode"), false,  i18n("Only one Krusader instance is allowed to run.") }
     };
 
     KonfiguratorCheckBoxGroup* cbs = createCheckBoxGroup(2, 0, settings, 2 /* settings count */, panelsGrp);
     panelsGrid->addWidget(cbs, 2, 0, 1, 2);
 
-    QHBoxLayout *iconThemeLayout = new QHBoxLayout();
+    auto *iconThemeLayout = new QHBoxLayout();
     QLabel *iconThemeLabel = new QLabel(i18n("Fallback Icon Theme:"));
     iconThemeLabel->setWhatsThis(i18n("Whenever icon is not found in system icon theme, "
                                       "this theme will be used as a fallback. "
                                       "If fallback theme doesn't contain the icon, "
                                       "Breeze or Oxygen will be used if any of these are present."));
     iconThemeLayout->addWidget(iconThemeLabel);
     KonfiguratorEditBox *iconThemeEditBox = createEditBox("Startup", "Fallback Icon Theme", "",
                                                           panelsGrp, true);
     iconThemeLayout->addWidget(iconThemeEditBox);
     iconThemeLayout->addStretch(1);
     panelsGrid->addLayout(iconThemeLayout, 3, 0, 1, 2);
 
     kgStartupLayout->addWidget(panelsGrp, 0, 0);
 
     //  ------------------------ USERINTERFACE GROUPBOX ------------------------------
 
     QGroupBox *uiGrp = createFrame(i18n("User Interface"), innerWidget);
     QGridLayout *uiGrid = createGridLayout(uiGrp);
 
     KONFIGURATOR_CHECKBOX_PARAM uiSettings[] = {
         // cfg_class cfg_name default text restart tooltip
         {"Startup", "Remember Position", _RememberPos,i18n("Save last position, size and panel settings"), false,
             i18n("<p>At startup, the main window will resize itself to the size it was when last shutdown. "
                  "It will also appear in the same location of the screen, having panels sorted and aligned as they were before.</p> "
                  "<p>If this option is disabled, you can use the menu <i>Window -> Save Position</i> option "
                  "to manually set the main window's size and position at startup.</p>") },
         {"Startup", "Update Default Panel Settings", _RememberPos, i18n("Update default panel settings"), true,
             i18n("When settings of a panel are changed, save them as the default for new panels of the same type.") },
         {"Startup", "Start To Tray", _StartToTray, i18n("Start to tray"), false,
             i18n("Krusader starts to tray, without showing the main window") },
     };
 
     KonfiguratorCheckBoxGroup *uiSettingsGroup = createCheckBoxGroup(1, 0, uiSettings, 3, uiGrp);
     uiGrid->addWidget(uiSettingsGroup, 1, 0);
 
    KONFIGURATOR_CHECKBOX_PARAM uiCheckBoxes[] = { //   cfg_class, cfg_name, default, text, restart, ToolTip
         {"Startup", "UI Save Settings", _UiSave, i18n("Save component settings on exit"), false,
             i18n("Check the state of the user interface components and restore them to their condition when last shutdown.") },
         {"Startup", "Show FN Keys",  _ShowFNkeys, i18n("Show function keys"), false, i18n("Function keys will be visible after startup.") },
         {"Startup", "Show Cmd Line",  _ShowCmdline,  i18n("Show command line"), false, i18n("Command line will be visible after startup.") },
         {"Startup", "Show Terminal Emulator", _ShowTerminalEmulator, i18n("Show embedded terminal"),  false,
             i18n("Embedded terminal will be visible after startup.") },
     };
 
     uiCbGroup = createCheckBoxGroup(1, 0, uiCheckBoxes, 4, uiGrp);
     connect(uiCbGroup->find("UI Save Settings"), &KonfiguratorCheckBox::stateChanged, this, &KgStartup::slotDisable);
 
     uiGrid->addWidget(uiCbGroup, 2, 0);
 
     slotDisable();
 
     kgStartupLayout->addWidget(uiGrp, 1, 0);
 }
 
 void KgStartup::slotDisable()
 {
     bool isUiSave   = !uiCbGroup->find("UI Save Settings")->isChecked();
 
     int i = 1;
     while (uiCbGroup->find(i))
         uiCbGroup->find(i++)->setEnabled(isUiSave);
 }
 
diff --git a/krusader/Konfigurator/kgstartup.h b/krusader/Konfigurator/kgstartup.h
index af7b1de7..504de2d0 100644
--- a/krusader/Konfigurator/kgstartup.h
+++ b/krusader/Konfigurator/kgstartup.h
@@ -1,42 +1,42 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGSTARTUP_H
 #define KGSTARTUP_H
 
 #include "konfiguratorpage.h"
 
 class KgStartup : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgStartup(bool first, QWidget* parent = 0);
+    explicit KgStartup(bool first, QWidget* parent = nullptr);
 
 public slots:
     void slotDisable();
 
 protected:
     KonfiguratorRadioButtons  *saveRadio;
     KonfiguratorCheckBoxGroup *uiCbGroup;
     KonfiguratorComboBox      *profileCombo;
 };
 
 #endif /* __KGSTARTUP_H__ */
diff --git a/krusader/Konfigurator/kguseractions.cpp b/krusader/Konfigurator/kguseractions.cpp
index 8bd372bc..f6b310dc 100644
--- a/krusader/Konfigurator/kguseractions.cpp
+++ b/krusader/Konfigurator/kguseractions.cpp
@@ -1,114 +1,114 @@
 /*****************************************************************************
  * Copyright (C) 2004 Jonas Bähr <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kguseractions.h"
 #include "../defaults.h"
 #include "../ActionMan/actionman.h"
 
 // QtWidgets
 #include <QGridLayout>
 #include <QLabel>
 #include <QPushButton>
 
 #include <KI18n/KLocalizedString>
 
 KgUserActions::KgUserActions(bool first, QWidget* parent) :
         KonfiguratorPage(first, parent)
 {
     QWidget *innerWidget = new QFrame(this);
     setWidget(innerWidget);
     setWidgetResizable(true);
-    QGridLayout *kgUserActionLayout = new QGridLayout(innerWidget);
+    auto *kgUserActionLayout = new QGridLayout(innerWidget);
 
     // ============= Info Group =============
     QGroupBox *InfoGroup = createFrame(i18n("Information"), innerWidget);
     QGridLayout *InfoGrid = createGridLayout(InfoGroup);
 
     // terminal for the UserActions
     QLabel *labelInfo = new QLabel(i18n(
                                        "Here you can configure settings about useractions.\n"
                                        "To set up, configure and manage your useractions please use ActionMan."
                                    ), InfoGroup);
     InfoGrid->addWidget(labelInfo, 0, 0);
     QPushButton *actionmanButton = new QPushButton(i18n("Start ActionMan"), InfoGroup);
     connect(actionmanButton, &QPushButton::clicked, this, &KgUserActions::startActionMan);
     InfoGrid->addWidget(actionmanButton, 1, 0);
 
     kgUserActionLayout->addWidget(InfoGroup, 0 , 0);
 
     // ============= Terminal Group =============
     QGroupBox *terminalGroup = createFrame(i18n("Terminal execution"), innerWidget);
     QGridLayout *terminalGrid = createGridLayout(terminalGroup);
 
     // terminal for the UserActions
     QLabel *labelTerminal = new QLabel(i18n("Terminal for UserActions:"),
                                        terminalGroup);
     terminalGrid->addWidget(labelTerminal, 0, 0);
     KonfiguratorURLRequester *urlReqUserActions = createURLRequester("UserActions",
             "Terminal", _UserActions_Terminal, terminalGroup, false, FIRST_PAGE, false);
     terminalGrid->addWidget(urlReqUserActions, 0, 1);
     labelTerminal = new QLabel(i18n("%t will be replaced by the title of the action,\n%d with the workdir."),
                                        terminalGroup);
     terminalGrid->addWidget(labelTerminal, 1, 1);
 
     kgUserActionLayout->addWidget(terminalGroup, 1 , 0);
 
     // ============= Outputcollection Group =============
     QGroupBox *outputGroup = createFrame(i18n("Output collection"), innerWidget);
     QGridLayout *outputGrid = createGridLayout(outputGroup);
 
     QWidget *hboxWidget = new QWidget(outputGroup);
-    QHBoxLayout *hbox = new QHBoxLayout(hboxWidget);
+    auto *hbox = new QHBoxLayout(hboxWidget);
     QLabel *lbel = new QLabel(i18n("Normal font:"), hboxWidget);
     hbox->addWidget(lbel);
 
     KonfiguratorFontChooser *chser = createFontChooser("UserActions", "Normal Font", _UserActions_NormalFont, hboxWidget);
     hbox->addWidget(chser);
 
     QWidget *spcer = createSpacer(hboxWidget);
     hbox->addWidget(spcer);
     outputGrid->addWidget(hboxWidget, 2, 0);
 
     hboxWidget = new QWidget(outputGroup);
     hbox = new QHBoxLayout(hboxWidget);
 
     lbel = new QLabel(i18n("Font with fixed width:"), hboxWidget);
     hbox->addWidget(lbel);
 
     chser = createFontChooser("UserActions", "Fixed Font", _UserActions_FixedFont, hboxWidget);
     hbox->addWidget(chser);
 
     spcer = createSpacer(hboxWidget);
     hbox->addWidget(spcer);
 
     outputGrid->addWidget(hboxWidget, 3, 0);
 
     KonfiguratorCheckBox *useFixed = createCheckBox("UserActions", "Use Fixed Font", _UserActions_UseFixedFont,
                                      i18n("Use fixed width font as default"), outputGroup);
     outputGrid->addWidget(useFixed, 4, 0);
 
     kgUserActionLayout->addWidget(outputGroup, 2 , 0);
 }
 
 void KgUserActions::startActionMan()
 {
     ActionMan actionMan(static_cast<QWidget*>(this));
 }
 
diff --git a/krusader/Konfigurator/kguseractions.h b/krusader/Konfigurator/kguseractions.h
index 0adbc343..e589582d 100644
--- a/krusader/Konfigurator/kguseractions.h
+++ b/krusader/Konfigurator/kguseractions.h
@@ -1,38 +1,38 @@
 /*****************************************************************************
  * Copyright (C) 2004 Jonas Bähr <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KGUSERACTIONS_H
 #define KGUSERACTIONS_H
 
 #include "konfiguratorpage.h"
 
 
 class KgUserActions : public KonfiguratorPage
 {
     Q_OBJECT
 
 public:
-    explicit KgUserActions(bool first, QWidget* parent = 0);
+    explicit KgUserActions(bool first, QWidget* parent = nullptr);
 
 public slots:
     void startActionMan();
 };
 
 #endif /* __KGUSERACTIONS_H__ */
diff --git a/krusader/Konfigurator/konfigurator.cpp b/krusader/Konfigurator/konfigurator.cpp
index 3862f044..ae75cceb 100644
--- a/krusader/Konfigurator/konfigurator.cpp
+++ b/krusader/Konfigurator/konfigurator.cpp
@@ -1,241 +1,241 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 
 #include "konfigurator.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../Dialogs/krdialogs.h"
 
 // QtGui
 #include <QPixmap>
 #include <QResizeEvent>
 
 #include <KConfigCore/KSharedConfig>
 #include <KConfigWidgets/KHelpClient>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "../defaults.h"
 #include "../krusaderview.h"
 #include "../GUI/kfnkeys.h"
 
 // the frames
 #include "kgstartup.h"
 #include "kgpanel.h"
 #include "kggeneral.h"
 #include "kgadvanced.h"
 #include "kgarchives.h"
 #include "kgdependencies.h"
 #include "kgcolors.h"
 #include "kguseractions.h"
 #include "kgprotocols.h"
 
-Konfigurator::Konfigurator(bool f, int startPage) : KPageDialog((QWidget *)0),
+Konfigurator::Konfigurator(bool f, int startPage) : KPageDialog((QWidget *)nullptr),
         firstTime(f), internalCall(false), sizeX(-1), sizeY(-1)
 {
     setWindowTitle(i18n("Konfigurator - Creating Your Own Krusader"));
     setWindowModality(Qt::ApplicationModal);
     setFaceType(KPageDialog::List);
 
     setStandardButtons(QDialogButtonBox::Help|QDialogButtonBox::RestoreDefaults|QDialogButtonBox::Close|
                        QDialogButtonBox::Apply|QDialogButtonBox::Reset);
     button(QDialogButtonBox::Apply)->setDefault(true);
 
     connect(button(QDialogButtonBox::Close), &QPushButton::clicked, this, &Konfigurator::slotClose);
     connect(button(QDialogButtonBox::Help), &QPushButton::clicked, this, &Konfigurator::slotShowHelp);
     connect(button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked, this, &Konfigurator::slotRestoreDefaults);
     connect(button(QDialogButtonBox::Reset), &QPushButton::clicked, this, &Konfigurator::slotReset);
     connect(button(QDialogButtonBox::Apply), &QPushButton::clicked, this, &Konfigurator::slotApply);
     connect(this, &Konfigurator::currentPageChanged, this, &Konfigurator::slotPageSwitch);
     connect(&restoreTimer, &QTimer::timeout, this, &Konfigurator::slotRestorePage);
 
     createLayout(startPage);
 
     KConfigGroup group(krConfig, "Konfigurator");
     int sx = group.readEntry("Window Width", -1);
     int sy = group.readEntry("Window Height", -1);
 
     if (sx != -1 && sy != -1)
         resize(sx, sy);
     else
         resize(900, 680);
 
     if (group.readEntry("Window Maximized",  false))
         showMaximized();
     else
         show();
 }
 
 void Konfigurator::resizeEvent(QResizeEvent *e)
 {
     if (!isMaximized()) {
         sizeX = e->size().width();
         sizeY = e->size().height();
     }
     QDialog::resizeEvent(e);
 }
 
 void Konfigurator::closeDialog()
 {
     KConfigGroup group(krConfig, "Konfigurator");
 
     group.writeEntry("Window Width", sizeX);
     group.writeEntry("Window Height", sizeY);
     group.writeEntry("Window Maximized", isMaximized());
 }
 
 void Konfigurator::reject()
 {
     closeDialog();
     QDialog::reject();
 }
 
 void Konfigurator::newPage(KonfiguratorPage *page, const QString &name, const QString &desc, const QIcon &icon)
 {
-    KPageWidgetItem *item = new KPageWidgetItem(page, name);
+    auto *item = new KPageWidgetItem(page, name);
     item->setIcon(icon);
     item->setHeader(desc);
     addPage(item);
 
     kgPages.append(item);
     connect(page, &KonfiguratorPage::sigChanged, this, &Konfigurator::slotApplyEnable);
 }
 
 void Konfigurator::createLayout(int startPage)
 {
     // startup
     newPage(new KgStartup(firstTime, this), i18n("Startup"), i18n("Krusader's settings upon startup"), Icon("go-home"));
     // panel
     newPage(new KgPanel(firstTime, this), i18n("Panel"), i18n("Panel"), Icon("view-choose"));
     // colors
     newPage(new KgColors(firstTime, this), i18n("Colors"), i18n("Colors"), Icon("color-picker"));
     // general
     newPage(new KgGeneral(firstTime, this), i18n("General"), i18n("Basic Operations"), Icon("system-run"));
     // advanced
     newPage(new KgAdvanced(firstTime, this), i18n("Advanced"), i18n("Be sure you know what you are doing."), Icon("dialog-messages"));
     // archives
     newPage(new KgArchives(firstTime, this), i18n("Archives"), i18n("Customize the way Krusader deals with archives"),
             Icon("archive-extract"));
     // dependencies
     newPage(new KgDependencies(firstTime, this), i18n("Dependencies"), i18n("Set the full path of the external applications"),
             Icon("debug-run"));
     // useractions
     newPage(new KgUserActions(firstTime, this), i18n("User Actions"), i18n("Configure your personal actions"),
             Icon("user-properties"));
     // protocols
     newPage(new KgProtocols(firstTime, this), i18n("Protocols"), i18n("Link MIMEs to protocols"),
             Icon("document-preview"));
 
     setCurrentPage(kgPages.at(startPage));
     slotApplyEnable();
 }
 
 void Konfigurator::closeEvent(QCloseEvent *event)
 {
     lastPage = currentPage();
     if(slotPageSwitch(lastPage, lastPage)) {
         hide();
         KPageDialog::closeEvent(event);
     } else
         event->ignore();
 }
 
 void Konfigurator::slotApplyEnable()
 {
     lastPage = currentPage();
     bool isChanged = ((KonfiguratorPage *)(lastPage->widget()))->isChanged();
     button(QDialogButtonBox::Apply)->setEnabled(isChanged);
     button(QDialogButtonBox::Reset)->setEnabled(isChanged);
 }
 
 bool Konfigurator::slotPageSwitch(KPageWidgetItem *current, KPageWidgetItem *before)
 {
-    if (before == 0)
+    if (before == nullptr)
         return true;
 
-    KonfiguratorPage *currentPg = (KonfiguratorPage *)(before->widget());
+    auto *currentPg = (KonfiguratorPage *)(before->widget());
 
     if (internalCall) {
         internalCall = false;
         return true;
     }
 
     if (currentPg->isChanged()) {
-        int result = KMessageBox::questionYesNoCancel(0, i18n("The current page has been changed. Do you want to apply changes?"));
+        int result = KMessageBox::questionYesNoCancel(nullptr, i18n("The current page has been changed. Do you want to apply changes?"));
 
         switch (result) {
         case KMessageBox::No:
             currentPg->loadInitialValues();
             currentPg->apply();
             break;
         case KMessageBox::Yes:
             emit configChanged(currentPg->apply());
             break;
         default:
             restoreTimer.setSingleShot(true);
             restoreTimer.start(0);
             return false;
         }
     }
 
     button(QDialogButtonBox::Apply)->setEnabled(currentPg->isChanged());
     lastPage = current;
     return true;
 }
 
 void Konfigurator::slotRestorePage()
 {
     if (lastPage != currentPage()) {
         internalCall = true;
         setCurrentPage(lastPage);
     }
 }
 
 void Konfigurator::slotClose()
 {
     lastPage = currentPage();
     if (slotPageSwitch(lastPage, lastPage)) {
         reject();
     }
 }
 
 void Konfigurator::slotApply()
 {
     emit configChanged(((KonfiguratorPage*)(currentPage()->widget()))->apply());
 }
 
 void Konfigurator::slotReset()
 {
     ((KonfiguratorPage *)(currentPage()->widget()))->loadInitialValues();
 }
 
 void Konfigurator::slotRestoreDefaults()
 {
     ((KonfiguratorPage *)(currentPage()->widget()))->setDefaults();
 }
 
 void Konfigurator::slotShowHelp()
 {
     KHelpClient::invokeHelp(QStringLiteral("konfigurator"));
 }
 
diff --git a/krusader/Konfigurator/konfiguratoritems.cpp b/krusader/Konfigurator/konfiguratoritems.cpp
index 78b8f1ab..9aba3d76 100644
--- a/krusader/Konfigurator/konfiguratoritems.cpp
+++ b/krusader/Konfigurator/konfiguratoritems.cpp
@@ -1,836 +1,837 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "konfiguratoritems.h"
 
 #include "../krglobal.h"
 #include "../icon.h"
 
 // QtCore
 #include <QMetaMethod>
 // QtGui
 #include <QPainter>
 #include <QPen>
 #include <QPixmap>
 // QtWidgets
 #include <QColorDialog>
 #include <QFontDialog>
 #include <QLabel>
 
 #include <KCompletion/KLineEdit>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
+#include <utility>
 
 
 KonfiguratorExtension::KonfiguratorExtension(QObject *obj, QString cfgGroup, QString cfgName,
                                              bool restartNeeded, int page)
-    : QObject(), objectPtr(obj), applyConnected(false), setDefaultsConnected(false), changed(false),
-      restartNeeded(restartNeeded), subpage(page), configGroup(cfgGroup), configName(cfgName)
+    : objectPtr(obj), applyConnected(false), setDefaultsConnected(false), changed(false),
+      restartNeeded(restartNeeded), subpage(page), configGroup(std::move(cfgGroup)), configName(std::move(cfgName))
 {
 }
 
 void KonfiguratorExtension::connectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&KonfiguratorExtension::applyManually))
         applyConnected = true;
     else if (signal == QMetaMethod::fromSignal(&KonfiguratorExtension::setDefaultsManually))
         setDefaultsConnected = true;
 
     QObject::connectNotify(signal);
 }
 
 bool KonfiguratorExtension::apply()
 {
     if (!changed)
         return false;
 
     if (applyConnected)
         emit applyManually(objectPtr, configGroup, configName);
     else
         emit applyAuto(objectPtr, configGroup, configName);
 
     setChanged(false);
     return restartNeeded;
 }
 
 void KonfiguratorExtension::setDefaults()
 {
     if (setDefaultsConnected)
         emit setDefaultsManually(objectPtr);
     else
         emit setDefaultsAuto(objectPtr);
 }
 
 void KonfiguratorExtension::loadInitialValue()
 {
     emit setInitialValue(objectPtr);
 }
 
 bool KonfiguratorExtension::isChanged()
 {
     return changed;
 }
 
 // KonfiguratorCheckBox class
 ///////////////////////////////
 
-KonfiguratorCheckBox::KonfiguratorCheckBox(QString configGroup, QString name, bool defaultValue, QString text,
+KonfiguratorCheckBox::KonfiguratorCheckBox(QString configGroup, QString name, bool defaultValue, const QString& text,
         QWidget *parent, bool restart, int page) : QCheckBox(text, parent),
         defaultValue(defaultValue)
 {
-    ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(name), restart, page);
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorCheckBox::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorCheckBox::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorCheckBox::loadInitialValue);
 
     connect(this, &KonfiguratorCheckBox::stateChanged, ext, QOverload<>::of(&KonfiguratorExtension::setChanged));
     loadInitialValue();
 }
 
 KonfiguratorCheckBox::~KonfiguratorCheckBox()
 {
     delete ext;
 }
 
 void KonfiguratorCheckBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     setChecked(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
 void KonfiguratorCheckBox::checkStateSet()
 {
     QCheckBox::checkStateSet();
     updateDeps();
 }
 
 void KonfiguratorCheckBox::nextCheckState()
 {
     QCheckBox::nextCheckState();
     updateDeps();
 }
 
 void KonfiguratorCheckBox::addDep(KonfiguratorCheckBox *dep)
 {
     deps << dep;
     dep->setEnabled(isChecked());
 }
 
 void KonfiguratorCheckBox::updateDeps()
 {
     foreach(KonfiguratorCheckBox *dep, deps)
         dep->setEnabled(isChecked());
 }
 
-void KonfiguratorCheckBox::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorCheckBox::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, isChecked());
 }
 
 void KonfiguratorCheckBox::slotSetDefaults(QObject *)
 {
     if (isChecked() != defaultValue)
         setChecked(defaultValue);
 }
 
 
 // KonfiguratorSpinBox class
 ///////////////////////////////
 
 KonfiguratorSpinBox::KonfiguratorSpinBox(QString configGroup, QString configName, int defaultValue,
                                          int min, int max, QWidget *parent, bool restartNeeded,
                                          int page)
     : QSpinBox(parent), defaultValue(defaultValue)
 {
-    ext = new KonfiguratorExtension(this, configGroup, configName, restartNeeded, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(configName), restartNeeded, page);
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorSpinBox::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorSpinBox::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorSpinBox::loadInitialValue);
 
     connect(this, QOverload<int>::of(&KonfiguratorSpinBox::valueChanged), ext, QOverload<>::of(&KonfiguratorExtension::setChanged));
 
     setMinimum(min);
     setMaximum(max);
 
     loadInitialValue();
 }
 
 KonfiguratorSpinBox::~KonfiguratorSpinBox()
 {
     delete ext;
 }
 
 void KonfiguratorSpinBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     setValue(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
-void KonfiguratorSpinBox::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorSpinBox::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, value());
 }
 
 void KonfiguratorSpinBox::slotSetDefaults(QObject *)
 {
     if (value() != defaultValue)
         setValue(defaultValue);
 }
 
 // KonfiguratorCheckBoxGroup class
 ///////////////////////////////
 
 void KonfiguratorCheckBoxGroup::add(KonfiguratorCheckBox *checkBox)
 {
     checkBoxList.append(checkBox);
 }
 
 KonfiguratorCheckBox * KonfiguratorCheckBoxGroup::find(int index)
 {
     if (index < 0 || index >= checkBoxList.count())
-        return 0;
+        return nullptr;
     return checkBoxList.at(index);
 }
 
-KonfiguratorCheckBox * KonfiguratorCheckBoxGroup::find(QString name)
+KonfiguratorCheckBox * KonfiguratorCheckBoxGroup::find(const QString& name)
 {
     QListIterator<KonfiguratorCheckBox *> it(checkBoxList);
     while (it.hasNext()) {
         KonfiguratorCheckBox * checkBox = it.next();
 
         if (checkBox->extension()->getConfigName() == name)
             return checkBox;
     }
 
-    return 0;
+    return nullptr;
 }
 
 
 // KonfiguratorRadioButtons class
 ///////////////////////////////
 
 KonfiguratorRadioButtons::KonfiguratorRadioButtons(QString configGroup, QString name,
         QString defaultValue, QWidget *parent, bool restart, int page) :
-        QWidget(parent), defaultValue(defaultValue)
+        QWidget(parent), defaultValue(std::move(defaultValue))
 {
-    ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(name), restart, page);
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorRadioButtons::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorRadioButtons::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorRadioButtons::loadInitialValue);
 }
 
 KonfiguratorRadioButtons::~KonfiguratorRadioButtons()
 {
     delete ext;
 }
 
-void KonfiguratorRadioButtons::addRadioButton(QRadioButton *radioWidget, QString name, QString value)
+void KonfiguratorRadioButtons::addRadioButton(QRadioButton *radioWidget, const QString& name, const QString& value)
 {
     radioButtons.append(radioWidget);
     radioNames.push_back(name);
     radioValues.push_back(value);
 
     connect(radioWidget, &QRadioButton::toggled, ext, QOverload<>::of(&KonfiguratorExtension::setChanged));
 }
 
 QRadioButton * KonfiguratorRadioButtons::find(int index)
 {
     if (index < 0 || index >= radioButtons.count())
-        return 0;
+        return nullptr;
 
     return radioButtons.at(index);
 }
 
-QRadioButton * KonfiguratorRadioButtons::find(QString name)
+QRadioButton * KonfiguratorRadioButtons::find(const QString& name)
 {
     int index = radioNames.indexOf(name);
     if (index == -1)
-        return 0;
+        return nullptr;
 
     return radioButtons.at(index);
 }
 
-void KonfiguratorRadioButtons::selectButton(QString value)
+void KonfiguratorRadioButtons::selectButton(const QString& value)
 {
     int cnt = 0;
 
     QListIterator<QRadioButton *> it(radioButtons);
     while (it.hasNext()) {
         QRadioButton * btn = it.next();
 
         if (value == radioValues[ cnt ]) {
             btn->setChecked(true);
             return;
         }
 
         cnt++;
     }
 
     if (!radioButtons.isEmpty())
         radioButtons.first()->setChecked(true);
 }
 
 void KonfiguratorRadioButtons::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     QString initValue = group.readEntry(ext->getConfigName(), defaultValue);
 
     selectButton(initValue);
     ext->setChanged(false);
 }
 
 QString KonfiguratorRadioButtons::selectedValue()
 {
     int cnt = 0;
 
     QListIterator<QRadioButton *> it(radioButtons);
     while (it.hasNext()) {
         QRadioButton * btn = it.next();
 
         if (btn->isChecked()) {
             return radioValues[ cnt ];
         }
 
         cnt++;
     }
     return QString();
 }
 
-void KonfiguratorRadioButtons::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorRadioButtons::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     QString value = selectedValue();
 
     if (!value.isEmpty())
         KConfigGroup(krConfig, configGroup).writeEntry(name, value);
 }
 
 void KonfiguratorRadioButtons::slotSetDefaults(QObject *)
 {
     selectButton(defaultValue);
 }
 
 // KonfiguratorEditBox class
 ///////////////////////////////
 
 KonfiguratorEditBox::KonfiguratorEditBox(QString configGroup, QString name, QString defaultValue,
         QWidget *parent, bool restart, int page) : QLineEdit(parent),
-        defaultValue(defaultValue)
+        defaultValue(std::move(defaultValue))
 {
-    ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(name), restart, page);
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorEditBox::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorEditBox::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorEditBox::loadInitialValue);
 
     connect(this, &KonfiguratorEditBox::textChanged, ext, QOverload<>::of(&KonfiguratorExtension::setChanged));
 
     loadInitialValue();
 }
 
 KonfiguratorEditBox::~KonfiguratorEditBox()
 {
     delete ext;
 }
 
 void KonfiguratorEditBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     setText(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
-void KonfiguratorEditBox::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorEditBox::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, text());
 }
 
 void KonfiguratorEditBox::slotSetDefaults(QObject *)
 {
     if (text() != defaultValue)
         setText(defaultValue);
 }
 
 
 // KonfiguratorURLRequester class
 ///////////////////////////////
 
 KonfiguratorURLRequester::KonfiguratorURLRequester(QString configGroup, QString name,
                                                    QString defaultValue, QWidget *parent,
                                                    bool restart, int page, bool expansion)
-    : KUrlRequester(parent), defaultValue(defaultValue), expansion(expansion)
+    : KUrlRequester(parent), defaultValue(std::move(defaultValue)), expansion(expansion)
 {
-    ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(name), restart, page);
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorURLRequester::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorURLRequester::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorURLRequester::loadInitialValue);
 
     connect(this, &KonfiguratorURLRequester::textChanged, ext, QOverload<>::of(&KonfiguratorExtension::setChanged));
 
     loadInitialValue();
 }
 
 KonfiguratorURLRequester::~KonfiguratorURLRequester()
 {
     delete ext;
 }
 
 void KonfiguratorURLRequester::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     lineEdit()->setText(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
-void KonfiguratorURLRequester::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorURLRequester::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     KConfigGroup(krConfig, configGroup)
         .writeEntry(name, expansion ? url().toDisplayString(QUrl::PreferLocalFile) : text());
 }
 
 void KonfiguratorURLRequester::slotSetDefaults(QObject *)
 {
     if (url().toDisplayString(QUrl::PreferLocalFile) != defaultValue)
         lineEdit()->setText(defaultValue);
 }
 
 // KonfiguratorFontChooser class
 ///////////////////////////////
 
-KonfiguratorFontChooser::KonfiguratorFontChooser(QString configGroup, QString name, QFont defaultValue,
+KonfiguratorFontChooser::KonfiguratorFontChooser(QString configGroup, QString name, const QFont& defaultValue,
         QWidget *parent, bool restart, int page) : QWidget(parent),
         defaultValue(defaultValue)
 {
-    QHBoxLayout *layout = new QHBoxLayout(this);
+    auto *layout = new QHBoxLayout(this);
 
-    ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(name), restart, page);
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorFontChooser::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorFontChooser::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorFontChooser::loadInitialValue);
 
     pLabel = new QLabel(this);
     pLabel->setMinimumWidth(150);
     layout->addWidget(pLabel);
 
     pToolButton = new QToolButton(this);
 
     connect(pToolButton, &QToolButton::clicked, this, &KonfiguratorFontChooser::slotBrowseFont);
 
     pToolButton->setIcon(Icon("document-open"));
     layout->addWidget(pToolButton);
 
     loadInitialValue();
 }
 
 KonfiguratorFontChooser::~KonfiguratorFontChooser()
 {
     delete ext;
 }
 
 void KonfiguratorFontChooser::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     font = group.readEntry(ext->getConfigName(), defaultValue);
     ext->setChanged(false);
     setFont();
 }
 
 void KonfiguratorFontChooser::setFont()
 {
     pLabel->setFont(font);
     pLabel->setText(font.family() + QString(", %1").arg(font.pointSize()));
 }
 
-void KonfiguratorFontChooser::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorFontChooser::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, font);
 }
 
 void KonfiguratorFontChooser::slotSetDefaults(QObject *)
 {
     font = defaultValue;
     ext->setChanged();
     setFont();
 }
 
 void KonfiguratorFontChooser::slotBrowseFont()
 {
     bool ok;
     font = QFontDialog::getFont(&ok, font, this);
     if (!ok) return;  // cancelled by the user, and font is actually not changed (getFont returns the font we gave it)
     ext->setChanged();
     setFont();
 }
 
 // KonfiguratorComboBox class
 ///////////////////////////////
 
 KonfiguratorComboBox::KonfiguratorComboBox(QString configGroup, QString name, QString defaultValue,
         KONFIGURATOR_NAME_VALUE_PAIR *listIn, int listInLen, QWidget *parent,
         bool restart, bool editable, int page) : QComboBox(parent),
-        defaultValue(defaultValue), listLen(listInLen)
+        defaultValue(std::move(defaultValue)), listLen(listInLen)
 {
     list = new KONFIGURATOR_NAME_VALUE_PAIR[ listInLen ];
 
     for (int i = 0; i != listLen; i++) {
         list[i] = listIn[i];
         addItem(list[i].text);
     }
 
-    ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(name), restart, page);
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorComboBox::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorComboBox::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorComboBox::loadInitialValue);
 
     //connect(this, &KonfiguratorComboBox::highlighted, ext, &KonfiguratorExtension::setChanged); /* Removed because of startup combo failure */
     connect(this, QOverload<int>::of(&KonfiguratorComboBox::activated), ext, QOverload<>::of(&KonfiguratorExtension::setChanged));
     connect(this, &KonfiguratorComboBox::currentTextChanged, ext, QOverload<>::of(&KonfiguratorExtension::setChanged));
 
     setEditable(editable);
     loadInitialValue();
 }
 
 KonfiguratorComboBox::~KonfiguratorComboBox()
 {
     delete []list;
     delete ext;
 }
 
 void KonfiguratorComboBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     QString select = group.readEntry(ext->getConfigName(), defaultValue);
     selectEntry(select);
     ext->setChanged(false);
 }
 
-void KonfiguratorComboBox::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorComboBox::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     QString text = isEditable() ? lineEdit()->text() : currentText();
     QString value = text;
 
     for (int i = 0; i != listLen; i++)
         if (list[i].text == text) {
             value = list[i].value;
             break;
         }
 
     KConfigGroup(krConfig, configGroup).writeEntry(name, value);
 }
 
-void KonfiguratorComboBox::selectEntry(QString entry)
+void KonfiguratorComboBox::selectEntry(const QString& entry)
 {
     for (int i = 0; i != listLen; i++)
         if (list[i].value == entry) {
             setCurrentIndex(i);
             return;
         }
 
     if (isEditable())
         lineEdit()->setText(entry);
     else
         setCurrentIndex(0);
 }
 
 void KonfiguratorComboBox::slotSetDefaults(QObject *)
 {
     selectEntry(defaultValue);
 }
 
 
 // KonfiguratorColorChooser class
 ///////////////////////////////
 
 KonfiguratorColorChooser::KonfiguratorColorChooser(QString configGroup, QString name,
-                                                   QColor defaultValue, QWidget *parent,
+                                                   const QColor& defaultValue, QWidget *parent,
                                                    bool restart, ADDITIONAL_COLOR *addColPtr,
                                                    int addColNum, int page)
     : QComboBox(parent), defaultValue(defaultValue), disableColorChooser(true)
 {
-    ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(name), restart, page);
 
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorColorChooser::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorColorChooser::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorColorChooser::loadInitialValue);
 
     addColor(i18n("Custom color"),  QColor(255, 255, 255));
     addColor(i18nc("Default color", "Default"), defaultValue);
 
     for (int i = 0; i != addColNum; i++) {
         additionalColors.push_back(addColPtr[i]);
         addColor(addColPtr[i].name, addColPtr[i].color);
     }
 
     addColor(i18n("Red"),           Qt::red);
     addColor(i18n("Green"),         Qt::green);
     addColor(i18n("Blue"),          Qt::blue);
     addColor(i18n("Cyan"),          Qt::cyan);
     addColor(i18n("Magenta"),       Qt::magenta);
     addColor(i18n("Yellow"),        Qt::yellow);
     addColor(i18n("Dark Red"),      Qt::darkRed);
     addColor(i18n("Dark Green"),    Qt::darkGreen);
     addColor(i18n("Dark Blue"),     Qt::darkBlue);
     addColor(i18n("Dark Cyan"),     Qt::darkCyan);
     addColor(i18n("Dark Magenta"),  Qt::darkMagenta);
     addColor(i18n("Dark Yellow"),   Qt::darkYellow);
     addColor(i18n("White"),         Qt::white);
     addColor(i18n("Light Gray"),    Qt::lightGray);
     addColor(i18n("Gray"),          Qt::gray);
     addColor(i18n("Dark Gray"),     Qt::darkGray);
     addColor(i18n("Black"),         Qt::black);
 
     connect(this, QOverload<int>::of(&KonfiguratorColorChooser::activated), this, &KonfiguratorColorChooser::slotCurrentChanged);
 
     loadInitialValue();
 }
 
 KonfiguratorColorChooser::~KonfiguratorColorChooser()
 {
     delete ext;
 }
 
-QPixmap KonfiguratorColorChooser::createPixmap(QColor color)
+QPixmap KonfiguratorColorChooser::createPixmap(const QColor& color)
 {
     QPainter painter;
     QPen pen;
     int size = QFontMetrics(font()).height() * 3 / 4;
     QRect rect(0, 0, size, size);
     QPixmap pixmap(rect.width(), rect.height());
 
     pen.setColor(Qt::black);
 
     painter.begin(&pixmap);
     QBrush brush(color);
     painter.fillRect(rect, brush);
     painter.setPen(pen);
     painter.drawRect(rect);
     painter.end();
 
     pixmap.detach();
     return pixmap;
 }
 
-void KonfiguratorColorChooser::addColor(QString text, QColor color)
+void KonfiguratorColorChooser::addColor(const QString& text, const QColor& color)
 {
     addItem(createPixmap(color), text);
     palette.push_back(color);
 }
 
 void KonfiguratorColorChooser::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     QString selected = group.readEntry(ext->getConfigName(), QString(""));
     setValue(selected);
     ext->setChanged(false);
 }
 
 void KonfiguratorColorChooser::setDefaultColor(QColor dflt)
 {
-    defaultValue = dflt;
+    defaultValue = std::move(dflt);
     palette[1] = defaultValue;
     setItemIcon(1, createPixmap(defaultValue));
 
     if (currentIndex() == 1)
         emit colorChanged();
 }
 
-void KonfiguratorColorChooser::changeAdditionalColor(int num, QColor color)
+void KonfiguratorColorChooser::changeAdditionalColor(int num, const QColor& color)
 {
     if (num < additionalColors.size()) {
         palette[2+num] = color;
         additionalColors[num].color = color;
         setItemIcon(2 + num, createPixmap(color));
 
         if (currentIndex() == 2 + num)
             emit colorChanged();
     }
 }
 
-void KonfiguratorColorChooser::setDefaultText(QString text)
+void KonfiguratorColorChooser::setDefaultText(const QString& text)
 {
     setItemIcon(1, createPixmap(defaultValue));
     setItemText(1, text);
 }
 
-void KonfiguratorColorChooser::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorColorChooser::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, getValue());
 }
 
-void KonfiguratorColorChooser::setValue(QString value)
+void KonfiguratorColorChooser::setValue(const QString& value)
 {
     disableColorChooser = true;
 
     if (value.isEmpty()) {
         setCurrentIndex(1);
         customValue = defaultValue;
     } else {
         bool found = false;
 
         for (int j = 0; j != additionalColors.size(); j++)
             if (additionalColors[j].value == value) {
                 setCurrentIndex(2 + j);
                 found = true;
                 break;
             }
 
         if (! found) {
             KConfigGroup colGroup(krConfig, ext->getConfigGroup());
             colGroup.writeEntry("TmpColor", value);
             QColor color = colGroup.readEntry("TmpColor", defaultValue);
             customValue = color;
             colGroup.deleteEntry("TmpColor");
 
             setCurrentIndex(0);
             for (int i = 2 + additionalColors.size(); i != palette.size(); i++)
                 if (palette[i] == color) {
                     setCurrentIndex(i);
                     break;
                 }
         }
     }
 
     palette[0] = customValue;
     setItemIcon(0, createPixmap(customValue));
 
     ext->setChanged();
     emit colorChanged();
     disableColorChooser = false;
 }
 
 QString KonfiguratorColorChooser::getValue()
 {
     QColor color = palette[ currentIndex()];
     if (currentIndex() == 1)     /* it's the default value? */
         return "";
     else if (currentIndex() >= 2 && currentIndex() < 2 + additionalColors.size())
         return additionalColors[ currentIndex() - 2 ].value;
     else
         return QString("%1,%2,%3").arg(color.red()).arg(color.green()).arg(color.blue());
 }
 
 bool KonfiguratorColorChooser::isValueRGB()
 {
     return !(currentIndex() >= 1 && currentIndex() < 2 + additionalColors.size());
 }
 
 void KonfiguratorColorChooser::slotSetDefaults(QObject *)
 {
     ext->setChanged();
     setCurrentIndex(1);
     emit colorChanged();
 }
 
 void KonfiguratorColorChooser::slotCurrentChanged(int number)
 {
     ext->setChanged();
     if (number == 0 && !disableColorChooser) {
         QColor color = QColorDialog::getColor(customValue, this);
         if (color.isValid()) {
             disableColorChooser = true;
             customValue = color;
             palette[0] = customValue;
             setItemIcon(0, createPixmap(customValue));
             disableColorChooser = false;
         }
     }
 
     emit colorChanged();
 }
 
 QColor KonfiguratorColorChooser::getColor()
 {
     return palette[ currentIndex()];
 }
 
 // KonfiguratorListBox class
 ///////////////////////////////
 
 KonfiguratorListBox::KonfiguratorListBox(QString configGroup, QString name, QStringList defaultValue,
         QWidget *parent, bool restart, int page) : KrListWidget(parent),
-        defaultValue(defaultValue)
+        defaultValue(std::move(defaultValue))
 {
-    ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
+    ext = new KonfiguratorExtension(this, std::move(configGroup), std::move(name), restart, page);
     connect(ext, &KonfiguratorExtension::applyAuto, this, &KonfiguratorListBox::slotApply);
     connect(ext, &KonfiguratorExtension::setDefaultsAuto, this, &KonfiguratorListBox::slotSetDefaults);
     connect(ext, &KonfiguratorExtension::setInitialValue, this, &KonfiguratorListBox::loadInitialValue);
 
     loadInitialValue();
 }
 
 KonfiguratorListBox::~KonfiguratorListBox()
 {
     delete ext;
 }
 
 void KonfiguratorListBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     setList(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
-void KonfiguratorListBox::slotApply(QObject *, QString configGroup, QString name)
+void KonfiguratorListBox::slotApply(QObject *, const QString& configGroup, const QString& name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, list());
 }
 
 void KonfiguratorListBox::slotSetDefaults(QObject *)
 {
     if (list() != defaultValue) {
         ext->setChanged();
         setList(defaultValue);
     }
 }
 
-void KonfiguratorListBox::setList(QStringList list)
+void KonfiguratorListBox::setList(const QStringList& list)
 {
     clear();
     addItems(list);
 }
 
 QStringList KonfiguratorListBox::list()
 {
     QStringList lst;
 
     for (int i = 0; i != count(); i++)
         lst += item(i)->text();
 
     return lst;
 }
 
 void KonfiguratorListBox::addItem(const QString & item)
 {
     if (!list().contains(item)) {
         KrListWidget::addItem(item);
         ext->setChanged();
     }
 }
 
 void KonfiguratorListBox::removeItem(const QString & item)
 {
     QList<QListWidgetItem *> list = findItems(item, Qt::MatchExactly);
     for (int i = 0; i != list.count(); i++)
         delete list[ i ];
 
     if (list.count())
         ext->setChanged();
 }
 
diff --git a/krusader/Konfigurator/konfiguratoritems.h b/krusader/Konfigurator/konfiguratoritems.h
index 269cb0e2..a1aa3574 100644
--- a/krusader/Konfigurator/konfiguratoritems.h
+++ b/krusader/Konfigurator/konfiguratoritems.h
@@ -1,427 +1,427 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KONFIGURATORITEMS_H
 #define KONFIGURATORITEMS_H
 
 // QtCore
 #include <QObject>
 #include <QString>
 #include <QList>
 // QtGui
 #include <QPixmap>
 #include <QFont>
 // QtWidgets
 #include <QBoxLayout>
 #include <QCheckBox>
 #include <QSpinBox>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QLineEdit>
 #include <QLabel>
 #include <QToolButton>
 #include <QComboBox>
 
 #include <KIOWidgets/KUrlRequester>
 
 #include "../GUI/krlistwidget.h"
 
 #define FIRST_PAGE        0
 
 class KonfiguratorExtension : public QObject
 {
     Q_OBJECT
 
 public:
   KonfiguratorExtension(QObject *obj, QString cfgGroup, QString cfgName, bool restartNeeded = false,
                         int page = FIRST_PAGE);
 
   virtual void loadInitialValue();
   virtual bool apply();
   virtual void setDefaults();
   virtual bool isChanged();
   virtual void setSubPage(int page) { subpage = page; }
   virtual int subPage() { return subpage; }
 
   inline QObject *object() { return objectPtr; }
 
   inline QString getConfigGroup() { return configGroup; }
   inline QString getConfigName() { return configName; }
 
 public slots:
     void    setChanged()               {
         emit sigChanged(changed = true);
     }
     void    setChanged(bool chg)     {
         emit sigChanged(changed = chg);
     }
 
 signals:
     void    applyManually(QObject *, QString, QString);
     void    applyAuto(QObject *, QString, QString);
     void    setDefaultsManually(QObject *);
     void    setDefaultsAuto(QObject *);
     void    setInitialValue(QObject *);
     void    sigChanged(bool);
 
 protected:
     QObject *objectPtr;
 
     bool    applyConnected;
     bool    setDefaultsConnected;
     bool    changed;
     bool    restartNeeded;
     int     subpage;
 
     QString configGroup;
     QString configName;
 
-    virtual void connectNotify(const QMetaMethod &signal) Q_DECL_OVERRIDE;
+    void connectNotify(const QMetaMethod &signal) Q_DECL_OVERRIDE;
 };
 
 
 // KonfiguratorCheckBox class
 ///////////////////////////////
 
 class KonfiguratorCheckBox : public QCheckBox
 {
     Q_OBJECT
 
 public:
-    KonfiguratorCheckBox(QString configGroup, QString name, bool defaultValue, QString text,
-                         QWidget *parent = 0, bool restart = false, int page = FIRST_PAGE);
-    ~KonfiguratorCheckBox();
+    KonfiguratorCheckBox(QString configGroup, QString name, bool defaultValue, const QString& text,
+                         QWidget *parent = nullptr, bool restart = false, int page = FIRST_PAGE);
+    ~KonfiguratorCheckBox() override;
 
     inline KonfiguratorExtension *extension() { return ext; }
 
     // indicate that a checkobox is dependent of this,
     // meaning that dep is only available if this box is checked
     void addDep(KonfiguratorCheckBox *dep);
 
 public slots:
     virtual void loadInitialValue();
-    void slotApply(QObject *, QString, QString);
+    void slotApply(QObject *, const QString&, const QString&);
     void slotSetDefaults(QObject *);
 
 protected:
-    virtual void checkStateSet() Q_DECL_OVERRIDE;
-    virtual void nextCheckState() Q_DECL_OVERRIDE;
+    void checkStateSet() Q_DECL_OVERRIDE;
+    void nextCheckState() Q_DECL_OVERRIDE;
     void updateDeps();
 
     bool  defaultValue;
     KonfiguratorExtension *ext;
     QList<KonfiguratorCheckBox*> deps;
 };
 
 // KonfiguratorSpinBox class
 ///////////////////////////////
 
 class KonfiguratorSpinBox : public QSpinBox
 {
     Q_OBJECT
 
 public:
     KonfiguratorSpinBox(QString configGroup, QString configName, int defaultValue, int min, int max,
-                        QWidget *parent = 0, bool restartNeeded = false, int page = FIRST_PAGE);
-    ~KonfiguratorSpinBox();
+                        QWidget *parent = nullptr, bool restartNeeded = false, int page = FIRST_PAGE);
+    ~KonfiguratorSpinBox() override;
 
     inline KonfiguratorExtension *extension() { return ext; }
 
 public slots:
     virtual void loadInitialValue();
-    void slotApply(QObject *, QString, QString);
+    void slotApply(QObject *, const QString&, const QString&);
     void slotSetDefaults(QObject *);
 
 protected:
     int  defaultValue;
     KonfiguratorExtension *ext;
 };
 
 // KonfiguratorCheckBoxGroup class
 ///////////////////////////////
 
 class KonfiguratorCheckBoxGroup : public QWidget
 {
 public:
-    explicit KonfiguratorCheckBoxGroup(QWidget *parent = 0) : QWidget(parent){}
+    explicit KonfiguratorCheckBoxGroup(QWidget *parent = nullptr) : QWidget(parent){}
 
     void                    add(KonfiguratorCheckBox *);
     int                     count() {
         return checkBoxList.count();
     };
     KonfiguratorCheckBox *  find(int index);
-    KonfiguratorCheckBox *  find(QString name);
+    KonfiguratorCheckBox *  find(const QString& name);
 
 private:
     QList<KonfiguratorCheckBox *>  checkBoxList;
 };
 
 // KonfiguratorRadioButtons class
 ///////////////////////////////
 
 class KonfiguratorRadioButtons : public QWidget
 {
     Q_OBJECT
 
 public:
     KonfiguratorRadioButtons(QString configGroup, QString name, QString defaultValue,
-                             QWidget *parent = 0, bool restart = false, int page = FIRST_PAGE);
-    ~KonfiguratorRadioButtons();
+                             QWidget *parent = nullptr, bool restart = false, int page = FIRST_PAGE);
+    ~KonfiguratorRadioButtons() override;
 
     inline KonfiguratorExtension *extension() { return ext; }
 
-    void addRadioButton(QRadioButton *radioWidget, QString name, QString value);
+    void addRadioButton(QRadioButton *radioWidget, const QString& name, const QString& value);
 
-    void selectButton(QString value);
+    void selectButton(const QString& value);
 
     int count() { return radioButtons.count(); }
     QString selectedValue();
     QRadioButton *find(int index);
-    QRadioButton *find(QString name);
+    QRadioButton *find(const QString& name);
 
 public slots:
     virtual void loadInitialValue();
-    void slotApply(QObject *, QString, QString);
+    void slotApply(QObject *, const QString&, const QString&);
     void slotSetDefaults(QObject *);
 
 protected:
     QList<QRadioButton *>  radioButtons;
     QList<QString>   radioValues;
     QList<QString>   radioNames;
 
     QString         defaultValue;
 
     KonfiguratorExtension *ext;
 };
 
 // KonfiguratorEditBox class
 ///////////////////////////////
 
 class KonfiguratorEditBox : public QLineEdit
 {
     Q_OBJECT
 
 public:
     KonfiguratorEditBox(QString configGroup, QString name, QString defaultValue,
-                        QWidget *parent = 0, bool restart = false, int page = FIRST_PAGE);
-    ~KonfiguratorEditBox();
+                        QWidget *parent = nullptr, bool restart = false, int page = FIRST_PAGE);
+    ~KonfiguratorEditBox() override;
 
     inline KonfiguratorExtension *extension() { return ext; }
 
 public slots:
     virtual void loadInitialValue();
-    void slotApply(QObject *, QString, QString);
+    void slotApply(QObject *, const QString&, const QString&);
     void slotSetDefaults(QObject *);
 
 protected:
     QString  defaultValue;
     KonfiguratorExtension *ext;
 };
 
 
 // KonfiguratorURLRequester class
 ///////////////////////////////
 
 class KonfiguratorURLRequester : public KUrlRequester
 {
     Q_OBJECT
 
 public:
     KonfiguratorURLRequester(QString configGroup, QString name, QString defaultValue,
-                             QWidget *parent = 0, bool restart = false, int page = FIRST_PAGE,
+                             QWidget *parent = nullptr, bool restart = false, int page = FIRST_PAGE,
                              bool expansion = true);
-    ~KonfiguratorURLRequester();
+    ~KonfiguratorURLRequester() override;
 
     inline KonfiguratorExtension *extension() { return ext; }
 
 public slots:
     virtual void loadInitialValue();
-    void slotApply(QObject *, QString, QString);
+    void slotApply(QObject *, const QString&, const QString&);
     void slotSetDefaults(QObject *);
 
 protected:
     QString  defaultValue;
     KonfiguratorExtension *ext;
     bool expansion;
 };
 
 // KonfiguratorFontChooser class
 ///////////////////////////////
 
 class KonfiguratorFontChooser : public QWidget
 {
     Q_OBJECT
 
 public:
-    KonfiguratorFontChooser(QString configGroup, QString name, QFont defaultValue,
-                            QWidget *parent = 0, bool restart = false, int page = FIRST_PAGE);
-    ~KonfiguratorFontChooser();
+    KonfiguratorFontChooser(QString configGroup, QString name, const QFont& defaultValue,
+                            QWidget *parent = nullptr, bool restart = false, int page = FIRST_PAGE);
+    ~KonfiguratorFontChooser() override;
 
     inline KonfiguratorExtension *extension() { return ext; }
 
 public slots:
     virtual void    loadInitialValue();
-    void            slotApply(QObject *, QString, QString);
+    void            slotApply(QObject *, const QString&, const QString&);
     void            slotSetDefaults(QObject *);
     void            slotBrowseFont();
 
 protected:
     QFont           defaultValue;
     QFont           font;
     KonfiguratorExtension *ext;
 
     QLabel        * pLabel;
     QToolButton   * pToolButton;
 
     void            setFont();
 };
 
 // KONFIGURATOR_NAME_VALUE_PAIR structure
 ///////////////////////////////
 
 struct KONFIGURATOR_NAME_VALUE_PAIR {
     QString text;
     QString value;
 };
 
 // KONFIGURATOR_NAME_VALUE_TIP structure
 ///////////////////////////////
 
 struct KONFIGURATOR_NAME_VALUE_TIP {
     QString text;
     QString value;
     QString tooltip;
 };
 
 // KonfiguratorComboBox class
 ///////////////////////////////
 
 class KonfiguratorComboBox : public QComboBox
 {
     Q_OBJECT
 
 public:
     KonfiguratorComboBox(QString configGroup, QString name, QString defaultValue,
-                         KONFIGURATOR_NAME_VALUE_PAIR *listIn, int listInLen, QWidget *parent = 0,
+                         KONFIGURATOR_NAME_VALUE_PAIR *listIn, int listInLen, QWidget *parent = nullptr,
                          bool restart = false, bool editable = false, int page = FIRST_PAGE);
-    ~KonfiguratorComboBox();
+    ~KonfiguratorComboBox() override;
 
     inline KonfiguratorExtension *extension() { return ext; }
 
 public slots:
     virtual void loadInitialValue();
-    void slotApply(QObject *, QString, QString);
+    void slotApply(QObject *, const QString&, const QString&);
     void slotSetDefaults(QObject *);
 
 protected:
     QString                       defaultValue;
     KONFIGURATOR_NAME_VALUE_PAIR *list;
     int                           listLen;
     KonfiguratorExtension        *ext;
 
-    void                          selectEntry(QString entry);
+    void                          selectEntry(const QString& entry);
 };
 
 
 // KonfiguratorColorChooser class
 ///////////////////////////////
 
 typedef struct {
     QString name;
     QColor  color;
     QString value;
 } ADDITIONAL_COLOR;
 
 class KonfiguratorColorChooser : public QComboBox
 {
     Q_OBJECT
 
 public:
-    KonfiguratorColorChooser(QString configGroup, QString name, QColor defaultValue,
-                             QWidget *parent = 0, bool restart = false,
-                             ADDITIONAL_COLOR *addColPtr = 0, int addColNum = 0, int page = FIRST_PAGE);
-    ~KonfiguratorColorChooser();
+    KonfiguratorColorChooser(QString configGroup, QString name, const QColor& defaultValue,
+                             QWidget *parent = nullptr, bool restart = false,
+                             ADDITIONAL_COLOR *addColPtr = nullptr, int addColNum = 0, int page = FIRST_PAGE);
+    ~KonfiguratorColorChooser() override;
 
     inline KonfiguratorExtension *extension()   {
         return ext;
     }
 
     void          setDefaultColor(QColor dflt);
-    void          setDefaultText(QString text);
+    void          setDefaultText(const QString& text);
     QColor        getColor();
-    void          changeAdditionalColor(int num, QColor color);
+    void          changeAdditionalColor(int num, const QColor& color);
     QString       getValue();
     bool          isValueRGB();
-    void          setValue(QString value);
+    void          setValue(const QString& value);
 
 public slots:
     virtual void  loadInitialValue();
-    void          slotApply(QObject *, QString, QString);
+    void          slotApply(QObject *, const QString&, const QString&);
     void          slotSetDefaults(QObject *);
     void          slotCurrentChanged(int number);
 
 signals:
     void          colorChanged();
 
 private:
-    void          addColor(QString text, QColor color);
-    QPixmap       createPixmap(QColor color);
+    void          addColor(const QString& text, const QColor& color);
+    QPixmap       createPixmap(const QColor& color);
 
 protected:
     QColor                          defaultValue;
     QColor                          customValue;
     QList<QColor>                   palette;
     QList<ADDITIONAL_COLOR>         additionalColors;
     KonfiguratorExtension          *ext;
     bool                            disableColorChooser;
 };
 
 // KonfiguratorListBox class
 ///////////////////////////////
 
 class KonfiguratorListBox : public KrListWidget
 {
     Q_OBJECT
 
 public:
     KonfiguratorListBox(QString configGroup, QString name, QStringList defaultValue,
-                        QWidget *parent = 0, bool restart = false, int page = FIRST_PAGE);
-    ~KonfiguratorListBox();
+                        QWidget *parent = nullptr, bool restart = false, int page = FIRST_PAGE);
+    ~KonfiguratorListBox() override;
 
     inline KonfiguratorExtension *extension() { return ext; }
 
     void addItem(const QString &);
     void removeItem(const QString &);
 
 public slots:
     virtual void loadInitialValue();
-    void slotApply(QObject *, QString, QString);
+    void slotApply(QObject *, const QString&, const QString&);
     void slotSetDefaults(QObject *);
 
 protected:
     QStringList list();
-    void setList(QStringList);
+    void setList(const QStringList&);
 
     QStringList defaultValue;
     KonfiguratorExtension *ext;
 };
 
 #endif /* __KONFIGURATOR_ITEMS_H__ */
 
diff --git a/krusader/Konfigurator/konfiguratorpage.cpp b/krusader/Konfigurator/konfiguratorpage.cpp
index f0448cdb..740233dd 100644
--- a/krusader/Konfigurator/konfiguratorpage.cpp
+++ b/krusader/Konfigurator/konfiguratorpage.cpp
@@ -1,284 +1,285 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "konfiguratorpage.h"
 
 // QtWidgets
 #include <QLayout>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QScrollArea>
 #include <QLabel>
 
 #include <KConfigCore/KConfig>
+#include <utility>
 
 #include "../krglobal.h"
 
 KonfiguratorPage::KonfiguratorPage(bool firstTime, QWidget* parent) :
         QScrollArea(parent), firstCall(firstTime)
 {
     setFrameStyle(QFrame::NoFrame);
 }
 
 bool KonfiguratorPage::apply()
 {
     bool restartNeeded = false;
 
-    for (QList<KonfiguratorExtension *>::iterator item = itemList.begin(); item != itemList.end(); item ++)
-        restartNeeded = (*item)->apply() || restartNeeded;
+    for (auto & item : itemList)
+        restartNeeded = item->apply() || restartNeeded;
 
     krConfig->sync();
     return restartNeeded;
 }
 
 void KonfiguratorPage::setDefaults()
 {
     int activePage = activeSubPage();
 
-    for (QList<KonfiguratorExtension *>::iterator item = itemList.begin(); item != itemList.end(); item ++) {
-        if ((*item)->subPage() == activePage)
-            (*item)->setDefaults();
+    for (auto & item : itemList) {
+        if (item->subPage() == activePage)
+            item->setDefaults();
     }
 }
 
 void KonfiguratorPage::loadInitialValues()
 {
-    for (QList<KonfiguratorExtension *>::iterator item = itemList.begin(); item != itemList.end(); item ++)
-        (*item)->loadInitialValue();
+    for (auto & item : itemList)
+        item->loadInitialValue();
 }
 
 bool KonfiguratorPage::isChanged()
 {
     bool isChanged = false;
 
-    for (QList<KonfiguratorExtension *>::iterator item = itemList.begin(); item != itemList.end(); item ++)
-        isChanged = isChanged || (*item)->isChanged();
+    for (auto & item : itemList)
+        isChanged = isChanged || item->isChanged();
 
     return isChanged;
 }
 
 KonfiguratorCheckBox* KonfiguratorPage::createCheckBox(QString configGroup, QString name,
-        bool defaultValue, QString text, QWidget *parent, bool restart, QString toolTip, int page)
+        bool defaultValue, QString text, QWidget *parent, bool restart, const QString& toolTip, int page)
 {
-    KonfiguratorCheckBox *checkBox = new KonfiguratorCheckBox(configGroup, name, defaultValue, text,
+    KonfiguratorCheckBox *checkBox = new KonfiguratorCheckBox(std::move(configGroup), std::move(name), defaultValue, std::move(text),
             parent, restart, page);
     if (!toolTip.isEmpty())
         checkBox->setWhatsThis(toolTip);
 
     registerObject(checkBox->extension());
     return checkBox;
 }
 
 KonfiguratorSpinBox* KonfiguratorPage::createSpinBox(QString configGroup, QString configName,
         int defaultValue, int min, int max, QWidget *parent, bool restart, int page)
 {
-    KonfiguratorSpinBox *spinBox = new KonfiguratorSpinBox(configGroup, configName, defaultValue,
+    KonfiguratorSpinBox *spinBox = new KonfiguratorSpinBox(std::move(configGroup), std::move(configName), defaultValue,
                                                            min, max, parent, restart, page);
 
     registerObject(spinBox->extension());
     return spinBox;
 }
 
 KonfiguratorEditBox* KonfiguratorPage::createEditBox(QString configGroup, QString name,
         QString defaultValue, QWidget *parent, bool restart, int page)
 {
-    KonfiguratorEditBox *editBox = new KonfiguratorEditBox(configGroup, name, defaultValue, parent,
+    KonfiguratorEditBox *editBox = new KonfiguratorEditBox(std::move(configGroup), std::move(name), std::move(defaultValue), parent,
             restart, page);
 
     registerObject(editBox->extension());
     return editBox;
 }
 
 KonfiguratorListBox* KonfiguratorPage::createListBox(QString configGroup, QString name,
         QStringList defaultValue, QWidget *parent, bool restart, int page)
 {
-    KonfiguratorListBox *listBox = new KonfiguratorListBox(configGroup, name, defaultValue, parent,
+    KonfiguratorListBox *listBox = new KonfiguratorListBox(std::move(configGroup), std::move(name), std::move(defaultValue), parent,
             restart, page);
 
     registerObject(listBox->extension());
     return listBox;
 }
 
 KonfiguratorURLRequester* KonfiguratorPage::createURLRequester(QString configGroup, QString name,
         QString defaultValue, QWidget *parent, bool restart, int page, bool expansion)
 {
-    KonfiguratorURLRequester *urlRequester = new KonfiguratorURLRequester(configGroup, name, defaultValue,
+    KonfiguratorURLRequester *urlRequester = new KonfiguratorURLRequester(std::move(configGroup), std::move(name), std::move(defaultValue),
             parent, restart, page, expansion);
 
     registerObject(urlRequester->extension());
     return urlRequester;
 }
 
-QGroupBox* KonfiguratorPage::createFrame(QString text, QWidget *parent)
+QGroupBox* KonfiguratorPage::createFrame(const QString& text, QWidget *parent)
 {
-    QGroupBox *groupBox = new QGroupBox(parent);
+    auto *groupBox = new QGroupBox(parent);
     if (!text.isNull())
         groupBox->setTitle(text);
     return groupBox;
 }
 
 QGridLayout* KonfiguratorPage::createGridLayout(QWidget *parent)
 {
-    QGridLayout *gridLayout = new QGridLayout(parent);
+    auto *gridLayout = new QGridLayout(parent);
     gridLayout->setAlignment(Qt::AlignTop);
     gridLayout->setSpacing(6);
     gridLayout->setContentsMargins(11, 11, 11, 11);
     return gridLayout;
 }
 
-QLabel* KonfiguratorPage::addLabel(QGridLayout *layout, int x, int y, QString label,
+QLabel* KonfiguratorPage::addLabel(QGridLayout *layout, int x, int y, const QString& label,
                                    QWidget *parent)
 {
     QLabel *lbl = new QLabel(label, parent);
     layout->addWidget(lbl, x, y);
     return lbl;
 }
 
 QWidget* KonfiguratorPage::createSpacer(QWidget *parent)
 {
     QWidget *widget = new QWidget(parent);
-    QHBoxLayout *hboxlayout = new QHBoxLayout(widget);
-    QSpacerItem* spacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+    auto *hboxlayout = new QHBoxLayout(widget);
+    auto* spacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     hboxlayout->addItem(spacer);
     return widget;
 }
 
 KonfiguratorCheckBoxGroup* KonfiguratorPage::createCheckBoxGroup(int sizex, int sizey,
         KONFIGURATOR_CHECKBOX_PARAM *params, int paramNum, QWidget *parent,
         int page)
 {
-    KonfiguratorCheckBoxGroup *groupWidget = new KonfiguratorCheckBoxGroup(parent);
-    QGridLayout *layout = new QGridLayout(groupWidget);
+    auto *groupWidget = new KonfiguratorCheckBoxGroup(parent);
+    auto *layout = new QGridLayout(groupWidget);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     int x = 0, y = 0;
 
     for (int i = 0; i != paramNum; i++) {
         KonfiguratorCheckBox *checkBox = createCheckBox(params[i].configClass,
                                          params[i].configName, params[i].defaultValue, params[i].text, groupWidget,
                                          params[i].restart, params[i].toolTip, page);
 
         groupWidget->add(checkBox);
         layout->addWidget(checkBox, y, x);
 
         if (sizex) {
             if (++x == sizex)
                 x = 0, y++;
         } else {
             if (++y == sizey)
                 y = 0, x++;
         }
     }
 
     return groupWidget;
 }
 
 KonfiguratorRadioButtons* KonfiguratorPage::createRadioButtonGroup(QString configGroup,
         QString name, QString defaultValue, int sizex, int sizey, KONFIGURATOR_NAME_VALUE_TIP *params,
         int paramNum, QWidget *parent, bool restart, int page)
 {
-    KonfiguratorRadioButtons *radioWidget = new KonfiguratorRadioButtons(configGroup, name, defaultValue, parent, restart, page);
+    KonfiguratorRadioButtons *radioWidget = new KonfiguratorRadioButtons(std::move(configGroup), std::move(name), std::move(defaultValue), parent, restart, page);
 
-    QGridLayout *layout = new QGridLayout(radioWidget);
+    auto *layout = new QGridLayout(radioWidget);
     layout->setAlignment(Qt::AlignTop);
     layout->setSpacing(6);
     layout->setContentsMargins(0, 0, 0, 0);
 
     int x = 0, y = 0;
 
     for (int i = 0; i != paramNum; i++) {
-        QRadioButton *radBtn = new QRadioButton(params[i].text, radioWidget);
+        auto *radBtn = new QRadioButton(params[i].text, radioWidget);
 
         if (!params[i].tooltip.isEmpty())
             radBtn->setWhatsThis(params[i].tooltip);
 
         layout->addWidget(radBtn, y, x);
 
         radioWidget->addRadioButton(radBtn, params[i].text, params[i].value);
 
         if (sizex) {
             if (++x == sizex)
                 x = 0, y++;
         } else {
             if (++y == sizey)
                 y = 0, x++;
         }
     }
 
     radioWidget->loadInitialValue();
     registerObject(radioWidget->extension());
     return radioWidget;
 }
 
 KonfiguratorFontChooser *KonfiguratorPage::createFontChooser(QString configGroup, QString name,
-        QFont defaultValue, QWidget *parent, bool restart, int page)
+        const QFont& defaultValue, QWidget *parent, bool restart, int page)
 {
-    KonfiguratorFontChooser *fontChooser = new KonfiguratorFontChooser(configGroup, name, defaultValue, parent,
+    KonfiguratorFontChooser *fontChooser = new KonfiguratorFontChooser(std::move(configGroup), std::move(name), defaultValue, parent,
             restart, page);
 
     registerObject(fontChooser->extension());
     return fontChooser;
 }
 
 KonfiguratorComboBox *KonfiguratorPage::createComboBox(QString configGroup, QString name, QString defaultValue,
         KONFIGURATOR_NAME_VALUE_PAIR *params, int paramNum, QWidget *parent, bool restart, bool editable, int page)
 {
-    KonfiguratorComboBox *comboBox = new KonfiguratorComboBox(configGroup, name, defaultValue, params,
+    KonfiguratorComboBox *comboBox = new KonfiguratorComboBox(std::move(configGroup), std::move(name), std::move(defaultValue), params,
             paramNum, parent, restart, editable, page);
 
     registerObject(comboBox->extension());
     return comboBox;
 }
 
 QFrame* KonfiguratorPage::createLine(QWidget *parent, bool vertical)
 {
     QFrame *line = new QFrame(parent);
     line->setFrameStyle((vertical ? QFrame::VLine : QFrame::HLine) | QFrame::Sunken);
     return line;
 }
 
 void KonfiguratorPage::registerObject(KonfiguratorExtension *item)
 {
     itemList.push_back(item);
     connect(item, SIGNAL(sigChanged(bool)), this, SIGNAL(sigChanged()));
 }
 
 void KonfiguratorPage::removeObject(KonfiguratorExtension *item)
 {
     int ndx = itemList.indexOf(item);
     if (ndx != -1) {
         QList<KonfiguratorExtension *>::iterator it = itemList.begin() + ndx;
         delete *it;
         itemList.erase(it);
     }
 }
 
 KonfiguratorColorChooser *KonfiguratorPage::createColorChooser(QString configGroup, QString name, QColor defaultValue,
         QWidget *parent, bool restart,
         ADDITIONAL_COLOR *addColPtr, int addColNum, int page)
 {
-    KonfiguratorColorChooser *colorChooser = new KonfiguratorColorChooser(configGroup, name, defaultValue,  parent,
+    KonfiguratorColorChooser *colorChooser = new KonfiguratorColorChooser(std::move(configGroup), std::move(name), std::move(defaultValue),  parent,
             restart, addColPtr, addColNum, page);
 
     registerObject(colorChooser->extension());
     return colorChooser;
 }
 
diff --git a/krusader/Konfigurator/konfiguratorpage.h b/krusader/Konfigurator/konfiguratorpage.h
index 03535574..3ec2889e 100644
--- a/krusader/Konfigurator/konfiguratorpage.h
+++ b/krusader/Konfigurator/konfiguratorpage.h
@@ -1,513 +1,513 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KONFIGURATORPAGE_H
 #define KONFIGURATORPAGE_H
 
 // QtWidgets
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
 #include <QLayout>
 #include <QScrollArea>
 
 #include "konfiguratoritems.h"
 
 struct KONFIGURATOR_CHECKBOX_PARAM;
 
 /**
   * KonfiguratorPage is responsible for handling pages in Konfigurator.
   * It provides simple methods for create and manage Konfigurator pages.
   *
   * @short The base class of a page in Konfigurator
   */
 class KonfiguratorPage : public QScrollArea
 {
     Q_OBJECT
 
 public:
     /**
       * The constructor of the KonfiguratorPage class.
       *
       * @param firstTime    this parameter is true if it is the first call of Konfigurator
       * @param parent       reference to the parent widget
       */
     KonfiguratorPage(bool firstTime, QWidget *parent);
 
     /**
       * Applies the changes in the Konfigurator page.
       *
       * Writes out all relevant information to the configuration object and synchronizes
       * it with the file storage (hard disk, krusaderrc file). This function calls the apply()
       * method of each konfigurator item and finally performs the synchronization.
       *
       * @return a boolean value indicates that Krusader restart is needed for the correct change
       */
     virtual bool apply();
 
     /**
       * Sets every konfigurator item to its default value on the page.
       *
       * This method calls the setDefaults() method of each konfigurator item. This function
       * doesn't modify the current configuration, only the values of the GUI items. The
       * apply() method must be called for finalizing the changes.
       */
     virtual void setDefaults();
 
     /**
       * Reloads the original value of each konfigurator item from the configuration object.
       *
       * This function calls the loadInitialValue() method of each konfigurator item.
       * Used to rollback the changes on the konfigurator page. Called if the user
       * responds 'No' to the "Apply changes" question.
       */
     virtual void loadInitialValues();
 
     /**
       * Checks whether the page was changed.
       *
       * This function calls the isChanged() method of each konfigurator item and
       * performs logical OR operation on them. Actually, this function returns true
       * if any of the konfigurator items was changed.
       *
       * @return             true if at least one of the konfigurator items was changed
       */
     virtual bool isChanged();
 
     /**
       * Flag, indicates the first call of Konfigurator
       * @return             true if konfigurator was started at the first time
       */
     inline bool isFirst() { return firstCall; }
 
     /**
       * This method is used to query the active subpage from the Konfigurator
       * @return             the active page (by default the first page)
       */
     virtual int activeSubPage() { return FIRST_PAGE; }
 
     /**
       * Adds a new checkbox item to the page.
       * <br>The checkbox widget's name is QString(configGroup + "/" + name).ascii()<br>
       *
       * Sample:<br><br>
       * KonfiguratorCheckBox *myCheckBox = createCheckBox( "class", "name", false, parentWidget);<br>
       * myLayout->addWidget( myCheckBox, 0, 0 );
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  name            The item name used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the checkbox
       * @param  text            The text field of the checkbox
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  toolTip         Tooltip used for this checkbox
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created checkbox
       */
     KonfiguratorCheckBox *createCheckBox(QString configGroup, QString name, bool defaultValue,
-                                         QString text, QWidget *parent = 0, bool restart = false,
-                                         QString toolTip = QString(), int page = FIRST_PAGE);
+                                         QString text, QWidget *parent = nullptr, bool restart = false,
+                                         const QString& toolTip = QString(), int page = FIRST_PAGE);
 
     /**
       * Adds a new spinbox item to the page.
       * <br>The spinbox widget's name is QString(configGroup + "/" + name).ascii()<br>
       *
       * Sample:<br><br>
       * KonfiguratorSpinBox *mySpinBox = createSpinBox( "class", "name", 10, 1, 100, parentWidget);<br>
       * myLayout->addWidget( mySpinBox, 0, 0 );
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  configName      The item name used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the spinbox
       * @param  min             The minimum value of the spinbox
       * @param  max             The maximum value of the spinbox
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created spinbox
       */
     KonfiguratorSpinBox *createSpinBox(QString configGroup, QString configName, int defaultValue,
-                                       int min, int max, QWidget *parent = 0, bool restart = false,
+                                       int min, int max, QWidget *parent = nullptr, bool restart = false,
                                        int page = FIRST_PAGE);
 
     /**
       * Adds a new editbox item to the page.
       * <br>The editbox widget's name is QString(configGroup + "/" + name).ascii()<br>
       *
       * Sample:<br><br>
       * KonfiguratorEditBox *myEditBox = createEditBox( "class", "name", "default", parentWidget);<br>
       * myLayout->addWidget( myEditBox, 0, 0 );
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  name            The itemname used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the editbox
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created editbox
       */
     KonfiguratorEditBox *createEditBox(QString configGroup, QString name, QString defaultValue,
-                                       QWidget *parent = 0, bool restart = false,
+                                       QWidget *parent = nullptr, bool restart = false,
                                        int page = FIRST_PAGE);
 
     /**
       * Adds a new listbox item to the page.
       * <br>The listbox widget's name is QString(configGroup + "/" + name).ascii()<br>
       *
       * Sample:<br><br>
       * QStringList valueList;<br>
       * valueList += "item";<br>
       * KonfiguratorListBox *myListBox = createListBox( "class", "name", valueList, parentWidget);<br>
       * myLayout->addWidget( myListBox, 0, 0 );
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  name            The itemname used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the listbox
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created editbox
       */
     KonfiguratorListBox *createListBox(QString configGroup, QString name, QStringList defaultValue,
-                                       QWidget *parent = 0, bool restart = false,
+                                       QWidget *parent = nullptr, bool restart = false,
                                        int page = FIRST_PAGE);
 
     /**
       * Adds a new URL requester item to the page.
       * <br>The URL requester widget's name is QString(configGroup + "/" + name).ascii()<br>
       *
       * Sample:<br><br>
       * KonfiguratorURLRequester *myURLRequester = createURLRequester( "class", "name", "default", parentWidget );<br>
       * myLayout->addWidget( myURLRequester, 0, 0 );
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  name            The itemname used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the URL requester
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       * @param  expansion       Whether to perform url expansion
       *
       * @return             reference to the newly created URL requester
       */
     KonfiguratorURLRequester *createURLRequester(QString configGroup, QString name,
                                                  QString defaultValue, QWidget *parent,
                                                  bool restart, int page = FIRST_PAGE,
                                                  bool expansion = true);
 
     /**
       * Adds a new font chooser item to the page.
       * <br>The font chooser widget's name is QString(configGroup + "/" + name).ascii()<br>
       *
       * Sample:<br><br>
       * KonfiguratorFontChooser *myFontChooser = createFontChooser( "class", "name", QFont(), parentWidget );<br>
       * myLayout->addWidget( myFontChooser, 0, 0 );
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  name            The item name used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the font chooser
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created font chooser
       */
     KonfiguratorFontChooser *createFontChooser(QString configGroup, QString name,
-                                               QFont defaultValue, QWidget *parent = 0,
+                                               const QFont& defaultValue, QWidget *parent = nullptr,
                                                bool restart = false, int page = FIRST_PAGE);
 
     /**
       * Adds a new combobox item to the page.
       * <br>The combobox widget's name is QString(configGroup + "/" + name).ascii()<br>
       *
       * Sample:<br><br>
       * KONFIGURATOR_NAME_VALUE_PAIR comboInfo[] =<br>
       * &nbsp;{{ i18n( "combo text1" ), "value1" },<br>
       * &nbsp;&nbsp;{ i18n( "combo text2" ), "value2" },<br>
       * &nbsp;&nbsp;{ i18n( "combo text3" ), "value3" }};<br><br>
       * KonfiguratorComboBox *myComboBox = createComboBox( "class", "name", "value2", comboInfo, 3, parentWidget );<br>
       * myLayout->addWidget( myComboBox, 0, 0 );
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  name            The item name used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the combobox
       * @param  params          Pointer to the name-value pair array (combo elements)
       * @param  paramNum        Number of the combobox elements
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  editable        Flag indicates that the combo can be edited
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created combobox
       */
     KonfiguratorComboBox *createComboBox(QString configGroup, QString name, QString defaultValue,
                                          KONFIGURATOR_NAME_VALUE_PAIR *params, int paramNum,
-                                         QWidget *parent = 0, bool restart = false,
+                                         QWidget *parent = nullptr, bool restart = false,
                                          bool editable = false, int page = FIRST_PAGE);
 
     /**
       * Creates a frame on the page.
       *
       * Sample:<br><br>
       * QGroupBox *myGroup = createFrame( i18n( "MyFrameName" ), parentWidget, "frameName" );<br>
       * myLayout->addWidget( myGroup, 0, 0 );
       *
       * @param  text        The text written out onto the frame
       * @param  parent      Reference to the parent widget
       *
       * @return             reference to the newly created frame
       */
-    QGroupBox *createFrame(QString text = QString(), QWidget *parent = 0);
+    QGroupBox *createFrame(const QString& text = QString(), QWidget *parent = nullptr);
 
     /**
       * Creates a new QGridLayout element and sets its margins.
       *
       * Sample:<br><br>
       * QGroupBox *myGroup = createFrame( i18n( "MyFrameName" ), parentWidget, "frameName" );<br>
       * QGridLayout *myLayout = createGridLayout( myGroup ) );<br>
       * myLayout->addWidget( myGroup, 0, 0 );
       *
       * @param  parent      Reference to the parent layout
       *
       * @return             reference to the newly created QGridLayout
       */
     QGridLayout *createGridLayout(QWidget *parent);
 
     /**
       * Adds a new label to a grid layout.
       *
       * Sample:<br><br>
       * QGroupBox *myGroup = createFrame( i18n( "MyFrameName" ), parentWidget, "frameName" );<br>
       * QGridLayout *myLayout = createGridLayout( myGroup->layout() );<br>
       * addLabel( myLayout, 0, 0, i18n( "Hello world!" ), myGroup, "myLabel" );<br>
       * mainLayout->addWidget( myGroup, 0, 0 );
       *
       * @param  layout      The grid layout on which the item will be placed
       * @param  x           the column to which the label will be placed
       * @param  y           the row to which the label will be placed
       * @param  label       the text of the label
       * @param  parent      Reference to the parent widget
       *
       * @return             reference to the newly created label
       */
-    QLabel *addLabel(QGridLayout *layout, int x, int y, QString label, QWidget *parent = 0);
+    QLabel *addLabel(QGridLayout *layout, int x, int y, const QString& label, QWidget *parent = nullptr);
 
     /**
       * Creates a spacer object (for justifying in QHBox).
       *
       * Sample:<br><br>
       * QHBox *hbox = new QHBox( myParent, "hbox" );<br>
       * createSpinBox( "class", "spin", 5, 1, 10, hbox );<br>
       * createSpacer( hbox );<br>
       * myLayout->addWidget( hbox, 0, 0 );
       *
       * @param  parent      Reference to the parent widget
       *
       * @return             reference to the newly created spacer widget
       */
-    QWidget *createSpacer(QWidget *parent = 0);
+    QWidget *createSpacer(QWidget *parent = nullptr);
 
     /**
       * Creates a separator line.
       *
       * Sample:<br><br>
       * QFrame *myLine = createLine( myParent, "myLine" );<br>
       * myLayout->addWidget( myLine, 1, 0 );<br>
       *
       * @param  parent      Reference to the parent widget
       * @param  vertical    Means vertical line
       *
       * @return             reference to the newly created spacer widget
       */
-    QFrame *createLine(QWidget *parent = 0, bool vertical = false);
+    QFrame *createLine(QWidget *parent = nullptr, bool vertical = false);
 
     /**
       * Creates a checkbox group. A checkbox group contains a lot of checkboxes.
       * The grouped checkboxes are embedded into one widget, which can be placed anywhere
       * on the GUI. The placing of the elements can be horizontal or vertical in the group.
       * At horizontal placing the sizex integer defines the maximum element number in
       * one row, sizey is 0. At vertical placing sizex is 0, and sizey defines the
       * maximum row number in one column. <br>
       *
       * One specific element can be reached by its name or index with the find methods.
       * The first element is checkBoxGroup->find( 0 ), "myCb" element is checkBoxGroup->find( "myCb") ...
       *
       * Sample:<br><br>
       * KONFIGURATOR_CHECKBOX_PARAM myCBArray[] =<br>
       * &nbsp;{{"CbClass","CbName1", false, i18n( "name1" ), false, "tooltip1"},<br>
       * &nbsp;&nbsp;{"CbClass","CbName2", true, i18n( "name2" ), false, "tooltip2"},<br>
       * &nbsp;&nbsp;{"CbClass","CbName3", true, i18n( "name3" ), false, "tooltip3"}};<br><br>
       * KonfiguratorCheckBoxGroup *myCheckBoxGroup = createCheckBoxGroup( 1, 0, myCBArray, 3, myParent, "myCheckboxGroup" );<br>
       * myCheckBoxGroup->find( 0 )->setEnabled( false );<br><br>
       * myLayout->addWidget( myCheckBoxGroup, 0, 0 );<br>
       *
       * @param  sizex       the maximum column number at horizontal placing
       * @param  sizey       the maximum row number at vertical placing
       * @param  params      pointer to the checkbox array
       * @param  paramNum    number of the checkbox elements
       * @param  parent      Reference to the parent widget
       * @param  page        The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created checkbox group widget
       */
     KonfiguratorCheckBoxGroup *createCheckBoxGroup(int sizex, int sizey,
                                                    KONFIGURATOR_CHECKBOX_PARAM *params,
-                                                   int paramNum, QWidget *parent = 0,
+                                                   int paramNum, QWidget *parent = nullptr,
                                                    int page = FIRST_PAGE);
     /**
       * Creates a radio button group. A radio button group contains a lot of radio buttons.
       * The grouped buttons are embedded into one widget, which can be placed anywhere
       * on the GUI. The placing of the elements can be horizontal or vertical in the group.
       * At horizontal placing the sizex integer defines the maximum element number in
       * one row, sizey is 0. At vertical placing sizex is 0, and sizey defines the
       * maximum row number in one column.<br>
       *
       * The references of the buttons can be accessed by the find methods of KonfiguratorRadioButtons.
       * The first element is myRadioGrp->find( 0 ), "myRadio" element is myRadioGrp->find( "myRadio") ...
       *
       * Sample:<br><br>
       * KONFIGURATOR_NAME_VALUE_TIP radioInfo[] =<br>
       * &nbsp;{{ i18n( "radio text1" ), "value1", i18n( "tooltip1" ) },<br>
       * &nbsp;&nbsp;{ i18n( "radio text2" ), "value2", i18n( "tooltip2" ) },<br>
       * &nbsp;&nbsp;{ i18n( "radio text3" ), "value3", i18n( "tooltip3" ) }};<br><br>
       * KonfiguratorRadioButtons *myRadioGroup = createRadioButtonGroup( "class", "name", "value1",
       *  1, 0, radioInfo, 3, myParent, "myRadioGroup" );<br>
       * myRadioGroup->find( i18n( "radio text1" ) )->setEnabled( false );<br>
       * myLayout->addWidget( myRadioGroup, 0, 0 );<br>
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  name            The item name used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the radio buttons
       * @param  sizex           the maximum column number at horizontal placing
       * @param  sizey           the maximum row number at vertical placing
       * @param  params          pointer to the checkbox array
       * @param  paramNum        number of the checkbox elements
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created radio button group widget
       */
     KonfiguratorRadioButtons *createRadioButtonGroup(QString configGroup, QString name,
                                                      QString defaultValue, int sizex, int sizey,
                                                      KONFIGURATOR_NAME_VALUE_TIP *params,
-                                                     int paramNum, QWidget *parent = 0,
+                                                     int paramNum, QWidget *parent = nullptr,
                                                      bool restart = false, int page = FIRST_PAGE);
 
     /**
       * This function is used to insert new, unknown items into KonfiguratorPage. The
       * item must be derived from KonfiguratorExtension class, which have
       * isChanged(), apply(), setDefaults, loadInitialValue() methods. After that, the
       * object is properly handled by Konfigurator page.
       *
       *
       * @param  item        The item to be added to KonfiguratorPage
       */
     void registerObject(KonfiguratorExtension *item);
 
     /**
       * This function is used to remove elements from KonfiguratorPage.
       *
       * Sample:<br><br>
       * KonfiguratorEditBox *myEditBox = createEditBox( "class", "name", "default", parentWidget);<br>
       * myLayout->addWidget( myEditBox, 0, 0 );<br>
       * removeObject( myEditBox->extension() );
       *
       * After the removeObject myEditBox will be untouched at apply(), setDefaults(), isChanged(),
       * loadInitialValues() methods of the KonfiguratorPage.
       *
       * @param  item        The item to be removed from KonfiguratorPage
       */
     void removeObject(KonfiguratorExtension *item);
 
     /**
       * Adds a new color chooser combobox item to the page.
       * <br>The chooser's widget's name is QString(configGroup + "/" + name).ascii()<br>
       *
       * Sample:<br><br>
       * KonfiguratorColorChooser *myColorChooser = createColorChooser( "class", "name", QColor( 255, 0, 255 ), parentWidget );<br>
       * myLayout->addWidget( myColorChooser, 0, 0 );
       *
       * @param  configGroup     The class name used in KConfig (ex. "Archives")
       * @param  name            The item name used in KConfig (ex. "Do Tar")
       * @param  defaultValue    The default value of the color chooser
       * @param  parent          Reference to the parent widget
       * @param  restart         The change of this parameter requires Krusader restart
       * @param  addColPtr       The additional color values
       * @param  addColNum       Number of additional colors
       * @param  page            The subpage of a Konfigurator page (because of setDefaults)
       *
       * @return             reference to the newly created combobox
       */
     KonfiguratorColorChooser *createColorChooser(QString configGroup, QString name,
-                                                 QColor defaultValue, QWidget *parent = 0,
+                                                 QColor defaultValue, QWidget *parent = nullptr,
                                                  bool restart = false,
-                                                 ADDITIONAL_COLOR *addColPtr = 0, int addColNum = 0,
+                                                 ADDITIONAL_COLOR *addColPtr = nullptr, int addColNum = 0,
                                                  int page = FIRST_PAGE);
 signals:
     /**
       * The signal is emitted if the changed flag was modified in any konfigurator item.
       * Used for enabling/disabling the apply button.
       */
     void sigChanged();
 
 protected:
     QList<KonfiguratorExtension *> itemList;
 
 private:
     bool firstCall;
 };
 
 /**
   * KONFIGURATOR_CHECKBOX_PARAM is the basic item of checkbox arrays. It contains
   * every information related to a checkbox.
   */
 struct KONFIGURATOR_CHECKBOX_PARAM {
     /**
       * The class used in KConfig (ex. "Archives")
       */
     QString configClass;
     /**
       * The item name used in KConfig (ex. "Do Tar")
       */
     QString configName;
     /**
       * The default value of the checkbox
       */
     bool defaultValue;
     /**
       * The text field of the checkbox
       */
     QString text;
     /**
       * The change of this parameter requires Krusader restart
       */
     bool restart;
     /**
       * The checkbox's tooltip
       */
     QString toolTip;
 };
 
 #endif /* __KONFIGURATOR_PAGE_H__ */
diff --git a/krusader/Konfigurator/krresulttable.cpp b/krusader/Konfigurator/krresulttable.cpp
index 2cb0293a..fb40efa6 100644
--- a/krusader/Konfigurator/krresulttable.cpp
+++ b/krusader/Konfigurator/krresulttable.cpp
@@ -1,397 +1,394 @@
 /*****************************************************************************
  * Copyright (C) 2005 Dirk Eschler <deschler@users.sourceforge.net>          *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krresulttable.h"
 
 #include <iostream>
 
 // QtCore
 #include <QList>
 // QtGui
 #include <QFontDatabase>
 #include <QGuiApplication>
 // QtWidgets
 #include <QGridLayout>
 #include <QLabel>
 
 #include <KI18n/KLocalizedString>
 
 #include "../krservices.h"
 #include "../Archive/krarchandler.h"
 
 using namespace std;
 
 #define PS(x) _supported.contains(x)>0
 
 KrResultTable::KrResultTable(QWidget* parent)
         : QWidget(parent),
         _numRows(1)
 {
 }
 
 KrResultTable::~KrResultTable()
-{
-}
+= default;
 
 
 QGridLayout* KrResultTable::initTable()
 {
     _grid = new QGridLayout(this);
     _grid->setColumnStretch(_numColumns - 1, 1); // stretch last column
     _grid->setContentsMargins(0, 0, 0, 0);
     _grid->setSpacing(0);
 
     // +++ Build and add table header +++
     int column = 0;
-    for (QStringList::Iterator it = _tableHeaders.begin(); it != _tableHeaders.end(); ++it) {
-        _label = new QLabel(*it, this);
+    for (auto & _tableHeader : _tableHeaders) {
+        _label = new QLabel(_tableHeader, this);
         _label->setContentsMargins(5, 5, 5, 5);
         _grid->addWidget(_label, 0, column);
 
         // Set font
         QFont defFont = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
         defFont.setPointSize(defFont.pointSize() - 1);
         defFont.setBold(true);
         _label->setFont(defFont);
 
         ++column;
     }
 
     return _grid;
 }
 
 
 void KrResultTable::adjustRow(QGridLayout* grid)
 {
     int i = 0;
     QLayoutItem *child;
     int col = 0;
 
-    while ((child = grid->itemAt(i)) != 0) {
+    while ((child = grid->itemAt(i)) != nullptr) {
         // Add some space between columns
         child->widget()->setMinimumWidth(child->widget()->sizeHint().width() + 15);
 
         // Paint uneven rows in alternate color
         if (((col / _numColumns) % 2)) {
             child->widget()->setAutoFillBackground(true);
             QPalette p = QGuiApplication::palette();
             QPalette pal = child->widget()->palette();
             pal.setColor(child->widget()->backgroundRole(), p.color(QPalette::Active, QPalette::AlternateBase));
             child->widget()->setPalette(pal);
         }
 
         ++i;
         ++col;
     }
 }
 
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 
 KrArchiverResultTable::KrArchiverResultTable(QWidget* parent)
         : KrResultTable(parent)
 {
     _supported = KRarcHandler::supportedPackers(); // get list of available packers
 
     Archiver* tar   = new Archiver("tar",   "https://www.gnu.org/",      PS("tar"),   true,  true);
     Archiver* gzip  = new Archiver("gzip",  "https://www.gnu.org/",      PS("gzip"),  true,  true);
     Archiver* bzip2 = new Archiver("bzip2", "https://www.gnu.org/",      PS("bzip2"), true,  true);
     Archiver* lzma  = new Archiver("lzma",  "https://tukaani.org/lzma/", PS("lzma"),  true,  true);
     Archiver* xz    = new Archiver("xz",    "https://tukaani.org/xz/",   PS("xz"),    true,  true);
     Archiver* lha   = new Archiver("lha",   "https://www.gnu.org/",      PS("lha"),   true,  true);
     Archiver* zip   = new Archiver("zip",   "http://www.info-zip.org",   PS("zip"),   true,  false);
     Archiver* unzip = new Archiver("unzip", "http://www.info-zip.org",   PS("unzip"), false, true);
     Archiver* arj   = new Archiver("arj",   "http://www.arjsoftware.com",  PS("arj"),   true,  true);
     Archiver* unarj = new Archiver("unarj", "http://www.arjsoftware.com",  PS("unarj"), false, true);
     Archiver* unace = new Archiver("unace", "http://www.winace.com",     PS("unace"), false, true);
     Archiver* rar   = new Archiver("rar",   "https://www.rarlab.com/",   PS("rar"),   true,  true);
     Archiver* unrar = new Archiver("unrar", "https://www.rarlab.com/",   PS("unrar"), false, true);
     Archiver* rpm   = new Archiver("rpm",   "https://www.gnu.org/",      PS("rpm"),   false, true);
     Archiver* dpkg  = new Archiver("dpkg",  "https://www.dpkg.org/",     PS("dpkg"),  false, true);
     Archiver* _7z   = new Archiver("7z",    "https://www.7-zip.org/",    PS("7z"),  true, true);
 
     // Special case: arj can unpack, but unarj is preferred
     if (PS("arj") && PS("unarj"))
         arj->setIsUnpacker(false);
     if (PS("arj") && !PS("unarj"))
         unarj->setNote(i18n("unarj not found, but arj found, which will be used for unpacking"));
     // Special case: rar can unpack, but unrar is preferred
     if (PS("rar") && PS("unrar"))
         rar->setIsUnpacker(false);
     // Special case: rpm needs cpio for unpacking
     if (PS("rpm") && !PS("cpio"))
         rpm->setNote(i18n("rpm found, but cpio not found which is required for unpacking"));
 
     _tableHeaders.append(i18n("Name"));
     _tableHeaders.append(i18n("Found"));
     _tableHeaders.append(i18n("Packing"));
     _tableHeaders.append(i18n("Unpacking"));
     _tableHeaders.append(i18n("Note"));
     _numColumns = _tableHeaders.size();
 
     _grid = initTable();
 
     addRow(tar, _grid);
     addRow(gzip, _grid);
     addRow(bzip2, _grid);
     addRow(lzma, _grid);
     addRow(xz, _grid);
     addRow(lha, _grid);
     addRow(zip, _grid);
     addRow(unzip, _grid);
     addRow(arj, _grid);
     addRow(unarj, _grid);
     addRow(unace, _grid);
     addRow(rar, _grid);
     addRow(unrar, _grid);
     addRow(rpm, _grid);
     addRow(dpkg, _grid);
     addRow(_7z, _grid);
 
     delete tar;
     delete gzip;
     delete bzip2;
     delete lzma;
     delete xz;
     delete lha;
     delete zip;
     delete unzip;
     delete arj;
     delete unarj;
     delete unace;
     delete rar;
     delete unrar;
     delete rpm;
     delete dpkg;
     delete _7z;
 }
 
 KrArchiverResultTable::~KrArchiverResultTable()
-{
-}
+= default;
 
 
 bool KrArchiverResultTable::addRow(SearchObject* search, QGridLayout* grid)
 {
-    Archiver* arch = dynamic_cast<Archiver*>(search);
+    auto* arch = dynamic_cast<Archiver*>(search);
 
     // Name column
     KUrlLabel *urlLabel = new KUrlLabel(arch->getWebsite(), arch->getSearchName(), this);
     urlLabel->setContentsMargins(5, 5, 5, 5);
     urlLabel->setAlignment(Qt::AlignTop);
     grid->addWidget(urlLabel, _numRows, 0);
     connect(urlLabel, QOverload<const QString &>::of(&KUrlLabel::leftClickedUrl),
             this, &KrArchiverResultTable::website);
     _label = urlLabel;
 
     // Found column
     _label = new QLabel(arch->getPath(), this);
     _label->setContentsMargins(5, 5, 5, 5);
     grid->addWidget(_label, _numRows, 1);
 
     // Packing column
     _label = new QLabel(this);
     _label->setContentsMargins(5, 5, 5, 5);
     _label->setAlignment(Qt::AlignTop);
     if (arch->getIsPacker() && arch->getFound()) {
         _label->setText(i18n("enabled"));
         QPalette pal = _label->palette();
         pal.setColor(_label->foregroundRole(), "darkgreen");
         _label->setPalette(pal);
     } else if (arch->getIsPacker() && !arch->getFound()) {
         _label->setText(i18n("disabled"));
         QPalette pal = _label->palette();
         pal.setColor(_label->foregroundRole(), "red");
         _label->setPalette(pal);
     } else
         _label->setText("");
     grid->addWidget(_label, _numRows, 2);
 
     // Unpacking column
     _label = new QLabel(this);
     _label->setContentsMargins(5, 5, 5, 5);
     _label->setAlignment(Qt::AlignTop);
     if (arch->getIsUnpacker() && arch->getFound()) {
         _label->setText(i18n("enabled"));
         QPalette pal = _label->palette();
         pal.setColor(_label->foregroundRole(), "darkgreen");
         _label->setPalette(pal);
     } else if (arch->getIsUnpacker() && !arch->getFound()) {
         _label->setText(i18n("disabled"));
         QPalette pal = _label->palette();
         pal.setColor(_label->foregroundRole(), "red");
         _label->setPalette(pal);
     } else
         _label->setText("");
     grid->addWidget(_label, _numRows, 3);
 
     // Note column
     _label = new QLabel(arch->getNote(), this);
     _label->setContentsMargins(5, 5, 5, 5);
     _label->setAlignment(Qt::AlignTop);
     _label->setWordWrap(true);   // wrap words
     grid->addWidget(_label, _numRows, 4);
 
     // Apply shared design elements
     adjustRow(_grid);
 
     // Ensure the last column takes more space
     _label->setMinimumWidth(300);
 
     ++_numRows;
     return true;
 }
 
 
 void KrArchiverResultTable::website(const QString& url)
 {
     (void) new KRun(QUrl(url), this);
 }
 
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 
 KrToolResultTable::KrToolResultTable(QWidget* parent)
         : KrResultTable(parent)
 {
     _supported = KrServices::supportedTools(); // get list of available tools
 
     QList<Application*> vecDiff, vecMail, vecRename, vecChecksum;
     Application* kdiff3         = new Application("kdiff3",        "https://www.kde.org/applications/development/kdiff3/", KrServices::cmdExist("kdiff3"));
     Application* kompare        = new Application("kompare",       "https://www.kde.org/applications/development/kompare/", KrServices::cmdExist("kompare"));
     Application* xxdiff         = new Application("xxdiff",        "http://furius.ca/xxdiff/", KrServices::cmdExist("xxdiff"));
     Application* thunderbird    = new Application("thunderbird",   "https://www.thunderbird.net/", KrServices::cmdExist("thunderbird"));
     Application* kmail          = new Application("kmail",         "https://kontact.kde.org/components/kmail.html", KrServices::cmdExist("kmail"));
     Application* krename        = new Application("krename",       "https://www.kde.org/applications/utilities/krename/", KrServices::cmdExist("krename"));
     Application* md5sum         = new Application("md5sum",        "https://www.gnu.org/software/textutils/textutils.html", KrServices::cmdExist("md5sum"));
 
     vecDiff.push_back(kdiff3);
     vecDiff.push_back(kompare);
     vecDiff.push_back(xxdiff);
     vecMail.push_back(thunderbird);
     vecMail.push_back(kmail);
     vecRename.push_back(krename);
     vecChecksum.push_back(md5sum);
 
     ApplicationGroup* diff     = new ApplicationGroup(i18n("diff utility"),     PS("DIFF"),   vecDiff);
     ApplicationGroup* mail     = new ApplicationGroup(i18n("email client"),     PS("MAIL"),   vecMail);
     ApplicationGroup* rename   = new ApplicationGroup(i18n("batch renamer"),    PS("RENAME"), vecRename);
     ApplicationGroup* checksum = new ApplicationGroup(i18n("checksum utility"), PS("MD5"),    vecChecksum);
 
     _tableHeaders.append(i18n("Group"));
     _tableHeaders.append(i18n("Tool"));
     _tableHeaders.append(i18n("Found"));
     _tableHeaders.append(i18n("Status"));
     _numColumns = _tableHeaders.size();
 
     _grid = initTable();
 
     addRow(diff, _grid);
     addRow(mail, _grid);
     addRow(rename, _grid);
     addRow(checksum, _grid);
 
     delete thunderbird;
     delete kmail;
     delete kompare;
     delete kdiff3;
     delete xxdiff;
     delete krename;
     delete md5sum;
 
     delete diff;
     delete mail;
     delete rename;
     delete checksum;
 }
 
 KrToolResultTable::~KrToolResultTable()
-{
-}
+= default;
 
 
 bool KrToolResultTable::addRow(SearchObject* search, QGridLayout* grid)
 {
-    ApplicationGroup* appGroup = dynamic_cast<ApplicationGroup*>(search);
+    auto* appGroup = dynamic_cast<ApplicationGroup*>(search);
     QList<Application*> _apps = appGroup->getAppVec();
 
     // Name column
     _label = new QLabel(appGroup->getSearchName(), this);
     _label->setContentsMargins(5, 5, 5, 5);
     _label->setAlignment(Qt::AlignTop);
     grid->addWidget(_label, _numRows, 0);
 
     // Tool column
     QWidget* toolBoxWidget = new QWidget(this);
-    QVBoxLayout * toolBox = new QVBoxLayout(toolBoxWidget);
+    auto * toolBox = new QVBoxLayout(toolBoxWidget);
 
-    for (QList<Application*>::Iterator it = _apps.begin(); it != _apps.end(); ++it) {
-        KUrlLabel* l = new KUrlLabel((*it)->getWebsite(), (*it)->getAppName(), toolBoxWidget);
+    for (auto & _app : _apps) {
+        auto* l = new KUrlLabel(_app->getWebsite(), _app->getAppName(), toolBoxWidget);
         toolBox->addWidget(l);
 
         l->setAlignment(Qt::AlignLeft | Qt::AlignTop);
         l->setContentsMargins(5, 5, 5, 5);
         connect(l, QOverload<const QString &>::of(&KUrlLabel::leftClickedUrl), this, &KrToolResultTable::website);
     }
     grid->addWidget(toolBoxWidget, _numRows, 1);
 
     // Found column
     QWidget* vboxWidget = new QWidget(this);
-    QVBoxLayout * vbox = new QVBoxLayout(vboxWidget);
+    auto * vbox = new QVBoxLayout(vboxWidget);
 
-    for (QList<Application*>::Iterator it = _apps.begin(); it != _apps.end(); ++it) {
-        _label = new QLabel((*it)->getPath(), vboxWidget);
+    for (auto & _app : _apps) {
+        _label = new QLabel(_app->getPath(), vboxWidget);
         _label->setContentsMargins(5, 5, 5, 5);
         _label->setAlignment(Qt::AlignTop);
         vbox->addWidget(_label);
     }
     grid->addWidget(vboxWidget, _numRows, 2);
 
     // Status column
     _label = new QLabel(this);
     _label->setContentsMargins(5, 5, 5, 5);
     _label->setAlignment(Qt::AlignTop);
     if (appGroup->getFoundGroup()) {
         _label->setText(i18n("enabled"));
         QPalette pal = _label->palette();
         pal.setColor(_label->foregroundRole(), "darkgreen");
         _label->setPalette(pal);
     } else {
         _label->setText(i18n("disabled"));
         QPalette pal = _label->palette();
         pal.setColor(_label->foregroundRole(), "red");
         _label->setPalette(pal);
     }
     grid->addWidget(_label, _numRows, 3);
 
     // Apply shared design elements
     adjustRow(_grid);
 
     // Ensure the last column takes more space
     _label->setMinimumWidth(300);
 
     ++_numRows;
     return true;
 }
 
 void KrToolResultTable::website(const QString& url)
 {
     (void) new KRun(QUrl(url), this);
 }
diff --git a/krusader/Konfigurator/krresulttable.h b/krusader/Konfigurator/krresulttable.h
index bf73fca8..ea83efda 100644
--- a/krusader/Konfigurator/krresulttable.h
+++ b/krusader/Konfigurator/krresulttable.h
@@ -1,119 +1,119 @@
 /*****************************************************************************
  * Copyright (C) 2005 Dirk Eschler <deschler@users.sourceforge.net>          *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRRESULTTABLE_H
 #define KRRESULTTABLE_H
 
 // QtCore
 #include <QString>
 #include <QStringList>
 #include <QList>
 // QtWidgets
 #include <QLabel>
 #include <QLayout>
 #include <QGridLayout>
 
 #include <KIOWidgets/KRun>
 #include <KWidgetsAddons/KSeparator>
 #include <KWidgetsAddons/KUrlLabel>
 
 #include "searchobject.h"
 
 class KrResultTable : public QWidget
 {
 public:
     explicit KrResultTable(QWidget* parent);
-    virtual ~KrResultTable();
+    ~KrResultTable() override;
 
     /**
     * Adds a row of search results to the end of a QGridLayout
     * Each KrResultTable has to implement it
     *
     * @param search  Name of the SearchObject
     * @param grid    The GridLayout where the row is inserted
     *
     * @return bool  True if row was added successfully to rows, else false
     */
     virtual bool addRow(SearchObject* search, QGridLayout* grid) = 0;
 
 protected:
     QStringList _supported;
     QStringList _tableHeaders;
     int _numColumns;
     int _numRows;
 
     QGridLayout* _grid;
     QLabel* _label; // generic label
 
     /**
     * Creates the main grid layout and attaches the table header
     *
     * @return bool  Pointer to the main grid layout
     */
     QGridLayout* initTable();
 
     /**
     * Applies settings to each cell of the grid layout
     * Supposed to be run after a row was added
     *
     * @param grid  The GridLayout
     */
     void adjustRow(QGridLayout* grid);
 };
 
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 
 class KrArchiverResultTable : public KrResultTable
 {
     Q_OBJECT
 public:
     explicit KrArchiverResultTable(QWidget* parent);
-    virtual ~KrArchiverResultTable();
+    ~KrArchiverResultTable() override;
 
     bool addRow(SearchObject* search, QGridLayout* grid) Q_DECL_OVERRIDE;
 
 protected:
     KUrlLabel* _nameLabel;
 
 protected slots:
     void website(const QString&);
 };
 
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 
 class KrToolResultTable : public KrResultTable
 {
     Q_OBJECT
 public:
     explicit KrToolResultTable(QWidget* parent);
-    virtual ~KrToolResultTable();
+    ~KrToolResultTable() override;
 
     bool addRow(SearchObject* search, QGridLayout* grid) Q_DECL_OVERRIDE;
 
 protected:
     QList<Application*> _apps;
 
 protected slots:
     void website(const QString&);
 };
 
 #endif
diff --git a/krusader/Konfigurator/krresulttabledialog.cpp b/krusader/Konfigurator/krresulttabledialog.cpp
index 65f85312..3111f355 100644
--- a/krusader/Konfigurator/krresulttabledialog.cpp
+++ b/krusader/Konfigurator/krresulttabledialog.cpp
@@ -1,124 +1,123 @@
 /*****************************************************************************
  * Copyright (C) 2005 Dirk Eschler <deschler@users.sourceforge.net>          *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krresulttabledialog.h"
 
 // QtGui
 #include <QFontDatabase>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QLabel>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #include <KConfigWidgets/KHelpClient>
 
 #include "../krglobal.h"
 #include "../icon.h"
 
 KrResultTableDialog::KrResultTableDialog(QWidget *parent, DialogType type,
         const QString& caption, const QString& heading, const QString& headerIcon,
         const QString& hint)
-        : QDialog(parent, 0)
+        : QDialog(parent, nullptr)
 
 {
     setWindowTitle(caption);
     setWindowModality(Qt::WindowModal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
-    QVBoxLayout *_topLayout = new QVBoxLayout();
+    auto *_topLayout = new QVBoxLayout();
     _topLayout->setAlignment(Qt::AlignTop);
 
     // +++ Heading +++
     // prepare the icon
     QWidget *_iconWidget = new QWidget(this);
-    QHBoxLayout * _iconBox = new QHBoxLayout(_iconWidget);
+    auto * _iconBox = new QHBoxLayout(_iconWidget);
     QLabel *_iconLabel = new QLabel(_iconWidget);
     _iconLabel->setPixmap(Icon(headerIcon).pixmap(32));
     _iconLabel->setMinimumWidth(fontMetrics().maxWidth()*20);
     _iconLabel->setAlignment(Qt::AlignLeft | Qt::AlignVCenter);
     _iconLabel->setFixedSize(_iconLabel->sizeHint());
     _iconBox->addWidget(_iconLabel);
     QLabel *_headingLabel = new QLabel(heading, _iconWidget);
     QFont defFont = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
     defFont.setBold(true);
     _headingLabel->setFont(defFont);
     _headingLabel->setIndent(10);
     _iconBox->addWidget(_headingLabel);
     _topLayout->addWidget(_iconWidget);
 
     // +++ Add some space between heading and table +++
-    QSpacerItem* hSpacer1 = new QSpacerItem(0, 5);
+    auto* hSpacer1 = new QSpacerItem(0, 5);
     _topLayout->addItem(hSpacer1);
 
     // +++ Table +++
     switch (type) {
     case Archiver:
         _resultTable = new KrArchiverResultTable(this);
         helpAnchor = QStringLiteral("konfig-archives"); // launch handbook at sect1-id via help button
         break;
     case Tool:
         _resultTable = new KrToolResultTable(this);
         helpAnchor = QStringLiteral("konfig-dependencies"); // TODO find a good anchor
         break;
     default:
         break;
     }
     _topLayout->addWidget(_resultTable);
 
     // +++ Separator +++
     KSeparator* hSep = new KSeparator(Qt::Horizontal, this);
     hSep->setContentsMargins(5, 5, 5, 5);
     _topLayout->addWidget(hSep);
 
     // +++ Hint +++
     if (!hint.isEmpty()) {
         QLabel *_hintLabel = new QLabel(hint, this);
         _hintLabel->setIndent(5);
         _hintLabel->setAlignment(Qt::AlignRight);
         _topLayout->addWidget(_hintLabel);
     }
     mainLayout->addLayout(_topLayout);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Help);
     mainLayout->addWidget(buttonBox);
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &KrResultTableDialog::accept);
     connect(buttonBox, &QDialogButtonBox::helpRequested, this, &KrResultTableDialog::showHelp);
     buttonBox->button(QDialogButtonBox::Ok)->setDefault(true);
 
     this->setFixedSize(this->sizeHint());   // make non-resizeable
 }
 
 KrResultTableDialog::~KrResultTableDialog()
-{
-}
+= default;
 
 void KrResultTableDialog::showHelp()
 {
     if(!helpAnchor.isEmpty()) {
         KHelpClient::invokeHelp(helpAnchor);
     }
 }
diff --git a/krusader/Konfigurator/searchobject.cpp b/krusader/Konfigurator/searchobject.cpp
index 11b7705a..1a9bb81d 100644
--- a/krusader/Konfigurator/searchobject.cpp
+++ b/krusader/Konfigurator/searchobject.cpp
@@ -1,98 +1,92 @@
 /*****************************************************************************
  * Copyright (C) 2005 Dirk Eschler <deschler@users.sourceforge.net>          *
  * Copyright (C) 2005-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "searchobject.h"
 
 #include "../krservices.h"
 
 SearchObject::SearchObject()
-{
-}
+= default;
 
 SearchObject::SearchObject(const QString& searchName, bool found, const QString& note)
         : _searchName(searchName),
         _found(found),
         _note(note)
 {
 }
 
 SearchObject::~SearchObject()
-{
-}
+= default;
 
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 
 Application::Application()
-{
-}
+= default;
 
 Application::Application(const QString& searchName, bool found, const QString& appName, const QString& website, const QString& note)
         : SearchObject(searchName, found, note),
         _appName(appName),
         _website(website),
         _path(KrServices::fullPathName(appName))
 {
 }
 
 Application::Application(const QString& searchName, const QString& website, bool found, const QString& note)
         : SearchObject(searchName, found, note),
         _appName(searchName),
         _website(website),
         _path(KrServices::fullPathName(searchName))
 {
 }
 
 Application::~Application()
-{
-}
+= default;
 
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 
 Archiver::Archiver()
         : Application()
 {
 }
 
 Archiver::Archiver(const QString& searchName, const QString& website, bool found, bool isPacker, bool isUnpacker, const QString& note)
         : Application(searchName, website, found, note),
         _isPacker(isPacker),
         _isUnpacker(isUnpacker)
 {
 }
 
 Archiver::~Archiver()
-{
-}
+= default;
 
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 
 ApplicationGroup::ApplicationGroup(const QString& searchName, bool foundGroup, const QList<Application*>& apps, const QString& note)
         : SearchObject(searchName, foundGroup, note),
         _apps(apps),
         _foundGroup(foundGroup)
 {
 }
 
 ApplicationGroup::~ApplicationGroup()
-{
-}
+= default;
diff --git a/krusader/Locate/locate.cpp b/krusader/Locate/locate.cpp
index 6e1f4f41..86809723 100644
--- a/krusader/Locate/locate.cpp
+++ b/krusader/Locate/locate.cpp
@@ -1,689 +1,689 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "locate.h"
 #include "../kractions.h"
 #include "../krglobal.h"
 #include "../filelisticon.h"
 #include "../krslots.h"
 #include "../krusaderview.h"
 #include "../Panel/krpanel.h"
 #include "../Panel/panelfunc.h"
 #include "../GUI/krtreewidget.h"
 #include "../defaults.h"
 #include "../krservices.h"
 #include "../FileSystem/filesystem.h"
 #include "../FileSystem/virtualfilesystem.h"
 #include "../KViewer/krviewer.h"
 #include "../panelmanager.h"
 
 // QtCore
 #include <QRegExp>
 #include <QEventLoop>
 #include <QDir>
 #include <QMimeData>
 // QtGui
 #include <QFontMetrics>
 #include <QKeyEvent>
 #include <QCursor>
 #include <QClipboard>
 #include <QFont>
 #include <QDrag>
 // QtWidgets
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QGridLayout>
 #include <QHeaderView>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QTreeWidget>
 
 #include <KConfigCore/KConfig>
 #include <KCoreAddons/KProcess>
 #include <KI18n/KLocalizedString>
 #include <KIOCore/KFileItem>
 #include <KWidgetsAddons/KMessageBox>
 #include <KCoreAddons/KShell>
 #include <KTextWidgets/KFindDialog>
 #include <KTextWidgets/KFind>
 
 // these are the values that will exist in the menu
 #define VIEW_ID                     90
 #define EDIT_ID                     91
 #define FIND_ID                     92
 #define FIND_NEXT_ID                93
 #define FIND_PREV_ID                94
 #define COPY_SELECTED_TO_CLIPBOARD  95
 #define COMPARE_ID                  96
 //////////////////////////////////////////////////////////
 
 class LocateListView : public KrTreeWidget
 {
 public:
     explicit LocateListView(QWidget * parent) : KrTreeWidget(parent) {
         setAlternatingRowColors(true);
     }
 
     void startDrag(Qt::DropActions supportedActs) Q_DECL_OVERRIDE {
         Q_UNUSED(supportedActs);
 
         QList<QUrl> urls;
         QList<QTreeWidgetItem *> list = selectedItems();
 
         QListIterator<QTreeWidgetItem *> it(list);
 
         while (it.hasNext()) {
             QTreeWidgetItem * item = it.next();
 
             urls.push_back(QUrl::fromLocalFile(item->text(0)));
         }
 
         if (urls.count() == 0)
             return;
 
 
-        QDrag *drag = new QDrag(this);
-        QMimeData *mimeData = new QMimeData;
+        auto *drag = new QDrag(this);
+        auto *mimeData = new QMimeData;
         mimeData->setImageData(FileListIcon("file").pixmap());
         mimeData->setUrls(urls);
         drag->setMimeData(mimeData);
         drag->start();
     }
 };
 
-KProcess *  LocateDlg::updateProcess = 0;
-LocateDlg * LocateDlg::LocateDialog = 0;
+KProcess *  LocateDlg::updateProcess = nullptr;
+LocateDlg * LocateDlg::LocateDialog = nullptr;
 
 LocateDlg::LocateDlg(QWidget *parent) : QDialog(parent), isFeedToListBox(false)
 {
     setWindowTitle(i18n("Krusader::Locate"));
     setWindowModality(Qt::NonModal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
-    QGridLayout *grid = new QGridLayout();
+    auto *grid = new QGridLayout();
     grid->setSpacing(6);
     grid->setContentsMargins(11, 11, 11, 11);
 
     QWidget *hboxWidget = new QWidget(this);
-    QHBoxLayout *hbox = new QHBoxLayout(hboxWidget);
+    auto *hbox = new QHBoxLayout(hboxWidget);
     hbox->setContentsMargins(0, 0, 0, 0);
 
     QLabel *label = new QLabel(i18n("Search for:"), hboxWidget);
     hbox->addWidget(label);
 
     locateSearchFor = new KHistoryComboBox(false, hboxWidget);
     locateSearchFor->setMinimumContentsLength(10);
     hbox->addWidget(locateSearchFor);
 
     label->setBuddy(locateSearchFor);
     KConfigGroup group(krConfig, "Locate");
     QStringList list = group.readEntry("Search For", QStringList());
     locateSearchFor->setMaxCount(25);  // remember 25 items
     locateSearchFor->setHistoryItems(list);
     locateSearchFor->setEditable(true);
     locateSearchFor->setDuplicatesEnabled(false);
     locateSearchFor->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     locateSearchFor->lineEdit()->setFocus();
 
     grid->addWidget(hboxWidget, 0, 0);
 
     QWidget *hboxWidget2 = new QWidget(this);
-    QHBoxLayout * hbox2 = new QHBoxLayout(hboxWidget2);
+    auto * hbox2 = new QHBoxLayout(hboxWidget2);
     hbox2->setContentsMargins(0, 0, 0, 0);
 
-    QSpacerItem* spacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+    auto* spacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     hbox2->addItem(spacer);
 
     dontSearchInPath = new QCheckBox(i18n("Do not search in path"), hboxWidget2);
     hbox2->addWidget(dontSearchInPath);
     dontSearchInPath->setChecked(group.readEntry("Don't Search In Path", false));
 
     existingFiles = new QCheckBox(i18n("Show only the existing files"), hboxWidget2);
     existingFiles->setChecked(group.readEntry("Existing Files", false));
     hbox2->addWidget(existingFiles);
 
     caseSensitive = new QCheckBox(i18n("Case Sensitive"), hboxWidget2);
     caseSensitive->setChecked(group.readEntry("Case Sensitive", false));
     hbox2->addWidget(caseSensitive);
 
     grid->addWidget(hboxWidget2, 1, 0);
 
     QFrame *line1 = new QFrame(this);
     line1->setFrameStyle(QFrame::HLine | QFrame::Sunken);
     grid->addWidget(line1, 2, 0);
 
     resultList = new LocateListView(this);  // create the main container
     resultList->setColumnCount(1);
     resultList->setHeaderLabel(i18n("Results"));
 
     resultList->setColumnWidth(0, QFontMetrics(resultList->font()).width("W") * 60);
 
     KConfigGroup gl(krConfig, "Look&Feel");
     resultList->setFont(gl.readEntry("Filelist Font", _FilelistFont));
 
     resultList->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     resultList->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     resultList->header()->setSortIndicatorShown(false);
     resultList->setSortingEnabled(false);
     resultList->setSelectionMode(QAbstractItemView::ExtendedSelection);
     resultList->setDragEnabled(true);
 
     connect(resultList, &KrTreeWidget::itemRightClicked, this, &LocateDlg::slotRightClick);
     connect(resultList, &KrTreeWidget::itemDoubleClicked, this, &LocateDlg::slotDoubleClick);
     connect(resultList, &KrTreeWidget::itemActivated, this, &LocateDlg::slotDoubleClick);
 
     grid->addWidget(resultList, 3, 0);
 
     QFrame *line2 = new QFrame(this);
     line2->setFrameStyle(QFrame::HLine | QFrame::Sunken);
     grid->addWidget(line2, 4, 0);
 
     mainLayout->addLayout(grid);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     locateButton = new QPushButton(i18n("Locate"));
     locateButton->setIcon(Icon(QStringLiteral("system-search")));
     locateButton->setDefault(true);
     buttonBox->addButton(locateButton, QDialogButtonBox::ActionRole);
 
     updateDbButton = new QPushButton(i18n("Update DB"));
     updateDbButton->setIcon(Icon(QStringLiteral("view-refresh")));
     buttonBox->addButton(updateDbButton, QDialogButtonBox::ActionRole);
 
     feedStopButton = new QPushButton;
     buttonBox->addButton(feedStopButton, QDialogButtonBox::ActionRole);
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &LocateDlg::reject);
     connect(locateButton, &QPushButton::clicked, this, &LocateDlg::slotLocate);
     connect(updateDbButton, &QPushButton::clicked, this, &LocateDlg::slotUpdateDb);
     connect(feedStopButton, &QPushButton::clicked, this, &LocateDlg::slotFeedStop);
 
     updateButtons(false);
 
     if (updateProcess) {
         if (updateProcess->state() == QProcess::Running) {
             connect(updateProcess, QOverload<int, QProcess::ExitStatus>::of(&KProcess::finished), this, &LocateDlg::updateFinished);
             updateDbButton->setEnabled(false);
         } else
             updateFinished();
     }
 
     show();
 
     LocateDialog = this;
 }
 
 void LocateDlg::slotFeedStop()   /* The stop / feed to listbox button */
 {
     if (isFeedToListBox)
         feedToListBox();
     else
         locateProc->kill();
 }
 
 void LocateDlg::slotUpdateDb()   /* The Update DB button */
 {
     if (!updateProcess) {
         KConfigGroup group(krConfig, "Locate");
 
         updateProcess = new KProcess(); // don't set the parent to 'this'! That would cause this process to be deleted once the dialog is closed
         *updateProcess << KrServices::fullPathName("updatedb");
         *updateProcess << KShell::splitArgs(group.readEntry("UpdateDB Arguments"));
 
         connect(updateProcess, QOverload<int, QProcess::ExitStatus>::of(&KProcess::finished), this, &LocateDlg::updateFinished);
         updateProcess->start();
         updateDbButton->setEnabled(false);
     }
 }
 
 void LocateDlg::updateFinished()
 {
     delete updateProcess;
-    updateProcess = 0;
+    updateProcess = nullptr;
     updateDbButton->setEnabled(true);
 }
 
 void LocateDlg::slotLocate()   /* The locate button */
 {
     locateSearchFor->addToHistory(locateSearchFor->currentText());
     QStringList list = locateSearchFor->historyItems();
     KConfigGroup group(krConfig, "Locate");
     group.writeEntry("Search For", list);
     group.writeEntry("Don't Search In Path", dontSearchPath = dontSearchInPath->isChecked());
     group.writeEntry("Existing Files", onlyExist = existingFiles->isChecked());
     group.writeEntry("Case Sensitive", isCs = caseSensitive->isChecked());
 
     if (!KrServices::cmdExist("locate")) {
-        KMessageBox::error(0,
+        KMessageBox::error(nullptr,
                            i18n("Cannot start 'locate'. Check the 'Dependencies' page in konfigurator."));
         return;
     }
 
     resultList->clear();
-    lastItem = 0;
+    lastItem = nullptr;
     remaining = "";
 
     updateButtons(true);
 
     isFeedToListBox = false;
     resultList->setFocus();
 
     qApp->processEvents(); //FIXME - what's this for ?
 
     locateProc = new KProcess(this);
     locateProc->setOutputChannelMode(KProcess::SeparateChannels); // default is forwarding to the parent channels
     connect(locateProc, &KProcess::readyReadStandardOutput, this, &LocateDlg::processStdout);
     connect(locateProc, &KProcess::readyReadStandardError, this, &LocateDlg::processStderr);
     connect(locateProc, QOverload<int,QProcess::ExitStatus>::of(&KProcess::finished), this, &LocateDlg::locateFinished);
     connect(locateProc, QOverload<QProcess::ProcessError>::of(&KProcess::error), this, &LocateDlg::locateError);
 
     *locateProc << KrServices::fullPathName("locate");
     if (!isCs)
         *locateProc << "-i";
     *locateProc << (pattern = locateSearchFor->currentText());
 
     if (!pattern.startsWith('*'))
         pattern = '*' + pattern;
     if (!pattern.endsWith('*'))
         pattern = pattern + '*';
 
     collectedErr = "";
     locateProc->start();
 }
 
 void LocateDlg::locateError()
 {
     if (locateProc->error() == QProcess::FailedToStart)
         KMessageBox::error(krMainWindow, i18n("Error during the start of 'locate' process."));
 }
 
 void LocateDlg::locateFinished()
 {
     if (locateProc->exitStatus() != QProcess::NormalExit || locateProc->exitStatus()) {
         if (!collectedErr.isEmpty())
             KMessageBox::error(krMainWindow, i18n("Locate produced the following error message:\n\n%1", collectedErr));
     }
 
     if (resultList->topLevelItemCount() == 0) {
         locateSearchFor->setFocus();
         isFeedToListBox = false;
     } else {
         isFeedToListBox = true;
     }
 
     updateButtons(false);
 }
 
 void LocateDlg::processStdout()
 {
     remaining += QString::fromLocal8Bit(locateProc->readAllStandardOutput());
 
     QStringList list = remaining.split('\n');
     int items = list.size();
 
-    for (QStringList::Iterator it = list.begin(); it != list.end(); ++it) {
+    for (auto & it : list) {
         if (--items == 0 && !remaining.endsWith('\n'))
-            remaining = *it;
+            remaining = it;
         else {
             if (dontSearchPath) {
                 QRegExp regExp(pattern, isCs ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard);
-                QString fileName = (*it).trimmed();
+                QString fileName = it.trimmed();
                 if (fileName.endsWith(QLatin1String("/")) && fileName != "/") {
                     fileName.truncate(fileName.length() - 1);
                 }
                 fileName = fileName.mid(fileName.lastIndexOf('/') + 1);
 
                 if (!regExp.exactMatch(fileName))
                     continue;
             }
             if (onlyExist) {
-                KFileItem file(QUrl::fromLocalFile((*it).trimmed()));
+                KFileItem file(QUrl::fromLocalFile(it.trimmed()));
                 if (!file.isReadable())
                     continue;
             }
 
             if (lastItem)
                 lastItem = new QTreeWidgetItem(resultList, lastItem);
             else
                 lastItem = new QTreeWidgetItem(resultList);
 
-            lastItem->setText(0, *it);
+            lastItem->setText(0, it);
         }
     }
 }
 
 void LocateDlg::processStderr()
 {
     collectedErr += QString::fromLocal8Bit(locateProc->readAllStandardError());
 }
 
 void LocateDlg::slotRightClick(QTreeWidgetItem *item, const QPoint &pos)
 {
     if (!item)
         return;
 
     // create the menu
     QMenu popup;
     popup.setTitle(i18nc("@title:menu", "Locate"));
 
     QAction * actView = popup.addAction(i18n("View (F3)"));
     QAction * actEdit = popup.addAction(i18n("Edit (F4)"));
     QAction * actComp = popup.addAction(i18n("Compare by content (F10)"));
     if (resultList->selectedItems().count() != 2)
         actComp->setEnabled(false);
     popup.addSeparator();
 
     QAction * actFind = popup.addAction(i18n("Find (Ctrl+F)"));
     QAction * actNext = popup.addAction(i18n("Find next (Ctrl+N)"));
     QAction * actPrev = popup.addAction(i18n("Find previous (Ctrl+P)"));
     popup.addSeparator();
 
     QAction * actClip = popup.addAction(i18n("Copy selected to clipboard"));
 
 
     QAction * result = popup.exec(pos);
 
     int ret = -1;
 
     if (result == actView)
         ret = VIEW_ID;
     else if (result == actEdit)
         ret = EDIT_ID;
     else if (result == actFind)
         ret = FIND_ID;
     else if (result == actNext)
         ret = FIND_NEXT_ID;
     else if (result == actPrev)
         ret = FIND_PREV_ID;
     else if (result == actClip)
         ret = COPY_SELECTED_TO_CLIPBOARD;
     else if (result == actComp)
         ret = COMPARE_ID;
 
     if (ret != - 1)
         operate(item, ret);
 }
 
 void LocateDlg::slotDoubleClick(QTreeWidgetItem *item)
 {
     if (!item)
         return;
 
     QString dirName = item->text(0);
     QString fileName;
 
     if (!QDir(dirName).exists()) {
         fileName = dirName.mid(dirName.lastIndexOf('/') + 1);
         dirName.truncate(dirName.lastIndexOf('/'));
     }
 
     ACTIVE_FUNC->openUrl(QUrl::fromLocalFile(dirName), fileName);
     QDialog::accept();
 }
 
 void LocateDlg::keyPressEvent(QKeyEvent *e)
 {
     if (KrGlobal::copyShortcut == QKeySequence(e->key() | e->modifiers())) {
-        operate(0, COPY_SELECTED_TO_CLIPBOARD);
+        operate(nullptr, COPY_SELECTED_TO_CLIPBOARD);
         e->accept();
         return;
     }
 
     switch (e->key()) {
     case Qt::Key_M :
         if (e->modifiers() == Qt::ControlModifier) {
             resultList->setFocus();
             e->accept();
         }
         break;
     case Qt::Key_F3 :
         if (resultList->currentItem())
             operate(resultList->currentItem(), VIEW_ID);
         break;
     case Qt::Key_F4 :
         if (resultList->currentItem())
             operate(resultList->currentItem(), EDIT_ID);
         break;
     case Qt::Key_F10 :
-        operate(0, COMPARE_ID);
+        operate(nullptr, COMPARE_ID);
         break;
     case Qt::Key_N :
         if (e->modifiers() == Qt::ControlModifier)
             operate(resultList->currentItem(), FIND_NEXT_ID);
         break;
     case Qt::Key_P :
         if (e->modifiers() == Qt::ControlModifier)
             operate(resultList->currentItem(), FIND_PREV_ID);
         break;
     case Qt::Key_F :
         if (e->modifiers() == Qt::ControlModifier)
             operate(resultList->currentItem(), FIND_ID);
         break;
     }
 
     QDialog::keyPressEvent(e);
 }
 
 void LocateDlg::operate(QTreeWidgetItem *item, int task)
 {
     QUrl name;
-    if (item != 0)
+    if (item != nullptr)
         name = QUrl::fromLocalFile(item->text(0));
 
     switch (task) {
     case VIEW_ID:
         KrViewer::view(name, this);   // view the file
         break;
     case EDIT_ID:
         KrViewer::edit(name, this);   // view the file
         break;
     case COMPARE_ID: {
         QList<QTreeWidgetItem *> list = resultList->selectedItems();
         if (list.count() != 2)
             break;
 
         QUrl url1 = QUrl::fromLocalFile(list[ 0 ]->text(0));
         QUrl url2 = QUrl::fromLocalFile(list[ 1 ]->text(0));
 
         SLOTS->compareContent(url1,url2);
     }
     break;
     case FIND_ID: {
         KConfigGroup group(krConfig, "Locate");
         long options = group.readEntry("Find Options", (long long)0);
         QStringList list = group.readEntry("Find Patterns", QStringList());
 
         QPointer<KFindDialog> dlg = new KFindDialog(this, options, list);
         if (dlg->exec() != QDialog::Accepted) {
             delete dlg;
             return;
         }
 
         QString first;
         if (list.count() != 0) {
             first = list.first();
         }
         if (first != (findPattern = dlg->pattern())) {
             list.push_front(dlg->pattern());
         }
 
         group.writeEntry("Find Options", (long long)(findOptions = dlg->options()));
         group.writeEntry("Find Patterns", list);
 
         if (!(findOptions & KFind::FromCursor) && resultList->topLevelItemCount())
             resultList->setCurrentItem((findOptions & KFind::FindBackwards) ?
                                        resultList->topLevelItem(resultList->topLevelItemCount() - 1) : resultList->topLevelItem(0));
 
         findCurrentItem = resultList->currentItem();
 
         if (find() && findCurrentItem) {
             resultList->selectionModel()->clearSelection(); // HACK: QT 4 is not able to paint the focus frame because of a bug
             resultList->setCurrentItem(findCurrentItem);
         } else {
             KMessageBox::information(this, i18n("Search string not found."));
         }
 
         resultList->scrollTo(resultList->currentIndex());
 
         delete dlg;
     }
     break;
     case FIND_NEXT_ID:
     case FIND_PREV_ID: {
         if (task == FIND_PREV_ID)
             findOptions ^= KFind::FindBackwards;
 
         findCurrentItem = resultList->currentItem();
         nextLine();
 
         if (find() && findCurrentItem) {
             resultList->selectionModel()->clearSelection(); // HACK: QT 4 is not able to paint the focus frame because of a bug
             resultList->setCurrentItem(findCurrentItem);
         } else
             KMessageBox::information(this, i18n("Search string not found."));
 
         resultList->scrollTo(resultList->currentIndex());
 
         if (task == FIND_PREV_ID)
             findOptions ^= KFind::FindBackwards;
     }
     break;
     case COPY_SELECTED_TO_CLIPBOARD: {
         QList<QUrl> urls;
 
         QTreeWidgetItemIterator it(resultList);
         while (*it) {
             if ((*it)->isSelected())
                 urls.push_back(QUrl::fromLocalFile((*it)->text(0)));
 
             it++;
         }
 
         if (urls.count() == 0)
             return;
 
-        QMimeData *mimeData = new QMimeData;
+        auto *mimeData = new QMimeData;
         mimeData->setImageData(FileListIcon("file").pixmap());
         mimeData->setUrls(urls);
 
         QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
     }
     break;
     }
 }
 
 void LocateDlg::nextLine()
 {
     if (findOptions & KFind::FindBackwards)
         findCurrentItem = resultList->itemAbove(findCurrentItem);
     else
         findCurrentItem = resultList->itemBelow(findCurrentItem);
 }
 
 bool LocateDlg::find()
 {
     while (findCurrentItem) {
         QString item = findCurrentItem->text(0);
 
         if (findOptions & KFind::RegularExpression) {
             if (item.contains(QRegExp(findPattern, ((findOptions & KFind::CaseSensitive) != 0) ? Qt::CaseSensitive : Qt::CaseInsensitive)))
                 return true;
         } else {
             if (item.contains(findPattern, ((findOptions & KFind::CaseSensitive) != 0) ? Qt::CaseSensitive : Qt::CaseInsensitive))
                 return true;
         }
 
         nextLine();
     }
 
     return false;
 }
 
 void LocateDlg::feedToListBox()
 {
     VirtualFileSystem virtFilesystem;
     virtFilesystem.scanDir(QUrl::fromLocalFile(QStringLiteral("/")));
 
     KConfigGroup group(krConfig, "Locate");
     int listBoxNum = group.readEntry("Feed To Listbox Counter", 1);
     QString queryName;
     do {
         queryName = i18n("Locate results") + QString(" %1").arg(listBoxNum++);
-    } while (virtFilesystem.getFileItem(queryName) != 0);
+    } while (virtFilesystem.getFileItem(queryName) != nullptr);
     group.writeEntry("Feed To Listbox Counter", listBoxNum);
 
     KConfigGroup ga(krConfig, "Advanced");
     if (ga.readEntry("Confirm Feed to Listbox",  _ConfirmFeedToListbox)) {
         bool ok;
         queryName = QInputDialog::getText(this, i18n("Query Name"), i18n("Here you can name the file collection:"),
                                           QLineEdit::Normal, queryName, &ok);
         if (! ok)
             return;
     }
 
     QList<QUrl> urlList;
     QTreeWidgetItemIterator it(resultList);
     while (*it) {
         QTreeWidgetItem * item = *it;
         urlList.push_back(QUrl::fromLocalFile(item->text(0)));
         it++;
     }
     QUrl url = QUrl(QStringLiteral("virt:/") + queryName);
     virtFilesystem.refresh(url); // create directory if it does not exist
     virtFilesystem.addFiles(urlList);
     //ACTIVE_FUNC->openUrl(url);
     ACTIVE_MNG->slotNewTab(url);
     accept();
 }
 
 void LocateDlg::reset()
 {
     locateSearchFor->lineEdit()->setFocus();
     locateSearchFor->lineEdit()->selectAll();
 }
 
 void LocateDlg::updateButtons(bool locateIsRunning)
 {
     locateButton->setEnabled(!locateIsRunning);
 
     if (locateIsRunning) {
         feedStopButton->setEnabled(true);
         feedStopButton->setText(i18n("Stop"));
         feedStopButton->setIcon(Icon(QStringLiteral("process-stop")));
     } else {
         if (resultList->topLevelItemCount() == 0) {
             feedStopButton->setEnabled(false);
             feedStopButton->setText(i18n("Stop"));
             feedStopButton->setIcon(Icon(QStringLiteral("process-stop")));
         } else {
             feedStopButton->setEnabled(true);
             feedStopButton->setText(i18n("Feed to listbox"));
             feedStopButton->setIcon(Icon(QStringLiteral("list-add")));
         }
     }
 }
 
diff --git a/krusader/MountMan/kmountman.cpp b/krusader/MountMan/kmountman.cpp
index 09dc20c6..8eedd235 100644
--- a/krusader/MountMan/kmountman.cpp
+++ b/krusader/MountMan/kmountman.cpp
@@ -1,464 +1,465 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kmountman.h"
 
 // QtCore
 #include <QDir>
 // QtWidgets
 #include <QApplication>
 #include <QMenu>
 
 #include <KConfigCore/KSharedConfig>
 #include <KCoreAddons/KJobTrackerInterface>
 #include <KCoreAddons/KProcess>
 #include <KI18n/KLocalizedString>
 #include <KIO/JobUiDelegate>
 #include <KWidgetsAddons/KMessageBox>
 #include <KWidgetsAddons/KToolBarPopupAction>
 
 #include <Solid/Block>
 #include <Solid/OpticalDisc>
 #include <Solid/OpticalDrive>
 #include <Solid/StorageAccess>
 #include <Solid/StorageVolume>
+#include <utility>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../kractions.h"
 #include "../defaults.h"
 #include "../Dialogs/krdialogs.h"
 #include "../krservices.h"
 #include "kmountmangui.h"
 #include "../FileSystem/krpermhandler.h"
 
 #ifdef _OS_SOLARIS_
 #define FSTAB "/etc/filesystemtab"
 #else
 #define FSTAB "/etc/fstab"
 #endif
 
-KMountMan::KMountMan(QWidget *parent) : QObject(), _operational(false), waiting(false), mountManGui(0), parentWindow(parent)
+KMountMan::KMountMan(QWidget *parent) : _operational(false), waiting(false), mountManGui(nullptr), parentWindow(parent)
 {
     _action = new KToolBarPopupAction(Icon("kr_mountman"), i18n("&MountMan..."), this);
     connect(_action, &QAction::triggered, this, &KMountMan::mainWindow);
     connect(_action->menu(), &QMenu::aboutToShow, this, &KMountMan::quickList);
     _manageAction = _action->menu()->addAction(i18n("Open &MountMan"));
     connect(_manageAction, &QAction::triggered, this, &KMountMan::mainWindow);
     _action->menu()->addSeparator();
 
     // added as a precaution, although we use kde services now
     _operational = KrServices::cmdExist("mount");
 
     network_fs << "nfs" << "smbfs" << "fuse.fusesmb" << "fuse.sshfs"; //TODO: is this list complete ?
 
     // list of FS that we don't manage at all
     invalid_fs << "swap" << "/dev/pts" << "tmpfs" << "devpts" << "sysfs" << "rpc_pipefs" << "usbfs" << "binfmt_misc";
 #ifdef BSD
     invalid_fs << "procfs";
 #else
     invalid_fs << "proc";
 #endif
 
     // list of FS that we don't allow to mount/unmount
     nonmount_fs << "supermount";
     {
         KConfigGroup group(krConfig, "Advanced");
         QStringList nonmount = group.readEntry("Nonmount Points", _NonMountPoints).split(',');
         nonmount_fs_mntpoint += nonmount;
         // simplify the white space
-        for (QStringList::Iterator it = nonmount_fs_mntpoint.begin(); it != nonmount_fs_mntpoint.end(); ++it) {
-            *it = (*it).simplified();
+        for (auto & it : nonmount_fs_mntpoint) {
+            it = it.simplified();
         }
     }
 
 }
 
-KMountMan::~KMountMan() {}
+KMountMan::~KMountMan() = default;
 
-bool KMountMan::invalidFilesystem(QString type)
+bool KMountMan::invalidFilesystem(const QString& type)
 {
     return (invalid_fs.contains(type) > 0);
 }
 
 // this is an ugly hack, but type can actually be a mountpoint. oh well...
-bool KMountMan::nonmountFilesystem(QString type, QString mntPoint)
+bool KMountMan::nonmountFilesystem(const QString& type, const QString& mntPoint)
 {
     return((nonmount_fs.contains(type) > 0) || (nonmount_fs_mntpoint.contains(mntPoint) > 0));
 }
 
-bool KMountMan::networkFilesystem(QString type)
+bool KMountMan::networkFilesystem(const QString& type)
 {
     return (network_fs.contains(type) > 0);
 }
 
 void KMountMan::mainWindow()
 {
     // left as a precaution, although we use kde's services now
     if (!KrServices::cmdExist("mount")) {
-        KMessageBox::error(0, i18n("Cannot start 'mount'. Check the 'Dependencies' page in konfigurator."));
+        KMessageBox::error(nullptr, i18n("Cannot start 'mount'. Check the 'Dependencies' page in konfigurator."));
         return;
     }
 
     mountManGui = new KMountManGUI(this);
     delete mountManGui;   /* as KMountManGUI is modal, we can now delete it */
     mountManGui = nullptr; /* for sanity */
 }
 
 QExplicitlySharedDataPointer<KMountPoint> KMountMan::findInListByMntPoint(KMountPoint::List &lst, QString value)
 {
     if (value.length() > 1 && value.endsWith('/'))
         value = value.left(value.length() - 1);
 
     QExplicitlySharedDataPointer<KMountPoint> m;
-    for (KMountPoint::List::iterator it = lst.begin(); it != lst.end(); ++it) {
-        m = it->data();
+    for (auto & it : lst) {
+        m = it.data();
         QString mntPnt = m->mountPoint();
         if (mntPnt.length() > 1 && mntPnt.endsWith('/'))
             mntPnt = mntPnt.left(mntPnt.length() - 1);
         if (mntPnt == value)
             return m;
     }
 
     return QExplicitlySharedDataPointer<KMountPoint>();
 }
 
 void KMountMan::jobResult(KJob *job)
 {
     waiting = false;
     if (job->error())
         job->uiDelegate()->showErrorMessage();
 }
 
-void KMountMan::mount(QString mntPoint, bool blocking)
+void KMountMan::mount(const QString& mntPoint, bool blocking)
 {
     QString udi = findUdiForPath(mntPoint, Solid::DeviceInterface::StorageAccess);
     if (!udi.isNull()) {
         Solid::Device device(udi);
-        Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
+        auto *access = device.as<Solid::StorageAccess>();
         if (access && !access->isAccessible()) {
             connect(access, &Solid::StorageAccess::setupDone, this, &KMountMan::slotSetupDone, Qt::UniqueConnection);
             if (blocking)
                 waiting = true; // prepare to block
             access->setup();
         }
     } else {
         KMountPoint::List possible = KMountPoint::possibleMountPoints(KMountPoint::NeedMountOptions);
         QExplicitlySharedDataPointer<KMountPoint> m = findInListByMntPoint(possible, mntPoint);
         if (!((bool)m)) return;
         if (blocking)
             waiting = true; // prepare to block
 
         // KDE4 doesn't allow mounting devices as user, because they think it's the right behaviour.
         // I add this patch, as I don't think so.
         if (geteuid()) { // tries to mount as an user?
             KProcess proc;
             proc << KrServices::fullPathName("mount") << mntPoint;
             proc.start();
             if (!blocking)
                 return;
             proc.waitForFinished(-1); // -1 msec blocks without timeout
             if (proc.exitStatus() == QProcess::NormalExit && proc.exitCode() == 0)
                 return;
         }
 
         KIO::SimpleJob *job = KIO::mount(false, m->mountType().toLocal8Bit(), m->mountedFrom(), m->mountPoint(), KIO::DefaultFlags);
         job->setUiDelegate(new KIO::JobUiDelegate());
         KIO::getJobTracker()->registerJob(job);
         connect(job, &KIO::SimpleJob::result, this, &KMountMan::jobResult);
     }
     while (blocking && waiting) {
         qApp->processEvents();
         usleep(1000);
     }
 }
 
-void KMountMan::unmount(QString mntPoint, bool blocking)
+void KMountMan::unmount(const QString& mntPoint, bool blocking)
 {
     //if working dir is below mountpoint cd to ~ first
     if(QUrl::fromLocalFile(QDir(mntPoint).canonicalPath()).isParentOf(QUrl::fromLocalFile(QDir::current().canonicalPath())))
         QDir::setCurrent(QDir::homePath());
 
     QString udi = findUdiForPath(mntPoint, Solid::DeviceInterface::StorageAccess);
     if (!udi.isNull()) {
         Solid::Device device(udi);
-        Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
+        auto *access = device.as<Solid::StorageAccess>();
         if (access && access->isAccessible()) {
             connect(access, &Solid::StorageAccess::teardownDone, this, &KMountMan::slotTeardownDone, Qt::UniqueConnection);
             access->teardown();
         }
     } else {
         if (blocking)
             waiting = true; // prepare to block
 
         // KDE4 doesn't allow unmounting devices as user, because they think it's the right behaviour.
         // I add this patch, as I don't think so.
         if (geteuid()) { // tries to mount as an user?
             KProcess proc;
             proc << KrServices::fullPathName("umount") << mntPoint;
             proc.start();
             if (!blocking)
                 return;
             proc.waitForFinished(-1); // -1 msec blocks without timeout
             if (proc.exitStatus() == QProcess::NormalExit && proc.exitCode() == 0)
                 return;
         }
 
         KIO::SimpleJob *job = KIO::unmount(mntPoint, KIO::DefaultFlags);
         job->setUiDelegate(new KIO::JobUiDelegate());
         KIO::getJobTracker()->registerJob(job);
         connect(job, &KIO::SimpleJob::result, this, &KMountMan::jobResult);
     }
     while (blocking && waiting) {
         qApp->processEvents();
         usleep(1000);
     }
 }
 
-KMountMan::mntStatus KMountMan::getStatus(QString mntPoint)
+KMountMan::mntStatus KMountMan::getStatus(const QString& mntPoint)
 {
     QExplicitlySharedDataPointer<KMountPoint> mountPoint;
 
     // 1: is it already mounted
     KMountPoint::List current = KMountPoint::currentMountPoints();
     mountPoint = findInListByMntPoint(current, mntPoint);
     if ((bool) mountPoint)
         return MOUNTED;
 
     // 2: is it a mount point but not mounted?
     KMountPoint::List possible = KMountPoint::possibleMountPoints();
     mountPoint = findInListByMntPoint(possible, mntPoint);
     if ((bool) mountPoint)
         return NOT_MOUNTED;
 
     // 3: unknown
     return DOESNT_EXIST;
 }
 
 
-void KMountMan::toggleMount(QString mntPoint)
+void KMountMan::toggleMount(const QString& mntPoint)
 {
     mntStatus status = getStatus(mntPoint);
     switch (status) {
     case MOUNTED:
         unmount(mntPoint);
         break;
     case NOT_MOUNTED:
         mount(mntPoint);
         break;
     case DOESNT_EXIST:
         // do nothing: no-op to make the compiler quiet ;-)
         break;
     }
 }
 
-void KMountMan::autoMount(QString path)
+void KMountMan::autoMount(const QString& path)
 {
     KConfigGroup group(krConfig, "Advanced");
     if (!group.readEntry("AutoMount", _AutoMount))
         return; // auto mount disabled
 
     if (getStatus(path) == NOT_MOUNTED)
         mount(path);
 }
 
-void KMountMan::eject(QString mntPoint)
+void KMountMan::eject(const QString& mntPoint)
 {
     QString udi = findUdiForPath(mntPoint, Solid::DeviceInterface::OpticalDrive);
     if (udi.isNull())
         return;
 
     Solid::Device dev(udi);
-    Solid::OpticalDrive *drive = dev.as<Solid::OpticalDrive>();
-    if (drive == 0)
+    auto *drive = dev.as<Solid::OpticalDrive>();
+    if (drive == nullptr)
         return;
 
     //if working dir is below mountpoint cd to ~ first
     if(QUrl::fromLocalFile(QDir(mntPoint).canonicalPath()).isParentOf(QUrl::fromLocalFile(QDir::current().canonicalPath())))
         QDir::setCurrent(QDir::homePath());
 
 
     connect(drive, &Solid::OpticalDrive::ejectDone, this, &KMountMan::slotTeardownDone);
 
     drive->eject();
 }
 
 // returns true if the path is an ejectable mount point (at the moment CDROM and DVD)
 bool KMountMan::ejectable(QString path)
 {
-    QString udi = findUdiForPath(path, Solid::DeviceInterface::OpticalDisc);
+    QString udi = findUdiForPath(std::move(path), Solid::DeviceInterface::OpticalDisc);
     if (udi.isNull())
         return false;
 
     Solid::Device dev(udi);
-    return dev.as<Solid::OpticalDisc>() != 0;
+    return dev.as<Solid::OpticalDisc>() != nullptr;
 }
 
 bool KMountMan::removable(QString path)
 {
-    QString udi = findUdiForPath(path, Solid::DeviceInterface::StorageAccess);
+    QString udi = findUdiForPath(std::move(path), Solid::DeviceInterface::StorageAccess);
     if (udi.isNull())
         return false;
 
     return removable(Solid::Device(udi));
 }
 
 bool KMountMan::removable(Solid::Device d)
 {
     if(!d.isValid())
         return false;
-    Solid::StorageDrive *drive = d.as<Solid::StorageDrive>();
+    auto *drive = d.as<Solid::StorageDrive>();
     if(drive)
         return drive->isRemovable();
     else
         return(removable(d.parent()));
 }
 
 
 // populate the pop-up menu of the mountman tool-button with actions
 void KMountMan::quickList()
 {
     if (!_operational) {
-        KMessageBox::error(0, i18n("MountMan is not operational. Sorry"));
+        KMessageBox::error(nullptr, i18n("MountMan is not operational. Sorry"));
         return;
     }
 
     // clear mount / unmount actions
     for (QAction *action : _action->menu()->actions()) {
         if (action == _manageAction || action->isSeparator()) {
             continue;
         }
         _action->menu()->removeAction(action);
     }
 
     // create lists of current and possible mount points
     const KMountPoint::List currentMountPoints = KMountPoint::currentMountPoints();
 
     // create a menu, displaying mountpoints with possible actions
     for (QExplicitlySharedDataPointer<KMountPoint> possibleMountPoint : KMountPoint::possibleMountPoints()) {
         // skip nonmountable file systems
         if (nonmountFilesystem(possibleMountPoint->mountType(), possibleMountPoint->mountPoint())
             || invalidFilesystem(possibleMountPoint->mountType())) {
             continue;
         }
         // does the mountpoint exist in current list?
         // if so, it can only be umounted, otherwise, it can be mounted
         bool needUmount = false;
         for (QExplicitlySharedDataPointer<KMountPoint> currentMountPoint : currentMountPoints) {
             if (currentMountPoint->mountPoint() == possibleMountPoint->mountPoint()) {
                 // found -> needs umount
                 needUmount = true;
                 break;
             }
         }
         // add the item to the menu
         const QString text = QString("%1 %2 (%3)").arg(needUmount ? i18n("Unmount") : i18n("Mount"),
                                                  possibleMountPoint->mountPoint(), possibleMountPoint->mountedFrom());
 
         QAction *act = _action->menu()->addAction(text);
         act->setData(QList<QVariant>({
             QVariant(needUmount ? KMountMan::ActionType::Unmount : KMountMan::ActionType::Mount),
             QVariant(possibleMountPoint->mountPoint())
         }));
     }
     connect(_action->menu(), &QMenu::triggered, this, &KMountMan::delayedPerformAction);
 
 }
 
 void KMountMan::delayedPerformAction(const QAction *action)
 {
 
     if (!action || !action->data().canConvert<QList<QVariant>>()) {
         return;
     }
 
-    disconnect(_action->menu(), &QMenu::triggered, 0, 0);
+    disconnect(_action->menu(), &QMenu::triggered, nullptr, nullptr);
 
     const QList<QVariant> actData = action->data().toList();
     const int actionType = actData[0].toInt();
     const QString mountPoint = actData[1].toString();
 
     QTimer::singleShot(0, this, [=] {
 
         if (actionType == KMountMan::ActionType::Mount) {
             mount(mountPoint);
         } else {
             unmount(mountPoint);
         }
     });
 }
 
-QString KMountMan::findUdiForPath(QString path, const Solid::DeviceInterface::Type &expType)
+QString KMountMan::findUdiForPath(const QString& path, const Solid::DeviceInterface::Type &expType)
 {
     KMountPoint::List current = KMountPoint::currentMountPoints();
     KMountPoint::List possible = KMountPoint::possibleMountPoints();
     QExplicitlySharedDataPointer<KMountPoint> mp = findInListByMntPoint(current, path);
     if (!(bool)mp) {
         mp = findInListByMntPoint(possible, path);
         if (!(bool)mp)
             return QString();
     }
     QString dev = QDir(mp->mountedFrom()).canonicalPath();
     QList<Solid::Device> storageDevices = Solid::Device::listFromType(Solid::DeviceInterface::Block);
 
     for (int p = storageDevices.count() - 1 ; p >= 0; p--) {
         Solid::Device device = storageDevices[ p ];
         QString udi     = device.udi();
 
-        Solid::Block * sb = device.as<Solid::Block>();
+        auto * sb = device.as<Solid::Block>();
         if (sb) {
             QString devb = QDir(sb->device()).canonicalPath();
             if (expType != Solid::DeviceInterface::Unknown && !device.isDeviceInterface(expType))
                 continue;
             if (devb == dev)
                 return udi;
         }
     }
 
     return QString();
 }
 
-QString KMountMan::pathForUdi(QString udi)
+QString KMountMan::pathForUdi(const QString& udi)
 {
     Solid::Device device(udi);
-    Solid::StorageAccess *access = device.as<Solid::StorageAccess>();
+    auto *access = device.as<Solid::StorageAccess>();
     if(access)
         return access->filePath();
     else
         return QString();
 }
 
-void KMountMan::slotTeardownDone(Solid::ErrorType error, QVariant errorData, const QString& /*udi*/)
+void KMountMan::slotTeardownDone(Solid::ErrorType error, const QVariant& errorData, const QString& /*udi*/)
 {
     waiting = false;
     if (error != Solid::NoError && errorData.isValid()) {
         KMessageBox::sorry(parentWindow, errorData.toString());
     }
 }
 
-void KMountMan::slotSetupDone(Solid::ErrorType error, QVariant errorData, const QString& /*udi*/)
+void KMountMan::slotSetupDone(Solid::ErrorType error, const QVariant& errorData, const QString& /*udi*/)
 {
     waiting = false;
     if (error != Solid::NoError && errorData.isValid()) {
         KMessageBox::sorry(parentWindow, errorData.toString());
     }
 }
 
diff --git a/krusader/MountMan/kmountman.h b/krusader/MountMan/kmountman.h
index 63744100..72d02c62 100644
--- a/krusader/MountMan/kmountman.h
+++ b/krusader/MountMan/kmountman.h
@@ -1,117 +1,117 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #ifndef KMOUNTMAN_H
 #define KMOUNTMAN_H
 
 // QtCore
 #include <QExplicitlySharedDataPointer>
 #include <QObject>
 #include <QString>
 #include <QPointer>
 #include <QUrl>
 // QtWidgets
 #include <QWidget>
 #include <QAction>
 
 #include <KIO/Job>
 #include <KIO/Global>
 #include <KIOCore/KMountPoint>
 
 #include <Solid/Device>
 #include <Solid/SolidNamespace>
 
 class KMountManGUI;
 class KToolBarPopupAction;
 
 class KMountMan : public QObject
 {
     Q_OBJECT
     friend class KMountManGUI;
 
 public:
     enum mntStatus {DOESNT_EXIST, NOT_MOUNTED, MOUNTED};
 
     inline bool operational() {
         return _operational;
     } // check this 1st
 
-    void mount(QString mntPoint, bool blocking = true); // this is probably what you need for mount
-    void unmount(QString mntPoint, bool blocking = true); // this is probably what you need for unmount
-    mntStatus getStatus(QString mntPoint);    // return the status of a mntPoint (if any)
-    void eject(QString mntPoint);
+    void mount(const QString& mntPoint, bool blocking = true); // this is probably what you need for mount
+    void unmount(const QString& mntPoint, bool blocking = true); // this is probably what you need for unmount
+    mntStatus getStatus(const QString& mntPoint);    // return the status of a mntPoint (if any)
+    void eject(const QString& mntPoint);
     bool ejectable(QString path);
     bool removable(QString path);
     bool removable(Solid::Device d);
-    bool invalidFilesystem(QString type);
-    bool networkFilesystem(QString type);
-    bool nonmountFilesystem(QString type, QString mntPoint);
+    bool invalidFilesystem(const QString& type);
+    bool networkFilesystem(const QString& type);
+    bool nonmountFilesystem(const QString& type, const QString& mntPoint);
     QAction *action() {
         return (QAction *) _action;
     }
 
     explicit KMountMan(QWidget *parent);
     ~KMountMan();
 
     // NOTE: this function needs some time (~50msec)
-    QString findUdiForPath(QString path, const Solid::DeviceInterface::Type &expType = Solid::DeviceInterface::Unknown);
-    QString pathForUdi(QString udi);
+    QString findUdiForPath(const QString& path, const Solid::DeviceInterface::Type &expType = Solid::DeviceInterface::Unknown);
+    QString pathForUdi(const QString& udi);
 
 public slots:
     void mainWindow();                        // opens up the GUI
-    void autoMount(QString path);             // just call it before refreshing into a dir
+    void autoMount(const QString& path);             // just call it before refreshing into a dir
     void delayedPerformAction(const QAction *action);
     void quickList();
 
 protected slots:
     void jobResult(KJob *job);
-    void slotTeardownDone(Solid::ErrorType error, QVariant errorData, const QString &udi);
-    void slotSetupDone(Solid::ErrorType error, QVariant errorData, const QString &udi);
+    void slotTeardownDone(Solid::ErrorType error, const QVariant& errorData, const QString &udi);
+    void slotSetupDone(Solid::ErrorType error, const QVariant& errorData, const QString &udi);
 
 protected:
     // used internally
     static QExplicitlySharedDataPointer<KMountPoint> findInListByMntPoint(KMountPoint::List &lst, QString value);
-    void toggleMount(QString mntPoint);
+    void toggleMount(const QString& mntPoint);
     void emitRefreshPanel(const QUrl &url) {
         emit refreshPanel(url);
     }
 
 signals:
     void refreshPanel(const QUrl &);
 
 private:
     enum ActionType { Mount, Unmount };
 
     KToolBarPopupAction *_action;
     QAction *_manageAction;
 
     bool _operational;   // if false, something went terribly wrong on startup
     bool waiting; // used to block krusader while waiting for (un)mount operation
     KMountManGUI *mountManGui;
     // the following is the FS type
     QStringList invalid_fs;
     QStringList nonmount_fs;
     QStringList network_fs;
     // the following is the FS name
     QStringList nonmount_fs_mntpoint;
     QPointer<QWidget> parentWindow;
 };
 
 #endif
diff --git a/krusader/MountMan/kmountmangui.cpp b/krusader/MountMan/kmountmangui.cpp
index 3cb0ec82..5c40118b 100644
--- a/krusader/MountMan/kmountmangui.cpp
+++ b/krusader/MountMan/kmountmangui.cpp
@@ -1,526 +1,526 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 #include "kmountmangui.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../Dialogs/krspecialwidgets.h"
 #include "../defaults.h"
 #include "../FileSystem/filesystem.h"
 
 // QtCore
 #include <QCryptographicHash>
 #include <QList>
 #include <QFileInfo>
 // QtGui
 #include <QPixmap>
 #include <QBitmap>
 #include <QCursor>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QHeaderView>
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QMenu>
 #include <QPushButton>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 #include <KWidgetsAddons/KGuiItem>
 #include <KIOCore/KDiskFreeSpaceInfo>
 #include <KIOCore/KMountPoint>
 #include <KCodecs/KCodecs>
 
 #include <Solid/StorageVolume>
 
 #ifndef BSD
 #define MTAB "/etc/mtab"
 #endif
 
 KMountManGUI::KMountManGUI(KMountMan *mntMan) : QDialog(mntMan->parentWindow),
     mountMan(mntMan),
-    info(0),
-    mountList(0),
-    cbShowOnlyRemovable(0),
-    watcher(0),
+    info(nullptr),
+    mountList(nullptr),
+    cbShowOnlyRemovable(nullptr),
+    watcher(nullptr),
     sizeX(-1),
     sizeY(-1)
 {
     setWindowTitle(i18n("MountMan - Your Mount-Manager"));
     setWindowModality(Qt::WindowModal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     watcher = new QTimer(this);
     connect(watcher, &QTimer::timeout, this, &KMountManGUI::checkMountChange);
 
     mainLayout->addLayout(createMainPage());
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     ejectButton = new QPushButton(i18n("&Eject"));
     ejectButton->setIcon(Icon(QStringLiteral("media-eject")));
     ejectButton->setEnabled(false);
     buttonBox->addButton(ejectButton, QDialogButtonBox::ActionRole);
 
     mountButton = new QPushButton(i18n("&Unmount"));
     mountButton->setEnabled(false);
     buttonBox->addButton(mountButton, QDialogButtonBox::ActionRole);
 
     // connections
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KMountManGUI::reject);
     connect(ejectButton, &QPushButton::clicked, this, &KMountManGUI::slotEject);
     connect(mountButton, &QPushButton::clicked, this, &KMountManGUI::slotToggleMount);
     connect(mountList, &KrTreeWidget::itemDoubleClicked, this, &KMountManGUI::doubleClicked);
     connect(mountList, &KrTreeWidget::itemRightClicked, this, &KMountManGUI::clicked);
     connect(mountList, &KrTreeWidget::itemClicked, this, QOverload<QTreeWidgetItem *>::of(&KMountManGUI::changeActive));
     connect(mountList, &KrTreeWidget::itemSelectionChanged, this, QOverload<>::of(&KMountManGUI::changeActive));
 
     KConfigGroup group(krConfig, "MountMan");
     int sx = group.readEntry("Window Width", -1);
     int sy = group.readEntry("Window Height", -1);
 
     if (sx != -1 && sy != -1)
         resize(sx, sy);
     else
         resize(600, 300);
 
     if (group.readEntry("Window Maximized",  false))
         showMaximized();
     else
         show();
 
     getSpaceData();
 
     exec();
 }
 
 KMountManGUI::~KMountManGUI()
 {
     watcher->stop();
     delete watcher;
 
     KConfigGroup group(krConfig, "MountMan");
 
     group.writeEntry("Window Width", sizeX);
     group.writeEntry("Window Height", sizeY);
     group.writeEntry("Window Maximized", isMaximized());
     group.writeEntry("Last State", mountList->header()->saveState());
     group.writeEntry("ShowOnlyRemovable", cbShowOnlyRemovable->isChecked());
 }
 
 
 void KMountManGUI::resizeEvent(QResizeEvent *e)
 {
     if (!isMaximized()) {
         sizeX = e->size().width();
         sizeY = e->size().height();
     }
 
     QDialog::resizeEvent(e);
 }
 
 QLayout *KMountManGUI::createMainPage()
 {
-    QGridLayout *layout = new QGridLayout();
+    auto *layout = new QGridLayout();
     layout->setSpacing(10);
     mountList = new KrTreeWidget(this);    // create the main container
     KConfigGroup grp(krConfig, "Look&Feel");
     mountList->setFont(grp.readEntry("Filelist Font", _FilelistFont));
     mountList->setSelectionMode(QAbstractItemView::SingleSelection);
     mountList->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     mountList->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
 
     QStringList labels;
     labels << i18n("Name");
     labels << i18n("Type");
     labels << i18n("Mnt.Point");
     labels << i18n("Total Size");
     labels << i18n("Free Size");
     labels << i18n("Free %");
     mountList->setHeaderLabels(labels);
 
     mountList->header()->setSectionResizeMode(QHeaderView::Interactive);
 
     grp = KConfigGroup(krConfig, "MountMan");
     if (grp.hasKey("Last State"))
         mountList->header()->restoreState(grp.readEntry("Last State", QByteArray()));
     else {
         int i = QFontMetrics(mountList->font()).width("W");
         int j = QFontMetrics(mountList->font()).width("0");
         j = (i > j ? i : j);
 
         mountList->setColumnWidth(0, j*8);
         mountList->setColumnWidth(1, j*4);
         mountList->setColumnWidth(2, j*8);
         mountList->setColumnWidth(3, j*6);
         mountList->setColumnWidth(4, j*6);
         mountList->setColumnWidth(5, j*5);
     }
 
     mountList->setAllColumnsShowFocus(true);
     mountList->header()->setSortIndicatorShown(true);
 
     mountList->sortItems(0, Qt::AscendingOrder);
 
     // now the list is created, time to fill it with data.
     //=>mountMan->forceUpdate();
 
     QGroupBox *box = new QGroupBox(i18n("MountMan.Info"), this);
     box->setAlignment(Qt::AlignHCenter);
-    QVBoxLayout *vboxl = new QVBoxLayout(box);
+    auto *vboxl = new QVBoxLayout(box);
     info = new KRFSDisplay(box);
     vboxl->addWidget(info);
     info->resize(info->width(), height());
 
     cbShowOnlyRemovable = new QCheckBox(i18n("Show only removable devices"), this);
     cbShowOnlyRemovable->setChecked(grp.readEntry("ShowOnlyRemovable", false));
     connect(cbShowOnlyRemovable , &QCheckBox::stateChanged, this, &KMountManGUI::updateList);
 
     layout->addWidget(box, 0, 0);
     layout->addWidget(cbShowOnlyRemovable, 1, 0);
     layout->addWidget(mountList, 0, 1, 2, 1);
 
     return layout;
 }
 
 void KMountManGUI::getSpaceData()
 {
     fileSystems.clear();
     KrMountDetector::getInstance()->hasMountsChanged();
 
     mounted = KMountPoint::currentMountPoints();
     possible = KMountPoint::possibleMountPoints();
     if (mounted.size() == 0) {   // nothing is mounted
         addNonMounted();
         updateList(); // let's continue
         return;
     }
 
-    for (KMountPoint::List::iterator it = mounted.begin(); it != mounted.end(); ++it) {
+    for (auto & it : mounted) {
         // don't bother with invalid file systems
-        if (mountMan->invalidFilesystem((*it)->mountType())) {
+        if (mountMan->invalidFilesystem(it->mountType())) {
             continue;
         }
-        KDiskFreeSpaceInfo info = KDiskFreeSpaceInfo::freeSpaceInfo((*it) ->mountPoint());
+        KDiskFreeSpaceInfo info = KDiskFreeSpaceInfo::freeSpaceInfo(it ->mountPoint());
         if(!info.isValid()) {
             continue;
         }
         fsData data;
-        data.setMntPoint((*it) ->mountPoint());
+        data.setMntPoint(it ->mountPoint());
         data.setMounted(true);
         data.setTotalBlks(info.size() / 1024);
         data.setFreeBlks(info.available() / 1024);
-        data.setName((*it)->mountedFrom());
-        data.setType((*it)->mountType());
+        data.setName(it->mountedFrom());
+        data.setType(it->mountType());
         fileSystems.append(data);
     }
     addNonMounted();
     updateList();
 }
 
 void KMountManGUI::addNonMounted()
 {
     // handle the non-mounted ones
-    for (KMountPoint::List::iterator it = possible.begin(); it != possible.end(); ++it) {
+    for (auto & it : possible) {
         // make sure we don't add things we've already added
-        if (KMountMan::findInListByMntPoint(mounted, (*it)->mountPoint())) {
+        if (KMountMan::findInListByMntPoint(mounted, it->mountPoint())) {
             continue;
         } else {
             fsData data;
-            data.setMntPoint((*it)->mountPoint());
+            data.setMntPoint(it->mountPoint());
             data.setMounted(false);
-            data.setType((*it)->mountType());
-            data.setName((*it)->mountedFrom());
+            data.setType(it->mountType());
+            data.setName(it->mountedFrom());
 
             if (mountMan->invalidFilesystem(data.type()))
                 continue;
 
             fileSystems.append(data);
         }
     }
 }
 
 void KMountManGUI::addItemToMountList(KrTreeWidget *lst, fsData &fs)
 {
     Solid::Device device(mountMan->findUdiForPath(fs.mntPoint(), Solid::DeviceInterface::StorageAccess));
 
     if (cbShowOnlyRemovable->isChecked() && !mountMan->removable(device))
         return;
 
     bool mtd = fs.mounted();
 
     QString tSize = QString("%1").arg(KIO::convertSizeFromKiB(fs.totalBlks()));
     QString fSize = QString("%1").arg(KIO::convertSizeFromKiB(fs.freeBlks()));
     QString sPrct = QString("%1%").arg(100 - (fs.usedPerct()));
-    QTreeWidgetItem *item = new QTreeWidgetItem(lst);
+    auto *item = new QTreeWidgetItem(lst);
     item->setText(0, fs.name());
     item->setText(1, fs.type());
     item->setText(2, fs.mntPoint());
     item->setText(3, (mtd ? tSize : QString("N/A")));
     item->setText(4, (mtd ? fSize : QString("N/A")));
     item->setText(5, (mtd ? sPrct : QString("N/A")));
 
-    Solid::StorageVolume *vol = device.as<Solid::StorageVolume> ();
+    auto *vol = device.as<Solid::StorageVolume> ();
     QString iconName;
 
     if(device.isValid())
         iconName = device.icon();
     else if(mountMan->networkFilesystem(fs.type()))
         iconName = "folder-remote";
     QStringList overlays;
     if (mtd) {
         overlays << "emblem-mounted";
     } else {
         overlays << QString(); // We have to guarantee the placement of the next emblem
     }
     if (vol && vol->usage() == Solid::StorageVolume::Encrypted) {
         overlays << "security-high";
     }
     item->setIcon(0, Icon(iconName, overlays));
 }
 
 void KMountManGUI::updateList()
 {
     QString currentMP;
     int currentIdx = 0;
     QTreeWidgetItem *currentItem = mountList->currentItem();
     if(currentItem) {
         currentMP = getMntPoint(currentItem);
         currentIdx = mountList->indexOfTopLevelItem(currentItem);
     }
 
     mountList->clearSelection();
     mountList->clear();
 
-    for (QList<fsData>::iterator it = fileSystems.begin(); it != fileSystems.end() ; ++it)
-        addItemToMountList(mountList, *it);
+    for (auto & fileSystem : fileSystems)
+        addItemToMountList(mountList, fileSystem);
 
     currentItem = mountList->topLevelItem(currentIdx);
     for(int i = 0; i < mountList->topLevelItemCount(); i++) {
         QTreeWidgetItem *item = mountList->topLevelItem(i);
         if(getMntPoint(item) == currentMP)
                 currentItem = item;
     }
     if(!currentItem)
         currentItem = mountList->topLevelItem(0);
     mountList->setCurrentItem(currentItem);
     changeActive(currentItem);
 
     mountList->setFocus();
 
     watcher->setSingleShot(true);
     watcher->start(WATCHER_DELAY);     // starting the watch timer ( single shot )
 }
 
 void KMountManGUI::checkMountChange()
 {
     if (KrMountDetector::getInstance()->hasMountsChanged())
         getSpaceData();
     watcher->setSingleShot(true);
     watcher->start(WATCHER_DELAY);     // starting the watch timer ( single shot )
 }
 
 void KMountManGUI::doubleClicked(QTreeWidgetItem *i)
 {
     if (!i)
         return; // we don't want to refresh to swap, do we ?
 
     // change the active panel to this mountpoint
     mountMan->emitRefreshPanel(QUrl::fromLocalFile(getMntPoint(i)));
     close();
 }
 
 void KMountManGUI::changeActive()
 {
     QList<QTreeWidgetItem *> seld = mountList->selectedItems();
     if (seld.count() > 0)
         changeActive(seld[ 0 ]);
 }
 
 // when user clicks on a filesystem, change information
 void KMountManGUI::changeActive(QTreeWidgetItem *i)
 {
     if (!i) {
         if (info) {
             info->setEmpty(true);
             info->update();
         }
         mountButton->setEnabled(false);
         ejectButton->setEnabled(false);
         return;
     }
 
     fsData *system = getFsData(i);
 
     info->setAlias(system->mntPoint());
     info->setRealName(system->name());
     info->setMounted(system->mounted());
     info->setEmpty(false);
     info->setTotalSpace(system->totalBlks());
     info->setFreeSpace(system->freeBlks());
     info->repaint();
 
     if(system->mounted())
         mountButton->setText(i18n("&Unmount"));
     else
         mountButton->setText(i18n("&Mount"));
 
     ejectButton->setEnabled(mountMan->ejectable(system->mntPoint()));
     mountButton->setEnabled(true);
 }
 
 // called when right-clicked on a filesystem
 void KMountManGUI::clicked(QTreeWidgetItem *item, const QPoint & pos)
 {
     // these are the values that will exist in the menu
 #define MOUNT_ID       90
 #define UNMOUNT_ID     91
 #define FORMAT_ID      93
 #define EJECT_ID       94
     //////////////////////////////////////////////////////////
     if (!item) return;
 
     fsData *system = getFsData(item);
     // create the menu
     QMenu popup;
     popup.setTitle(i18n("MountMan"));
     if (!system->mounted()) {
         QAction *mountAct = popup.addAction(i18n("Mount"));
         mountAct->setData(QVariant(MOUNT_ID));
         bool enable = !(mountMan->nonmountFilesystem(system->type(), system->mntPoint()));
         mountAct->setEnabled(enable);
     } else {
         QAction * umountAct =  popup.addAction(i18n("Unmount"));
         umountAct->setData(QVariant(UNMOUNT_ID));
         bool enable = !(mountMan->nonmountFilesystem(system->type(), system->mntPoint()));
         umountAct->setEnabled(enable);
     }
     if (mountMan->ejectable(system->mntPoint()))
         //  if (system->type()=="iso9660" || mountMan->followLink(system->name()).left(2)=="cd")
         popup.addAction(i18n("Eject"))->setData(QVariant(EJECT_ID));
     else {
         QAction *formatAct = popup.addAction(i18n("Format"));
         formatAct->setData(QVariant(FORMAT_ID));
         formatAct->setEnabled(false);
     }
 
     QString mountPoint = system->mntPoint();
 
     QAction * res = popup.exec(pos);
     int result = -1;
 
     if (res && res->data().canConvert<int>())
         result = res->data().toInt();
 
     // check out the user's option
     switch (result) {
     case - 1 : return ;     // the user clicked outside of the menu
     case MOUNT_ID :
     case UNMOUNT_ID :
         mountMan->toggleMount(mountPoint);
         break;
     case FORMAT_ID :
         break;
     case EJECT_ID :
         mountMan->eject(mountPoint);
         break;
     }
 }
 
 void KMountManGUI::slotToggleMount()
 {
     QTreeWidgetItem *item = mountList->currentItem();
     if(item) {
         mountMan->toggleMount(getFsData(item)->mntPoint());
     }
 }
 
 void KMountManGUI::slotEject()
 {
     QTreeWidgetItem *item = mountList->currentItem();
     if(item) {
         mountMan->eject(getFsData(item)->mntPoint());
     }
 }
 
 fsData* KMountManGUI::getFsData(QTreeWidgetItem *item)
 {
-    for (QList<fsData>::Iterator it = fileSystems.begin(); it != fileSystems.end(); ++it) {
+    for (auto & fileSystem : fileSystems) {
         // the only thing which is unique is the mount point
-        if ((*it).mntPoint() == getMntPoint(item)) {
-            return & (*it);
+        if (fileSystem.mntPoint() == getMntPoint(item)) {
+            return & fileSystem;
         }
     }
     //this point shouldn't be reached
     abort();
-    return 0;
+    return nullptr;
 }
 
 QString KMountManGUI::getMntPoint(QTreeWidgetItem *item)
 {
     return item->text(2); // text(2) ? ugly ugly ugly
 }
 
 
 KrMountDetector::KrMountDetector()
 {
     hasMountsChanged();
 }
 
 bool KrMountDetector::hasMountsChanged()
 {
     bool result = false;
 #ifndef BSD
     QFileInfo mtabInfo(MTAB);
     if (!mtabInfo.exists() || mtabInfo.isSymLink()) { // if mtab is a symlimk to /proc/mounts the mtime is unusable
 #endif
         KMountPoint::List mountPoints = KMountPoint::currentMountPoints(KMountPoint::NeedRealDeviceName);
         QCryptographicHash md5(QCryptographicHash::Md5);
-        for (KMountPoint::List::iterator i = mountPoints.begin(); i != mountPoints.end(); ++i) {
-            md5.addData((*i)->mountedFrom().toUtf8());
-            md5.addData((*i)->realDeviceName().toUtf8());
-            md5.addData((*i)->mountPoint().toUtf8());
-            md5.addData((*i)->mountType().toUtf8());
+        for (auto & mountPoint : mountPoints) {
+            md5.addData(mountPoint->mountedFrom().toUtf8());
+            md5.addData(mountPoint->realDeviceName().toUtf8());
+            md5.addData(mountPoint->mountPoint().toUtf8());
+            md5.addData(mountPoint->mountType().toUtf8());
         }
         QString s = md5.result();
         result = s != checksum;
         checksum = s;
 #ifndef BSD
     } else {
         result = mtabInfo.lastModified() != lastMtab;
         lastMtab = mtabInfo.lastModified();
     }
 #endif
     return result;
 }
 
 KrMountDetector krMountDetector;
 KrMountDetector * KrMountDetector::getInstance()
 {
     return & krMountDetector;
 }
 
diff --git a/krusader/MountMan/kmountmangui.h b/krusader/MountMan/kmountmangui.h
index f26f98f3..e48e26b8 100644
--- a/krusader/MountMan/kmountmangui.h
+++ b/krusader/MountMan/kmountmangui.h
@@ -1,193 +1,194 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 #ifndef KMOUNTMANGUI_H
 #define KMOUNTMANGUI_H
 
 // QtCore
 #include <QTimer>
 #include <QList>
 #include <QDateTime>
 // QtWidgets
 #include <QDialog>
 #include <QFrame>
 
 #include <KIOCore/KMountPoint>
+#include <utility>
 
 #include "../GUI/krtreewidget.h"
 #include "kmountman.h"
 
 #define  WATCHER_DELAY    500
 
 class QCheckBox;
 class KRFSDisplay;
 
 // forward definitions
 class fsData;
 
 class KMountManGUI : public QDialog
 {
     Q_OBJECT
 
     enum Pages {
         Filesystems = 0
     };
 
 public:
     explicit KMountManGUI(KMountMan *mntMan);
-    ~KMountManGUI();
+    ~KMountManGUI() override;
 
 protected:
-    virtual void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
+    void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
 
 protected slots:
     void doubleClicked(QTreeWidgetItem *);
     void clicked(QTreeWidgetItem *, const QPoint &);
     void slotToggleMount();
     void slotEject();
     void changeActive();
     void changeActive(QTreeWidgetItem *);
     void checkMountChange(); // check whether the mount table was changed
 
     void updateList();     // fill-up the filesystems list
     void getSpaceData();
 
 protected:
     QLayout *createMainPage(); // creator of the main page - filesystems
     void addItemToMountList(KrTreeWidget *lst, fsData &fs);
     fsData* getFsData(QTreeWidgetItem *item);
     QString getMntPoint(QTreeWidgetItem *item);
     void addNonMounted();
 
 private:
     KMountMan *mountMan;
     KRFSDisplay *info;
     KrTreeWidget *mountList;
     QCheckBox *cbShowOnlyRemovable;
     QPushButton *mountButton;
     QPushButton *ejectButton;
     QTimer *watcher;
     QDateTime lastMtab;
     // used for the getSpace - gotSpace functions
     KMountPoint::List possible, mounted;
     QList<fsData> fileSystems;
 
     int sizeX;
     int sizeY;
 };
 
 // Data container for a single-filesystem data
 // maximum size supported is 2GB of 1kb blocks == 2048GB, enough.
 // not really needed, but kept for backward compatibility
 class fsData
 {
 public:
     fsData() : Name(), Type(), MntPoint(), TotalBlks(0),
             FreeBlks(0), Mounted(false) {}
 
     // get information
     inline QString name() {
         return Name;
     }
     inline QString shortName() {
         return Name.right(Name.length() - Name.indexOf("/", 1) - 1);
     }
     inline QString type() {
         return Type;
     }
     inline QString mntPoint() {
         return MntPoint;
     }
     inline long totalBlks() {
         return TotalBlks;
     }
     inline long freeBlks() {
         return FreeBlks;
     }
     inline KIO::filesize_t totalBytes() {
         return TotalBlks * 1024;
     }
     inline KIO::filesize_t freeBytes() {
         return FreeBlks * 1024;
     }
     //////////////////// insert a good round function here /////////////////
     int usedPerct() {
         if (TotalBlks == 0)
             return 0;
         float res = ((float)(TotalBlks - FreeBlks)) / ((float) TotalBlks) * 100;
         if ((res - (int) res) > 0.5)
             return (int) res + 1;
         else
             return (int) res;
     }
     inline bool mounted() {
         return Mounted;
     }
 
     // set information
     inline void setName(QString n_) {
-        Name = n_;
+        Name = std::move(n_);
     }
     inline void setType(QString t_) {
-        Type = t_;
+        Type = std::move(t_);
     }
     inline void setMntPoint(QString m_) {
-        MntPoint = m_;
+        MntPoint = std::move(m_);
     }
     inline void setTotalBlks(long t_) {
         TotalBlks = t_;
     }
     inline void setFreeBlks(long f_) {
         FreeBlks = f_;
     }
     inline void setMounted(bool m_) {
         Mounted = m_;
     }
 
 private:
     QString Name;       // i.e: /dev/cdrom
     QString Type;       // i.e: iso9600
     QString MntPoint;   // i.e: /mnt/cdrom
     long TotalBlks;  // measured in 1024bytes per block
     long FreeBlks;
     bool Mounted;    // true if filesystem is mounted
 
     // additional attributes of a filesystem, parsed from fstab
 public:
     QString options;    // additional fstab options
 };
 
 class KrMountDetector
 {
     QString checksum;
 #ifndef BSD
     QDateTime lastMtab;
 #endif
 public:
     KrMountDetector();
     static KrMountDetector * getInstance();
     bool hasMountsChanged();
 };
 
 
 
 #endif
diff --git a/krusader/Panel/PanelView/krinterbriefview.cpp b/krusader/Panel/PanelView/krinterbriefview.cpp
index e2c63f4a..77391d4b 100644
--- a/krusader/Panel/PanelView/krinterbriefview.cpp
+++ b/krusader/Panel/PanelView/krinterbriefview.cpp
@@ -1,704 +1,704 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krinterbriefview.h"
 
 // QtCore
 #include <QDir>
 #include <QHashIterator>
 #include <QItemSelection>
 #include <QItemSelectionRange>
 // QtGui
 #include <QFontMetrics>
 #include <QPainter>
 #include <QRegion>
 // QtWidgets
 #include <QDirModel>
 #include <QApplication>
 #include <QMenu>
 #include <QScrollBar>
 
 #include <KConfigCore/KConfig>
 #include <KI18n/KLocalizedString>
 #include <KIOWidgets/KDirLister>
 
 #include "krmousehandler.h"
 #include "krviewfactory.h"
 #include "krviewitemdelegate.h"
 #include "krviewitem.h"
 #include "listmodel.h"
 #include "../krcolorcache.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../defaults.h"
 #include "../GUI/krstyleproxy.h"
 
 #define MAX_BRIEF_COLS 5
 
 KrInterBriefView::KrInterBriefView(QWidget *parent, KrViewInstance &instance, KConfig *cfg) :
         QAbstractItemView(parent),
         KrInterView(instance, cfg, this),
-        _header(0)
+        _header(nullptr)
 {
     setWidget(this);
     setModel(_model);
 
     setSelectionMode(QAbstractItemView::NoSelection);
     setSelectionModel(new DummySelectionModel(_model, this));
 
     KConfigGroup grpSvr(_config, "Look&Feel");
     _viewFont = grpSvr.readEntry("Filelist Font", _FilelistFont);
 
-    KrStyleProxy *style = new KrStyleProxy();
+    auto *style = new KrStyleProxy();
     style->setParent(this);
     setStyle(style);
     viewport()->setStyle(style); // for custom tooltip delay
     setItemDelegate(new KrViewItemDelegate());
     setMouseTracking(true);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
 
     connect(_mouseHandler, &KrMouseHandler::renameCurrentItem, this, &KrInterBriefView::renameCurrentItem);
 
     _model->setExtensionEnabled(false);
     _model->setAlternatingTable(true);
     connect(_model, &ListModel::layoutChanged, this, &KrInterBriefView::updateGeometries);
 }
 
 KrInterBriefView::~KrInterBriefView()
 {
     delete _properties;
-    _properties = 0;
+    _properties = nullptr;
 
     delete _operator;
-    _operator = 0;
+    _operator = nullptr;
 }
 
 void KrInterBriefView::doRestoreSettings(KConfigGroup group)
 {
     _properties->numberOfColumns = group.readEntry("Number Of Brief Columns", _NumberOfBriefColumns);
     if (_properties->numberOfColumns < 1)
         _properties->numberOfColumns = 1;
     else if (_properties->numberOfColumns > MAX_BRIEF_COLS)
         _properties->numberOfColumns = MAX_BRIEF_COLS;
 
     _numOfColumns = _properties->numberOfColumns;
 
     KrInterView::doRestoreSettings(group);
 
     updateGeometries();
 }
 
 void KrInterBriefView::saveSettings(KConfigGroup grp, KrViewProperties::PropertyType properties)
 {
     KrInterView::saveSettings(grp, properties);
     if(properties & KrViewProperties::PropColumns)
         grp.writeEntry("Number Of Brief Columns", _numOfColumns);
 }
 
 int KrInterBriefView::itemsPerPage()
 {
     int height = getItemHeight();
     if (height == 0)
         height ++;
     int numRows = viewport()->height() / height;
     return numRows;
 }
 void KrInterBriefView::updateView()
 {
 }
 
 void KrInterBriefView::setup()
 {
     _header = new QHeaderView(Qt::Horizontal, this);
     _header->setDefaultAlignment(Qt::AlignLeft | Qt::AlignVCenter);
     _header->setParent(this);
     _header->setModel(_model);
     _header->hideSection(KrViewProperties::Type);
     _header->hideSection(KrViewProperties::Permissions);
     _header->hideSection(KrViewProperties::KrPermissions);
     _header->hideSection(KrViewProperties::Owner);
     _header->hideSection(KrViewProperties::Group);
     _header->hideSection(KrViewProperties::Changed);
     _header->hideSection(KrViewProperties::Accessed);
     _header->setStretchLastSection(true);
     _header->setSectionResizeMode(QHeaderView::Fixed);
     _header->setSectionsClickable(true);
     _header->setSortIndicatorShown(true);
     connect(_header, &QHeaderView::sortIndicatorChanged, _model, QOverload<int, Qt::SortOrder>::of(&ListModel::sort));
     _header->installEventFilter(this);
 
     _numOfColumns = _properties->numberOfColumns;
 
     setSortMode(_properties->sortColumn, (_properties->sortOptions & KrViewProperties::Descending));
 }
 
 void KrInterBriefView::keyPressEvent(QKeyEvent *e)
 {
     if (!e || !_model->ready())
         return ; // subclass bug
 
     if (handleKeyEvent(e))
         return;
 
     QAbstractItemView::keyPressEvent(e);
 }
 
 bool KrInterBriefView::handleKeyEvent(QKeyEvent *e)
 {
     if ((e->key() != Qt::Key_Left && e->key() != Qt::Key_Right) && (KrView::handleKeyEvent(e)))
         // did the view class handled the event?
         return true;
 
     switch (e->key()) {
     case Qt::Key_Right : {
         if (e->modifiers() == Qt::ControlModifier) {
             // let the panel handle it
             e->ignore();
             break;
         }
         KrViewItem *i = getCurrentKrViewItem();
         KrViewItem *newCurrent = i;
 
         if (!i)
             break;
 
         int num = itemsPerPage() + 1;
 
         if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
 
         while (i && num > 0) {
             if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
             newCurrent = i;
             i = getNext(i);
             num--;
         }
 
         if (newCurrent) {
             setCurrentKrViewItem(newCurrent);
             makeCurrentVisible();
         }
         if (e->modifiers() & Qt::ShiftModifier)
             op()->emitSelectionChanged();
         return true;
     }
     case Qt::Key_Left : {
         if (e->modifiers() == Qt::ControlModifier) {
             // let the panel handle it
             e->ignore();
             break;
         }
         KrViewItem *i = getCurrentKrViewItem();
         KrViewItem *newCurrent = i;
 
         if (!i)
             break;
 
         int num = itemsPerPage() + 1;
 
         if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
 
         while (i && num > 0) {
             if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
             newCurrent = i;
             i = getPrev(i);
             num--;
         }
 
         if (newCurrent) {
             setCurrentKrViewItem(newCurrent);
             makeCurrentVisible();
         }
         if (e->modifiers() & Qt::ShiftModifier)
             op()->emitSelectionChanged();
         return true;
     }
     }
 
     return false;
 }
 
 void KrInterBriefView::wheelEvent(QWheelEvent *ev)
 {
     if (!_mouseHandler->wheelEvent(ev))
         QApplication::sendEvent(horizontalScrollBar(), ev);
 }
 
 bool KrInterBriefView::eventFilter(QObject *object, QEvent *event)
 {
     if (object == _header) {
         if (event->type() == QEvent::ContextMenu) {
-            QContextMenuEvent *me = (QContextMenuEvent *)event;
+            auto *me = (QContextMenuEvent *)event;
             showContextMenu(me->globalPos());
             return true;
         }
     }
     return false;
 }
 
 void KrInterBriefView::showContextMenu(const QPoint & p)
 {
     QMenu popup(this);
     popup.setTitle(i18n("Columns"));
 
     int COL_ID = 14700;
 
     for (int i = 1; i <= MAX_BRIEF_COLS; i++) {
         QAction *act = popup.addAction(QString("%1").arg(i));
         act->setData(QVariant(COL_ID + i));
         act->setCheckable(true);
         act->setChecked(properties()->numberOfColumns == i);
     }
 
     QAction * res = popup.exec(p);
     int result = -1;
     if (res && res->data().canConvert<int>())
         result = res->data().toInt();
 
     if (result > COL_ID && result <= COL_ID + MAX_BRIEF_COLS) {
         _properties->numberOfColumns = result - COL_ID;
         _numOfColumns = _properties->numberOfColumns;
         updateGeometries();
         op()->settingsChanged(KrViewProperties::PropColumns);
     }
 }
 
 QRect KrInterBriefView::visualRect(const QModelIndex&ndx) const
 {
     int width = (viewport()->width()) / _numOfColumns;
     if ((viewport()->width()) % _numOfColumns)
         width++;
     int height = getItemHeight();
     int numRows = viewport()->height() / height;
     if (numRows == 0)
         numRows++;
     int x = width * (ndx.row() / numRows);
     int y = height * (ndx.row() % numRows);
     return mapToViewport(QRect(x, y, width, height));
 }
 
 void KrInterBriefView::scrollTo(const QModelIndex &ndx, QAbstractItemView::ScrollHint hint)
 {
     const QRect rect = visualRect(ndx);
     if (hint == EnsureVisible && viewport()->rect().contains(rect)) {
         setDirtyRegion(rect);
         return;
     }
 
     const QRect area = viewport()->rect();
 
     const bool leftOf = rect.left() < area.left();
     const bool rightOf = rect.right() > area.right();
 
     int horizontalValue = horizontalScrollBar()->value();
 
     if (leftOf)
         horizontalValue -= area.left() - rect.left();
     else if (rightOf)
         horizontalValue += rect.right() - area.right();
 
     horizontalScrollBar()->setValue(horizontalValue);
 }
 
 QModelIndex KrInterBriefView::indexAt(const QPoint& p) const
 {
     int x = p.x() + horizontalOffset();
     int y = p.y() + verticalOffset();
 
     int itemWidth = (viewport()->width()) / _numOfColumns;
     if ((viewport()->width()) % _numOfColumns)
         itemWidth++;
     int itemHeight = getItemHeight();
 
     int numRows = viewport()->height() / itemHeight;
     if (numRows == 0)
         numRows++;
 
     int row = y / itemHeight;
     int col = x / itemWidth;
 
     int numColsTotal = _model->rowCount() / numRows;
     if(_model->rowCount() % numRows)
         numColsTotal++;
 
     if(row < numRows && col < numColsTotal)
         return _model->index((col * numRows) + row, 0);
 
     return QModelIndex();
 }
 
 QModelIndex KrInterBriefView::moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers)
 {
     if (_model->rowCount() == 0)
         return QModelIndex();
 
     QModelIndex current = currentIndex();
     if (!current.isValid())
         return _model->index(0, 0);
 
     switch (cursorAction) {
     case MoveLeft:
     case MovePageDown: {
         int newRow = current.row() - itemsPerPage();
         if (newRow < 0)
             newRow = 0;
         return _model->index(newRow, 0);
     }
     case MoveRight:
     case MovePageUp: {
         int newRow = current.row() + itemsPerPage();
         if (newRow >= _model->rowCount())
             newRow = _model->rowCount() - 1;
         return _model->index(newRow, 0);
     }
     case MovePrevious:
     case MoveUp: {
         int newRow = current.row() - 1;
         if (newRow < 0)
             newRow = 0;
         return _model->index(newRow, 0);
     }
     case MoveNext:
     case MoveDown: {
         int newRow = current.row() + 1;
         if (newRow >= _model->rowCount())
             newRow = _model->rowCount() - 1;
         return _model->index(newRow, 0);
     }
     case MoveHome:
         return _model->index(0, 0);
     case MoveEnd:
         return _model->index(_model->rowCount() - 1, 0);
     }
 
     return current;
 }
 
 int KrInterBriefView::horizontalOffset() const
 {
     return horizontalScrollBar()->value();
 }
 
 int KrInterBriefView::verticalOffset() const
 {
     return 0;
 }
 
 bool KrInterBriefView::isIndexHidden(const QModelIndex&ndx) const
 {
     return ndx.column() != 0;
 }
 #if 0
 QRegion KrInterBriefView::visualRegionForSelection(const QItemSelection &selection) const
 {
     if (selection.isEmpty())
         return QRegion();
 
     QRegion selectionRegion;
     for (int i = 0; i < selection.count(); ++i) {
         QItemSelectionRange range = selection.at(i);
         if (!range.isValid())
             continue;
         QModelIndex leftIndex = range.topLeft();
         if (!leftIndex.isValid())
             continue;
         const QRect leftRect = visualRect(leftIndex);
         int top = leftRect.top();
         QModelIndex rightIndex = range.bottomRight();
         if (!rightIndex.isValid())
             continue;
         const QRect rightRect = visualRect(rightIndex);
         int bottom = rightRect.bottom();
         if (top > bottom)
             qSwap<int>(top, bottom);
         int height = bottom - top + 1;
         QRect combined = leftRect | rightRect;
         combined.setX(range.left());
         selectionRegion += combined;
     }
     return selectionRegion;
 }
 #endif
 void KrInterBriefView::paintEvent(QPaintEvent *e)
 {
     QStyleOptionViewItem option = viewOptions();
     option.widget = this;
     option.decorationSize = QSize(_fileIconSize, _fileIconSize);
     option.decorationPosition = QStyleOptionViewItem::Left;
     QPainter painter(viewport());
 
     QModelIndex curr = currentIndex();
 
     QVector<QModelIndex> intersectVector;
     QRect area = e->rect();
     area.adjust(horizontalOffset(), verticalOffset(), horizontalOffset(), verticalOffset());
     intersectionSet(area, intersectVector);
 
     foreach(const QModelIndex &mndx, intersectVector) {
         option.state = QStyle::State_None;
         option.rect = visualRect(mndx);
         painter.save();
 
         itemDelegate()->paint(&painter, option, mndx);
 
         // (always) draw dashed line border around current item row
         const bool isCurrent = curr.isValid() && curr.row() == mndx.row();
         if (isCurrent && drawCurrent()) {
             QStyleOptionFocusRect o;
             o.QStyleOption::operator=(option);
             QPalette::ColorGroup cg = QPalette::Normal;
             o.backgroundColor = option.palette.color(cg, QPalette::Background);
 
             style()->drawPrimitive(QStyle::PE_FrameFocusRect, &o, &painter);
         }
 
         painter.restore();
     }
 }
 
 int KrInterBriefView::getItemHeight() const
 {
     int textHeight = QFontMetrics(_viewFont).height();
     int height = textHeight;
     int iconSize = 0;
     if (properties()->displayIcons)
         iconSize = _fileIconSize;
     if (iconSize > textHeight)
         height = iconSize;
     if (height == 0)
         height++;
     return height;
 }
 
 void KrInterBriefView::updateGeometries()
 {
     if (_header) {
         QSize hint = _header->sizeHint();
         setViewportMargins(0, hint.height(), 0, 0);
         QRect vg = viewport()->geometry();
         QRect geometryRect(vg.left(), vg.top() - hint.height(), vg.width(), hint.height());
         _header->setGeometry(geometryRect);
 
         int items = 0;
         for (int i = 0;  i != _header->count(); i++)
             if (!_header->isSectionHidden(i))
                 items++;
         if (items == 0)
             items++;
 
         int sectWidth = viewport()->width() / items;
         for (int i = 0;  i != _header->count(); i++)
             if (!_header->isSectionHidden(i))
                 _header->resizeSection(i, sectWidth);
 
         QMetaObject::invokeMethod(_header, "updateGeometries");
     }
 
     if (_model->rowCount() <= 0)
         horizontalScrollBar()->setRange(0, 0);
     else {
         int itemsPerColumn = viewport()->height() / getItemHeight();
         if (itemsPerColumn <= 0)
             itemsPerColumn = 1;
         int columnWidth = (viewport()->width()) / _numOfColumns;
         if ((viewport()->width()) % _numOfColumns)
             columnWidth++;
         int maxWidth = _model->rowCount() / itemsPerColumn;
         if (_model->rowCount() % itemsPerColumn)
             maxWidth++;
         maxWidth *= columnWidth;
         if (maxWidth > viewport()->width()) {
             horizontalScrollBar()->setSingleStep(columnWidth);
             horizontalScrollBar()->setPageStep(columnWidth * _numOfColumns);
             horizontalScrollBar()->setRange(0, maxWidth - viewport()->width());
         } else {
             horizontalScrollBar()->setRange(0, 0);
         }
     }
 
     QAbstractItemView::updateGeometries();
 }
 
 void KrInterBriefView::setSortMode(KrViewProperties::ColumnType sortColumn, bool descending)
 {
     Qt::SortOrder sortDir = descending ? Qt::DescendingOrder : Qt::AscendingOrder;
     _header->setSortIndicator(sortColumn, sortDir);
 }
 
 int KrInterBriefView::elementWidth(const QModelIndex & index)
 {
     QString text = index.data(Qt::DisplayRole).toString();
 
     int textWidth = QFontMetrics(_viewFont).width(text);
 
     const int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
     textWidth += 2 * textMargin;
 
     QVariant decor = index.data(Qt::DecorationRole);
     if (decor.isValid() && decor.type() == QVariant::Pixmap) {
         QPixmap p = decor.value<QPixmap>();
         textWidth += p.width() + 2 * textMargin;
     }
 
     return textWidth;
 }
 
 void KrInterBriefView::intersectionSet(const QRect &rect, QVector<QModelIndex> &ndxList)
 {
     int maxNdx = _model->rowCount();
     int width = (viewport()->width()) / _numOfColumns;
     if ((viewport()->width()) % _numOfColumns)
         width++;
 
     int height = getItemHeight();
     int items = viewport()->height() / height;
     if (items == 0)
         items++;
 
     int xmin = -1;
     int ymin = -1;
     int xmax = -1;
     int ymax = -1;
 
     xmin = rect.x() / width;
     ymin = rect.y() / height;
     xmax = (rect.x() + rect.width()) / width;
     if ((rect.x() + rect.width()) % width)
         xmax++;
     ymax = (rect.y() + rect.height()) / height;
     if ((rect.y() + rect.height()) % height)
         ymax++;
 
     for (int i = ymin; i < ymax; i++)
         for (int j = xmin; j < xmax; j++) {
             int ndx = j * items + i;
             if (ndx < maxNdx)
                 ndxList.append(_model->index(ndx, 0));
         }
 }
 
 QRect KrInterBriefView::itemRect(const FileItem *item)
 {
     return visualRect(_model->fileItemIndex(item));
 }
 
 void KrInterBriefView::copySettingsFrom(KrView *other)
 {
     if(other->instance() == instance()) { // the other view is of the same type
-        KrInterBriefView *v = static_cast<KrInterBriefView*>(other);
+        auto *v = dynamic_cast<KrInterBriefView*>(other);
         int column = v->_model->lastSortOrder();
         Qt::SortOrder sortDir = v->_model->lastSortDir();
         _header->setSortIndicator(column, sortDir);
         _model->sort(column, sortDir);
         setFileIconSize(v->fileIconSize());
     }
 }
 
 
 void KrInterBriefView::setFileIconSize(int size)
 {
     KrView::setFileIconSize(size);
     setIconSize(QSize(fileIconSize(), fileIconSize()));
     updateGeometries();
 }
 
 void KrInterBriefView::currentChanged(const QModelIndex & current, const QModelIndex & previous)
 {
     if (_model->ready()) {
         KrViewItem * item = getKrViewItem(currentIndex());
         op()->emitCurrentChanged(item);
     }
     QAbstractItemView::currentChanged(current, previous);
 }
 
 void KrInterBriefView::renameCurrentItem()
 {
     QModelIndex cIndex = currentIndex();
     QModelIndex nameIndex = _model->index(cIndex.row(), KrViewProperties::Name);
     edit(nameIndex);
     updateEditorData();
     update(nameIndex);
 }
 
 bool KrInterBriefView::event(QEvent * e)
 {
     _mouseHandler->otherEvent(e);
     return QAbstractItemView::event(e);
 }
 
 void KrInterBriefView::mousePressEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mousePressEvent(ev))
         QAbstractItemView::mousePressEvent(ev);
 }
 
 void KrInterBriefView::mouseReleaseEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mouseReleaseEvent(ev))
         QAbstractItemView::mouseReleaseEvent(ev);
 }
 
 void KrInterBriefView::mouseDoubleClickEvent(QMouseEvent *ev)
 {
     if (!_mouseHandler->mouseDoubleClickEvent(ev))
         QAbstractItemView::mouseDoubleClickEvent(ev);
 }
 
 void KrInterBriefView::mouseMoveEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mouseMoveEvent(ev))
         QAbstractItemView::mouseMoveEvent(ev);
 }
 
 void KrInterBriefView::dragEnterEvent(QDragEnterEvent *ev)
 {
     if (!_mouseHandler->dragEnterEvent(ev))
         QAbstractItemView::dragEnterEvent(ev);
 }
 
 void KrInterBriefView::dragMoveEvent(QDragMoveEvent *ev)
 {
     QAbstractItemView::dragMoveEvent(ev);
     _mouseHandler->dragMoveEvent(ev);
 }
 
 void KrInterBriefView::dragLeaveEvent(QDragLeaveEvent *ev)
 {
     if (!_mouseHandler->dragLeaveEvent(ev))
         QAbstractItemView::dragLeaveEvent(ev);
 }
 
 void KrInterBriefView::dropEvent(QDropEvent *ev)
 {
     if (!_mouseHandler->dropEvent(ev))
         QAbstractItemView::dropEvent(ev);
 }
 
 QRect KrInterBriefView::mapToViewport(const QRect &rect) const
 {
     if (!rect.isValid())
         return rect;
 
     QRect result = rect;
 
     int dx = -horizontalOffset();
     int dy = -verticalOffset();
     result.adjust(dx, dy, dx, dy);
     return result;
 }
diff --git a/krusader/Panel/PanelView/krinterbriefview.h b/krusader/Panel/PanelView/krinterbriefview.h
index 300b5c1f..85b97d96 100644
--- a/krusader/Panel/PanelView/krinterbriefview.h
+++ b/krusader/Panel/PanelView/krinterbriefview.h
@@ -1,121 +1,121 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRINTERBRIEFVIEW_H
 #define KRINTERBRIEFVIEW_H
 
 // QtCore
 #include <QVector>
 // QtGui
 #include <QFont>
 // QtWidgets
 #include <QAbstractItemView>
 #include <QHeaderView>
 #include <QWidget>
 
 #include "krinterview.h"
 
 /**
  * @brief Compact view showing only icon and file name of view items
  */
 class KrInterBriefView : public QAbstractItemView, public KrInterView
 {
     Q_OBJECT
 public:
     KrInterBriefView(QWidget *parent, KrViewInstance &instance, KConfig *cfg);
-    virtual ~KrInterBriefView();
+    ~KrInterBriefView() override;
 
     // ---- reimplemented from QAbstractItemView ----
     QRect visualRect(const QModelIndex&) const Q_DECL_OVERRIDE;
     QModelIndex indexAt(const QPoint&) const Q_DECL_OVERRIDE;
     void scrollTo(const QModelIndex &, QAbstractItemView::ScrollHint = QAbstractItemView::EnsureVisible) Q_DECL_OVERRIDE;
 
     // ---- reimplemented from KrView ----
     int  itemsPerPage() Q_DECL_OVERRIDE;
     void updateView() Q_DECL_OVERRIDE;
     bool ensureVisibilityAfterSelect() Q_DECL_OVERRIDE {
         return false;
     }
     void setSortMode(KrViewProperties::ColumnType sortColumn, bool descending) Q_DECL_OVERRIDE;
 
     // ---- reimplemented from QAbstractItemView ----
     // Don't do anything, selections are handled by the mouse handler
     void setSelection(const QRect &, QItemSelectionModel::SelectionFlags) Q_DECL_OVERRIDE {}
     void selectAll() Q_DECL_OVERRIDE {}
     // this shouldn't be called
     QRegion visualRegionForSelection(const QItemSelection&) const Q_DECL_OVERRIDE {
         return QRegion();
     }
 
     // ---- reimplemented from KrView ----
     void setFileIconSize(int size) Q_DECL_OVERRIDE;
 
 protected slots:
     // ---- reimplemented from QAbstractItemView ----
     void updateGeometries() Q_DECL_OVERRIDE;
 
     // ---- reimplemented from KrView ----
     void currentChanged(const QModelIndex & current, const QModelIndex & previous) Q_DECL_OVERRIDE;
 
     void renameCurrentItem() Q_DECL_OVERRIDE;
 
 protected:
     // ---- reimplemented from KrView ----
     bool handleKeyEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
     // ---- reimplemented from QAbstractItemView ----
     bool eventFilter(QObject *object, QEvent *event) Q_DECL_OVERRIDE;
     void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
     void paintEvent(QPaintEvent *e) Q_DECL_OVERRIDE;
     QModelIndex moveCursor(QAbstractItemView::CursorAction, Qt::KeyboardModifiers) Q_DECL_OVERRIDE;
     int horizontalOffset() const Q_DECL_OVERRIDE;
     int verticalOffset() const Q_DECL_OVERRIDE;
     bool isIndexHidden(const QModelIndex&) const Q_DECL_OVERRIDE;
 //     QRegion visualRegionForSelection(const QItemSelection&) const Q_DECL_OVERRIDE;
     bool event(QEvent * e) Q_DECL_OVERRIDE;
     void mousePressEvent(QMouseEvent *) Q_DECL_OVERRIDE;
     void mouseReleaseEvent(QMouseEvent *) Q_DECL_OVERRIDE;
     void mouseDoubleClickEvent(QMouseEvent *ev) Q_DECL_OVERRIDE;
     void mouseMoveEvent(QMouseEvent *) Q_DECL_OVERRIDE;
     void wheelEvent(QWheelEvent *) Q_DECL_OVERRIDE;
     void dragEnterEvent(QDragEnterEvent *e) Q_DECL_OVERRIDE;
     void dragMoveEvent(QDragMoveEvent *e) Q_DECL_OVERRIDE;
     void dragLeaveEvent(QDragLeaveEvent *e) Q_DECL_OVERRIDE;
     void dropEvent(QDropEvent *) Q_DECL_OVERRIDE;
 
     // ---- reimplemented from KrView ----
     void setup() Q_DECL_OVERRIDE;
     void doRestoreSettings(KConfigGroup group) Q_DECL_OVERRIDE;
     void saveSettings(KConfigGroup grp, KrViewProperties::PropertyType properties) Q_DECL_OVERRIDE;
     void copySettingsFrom(KrView *other) Q_DECL_OVERRIDE;
     QRect itemRect(const FileItem *fileitem) Q_DECL_OVERRIDE;
     void showContextMenu(const QPoint & p) Q_DECL_OVERRIDE;
     QRect mapToViewport(const QRect &rect) const;
 
     int getItemHeight() const;
     int elementWidth(const QModelIndex & index);
     void intersectionSet(const QRect &, QVector<QModelIndex> &);
 
 private:
     QFont _viewFont;
     int _numOfColumns;
     QHeaderView * _header;
 };
 
 #endif // KRINTERBRIEFVIEW_H
diff --git a/krusader/Panel/PanelView/krinterdetailedview.cpp b/krusader/Panel/PanelView/krinterdetailedview.cpp
index d10725ce..23d7c17a 100644
--- a/krusader/Panel/PanelView/krinterdetailedview.cpp
+++ b/krusader/Panel/PanelView/krinterdetailedview.cpp
@@ -1,450 +1,450 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krinterdetailedview.h"
 
 // QtCore
 #include <QDir>
 #include <QHashIterator>
 // QtWidgets
 #include <QApplication>
 #include <QDirModel>
 #include <QHeaderView>
 #include <QMenu>
 #include <QToolTip>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIOWidgets/KDirLister>
 
 #include "krviewfactory.h"
 #include "krviewitemdelegate.h"
 #include "krviewitem.h"
 #include "listmodel.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "krmousehandler.h"
 #include "../krcolorcache.h"
 #include "../GUI/krstyleproxy.h"
 
 
 KrInterDetailedView::KrInterDetailedView(QWidget *parent, KrViewInstance &instance, KConfig *cfg):
         QTreeView(parent),
         KrInterView(instance, cfg, this),
         _autoResizeColumns(true)
 {
     connect(_mouseHandler, &KrMouseHandler::renameCurrentItem, this, &KrInterDetailedView::renameCurrentItem);
     setWidget(this);
 
     KConfigGroup grpSvr(_config, "Look&Feel");
     _viewFont = grpSvr.readEntry("Filelist Font", _FilelistFont);
 
     setModel(_model);
     setRootIsDecorated(false);
     setItemsExpandable(false);
     setAllColumnsShowFocus(true);
     setUniformRowHeights(true);
 
     setMouseTracking(true);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
 
     setSelectionMode(QAbstractItemView::NoSelection);
     setSelectionModel(new DummySelectionModel(_model, this));
 
     header()->installEventFilter(this);
     header()->setSectionResizeMode(QHeaderView::Interactive);
     header()->setStretchLastSection(false);
 
-    KrStyleProxy *style = new KrStyleProxy();
+    auto *style = new KrStyleProxy();
     style->setParent(this);
     setStyle(style);
     viewport()->setStyle(style); // for custom tooltip delay
 
     setItemDelegate(new KrViewItemDelegate(this));
 
     connect(header(), &QHeaderView::sectionResized, this, &KrInterDetailedView::sectionResized);
     connect(header(), &QHeaderView::sectionMoved, this, &KrInterDetailedView::sectionMoved);
 }
 
 KrInterDetailedView::~KrInterDetailedView()
 {
     delete _properties;
-    _properties = 0;
+    _properties = nullptr;
     delete _operator;
-    _operator = 0;
+    _operator = nullptr;
 }
 
 void KrInterDetailedView::currentChanged(const QModelIndex & current, const QModelIndex & previous)
 {
     if (_model->ready()) {
         KrViewItem * item = getKrViewItem(currentIndex());
         op()->emitCurrentChanged(item);
     }
     QTreeView::currentChanged(current, previous);
 }
 
 void KrInterDetailedView::doRestoreSettings(KConfigGroup grp)
 {
     auto headerView = header();
 
     _autoResizeColumns = grp.readEntry("AutoResizeColumns", true);
 
     QByteArray savedState = grp.readEntry("Saved State", QByteArray());
     if (savedState.isEmpty()) {
         hideColumn(KrViewProperties::Type);
         hideColumn(KrViewProperties::Permissions);
         hideColumn(KrViewProperties::Owner);
         hideColumn(KrViewProperties::Group);
         hideColumn(KrViewProperties::Changed);
         hideColumn(KrViewProperties::Accessed);
         headerView->resizeSection(KrViewProperties::Ext, QFontMetrics(_viewFont).width("tar.bz2  "));
         headerView->resizeSection(KrViewProperties::KrPermissions, QFontMetrics(_viewFont).width("rwx  "));
         headerView->resizeSection(KrViewProperties::Size, QFontMetrics(_viewFont).width("9") * 10);
 
         QDateTime tmp(QDate(2099, 12, 29), QTime(23, 59));
         QString desc = QLocale().toString(tmp, QLocale::ShortFormat) + "  ";
 
         headerView->resizeSection(KrViewProperties::Modified, QFontMetrics(_viewFont).width(desc));
     } else {
         headerView->restoreState(savedState);
 
         // do not show new columns by default; restoreState() shows columns not saved
         if (KrGlobal::sCurrentConfigVersion < KrGlobal::sConfigVersion) {
             hideColumn(KrViewProperties::Changed);
             hideColumn(KrViewProperties::Accessed);
         }
 
         _model->setExtensionEnabled(!isColumnHidden(KrViewProperties::Ext));
     }
 
     // In case a column is assigned zero size for some reason, it's impossible to fix this from interface.
     // We correct this problem by enforcing the minimum width of the column.
     auto minSize = headerView->minimumSectionSize();
     for (int i = KrViewProperties::Ext; i < KrViewProperties::MAX_COLUMNS; i++) {
         if (!headerView->isSectionHidden(i) && headerView->sectionSize(i) < minSize) {
             headerView->resizeSection(i, minSize);
         }
     }
 
     KrInterView::doRestoreSettings(grp);
 }
 
 void KrInterDetailedView::saveSettings(KConfigGroup grp, KrViewProperties::PropertyType properties)
 {
     KrInterView::saveSettings(grp, properties);
 
     grp.writeEntry("AutoResizeColumns", _autoResizeColumns);
 
     if(properties & KrViewProperties::PropColumns) {
         QByteArray state = header()->saveState();
         grp.writeEntry("Saved State", state);
     }
 }
 
 int KrInterDetailedView::itemsPerPage()
 {
     QRect rect = visualRect(currentIndex());
     if (!rect.isValid()) {
         for (int i = 0; i != _model->rowCount(); i++) {
             rect = visualRect(_model->index(i, 0));
             if (rect.isValid())
                 break;
         }
     }
     if (!rect.isValid())
         return 0;
     int size = (height() - header()->height()) / rect.height();
     if (size < 0)
         size = 0;
     return size;
 }
 
 void KrInterDetailedView::updateView()
 {
 }
 
 void KrInterDetailedView::setup()
 {
     setSortMode(_properties->sortColumn, (_properties->sortOptions & KrViewProperties::Descending));
     setSortingEnabled(true);
 }
 
 void KrInterDetailedView::keyPressEvent(QKeyEvent *e)
 {
     if (!e || !_model->ready())
         return ; // subclass bug
     if (handleKeyEvent(e))    // did the view class handled the event?
         return;
     QTreeView::keyPressEvent(e);
 }
 
 void KrInterDetailedView::mousePressEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mousePressEvent(ev))
         QTreeView::mousePressEvent(ev);
 }
 
 void KrInterDetailedView::mouseReleaseEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mouseReleaseEvent(ev))
         QTreeView::mouseReleaseEvent(ev);
 }
 
 void KrInterDetailedView::mouseDoubleClickEvent(QMouseEvent *ev)
 {
     if (!_mouseHandler->mouseDoubleClickEvent(ev))
         QTreeView::mouseDoubleClickEvent(ev);
 }
 
 void KrInterDetailedView::mouseMoveEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mouseMoveEvent(ev))
         QTreeView::mouseMoveEvent(ev);
 }
 
 void KrInterDetailedView::wheelEvent(QWheelEvent *ev)
 {
     if (!_mouseHandler->wheelEvent(ev))
         QTreeView::wheelEvent(ev);
 }
 
 void KrInterDetailedView::dragEnterEvent(QDragEnterEvent *ev)
 {
     if (!_mouseHandler->dragEnterEvent(ev))
         QTreeView::dragEnterEvent(ev);
 }
 
 void KrInterDetailedView::dragMoveEvent(QDragMoveEvent *ev)
 {
     QTreeView::dragMoveEvent(ev);
     _mouseHandler->dragMoveEvent(ev);
 }
 
 void KrInterDetailedView::dragLeaveEvent(QDragLeaveEvent *ev)
 {
     if (!_mouseHandler->dragLeaveEvent(ev))
         QTreeView::dragLeaveEvent(ev);
 }
 
 void KrInterDetailedView::dropEvent(QDropEvent *ev)
 {
     if (!_mouseHandler->dropEvent(ev))
         QTreeView::dropEvent(ev);
 }
 
 bool KrInterDetailedView::event(QEvent * e)
 {
     _mouseHandler->otherEvent(e);
     return QTreeView::event(e);
 }
 
 void KrInterDetailedView::renameCurrentItem()
 {
     QModelIndex cIndex = currentIndex();
     QModelIndex nameIndex = _model->index(cIndex.row(), KrViewProperties::Name);
     edit(nameIndex);
     updateEditorData();
     update(nameIndex);
 }
 
 bool KrInterDetailedView::eventFilter(QObject *object, QEvent *event)
 {
     if (object == header()) {
         if (event->type() == QEvent::ContextMenu) {
-            QContextMenuEvent *me = (QContextMenuEvent *)event;
+            auto *me = (QContextMenuEvent *)event;
             showContextMenu(me->globalPos());
             return true;
         } else if (event->type() == QEvent::Resize) {
             recalculateColumnSizes();
             return false;
         }
     }
     return false;
 }
 
 void KrInterDetailedView::showContextMenu(const QPoint & p)
 {
     QMenu popup(this);
     popup.setTitle(i18n("Columns"));
 
     QVector<QAction*> actions;
 
     for(int i = KrViewProperties::Ext; i < KrViewProperties::MAX_COLUMNS; i++) {
         QString text = (_model->headerData(i, Qt::Horizontal)).toString();
         QAction *act = popup.addAction(text);
         act->setCheckable(true);
         act->setChecked(!header()->isSectionHidden(i));
         act->setData(i);
         actions.append(act);
     }
 
     popup.addSeparator();
     QAction *actAutoResize = popup.addAction(i18n("Automatically Resize Columns"));
     actAutoResize->setCheckable(true);
     actAutoResize->setChecked(_autoResizeColumns);
 
     QAction *res = popup.exec(p);
-    if (res == 0)
+    if (res == nullptr)
         return;
 
     if(res == actAutoResize) {
         _autoResizeColumns = actAutoResize->isChecked();
         recalculateColumnSizes();
     } else {
         int column = res->data().toInt();
 
         if(header()->isSectionHidden(column))
             header()->showSection(column);
         else
             header()->hideSection(column);
 
         if(KrViewProperties::Ext == column)
             _model->setExtensionEnabled(!header()->isSectionHidden(KrViewProperties::Ext));
     }
     op()->settingsChanged(KrViewProperties::PropColumns);
 }
 
 void KrInterDetailedView::sectionResized(int /*column*/, int oldSize, int newSize)
 {
     // *** taken from dolphin ***
     // If the user changes the size of the headers, the autoresize feature should be
     // turned off. As there is no dedicated interface to find out whether the header
     // section has been resized by the user or by a resize event, another approach is used.
     // Attention: Take care when changing the if-condition to verify that there is no
     // regression in combination with bug 178630 (see fix in comment #8).
     if ((QApplication::mouseButtons() & Qt::LeftButton) && header()->underMouse()) {
         _autoResizeColumns = false;
         op()->settingsChanged(KrViewProperties::PropColumns);
     }
 
     if (oldSize == newSize || !_model->ready())
         return;
 
     recalculateColumnSizes();
 }
 
 void KrInterDetailedView::sectionMoved(int /*logicalIndex*/, int /*oldVisualIndex*/, int /*newVisualIndex*/)
 {
     op()->settingsChanged(KrViewProperties::PropColumns);
 }
 
 void KrInterDetailedView::recalculateColumnSizes()
 {
     if(!_autoResizeColumns)
         return;
     int sum = 0;
     for (int i = 0; i != _model->columnCount(); i++) {
         if (!isColumnHidden(i))
             sum += header()->sectionSize(i);
     }
 
     if (sum != header()->width()) {
         int delta = sum - header()->width();
         int nameSize = header()->sectionSize(KrViewProperties::Name);
         if (nameSize - delta > 20)
             header()->resizeSection(KrViewProperties::Name, nameSize - delta);
     }
 }
 
 bool KrInterDetailedView::viewportEvent(QEvent * event)
 {
     if (event->type() == QEvent::ToolTip) {
         // only show tooltip if column is not wide enough to show all text. In this case the column
         // data text is abbreviated and the full text is shown as tooltip, see ListModel::data().
 
-        QHelpEvent *he = static_cast<QHelpEvent*>(event);
+        auto *he = dynamic_cast<QHelpEvent*>(event);
         const QModelIndex index = indexAt(he->pos());
         // name column has a detailed tooltip
         if (index.isValid() && index.column() != KrViewProperties::Name) {
             int width = header()->sectionSize(index.column());
             QString text = index.data(Qt::DisplayRole).toString();
 
             int textWidth = QFontMetrics(_viewFont).width(text);
 
             const int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
             textWidth += 2 * textMargin;
 
             QVariant decor = index.data(Qt::DecorationRole);
             if (decor.isValid() && decor.type() == QVariant::Pixmap) {
                 QPixmap p = decor.value<QPixmap>();
                 textWidth += p.width() + 2 * textMargin;
             }
 
             if (textWidth <= width) {
                 QToolTip::hideText();
                 event->accept();
                 return true;
             }
         }
     }
     return QTreeView::viewportEvent(event);
 }
 
 void KrInterDetailedView::drawRow(QPainter *painter, const QStyleOptionViewItem &options,
                                   const QModelIndex &index) const
 {
     QTreeView::drawRow(painter, options, index);
     // (may) draw dashed line border around current item row. This is done internally in
     // QTreeView::drawRow() only when panel is focused, we have to repeat it here.
     if (index == currentIndex() && drawCurrent()) {
         QStyleOptionFocusRect o;
         o.backgroundColor = options.palette.color(QPalette::Normal, QPalette::Background);
 
         const QRect focusRect(0, options.rect.y(), header()->length(), options.rect.height());
         o.rect = style()->visualRect(layoutDirection(), viewport()->rect(), focusRect);
 
         style()->drawPrimitive(QStyle::PE_FrameFocusRect, &o, painter);
     }
 }
 
 void KrInterDetailedView::setSortMode(KrViewProperties::ColumnType sortColumn, bool descending)
 {
     Qt::SortOrder sortDir = descending ? Qt::DescendingOrder : Qt::AscendingOrder;
     sortByColumn(sortColumn, sortDir);
 }
 
 void KrInterDetailedView::setFileIconSize(int size)
 {
     KrView::setFileIconSize(size);
     setIconSize(QSize(fileIconSize(), fileIconSize()));
 }
 
 QRect KrInterDetailedView::itemRect(const FileItem *item)
 {
     QRect r = visualRect(_model->fileItemIndex(item));
     r.setLeft(0);
     r.setWidth(header()->length());
     return r;
 }
 
 void KrInterDetailedView::copySettingsFrom(KrView *other)
 {
     if(other->instance() == instance()) { // the other view is of the same type
-        KrInterDetailedView *v = static_cast<KrInterDetailedView*>(other);
+        auto *v = dynamic_cast<KrInterDetailedView*>(other);
         _autoResizeColumns = v->_autoResizeColumns;
         header()->restoreState(v->header()->saveState());
         _model->setExtensionEnabled(!isColumnHidden(KrViewProperties::Ext));
         recalculateColumnSizes();
         setFileIconSize(v->fileIconSize());
     }
 }
diff --git a/krusader/Panel/PanelView/krinterdetailedview.h b/krusader/Panel/PanelView/krinterdetailedview.h
index 6d69e4ab..b28efdb5 100644
--- a/krusader/Panel/PanelView/krinterdetailedview.h
+++ b/krusader/Panel/PanelView/krinterdetailedview.h
@@ -1,96 +1,96 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRINTERDETAILEDVIEW_H
 #define KRINTERDETAILEDVIEW_H
 
 // QtCore
 #include <QVector>
 // QtGui
 #include <QFont>
 // QtWidgets
 #include <QTreeView>
 
 #include "krinterview.h"
 
 class QMouseEvent;
 class QKeyEvent;
 class QDragEnterEvent;
 
 class KrInterDetailedView : public QTreeView, public KrInterView
 {
     Q_OBJECT
 
 public:
     KrInterDetailedView(QWidget *parent, KrViewInstance &instance, KConfig *cfg);
-    virtual ~KrInterDetailedView();
+    ~KrInterDetailedView() override;
 
     void updateView() Q_DECL_OVERRIDE;
 
     bool ensureVisibilityAfterSelect() Q_DECL_OVERRIDE {
         return false;
     }
     int  itemsPerPage() Q_DECL_OVERRIDE;
     void setSortMode(KrViewProperties::ColumnType sortColumn, bool descending) Q_DECL_OVERRIDE;
     void setFileIconSize(int size) Q_DECL_OVERRIDE;
     void doRestoreSettings(KConfigGroup grp) Q_DECL_OVERRIDE;
 
 protected slots:
     void renameCurrentItem() Q_DECL_OVERRIDE;
     void sectionResized(int, int, int);
     void sectionMoved(int, int, int);
     void currentChanged(const QModelIndex & current, const QModelIndex & previous) Q_DECL_OVERRIDE;
 
 protected:
     void setup() Q_DECL_OVERRIDE;
     void copySettingsFrom(KrView *other) Q_DECL_OVERRIDE;
     void saveSettings(KConfigGroup grp, KrViewProperties::PropertyType properties) Q_DECL_OVERRIDE;
 
     // Don't do anything, selections are handled by the mouse handler
     void setSelection(const QRect &, QItemSelectionModel::SelectionFlags) Q_DECL_OVERRIDE {}
     void selectAll() Q_DECL_OVERRIDE {}
 
     void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
     void mousePressEvent(QMouseEvent *) Q_DECL_OVERRIDE;
     void mouseReleaseEvent(QMouseEvent *) Q_DECL_OVERRIDE;
     void mouseDoubleClickEvent(QMouseEvent *ev) Q_DECL_OVERRIDE;
     void mouseMoveEvent(QMouseEvent *) Q_DECL_OVERRIDE;
     void wheelEvent(QWheelEvent *) Q_DECL_OVERRIDE;
     bool event(QEvent * e) Q_DECL_OVERRIDE;
     void dragEnterEvent(QDragEnterEvent *e) Q_DECL_OVERRIDE;
     void dragMoveEvent(QDragMoveEvent *e) Q_DECL_OVERRIDE;
     void dragLeaveEvent(QDragLeaveEvent *e) Q_DECL_OVERRIDE;
     void dropEvent(QDropEvent *) Q_DECL_OVERRIDE;
     bool eventFilter(QObject *object, QEvent *event) Q_DECL_OVERRIDE;
     bool viewportEvent(QEvent * event) Q_DECL_OVERRIDE;
     void drawRow(QPainter *painter, const QStyleOptionViewItem &options,
                  const QModelIndex &index) const Q_DECL_OVERRIDE;
 
     QRect itemRect(const FileItem *fileitem) Q_DECL_OVERRIDE;
 
     void showContextMenu(const QPoint & p) Q_DECL_OVERRIDE;
     void recalculateColumnSizes();
 
 private:
     QFont _viewFont;
     bool _autoResizeColumns;
 };
 #endif // __krinterview__
diff --git a/krusader/Panel/PanelView/krinterview.cpp b/krusader/Panel/PanelView/krinterview.cpp
index 635c2d27..3217bd23 100644
--- a/krusader/Panel/PanelView/krinterview.cpp
+++ b/krusader/Panel/PanelView/krinterview.cpp
@@ -1,404 +1,404 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krinterview.h"
 
 #include <QDebug>
 
 #include "krmousehandler.h"
 #include "listmodel.h"
 #include "krviewitem.h"
 #include "../krpreviews.h"
 #include "../krcolorcache.h"
 #include "../FileSystem/dirlisterinterface.h"
 #include "../FileSystem/fileitem.h"
 
 KrInterView::KrInterView(KrViewInstance &instance, KConfig *cfg,
                          QAbstractItemView *itemView) :
-        KrView(instance, cfg), _itemView(itemView), _mouseHandler(0)
+        KrView(instance, cfg), _itemView(itemView), _mouseHandler(nullptr)
 {
     _model = new ListModel(this);
 
     // fix the context menu problem
     int j = QFontMetrics(_itemView->font()).height() * 2;
     _mouseHandler = new KrMouseHandler(this, j);
 }
 
 KrInterView::~KrInterView()
 {
     // any references to the model should be cleared ar this point,
     // but sometimes for some reason it is still referenced by
     // QPersistentModelIndex instances held by QAbstractItemView and/or QItemSelectionModel(child object) -
     // so schedule _model for later deletion
     _model->clear(false);
     _model->deleteLater();
-    _model = 0;
+    _model = nullptr;
     delete _mouseHandler;
-    _mouseHandler = 0;
+    _mouseHandler = nullptr;
     QHashIterator< FileItem *, KrViewItem *> it(_itemHash);
     while (it.hasNext())
         delete it.next().value();
     _itemHash.clear();
 }
 
 void KrInterView::selectRegion(KrViewItem *i1, KrViewItem *i2, bool select)
 {
-    FileItem* file1 = (FileItem *)i1->getFileItem();
+    auto* file1 = (FileItem *)i1->getFileItem();
     QModelIndex mi1 = _model->fileItemIndex(file1);
-    FileItem* file2 = (FileItem *)i2->getFileItem();
+    auto* file2 = (FileItem *)i2->getFileItem();
     QModelIndex mi2 = _model->fileItemIndex(file2);
 
     if (mi1.isValid() && mi2.isValid()) {
         int r1 = mi1.row();
         int r2 = mi2.row();
 
         if (r1 > r2) {
             int t = r1;
             r1 = r2;
             r2 = t;
         }
 
         op()->setMassSelectionUpdate(true);
         for (int row = r1; row <= r2; row++)
             setSelected(_model->fileItemAt(_model->index(row, 0)), select);
         op()->setMassSelectionUpdate(false);
 
         redraw();
 
     } else if (mi1.isValid() && !mi2.isValid())
         i1->setSelected(select);
     else if (mi2.isValid() && !mi1.isValid())
         i2->setSelected(select);
 }
 
 void KrInterView::intSetSelected(const FileItem* item, bool select)
 {
     if(select)
         _selection.insert(item);
     else
         _selection.remove(item);
 }
 
 bool KrInterView::isSelected(const QModelIndex &ndx)
 {
     return isSelected(_model->fileItemAt(ndx));
 }
 
 KrViewItem* KrInterView::findItemByName(const QString &name)
 {
     if (!_model->ready())
-        return 0;
+        return nullptr;
 
     QModelIndex ndx = _model->nameIndex(name);
     if (!ndx.isValid())
-        return 0;
+        return nullptr;
     return getKrViewItem(ndx);
 }
 
 KrViewItem *KrInterView::findItemByUrl(const QUrl &url)
 {
     if (!_model->ready())
-        return 0;
+        return nullptr;
 
     const QModelIndex ndx = _model->indexFromUrl(url);
     if (!ndx.isValid())
-        return 0;
+        return nullptr;
 
     return getKrViewItem(ndx);
 }
 
 QString KrInterView::getCurrentItem() const
 {
     if (!_model->ready())
         return QString();
 
     FileItem *fileItem = _model->fileItemAt(_itemView->currentIndex());
     return fileItem ? fileItem->getName() : QString();
 }
 
 KrViewItem* KrInterView::getCurrentKrViewItem()
 {
     if (!_model->ready())
-        return 0;
+        return nullptr;
 
     return getKrViewItem(_itemView->currentIndex());
 }
 
 KrViewItem* KrInterView::getFirst()
 {
     if (!_model->ready())
-        return 0;
+        return nullptr;
 
     return getKrViewItem(_model->index(0, 0, QModelIndex()));
 }
 
 KrViewItem* KrInterView::getLast()
 {
     if (!_model->ready())
-        return 0;
+        return nullptr;
 
     return getKrViewItem(_model->index(_model->rowCount() - 1, 0, QModelIndex()));
 }
 
 KrViewItem* KrInterView::getNext(KrViewItem *current)
 {
-    FileItem* fileItem = (FileItem *)current->getFileItem();
+    auto* fileItem = (FileItem *)current->getFileItem();
     QModelIndex ndx = _model->fileItemIndex(fileItem);
     if (ndx.row() >= _model->rowCount() - 1)
-        return 0;
+        return nullptr;
     return getKrViewItem(_model->index(ndx.row() + 1, 0, QModelIndex()));
 }
 
 KrViewItem* KrInterView::getPrev(KrViewItem *current)
 {
-    FileItem* fileItem = (FileItem *)current->getFileItem();
+    auto* fileItem = (FileItem *)current->getFileItem();
     QModelIndex ndx = _model->fileItemIndex(fileItem);
     if (ndx.row() <= 0)
-        return 0;
+        return nullptr;
     return getKrViewItem(_model->index(ndx.row() - 1, 0, QModelIndex()));
 }
 
 KrViewItem* KrInterView::getKrViewItemAt(const QPoint &vp)
 {
     if (!_model->ready())
-        return 0;
+        return nullptr;
 
     return getKrViewItem(_itemView->indexAt(vp));
 }
 
 KrViewItem * KrInterView::getKrViewItem(FileItem *fileItem)
 {
     QHash<FileItem *, KrViewItem*>::iterator it = _itemHash.find(fileItem);
     if (it == _itemHash.end()) {
-        KrViewItem * newItem =  new KrViewItem(fileItem, this);
+        auto * newItem =  new KrViewItem(fileItem, this);
         _itemHash[ fileItem ] = newItem;
         return newItem;
     }
     return *it;
 }
 
 KrViewItem * KrInterView::getKrViewItem(const QModelIndex & ndx)
 {
     if (!ndx.isValid())
-        return 0;
+        return nullptr;
     FileItem * fileitem = _model->fileItemAt(ndx);
-    if (fileitem == 0)
-        return 0;
+    if (fileitem == nullptr)
+        return nullptr;
     else
         return getKrViewItem(fileitem);
 }
 
 void KrInterView::makeCurrentVisible()
 {
     makeItemVisible(getCurrentKrViewItem());
 }
 
 void KrInterView::makeItemVisible(const KrViewItem *item)
 {
-    if (item == 0)
+    if (item == nullptr)
         return;
 
-    FileItem* fileitem = (FileItem *)item->getFileItem();
+    auto* fileitem = (FileItem *)item->getFileItem();
     const QModelIndex index = _model->fileItemIndex(fileitem);
     qDebug() << "scroll to item; name=" << fileitem->getName() << " index=" << index;
     if (index.isValid())
         _itemView->scrollTo(index);
 }
 
 bool KrInterView::isItemVisible(const KrViewItem *item)
 {
     return item && _itemView->viewport()->rect().contains(item->itemRect());
 }
 
 void KrInterView::setCurrentItem(const QString &name, bool scrollToCurrent,
                                  const QModelIndex &fallbackToIndex)
 {
     // find index by given name and set it as current
     const QModelIndex index = _model->nameIndex(name);
     if (index.isValid()) {
         setCurrent(index, scrollToCurrent);
     } else if (fallbackToIndex.isValid()) {
         // set fallback index as current if not too big, else set the last item as current
         if (fallbackToIndex.row() < _itemView->model()->rowCount()) {
             setCurrent(fallbackToIndex, scrollToCurrent);
         } else {
             setCurrentKrViewItem(getLast(), scrollToCurrent);
         }
     } else {
         // when given parameters fail, set the first item as current
         setCurrentKrViewItem(getFirst(), scrollToCurrent);
     }
 }
 
 void KrInterView::setCurrentKrViewItem(KrViewItem *item, bool scrollToCurrent)
 {
     if (!item) {
         setCurrent(QModelIndex(), scrollToCurrent);
         return;
     }
 
-    FileItem* fileitem = (FileItem *)item->getFileItem();
+    auto* fileitem = (FileItem *)item->getFileItem();
     const QModelIndex index = _model->fileItemIndex(fileitem);
     if (index.isValid() && index.row() != _itemView->currentIndex().row()) {
         setCurrent(index, scrollToCurrent);
     }
 }
 
 void KrInterView::setCurrent(const QModelIndex &index, bool scrollToCurrent) {
     const bool disableAutoScroll = _itemView->hasAutoScroll() && !scrollToCurrent;
     if (disableAutoScroll) {
         // setCurrentIndex() scrolls to current if autoScroll is turned on
         _itemView->setAutoScroll(false);
     }
 
     _mouseHandler->cancelTwoClickRename();
     _itemView->setCurrentIndex(index);
 
     if (disableAutoScroll) {
         _itemView->setAutoScroll(true);
     }
 }
 
 void KrInterView::sort()
 {
     _model->sort();
 }
 
 void KrInterView::clear()
 {
     _selection.clear();
     _itemView->clearSelection();
     _itemView->setCurrentIndex(QModelIndex());
     _model->clear();
     QHashIterator< FileItem *, KrViewItem *> it(_itemHash);
     while (it.hasNext())
         delete it.next().value();
     _itemHash.clear();
 
     KrView::clear();
 }
 
 void KrInterView::populate(const QList<FileItem*> &fileItems, FileItem *dummy)
 {
     _model->populate(fileItems, dummy);
 }
 
 KrViewItem* KrInterView::preAddItem(FileItem *fileitem)
 {
     const QModelIndex index = _model->addItem(fileitem);
     return getKrViewItem(index);
 }
 
 void KrInterView::preDeleteItem(KrViewItem *item)
 {
     setSelected(item->getFileItem(), false);
 
     // if the next item is current, current selection is lost on remove; preserve manually
     KrViewItem *currentItem = getCurrentKrViewItem();
-    KrViewItem *nextCurrentItem = currentItem && currentItem == getNext(item) ? currentItem : 0;
+    KrViewItem *nextCurrentItem = currentItem && currentItem == getNext(item) ? currentItem : nullptr;
 
     _model->removeItem((FileItem *)item->getFileItem());
 
     if (nextCurrentItem)
         setCurrentKrViewItem(nextCurrentItem, false);
 
     _itemHash.remove((FileItem *)item->getFileItem());
 }
 
 void KrInterView::prepareForActive()
 {
     _focused = true;
     _itemView->setFocus();
 }
 
 void KrInterView::prepareForPassive()
 {
     _focused = false;
     _mouseHandler->cancelTwoClickRename();
     //if ( renameLineEdit() ->isVisible() )
     //renameLineEdit() ->clearFocus();
 }
 
 void KrInterView::redraw()
 {
     _itemView->viewport()->update();
 }
 
 void KrInterView::refreshColors()
 {
     QPalette p(_itemView->palette());
     KrColorGroup cg;
     KrColorCache::getColorCache().getColors(cg, KrColorItemType(KrColorItemType::File,
         false, _focused, false, false));
     p.setColor(QPalette::Text, cg.text());
     p.setColor(QPalette::Base, cg.background());
     _itemView->setPalette(p);
     redraw();
 }
 
 void KrInterView::sortModeUpdated(int column, Qt::SortOrder order)
 {
     KrView::sortModeUpdated(static_cast<KrViewProperties::ColumnType>(column),
                             order == Qt::DescendingOrder);
 }
 
 KIO::filesize_t KrInterView::calcSize()
 {
     KIO::filesize_t size = 0;
     foreach(FileItem *fileitem, _model->fileItems()) {
         size += fileitem->getSize();
     }
     return size;
 }
 
 KIO::filesize_t KrInterView::calcSelectedSize()
 {
     KIO::filesize_t size = 0;
     foreach(const FileItem *fileitem, _selection) {
         size += fileitem->getSize();
     }
     return size;
 }
 
 QList<QUrl> KrInterView::selectedUrls()
 {
     QList<QUrl> list;
     foreach(const FileItem *fileitem, _selection) {
         list << fileitem->getUrl();
     }
     return list;
 }
 
 void KrInterView::setSelectionUrls(const QList<QUrl> urls)
 {
     op()->setMassSelectionUpdate(true);
 
     _selection.clear();
 
     foreach(const QUrl &url, urls) {
         const QModelIndex idx = _model->indexFromUrl(url);
         if(idx.isValid())
             setSelected(_model->fileItemAt(idx), true);
     }
 
     op()->setMassSelectionUpdate(false);
 }
diff --git a/krusader/Panel/PanelView/krmousehandler.cpp b/krusader/Panel/PanelView/krmousehandler.cpp
index 2c8aa349..337e1ad3 100644
--- a/krusader/Panel/PanelView/krmousehandler.cpp
+++ b/krusader/Panel/PanelView/krmousehandler.cpp
@@ -1,387 +1,387 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krmousehandler.h"
 #include "krselectionmode.h"
 #include "krview.h"
 #include "krviewitem.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 
 // QtCore
 #include <QStandardPaths>
 // QtWidgets
 #include <QApplication>
 #include <QStyle>
 
 #include <KCoreAddons/KUrlMimeData>
 #include <KConfigCore/KSharedConfig>
 
 #define CANCEL_TWO_CLICK_RENAME {_singleClicked = false;_renameTimer.stop();}
 
-KrMouseHandler::KrMouseHandler(KrView * view, int contextMenuShift) : _view(view), _rightClickedItem(0),
-        _contextMenuTimer(), _contextMenuShift(contextMenuShift), _singleClicked(false), _singleClickTime(),
-        _renameTimer(), _dragStartPos(-1, -1), _emptyContextMenu(false), _selectedItemNames()
+KrMouseHandler::KrMouseHandler(KrView *view, int contextMenuShift)
+    : _view(view), _rightClickedItem(nullptr), _contextMenuShift(contextMenuShift),
+      _singleClicked(false), _dragStartPos(-1, -1), _emptyContextMenu(false)
 {
     KConfigGroup grpSvr(krConfig, "Look&Feel");
     // decide on single click/double click selection
     bool singleClickTmp = QApplication::style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick);
     _singleClick = grpSvr.readEntry("Single Click Selects", _SingleClickSelects) && singleClickTmp;
     connect(&_contextMenuTimer, &QTimer::timeout, this, &KrMouseHandler::showContextMenu);
     connect(&_renameTimer, &QTimer::timeout, this, &KrMouseHandler::renameCurrentItem);
 }
 
 bool KrMouseHandler::mousePressEvent(QMouseEvent *e)
 {
-    _rightClickedItem = _clickedItem = 0;
+    _rightClickedItem = _clickedItem = nullptr;
     KrViewItem * item = _view->getKrViewItemAt(e->pos());
     if (!_view->isFocused())
         _view->op()->emitNeedFocus();
     if (e->button() == Qt::LeftButton) {
         _dragStartPos = e->pos();
         if (e->modifiers() == Qt::NoModifier) {
             if (item) {
                 if (KrSelectionMode::getSelectionHandler()->leftButtonSelects()) {
                     if (KrSelectionMode::getSelectionHandler()->leftButtonPreservesSelection())
                         item->setSelected(!item->isSelected());
                     else {
                         if (item->isSelected())
                             _clickedItem = item;
                         else {
                             // clear the current selection
                             _view->changeSelection(KRQuery("*"), false, true);
                             item->setSelected(true);
                         }
                     }
                 }
                 _view->setCurrentKrViewItem(item);
             } else {
                 // empty space under items clicked
                 if (KrSelectionMode::getSelectionHandler()->leftButtonSelects()
                     && !KrSelectionMode::getSelectionHandler()->leftButtonPreservesSelection()) {
 
                     // clear the current selection
                     _view->changeSelection(KRQuery("*"), false, true);
                 }
             }
             e->accept();
             return true;
         } else if (e->modifiers() == Qt::ControlModifier) {
 
             if (item && (KrSelectionMode::getSelectionHandler()->shiftCtrlLeftButtonSelects() ||
                          KrSelectionMode::getSelectionHandler()->leftButtonSelects())) {
 
                 // get current selected item names
                 _selectedItemNames.clear();
                 _view->getSelectedItems(&_selectedItemNames, false);
 
                 item->setSelected(!item->isSelected());
 
                 // select also the focused item if there are no other selected items
                 KrViewItem * previousItem = _view->getCurrentKrViewItem();
                 if (previousItem->name() != ".." && _selectedItemNames.empty()) {
                     previousItem->setSelected(true);
                 }
             }
             if (item) {
                 _view->setCurrentKrViewItem(item);
             }
             e->accept();
             return true;
         } else if (e->modifiers() == Qt::ShiftModifier) {
             if (item && (KrSelectionMode::getSelectionHandler()->shiftCtrlLeftButtonSelects() ||
                          KrSelectionMode::getSelectionHandler()->leftButtonSelects())) {
                 KrViewItem * current = _view->getCurrentKrViewItem();
-                if (current != 0)
+                if (current != nullptr)
                     _view->selectRegion(item, current, true);
             }
             if (item)
                 _view->setCurrentKrViewItem(item);
             e->accept();
             return true;
         }
     }
     if (e->button() == Qt::RightButton) {
         //dragStartPos = e->pos();
         if (e->modifiers() == Qt::NoModifier) {
             if (item) {
                 if (KrSelectionMode::getSelectionHandler()->rightButtonSelects()) {
                     if (KrSelectionMode::getSelectionHandler()->rightButtonPreservesSelection()) {
                         if (KrSelectionMode::getSelectionHandler()->showContextMenu() >= 0) {
                             _rightClickSelects = !item->isSelected();
                             _rightClickedItem = item;
                         }
                         item->setSelected(!item->isSelected());
                     } else {
                         if (item->isSelected()) {
                             _clickedItem = item;
                         } else {
                             // clear the current selection
                             _view->changeSelection(KRQuery("*"), false, true);
                             item->setSelected(true);
                         }
                     }
                 }
                 _view->setCurrentKrViewItem(item);
             }
             handleContextMenu(item, e->globalPos());
             e->accept();
             return true;
         } else if (e->modifiers() == Qt::ControlModifier) {
             if (item && (KrSelectionMode::getSelectionHandler()->shiftCtrlRightButtonSelects() ||
                          KrSelectionMode::getSelectionHandler()->rightButtonSelects())) {
                 item->setSelected(!item->isSelected());
             }
             if (item)
                 _view->setCurrentKrViewItem(item);
             e->accept();
             return true;
         } else if (e->modifiers() == Qt::ShiftModifier) {
             if (item && (KrSelectionMode::getSelectionHandler()->shiftCtrlRightButtonSelects() ||
                          KrSelectionMode::getSelectionHandler()->rightButtonSelects())) {
                 KrViewItem * current = _view->getCurrentKrViewItem();
-                if (current != 0)
+                if (current != nullptr)
                     _view->selectRegion(item, current, true);
             }
             if (item)
                 _view->setCurrentKrViewItem(item);
             e->accept();
             return true;
         }
     }
     if (e->button() == Qt::ForwardButton) {
         _view->op()->emitGoForward();
         return true;
     }
     if (e->button() == Qt::BackButton) {
         _view->op()->emitGoBack();
         return true;
     }
     return false;
 }
 
 bool KrMouseHandler::mouseReleaseEvent(QMouseEvent *e)
 {
     if (e->button() == Qt::LeftButton)
         _dragStartPos = QPoint(-1, -1);
     KrViewItem * item = _view->getKrViewItemAt(e->pos());
 
     if (item && item == _clickedItem) {
         if (((e->button() == Qt::LeftButton) && (e->modifiers() == Qt::NoModifier) &&
                 (KrSelectionMode::getSelectionHandler()->leftButtonSelects()) &&
                 !(KrSelectionMode::getSelectionHandler()->leftButtonPreservesSelection())) ||
                 ((e->button() == Qt::RightButton) && (e->modifiers() == Qt::NoModifier) &&
                  (KrSelectionMode::getSelectionHandler()->rightButtonSelects()) &&
                  !(KrSelectionMode::getSelectionHandler()->rightButtonPreservesSelection()))) {
             // clear the current selection
             _view->changeSelection(KRQuery("*"), false, true);
             item->setSelected(true);
         }
     }
 
     if (e->button() == Qt::RightButton) {
-        _rightClickedItem = 0;
+        _rightClickedItem = nullptr;
         _contextMenuTimer.stop();
     }
     if (_singleClick && e->button() == Qt::LeftButton && e->modifiers() == Qt::NoModifier) {
         CANCEL_TWO_CLICK_RENAME;
         e->accept();
-        if (item == 0)
+        if (item == nullptr)
             return true;
         QString tmp = item->name();
         _view->op()->emitExecuted(tmp);
         return true;
     } else if (!_singleClick && e->button() == Qt::LeftButton) {
         if (item && e->modifiers() == Qt::NoModifier) {
             if (_singleClicked && !_renameTimer.isActive() && _singleClickedItem == item) {
                 KSharedConfigPtr config = KSharedConfig::openConfig();
                 KConfigGroup group(krConfig, "KDE");
                 int doubleClickInterval = group.readEntry("DoubleClickInterval", 400);
 
                 int msecsFromLastClick = _singleClickTime.msecsTo(QTime::currentTime());
 
                 if (msecsFromLastClick > doubleClickInterval && msecsFromLastClick < 5 * doubleClickInterval) {
                     _singleClicked = false;
                     _renameTimer.setSingleShot(true);
                     _renameTimer.start(doubleClickInterval);
                     return true;
                 }
             }
 
             CANCEL_TWO_CLICK_RENAME;
             _singleClicked = true;
             _singleClickedItem = item;
             _singleClickTime = QTime::currentTime();
 
             return true;
         }
     }
 
     CANCEL_TWO_CLICK_RENAME;
 
-    if (e->button() == Qt::MidButton && item != 0) {
+    if (e->button() == Qt::MidButton && item != nullptr) {
         e->accept();
-        if (item == 0)
+        if (item == nullptr)
             return true;
         _view->op()->emitMiddleButtonClicked(item);
         return true;
     }
     return false;
 }
 
 bool KrMouseHandler::mouseDoubleClickEvent(QMouseEvent *e)
 {
     CANCEL_TWO_CLICK_RENAME;
 
     KrViewItem * item = _view->getKrViewItemAt(e->pos());
     if (_singleClick)
         return false;
-    if (e->button() == Qt::LeftButton && item != 0) {
+    if (e->button() == Qt::LeftButton && item != nullptr) {
         e->accept();
-        QString tmp = item->name();
+        const QString& tmp = item->name();
         _view->op()->emitExecuted(tmp);
         return true;
     }
     return false;
 }
 
 bool KrMouseHandler::mouseMoveEvent(QMouseEvent *e)
 {
     KrViewItem * item =  _view->getKrViewItemAt(e->pos());
     if ((_singleClicked || _renameTimer.isActive()) && item != _singleClickedItem)
         CANCEL_TWO_CLICK_RENAME;
 
     if (!item)
         return false;
 
     const QString desc = item->description();
     _view->op()->emitItemDescription(desc);
 
     if (_dragStartPos != QPoint(-1, -1) &&
             (e->buttons() & Qt::LeftButton) && (_dragStartPos - e->pos()).manhattanLength() > QApplication::startDragDistance()) {
         _view->op()->startDrag();
         return true;
     }
 
     if (KrSelectionMode::getSelectionHandler()->rightButtonPreservesSelection()
             && KrSelectionMode::getSelectionHandler()->rightButtonSelects()
             && KrSelectionMode::getSelectionHandler()->showContextMenu() >= 0 && e->buttons() == Qt::RightButton) {
         e->accept();
         if (item != _rightClickedItem && item && _rightClickedItem) {
             _view->selectRegion(item, _rightClickedItem, _rightClickSelects);
             _rightClickedItem = item;
             _view->setCurrentKrViewItem(item);
             _contextMenuTimer.stop();
         }
         return true;
     }
     return false;
 }
 
 bool KrMouseHandler::wheelEvent(QWheelEvent *e)
 {
     if (!_view->isFocused())
         _view->op()->emitNeedFocus();
 
     if (e->modifiers() == Qt::ControlModifier) {
         if (e->delta() > 0) {
             _view->zoomIn();
         } else {
             _view->zoomOut();
         }
         e->accept();
         return true;
     }
 
     return false;
 }
 
 void KrMouseHandler::showContextMenu()
 {
     if (_rightClickedItem)
         _rightClickedItem->setSelected(true);
     if (_emptyContextMenu)
         _view->op()->emitEmptyContextMenu(_contextMenuPoint);
     else
         _view->op()->emitContextMenu(_contextMenuPoint);
 }
 
 void KrMouseHandler::handleContextMenu(KrViewItem * it, const QPoint & pos)
 {
     if (!_view->isFocused())
         _view->op()->emitNeedFocus();
     int i = KrSelectionMode::getSelectionHandler()->showContextMenu();
     _contextMenuPoint = QPoint(pos.x(), pos.y() - _contextMenuShift);
     if (i < 0) {
         if (!it || it->isDummy())
             _view->op()->emitEmptyContextMenu(_contextMenuPoint);
         else {
             _view->setCurrentKrViewItem(it);
             _view->op()->emitContextMenu(_contextMenuPoint);
         }
     } else if (i > 0) {
         _emptyContextMenu = !it || it->isDummy();
         _contextMenuTimer.setSingleShot(true);
         _contextMenuTimer.start(i);
     }
 }
 
 void KrMouseHandler::otherEvent(QEvent * e)
 {
     switch (e->type()) {
     case QEvent::Timer:
     case QEvent::MouseMove:
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonRelease:
         break;
     default:
         CANCEL_TWO_CLICK_RENAME;
     }
 }
 
 void KrMouseHandler::cancelTwoClickRename()
 {
     CANCEL_TWO_CLICK_RENAME;
 }
 
 bool KrMouseHandler::dragEnterEvent(QDragEnterEvent *e)
 {
     QList<QUrl> URLs = KUrlMimeData::urlsFromMimeData(e->mimeData());
     e->setAccepted(!URLs.isEmpty());
     return true;
 }
 
 bool KrMouseHandler::dragMoveEvent(QDragMoveEvent *e)
 {
     QList<QUrl> URLs = KUrlMimeData::urlsFromMimeData(e->mimeData());
     e->setAccepted(!URLs.isEmpty());
     return true;
 }
 
 bool KrMouseHandler::dragLeaveEvent(QDragLeaveEvent * /*e*/)
 {
     return false;
 }
 
 bool KrMouseHandler::dropEvent(QDropEvent *e)
 {
     _view->op()->emitGotDrop(e);
     return true;
 }
diff --git a/krusader/Panel/PanelView/krselectionmode.cpp b/krusader/Panel/PanelView/krselectionmode.cpp
index 72c5927c..f2e199eb 100644
--- a/krusader/Panel/PanelView/krselectionmode.cpp
+++ b/krusader/Panel/PanelView/krselectionmode.cpp
@@ -1,101 +1,101 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krselectionmode.h"
 #include "../krglobal.h"
 #include "../defaults.h"
 
 #include <KConfigCore/KSharedConfig>
 
-static KrSelectionMode *__currentSelectionMode = 0; // uninitiated, at first
+static KrSelectionMode *__currentSelectionMode = nullptr; // uninitiated, at first
 
 
 KonqSelectionMode konqSelectionMode;
 OriginalSelectionMode originalSelectionMode;
 TCSelectionMode tcSelectionMode;
 ErgonomicSelectionMode ergonomicSelectionMode;
 UserSelectionMode userSelectionMode;
 
 KrSelectionMode* KrSelectionMode::getSelectionHandlerForMode(const QString &mode)
 {
-    KrSelectionMode *res = NULL;
+    KrSelectionMode *res = nullptr;
     bool isNum;
     int modenum = mode.toInt(&isNum);
     switch (modenum) {
     case 0:
         res = &originalSelectionMode;
         break;
     case 1:
         res = &konqSelectionMode;
         break;
     case 2:
         res = &tcSelectionMode;
         break;
     case 3:
         //costom mode
         break;
     case 4:
         res = &ergonomicSelectionMode;
         break;
     default:
         break;
     }
     return res;
 }
 
 KrSelectionMode* KrSelectionMode::getSelectionHandler()
 {
     if (__currentSelectionMode) { // don't check krConfig every time
         return __currentSelectionMode;
     } else { // nothing yet, set the correct one
         KConfigGroup group(krConfig, "Look&Feel");
         QString mode = group.readEntry("Mouse Selection", QString(""));
         __currentSelectionMode = getSelectionHandlerForMode(mode);
-        if (__currentSelectionMode == NULL) {
+        if (__currentSelectionMode == nullptr) {
             __currentSelectionMode = &userSelectionMode;
         }
         // init and return
         __currentSelectionMode->init();
         return __currentSelectionMode;
     }
 }
 
 void KrSelectionMode::resetSelectionHandler()
 {
-    __currentSelectionMode = 0;
+    __currentSelectionMode = nullptr;
 }
 
 void UserSelectionMode::init()
 {
     KConfigGroup group(krConfig, "Custom Selection Mode");
     _useQTSelection = group.readEntry("QT Selection", _QtSelection);
     _leftButtonSelects = group.readEntry("Left Selects", _LeftSelects);
     _leftButtonPreservesSelection = group.readEntry("Left Preserves", _LeftPreserves);
     _shiftCtrlLeftButtonSelects = group.readEntry("ShiftCtrl Left Selects", _ShiftCtrlLeft);
     _rightButtonSelects = group.readEntry("Right Selects", _RightSelects);
     _rightButtonPreservesSelection = group.readEntry("Right Preserves", _RightPreserves);
     _shiftCtrlRightButtonSelects = group.readEntry("ShiftCtrl Right Selects", _ShiftCtrlRight);
     _spaceMovesDown = group.readEntry("Space Moves Down", _SpaceMovesDown);
     _spaceCalculatesDiskSpace = group.readEntry("Space Calc Space", _SpaceCalcSpace);
     _insertMovesDown = group.readEntry("Insert Moves Down", _InsertMovesDown);
     _showContextMenu = (group.readEntry("Immediate Context Menu", _ImmediateContextMenu) ? -1 : 500);
 }
 
diff --git a/krusader/Panel/PanelView/krsort.cpp b/krusader/Panel/PanelView/krsort.cpp
index a96cb048..a2734a49 100644
--- a/krusader/Panel/PanelView/krsort.cpp
+++ b/krusader/Panel/PanelView/krsort.cpp
@@ -1,333 +1,335 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krsort.h"
 
+#include <utility>
+
 #include "krview.h"
 #include "../FileSystem/fileitem.h"
 
 namespace KrSort {
 
 void SortProps::init(FileItem *fileitem, int col, const KrViewProperties * props, bool isDummy, bool asc, int origNdx, QVariant customData) {
     _col = col;
     _prop = props;
     _isdummy = isDummy;
     _ascending = asc;
     _fileItem = fileitem;
     _index = origNdx;
     _name = fileitem->getName();
-    _customData = customData;
+    _customData = std::move(customData);
 
     if(_prop->sortOptions & KrViewProperties::IgnoreCase)
         _name = _name.toLower();
 
     switch (_col) {
     case KrViewProperties::Ext: {
         if (fileitem->isDir()) {
             _ext = "";
         } else {
             // check if the file has an extension
             const QString& fileitemName = fileitem->getName();
             int loc = fileitemName.lastIndexOf('.');
             if (loc > 0) { // avoid mishandling of .bashrc and friend
                 // check if it has one of the predefined 'atomic extensions'
-                for (QStringList::const_iterator i = props->atomicExtensions.begin(); i != props->atomicExtensions.end(); ++i) {
-                    if (fileitemName.endsWith(*i) && fileitemName != *i) {
-                        loc = fileitemName.length() - (*i).length();
+                for (const auto & atomicExtension : props->atomicExtensions) {
+                    if (fileitemName.endsWith(atomicExtension) && fileitemName != atomicExtension) {
+                        loc = fileitemName.length() - atomicExtension.length();
                         break;
                     }
                 }
                 _ext = _name.mid(loc);
             } else
                 _ext = "";
         }
         break;
     }
     case KrViewProperties::Type:
         _data = isDummy ? "" : KrView::mimeTypeText(fileitem);
         break;
     case KrViewProperties::Permissions:
         _data = isDummy ? "" : KrView::permissionsText(properties(), fileitem);
         break;
     case KrViewProperties::KrPermissions:
         _data = isDummy ? "" : KrView::krPermissionText(fileitem);
         break;
     case KrViewProperties::Owner:
         _data = isDummy ? "" : fileitem->getOwner();
         break;
     case KrViewProperties::Group:
         _data = isDummy ? "" : fileitem->getGroup();
         break;
     default:
         break;
     }
 }
 
 
 // compares numbers within two strings
 int compareNumbers(QString& aS1, int& aPos1, QString& aS2, int& aPos2)
 {
     int res = 0;
     int start1 = aPos1;
     int start2 = aPos2;
     while (aPos1 < aS1.length() && aS1.at(aPos1).isDigit()) aPos1++;
     while (aPos2 < aS2.length() && aS2.at(aPos2).isDigit()) aPos2++;
     // the left-most difference determines what's bigger
     int i1 = aPos1 - 1;
     int i2 = aPos2 - 1;
     for (; i1 >= start1 || i2 >= start2; i1--, i2--) {
         int c1 = 0;
         int c2 = 0;
         if (i1 >= start1) c1 = aS1.at(i1).digitValue();
         if (i2 >= start2) c2 = aS2.at(i2).digitValue();
         if (c1 < c2) res = -1;
         else if (c1 > c2) res = 1;
     }
     return res;
 }
 
 bool compareTextsAlphabetical(QString& aS1, QString& aS2, const KrViewProperties * _viewProperties, bool aNumbers)
 {
     int lPositionS1 = 0;
     int lPositionS2 = 0;
     // sometimes, localeAwareCompare is not case sensitive. in that case, we need to fallback to a simple string compare (KDE bug #40131)
     bool lUseLocaleAware = ((_viewProperties->sortOptions & KrViewProperties::IgnoreCase)
                 || _viewProperties->localeAwareCompareIsCaseSensitive)
             && (_viewProperties->sortOptions & KrViewProperties::LocaleAwareSort);
     int j = 0;
     QChar lchar1;
     QChar lchar2;
     while (true) {
         lchar1 = aS1[lPositionS1];
         lchar2 = aS2[lPositionS2];
         // detect numbers
         if (aNumbers && lchar1.isDigit() && lchar2.isDigit()) {
             int j = compareNumbers(aS1, lPositionS1, aS2, lPositionS2);
             if (j != 0) return j < 0;
         } else if (lUseLocaleAware
                    &&
                    ((lchar1 >= 128
                      && ((lchar2 >= 'A' && lchar2 <= 'Z') || (lchar2 >= 'a' && lchar2 <= 'z') || lchar2 >= 128))
                     ||
                     (lchar2 >= 128
                      && ((lchar1 >= 'A' && lchar1 <= 'Z') || (lchar1 >= 'a' && lchar1 <= 'z') || lchar1 >= 128))
                    )
                   ) {
             // use localeAwareCompare when a unicode character is encountered
             j = QString::localeAwareCompare(lchar1, lchar2);
             if (j != 0) return j < 0;
             lPositionS1++;
             lPositionS2++;
         } else {
             // if characters are latin or localeAwareCompare is not case sensitive then use simple characters compare is enough
             if (lchar1 < lchar2) return true;
             if (lchar1 > lchar2) return false;
             lPositionS1++;
             lPositionS2++;
         }
         // at this point strings are equal, check if ends of strings are reached
         if (lPositionS1 == aS1.length() && lPositionS2 == aS2.length()) return false;
         if (lPositionS1 == aS1.length() && lPositionS2 < aS2.length()) return true;
         if (lPositionS1 < aS1.length() && lPositionS2 == aS2.length()) return false;
     }
 }
 
 bool compareTextsCharacterCode(QString& aS1, QString& aS2, const KrViewProperties * _viewProperties, bool aNumbers)
 {
     Q_UNUSED(_viewProperties);
 
     int lPositionS1 = 0;
     int lPositionS2 = 0;
     while (true) {
         // detect numbers
         if (aNumbers && aS1[lPositionS1].isDigit() && aS2[lPositionS2].isDigit()) {
             int j = compareNumbers(aS1, lPositionS1, aS2, lPositionS2);
             if (j != 0) return j < 0;
         } else {
             if (aS1[lPositionS1] < aS2[lPositionS2]) return true;
             if (aS1[lPositionS1] > aS2[lPositionS2]) return false;
             lPositionS1++;
             lPositionS2++;
         }
         // at this point strings are equal, check if ends of strings are reached
         if (lPositionS1 == aS1.length() && lPositionS2 == aS2.length()) return false;
         if (lPositionS1 == aS1.length() && lPositionS2 < aS2.length()) return true;
         if (lPositionS1 < aS1.length() && lPositionS2 == aS2.length()) return false;
     }
 }
 
 bool compareTextsKrusader(const QString &aS1, const QString &aS2, const KrViewProperties *_viewProperties)
 {
     // sometimes, localeAwareCompare is not case sensitive. in that case, we need to fallback to a simple string compare (KDE bug #40131)
     if (((_viewProperties->sortOptions & KrViewProperties::IgnoreCase)
                 || _viewProperties->localeAwareCompareIsCaseSensitive)
             && (_viewProperties->sortOptions & KrViewProperties::LocaleAwareSort))
         return QString::localeAwareCompare(aS1, aS2) < 0;
     else
         // if localeAwareCompare is not case sensitive then use simple compare is enough
         return QString::compare(aS1, aS2) < 0;
 }
 
 bool compareTexts(QString aS1, QString aS2, const KrViewProperties * _viewProperties, bool asc, bool isName)
 {
     //check empty strings
     if (aS1.length() == 0 && aS2.length() == 0) {
         return false;
     } else if (aS1.length() == 0) {
         return true;
     } else if (aS2.length() == 0) {
         return false;
     }
 
     if (isName) {
         if (aS1 == "..") {
             return !asc;
         } else {
             if (aS2 == "..")
                 return asc;
         }
     }
 
     switch (_viewProperties->sortMethod) {
     case KrViewProperties::Alphabetical:
         return compareTextsAlphabetical(aS1, aS2, _viewProperties, false);
     case KrViewProperties::AlphabeticalNumbers:
         return compareTextsAlphabetical(aS1, aS2, _viewProperties, true);
     case KrViewProperties::CharacterCode:
         return compareTextsCharacterCode(aS1, aS2, _viewProperties, false);
     case KrViewProperties::CharacterCodeNumbers:
         return compareTextsCharacterCode(aS1, aS2, _viewProperties, true);
     case KrViewProperties::Krusader:
     default:
         return compareTextsKrusader(aS1, aS2, _viewProperties);
     }
 }
 
 bool itemLessThan(SortProps *sp, SortProps *sp2)
 {
     FileItem * file1 = sp->fileitem();
     FileItem * file2 = sp2->fileitem();
     bool isdir1 = file1->isDir();
     bool isdir2 = file2->isDir();
     bool dirsFirst = sp->properties()->sortOptions & KrViewProperties::DirsFirst;
     bool alwaysSortDirsByName = sp->properties()->sortOptions & KrViewProperties::AlwaysSortDirsByName && dirsFirst && isdir1 && isdir2;
 
     if(dirsFirst) {
         if (isdir1 && !isdir2)
             return sp->isAscending();
         if (isdir2 && !isdir1)
             return !sp->isAscending();
     }
 
     if (sp->isDummy())
         return sp->isAscending();
     if (sp2->isDummy())
         return !sp->isAscending();
 
     int column = sp->column();
 
     if (dirsFirst && isdir1 && isdir2 && alwaysSortDirsByName) {
         alwaysSortDirsByName = !sp->isAscending();
         column = KrViewProperties::Name;
     }
 
     switch (column) {
     case KrViewProperties::Name:
         return compareTexts(sp->name(), sp2->name(), sp->properties(), sp->isAscending(), true) ^ alwaysSortDirsByName;
     case KrViewProperties::Ext:
         if (sp->extension() == sp2->extension())
             return compareTexts(sp->name(), sp2->name(), sp->properties(), sp->isAscending(), true);
         return compareTexts(sp->extension(), sp2->extension(), sp->properties(), sp->isAscending(), true);
     case KrViewProperties::Size:
         if (file1->getSize() == file2->getSize())
             return compareTexts(sp->name(), sp2->name(), sp->properties(), sp->isAscending(), true);
         return file1->getSize() < file2->getSize();
     case KrViewProperties::Modified:
             return compareTime(file1->getTime_t(), file2->getTime_t(), sp, sp2);
     case KrViewProperties::Changed:
             return compareTime(file1->getChangedTime(), file2->getChangedTime(), sp, sp2);
     case KrViewProperties::Accessed:
             return compareTime(file1->getAccessTime(), file2->getAccessTime(), sp, sp2);
     case KrViewProperties::Type:
     case KrViewProperties::Permissions:
     case KrViewProperties::KrPermissions:
     case KrViewProperties::Owner:
     case KrViewProperties::Group:
         if (sp->data() == sp2->data())
             return compareTexts(sp->name(), sp2->name(), sp->properties(), sp->isAscending(), true);
         return compareTexts(sp->data(), sp2->data(), sp->properties(), sp->isAscending(), true);
     }
     return sp->name() < sp2->name();
 }
 
 bool compareTime(time_t time1, time_t time2, SortProps *sp, SortProps *sp2)
 {
     return time1 != time2 ? time1 < time2 :
            compareTexts(sp->name(), sp2->name(), sp->properties(), sp->isAscending(), true);
 }
 
 bool itemGreaterThan(SortProps *sp, SortProps *sp2)
 {
     return !itemLessThan(sp, sp2);
 }
 
 
 Sorter::Sorter(int reserveItems, const KrViewProperties *viewProperties,
         LessThanFunc lessThanFunc, LessThanFunc greaterThanFunc) :
     _viewProperties(viewProperties),
     _lessThanFunc(lessThanFunc),
     _greaterThanFunc(greaterThanFunc)
  {
     _items.reserve(reserveItems);
     _itemStore.reserve(reserveItems);
  }
 
 void Sorter::addItem(FileItem *fileitem, bool isDummy, int idx, QVariant customData)
 {
-    _itemStore << SortProps(fileitem, _viewProperties->sortColumn, _viewProperties, isDummy, !descending(), idx, customData);
+    _itemStore << SortProps(fileitem, _viewProperties->sortColumn, _viewProperties, isDummy, !descending(), idx, std::move(customData));
     _items << &_itemStore.last();
 }
 
 void Sorter::sort()
 {
     qStableSort(_items.begin(), _items.end(),
                 descending() ? _greaterThanFunc : _lessThanFunc);
 }
 
 int Sorter::insertIndex(FileItem *fileitem, bool isDummy, QVariant customData)
 {
-    SortProps props(fileitem,  _viewProperties->sortColumn, _viewProperties, isDummy, !descending(), -1, customData);
+    SortProps props(fileitem,  _viewProperties->sortColumn, _viewProperties, isDummy, !descending(), -1, std::move(customData));
     const QVector<SortProps*>::iterator it =
         qLowerBound(_items.begin(), _items.end(), &props,
                         descending() ? _greaterThanFunc : _lessThanFunc);
 
     if(it != _items.end())
          return _items.indexOf((*it));
     else
         return _items.count();
 }
 
 bool Sorter::descending() const
 {
     return _viewProperties->sortOptions & KrViewProperties::Descending;
 }
 
 } // namespace KrSort
diff --git a/krusader/Panel/PanelView/krview.cpp b/krusader/Panel/PanelView/krview.cpp
index 6c96041a..67a1519f 100644
--- a/krusader/Panel/PanelView/krview.cpp
+++ b/krusader/Panel/PanelView/krview.cpp
@@ -1,1223 +1,1222 @@
 /*****************************************************************************
  * Copyright (C) 2000-2002 Shie Erlich <krusader@users.sourceforge.net>      *
  * Copyright (C) 2000-2002 Rafi Yanai <krusader@users.sourceforge.net>       *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krview.h"
 
 #include "krselectionmode.h"
 #include "krviewfactory.h"
 #include "krviewitem.h"
 #include "../FileSystem/dirlisterinterface.h"
 #include "../FileSystem/fileitem.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../Filter/filterdialog.h"
 #include "../defaults.h"
 #include "../filelisticon.h"
 #include "../krcolorcache.h"
 #include "../krglobal.h"
 #include "../krpreviews.h"
 #include "../viewactions.h"
 
 // QtCore
 #include <QDebug>
 #include <QDir>
 // QtGui
 #include <QPixmapCache>
 #include <QBitmap>
 #include <QPainter>
 #include <QPixmap>
 // QtWidgets
 #include <QAction>
 #include <QInputDialog>
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <qnamespace.h>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 
 #define FILEITEM getFileItem()
 
-KrView *KrViewOperator::_changedView = 0;
+KrView *KrViewOperator::_changedView = nullptr;
 KrViewProperties::PropertyType KrViewOperator::_changedProperties = KrViewProperties::NoProperty;
 
 
 // ----------------------------- operator
 KrViewOperator::KrViewOperator(KrView *view, QWidget *widget) :
         _view(view), _widget(widget), _massSelectionUpdate(false)
 {
     _saveDefaultSettingsTimer.setSingleShot(true);
     connect(&_saveDefaultSettingsTimer, &QTimer::timeout, this, &KrViewOperator::saveDefaultSettings);
 }
 
 KrViewOperator::~KrViewOperator()
 {
     if(_changedView == _view)
         saveDefaultSettings();
 }
 
 void KrViewOperator::startUpdate()
 {
     _view->refresh();
 }
 
 void KrViewOperator::cleared()
 {
     _view->clear();
 }
 
 void KrViewOperator::fileAdded(FileItem *fileitem)
 {
     _view->addItem(fileitem);
 }
 
 void KrViewOperator::fileUpdated(FileItem *newFileitem)
 {
     _view->updateItem(newFileitem);
 }
 
 void KrViewOperator::startDrag()
 {
     QStringList items;
     _view->getSelectedItems(&items);
     if (items.empty())
         return ; // don't drag an empty thing
     QPixmap px;
-    if (items.count() > 1 || _view->getCurrentKrViewItem() == 0)
+    if (items.count() > 1 || _view->getCurrentKrViewItem() == nullptr)
         px = FileListIcon("document-multiple").pixmap();  // we are dragging multiple items
     else
         px = _view->getCurrentKrViewItem()->icon();
     emit letsDrag(items, px);
 }
 
 bool KrViewOperator::searchItem(const QString &text, bool caseSensitive, int direction)
 {
     KrViewItem * item = _view->getCurrentKrViewItem();
     if (!item) {
         return false;
     }
     const QRegExp regeEx(text, caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive,
                          QRegExp::Wildcard);
     if (!direction) {
         if (regeEx.indexIn(item->name()) == 0) {
             return true;
         }
         direction = 1;
     }
     KrViewItem * startItem = item;
     while (true) {
         item = (direction > 0) ? _view->getNext(item) : _view->getPrev(item);
         if (!item)
             item = (direction > 0) ? _view->getFirst() : _view->getLast();
         if (regeEx.indexIn(item->name()) == 0) {
             _view->setCurrentKrViewItem(item);
             _view->makeItemVisible(item);
             return true;
         }
         if (item == startItem) {
             return false;
         }
     }
 }
 
 bool KrViewOperator::filterSearch(const QString &text, bool caseSensitive)
 {
     _view->_quickFilterMask = QRegExp(text,
                                       caseSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive,
                                       QRegExp::Wildcard);
     _view->refresh();
     return _view->_count || !_view->_files->numFileItems();
 }
 
 void KrViewOperator::setMassSelectionUpdate(bool upd)
 {
     _massSelectionUpdate = upd;
     if (!upd) {
         emit selectionChanged();
         _view->redraw();
     }
 }
 
 void KrViewOperator::settingsChanged(KrViewProperties::PropertyType properties)
 {
     if(!_view->_updateDefaultSettings || _view->_ignoreSettingsChange)
         return;
 
     if(_changedView != _view)
         saveDefaultSettings();
     _changedView = _view;
     _changedProperties = static_cast<KrViewProperties::PropertyType>(_changedProperties | properties);
     _saveDefaultSettingsTimer.start(100);
 }
 
 void KrViewOperator::saveDefaultSettings()
 {
     _saveDefaultSettingsTimer.stop();
     if(_changedView)
         _changedView->saveDefaultSettings(_changedProperties);
     _changedProperties = KrViewProperties::NoProperty;
-    _changedView = 0;
+    _changedView = nullptr;
 }
 
 // ----------------------------- krview
 
 const KrView::IconSizes KrView::iconSizes;
 
 KrView::KrView(KrViewInstance &instance, KConfig *cfg)
-    : _config(cfg), _properties(0), _focused(false), _fileIconSize(0),
-      _instance(instance), _files(0), _mainWindow(0), _widget(0), _nameToMakeCurrent(QString()),
-      _previews(0), _updateDefaultSettings(false), _ignoreSettingsChange(false), _count(0),
-      _numDirs(0), _dummyFileItem(0)
+    : _config(cfg), _properties(nullptr), _focused(false), _fileIconSize(0),
+      _instance(instance), _files(nullptr), _mainWindow(nullptr), _widget(nullptr), _nameToMakeCurrent(QString()),
+      _previews(nullptr), _updateDefaultSettings(false), _ignoreSettingsChange(false), _count(0),
+      _numDirs(0), _dummyFileItem(nullptr)
 {
 }
 
 KrView::~KrView()
 {
     _instance.m_objects.removeOne(this);
     delete _previews;
-    _previews = 0;
+    _previews = nullptr;
     delete _dummyFileItem;
-    _dummyFileItem = 0;
+    _dummyFileItem = nullptr;
     if (_properties)
         qFatal("A class inheriting KrView didn't delete _properties!");
     if (_operator)
         qFatal("A class inheriting KrView didn't delete _operator!");
 }
 
 void KrView::init(bool enableUpdateDefaultSettings)
 {
     // sanity checks:
     if (!_widget)
         qFatal("_widget must be set during construction of KrView inheritors");
     // ok, continue
     initProperties();
     _operator = createOperator();
     setup();
     restoreDefaultSettings();
 
     _updateDefaultSettings = enableUpdateDefaultSettings &&
         KConfigGroup(_config, "Startup").readEntry("Update Default Panel Settings", _RememberPos);
 
     _instance.m_objects.append(this);
 }
 
 void KrView::initProperties()
 {
     const KConfigGroup grpInstance(_config, _instance.name());
     const bool displayIcons = grpInstance.readEntry("With Icons", _WithIcons);
 
     const KConfigGroup grpSvr(_config, "Look&Feel");
     const bool numericPermissions = grpSvr.readEntry("Numeric permissions", _NumericPermissions);
 
     int sortOps = 0;
     if (grpSvr.readEntry("Show Directories First", true))
         sortOps |= KrViewProperties::DirsFirst;
     if(grpSvr.readEntry("Always sort dirs by name", false))
         sortOps |=  KrViewProperties::AlwaysSortDirsByName;
     if (!grpSvr.readEntry("Case Sensative Sort", _CaseSensativeSort))
         sortOps |= KrViewProperties::IgnoreCase;
     if (grpSvr.readEntry("Locale Aware Sort", true))
         sortOps |= KrViewProperties::LocaleAwareSort;
-    KrViewProperties::SortOptions sortOptions = static_cast<KrViewProperties::SortOptions>(sortOps);
+    auto sortOptions = static_cast<KrViewProperties::SortOptions>(sortOps);
 
     KrViewProperties::SortMethod sortMethod = static_cast<KrViewProperties::SortMethod>(
         grpSvr.readEntry("Sort method", (int)_DefaultSortMethod));
     const bool humanReadableSize = grpSvr.readEntry("Human Readable Size", _HumanReadableSize);
 
     // see KDE bug #40131
     const bool localeAwareCompareIsCaseSensitive = QString("a").localeAwareCompare("B") > 0;
 
     QStringList defaultAtomicExtensions;
     defaultAtomicExtensions += ".tar.gz";
     defaultAtomicExtensions += ".tar.bz2";
     defaultAtomicExtensions += ".tar.lzma";
     defaultAtomicExtensions += ".tar.xz";
     defaultAtomicExtensions += ".moc.cpp";
     QStringList atomicExtensions = grpSvr.readEntry("Atomic Extensions", defaultAtomicExtensions);
     for (QStringList::iterator i = atomicExtensions.begin(); i != atomicExtensions.end();) {
         QString & ext = *i;
         ext = ext.trimmed();
         if (!ext.length()) {
             i = atomicExtensions.erase(i);
             continue;
         }
         if (!ext.startsWith('.'))
             ext.insert(0, '.');
         ++i;
     }
 
     _properties = new KrViewProperties(displayIcons, numericPermissions, sortOptions, sortMethod,
                                        humanReadableSize, localeAwareCompareIsCaseSensitive,
                                        atomicExtensions);
 }
 
 void KrView::showPreviews(bool show)
 {
     if(show) {
         if(!_previews) {
             _previews = new KrPreviews(this);
             _previews->update();
         }
     } else {
         delete _previews;
-        _previews = 0;
+        _previews = nullptr;
     }
     redraw();
 //     op()->settingsChanged(KrViewProperties::PropShowPreviews);
     op()->emitRefreshActions();
 }
 
 void KrView::updatePreviews()
 {
     if(_previews)
         _previews->update();
 }
 
 QPixmap KrView::processIcon(const QPixmap &icon, bool dim, const QColor & dimColor, int dimFactor, bool symlink)
 {
     QPixmap pixmap = icon;
 
     if (symlink) {
         const QStringList overlays = QStringList() << QString() << "emblem-symbolic-link";
         Icon::applyOverlays(&pixmap, overlays);
     }
 
     if(!dim)
         return pixmap;
 
     QImage dimmed = pixmap.toImage();
 
     QPainter p(&dimmed);
     p.setCompositionMode(QPainter::CompositionMode_SourceIn);
     p.fillRect(0, 0, icon.width(), icon.height(), dimColor);
     p.setCompositionMode(QPainter::CompositionMode_SourceOver);
     p.setOpacity((qreal)dimFactor / (qreal)100);
     p.drawPixmap(0, 0, icon.width(), icon.height(), pixmap);
 
     return QPixmap::fromImage(dimmed, Qt::ColorOnly | Qt::ThresholdDither |
                                 Qt::ThresholdAlphaDither | Qt::NoOpaqueDetection );
 }
 
 QPixmap KrView::getIcon(FileItem *fileitem, bool active, int size/*, KRListItem::cmpColor color*/)
 {
     // KConfigGroup ag( krConfig, "Advanced");
     //////////////////////////////
     QPixmap icon;
     QString iconName = fileitem->getIcon();
     QString cacheName;
 
     if(!size)
         size = _FilelistIconSize.toInt();
 
     QColor dimColor;
     int dimFactor;
     bool dim = !active && KrColorCache::getColorCache().getDimSettings(dimColor, dimFactor);
 
     if (iconName.isNull())
         iconName = "";
 
     cacheName.append(QString::number(size));
     if(fileitem->isSymLink())
         cacheName.append("LINK_");
     if(dim)
         cacheName.append("DIM_");
     cacheName.append(iconName);
 
     //QPixmapCache::setCacheLimit( ag.readEntry("Icon Cache Size",_IconCacheSize) );
 
     // first try the cache
     if (!QPixmapCache::find(cacheName, icon)) {
         icon = processIcon(Icon(iconName, Icon("unknown")).pixmap(size),
                            dim, dimColor, dimFactor, fileitem->isSymLink());
         // insert it into the cache
         QPixmapCache::insert(cacheName, icon);
     }
 
     return icon;
 }
 
 QPixmap KrView::getIcon(FileItem *fileitem)
 {
     if(_previews) {
         QPixmap icon;
         if(_previews->getPreview(fileitem, icon, _focused))
             return icon;
     }
     return getIcon(fileitem, _focused, _fileIconSize);
 }
 
 /**
  * this function ADDs a list of selected item names into 'names'.
  * it assumes the list is ready and doesn't initialize it, or clears it
  */
-void KrView::getItemsByMask(QString mask, QStringList* names, bool dirs, bool files)
+void KrView::getItemsByMask(const QString& mask, QStringList* names, bool dirs, bool files)
 {
-    for (KrViewItem * it = getFirst(); it != 0; it = getNext(it)) {
+    for (KrViewItem * it = getFirst(); it != nullptr; it = getNext(it)) {
         if ((it->name() == "..") || !QDir::match(mask, it->name())) continue;
         // if we got here, than the item fits the mask
         if (it->getFileItem()->isDir() && !dirs) continue;   // do we need to skip folders?
         if (!it->getFileItem()->isDir() && !files) continue;   // do we need to skip files
         names->append(it->name());
     }
 }
 
 /**
  * this function ADDs a list of selected item names into 'names'.
  * it assumes the list is ready and doesn't initialize it, or clears it
  */
 void KrView::getSelectedItems(QStringList *names, bool fallbackToFocused)
 {
-    for (KrViewItem *it = getFirst(); it != 0; it = getNext(it))
+    for (KrViewItem *it = getFirst(); it != nullptr; it = getNext(it))
         if (it->isSelected() && (it->name() != ".."))
             names->append(it->name());
 
     if (fallbackToFocused) {
         // if all else fails, take the current item
         const QString item = getCurrentItem();
         if (names->empty() && !item.isEmpty() && item != "..") {
             names->append(item);
         }
     }
 }
 
 void KrView::getSelectedKrViewItems(KrViewItemList *items)
 {
-    for (KrViewItem * it = getFirst(); it != 0; it = getNext(it))
+    for (KrViewItem * it = getFirst(); it != nullptr; it = getNext(it))
         if (it->isSelected() && (it->name() != "..")) items->append(it);
 
     // if all else fails, take the current item
     QString item = getCurrentItem();
     if (items->empty() &&
             !item.isEmpty() &&
             item != ".." &&
-            getCurrentKrViewItem() != 0) {
+            getCurrentKrViewItem() != nullptr) {
         items->append(getCurrentKrViewItem());
     }
 }
 
 QString KrView::statistics()
 {
     KIO::filesize_t size = calcSize();
     KIO::filesize_t selectedSize = calcSelectedSize();
     QString tmp;
     KConfigGroup grp(_config, "Look&Feel");
     if(grp.readEntry("Show Size In Bytes", false)) {
         tmp = i18nc("%1=number of selected items,%2=total number of items, \
                     %3=filesize of selected items,%4=filesize in Bytes, \
                     %5=filesize of all items in folder,%6=filesize in Bytes",
                     "%1 out of %2, %3 (%4) out of %5 (%6)",
                     numSelected(), _count, KIO::convertSize(selectedSize),
                     KRpermHandler::parseSize(selectedSize),
                     KIO::convertSize(size),
                     KRpermHandler::parseSize(size));
     } else {
         tmp = i18nc("%1=number of selected items,%2=total number of items, \
                     %3=filesize of selected items,%4=filesize of all items in folder",
                     "%1 out of %2, %3 out of %4",
                     numSelected(), _count, KIO::convertSize(selectedSize),
                     KIO::convertSize(size));
     }
 
     // notify if we're running a filtered view
     if (filter() != KrViewProperties::All)
         tmp = ">> [ " + filterMask().nameFilter() + " ]  " + tmp;
     return tmp;
 }
 
 bool KrView::changeSelection(const KRQuery& filter, bool select)
 {
     KConfigGroup grpSvr(_config, "Look&Feel");
     return changeSelection(filter, select, grpSvr.readEntry("Mark Dirs", _MarkDirs), true);
 }
 
 bool KrView::changeSelection(const KRQuery& filter, bool select, bool includeDirs, bool makeVisible)
 {
     if (op()) op()->setMassSelectionUpdate(true);
 
     KrViewItem *temp = getCurrentKrViewItem();
-    KrViewItem *firstMatch = 0;
-    for (KrViewItem * it = getFirst(); it != 0; it = getNext(it)) {
+    KrViewItem *firstMatch = nullptr;
+    for (KrViewItem * it = getFirst(); it != nullptr; it = getNext(it)) {
         if (it->name() == "..")
             continue;
         if (it->getFileItem()->isDir() && !includeDirs)
             continue;
 
         FileItem * file = it->getMutableFileItem(); // filter::match calls getMimetype which isn't const
-        if (file == 0)
+        if (file == nullptr)
             continue;
 
         if (filter.match(file)) {
             it->setSelected(select);
             if (!firstMatch) firstMatch = it;
         }
     }
 
     if (op()) op()->setMassSelectionUpdate(false);
     updateView();
-    if (ensureVisibilityAfterSelect() && temp != 0) {
+    if (ensureVisibilityAfterSelect() && temp != nullptr) {
         makeItemVisible(temp);
-    } else if (makeVisible && firstMatch != 0) {
+    } else if (makeVisible && firstMatch != nullptr) {
         // if no selected item is visible...
         KrViewItemList selectedItems;
         getSelectedKrViewItems(&selectedItems);
         bool anyVisible = false;
         for (KrViewItem *item : selectedItems) {
             if (isItemVisible(item)) {
                 anyVisible = true;
                 break;
             }
         }
         if (!anyVisible) {
             // ...scroll to fist selected item
             makeItemVisible(firstMatch);
         }
     }
     redraw();
 
-    return firstMatch != 0; // return if any file was selected
+    return firstMatch != nullptr; // return if any file was selected
 }
 
 void KrView::invertSelection()
 {
     if (op()) op()->setMassSelectionUpdate(true);
     KConfigGroup grpSvr(_config, "Look&Feel");
     bool markDirs = grpSvr.readEntry("Mark Dirs", _MarkDirs);
 
     KrViewItem *temp = getCurrentKrViewItem();
-    for (KrViewItem * it = getFirst(); it != 0; it = getNext(it)) {
+    for (KrViewItem * it = getFirst(); it != nullptr; it = getNext(it)) {
         if (it->name() == "..")
             continue;
         if (it->getFileItem()->isDir() && !markDirs && !it->isSelected())
             continue;
         it->setSelected(!it->isSelected());
     }
     if (op()) op()->setMassSelectionUpdate(false);
     updateView();
-    if (ensureVisibilityAfterSelect() && temp != 0)
+    if (ensureVisibilityAfterSelect() && temp != nullptr)
         makeItemVisible(temp);
 }
 
 QString KrView::firstUnmarkedBelowCurrent(const bool skipCurrent)
 {
-    if (getCurrentKrViewItem() == 0)
+    if (getCurrentKrViewItem() == nullptr)
         return QString();
 
     KrViewItem *iterator = getCurrentKrViewItem();
     if (skipCurrent)
         iterator = getNext(iterator);
     while (iterator && iterator->isSelected())
         iterator = getNext(iterator);
     if (!iterator) {
         iterator = getPrev(getCurrentKrViewItem());
         while (iterator && iterator->isSelected())
             iterator = getPrev(iterator);
     }
     if (!iterator) return QString();
     return iterator->name();
 }
 
 void KrView::deleteItem(const QString &name, bool onUpdate)
 {
     KrViewItem *viewItem = findItemByName(name);
     if (!viewItem)
         return;
 
     if (_previews && !onUpdate)
         _previews->deletePreview(viewItem);
 
     preDeleteItem(viewItem);
 
     if (viewItem->FILEITEM->isDir()) {
         --_numDirs;
     }
 
     --_count;
     delete viewItem;
 
     if (!onUpdate)
         op()->emitSelectionChanged();
 }
 
 void KrView::addItem(FileItem *fileItem, bool onUpdate)
 {
     if (isFiltered(fileItem))
         return;
 
     KrViewItem *viewItem = preAddItem(fileItem);
     if (!viewItem)
         return; // not added
 
     if (_previews)
         _previews->updatePreview(viewItem);
 
     if (fileItem->isDir())
         ++_numDirs;
 
     ++_count;
 
     if (!onUpdate) {
         op()->emitSelectionChanged();
     }
 }
 
 void KrView::updateItem(FileItem *newFileItem)
 {
     // file name did not change
     const QString name = newFileItem->getName();
 
     // preserve 'current' and 'selection'
     const bool isCurrent = getCurrentItem() == name;
     QStringList selectedNames;
     getSelectedItems(&selectedNames, false);
     const bool isSelected = selectedNames.contains(name);
 
     // delete old file item
     deleteItem(name, true);
 
     if (!isFiltered(newFileItem)) {
         addItem(newFileItem, true);
     }
 
     if (isCurrent)
         setCurrentItem(name, false);
     if (isSelected)
         setSelected(newFileItem, true);
 
     op()->emitSelectionChanged();
 }
 
 void KrView::clear()
 {
     if(_previews)
         _previews->clear();
     _count = _numDirs = 0;
     delete _dummyFileItem;
-    _dummyFileItem = 0;
+    _dummyFileItem = nullptr;
     redraw();
 }
 
 bool KrView::handleKeyEvent(QKeyEvent *e)
 {
     qDebug() << "key event=" << e;
     switch (e->key()) {
     case Qt::Key_Enter :
     case Qt::Key_Return : {
         if (e->modifiers() & Qt::ControlModifier)
             // let the panel handle it
             e->ignore();
         else {
             KrViewItem * i = getCurrentKrViewItem();
-            if (i == 0)
+            if (i == nullptr)
                 return true;
             QString tmp = i->name();
             op()->emitExecuted(tmp);
         }
         return true;
     }
     case Qt::Key_QuoteLeft :
         // Terminal Emulator bugfix
         if (e->modifiers() == Qt::ControlModifier) {
             // let the panel handle it
             e->ignore();
         } else {
             // a normal click - do a lynx-like moving thing
             // ask krusader to move to the home directory
             op()->emitGoHome();
         }
         return true;
     case Qt::Key_Delete :
         // delete/trash the file (delete with alternative mode is a panel action)
         // allow only no modifier or KeypadModifier (i.e. Del on a Numeric Keypad)
         if ((e->modifiers() & ~Qt::KeypadModifier) == Qt::NoModifier) {
             op()->emitDefaultDeleteFiles();
         }
         return true;
     case Qt::Key_Insert: {
         KrViewItem * i = getCurrentKrViewItem();
         if (!i)
             return true;
         i->setSelected(!i->isSelected());
         if (KrSelectionMode::getSelectionHandler()->insertMovesDown()) {
             KrViewItem * next = getNext(i);
             if (next) {
                 setCurrentKrViewItem(next);
                 makeItemVisible(next);
             }
         }
         op()->emitSelectionChanged();
         return true;
     }
     case Qt::Key_Space: {
         KrViewItem * viewItem = getCurrentKrViewItem();
-        if (viewItem != 0) {
+        if (viewItem != nullptr) {
             viewItem->setSelected(!viewItem->isSelected());
 
             if (viewItem->getFileItem()->isDir() &&
                 KrSelectionMode::getSelectionHandler()->spaceCalculatesDiskSpace()) {
                 op()->emitQuickCalcSpace(viewItem);
             }
             if (KrSelectionMode::getSelectionHandler()->spaceMovesDown()) {
                 KrViewItem * next = getNext(viewItem);
                 if (next) {
                     setCurrentKrViewItem(next);
                     makeItemVisible(next);
                 }
             }
             op()->emitSelectionChanged();
         }
         return true;
     }
     case Qt::Key_Backspace :
             // Terminal Emulator bugfix
     case Qt::Key_Left :
         if (e->modifiers() == Qt::ControlModifier || e->modifiers() == Qt::ShiftModifier ||
                 e->modifiers() == Qt::AltModifier) {
             // let the panel handle it
             e->ignore();
         } else {
             // a normal click - do a lynx-like moving thing
             // ask krusader to move up a directory
             op()->emitDirUp();
         }
         return true; // safety
     case Qt::Key_Right :
         if (e->modifiers() == Qt::ControlModifier || e->modifiers() == Qt::ShiftModifier ||
                 e->modifiers() == Qt::AltModifier) {
             // let the panel handle it
             e->ignore();
         } else {
             // just a normal click - do a lynx-like moving thing
             KrViewItem *i = getCurrentKrViewItem();
             if (i)
                 op()->emitGoInside(i->name());
         }
         return true;
     case Qt::Key_Up :
         if (e->modifiers() == Qt::ControlModifier) {
             // let the panel handle it - jump to the Location Bar
             e->ignore();
         } else {
             KrViewItem *item = getCurrentKrViewItem();
             if (item) {
                 if (e->modifiers() == Qt::ShiftModifier) {
                     item->setSelected(!item->isSelected());
                     op()->emitSelectionChanged();
                 }
                 item = getPrev(item);
                 if (item) {
                     setCurrentKrViewItem(item);
                     makeItemVisible(item);
                 }
             }
         }
         return true;
     case Qt::Key_Down :
         if (e->modifiers() == Qt::ControlModifier || e->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {
             // let the panel handle it - jump to command line
             e->ignore();
         } else {
             KrViewItem *item = getCurrentKrViewItem();
             if (item) {
                 if (e->modifiers() == Qt::ShiftModifier) {
                     item->setSelected(!item->isSelected());
                     op()->emitSelectionChanged();
                 }
                 item = getNext(item);
                 if (item) {
                     setCurrentKrViewItem(item);
                     makeItemVisible(item);
                 }
             }
         }
         return true;
     case Qt::Key_Home: {
         if (e->modifiers() & Qt::ShiftModifier) {
             bool select = true;
             KrViewItem *pos = getCurrentKrViewItem();
-            if (pos == 0)
+            if (pos == nullptr)
                 pos = getLast();
             KrViewItem *item = getFirst();
             op()->setMassSelectionUpdate(true);
             while (item) {
                 item->setSelected(select);
                 if (item == pos)
                     select = false;
                 item = getNext(item);
             }
             op()->setMassSelectionUpdate(false);
         }
         KrViewItem * first = getFirst();
         if (first) {
             setCurrentKrViewItem(first);
             makeItemVisible(first);
         }
     }
     return true;
     case Qt::Key_End:
         if (e->modifiers() & Qt::ShiftModifier) {
             bool select = false;
             KrViewItem *pos = getCurrentKrViewItem();
-            if (pos == 0)
+            if (pos == nullptr)
                 pos = getFirst();
             op()->setMassSelectionUpdate(true);
             KrViewItem *item = getFirst();
             while (item) {
                 if (item == pos)
                     select = true;
                 item->setSelected(select);
                 item = getNext(item);
             }
             op()->setMassSelectionUpdate(false);
         } else {
             KrViewItem *last = getLast();
             if (last) {
                 setCurrentKrViewItem(last);
                 makeItemVisible(last);
             }
         }
         return true;
     case Qt::Key_PageDown: {
         KrViewItem * current = getCurrentKrViewItem();
         int downStep = itemsPerPage();
         while (downStep != 0 && current) {
             KrViewItem * newCurrent = getNext(current);
-            if (newCurrent == 0)
+            if (newCurrent == nullptr)
                 break;
             current = newCurrent;
             downStep--;
         }
         if (current) {
             setCurrentKrViewItem(current);
             makeItemVisible(current);
         }
         return true;
     }
     case Qt::Key_PageUp: {
         KrViewItem * current = getCurrentKrViewItem();
         int upStep = itemsPerPage();
         while (upStep != 0 && current) {
             KrViewItem * newCurrent = getPrev(current);
-            if (newCurrent == 0)
+            if (newCurrent == nullptr)
                 break;
             current = newCurrent;
             upStep--;
         }
         if (current) {
             setCurrentKrViewItem(current);
             makeItemVisible(current);
         }
         return true;
     }
     case Qt::Key_Escape:
         e->ignore();
         return true; // otherwise the selection gets lost??!??
                      // also it is needed by the panel
     case Qt::Key_A : // mark all
         if (e->modifiers() == Qt::ControlModifier) {
             //FIXME: shouldn't there also be a shortcut for unselecting everything ?
             selectAllIncludingDirs();
             return true;
         }
 #if __GNUC__ >= 7
         [[gnu::fallthrough]];
 #endif
     default:
         return false;
     }
     return false;
 }
 
 void KrView::zoomIn()
 {
     int idx = iconSizes.indexOf(_fileIconSize);
     if(idx >= 0 && (idx+1) < iconSizes.count())
         setFileIconSize(iconSizes[idx+1]);
 }
 
 void KrView::zoomOut()
 {
     int idx = iconSizes.indexOf(_fileIconSize);
     if(idx > 0)
         setFileIconSize(iconSizes[idx-1]);
 }
 
 void KrView::setFileIconSize(int size)
 {
     if(iconSizes.indexOf(size) < 0)
         return;
     _fileIconSize = size;
     if(_previews) {
         _previews->clear();
         _previews->update();
     }
     redraw();
     op()->emitRefreshActions();
 }
 
 int KrView::defaultFileIconSize()
 {
     KConfigGroup grpSvr(_config, _instance.name());
     return grpSvr.readEntry("IconSize", _FilelistIconSize).toInt();
 }
 
 void KrView::saveDefaultSettings(KrViewProperties::PropertyType properties)
 {
     saveSettings(KConfigGroup(_config, _instance.name()), properties);
     op()->emitRefreshActions();
 }
 
 void KrView::restoreDefaultSettings()
 {
     restoreSettings(KConfigGroup(_config, _instance.name()));
 }
 
 void KrView::saveSettings(KConfigGroup group, KrViewProperties::PropertyType properties)
 {
     if(properties & KrViewProperties::PropIconSize)
         group.writeEntry("IconSize", fileIconSize());
     if(properties & KrViewProperties::PropShowPreviews)
         group.writeEntry("ShowPreviews", previewsShown());
     if(properties & KrViewProperties::PropSortMode)
         saveSortMode(group);
     if(properties & KrViewProperties::PropFilter) {
         group.writeEntry("Filter", static_cast<int>(_properties->filter));
         group.writeEntry("FilterApplysToDirs", _properties->filterApplysToDirs);
         if(_properties->filterSettings.isValid())
             _properties->filterSettings.save(KConfigGroup(&group, "FilterSettings"));
     }
 }
 
-void KrView::restoreSettings(KConfigGroup group)
+void KrView::restoreSettings(const KConfigGroup& group)
 {
     _ignoreSettingsChange = true;
     doRestoreSettings(group);
     _ignoreSettingsChange = false;
     refresh();
 }
 
 void KrView::doRestoreSettings(KConfigGroup group)
 {
     restoreSortMode(group);
     setFileIconSize(group.readEntry("IconSize", defaultFileIconSize()));
     showPreviews(group.readEntry("ShowPreviews", false));
     _properties->filter = static_cast<KrViewProperties::FilterSpec>(group.readEntry("Filter",
                                                     static_cast<int>(KrViewProperties::All)));
     _properties->filterApplysToDirs = group.readEntry("FilterApplysToDirs", false);
     _properties->filterSettings.load(KConfigGroup(&group, "FilterSettings"));
     _properties->filterMask = _properties->filterSettings.toQuery();
 }
 
 void KrView::applySettingsToOthers()
 {
-    for(int i = 0; i < _instance.m_objects.length(); i++) {
-        KrView *view = _instance.m_objects[i];
+    for(auto view : _instance.m_objects) {
         if(this != view) {
             view->_ignoreSettingsChange = true;
             view->copySettingsFrom(this);
             view->_ignoreSettingsChange = false;
         }
     }
 }
 
 void KrView::sortModeUpdated(KrViewProperties::ColumnType sortColumn, bool descending)
 {
     if(sortColumn == _properties->sortColumn && descending == (bool) (_properties->sortOptions & KrViewProperties::Descending))
         return;
 
     int options = _properties->sortOptions;
     if(descending)
         options |= KrViewProperties::Descending;
     else
         options &= ~KrViewProperties::Descending;
     _properties->sortColumn = sortColumn;
     _properties->sortOptions = static_cast<KrViewProperties::SortOptions>(options);
 
     //     op()->settingsChanged(KrViewProperties::PropSortMode);
 }
 
 bool KrView::drawCurrent() const
 {
     return isFocused() ||
            KConfigGroup(_config, "Look&Feel")
                .readEntry("Always Show Current Item", _AlwaysShowCurrentItem);
 }
 
 void KrView::saveSortMode(KConfigGroup &group)
 {
     group.writeEntry("Sort Column", static_cast<int>(_properties->sortColumn));
     group.writeEntry("Descending Sort Order", _properties->sortOptions & KrViewProperties::Descending);
 }
 
 void KrView::restoreSortMode(KConfigGroup &group)
 {
     int column = group.readEntry("Sort Column", static_cast<int>(KrViewProperties::Name));
     bool isDescending = group.readEntry("Descending Sort Order", false);
     setSortMode(static_cast<KrViewProperties::ColumnType>(column), isDescending);
 }
 
 QString KrView::krPermissionText(const FileItem * fileitem)
 {
     QString tmp;
     switch (fileitem->isReadable()) {
     case ALLOWED_PERM: tmp+='r'; break;
     case UNKNOWN_PERM: tmp+='?'; break;
     case NO_PERM:      tmp+='-'; break;
     }
     switch (fileitem->isWriteable()) {
     case ALLOWED_PERM: tmp+='w'; break;
     case UNKNOWN_PERM: tmp+='?'; break;
     case NO_PERM:      tmp+='-'; break;
     }
     switch (fileitem->isExecutable()) {
     case ALLOWED_PERM: tmp+='x'; break;
     case UNKNOWN_PERM: tmp+='?'; break;
     case NO_PERM:      tmp+='-'; break;
     }
     return tmp;
 }
 
 QString KrView::permissionsText(const KrViewProperties *properties, const FileItem *fileItem)
 {
     return properties->numericPermissions ?
                QString().asprintf("%.4o", fileItem->getMode() & (S_ISUID | S_ISGID | S_ISVTX |
                                                                  S_IRWXU | S_IRWXG | S_IRWXO)) :
                fileItem->getPerm();
 }
 
 QString KrView::sizeText(const KrViewProperties *properties, KIO::filesize_t size)
 {
     return properties->humanReadableSize ? KIO::convertSize(size) : KRpermHandler::parseSize(size);
 }
 
 QString KrView::mimeTypeText(FileItem *fileItem)
 {
     QMimeType mt = QMimeDatabase().mimeTypeForName(fileItem->getMime());
     return mt.isValid() ? mt.comment() : QString();
 }
 
 bool KrView::isFiltered(FileItem *fileitem)
 {
     if (_quickFilterMask.isValid() && _quickFilterMask.indexIn(fileitem->getName()) == -1)
         return true;
 
     bool filteredOut = false;
     bool isDir = fileitem->isDir();
     if (!isDir || (isDir && properties()->filterApplysToDirs)) {
         switch (properties()->filter) {
         case KrViewProperties::All :
             break;
         case KrViewProperties::Custom :
             if (!properties()->filterMask.match(fileitem))
                 filteredOut = true;
             break;
         case KrViewProperties::Dirs:
             if (!isDir)
                 filteredOut = true;
             break;
         case KrViewProperties::Files:
             if (isDir)
                 filteredOut = true;
             break;
         default:
             break;
         }
     }
     return filteredOut;
 }
 
 void KrView::setFiles(DirListerInterface *files)
 {
     if(files != _files) {
         clear();
         if(_files)
-            QObject::disconnect(_files, 0, op(), 0);
+            QObject::disconnect(_files, nullptr, op(), nullptr);
         _files = files;
     }
 
     if(!_files)
         return;
 
-    QObject::disconnect(_files, 0, op(), 0);
+    QObject::disconnect(_files, nullptr, op(), nullptr);
     QObject::connect(_files, &DirListerInterface::scanDone, op(), &KrViewOperator::startUpdate);
     QObject::connect(_files, &DirListerInterface::cleared, op(), &KrViewOperator::cleared);
     QObject::connect(_files, &DirListerInterface::addedFileItem, op(), &KrViewOperator::fileAdded);
     QObject::connect(_files, &DirListerInterface::updatedFileItem, op(), &KrViewOperator::fileUpdated);
 }
 
-void KrView::setFilter(KrViewProperties::FilterSpec filter, FilterSettings customFilter, bool applyToDirs)
+void KrView::setFilter(KrViewProperties::FilterSpec filter, const FilterSettings& customFilter, bool applyToDirs)
 {
     _properties->filter = filter;
     _properties->filterSettings = customFilter;
     _properties->filterMask = customFilter.toQuery();
     _properties->filterApplysToDirs = applyToDirs;
     refresh();
 }
 
 void KrView::setFilter(KrViewProperties::FilterSpec filter)
 {
 
     KConfigGroup cfg(_config, "Look&Feel");
     bool rememberSettings = cfg.readEntry("FilterDialogRemembersSettings", _FilterDialogRemembersSettings);
     bool applyToDirs = rememberSettings ? _properties->filterApplysToDirs : false;
     switch (filter) {
     case KrViewProperties::All :
         break;
     case KrViewProperties::Custom :
         {
             FilterDialog dialog(_widget, i18n("Filter Files"), QStringList(i18n("Apply filter to folders")), false);
             dialog.checkExtraOption(i18n("Apply filter to folders"), applyToDirs);
             if(rememberSettings)
                 dialog.applySettings(_properties->filterSettings);
             dialog.exec();
             FilterSettings s(dialog.getSettings());
             if(!s.isValid()) // if the user canceled - quit
                 return;
             _properties->filterSettings = s;
             _properties->filterMask = s.toQuery();
             applyToDirs = dialog.isExtraOptionChecked(i18n("Apply filter to folders"));
         }
         break;
     default:
         return;
     }
     _properties->filterApplysToDirs = applyToDirs;
     _properties->filter = filter;
     refresh();
 }
 
 void KrView::customSelection(bool select)
 {
     KConfigGroup grpSvr(_config, "Look&Feel");
     bool includeDirs = grpSvr.readEntry("Mark Dirs", _MarkDirs);
 
-    FilterDialog dialog(0, i18n("Select Files"), QStringList(i18n("Apply selection to folders")), false);
+    FilterDialog dialog(nullptr, i18n("Select Files"), QStringList(i18n("Apply selection to folders")), false);
     dialog.checkExtraOption(i18n("Apply selection to folders"), includeDirs);
     dialog.exec();
     KRQuery query = dialog.getQuery();
     // if the user canceled - quit
     if (query.isNull())
         return;
     includeDirs = dialog.isExtraOptionChecked(i18n("Apply selection to folders"));
 
     changeSelection(query, select, includeDirs);
 }
 
 void KrView::refresh()
 {
     const QString currentItem = !nameToMakeCurrent().isEmpty() ? //
                                     nameToMakeCurrent() :
                                     getCurrentItem();
     bool scrollToCurrent = !nameToMakeCurrent().isEmpty() || isItemVisible(getCurrentKrViewItem());
     setNameToMakeCurrent(QString());
 
     const QModelIndex currentIndex = getCurrentIndex();
     const QList<QUrl> selection = selectedUrls();
 
     clear();
 
     if(!_files)
         return;
 
     QList<FileItem*> fileItems;
 
     // if we are not at the root add the ".." entry
     if(!_files->isRoot()) {
         _dummyFileItem = FileItem::createDummy();
         fileItems << _dummyFileItem;
     }
 
     foreach(FileItem *fileitem, _files->fileItems()) {
         if(!fileitem || isFiltered(fileitem))
             continue;
         if(fileitem->isDir())
             _numDirs++;
         _count++;
         fileItems << fileitem;
     }
 
     populate(fileItems, _dummyFileItem);
 
     if(!selection.isEmpty())
         setSelectionUrls(selection);
 
     if (!currentItem.isEmpty()) {
         if (currentItem == ".." && _count > 0 && //
             !_quickFilterMask.isEmpty() && _quickFilterMask.isValid()) {
             // In a filtered view we should never select the dummy entry if
             // there are real matches.
             setCurrentKrViewItem(getNext(getFirst()));
         } else {
             setCurrentItem(currentItem, scrollToCurrent, currentIndex);
         }
     } else {
         setCurrentKrViewItem(getFirst());
     }
 
     updatePreviews();
     redraw();
 
     op()->emitSelectionChanged();
 }
 
 void KrView::setSelected(const FileItem* fileitem, bool select)
 {
     if (fileitem == _dummyFileItem)
         return;
 
     if (select)
         clearSavedSelection();
     intSetSelected(fileitem, select);
 }
 
 void KrView::saveSelection()
 {
     _savedSelection = selectedUrls();
     op()->emitRefreshActions();
 }
 
 void KrView::restoreSelection()
 {
     if(canRestoreSelection())
         setSelectionUrls(_savedSelection);
 }
 
 void KrView::clearSavedSelection() {
     _savedSelection.clear();
     op()->emitRefreshActions();
 }
 
 void KrView::markSameBaseName()
 {
     KrViewItem* item = getCurrentKrViewItem();
     if (!item)
         return;
     KRQuery query(QString("%1.*").arg(item->name(false)));
     changeSelection(query, true, false);
 }
 
 void KrView::markSameExtension()
 {
     KrViewItem* item = getCurrentKrViewItem();
     if (!item)
         return;
     KRQuery query(QString("*.%1").arg(item->extension()));
     changeSelection(query, true, false);
 }
diff --git a/krusader/Panel/PanelView/krview.h b/krusader/Panel/PanelView/krview.h
index d1781123..b0ac3ffa 100644
--- a/krusader/Panel/PanelView/krview.h
+++ b/krusader/Panel/PanelView/krview.h
@@ -1,384 +1,385 @@
 /*****************************************************************************
  * Copyright (C) 2000-2002 Shie Erlich <krusader@users.sourceforge.net>      *
  * Copyright (C) 2000-2002 Rafi Yanai <krusader@users.sourceforge.net>       *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRVIEW_H
 #define KRVIEW_H
 
 // QtCore
 #include <QHash>
 #include <QList>
 #include <QModelIndex>
 #include <QRegExp>
 #include <QTimer>
 #include <QVariant>
 // QtGui
 #include <QDropEvent>
 #include <QPixmap>
+#include <utility>
 
 #include "krviewproperties.h"
 
 class KrView;
 class KrViewItem;
 class KrPreviews;
 class KrViewInstance;
 class DirListerInterface;
 
 typedef QList<KrViewItem *> KrViewItemList;
 
 // operator can handle two ways of doing things:
 // 1. if the view is a widget (inherits krview and klistview for example)
 // 2. if the view HAS A widget (a krview-son has a member of klistview)
 // this is done by specifying the view and the widget in the constructor,
 // even if they are actually the same object (specify it twice in that case)
 class KrViewOperator : public QObject
 {
     Q_OBJECT
 public:
     KrViewOperator(KrView *view, QWidget *widget);
-    ~KrViewOperator();
+    ~KrViewOperator() override;
 
     KrView *view() const { return _view; }
     QWidget *widget() const { return _widget; }
     void startDrag();
 
     void emitGotDrop(QDropEvent *e) { emit gotDrop(e); }
-    void emitLetsDrag(QStringList items, QPixmap icon) { emit letsDrag(items, icon); }
+    void emitLetsDrag(QStringList items, const QPixmap& icon) { emit letsDrag(std::move(items), icon); }
     void emitItemDescription(const QString &desc) { emit itemDescription(desc); }
     void emitContextMenu(const QPoint &point) { emit contextMenu(point); }
     void emitEmptyContextMenu(const QPoint &point) { emit emptyContextMenu(point); }
     void emitRenameItem(const QString &oldName, const QString &newName) {
         emit renameItem(oldName, newName);
     }
     void emitExecuted(const QString &name) { emit executed(name); }
     void emitGoInside(const QString &name) { emit goInside(name); }
     void emitNeedFocus() { emit needFocus(); }
     void emitMiddleButtonClicked(KrViewItem *item) { emit middleButtonClicked(item); }
     void emitCurrentChanged(KrViewItem *item) { emit currentChanged(item); }
     void emitPreviewJobStarted(KJob *job) { emit previewJobStarted(job); }
     void emitGoHome() { emit goHome(); }
     void emitDirUp() { emit dirUp(); }
     void emitQuickCalcSpace(KrViewItem *item) { emit quickCalcSpace(item); }
     void emitDefaultDeleteFiles() { emit defaultDeleteFiles(); }
     void emitRefreshActions() { emit refreshActions(); }
     void emitGoBack() { emit goBack(); }
     void emitGoForward() { emit goForward(); }
 
     /**
      * Search for an item by file name beginning at the current cursor position and set the
      * cursor to it.
      *
      * @param text file name to search for, can be regex
      * @param caseSensitive whether the search is case sensitive
      * @param direction @c 0 is for forward, @c 1 is for backward
      * @return true if there is a next/previous item matching the text, else false
      */
     bool searchItem(const QString &text, bool caseSensitive, int direction = 0);
     /**
      * Filter view items.
      */
     bool filterSearch(const QString &, bool);
     void setMassSelectionUpdate(bool upd);
     bool isMassSelectionUpdate() { return _massSelectionUpdate; }
     void settingsChanged(KrViewProperties::PropertyType properties);
 
 public slots:
     void emitSelectionChanged() {
         if (!_massSelectionUpdate)
             emit selectionChanged();
     }
 
     void startUpdate();
     void cleared();
     void fileAdded(FileItem *fileitem);
     void fileUpdated(FileItem *newFileitem);
 
 signals:
     void selectionChanged();
     void gotDrop(QDropEvent *e);
     void letsDrag(QStringList items, QPixmap icon);
     void itemDescription(const QString &desc);
     void contextMenu(const QPoint &point);
     void emptyContextMenu(const QPoint &point);
     void renameItem(const QString &oldName, const QString &newName);
     void executed(const QString &name);
     void goInside(const QString &name);
     void needFocus();
     void middleButtonClicked(KrViewItem *item);
     void currentChanged(KrViewItem *item);
     void previewJobStarted(KJob *job);
     void goHome();
     void defaultDeleteFiles();
     void dirUp();
     void quickCalcSpace(KrViewItem *item);
     void refreshActions();
     void goBack();
     void goForward();
 
 protected slots:
     void saveDefaultSettings();
 
 protected:
     // never delete those
     KrView *_view;
     QWidget *_widget;
 
 private:
     bool _massSelectionUpdate;
     QTimer _saveDefaultSettingsTimer;
     static KrViewProperties::PropertyType _changedProperties;
     static KrView *_changedView;
 };
 
 /****************************************************************************
  * READ THIS FIRST: Using the view
  *
  * You always hold a pointer to KrView, thus you can only use functions declared
  * in this class. If you need something else, either this class is missing something
  * or you are ;-)
  *
  * The functions you'd usually want:
  * 1) getSelectedItems - returns all selected items, or (if none) the current item.
  *    it never returns anything which includes the "..", and thus can return an empty list!
  * 2) getSelectedKrViewItems - the same as (1), but returns a QValueList with KrViewItems
  * 3) getCurrentItem, setCurrentItem - work with QString
  * 4) getFirst, getNext, getPrev, getCurrentKrViewItem - all work with KrViewItems, and
  *    used to iterate through a list of items. note that getNext and getPrev accept a pointer
  *    to the current item (used in detailedview for safe iterating), thus your loop should be:
  *       for (KrViewItem *it = view->getFirst(); it!=0; it = view->getNext(it)) { blah; }
  * 5) nameToMakeCurrent(), setNameToMakeCurrent() - work with QString
  *
  * IMPORTANT NOTE: every one who subclasses this must call initProperties() in the constructor !!!
  */
 class KrView
 {
     friend class KrViewItem;
     friend class KrViewOperator;
 
 public:
     class IconSizes : public QVector<int>
     {
       public:
-        IconSizes() : QVector<int>() { *this << 12 << 16 << 22 << 32 << 48 << 64 << 128 << 256; }
+        IconSizes() { *this << 12 << 16 << 22 << 32 << 48 << 64 << 128 << 256; }
     };
 
     // instantiating a new view
     // 1. new KrView
     // 2. view->init()
     // notes: constructor does as little as possible, setup() does the rest. esp, note that
     // if you need something from operator or properties, move it into setup()
     void init(bool enableUpdateDefaultSettings = true);
     KrViewInstance *instance() { return &_instance; }
     static const IconSizes iconSizes;
 
 protected:
     void initProperties();
     KrViewOperator *createOperator() { return new KrViewOperator(this, _widget); }
     virtual void setup() = 0;
 
     ///////////////////////////////////////////////////////
     // Every view must implement the following functions //
     ///////////////////////////////////////////////////////
 public:
     // interview related functions
     virtual QModelIndex getCurrentIndex() = 0;
     virtual bool isSelected(const QModelIndex &) = 0;
     virtual bool ensureVisibilityAfterSelect() = 0;
     virtual void selectRegion(KrViewItem *, KrViewItem *, bool) = 0;
 
     virtual uint numSelected() const = 0;
     virtual QList<QUrl> selectedUrls() = 0;
     virtual void setSelectionUrls(const QList<QUrl> urls) = 0;
     virtual KrViewItem *getFirst() = 0;
     virtual KrViewItem *getLast() = 0;
     virtual KrViewItem *getNext(KrViewItem *current) = 0;
     virtual KrViewItem *getPrev(KrViewItem *current) = 0;
     virtual KrViewItem *getCurrentKrViewItem() = 0;
     virtual KrViewItem *getKrViewItemAt(const QPoint &vp) = 0;
     virtual KrViewItem *findItemByName(const QString &name) = 0;
     virtual KrViewItem *findItemByUrl(const QUrl &url) = 0;
     virtual QString getCurrentItem() const = 0;
     virtual void setCurrentItem(const QString &name, bool scrollToCurrent = true,
                                 const QModelIndex &fallbackToIndex = QModelIndex()) = 0;
     virtual void setCurrentKrViewItem(KrViewItem *item, bool scrollToCurrent = true) = 0;
     virtual void makeItemVisible(const KrViewItem *item) = 0;
     virtual bool isItemVisible(const KrViewItem *item) = 0;
     virtual void updateView() = 0;
     virtual void sort() = 0;
     virtual void refreshColors() = 0;
     virtual void redraw() = 0;
     virtual bool handleKeyEvent(QKeyEvent *e);
     virtual void prepareForActive() = 0;
     virtual void prepareForPassive() = 0;
     virtual void renameCurrentItem() = 0; // Rename current item. returns immediately
     virtual int itemsPerPage() = 0;
     virtual void showContextMenu(const QPoint &point = QPoint(0, 0)) = 0;
 
 protected:
     virtual KrViewItem *preAddItem(FileItem *fileitem) = 0;
     virtual void preDeleteItem(KrViewItem *item) = 0;
     virtual void copySettingsFrom(KrView *other) = 0;
     virtual void populate(const QList<FileItem *> &fileItems, FileItem *dummy) = 0;
     virtual void intSetSelected(const FileItem *fileitem, bool select) = 0;
     virtual void clear();
 
 
     void addItem(FileItem *fileItem, bool onUpdate = false);
     void deleteItem(const QString &name, bool onUpdate = false);
     void updateItem(FileItem *newFileItem);
 
 public:
     //////////////////////////////////////////////////////
     // the following functions are already implemented, //
     // and normally - should NOT be re-implemented.     //
     //////////////////////////////////////////////////////
     uint numFiles() const { return _count - _numDirs; }
     uint numDirs() const { return _numDirs; }
     uint count() const { return _count; }
     void getSelectedItems(QStringList *names, bool fallbackToFocused = true);
-    void getItemsByMask(QString mask, QStringList *names, bool dirs = true, bool files = true);
+    void getItemsByMask(const QString& mask, QStringList *names, bool dirs = true, bool files = true);
     void getSelectedKrViewItems(KrViewItemList *items);
     void selectAllIncludingDirs() { changeSelection(KRQuery("*"), true, true); }
     void select(const KRQuery &filter = KRQuery("*")) { changeSelection(filter, true); }
     void unselect(const KRQuery &filter = KRQuery("*")) { changeSelection(filter, false); }
     void unselectAll() { changeSelection(KRQuery("*"), false, true); }
     void invertSelection();
     QString nameToMakeCurrent() const { return _nameToMakeCurrent; }
-    void setNameToMakeCurrent(const QString name) { _nameToMakeCurrent = name; }
+    void setNameToMakeCurrent(const QString& name) { _nameToMakeCurrent = name; }
     QString firstUnmarkedBelowCurrent(const bool skipCurrent);
     QString statistics();
     const KrViewProperties *properties() const { return _properties; }
     KrViewOperator *op() const { return _operator; }
     void showPreviews(bool show);
-    bool previewsShown() { return _previews != 0; }
+    bool previewsShown() { return _previews != nullptr; }
     void applySettingsToOthers();
 
     void setFiles(DirListerInterface *files);
 
     /**
      * Refresh the file view items after the underlying file model changed.
      *
      * Tries to preserve current file and file selection if applicable.
      */
     void refresh();
 
     bool changeSelection(const KRQuery &filter, bool select);
     bool changeSelection(const KRQuery &filter, bool select, bool includeDirs,
                          bool makeVisible = false);
     bool isFiltered(FileItem *fileitem);
     void setSelected(const FileItem *fileitem, bool select);
 
     /////////////////////////////////////////////////////////////
     // the following functions have a default and minimalistic //
     // implementation, and may be re-implemented if needed     //
     /////////////////////////////////////////////////////////////
     virtual void setSortMode(KrViewProperties::ColumnType sortColumn, bool descending) {
         sortModeUpdated(sortColumn, descending);
     }
     const KRQuery &filterMask() const { return _properties->filterMask; }
     KrViewProperties::FilterSpec filter() const { return _properties->filter; }
     void setFilter(KrViewProperties::FilterSpec filter);
-    void setFilter(KrViewProperties::FilterSpec filter, FilterSettings customFilter,
+    void setFilter(KrViewProperties::FilterSpec filter, const FilterSettings& customFilter,
                    bool applyToDirs);
     void customSelection(bool select);
     int defaultFileIconSize();
     virtual void setFileIconSize(int size);
     void setDefaultFileIconSize() { setFileIconSize(defaultFileIconSize()); }
     void zoomIn();
     void zoomOut();
 
     // save this view's settings to be restored after restart
     virtual void
     saveSettings(KConfigGroup grp,
                  KrViewProperties::PropertyType properties = KrViewProperties::AllProperties);
 
     inline QWidget *widget() { return _widget; }
     inline int fileIconSize() const { return _fileIconSize; }
     inline bool isFocused() const { return _focused; }
 
     QPixmap getIcon(FileItem *fileitem);
 
     void setMainWindow(QWidget *mainWindow) { _mainWindow = mainWindow; }
 
     // save this view's settings as default for new views of this type
     void saveDefaultSettings(
         KrViewProperties::PropertyType properties = KrViewProperties::AllProperties);
     // restore the default settings for this view type
     void restoreDefaultSettings();
     // call this to restore this view's settings after restart
-    void restoreSettings(KConfigGroup grp);
+    void restoreSettings(const KConfigGroup& grp);
 
     void saveSelection();
     void restoreSelection();
     bool canRestoreSelection() { return !_savedSelection.isEmpty(); }
     void clearSavedSelection();
 
     void markSameBaseName();
     void markSameExtension();
 
     // todo: what about selection modes ???
     virtual ~KrView();
 
     static QPixmap getIcon(FileItem *fileitem, bool active, int size = 0);
     static QPixmap processIcon(const QPixmap &icon, bool dim, const QColor &dimColor, int dimFactor,
                                bool symlink);
 
     // Get GUI strings for file item properties
     static QString krPermissionText(const FileItem *fileitem);
     static QString permissionsText(const KrViewProperties *properties, const FileItem *fileItem);
     static QString sizeText(const KrViewProperties *properties, KIO::filesize_t size);
     static QString mimeTypeText(FileItem *fileItem);
 
 protected:
     KrView(KrViewInstance &instance, KConfig *cfg);
 
     virtual void doRestoreSettings(KConfigGroup grp);
     virtual KIO::filesize_t calcSize() = 0;
     virtual KIO::filesize_t calcSelectedSize() = 0;
     void sortModeUpdated(KrViewProperties::ColumnType sortColumn, bool descending);
     inline void setWidget(QWidget *w) { _widget = w; }
     bool drawCurrent() const;
 
     KConfig *_config;
     KrViewProperties *_properties;
     KrViewOperator *_operator;
     bool _focused;
     int _fileIconSize;
 
 private:
     void updatePreviews();
     void saveSortMode(KConfigGroup &group);
     void restoreSortMode(KConfigGroup &group);
 
     KrViewInstance &_instance;
     DirListerInterface *_files;
     QWidget *_mainWindow;
     QWidget *_widget;
     QList<QUrl> _savedSelection;
     QString _nameToMakeCurrent;
     KrPreviews *_previews;
     bool _updateDefaultSettings;
     bool _ignoreSettingsChange;
     QRegExp _quickFilterMask;
     uint _count, _numDirs;
     FileItem *_dummyFileItem;
 };
 
 #endif /* KRVIEW_H */
diff --git a/krusader/Panel/PanelView/krviewfactory.cpp b/krusader/Panel/PanelView/krviewfactory.cpp
index 037f9280..656783c1 100644
--- a/krusader/Panel/PanelView/krviewfactory.cpp
+++ b/krusader/Panel/PanelView/krviewfactory.cpp
@@ -1,107 +1,107 @@
 /*****************************************************************************
  * Copyright (C) 2000-2007 Shie Erlich <krusader@users.sourceforge.net>      *
  * Copyright (C) 2000-2007 Rafi Yanai <krusader@users.sourceforge.net>       *
  * Copyright (C) 2000-2007 Csaba Karai <krusader@users.sourceforge.net>      *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krviewfactory.h"
 
 #include "krinterdetailedview.h"
 #include "krinterbriefview.h"
 
 #include <stdio.h>
 
 #include <KI18n/KLocalizedString>
 
 KrViewInstance::KrViewInstance(int id, const QString &name, const QString &desc,
                                const QString &iconName, const QKeySequence &shortcut)
     : m_id(id), m_name(name), m_description(desc), m_iconName(iconName), m_shortcut(shortcut)
 {
 }
 
 template <typename T>
 class KrViewInstanceImpl : public KrViewInstance
 {
   public:
     KrViewInstanceImpl(int id, const QString &name, const QString &desc, const QString &icon,
                        const QKeySequence &shortcut)
         : KrViewInstance(id, name, desc, icon, shortcut) {}
 
-    virtual KrView *create(QWidget *w, KConfig *cfg) Q_DECL_OVERRIDE {
+    KrView *create(QWidget *w, KConfig *cfg) Q_DECL_OVERRIDE {
         return new T(w, *this, cfg);
     }
 };
 
 KrViewFactory::KrViewFactory() : m_defaultViewId(-1) {}
 
 // static initialization, on first use idiom
 KrViewFactory &KrViewFactory::self()
 {
-    static KrViewFactory *factory = 0;
+    static KrViewFactory *factory = nullptr;
     if (!factory) {
         factory = new KrViewFactory();
         factory->init();
     }
     return *factory;
 }
 
 void KrViewFactory::init()
 {
     registerView(new KrViewInstanceImpl<KrInterDetailedView> (0, "KrInterDetailedView",
         i18n("&Detailed View"), "view-list-details", Qt::ALT + Qt::SHIFT + Qt::Key_D));
 
     registerView(new KrViewInstanceImpl<KrInterBriefView> (1, "KrInterBriefView",
         i18n("&Brief View"), "view-list-icons", Qt::ALT + Qt::SHIFT + Qt::Key_B));
 }
 
 KrView *KrViewFactory::createView(int id, QWidget *widget, KConfig *cfg)
 {
     return self().viewInstance(id)->create(widget, cfg);
 }
 
 void KrViewFactory::registerView(KrViewInstance *inst)
 {
     int position = 0;
 
     while (position < m_registeredViews.count()) {
         if (m_registeredViews[position]->id() > inst->id())
             break;
         position++;
     }
 
     m_registeredViews.insert(m_registeredViews.begin() + position, inst);
     if (m_defaultViewId == -1 || inst->id() < m_defaultViewId)
         m_defaultViewId = inst->id();
 }
 
 KrViewInstance *KrViewFactory::viewInstance(int id)
 {
     foreach (KrViewInstance *inst, m_registeredViews) {
         if (inst->id() == id)
             return inst;
     }
 
     foreach (KrViewInstance *inst_dflt, m_registeredViews) {
         if (inst_dflt->id() == m_defaultViewId)
             return inst_dflt;
     }
 
     fprintf(stderr, "Internal Error: no views registered!\n");
     exit(-1);
 }
diff --git a/krusader/Panel/PanelView/krviewitem.cpp b/krusader/Panel/PanelView/krviewitem.cpp
index e5e5db80..699e6e7a 100644
--- a/krusader/Panel/PanelView/krviewitem.cpp
+++ b/krusader/Panel/PanelView/krviewitem.cpp
@@ -1,150 +1,148 @@
 /*****************************************************************************
  * Copyright (C) 2000-2002 Shie Erlich <erlich@users.sourceforge.net>        *
  * Copyright (C) 2000-2002 Rafi Yanai <yanai@users.sourceforge.net>          *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krviewitem.h"
 
 #include "krinterview.h"
 #include "listmodel.h"
 #include "../FileSystem/fileitem.h"
 #include "../FileSystem/krpermhandler.h"
 
 // QtCore
 #include <QLocale>
 #include <QMimeDatabase>
 #include <QMimeType>
 // QtGui
 #include <QPixmap>
 
 #include <KI18n/KLocalizedString>
 
 KrViewItem::KrViewItem(FileItem *fileitem, KrInterView *parentView):
         _fileitem(fileitem), _view(parentView), _viewProperties(parentView->properties()), _hasExtension(false),
         _hidden(false), _extension("")
 {
     dummyFileItem = parentView->_model->dummyFileItem() == fileitem;
 
     if (fileitem) {
         // check if the file has an extension
         const QString& fileitemName = fileitem->getName();
         int loc = fileitemName.lastIndexOf('.');
         if (loc > 0) { // avoid mishandling of .bashrc and friend
             // check if it has one of the predefined 'atomic extensions'
-            for (QStringList::const_iterator i = _viewProperties->atomicExtensions.begin();
-                 i != _viewProperties->atomicExtensions.end();
-                 ++i) {
-                if (fileitemName.endsWith(*i)) {
-                    loc = fileitemName.length() - (*i).length();
+            for (const auto & atomicExtension : _viewProperties->atomicExtensions) {
+                if (fileitemName.endsWith(atomicExtension)) {
+                    loc = fileitemName.length() - atomicExtension.length();
                     break;
                 }
             }
             _name = fileitemName.left(loc);
             _extension = fileitemName.mid(loc + 1);
             _hasExtension = true;
         }
 
         if (fileitemName.startsWith('.'))
             _hidden = true;
     }
 }
 
 const QString& KrViewItem::name(bool withExtension) const
 {
     if (!withExtension && _hasExtension) return _name;
     else return _fileitem->getName();
 }
 
 QString KrViewItem::description() const
 {
     if (dummyFileItem)
         return i18n("Climb up the folder tree");
 
     // else is implied
 
     QString mimeTypeComment;
     QMimeType mt = QMimeDatabase().mimeTypeForName(_fileitem->getMime());
     if (mt.isValid())
         mimeTypeComment = mt.comment();
 
     QString text = _fileitem->getName();
     if (_fileitem->isSymLink()) {
         text += " -> " + _fileitem->getSymDest() + "  ";
         if (_fileitem->isBrokenLink())
             text += i18n("(Broken Link)");
         else if (mimeTypeComment.isEmpty())
             text += i18n("Symbolic Link");
         else
             text += i18n("%1 (Link)", mimeTypeComment);
 
     } else {
         if (_fileitem->isDir())
             text += '/';
 
         if (_fileitem->getUISize() != (KIO::filesize_t)-1) {
             const QString size = KrView::sizeText(_viewProperties, _fileitem->getUISize());
             text += QString("  (%1)").arg(size);
         }
 
         text += "  " + mimeTypeComment;
     }
     return text;
 }
 
 QPixmap KrViewItem::icon()
 {
 #if 0
     QPixmap *p;
 
     // This is bad - very bad. the function must return a valid reference,
     // This is an interface flow - shie please fix it with a function that return QPixmap*
     // this way we can return 0 - and do our error checking...
 
     // shie answers: why? what's the difference? if we return an empty pixmap, others can use it as it
     // is, without worrying or needing to do error checking. empty pixmap displays nothing
 #endif
     if (dummyFileItem || !_viewProperties->displayIcons)
         return QPixmap();
     else return KrView::getIcon(_fileitem, true);
 }
 
 bool KrViewItem::isSelected() const {
     return _view->isSelected(_fileitem);
 }
 
 void KrViewItem::setSelected(bool s) {
     _view->setSelected(_fileitem, s);
     if(!_view->op()->isMassSelectionUpdate()) {
         redraw();
         _view->op()->emitSelectionChanged();
     }
 }
 
 QRect KrViewItem::itemRect() const {
     return _view->itemRect(_fileitem);
 }
 
 void KrViewItem::redraw() {
     _view->_itemView->viewport()->update(itemRect());
 }
 
 void KrViewItem::setSize(KIO::filesize_t size)
 {
     _fileitem->setSize(size);
 }
diff --git a/krusader/Panel/PanelView/krviewitemdelegate.cpp b/krusader/Panel/PanelView/krviewitemdelegate.cpp
index 70da91ed..3bdcf6c5 100644
--- a/krusader/Panel/PanelView/krviewitemdelegate.cpp
+++ b/krusader/Panel/PanelView/krviewitemdelegate.cpp
@@ -1,153 +1,153 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krviewitemdelegate.h"
 
 #include "krviewproperties.h"
 #include "../krglobal.h"
 #include "../listpanel.h"
 
 // QtGui
 #include <QKeyEvent>
 #include <QPainter>
 // QtWidgets
 #include <QDialog>
 #include <QApplication>
 #include <QLineEdit>
 
 #include <KConfigCore/KSharedConfig>
 
 KrViewItemDelegate::KrViewItemDelegate(QObject *parent) :
         QItemDelegate(parent), _currentlyEdited(-1), _dontDraw(false) {}
 
 void KrViewItemDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     QStyleOptionViewItem opt = option;
     opt.state &= ~QStyle::State_Selected;
     _dontDraw = (_currentlyEdited == index.row()) && (index.column() == KrViewProperties::Ext);
     QItemDelegate::paint(painter, opt, index);
 }
 
 void KrViewItemDelegate::drawDisplay(QPainter * painter, const QStyleOptionViewItem & option, const QRect & rect, const QString & text) const
 {
     if (!_dontDraw)
         QItemDelegate::drawDisplay(painter, option, rect, text);
 }
 
 QWidget * KrViewItemDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &sovi, const QModelIndex &index) const
 {
     _currentlyEdited = index.row();
     return QItemDelegate::createEditor(parent, sovi, index);
 }
 
 void KrViewItemDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
 {
     QItemDelegate::setEditorData(editor, index);
-    QLineEdit *lineEdit = qobject_cast<QLineEdit *> (editor);
+    auto *lineEdit = qobject_cast<QLineEdit *> (editor);
     if (lineEdit) {
         KConfigGroup gl(krConfig, "Look&Feel");
         QFont font = index.data(Qt::FontRole).value<QFont>();
         lineEdit->setFont(font);
         if (gl.readEntry("Rename Selects Extension", true))
             lineEdit->selectAll();
         else {
             QString nameWithoutExt = index.data(Qt::UserRole).toString();
             lineEdit->deselect();
             lineEdit->setSelection(0, nameWithoutExt.length());
         }
     }
 }
 
 QSize KrViewItemDelegate::sizeHint(const QStyleOptionViewItem & option, const QModelIndex & index) const
 {
     QSize size = QItemDelegate::sizeHint(option, index);
     if (size.isEmpty()) {
         // prevent items without text from bloating the view vertically
         return QSize(0, 0);
     }
     return size;
 }
 
 bool KrViewItemDelegate::eventFilter(QObject *object, QEvent *event)
 {
     QWidget *editor = qobject_cast<QWidget*>(object);
     if (!editor)
         return false;
     if (event->type() == QEvent::KeyPress) {
-        switch (static_cast<QKeyEvent *>(event)->key()) {
+        switch (dynamic_cast<QKeyEvent *>(event)->key()) {
         case Qt::Key_Tab:
         case Qt::Key_Backtab:
             _currentlyEdited = -1;
             emit closeEditor(editor, QAbstractItemDelegate::RevertModelCache);
             return true;
         case Qt::Key_Enter:
         case Qt::Key_Return:
-            if (QLineEdit *e = qobject_cast<QLineEdit*>(editor)) {
+            if (auto *e = qobject_cast<QLineEdit*>(editor)) {
                 if (!e->hasAcceptableInput())
                     return true;
                 event->accept();
                 emit commitData(editor);
                 emit closeEditor(editor, QAbstractItemDelegate::SubmitModelCache);
                 _currentlyEdited = -1;
                 return true;
             }
             return false;
         case Qt::Key_Escape:
             event->accept();
             // don't commit data
             _currentlyEdited = -1;
             emit closeEditor(editor, QAbstractItemDelegate::RevertModelCache);
             break;
         default:
             return false;
         }
 
         if (editor->parentWidget())
             editor->parentWidget()->setFocus();
         return true;
     } else if (event->type() == QEvent::FocusOut) {
         if (!editor->isActiveWindow() || (QApplication::focusWidget() != editor)) {
             QWidget *w = QApplication::focusWidget();
             while (w) { // don't worry about focus changes internally in the editor
                 if (w == editor)
                     return false;
                 w = w->parentWidget();
             }
             // Opening a modal dialog will start a new eventloop
             // that will process the deleteLater event.
             if (QApplication::activeModalWidget()
                     && !QApplication::activeModalWidget()->isAncestorOf(editor)
                     && qobject_cast<QDialog*>(QApplication::activeModalWidget()))
                 return false;
             _currentlyEdited = -1;
             // manually set focus back to panel after rename canceled by focusing another window
             ACTIVE_PANEL->gui->slotFocusOnMe();
             emit closeEditor(editor, RevertModelCache);
         }
     } else if (event->type() == QEvent::ShortcutOverride) {
-        const QKeyEvent *ke = static_cast<QKeyEvent *>(event);
+        const QKeyEvent *ke = dynamic_cast<QKeyEvent *>(event);
         if (ke->key() == Qt::Key_Escape ||
             (ke->key() == Qt::Key_Backspace && ke->modifiers() == Qt::ControlModifier)) {
             event->accept();
             return true;
         }
     }
     return false;
 }
diff --git a/krusader/Panel/PanelView/krviewproperties.cpp b/krusader/Panel/PanelView/krviewproperties.cpp
index cadb6149..e6322594 100644
--- a/krusader/Panel/PanelView/krviewproperties.cpp
+++ b/krusader/Panel/PanelView/krviewproperties.cpp
@@ -1,33 +1,35 @@
 /*****************************************************************************
  * Copyright (C) 2017-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krviewproperties.h"
 
+#include <utility>
+
 KrViewProperties::KrViewProperties(bool displayIcons, bool numericPermissions,
                                    KrViewProperties::SortOptions sortOptions,
                                    KrViewProperties::SortMethod sortMethod, bool humanReadableSize,
                                    bool localeAwareCompareIsCaseSensitive,
                                    QStringList atomicExtensions)
     : numericPermissions(numericPermissions), displayIcons(displayIcons), sortColumn(Name),
       sortOptions(sortOptions), sortMethod(sortMethod), filter(KrViewProperties::All),
       filterMask(KRQuery("*")), filterApplysToDirs(false),
       localeAwareCompareIsCaseSensitive(localeAwareCompareIsCaseSensitive),
-      humanReadableSize(humanReadableSize), atomicExtensions(atomicExtensions), numberOfColumns(1)
+      humanReadableSize(humanReadableSize), atomicExtensions(std::move(atomicExtensions)), numberOfColumns(1)
 {
 }
diff --git a/krusader/Panel/PanelView/listmodel.cpp b/krusader/Panel/PanelView/listmodel.cpp
index 10d6afb6..600e83ed 100644
--- a/krusader/Panel/PanelView/listmodel.cpp
+++ b/krusader/Panel/PanelView/listmodel.cpp
@@ -1,537 +1,536 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "listmodel.h"
 
 #include "krinterview.h"
 #include "krviewproperties.h"
 #include "../FileSystem/fileitem.h"
 #include "../defaults.h"
 #include "../krcolorcache.h"
 #include "../krglobal.h"
 #include "../krpanel.h"
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 ListModel::ListModel(KrInterView *view)
-    : QAbstractListModel(0), _extensionEnabled(true), _view(view), _dummyFileItem(0), _ready(false),
+    : QAbstractListModel(nullptr), _extensionEnabled(true), _view(view), _dummyFileItem(nullptr), _ready(false),
       _justForSizeHint(false), _alternatingTable(false)
 {
     KConfigGroup grpSvr(krConfig, "Look&Feel");
     _defaultFont = grpSvr.readEntry("Filelist Font", _FilelistFont);
 }
 
 void ListModel::populate(const QList<FileItem *> &files, FileItem *dummy)
 {
     _fileItems = files;
     _dummyFileItem = dummy;
     _ready = true;
 
     if(lastSortOrder() != KrViewProperties::NoColumn)
         sort();
     else {
         emit layoutAboutToBeChanged();
         for(int i = 0; i < _fileItems.count(); i++) {
             updateIndices(_fileItems[i], i);
         }
         emit layoutChanged();
     }
 }
 
 ListModel::~ListModel()
-{
-}
+= default;
 
 void ListModel::clear(bool emitLayoutChanged)
 {
     if(!_fileItems.count())
         return;
 
     emit layoutAboutToBeChanged();
     // clear persistent indexes
     QModelIndexList oldPersistentList = persistentIndexList();
     QModelIndexList newPersistentList;
     newPersistentList.reserve(oldPersistentList.size());
     for (int i=0; i< oldPersistentList.size(); ++i)
         newPersistentList.append(QModelIndex());
     changePersistentIndexList(oldPersistentList, newPersistentList);
 
     _fileItems.clear();
     _fileItemNdx.clear();
     _nameNdx.clear();
     _urlNdx.clear();
-    _dummyFileItem = 0;
+    _dummyFileItem = nullptr;
 
     if (emitLayoutChanged)
         emit layoutChanged();
 }
 
 int ListModel::rowCount(const QModelIndex& /*parent*/) const
 {
     return _fileItems.count();
 }
 
 
 int ListModel::columnCount(const QModelIndex& /*parent*/) const
 {
     return KrViewProperties::MAX_COLUMNS;
 }
 
 QVariant ListModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid() || index.row() >= rowCount())
         return QVariant();
     FileItem *fileitem = _fileItems.at(index.row());
-    if (fileitem == 0)
+    if (fileitem == nullptr)
         return QVariant();
 
     switch (role) {
     case Qt::FontRole:
         return _defaultFont;
     case Qt::EditRole: {
         if (index.column() == 0) {
             return fileitem->getName();
         }
         return QVariant();
     }
     case Qt::UserRole: {
         if (index.column() == 0) {
             return nameWithoutExtension(fileitem, false);
         }
         return QVariant();
     }
     case Qt::ToolTipRole: {
         if (index.column() == KrViewProperties::Name) {
             return fileitem == _dummyFileItem ? QVariant() : toolTipText(fileitem);
         }
 #if __GNUC__ >= 7
         [[gnu::fallthrough]];
 #endif
     }
     case Qt::DisplayRole: {
         switch (index.column()) {
         case KrViewProperties::Name: {
             return nameWithoutExtension(fileitem);
         }
         case KrViewProperties::Ext: {
             QString nameOnly = nameWithoutExtension(fileitem);
             const QString& fileitemName = fileitem->getName();
             return fileitemName.mid(nameOnly.length() + 1);
         }
         case KrViewProperties::Size: {
             if (fileitem->getUISize() == (KIO::filesize_t)-1) {
                 //HACK add <> brackets AFTER translating - otherwise KUIT thinks it's a tag
                 static QString label = QString("<") +
                     i18nc("Show the string 'DIR' instead of file size in detailed view (for folders)", "DIR") + '>';
                 return label;
             } else
                 return KrView::sizeText(properties(), fileitem->getUISize());
         }
         case KrViewProperties::Type: {
             if (fileitem == _dummyFileItem)
                 return QVariant();
             const QString mimeType = KrView::mimeTypeText(fileitem);
             return mimeType.isEmpty() ? QVariant() : mimeType;
         }
         case KrViewProperties::Modified: {
             return fileitem == _dummyFileItem ? QVariant() : dateText(fileitem->getTime_t());
         }
         case KrViewProperties::Changed: {
             return fileitem == _dummyFileItem ? QVariant() : dateText(fileitem->getChangedTime());
         }
         case KrViewProperties::Accessed: {
             return fileitem == _dummyFileItem ? QVariant() : dateText(fileitem->getAccessTime());
         }
         case KrViewProperties::Permissions: {
             if (fileitem == _dummyFileItem)
                 return QVariant();
             return KrView::permissionsText(properties(), fileitem);
         }
         case KrViewProperties::KrPermissions: {
             if (fileitem == _dummyFileItem)
                 return QVariant();
             return KrView::krPermissionText(fileitem);
         }
         case KrViewProperties::Owner: {
             if (fileitem == _dummyFileItem)
                 return QVariant();
             return fileitem->getOwner();
         }
         case KrViewProperties::Group: {
             if (fileitem == _dummyFileItem)
                 return QVariant();
             return fileitem->getGroup();
         }
         default: return QString();
         }
         return QVariant();
     }
     case Qt::DecorationRole: {
         switch (index.column()) {
         case KrViewProperties::Name: {
             if (properties()->displayIcons) {
                 if (_justForSizeHint)
                     return QPixmap(_view->fileIconSize(), _view->fileIconSize());
                 return _view->getIcon(fileitem);
             }
             break;
         }
         default:
             break;
         }
         return QVariant();
     }
     case Qt::TextAlignmentRole: {
         switch (index.column()) {
         case KrViewProperties::Size:
             return QVariant(Qt::AlignRight | Qt::AlignVCenter);
         default:
             return QVariant(Qt::AlignLeft | Qt::AlignVCenter);
         }
         return QVariant();
     }
     case Qt::BackgroundRole:
     case Qt::ForegroundRole: {
         KrColorItemType colorItemType;
         colorItemType.m_activePanel = _view->isFocused();
         int actRow = index.row();
         if (_alternatingTable) {
             int itemNum = _view->itemsPerPage();
             if (itemNum == 0)
                 itemNum++;
             if ((itemNum & 1) == 0)
                 actRow += (actRow / itemNum);
         }
         colorItemType.m_alternateBackgroundColor = (actRow & 1);
         colorItemType.m_currentItem = _view->getCurrentIndex().row() == index.row();
         colorItemType.m_selectedItem = _view->isSelected(index);
         if (fileitem->isSymLink()) {
             if (fileitem->isBrokenLink())
                 colorItemType.m_fileType = KrColorItemType::InvalidSymlink;
             else
                 colorItemType.m_fileType = KrColorItemType::Symlink;
         } else if (fileitem->isDir())
             colorItemType.m_fileType = KrColorItemType::Directory;
         else if (fileitem->isExecutable())
             colorItemType.m_fileType = KrColorItemType::Executable;
         else
             colorItemType.m_fileType = KrColorItemType::File;
 
         KrColorGroup cols;
         KrColorCache::getColorCache().getColors(cols, colorItemType);
 
         if (colorItemType.m_selectedItem) {
             if (role == Qt::ForegroundRole)
                 return cols.highlightedText();
             else
                 return cols.highlight();
         }
         if (role == Qt::ForegroundRole)
             return cols.text();
         else
             return cols.background();
     }
     default:
         return QVariant();
     }
 }
 
 bool ListModel::setData(const QModelIndex & index, const QVariant & value, int role)
 {
     if (role == Qt::EditRole && index.isValid()) {
         if (index.row() < rowCount() && index.row() >= 0) {
             FileItem *fileitem = _fileItems.at(index.row());
-            if (fileitem == 0)
+            if (fileitem == nullptr)
                 return false;
             _view->op()->emitRenameItem(fileitem->getName(), value.toString());
         }
     }
     if (role == Qt::UserRole && index.isValid()) {
         _justForSizeHint = value.toBool();
     }
     return QAbstractListModel::setData(index, value, role);
 }
 
 void ListModel::sort(int column, Qt::SortOrder order)
 {
     _view->sortModeUpdated(column, order);
 
     if(lastSortOrder() == KrViewProperties::NoColumn)
         return;
 
     emit layoutAboutToBeChanged();
 
     QModelIndexList oldPersistentList = persistentIndexList();
 
     KrSort::Sorter sorter(createSorter());
     sorter.sort();
 
     _fileItems.clear();
     _fileItemNdx.clear();
     _nameNdx.clear();
     _urlNdx.clear();
 
     bool sortOrderChanged = false;
     QHash<int, int> changeMap;
     for (int i = 0; i < sorter.items().count(); ++i) {
         const KrSort::SortProps *props = sorter.items()[i];
         _fileItems.append(props->fileitem());
         changeMap[ props->originalIndex() ] = i;
         if (i != props->originalIndex())
             sortOrderChanged = true;
         updateIndices(props->fileitem(), i);
     }
 
     QModelIndexList newPersistentList;
     foreach(const QModelIndex &mndx, oldPersistentList)
         newPersistentList << index(changeMap[ mndx.row()], mndx.column());
 
     changePersistentIndexList(oldPersistentList, newPersistentList);
 
     emit layoutChanged();
     if (sortOrderChanged)
         _view->makeItemVisible(_view->getCurrentKrViewItem());
 }
 
 QModelIndex ListModel::addItem(FileItem *fileitem)
 {
     emit layoutAboutToBeChanged();
 
     if (lastSortOrder() == KrViewProperties::NoColumn) {
         int idx = _fileItems.count();
         _fileItems.append(fileitem);
         updateIndices(fileitem, idx);
         emit layoutChanged();
         return index(idx, 0);
     }
 
     QModelIndexList oldPersistentList = persistentIndexList();
 
     KrSort::Sorter sorter(createSorter());
 
     const bool isDummy = fileitem == _dummyFileItem;
     const int insertIndex = sorter.insertIndex(fileitem, isDummy, customSortData(fileitem));
     if (insertIndex != _fileItems.count())
         _fileItems.insert(insertIndex, fileitem);
     else
         _fileItems.append(fileitem);
 
     for (int i = insertIndex; i < _fileItems.count(); ++i) {
         updateIndices(_fileItems[i], i);
     }
 
     QModelIndexList newPersistentList;
     foreach (const QModelIndex &mndx, oldPersistentList) {
         int newRow = mndx.row();
         if (newRow >= insertIndex)
             newRow++;
         newPersistentList << index(newRow, mndx.column());
     }
 
     changePersistentIndexList(oldPersistentList, newPersistentList);
     emit layoutChanged();
 
     return index(insertIndex, 0);
 }
 
 void ListModel::removeItem(FileItem *fileItem)
 {
     const int rowToRemove = _fileItems.indexOf(fileItem);
     if (rowToRemove < 0)
         return;
 
     emit layoutAboutToBeChanged();
 
     _fileItems.removeAt(rowToRemove);
 
     _fileItemNdx.remove(fileItem);
     _nameNdx.remove(fileItem->getName());
     _urlNdx.remove(fileItem->getUrl());
     // update indices for fileItems following fileitem
     for (int i = rowToRemove; i < _fileItems.count(); i++) {
         updateIndices(_fileItems[i], i);
     }
 
     const QModelIndexList oldPersistentList = persistentIndexList();
     QModelIndexList newPersistentList;
     foreach (const QModelIndex &mndx, oldPersistentList) {
         int newRow = mndx.row();
         if (newRow > rowToRemove)
             newRow--;
         if (newRow != rowToRemove)
             newPersistentList << index(newRow, mndx.column());
         else
             newPersistentList << QModelIndex();
     }
     changePersistentIndexList(oldPersistentList, newPersistentList);
     emit layoutChanged();
 }
 
 QVariant ListModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     // ignore anything that's not display, and not horizontal
     if (role != Qt::DisplayRole || orientation != Qt::Horizontal)
         return QVariant();
 
     switch (section) {
     case KrViewProperties::Name: return i18nc("File property", "Name");
     case KrViewProperties::Ext: return i18nc("File property", "Ext");
     case KrViewProperties::Size: return i18nc("File property", "Size");
     case KrViewProperties::Type: return i18nc("File property", "Type");
     case KrViewProperties::Modified: return i18nc("File property", "Modified");
     case KrViewProperties::Changed: return i18nc("File property", "Changed");
     case KrViewProperties::Accessed: return i18nc("File property", "Accessed");
     case KrViewProperties::Permissions: return i18nc("File property", "Perms");
     case KrViewProperties::KrPermissions: return i18nc("File property", "rwx");
     case KrViewProperties::Owner: return i18nc("File property", "Owner");
     case KrViewProperties::Group: return i18nc("File property", "Group");
     }
     return QString();
 }
 
 const KrViewProperties *ListModel::properties() const
 {
     return _view->properties();
 }
 
 FileItem *ListModel::fileItemAt(const QModelIndex &index)
 {
     if (!index.isValid() || index.row() < 0 || index.row() >= _fileItems.count())
-        return 0;
+        return nullptr;
     return _fileItems[ index.row()];
 }
 
 const QModelIndex & ListModel::fileItemIndex(const FileItem *fileitem)
 {
     return _fileItemNdx[ (FileItem *) fileitem ];
 }
 
 const QModelIndex & ListModel::nameIndex(const QString & st)
 {
     return _nameNdx[ st ];
 }
 
 Qt::ItemFlags ListModel::flags(const QModelIndex & index) const
 {
     Qt::ItemFlags flags = QAbstractListModel::flags(index);
 
     if (!index.isValid())
         return flags;
 
     if (index.row() >= rowCount())
         return flags;
     FileItem *fileitem = _fileItems.at(index.row());
     if (fileitem == _dummyFileItem) {
         flags = (flags & (~Qt::ItemIsSelectable)) | Qt::ItemIsDropEnabled;
     } else
         flags = flags | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
     return flags;
 }
 
 Qt::SortOrder ListModel::lastSortDir() const
 {
     return (properties()->sortOptions & KrViewProperties::Descending) ?
                 Qt::DescendingOrder : Qt::AscendingOrder;
 }
 
 int ListModel::lastSortOrder() const
 {
     return properties()->sortColumn;
 }
 
 QString ListModel::nameWithoutExtension(const FileItem *fileItem, bool checkEnabled) const
 {
     if ((checkEnabled && !_extensionEnabled) || fileItem->isDir())
         return fileItem->getName();
     // check if the file has an extension
     const QString& fileItemName = fileItem->getName();
     int loc = fileItemName.lastIndexOf('.');
     // avoid mishandling of .bashrc and friend
     // and virtfs / search result names like "/dir/.file" which would become "/dir/"
     if (loc > 0 && fileItemName.lastIndexOf('/') < loc) {
         // check if it has one of the predefined 'atomic extensions'
-        for (QStringList::const_iterator i = properties()->atomicExtensions.begin(); i != properties()->atomicExtensions.end(); ++i) {
-            if (fileItemName.endsWith(*i) && fileItemName != *i) {
-                loc = fileItemName.length() - (*i).length();
+        for (const auto & atomicExtension : properties()->atomicExtensions) {
+            if (fileItemName.endsWith(atomicExtension) && fileItemName != atomicExtension) {
+                loc = fileItemName.length() - atomicExtension.length();
                 break;
             }
         }
     } else
         return fileItemName;
     return fileItemName.left(loc);
 }
 
 const QModelIndex &ListModel::indexFromUrl(const QUrl &url)
 {
     return _urlNdx[url];
 }
 
 KrSort::Sorter ListModel::createSorter()
 {
     KrSort::Sorter sorter(_fileItems.count(), properties(), lessThanFunc(), greaterThanFunc());
     for(int i = 0; i < _fileItems.count(); i++)
         sorter.addItem(_fileItems[i], _fileItems[i] == _dummyFileItem, i, customSortData(_fileItems[i]));
     return sorter;
 }
 
 void ListModel::updateIndices(FileItem *file, int i)
 {
     _fileItemNdx[file] = index(i, 0);
     _nameNdx[file->getName()] = index(i, 0);
     _urlNdx[file->getUrl()] = index(i, 0);
 }
 
 QString ListModel::toolTipText(FileItem *fileItem) const
 {
     //"<p style='white-space:pre'>"; // disable automatic word-wrap
     QString text = "<b>" + fileItem->getName() + "</b><hr>";
     if (fileItem->getUISize() != (KIO::filesize_t)-1) {
         const QString size = KrView::sizeText(properties(), fileItem->getUISize());
         text += i18n("Size: %1", size) + "<br>";
     }
     text += i18nc("File property", "Type: %1", KrView::mimeTypeText(fileItem));
     text += "<br>" + i18nc("File property", "Modified: %1", dateText(fileItem->getTime_t()));
     text += "<br>" + i18nc("File property", "Changed: %1", dateText(fileItem->getChangedTime()));
     text += "<br>" + i18nc("File property", "Last Access: %1", dateText(fileItem->getAccessTime()));
     text += "<br>" + i18nc("File property", "Permissions: %1",
             KrView::permissionsText(properties(), fileItem));
     text += "<br>" + i18nc("File property", "Owner: %1", fileItem->getOwner());
     text += "<br>" + i18nc("File property", "Group: %1", fileItem->getGroup());
     if (fileItem->isSymLink()) {
         KLocalizedString ls;
         if (fileItem->isBrokenLink())
             ls = ki18nc("File property; broken symbolic link", "Link to: %1 - (broken)");
         else
             ls = ki18nc("File property", "Link to: %1");
         text += "<br>" + ls.subs(fileItem->getSymDest()).toString();
     }
     return text;
 }
 
 QString ListModel::dateText(time_t time)
 {
     struct tm* t = localtime((time_t *) & time);
 
     const QDateTime dateTime(QDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday),
                              QTime(t->tm_hour, t->tm_min));
     return QLocale().toString(dateTime, QLocale::ShortFormat);
 }
diff --git a/krusader/Panel/PanelView/listmodel.h b/krusader/Panel/PanelView/listmodel.h
index d8629424..9b7d552c 100644
--- a/krusader/Panel/PanelView/listmodel.h
+++ b/krusader/Panel/PanelView/listmodel.h
@@ -1,121 +1,121 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef LISTMODEL_H
 #define LISTMODEL_H
 
 // QtCore
 #include <QAbstractListModel>
 // QtGui
 #include <QFont>
 
 #include "krsort.h"
 
 class FileItem;
 class KrInterView;
 class KrViewProperties;
 
 /**
  * @brief The list model for all panel views.
  */
 class ListModel: public QAbstractListModel
 {
     Q_OBJECT
 
 public:
     explicit ListModel(KrInterView *);
-    virtual ~ListModel();
+    ~ListModel() override;
 
     inline bool ready() const {
         return _ready;
     }
     void populate(const QList<FileItem*> &files, FileItem *dummy);
     QModelIndex addItem(FileItem *);
     void removeItem(FileItem *);
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const Q_DECL_OVERRIDE;
     int columnCount(const QModelIndex &parent = QModelIndex()) const  Q_DECL_OVERRIDE;
     QVariant data(const QModelIndex &index, int role) const  Q_DECL_OVERRIDE;
     bool setData(const QModelIndex & index, const QVariant & value, int role = Qt::EditRole)  Q_DECL_OVERRIDE;
     QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const  Q_DECL_OVERRIDE;
     void setExtensionEnabled(bool exten) {
         _extensionEnabled = exten;
     }
     const KrViewProperties * properties() const;
     void sort() {
         sort(lastSortOrder(), lastSortDir());
     }
     void clear(bool emitLayoutChanged = true);
     QList<FileItem*> fileItems() {
         return _fileItems;
     }
     FileItem * fileItemAt(const QModelIndex &index);
     FileItem *dummyFileItem() const {
         return _dummyFileItem;
     }
     const QModelIndex & fileItemIndex(const FileItem *);
     const QModelIndex & nameIndex(const QString &);
     const QModelIndex & indexFromUrl(const QUrl &url);
-    virtual Qt::ItemFlags flags(const QModelIndex & index) const Q_DECL_OVERRIDE;
+    Qt::ItemFlags flags(const QModelIndex & index) const Q_DECL_OVERRIDE;
     void emitChanged() {
         emit layoutChanged();
     }
     Qt::SortOrder lastSortDir() const;
     int lastSortOrder() const;
     void setAlternatingTable(bool altTable) {
         _alternatingTable = altTable;
     }
 
 public slots:
-    virtual void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) Q_DECL_OVERRIDE;
+    void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) Q_DECL_OVERRIDE;
 
 protected:
     KrSort::LessThanFunc lessThanFunc() {
         return KrSort::itemLessThan;
     }
     KrSort::LessThanFunc greaterThanFunc() const {
         return KrSort::itemGreaterThan;
     }
     QVariant customSortData(FileItem *) const {
         return QVariant();
     }
     KrSort::Sorter createSorter();
     QString nameWithoutExtension(const FileItem * fileitem, bool checkEnabled = true) const;
 
 private:
     void updateIndices(FileItem *file, int index);
     QString toolTipText(FileItem *fileItem) const;
     static QString dateText(time_t time);
 
     QList<FileItem*>               _fileItems;
     QHash<FileItem *, QModelIndex> _fileItemNdx;
     QHash<QString, QModelIndex> _nameNdx;
     QHash<QUrl, QModelIndex>    _urlNdx;
     bool                        _extensionEnabled;
     KrInterView                 * _view;
     FileItem *                     _dummyFileItem;
     bool                        _ready;
     QFont                       _defaultFont;
     bool                        _justForSizeHint;
     bool                        _alternatingTable;
 };
 
 #endif // __listmodel__
diff --git a/krusader/Panel/dirhistoryqueue.cpp b/krusader/Panel/dirhistoryqueue.cpp
index 8db15e75..f80e484f 100644
--- a/krusader/Panel/dirhistoryqueue.cpp
+++ b/krusader/Panel/dirhistoryqueue.cpp
@@ -1,162 +1,162 @@
 /*****************************************************************************
  * Copyright (C) 2004 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2004 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "dirhistoryqueue.h"
 
 #include "krpanel.h"
 #include "PanelView/krview.h"
 #include "../defaults.h"
 #include "../krservices.h"
 
 // QtCore
 #include <QDir>
 
 DirHistoryQueue::DirHistoryQueue(KrPanel *panel) :
     _panel(panel), _currentPos(0)
 {
 }
 
-DirHistoryQueue::~DirHistoryQueue() {}
+DirHistoryQueue::~DirHistoryQueue() = default;
 
 void DirHistoryQueue::clear()
 {
     _urlQueue.clear();
     _currentItems.clear();
     _currentPos = 0;
 }
 
 QUrl DirHistoryQueue::currentUrl()
 {
     if(_urlQueue.count())
         return _urlQueue[_currentPos];
     else
         return QUrl();
 }
 
 void DirHistoryQueue::setCurrentUrl(const QUrl &url)
 {
     if(_urlQueue.count())
         _urlQueue[_currentPos] = url;
 }
 
 QString DirHistoryQueue::currentItem()
 {
     if(count())
         return _currentItems[_currentPos];
     else
         return QString();
 }
 
 void DirHistoryQueue::saveCurrentItem()
 {
     // if the filesystem-url hasn't been refreshed yet,
     // avoid saving current item for the wrong url
     if(count() &&  _panel->virtualPath().matches(_urlQueue[_currentPos], QUrl::StripTrailingSlash))
         _currentItems[_currentPos] = _panel->view->getCurrentItem();
 }
 
-void DirHistoryQueue::add(QUrl url, QString currentItem)
+void DirHistoryQueue::add(QUrl url, const QString& currentItem)
 {
     url.setPath(QDir::cleanPath(url.path()));
 
     if(_urlQueue.isEmpty()) {
         _urlQueue.push_front(url);
         _currentItems.push_front(currentItem);
         return;
     }
 
     if(_urlQueue[_currentPos].matches(url, QUrl::StripTrailingSlash)) {
         _currentItems[_currentPos] = currentItem;
         return;
     }
 
     for (int i = 0; i < _currentPos; i++) {
         _urlQueue.pop_front();
         _currentItems.pop_front();
     }
 
     _currentPos = 0;
 
     // do we have room for another ?
     if (_urlQueue.count() > 12) { // FIXME: use user-defined size
         // no room - remove the oldest entry
         _urlQueue.pop_back();
         _currentItems.pop_back();
     }
 
     saveCurrentItem();
     _urlQueue.push_front(url);
     _currentItems.push_front(currentItem);
 }
 
 bool DirHistoryQueue::gotoPos(int pos)
 {
     if(pos >= 0 && pos < _urlQueue.count()) {
         saveCurrentItem();
         _currentPos = pos;
         return true;
     }
     return false;
 }
 
 bool DirHistoryQueue::goBack()
 {
     return gotoPos(_currentPos + 1);
 }
 
 bool DirHistoryQueue::goForward()
 {
     return gotoPos(_currentPos - 1);
 }
 
 void DirHistoryQueue::save(KConfigGroup cfg)
 {
     saveCurrentItem();
 
     QList<QUrl> urls;
     foreach(const QUrl &url, _urlQueue) {
         // make sure no passwords are permanently stored
         QUrl safeUrl(url);
         safeUrl.setPassword(QString());
         urls << safeUrl;
     }
 
     cfg.writeEntry("Entrys", KrServices::toStringList(urls)); // krazy:exclude=spelling
     cfg.writeEntry("CurrentItems", _currentItems);
     cfg.writeEntry("CurrentIndex", _currentPos);
 }
 
-bool DirHistoryQueue::restore(KConfigGroup cfg)
+bool DirHistoryQueue::restore(const KConfigGroup& cfg)
 {
     clear();
     _urlQueue = KrServices::toUrlList(cfg.readEntry("Entrys", QStringList())); // krazy:exclude=spelling
     _currentItems = cfg.readEntry("CurrentItems", QStringList());
     if(!_urlQueue.count() || _urlQueue.count() != _currentItems.count()) {
         clear();
         return false;
     }
     _currentPos = cfg.readEntry("CurrentIndex", 0);
     if(_currentPos >= _urlQueue.count() || _currentPos < 0)
         _currentPos  = 0;
 
     return true;
 }
diff --git a/krusader/Panel/dirhistoryqueue.h b/krusader/Panel/dirhistoryqueue.h
index 4bc2b76b..19905488 100644
--- a/krusader/Panel/dirhistoryqueue.h
+++ b/krusader/Panel/dirhistoryqueue.h
@@ -1,79 +1,79 @@
 /*****************************************************************************
  * Copyright (C) 2004 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2004 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef DIRHISTORYQUEUE_H
 #define DIRHISTORYQUEUE_H
 
 // QtCore
 #include <QObject>
 #include <QStringList>
 #include <QUrl>
 
 # include <KConfigCore/KConfigGroup>
 
 class KrPanel;
 
 class DirHistoryQueue : public QObject
 {
     Q_OBJECT
 public:
     explicit DirHistoryQueue(KrPanel *panel);
-    ~DirHistoryQueue();
+    ~DirHistoryQueue() override;
 
     void clear();
     int currentPos() {
         return _currentPos;
     }
     int count() {
         return _urlQueue.count();
     }
     QUrl currentUrl();
     void setCurrentUrl(const QUrl &url);
     const QUrl &get(int pos) {
         return _urlQueue[pos];
     }
-    void add(QUrl url, QString currentItem);
+    void add(QUrl url, const QString& currentItem);
     bool gotoPos(int pos);
     bool goBack();
     bool goForward();
     bool canGoBack() {
         return _currentPos < count() - 1;
     }
     bool canGoForward() {
         return _currentPos > 0;
     }
     QString currentItem(); // current item of the view
 
     void save(KConfigGroup cfg);
-    bool restore(KConfigGroup cfg);
+    bool restore(const KConfigGroup& cfg);
 
 public slots:
     void saveCurrentItem();
 
 private:
     KrPanel* _panel;
     int _currentPos;
     QList<QUrl> _urlQueue;
     QStringList _currentItems;
 };
 
 #endif
diff --git a/krusader/Panel/krcalcspacedialog.cpp b/krusader/Panel/krcalcspacedialog.cpp
index 658f5b89..6d244bb5 100644
--- a/krusader/Panel/krcalcspacedialog.cpp
+++ b/krusader/Panel/krcalcspacedialog.cpp
@@ -1,130 +1,130 @@
 /*****************************************************************************
  * Copyright (C) 2004 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krcalcspacedialog.h"
 
 // QtCore
 #include <QTimer>
 // QtWidgets
 #include <QApplication>
 #include <QLabel>
 #include <QPushButton>
 #include <QVBoxLayout>
 // QtGui
 #include <QKeyEvent>
 
 #include <KI18n/KLocalizedString>
 
 #include "../krglobal.h"
 #include "../FileSystem/sizecalculator.h"
 
 KrCalcSpaceDialog::KrCalcSpaceDialog(QWidget *parent, SizeCalculator *calculator)
     : QDialog(parent), m_calculator(calculator)
 {
     setWindowTitle(i18n("Calculate Occupied Space"));
 
-    QVBoxLayout *layout = new QVBoxLayout;
+    auto *layout = new QVBoxLayout;
     setLayout(layout);
     layout->setSizeConstraint(QLayout::SetFixedSize);
 
     m_label = new QLabel(this);
     layout->addWidget(m_label);
     layout->addStretch(10);
 
     // buttons: Cancel is replaced with Ok when calculator is finished
     m_buttonBox = new QDialogButtonBox(QDialogButtonBox::Cancel);
     layout->addWidget(m_buttonBox);
     connect(m_buttonBox, &QDialogButtonBox::rejected, this, &KrCalcSpaceDialog::slotCancel);
     connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
 
     connect(m_calculator, &SizeCalculator::finished, this, &KrCalcSpaceDialog::slotCalculatorFinished);
 
     m_updateTimer = new QTimer(this);
     connect(m_updateTimer, &QTimer::timeout, this, &KrCalcSpaceDialog::updateResult);
     m_updateTimer->start(1000);
 
     updateResult();
 }
 
 void KrCalcSpaceDialog::closeEvent(QCloseEvent *event)
 {
     if (event) {
         if (m_updateTimer->isActive())
             slotCancel();
         else
             accept();
     }
 }
 
 void KrCalcSpaceDialog::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Escape) {
         if (m_updateTimer->isActive())
             slotCancel();
         else
             reject();
     }
 }
 
 void KrCalcSpaceDialog::showDialog(QWidget *parent, SizeCalculator *calculator)
 {
-    KrCalcSpaceDialog *dialog = new KrCalcSpaceDialog(parent, calculator);
+    auto *dialog = new KrCalcSpaceDialog(parent, calculator);
     dialog->show();
 }
 
 void KrCalcSpaceDialog::slotCancel()
 {
     m_updateTimer->stop();
     m_calculator->cancel();
 
     reject(); // close and delete this dialog
 }
 
 void KrCalcSpaceDialog::slotCalculatorFinished()
 {
     m_buttonBox->clear();
     QPushButton *okButton = m_buttonBox->addButton(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setFocus();
 
     m_updateTimer->stop();
     updateResult();
 }
 
 void KrCalcSpaceDialog::updateResult()
 {
     const KIO::filesize_t totalSize = m_calculator->totalSize();
     const unsigned long totalFiles = m_calculator->totalFiles();
     const unsigned long totalDirs = m_calculator->totalDirs();
 
     const QList<QUrl> urls = m_calculator->urls();
     const QString fileName =
         urls.count() == 1 ? i18n("Name: %1\n", urls.first().fileName()) : QString("");
 
     QString msg = fileName + i18n("Total occupied space: %1", KIO::convertSize(totalSize));
     if (totalSize >= 1024)
         msg += i18np(" (%2 byte)", " (%2 bytes)", totalSize, QLocale().toString(totalSize));
     msg += '\n';
     msg += i18np("in %1 folder", "in %1 folders", totalDirs);
     msg += ' ';
     msg += i18np("and %1 file", "and %1 files", totalFiles);
     m_label->setText(msg);
 }
diff --git a/krusader/Panel/krcolorcache.cpp b/krusader/Panel/krcolorcache.cpp
index 7986cc81..c1e79776 100644
--- a/krusader/Panel/krcolorcache.cpp
+++ b/krusader/Panel/krcolorcache.cpp
@@ -1,761 +1,761 @@
 /*****************************************************************************
  * Copyright (C) 2000-2002 Shie Erlich <erlich@users.sourceforge.net>        *
  * Copyright (C) 2000-2002 Rafi Yanai <yanai@users.sourceforge.net>          *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krcolorcache.h"
 #include "../krglobal.h"
 #include "../defaults.h"
 
 // QtCore
 #include <QDebug>
 #include <QFile>
 #include <QList>
 // QtGui
 #include <QPixmapCache>
 // QtWidgets
 #include <QApplication>
 
 #include <KConfigCore/KSharedConfig>
 
 // Macro: set target = col, if col is valid
 #define SETCOLOR(target, col) { if (col.isValid()) target = col; }
 
 // Static class, which lists all allowed keywords for a quick access.
 // Just call a method to initialize it.
 class KrColorSettingNames
 {
     static QMap<QString, bool> s_colorNames;
     static QMap<QString, bool> s_numNames;
     static QMap<QString, bool> s_boolNames;
     static void initialize();
 public:
     static QStringList getColorNames();
     static bool isColorNameValid(const QString & settingName);
     static QStringList getNumNames();
     static bool isNumNameValid(const QString & settingName);
     static QStringList getBoolNames();
     static bool isBoolNameValid(const QString & settingName);
 } krColorSettingNames;
 
 QMap<QString, bool> KrColorSettingNames::s_colorNames;
 QMap<QString, bool> KrColorSettingNames::s_numNames;
 QMap<QString, bool> KrColorSettingNames::s_boolNames;
 
 void KrColorSettingNames::initialize()
 {
     if (!s_colorNames.empty())
         return;
     s_colorNames["Foreground"] = true;
     s_colorNames["Inactive Foreground"] = true;
     s_colorNames["Directory Foreground"] = true;
     s_colorNames["Inactive Directory Foreground"] = true;
     s_colorNames["Executable Foreground"] = true;
     s_colorNames["Inactive Executable Foreground"] = true;
     s_colorNames["Symlink Foreground"] = true;
     s_colorNames["Inactive Symlink Foreground"] = true;
     s_colorNames["Invalid Symlink Foreground"] = true;
     s_colorNames["Inactive Invalid Symlink Foreground"] = true;
     s_colorNames["Marked Foreground"] = true;
     s_colorNames["Inactive Marked Foreground"] = true;
     s_colorNames["Marked Background"] = true;
     s_colorNames["Inactive Marked Background"] = true;
     s_colorNames["Current Foreground"] = true;
     s_colorNames["Inactive Current Foreground"] = true;
     s_colorNames["Current Background"] = true;
     s_colorNames["Inactive Current Background"] = true;
     s_colorNames["Marked Current Foreground"] = true;
     s_colorNames["Inactive Marked Current Foreground"] = true;
     s_colorNames["Alternate Background"] = true;
     s_colorNames["Inactive Alternate Background"] = true;
     s_colorNames["Background"] = true;
     s_colorNames["Inactive Background"] = true;
     s_colorNames["Alternate Marked Background"] = true;
     s_colorNames["Inactive Alternate Marked Background"] = true;
     s_colorNames["Dim Target Color"] = true;
 
     s_numNames["Dim Factor"] = true;
 
     s_boolNames["KDE Default"] = true;
     s_boolNames["Enable Alternate Background"] = true;
     s_boolNames["Show Current Item Always"] = true;
     s_boolNames["Dim Inactive Colors"] = true;
 }
 
 QStringList KrColorSettingNames::getColorNames()
 {
     initialize();
     return s_colorNames.keys();
 }
 
 bool KrColorSettingNames::isColorNameValid(const QString & settingName)
 {
     initialize();
     return s_colorNames.contains(settingName);
 }
 
 QStringList KrColorSettingNames::getNumNames()
 {
     initialize();
     return s_numNames.keys();
 }
 
 bool KrColorSettingNames::isNumNameValid(const QString & settingName)
 {
     initialize();
     return s_numNames.contains(settingName);
 }
 
 QStringList KrColorSettingNames::getBoolNames()
 {
     initialize();
     return s_boolNames.keys();
 }
 
 bool KrColorSettingNames::isBoolNameValid(const QString & settingName)
 {
     initialize();
     return s_boolNames.contains(settingName);
 }
 
 
 
 /*
 KrColorSettings implementation. Contains all properties in QMaps. loadFromConfig initializes them from krConfig.
 */
 class KrColorSettingsImpl
 {
     friend class KrColorSettings;
     QMap<QString, QString> m_colorTextValues;
     QMap<QString, QColor> m_colorValues;
     QMap<QString, int> m_numValues;
     QMap<QString, bool> m_boolValues;
     void loadFromConfig();
 };
 
 void KrColorSettingsImpl::loadFromConfig()
 {
     KConfigGroup group(krConfig, "Colors");
     QStringList names = KrColorSettingNames::getColorNames();
-    for (QStringList::Iterator it = names.begin(); it != names.end(); ++it) {
-        m_colorTextValues[*it] = group.readEntry(*it, QString());
-        if (m_colorTextValues[*it].count(',') == 2)
-            m_colorValues[*it] = group.readEntry(*it, QColor());
+    for (auto & name : names) {
+        m_colorTextValues[name] = group.readEntry(name, QString());
+        if (m_colorTextValues[name].count(',') == 2)
+            m_colorValues[name] = group.readEntry(name, QColor());
         else
-            m_colorValues[*it] = QColor();
+            m_colorValues[name] = QColor();
     }
     names = KrColorSettingNames::getNumNames();
-    for (QStringList::Iterator it = names.begin(); it != names.end(); ++it) {
-        if (!group.readEntry(*it, QString()).isEmpty()) {
-            m_numValues[*it] = group.readEntry(*it, (long long)0);
+    for (auto & name : names) {
+        if (!group.readEntry(name, QString()).isEmpty()) {
+            m_numValues[name] = group.readEntry(name, (long long)0);
         }
     }
     names = KrColorSettingNames::getBoolNames();
-    for (QStringList::Iterator it = names.begin(); it != names.end(); ++it) {
-        if (!group.readEntry(*it, QString()).isEmpty()) {
-            m_boolValues[*it] = group.readEntry(*it, false);
+    for (auto & name : names) {
+        if (!group.readEntry(name, QString()).isEmpty()) {
+            m_boolValues[name] = group.readEntry(name, false);
         }
     }
 }
 
 KrColorSettings::KrColorSettings()
 {
     m_impl = new KrColorSettingsImpl();
     m_impl->loadFromConfig();
 }
 
 KrColorSettings::KrColorSettings(const KrColorSettings & src)
 {
     m_impl = new KrColorSettingsImpl();
     operator =(src);
 }
 
 KrColorSettings::~KrColorSettings()
 {
     delete m_impl;
 }
 
 const KrColorSettings & KrColorSettings::operator= (const KrColorSettings & src)
 {
     if (this == & src)
         return * this;
     QStringList names = KrColorSettingNames::getColorNames();
-    for (QStringList::Iterator it = names.begin(); it != names.end(); ++it) {
-        m_impl->m_colorTextValues[*it] = src.m_impl->m_colorTextValues[*it];
-        m_impl->m_colorValues[*it] = src.m_impl->m_colorValues[*it];
+    for (auto & name : names) {
+        m_impl->m_colorTextValues[name] = src.m_impl->m_colorTextValues[name];
+        m_impl->m_colorValues[name] = src.m_impl->m_colorValues[name];
     }
     for (QMap<QString, int>::Iterator it = src.m_impl->m_numValues.begin(); it != src.m_impl->m_numValues.end(); ++it) {
         m_impl->m_numValues[it.key()] = it.value();
     }
     for (QMap<QString, bool>::Iterator it = src.m_impl->m_boolValues.begin(); it != src.m_impl->m_boolValues.end(); ++it) {
         m_impl->m_boolValues[it.key()] = it.value();
     }
     return * this;
 }
 
 QList<QString> KrColorSettings::getColorNames()
 {
     return KrColorSettingNames::getColorNames();
 }
 
 bool KrColorSettings::isColorNameValid(const QString & settingName)
 {
     return KrColorSettingNames::isColorNameValid(settingName);
 }
 
 bool KrColorSettings::setColorValue(const QString & settingName, const QColor & color)
 {
     if (!isColorNameValid(settingName)) {
         qWarning() << "Invalid color setting name: " << settingName;
         return false;
     }
     m_impl->m_colorValues[settingName] = color;
     return true;
 }
 
 QColor KrColorSettings::getColorValue(const QString & settingName) const
 {
     if (!isColorNameValid(settingName)) {
         qWarning() << "Invalid color setting name: " << settingName;
         return QColor();
     }
     return m_impl->m_colorValues[settingName];
 }
 
 bool KrColorSettings::setColorTextValue(const QString & settingName, const QString & colorText)
 {
     if (!isColorNameValid(settingName)) {
         qWarning() << "Invalid color setting name: " << settingName;
         return false;
     }
     m_impl->m_colorTextValues[settingName] = colorText;
     return true;
 }
 
 QString KrColorSettings::getColorTextValue(const QString & settingName) const
 {
     if (!isColorNameValid(settingName)) {
         qWarning() << "Invalid color setting name: " << settingName;
         return QString();
     }
     return m_impl->m_colorTextValues[settingName];
 }
 
 QList<QString> KrColorSettings::getNumNames()
 {
     return KrColorSettingNames::getNumNames();
 }
 
 bool KrColorSettings::isNumNameValid(const QString & settingName)
 {
     return KrColorSettingNames::isNumNameValid(settingName);
 }
 
 bool KrColorSettings::setNumValue(const QString & settingName, int value)
 {
     if (!isNumNameValid(settingName)) {
         qWarning() << "Invalid number setting name: " << settingName;
         return false;
     }
     m_impl->m_numValues[settingName] = value;
     return true;
 }
 
 int KrColorSettings::getNumValue(const QString & settingName, int defaultValue) const
 {
     if (!isNumNameValid(settingName)) {
         qWarning() << "Invalid number setting name: " << settingName;
         return 0;
     }
     if (!m_impl->m_numValues.contains(settingName))
         return defaultValue;
     return m_impl->m_numValues[settingName];
 }
 
 QList<QString> KrColorSettings::getBoolNames()
 {
     return KrColorSettingNames::getBoolNames();
 }
 
 bool KrColorSettings::isBoolNameValid(const QString & settingName)
 {
     return KrColorSettingNames::isBoolNameValid(settingName);
 }
 
 bool KrColorSettings::setBoolValue(const QString & settingName, bool value)
 {
     if (!isBoolNameValid(settingName)) {
         qWarning() << "Invalid bool setting name: " << settingName;
         return false;
     }
     m_impl->m_boolValues[settingName] = value;
     return true;
 }
 
 int KrColorSettings::getBoolValue(const QString & settingName, bool defaultValue) const
 {
     if (!isBoolNameValid(settingName)) {
         qWarning() << "Invalid bool setting name: " << settingName;
         return false;
     }
     if (!m_impl->m_boolValues.contains(settingName))
         return defaultValue;
     return m_impl->m_boolValues[settingName];
 }
 
 
 
 KrColorItemType::KrColorItemType()
 {
     m_fileType = File;
     m_alternateBackgroundColor = false;
     m_activePanel = false;
     m_currentItem = false;
     m_selectedItem = false;
 }
 
 KrColorItemType::KrColorItemType(FileType type, bool alternateBackgroundColor, bool activePanel, bool currentItem, bool selectedItem)
 {
     m_fileType = type;
     m_alternateBackgroundColor = alternateBackgroundColor;
     m_activePanel = activePanel;
     m_currentItem = currentItem;
     m_selectedItem = selectedItem;
 }
 
 KrColorItemType::KrColorItemType(const KrColorItemType & src)
 {
     operator= (src);
 }
 
 const KrColorItemType & KrColorItemType::operator= (const KrColorItemType & src)
 {
     if (this == & src)
         return * this;
     m_fileType = src.m_fileType;
     m_alternateBackgroundColor = src.m_alternateBackgroundColor;
     m_activePanel = src.m_activePanel;
     m_currentItem = src.m_currentItem;
     m_selectedItem = src.m_selectedItem;
     return * this;
 }
 
 
 
 
 /*
 KrColorCache implementation. Contains the KrColorSettings used for teh calculation and the cache for the results.
 getColors is the only method to call. All other are taken from the previous versions.
 */
 class KrColorCacheImpl
 {
     friend class KrColorCache;
     QMap<QString, KrColorGroup> m_cachedColors;
     KrColorSettings m_colorSettings;
 
     KrColorGroup getColors(const KrColorItemType & type) const;
     static const QColor & setColorIfContrastIsSufficient(const QColor & background, const QColor & color1, const QColor & color2);
     QColor getForegroundColor(bool isActive) const;
     QColor getSpecialForegroundColor(const QString & type, bool isActive) const;
     QColor getBackgroundColor(bool isActive) const;
     QColor getAlternateBackgroundColor(bool isActive) const;
     QColor getMarkedForegroundColor(bool isActive) const;
     QColor getMarkedBackgroundColor(bool isActive) const;
     QColor getAlternateMarkedBackgroundColor(bool isActive) const;
     QColor getCurrentForegroundColor(bool isActive) const;
     QColor getCurrentBackgroundColor(bool isActive) const;
     QColor getCurrentMarkedForegroundColor(bool isActive) const;
     QColor dimColor(QColor color, bool isBackgroundColor) const;
 };
 
 KrColorGroup KrColorCacheImpl::getColors(const KrColorItemType & type) const
 {
     KrColorGroup result;
     if (m_colorSettings.getBoolValue("KDE Default", _KDEDefaultColors)) {
         bool enableAlternateBackground = m_colorSettings.getBoolValue("Enable Alternate Background", _AlternateBackground);
 
         QPalette p = QGuiApplication::palette();
         QColor background = enableAlternateBackground && type.m_alternateBackgroundColor ?
                     p.color(QPalette::Active, QPalette::Base)
                   :  p.color(QPalette::Active, QPalette::AlternateBase);
         result.setBackground(background);
         result.setText(p.color(QPalette::Active, QPalette::Text));
         result.setHighlight(p.color(QPalette::Active, QPalette::Highlight));
         result.setHighlightedText(p.color(QPalette::Active, QPalette::HighlightedText));
 
         /*  if (type.m_currentItem && type.m_activePanel)
           {
            QColor currentBackground = KColorScheme(QPalette::Active).background(KColorScheme::ActiveBackground).color();
            // set the background
            result.setColor(QColorGroup::Highlight, currentBackground);
            result.setColor(QColorGroup::Base, currentBackground);
            result.setColor(QColorGroup::Background, currentBackground);
           }*/
         return result;
     }
     bool markCurrentAlways = m_colorSettings.getBoolValue("Show Current Item Always", _ShowCurrentItemAlways);
     bool dimBackground = m_colorSettings.getBoolValue("Dim Inactive Colors", false);
 
     // cache m_activePanel flag. If color dimming is turned on, it is set to true, as the inactive colors
     // are calculated from the active ones at the end.
     bool isActive = type.m_activePanel;
     if (dimBackground)
         isActive = true;
 
     // First calculate fore- and background.
     QColor background = type.m_alternateBackgroundColor ?
                         getAlternateBackgroundColor(isActive)
                         : getBackgroundColor(isActive);
     QColor foreground;
     switch (type.m_fileType) {
     case KrColorItemType::Directory :
         foreground = getSpecialForegroundColor("Directory", isActive);
         break;
     case KrColorItemType::Executable :
         foreground = getSpecialForegroundColor("Executable", isActive);
         break;
     case KrColorItemType::InvalidSymlink :
         foreground = getSpecialForegroundColor("Invalid Symlink", isActive);
         break;
     case KrColorItemType::Symlink :
         foreground = getSpecialForegroundColor("Symlink", isActive);
         break;
     default:
         foreground = getForegroundColor(isActive);
     }
 
     // set the background color
     result.setBackground(background);
 
     // set the foreground color
     result.setText(foreground);
 
     // now the color of a marked item
     QColor markedBackground = type.m_alternateBackgroundColor ?
                               getAlternateMarkedBackgroundColor(isActive)
                               : getMarkedBackgroundColor(isActive);
     QColor markedForeground = getMarkedForegroundColor(isActive);
     if (!markedForeground.isValid()) // transparent
         // choose fore- or background, depending on its contrast compared to markedBackground
         markedForeground = setColorIfContrastIsSufficient(markedBackground, foreground, background);
 
     // set it in the color group (different group color than normal foreground!)
     result.setHighlightedText(markedForeground);
     result.setHighlight(markedBackground);
 
     // In case the current item is a selected one, set the fore- and background colors for the contrast calculation below
     if (type.m_selectedItem) {
         background = markedBackground;
         foreground = markedForeground;
     }
 
     // finally the current item
     if (type.m_currentItem && (markCurrentAlways || isActive)) {
         // if this is the current item AND the panels has the focus OR the current should be marked always
         QColor currentBackground = getCurrentBackgroundColor(isActive);
 
         if (!currentBackground.isValid()) // transparent
             currentBackground = background;
 
         // set the background
         result.setHighlight(currentBackground);
         result.setBackground(currentBackground);
 
         QColor color;
         if (type.m_selectedItem)
             color = getCurrentMarkedForegroundColor(isActive);
         if (!color.isValid()) { // not used
             color = getCurrentForegroundColor(isActive);
             if (!color.isValid()) // transparent
                 // choose fore- or background, depending on its contrast compared to markedBackground
                 color = setColorIfContrastIsSufficient(currentBackground, foreground, background);
         }
 
         // set the foreground
         result.setText(color);
         result.setHighlightedText(color);
     }
 
     if (dimBackground && !type.m_activePanel) {
         // if color dimming is chosen, dim the colors for the inactive panel
         result.setBackground(dimColor(result.background(), true));
         result.setText(dimColor(result.text(), false));
         result.setHighlightedText(dimColor(result.highlightedText(), false));
         result.setHighlight(dimColor(result.highlight(), true));
     }
     return result;
 }
 
 const QColor & KrColorCacheImpl::setColorIfContrastIsSufficient(const QColor & background, const QColor & color1, const QColor & color2)
 {
 #define sqr(x) ((x)*(x))
     int contrast = sqr(color1.red() - background.red()) + sqr(color1.green() - background.green()) + sqr(color1.blue() - background.blue());
 
     // if the contrast between background and color1 is too small, take color2 instead.
     if (contrast < 1000)
         return color2;
     return color1;
 }
 
 QColor KrColorCacheImpl::getForegroundColor(bool isActive) const
 {
     QPalette p = QGuiApplication::palette();
     QColor color = p.color(QPalette::Active, QPalette::Text);
     SETCOLOR(color, m_colorSettings.getColorValue("Foreground"));
     if (!isActive) SETCOLOR(color, m_colorSettings.getColorValue("Inactive Foreground"));
     return color;
 }
 
 QColor KrColorCacheImpl::getSpecialForegroundColor(const QString & type, bool isActive) const
 {
     QString colorName = "Inactive " + type + " Foreground";
     if (!isActive && m_colorSettings.getColorTextValue(colorName) == "Inactive Foreground")
         return getForegroundColor(false);
     QColor color = m_colorSettings.getColorValue(type + " Foreground");
     if (!isActive) SETCOLOR(color, m_colorSettings.getColorValue(colorName));
     if (!color.isValid())
         return getForegroundColor(isActive);
     return color;
 }
 
 QColor KrColorCacheImpl::getBackgroundColor(bool isActive) const
 {
     QColor color = QGuiApplication::palette().color(QPalette::Active, QPalette::Base);
     SETCOLOR(color, m_colorSettings.getColorValue("Background"));
     if (!isActive) SETCOLOR(color, m_colorSettings.getColorValue("Inactive Background"));
     return color;
 }
 
 QColor KrColorCacheImpl::getAlternateBackgroundColor(bool isActive) const
 {
     QPalette p = QGuiApplication::palette();
     if (isActive && m_colorSettings.getColorTextValue("Alternate Background") == "Background")
         return getBackgroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Alternate Background").isEmpty())
         return getAlternateBackgroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Alternate Background") == "Inactive Background")
         return getBackgroundColor(false);
     QColor color = isActive ?
                    m_colorSettings.getColorValue("Alternate Background")
                    : m_colorSettings.getColorValue("Inactive Alternate Background");
     if (!color.isValid())
         color = p.color(QPalette::Active, QPalette::AlternateBase);
     if (!color.isValid())
         color = p.color(QPalette::Active, QPalette::Base);
     return color;
 }
 
 QColor KrColorCacheImpl::getMarkedForegroundColor(bool isActive) const
 {
     QString colorName = isActive ? "Marked Foreground" : "Inactive Marked Foreground";
     if (m_colorSettings.getColorTextValue(colorName) == "transparent")
         return QColor();
     if (isActive && m_colorSettings.getColorTextValue(colorName).isEmpty())
         return QGuiApplication::palette().color(QPalette::Active, QPalette::HighlightedText);
     if (!isActive && m_colorSettings.getColorTextValue(colorName).isEmpty())
         return getMarkedForegroundColor(true);
     return m_colorSettings.getColorValue(colorName);
 }
 
 QColor KrColorCacheImpl::getMarkedBackgroundColor(bool isActive) const
 {
     if (isActive && m_colorSettings.getColorTextValue("Marked Background").isEmpty())
         return QGuiApplication::palette().color(QPalette::Active, QPalette::Highlight);
     if (isActive && m_colorSettings.getColorTextValue("Marked Background") == "Background")
         return getBackgroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Marked Background").isEmpty())
         return getMarkedBackgroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Marked Background") == "Inactive Background")
         return getBackgroundColor(false);
     return isActive ?
            m_colorSettings.getColorValue("Marked Background")
            : m_colorSettings.getColorValue("Inactive Marked Background");
 }
 
 QColor KrColorCacheImpl::getAlternateMarkedBackgroundColor(bool isActive) const
 {
     if (isActive && m_colorSettings.getColorTextValue("Alternate Marked Background") == "Alternate Background")
         return getAlternateBackgroundColor(true);
     if (isActive && m_colorSettings.getColorTextValue("Alternate Marked Background").isEmpty())
         return getMarkedBackgroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Alternate Marked Background").isEmpty())
         return getAlternateMarkedBackgroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Alternate Marked Background") == "Inactive Alternate Background")
         return getAlternateBackgroundColor(false);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Alternate Marked Background") == "Inactive Marked Background")
         return getMarkedBackgroundColor(false);
     return isActive ?
            m_colorSettings.getColorValue("Alternate Marked Background")
            : m_colorSettings.getColorValue("Inactive Alternate Marked Background");
 }
 
 QColor KrColorCacheImpl::getCurrentForegroundColor(bool isActive) const
 {
     QColor color = m_colorSettings.getColorValue("Current Foreground");
     if (!isActive) SETCOLOR(color, m_colorSettings.getColorValue("Inactive Current Foreground"));
     return color;
 }
 
 QColor KrColorCacheImpl::getCurrentBackgroundColor(bool isActive) const
 {
     if (isActive && m_colorSettings.getColorTextValue("Current Background").isEmpty())
         return QColor();
     if (isActive && m_colorSettings.getColorTextValue("Current Background") == "Background")
         return getBackgroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Current Background").isEmpty())
         return getCurrentBackgroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue("Inactive Current Background") == "Inactive Background")
         return getBackgroundColor(false);
     return isActive ?
            m_colorSettings.getColorValue("Current Background")
            : m_colorSettings.getColorValue("Inactive Current Background");
 }
 
 QColor KrColorCacheImpl::getCurrentMarkedForegroundColor(bool isActive) const
 {
     QString colorName = isActive ? "Marked Current Foreground" : "Inactive Marked Current Foreground";
     if (isActive && m_colorSettings.getColorTextValue(colorName).isEmpty())
         return QColor();
     if (isActive && m_colorSettings.getColorTextValue(colorName) == "Marked Foreground")
         return getMarkedForegroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue(colorName).isEmpty())
         return getCurrentMarkedForegroundColor(true);
     if (!isActive && m_colorSettings.getColorTextValue(colorName) == "Inactive Marked Foreground")
         return getMarkedForegroundColor(false);
     return m_colorSettings.getColorValue(colorName);
 }
 
 QColor KrColorCacheImpl::dimColor(QColor color, bool /* isBackgroundColor */) const
 {
     int dimFactor = m_colorSettings.getNumValue("Dim Factor", 100);
     QColor targetColor = m_colorSettings.getColorValue("Dim Target Color");
     if (!targetColor.isValid())
         targetColor = QColor(255, 255, 255);
     bool dimBackground = m_colorSettings.getBoolValue("Dim Inactive Colors", false);
     bool dim = dimFactor >= 0 && dimFactor < 100 && dimBackground;
     if (dim)
         color = KrColorCache::dimColor(color, dimFactor, targetColor);
     return color;
 }
 
 
 
 
 
 
-KrColorCache * KrColorCache::m_instance = 0;
+KrColorCache * KrColorCache::m_instance = nullptr;
 
 KrColorCache::KrColorCache()
 {
     m_impl = new KrColorCacheImpl;
 }
 
 KrColorCache::~KrColorCache()
 {
     delete m_impl;
 }
 
 KrColorCache & KrColorCache::getColorCache()
 {
     if (!m_instance) {
         m_instance = new KrColorCache;
         m_instance->refreshColors();
     }
     return * m_instance;
 }
 
 void KrColorCache::getColors(KrColorGroup  & result, const KrColorItemType & type) const
 {
     // for the cache lookup: calculate a unique key from the type
     char hashKey[128];
     switch (type.m_fileType) {
     case KrColorItemType::Directory :
         strcpy(hashKey, "Directory");
         break;
     case KrColorItemType::Executable :
         strcpy(hashKey, "Executable");
         break;
     case KrColorItemType::InvalidSymlink :
         strcpy(hashKey, "InvalidSymlink");
         break;
     case KrColorItemType::Symlink :
         strcpy(hashKey, "Symlink");
         break;
     default:
         strcpy(hashKey, "File");
     }
     if (type.m_activePanel)
         strcat(hashKey, "-Active");
     if (type.m_alternateBackgroundColor)
         strcat(hashKey, "-Alternate");
     if (type.m_currentItem)
         strcat(hashKey, "-Current");
     if (type.m_selectedItem)
         strcat(hashKey, "-Selected");
 
     // lookup in cache
     if (!m_impl->m_cachedColors.contains(hashKey))
         // not found: calculate color group and store it in cache
         m_impl->m_cachedColors[hashKey] = m_impl->getColors(type);
 
     // get color group from cache
     const KrColorGroup & col = m_impl->m_cachedColors[hashKey];
 
     // copy colors in question to result color group
     result.setBackground(col.background());
     result.setText(col.text());
     result.setHighlightedText(col.highlightedText());
     result.setHighlight(col.highlight());
 }
 
 bool KrColorCache::getDimSettings(QColor & dimColor, int & dimFactor)
 {
     if (m_impl->m_colorSettings.getBoolValue("Dim Inactive Colors", false)) {
         dimFactor = m_impl->m_colorSettings.getNumValue("Dim Factor", 100);
         dimColor = m_impl->m_colorSettings.getColorValue("Dim Target Color");
         if (!dimColor.isValid())
             dimColor.setRgb(255, 255, 255);
         return dimFactor >= 0 && dimFactor < 100;
     }
     return false;
 }
 
 QColor KrColorCache::dimColor(const QColor & color, int dim, const QColor & targetColor)
 {
     return QColor((targetColor.red() * (100 - dim) + color.red() * dim) / 100,
                   (targetColor.green() * (100 - dim) + color.green() * dim) / 100,
                   (targetColor.blue() * (100 - dim) + color.blue() * dim) / 100);
 }
 
 void KrColorCache::refreshColors()
 {
     m_impl->m_cachedColors.clear();
     m_impl->m_colorSettings = KrColorSettings();
     QPixmapCache::clear(); // dimmed icons are cached
     colorsRefreshed();
 }
 
 void KrColorCache::setColors(const KrColorSettings & colorSettings)
 {
     m_impl->m_cachedColors.clear();
     m_impl->m_colorSettings = colorSettings;
     QPixmapCache::clear(); // dimmed icons are cached
     colorsRefreshed();
 }
 
diff --git a/krusader/Panel/krcolorcache.h b/krusader/Panel/krcolorcache.h
index aa61c55a..ad065d83 100644
--- a/krusader/Panel/krcolorcache.h
+++ b/krusader/Panel/krcolorcache.h
@@ -1,173 +1,173 @@
 /*****************************************************************************
  * Copyright (C) 2000-2002 Shie Erlich <erlich@users.sourceforge.net>        *
  * Copyright (C) 2000-2002 Rafi Yanai <yanai@users.sourceforge.net>          *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRCOLORCACHE_H
 #define KRCOLORCACHE_H
 
 // QtCore
 #include <QObject>
 #include <QList>
 // QtGui
 #include <QColor>
 #include <QPalette>
 
 /**
  * Design goals: Color calculation is done on one place only.
  * Configuration through krConfig OR through local settings.
  * Calculation must be fast through caching.
  *
  * This implementation exposes 3 classes:
  * KrColorSettings: holds the color settings from krConfig,
  *                  which can be changed locally
  * KrColorItemType: specifies the colors to be calculated
  * KrColorCache: performs the color calculation and caches the result.
  *               Uses KrColorSettings for the calculation
  *
  * Copies all used color settings from krConfig into a local cache on creation.
  * It contains 3 types of properties:
  * color, numeric (int) and boolean.
  * Color properties can have string or color values.
  * Property values can be changed.
  * These changes does not go into krConfig!
  *
  * is*Valid checks, if a property name is valid
  * get*Names returns a list of all allowed property names
  * set*Value overwrites a property with a new value
  * get*Value returns the current value
  *
  * For colors the value can be returned as text or as color.
  * If a text representation is not a valid color, setColorValue(QColor())
  * should be called.
  */
 class KrColorSettings
 {
     class KrColorSettingsImpl * m_impl;
 public:
     KrColorSettings();
     KrColorSettings(const KrColorSettings &);
     ~KrColorSettings();
     const KrColorSettings & operator= (const KrColorSettings &);
 
     static bool isColorNameValid(const QString & settingName);
     static QList<QString> getColorNames();
     bool setColorValue(const QString & settingName, const QColor & color);
     QColor getColorValue(const QString & settingName) const;
     bool setColorTextValue(const QString & settingName, const QString & colorText);
     QString getColorTextValue(const QString & settingName) const;
 
     static bool isNumNameValid(const QString & settingName);
     static QList<QString> getNumNames();
     bool setNumValue(const QString & settingName, int value);
     int getNumValue(const QString & settingName, int defaultValue = 0) const;
 
     static bool isBoolNameValid(const QString & settingName);
     static QList<QString> getBoolNames();
     bool setBoolValue(const QString & settingName, bool value);
     int getBoolValue(const QString & settingName, bool defaultValue = false) const;
 };
 
 /**
  * A collection of properties which describe the color group to be calculated
  */
 class KrColorItemType
 {
 public:
     enum FileType {File, InvalidSymlink, Symlink, Directory, Executable};
     FileType m_fileType;
     bool m_alternateBackgroundColor, m_activePanel, m_currentItem, m_selectedItem;
     KrColorItemType();
     KrColorItemType(FileType type, bool alternateBackgroundColor, bool activePanel, bool currentItem, bool selectedItem);
     KrColorItemType(const KrColorItemType &);
     const KrColorItemType & operator= (const KrColorItemType &);
 };
 
 /**
  * The color calculation. It bases on an internal KrColorSettings instance.
  * Via setColors it can be changed.
  * getColors does the color calculation.
  * It sets the colors Base, Background, Text, HighlightedText and Highlight.
  * All calculated values are cached.
  * The cache is deleted on refreshColors and setColors, which also trigger
  * colorsRefreshed.
  * getColorCache returns a static color cached for painting the panels.
  * On the color cache setColors should NEVER be called!
  */
 class KrColorGroup
 {
 public:
     inline KrColorGroup() : _textColor(), _backgroundColor(), _highlightedTextColor(),
             _highlightedBackgroundColor() {}
 
     inline const QColor & text() const            {
         return _textColor;
     }
     inline const QColor & background() const      {
         return _backgroundColor;
     }
     inline const QColor & highlight() const       {
         return _highlightedBackgroundColor;
     }
     inline const QColor & highlightedText() const {
         return _highlightedTextColor;
     }
 
     inline void setText(const QColor & c)               {
         _textColor = c;
     }
     inline void setBackground(const QColor & c)          {
         _backgroundColor = c;
     }
     inline void setHighlight(const QColor & c)          {
         _highlightedBackgroundColor = c;
     }
     inline void setHighlightedText(const QColor & c)    {
         _highlightedTextColor = c;
     }
 
 protected:
     QColor _textColor;
     QColor _backgroundColor;
     QColor _highlightedTextColor;
     QColor _highlightedBackgroundColor;
 };
 
 class KrColorCache : public QObject
 {
     Q_OBJECT
     static KrColorCache * m_instance;
     class KrColorCacheImpl * m_impl;
     KrColorCache(const KrColorCache &);
     const KrColorCache & operator= (const KrColorCache &);
 public:
     KrColorCache();
-    ~KrColorCache();
+    ~KrColorCache() override;
     static KrColorCache & getColorCache();
     void getColors(KrColorGroup & result, const KrColorItemType & type) const;
     bool getDimSettings(QColor & dimColor, int & dimFactor);
     static QColor dimColor(const QColor & color, int dim, const QColor & targetColor);
 public slots:
     void refreshColors();
     void setColors(const KrColorSettings &);
 signals:
     void colorsRefreshed();
 };
 
 #endif
diff --git a/krusader/Panel/krerrordisplay.cpp b/krusader/Panel/krerrordisplay.cpp
index bdb6de9f..cda39959 100644
--- a/krusader/Panel/krerrordisplay.cpp
+++ b/krusader/Panel/krerrordisplay.cpp
@@ -1,67 +1,67 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krerrordisplay.h"
 #include <stdio.h>
 
 #include "krcolorcache.h"
 
 
 KrErrorDisplay::KrErrorDisplay(QWidget *parent) :
     QLabel(parent),
     _currentDim(100)
 {
     setAutoFillBackground(true);
     _startColor = QColor(240,150,150);
     QPalette p(palette());
     _targetColor = p.color(QPalette::Window);
     p.setColor(QPalette::Window, _startColor);
     setPalette(p);
 
     _dimTimer.setSingleShot(true);
     connect(&_dimTimer, &QTimer::timeout, this, &KrErrorDisplay::slotTimeout);
 }
 
-void KrErrorDisplay::setText(QString text)
+void KrErrorDisplay::setText(const QString& text)
 {
     QLabel::setText(text);
     _currentDim = 100;
 
     QPalette p(palette());
     p.setColor(QPalette::Window, _startColor);
     setPalette(p);
 
     _dimTimer.start(5000);
 }
 
 void KrErrorDisplay::slotTimeout()
 {
     _currentDim -= 2;
     dim();
     if( _currentDim > 0)
         _dimTimer.start(50);
 }
 
 void KrErrorDisplay::dim()
 {
     QPalette p(palette());
     p.setColor(QPalette::Window, KrColorCache::dimColor(_startColor, _currentDim, _targetColor));
     setPalette(p);
 }
diff --git a/krusader/Panel/krerrordisplay.h b/krusader/Panel/krerrordisplay.h
index c30ea6a5..4a9c4560 100644
--- a/krusader/Panel/krerrordisplay.h
+++ b/krusader/Panel/krerrordisplay.h
@@ -1,52 +1,52 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRERRORDISPLAY_H
 #define KRERRORDISPLAY_H
 
 // QtCore
 #include <QTimer>
 // QtGui
 #include <QColor>
 // QtWidgets
 #include <QWidget>
 #include <QLabel>
 
 class KrErrorDisplay: public QLabel
 {
     Q_OBJECT
 public:
     explicit KrErrorDisplay(QWidget *parent);
 
-    void setText(QString text);
+    void setText(const QString& text);
 
 private slots:
     void slotTimeout();
 
 private:
     void dim();
 
     QTimer _dimTimer;
     QColor _startColor;
     QColor _targetColor;
     int _currentDim;
 };
 
 #endif
diff --git a/krusader/Panel/krfiletreeview.cpp b/krusader/Panel/krfiletreeview.cpp
index 1c14abed..9a7723a9 100644
--- a/krusader/Panel/krfiletreeview.cpp
+++ b/krusader/Panel/krfiletreeview.cpp
@@ -1,401 +1,400 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #include "krfiletreeview.h"
 
 #include "panelfunc.h"
 
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../FileSystem/filesystemprovider.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QCursor>
 #include <QDir>
 #include <QDropEvent>
 #include <QHeaderView>
 #include <QMenu>
 #include <QMimeData>
 #include <QProxyStyle>
 
 #include <KFileItemListProperties>
 #include <KJobWidgets>
 #include <KUrlMimeData>
 
 #include <KI18n/KLocalizedString>
 #include <KIO/DropJob>
 #include <KIO/Paste>
 #include <KIO/PasteJob>
 #include <KIOCore/KFileItem>
 #include <KIOWidgets/KDirLister>
 #include <KIOWidgets/KFileItemDelegate>
 #include <KIOWidgets/KPropertiesDialog>
 
 
 class KrDirModel : public KDirModel
 {
 public:
     KrDirModel(QWidget *parent, KrFileTreeView *ftv) : KDirModel(parent), fileTreeView(ftv) {}
 
 protected:
-    virtual Qt::ItemFlags flags(const QModelIndex &index) const Q_DECL_OVERRIDE
+    Qt::ItemFlags flags(const QModelIndex &index) const Q_DECL_OVERRIDE
     {
         Qt::ItemFlags itflags = KDirModel::flags(index);
         if (index.column() != KDirModel::Name)
             itflags &= ~Qt::ItemIsDropEnabled;
         return itflags;
     }
 
 private:
     KrFileTreeView *fileTreeView;
 };
 
 class TreeStyle : public QProxyStyle
 {
 public:
     explicit TreeStyle(QStyle *style) : QProxyStyle(style) {}
 
     int styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget,
                   QStyleHintReturn *returnData) const Q_DECL_OVERRIDE
     {
         if (hint == QStyle::SH_ItemView_ActivateItemOnSingleClick) {
             return true;
         }
 
         return QProxyStyle::styleHint(hint, option, widget, returnData);
     }
 };
 
 KrFileTreeView::KrFileTreeView(QWidget *parent)
-    : QTreeView(parent), mCurrentUrl(),
-      mCurrentTreeBase(), mStartTreeFromCurrent(false), mStartTreeFromPlace(true)
+    : QTreeView(parent), mStartTreeFromCurrent(false), mStartTreeFromPlace(true)
 {
     mSourceModel = new KrDirModel(this, this);
     mSourceModel->dirLister()->setDirOnlyMode(true);
 
     mProxyModel = new KDirSortFilterProxyModel(this);
     mProxyModel->setSourceModel(mSourceModel);
     setModel(mProxyModel);
 
     mFilePlacesModel = new KFilePlacesModel(this);
 
     setItemDelegate(new KFileItemDelegate(this));
     setUniformRowHeights(true);
 
     // drag&drop
     setAcceptDrops(true);
     setDragEnabled(true);
     setDropIndicatorShown(true);
     mSourceModel->setDropsAllowed(KDirModel::DropOnDirectory);
 
     setStyle(new TreeStyle(style()));
     connect(this, &KrFileTreeView::activated, this, &KrFileTreeView::slotActivated);
 
     connect(mSourceModel, &KDirModel::expand, this, &KrFileTreeView::slotExpanded);
 
     QFontMetrics fontMetrics(viewport()->font());
     header()->resizeSection(KDirModel::Name, fontMetrics.width("WWWWWWWWWWWWWWW"));
 
     header()->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(header(), &QHeaderView::customContextMenuRequested, this,
             &KrFileTreeView::showHeaderContextMenu);
 
     setBriefMode(true);
 
     setContextMenuPolicy(Qt::CustomContextMenu);
     connect(this, &KrFileTreeView::customContextMenuRequested, this,
             &KrFileTreeView::slotCustomContextMenuRequested);
 
     setTree(mStartTreeFromCurrent, mStartTreeFromPlace);
 }
 
 void KrFileTreeView::setCurrentUrl(const QUrl &url)
 {
     mCurrentUrl = url;
     if (mStartTreeFromCurrent) {
         setTreeRoot(url);
     } else {
         if (mStartTreeFromPlace) {
             const QModelIndex index = mFilePlacesModel->closestItem(url); // magic here
             const QUrl rootBase = index.isValid() ? mFilePlacesModel->url(index) :
                                                     QUrl::fromLocalFile(QDir::root().path());
             setTreeRoot(rootBase);
         }
         if (isVisible(url)) {
             // avoid unwanted scrolling by KDirModel::expandToUrl()
             setCurrentIndex(mProxyModel->mapFromSource(mSourceModel->indexForUrl(url)));
         } else {
             mSourceModel->expandToUrl(url);
         }
     }
 }
 
 QUrl KrFileTreeView::urlForProxyIndex(const QModelIndex &index) const
 {
     const KFileItem item = mSourceModel->itemForIndex(mProxyModel->mapToSource(index));
 
     return !item.isNull() ? item.url() : QUrl();
 }
 
 void KrFileTreeView::slotActivated(const QModelIndex &index)
 {
     const QUrl url = urlForProxyIndex(index);
     if (url.isValid()) {
         emit urlActivated(url);
     }
 }
 
 void KrFileTreeView::dropEvent(QDropEvent *event)
 {
     QUrl destination = urlForProxyIndex(indexAt(event->pos()));
     if (destination.isEmpty()) {
         return;
     }
 
     FileSystemProvider::instance().startDropFiles(event, destination);
 }
 
 void KrFileTreeView::slotExpanded(const QModelIndex &baseIndex)
 {
     const QModelIndex index = mProxyModel->mapFromSource(baseIndex);
 
     expand(index); // expand view now after model was expanded
     selectionModel()->clearSelection();
     selectionModel()->setCurrentIndex(index, QItemSelectionModel::SelectCurrent);
 
     scrollTo(index);
 }
 
 void KrFileTreeView::showHeaderContextMenu()
 {
     QMenu popup(this);
     popup.setToolTipsVisible(true);
 
     QAction *detailAction = popup.addAction(i18n("Show Details"));
     detailAction->setCheckable(true);
     detailAction->setChecked(!briefMode());
     detailAction->setToolTip(i18n("Show columns with details"));
     QAction *showHiddenAction = popup.addAction(i18n("Show Hidden Folders"));
     showHiddenAction->setCheckable(true);
     showHiddenAction->setChecked(mSourceModel->dirLister()->showingDotFiles());
     showHiddenAction->setToolTip(i18n("Show folders starting with a dot"));
 
     popup.addSeparator();
-    QActionGroup *rootActionGroup = new QActionGroup(this);
+    auto *rootActionGroup = new QActionGroup(this);
 
     QAction *startFromRootAction = popup.addAction(i18n("Start From Root"));
     startFromRootAction->setCheckable(true);
     startFromRootAction->setChecked(!mStartTreeFromCurrent && !mStartTreeFromPlace);
     startFromRootAction->setToolTip(i18n("Set root of the tree to root of filesystem"));
     startFromRootAction->setActionGroup(rootActionGroup);
 
     QAction *startFromCurrentAction = popup.addAction(i18n("Start From Current"));
     startFromCurrentAction->setCheckable(true);
     startFromCurrentAction->setChecked(mStartTreeFromCurrent);
     startFromCurrentAction->setToolTip(i18n("Set root of the tree to the current folder"));
     startFromCurrentAction->setActionGroup(rootActionGroup);
 
     QAction *startFromPlaceAction = popup.addAction(i18n("Start From Place"));
     startFromPlaceAction->setCheckable(true);
     startFromPlaceAction->setChecked(mStartTreeFromPlace);
     startFromPlaceAction->setToolTip(
         i18n("Set root of the tree to closest folder listed in 'Places'"));
     startFromPlaceAction->setActionGroup(rootActionGroup);
 
     QAction *triggeredAction = popup.exec(QCursor::pos());
     if (triggeredAction == detailAction) {
         setBriefMode(!detailAction->isChecked());
     } else if (triggeredAction == showHiddenAction) {
         KDirLister *dirLister = mSourceModel->dirLister();
         dirLister->setShowingDotFiles(showHiddenAction->isChecked());
         dirLister->emitChanges();
     } else if (triggeredAction && triggeredAction->actionGroup() == rootActionGroup) {
         setTree(startFromCurrentAction->isChecked(), startFromPlaceAction->isChecked());
     }
 }
 
 void KrFileTreeView::slotCustomContextMenuRequested(const QPoint &point)
 {
     const QModelIndex index = indexAt(point);
     if (!index.isValid())
         return;
 
     const KFileItem fileItem = mSourceModel->itemForIndex(mProxyModel->mapToSource(index));
     const KFileItemListProperties capabilities(KFileItemList() << fileItem);
 
-    QMenu* popup = new QMenu(this);
+    auto* popup = new QMenu(this);
 
     // TODO nice to have: "open with"
 
     // cut/copy/paste
     QAction* cutAction = new QAction(Icon(QStringLiteral("edit-cut")), i18nc("@action:inmenu", "Cut"), this);
     cutAction->setEnabled(capabilities.supportsMoving());
     connect(cutAction, &QAction::triggered, this, [=]() { copyToClipBoard(fileItem, true); });
     popup->addAction(cutAction);
 
     QAction* copyAction = new QAction(Icon(QStringLiteral("edit-copy")), i18nc("@action:inmenu", "Copy"), this);
     connect(copyAction, &QAction::triggered, this, [=]() { copyToClipBoard(fileItem, false); });
     popup->addAction(copyAction);
 
     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
     bool canPaste;
     const QString text = KIO::pasteActionText(mimeData, &canPaste, fileItem);
     QAction* pasteAction = new QAction(Icon(QStringLiteral("edit-paste")), text, this);
     connect(pasteAction, &QAction::triggered, this, [=]() {
         KIO::PasteJob *job = KIO::paste(QApplication::clipboard()->mimeData(), fileItem.url());
         KJobWidgets::setWindow(job, this);
     });
     pasteAction->setEnabled(canPaste);
     popup->addAction(pasteAction);
 
     popup->addSeparator();
 
     // TODO nice to have: rename
 
     // trash
     if (KConfigGroup(krConfig, "General").readEntry("Move To Trash", _MoveToTrash)) {
         QAction* moveToTrashAction = new QAction(Icon(QStringLiteral("user-trash")),
                                                 i18nc("@action:inmenu", "Move to Trash"), this);
         const bool enableMoveToTrash = capabilities.isLocal() && capabilities.supportsMoving();
         moveToTrashAction->setEnabled(enableMoveToTrash);
         connect(moveToTrashAction, &QAction::triggered, this, [=]() {
             deleteFile(fileItem, true);
         });
         popup->addAction(moveToTrashAction);
     }
 
     // delete
     QAction *deleteAction = new QAction(Icon(QStringLiteral("edit-delete")),
                                         i18nc("@action:inmenu", "Delete"), this);
     deleteAction->setEnabled(capabilities.supportsDeleting());
     connect(deleteAction, &QAction::triggered, this, [=]() {
         deleteFile(fileItem, false);
     });
     popup->addAction(deleteAction);
 
     popup->addSeparator();
 
     // properties
     if (!fileItem.isNull()) {
         QAction* propertiesAction = new QAction(i18nc("@action:inmenu", "Properties"), this);
         propertiesAction->setIcon(Icon(QStringLiteral("document-properties")));
         connect(propertiesAction, &QAction::triggered, this, [=]() {
             KPropertiesDialog* dialog = new KPropertiesDialog(fileItem.url(), this);
             dialog->setAttribute(Qt::WA_DeleteOnClose);
             dialog->show();
         });
         popup->addAction(propertiesAction);
     }
 
     QPointer<QMenu> popupPtr = popup;
     popup->exec(QCursor::pos());
     if (popupPtr.data()) {
         popupPtr.data()->deleteLater();
     }
 }
 
 void KrFileTreeView::copyToClipBoard(const KFileItem &fileItem, bool cut) const
 {
-    QMimeData* mimeData = new QMimeData();
+    auto* mimeData = new QMimeData();
 
     QList<QUrl> kdeUrls;
     kdeUrls.append(fileItem.url());
     QList<QUrl> mostLocalUrls;
     bool dummy;
     mostLocalUrls.append(fileItem.mostLocalUrl(dummy));
 
     KIO::setClipboardDataCut(mimeData, cut);
     KUrlMimeData::setUrls(kdeUrls, mostLocalUrls, mimeData);
 
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void KrFileTreeView::deleteFile(const KFileItem &fileItem, bool moveToTrash) const
 {
     const QList<QUrl> confirmedFiles =
         ListPanelFunc::confirmDeletion(QList<QUrl>() << fileItem.url(), moveToTrash, false, true);
     if (confirmedFiles.isEmpty())
         return;
 
     FileSystemProvider::instance().startDeleteFiles(confirmedFiles, moveToTrash);
 }
 
 bool KrFileTreeView::briefMode() const
 {
     return isColumnHidden(mProxyModel->columnCount() - 1); // find out by last column
 }
 
 void KrFileTreeView::setBriefMode(bool brief)
 {
     for (int i=1; i < mProxyModel->columnCount(); i++) { // show only first column
         setColumnHidden(i, brief);
     }
 }
 
 void KrFileTreeView::setTree(bool startFromCurrent, bool startFromPlace)
 {
     mStartTreeFromCurrent = startFromCurrent;
     mStartTreeFromPlace = startFromPlace;
 
     if (!mStartTreeFromCurrent && !mStartTreeFromPlace) {
         setTreeRoot(QUrl::fromLocalFile(QDir::root().path()));
     }
     setCurrentUrl(mCurrentUrl); // refresh
 }
 
 void KrFileTreeView::setTreeRoot(const QUrl &rootBase)
 {
     if (rootBase == mCurrentTreeBase) // avoid collapsing the subdirs in tree
         return;
 
     mCurrentTreeBase = rootBase;
     mSourceModel->dirLister()->openUrl(mCurrentTreeBase);
 }
 
 void KrFileTreeView::saveSettings(KConfigGroup cfg) const
 {
     KConfigGroup group = KConfigGroup(&cfg, "TreeView");
     group.writeEntry("BriefMode", briefMode());
     group.writeEntry("ShowHiddenFolders", mSourceModel->dirLister()->showingDotFiles());
     group.writeEntry("StartFromCurrent", mStartTreeFromCurrent);
     group.writeEntry("StartFromPlace", mStartTreeFromPlace);
 }
 
 void KrFileTreeView::restoreSettings(const KConfigGroup &cfg)
 {
     const KConfigGroup group = KConfigGroup(&cfg, "TreeView");
     setBriefMode(group.readEntry("BriefMode", true));
     mSourceModel->dirLister()->setShowingDotFiles(group.readEntry("ShowHiddenFolders", false));
     setTree(group.readEntry("StartFromCurrent", false),
                 group.readEntry("StartFromPlace", false));
 }
 
 bool KrFileTreeView::isVisible(const QUrl &url)
 {
     QModelIndex index = indexAt(rect().topLeft());
     while (index.isValid()) {
         if (url == urlForProxyIndex(index)) {
             return true;
         }
         index = indexBelow(index);
     }
     return false;
 }
diff --git a/krusader/Panel/krfiletreeview.h b/krusader/Panel/krfiletreeview.h
index 5cb7d9e0..55ea753b 100644
--- a/krusader/Panel/krfiletreeview.h
+++ b/krusader/Panel/krfiletreeview.h
@@ -1,89 +1,89 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRFILETREEVIEW_H
 #define KRFILETREEVIEW_H
 
 #include <QList>
 #include <QModelIndex>
 #include <QTreeView>
 #include <QUrl>
 #include <QWidget>
 
 #include <KConfigCore/KSharedConfig>
 #include <KIOFileWidgets/KDirSortFilterProxyModel>
 #include <KIOFileWidgets/KFilePlacesModel>
 #include <KIOWidgets/KDirModel>
 
 /**
  * Show folders in a tree view.
  *
  * A context menu with settings is accessible through the header.
  *
  * Supports dragging from this view and dropping files on it.
  */
 class KrFileTreeView : public QTreeView
 {
     friend class KrDirModel;
     Q_OBJECT
 
 public:
-    explicit KrFileTreeView(QWidget *parent = 0);
-    virtual ~KrFileTreeView() {}
+    explicit KrFileTreeView(QWidget *parent = nullptr);
+    ~KrFileTreeView() override = default;
 
     void setCurrentUrl(const QUrl &url);
 
     void saveSettings(KConfigGroup cfg) const;
     void restoreSettings(const KConfigGroup &cfg);
 
 signals:
     void urlActivated(const QUrl &url);
 
 private slots:
     void slotActivated(const QModelIndex &index);
     void slotExpanded(const QModelIndex&);
     void showHeaderContextMenu();
     void slotCustomContextMenuRequested(const QPoint &point);
 
 protected:
     void dropEvent(QDropEvent *event) Q_DECL_OVERRIDE;
 
 private:
     QUrl urlForProxyIndex(const QModelIndex &index) const;
     void dropMimeData(const QList<QUrl> & lst, const QUrl &url) const;
     void copyToClipBoard(const KFileItem &fileItem, bool cut) const;
     void deleteFile(const KFileItem &fileItem, bool moveToTrash = true) const;
     bool briefMode() const;
     void setBriefMode(bool brief); // show only column with directory names
     void setTree(bool startFromCurrent, bool startFromPlace);
     void setTreeRoot(const QUrl &rootBase);
     bool isVisible(const QUrl &url);
 
     KDirModel *mSourceModel;
     KDirSortFilterProxyModel *mProxyModel;
     KFilePlacesModel *mFilePlacesModel;
     QUrl mCurrentUrl;
     QUrl mCurrentTreeBase;
 
     bool mStartTreeFromCurrent; // NAND...
     bool mStartTreeFromPlace;
 };
 
 #endif // KRFILETREEVIEW_H
diff --git a/krusader/Panel/krlayoutfactory.cpp b/krusader/Panel/krlayoutfactory.cpp
index bfac7404..f9dc3867 100644
--- a/krusader/Panel/krlayoutfactory.cpp
+++ b/krusader/Panel/krlayoutfactory.cpp
@@ -1,306 +1,306 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krlayoutfactory.h"
 
 #include "listpanelframe.h"
 #include "listpanel.h"
 #include "../krglobal.h"
 
 // QtCore
 #include <QDebug>
 #include <QMetaEnum>
 #include <QFile>
 #include <QResource>
 #include <QStandardPaths>
 // QtWidgets
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 // QtXml
 #include <QDomDocument>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 #define XMLFILE_VERSION "1.0"
 #define MAIN_FILE "layout.xml"
 #define MAIN_FILE_RC_PATH ":/" MAIN_FILE
 #define EXTRA_FILE_MASK "layouts/*.xml"
 #define DEFAULT_LAYOUT "krusader:default"
 
 
 bool KrLayoutFactory::_parsed = false;
 QDomDocument KrLayoutFactory::_mainDoc;
 QList<QDomDocument> KrLayoutFactory::_extraDocs;
 
 
-QString KrLayoutFactory::layoutDescription(QString layoutName)
+QString KrLayoutFactory::layoutDescription(const QString& layoutName)
 {
     if(layoutName == DEFAULT_LAYOUT)
         return i18nc("Default layout", "Default");
     else if(layoutName == "krusader:compact")
         return i18n("Compact");
     else if(layoutName == "krusader:classic")
         return i18n("Classic");
     else
         return i18n("Custom layout: \"%1\"", layoutName);
 }
 
 bool KrLayoutFactory::parseFiles()
 {
     if (_parsed)
         return true;
 
     _parsed = parseResource(MAIN_FILE_RC_PATH, _mainDoc);
     if (!_parsed) {
         return false;
     }
 
     QStringList extraFilePaths = QStandardPaths::locateAll(QStandardPaths::DataLocation, EXTRA_FILE_MASK);
 
     foreach(const QString &path, extraFilePaths) {
         qWarning() << "extra file: " << path;
         QDomDocument doc;
         if (parseFile(path, doc))
             _extraDocs << doc;
     }
 
     return true;
 }
 
-bool KrLayoutFactory::parseFile(QString path, QDomDocument &doc)
+bool KrLayoutFactory::parseFile(const QString& path, QDomDocument &doc)
 {
     bool success = false;
 
     QFile file(path);
 
     if (file.open(QIODevice::ReadOnly))
         return parseContent(file.readAll(), path, doc);
     else
         qWarning() << "can't open" << path;
 
     return success;
 }
 
-bool KrLayoutFactory::parseResource(QString path, QDomDocument &doc)
+bool KrLayoutFactory::parseResource(const QString& path, QDomDocument &doc)
 {
     QResource res(path);
     if (res.isValid()) {
         QByteArray data;
         if (res.isCompressed())
             data = qUncompress(res.data(), res.size());
         else
             data = QByteArray(reinterpret_cast<const char*>(res.data()), res.size());
         return parseContent(data, path, doc);
     } else {
         qWarning() << "resource does not exist:" << path;
         return false;
     }
 }
 
-bool KrLayoutFactory::parseContent(QByteArray content, QString fileName, QDomDocument &doc)
+bool KrLayoutFactory::parseContent(const QByteArray& content, const QString& fileName, QDomDocument &doc)
 {
     bool success = false;
 
     QString errorMsg;
     if (doc.setContent(content, &errorMsg)) {
         QDomElement root = doc.documentElement();
         if (root.tagName() == "KrusaderLayout") {
             QString version = root.attribute("version");
             if(version == XMLFILE_VERSION)
                 success = true;
             else
                 qWarning() << fileName << "has wrong version" << version << "- required is" << XMLFILE_VERSION;
         } else
             qWarning() << "root.tagName() != \"KrusaderLayout\"";
     } else
         qWarning() << "error parsing" << fileName << ":" << errorMsg;
 
     return success;
 }
 
-void KrLayoutFactory::getLayoutNames(QDomDocument doc, QStringList &names)
+void KrLayoutFactory::getLayoutNames(const QDomDocument& doc, QStringList &names)
 {
     QDomElement root = doc.documentElement();
 
     for(QDomElement e = root.firstChildElement(); ! e.isNull(); e = e.nextSiblingElement()) {
         if (e.tagName() == "layout") {
             QString name(e.attribute("name"));
             if (!name.isEmpty() && (name != DEFAULT_LAYOUT))
                 names << name;
         }
     }
 }
 
 QStringList KrLayoutFactory::layoutNames()
 {
     QStringList names;
     names << DEFAULT_LAYOUT;
 
     if (parseFiles()) {
         getLayoutNames(_mainDoc, names);
 
         foreach(const QDomDocument &doc, _extraDocs)
             getLayoutNames(doc, names);
     }
 
     return names;
 }
 
-QDomElement KrLayoutFactory::findLayout(QDomDocument doc, QString layoutName)
+QDomElement KrLayoutFactory::findLayout(const QDomDocument& doc, const QString& layoutName)
 {
     QDomElement root = doc.documentElement();
 
     for(QDomElement e = root.firstChildElement(); ! e.isNull(); e = e.nextSiblingElement()) {
         if (e.tagName() == "layout" && e.attribute("name") == layoutName)
             return e;
     }
 
     return QDomElement();
 }
 
 QLayout *KrLayoutFactory::createLayout(QString layoutName)
 {
     if(layoutName.isEmpty()) {
         KConfigGroup cg(krConfig, "PanelLayout");
         layoutName = cg.readEntry("Layout", DEFAULT_LAYOUT);
     }
-    QLayout *layout = 0;
+    QLayout *layout = nullptr;
 
     if (parseFiles()) {
         QDomElement layoutRoot;
 
         layoutRoot = findLayout(_mainDoc, layoutName);
         if (layoutRoot.isNull()) {
             foreach(const QDomDocument &doc, _extraDocs) {
                 layoutRoot = findLayout(doc, layoutName);
                 if(!layoutRoot.isNull())
                     break;
             }
         }
         if (layoutRoot.isNull()) {
             qWarning() << "no layout with name" << layoutName << "found";
             if(layoutName != DEFAULT_LAYOUT)
                 return createLayout(DEFAULT_LAYOUT);
         } else {
             layout = createLayout(layoutRoot, panel);
         }
     }
 
     if(layout) {
         foreach(const QString &name, widgets.keys()) {
             qWarning() << "widget" << name << "was not added to the layout";
             widgets[name]->hide();
         }
     } else
          qWarning() << "couldn't load layout" << layoutName;
 
 
     return layout;
 }
 
-QBoxLayout *KrLayoutFactory::createLayout(QDomElement e, QWidget *parent)
+QBoxLayout *KrLayoutFactory::createLayout(const QDomElement& e, QWidget *parent)
 {
-    QBoxLayout *l = 0;
+    QBoxLayout *l = nullptr;
     bool horizontal = false;
 
     if(e.attribute("type") == "horizontal") {
         horizontal = true;
         l = new QHBoxLayout();
     }
     else if(e.attribute("type") == "vertical")
         l = new QVBoxLayout();
     else {
         qWarning() << "unknown layout type:" << e.attribute("type");
-        return 0;
+        return nullptr;
     }
 
     l->setSpacing(0);
     l->setContentsMargins(0, 0, 0, 0);
 
     for(QDomElement child = e.firstChildElement(); ! child.isNull(); child = child.nextSiblingElement()) {
         if (child.tagName() == "layout") {
             if(QLayout *childLayout = createLayout(child, parent))
                 l->addLayout(childLayout);
         } else if(child.tagName() == "frame") {
             QWidget *frame = createFrame(child, parent);
             l->addWidget(frame);
         } else if(child.tagName() == "widget") {
             if(QWidget *w = widgets.take(child.attribute("name")))
                 l->addWidget(w);
             else
                 qWarning() << "layout: no such widget:" << child.attribute("name");
         } else if(child.tagName() == "hide_widget") {
             if(QWidget *w = widgets.take(child.attribute("name")))
                 w->hide();
             else
                 qWarning() << "layout: no such widget:" << child.attribute("name");
         } else if(child.tagName() == "spacer") {
             if(horizontal)
                 l->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed));
             else
                 l->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Fixed, QSizePolicy::Expanding));
         }
     }
 
     return l;
 }
 
-QWidget *KrLayoutFactory::createFrame(QDomElement e, QWidget *parent)
+QWidget *KrLayoutFactory::createFrame(const QDomElement& e, QWidget *parent)
 {
     KConfigGroup cg(krConfig, "PanelLayout");
 
     QString color = cg.readEntry("FrameColor", "default");
     if(color == "default")
         color = e.attribute("color");
     else if(color == "none")
         color.clear();
 
     int shadow = -1, shape = -1;
 
     QMetaEnum shadowEnum = QFrame::staticMetaObject.enumerator(QFrame::staticMetaObject.indexOfEnumerator("Shadow"));
     QString cfgShadow = cg.readEntry("FrameShadow", "default");
     if(cfgShadow != "default")
         shadow = shadowEnum.keyToValue(cfgShadow.toLatin1().data());
     if(shadow < 0)
         shadow = shadowEnum.keyToValue(e.attribute("shadow").toLatin1().data());
 
     QMetaEnum shapeEnum = QFrame::staticMetaObject.enumerator(QFrame::staticMetaObject.indexOfEnumerator("Shape"));
     QString cfgShape = cg.readEntry("FrameShape", "default");
     if(cfgShape!= "default")
         shape = shapeEnum.keyToValue(cfgShape.toLatin1().data());
     if(shape < 0)
         shape = shapeEnum.keyToValue(e.attribute("shape").toLatin1().data());
 
     ListPanelFrame *frame = new ListPanelFrame(parent, color);
     frame->setFrameStyle(shape | shadow);
     frame->setAcceptDrops(true);
 
     if(QLayout *l = createLayout(e, frame)) {
         l->setContentsMargins(frame->frameWidth(), frame->frameWidth(), frame->frameWidth(), frame->frameWidth());
         frame->setLayout(l);
     }
 
     QObject::connect(frame, &ListPanelFrame::dropped, panel, [=](QDropEvent *event) { qobject_cast<ListPanel*>(panel)->handleDrop(event); });
     if(!color.isEmpty())
         QObject::connect(panel, &ListPanel::signalRefreshColors, frame, &ListPanelFrame::refreshColors);
 
     return frame;
 }
diff --git a/krusader/Panel/krlayoutfactory.h b/krusader/Panel/krlayoutfactory.h
index a64be59a..846515da 100644
--- a/krusader/Panel/krlayoutfactory.h
+++ b/krusader/Panel/krlayoutfactory.h
@@ -1,68 +1,68 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRLAYOUTFACTORY_H
 #define KRLAYOUTFACTORY_H
 
 // QtCore
 #include <QString>
 #include <QHash>
 // QtWidgets
 #include <QBoxLayout>
 #include <QLayout>
 #include <QWidget>
 // QtXml
 #include <QDomElement>
 
 class ListPanel;
 
 
 class KrLayoutFactory
 {
 public:
     KrLayoutFactory(ListPanel *panel, QHash<QString, QWidget *> &widgets)
         : panel(panel), widgets(widgets)
     {}
     // creates the layout and adds the widgets to it
     QLayout *createLayout(QString layoutName = QString());
 
     static QStringList layoutNames();
-    static QString layoutDescription(QString layoutName);
+    static QString layoutDescription(const QString& layoutName);
 
 private:
-    QBoxLayout *createLayout(QDomElement e, QWidget *parent);
-    QWidget *createFrame(QDomElement e, QWidget *parent);
+    QBoxLayout *createLayout(const QDomElement& e, QWidget *parent);
+    QWidget *createFrame(const QDomElement& e, QWidget *parent);
 
     static bool parseFiles();
-    static bool parseFile(QString path, QDomDocument &doc);
-    static bool parseResource(QString path, QDomDocument &doc);
-    static bool parseContent(QByteArray content, QString fileName, QDomDocument &doc);
-    static void getLayoutNames(QDomDocument doc, QStringList &names);
-    static QDomElement findLayout(QDomDocument doc, QString layoutName);
+    static bool parseFile(const QString& path, QDomDocument &doc);
+    static bool parseResource(const QString& path, QDomDocument &doc);
+    static bool parseContent(const QByteArray& content, const QString& fileName, QDomDocument &doc);
+    static void getLayoutNames(const QDomDocument& doc, QStringList &names);
+    static QDomElement findLayout(const QDomDocument& doc, const QString& layoutName);
 
     ListPanel *panel;
     QHash<QString, QWidget*> &widgets;
 
     static bool _parsed;
     static QDomDocument _mainDoc;
     static QList<QDomDocument> _extraDocs;
 };
 
 #endif
diff --git a/krusader/Panel/krpreviewjob.cpp b/krusader/Panel/krpreviewjob.cpp
index d5de989e..cace272f 100644
--- a/krusader/Panel/krpreviewjob.cpp
+++ b/krusader/Panel/krpreviewjob.cpp
@@ -1,162 +1,162 @@
 /*****************************************************************************
  * Copyright (C) 2009 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krpreviewjob.h"
 
 #include "krpreviews.h"
 #include "PanelView/krview.h"
 #include "PanelView/krviewitem.h"
 #include "../FileSystem/fileitem.h"
 #include "../defaults.h"
 
 #include <stdio.h>
 
 // QtWidgets
 #include <QWidget>
 
 #define ASSERT(what) if(!what) abort();
 
 // how much items to process by a single job
 // view becomes unresponsive during load if set too high
 #define MAX_CHUNK_SIZE 50
 
 
-KrPreviewJob::KrPreviewJob(KrPreviews *parent) : _job(0), _parent(parent)
+KrPreviewJob::KrPreviewJob(KrPreviews *parent) : _job(nullptr), _parent(parent)
 {
     _timer.setSingleShot(true);
     _timer.setInterval(0);
     connect(&_timer, &QTimer::timeout, this, &KrPreviewJob::slotStartJob);
 }
 
 KrPreviewJob::~KrPreviewJob()
 {
     doKill();
 }
 
 void KrPreviewJob::scheduleItem(KrViewItem *item)
 {
     if(!_scheduled.contains(item)) {
         _scheduled.append(item);
         setTotalAmount(KJob::Files, totalAmount(KJob::Files) + 1);
     }
     if(!_job)
         _timer.start();
 }
 
 void KrPreviewJob::removeItem(KrViewItem *item)
 {
     setTotalAmount(KJob::Files, totalAmount(KJob::Files) - _scheduled.removeAll(item));
     if(_job) {
         doKill();
         if(!_scheduled.isEmpty())
             _timer.start();
     }
     if(_scheduled.isEmpty())
         emitResult();
 }
 
 void KrPreviewJob::slotFailed(const KFileItem & item)
 {
     slotGotPreview(item, QPixmap());
 }
 
 void KrPreviewJob::slotGotPreview(const KFileItem & item, const QPixmap & preview)
 {
     KrViewItem *vi = _hash[item];
     ASSERT(vi);
 
     _scheduled.removeOne(vi);
 
     const FileItem *file = vi->getFileItem();
     _parent->addPreview(file, preview);
     vi->redraw();
 
     setProcessedAmount(KJob::Files, processedAmount(KJob::Files) + 1);
     emitPercent(processedAmount(KJob::Files), totalAmount(KJob::Files));
 }
 
 void KrPreviewJob::slotStartJob()
 {
     ASSERT(_job == 0);
     ASSERT(!_scheduled.isEmpty());
 
     _hash.clear();
     sort();
 
     int size = _parent->_view->fileIconSize();
 
     KFileItemList list;
     for(int i = 0; i < _scheduled.count() && i < MAX_CHUNK_SIZE; i++) {
-        KFileItem fi(_scheduled[i]->getFileItem()->getUrl(), 0, 0);
+        KFileItem fi(_scheduled[i]->getFileItem()->getUrl(), nullptr, 0);
         list.append(fi);
         _hash.insert(fi, _scheduled[i]);
     }
     QStringList allPlugins = KIO::PreviewJob::availablePlugins();
     _job = new KIO::PreviewJob(list, QSize(size, size), &allPlugins);
     _job->setOverlayIconAlpha(0);
     _job->setOverlayIconSize(0);
     _job->setScaleType(KIO::PreviewJob::ScaledAndCached);
     connect(_job, &KIO::PreviewJob::gotPreview, this, &KrPreviewJob::slotGotPreview);
     connect(_job, &KIO::PreviewJob::failed, this, &KrPreviewJob::slotFailed);
     connect(_job, &KIO::PreviewJob::result, this, &KrPreviewJob::slotJobResult);
 }
 
 void KrPreviewJob::slotJobResult(KJob *job)
 {
     (void) job;
 
-    if(!disconnect(_job, 0, this, 0))
+    if(!disconnect(_job, nullptr, this, nullptr))
         abort();
 
-    _job = 0;
+    _job = nullptr;
     _hash.clear();
 
     if(_scheduled.isEmpty())
         emitResult();
     else
          _timer.start();
 }
 
 // move currently visible items to beginning of the list
 void KrPreviewJob::sort()
 {
     for(int i = 0, visible_end = 0; i < _scheduled.count(); i++) {
         KrViewItem *item = _scheduled[i];
         if(_parent->_view->widget()->rect().intersects(item->itemRect())) {
             if(i != visible_end)
                 _scheduled.move(i, visible_end);
             visible_end++;
         }
     }
 }
 
 bool KrPreviewJob::doKill()
 {
     _timer.stop();
     if(_job) {
-        if(!disconnect(_job, 0, this, 0))
+        if(!disconnect(_job, nullptr, this, nullptr))
             abort();
         if(!_job->kill())
             abort();
-        _job = 0;
+        _job = nullptr;
     }
     _hash.clear();
     return true;
 }
diff --git a/krusader/Panel/krpreviewjob.h b/krusader/Panel/krpreviewjob.h
index 5b1299c6..8e5202b7 100644
--- a/krusader/Panel/krpreviewjob.h
+++ b/krusader/Panel/krpreviewjob.h
@@ -1,66 +1,66 @@
 /*****************************************************************************
  * Copyright (C) 2009 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRPREVIEWJOB_H
 #define KRPREVIEWJOB_H
 
 // QtCore
 #include <QVector>
 #include <QHash>
 #include <QTimer>
 // QtGui
 #include <QPixmap>
 
 #include <KIO/PreviewJob>
 #include <KIOCore/KFileItem>
 
 class KrViewItem;
 class KrPreviews;
 
 class KrPreviewJob : public KJob
 {
 friend class KrPreviews;
     Q_OBJECT
 public:
-    virtual void start() Q_DECL_OVERRIDE {}
+    void start() Q_DECL_OVERRIDE {}
 
 protected slots:
     void slotStartJob();
     void slotJobResult(KJob *job);
     void slotGotPreview(const KFileItem & item, const QPixmap & preview);
     void slotFailed(const KFileItem & item);
 
 protected:
     QList<KrViewItem*> _scheduled;
     QHash<const KFileItem, KrViewItem*> _hash;
     KIO::PreviewJob *_job;
     QTimer _timer;
     KrPreviews *_parent;
 
     explicit KrPreviewJob(KrPreviews *parent);
-    ~KrPreviewJob();
+    ~KrPreviewJob() override;
     void scheduleItem(KrViewItem *item);
     void removeItem(KrViewItem *item);
 
     void sort();
-    virtual bool doKill() Q_DECL_OVERRIDE;
+    bool doKill() Q_DECL_OVERRIDE;
 };
 
 #endif // __krpreviewjob__
diff --git a/krusader/Panel/krpreviewpopup.cpp b/krusader/Panel/krpreviewpopup.cpp
index 90aaa000..0fe6b44d 100644
--- a/krusader/Panel/krpreviewpopup.cpp
+++ b/krusader/Panel/krpreviewpopup.cpp
@@ -1,151 +1,151 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krpreviewpopup.h"
 
 #include <algorithm>
 
 // QtGui
 #include <QPixmap>
 #include <QPainter>
 // QtWidgets
 #include <QApplication>
 #include <QStyleOptionMenuItem>
 #include <QProxyStyle>
 
 #include <KI18n/KLocalizedString>
 #include <KIO/PreviewJob>
 
 #include "../KViewer/krviewer.h"
 
 class KrPreviewPopup::ProxyStyle : public QProxyStyle
 {
 public:
     ProxyStyle() : QProxyStyle(QApplication::style()) {}
 
-    virtual QSize sizeFromContents(ContentsType type, const QStyleOption *option,
-                                   const QSize &contentsSize, const QWidget *widget = 0) const Q_DECL_OVERRIDE
+    QSize sizeFromContents(ContentsType type, const QStyleOption *option,
+                                   const QSize &contentsSize, const QWidget *widget = nullptr) const Q_DECL_OVERRIDE
     {
         if(type == QStyle::CT_MenuItem) {
-            const QStyleOptionMenuItem *menuItem =
+            const auto *menuItem =
                     qstyleoption_cast<const QStyleOptionMenuItem*>(option);
 
             QFontMetrics fontMetrics(menuItem->font);
             QSize iconSize = menuItem->icon.actualSize(QSize(MAX_SIZE, MAX_SIZE));
             QSize textSize = QSize(fontMetrics.boundingRect(menuItem->text).width(),
                                    fontMetrics.height());
 
             return QSize(std::max(iconSize.width(), textSize.width()) + MARGIN*2,
                          iconSize.height() + textSize.height() + MARGIN*2);
         } else
             return QProxyStyle::sizeFromContents(type, option, contentsSize, widget);
     }
 
-    virtual void drawControl(ControlElement element, const QStyleOption *option,
-                                    QPainter *painter, const QWidget *widget = 0 ) const Q_DECL_OVERRIDE
+    void drawControl(ControlElement element, const QStyleOption *option,
+                                    QPainter *painter, const QWidget *widget = nullptr ) const Q_DECL_OVERRIDE
     {
         if(element == QStyle::CE_MenuItem) {
             painter->save();
 
-            const QStyleOptionMenuItem *menuItem =
+            const auto *menuItem =
                     qstyleoption_cast<const QStyleOptionMenuItem*>(option);
 
             bool active = menuItem->state & State_Selected;
 
             QRect rect = menuItem->rect;
 
             if(active)
                 painter->fillRect(rect, menuItem->palette.brush(QPalette::Highlight));
 
             rect.adjust(MARGIN, MARGIN, -MARGIN, -MARGIN);
 
             int textHeight = QFontMetrics(menuItem->font).height();
 
             QRect previewRect = rect;
             previewRect.setHeight(rect.height() - textHeight);
             QPixmap pixmap = menuItem->icon.pixmap(menuItem->icon.actualSize(QSize(MAX_SIZE, MAX_SIZE)));
             QProxyStyle::drawItemPixmap(painter, previewRect, Qt::AlignCenter, pixmap);
 
             QRect textRect = rect;
             textRect.setTop(previewRect.bottom() + 1);
             painter->setPen(active ? menuItem->palette.highlightedText().color() :
                                      menuItem->palette.buttonText().color());
             int textFlags = Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine |
                                 Qt::AlignCenter;
             painter->drawText(textRect, textFlags, menuItem->text);
 
             painter->restore();
         } else
             QProxyStyle::drawControl(element, option, painter, widget);
     }
 };
 
 
 KrPreviewPopup::KrPreviewPopup() : jobStarted(false)
 {
     prevNotAvailAction = addAction(i18n("Preview not available"));
 
     setStyle(new ProxyStyle());
 
     connect(this, &KrPreviewPopup::triggered, this, &KrPreviewPopup::view);
 }
 
 void KrPreviewPopup::showEvent(QShowEvent *event)
 {
     QMenu::showEvent(event);
 
     if (!jobStarted) {
         QStringList allPlugins = KIO::PreviewJob::availablePlugins();
         KIO::PreviewJob *pjob = new KIO::PreviewJob(files, QSize(MAX_SIZE, MAX_SIZE), &allPlugins);
             pjob->setOverlayIconSize(0);
             pjob->setOverlayIconAlpha(1);
             pjob->setScaleType(KIO::PreviewJob::ScaledAndCached);
         connect(pjob, &KIO::PreviewJob::gotPreview, this, &KrPreviewPopup::addPreview);
         jobStarted = true;
     }
 }
 
 void KrPreviewPopup::setUrls(const QList<QUrl> &urls)
 {
     foreach(const QUrl &url, urls) {
         files.push_back(KFileItem(url));
     }
 }
 
 void KrPreviewPopup::addPreview(const KFileItem& file, const QPixmap& preview)
 {
     if (prevNotAvailAction) {
         removeAction(prevNotAvailAction);
         delete prevNotAvailAction;
-        prevNotAvailAction = 0;
+        prevNotAvailAction = nullptr;
     }
 
     QAction *act = addAction(file.text());
     act->setIcon(QIcon(preview));
     act->setData(QVariant::fromValue(file.url()));
 }
 
 void KrPreviewPopup::view(QAction *clicked)
 {
     if (clicked && clicked->data().canConvert<QUrl>())
         KrViewer::view(clicked->data().value<QUrl>());
 }
 
diff --git a/krusader/Panel/krpreviewpopup.h b/krusader/Panel/krpreviewpopup.h
index 3d35343d..cd89031d 100644
--- a/krusader/Panel/krpreviewpopup.h
+++ b/krusader/Panel/krpreviewpopup.h
@@ -1,60 +1,60 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRPREVIEWPOPUP_H
 #define KRPREVIEWPOPUP_H
 
 // QtCore
 #include <QUrl>
 // QtGui
 #include <QPixmap>
 // QtWidgets
 #include <QMenu>
 
 #include <KIOCore/KFileItem>
 
 class KrPreviewPopup : public QMenu
 {
     Q_OBJECT
 
 public:
     KrPreviewPopup();
 
     void setUrls(const QList<QUrl> &urls);
 public slots:
     void addPreview(const KFileItem& file, const QPixmap& preview);
     void view(QAction *);
 
 protected:
-    virtual void showEvent(QShowEvent *event) Q_DECL_OVERRIDE;
+    void showEvent(QShowEvent *event) Q_DECL_OVERRIDE;
 
     QAction * prevNotAvailAction;
     QList<KFileItem> files;
     bool jobStarted;
 
 private:
     static const int MAX_SIZE =400;
     static const short MARGIN =5;
 
     class ProxyStyle;
 };
 
 #endif
diff --git a/krusader/Panel/krpreviews.cpp b/krusader/Panel/krpreviews.cpp
index f58282c9..e39a93a2 100644
--- a/krusader/Panel/krpreviews.cpp
+++ b/krusader/Panel/krpreviews.cpp
@@ -1,130 +1,130 @@
 /*****************************************************************************
  * Copyright (C) 2009 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krpreviews.h"
 #include "krpreviewjob.h"
 
 #include "krcolorcache.h"
 #include "PanelView/krview.h"
 #include "PanelView/krviewitem.h"
 #include "../FileSystem/fileitem.h"
 #include "../defaults.h"
 
 #include <stdio.h>
 
 #define ASSERT(what) if(!what) abort();
 
 
-KrPreviews::KrPreviews(KrView *view) :  _job(0), _view(view)
+KrPreviews::KrPreviews(KrView *view) :  _job(nullptr), _view(view)
 {
     _dim = KrColorCache::getColorCache().getDimSettings(_dimColor, _dimFactor);
     connect(&KrColorCache::getColorCache(), &KrColorCache::colorsRefreshed, this, &KrPreviews::slotRefreshColors);
 }
 
 KrPreviews::~KrPreviews()
 {
     clear();
 }
 
 void KrPreviews::clear()
 {
     if(_job) {
         _job->kill(KJob::EmitResult);
-        _job = 0;
+        _job = nullptr;
     }
     _previews.clear();
     _previewsInactive.clear();
 }
 
 void KrPreviews::update()
 {
     if(_job)
         return;
-    for (KrViewItem *it = _view->getFirst(); it != 0; it = _view->getNext(it)) {
+    for (KrViewItem *it = _view->getFirst(); it != nullptr; it = _view->getNext(it)) {
         if(!_previews.contains(it->getFileItem()))
             updatePreview(it);
     }
 }
 
 void KrPreviews::deletePreview(KrViewItem *item)
 {
     if(_job) {
         _job->removeItem(item);
     }
     removePreview(item->getFileItem());
 }
 
 void KrPreviews::updatePreview(KrViewItem *item)
 {
     if(!_job) {
         _job = new KrPreviewJob(this);
         connect(_job, &KrPreviewJob::result, this, &KrPreviews::slotJobResult);
         _view->op()->emitPreviewJobStarted(_job);
     }
     _job->scheduleItem(item);
 }
 
 bool KrPreviews::getPreview(const FileItem *file, QPixmap &pixmap, bool active)
 {
     if(active || !_dim)
         pixmap = _previews.value(file);
     else
         pixmap = _previewsInactive.value(file);
 
     return !pixmap.isNull();
 }
 
 void KrPreviews::slotJobResult(KJob *job)
 {
     (void) job;
-    _job = 0;
+    _job = nullptr;
 }
 
 void KrPreviews::slotRefreshColors()
 {
     clear();
     _dim = KrColorCache::getColorCache().getDimSettings(_dimColor, _dimFactor);
     update();
 }
 
 void KrPreviews::addPreview(const FileItem *file, const QPixmap &preview)
 {
     QPixmap active, inactive;
 
     if(preview.isNull()) {
         active = KrView::getIcon((FileItem *)file, true, _view->fileIconSize());
         if(_dim)
             inactive = KrView::getIcon((FileItem *)file, false, _view->fileIconSize());
     } else {
         active = KrView::processIcon(preview, false, _dimColor, _dimFactor, file->isSymLink());
         if(_dim)
             inactive = KrView::processIcon(preview, true, _dimColor, _dimFactor, file->isSymLink());
     }
 
     _previews.insert(file, active);
     if(_dim)
         _previewsInactive.insert(file, inactive);
 }
 
 void KrPreviews::removePreview(const FileItem *file)
 {
     _previews.remove(file);
     _previewsInactive.remove(file);
 }
diff --git a/krusader/Panel/krpreviews.h b/krusader/Panel/krpreviews.h
index 63cb0455..f8008859 100644
--- a/krusader/Panel/krpreviews.h
+++ b/krusader/Panel/krpreviews.h
@@ -1,69 +1,69 @@
 /*****************************************************************************
  * Copyright (C) 2009 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2009-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRPREVIEWS_H
 #define KRPREVIEWS_H
 
 // QtCore
 #include <QList>
 #include <QHash>
 // QtGui
 #include <QPixmap>
 #include <QColor>
 
 class KJob;
 class KrView;
 class KrViewItem;
 class KrPreviewJob;
 class FileItem;
 
 class KrPreviews: public QObject
 {
 friend class KrPreviewJob;
     Q_OBJECT
 public:
     explicit KrPreviews(KrView *view);
-    ~KrPreviews();
+    ~KrPreviews() override;
 
     bool getPreview(const FileItem* file, QPixmap &pixmap, bool active);
     void updatePreview(KrViewItem *item);
     void deletePreview(KrViewItem *item);
     //updates all items for which no preview has been loaded yet
     void update();
     void clear();
 
 protected slots:
     void slotRefreshColors();
     void slotJobResult(KJob *job);
 
 protected:
     void addPreview(const FileItem *file, const QPixmap &preview);
     void removePreview(const FileItem* file);
 
     KrPreviewJob *_job;
     bool _dim;
     QColor _dimColor;
     int _dimFactor;
     QHash<const FileItem*, QPixmap> _previews;
     QHash<const FileItem*, QPixmap> _previewsInactive;
     KrView *_view;
 };
 
 #endif // __krpreviews__
diff --git a/krusader/Panel/krsearchbar.cpp b/krusader/Panel/krsearchbar.cpp
index e9b6ced0..b5750dad 100644
--- a/krusader/Panel/krsearchbar.cpp
+++ b/krusader/Panel/krsearchbar.cpp
@@ -1,445 +1,437 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krsearchbar.h"
 
 #include "PanelView/krview.h"
 #include "PanelView/krviewitem.h"
 #include "../FileSystem/dirlisterinterface.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../icon.h"
 
 #include <QDebug>
 #include <QGuiApplication>
 #include <QHBoxLayout>
 #include <QKeyEvent>
 #include <QLineEdit>
 #include <QToolButton>
 #include <QToolTip>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 
 KrSearchBar::KrSearchBar(KrView *view, QWidget *parent)
-    : QWidget(parent), _view(0), _rightArrowEntersDirFlag(true)
+    : QWidget(parent), _view(nullptr), _rightArrowEntersDirFlag(true)
 {
     // close button
-    QToolButton *closeButton = new QToolButton(this);
+    auto *closeButton = new QToolButton(this);
     closeButton->setAutoRaise(true);
     closeButton->setIcon(Icon(QStringLiteral("dialog-close")));
     closeButton->setToolTip(i18n("Close the search bar"));
     connect(closeButton, &QToolButton::clicked, this, &KrSearchBar::hideBar);
 
     // combo box for changing search mode
     _modeBox = new QComboBox(this);
     _modeBox->addItems(QStringList() << i18n("Search") << i18n("Select") << i18n("Filter"));
     _modeBox->setToolTip(i18n("Change the search mode"));
     connect(_modeBox, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &KrSearchBar::onModeChange);
 
     _currentMode = static_cast<SearchMode>(_modeBox->currentIndex());
 
     // combo box for entering search string
     _textBox = new KComboBox(this);
     _textBox->setEditable(true);
     _modeBox->setToolTip(i18n("Enter or select search string"));
     QStringList savedSearches = KConfigGroup(krConfig, "Private")
                       .readEntry("Predefined Selections", QStringList());
     if (savedSearches.count() > 0)
         _textBox->addItems(savedSearches);
     _textBox->setCurrentText("");
     _textBox->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred));
     connect(_textBox, &KComboBox::currentTextChanged, this, &KrSearchBar::onSearchChange);
 
-    QToolButton *saveSearchBtn = new QToolButton(this);
+    auto *saveSearchBtn = new QToolButton(this);
     saveSearchBtn->setIcon(Icon("document-save"));
     saveSearchBtn->setFixedSize(20, 20);
     saveSearchBtn->setToolTip(i18n("Save the current search string"));
     connect(saveSearchBtn, &QToolButton::clicked, this, &KrSearchBar::saveSearchString);
 
     _openSelectDialogBtn = new QToolButton(this);
     _openSelectDialogBtn->setIcon(Icon("configure"));
     _openSelectDialogBtn->setFixedSize(20, 20);
     _openSelectDialogBtn->setToolTip(i18n("Open selection dialog"));
 
-    QHBoxLayout *layout = new QHBoxLayout(this);
+    auto *layout = new QHBoxLayout(this);
     layout->setMargin(0);
     layout->addWidget(closeButton);
     layout->addWidget(_modeBox);
     layout->addWidget(_textBox);
     layout->addWidget(saveSearchBtn);
     layout->addWidget(_openSelectDialogBtn);
 
     _textBox->installEventFilter(this);
 
     setView(view);
 }
 
 void KrSearchBar::setView(KrView *view)
 {
     if (_view) {
         _view->widget()->removeEventFilter(this);
-        disconnect(_openSelectDialogBtn, 0, 0, 0);
+        disconnect(_openSelectDialogBtn, nullptr, nullptr, nullptr);
     }
 
     _view = view;
 
     connect(_openSelectDialogBtn, &QToolButton::clicked, [this](){ _view->customSelection(true); });
     _view->widget()->installEventFilter(this);
 }
 
 void KrSearchBar::hideBarIfSearching()
 {
     if (_currentMode == MODE_SEARCH)
         hideBar();
 }
 
 // #### public slots
 
 void KrSearchBar::showBar(SearchMode mode)
 {
     int index = mode == MODE_DEFAULT ?
                     KConfigGroup(krConfig, "Look&Feel")
                         .readEntry("Default Search Mode", QString::number(KrSearchBar::MODE_SEARCH))
                         .toInt() :
                     mode;
     _modeBox->setCurrentIndex(index);
 
     show();
     _textBox->setFocus();
     _rightArrowEntersDirFlag = true;
 }
 
 void KrSearchBar::hideBar()
 {
     resetSearch();
     if (_textBox->hasFocus())
         _view->widget()->setFocus();
     hide();
 }
 
 void KrSearchBar::resetSearch()
 {
     _textBox->clearEditText();
     indicateMatch(true);
 }
 
 // #### protected slots
 
 void KrSearchBar::onModeChange()
 {
     if (_currentMode == MODE_FILTER) {
         _view->op()->filterSearch(QString(), true); // reset filter
     }
     _currentMode = static_cast<SearchMode>(_modeBox->currentIndex());
 
     onSearchChange();
 }
 
 void KrSearchBar::onSearchChange()
 {
     const QString text = _textBox->currentText();
 
     switch(_currentMode) {
         case MODE_SEARCH: {
             const bool anyMatch = _view->op()->searchItem(text, caseSensitive());
             indicateMatch(anyMatch);
             break;
         }
         case MODE_SELECT: {
             _view->unselectAll();
             if (!text.isEmpty()) {
                 const bool anyMatch = _view->changeSelection(KRQuery(text, caseSensitive()), true);
                 indicateMatch(anyMatch);
             }
             break;
         }
         case MODE_FILTER: {
             const bool anyMatch =_view->op()->filterSearch(text, caseSensitive());
             indicateMatch(anyMatch);
             break;
         }
         default:
             qWarning() << "unexpected search mode: " << _currentMode;
     }
 
     _textBox->setFocus();
 }
 
 void KrSearchBar::saveSearchString()
 {
     KConfigGroup group(krConfig, "Private");
     QStringList lst = group.readEntry("Predefined Selections", QStringList());
     QString searchString = _textBox->currentText();
     if (lst.indexOf(searchString) != -1) {
         // already saved
         return;
     }
 
     lst.append(searchString);
     group.writeEntry("Predefined Selections", lst);
 
     _textBox->addItem(searchString);
     QToolTip::showText(QCursor::pos(), i18n("Saved search text to history"));
 }
 
 // #### protected
 
 void KrSearchBar::keyPressEvent(QKeyEvent *event)
 {
     const bool handled = handleKeyPressEvent(static_cast<QKeyEvent*>(event));
     if (handled) {
         return;
     }
 
     QWidget::keyPressEvent(event);
 }
 
 bool KrSearchBar::eventFilter(QObject *watched, QEvent *event)
 {
-    if (event->type() != QEvent::ShortcutOverride && watched == _view->widget()) {
-        QKeyEvent *ke = static_cast<QKeyEvent *>(event);
-        // overwrite "escape" shortcut if bar is shown
-        if ((ke->key() == Qt::Key_Escape) && (ke->modifiers() == Qt::NoModifier) && !isHidden()) {
-            ke->accept();
-            handleKeyPressEvent(ke);
-            return true;
-        }
-    }
-
+    // only handle KeyPress events in this method
     if (event->type() != QEvent::KeyPress) {
         return false;
     }
 
     qDebug() << "key press event=" << event;
 
-    QKeyEvent *ke = static_cast<QKeyEvent *>(event);
+    auto *ke = static_cast<QKeyEvent *>(event);
     auto modifiers = ke->modifiers();
+
     if (watched == _view->widget()) {
         KConfigGroup grpSv(krConfig, "Look&Feel");
         const bool autoShow = grpSv.readEntry("New Style Quicksearch", _NewStyleQuicksearch);
 
         if (isHidden() && !autoShow) {
             return false;
         }
 
         if (!isHidden()) {
             // view widget has focus but search bar is open and may wants to steal key events
             const bool handled = handleKeyPressEvent(ke);
             if (handled) {
                 return true;
             }
         }
 
         if (isHidden() ||
             // view can handle its own event if user does not want to remove text or...
             !((ke->key() == Qt::Key_Backspace && !_textBox->currentText().isEmpty()) ||
               // ...insert space in search bar (even if not focused)
               (ke->key() == Qt::Key_Space && _currentMode == KrSearchBar::MODE_SEARCH))) {
             const bool handled = _view->handleKeyEvent(ke);
             if (handled) {
                 return true;
             }
         }
 
         if (ke->text().isEmpty() || (modifiers != Qt::NoModifier &&
                                      modifiers != Qt::ShiftModifier &&
                                      modifiers != Qt::KeypadModifier)) {
             return false;
         }
 
         // start searching if bar is hidden?
         if (isHidden()) {
             if (autoShow) {
                 showBar();
             } else {
                 return false;
             }
         }
 
         // bar is visible and gets the key input
         _textBox->setFocus();
         if (ke->key() == Qt::Key_Backspace) {
             _textBox->lineEdit()->backspace();
         } else {
             _textBox->setEditText(_textBox->currentText().append(ke->text()));
         }
         return true;
     } else if (watched == _textBox) {
         const bool handled = handleKeyPressEvent(ke);
         if (handled) {
              _view->widget()->setFocus();
             return true;
         }
         // allow the view to handle (most) key events from the text box
         if ((modifiers == Qt::NoModifier || modifiers == Qt::KeypadModifier) &&
             ke->key() != Qt::Key_Space &&
             ke->key() != Qt::Key_Backspace &&
             ke->key() != Qt::Key_Left &&
             ke->key() != Qt::Key_Right) {
             const bool handled = _view->handleKeyEvent(ke);
             if (handled) {
                 _view->widget()->setFocus();
                 return true;
             }
         }
     }
     return false;
 }
 
 // #### private
 
 bool KrSearchBar::handleKeyPressEvent(QKeyEvent *ke)
 {
     auto modifiers = ke->modifiers();
     if (!(modifiers == Qt::NoModifier || modifiers == Qt::KeypadModifier)) {
         return false;
     }
 
     switch (ke->key()) {
     case Qt::Key_Escape: {
         hideBar();
         return true;
     }
 
     case Qt::Key_Enter:
     case Qt::Key_Return: {
         hideBarIfSearching();
         return false;
     }
 
     case Qt::Key_Up:
         return handleUpDownKeyPress(true);
     case Qt::Key_Down:
         return handleUpDownKeyPress(false);
     case Qt::Key_Left:
     case Qt::Key_Right:
         return handleLeftRightKeyPress(ke);
     case Qt::Key_Insert: {
         // select current item and jump to next search result
         KrViewItem * item = _view->getCurrentKrViewItem();
         if (item) {
             item->setSelected(!item->isSelected());
             _view->op()->searchItem(_textBox->currentText(), caseSensitive(), 1);
         }
         return true;
     }
     case Qt::Key_Home: {
         // jump to first search result
         KrViewItem * item = _view->getLast();
         if (item) {
             _view->setCurrentKrViewItem(_view->getLast());
             _view->op()->searchItem(_textBox->currentText(), caseSensitive(), 1);
         }
         return true;
     }
     case Qt::Key_End: {
         // jump to last search result
         KrViewItem * item = _view->getFirst();
         if (item) {
             _view->setCurrentKrViewItem(_view->getFirst());
             _view->op()->searchItem(_textBox->currentText(), caseSensitive(), -1);
         }
         return true;
     }
     }
     return false;
 }
 
 bool KrSearchBar::handleUpDownKeyPress(bool up)
 {
     if (_currentMode != MODE_SEARCH) {
         return false;
     }
 
     const bool updownCancel = KConfigGroup(krConfig, "Look&Feel")
                         .readEntry("Up/Down Cancels Quicksearch", false);
     if (updownCancel) {
         hideBar();
         return false;
     }
 
     const bool anyMatch = _view->op()->searchItem(_textBox->currentText(), caseSensitive(), up ? -1 : 1);
     indicateMatch(anyMatch);
     return true;
 }
 
 bool KrSearchBar::handleLeftRightKeyPress(QKeyEvent *ke)
 {
     const bool useQuickDirectoryNavigation = KConfigGroup(krConfig, "Look&Feel")
         .readEntry("Navigation with Right Arrow Quicksearch", true);
     if (!useQuickDirectoryNavigation)
         return false;
 
     const bool isRight = ke->key() == Qt::Key_Right;
 
     if (isRight && _rightArrowEntersDirFlag) {
         // in case the Right Arrow has been pressed when cursor is in the end of the line
         if (_textBox->cursorPosition() == _textBox->currentText().length())
             // we let the view enter the directory if it's selected
             return _view->handleKeyEvent(ke);
     } else {
         _rightArrowEntersDirFlag = false;
     }
 
     return false;
 }
 
 void KrSearchBar::indicateMatch(bool anyMatch)
 {
     KConfigGroup gc(krConfig, "Colors");
     QPalette p = QGuiApplication::palette();
     QString foreground, background;
     if (anyMatch) {
         foreground = "Quicksearch Match Foreground";
         background = "Quicksearch Match Background";
     } else {
         foreground = "Quicksearch Non-match Foreground";
         background = "Quicksearch Non-match Background";
     }
 
     QColor fore = Qt::black;
     QString foreSetting = gc.readEntry(foreground, QString());
     if (foreSetting == "KDE default") {
         fore = p.color(QPalette::Active, QPalette::Text);
     } else if (!foreSetting.isEmpty()) {
         fore = gc.readEntry(foreground, fore);
     }
 
     QColor back = anyMatch ? QColor(192, 255, 192) : QColor(255, 192, 192);
     QString backSetting = gc.readEntry(background, QString());
     if (backSetting == "KDE default") {
         back = p.color(QPalette::Active, QPalette::Base);
     } else if (!backSetting.isEmpty()) {
         back = gc.readEntry(background, back);
     }
 
     QPalette pal = palette();
     pal.setColor(QPalette::Base, back);
     pal.setColor(QPalette::Text, fore);
     _textBox->lineEdit()->setPalette(pal);
 }
 
 bool KrSearchBar::caseSensitive()
 {
     KConfigGroup grpSvr(krConfig, "Look&Feel");
     return grpSvr.readEntry("Case Sensitive Quicksearch", _CaseSensitiveQuicksearch);
 }
diff --git a/krusader/Panel/listpanel.cpp b/krusader/Panel/listpanel.cpp
index 24df4d23..9a03cd4a 100644
--- a/krusader/Panel/listpanel.cpp
+++ b/krusader/Panel/listpanel.cpp
@@ -1,1378 +1,1379 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "listpanel.h"
 
 // QtCore
 #include <QStringList>
 #include <QList>
 #include <QEvent>
 #include <QMimeData>
 #include <QTimer>
 #include <QRegExp>
 #include <QUrl>
 // QtGui
 #include <QBitmap>
 #include <QKeyEvent>
 #include <QPixmap>
 #include <QDropEvent>
 #include <QHideEvent>
 #include <QShowEvent>
 #include <QDrag>
 #include <QImage>
 // QtWidgets
 #include <QHBoxLayout>
 #include <QFrame>
 #include <QMenu>
 #include <QSplitter>
 #include <QTabBar>
 
 #include <KCoreAddons/KUrlMimeData>
 #include <KI18n/KLocalizedString>
 #include <KIO/DropJob>
 #include <KWidgetsAddons/KCursor>
 #include <KWidgetsAddons/KMessageBox>
 #include <KIOFileWidgets/KFilePlacesModel>
 #include <KIOWidgets/KUrlComboBox>
+#include <utility>
 
 #include "dirhistoryqueue.h"
 #include "krcolorcache.h"
 #include "krerrordisplay.h"
 #include "krlayoutfactory.h"
 #include "krpreviewpopup.h"
 #include "krsearchbar.h"
 #include "listpanelactions.h"
 #include "panelcontextmenu.h"
 #include "panelfunc.h"
 #include "sidebar.h"
 #include "viewactions.h"
 
 #include "PanelView/krview.h"
 #include "PanelView/krviewfactory.h"
 #include "PanelView/krviewitem.h"
 
 #include "../defaults.h"
 #include "../icon.h"
 #include "../krservices.h"
 #include "../krslots.h"
 #include "../krusader.h"
 #include "../krusaderview.h"
 
 #include "../Archive/krarchandler.h"
 #include "../BookMan/krbookmarkbutton.h"
 #include "../FileSystem/fileitem.h"
 #include "../FileSystem/filesystem.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../FileSystem/sizecalculator.h"
 #include "../Dialogs/krdialogs.h"
 #include "../Dialogs/krspwidgets.h"
 #include "../Dialogs/krsqueezedtextlabel.h"
 #include "../Dialogs/percentalsplitter.h"
 #include "../Dialogs/popularurls.h"
 #include "../GUI/dirhistorybutton.h"
 #include "../GUI/kcmdline.h"
 #include "../GUI/mediabutton.h"
 #include "../MountMan/kmountman.h"
 #include "../UserAction/useractionpopupmenu.h"
 
 class ActionButton : public QToolButton
 {
 public:
-    ActionButton(QWidget *parent, ListPanel *panel, QAction *action, QString text = QString()) :
+    ActionButton(QWidget *parent, ListPanel *panel, QAction *action, const QString& text = QString()) :
             QToolButton(parent),  panel(panel), action(action) {
         setText(text);
         setAutoRaise(true);
         if(KConfigGroup(krConfig, "ListPanelButtons").readEntry("Icons", false) || text.isEmpty())
             setIcon(action->icon());
         setToolTip(action->toolTip());
     }
 
 protected:
-    virtual void mousePressEvent(QMouseEvent *) Q_DECL_OVERRIDE {
+    void mousePressEvent(QMouseEvent *) Q_DECL_OVERRIDE {
         panel->slotFocusOnMe();
         action->trigger();
     }
 
     ListPanel *panel;
     QAction *action;
 };
 
 
 /////////////////////////////////////////////////////
 //      The list panel constructor       //
 /////////////////////////////////////////////////////
-ListPanel::ListPanel(QWidget *parent, AbstractPanelManager *manager, KConfigGroup cfg) :
-        QWidget(parent), KrPanel(manager, this, new ListPanelFunc(this)),
-        panelType(-1), colorMask(255), compareMode(false),
-        previewJob(0), inlineRefreshJob(0), searchBar(0), cdRootButton(0), cdUpButton(0),
-        sidebarButton(0), sidebar(0), fileSystemError(0), _navigatorUrl(), _tabState(TabState::DEFAULT)
+ListPanel::ListPanel(QWidget *parent, AbstractPanelManager *manager, const KConfigGroup &cfg)
+    : QWidget(parent), KrPanel(manager, this, new ListPanelFunc(this)), panelType(-1),
+      colorMask(255), compareMode(false), previewJob(nullptr), inlineRefreshJob(nullptr),
+      searchBar(nullptr), cdRootButton(nullptr), cdUpButton(nullptr), sidebarButton(nullptr),
+      sidebar(nullptr), fileSystemError(nullptr), _tabState(TabState::DEFAULT)
 {
     if(cfg.isValid())
         panelType = cfg.readEntry("Type", -1);
     if (panelType == -1)
         panelType = defaultPanelType();
 
     _actions = krApp->listPanelActions();
 
     setAcceptDrops(true);
 
     QHash<QString, QWidget*> widgets;
 
 #define ADD_WIDGET(widget) widgets.insert(#widget, widget);
 
     // media button
     mediaButton = new MediaButton(this);
     connect(mediaButton, &MediaButton::aboutToShow, this, [=]() { slotFocusOnMe(); });
     connect(mediaButton, &MediaButton::openUrl, [=](const QUrl & _t1) { func->openUrl(_t1); });
     connect(mediaButton, &MediaButton::newTab, this, [=](const QUrl &url) { newTab(url); });
     ADD_WIDGET(mediaButton);
 
     // status bar
     status = new KrSqueezedTextLabel(this);
     KConfigGroup group(krConfig, "Look&Feel");
     status->setFont(group.readEntry("Filelist Font", _FilelistFont));
     status->setAutoFillBackground(false);
     status->setText("");          // needed for initialization code!
     status->setWhatsThis(i18n("The statusbar displays information about the filesystem "
                               "which holds your current folder: total size, free space, "
                               "type of filesystem, etc."));
     ADD_WIDGET(status);
 
     // back button
     backButton = new ActionButton(this, this, _actions->actHistoryBackward);
     ADD_WIDGET(backButton);
 
     // forward button
     forwardButton = new ActionButton(this, this, _actions->actHistoryForward);
     ADD_WIDGET(forwardButton);
 
 
     // ... create the history button
     historyButton = new DirHistoryButton(func->history, this);
     connect(historyButton, &DirHistoryButton::aboutToShow, this, [=]() { slotFocusOnMe(); });
     connect(historyButton, &DirHistoryButton::gotoPos, func, &ListPanelFunc::historyGotoPos);
     ADD_WIDGET(historyButton);
 
     // bookmarks button
     bookmarksButton = new KrBookmarkButton(this);
     connect(bookmarksButton, &KrBookmarkButton::aboutToShow, this, [=]() { slotFocusOnMe(); });
     connect(bookmarksButton, &KrBookmarkButton::openUrl, [=](const QUrl & _t1) { func->openUrl(_t1); });
     bookmarksButton->setWhatsThis(i18n("Open menu with bookmarks. You can also add "
                                        "current location to the list, edit bookmarks "
                                        "or add subfolder to the list."));
     ADD_WIDGET(bookmarksButton);
 
     // url input field
     urlNavigator = new KUrlNavigator(new KFilePlacesModel(this), QUrl(), this);
     urlNavigator->setWhatsThis(i18n("Name of folder where you are. You can also "
                                     "enter name of desired location to move there. "
                                     "Use of Net protocols like ftp or fish is possible."));
     // handle certain key events here in event filter
     urlNavigator->editor()->installEventFilter(this);
     urlNavigator->setUrlEditable(isNavigatorEditModeSet());
     urlNavigator->setShowFullPath(group.readEntry("Navigator Full Path", false));
     connect(urlNavigator, &KUrlNavigator::returnPressed, this, [=]() { slotFocusOnMe(); });
     connect(urlNavigator, &KUrlNavigator::urlChanged, this, &ListPanel::slotNavigatorUrlChanged);
     connect(urlNavigator->editor()->lineEdit(), &QLineEdit::editingFinished, this, &ListPanel::resetNavigatorMode);
     connect(urlNavigator, &KUrlNavigator::tabRequested, this, [=](const QUrl &url) { ListPanel::newTab(url); });
     connect(urlNavigator, &KUrlNavigator::urlsDropped, this, QOverload<const QUrl &, QDropEvent *>::of(&ListPanel::handleDrop));
     ADD_WIDGET(urlNavigator);
 
     // toolbar
     QWidget * toolbar = new QWidget(this);
-    QHBoxLayout * toolbarLayout = new QHBoxLayout(toolbar);
+    auto * toolbarLayout = new QHBoxLayout(toolbar);
     toolbarLayout->setContentsMargins(0, 0, 0, 0);
     toolbarLayout->setSpacing(0);
     ADD_WIDGET(toolbar);
 
     fileSystemError = new KrErrorDisplay(this);
     fileSystemError->setWordWrap(true);
     fileSystemError->hide();
     ADD_WIDGET(fileSystemError);
 
     // client area
     clientArea = new QWidget(this);
-    QVBoxLayout *clientLayout = new QVBoxLayout(clientArea);
+    auto *clientLayout = new QVBoxLayout(clientArea);
     clientLayout->setSpacing(0);
     clientLayout->setContentsMargins(0, 0, 0, 0);
     ADD_WIDGET(clientArea);
 
     // totals label
     totals = new KrSqueezedTextLabel(this);
     totals->setFont(group.readEntry("Filelist Font", _FilelistFont));
     totals->setAutoFillBackground(false);
     totals->setWhatsThis(i18n("The totals bar shows how many files exist, "
                               "how many selected and the bytes math"));
     ADD_WIDGET(totals);
 
     // free space label
     freeSpace = new KrSqueezedTextLabel(this);
     freeSpace->setFont(group.readEntry("Filelist Font", _FilelistFont));
     freeSpace->setAutoFillBackground(false);
     freeSpace->setText("");
     freeSpace->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
     ADD_WIDGET(freeSpace);
 
     // progress indicator and cancel button for the quick calc size
     quickSizeCalcProgress = new QProgressBar(this);
     quickSizeCalcProgress->hide();
     ADD_WIDGET(quickSizeCalcProgress);
     cancelQuickSizeCalcButton = new QToolButton(this);
     cancelQuickSizeCalcButton->hide();
     cancelQuickSizeCalcButton->setIcon(Icon("dialog-cancel"));
     cancelQuickSizeCalcButton->setToolTip(i18n("Cancel directory space calculation"));
     ADD_WIDGET(cancelQuickSizeCalcButton);
 
     // progress indicator for the preview job
     previewProgress = new QProgressBar(this);
     previewProgress->hide();
     ADD_WIDGET(previewProgress);
 
     // a cancel button for the filesystem refresh and preview job
     cancelProgressButton = new QToolButton(this);
     cancelProgressButton->hide();
     cancelProgressButton->setIcon(Icon("dialog-cancel"));
     connect(cancelProgressButton, &QToolButton::clicked, this, &ListPanel::cancelProgress);
     ADD_WIDGET(cancelProgressButton);
 
     // button for changing the panel sidebar position in the panel
     sidebarPositionButton = new QToolButton(this);
     sidebarPositionButton->hide();
     sidebarPositionButton->setAutoRaise(true);
     sidebarPositionButton->setIcon(Icon("exchange-positions"));
     sidebarPositionButton->setToolTip(i18n("Move Sidebar clockwise"));
     connect(sidebarPositionButton, &QToolButton::clicked, [this]() {
         // moving position clockwise
         setSidebarPosition((sidebarPosition() + 1) % 4); });
     ADD_WIDGET(sidebarPositionButton);
 
     // a quick button to open the sidebar
     sidebarButton = new QToolButton(this);
     sidebarButton->setAutoRaise(true);
     sidebarButton->setIcon(Icon("arrow-up"));
     connect(sidebarButton, &QToolButton::clicked, this, &ListPanel::toggleSidebar);
     sidebarButton->setToolTip(i18n("Open the Sidebar"));
     ADD_WIDGET(sidebarButton);
 
 #undef ADD_WIDGET
 
     // toolbar buttons
     cdOtherButton = new ActionButton(toolbar, this, _actions->actCdToOther, "=");
     toolbarLayout->addWidget(cdOtherButton);
 
     cdUpButton = new ActionButton(toolbar, this, _actions->actDirUp, "..");
     toolbarLayout->addWidget(cdUpButton);
 
     cdHomeButton = new ActionButton(toolbar, this, _actions->actHome, "~");
     toolbarLayout->addWidget(cdHomeButton);
 
     cdRootButton = new ActionButton(toolbar, this, _actions->actRoot, "/");
     toolbarLayout->addWidget(cdRootButton);
 
     // create the button for sync-browsing
     syncBrowseButton = new QToolButton(toolbar);
     syncBrowseButton->setIcon(Icon("kr_syncbrowse_off"));
     syncBrowseButton->setCheckable(true);
 
     const QString syncBrowseText = i18n("This button toggles the sync-browse mode.\n"
                                         "When active, each folder change is performed in the\n"
                                         "active and inactive panel - if possible.");
     syncBrowseButton->setText(syncBrowseText);
     syncBrowseButton->setToolTip(syncBrowseText);
     connect(syncBrowseButton, &QToolButton::toggled, [=](bool checked) {
         syncBrowseButton->setIcon(
             Icon(checked ? "kr_syncbrowse_on" : "kr_syncbrowse_off"));
     });
     syncBrowseButton->setAutoRaise(true);
     toolbarLayout->addWidget(syncBrowseButton);
 
     setButtons();
 
     // create a splitter to hold the view and the sidebar
     sidebarSplitter = new PercentalSplitter(clientArea);
     sidebarSplitter->setChildrenCollapsible(true);
     sidebarSplitter->setOrientation(Qt::Horizontal);
     // expand vertical if splitter orientation is horizontal
     QSizePolicy sizePolicy = sidebarSplitter->sizePolicy();
     sizePolicy.setVerticalPolicy(QSizePolicy::Expanding);
     sidebarSplitter->setSizePolicy(sizePolicy);
     clientLayout->addWidget(sidebarSplitter);
 
     // view
     createView();
 
     // search (in folder) bar
     searchBar = new KrSearchBar(view, clientArea);
     searchBar->hide();
     bool top = group.readEntry("Quicksearch Position", "bottom") == "top";
     clientLayout->insertWidget(top ? 0 : -1, searchBar);
 
     // create the layout
     KrLayoutFactory fact(this, widgets);
     QLayout *layout = fact.createLayout();
 
     if(!layout) { // fallback: create a layout by ourself
-        QVBoxLayout *v = new QVBoxLayout;
+        auto *v = new QVBoxLayout;
         v->setContentsMargins(0, 0, 0, 0);
         v->setSpacing(0);
 
-        QHBoxLayout *h = new QHBoxLayout;
+        auto *h = new QHBoxLayout;
         h->setContentsMargins(0, 0, 0, 0);
         h->setSpacing(0);
         h->addWidget(urlNavigator);
         h->addWidget(toolbar);
         h->addStretch();
         v->addLayout(h);
 
         h = new QHBoxLayout;
         h->setContentsMargins(0, 0, 0, 0);
         h->setSpacing(0);
         h->addWidget(mediaButton);
         h->addWidget(status);
         h->addWidget(backButton);
         h->addWidget(forwardButton);
         h->addWidget(historyButton);
         h->addWidget(bookmarksButton);
         v->addLayout(h);
 
         v->addWidget(fileSystemError);
         v->addWidget(clientArea);
 
         h = new QHBoxLayout;
         h->setContentsMargins(0, 0, 0, 0);
         h->setSpacing(0);
         h->addWidget(totals);
         h->addWidget(freeSpace);
         h->addWidget(quickSizeCalcProgress);
         h->addWidget(cancelQuickSizeCalcButton);
         h->addWidget(previewProgress);
         h->addWidget(cancelProgressButton);
         h->addWidget(sidebarButton);
         v->addLayout(h);
 
         layout = v;
     }
 
     setLayout(layout);
 
     connect(&KrColorCache::getColorCache(), &KrColorCache::colorsRefreshed, this, &ListPanel::slotRefreshColors);
     connect(krApp, &Krusader::shutdown, this, &ListPanel::cancelProgress);
 }
 
 ListPanel::~ListPanel()
 {
     cancelProgress();
     delete view;
-    view = 0;
+    view = nullptr;
     delete func;
     delete status;
     delete bookmarksButton;
     delete totals;
     delete urlNavigator;
     delete cdRootButton;
     delete cdHomeButton;
     delete cdUpButton;
     delete cdOtherButton;
     delete syncBrowseButton;
 //     delete layout;
 }
 
 void ListPanel::reparent(QWidget *parent, AbstractPanelManager *manager)
 {
     setParent(parent);
     _manager = manager;
 }
 
 int ListPanel::defaultPanelType()
 {
     KConfigGroup group(krConfig, "Look&Feel");
     return group.readEntry("Default Panel Type", KrViewFactory::defaultViewId());
 }
 
 bool ListPanel::isNavigatorEditModeSet()
 {
     KConfigGroup group(krConfig, "Look&Feel");
     return group.readEntry("Navigator Edit Mode", false);
 }
 
 void ListPanel::createView()
 {
     view = KrViewFactory::createView(panelType, sidebarSplitter, krConfig);
     view->init();
     view->setMainWindow(krApp);
 
     // KrViewFactory may create a different view type than requested
     panelType = view->instance()->id();
 
     if(this == ACTIVE_PANEL)
         view->prepareForActive();
     else
         view->prepareForPassive();
     view->refreshColors();
 
     sidebarSplitter->insertWidget(sidebarPosition() < 2 ? 1 : 0, view->widget());
 
     view->widget()->installEventFilter(this);
 
     connect(view->op(), &KrViewOperator::quickCalcSpace, func, &ListPanelFunc::quickCalcSpace);
     connect(view->op(), &KrViewOperator::goHome, func, &ListPanelFunc::home);
     connect(view->op(), &KrViewOperator::dirUp, func, &ListPanelFunc::dirUp);
     connect(view->op(), &KrViewOperator::defaultDeleteFiles, func, &ListPanelFunc::defaultDeleteFiles);
     connect(view->op(), &KrViewOperator::middleButtonClicked, this,  QOverload<KrViewItem *>::of(&ListPanel::newTab));
     connect(view->op(), &KrViewOperator::currentChanged, this, &ListPanel::slotCurrentChanged);
     connect(view->op(), &KrViewOperator::renameItem, func, QOverload<const QString &, const QString &>::of(&ListPanelFunc::rename));
     connect(view->op(), &KrViewOperator::executed, func, &ListPanelFunc::execute);
     connect(view->op(), &KrViewOperator::goInside, func, &ListPanelFunc::goInside);
     connect(view->op(), &KrViewOperator::needFocus, this, [=]() { slotFocusOnMe(); });
     connect(view->op(), &KrViewOperator::selectionChanged, this, &ListPanel::slotUpdateTotals);
     connect(view->op(), &KrViewOperator::itemDescription, krApp, &Krusader::statusBarUpdate);
     connect(view->op(), &KrViewOperator::contextMenu, this, &ListPanel::popRightClickMenu);
     connect(view->op(), &KrViewOperator::emptyContextMenu, this, &ListPanel::popEmptyRightClickMenu);
     connect(view->op(), &KrViewOperator::letsDrag, this, &ListPanel::startDragging);
     connect(view->op(), &KrViewOperator::gotDrop, this, [this](QDropEvent *event) {handleDrop(event, true); });
     connect(view->op(), &KrViewOperator::previewJobStarted, this, &ListPanel::slotPreviewJobStarted);
     connect(view->op(), &KrViewOperator::refreshActions, krApp->viewActions(), &ViewActions::refreshActions);
     connect(view->op(), &KrViewOperator::currentChanged, func->history, &DirHistoryQueue::saveCurrentItem);
     connect(view->op(), &KrViewOperator::goBack, func, &ListPanelFunc::historyBackward);
     connect(view->op(), &KrViewOperator::goForward, func, &ListPanelFunc::historyForward);
 
     view->setFiles(func->files());
 
     func->refreshActions();
 }
 
 void ListPanel::changeType(int type)
 {
     if (panelType != type) {
         QString current = view->getCurrentItem();
         QList<QUrl> selection = view->selectedUrls();
         bool filterApplysToDirs = view->properties()->filterApplysToDirs;
         KrViewProperties::FilterSpec filter = view->filter();
         FilterSettings filterSettings = view->properties()->filterSettings;
 
         panelType = type;
 
         KrView *oldView = view;
         createView();
         searchBar->setView(view);
         delete oldView;
 
         view->setFilter(filter, filterSettings, filterApplysToDirs);
         view->setSelectionUrls(selection);
         view->setCurrentItem(current);
         view->makeItemVisible(view->getCurrentKrViewItem());
     }
 }
 
 int ListPanel::getProperties()
 {
     int props = 0;
     if (syncBrowseButton->isChecked()) {
         props |= PROP_SYNC_BUTTON_ON;
     }
     if (isLocked()) {
         props |= PROP_LOCKED;
     } else if (isPinned()) {
         props |= PROP_PINNED;
     }
     return props;
 }
 
 void ListPanel::setProperties(int prop)
 {
     syncBrowseButton->setChecked(prop & PROP_SYNC_BUTTON_ON);
     if (prop & PROP_LOCKED) {
         _tabState = TabState::LOCKED;
     } else if (prop & PROP_PINNED) {
         _tabState = TabState::PINNED;
     } else {
         _tabState = TabState::DEFAULT;
     }
 }
 
 bool ListPanel::eventFilter(QObject * watched, QEvent * e)
 {
     if(view && watched == view->widget()) {
         if(e->type() == QEvent::FocusIn && this != ACTIVE_PANEL && !isHidden())
             slotFocusOnMe();
         else if(e->type() == QEvent::ShortcutOverride) {
-            QKeyEvent *ke = static_cast<QKeyEvent*>(e);
+            auto *ke = dynamic_cast<QKeyEvent*>(e);
             if(ke->key() == Qt::Key_Escape && ke->modifiers() == Qt::NoModifier) {
                 // if the cancel refresh action has no shortcut assigned,
                 // we need this event ourselves to cancel refresh
                 if(_actions->actCancelRefresh->shortcut().isEmpty()) {
                     e->accept();
                     return true;
                 }
             }
         }
     }
     // handle URL navigator key events
     else if(watched == urlNavigator->editor()) {
         // override default shortcut for panel focus
         if(e->type() == QEvent::ShortcutOverride) {
-            QKeyEvent *ke = static_cast<QKeyEvent *>(e);
+            auto *ke = dynamic_cast<QKeyEvent *>(e);
             if ((ke->key() == Qt::Key_Escape) && (ke->modifiers() == Qt::NoModifier)) {
                 e->accept(); // we will get the key press event now
                 return true;
             }
         } else if(e->type() == QEvent::KeyPress) {
-            QKeyEvent *ke = static_cast<QKeyEvent *>(e);
+            auto *ke = dynamic_cast<QKeyEvent *>(e);
             if ((ke->key() == Qt::Key_Down) && (ke->modifiers() == Qt::ControlModifier)) {
                 slotFocusOnMe();
                 return true;
             } else if ((ke->key() == Qt::Key_Escape) && (ke->modifiers() == Qt::NoModifier)) {
                 // reset navigator
                 urlNavigator->editor()->setUrl(urlNavigator->locationUrl());
                 slotFocusOnMe();
                 return true;
             }
         }
     }
     return false;
 }
 
 void ListPanel::toggleSidebar()
 {
     if(!sidebar) {
         sidebar = new Sidebar(sidebarSplitter);
         // fix vertical grow of splitter (and entire window) if its content
         // demands more space
         QSizePolicy sizePolicy = sidebar->sizePolicy();
         sizePolicy.setVerticalPolicy(QSizePolicy::Ignored);
         sidebar->setSizePolicy(sizePolicy);
         connect(this, &ListPanel::pathChanged, sidebar, &Sidebar::onPanelPathChange);
         connect(sidebar, &Sidebar::urlActivated, SLOTS, &KRslots::refresh);
         sidebarSplitter->insertWidget(0, sidebar);
     }
 
     if (sidebar->isHidden()) {
         if (sidebarSplitterSizes.count() > 0) {
             sidebarSplitter->setSizes(sidebarSplitterSizes);
         } else { // on the first time, resize to 50%
             QList<int> lst;
             lst << height() / 2 << height() / 2;
             sidebarSplitter->setSizes(lst);
         }
 
         sidebar->show();
         sidebarButton->setIcon(Icon("arrow-down"));
         sidebarButton->setToolTip(i18n("Close the Sidebar"));
         sidebarPositionButton->show();
     } else {
         sidebarSplitterSizes.clear();
         sidebarSplitterSizes = sidebarSplitter->sizes();
         sidebar->hide();
         sidebarButton->setIcon(Icon("arrow-up"));
         sidebarButton->setToolTip(i18n("Open the Sidebar"));
         sidebarPositionButton->hide();
 
         QList<int> lst;
         lst << height() << 0;
         sidebarSplitter->setSizes(lst);
         if (ACTIVE_PANEL)
             ACTIVE_PANEL->gui->slotFocusOnMe();
     }
 }
 
 QString ListPanel::lastLocalPath() const
 {
     return _lastLocalPath;
 }
 
 void ListPanel::setButtons()
 {
     KConfigGroup group(krConfig, "Look&Feel");
 
     mediaButton->setVisible(group.readEntry("Media Button Visible", true));
     backButton->setVisible(group.readEntry("Back Button Visible", false));
     forwardButton->setVisible(group.readEntry("Forward Button Visible", false));
     historyButton->setVisible(group.readEntry("History Button Visible", true));
     bookmarksButton->setVisible(group.readEntry("Bookmarks Button Visible", true));
 
     if (group.readEntry("Panel Toolbar visible", _PanelToolBar)) {
         cdRootButton->setVisible(group.readEntry("Root Button Visible", _cdRoot));
         cdHomeButton->setVisible(group.readEntry("Home Button Visible", _cdHome));
         cdUpButton->setVisible(group.readEntry("Up Button Visible", _cdUp));
         cdOtherButton->setVisible(group.readEntry("Equal Button Visible", _cdOther));
         syncBrowseButton->setVisible(group.readEntry("SyncBrowse Button Visible", _syncBrowseButton));
     } else {
         cdRootButton->hide();
         cdHomeButton->hide();
         cdUpButton->hide();
         cdOtherButton->hide();
         syncBrowseButton->hide();
     }
 }
 
 void ListPanel::slotUpdateTotals()
 {
     totals->setText(view->statistics());
 }
 
 void ListPanel::compareDirs(bool otherPanelToo)
 {
     // Performs a check in order to avoid that the next code is executed twice
     if (otherPanelToo == true) {
         // If both panels are showing the same directory
         if (_manager->currentPanel()->virtualPath() == otherPanel()->virtualPath()) {
             if (KMessageBox::warningContinueCancel(this,
                 i18n("Warning: The left and the right side are showing the same folder.")) != KMessageBox::Continue) {
                 return;
             }
         }
     }
 
     KConfigGroup pg(krConfig, "Private");
     int compareMode = pg.readEntry("Compare Mode", 0);
     KConfigGroup group(krConfig, "Look&Feel");
     bool selectDirs = group.readEntry("Mark Dirs", false);
 
     KrViewItem *item, *otherItem;
 
-    for (item = view->getFirst(); item != 0; item = view->getNext(item)) {
+    for (item = view->getFirst(); item != nullptr; item = view->getNext(item)) {
         if (item->name() == "..")
             continue;
 
-        for (otherItem = otherPanel()->view->getFirst(); otherItem != 0 && otherItem->name() != item->name();
+        for (otherItem = otherPanel()->view->getFirst(); otherItem != nullptr && otherItem->name() != item->name();
                 otherItem = otherPanel()->view->getNext(otherItem));
 
-        bool isSingle = (otherItem == 0), isDifferent = false, isNewer = false;
+        bool isSingle = (otherItem == nullptr), isDifferent = false, isNewer = false;
 
         if (func->getFileItem(item)->isDir() && !selectDirs) {
             item->setSelected(false);
             continue;
         }
 
         if (otherItem) {
             if (!func->getFileItem(item)->isDir())
                 isDifferent = otherPanel()->func->getFileItem(otherItem)->getSize() != func->getFileItem(item)->getSize();
             isNewer = func->getFileItem(item)->getTime_t() > otherPanel()->func->getFileItem(otherItem)->getTime_t();
         }
 
         switch (compareMode) {
         case 0:
             item->setSelected(isNewer || isSingle);
             break;
         case 1:
             item->setSelected(isNewer);
             break;
         case 2:
             item->setSelected(isSingle);
             break;
         case 3:
             item->setSelected(isDifferent || isSingle);
             break;
         case 4:
             item->setSelected(isDifferent);
             break;
         }
     }
 
     view->updateView();
 
     if (otherPanelToo)
         otherPanel()->gui->compareDirs(false);
 }
 
 void ListPanel::slotRefreshColors()
 {
     view->refreshColors();
     emit signalRefreshColors(this == ACTIVE_PANEL);
 }
 
 void ListPanel::slotFocusOnMe(bool focus)
 {
     if (focus && _manager->currentPanel() != this) {
         // ignore focus request if this panel is not shown
         return;
     }
 
     krApp->setUpdatesEnabled(false);
 
     if(focus) {
         emit activate();
         _actions->activePanelChanged();
         func->refreshActions();
         slotCurrentChanged(view->getCurrentKrViewItem());
         view->prepareForActive();
         otherPanel()->gui->slotFocusOnMe(false);
     } else {
         // in case a new url was entered but not refreshed to,
         // reset url navigator to the current url
         setNavigatorUrl(virtualPath());
         view->prepareForPassive();
     }
 
     urlNavigator->setActive(focus);
     slotRefreshColors();
 
     krApp->setUpdatesEnabled(true);
 }
 
 // this is used to start the panel
 //////////////////////////////////////////////////////////////////
 void ListPanel::start(const QUrl &url)
 {
     QUrl startUrl(url);
 
     if (!startUrl.isValid())
         startUrl = QUrl::fromLocalFile(ROOT_DIR);
 
     _lastLocalPath = startUrl.isLocalFile() ? startUrl.path() : ROOT_DIR;
 
 
     func->openUrl(startUrl);
 
     setJumpBack(startUrl);
 }
 
 void ListPanel::slotStartUpdate(bool directoryChange)
 {
     if (inlineRefreshJob)
-        inlineRefreshListResult(0);
+        inlineRefreshListResult(nullptr);
 
     setCursor(Qt::BusyCursor);
 
     const QUrl currentUrl = virtualPath();
     if (directoryChange) {
 
         if (this == ACTIVE_PANEL) {
             slotFocusOnMe();
         }
 
         if (currentUrl.isLocalFile())
             _lastLocalPath = currentUrl.path();
 
         setNavigatorUrl(currentUrl);
 
         emit pathChanged(currentUrl);
 
         krApp->popularUrls()->addUrl(currentUrl);
 
         searchBar->hideBar();
     }
 
     if (compareMode)
         otherPanel()->view->refresh();
 
     // return cursor to normal arrow
     setCursor(Qt::ArrowCursor);
 
     slotUpdateTotals();
 }
 
 void ListPanel::updateFilesystemStats(const QString &metaInfo, const QString &fsType,
                                       KIO::filesize_t total, KIO::filesize_t free)
 {
     QString statusText, mountPoint, freeSpaceText;
 
     if (!metaInfo.isEmpty()) {
         statusText = metaInfo;
         mountPoint = freeSpaceText = "";
     } else {
         const int perc = total == 0 ? 0 : (int)(((float)free / (float)total) * 100.0);
         mountPoint = func->files()->mountPoint();
         statusText = i18nc("%1=free space,%2=total space,%3=percentage of usage, "
                            "%4=mountpoint,%5=filesystem type",
                            "%1 free out of %2 (%3%) on %4 [(%5)]", KIO::convertSize(free),
                            KIO::convertSize(total), perc, mountPoint, fsType);
 
         freeSpaceText = "    " + i18n("%1 free", KIO::convertSize(free));
     }
 
     status->setText(statusText);
     freeSpace->setText(freeSpaceText);
     mediaButton->updateIcon(mountPoint);
 }
 
 void ListPanel::handleDrop(QDropEvent *event, bool onView)
 {
     // check what was dropped
     const QList<QUrl> urls = KUrlMimeData::urlsFromMimeData(event->mimeData());
     if (urls.isEmpty()) {
         event->ignore(); // not for us to handle!
         return;
     }
 
     // find dropping destination
     QString destinationDir = "";
     const bool dragFromThisPanel = event->source() == this;
-    const KrViewItem *item = onView ? view->getKrViewItemAt(event->pos()) : 0;
+    const KrViewItem *item = onView ? view->getKrViewItemAt(event->pos()) : nullptr;
     if (item) {
         const FileItem *file = item->getFileItem();
         if (file && !file->isDir() && dragFromThisPanel) {
             event->ignore(); // dragging on files in same panel, ignore
             return;
         } else if (!file || file->isDir()) { // item is ".." dummy or a directory
             destinationDir = item->name();
         }
     } else if (dragFromThisPanel) {
         event->ignore(); // dragged from this panel onto an empty spot in this panel, ignore
         return;
     }
 
     QUrl destination = QUrl(virtualPath());
     destination.setPath(destination.path() + '/' + destinationDir);
 
     func->files()->dropFiles(destination, event);
 
     if(KConfigGroup(krConfig, "Look&Feel").readEntry("UnselectBeforeOperation",
                                                      _UnselectBeforeOperation)) {
         KrPanel *p = dragFromThisPanel ? this : otherPanel();
         p->view->saveSelection();
         p->view->unselectAll();
     }
 }
 
 void ListPanel::handleDrop(const QUrl &destination, QDropEvent *event)
 {
     func->files()->dropFiles(destination, event);
 }
 
-void ListPanel::startDragging(QStringList names, QPixmap px)
+void ListPanel::startDragging(const QStringList& names, const QPixmap& px)
 {
     if (names.isEmpty()) {  // avoid dragging empty urls
         return;
     }
 
     QList<QUrl> urls = func->files()->getUrls(names);
 
-    QDrag *drag = new QDrag(this);
-    QMimeData *mimeData = new QMimeData;
+    auto *drag = new QDrag(this);
+    auto *mimeData = new QMimeData;
     drag->setPixmap(px);
     mimeData->setUrls(urls);
     drag->setMimeData(mimeData);
 
     drag->start(Qt::MoveAction | Qt::CopyAction | Qt::LinkAction);
 }
 
 // pops a right-click menu for items
 void ListPanel::popRightClickMenu(const QPoint &loc)
 {
     // run it, on the mouse location
     int j = QFontMetrics(font()).height() * 2;
     PanelContextMenu::run(QPoint(loc.x() + 5, loc.y() + j), this);
 }
 
 void ListPanel::popEmptyRightClickMenu(const QPoint &loc)
 {
     PanelContextMenu::run(loc, this);
 }
 
 QString ListPanel::getCurrentName()
 {
     QString name = view->getCurrentItem();
     if (name != "..")
         return name;
     else
         return QString();
 }
 
 QStringList ListPanel::getSelectedNames()
 {
     QStringList fileNames;
     view->getSelectedItems(&fileNames);
     return fileNames;
 }
 
 void ListPanel::prepareToDelete()
 {
     const bool skipCurrent = (view->numSelected() == 0);
     view->setNameToMakeCurrent(view->firstUnmarkedBelowCurrent(skipCurrent));
 }
 
 void ListPanel::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Enter :
     case Qt::Key_Return :
         if (e->modifiers() & Qt::ControlModifier) {
             if (e->modifiers() & Qt::AltModifier) {
                 FileItem *fileitem =
                     func->files()->getFileItem(view->getCurrentKrViewItem()->name());
                 if (fileitem && fileitem->isDir())
                     newTab(fileitem->getUrl(), true);
             } else {
                 SLOTS->insertFileName((e->modifiers()&Qt::ShiftModifier)!=0);
             }
         } else {
             e->ignore();
         }
         break;
     case Qt::Key_Right :
     case Qt::Key_Left :
         if (e->modifiers() == Qt::ControlModifier) {
             // user pressed CTRL+Right/Left - refresh other panel to the selected path if it's a
             // directory otherwise as this one
             if ((isLeft() && e->key() == Qt::Key_Right) || (!isLeft() && e->key() == Qt::Key_Left)) {
                 QUrl newPath;
                 KrViewItem *it = view->getCurrentKrViewItem();
 
                 if (it->name() == "..") {
                     newPath = KIO::upUrl(virtualPath());
                 } else {
                     FileItem *v = func->getFileItem(it);
                     // If it's a directory different from ".."
                     if (v && v->isDir() && v->getName() != "..") {
                         newPath = v->getUrl();
                     } else {
                         // If it's a supported compressed file
                         if (v && KRarcHandler::arcSupported(v->getMime()))   {
                             newPath = func->browsableArchivePath(v->getUrl().fileName());
                         } else {
                             newPath = virtualPath();
                         }
                     }
                 }
                 otherPanel()->func->openUrl(newPath);
             } else {
                 func->openUrl(otherPanel()->virtualPath());
             }
             return;
         } else
             e->ignore();
         break;
     case Qt::Key_Down :
         if (e->modifiers() == Qt::ControlModifier) {   // give the keyboard focus to the command line
             if (MAIN_VIEW->cmdLine()->isVisible())
                 MAIN_VIEW->cmdLineFocus();
             else
                 MAIN_VIEW->focusTerminalEmulator();
             return;
         } else if (e->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {     // give the keyboard focus to TE
             MAIN_VIEW->focusTerminalEmulator();
         } else
             e->ignore();
         break;
 
     case Qt::Key_Up :
         if (e->modifiers() == Qt::ControlModifier) {   // give the keyboard focus to the url navigator
             editLocation();
             return;
         } else
             e->ignore();
         break;
 
     case Qt::Key_Escape:
         cancelProgress();
         break;
 
     default:
         // if we got this, it means that the view is not doing
         // the quick search thing, so send the characters to the commandline, if normal key
         if (e->modifiers() == Qt::NoModifier)
             MAIN_VIEW->cmdLine()->addText(e->text());
 
         //e->ignore();
     }
 }
 
 void ListPanel::showEvent(QShowEvent *e)
 {
     panelVisible();
     QWidget::showEvent(e);
 }
 
 void ListPanel::hideEvent(QHideEvent *e)
 {
     panelHidden();
     QWidget::hideEvent(e);
 }
 
 void ListPanel::panelVisible()
 {
     func->setPaused(false);
 }
 
 void ListPanel::panelHidden()
 {
     func->setPaused(true);
 }
 
 void ListPanel::slotPreviewJobStarted(KJob *job)
 {
     previewJob = job;
     connect(job, SIGNAL(percent(KJob*,ulong)), SLOT(slotPreviewJobPercent(KJob*,ulong)));
     connect(job, &KJob::result, this, &ListPanel::slotPreviewJobResult);
     cancelProgressButton->setMaximumHeight(sidebarButton->height());
     cancelProgressButton->show();
     previewProgress->setValue(0);
     previewProgress->setFormat(i18n("loading previews: %p%"));
     previewProgress->setMaximumHeight(cancelProgressButton->height());
     previewProgress->show();
 }
 
 void ListPanel::slotPreviewJobPercent(KJob* /*job*/, unsigned long percent)
 {
     previewProgress->setValue(percent);
 }
 
 void ListPanel::slotPreviewJobResult(KJob* /*job*/)
 {
-    previewJob = 0;
+    previewJob = nullptr;
     previewProgress->hide();
     if(!inlineRefreshJob)
         cancelProgressButton->hide();
 }
 
 void ListPanel::slotRefreshJobStarted(KIO::Job* job)
 {
     // disable the parts of the panel we don't want touched
     status->setEnabled(false);
     urlNavigator->setEnabled(false);
     cdRootButton->setEnabled(false);
     cdHomeButton->setEnabled(false);
     cdUpButton->setEnabled(false);
     cdOtherButton->setEnabled(false);
     sidebarButton->setEnabled(false);
     if(sidebar)
         sidebar->setEnabled(false);
     bookmarksButton->setEnabled(false);
     historyButton->setEnabled(false);
     syncBrowseButton->setEnabled(false);
 
     // connect to the job interface to provide in-panel refresh notification
     connect(job, &KIO::Job::infoMessage, this, &ListPanel::inlineRefreshInfoMessage);
     connect(job, SIGNAL(percent(KJob*,ulong)),
             SLOT(inlineRefreshPercent(KJob*,ulong)));
     connect(job, &KIO::Job::result, this, &ListPanel::inlineRefreshListResult);
 
     inlineRefreshJob = job;
 
     totals->setText(i18n(">> Reading..."));
     cancelProgressButton->show();
 }
 
 void ListPanel::cancelProgress()
 {
     if (inlineRefreshJob) {
-        disconnect(inlineRefreshJob, 0, this, 0);
+        disconnect(inlineRefreshJob, nullptr, this, nullptr);
         inlineRefreshJob->kill(KJob::EmitResult);
-        inlineRefreshListResult(0);
+        inlineRefreshListResult(nullptr);
     }
     if(previewJob) {
-        disconnect(previewJob, 0, this, 0);
+        disconnect(previewJob, nullptr, this, nullptr);
         previewJob->kill(KJob::EmitResult);
-        slotPreviewJobResult(0);
+        slotPreviewJobResult(nullptr);
     }
 }
 
 void ListPanel::setNavigatorUrl(const QUrl &url)
 {
     _navigatorUrl = url;
    urlNavigator->setLocationUrl(url);
 }
 
 void ListPanel::inlineRefreshPercent(KJob*, unsigned long perc)
 {
     QString msg = i18n(">> Reading: %1 % complete...", perc);
     totals->setText(msg);
 }
 
 void ListPanel::inlineRefreshInfoMessage(KJob*, const QString &msg)
 {
     totals->setText(i18n(">> Reading: %1", msg));
 }
 
 void ListPanel::inlineRefreshListResult(KJob*)
 {
     if(inlineRefreshJob)
-        disconnect(inlineRefreshJob, 0, this, 0);
-    inlineRefreshJob = 0;
+        disconnect(inlineRefreshJob, nullptr, this, nullptr);
+    inlineRefreshJob = nullptr;
     // reenable everything
     status->setEnabled(true);
     urlNavigator->setEnabled(true);
     cdRootButton->setEnabled(true);
     cdHomeButton->setEnabled(true);
     cdUpButton->setEnabled(true);
     cdOtherButton->setEnabled(true);
     sidebarButton->setEnabled(true);
     if(sidebar)
         sidebar->setEnabled(true);
     bookmarksButton->setEnabled(true);
     historyButton->setEnabled(true);
     syncBrowseButton->setEnabled(true);
 
     if(!previewJob)
         cancelProgressButton->hide();
 }
 
 void ListPanel::jumpBack()
 {
     func->openUrl(_jumpBackURL);
 }
 
 void ListPanel::setJumpBack(QUrl url)
 {
-    _jumpBackURL = url;
+    _jumpBackURL = std::move(url);
 }
 
-void ListPanel::slotFilesystemError(QString msg)
+void ListPanel::slotFilesystemError(const QString& msg)
 {
     slotRefreshColors();
     fileSystemError->setText(i18n("Error: %1", msg));
     fileSystemError->show();
 }
 
 void ListPanel::showButtonMenu(QToolButton *b)
 {
     if(this != ACTIVE_PANEL)
         slotFocusOnMe();
 
     if(b->isHidden())
         b->menu()->exec(mapToGlobal(clientArea->pos()));
     else
         b->click();
 }
 
 void ListPanel::openBookmarks()
 {
     showButtonMenu(bookmarksButton);
 }
 
 void ListPanel::openHistory()
 {
     showButtonMenu(historyButton);
 }
 
 void ListPanel::openMedia()
 {
     showButtonMenu(mediaButton);
 }
 
 void ListPanel::rightclickMenu()
 {
     if (view->getCurrentKrViewItem())
         popRightClickMenu(mapToGlobal(view->getCurrentKrViewItem()->itemRect().topLeft()));
 }
 
 void ListPanel::toggleSyncBrowse()
 {
     syncBrowseButton->toggle();
 }
 
 void ListPanel::editLocation()
 {
     urlNavigator->setUrlEditable(true);
     urlNavigator->setFocus();
     urlNavigator->editor()->lineEdit()->selectAll();
 }
 
 void ListPanel::showSearchBar()
 {
     searchBar->showBar(KrSearchBar::MODE_SEARCH);
 }
 
 void ListPanel::showSearchBarSelection()
 {
     searchBar->showBar(KrSearchBar::MODE_SELECT);
 }
 
 void ListPanel::showSearchBarFilter()
 {
     searchBar->showBar(KrSearchBar::MODE_FILTER);
 }
 
 void ListPanel::saveSettings(KConfigGroup cfg, bool saveHistory)
 {
     QUrl url = virtualPath();
     url.setPassword(QString()); // make sure no password is saved
     cfg.writeEntry("Url", url.toString());
     cfg.writeEntry("Type", getType());
     cfg.writeEntry("Properties", getProperties());
     cfg.writeEntry("PinnedUrl", pinnedUrl().toString());
     if(saveHistory)
         func->history->save(KConfigGroup(&cfg, "History"));
     view->saveSettings(KConfigGroup(&cfg, "View"));
 
     // splitter/sidebar state
     if (sidebar && !sidebar->isHidden()) {
         sidebar->saveSettings(KConfigGroup(&cfg, "PanelPopup"));
         cfg.writeEntry("PopupPosition", sidebarPosition());
         cfg.writeEntry("SplitterSizes", sidebarSplitter->saveState());
         cfg.writeEntry("PopupPage", sidebar->currentPage());
     } else {
         cfg.deleteEntry("PopupPosition");
         cfg.deleteEntry("SplitterSizes");
         cfg.deleteEntry("PopupPage");
     }
 }
 
 void ListPanel::restoreSettings(KConfigGroup cfg)
 {
     changeType(cfg.readEntry("Type", defaultPanelType()));
     view->restoreSettings(KConfigGroup(&cfg, "View"));
 
     // "locked" property must be set after URL path is restored!
     // This panel can be reused when loading a profile,
     // so we reset its properties before calling openUrl().
     setProperties(0);
 
     _lastLocalPath = ROOT_DIR;
     if(func->history->restore(KConfigGroup(&cfg, "History"))) {
         func->refresh();
     } else {
         QUrl url(cfg.readEntry("Url", "invalid"));
         if (!url.isValid())
             url = QUrl::fromLocalFile(ROOT_DIR);
         func->openUrl(url);
     }
 
     setJumpBack(func->history->currentUrl());
 
     setProperties(cfg.readEntry("Properties", 0));
 
     if (isPinned()) {
         QUrl pinnedUrl(cfg.readEntry("PinnedUrl", "invalid"));
         if (!pinnedUrl.isValid()) {
             pinnedUrl = func->history->currentUrl();
         }
         func->openUrl(pinnedUrl);
         setPinnedUrl(pinnedUrl);
     }
 
     if (cfg.hasKey("PopupPosition")) { // sidebar was visible, restore
         toggleSidebar(); // create and show
         sidebar->restoreSettings(KConfigGroup(&cfg, "PanelPopup"));
         setSidebarPosition(cfg.readEntry("PopupPosition", 42 /* dummy */));
         sidebarSplitter->restoreState(cfg.readEntry("SplitterSizes", QByteArray()));
         sidebar->setCurrentPage(cfg.readEntry("PopupPage", 0));
     }
 }
 
 void ListPanel::slotCurrentChanged(KrViewItem *item)
 {
     // update status bar
     if (item)
         krApp->statusBarUpdate(item->description());
 
     // update sidebar; which panel to display on?
     Sidebar *p;
     if (sidebar && !sidebar->isHidden()) {
         p = sidebar;
     } else if(otherPanel()->gui->sidebar && !otherPanel()->gui->sidebar->isHidden()) {
         p = otherPanel()->gui->sidebar;
     } else {
         return;
     }
 
     p->update(item ? func->files()->getFileItem(item->name()) : nullptr);
 }
 
 void ListPanel::otherPanelChanged()
 {
     func->syncURL = QUrl();
 }
 
 void ListPanel::getFocusCandidates(QVector<QWidget*> &widgets)
 {
     if(urlNavigator->editor()->isVisible())
         widgets << urlNavigator->editor();
     if(view->widget()->isVisible())
         widgets << view->widget();
     if(sidebar && sidebar->isVisible())
         widgets << sidebar;
 }
 
 void ListPanel::updateButtons()
 {
     backButton->setEnabled(func->history->canGoBack());
     forwardButton->setEnabled(func->history->canGoForward());
     historyButton->setEnabled(func->history->count() > 1);
     cdRootButton->setEnabled(!virtualPath().matches(QUrl::fromLocalFile(ROOT_DIR),
                                                     QUrl::StripTrailingSlash));
     cdUpButton->setEnabled(!func->files()->isRoot());
     cdHomeButton->setEnabled(!func->atHome());
 }
 
 void ListPanel::newTab(KrViewItem *it)
 {
     if (!it)
         return;
     else if (it->name() == "..") {
         newTab(KIO::upUrl(virtualPath()), true);
     } else if (func->getFileItem(it)->isDir()) {
         QUrl url = virtualPath();
         url = url.adjusted(QUrl::StripTrailingSlash);
         url.setPath(url.path() + '/' + (it->name()));
         newTab(url, true);
     }
 }
 
 void ListPanel::newTab(const QUrl &url, bool nextToThis)
 {
-    _manager->newTab(url, nextToThis ? this : 0);
+    _manager->newTab(url, nextToThis ? this : nullptr);
 }
 
 void ListPanel::slotNavigatorUrlChanged(const QUrl &url)
 {
     if (url == _navigatorUrl)
         return; // this is the URL we just set ourself
 
     if (!isNavigatorEditModeSet()) {
         urlNavigator->setUrlEditable(false);
     }
 
     func->openUrl(KrServices::escapeFileUrl(url), QString(), true);
 }
 
 void ListPanel::resetNavigatorMode()
 {
     if (isNavigatorEditModeSet())
         return;
 
     // set to "navigate" mode if url wasn't changed
     if (urlNavigator->uncommittedUrl().matches(virtualPath(), QUrl::StripTrailingSlash)) {
         // NOTE: this also sets focus to the navigator
         urlNavigator->setUrlEditable(false);
         slotFocusOnMe();
     }
 }
 
 int ListPanel::sidebarPosition() const
 {
     int pos = sidebarSplitter->orientation() == Qt::Vertical ? 1 : 0;
     return pos + (qobject_cast<Sidebar*>(sidebarSplitter->widget(0)) == NULL ? 2 : 0);
 }
 
 void ListPanel::setSidebarPosition(int pos)
 {
     sidebarSplitter->setOrientation(pos % 2 == 0 ? Qt::Horizontal : Qt::Vertical);
     if ((pos < 2) != (qobject_cast<Sidebar*>(sidebarSplitter->widget(0)) != NULL)) {
         sidebarSplitter->insertWidget(0, sidebarSplitter->widget(1)); // swapping widgets in splitter
     }
 }
 
 void ListPanel::connectQuickSizeCalculator(SizeCalculator *sizeCalculator)
 {
     connect(sizeCalculator, &SizeCalculator::started, this, [=]() {
         quickSizeCalcProgress->reset();
         quickSizeCalcProgress->show();
         cancelQuickSizeCalcButton->show();
     });
     connect(cancelQuickSizeCalcButton, &QToolButton::clicked, sizeCalculator, &SizeCalculator::cancel);
     connect(sizeCalculator, &SizeCalculator::progressChanged, quickSizeCalcProgress, &QProgressBar::setValue);
     connect(sizeCalculator, &SizeCalculator::finished, this, [=]() {
         cancelQuickSizeCalcButton->hide();
         quickSizeCalcProgress->hide();
     });
 }
diff --git a/krusader/Panel/listpanel.h b/krusader/Panel/listpanel.h
index 4297ad08..fd36820a 100644
--- a/krusader/Panel/listpanel.h
+++ b/krusader/Panel/listpanel.h
@@ -1,258 +1,258 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 #ifndef LISTPANEL_H
 #define LISTPANEL_H
 
 // QtCore
 #include <QString>
 #include <QDir>
 #include <QList>
 #include <QEvent>
 #include <QPointer>
 #include <QUrl>
 // QtGui
 #include <QPixmap>
 #include <QPixmapCache>
 #include <QIcon>
 #include <QDropEvent>
 #include <QKeyEvent>
 #include <QShowEvent>
 #include <QHideEvent>
 // QtWidgets
 #include <QProgressBar>
 #include <QWidget>
 #include <QLabel>
 #include <QLayout>
 #include <QSplitter>
 #include <QToolButton>
 #include <QGridLayout>
 
 #include <KCompletion/KLineEdit>
 #include <KConfigCore/KConfigGroup>
 #include <KIO/Job>
 #include <KIOCore/KFileItem>
 #include <KIOFileWidgets/KUrlNavigator>
 
 #include "krpanel.h"
 
 #define PROP_SYNC_BUTTON_ON               1
 #define PROP_LOCKED                       2
 #define PROP_PINNED                       4
 
 class DirHistoryButton;
 class KrBookmarkButton;
 class KrErrorDisplay;
 class KrSqueezedTextLabel;
 class KrSearchBar;
 class KrView;
 class KrViewItem;
 class ListPanelActions;
 class ListPanelFunc;
 class MediaButton;
 class Sidebar;
 class SizeCalculator;
 
 class ListPanel : public QWidget, public KrPanel
 {
     friend class ListPanelFunc;
     Q_OBJECT
 public:
 
     enum TabState {
         DEFAULT,
         LOCKED,
         // locked tab with changeable address
         PINNED
     };
 
     // constructor create the panel, but DOESN'T fill it with data, use start()
-    ListPanel(QWidget *parent, AbstractPanelManager *manager, KConfigGroup cfg = KConfigGroup());
-    ~ListPanel();
+    ListPanel(QWidget *parent, AbstractPanelManager *manager, const KConfigGroup& cfg = KConfigGroup());
+    ~ListPanel() override;
 
-    virtual void otherPanelChanged() Q_DECL_OVERRIDE;
+    void otherPanelChanged() Q_DECL_OVERRIDE;
 
     void start(const QUrl &url = QUrl());
 
     void reparent(QWidget *parent, AbstractPanelManager *manager);
 
     int getType() {
         return panelType;
     }
     void changeType(int);
     bool isLocked() {
         return _tabState == TabState::LOCKED;
     }
     bool isPinned() {
         return _tabState == TabState::PINNED;
     }
     void setTabState(TabState tabState) {
         _tabState = tabState;
     }
 
     ListPanelActions *actions() {
         return _actions;
     }
     QString lastLocalPath() const;
     QString getCurrentName();
     QStringList getSelectedNames();
     void setButtons();
     void setJumpBack(QUrl url);
 
     int  getProperties();
     void setProperties(int);
 
     void getFocusCandidates(QVector<QWidget*> &widgets);
 
     void saveSettings(KConfigGroup cfg, bool saveHistory);
     void restoreSettings(KConfigGroup cfg);
 
     void setPinnedUrl(QUrl &pinnedUrl) { _pinnedUrl = pinnedUrl; };
     QUrl pinnedUrl() const { return _pinnedUrl; };
 
 public slots:
     void handleDrop(QDropEvent *event, bool onView = false); // handle drops on frame or view
     void handleDrop(const QUrl &destination, QDropEvent *event); // handle drops with destination
     void popRightClickMenu(const QPoint&);
     void popEmptyRightClickMenu(const QPoint &);
     void compareDirs(bool otherPanelToo = true);
     void slotFocusOnMe(bool focus = true);
     void slotUpdateTotals();
     // react to file changes in filesystem (path change or refresh)
     void slotStartUpdate(bool directoryChange);
     void toggleSidebar();
     void panelVisible(); // called when the panel becomes active
     void panelHidden(); // called when panel becomes inactive
     void slotRefreshColors();
     void cancelProgress(); // cancel filesystem refresh and/or preview (if running)
     void setNavigatorUrl(const QUrl &url);
 
     void openMedia();
     void openHistory();
     void openBookmarks();
     void rightclickMenu();
     void toggleSyncBrowse();
     void editLocation();
     void showSearchBar();
     void showSearchBarSelection();
     void showSearchBarFilter();
     void jumpBack();
     void setJumpBack() {
         setJumpBack(virtualPath());
     }
 
     ///////////////////////// service functions - called internally ////////////////////////
     void prepareToDelete();                   // internal use only
 
 protected:
-    virtual void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
-    virtual void mousePressEvent(QMouseEvent*) Q_DECL_OVERRIDE {
+    void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
+    void mousePressEvent(QMouseEvent*) Q_DECL_OVERRIDE {
         slotFocusOnMe();
     }
-    virtual void showEvent(QShowEvent *) Q_DECL_OVERRIDE;
-    virtual void hideEvent(QHideEvent *) Q_DECL_OVERRIDE;
-    virtual bool eventFilter(QObject * watched, QEvent * e) Q_DECL_OVERRIDE;
+    void showEvent(QShowEvent *) Q_DECL_OVERRIDE;
+    void hideEvent(QHideEvent *) Q_DECL_OVERRIDE;
+    bool eventFilter(QObject * watched, QEvent * e) Q_DECL_OVERRIDE;
 
     void showButtonMenu(QToolButton *b);
     void createView();
     void updateButtons();
 
     static int defaultPanelType();
     static bool isNavigatorEditModeSet(); // return the navigator edit mode setting
 
 protected slots:
     void slotCurrentChanged(KrViewItem *item);
-    void startDragging(QStringList, QPixmap);
+    void startDragging(const QStringList&, const QPixmap&);
     void slotPreviewJobStarted(KJob *job);
     void slotPreviewJobPercent(KJob *job, unsigned long percent);
     void slotPreviewJobResult(KJob *job);
     // those handle the in-panel refresh notifications
     void slotRefreshJobStarted(KIO::Job* job);
     void inlineRefreshInfoMessage(KJob* job, const QString &msg);
     void inlineRefreshListResult(KJob* job);
     void inlineRefreshPercent(KJob*, unsigned long);
-    void slotFilesystemError(QString msg);
+    void slotFilesystemError(const QString& msg);
     void newTab(KrViewItem *item);
     void newTab(const QUrl &url, bool nextToThis = false);
     void slotNavigatorUrlChanged(const QUrl &url);
     void resetNavigatorMode(); // set navigator mode after focus was lost
     // update filesystem meta info, disk-free and mount status
     void updateFilesystemStats(const QString &metaInfo,  const QString &fsType,
                                KIO::filesize_t total, KIO::filesize_t free);
 
 signals:
     void signalStatus(QString msg); // emitted when we need to update the status bar
     void pathChanged(const QUrl &url); // directory changed or refreshed
     void activate(); // emitted when the user changes panels
     void finishedDragging(); // NOTE: currently not used
     void signalRefreshColors(bool active);
 
 protected:
     int panelType;
     QString _lastLocalPath;
     QUrl _jumpBackURL;
     int colorMask;
     bool compareMode;
     //FilterSpec    filter;
     KJob *previewJob;
     KIO::Job *inlineRefreshJob;
     ListPanelActions *_actions;
 
     QPixmap currDragPix;
     QWidget *clientArea;
     QSplitter *sidebarSplitter;
     KUrlNavigator* urlNavigator;
     KrSearchBar* searchBar;
     QToolButton *backButton, *forwardButton;
     QToolButton *cdRootButton;
     QToolButton *cdHomeButton;
     QToolButton *cdUpButton;
     QToolButton *cdOtherButton;
     QToolButton *sidebarPositionButton;
     QToolButton *sidebarButton;
     Sidebar *sidebar; // lazy initialized
     KrBookmarkButton *bookmarksButton;
     KrSqueezedTextLabel *status, *totals, *freeSpace;
 
     QProgressBar *quickSizeCalcProgress;
     QToolButton *cancelQuickSizeCalcButton;
     QProgressBar *previewProgress;
     DirHistoryButton* historyButton;
     MediaButton *mediaButton;
     QToolButton *syncBrowseButton;
     QToolButton *cancelProgressButton; // for thumbnail previews and filesystem refresh
     KrErrorDisplay *fileSystemError;
 
 private:
     bool handleDropInternal(QDropEvent *event, const QString &dir);
     int sidebarPosition() const; // 0: West, 1: North, 2: East, 3: South
     void setSidebarPosition(int);
     void connectQuickSizeCalculator(SizeCalculator *sizeCalculator);
 
 private:
     QUrl _navigatorUrl; // distinguish between new user set URL and new custom set URL
     QUrl _pinnedUrl; // only for TabState::PINNED
     TabState _tabState;
     QList<int> sidebarSplitterSizes;
 };
 
 #endif
diff --git a/krusader/Panel/listpanelactions.cpp b/krusader/Panel/listpanelactions.cpp
index 9f5cb4fa..ba5862d7 100644
--- a/krusader/Panel/listpanelactions.cpp
+++ b/krusader/Panel/listpanelactions.cpp
@@ -1,219 +1,219 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "listpanelactions.h"
 
 #include "listpanel.h"
 #include "panelfunc.h"
 #include "PanelView/krviewfactory.h"
 #include "../krmainwindow.h"
 #include "../Dialogs/krdialogs.h"
 #include "../KViewer/krviewer.h"
 #include "../icon.h"
 
 // QtCore
 #include <QSignalMapper>
 // QtWidgets
 #include <QActionGroup>
 
 #include <KI18n/KLocalizedString>
 #include <KXmlGui/KActionCollection>
 
 
 ListPanelActions::ListPanelActions(QObject *parent, KrMainWindow *mainWindow) :
         ActionsBase(parent, mainWindow)
 {
     // set view type
-    QSignalMapper *mapper = new QSignalMapper(this);
+    auto *mapper = new QSignalMapper(this);
     connect(mapper, QOverload<int>::of(&QSignalMapper::mapped), this, &ListPanelActions::setView);
-    QActionGroup *group = new QActionGroup(this);
+    auto *group = new QActionGroup(this);
     group->setExclusive(true);
     QList<KrViewInstance*> views = KrViewFactory::registeredViews();
     for(int i = 0; i < views.count(); i++) {
         KrViewInstance *inst = views[i];
         QAction *action = new QAction(Icon(inst->iconName()), inst->description(), group);
         action->setCheckable(true);
         connect(action, &QAction::triggered, mapper, QOverload<>::of(&QSignalMapper::map));
         mapper->setMapping(action, inst->id());
         _mainWindow->actions()->addAction("view" + QString::number(i), action);
         _mainWindow->actions()->setDefaultShortcut(action, inst->shortcut());
         setViewActions.insert(inst->id(), action);
     }
 
     // standard actions
     actHistoryBackward = stdAction(KStandardAction::Back, _func, SLOT(historyBackward()));
     actHistoryForward = stdAction(KStandardAction::Forward, _func, SLOT(historyForward()));
     //FIXME: second shortcut for up: see actDirUp
     //   KStandardAction::up( this, SLOT(dirUp()), actionCollection )->setShortcut(Qt::Key_Backspace);
     /* Shortcut disabled because of the Terminal Emulator bug. */
     actDirUp = stdAction(KStandardAction::Up, _func, SLOT(dirUp()));
     actHome = stdAction(KStandardAction::Home, _func, SLOT(home()));
 
     actCut = stdAction(KStandardAction::Cut, _func, SLOT(cut()));
     actCut->setText(i18n("Cut to Clipboard"));
     // removing alternative shift+del shortcut, it is used for the alternative delete files action
     QList<QKeySequence> cutShortcuts = actCut->shortcuts();
     cutShortcuts.removeAll(QKeySequence(Qt::SHIFT | Qt::Key_Delete));
     _mainWindow->actions()->setDefaultShortcuts(actCut, cutShortcuts);
     actCopy = stdAction(KStandardAction::Copy, _func, SLOT(copyToClipboard()));
     actCopy->setText(i18n("Copy to Clipboard"));
     actPaste = stdAction(KStandardAction::Paste, _func, SLOT(pasteFromClipboard()));
     actPaste->setText(i18n("Paste from Clipboard"));
 
     // Fn keys
     actRenameF2 = action(i18n("Rename"), "edit-rename", Qt::Key_F2, _func, SLOT(rename()) , "F2_Rename");
-    actViewFileF3 = action(i18n("View File"), 0, Qt::Key_F3, _func, SLOT(view()), "F3_View");
-    actEditFileF4 = action(i18n("Edit File"), 0, Qt::Key_F4, _func, SLOT(edit()) , "F4_Edit");
-    actCopyF5 = action(i18n("Copy to other panel"), 0, Qt::Key_F5, _func, SLOT(copyFiles()) , "F5_Copy");
-    actMoveF6 = action(i18n("Move to other panel"), 0, Qt::Key_F6, _func, SLOT(moveFiles()) , "F6_Move");
-    actCopyDelayedF5 = action(i18n("Copy delayed..."), 0, Qt::SHIFT + Qt::Key_F5, _func, SLOT(copyFilesDelayed()) , "F5_Copy_Queue");
-    actMoveDelayedShiftF6 = action(i18n("Move delayed..."), 0, Qt::SHIFT + Qt::Key_F6, _func, SLOT(moveFilesDelayed()) , "F6_Move_Queue");
+    actViewFileF3 = action(i18n("View File"), nullptr, Qt::Key_F3, _func, SLOT(view()), "F3_View");
+    actEditFileF4 = action(i18n("Edit File"), nullptr, Qt::Key_F4, _func, SLOT(edit()) , "F4_Edit");
+    actCopyF5 = action(i18n("Copy to other panel"), nullptr, Qt::Key_F5, _func, SLOT(copyFiles()) , "F5_Copy");
+    actMoveF6 = action(i18n("Move to other panel"), nullptr, Qt::Key_F6, _func, SLOT(moveFiles()) , "F6_Move");
+    actCopyDelayedF5 = action(i18n("Copy delayed..."), nullptr, Qt::SHIFT + Qt::Key_F5, _func, SLOT(copyFilesDelayed()) , "F5_Copy_Queue");
+    actMoveDelayedShiftF6 = action(i18n("Move delayed..."), nullptr, Qt::SHIFT + Qt::Key_F6, _func, SLOT(moveFilesDelayed()) , "F6_Move_Queue");
     actNewFolderF7 = action(i18n("New Folder..."), "folder-new", Qt::Key_F7, _func, SLOT(mkdir()) , "F7_Mkdir");
     actDeleteF8 = action(i18n("Delete"), "edit-delete", Qt::Key_F8, _func, SLOT(defaultDeleteFiles()) , "F8_Delete");
     actTerminalF9 = action(i18n("Start Terminal Here"), "utilities-terminal", Qt::Key_F9, _func, SLOT(terminal()) , "F9_Terminal");
     action(i18n("&New Text File..."), "document-new", Qt::SHIFT + Qt::Key_F4, _func, SLOT(editNew()), "edit_new_file");
-    action(i18n("F3 View Dialog"), 0, Qt::SHIFT + Qt::Key_F3, _func, SLOT(viewDlg()), "F3_ViewDlg");
+    action(i18n("F3 View Dialog"), nullptr, Qt::SHIFT + Qt::Key_F3, _func, SLOT(viewDlg()), "F3_ViewDlg");
 
     // file operations
-    action(i18n("Right-click Menu"), 0, Qt::Key_Menu, _gui, SLOT(rightclickMenu()), "rightclick menu");
+    action(i18n("Right-click Menu"), nullptr, Qt::Key_Menu, _gui, SLOT(rightclickMenu()), "rightclick menu");
     actProperties = action(i18n("&Properties..."), "document-properties", Qt::ALT + Qt::Key_Return, _func, SLOT(properties()), "properties");
     actCompDirs = action(i18n("&Compare Folders"), "kr_comparedirs", Qt::ALT + Qt::SHIFT + Qt::Key_C, _gui, SLOT(compareDirs()), "compare dirs");
     actCalculate = action(i18n("Calculate &Occupied Space"), "accessories-calculator", 0, _func, SLOT(calcSpace()), "calculate");
     actPack = action(i18n("Pac&k..."), "archive-insert", Qt::ALT + Qt::SHIFT + Qt::Key_P, _func, SLOT(pack()), "pack");
     actUnpack = action(i18n("&Unpack..."), "archive-extract", Qt::ALT + Qt::SHIFT + Qt::Key_U, _func, SLOT(unpack()), "unpack");
     actCreateChecksum = action(i18n("Create Checksum..."), "document-edit-sign", 0, _func, SLOT(createChecksum()), "create checksum");
     actMatchChecksum = action(i18n("Verify Checksum..."), "document-edit-decrypt-verify", 0, _func, SLOT(matchChecksum()), "match checksum");
-    action(i18n("New Symlink..."), 0, Qt::CTRL + Qt::ALT + Qt::Key_S, _func, SLOT(krlink()), "new symlink");
+    action(i18n("New Symlink..."), nullptr, Qt::CTRL + Qt::ALT + Qt::Key_S, _func, SLOT(krlink()), "new symlink");
     actTest = action(i18n("T&est Archive"), "archive-extract", Qt::ALT + Qt::SHIFT + Qt::Key_E, _func, SLOT(testArchive()), "test archives");
     action(i18n("Alternative Delete"), "edit-delete", Qt::Key_Delete + Qt::CTRL, _func, SLOT(alternativeDeleteFiles()), "alternative delete");
 
     // navigation
     actRoot = action(i18n("Root"), "folder-red", Qt::CTRL + Qt::Key_Backspace, _func, SLOT(root()), "root");
-    actCdToOther = action(i18n("Go to Other Panel's Folder"), 0, Qt::CTRL + Qt::Key_Equal, _func, SLOT(cdToOtherPanel()), "cd to other panel");
+    actCdToOther = action(i18n("Go to Other Panel's Folder"), nullptr, Qt::CTRL + Qt::Key_Equal, _func, SLOT(cdToOtherPanel()), "cd to other panel");
     action(i18n("&Reload"), "view-refresh", Qt::CTRL + Qt::Key_R, _func, SLOT(refresh()), "std_redisplay");
     actCancelRefresh = action(i18n("Cancel Refresh of View"), "dialog-cancel", 0, _gui, SLOT(cancelProgress()), "cancel refresh");
     actFTPNewConnect = action(i18n("New Net &Connection..."), "network-connect", Qt::CTRL + Qt::Key_N, _func, SLOT(newFTPconnection()), "ftp new connection");
     actFTPDisconnect = action(i18n("Disconnect &from Net"), "network-disconnect", Qt::SHIFT + Qt::CTRL + Qt::Key_D, _func, SLOT(FTPDisconnect()), "ftp disconnect");
-    action(i18n("Sync Panels"), 0, Qt::ALT + Qt::SHIFT + Qt::Key_O, _func, SLOT(syncOtherPanel()), "sync panels");
+    action(i18n("Sync Panels"), nullptr, Qt::ALT + Qt::SHIFT + Qt::Key_O, _func, SLOT(syncOtherPanel()), "sync panels");
     actJumpBack = action(i18n("Jump Back"), "go-jump", Qt::CTRL + Qt::Key_J, _gui, SLOT(jumpBack()), "jump_back");
     actSetJumpBack = action(i18n("Set Jump Back Point"), "go-jump-definition", Qt::CTRL + Qt::SHIFT + Qt::Key_J, _gui, SLOT(setJumpBack()), "set_jump_back");
     actSyncBrowse = action(i18n("S&ynchron Folder Changes"), "kr_syncbrowse_off", Qt::ALT + Qt::SHIFT + Qt::Key_Y, _gui, SLOT(toggleSyncBrowse()), "sync browse");
-    actLocationBar = action(i18n("Go to Location Bar"), 0, Qt::CTRL + Qt::Key_L, _gui, SLOT(editLocation()), "location_bar");
-    toggleAction(i18n("Toggle Sidebar"), 0, Qt::ALT + Qt::Key_Down, _gui, SLOT(toggleSidebar()), "toggle sidebar");
-    action(i18n("Bookmarks"), 0, Qt::CTRL + Qt::Key_D, _gui, SLOT(openBookmarks()), "bookmarks");
-    action(i18n("Left Bookmarks"), 0, 0, this, SLOT(openLeftBookmarks()), "left bookmarks");
-    action(i18n("Right Bookmarks"), 0, 0, this, SLOT(openRightBookmarks()), "right bookmarks");
-    action(i18n("History"), 0, Qt::CTRL + Qt::Key_H, _gui, SLOT(openHistory()), "history");
-    action(i18n("Left History"), 0, Qt::ALT + Qt::CTRL + Qt::Key_Left, this, SLOT(openLeftHistory()), "left history");
-    action(i18n("Right History"), 0, Qt::ALT + Qt::CTRL + Qt::Key_Right, this, SLOT(openRightHistory()), "right history");
-    action(i18n("Media"), 0, Qt::CTRL + Qt::Key_M, _gui, SLOT(openMedia()), "media");
-    action(i18n("Left Media"), 0, Qt::CTRL + Qt::SHIFT + Qt::Key_Left, this, SLOT(openLeftMedia()), "left media");
-    action(i18n("Right Media"), 0, Qt::CTRL + Qt::SHIFT + Qt::Key_Right, this, SLOT(openRightMedia()), "right media");
+    actLocationBar = action(i18n("Go to Location Bar"), nullptr, Qt::CTRL + Qt::Key_L, _gui, SLOT(editLocation()), "location_bar");
+    toggleAction(i18n("Toggle Sidebar"), nullptr, Qt::ALT + Qt::Key_Down, _gui, SLOT(toggleSidebar()), "toggle sidebar");
+    action(i18n("Bookmarks"), nullptr, Qt::CTRL + Qt::Key_D, _gui, SLOT(openBookmarks()), "bookmarks");
+    action(i18n("Left Bookmarks"), nullptr, 0, this, SLOT(openLeftBookmarks()), "left bookmarks");
+    action(i18n("Right Bookmarks"), nullptr, 0, this, SLOT(openRightBookmarks()), "right bookmarks");
+    action(i18n("History"), nullptr, Qt::CTRL + Qt::Key_H, _gui, SLOT(openHistory()), "history");
+    action(i18n("Left History"), nullptr, Qt::ALT + Qt::CTRL + Qt::Key_Left, this, SLOT(openLeftHistory()), "left history");
+    action(i18n("Right History"), nullptr, Qt::ALT + Qt::CTRL + Qt::Key_Right, this, SLOT(openRightHistory()), "right history");
+    action(i18n("Media"), nullptr, Qt::CTRL + Qt::Key_M, _gui, SLOT(openMedia()), "media");
+    action(i18n("Left Media"), nullptr, Qt::CTRL + Qt::SHIFT + Qt::Key_Left, this, SLOT(openLeftMedia()), "left media");
+    action(i18n("Right Media"), nullptr, Qt::CTRL + Qt::SHIFT + Qt::Key_Right, this, SLOT(openRightMedia()), "right media");
 
     // quick search bar
-    action(i18n("Find in folder..."), 0, Qt::CTRL + Qt::Key_F, _gui, SLOT(showSearchBar()), "search bar");
-    action(i18n("Select in folder..."), 0, Qt::CTRL + Qt::SHIFT + Qt::Key_S, _gui, SLOT(showSearchBarSelection()), "search bar selection");
-    action(i18n("Filter in folder..."), 0, Qt::CTRL + Qt::Key_I, _gui, SLOT(showSearchBarFilter()), "search bar filter");
+    action(i18n("Find in folder..."), nullptr, Qt::CTRL + Qt::Key_F, _gui, SLOT(showSearchBar()), "search bar");
+    action(i18n("Select in folder..."), nullptr, Qt::CTRL + Qt::SHIFT + Qt::Key_S, _gui, SLOT(showSearchBarSelection()), "search bar selection");
+    action(i18n("Filter in folder..."), nullptr, Qt::CTRL + Qt::Key_I, _gui, SLOT(showSearchBarFilter()), "search bar filter");
 
     // and at last we can set the tool-tips
     actRoot->setToolTip(i18n("ROOT (/)"));
 
     actRenameF2->setToolTip(i18n("Rename file, folder, etc."));
     actViewFileF3->setToolTip(i18n("Open file in viewer."));
     actEditFileF4->setToolTip(i18n("<qt><p>Edit file.</p>"
                            "<p>The editor can be defined in Konfigurator, "
                            "default is <b>internal editor</b>.</p></qt>"));
     actCopyF5->setToolTip(i18n("Copy file from one panel to the other."));
     actMoveF6->setToolTip(i18n("Move file from one panel to the other."));
     actNewFolderF7->setToolTip(i18n("Create folder in current panel."));
     actDeleteF8->setToolTip(i18n("Delete file, folder, etc."));
     actTerminalF9->setToolTip(i18n("<qt><p>Open terminal in current folder.</p>"
                            "<p>The terminal can be defined in Konfigurator, "
                            "default is <b>konsole</b>.</p></qt>"));
 
 }
 
 void ListPanelActions::activePanelChanged()
 {
     _gui.reconnect(activePanel()->gui);
     _func.reconnect(activePanel()->func);
 }
 
 void ListPanelActions::guiUpdated()
 {
     QList<QAction*> actions;
     foreach(QAction *action, setViewActions.values())
         actions << action;
     static_cast<KrMainWindow*>(_mainWindow)->plugActionList("view_actionlist", actions);
 }
 
 inline KrPanel *ListPanelActions::activePanel()
 {
     return static_cast<KrMainWindow*>(_mainWindow)->activePanel();
 }
 
 inline KrPanel *ListPanelActions::leftPanel()
 {
     return static_cast<KrMainWindow*>(_mainWindow)->leftPanel();
 }
 
 inline KrPanel *ListPanelActions::rightPanel()
 {
     return static_cast<KrMainWindow*>(_mainWindow)->rightPanel();
 }
 
 // set view type
 
 void ListPanelActions::setView(int id)
 {
     activePanel()->gui->changeType(id);
 }
 
 // navigation
 
 void ListPanelActions::openLeftBookmarks()
 {
     leftPanel()->gui->openBookmarks();
 }
 
 void ListPanelActions::openRightBookmarks()
 {
     rightPanel()->gui->openBookmarks();
 }
 
 void ListPanelActions::openLeftHistory()
 {
     leftPanel()->gui->openHistory();
 }
 
 void ListPanelActions::openRightHistory()
 {
     rightPanel()->gui->openHistory();
 }
 
 void ListPanelActions::openLeftMedia()
 {
     leftPanel()->gui->openMedia();
 }
 
 void ListPanelActions::openRightMedia()
 {
     rightPanel()->gui->openMedia();
 }
diff --git a/krusader/Panel/listpanelframe.cpp b/krusader/Panel/listpanelframe.cpp
index 5ab08240..9388dce8 100644
--- a/krusader/Panel/listpanelframe.cpp
+++ b/krusader/Panel/listpanelframe.cpp
@@ -1,107 +1,107 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "listpanelframe.h"
 
 #include "krcolorcache.h"
 #include "../krglobal.h"
 
 // QtCore
 #include <QUrl>
 // QtGui
 #include <QDragEnterEvent>
 #include <QGuiApplication>
 
 #include <KConfigCore/KSharedConfig>
 #include <KCoreAddons/KUrlMimeData>
 
-ListPanelFrame::ListPanelFrame(QWidget *parent, QString color) : QFrame(parent), color(color)
+ListPanelFrame::ListPanelFrame(QWidget *parent, const QString& color) : QFrame(parent), color(color)
 {
     if(!color.isEmpty()) {
         colorsChanged();
         refreshColors(false);
         setAutoFillBackground(true);
         connect(&KrColorCache::getColorCache(), &KrColorCache::colorsRefreshed, this, &ListPanelFrame::colorsChanged);
     }
 }
 
 void ListPanelFrame::dragEnterEvent(QDragEnterEvent *e)
 {
     if (acceptDrops()) {
         QList<QUrl> URLs = KUrlMimeData::urlsFromMimeData(e->mimeData());
         e->setAccepted(!URLs.isEmpty());
     } else
         QFrame::dragEnterEvent(e);
 }
 
 void ListPanelFrame::colorsChanged()
 {
     QPalette p = QGuiApplication::palette();
-    QColor windowForeground = p.color(QPalette::Active, QPalette::WindowText);
-    QColor windowBackground = p.color(QPalette::Active, QPalette::Window);
+    const QColor& windowForeground = p.color(QPalette::Active, QPalette::WindowText);
+    const QColor& windowBackground = p.color(QPalette::Active, QPalette::Window);
 
     KConfigGroup gc(krConfig, "Colors");
     QColor fgAct = getColor(gc, color + " Foreground Active",
                             p.color(QPalette::Active, QPalette::HighlightedText),
                             windowForeground);
     QColor bgAct = getColor(gc, color + " Background Active",
                             p.color(QPalette::Active, QPalette::Highlight),
                             windowBackground);
     QColor fgInact = getColor(gc, color + " Foreground Inactive",
                               p.color(QPalette::Active, QPalette::Text),
                               windowForeground);
     QColor bgInact = getColor(gc, color + " Background Inactive",
                               p.color(QPalette::Active, QPalette::Base),
                               windowBackground);
 
     palActive = palInactive = palette();
 
     // --- active ---
     // foreground
     palActive.setColor(QPalette::WindowText, fgAct);
     palActive.setColor(QPalette::ButtonText, fgAct);
     // background
     palActive.setColor(QPalette::Window, bgAct);
     palActive.setColor(QPalette::Button, bgAct);
 
     // --- inactive ---
     // foreground
     palInactive.setColor(QPalette::WindowText, fgInact);
     palInactive.setColor(QPalette::ButtonText, fgInact);
     // background
     palInactive.setColor(QPalette::Window, bgInact);
     palInactive.setColor(QPalette::Button, bgInact);
 }
 
 void ListPanelFrame::refreshColors(bool active)
 {
     if(color.isEmpty())
         return;
     setPalette(active ? palActive : palInactive);
 }
 
-QColor ListPanelFrame::getColor(KConfigGroup &cg, QString name, const QColor &def, const QColor &kdedef)
+QColor ListPanelFrame::getColor(KConfigGroup &cg, const QString& name, const QColor &def, const QColor &kdedef)
 {
     if (cg.readEntry(name, QString()) == "KDE default")
         return kdedef;
     else if(!cg.readEntry(name, QString()).isEmpty())
         return cg.readEntry(name, def);
     return def;
 }
diff --git a/krusader/Panel/listpanelframe.h b/krusader/Panel/listpanelframe.h
index 403c1420..582d65b6 100644
--- a/krusader/Panel/listpanelframe.h
+++ b/krusader/Panel/listpanelframe.h
@@ -1,60 +1,60 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef LISTPANELFRAME_H
 #define LISTPANELFRAME_H
 
 // QtGui
 #include <QDropEvent>
 // QtWidgets
 #include <QFrame>
 
 # include <KConfigCore/KConfigGroup>
 
 class QDragEnterEvent;
 
 class ListPanelFrame : public QFrame
 {
     Q_OBJECT
 public:
-    ListPanelFrame(QWidget *parent, QString color);
+    ListPanelFrame(QWidget *parent, const QString& color);
 
 signals:
     void dropped(QDropEvent*, QWidget*); /**< emitted when someone drops URL onto the frame */
 
 protected slots:
     void colorsChanged();
 
 public slots:
     void refreshColors(bool active);
 
 protected:
-    QColor getColor(KConfigGroup &cg, QString name, const QColor &def, const QColor &kdedef);
+    QColor getColor(KConfigGroup &cg, const QString& name, const QColor &def, const QColor &kdedef);
 
-    virtual void dropEvent(QDropEvent *e) Q_DECL_OVERRIDE {
+    void dropEvent(QDropEvent *e) Q_DECL_OVERRIDE {
         emit dropped(e, this);
     }
-    virtual void dragEnterEvent(QDragEnterEvent*) Q_DECL_OVERRIDE;
+    void dragEnterEvent(QDragEnterEvent*) Q_DECL_OVERRIDE;
 
     QString color;
     QPalette palActive, palInactive;
 };
 
 #endif // LISTPANELFRAME_H
diff --git a/krusader/Panel/panelcontextmenu.cpp b/krusader/Panel/panelcontextmenu.cpp
index ad8fdbb9..1e680b5a 100644
--- a/krusader/Panel/panelcontextmenu.cpp
+++ b/krusader/Panel/panelcontextmenu.cpp
@@ -1,433 +1,433 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2003 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "panelcontextmenu.h"
 
 // QtGui
 #include <QPixmap>
 
 #include <KCoreAddons/KProcess>
 #include <KI18n/KLocalizedString>
 #include <KIOWidgets/KRun>
 #include <KWidgetsAddons/KMessageBox>
 #include <KService/KMimeTypeTrader>
 #include <KService/KToolInvocation>
 #include <KXmlGui/KActionCollection>
 #include <KIOCore/KFileItemListProperties>
 #include <KIOWidgets/KAbstractFileItemActionPlugin>
 #include <KCoreAddons/KPluginMetaData>
 
 #include "krpreviewpopup.h"
 #include "listpanel.h"
 #include "listpanelactions.h"
 #include "panelfunc.h"
 #include "PanelView/krview.h"
 #include "PanelView/krviewitem.h"
 #include "../defaults.h"
 #include "../icon.h"
 #include "../krservices.h"
 #include "../krslots.h"
 #include "../krusader.h"
 #include "../krusaderview.h"
 #include "../panelmanager.h"
 #include "../Archive/krarchandler.h"
 #include "../FileSystem/fileitem.h"
 #include "../FileSystem/filesystem.h"
 #include "../FileSystem/krtrashhandler.h"
 #include "../MountMan/kmountman.h"
 #include "../UserAction/useractionpopupmenu.h"
 
 void PanelContextMenu::run(const QPoint &pos, KrPanel *panel)
 {
     PanelContextMenu menu(panel);
     QAction * res = menu.exec(pos);
     int result = -1;
     if (res && res->data().canConvert<int>())
         result = res->data().toInt();
     menu.performAction(result);
 }
 
 /**
  * Copied from dolphin/src/dolphincontextmenu.cpp and modified to add only compress and extract submenus.
  */
 void PanelContextMenu::addCompressAndExtractPluginActions()
 {
     KFileItemListProperties props(_items);
 
     QVector<KPluginMetaData> jsonPlugins = KPluginLoader::findPlugins("kf5/kfileitemaction",
                                                                       [=](const KPluginMetaData& metaData) {
         return metaData.pluginId() == "compressfileitemaction" || metaData.pluginId() == "extractfileitemaction";
     });
 
     foreach (const KPluginMetaData &jsonMetadata, jsonPlugins) {
-        KAbstractFileItemActionPlugin* abstractPlugin = KPluginLoader(jsonMetadata.fileName())
+        auto* abstractPlugin = KPluginLoader(jsonMetadata.fileName())
                                                             .factory()->create<KAbstractFileItemActionPlugin>();
         if (abstractPlugin) {
             abstractPlugin->setParent(this);
             addActions(abstractPlugin->actions(props, this));
         }
     }
 }
 
 PanelContextMenu::PanelContextMenu(KrPanel *krPanel, QWidget *parent)
     : QMenu(parent), panel(krPanel)
 {
     // selected file names
     const QStringList fileNames = panel->gui->getSelectedNames();
 
     // file items
     QList<FileItem*> files;
-    for (const QString fileName : fileNames) {
+    for (const QString& fileName : fileNames) {
         files.append(panel->func->files()->getFileItem(fileName));
     }
 
     // KFileItems
     for (FileItem *file : files) {
         _items.append(KFileItem(file->getUrl(), file->getMime(),
                                 file->getMode()));
     }
 
     if (files.empty()) {
         addCreateNewMenu();
         addSeparator();
         addEmptyMenuEntries();
         return;
     }
 
     const bool multipleSelections = files.size() > 1;
 
     QSet<QString> protocols;
     for (FileItem *file : files) {
         protocols.insert(file->getUrl().scheme());
     }
     const bool inTrash = protocols.contains("trash");
     const bool trashOnly = inTrash && protocols.count() == 1;
 
     FileItem *file = files.first();
 
     // ------------ the OPEN/BROWSE option - open preferred service
     QAction * openAct = addAction(i18n("Open/Run"));
     openAct->setData(QVariant(OPEN_ID));
     if (!multipleSelections) { // meaningful only if one file is selected
         KrViewItemList viewItems;
         panel->view->getSelectedKrViewItems(&viewItems);
         openAct->setIcon(viewItems.first()->icon());
         openAct->setText(file->isExecutable() && !file->isDir() ?
                              i18n("Run") : i18n("Open"));
         // open in a new tab (if folder)
         if (file->isDir()) {
             QAction * openTab = addAction(i18n("Open in New Tab"));
             openTab->setData(QVariant(OPEN_TAB_ID));
             openTab->setIcon(Icon("tab-new"));
             openTab->setText(i18n("Open in New Tab"));
         }
         // if the file can be browsed as archive...
         if (!panel->func->browsableArchivePath(file->getName()).isEmpty()
             // ...but user disabled archive browsing...
             && (!KConfigGroup(krConfig, "Archives")
                 .readEntry("ArchivesAsDirectories", _ArchivesAsDirectories)
              // ...or the file is not a standard archive (e.g. odt, docx, etc.)...
              || !KRarcHandler::arcSupported(file->getMime()))) {
             // ...it will not be browsed as a directory by default, but add an option for it
             QAction *browseAct = addAction(i18n("Browse"));
             browseAct->setData(QVariant(BROWSE_ID));
             browseAct->setIcon(Icon());
             browseAct->setText(i18n("Browse Archive"));
         }
         addSeparator();
     }
 
     // ------------- Preview - local filesystem only ?
     if (panel->func->files()->isLocal()) {
         // create the preview popup
         KrPreviewPopup preview;
         preview.setUrls(panel->func->files()->getUrls(fileNames));
         QAction *previewAction = addMenu(&preview);
         previewAction->setData(QVariant(PREVIEW_ID));
         previewAction->setText(i18n("Preview"));
         previewAction->setIcon(Icon("document-print-preview"));
     }
 
     // -------------- Open with: try to find-out which apps can open the file
     QSet<QString> uniqueMimeTypes;
     for (FileItem *file : files)
         uniqueMimeTypes.insert(file->getMime());
     const QStringList mimeTypes = uniqueMimeTypes.toList();
 
     offers = mimeTypes.count() == 1 ?
                  KMimeTypeTrader::self()->query(mimeTypes.first()) :
                  KFileItemActions::associatedApplications(mimeTypes, QString());
 
     if (!offers.isEmpty()) {
-        QMenu *openWithMenu = new QMenu(this);
+        auto *openWithMenu = new QMenu(this);
         for (int i = 0; i < offers.count(); ++i) {
             QExplicitlySharedDataPointer<KService> service = offers[i];
             if (service->isValid() && service->isApplication()) {
                 openWithMenu->addAction(Icon(service->icon()),
                                    service->name())->setData(QVariant(SERVICE_LIST_ID + i));
             }
         }
         openWithMenu->addSeparator();
         if (!multipleSelections && file->isDir())
             openWithMenu->addAction(Icon("utilities-terminal"),
                                i18n("Terminal"))->setData(QVariant(OPEN_TERM_ID));
         openWithMenu->addAction(i18n("Other..."))->setData(QVariant(CHOOSE_ID));
         QAction *openWithAction = addMenu(openWithMenu);
         openWithAction->setText(i18n("Open With"));
         openWithAction->setIcon(Icon("document-open"));
         addSeparator();
     }
 
     // --------------- user actions
     QAction *userAction = new UserActionPopupMenu(file->getUrl(), this);
     userAction->setText(i18n("User Actions"));
     addAction(userAction);
 
     // --------------- compress/extract actions
     // workaround for Bug 372999: application freezes very long time if many files are selected
     if (_items.length() < 1000)
         // add compress and extract plugins (if available)
         addCompressAndExtractPluginActions();
 
     // --------------- KDE file item actions
     // NOTE: design and usability problem here. Services disabled in kservicemenurc settings won't
     // be added to the menu. But Krusader does not provide a way do change these settings (only
     // Dolphin does).
-    KFileItemActions *fileItemActions = new KFileItemActions(this);
+    auto *fileItemActions = new KFileItemActions(this);
     fileItemActions->setItemListProperties(KFileItemListProperties(_items));
     fileItemActions->setParentWidget(MAIN_VIEW);
     fileItemActions->addServiceActionsTo(this);
 
     addSeparator();
 
     // ------------- 'create new' submenu
     addCreateNewMenu();
     addSeparator();
 
     // ---------- COPY
     addAction(panel->gui->actions()->actCopyF5);
     // ------- MOVE
     addAction(panel->gui->actions()->actMoveF6);
     // ------- RENAME - only one file
     if (!multipleSelections && !inTrash) {
         addAction(panel->gui->actions()->actRenameF2);
     }
 
     // -------- MOVE TO TRASH
     if (KConfigGroup(krConfig, "General").readEntry("Move To Trash", _MoveToTrash)
         && panel->func->files()->canMoveToTrash(fileNames)) {
         addAction(Icon("user-trash"),
                   i18n("Move to Trash"))->setData(QVariant(TRASH_ID));
     }
     // -------- DELETE
     addAction(Icon("edit-delete"),
               i18n("Delete"))->setData(QVariant(DELETE_ID));
     // -------- SHRED - only one file
     /*      if ( panel->func->files() ->getType() == filesystem:fileSystemM_NORMAL &&
                 !fileitem->isDir() && !multipleSelections )
              addAction( i18n( "Shred" ) )->setData( QVariant( SHRED_ID ) );*/
 
     // ---------- link handling
     // create new shortcut or redirect links - only on local directories:
     if (panel->func->files()->isLocal()) {
         addSeparator();
-        QMenu *linkMenu = new QMenu(this);
+        auto *linkMenu = new QMenu(this);
         linkMenu->addAction(i18n("New Symlink..."))->setData(QVariant(NEW_SYMLINK_ID));
         linkMenu->addAction(i18n("New Hardlink..."))->setData(QVariant(NEW_LINK_ID));
         if (file->isSymLink()) {
             linkMenu->addAction(i18n("Redirect Link..."))->setData(QVariant(REDIRECT_LINK_ID));
         }
         QAction *linkAction = addMenu(linkMenu);
         linkAction->setText(i18n("Link Handling"));
         linkAction->setIcon(Icon("insert-link"));
     }
     addSeparator();
 
     // ---------- calculate space
     if (panel->func->files()->isLocal() && (file->isDir() || multipleSelections))
         addAction(panel->gui->actions()->actCalculate);
 
     // ---------- mount/umount/eject
     if (panel->func->files()->isLocal() && file->isDir() && !multipleSelections) {
         const QString selectedDirectoryPath = file->getUrl().path();
         if (krMtMan.getStatus(selectedDirectoryPath) == KMountMan::MOUNTED)
             addAction(i18n("Unmount"))->setData(QVariant(UNMOUNT_ID));
         else if (krMtMan.getStatus(selectedDirectoryPath) == KMountMan::NOT_MOUNTED)
             addAction(i18n("Mount"))->setData(QVariant(MOUNT_ID));
         if (krMtMan.ejectable(selectedDirectoryPath))
             addAction(i18n("Eject"))->setData(QVariant(EJECT_ID));
     }
 
     // --------- send by mail
     if (KrServices::supportedTools().contains("MAIL") && !file->isDir()) {
         addAction(Icon("mail-send"),
                   i18n("Send by Email"))->setData(QVariant(SEND_BY_EMAIL_ID));
     }
 
     // --------- empty trash
     if (trashOnly) {
         addAction(i18n("Restore"))->setData(QVariant(RESTORE_TRASHED_FILE_ID));
         addAction(i18n("Empty Trash"))->setData(QVariant(EMPTY_TRASH_ID));
     }
 
 #ifdef SYNCHRONIZER_ENABLED
     // --------- synchronize
     if (panel->view->numSelected()) {
         addAction(i18n("Synchronize Selected Files..."))->setData(QVariant(SYNC_SELECTED_ID));
     }
 #endif
 
     // --------- copy/paste
     addSeparator();
     addAction(panel->gui->actions()->actCut);
     addAction(panel->gui->actions()->actCopy);
     addAction(panel->gui->actions()->actPaste);
     addSeparator();
 
     // --------- properties
     addAction(panel->gui->actions()->actProperties);
 }
 
 void PanelContextMenu::addEmptyMenuEntries()
 {
     addAction(panel->gui->actions()->actPaste);
 }
 
 void PanelContextMenu::addCreateNewMenu()
 {
-    QMenu *createNewMenu = new QMenu(this);
+    auto *createNewMenu = new QMenu(this);
 
     createNewMenu->addAction(Icon("folder"),
                              i18n("Folder..."))->setData(QVariant(MKDIR_ID));
     createNewMenu->addAction(Icon("text-plain"),
                              i18n("Text File..."))->setData(QVariant(NEW_TEXT_FILE_ID));
 
     QAction *newMenuAction = addMenu(createNewMenu);
     newMenuAction->setText(i18n("Create New"));
     newMenuAction->setIcon(Icon("document-new"));
 }
 
 void PanelContextMenu::performAction(int id)
 {
     const QUrl singleURL = _items.isEmpty() ? QUrl() : _items.first().url();
 
     switch (id) {
     case - 1 : // the user clicked outside of the menu
         return;
     case OPEN_TAB_ID :
         // assuming only 1 file is selected (otherwise we won't get here)
         panel->manager()->newTab(singleURL, panel);
         break;
     case OPEN_ID :
         foreach(const KFileItem &fi, _items)
             panel->func->execute(fi.name());
         break;
     case BROWSE_ID :
         panel->func->goInside(singleURL.fileName());
         break;
     case COPY_ID :
         panel->func->copyFiles();
         break;
     case MOVE_ID :
         panel->func->moveFiles();
         break;
     case TRASH_ID :
         panel->func->deleteFiles(true);
         break;
     case DELETE_ID :
         panel->func->deleteFiles(false);
         break;
     case EJECT_ID :
         krMtMan.eject(singleURL.adjusted(QUrl::StripTrailingSlash).path());
         break;
 //     case SHRED_ID :
 //        if ( KMessageBox::warningContinueCancel( krApp,
 //             i18n("<qt>Do you really want to shred <b>%1</b>? Once shred, the file is gone forever.</qt>", item->name()),
 //             QString(), KStandardGuiItem::cont(), KStandardGuiItem::cancel(), "Shred" ) == KMessageBox::Continue )
 //           KShred::shred( panel->func->files() ->getFile( item->name() ).adjusted(QUrl::RemoveTrailingSlash).path() );
 //      break;
     case OPEN_KONQ_ID :
         KToolInvocation::startServiceByDesktopName("konqueror", singleURL.toDisplayString(QUrl::PreferLocalFile));
         break;
     case CHOOSE_ID : // open-with dialog
         panel->func->displayOpenWithDialog(_items.urlList());
         break;
     case MOUNT_ID :
         krMtMan.mount(singleURL.adjusted(QUrl::StripTrailingSlash).path());
         break;
     case NEW_LINK_ID :
         panel->func->krlink(false);
         break;
     case NEW_SYMLINK_ID :
         panel->func->krlink(true);
         break;
     case REDIRECT_LINK_ID :
         panel->func->redirectLink();
         break;
     case EMPTY_TRASH_ID :
         KrTrashHandler::emptyTrash();
         break;
     case RESTORE_TRASHED_FILE_ID :
         KrTrashHandler::restoreTrashedFiles(_items.urlList());
     break;
     case UNMOUNT_ID :
         krMtMan.unmount(singleURL.adjusted(QUrl::StripTrailingSlash).path());
         break;
     case SEND_BY_EMAIL_ID : {
         SLOTS->sendFileByEmail(_items.urlList());
         break;
     }
     case MKDIR_ID :
         panel->func->mkdir();
         break;
     case NEW_TEXT_FILE_ID:
         panel->func->editNew();
         break;
 #ifdef SYNCHRONIZER_ENABLED
     case SYNC_SELECTED_ID : {
         QStringList selectedNames;
-        for (const KFileItem item : _items) {
+        for (const KFileItem& item : _items) {
             selectedNames.append(item.name());
         }
         KrViewItemList otherItems;
         panel->otherPanel()->view->getSelectedKrViewItems(&otherItems);
         for (KrViewItem *otherItem : otherItems) {
-            const QString name = otherItem->name();
+            const QString& name = otherItem->name();
             if (!selectedNames.contains(name)) {
                 selectedNames.append(name);
             }
         }
         SLOTS->slotSynchronizeDirs(selectedNames);
     }
     break;
 #endif
     case OPEN_TERM_ID :
         SLOTS->runTerminal(singleURL.path());
         break;
     }
 
     // check if something from the open-with-offered-services was selected
     if (id >= SERVICE_LIST_ID) {
         const QStringList names = panel->gui->getSelectedNames();
         panel->func->runService(*(offers[ id - SERVICE_LIST_ID ]),
                                 panel->func->files()->getUrls(names));
     }
 }
diff --git a/krusader/Panel/panelcontextmenu.h b/krusader/Panel/panelcontextmenu.h
index fc1648ec..bc241ee7 100644
--- a/krusader/Panel/panelcontextmenu.h
+++ b/krusader/Panel/panelcontextmenu.h
@@ -1,88 +1,88 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2003 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef PANELCONTEXTMENU_H
 #define PANELCONTEXTMENU_H
 
 // QtWidgets
 #include <QMenu>
 
 #include <KService/KService>
 #include <KIOWidgets/KFileItemActions>
 
 class KrPanel;
 
 
 /**
  * The right-click context menu for files and folders in the panel view.
  *
  * An instance is created each time a menu is shown.
  */
 class PanelContextMenu : public QMenu
 {
     Q_OBJECT
 public:
     static void run(const QPoint &pos, KrPanel *panel);
 
 private:
-    explicit PanelContextMenu(KrPanel *thePanel, QWidget *parent = 0);
+    explicit PanelContextMenu(KrPanel *thePanel, QWidget *parent = nullptr);
     void performAction(int id);
     void addEmptyMenuEntries(); // adds the choices for a menu without selected items
     void addCreateNewMenu(); // adds a "create new" submenu
     void addCompressAndExtractPluginActions(); // adds various plugin actions
 
     enum ID {
         OPEN_ID,
         BROWSE_ID,
         OPEN_KONQ_ID,
         OPEN_TERM_ID,
         OPEN_TAB_ID,
         PREVIEW_ID,
         KONQ_MENU_ID,
         CHOOSE_ID,
         DELETE_ID,
         COPY_ID,
         MOVE_ID,
         PROPERTIES_ID,
         MOUNT_ID,
         UNMOUNT_ID,
         TRASH_ID,
         NEW_LINK_ID,
         NEW_SYMLINK_ID,
         REDIRECT_LINK_ID,
         EMPTY_TRASH_ID,
         RESTORE_TRASHED_FILE_ID,
         SYNC_SELECTED_ID,
         SEND_BY_EMAIL_ID,
         EJECT_ID,
         MKDIR_ID,
         NEW_TEXT_FILE_ID,
         SERVICE_LIST_ID // ALWAYS KEEP THIS ONE LAST!!!
     };
 
 private:
     KrPanel *const panel;
     KFileItemList _items;
     KService::List offers;
 
 };
 
 #endif
diff --git a/krusader/Panel/panelfunc.cpp b/krusader/Panel/panelfunc.cpp
index f8f08655..b2aba1dc 100644
--- a/krusader/Panel/panelfunc.cpp
+++ b/krusader/Panel/panelfunc.cpp
@@ -1,1291 +1,1291 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "panelfunc.h"
 
 // QtCore
 #include <QEventLoop>
 #include <QList>
 #include <QMimeData>
 #include <QDir>
 #include <QTemporaryFile>
 #include <QUrl>
 // QtGui
 #include <QClipboard>
 #include <QDrag>
 // QtWidgets
 #include <QApplication>
 #include <QInputDialog>
 
 #include <KArchive/KTar>
 #include <KConfigCore/KDesktopFile>
 #include <KCoreAddons/KJobTrackerInterface>
 #include <KCoreAddons/KProcess>
 #include <KCoreAddons/KShell>
 #include <KCoreAddons/KUrlMimeData>
 #include <KI18n/KLocalizedString>
 #include <KIO/DesktopExecParser>
 #include <KIO/JobUiDelegate>
 #include <KIOCore/KProtocolInfo>
 #include <KIOWidgets/KOpenWithDialog>
 #include <KIOWidgets/KPropertiesDialog>
 #include <KIOWidgets/KRun>
 #include <KService/KMimeTypeTrader>
 #include <KWidgetsAddons/KCursor>
 #include <KWidgetsAddons/KMessageBox>
 #include <KWidgetsAddons/KToggleAction>
 
 #include "dirhistoryqueue.h"
 #include "krcalcspacedialog.h"
 #include "krerrordisplay.h"
 #include "krsearchbar.h"
 #include "listpanel.h"
 #include "listpanelactions.h"
 #include "PanelView/krview.h"
 #include "PanelView/krviewitem.h"
 #include "../krglobal.h"
 #include "../krslots.h"
 #include "../kractions.h"
 #include "../defaults.h"
 #include "../abstractpanelmanager.h"
 #include "../krservices.h"
 #include "../Archive/krarchandler.h"
 #include "../Archive/packjob.h"
 #include "../FileSystem/fileitem.h"
 #include "../FileSystem/virtualfilesystem.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../FileSystem/filesystemprovider.h"
 #include "../FileSystem/sizecalculator.h"
 #include "../Dialogs/packgui.h"
 #include "../Dialogs/krdialogs.h"
 #include "../Dialogs/krpleasewait.h"
 #include "../Dialogs/krspwidgets.h"
 #include "../Dialogs/checksumdlg.h"
 #include "../KViewer/krviewer.h"
 #include "../MountMan/kmountman.h"
 
 QPointer<ListPanelFunc> ListPanelFunc::copyToClipboardOrigin;
 
 ListPanelFunc::ListPanelFunc(ListPanel *parent) : QObject(parent),
-        panel(parent), fileSystemP(0), urlManuallyEntered(false),
-        _isPaused(true), _refreshAfterPaused(true), _quickSizeCalculator(0)
+        panel(parent), fileSystemP(nullptr), urlManuallyEntered(false),
+        _isPaused(true), _refreshAfterPaused(true), _quickSizeCalculator(nullptr)
 {
     history = new DirHistoryQueue(panel);
     delayTimer.setSingleShot(true);
     connect(&delayTimer, &QTimer::timeout, this, &ListPanelFunc::doRefresh);
 }
 
 ListPanelFunc::~ListPanelFunc()
 {
     if (fileSystemP) {
         fileSystemP->deleteLater();
     }
     delete history;
     if (_quickSizeCalculator)
         _quickSizeCalculator->deleteLater();
 }
 
 bool ListPanelFunc::isSyncing(const QUrl &url)
 {
     if(otherFunc()->otherFunc() == this &&
        panel->otherPanel()->gui->syncBrowseButton->isChecked() &&
        !otherFunc()->syncURL.isEmpty() &&
        otherFunc()->syncURL == url)
         return true;
 
     return false;
 }
 
 void ListPanelFunc::openFileNameInternal(const QString &name, bool externallyExecutable)
 {
     if (name == "..") {
         dirUp();
         return;
     }
 
     FileItem *fileitem = files()->getFileItem(name);
-    if (fileitem == 0)
+    if (fileitem == nullptr)
         return;
 
     QUrl url = files()->getUrl(name);
 
     if (fileitem->isDir()) {
         panel->view->setNameToMakeCurrent(QString());
         openUrl(url);
         return;
     }
 
     QString mime = fileitem->getMime();
 
     QUrl arcPath = browsableArchivePath(name);
     if (!arcPath.isEmpty()) {
         bool browseAsDirectory = !externallyExecutable
                 || (KConfigGroup(krConfig, "Archives").readEntry("ArchivesAsDirectories", _ArchivesAsDirectories)
                 && (KRarcHandler::arcSupported(mime) || KrServices::isoSupported(mime)));
         if (browseAsDirectory) {
             openUrl(arcPath);
             return;
         }
     }
 
     if (externallyExecutable) {
         if (KRun::isExecutableFile(url, mime)) {
             runCommand(KShell::quoteArg(url.path()));
             return;
         }
 
         KService::Ptr service = KMimeTypeTrader::self()->preferredService(mime);
         if(service) {
             runService(*service, QList<QUrl>() << url);
             return;
         }
 
         displayOpenWithDialog(QList<QUrl>() << url);
     }
 }
 
 QUrl ListPanelFunc::cleanPath(const QUrl &urlIn)
 {
     QUrl url = urlIn;
     url.setPath(QDir::cleanPath(url.path()));
     if (!url.isValid() || url.isRelative()) {
         if (url.url() == "~")
             url = QUrl::fromLocalFile(QDir::homePath());
         else if (!url.url().startsWith('/')) {
             // possible relative URL - translate to full URL
             url = files()->currentDirectory();
             url.setPath(url.path() + '/' + urlIn.path());
         }
     }
     url.setPath(QDir::cleanPath(url.path()));
     return url;
 }
 
 void ListPanelFunc::openUrl(const QUrl &url, const QString& nameToMakeCurrent,
                             bool manuallyEntered)
 {
     qDebug() << "URL=" << url.toDisplayString() << "; name to current=" << nameToMakeCurrent;
     if (panel->syncBrowseButton->isChecked()) {
         //do sync-browse stuff....
         if(syncURL.isEmpty())
             syncURL = panel->otherPanel()->virtualPath();
 
         QString relative = QDir(panel->virtualPath().path() + '/').relativeFilePath(url.path());
         syncURL.setPath(QDir::cleanPath(syncURL.path() + '/' + relative));
         panel->otherPanel()->gui->setTabState(ListPanel::TabState::DEFAULT);
         otherFunc()->openUrlInternal(syncURL, nameToMakeCurrent, false, false);
     }
     openUrlInternal(url, nameToMakeCurrent, false, manuallyEntered);
 }
 
 void ListPanelFunc::immediateOpenUrl(const QUrl &url)
 {
     openUrlInternal(url, QString(), true, false);
 }
 
 void ListPanelFunc::openUrlInternal(const QUrl &url, const QString& nameToMakeCurrent,
                                     bool immediately, bool manuallyEntered)
 {
     const QUrl cleanUrl = cleanPath(url);
 
     if (panel->isLocked() &&
             !files()->currentDirectory().matches(cleanUrl, QUrl::StripTrailingSlash)) {
         panel->_manager->newTab(url);
         urlManuallyEntered = false;
         return;
     }
 
     urlManuallyEntered = manuallyEntered;
 
     const QString currentItem = history->currentUrl().path() == cleanUrl.path()
                                 ? history->currentItem()
                                 : nameToMakeCurrent;
 
     history->add(cleanUrl, currentItem);
 
     if(immediately)
         doRefresh();
     else
         refresh();
 }
 
 void ListPanelFunc::refresh()
 {
     panel->cancelProgress();
     delayTimer.start(0); // to avoid qApp->processEvents() deadlock situation
 }
 
 void ListPanelFunc::doRefresh()
 {
     delayTimer.stop();
 
     if (_isPaused) {
         _refreshAfterPaused = true;
         // simulate refresh
         panel->slotStartUpdate(true);
         return;
     } else {
         _refreshAfterPaused = false;
     }
 
     const QUrl url = history->currentUrl();
 
     if(!url.isValid()) {
         panel->slotStartUpdate(true);  // refresh the panel
         urlManuallyEntered = false;
         return;
     }
 
     panel->cancelProgress();
 
     // if we are not refreshing to current URL
     const bool isEqualUrl = files()->currentDirectory().matches(url, QUrl::StripTrailingSlash);
 
     if (!isEqualUrl) {
         panel->setCursor(Qt::WaitCursor);
         panel->view->clearSavedSelection();
     }
 
     if (panel->fileSystemError) {
         panel->fileSystemError->hide();
     }
 
     panel->setNavigatorUrl(url);
 
     // may get a new filesystem for this url
     FileSystem *fileSystem = FileSystemProvider::instance().getFilesystem(url, files());
     fileSystem->setParentWindow(krMainWindow);
     connect(fileSystem, &FileSystem::aboutToOpenDir, &krMtMan, &KMountMan::autoMount, Qt::DirectConnection);
     if (fileSystem != fileSystemP) {
-        panel->view->setFiles(0);
+        panel->view->setFiles(nullptr);
 
         // disconnect older signals
-        disconnect(fileSystemP, 0, panel, 0);
+        disconnect(fileSystemP, nullptr, panel, nullptr);
 
         fileSystemP->deleteLater();
         fileSystemP = fileSystem; // v != 0 so this is safe
     } else {
         if (fileSystemP->isRefreshing()) {
             // TODO remove busy waiting here
             delayTimer.start(100); /* if filesystem is busy try refreshing later */
             return;
         }
     }
     // (re)connect filesystem signals
-    disconnect(files(), 0, panel, 0);
+    disconnect(files(), nullptr, panel, nullptr);
     connect(files(), &DirListerInterface::scanDone, panel, &ListPanel::slotStartUpdate);
     connect(files(), &FileSystem::fileSystemInfoChanged, panel, &ListPanel::updateFilesystemStats);
     connect(files(), &FileSystem::refreshJobStarted, panel, &ListPanel::slotRefreshJobStarted);
     connect(files(), &FileSystem::error, panel, &ListPanel::slotFilesystemError);
 
     panel->view->setFiles(files());
 
     if (!isEqualUrl || !panel->view->getCurrentKrViewItem()) {
         // set current item after refresh from history, if there is none yet
         panel->view->setNameToMakeCurrent(history->currentItem());
     }
 
     // workaround for detecting panel deletion while filesystem is refreshing
     QPointer<ListPanel> panelSave = panel;
     // NOTE: this is blocking. Returns false on error or interruption (cancel requested or panel
     // was deleted)
     const bool scanned = fileSystemP->refresh(url);
     if (scanned) {
         // update the history and address bar, as the actual url might differ from the one requested
         history->setCurrentUrl(fileSystemP->currentDirectory());
         panel->setNavigatorUrl(fileSystemP->currentDirectory());
     } else if (!panelSave) {
         return;
     }
 
     panel->view->setNameToMakeCurrent(QString());
 
     panel->setCursor(Qt::ArrowCursor);
 
     // on local file system change the working directory
     if (files()->isLocal())
         QDir::setCurrent(KrServices::urlToLocalPath(files()->currentDirectory()));
 
     // see if the open url operation failed, and if so,
     // put the attempted url in the navigator bar and let the user change it
     if (!scanned) {
         if(isSyncing(url))
             panel->otherPanel()->gui->syncBrowseButton->setChecked(false);
         else if(urlManuallyEntered) {
             panel->setNavigatorUrl(url);
             if(panel == ACTIVE_PANEL)
                 panel->editLocation();
         }
     }
 
     if(otherFunc()->otherFunc() == this)  // not true if our tab is not active
         otherFunc()->syncURL = QUrl();
 
     urlManuallyEntered = false;
 
     refreshActions();
 }
 
 void ListPanelFunc::setPaused(bool paused) {
     if (paused == _isPaused)
         return;
     _isPaused = paused;
 
     // TODO: disable refresh() in local file system when paused
 
     if (!_isPaused && _refreshAfterPaused)
         refresh();
 }
 
 void ListPanelFunc::redirectLink()
 {
     if (!files()->isLocal()) {
         KMessageBox::sorry(krMainWindow, i18n("You can edit links only on local file systems"));
         return;
     }
 
     FileItem *fileitem = files()->getFileItem(panel->getCurrentName());
     if (!fileitem)
         return;
 
     QString file = fileitem->getUrl().path();
     QString currentLink = fileitem->getSymDest();
     if (currentLink.isEmpty()) {
         KMessageBox::sorry(krMainWindow, i18n("The current file is not a link, so it cannot be redirected."));
         return;
     }
 
     // ask the user for a new destination
     bool ok = false;
     QString newLink =
         QInputDialog::getText(krMainWindow, i18n("Link Redirection"), i18n("Please enter the new link destination:"), QLineEdit::Normal, currentLink, &ok);
 
     // if the user canceled - quit
     if (!ok || newLink == currentLink)
         return;
     // delete the current link
     if (unlink(file.toLocal8Bit()) == -1) {
         KMessageBox::sorry(krMainWindow, i18n("Cannot remove old link: %1", file));
         return;
     }
     // try to create a new symlink
     if (symlink(newLink.toLocal8Bit(), file.toLocal8Bit()) == -1) {
         KMessageBox:: /* --=={ Patch by Heiner <h.eichmann@gmx.de> }==-- */sorry(krMainWindow, i18n("Failed to create a new link: %1", file));
         return;
     }
 }
 
 void ListPanelFunc::krlink(bool sym)
 {
     if (!files()->isLocal()) {
         KMessageBox::sorry(krMainWindow, i18n("You can create links only on local file systems"));
         return;
     }
 
     QString name = panel->getCurrentName();
 
     // ask the new link name..
     bool ok = false;
     QString linkName =
         QInputDialog::getText(krMainWindow, i18n("New Link"),
                               i18n("Create a new link to: %1", name), QLineEdit::Normal, name, &ok);
 
     // if the user canceled - quit
     if (!ok || linkName == name)
         return;
 
     // if the name is already taken - quit
-    if (files()->getFileItem(linkName) != 0) {
+    if (files()->getFileItem(linkName) != nullptr) {
         KMessageBox::sorry(krMainWindow, i18n("A folder or a file with this name already exists."));
         return;
     }
 
     // make link name and target absolute path
     if (linkName.left(1) != "/")
         linkName = files()->currentDirectory().path() + '/' + linkName;
     name = files()->getUrl(name).path();
 
     if (sym) {
         if (symlink(name.toLocal8Bit(), linkName.toLocal8Bit()) == -1)
             KMessageBox::sorry(krMainWindow,
                                i18n("Failed to create a new symlink '%1' to: '%2'", linkName, name));
     } else {
         if (link(name.toLocal8Bit(), linkName.toLocal8Bit()) == -1)
             KMessageBox::sorry(krMainWindow,
                                i18n("Failed to create a new link '%1' to '%2'", linkName, name));
     }
 }
 
 void ListPanelFunc::view()
 {
     panel->searchBar->hideBarIfSearching();
 
     QString fileName = panel->getCurrentName();
     if (fileName.isNull())
         return;
 
     // if we're trying to view a directory, just exit
     FileItem *fileitem = files()->getFileItem(fileName);
     if (!fileitem || fileitem->isDir())
         return;
     if (!fileitem->isReadable()) {
-        KMessageBox::sorry(0, i18n("No permissions to view this file."));
+        KMessageBox::sorry(nullptr, i18n("No permissions to view this file."));
         return;
     }
     // call KViewer.
     KrViewer::view(files()->getUrl(fileName));
     // nothing more to it!
 }
 
 void ListPanelFunc::viewDlg()
 {
     // ask the user for a url to view
     QUrl dest = KChooseDir::getFile(i18n("Enter a URL to view:"), QUrl(panel->getCurrentName()), panel->virtualPath());
     if (dest.isEmpty())
         return ;   // the user canceled
 
     KrViewer::view(dest);   // view the file
 }
 
 void ListPanelFunc::terminal()
 {
     SLOTS->runTerminal(panel->lastLocalPath());
 }
 
 void ListPanelFunc::edit()
 {
     panel->searchBar->hideBarIfSearching();
     KFileItem tmp;
 
     if (fileToCreate.isEmpty()) {
         QString name = panel->getCurrentName();
         if (name.isNull())
             return;
         fileToCreate = files()->getUrl(name);
     }
 
     tmp = KFileItem(fileToCreate);
 
     if (tmp.isDir()) {
         KMessageBox::sorry(krMainWindow, i18n("You cannot edit a folder"));
         fileToCreate = QUrl();
         return;
     }
 
     if (!tmp.isReadable()) {
-        KMessageBox::sorry(0, i18n("No permissions to edit this file."));
+        KMessageBox::sorry(nullptr, i18n("No permissions to edit this file."));
         fileToCreate = QUrl();
         return;
     }
 
     KrViewer::edit(fileToCreate);
     fileToCreate = QUrl();
 }
 
 void ListPanelFunc::editNew()
 {
     if(!fileToCreate.isEmpty())
         return;
 
     // ask the user for the filename to edit
     fileToCreate = KChooseDir::getFile(i18n("Enter the filename to edit:"), QUrl(panel->getCurrentName()), panel->virtualPath());
     if(fileToCreate.isEmpty())
         return ;   // the user canceled
 
     // if the file exists, edit it instead of creating a new one
     QFile f(fileToCreate.toLocalFile());
 
     if(f.exists()) {
         edit();
     } else {
-        QTemporaryFile *tempFile = new QTemporaryFile;
+        auto *tempFile = new QTemporaryFile;
         tempFile->open();
 
         KIO::CopyJob *job = KIO::copy(QUrl::fromLocalFile(tempFile->fileName()), fileToCreate);
-        job->setUiDelegate(0);
+        job->setUiDelegate(nullptr);
         job->setDefaultPermissions(true);
         connect(job, &KIO::CopyJob::result, this, &ListPanelFunc::slotFileCreated);
         connect(job, &KIO::CopyJob::result, tempFile, &QTemporaryFile::deleteLater);
     }
 }
 
 void ListPanelFunc::slotFileCreated(KJob *job)
 {
     if(!job->error() || job->error() == KIO::ERR_FILE_ALREADY_EXIST) {
         KrViewer::edit(fileToCreate);
 
         if(KIO::upUrl(fileToCreate).matches(panel->virtualPath(), QUrl::StripTrailingSlash))
             refresh();
         else if(KIO::upUrl(fileToCreate).matches(panel->otherPanel()->virtualPath(), QUrl::StripTrailingSlash))
             otherFunc()->refresh();
     }
     else
         KMessageBox::sorry(krMainWindow, job->errorString());
 
     fileToCreate = QUrl();
 }
 
 void ListPanelFunc::copyFiles(bool enqueue, bool move)
 {
     panel->searchBar->hideBarIfSearching();
 
     const QStringList fileNames = panel->getSelectedNames();
     if (fileNames.isEmpty())
         return ;  // safety
 
     QUrl destination = panel->otherPanel()->virtualPath();
 
     bool fullDestPath = false;
     if (fileNames.count() == 1 && otherFunc()->files()->type() != FileSystem::FS_VIRTUAL) {
         FileItem *item = files()->getFileItem(fileNames[0]);
         if (item && !item->isDir()) {
             fullDestPath = true;
             // add original filename to destination
             destination.setPath(QDir(destination.path()).filePath(item->getUrl().fileName()));
         }
     }
     if (!fullDestPath) {
         destination = FileSystem::ensureTrailingSlash(destination);
     }
 
     const KConfigGroup group(krConfig, "Advanced");
     const bool showDialog = move ? group.readEntry("Confirm Move", _ConfirmMove) :
                                    group.readEntry("Confirm Copy", _ConfirmCopy);
 
     if (showDialog) {
         QString operationText;
         if (move) {
             operationText = fileNames.count() == 1
                                 ? i18n("Move %1 to:", fileNames.first())
                                 : i18np("Move %1 file to:", "Move %1 files to:", fileNames.count());
         } else {
             operationText = fileNames.count() == 1
                                 ? i18n("Copy %1 to:", fileNames.first())
                                 : i18np("Copy %1 file to:", "Copy %1 files to:", fileNames.count());
         }
 
         // ask the user for the copy/move dest
         const KChooseDir::ChooseResult result =
             KChooseDir::getCopyDir(operationText, destination, panel->virtualPath());
         destination = result.url;
         if (destination.isEmpty())
             return ; // the user canceled
 
         enqueue = result.enqueue;
     }
 
     const JobMan::StartMode startMode =
         enqueue && krJobMan->isQueueModeEnabled() ? JobMan::Delay :
         !enqueue && !krJobMan->isQueueModeEnabled() ? JobMan::Start : JobMan::Enqueue;
 
     const QList<QUrl> fileUrls = files()->getUrls(fileNames);
 
     if (move) {
         // after the delete return the cursor to the first unmarked file above the current item
         panel->prepareToDelete();
     }
 
     // make sure the user does not overwrite multiple files by mistake
     if (fileNames.count() > 1) {
         destination = FileSystem::ensureTrailingSlash(destination);
     }
 
     const KIO::CopyJob::CopyMode mode = move ? KIO::CopyJob::Move : KIO::CopyJob::Copy;
     FileSystemProvider::instance().startCopyFiles(fileUrls, destination, mode, true, startMode);
 
     if(KConfigGroup(krConfig, "Look&Feel").readEntry("UnselectBeforeOperation", _UnselectBeforeOperation)) {
         panel->view->saveSelection();
         panel->view->unselectAll();
     }
 }
 
 // called from SLOTS to begin the renaming process
 void ListPanelFunc::rename()
 {
     panel->searchBar->hideBarIfSearching();
     panel->view->renameCurrentItem();
 }
 
 // called by signal itemRenamed() from the view to complete the renaming process
 void ListPanelFunc::rename(const QString &oldname, const QString &newname)
 {
     if (oldname == newname)
         return ; // do nothing
 
     // set current after rename
     panel->view->setNameToMakeCurrent(newname);
 
     // as always - the filesystem do the job
     files()->rename(oldname, newname);
 }
 
 void ListPanelFunc::mkdir()
 {
     // ask the new dir name..
     // suggested name is the complete name for the directories
     // while filenames are suggested without their extension
     QString suggestedName = panel->getCurrentName();
     if (!suggestedName.isEmpty() && !files()->getFileItem(suggestedName)->isDir())
         suggestedName = QFileInfo(suggestedName).completeBaseName();
 
     const QString dirName = QInputDialog::getText(krMainWindow, i18n("New folder"), i18n("Folder's name:"), QLineEdit::Normal, suggestedName);
 
     const QString firstName = dirName.section('/', 0, 0, QString::SectionIncludeLeadingSep);
 
     // if the user canceled or the name was composed of slashes - quit
     if (!dirName.startsWith('/') && firstName.isEmpty()) {
         return;
     }
 
     // notify user about existing folder if only single directory was given
     if (!dirName.contains('/') && files()->getFileItem(firstName)) {
         // focus the existing directory
         panel->view->setCurrentItem(firstName);
         // show error message
         KMessageBox::sorry(krMainWindow, i18n("A folder or a file with this name already exists."));
         return;
     }
 
     // focus new directory when next refresh happens
     panel->view->setNameToMakeCurrent(firstName);
 
     // create new directory (along with underlying directories if necessary)
     files()->mkDir(dirName);
 }
 
 void ListPanelFunc::defaultOrAlternativeDeleteFiles(bool invert)
 {
     const bool trash = KConfigGroup(krConfig, "General").readEntry("Move To Trash", _MoveToTrash);
     deleteFiles(trash != invert);
 }
 
 void ListPanelFunc::deleteFiles(bool moveToTrash)
 {
     panel->searchBar->hideBarIfSearching();
 
     const bool isVFS = files()->type() == FileSystem::FS_VIRTUAL;
     if (isVFS && files()->isRoot()) {
         // only virtual deletion possible
         removeVirtualFiles();
         return;
     }
 
     // first get the selected file names list
     const QStringList fileNames = panel->getSelectedNames();
     if (fileNames.isEmpty())
         return;
 
     // move to trash: only if possible
     moveToTrash = moveToTrash && files()->canMoveToTrash(fileNames);
 
     // now ask the user if he/she is sure:
 
     const QList<QUrl> confirmedUrls = confirmDeletion(
         files()->getUrls(fileNames), moveToTrash, isVFS, false);
 
     if (confirmedUrls.isEmpty())
         return; // nothing to delete
 
     // after the delete return the cursor to the first unmarked
     // file above the current item;
     panel->prepareToDelete();
 
     // let the filesystem do the job...
     files()->deleteFiles(confirmedUrls, moveToTrash);
 }
 
 QList<QUrl> ListPanelFunc::confirmDeletion(const QList<QUrl> &urls, bool moveToTrash,
                                            bool virtualFS, bool showPath)
 {
     QStringList files;
-    for (QUrl fileUrl : urls) {
+    for (const QUrl& fileUrl : urls) {
         files.append(showPath ? fileUrl.toDisplayString(QUrl::PreferLocalFile) : fileUrl.fileName());
     }
 
     const KConfigGroup advancedGroup(krConfig, "Advanced");
     if (advancedGroup.readEntry("Confirm Delete", _ConfirmDelete)) {
         QString s; // text
         KGuiItem b; // continue button
 
         if (moveToTrash) {
             s = i18np("Do you really want to move this item to the trash?",
                       "Do you really want to move these %1 items to the trash?", files.count());
             b = KGuiItem(i18n("&Trash"));
         } else if (virtualFS) {
             s = i18np("<qt>Do you really want to delete this item <b>physically</b> (not just "
                       "removing it from the virtual items)?</qt>",
                       "<qt>Do you really want to delete these %1 items <b>physically</b> (not just "
                       "removing them from the virtual items)?</qt>",
                       files.count());
             b = KStandardGuiItem::del();
         } else {
             s = i18np("Do you really want to delete this item?",
                       "Do you really want to delete these %1 items?", files.count());
             b = KStandardGuiItem::del();
         }
 
         // show message
         // note: i'm using continue and not yes/no because the yes/no has cancel as default button
         if (KMessageBox::warningContinueCancelList(krMainWindow, s, files, i18n("Warning"),
                                                    b) != KMessageBox::Continue) {
             return QList<QUrl>();
         }
     }
 
     // we want to warn the user about non empty dir
     const bool emptyDirVerify = advancedGroup.readEntry("Confirm Unempty Dir", _ConfirmUnemptyDir);
 
     QList<QUrl> toDelete;
     if (emptyDirVerify) {
         QSet<QUrl> confirmedFiles = urls.toSet();
-        for (QUrl fileUrl : urls) {
+        for (const QUrl& fileUrl : urls) {
             if (!fileUrl.isLocalFile()) {
                 continue; // TODO only local fs supported
             }
 
             const QString filePath = fileUrl.toLocalFile();
             QFileInfo fileInfo(filePath);
             if (fileInfo.isDir() && !fileInfo.isSymLink()) {
                 // read local dir...
                 const QDir dir(filePath);
                 if (!dir.entryList(QDir::AllEntries | QDir::System | QDir::Hidden |
                                    QDir::NoDotAndDotDot).isEmpty()) {
 
                     // ...is not empty, ask user
                     const QString fileString = showPath ? filePath : fileUrl.fileName();
                     const KMessageBox::ButtonCode result = KMessageBox::warningYesNoCancel(
                         krMainWindow,
                         i18n("<qt><p>Folder <b>%1</b> is not empty.</p>", fileString) +
                             (moveToTrash ? i18n("<p>Skip this one or trash all?</p></qt>") :
                                            i18n("<p>Skip this one or delete all?</p></qt>")),
                         QString(), KGuiItem(i18n("&Skip")),
                         KGuiItem(moveToTrash ? i18n("&Trash All") : i18n("&Delete All")));
                     if (result == KMessageBox::Yes) {
                         confirmedFiles.remove(fileUrl); // skip this dir
                     } else if (result == KMessageBox::No) {
                         break; // accept all remaining
                     } else {
                         return QList<QUrl>(); // cancel
                     }
                 }
             }
         }
         toDelete = confirmedFiles.toList();
     } else {
         toDelete = urls;
     }
 
     return toDelete;
 }
 
 void ListPanelFunc::removeVirtualFiles()
 {
     if (files()->type() != FileSystem::FS_VIRTUAL) {
         qWarning() << "filesystem not virtual";
         return;
     }
 
     const QStringList fileNames = panel->getSelectedNames();
     if (fileNames.isEmpty())
         return;
 
     const QString text =
         i18np("Do you really want to delete this virtual item (physical files stay untouched)?",
               "Do you really want to delete these %1 virtual items (physical files stay "
               "untouched)?",
               fileNames.count());
     if (KMessageBox::warningContinueCancelList(krMainWindow, text, fileNames, i18n("Warning"),
                                                KStandardGuiItem::remove()) != KMessageBox::Continue)
         return;
 
-    VirtualFileSystem *fileSystem = static_cast<VirtualFileSystem*>(files());
+    auto *fileSystem = dynamic_cast<VirtualFileSystem*>(files());
     fileSystem->remove(fileNames);
 }
 
 void ListPanelFunc::goInside(const QString& name)
 {
     openFileNameInternal(name, false);
 }
 
-void ListPanelFunc::runCommand(QString cmd)
+void ListPanelFunc::runCommand(const QString& cmd)
 {
     qDebug() << "command=" << cmd;
     const QString workdir = panel->virtualPath().isLocalFile() ?
             panel->virtualPath().path() : QDir::homePath();
     if(!KRun::runCommand(cmd, krMainWindow, workdir))
-        KMessageBox::error(0, i18n("Could not start %1", cmd));
+        KMessageBox::error(nullptr, i18n("Could not start %1", cmd));
 }
 
-void ListPanelFunc::runService(const KService &service, QList<QUrl> urls)
+void ListPanelFunc::runService(const KService &service, const QList<QUrl>& urls)
 {
     qDebug() << "service name=" << service.name();
     KIO::DesktopExecParser parser(service, urls);
     QStringList args = parser.resultingArguments();
     if (!args.isEmpty())
         runCommand(KShell::joinArgs(args));
     else
-        KMessageBox::error(0, i18n("%1 cannot open %2", service.name(), KrServices::toStringList(urls).join(", ")));
+        KMessageBox::error(nullptr, i18n("%1 cannot open %2", service.name(), KrServices::toStringList(urls).join(", ")));
 }
 
-void ListPanelFunc::displayOpenWithDialog(QList<QUrl> urls)
+void ListPanelFunc::displayOpenWithDialog(const QList<QUrl>& urls)
 {
     // NOTE: we are not using KRun::displayOpenWithDialog() because we want the commands working
     // directory to be the panel directory
     KOpenWithDialog dialog(urls, panel);
     dialog.hideRunInTerminal();
     if (dialog.exec()) {
         KService::Ptr service = dialog.service();
         if(!service)
             service = KService::Ptr(new KService(dialog.text(), dialog.text(), QString()));
         runService(*service, urls);
     }
 }
 
 QUrl ListPanelFunc::browsableArchivePath(const QString &filename)
 {
     FileItem *fileitem = files()->getFileItem(filename);
     QUrl url = files()->getUrl(filename);
     QString mime = fileitem->getMime();
 
     if(url.isLocalFile()) {
         QString protocol = KrServices::registeredProtocol(mime);
         if(!protocol.isEmpty()) {
             url.setScheme(protocol);
             return url;
         }
     }
     return QUrl();
 }
 
 // this is done when you double click on a file
 void ListPanelFunc::execute(const QString& name)
 {
     openFileNameInternal(name, true);
 }
 
 void ListPanelFunc::pack()
 {
     const QStringList fileNames = panel->getSelectedNames();
     if (fileNames.isEmpty())
         return ;  // safety
 
     if (fileNames.count() == 0)
         return ; // nothing to pack
 
     // choose the default name
     QString defaultName = panel->virtualPath().fileName();
     if (defaultName.isEmpty())
         defaultName = "pack";
     if (fileNames.count() == 1)
         defaultName = fileNames.first();
     // ask the user for archive name and packer
     new PackGUI(defaultName, panel->otherPanel()->virtualPath().toDisplayString(QUrl::PreferLocalFile | QUrl::StripTrailingSlash),
                 fileNames.count(), fileNames.first());
     if (PackGUI::type.isEmpty()) {
         return ; // the user canceled
     }
 
     // check for partial URLs
     if (!PackGUI::destination.contains(":/") && !PackGUI::destination.startsWith('/')) {
         PackGUI::destination = panel->virtualPath().toDisplayString() + '/' + PackGUI::destination;
     }
 
     QString destDir = PackGUI::destination;
     if (!destDir.endsWith('/'))
         destDir += '/';
 
     bool packToOtherPanel = (destDir == FileSystem::ensureTrailingSlash(panel->otherPanel()->virtualPath()).toDisplayString(QUrl::PreferLocalFile));
 
     QUrl destURL = QUrl::fromUserInput(destDir + PackGUI::filename + '.' + PackGUI::type, QString(), QUrl::AssumeLocalFile);
     if (destURL.isLocalFile() && QFile::exists(destURL.path())) {
         QString msg = i18n("<qt><p>The archive <b>%1.%2</b> already exists. Do you want to overwrite it?</p><p>All data in the previous archive will be lost.</p></qt>", PackGUI::filename, PackGUI::type);
         if (PackGUI::type == "zip") {
             msg = i18n("<qt><p>The archive <b>%1.%2</b> already exists. Do you want to overwrite it?</p><p>Zip will replace identically named entries in the zip archive or add entries for new names.</p></qt>", PackGUI::filename, PackGUI::type);
         }
         if (KMessageBox::warningContinueCancel(krMainWindow, msg, QString(), KStandardGuiItem::overwrite())
                 == KMessageBox::Cancel)
             return ; // stop operation
     } else if (destURL.scheme() == QStringLiteral("virt")) {
         KMessageBox::error(krMainWindow, i18n("Cannot pack files onto a virtual destination."));
         return;
     }
 
     PackJob * job = PackJob::createPacker(files()->currentDirectory(), destURL, fileNames, PackGUI::type, PackGUI::extraProps);
     job->setUiDelegate(new KIO::JobUiDelegate());
     KIO::getJobTracker()->registerJob(job);
     job->uiDelegate()->setAutoErrorHandlingEnabled(true);
 
     if (packToOtherPanel)
         connect(job, &PackJob::result, panel->otherPanel()->func, &ListPanelFunc::refresh);
 
 }
 
 void ListPanelFunc::testArchive()
 {
     const QStringList fileNames = panel->getSelectedNames();
     if (fileNames.isEmpty())
         return ;  // safety
 
     TestArchiveJob * job = TestArchiveJob::testArchives(files()->currentDirectory(), fileNames);
     job->setUiDelegate(new KIO::JobUiDelegate());
     KIO::getJobTracker()->registerJob(job);
     job->uiDelegate()->setAutoErrorHandlingEnabled(true);
 }
 
 void ListPanelFunc::unpack()
 {
     const QStringList fileNames = panel->getSelectedNames();
     if (fileNames.isEmpty())
         return ;  // safety
 
     QString s;
     if (fileNames.count() == 1)
         s = i18n("Unpack %1 to:", fileNames[0]);
     else
         s = i18np("Unpack %1 file to:", "Unpack %1 files to:", fileNames.count());
 
     // ask the user for the copy dest
     QUrl dest = KChooseDir::getDir(s, panel->otherPanel()->virtualPath(), panel->virtualPath());
     if (dest.isEmpty()) return ;   // the user canceled
 
     bool packToOtherPanel = (dest.matches(panel->otherPanel()->virtualPath(), QUrl::StripTrailingSlash));
 
     UnpackJob * job = UnpackJob::createUnpacker(files()->currentDirectory(), dest, fileNames);
     job->setUiDelegate(new KIO::JobUiDelegate());
     KIO::getJobTracker()->registerJob(job);
     job->uiDelegate()->setAutoErrorHandlingEnabled(true);
 
     if (packToOtherPanel)
         connect(job, &UnpackJob::result, panel->otherPanel()->func, &ListPanelFunc::refresh);
 
 }
 
 void ListPanelFunc::createChecksum()
 {
     if (!panel->func->files()->isLocal())
         return; // only local, non-virtual files are supported
 
     KrViewItemList items;
     panel->view->getSelectedKrViewItems(&items);
 
     QStringList fileNames;
     for (KrViewItem *item : items) {
         FileItem *file = panel->func->getFileItem(item);
         fileNames.append(file->getUrl().fileName());
     }
 
     if (fileNames.isEmpty())
         return; // nothing selected and no valid current file
 
     Checksum::startCreationWizard(panel->virtualPath().toLocalFile(), fileNames);
 }
 
 void ListPanelFunc::matchChecksum()
 {
     if (!panel->func->files()->isLocal())
         return; // only local, non-virtual files are supported
 
     FileItem *currentItem = files()->getFileItem(panel->getCurrentName());
     const QString checksumFilePath = currentItem ? currentItem->getUrl().toLocalFile() : QString();
 
     Checksum::startVerifyWizard(panel->virtualPath().toLocalFile(), checksumFilePath);
 }
 
 void ListPanelFunc::calcSpace()
 {
     QStringList fileNames;
     panel->view->getSelectedItems(&fileNames);
     if (fileNames.isEmpty()) {
         // current file is ".." dummy file
         panel->view->selectAllIncludingDirs();
         panel->view->getSelectedItems(&fileNames);
         panel->view->unselectAll();
     }
 
     SizeCalculator *sizeCalculator = createAndConnectSizeCalculator(files()->getUrls(fileNames));
     KrCalcSpaceDialog::showDialog(panel, sizeCalculator);
 }
 
 void ListPanelFunc::quickCalcSpace()
 {
     const QString currentName = panel->getCurrentName();
     if (currentName.isEmpty()) {
         // current file is ".." dummy, do a verbose calcSpace
         calcSpace();
         return;
     }
 
     if (!_quickSizeCalculator) {
         _quickSizeCalculator = createAndConnectSizeCalculator(QList<QUrl>());
         panel->connectQuickSizeCalculator(_quickSizeCalculator);
     }
 
     _quickSizeCalculator->add(files()->getUrl(currentName));
 }
 
 
 SizeCalculator *ListPanelFunc::createAndConnectSizeCalculator(const QList<QUrl> &urls)
 {
-    SizeCalculator *sizeCalculator = new SizeCalculator(urls);
+    auto *sizeCalculator = new SizeCalculator(urls);
     connect(sizeCalculator, &SizeCalculator::calculated, this, &ListPanelFunc::slotSizeCalculated);
     connect(sizeCalculator, &SizeCalculator::finished, panel, &ListPanel::slotUpdateTotals);
     connect(this, &ListPanelFunc::destroyed, sizeCalculator, &SizeCalculator::deleteLater);
     return sizeCalculator;
 }
 
 void ListPanelFunc::slotSizeCalculated(const QUrl &url, KIO::filesize_t size)
 {
     KrViewItem *item = panel->view->findItemByUrl(url);
     if (!item)
         return;
 
     item->setSize(size);
     item->redraw();
 }
 
 void ListPanelFunc::FTPDisconnect()
 {
     // you can disconnect only if connected!
     if (files()->isRemote()) {
         panel->_actions->actFTPDisconnect->setEnabled(false);
         panel->view->setNameToMakeCurrent(QString());
         openUrl(QUrl::fromLocalFile(panel->lastLocalPath()));
     }
 }
 
 void ListPanelFunc::newFTPconnection()
 {
     QUrl url = KRSpWidgets::newFTP();
     // if the user canceled - quit
     if (url.isEmpty())
         return;
 
     panel->_actions->actFTPDisconnect->setEnabled(true);
 
     qDebug() << "URL=" << url.toDisplayString();
 
     openUrl(url);
 }
 
 void ListPanelFunc::properties()
 {
     const QStringList names = panel->getSelectedNames();
     if (names.isEmpty()) {
         return ;  // no names...
     }
 
     KFileItemList fileItems;
 
-    for (const QString name : names) {
+    for (const QString& name : names) {
         FileItem *fileitem = files()->getFileItem(name);
         if (!fileitem) {
             continue;
         }
 
         fileItems.push_back(KFileItem(fileitem->getEntry(), files()->getUrl(name)));
     }
 
     if (fileItems.isEmpty())
         return;
 
     // Show the properties dialog
-    KPropertiesDialog *dialog = new KPropertiesDialog(fileItems, krMainWindow);
+    auto *dialog = new KPropertiesDialog(fileItems, krMainWindow);
     connect(dialog, &KPropertiesDialog::applied, this, &ListPanelFunc::refresh);
     dialog->show();
 }
 
 void ListPanelFunc::refreshActions()
 {
     panel->updateButtons();
 
     if(ACTIVE_PANEL != panel)
         return;
 
     QString protocol = files()->currentDirectory().scheme();
     krRemoteEncoding->setEnabled(protocol == "ftp" || protocol == "sftp" || protocol == "fish" || protocol == "krarc");
     //krMultiRename->setEnabled( fileSystemType == FileSystem::FS_NORMAL );  // batch rename
     //krProperties ->setEnabled( fileSystemType == FileSystem::FS_NORMAL || fileSystemType == FileSystem::FS_FTP ); // file properties
 
     /*
       krUnpack->setEnabled(true);                            // unpack archive
       krTest->setEnabled(true);                              // test archive
       krSelect->setEnabled(true);                            // select a group by filter
       krSelectAll->setEnabled(true);                         // select all files
       krUnselect->setEnabled(true);                          // unselect by filter
       krUnselectAll->setEnabled( true);                      // remove all selections
       krInvert->setEnabled(true);                            // invert the selection
       krFTPConnect->setEnabled(true);                        // connect to an ftp
       krFTPNew->setEnabled(true);                            // create a new connection
       krAllFiles->setEnabled(true);                          // show all files in list
       krCustomFiles->setEnabled(true);                       // show a custom set of files
       krRoot->setEnabled(true);                              // go all the way up
           krExecFiles->setEnabled(true);                         // show only executables
     */
 
     panel->_actions->setViewActions[panel->panelType]->setChecked(true);
     panel->_actions->actFTPDisconnect->setEnabled(files()->isRemote()); // allow disconnecting a network session
     panel->_actions->actCreateChecksum->setEnabled(files()->isLocal());
     panel->_actions->actDirUp->setEnabled(!files()->isRoot());
     panel->_actions->actRoot->setEnabled(!panel->virtualPath().matches(QUrl::fromLocalFile(ROOT_DIR),
                                                                        QUrl::StripTrailingSlash));
     panel->_actions->actHome->setEnabled(!atHome());
     panel->_actions->actHistoryBackward->setEnabled(history->canGoBack());
     panel->_actions->actHistoryForward->setEnabled(history->canGoForward());
     panel->view->op()->emitRefreshActions();
 }
 
 FileSystem* ListPanelFunc::files()
 {
     if (!fileSystemP)
         fileSystemP = FileSystemProvider::instance().getFilesystem(QUrl::fromLocalFile(ROOT_DIR));
     return fileSystemP;
 }
 
 QUrl ListPanelFunc::virtualDirectory()
 {
     return _isPaused ? history->currentUrl() : files()->currentDirectory();
 }
 
 FileItem *ListPanelFunc::getFileItem(const QString &name)
 {
     return files()->getFileItem(name);
 }
 
 FileItem *ListPanelFunc::getFileItem(KrViewItem *item)
 {
     return files()->getFileItem(item->name());
 }
 
 void ListPanelFunc::clipboardChanged(QClipboard::Mode mode)
 {
     if (mode == QClipboard::Clipboard && this == copyToClipboardOrigin) {
-        disconnect(QApplication::clipboard(), 0, this, 0);
-        copyToClipboardOrigin = 0;
+        disconnect(QApplication::clipboard(), nullptr, this, nullptr);
+        copyToClipboardOrigin = nullptr;
     }
 }
 
 void ListPanelFunc::copyToClipboard(bool move)
 {
     const QStringList fileNames = panel->getSelectedNames();
     if (fileNames.isEmpty())
         return ;  // safety
 
     QList<QUrl> fileUrls = files()->getUrls(fileNames);
-    QMimeData *mimeData = new QMimeData;
+    auto *mimeData = new QMimeData;
     mimeData->setData("application/x-kde-cutselection", move ? "1" : "0");
     mimeData->setUrls(fileUrls);
 
     if (copyToClipboardOrigin)
-        disconnect(QApplication::clipboard(), 0, copyToClipboardOrigin, 0);
+        disconnect(QApplication::clipboard(), nullptr, copyToClipboardOrigin, nullptr);
     copyToClipboardOrigin = this;
 
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
 
     connect(QApplication::clipboard(), &QClipboard::changed, this, &ListPanelFunc::clipboardChanged);
 }
 
 void ListPanelFunc::pasteFromClipboard()
 {
     QClipboard * cb = QApplication::clipboard();
 
-    ListPanelFunc *origin = 0;
+    ListPanelFunc *origin = nullptr;
 
     if (copyToClipboardOrigin) {
-        disconnect(QApplication::clipboard(), 0, copyToClipboardOrigin, 0);
+        disconnect(QApplication::clipboard(), nullptr, copyToClipboardOrigin, nullptr);
         origin = copyToClipboardOrigin;
-        copyToClipboardOrigin = 0;
+        copyToClipboardOrigin = nullptr;
     }
 
     bool move = false;
     const QMimeData *data = cb->mimeData();
     if (data->hasFormat("application/x-kde-cutselection")) {
         QByteArray a = data->data("application/x-kde-cutselection");
         if (!a.isEmpty())
             move = (a.at(0) == '1'); // true if 1
     }
 
     QList<QUrl> urls = data->urls();
     if (urls.isEmpty())
         return;
 
     if(origin && KConfigGroup(krConfig, "Look&Feel").readEntry("UnselectBeforeOperation", _UnselectBeforeOperation)) {
         origin->panel->view->saveSelection();
-        for(KrViewItem *item = origin->panel->view->getFirst(); item != 0; item = origin->panel->view->getNext(item)) {
+        for(KrViewItem *item = origin->panel->view->getFirst(); item != nullptr; item = origin->panel->view->getNext(item)) {
             if (urls.contains(item->getFileItem()->getUrl()))
                 item->setSelected(false);
         }
     }
 
     files()->addFiles(urls, move ? KIO::CopyJob::Move : KIO::CopyJob::Copy);
 }
 
 ListPanelFunc* ListPanelFunc::otherFunc()
 {
     return panel->otherPanel()->func;
 }
 
 void ListPanelFunc::historyGotoPos(int pos)
 {
     if(history->gotoPos(pos))
         refresh();
 }
 
 void ListPanelFunc::historyBackward()
 {
     if(history->goBack())
         refresh();
 }
 
 void ListPanelFunc::historyForward()
 {
     if(history->goForward())
         refresh();
 }
 
 void ListPanelFunc::dirUp()
 {
     openUrl(KIO::upUrl(files()->currentDirectory()), files()->currentDirectory().fileName());
 }
 
 void ListPanelFunc::home()
 {
     openUrl(QUrl::fromLocalFile(QDir::homePath()));
 }
 
 void ListPanelFunc::root()
 {
     openUrl(QUrl::fromLocalFile(ROOT_DIR));
 }
 
 void ListPanelFunc::cdToOtherPanel()
 {
     openUrl(panel->otherPanel()->virtualPath());
 }
 
 void ListPanelFunc::syncOtherPanel()
 {
     otherFunc()->openUrl(panel->virtualPath());
 }
 
 bool ListPanelFunc::atHome()
 {
     return QUrl::fromLocalFile(QDir::homePath()).matches(panel->virtualPath(), QUrl::StripTrailingSlash);
 }
diff --git a/krusader/Panel/panelfunc.h b/krusader/Panel/panelfunc.h
index c9e075b7..d346fa61 100644
--- a/krusader/Panel/panelfunc.h
+++ b/krusader/Panel/panelfunc.h
@@ -1,168 +1,168 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 #ifndef PANELFUNC_H
 #define PANELFUNC_H
 
 // QtCore
 #include <QObject>
 #include <QTimer>
 #include <QUrl>
 // QtGui
 #include <QClipboard>
 
 #include <KCoreAddons/KJob>
 #include <KIO/Global>
 #include <KService/KService>
 
 class DirHistoryQueue;
 class FileItem;
 class FileSystem;
 class KrViewItem;
 class ListPanel;
 class SizeCalculator;
 
 class ListPanelFunc : public QObject
 {
     friend class ListPanel;
     Q_OBJECT
 public slots:
     void execute(const QString&);
     void goInside(const QString&);
     void openUrl(const QUrl &path, const QString& nameToMakeCurrent = QString(),
                  bool manuallyEntered = false);
     void rename(const QString &oldname, const QString &newname);
 
     // actions
     void historyBackward();
     void historyForward();
     void dirUp();
     void refresh();
     void home();
     void root();
     void cdToOtherPanel();
     void FTPDisconnect();
     void newFTPconnection();
     void terminal();
     void view();
     void viewDlg();
     void edit();
     void editNew(); // create a new textfile and edit it
     void moveFilesDelayed() { moveFiles(true); }
     void copyFilesDelayed() { copyFiles(true); }
     void moveFiles(bool enqueue = false) { copyFiles(enqueue, true); }
     void copyFiles(bool enqueue = false, bool move = false);
 
     /*!
      * asks the user the new directory name
      */
     void mkdir();
     /** Delete or move selected files to trash - depending on user setting. */
     void defaultDeleteFiles() { defaultOrAlternativeDeleteFiles(false); }
     /** Delete or move selected files to trash - inverting the user setting. */
     void alternativeDeleteFiles() { defaultOrAlternativeDeleteFiles(true); }
     /** Delete virtual files or directories in virtual filesystem. */
     void removeVirtualFiles();
     void rename();
     void krlink(bool sym = true);
     void createChecksum();
     void matchChecksum();
     void pack();
     void unpack();
     void testArchive();
     /** Calculate the occupied space of the currently selected items and show a dialog. */
     void calcSpace();
     /** Calculate the occupied space of the current item without dialog. */
     void quickCalcSpace();
     void properties();
     void cut() {
         copyToClipboard(true);
     }
     void copyToClipboard(bool move = false);
     void pasteFromClipboard();
     void syncOtherPanel();
     /** Disable refresh if panel is not visible. */
     void setPaused(bool paused);
 
 public:
     explicit ListPanelFunc(ListPanel *parent);
-    ~ListPanelFunc();
+    ~ListPanelFunc() override;
 
     FileSystem* files();  // return a pointer to the filesystem
     QUrl virtualDirectory(); // return the current URL (simulated when panel is paused)
 
     FileItem* getFileItem(KrViewItem *item);
     FileItem* getFileItem(const QString& name);
 
     void refreshActions();
     void redirectLink();
-    void runService(const KService &service, QList<QUrl> urls);
-    void displayOpenWithDialog(QList<QUrl> urls);
+    void runService(const KService &service, const QList<QUrl>& urls);
+    void displayOpenWithDialog(const QList<QUrl>& urls);
     QUrl browsableArchivePath(const QString &);
     void deleteFiles(bool moveToTrash);
 
     ListPanelFunc* otherFunc();
     bool atHome();
 
     /** Ask user for confirmation before deleting files. Returns only confirmed files.*/
     static QList<QUrl> confirmDeletion(const QList<QUrl> &urls, bool moveToTrash,
                                        bool virtualFS, bool showPath);
 
 protected slots:
     // Load the current url from history and refresh filesystem and panel to it
     void doRefresh();
     void slotFileCreated(KJob *job); // a file has been created by editNewFile()
     void historyGotoPos(int pos);
     void clipboardChanged(QClipboard::Mode mode);
     // Update the directory size in view
     void slotSizeCalculated(const QUrl &url, KIO::filesize_t size);
 
 protected:
     QUrl cleanPath(const QUrl &url);
     bool isSyncing(const QUrl &url);
     // when externallyExecutable == true, the file can be executed or opened with other software
     void openFileNameInternal(const QString &name, bool externallyExecutable);
     void immediateOpenUrl(const QUrl &url);
     void openUrlInternal(const QUrl &url, const QString& makeCurrent,
                          bool immediately, bool manuallyEntered);
-    void runCommand(QString cmd);
+    void runCommand(const QString& cmd);
 
     ListPanel*               panel;     // our ListPanel
     DirHistoryQueue*         history;
     FileSystem*              fileSystemP;      // pointer to fileSystem.
     QTimer                   delayTimer;
     QUrl                     syncURL;
     QUrl                     fileToCreate; // file that's to be created by editNewFile()
     bool                     urlManuallyEntered;
 
     static QPointer<ListPanelFunc> copyToClipboardOrigin;
 
 private:
     void defaultOrAlternativeDeleteFiles(bool invert);
     bool getSelectedFiles(QStringList& args);
     SizeCalculator *createAndConnectSizeCalculator(const QList<QUrl> &urls);
     bool _isPaused; // do not refresh while panel is not visible
     bool _refreshAfterPaused; // refresh after not paused anymore
     QPointer<SizeCalculator> _quickSizeCalculator;
 };
 
 #endif
diff --git a/krusader/Panel/sidebar.cpp b/krusader/Panel/sidebar.cpp
index 90d5d7d5..cf24251a 100644
--- a/krusader/Panel/sidebar.cpp
+++ b/krusader/Panel/sidebar.cpp
@@ -1,289 +1,289 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2003 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "sidebar.h"
 
 #include "krfiletreeview.h"
 #include "krpanel.h"
 #include "panelfunc.h"
 #include "viewactions.h"
 #include "../defaults.h"
 #include "../icon.h"
 #include "../Dialogs/krsqueezedtextlabel.h"
 #include "../FileSystem/fileitem.h"
 #include "../FileSystem/filesystem.h"
 #include "../KViewer/diskusageviewer.h"
 #include "../KViewer/panelviewer.h"
 #include "PanelView/krview.h"
 #include "PanelView/krviewitem.h"
 
 // QtCore
 #include <QMimeDatabase>
 #include <QMimeType>
 // QtWidgets
 #include <QAbstractItemView>
 #include <QGridLayout>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 
-Sidebar::Sidebar(QWidget *parent) : QWidget(parent), stack(0), imageFilePreview(0), pjob(0)
+Sidebar::Sidebar(QWidget *parent) : QWidget(parent), stack(nullptr), imageFilePreview(nullptr), pjob(nullptr)
 {
-    QGridLayout * layout = new QGridLayout(this);
+    auto * layout = new QGridLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
 
     // create the label+buttons setup
     dataLine = new KrSqueezedTextLabel(this);
     KConfigGroup lg(krConfig, "Look&Feel");
     dataLine->setFont(lg.readEntry("Filelist Font", _FilelistFont));
     // --- hack: setup colors to be the same as an inactive panel
     dataLine->setBackgroundRole(QPalette::Window);
     int sheight = QFontMetrics(dataLine->font()).height() + 4;
     dataLine->setMaximumHeight(sheight);
 
     btns = new QButtonGroup(this);
     btns->setExclusive(true);
     connect(btns, QOverload<int>::of(&QButtonGroup::buttonClicked), this, &Sidebar::tabSelected);
 
     treeBtn = new QToolButton(this);
     treeBtn->setToolTip(i18n("Tree Panel: a tree view of the local file system"));
     treeBtn->setIcon(Icon("view-list-tree"));
     treeBtn->setFixedSize(20, 20);
     treeBtn->setCheckable(true);
     btns->addButton(treeBtn, Tree);
 
     previewBtn = new QToolButton(this);
     previewBtn->setToolTip(i18n("Preview Panel: display a preview of the current file"));
     previewBtn->setIcon(Icon("view-preview"));
     previewBtn->setFixedSize(20, 20);
     previewBtn->setCheckable(true);
     btns->addButton(previewBtn, Preview);
 
     viewerBtn = new QToolButton(this);
     viewerBtn->setToolTip(i18n("View Panel: view the current file"));
     viewerBtn->setIcon(Icon("zoom-original"));
     viewerBtn->setFixedSize(20, 20);
     viewerBtn->setCheckable(true);
     btns->addButton(viewerBtn, View);
 
     duBtn = new QToolButton(this);
     duBtn->setToolTip(i18n("Disk Usage Panel: view the usage of a folder"));
     duBtn->setIcon(Icon("kr_diskusage"));
     duBtn->setFixedSize(20, 20);
     duBtn->setCheckable(true);
     btns->addButton(duBtn, DskUsage);
 
     layout->addWidget(dataLine, 0, 0);
     layout->addWidget(treeBtn, 0, 1);
     layout->addWidget(previewBtn, 0, 2);
     layout->addWidget(viewerBtn, 0, 3);
     layout->addWidget(duBtn, 0, 4);
 
     // create a widget stack on which to put the parts
     stack = new QStackedWidget(this);
 
     // create the tree part ----------
     tree = new KrFileTreeView(stack);
     tree->setProperty("KrusaderWidgetId", QVariant(Tree));
     stack->addWidget(tree);
     // NOTE: the F2 key press event is caught before it gets to the tree
     tree->setEditTriggers(QAbstractItemView::EditKeyPressed);
     // connecting signal to signal
     connect(tree, &KrFileTreeView::urlActivated, this, &Sidebar::urlActivated);
 
     // create the quickview part ------
     imageFilePreview = new KImageFilePreview(stack);
     imageFilePreview->setProperty("KrusaderWidgetId", QVariant(Preview));
     stack->addWidget(imageFilePreview);
 
     // create the panelview
     fileViewer = new PanelViewer(stack);
     fileViewer->setProperty("KrusaderWidgetId", QVariant(View));
     // kparts demand too much width
     QSizePolicy sizePolicy = fileViewer->sizePolicy();
     sizePolicy.setHorizontalPolicy(QSizePolicy::Ignored);
     fileViewer->setSizePolicy(sizePolicy);
     stack->addWidget(fileViewer);
     connect(fileViewer, &PanelViewer::openUrlRequest, this, &Sidebar::handleOpenUrlRequest);
 
     // create the disk usage view
     diskusage = new DiskUsageViewer(stack);
     diskusage->setStatusLabel(dataLine, i18n("Disk Usage:"));
     diskusage->setProperty("KrusaderWidgetId", QVariant(DskUsage));
     stack->addWidget(diskusage);
     connect(diskusage, &DiskUsageViewer::openUrlRequest, this, &Sidebar::handleOpenUrlRequest);
 
     // -------- finish the layout (General one)
     layout->addWidget(stack, 1, 0, 1, 5);
 
     hide(); // for not to open the 3rd hand tool at start (selecting the last used tab)
     setCurrentPage(0);
 }
 
-Sidebar::~Sidebar() {}
+Sidebar::~Sidebar() = default;
 
-void Sidebar::saveSettings(KConfigGroup cfg) const
+void Sidebar::saveSettings(const KConfigGroup& cfg) const
 {
     tree->saveSettings(cfg);
 }
 
 void Sidebar::restoreSettings(const KConfigGroup &cfg)
 {
     tree->restoreSettings(cfg);
 }
 
 void Sidebar::setCurrentPage(int id)
 {
     QAbstractButton * curr = btns->button(id);
     if (curr) {
         curr->click();
     }
 }
 
 void Sidebar::show()
 {
     QWidget::show();
     tabSelected(currentPage());
 }
 
 void Sidebar::hide()
 {
     QWidget::hide();
     if (currentPage() == View) fileViewer->closeUrl();
     if (currentPage() == DskUsage) diskusage->closeUrl();
 }
 
 void Sidebar::focusInEvent(QFocusEvent*)
 {
     switch (currentPage()) {
     case Preview:
         if (!isHidden())
             imageFilePreview->setFocus();
         break;
     case View:
         if (!isHidden() && fileViewer->part() && fileViewer->part()->widget())
             fileViewer->part()->widget()->setFocus();
         break;
     case DskUsage:
         if (!isHidden() && diskusage->getWidget() && diskusage->getWidget()->currentWidget())
             diskusage->getWidget()->currentWidget()->setFocus();
         break;
     case Tree:
         if (!isHidden())
             tree->setFocus();
         break;
     }
 }
 
 void Sidebar::handleOpenUrlRequest(const QUrl &url)
 {
     QMimeDatabase db;
     QMimeType mime = db.mimeTypeForUrl(url);
     if (mime.isValid() && mime.name() == "inode/directory") ACTIVE_PANEL->func->openUrl(url);
 }
 
 void Sidebar::tabSelected(int id)
 {
     QUrl url;
-    const FileItem *fileitem = 0;
+    const FileItem *fileitem = nullptr;
     if (ACTIVE_PANEL && ACTIVE_PANEL->view)
         fileitem = ACTIVE_PANEL->func->files()->getFileItem(ACTIVE_PANEL->view->getCurrentItem());
     if(fileitem)
         url = fileitem->getUrl();
 
     // if tab is tree, set something logical in the data line
     switch (id) {
     case Tree:
         stack->setCurrentWidget(tree);
         dataLine->setText(i18n("Tree:"));
         if (!isHidden())
             tree->setFocus();
         if (ACTIVE_PANEL)
             tree->setCurrentUrl(ACTIVE_PANEL->virtualPath());
         break;
     case Preview:
         stack->setCurrentWidget(imageFilePreview);
         dataLine->setText(i18n("Preview:"));
         update(fileitem);
         break;
     case View:
         stack->setCurrentWidget(fileViewer);
         dataLine->setText(i18n("View:"));
         update(fileitem);
         if (!isHidden() && fileViewer->part() && fileViewer->part()->widget())
             fileViewer->part()->widget()->setFocus();
         break;
     case DskUsage:
         stack->setCurrentWidget(diskusage);
         dataLine->setText(i18n("Disk Usage:"));
         update(fileitem);
         if (!isHidden() && diskusage->getWidget() && diskusage->getWidget()->currentWidget())
             diskusage->getWidget()->currentWidget()->setFocus();
         break;
     }
     if (id != View) fileViewer->closeUrl();
 }
 
 // decide which part to update, if at all
 void Sidebar::update(const FileItem *fileitem)
 {
     if (isHidden())
         return;
 
     QUrl url;
     if(fileitem)
        url = fileitem->getUrl();
 
     switch (currentPage()) {
     case Preview:
         imageFilePreview->showPreview(url);
         dataLine->setText(i18n("Preview: %1", url.fileName()));
         break;
     case View:
         if(fileitem && !fileitem->isDir() && fileitem->isReadable())
             fileViewer->openUrl(fileitem->getUrl());
         else
             fileViewer->closeUrl();
         dataLine->setText(i18n("View: %1", url.fileName()));
         break;
     case DskUsage: {
         if(fileitem && !fileitem->isDir())
             url = KIO::upUrl(url);
         dataLine->setText(i18n("Disk Usage: %1", url.fileName()));
         diskusage->openUrl(url);
     }
     break;
     case Tree:  // nothing to do
         break;
     }
 }
 
 void Sidebar::onPanelPathChange(const QUrl &url)
 {
     switch (currentPage()) {
     case Tree:
         if (url.isLocalFile()) {
             tree->setCurrentUrl(url); // synchronize panel path with tree path
         }
         break;
     }
 }
diff --git a/krusader/Panel/sidebar.h b/krusader/Panel/sidebar.h
index 354621c8..f94e2556 100644
--- a/krusader/Panel/sidebar.h
+++ b/krusader/Panel/sidebar.h
@@ -1,102 +1,102 @@
 /*****************************************************************************
  * Copyright (C) 2003 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2003 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SIDEBAR_H
 #define SIDEBAR_H
 
 // QtCore
 #include <QPointer>
 // QtWidgets
 #include <QButtonGroup>
 #include <QStackedWidget>
 #include <QToolButton>
 #include <QWidget>
 
 #include <KConfigCore/KConfigGroup>
 #include <KIO/PreviewJob>
 #include <KIOFileWidgets/KImageFilePreview>
 
 class KrSqueezedTextLabel;
 class PanelViewer;
 class DiskUsageViewer;
 class KrFileTreeView;
 class FileItem;
 
 /**
  * Additional side widget showing various meta information for the current file/directories.
  */
 class Sidebar: public QWidget
 {
     Q_OBJECT
 
     enum Parts {
         /** Folder tree view */
         Tree,
         /** Preview image for current file/directory */
         Preview,
         /** File view: show file in most appropriate, read-only editor */
         View,
         /** Disk usage for current directory structure */
         DskUsage,
         /** Dummy */
         Last = 0xFF
     };
 
 public:
     explicit Sidebar(QWidget *parent);
-    ~Sidebar();
+    ~Sidebar() override;
     inline int currentPage() const {
         return stack->currentWidget()->property("KrusaderWidgetId").toInt();
     }
-    void saveSettings(KConfigGroup cfg) const;
+    void saveSettings(const KConfigGroup& cfg) const;
     void restoreSettings(const KConfigGroup &cfg);
     void setCurrentPage(int);
 
 public slots:
     void update(const FileItem *fileitem);
     void onPanelPathChange(const QUrl &url);
     void show();
     void hide();
 
 signals:
     void urlActivated(const QUrl &url);
     void hideMe();
 
 protected slots:
     void tabSelected(int id);
     void handleOpenUrlRequest(const QUrl &url);
 
 protected:
-    virtual void focusInEvent(QFocusEvent*) Q_DECL_OVERRIDE;
+    void focusInEvent(QFocusEvent*) Q_DECL_OVERRIDE;
 
     bool _hidden;
     QStackedWidget *stack;
     KImageFilePreview *imageFilePreview;
     KrSqueezedTextLabel *dataLine;
     QPointer<KIO::PreviewJob> pjob;
     KrFileTreeView *tree;
     QToolButton *treeBtn, *previewBtn, *viewerBtn, *duBtn;
     QButtonGroup *btns;
     PanelViewer *fileViewer;
     DiskUsageViewer *diskusage;
 };
 
 #endif
diff --git a/krusader/Panel/viewactions.cpp b/krusader/Panel/viewactions.cpp
index 582f76ad..e07a9ad5 100644
--- a/krusader/Panel/viewactions.cpp
+++ b/krusader/Panel/viewactions.cpp
@@ -1,183 +1,183 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <krusader@users.sourceforge.net>            *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "viewactions.h"
 
 #include "PanelView/krview.h"
 #include "../krmainwindow.h"
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KToggleAction>
 
 ViewActions::ViewActions(QObject *parent, KrMainWindow *mainWindow) :
     ActionsBase(parent, mainWindow)
 {
     // zoom
     actZoomIn = action(i18n("Zoom In"), "zoom-in", 0, SLOT(zoomIn()), "zoom_in");
     actZoomOut = action(i18n("Zoom Out"), "zoom-out", 0, SLOT(zoomOut()), "zoom_out");
     actDefaultZoom = action(i18n("Default Zoom"), "zoom-original", 0, SLOT(defaultZoom()), "default_zoom");
 
     // filter
-    action(i18n("&All Files"), 0, Qt::SHIFT + Qt::Key_F10, SLOT(allFilter()), "all files");
+    action(i18n("&All Files"), nullptr, Qt::SHIFT + Qt::Key_F10, SLOT(allFilter()), "all files");
     //actExecFilter = new QAction( i18n( "&Executables" ), SHIFT + Qt::Key_F11,
     //                             SLOTS, SLOT(execFilter()), actionCollection(), "exec files" );
-    action(i18n("&Custom"), 0, Qt::SHIFT + Qt::Key_F12, SLOT(customFilter()), "custom files");
+    action(i18n("&Custom"), nullptr, Qt::SHIFT + Qt::Key_F12, SLOT(customFilter()), "custom files");
 
     // selection
     actSelect = action(i18n("Select &Group..."), "edit-select", Qt::CTRL + Qt::Key_Plus, SLOT(markGroup()), "select group");
     actSelectAll = action(i18n("&Select All"), "edit-select-all", Qt::ALT + Qt::Key_Plus, SLOT(markAll()), "select all");
     actUnselect = action(i18n("&Unselect Group..."), "kr_unselect", Qt::CTRL + Qt::Key_Minus, SLOT(unmarkGroup()), "unselect group");
     actUnselectAll = action(i18n("U&nselect All"), "edit-select-none", Qt::ALT + Qt::Key_Minus, SLOT(unmarkAll()), "unselect all");
     actInvert = action(i18n("&Invert Selection"), "edit-select-invert", Qt::ALT + Qt::Key_Asterisk, SLOT(invertSelection()), "invert");
-    actRestoreSelection = action(i18n("Restore Selection"), 0, 0, SLOT(restoreSelection()), "restore_selection");
-    actMarkSameBaseName = action(i18n("Select Files with the Same Name"), 0, 0, SLOT(markSameBaseName()), "select_same_base_name");
-    actMarkSameExtension = action(i18n("Select Files with the Same Extension"), 0, 0, SLOT(markSameExtension()), "select_same_extension");
+    actRestoreSelection = action(i18n("Restore Selection"), nullptr, 0, SLOT(restoreSelection()), "restore_selection");
+    actMarkSameBaseName = action(i18n("Select Files with the Same Name"), nullptr, 0, SLOT(markSameBaseName()), "select_same_base_name");
+    actMarkSameExtension = action(i18n("Select Files with the Same Extension"), nullptr, 0, SLOT(markSameExtension()), "select_same_extension");
 
     // other stuff
-    action(i18n("Show View Options Menu"), 0, 0, SLOT(showOptionsMenu()), "show_view_options_menu");
-    action(i18n("Set Focus to the Panel"), 0, 0, SLOT(focusPanel()), "focus_panel");
-    action(i18n("Apply settings to other tabs"), 0, 0, SLOT(applySettingsToOthers()), "view_apply_settings_to_others");
-    actTogglePreviews = toggleAction(i18n("Show Previews"), 0, 0, SLOT(togglePreviews(bool)), "toggle previews");
-    QAction *actSaveaveDefaultSettings = action(i18n("Save settings as default"), 0, 0, SLOT(saveDefaultSettings()), "view_save_default_settings");
+    action(i18n("Show View Options Menu"), nullptr, 0, SLOT(showOptionsMenu()), "show_view_options_menu");
+    action(i18n("Set Focus to the Panel"), nullptr, 0, SLOT(focusPanel()), "focus_panel");
+    action(i18n("Apply settings to other tabs"), nullptr, 0, SLOT(applySettingsToOthers()), "view_apply_settings_to_others");
+    actTogglePreviews = toggleAction(i18n("Show Previews"), nullptr, 0, SLOT(togglePreviews(bool)), "toggle previews");
+    QAction *actSaveaveDefaultSettings = action(i18n("Save settings as default"), nullptr, 0, SLOT(saveDefaultSettings()), "view_save_default_settings");
 
     // tooltips
     actSelect->setToolTip(i18n("Select group"));
     actSelectAll->setToolTip(i18n("Select all files in the current folder"));
     actUnselectAll->setToolTip(i18n("Unselect all"));
     actSaveaveDefaultSettings->setToolTip(i18n("Save settings as default for new instances of this view type"));
 }
 
 inline KrView *ViewActions::view()
 {
     return _mainWindow->activeView();
 }
 
 // zoom
 
 void ViewActions::zoomIn()
 {
     view()->zoomIn();
 }
 
 void ViewActions::zoomOut()
 {
     view()->zoomOut();
 }
 
 void ViewActions::defaultZoom()
 {
     view()->setDefaultFileIconSize();
 }
 
 // filter
 
 void ViewActions::allFilter()
 {
     view()->setFilter(KrViewProperties::All);
 }
 #if 0
 void ViewActions::execFilter()
 {
     view()->setFilter(KrViewProperties::All);
 }
 #endif
 void ViewActions::customFilter()
 {
     view()->setFilter(KrViewProperties::Custom);
 }
 
 void ViewActions::showOptionsMenu()
 {
     view()->showContextMenu();
 }
 
 // selection
 
 void ViewActions::markAll()
 {
     view()->changeSelection(KRQuery("*"), true);
 }
 
 void ViewActions::unmarkAll()
 {
     view()->unselectAll();
 }
 
 void ViewActions::markGroup()
 {
     view()->customSelection(true);
 }
 
 void ViewActions::unmarkGroup()
 {
     view()->customSelection(false);
 }
 
 void ViewActions::invertSelection()
 {
     view()->invertSelection();
 }
 
 void ViewActions::restoreSelection()
 {
     view()->restoreSelection();
 }
 
 void ViewActions::markSameBaseName()
 {
     view()->markSameBaseName();
 }
 
 void ViewActions::markSameExtension()
 {
     view()->markSameExtension();
 }
 
 // other stuff
 
 void ViewActions::saveDefaultSettings()
 {
     view()->saveDefaultSettings();
 }
 
 void ViewActions::applySettingsToOthers()
 {
     view()->applySettingsToOthers();
 }
 
 void ViewActions::focusPanel()
 {
     view()->widget()->setFocus();
 }
 
 void ViewActions::togglePreviews(bool show)
 {
     view()->showPreviews(show);
 }
 
 void ViewActions::refreshActions()
 {
     actDefaultZoom->setEnabled(view()->defaultFileIconSize() != view()->fileIconSize());
     int idx = KrView::iconSizes.indexOf(view()->fileIconSize());
     actZoomOut->setEnabled(idx > 0);
     actZoomIn->setEnabled(idx < (KrView::iconSizes.count() - 1));
     actRestoreSelection->setEnabled(view()->canRestoreSelection());
     actTogglePreviews->setChecked(view()->previewsShown());
 }
diff --git a/krusader/Search/krsearchdialog.cpp b/krusader/Search/krsearchdialog.cpp
index 6079f681..77390f36 100644
--- a/krusader/Search/krsearchdialog.cpp
+++ b/krusader/Search/krsearchdialog.cpp
@@ -1,661 +1,661 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krsearchdialog.h"
 
 // QtCore
 #include <QRegExp>
 #include <QMimeData>
 // QtGui
 #include <QKeyEvent>
 #include <QResizeEvent>
 #include <QCursor>
 #include <QClipboard>
 #include <QDrag>
 #include <QCloseEvent>
 // QtWidgets
 #include <QApplication>
 #include <QGridLayout>
 #include <QInputDialog>
 #include <QHBoxLayout>
 #include <QMenu>
 
 #include <KConfigCore/KConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "krsearchmod.h"
 #include "../Dialogs/krdialogs.h"
 #include "../Dialogs/krspecialwidgets.h"
 #include "../Dialogs/krsqueezedtextlabel.h"
 #include "../FileSystem/fileitem.h"
 #include "../FileSystem/krquery.h"
 #include "../FileSystem/virtualfilesystem.h"
 #include "../Filter/filtertabs.h"
 #include "../Filter/generalfilter.h"
 #include "../KViewer/krviewer.h"
 #include "../Panel/PanelView/krview.h"
 #include "../Panel/PanelView/krviewfactory.h"
 #include "../Panel/PanelView/krviewitem.h"
 #include "../Panel/krpanel.h"
 #include "../Panel/krsearchbar.h"
 #include "../Panel/panelfunc.h"
 #include "../defaults.h"
 #include "../kractions.h"
 #include "../krglobal.h"
 #include "../filelisticon.h"
 #include "../krservices.h"
 #include "../krslots.h"
 #include "../krusaderview.h"
 #include "../panelmanager.h"
 
 #define RESULTVIEW_TYPE 0
 
 class SearchResultContainer : public DirListerInterface
 {
 public:
     explicit SearchResultContainer(QObject *parent) : DirListerInterface(parent) {}
-    virtual ~SearchResultContainer() {
+    ~SearchResultContainer() override {
         clear();
     }
 
-    virtual QList<FileItem *> fileItems() const Q_DECL_OVERRIDE {
+    QList<FileItem *> fileItems() const Q_DECL_OVERRIDE {
         return _fileItems;
     }
-    virtual unsigned long numFileItems() const Q_DECL_OVERRIDE {
+    unsigned long numFileItems() const Q_DECL_OVERRIDE {
         return _fileItems.count();
     }
-    virtual bool isRoot() const Q_DECL_OVERRIDE {
+    bool isRoot() const Q_DECL_OVERRIDE {
         return true;
     }
 
     void clear() {
         emit cleared();
         foreach(FileItem *fileitem, _fileItems)
             delete fileitem;
         _fileItems.clear();
         _foundText.clear();
     }
 
     void addItem(const FileItem &file, const QString &foundText)
     {
         const QString path = file.getUrl().toDisplayString(QUrl::PreferLocalFile);
         FileItem *fileitem = FileItem::createCopy(file, path);
         _fileItems << fileitem;
         if(!foundText.isEmpty())
             _foundText[fileitem] = foundText;
         emit addedFileItem(fileitem);
     }
 
     QString foundText(const FileItem *fileitem) {
         return _foundText[fileitem];
     }
 
 private:
     QList<FileItem *> _fileItems;
     QHash<const FileItem *, QString> _foundText;
 };
 
 
-KrSearchDialog *KrSearchDialog::SearchDialog = 0;
+KrSearchDialog *KrSearchDialog::SearchDialog = nullptr;
 
 QString KrSearchDialog::lastSearchText = QString('*');
 int KrSearchDialog::lastSearchType = 0;
 bool KrSearchDialog::lastSearchForCase = false;
 bool KrSearchDialog::lastContainsWholeWord = false;
 bool KrSearchDialog::lastContainsWithCase = false;
 bool KrSearchDialog::lastSearchInSubDirs = true;
 bool KrSearchDialog::lastSearchInArchives = false;
 bool KrSearchDialog::lastFollowSymLinks = false;
 bool KrSearchDialog::lastContainsRegExp = false;
 
 
 // class starts here /////////////////////////////////////////
-KrSearchDialog::KrSearchDialog(QString profile, QWidget* parent)
-        : QDialog(parent), query(0), searcher(0), isBusy(false), closed(false)
+KrSearchDialog::KrSearchDialog(const QString& profile, QWidget* parent)
+        : QDialog(parent), query(nullptr), searcher(nullptr), isBusy(false), closed(false)
 {
     KConfigGroup group(krConfig, "Search");
 
     setWindowTitle(i18n("Krusader::Search"));
     setWindowIcon(Icon("system-search"));
 
-    QGridLayout* searchBaseLayout = new QGridLayout(this);
+    auto* searchBaseLayout = new QGridLayout(this);
     searchBaseLayout->setSpacing(6);
     searchBaseLayout->setContentsMargins(11, 11, 11, 11);
 
     // creating the dialog buttons ( Search, Stop, Close )
 
-    QHBoxLayout* buttonsLayout = new QHBoxLayout();
+    auto* buttonsLayout = new QHBoxLayout();
     buttonsLayout->setSpacing(6);
     buttonsLayout->setContentsMargins(0, 0, 0, 0);
 
     profileManager = new ProfileManager("SearcherProfile", this);
     buttonsLayout->addWidget(profileManager);
 
     searchTextToClipboard = new QCheckBox(this);
     searchTextToClipboard->setText(i18n("Query to clipboard"));
     searchTextToClipboard->setToolTip(i18n("Place search text to clipboard when a found file is opened."));
     searchTextToClipboard->setCheckState(static_cast<Qt::CheckState>(group.readEntry("QueryToClipboard", 0)));
     connect(searchTextToClipboard, &QCheckBox::stateChanged, this, [=](int state) {
         KConfigGroup group(krConfig, "Search");
         group.writeEntry("QueryToClipboard", state);
     });
     buttonsLayout->addWidget(searchTextToClipboard);
 
-    QSpacerItem* spacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+    auto* spacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     buttonsLayout->addItem(spacer);
 
     mainSearchBtn = new QPushButton(this);
     mainSearchBtn->setText(i18n("Search"));
     mainSearchBtn->setIcon(Icon("edit-find"));
     mainSearchBtn->setDefault(true);
     buttonsLayout->addWidget(mainSearchBtn);
 
     mainStopBtn = new QPushButton(this);
     mainStopBtn->setEnabled(false);
     mainStopBtn->setText(i18n("Stop"));
     mainStopBtn->setIcon(Icon("process-stop"));
     buttonsLayout->addWidget(mainStopBtn);
 
     mainCloseBtn = new QPushButton(this);
     mainCloseBtn->setText(i18n("Close"));
     mainCloseBtn->setIcon(Icon("dialog-close"));
     buttonsLayout->addWidget(mainCloseBtn);
 
     searchBaseLayout->addLayout(buttonsLayout, 1, 0);
 
     // creating the searcher tabs
 
     searcherTabs = new QTabWidget(this);
 
     filterTabs = FilterTabs::addTo(searcherTabs, FilterTabs::Default);
     generalFilter = (GeneralFilter *)filterTabs->get("GeneralFilter");
 
     QWidget* resultTab = new QWidget(searcherTabs);
-    QGridLayout* resultLayout = new QGridLayout(resultTab);
+    auto* resultLayout = new QGridLayout(resultTab);
     resultLayout->setSpacing(6);
     resultLayout->setContentsMargins(6, 6, 6, 6);
 
     // creating the result tab
 
     // creating the result list view
     result = new SearchResultContainer(this);
     // the view
     resultView = KrViewFactory::createView(RESULTVIEW_TYPE, resultTab, krConfig);
     resultView->init(false);
     resultView->restoreSettings(KConfigGroup(&group, "ResultView"));
     resultView->setMainWindow(this);
     resultView->prepareForActive();
     resultView->refreshColors();
     resultView->setFiles(result);
     resultView->refresh();
     resultLayout->addWidget(resultView->widget(), 0, 0);
     // search bar - hidden by default
     searchBar = new KrSearchBar(resultView, this);
     searchBar->hide();
     resultLayout->addWidget(searchBar, 1, 0);
 
     // text found row
     foundTextFrame = new QFrame(resultTab);
     foundTextFrame->setFrameShape(QLabel::StyledPanel);
     foundTextFrame->setFrameShadow(QLabel::Sunken);
 
-    QHBoxLayout* foundTextLayout = new QHBoxLayout();
+    auto* foundTextLayout = new QHBoxLayout();
     foundTextLayout->setSpacing(6);
 
     QLabel *textFoundLabel = new QLabel(i18n("Text found:"), resultTab);
     foundTextLayout->addWidget(textFoundLabel);
     foundTextLabel = new KrSqueezedTextLabel(resultTab);
     foundTextLayout->addWidget(foundTextLabel);
 
     foundTextFrame->setLayout(foundTextLayout);
     foundTextFrame->hide();
 
     resultLayout->addWidget(foundTextFrame, 2, 0);
 
     // result info row
-    QHBoxLayout* resultLabelLayout = new QHBoxLayout();
+    auto* resultLabelLayout = new QHBoxLayout();
     resultLabelLayout->setSpacing(6);
     resultLabelLayout->setContentsMargins(0, 0, 0, 0);
 
     searchingLabel = new KSqueezedTextLabel(i18n("Idle"), resultTab);
     resultLabelLayout->addWidget(searchingLabel);
 
     foundLabel = new QLabel("", resultTab);
     resultLabelLayout->addWidget(foundLabel);
 
     mainFeedToListBoxBtn = new QPushButton(QIcon::fromTheme("list-add"), i18n("Feed to listbox"), this);
     mainFeedToListBoxBtn->setEnabled(false);
     resultLabelLayout->addWidget(mainFeedToListBoxBtn);
 
     resultLayout->addLayout(resultLabelLayout, 3, 0);
 
     searcherTabs->addTab(resultTab, i18n("&Results"));
 
     searchBaseLayout->addWidget(searcherTabs, 0, 0);
 
     // signals and slots connections
 
     connect(mainSearchBtn, &QPushButton::clicked, this, &KrSearchDialog::startSearch);
     connect(mainStopBtn, &QPushButton::clicked, this, &KrSearchDialog::stopSearch);
     connect(mainCloseBtn, &QPushButton::clicked, this, &KrSearchDialog::closeDialog);
     connect(mainFeedToListBoxBtn, &QPushButton::clicked, this, &KrSearchDialog::feedToListBox);
 
     connect(profileManager, &ProfileManager::loadFromProfile, filterTabs, &FilterTabs::loadFromProfile);
     connect(profileManager, &ProfileManager::saveToProfile, filterTabs, &FilterTabs::saveToProfile);
 
     connect(resultView->op(), &KrViewOperator::currentChanged, this, &KrSearchDialog::currentChanged);
     connect(resultView->op(), &KrViewOperator::executed, this, &KrSearchDialog::executed);
     connect(resultView->op(), &KrViewOperator::contextMenu, this, &KrSearchDialog::contextMenu);
 
     // tab order
 
     setTabOrder(mainSearchBtn, mainCloseBtn);
     setTabOrder(mainCloseBtn, mainStopBtn);
     setTabOrder(mainStopBtn, searcherTabs);
     setTabOrder(searcherTabs, resultView->widget());
 
     sizeX = group.readEntry("Window Width",  -1);
     sizeY = group.readEntry("Window Height",  -1);
 
     if (sizeX != -1 && sizeY != -1)
         resize(sizeX, sizeY);
 
     if (group.readEntry("Window Maximized",  false))
         showMaximized();
     else
         show();
 
     generalFilter->searchFor->setFocus();
 
     // finally, load a profile of apply defaults:
 
     if (profile.isEmpty()) {
         // load the last used values
         generalFilter->searchFor->setEditText(lastSearchText);
         generalFilter->searchFor->lineEdit()->selectAll();
         generalFilter->ofType->setCurrentIndex(lastSearchType);
         generalFilter->searchForCase->setChecked(lastSearchForCase);
         generalFilter->containsWholeWord->setChecked(lastContainsWholeWord);
         generalFilter->containsTextCase->setChecked(lastContainsWithCase);
         generalFilter->containsRegExp->setChecked(lastContainsRegExp);
         generalFilter->searchInDirs->setChecked(lastSearchInSubDirs);
         generalFilter->searchInArchives->setChecked(lastSearchInArchives);
         generalFilter->followLinks->setChecked(lastFollowSymLinks);
         // the path in the active panel should be the default search location
         generalFilter->searchIn->lineEdit()->setText(ACTIVE_PANEL->virtualPath().toDisplayString(QUrl::PreferLocalFile));
     } else
         profileManager->loadProfile(profile);   // important: call this _after_ you've connected profileManager ot the loadFromProfile!!
 }
 
 KrSearchDialog::~KrSearchDialog()
 {
     delete query;
-    query = 0;
+    query = nullptr;
     delete resultView;
-    resultView = 0;
+    resultView = nullptr;
 }
 
 void KrSearchDialog::closeDialog(bool isAccept)
 {
     if(isBusy) {
         closed = true;
         return;
     }
 
     // stop the search if it's on-going
-    if (searcher != 0) {
+    if (searcher != nullptr) {
         delete searcher;
-        searcher = 0;
+        searcher = nullptr;
     }
 
     // saving the searcher state
 
     KConfigGroup group(krConfig, "Search");
 
     group.writeEntry("Window Width", sizeX);
     group.writeEntry("Window Height", sizeY);
     group.writeEntry("Window Maximized", isMaximized());
 
     resultView->saveSettings(KConfigGroup(&group, "ResultView"));
 
     lastSearchText = generalFilter->searchFor->currentText();
     lastSearchType = generalFilter->ofType->currentIndex();
     lastSearchForCase = generalFilter->searchForCase->isChecked();
     lastContainsWholeWord = generalFilter->containsWholeWord->isChecked();
     lastContainsWithCase = generalFilter->containsTextCase->isChecked();
     lastContainsRegExp = generalFilter->containsRegExp->isChecked();
     lastSearchInSubDirs = generalFilter->searchInDirs->isChecked();
     lastSearchInArchives = generalFilter->searchInArchives->isChecked();
     lastFollowSymLinks = generalFilter->followLinks->isChecked();
     hide();
 
-    SearchDialog = 0;
+    SearchDialog = nullptr;
     if (isAccept)
         QDialog::accept();
     else
         QDialog::reject();
 
     this->deleteLater();
 }
 
 void KrSearchDialog::reject()
 {
     closeDialog(false);
 }
 
 void KrSearchDialog::resizeEvent(QResizeEvent *e)
 {
     if (!isMaximized()) {
         sizeX = e->size().width();
         sizeY = e->size().height();
     }
 }
 
 void KrSearchDialog::slotFound(const FileItem &file, const QString &foundText)
 {
     result->addItem(file, foundText);
     foundLabel->setText(i18np("Found %1 match.", "Found %1 matches.", result->numFileItems()));
 }
 
 bool KrSearchDialog::gui2query()
 {
     // prepare the query ...
     /////////////////// names, locations and greps
-    if (query != 0) {
-        delete query; query = 0;
+    if (query != nullptr) {
+        delete query; query = nullptr;
     }
     query = new KRQuery();
 
     return filterTabs->fillQuery(query);
 }
 
 void KrSearchDialog::startSearch()
 {
     if(isBusy)
         return;
 
     // prepare the query /////////////////////////////////////////////
     if (!gui2query()) return;
 
     // first, informative messages
     if (query->searchInArchives()) {
         KMessageBox::information(this, i18n("Since you chose to also search in archives, "
                                             "note the following limitations:\n"
                                             "You cannot search for text (grep) while doing"
-                                            " a search that includes archives."), 0, "searchInArchives");
+                                            " a search that includes archives."), nullptr, "searchInArchives");
     }
 
     // prepare the gui ///////////////////////////////////////////////
     result->clear();
     resultView->setSortMode(KrViewProperties::NoColumn, 0);
 
     foundTextFrame->setVisible(!query->content().isEmpty());
     foundTextLabel->setText("");
 
     searchingLabel->setText("");
     foundLabel->setText(i18n("Found 0 matches."));
     mainFeedToListBoxBtn->setEnabled(false);
 
     mainSearchBtn->setEnabled(false);
     mainStopBtn->setEnabled(true);
     mainCloseBtn->setEnabled(false);
 
     searcherTabs->setCurrentIndex(2); // show the results page
 
     isBusy = true;
 
     qApp->processEvents();
 
     // start the search.
-    if (searcher != 0)
+    if (searcher != nullptr)
         abort();
     searcher  = new KRSearchMod(query);
     connect(searcher, &KRSearchMod::searching, searchingLabel, &KSqueezedTextLabel::setText);
     connect(searcher, &KRSearchMod::found, this, &KrSearchDialog::slotFound);
     connect(searcher, &KRSearchMod::finished, this, &KrSearchDialog::stopSearch);
 
     searcher->start();
 
     isBusy = false;
 
     delete searcher;
-    searcher = 0;
+    searcher = nullptr;
 
     // gui stuff
     mainSearchBtn->setEnabled(true);
     mainCloseBtn->setEnabled(true);
     mainStopBtn->setEnabled(false);
     if (result->numFileItems())
         mainFeedToListBoxBtn->setEnabled(true);
     searchingLabel->setText(i18n("Finished searching."));
 
     if (closed)
         closeDialog();
 }
 
 void KrSearchDialog::stopSearch()
 {
-    if (searcher != 0) {
+    if (searcher != nullptr) {
         searcher->stop();
-        disconnect(searcher, 0, 0, 0);
+        disconnect(searcher, nullptr, nullptr, nullptr);
     }
 }
 
 void KrSearchDialog::executed(const QString &name)
 {
     // 'name' is (local) file path or complete URL
     QString path = name;
     QString fileName;
     if(!name.endsWith('/')) {
         // not a directory, split filename and path
         int idx = name.lastIndexOf("/");
         fileName = name.mid(idx+1);
         path = name.left(idx);
     }
     QUrl url(path);
     if (url.scheme().isEmpty()) {
         url = QUrl::fromLocalFile(path);
     }
     ACTIVE_FUNC->openUrl(url, fileName);
     showMinimized();
 }
 
 void KrSearchDialog::currentChanged(KrViewItem *item)
 {
     if(!item)
         return;
     QString text = result->foundText(item->getFileItem());
     if(!text.isEmpty()) {
         // ugly hack: find the <b> and </b> in the text, then
         // use it to set the are which we don't want squeezed
         int idx = text.indexOf("<b>") - 4; // take "<qt>" into account
         int length = text.indexOf("</b>") - idx + 4;
         foundTextLabel->setText(text, idx, length);
     }
 }
 
 void KrSearchDialog::closeEvent(QCloseEvent *e)
 {                     /* if searching is in progress we must not close the window */
     if (isBusy)    /* because qApp->processEvents() is called by the searcher and */
     {                   /* at window destruction, the searcher object will be deleted */
         stopSearch();         /* instead we stop searching */
         closed = true;        /* and after stopping: startSearch can close the window */
         e->ignore();          /* ignoring the close event */
     } else
         QDialog::closeEvent(e);     /* if no searching, let QDialog handle the event */
 }
 
 void KrSearchDialog::keyPressEvent(QKeyEvent *e)
 {
     // TODO: don't use hardcoded shortcuts
 
     if (isBusy && e->key() == Qt::Key_Escape) { /* at searching we must not close the window */
         stopSearch();         /* so we simply stop searching */
         return;
     }
     if (resultView->widget()->hasFocus()) {
         if ((e->key() | e->modifiers()) == (Qt::CTRL | Qt::Key_I)) {
             searchBar->showBar(KrSearchBar::MODE_FILTER);
         } else if (e->key() == Qt::Key_F4) {
             tryPlaceSearchQueryToClipboard();
             editCurrent();
             return;
         } else if (e->key() == Qt::Key_F3) {
             tryPlaceSearchQueryToClipboard();
             viewCurrent();
             return;
         } else if (e->key() == Qt::Key_F10) {
             compareByContent();
             return;
         } else if (KrGlobal::copyShortcut == QKeySequence(e->key() | e->modifiers())) {
             copyToClipBoard();
             return;
         }
     }
     QDialog::keyPressEvent(e);
 }
 
 void KrSearchDialog::editCurrent()
 {
     KrViewItem *current = resultView->getCurrentKrViewItem();
     if (current)
         KrViewer::edit(current->getFileItem()->getUrl(), this);
 }
 
 void KrSearchDialog::viewCurrent()
 {
     KrViewItem *current = resultView->getCurrentKrViewItem();
     if (current)
         KrViewer::view(current->getFileItem()->getUrl(), this);
 }
 
 void KrSearchDialog::compareByContent()
 {
     KrViewItemList list;
     resultView->getSelectedKrViewItems(&list);
     if (list.count() != 2)
         return;
 
     SLOTS->compareContent(list[0]->getFileItem()->getUrl(),list[1]->getFileItem()->getUrl());
 }
 
 void KrSearchDialog::contextMenu(const QPoint &pos)
 {
     // create the menu
     QMenu popup;
     popup.setTitle(i18n("Krusader Search"));
 
     QAction *actView = popup.addAction(i18n("View File (F3)"));
     QAction *actEdit = popup.addAction(i18n("Edit File (F4)"));
     QAction *actComp = popup.addAction(i18n("Compare by content (F10)"));
     if(resultView->numSelected() != 2)
         actComp->setEnabled(false);
     QAction *actClip = popup.addAction(i18n("Copy selected to clipboard"));
 
     QAction *result = popup.exec(pos);
 
     // check out the user's option
     if (result == actView)
         viewCurrent();
     else if (result == actEdit)
         editCurrent();
     else if (result == actClip)
         copyToClipBoard();
     else if (result == actComp)
         compareByContent();
 }
 
 void KrSearchDialog::feedToListBox()
 {
     VirtualFileSystem virtFilesystem;
     virtFilesystem.scanDir(QUrl::fromLocalFile("/"));
 
     KConfigGroup group(krConfig, "Search");
     int listBoxNum = group.readEntry("Feed To Listbox Counter", 1);
     QString queryName;
     if(query) {
         const QString where = KrServices::toStringList(query->searchInDirs()).join(", ");
         queryName = query->content().isEmpty() ?
                         i18n("Search results for \"%1\" in %2", query->nameFilter(), where) :
                         i18n("Search results for \"%1\" containing \"%2\" in %3", query->nameFilter(), query->content(), where);
     }
     QString fileSystemName;
     do {
         fileSystemName = i18n("Search results") + QString(" %1").arg(listBoxNum++);
-    } while (virtFilesystem.getFileItem(fileSystemName) != 0);
+    } while (virtFilesystem.getFileItem(fileSystemName) != nullptr);
     group.writeEntry("Feed To Listbox Counter", listBoxNum);
 
     KConfigGroup ga(krConfig, "Advanced");
     if (ga.readEntry("Confirm Feed to Listbox",  _ConfirmFeedToListbox)) {
         bool ok;
         fileSystemName = QInputDialog::getText(this, i18n("Query name"), i18n("Here you can name the file collection"),
                                         QLineEdit::Normal, fileSystemName, &ok);
         if (! ok)
             return;
     }
 
     QList<QUrl> urlList;
     foreach(FileItem *fileitem, result->fileItems())
         urlList.push_back(fileitem->getUrl());
 
     mainSearchBtn->setEnabled(false);
     mainCloseBtn->setEnabled(false);
     mainFeedToListBoxBtn->setEnabled(false);
 
     isBusy = true;
 
     const QUrl url = QUrl(QString("virt:/") + fileSystemName);
     virtFilesystem.scanDir(url);
     virtFilesystem.addFiles(urlList);
     virtFilesystem.setMetaInformation(queryName);
     //ACTIVE_FUNC->openUrl(url);
     ACTIVE_MNG->slotNewTab(url);
 
     isBusy = false;
 
     closeDialog();
 }
 
 void KrSearchDialog::copyToClipBoard()
 {
     QList<QUrl> urls;
     foreach(FileItem *fileitem, result->fileItems())
         urls.push_back(fileitem->getUrl());
 
     if (urls.count() == 0)
         return;
 
-    QMimeData *mimeData = new QMimeData;
+    auto *mimeData = new QMimeData;
     mimeData->setImageData(FileListIcon("file").pixmap());
     mimeData->setUrls(urls);
 
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
 }
 
 void KrSearchDialog::tryPlaceSearchQueryToClipboard()
 {
     if (searchTextToClipboard->isChecked()
             && !generalFilter->containsText->currentText().isEmpty()
             && QApplication::clipboard()->text() != generalFilter->containsText->currentText()) {
         QApplication::clipboard()->setText(generalFilter->containsText->currentText());
     }
 }
diff --git a/krusader/Search/krsearchdialog.h b/krusader/Search/krsearchdialog.h
index ce83475a..0e85e853 100644
--- a/krusader/Search/krsearchdialog.h
+++ b/krusader/Search/krsearchdialog.h
@@ -1,130 +1,130 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRSEARCHDIALOG_H
 #define KRSEARCHDIALOG_H
 
 // QtCore
 #include <QString>
 #include <QStringList>
 // QtWidgets
 #include <QCheckBox>
 #include <QDialog>
 #include <QLabel>
 #include <QTabWidget>
 
 class FileItem;
 class FilterTabs;
 class GeneralFilter;
 class KrSearchBar;
 class KrSqueezedTextLabel;
 class KrView;
 class KrViewItem;
 class KRQuery;
 class KRSearchMod;
 class KSqueezedTextLabel;
 class ProfileManager;
 class SearchResultContainer;
 
 class KrSearchDialog : public QDialog
 {
     Q_OBJECT
 public:
-    explicit KrSearchDialog(QString profile = QString(), QWidget* parent = 0);
-    ~KrSearchDialog();
+    explicit KrSearchDialog(const QString& profile = QString(), QWidget* parent = nullptr);
+    ~KrSearchDialog() override;
 
     void prepareGUI();
 
     static KrSearchDialog *SearchDialog;
 
 public slots:
     void startSearch();
     void stopSearch();
     void feedToListBox();
     void copyToClipBoard();
     void slotFound(const FileItem &file, const QString &foundText);
     void closeDialog(bool isAccept = true);
     void executed(const QString &name);
     void currentChanged(KrViewItem *item);
     void contextMenu(const QPoint &);
 
-    virtual void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
-    virtual void closeEvent(QCloseEvent *e) Q_DECL_OVERRIDE;
-    virtual void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
+    void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
+    void closeEvent(QCloseEvent *e) Q_DECL_OVERRIDE;
+    void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
 
 protected slots:
     void reject() Q_DECL_OVERRIDE;
 
 private:
     bool gui2query();
     void editCurrent();
     void viewCurrent();
     void compareByContent();
 
     /**
      * Placing search query to clipboard is optional (opt-in).
      * So user has clipboard untact by default when opening found documents,
      * but can enable it persistently by checking "Query to clipboard" checkbox.
      */
     void tryPlaceSearchQueryToClipboard();
 
 private:
     ProfileManager *profileManager;
     QCheckBox *searchTextToClipboard;
 
     FilterTabs * filterTabs;
     GeneralFilter * generalFilter;
 
     QPushButton* mainSearchBtn;
     QPushButton* mainStopBtn;
     QPushButton* mainCloseBtn;
     QPushButton* mainFeedToListBoxBtn;
 
     QTabWidget* searcherTabs;
     QLabel* foundLabel;
     KrSqueezedTextLabel *foundTextLabel;
     KSqueezedTextLabel *searchingLabel;
 
     SearchResultContainer *result;
     KrView *resultView;
     KrSearchBar *searchBar;
     QFrame *foundTextFrame;
 
     KRQuery *query;
     KRSearchMod *searcher;
     bool isBusy;
     bool closed;
 
     static QString lastSearchText;
     static int     lastSearchType;
     static bool    lastSearchForCase;
     static bool    lastContainsWholeWord;
     static bool    lastContainsWithCase;
     static bool    lastSearchInSubDirs;
     static bool    lastSearchInArchives;
     static bool    lastFollowSymLinks;
     static bool    lastContainsRegExp;
 
     int            sizeX;
     int            sizeY;
 };
 
 #endif
diff --git a/krusader/Search/krsearchmod.h b/krusader/Search/krsearchmod.h
index 4a5572f9..2d6287b6 100644
--- a/krusader/Search/krsearchmod.h
+++ b/krusader/Search/krsearchmod.h
@@ -1,82 +1,82 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRSEARCHMOD_H
 #define KRSEARCHMOD_H
 
 // QtCore
 #include <QDateTime>
 #include <QObject>
 #include <QStack>
 #include <QStringList>
 #include <QUrl>
 
 #include <KIO/Global>
 
 class KRQuery;
 class FileItem;
 class FileSystem;
 class DefaultFileSystem;
 class VirtualFileSystem;
 
 /**
  * Search for files based on a search query.
  *
  * Subdirectories are included if query->isRecursive() is true.
  */
 class KRSearchMod : public QObject
 {
     Q_OBJECT
 public:
     explicit KRSearchMod(const KRQuery *query);
-    ~KRSearchMod();
+    ~KRSearchMod() override;
 
     void start();
     void stop();
 
 private:
     void scanUrl(const QUrl &url);
     void scanDirectory(const QUrl &url);
     FileSystem *getFileSystem(const QUrl &url);
 
 signals:
     void searching(const QString &url);
     void found(const FileItem &file, const QString &foundText);
     // NOTE: unused
     void error(const QUrl &url);
     void finished();
 
 private slots:
     void slotProcessEvents(bool &stopped);
 
 private:
     KRQuery *m_query;
     DefaultFileSystem *m_defaultFileSystem;
     VirtualFileSystem *m_virtualFileSystem;
 
     bool m_stopSearch;
 
     QStack<QUrl> m_scannedUrls;
     QStack<QUrl> m_unScannedUrls;
     QTime m_timer;
 };
 
 #endif
diff --git a/krusader/Splitter/combiner.cpp b/krusader/Splitter/combiner.cpp
index e0b00c85..28682172 100644
--- a/krusader/Splitter/combiner.cpp
+++ b/krusader/Splitter/combiner.cpp
@@ -1,342 +1,343 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "combiner.h"
 #include "../FileSystem/filesystem.h"
 
 // QtCore
 #include <QFileInfo>
 
 #include <KI18n/KLocalizedString>
 #include <KIOCore/KFileItem>
 #include <KIO/Job>
 #include <KIO/JobUiDelegate>
 #include <KWidgetsAddons/KMessageBox>
+#include <utility>
 
 //TODO: delete destination file on error
 //TODO: cache more than one byte array of data
 
 Combiner::Combiner(QWidget* parent,  QUrl baseURLIn, QUrl destinationURLIn, bool unixNamingIn) :
-        QProgressDialog(parent, 0), baseURL(baseURLIn), destinationURL(destinationURLIn),
+        QProgressDialog(parent, nullptr), baseURL(std::move(baseURLIn)), destinationURL(std::move(destinationURLIn)),
         hasValidSplitFile(false), fileCounter(0), permissions(-1), receivedSize(0),
-        statJob(0), combineReadJob(0), combineWriteJob(0), unixNaming(unixNamingIn)
+        statJob(nullptr), combineReadJob(nullptr), combineWriteJob(nullptr), unixNaming(unixNamingIn)
 {
     crcContext = new CRC32();
 
     splitFile = "";
 
     setMaximum(100);
     setAutoClose(false);    /* don't close or reset the dialog automatically */
     setAutoReset(false);
     setLabelText("Krusader::Combiner");
     setWindowModality(Qt::WindowModal);
 
     firstFileIs000 = true; //start with this assumption, will set it to false as soon as .000 isn't found
 }
 
 Combiner::~Combiner()
 {
     combineAbortJobs();
     delete crcContext;
 }
 
 void Combiner::combine()
 {
     setWindowTitle(i18n("Krusader::Combining..."));
     setLabelText(i18n("Combining the file %1...", baseURL.toDisplayString(QUrl::PreferLocalFile)));
 
     /* check whether the .crc file exists */
     splURL = baseURL.adjusted(QUrl::RemoveFilename);
     splURL.setPath(splURL.path() + baseURL.fileName() + ".crc");
     KFileItem file(splURL);
     //FIXME: works only for local files - use KIO::stat() instead
     file.refresh();
 
     if (!file.isReadable()) {
-        int ret = KMessageBox::questionYesNo(0, i18n("The CRC information file (%1) is missing.\n"
+        int ret = KMessageBox::questionYesNo(nullptr, i18n("The CRC information file (%1) is missing.\n"
                                              "Validity checking is impossible without it. Continue combining?",
                                              splURL.toDisplayString(QUrl::PreferLocalFile)));
 
         if (ret == KMessageBox::No) {
             emit reject();
             return;
         }
 
         statDest();
     } else {
         permissions = file.permissions() | QFile::WriteUser;
 
         combineReadJob = KIO::get(splURL, KIO::NoReload, KIO::HideProgressInfo);
 
         connect(combineReadJob, &KIO::TransferJob::data, this, &Combiner::combineSplitFileDataReceived);
         connect(combineReadJob, &KIO::TransferJob::result, this, &Combiner::combineSplitFileFinished);
     }
 
     exec();
 }
 
 void Combiner::combineSplitFileDataReceived(KIO::Job *, const QByteArray &byteArray)
 {
     splitFile += QString(byteArray);
 }
 
 void Combiner::combineSplitFileFinished(KJob *job)
 {
-    combineReadJob = 0;
+    combineReadJob = nullptr;
     QString error;
 
     if (job->error())
         error = i18n("Error at reading the CRC file (%1).", splURL.toDisplayString(QUrl::PreferLocalFile));
     else {
         splitFile.remove('\r');   // Windows compatibility
         QStringList splitFileContent = splitFile.split('\n');
 
         bool hasFileName = false, hasSize = false, hasCrc = false;
 
         for (int i = 0; i != splitFileContent.count(); i++) {
             int ndx = splitFileContent[i].indexOf('=');
             if (ndx == -1)
                 continue;
             QString token = splitFileContent[i].left(ndx).trimmed();
             QString value = splitFileContent[i].mid(ndx + 1);
 
             if (token == "filename") {
                 expectedFileName = value;
                 hasFileName = true;
             } else if (token == "size") {
                 //FIXME - don't use c functions !!!
                 sscanf(value.trimmed().toLocal8Bit(), "%llu", &expectedSize);
                 hasSize = true;
             }
             if (token == "crc32") {
                 expectedCrcSum   = value.trimmed().rightJustified(8, '0');
                 hasCrc = true;
             }
         }
 
         if (!hasFileName || !hasSize || !hasCrc)
             error = i18n("Not a valid CRC file.");
         else
             hasValidSplitFile = true;
     }
 
     if (!error.isEmpty()) {
-        int ret = KMessageBox::questionYesNo(0,
+        int ret = KMessageBox::questionYesNo(nullptr,
                                              error + i18n("\nValidity checking is impossible without a good CRC file. Continue combining?"));
         if (ret == KMessageBox::No) {
             emit reject();
             return;
         }
     }
 
     statDest();
 }
 
 void Combiner::statDest()
 {
     if (writeURL.isEmpty()) {
         writeURL = FileSystem::ensureTrailingSlash(destinationURL);
         if (hasValidSplitFile)
             writeURL.setPath(writeURL.path() + expectedFileName);
         else if (unixNaming)
             writeURL.setPath(writeURL.path() + baseURL.fileName() + ".out");
         else
             writeURL.setPath(writeURL.path() + baseURL.fileName());
     }
 
     statJob = KIO::stat(writeURL, KIO::StatJob::DestinationSide, 0, KIO::HideProgressInfo);
     connect(statJob, &KIO::StatJob::result, this, &Combiner::statDestResult);
 }
 
 void Combiner::statDestResult(KJob* job)
 {
-    statJob = 0;
+    statJob = nullptr;
 
     if (job->error()) {
         if (job->error() == KIO::ERR_DOES_NOT_EXIST) {
             openNextFile();
         } else {
-            static_cast<KIO::Job*>(job)->uiDelegate()->showErrorMessage();
+            dynamic_cast<KIO::Job*>(job)->uiDelegate()->showErrorMessage();
             emit reject();
         }
     } else { // destination already exists
-        KIO::RenameDialog_Options mode = static_cast<KIO::StatJob*>(job)->statResult().isDir() ?
+        KIO::RenameDialog_Options mode = dynamic_cast<KIO::StatJob*>(job)->statResult().isDir() ?
             KIO::RenameDialog_IsDirectory : KIO::RenameDialog_Overwrite;
         KIO::RenameDialog dlg(this, i18n("File Already Exists"), QUrl(), writeURL, mode);
         switch (dlg.exec()) {
         case KIO::R_OVERWRITE:
             openNextFile();
             break;
         case KIO::R_RENAME: {
             writeURL = dlg.newDestUrl();
             statDest();
             break;
         }
         default:
             emit reject();
         }
     }
 }
 
 void Combiner::openNextFile()
 {
     if (unixNaming) {
         if (readURL.isEmpty())
             readURL = baseURL;
         else {
             QString name = readURL.fileName();
             int pos = name.length() - 1;
             QChar ch;
 
             do {
                 ch = name.at(pos).toLatin1() + 1;
                 if (ch == QChar('Z' + 1))
                     ch = 'A';
                 if (ch == QChar('z' + 1))
                     ch = 'a';
                 name[ pos ] = ch;
                 pos--;
             } while (pos >= 0 && ch.toUpper() == QChar('A'));
             readURL = readURL.adjusted(QUrl::RemoveFilename);
             readURL.setPath(readURL.path() + name);
         }
     } else {
         QString index("%1");        /* determining the filename */
         index = index.arg(fileCounter++).rightJustified(3, '0');
         readURL = baseURL.adjusted(QUrl::RemoveFilename);
         readURL.setPath(readURL.path() + baseURL.fileName() + '.' + index);
     }
 
     /* creating a read job */
     combineReadJob = KIO::get(readURL, KIO::NoReload, KIO::HideProgressInfo);
 
     connect(combineReadJob, &KIO::TransferJob::data, this, &Combiner::combineDataReceived);
     connect(combineReadJob, &KIO::TransferJob::result, this, &Combiner::combineReceiveFinished);
     if (hasValidSplitFile)
         connect(combineReadJob, SIGNAL(percent(KJob*,ulong)),
                 this, SLOT(combineWritePercent(KJob*,ulong)));
 
 }
 
 void Combiner::combineDataReceived(KIO::Job *, const QByteArray &byteArray)
 {
     if (byteArray.size() == 0)
         return;
 
     crcContext->update((unsigned char *)byteArray.data(), byteArray.size());
     transferArray = QByteArray(byteArray.data(), byteArray.length());
 
     receivedSize += byteArray.size();
 
-    if (combineWriteJob == 0) {
+    if (combineWriteJob == nullptr) {
         combineWriteJob = KIO::put(writeURL, permissions, KIO::HideProgressInfo | KIO::Overwrite);
 
         connect(combineWriteJob, &KIO::TransferJob::dataReq, this, &Combiner::combineDataSend);
         connect(combineWriteJob, &KIO::TransferJob::result, this, &Combiner::combineSendFinished);
     }
 
      // continue writing and suspend read job until received data is handed over to the write job
     combineReadJob->suspend();
     combineWriteJob->resume();
 }
 
 void Combiner::combineReceiveFinished(KJob *job)
 {
-    combineReadJob = 0;   /* KIO automatically deletes the object after Finished signal */
+    combineReadJob = nullptr;   /* KIO automatically deletes the object after Finished signal */
     if (job->error()) {
         if (job->error() == KIO::ERR_DOES_NOT_EXIST) {
             if (fileCounter == 1) { // .000 file doesn't exist but .001 is still a valid first file
                 firstFileIs000 = false;
                 openNextFile();
             }
             else if (!firstFileIs000 && fileCounter == 2) { // neither .000 nor .001 exist
                 combineAbortJobs();
-                KMessageBox::error(0, i18n("Cannot open the first split file of %1.",
+                KMessageBox::error(nullptr, i18n("Cannot open the first split file of %1.",
                                            baseURL.toDisplayString(QUrl::PreferLocalFile)));
                 emit reject();
             } else { // we've received the last file
                 // write out the remaining part of the file
                 combineWriteJob->resume();
 
                 if (hasValidSplitFile) {
                     QString crcResult = QString("%1").arg(crcContext->result(), 0, 16).toUpper().trimmed()
                                         .rightJustified(8, '0');
 
                     if (receivedSize != expectedSize)
                         error = i18n("Incorrect filesize, the file might have been corrupted.");
                     else if (crcResult != expectedCrcSum.toUpper().trimmed())
                         error = i18n("Incorrect CRC checksum, the file might have been corrupted.");
                 }
             }
         } else {
             combineAbortJobs();
-            static_cast<KIO::Job*>(job)->uiDelegate()->showErrorMessage();
+            dynamic_cast<KIO::Job*>(job)->uiDelegate()->showErrorMessage();
             emit reject();
         }
     } else
         openNextFile();
 }
 
 void Combiner::combineDataSend(KIO::Job *, QByteArray &byteArray)
 {
     byteArray = transferArray;
     transferArray = QByteArray();
 
     if (combineReadJob) {
         // continue reading and suspend write job until data is available
         combineReadJob->resume();
         combineWriteJob->suspend();
     }
 }
 
 void Combiner::combineSendFinished(KJob *job)
 {
-    combineWriteJob = 0;  /* KIO automatically deletes the object after Finished signal */
+    combineWriteJob = nullptr;  /* KIO automatically deletes the object after Finished signal */
 
     if (job->error()) {   /* any error occurred? */
         combineAbortJobs();
-        static_cast<KIO::Job*>(job)->uiDelegate()->showErrorMessage();
+        dynamic_cast<KIO::Job*>(job)->uiDelegate()->showErrorMessage();
         emit reject();
     } else if (!error.isEmpty()) {  /* was any error message at reading ? */
         combineAbortJobs();             /* we cannot write out it in combineReceiveFinished */
-        KMessageBox::error(0, error);   /* because emit accept closes it in this function */
+        KMessageBox::error(nullptr, error);   /* because emit accept closes it in this function */
         emit reject();
     } else
         emit accept();
 }
 
 void Combiner::combineAbortJobs()
 {
     if (statJob)
         statJob->kill(KJob::Quietly);
     if (combineReadJob)
         combineReadJob->kill(KJob::Quietly);
     if (combineWriteJob)
         combineWriteJob->kill(KJob::Quietly);
 
-    statJob = combineReadJob = combineWriteJob = 0;
+    statJob = combineReadJob = combineWriteJob = nullptr;
 }
 
 void Combiner::combineWritePercent(KJob *, unsigned long)
 {
-    int percent = (int)((((double)receivedSize / expectedSize) * 100.) + 0.5);
+    auto percent = (int)((((double)receivedSize / expectedSize) * 100.) + 0.5);
     setValue(percent);
 }
 
diff --git a/krusader/Splitter/combiner.h b/krusader/Splitter/combiner.h
index 6420c82d..6ffcce03 100644
--- a/krusader/Splitter/combiner.h
+++ b/krusader/Splitter/combiner.h
@@ -1,89 +1,89 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef COMBINER_H
 #define COMBINER_H
 
 // QtCore
 #include <QString>
 #include <QUrl>
 // QtWidgets
 #include <QProgressDialog>
 
 #include <KIO/Job>
 
 #include "crc32.h"
 
 class Combiner : public QProgressDialog
 {
     Q_OBJECT
 
 public:
     Combiner(QWidget* parent,  QUrl baseURLIn, QUrl destinationURLIn, bool unixNamingIn = false);
-    ~Combiner();
+    ~Combiner() override;
 
     void combine();
 
 private slots:
     void statDest();
     void statDestResult(KJob* job);
     void combineSplitFileDataReceived(KIO::Job *, const QByteArray &byteArray);
     void combineSplitFileFinished(KJob *job);
     void combineDataReceived(KIO::Job *, const QByteArray &);
     void combineReceiveFinished(KJob *);
     void combineDataSend(KIO::Job *, QByteArray &);
     void combineSendFinished(KJob *);
     void combineWritePercent(KJob *, unsigned long);
 
 private:
     void openNextFile();
     void combineAbortJobs();
 
 
     QUrl            splURL;
     QUrl            readURL;
     QUrl            writeURL;
 
     QUrl            baseURL;
     QUrl            destinationURL;
     CRC32          *crcContext;
     QByteArray      transferArray;
 
     QString         splitFile;
     QString         error;
 
     bool            hasValidSplitFile;
     QString         expectedFileName;
     KIO::filesize_t expectedSize;
     QString         expectedCrcSum;
 
     int             fileCounter;
     bool            firstFileIs000;
     int             permissions;
     KIO::filesize_t receivedSize;
 
     KIO::Job         *statJob;
     KIO::TransferJob *combineReadJob;
     KIO::TransferJob *combineWriteJob;
 
     bool            unixNaming;
 };
 
 #endif /* __COMBINER_H__ */
diff --git a/krusader/Splitter/splitter.cpp b/krusader/Splitter/splitter.cpp
index 3da247e9..067c45a1 100644
--- a/krusader/Splitter/splitter.cpp
+++ b/krusader/Splitter/splitter.cpp
@@ -1,295 +1,296 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "splitter.h"
 #include "../FileSystem/filesystem.h"
 
 // QtCore
 #include <QFileInfo>
 // QtWidgets
 #include <QLayout>
 
 #include <KI18n/KLocalizedString>
 #include <KIO/Job>
 #include <KIOCore/KFileItem>
 #include <KIO/JobUiDelegate>
 #include <KWidgetsAddons/KMessageBox>
+#include <utility>
 
 Splitter::Splitter(QWidget* parent,  QUrl fileNameIn, QUrl destinationDirIn, bool overWriteIn) :
-        QProgressDialog(parent, 0),
-        fileName(fileNameIn),
-        destinationDir(destinationDirIn),
+        QProgressDialog(parent, nullptr),
+        fileName(std::move(fileNameIn)),
+        destinationDir(std::move(destinationDirIn)),
         splitSize(0),
         permissions(0),
         overwrite(overWriteIn),
         fileNumber(0),
         outputFileRemaining(0),
         receivedSize(0),
         crcContext(new CRC32()),
-        statJob(0),
-        splitReadJob(0),
-        splitWriteJob(0)
+        statJob(nullptr),
+        splitReadJob(nullptr),
+        splitWriteJob(nullptr)
 
 {
     setMaximum(100);
     setAutoClose(false);    /* don't close or reset the dialog automatically */
     setAutoReset(false);
     setLabelText("Krusader::Splitter");
     setWindowModality(Qt::WindowModal);
 }
 
 Splitter::~Splitter()
 {
     splitAbortJobs();
     delete crcContext;
 }
 
 void Splitter::split(KIO::filesize_t splitSizeIn)
 {
     Q_ASSERT(!splitReadJob);
     Q_ASSERT(!splitWriteJob);
     Q_ASSERT(!fileNumber);
     Q_ASSERT(!receivedSize);
     Q_ASSERT(!outputFileRemaining);
 
-    splitReadJob = splitWriteJob = 0;
+    splitReadJob = splitWriteJob = nullptr;
     fileNumber = receivedSize = outputFileRemaining = 0;
 
     splitSize = splitSizeIn;
 
     KFileItem file(fileName);
     file.refresh(); //FIXME: works only for local files - use KIO::stat() instead
 
     permissions = file.permissions() | QFile::WriteUser;
 
     setWindowTitle(i18n("Krusader::Splitting..."));
     setLabelText(i18n("Splitting the file %1...", fileName.toDisplayString(QUrl::PreferLocalFile)));
 
     if (file.isDir()) {
-        KMessageBox::error(0, i18n("Cannot split a folder."));
+        KMessageBox::error(nullptr, i18n("Cannot split a folder."));
         return;
     }
 
     splitReadJob = KIO::get(fileName, KIO::NoReload, KIO::HideProgressInfo);
 
     connect(splitReadJob, &KIO::TransferJob::data, this, &Splitter::splitDataReceived);
     connect(splitReadJob, &KIO::TransferJob::result, this, &Splitter::splitReceiveFinished);
     connect(splitReadJob, SIGNAL(percent(KJob*,ulong)),
             this, SLOT(splitReceivePercent(KJob*,ulong)));
 
     exec();
 }
 
 void Splitter::splitDataReceived(KIO::Job *, const QByteArray &byteArray)
 {
     Q_ASSERT(!transferArray.length()); // transfer buffer must be empty
 
     if (byteArray.size() == 0)
         return;
 
     crcContext->update((unsigned char *)byteArray.data(), byteArray.size());
     receivedSize += byteArray.size();
 
     if (!splitWriteJob)
         nextOutputFile();
 
     transferArray = QByteArray(byteArray.data(), byteArray.length());
 
     // suspend read job until transfer buffer is handed to the write job
     splitReadJob->suspend();
 
     if (splitWriteJob)
         splitWriteJob->resume();
 }
 
 void Splitter::splitReceiveFinished(KJob *job)
 {
-    splitReadJob = 0;   /* KIO automatically deletes the object after Finished signal */
+    splitReadJob = nullptr;   /* KIO automatically deletes the object after Finished signal */
 
     if (splitWriteJob)
         splitWriteJob->resume(); // finish writing the output
 
     if (job->error()) {   /* any error occurred? */
         splitAbortJobs();
-        KMessageBox::error(0, i18n("Error reading file %1: %2", fileName.toDisplayString(QUrl::PreferLocalFile),
+        KMessageBox::error(nullptr, i18n("Error reading file %1: %2", fileName.toDisplayString(QUrl::PreferLocalFile),
                                    job->errorString()));
         emit reject();
         return;
     }
 
     QString crcResult = QString("%1").arg(crcContext->result(), 0, 16).toUpper().trimmed()
                         .rightJustified(8, '0');
 
     splitInfoFileContent = QString("filename=%1\n").arg(fileName.fileName()) +
                 QString("size=%1\n")    .arg(KIO::number(receivedSize)) +
                 QString("crc32=%1\n")   .arg(crcResult);
 }
 
 void Splitter::splitReceivePercent(KJob *, unsigned long percent)
 {
     setValue(percent);
 }
 
 void Splitter::nextOutputFile()
 {
     Q_ASSERT(!outputFileRemaining);
 
     fileNumber++;
 
     outputFileRemaining = splitSize;
 
     QString index("%1"); /* making the split filename */
     index = index.arg(fileNumber).rightJustified(3, '0');
     QString outFileName = fileName.fileName() + '.' + index;
 
     writeURL = destinationDir;
     writeURL = writeURL.adjusted(QUrl::StripTrailingSlash);
     writeURL.setPath(writeURL.path() + '/' + (outFileName));
 
     if (overwrite)
         openOutputFile();
     else {
         statJob = KIO::stat(writeURL, KIO::StatJob::DestinationSide, 0, KIO::HideProgressInfo);
         connect(statJob, &KIO::Job::result, this, &Splitter::statOutputFileResult);
     }
 }
 
 void Splitter::statOutputFileResult(KJob* job)
 {
-    statJob = 0;
+    statJob = nullptr;
 
     if (job->error()) {
         if (job->error() == KIO::ERR_DOES_NOT_EXIST)
             openOutputFile();
         else {
-            static_cast<KIO::Job*>(job)->uiDelegate()->showErrorMessage();
+            dynamic_cast<KIO::Job*>(job)->uiDelegate()->showErrorMessage();
             emit reject();
         }
     } else { // destination already exists
         KIO::RenameDialog dlg(this, i18n("File Already Exists"), QUrl(), writeURL,
                 static_cast<KIO::RenameDialog_Options>(KIO::M_MULTI | KIO::M_OVERWRITE | KIO::M_NORENAME));
         switch (dlg.exec()) {
         case KIO::R_OVERWRITE:
             openOutputFile();
             break;
         case KIO::R_OVERWRITE_ALL:
             overwrite = true;
             openOutputFile();
             break;
         default:
             emit reject();
         }
     }
 }
 
 void Splitter::openOutputFile()
 {
     // create write job
     splitWriteJob = KIO::put(writeURL, permissions, KIO::HideProgressInfo | KIO::Overwrite);
     connect(splitWriteJob, &KIO::TransferJob::dataReq, this, &Splitter::splitDataSend);
     connect(splitWriteJob, &KIO::TransferJob::result, this, &Splitter::splitSendFinished);
 
 }
 
 void Splitter::splitDataSend(KIO::Job *, QByteArray &byteArray)
 {
     KIO::filesize_t bufferLen = transferArray.size();
 
     if (!outputFileRemaining) { // current output file needs to be closed ?
         byteArray = QByteArray();  // giving empty buffer which indicates closing
     } else if (bufferLen > outputFileRemaining) { // maximum length reached ?
         byteArray = QByteArray(transferArray.data(), outputFileRemaining);
         transferArray = QByteArray(transferArray.data() + outputFileRemaining,
                                    bufferLen - outputFileRemaining);
         outputFileRemaining = 0;
     } else {
         outputFileRemaining -= bufferLen;  // write the whole buffer to the output file
 
         byteArray = transferArray;
         transferArray = QByteArray();
 
         if (splitReadJob) {
             // suspend write job until transfer buffer is filled or the read job is finished
             splitWriteJob->suspend();
             splitReadJob->resume();
         } // else: write job continues until transfer buffer is empty
     }
 }
 
 void Splitter::splitSendFinished(KJob *job)
 {
-    splitWriteJob = 0;  /* KIO automatically deletes the object after Finished signal */
+    splitWriteJob = nullptr;  /* KIO automatically deletes the object after Finished signal */
 
     if (job->error()) {   /* any error occurred? */
         splitAbortJobs();
-        KMessageBox::error(0, i18n("Error writing file %1: %2", writeURL.toDisplayString(QUrl::PreferLocalFile),
+        KMessageBox::error(nullptr, i18n("Error writing file %1: %2", writeURL.toDisplayString(QUrl::PreferLocalFile),
                                    job->errorString()));
         emit reject();
         return;
     }
 
     if (transferArray.size())  /* any data remained in the transfer buffer? */
         nextOutputFile();
     else if (splitReadJob)
         splitReadJob->resume();
     else { // read job is finished and transfer buffer is empty -> splitting is finished
         /* writing the split information file out */
         writeURL      = destinationDir;
         writeURL = writeURL.adjusted(QUrl::StripTrailingSlash);
         writeURL.setPath(writeURL.path() + '/' + (fileName.fileName() + ".crc"));
         splitWriteJob = KIO::put(writeURL, permissions, KIO::HideProgressInfo | KIO::Overwrite);
         connect(splitWriteJob, &KIO::TransferJob::dataReq, this, &Splitter::splitFileSend);
         connect(splitWriteJob, &KIO::TransferJob::result,
                 this, &Splitter::splitFileFinished);
     }
 }
 
 void Splitter::splitAbortJobs()
 {
     if (statJob)
         statJob->kill(KJob::Quietly);
     if (splitReadJob)
         splitReadJob->kill(KJob::Quietly);
     if (splitWriteJob)
         splitWriteJob->kill(KJob::Quietly);
 
-    splitReadJob = splitWriteJob = 0;
+    splitReadJob = splitWriteJob = nullptr;
 }
 
 void Splitter::splitFileSend(KIO::Job *, QByteArray &byteArray)
 {
     byteArray = splitInfoFileContent.toLocal8Bit();
     splitInfoFileContent = "";
 }
 
 void Splitter::splitFileFinished(KJob *job)
 {
-    splitWriteJob = 0;  /* KIO automatically deletes the object after Finished signal */
+    splitWriteJob = nullptr;  /* KIO automatically deletes the object after Finished signal */
 
     if (job->error()) {   /* any error occurred? */
-        KMessageBox::error(0, i18n("Error writing file %1: %2", writeURL.toDisplayString(QUrl::PreferLocalFile),
+        KMessageBox::error(nullptr, i18n("Error writing file %1: %2", writeURL.toDisplayString(QUrl::PreferLocalFile),
                                    job->errorString()));
         emit reject();
         return;
     }
 
     emit accept();
 }
 
diff --git a/krusader/Splitter/splitter.h b/krusader/Splitter/splitter.h
index 1ceab761..496f35dc 100644
--- a/krusader/Splitter/splitter.h
+++ b/krusader/Splitter/splitter.h
@@ -1,82 +1,82 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SPLITTER_H
 #define SPLITTER_H
 
 // QtCore
 #include <QString>
 #include <QUrl>
 // QtWidgets
 #include <QProgressDialog>
 
 #include <KIO/Job>
 
 #include "crc32.h"
 
 class Splitter : public QProgressDialog
 {
     Q_OBJECT
 
 public:
     Splitter(QWidget* parent,  QUrl fileNameIn, QUrl destinationDirIn, bool overWriteIn);
-    ~Splitter();
+    ~Splitter() override;
 
     void split(KIO::filesize_t splitSizeIn);
 
 private slots:
     void splitDataReceived(KIO::Job *, const QByteArray &);
     void splitDataSend(KIO::Job *, QByteArray &);
     void splitSendFinished(KJob *);
     void splitReceiveFinished(KJob *);
     void splitReceivePercent(KJob *, unsigned long);
     void splitFileSend(KIO::Job *, QByteArray &);
     void splitFileFinished(KJob *);
     void statOutputFileResult(KJob* job);
 
 private:
     void splitAbortJobs();
     void nextOutputFile();
     void openOutputFile();
 
 
     // parameters
     QUrl            fileName;
     QUrl            destinationDir;
     KIO::filesize_t splitSize;
     int             permissions;
     bool            overwrite;
 
     // current split file stuff
     int             fileNumber;
     QUrl            writeURL;
     // how much can still be written to the current output file
     KIO::filesize_t outputFileRemaining;
 
     QByteArray      transferArray;
     KIO::filesize_t receivedSize;
     QString         splitInfoFileContent;
     CRC32          *crcContext;
     KIO::Job         *statJob;
     KIO::TransferJob *splitReadJob;
     KIO::TransferJob *splitWriteJob;
 };
 
 #endif /* __SPLITTER_H__ */
diff --git a/krusader/Splitter/splittergui.cpp b/krusader/Splitter/splittergui.cpp
index 6cf72280..252ee2e8 100644
--- a/krusader/Splitter/splittergui.cpp
+++ b/krusader/Splitter/splittergui.cpp
@@ -1,265 +1,266 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "splittergui.h"
 
 #include "../FileSystem/filesystem.h"
 
 // QtCore
 #include <QDebug>
 // QtGui
 #include <QValidator>
 #include <QKeyEvent>
 // QtWidgets
 #include <QDoubleSpinBox>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QLineEdit>
 #include <QLayout>
 #include <QLabel>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QFrame>
 #include <QDialogButtonBox>
 
 #include <KConfigCore/KConfigGroup>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
+#include <utility>
 
 struct SplitterGUI::PredefinedDevice
 {
     PredefinedDevice(QString name, KIO::filesize_t capacity) :
-        name(name), capacity(capacity) {}
+        name(std::move(name)), capacity(capacity) {}
     PredefinedDevice(const PredefinedDevice &other) :
         name(other.name), capacity(other.capacity) {}
     PredefinedDevice &operator=(const PredefinedDevice &other);
 
     QString name;
     KIO::filesize_t capacity;
 };
 
 
 const QList<SplitterGUI::PredefinedDevice> &SplitterGUI::predefinedDevices()
 {
     static QList<PredefinedDevice> list;
     if(!list.count()) {
         list << PredefinedDevice(i18n("1.44 MB (3.5\")"), 1457664);
         list << PredefinedDevice(i18n("1.2 MB (5.25\")"), 1213952);
         list << PredefinedDevice(i18n("720 kB (3.5\")"), 730112);
         list << PredefinedDevice(i18n("360 kB (5.25\")"), 362496);
         list << PredefinedDevice(i18n("100 MB (ZIP)"), 100431872);
         list << PredefinedDevice(i18n("250 MB (ZIP)"), 250331136);
         list << PredefinedDevice(i18n("650 MB (CD-R)"), 650*0x100000);
         list << PredefinedDevice(i18n("700 MB (CD-R)"), 700*0x100000);
     }
     return list;
 };
 
-SplitterGUI::SplitterGUI(QWidget* parent,  QUrl fileURL, QUrl defaultDir) :
+SplitterGUI::SplitterGUI(QWidget* parent,  const QUrl& fileURL, const QUrl& defaultDir) :
         QDialog(parent),
         userDefinedSize(0x100000), lastSelectedDevice(-1),
         division(1)
 {
     setModal(true);
 
-    QGridLayout *grid = new QGridLayout(this);
+    auto *grid = new QGridLayout(this);
     grid->setSpacing(6);
     grid->setContentsMargins(11, 11, 11, 11);
 
     QLabel *splitterLabel = new QLabel(this);
     splitterLabel->setText(i18n("Split the file %1 to folder:", fileURL.toDisplayString(QUrl::PreferLocalFile)));
     splitterLabel->setMinimumWidth(400);
     grid->addWidget(splitterLabel, 0 , 0);
 
     urlReq = new KUrlRequester(this);
     urlReq->setUrl(defaultDir);
     urlReq->setMode(KFile::Directory);
     grid->addWidget(urlReq, 1 , 0);
 
     QWidget *splitSizeLine = new QWidget(this);
-    QHBoxLayout * splitSizeLineLayout = new QHBoxLayout;
+    auto * splitSizeLineLayout = new QHBoxLayout;
     splitSizeLineLayout->setContentsMargins(0, 0, 0, 0);
     splitSizeLine->setLayout(splitSizeLineLayout);
 
     deviceCombo = new QComboBox(splitSizeLine);
     for (int i = 0; i != predefinedDevices().count(); i++)
         deviceCombo->addItem(predefinedDevices()[i].name);
     deviceCombo->addItem(i18n("User Defined"));
     splitSizeLineLayout->addWidget(deviceCombo);
 
     QLabel *spacer = new QLabel(splitSizeLine);
     spacer->setText(" ");
     spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
     splitSizeLineLayout->addWidget(spacer);
 
     QLabel *bytesPerFile = new QLabel(splitSizeLine);
     bytesPerFile->setText(i18n("Max file size:"));
     splitSizeLineLayout->addWidget(bytesPerFile);
 
     spinBox = new QDoubleSpinBox(splitSizeLine);
     spinBox->setMaximum(9999999999.0);
     spinBox->setMinimumWidth(85);
     spinBox->setEnabled(false);
     splitSizeLineLayout->addWidget(spinBox);
 
     sizeCombo = new QComboBox(splitSizeLine);
     sizeCombo->addItem(i18n("Byte"));
     sizeCombo->addItem(i18n("kByte"));
     sizeCombo->addItem(i18n("MByte"));
     sizeCombo->addItem(i18n("GByte"));
     splitSizeLineLayout->addWidget(sizeCombo);
 
     grid->addWidget(splitSizeLine, 2 , 0);
 
     overwriteCb = new QCheckBox(i18n("Overwrite files without confirmation"), this);
     grid->addWidget(overwriteCb, 3, 0);
 
     QFrame *separator = new QFrame(this);
     separator->setFrameStyle(QFrame::HLine | QFrame::Sunken);
     separator->setFixedHeight(separator->sizeHint().height());
 
     grid->addWidget(separator, 4 , 0);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     buttonBox->button(QDialogButtonBox::Ok)->setText(i18n("&Split"));
 
     grid->addWidget(buttonBox, 5 , 0);
 
     setWindowTitle(i18n("Krusader::Splitter"));
 
 
     KConfigGroup cfg(KSharedConfig::openConfig(), QStringLiteral("Splitter"));
     overwriteCb->setChecked(cfg.readEntry("OverWriteFiles", false));
 
     connect(sizeCombo, QOverload<int>::of(&QComboBox::activated), this, &SplitterGUI::sizeComboActivated);
     connect(deviceCombo, QOverload<int>::of(&QComboBox::activated), this, &SplitterGUI::predefinedComboActivated);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &SplitterGUI::reject);
     connect(buttonBox , &QDialogButtonBox::accepted, this, &SplitterGUI::splitPressed);
 
     predefinedComboActivated(0);
 }
 
 SplitterGUI::~SplitterGUI()
 {
     KConfigGroup cfg(KSharedConfig::openConfig(), QStringLiteral("Splitter"));
     cfg.writeEntry("OverWriteFiles", overwriteCb->isChecked());
 }
 
 KIO::filesize_t SplitterGUI::getSplitSize()
 {
     if(deviceCombo->currentIndex() < predefinedDevices().count()) // predefined size selected
         return predefinedDevices()[deviceCombo->currentIndex()].capacity;
     // user defined size selected
     return spinBox->value() * division;
 }
 
 bool SplitterGUI::overWriteFiles()
 {
     return overwriteCb->isChecked();
 }
 
 void SplitterGUI::sizeComboActivated(int item)
 {
     KIO::filesize_t prevDivision = division;
     switch (item) {
     case 0:
         division = 1;            /* byte */
         break;
     case 1:
         division = 0x400;        /* kbyte */
         break;
     case 2:
         division = 0x100000;     /* Mbyte */
         break;
     case 3:
         division = 0x40000000;   /* Gbyte */
         break;
     }
     double value;
     if(deviceCombo->currentIndex() < predefinedDevices().count()) // predefined size selected
         value = (double)predefinedDevices()[deviceCombo->currentIndex()].capacity / division;
     else { // use defined size selected
         value = (double)(spinBox->value() * prevDivision) / division;
         if(value < 1)
             value = 1;
     }
     spinBox->setValue(value);
 }
 
 void SplitterGUI::predefinedComboActivated(int item)
 {
     if(item == lastSelectedDevice)
         return;
 
     KIO::filesize_t capacity = userDefinedSize;
 
     if (lastSelectedDevice == predefinedDevices().count()) // user defined was selected previously
         userDefinedSize = spinBox->value() * division; // remember user defined size
 
     if(item < predefinedDevices().count()) { // predefined size selected
         capacity = predefinedDevices()[item].capacity;
         spinBox->setEnabled(false);
     } else // user defined size selected
         spinBox->setEnabled(true);
 
     //qDebug() << capacity;
 
     if (capacity >= 0x40000000) {          /* Gbyte */
         sizeCombo->setCurrentIndex(3);
         division = 0x40000000;
     } else if (capacity >= 0x100000) {      /* Mbyte */
         sizeCombo->setCurrentIndex(2);
         division = 0x100000;
     } else if (capacity >= 0x400) {         /* kbyte */
         sizeCombo->setCurrentIndex(1);
         division = 0x400;
     } else {
         sizeCombo->setCurrentIndex(0);       /* byte */
         division = 1;
     }
 
     spinBox->setValue((double)capacity / division);
 
     lastSelectedDevice = item;
 }
 
 void SplitterGUI::splitPressed()
 {
     if (!urlReq->url().isValid()) {
         KMessageBox::error(this, i18n("The folder path URL is malformed."));
         return;
     }
     if(getSplitSize() > 0)
         emit accept();
 }
 
 void SplitterGUI::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Enter :
     case Qt::Key_Return :
         emit splitPressed();
         return;
     default:
         QDialog::keyPressEvent(e);
     }
 }
 
diff --git a/krusader/Splitter/splittergui.h b/krusader/Splitter/splittergui.h
index deb048ce..2bd213d5 100644
--- a/krusader/Splitter/splittergui.h
+++ b/krusader/Splitter/splittergui.h
@@ -1,74 +1,74 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SPLITTERGUI_H
 #define SPLITTERGUI_H
 
 // QtCore
 #include <QUrl>
 // QtWidgets
 #include <QDialog>
 
 #include <KIOWidgets/KUrlRequester>
 #include <KIO/Global>
 
 class QComboBox;
 class QCheckBox;
 class QDoubleSpinBox;
 
 
 class SplitterGUI : public QDialog
 {
     Q_OBJECT
 private:
     struct PredefinedDevice;
 
     static const QList<PredefinedDevice> &predefinedDevices();
 
     KIO::filesize_t                 userDefinedSize;
     int                             lastSelectedDevice;
     KIO::filesize_t                 division;
 
     QDoubleSpinBox  *spinBox;
     QComboBox       *deviceCombo;
     QComboBox       *sizeCombo;
     QCheckBox       *overwriteCb;
     KUrlRequester   *urlReq;
 
 public:
-    SplitterGUI(QWidget* parent,  QUrl fileURL, QUrl defaultDir);
-    ~SplitterGUI();
+    SplitterGUI(QWidget* parent,  const QUrl& fileURL, const QUrl& defaultDir);
+    ~SplitterGUI() override;
 
     QUrl    getDestinationDir()     {
         return urlReq->url();
     }
     KIO::filesize_t getSplitSize();
     bool overWriteFiles();
 
 public slots:
     virtual void sizeComboActivated(int item);
     virtual void predefinedComboActivated(int item);
     virtual void splitPressed();
 
 protected:
-    virtual void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
+    void keyPressEvent(QKeyEvent *e) Q_DECL_OVERRIDE;
 };
 
 #endif /* __SPLITTERGUI_H__ */
diff --git a/krusader/Synchronizer/feedtolistboxdialog.cpp b/krusader/Synchronizer/feedtolistboxdialog.cpp
index 295ac34b..0935d864 100644
--- a/krusader/Synchronizer/feedtolistboxdialog.cpp
+++ b/krusader/Synchronizer/feedtolistboxdialog.cpp
@@ -1,206 +1,206 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "feedtolistboxdialog.h"
 #include "synchronizer.h"
 #include "synchronizergui.h"
 #include "../FileSystem/filesystem.h"
 #include "../FileSystem/virtualfilesystem.h"
 #include "../krglobal.h"
 #include "../krusaderview.h"
 #include "../panelmanager.h"
 
 // QtWidgets
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QLineEdit>
 #include <QLabel>
 #include <QComboBox>
 #include <QVBoxLayout>
 
 #include <KConfigCore/KConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #define  S_LEFT        0
 #define  S_RIGHT       1
 #define  S_BOTH        2
 
 FeedToListBoxDialog::FeedToListBoxDialog(QWidget *parent, Synchronizer *sync,
         QTreeWidget *syncL, bool equOK) : QDialog(parent),
         synchronizer(sync), syncList(syncL), equalAllowed(equOK), accepted(false)
 {
 
     setWindowTitle(i18n("Krusader::Feed to listbox"));
     setWindowModality(Qt::WindowModal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     // autodetecting the parameters
 
     int selectedNum = 0;
     int itemNum = 0;
     int leftExistingNum = 0;
     int rightExistingNum = 0;
 
     QTreeWidgetItemIterator it(syncList);
     while (*it) {
-        SynchronizerGUI::SyncViewItem *item = (SynchronizerGUI::SyncViewItem *) * it;
+        auto *item = (SynchronizerGUI::SyncViewItem *) * it;
         SynchronizerFileItem *syncItem = item->synchronizerItemRef();
 
         if (syncItem && syncItem->isMarked()) {
             if (item->isSelected() || syncItem->task() != TT_EQUALS || equalAllowed) {
                 itemNum++;
                 if (item->isSelected())
                     selectedNum++;
 
                 if (syncItem->existsInLeft())
                     leftExistingNum++;
                 if (syncItem->existsInRight())
                     rightExistingNum++;
             }
         }
         it++;
     }
 
     if (itemNum == 0) {
         hide();
         KMessageBox::error(parent, i18n("No elements to feed."));
         return;
     }
 
     // guessing the collection name
 
     VirtualFileSystem virtFilesystem;
     if (!virtFilesystem.scanDir(QUrl("virt:/")))
         return;
 
     KConfigGroup group(krConfig, "Synchronize");
     int listBoxNum = group.readEntry("Feed To Listbox Counter", 1);
     QString queryName;
     do {
         queryName = i18n("Synchronize results") + QString(" %1").arg(listBoxNum++);
-    } while (virtFilesystem.getFileItem(queryName) != 0);
+    } while (virtFilesystem.getFileItem(queryName) != nullptr);
     group.writeEntry("Feed To Listbox Counter", listBoxNum);
 
     // creating the widget
 
     QLabel *label = new QLabel(i18n("Here you can name the file collection"), this);
     mainLayout->addWidget(label);
 
     lineEdit = new QLineEdit(this);
     lineEdit->setText(queryName);
     lineEdit->setClearButtonEnabled(true);
     lineEdit->selectAll();
     mainLayout->addWidget(lineEdit);
 
-    QHBoxLayout * hbox = new QHBoxLayout;
+    auto * hbox = new QHBoxLayout;
 
     QLabel *label2 = new QLabel(i18n("Side to feed:"), this);
     label2->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     hbox->addWidget(label2);
 
     sideCombo = new QComboBox(this);
     sideCombo->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     sideCombo->addItem(i18n("Left"));
     sideCombo->addItem(i18n("Right"));
     sideCombo->addItem(i18n("Both"));
     hbox->addWidget(sideCombo);
 
     if (leftExistingNum == 0) {
         sideCombo->setCurrentIndex(1);
         sideCombo->setEnabled(false);
     } else if (rightExistingNum == 0) {
         sideCombo->setCurrentIndex(0);
         sideCombo->setEnabled(false);
     } else
         sideCombo->setCurrentIndex(2);
 
     QFrame *line = new QFrame(this);
     line->setFrameStyle(QFrame::VLine | QFrame::Sunken);
     line->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     hbox->addWidget(line);
 
     cbSelected = new QCheckBox(i18n("Selected files only"), this);
     cbSelected->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     cbSelected->setEnabled(selectedNum != 0);
     cbSelected->setChecked(selectedNum != 0);
     hbox->addWidget(cbSelected);
 
     mainLayout->addLayout(hbox);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel);
     mainLayout->addWidget(buttonBox);
 
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
 
     connect(buttonBox, &QDialogButtonBox::accepted, this, &FeedToListBoxDialog::slotOk);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &FeedToListBoxDialog::reject);
 
     exec();
 }
 
 void FeedToListBoxDialog::slotOk()
 {
     int side = sideCombo->currentIndex();
     bool selected = cbSelected->isChecked();
     QString name = lineEdit->text();
     QList<QUrl> urlList;
 
     QTreeWidgetItemIterator it(syncList);
     for (;*it; it++) {
-        SynchronizerGUI::SyncViewItem *item = (SynchronizerGUI::SyncViewItem *) * it;
+        auto *item = (SynchronizerGUI::SyncViewItem *) * it;
         SynchronizerFileItem *syncItem = item->synchronizerItemRef();
 
         if (!syncItem || !syncItem->isMarked())
             continue;
         if (selected && !item->isSelected())
             continue;
         if (!equalAllowed && syncItem->task() == TT_EQUALS && (!selected || !item->isSelected()))
             continue;
 
         if ((side == S_BOTH || side == S_LEFT) && syncItem->existsInLeft()) {
             QString leftDirName = syncItem->leftDirectory().isEmpty() ? "" : syncItem->leftDirectory() + '/';
             QUrl leftURL = Synchronizer::fsUrl(synchronizer->leftBaseDirectory() + leftDirName + syncItem->leftName());
             urlList.push_back(leftURL);
         }
 
         if ((side == S_BOTH || side == S_RIGHT) && syncItem->existsInRight()) {
             QString rightDirName = syncItem->rightDirectory().isEmpty() ? "" : syncItem->rightDirectory() + '/';
             QUrl leftURL = Synchronizer::fsUrl(synchronizer->rightBaseDirectory() + rightDirName + syncItem->rightName());
             urlList.push_back(leftURL);
         }
     }
 
     QUrl url = QUrl(QString("virt:/") + name);
     VirtualFileSystem virtFilesystem;
     if (!virtFilesystem.refresh(url)) { // create directory if it does not exist
         KMessageBox::error(parentWidget(), i18n("Cannot open %1.", url.toDisplayString()));
         return;
     }
     virtFilesystem.addFiles(urlList);
     ACTIVE_MNG->slotNewTab(url);
     accepted = true;
     accept();
 }
 
diff --git a/krusader/Synchronizer/feedtolistboxdialog.h b/krusader/Synchronizer/feedtolistboxdialog.h
index 2165eb39..8b1b117d 100644
--- a/krusader/Synchronizer/feedtolistboxdialog.h
+++ b/krusader/Synchronizer/feedtolistboxdialog.h
@@ -1,58 +1,58 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef FEEDTOLISTBOXDIALOG_H
 #define FEEDTOLISTBOXDIALOG_H
 
 // QtWidgets
 #include <QDialog>
 
 class Synchronizer;
 class QCheckBox;
 class QLineEdit;
 class QComboBox;
 class QTreeWidget;
 
 class FeedToListBoxDialog : public QDialog
 {
     Q_OBJECT
 
 public:
     FeedToListBoxDialog(QWidget*, Synchronizer *, QTreeWidget *, bool);
-    virtual ~FeedToListBoxDialog() {}
+    ~FeedToListBoxDialog() override = default;
 
     bool isAccepted() {
         return accepted;
     }
 
 protected slots:
     void slotOk();
 
 private:
     Synchronizer * synchronizer;
     QTreeWidget  * syncList;
     QCheckBox    * cbSelected;
     QLineEdit    * lineEdit;
     QComboBox    * sideCombo;
     bool           equalAllowed;
     bool           accepted;
 };
 
 #endif /* __FEED_TO_LISTBOX_DIALOG__ */
diff --git a/krusader/Synchronizer/synchronizedialog.cpp b/krusader/Synchronizer/synchronizedialog.cpp
index d94361d3..e47afd4b 100644
--- a/krusader/Synchronizer/synchronizedialog.cpp
+++ b/krusader/Synchronizer/synchronizedialog.cpp
@@ -1,204 +1,204 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "synchronizedialog.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../defaults.h"
 
 // QtWidgets
 #include <QLayout>
 #include <QVBoxLayout>
 #include <QLabel>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 SynchronizeDialog::SynchronizeDialog(QWidget* parent,
                                      Synchronizer *sync, int pleftCopyNr, KIO::filesize_t pleftCopySize,
                                      int prightCopyNr, KIO::filesize_t prightCopySize, int pdeleteNr,
                                      KIO::filesize_t pdeleteSize, int parThreads) : QDialog(parent),
         synchronizer(sync), leftCopyNr(pleftCopyNr),
         leftCopySize(pleftCopySize), rightCopyNr(prightCopyNr),
         rightCopySize(prightCopySize), deleteNr(pdeleteNr),
         deleteSize(pdeleteSize), parallelThreads(parThreads),
         isPause(true), syncStarted(false)
 {
     setWindowTitle(i18n("Krusader::Synchronize"));
     setModal(true);
 
-    QVBoxLayout *layout = new QVBoxLayout(this);
+    auto *layout = new QVBoxLayout(this);
     layout->setContentsMargins(11, 11, 11, 11);
     layout->setSpacing(6);
 
     cbRightToLeft = new QCheckBox(i18np("Right to left: Copy 1 file", "Right to left: Copy %1 files", leftCopyNr) + ' ' +
                                   i18np("(1 byte)", "(%1 bytes)", KRpermHandler::parseSize(leftCopySize).trimmed().toInt()),
                                   this);
     cbRightToLeft->setChecked(leftCopyNr != 0);
     cbRightToLeft->setEnabled(leftCopyNr != 0);
     layout->addWidget(cbRightToLeft);
 
     lbRightToLeft = new QLabel(i18np("\tReady: %2/1 file, %3/%4", "\tReady: %2/%1 files, %3/%4", leftCopyNr, 0,
                                      0, KRpermHandler::parseSize(leftCopySize).trimmed()),
                                this);
     lbRightToLeft->setEnabled(leftCopyNr != 0);
     layout->addWidget(lbRightToLeft);
 
     cbLeftToRight = new QCheckBox(i18np("Left to right: Copy 1 file", "Left to right: Copy %1 files", rightCopyNr) + ' ' +
                                   i18np("(1 byte)", "(%1 bytes)", KRpermHandler::parseSize(rightCopySize).trimmed().toInt()),
                                   this);
     cbLeftToRight->setChecked(rightCopyNr != 0);
     cbLeftToRight->setEnabled(rightCopyNr != 0);
     layout->addWidget(cbLeftToRight);
 
     lbLeftToRight = new QLabel(i18np("\tReady: %2/1 file, %3/%4", "\tReady: %2/%1 files, %3/%4", rightCopyNr, 0,
                                      0, KRpermHandler::parseSize(rightCopySize).trimmed()),
                                this);
     lbLeftToRight->setEnabled(rightCopyNr != 0);
     layout->addWidget(lbLeftToRight);
 
     cbDeletable = new QCheckBox(i18np("Left: Delete 1 file", "Left: Delete %1 files", deleteNr) + ' ' +
                                 i18np("(1 byte)", "(%1 bytes)", KRpermHandler::parseSize(deleteSize).trimmed().toInt()),
                                 this);
     cbDeletable->setChecked(deleteNr != 0);
     cbDeletable->setEnabled(deleteNr != 0);
     layout->addWidget(cbDeletable);
 
     lbDeletable   = new QLabel(i18np("\tReady: %2/1 file, %3/%4", "\tReady: %2/%1 files, %3/%4", deleteNr, 0,
                                      0, KRpermHandler::parseSize(deleteSize).trimmed()),
                                this);
     lbDeletable->setEnabled(deleteNr != 0);
     layout->addWidget(lbDeletable);
 
     progress = new QProgressBar(this);
     progress->setMaximum(1000);
     progress->setMinimum(0);
     progress->setValue(0);
     progress->setMinimumWidth(400);
     layout->addWidget(progress);
 
     QWidget *hboxWidget = new QWidget(this);
-    QHBoxLayout * hbox = new QHBoxLayout(hboxWidget);
+    auto * hbox = new QHBoxLayout(hboxWidget);
 
     hbox->setSpacing(6);
 
     cbOverwrite = new QCheckBox(i18n("Confirm overwrites"), this);
     KConfigGroup group(krConfig, "Synchronize");
     cbOverwrite->setChecked(group.readEntry("Confirm overwrites", _ConfirmOverWrites));
     layout->addWidget(cbOverwrite);
 
-    QSpacerItem* spacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+    auto* spacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     hbox->addItem(spacer);
 
     btnStart = new QPushButton(hboxWidget);
     btnStart->setText(i18n("&Start"));
     btnStart->setIcon(Icon("media-playback-start"));
     hbox->addWidget(btnStart);
 
     btnPause = new QPushButton(hboxWidget);
     btnPause->setEnabled(false);
     btnPause->setText(i18n("&Pause"));
     btnPause->setIcon(Icon("media-playback-pause"));
     hbox->addWidget(btnPause);
 
-    QPushButton *btnClose = new QPushButton(hboxWidget);
+    auto *btnClose = new QPushButton(hboxWidget);
     btnClose->setText(i18n("&Close"));
     btnClose->setIcon(Icon("dialog-close"));
     hbox->addWidget(btnClose);
 
     layout->addWidget(hboxWidget);
 
     connect(btnStart,  &QPushButton::clicked, this, [=]() { startSynchronization(); });
     connect(btnPause,  &QPushButton::clicked, this, [=]() { pauseOrResume(); });
     connect(btnClose,  &QPushButton::clicked, this, [=]() { reject(); });
 
     exec();
 }
 
 SynchronizeDialog::~SynchronizeDialog()
 {
     KConfigGroup group(krConfig, "Synchronize");
     group.writeEntry("Confirm overwrites", cbOverwrite->isChecked());
 }
 
 void SynchronizeDialog::startSynchronization()
 {
     btnStart->setEnabled(false);
     btnPause->setEnabled(syncStarted = true);
     connect(synchronizer,  SIGNAL(synchronizationFinished()), this, SLOT(synchronizationFinished()));
     connect(synchronizer,  SIGNAL(processedSizes(int,KIO::filesize_t,int,KIO::filesize_t,int,KIO::filesize_t)),
             this, SLOT(processedSizes(int,KIO::filesize_t,int,KIO::filesize_t,int,KIO::filesize_t)));
     connect(synchronizer,  SIGNAL(pauseAccepted()), this, SLOT(pauseAccepted()));
 
     if (!cbRightToLeft->isChecked()) leftCopySize = 0;
     if (!cbLeftToRight->isChecked()) rightCopySize = 0;
     if (!cbDeletable->isChecked())   deleteSize = 0;
 
     synchronizer->synchronize(this, cbRightToLeft->isChecked(), cbLeftToRight->isChecked(),
                               cbDeletable->isChecked(), !cbOverwrite->isChecked(), parallelThreads);
 }
 
 void SynchronizeDialog::synchronizationFinished()
 {
     QDialog::reject();
 }
 
 void SynchronizeDialog::processedSizes(int leftNr, KIO::filesize_t leftSize, int rightNr,
                                        KIO::filesize_t rightSize, int delNr, KIO::filesize_t delSize)
 {
     lbRightToLeft->setText(i18np("\tReady: %2/1 file, %3/%4", "\tReady: %2/%1 files, %3/%4", leftCopyNr, leftNr,
                                 KRpermHandler::parseSize(leftSize).trimmed(),
                                 KRpermHandler::parseSize(leftCopySize).trimmed()));
     lbLeftToRight->setText(i18np("\tReady: %2/1 file, %3/%4", "\tReady: %2/%1 files, %3/%4", rightCopyNr, rightNr,
                                 KRpermHandler::parseSize(rightSize).trimmed(),
                                 KRpermHandler::parseSize(rightCopySize).trimmed()));
     lbDeletable->setText(i18np("\tReady: %2/1 file, %3/%4", "\tReady: %2/%1 files, %3/%4", deleteNr, delNr,
                               KRpermHandler::parseSize(delSize).trimmed(),
                               KRpermHandler::parseSize(deleteSize).trimmed()));
 
     KIO::filesize_t totalSum      = leftCopySize + rightCopySize + deleteSize;
     KIO::filesize_t processedSum  = leftSize + rightSize + delSize;
 
     if (totalSum == 0)
         totalSum++;
 
     progress->setValue((int)(((double)processedSum / (double)totalSum)*1000));
 }
 
 void SynchronizeDialog::pauseOrResume()
 {
     if (isPause) {
         btnPause->setEnabled(false);
         synchronizer->pause();
     } else {
         btnPause->setText(i18n("Pause"));
         synchronizer->resume();
         isPause = true;
     }
 }
 
 void SynchronizeDialog::pauseAccepted()
 {
     btnPause->setText(i18n("Resume"));
     btnPause->setEnabled(true);
     isPause = false;
 }
 
diff --git a/krusader/Synchronizer/synchronizedialog.h b/krusader/Synchronizer/synchronizedialog.h
index 283ada57..f11c2f3e 100644
--- a/krusader/Synchronizer/synchronizedialog.h
+++ b/krusader/Synchronizer/synchronizedialog.h
@@ -1,84 +1,84 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SYNCHRONIZEDIALOG_H
 #define SYNCHRONIZEDIALOG_H
 
 // QtWidgets
 #include <QDialog>
 #include <QCheckBox>
 #include <QLabel>
 #include <QProgressBar>
 #include <QPushButton>
 
 #include "synchronizer.h"
 
 class SynchronizeDialog : QDialog
 {
     Q_OBJECT
 
 public:
     SynchronizeDialog(QWidget*, Synchronizer *sync,
                       int, KIO::filesize_t, int, KIO::filesize_t, int, KIO::filesize_t, int);
-    ~SynchronizeDialog();
+    ~SynchronizeDialog() override;
 
     inline bool wasSyncronizationStarted()    {
         return syncStarted;
     }
 
 public slots:
     void startSynchronization();
     void synchronizationFinished();
     void processedSizes(int, KIO::filesize_t, int, KIO::filesize_t, int, KIO::filesize_t);
     void pauseOrResume();
     void pauseAccepted();
 
 private:
     QProgressBar  *progress;
 
     QCheckBox     *cbRightToLeft;
     QCheckBox     *cbLeftToRight;
     QCheckBox     *cbDeletable;
 
     QLabel        *lbRightToLeft;
     QLabel        *lbLeftToRight;
     QLabel        *lbDeletable;
 
     QCheckBox     *cbOverwrite;
 
     QPushButton   *btnStart;
     QPushButton   *btnPause;
 
     Synchronizer  *synchronizer;
 
     int               leftCopyNr;
     KIO::filesize_t   leftCopySize;
     int               rightCopyNr;
     KIO::filesize_t   rightCopySize;
     int               deleteNr;
     KIO::filesize_t   deleteSize;
 
     int               parallelThreads;
 
     bool           isPause;
     bool           syncStarted;
 };
 
 #endif /* __SYNCHRONIZE_DIALOG__ */
diff --git a/krusader/Synchronizer/synchronizer.cpp b/krusader/Synchronizer/synchronizer.cpp
index ae4ff27a..25d84e3e 100644
--- a/krusader/Synchronizer/synchronizer.cpp
+++ b/krusader/Synchronizer/synchronizer.cpp
@@ -1,1443 +1,1443 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "synchronizer.h"
 #include "synchronizerdirlist.h"
 #include "../krglobal.h"
 #include "../krservices.h"
 #include "../FileSystem/filesystem.h"
 #include "../FileSystem/krquery.h"
 
 #include <utime.h>
 
 // QtCore
 #include <QRegExp>
 #include <QDir>
 #include <QEventLoop>
 #include <QTimer>
 #include <QTime>
 #include <QDateTime>
 #include <QUrl>
 // QtWidgets
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QVBoxLayout>
 #include <QLayout>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QLabel>
 
 #include <KI18n/KLocalizedString>
 #include <KIO/DeleteJob>
 #include <KIO/JobUiDelegate>
 #include <KIO/SkipDialog>
 #include <KCoreAddons/KProcess>
 #include <KIOWidgets/KUrlCompletion>
 #include <KWidgetsAddons/KMessageBox>
 
 
 #ifdef HAVE_POSIX_ACL
 #include <sys/acl.h>
 #ifdef HAVE_NON_POSIX_ACL_EXTENSIONS
 #include <acl/libacl.h>
 #endif
 #endif
 
 
 #define  DISPLAY_UPDATE_PERIOD        2
 
-Synchronizer::Synchronizer() : displayUpdateCount(0), markEquals(true),
-        markDiffers(true), markCopyToLeft(true), markCopyToRight(true), markDeletable(true),
-        stack(), jobMap(), receivedMap(), parentWidget(0), resultListIt(resultList)
+Synchronizer::Synchronizer()
+    : displayUpdateCount(0), markEquals(true), markDiffers(true), markCopyToLeft(true),
+      markCopyToRight(true), markDeletable(true), parentWidget(nullptr), resultListIt(resultList)
 {
 }
 
 Synchronizer::~Synchronizer()
 {
     clearLists();
 }
 
-QUrl Synchronizer::fsUrl(QString strUrl)
+QUrl Synchronizer::fsUrl(const QString& strUrl)
 {
     QUrl result = QUrl::fromUserInput(strUrl, QString(), QUrl::AssumeLocalFile);
     return KrServices::escapeFileUrl(result);
 }
 
 void Synchronizer::clearLists()
 {
     QListIterator<SynchronizerFileItem *> i1(resultList);
     while (i1.hasNext())
         delete i1.next();
     resultList.clear();
 
     QListIterator<SynchronizerTask *> i2(stack);
     while (i2.hasNext())
         delete i2.next();
     stack.clear();
 
     temporaryList.clear();
 }
 
 void Synchronizer::reset()
 {
     displayUpdateCount = 0;
     markEquals = markDiffers = markCopyToLeft = markCopyToRight = markDeletable = true;
     stopped = false;
     recurseSubDirs = followSymLinks = ignoreDate = asymmetric = cmpByContent = ignoreCase = autoScroll = false;
     markEquals = markDiffers = markCopyToLeft = markCopyToRight = markDeletable = markDuplicates = markSingles = false;
     leftCopyEnabled = rightCopyEnabled = deleteEnabled = overWrite = autoSkip = paused = false;
     leftCopyNr = rightCopyNr = deleteNr = 0;
     leftCopySize = rightCopySize = deleteSize = 0;
     comparedDirs = fileCount = 0;
     leftBaseDir.clear();
     rightBaseDir.clear();
     clearLists();
 }
 
 int Synchronizer::compare(QString leftURL, QString rightURL, KRQuery *query, bool subDirs,
                           bool symLinks, bool igDate, bool asymm, bool cmpByCnt, bool igCase,
                           bool autoSc, QStringList &selFiles, int equThres, int timeOffs, int parThreads, bool hiddenFiles)
 {
     clearLists();
 
     recurseSubDirs = subDirs;
     followSymLinks = symLinks;
     ignoreDate     = igDate;
     asymmetric     = asymm;
     cmpByContent   = cmpByCnt;
     autoScroll     = autoSc;
     ignoreCase     = igCase;
     selectedFiles  = selFiles;
     equalsThreshold = equThres;
     timeOffset     = timeOffs;
     parallelThreads = parThreads;
     ignoreHidden   = hiddenFiles;
 
     stopped = false;
 
     this->query = query;
 
     leftURL = KUrlCompletion::replacedPath(leftURL, true, true);
     rightURL = KUrlCompletion::replacedPath(rightURL, true, true);
 
     if (!leftURL.endsWith('/'))  leftURL += '/';
     if (!rightURL.endsWith('/')) rightURL += '/';
 
     excludedPaths = KrServices::toStringList(query->dontSearchInDirs());
     for (int i = 0; i != excludedPaths.count(); i++)
         if (excludedPaths[ i ].endsWith('/'))
             excludedPaths[ i ].truncate(excludedPaths[ i ].length() - 1);
 
     comparedDirs = fileCount = 0;
 
-    stack.append(new CompareTask(0, leftBaseDir = leftURL, rightBaseDir = rightURL, "", "", ignoreHidden));
+    stack.append(new CompareTask(nullptr, leftBaseDir = leftURL, rightBaseDir = rightURL, "", "", ignoreHidden));
     compareLoop();
 
     QListIterator<SynchronizerFileItem *> it(temporaryList);
     while (it.hasNext()) {
         SynchronizerFileItem * item = it.next();
 
         if (item->isTemporary())
             delete item;
     }
     temporaryList.clear();
 
 
     if (!autoScroll)
         refresh(true);
 
     emit statusInfo(i18n("Number of files: %1", fileCount));
     return fileCount;
 }
 
 void Synchronizer::compareLoop()
 {
     while (!stopped && !stack.isEmpty()) {
         for (int thread = 0; thread < (int)stack.count() && thread < parallelThreads; thread++) {
             SynchronizerTask * entry = stack.at(thread);
 
             if (entry->state() == ST_STATE_NEW)
                 entry->start(parentWidget);
 
             if (entry->inherits("CompareTask")) {
                 if (entry->state() == ST_STATE_READY) {
-                    CompareTask *ctentry = (CompareTask *) entry;
+                    auto *ctentry = (CompareTask *) entry;
                     if (ctentry->isDuplicate())
                         compareDirectory(ctentry->parent(), ctentry->leftDirList(), ctentry->rightDirList(),
                                          ctentry->leftDir(), ctentry->rightDir());
                     else
                         addSingleDirectory(ctentry->parent(), ctentry->dirList(), ctentry->dir(),
                                            ctentry->isLeft());
                 }
                 if (entry->state() == ST_STATE_READY || entry->state() == ST_STATE_ERROR)
                     comparedDirs++;
             }
             switch (entry->state()) {
             case ST_STATE_STATUS:
                 emit statusInfo(entry->status());
                 break;
             case ST_STATE_READY:
             case ST_STATE_ERROR:
                 emit statusInfo(i18n("Number of compared folders: %1", comparedDirs));
                 stack.removeAll(entry);
                 delete entry;
                 continue;
             default:
                 break;
             }
         }
         if (!stack.isEmpty())
             qApp->processEvents();
     }
 
     QListIterator<SynchronizerTask *> it(stack);
     while (it.hasNext())
         delete it.next();
     stack.clear();
 }
 
 void Synchronizer::compareDirectory(SynchronizerFileItem *parent, SynchronizerDirList * left_directory,
                                     SynchronizerDirList * right_directory, const QString &leftDir,
                                     const QString &rightDir)
 {
     const QString &leftURL = left_directory->url();
     const QString &rightURL = right_directory->url();
     FileItem *left_file;
     FileItem *right_file;
 
     QString file_name;
     bool checkIfSelected = false;
 
     if (leftDir.isEmpty() && rightDir.isEmpty() && selectedFiles.count())
         checkIfSelected = true;
 
     /* walking through in the left directory */
-    for (left_file = left_directory->first(); left_file != 0 && !stopped;
+    for (left_file = left_directory->first(); left_file != nullptr && !stopped;
             left_file = left_directory->next()) {
         if (isDir(left_file))
             continue;
 
         file_name =  left_file->getName();
 
         if (checkIfSelected && !selectedFiles.contains(file_name))
             continue;
 
         if (!query->match(left_file))
             continue;
 
-        if ((right_file = right_directory->search(file_name, ignoreCase)) == 0)
+        if ((right_file = right_directory->search(file_name, ignoreCase)) == nullptr)
             addLeftOnlyItem(parent, file_name, leftDir, left_file->getSize(), left_file->getTime_t(),
                             readLink(left_file), left_file->getOwner(), left_file->getGroup(),
                             left_file->getMode(), left_file->getACL());
         else {
             if (isDir(right_file))
                 continue;
 
             addDuplicateItem(parent, file_name, right_file->getName(), leftDir, rightDir, left_file->getSize(), right_file->getSize(),
                              left_file->getTime_t(), right_file->getTime_t(), readLink(left_file),
                              readLink(right_file), left_file->getOwner(), right_file->getOwner(),
                              left_file->getGroup(), right_file->getGroup(),
                              left_file->getMode(), right_file->getMode(),
                              left_file->getACL(), right_file->getACL());
         }
     }
 
     /* walking through in the right directory */
-    for (right_file = right_directory->first(); right_file != 0 && !stopped;
+    for (right_file = right_directory->first(); right_file != nullptr && !stopped;
             right_file = right_directory->next()) {
         if (isDir(right_file))
             continue;
 
         file_name =  right_file->getName();
 
         if (checkIfSelected && !selectedFiles.contains(file_name))
             continue;
 
         if (!query->match(right_file))
             continue;
 
-        if (left_directory->search(file_name, ignoreCase) == 0)
+        if (left_directory->search(file_name, ignoreCase) == nullptr)
             addRightOnlyItem(parent, file_name, rightDir, right_file->getSize(), right_file->getTime_t(),
                              readLink(right_file), right_file->getOwner(), right_file->getGroup(),
                              right_file->getMode(), right_file->getACL());
     }
 
     /* walking through the subdirectories */
     if (recurseSubDirs) {
-        for (left_file = left_directory->first(); left_file != 0 && !stopped;
+        for (left_file = left_directory->first(); left_file != nullptr && !stopped;
                 left_file = left_directory->next()) {
             if (left_file->isDir() && (followSymLinks || !left_file->isSymLink())) {
                 QString left_file_name =  left_file->getName();
 
                 if (checkIfSelected && !selectedFiles.contains(left_file_name))
                     continue;
 
                 if (excludedPaths.contains(leftDir.isEmpty() ? left_file_name : leftDir + '/' + left_file_name))
                     continue;
 
                 if (!query->matchDirName(left_file_name))
                     continue;
 
-                if ((right_file = right_directory->search(left_file_name, ignoreCase)) == 0) {
+                if ((right_file = right_directory->search(left_file_name, ignoreCase)) == nullptr) {
                     SynchronizerFileItem *me = addLeftOnlyItem(parent, left_file_name, leftDir, 0,
                                                left_file->getTime_t(), readLink(left_file),
                                                left_file->getOwner(), left_file->getGroup(),
                                                left_file->getMode(), left_file->getACL(),
                                                true, !query->match(left_file));
                     stack.append(new CompareTask(me, leftURL + left_file_name + '/',
                                                  leftDir.isEmpty() ? left_file_name : leftDir + '/' + left_file_name, true, ignoreHidden));
                 } else {
                     QString right_file_name =  right_file->getName();
                     SynchronizerFileItem *me = addDuplicateItem(parent, left_file_name, right_file_name,
                                                leftDir, rightDir, 0, 0,
                                                left_file->getTime_t(), right_file->getTime_t(),
                                                readLink(left_file), readLink(right_file),
                                                left_file->getOwner(), right_file->getOwner(),
                                                left_file->getGroup(), right_file->getGroup(),
                                                left_file->getMode(), right_file->getMode(),
                                                left_file->getACL(), right_file->getACL(),
                                                true, !query->match(left_file));
                     stack.append(new CompareTask(me, leftURL + left_file_name + '/', rightURL + right_file_name + '/',
                                                  leftDir.isEmpty() ? left_file_name : leftDir + '/' + left_file_name,
                                                  rightDir.isEmpty() ? right_file_name : rightDir + '/' + right_file_name, ignoreHidden));
                 }
             }
         }
 
         /* walking through the right side subdirectories */
-        for (right_file = right_directory->first(); right_file != 0 && !stopped;
+        for (right_file = right_directory->first(); right_file != nullptr && !stopped;
                 right_file = right_directory->next()) {
             if (right_file->isDir() && (followSymLinks || !right_file->isSymLink())) {
                 file_name =  right_file->getName();
 
                 if (checkIfSelected && !selectedFiles.contains(file_name))
                     continue;
 
                 if (excludedPaths.contains(rightDir.isEmpty() ? file_name : rightDir + '/' + file_name))
                     continue;
 
                 if (!query->matchDirName(file_name))
                     continue;
 
-                if (left_directory->search(file_name, ignoreCase) == 0) {
+                if (left_directory->search(file_name, ignoreCase) == nullptr) {
                     SynchronizerFileItem *me = addRightOnlyItem(parent, file_name, rightDir, 0,
                                                right_file->getTime_t(), readLink(right_file),
                                                right_file->getOwner(), right_file->getGroup(),
                                                right_file->getMode(), right_file->getACL(),
                                                true, !query->match(right_file));
                     stack.append(new CompareTask(me, rightURL + file_name + '/',
                                                  rightDir.isEmpty() ? file_name : rightDir + '/' + file_name, false, ignoreHidden));
                 }
             }
         }
     }
 }
 
 QString Synchronizer::getTaskTypeName(TaskType taskType)
 {
     static QString names[] = {"=", "!=", "<-", "->", "DEL", "?", "?", "?", "?", "?"};
 
     return names[taskType];
 }
 
 SynchronizerFileItem * Synchronizer::addItem(SynchronizerFileItem *parent, const QString &leftFile,
         const QString &rightFile, const QString &leftDir,
         const QString &rightDir, bool existsLeft, bool existsRight,
         KIO::filesize_t leftSize, KIO::filesize_t rightSize,
         time_t leftDate, time_t rightDate, const QString &leftLink,
         const QString &rightLink, const QString &leftOwner,
         const QString &rightOwner, const QString &leftGroup,
         const QString &rightGroup, mode_t leftMode, mode_t rightMode,
         const QString &leftACL, const QString &rightACL, TaskType tsk,
         bool isDir, bool isTemp)
 {
     bool marked = autoScroll ? !isTemp && isMarked(tsk, existsLeft && existsRight) : false;
-    SynchronizerFileItem *item = new SynchronizerFileItem(leftFile, rightFile, leftDir, rightDir, marked,
+    auto *item = new SynchronizerFileItem(leftFile, rightFile, leftDir, rightDir, marked,
             existsLeft, existsRight, leftSize, rightSize, leftDate, rightDate, leftLink, rightLink,
             leftOwner, rightOwner, leftGroup, rightGroup, leftMode, rightMode, leftACL, rightACL, tsk, isDir,
             isTemp, parent);
 
     if (!isTemp) {
         while (parent && parent->isTemporary())
             setPermanent(parent);
 
         bool doRefresh = false;
 
         if (marked) {
             fileCount++;
             if (autoScroll && markParentDirectories(item))
                 doRefresh = true;
         }
 
         resultList.append(item);
         emit comparedFileData(item);
 
         if (doRefresh)
             refresh(true);
 
         if (marked && (displayUpdateCount++ % DISPLAY_UPDATE_PERIOD == (DISPLAY_UPDATE_PERIOD - 1)))
             qApp->processEvents();
     } else
         temporaryList.append(item);
 
     return item;
 }
 
 void Synchronizer::compareContentResult(SynchronizerFileItem * item, bool res)
 {
     item->compareContentResult(res);
     bool marked = autoScroll ? isMarked(item->task(), item->existsInLeft() && item->existsInRight()) : false;
     item->setMarked(marked);
     if (marked) {
         markParentDirectories(item);
         fileCount++;
         emit markChanged(item, true);
     }
 }
 
 void Synchronizer::setPermanent(SynchronizerFileItem *item)
 {
     if (item->parent() && item->parent()->isTemporary())
         setPermanent(item->parent());
 
     item->setPermanent();
     resultList.append(item);
     emit comparedFileData(item);
 }
 
 SynchronizerFileItem * Synchronizer::addLeftOnlyItem(SynchronizerFileItem *parent,
         const QString &file_name, const QString &dir, KIO::filesize_t size,
         time_t date, const QString &link, const QString &owner,
         const QString &group, mode_t mode, const QString &acl, bool isDir,
         bool isTemp)
 {
     return addItem(parent, file_name, file_name, dir, dir, true, false, size, 0, date, 0, link, QString(),
                    owner, QString(), group, QString(), mode, (mode_t) - 1, acl, QString(),
                    asymmetric ? TT_DELETE : TT_COPY_TO_RIGHT, isDir, isTemp);
 }
 
 SynchronizerFileItem * Synchronizer::addRightOnlyItem(SynchronizerFileItem *parent,
         const QString &file_name, const QString &dir, KIO::filesize_t size,
         time_t date, const QString &link, const QString &owner,
         const QString &group, mode_t mode, const QString &acl, bool isDir,
         bool isTemp)
 {
     return addItem(parent, file_name, file_name, dir, dir, false, true, 0, size, 0, date, QString(), link,
                    QString(), owner, QString(), group, (mode_t) - 1, mode, QString(), acl,
                    TT_COPY_TO_LEFT, isDir, isTemp);
 }
 
 SynchronizerFileItem * Synchronizer::addDuplicateItem(SynchronizerFileItem *parent,
         const QString &leftName, const QString &rightName,
         const QString &leftDir, const QString &rightDir,
         KIO::filesize_t leftSize, KIO::filesize_t rightSize, time_t leftDate, time_t rightDate,
         const QString &leftLink, const QString &rightLink,
         const QString &leftOwner, const QString &rightOwner,
         const QString &leftGroup, const QString &rightGroup,
         mode_t leftMode, mode_t rightMode,
         const QString &leftACL, const QString &rightACL,
         bool isDir, bool isTemp)
 {
     TaskType        task;
 
     int checkedRightDate = rightDate - timeOffset;
     int uncertain = 0;
 
     do {
         if (isDir) {
             task = TT_EQUALS;
             break;
         }
         if (leftSize == rightSize) {
             if (!leftLink.isNull() || !rightLink.isNull()) {
                 if (leftLink == rightLink) {
                     task = TT_EQUALS;
                     break;
                 }
             } else if (cmpByContent)
                 uncertain = TT_UNKNOWN;
             else {
                 if (ignoreDate || leftDate == checkedRightDate) {
                     task = TT_EQUALS;
                     break;
                 }
                 time_t diff = (leftDate > checkedRightDate) ? leftDate - checkedRightDate : checkedRightDate - leftDate;
                 if (diff <= equalsThreshold) {
                     task = TT_EQUALS;
                     break;
                 }
             }
         }
 
         if (asymmetric)
             task = TT_COPY_TO_LEFT;
         else if (ignoreDate)
             task = TT_DIFFERS;
         else if (leftDate > checkedRightDate)
             task = TT_COPY_TO_RIGHT;
         else if (leftDate < checkedRightDate)
             task = TT_COPY_TO_LEFT;
         else
             task = TT_DIFFERS;
 
     } while (false);
 
     SynchronizerFileItem * item = addItem(parent, leftName, rightName, leftDir, rightDir, true, true,
                                           leftSize, rightSize, leftDate, rightDate, leftLink, rightLink,
                                           leftOwner, rightOwner, leftGroup, rightGroup,
                                           leftMode, rightMode, leftACL, rightACL,
                                           (TaskType)(task + uncertain), isDir, isTemp);
 
     if (uncertain == TT_UNKNOWN) {
         QUrl leftURL = Synchronizer::fsUrl(leftDir.isEmpty() ? leftBaseDir + leftName : leftBaseDir + leftDir + '/' + leftName);
         QUrl rightURL = Synchronizer::fsUrl(rightDir.isEmpty() ? rightBaseDir + rightName : rightBaseDir + rightDir + '/' + rightName);
         stack.append(new CompareContentTask(this, item, leftURL, rightURL, leftSize));
     }
 
     return item;
 }
 
 void Synchronizer::addSingleDirectory(SynchronizerFileItem *parent, SynchronizerDirList *directory,
                                       const QString &dirName, bool isLeft)
 {
     const QString &url = directory->url();
     FileItem *file;
     QString file_name;
 
     /* walking through the directory files */
-    for (file = directory->first(); file != 0 && !stopped; file = directory->next()) {
+    for (file = directory->first(); file != nullptr && !stopped; file = directory->next()) {
         if (isDir(file))
             continue;
 
         file_name =  file->getName();
 
         if (!query->match(file))
             continue;
 
         if (isLeft)
             addLeftOnlyItem(parent, file_name, dirName, file->getSize(), file->getTime_t(), readLink(file),
                             file->getOwner(), file->getGroup(), file->getMode(), file->getACL());
         else
             addRightOnlyItem(parent, file_name, dirName, file->getSize(), file->getTime_t(), readLink(file),
                              file->getOwner(), file->getGroup(), file->getMode(), file->getACL());
     }
 
     /* walking through the subdirectories */
-    for (file = directory->first(); file != 0 && !stopped; file = directory->next()) {
+    for (file = directory->first(); file != nullptr && !stopped; file = directory->next()) {
         if (file->isDir() && (followSymLinks || !file->isSymLink())) {
             file_name =  file->getName();
 
             if (excludedPaths.contains(dirName.isEmpty() ? file_name : dirName + '/' + file_name))
                 continue;
 
             if (!query->matchDirName(file_name))
                 continue;
 
             SynchronizerFileItem *me;
 
             if (isLeft)
                 me = addLeftOnlyItem(parent, file_name, dirName, 0, file->getTime_t(), readLink(file),
                                      file->getOwner(), file->getGroup(), file->getMode(),
                                      file->getACL(), true, !query->match(file));
             else
                 me = addRightOnlyItem(parent, file_name, dirName, 0, file->getTime_t(), readLink(file),
                                       file->getOwner(), file->getGroup(), file->getMode(),
                                       file->getACL(), true, !query->match(file));
             stack.append(new CompareTask(me, url + file_name + '/',
                                          dirName.isEmpty() ? file_name : dirName + '/' + file_name, isLeft, ignoreHidden));
         }
     }
 }
 
 void Synchronizer::setMarkFlags(bool left, bool equal, bool differs, bool right, bool dup, bool sing,
                                 bool del)
 {
     markEquals      = equal;
     markDiffers     = differs;
     markCopyToLeft  = left;
     markCopyToRight = right;
     markDeletable   = del;
     markDuplicates  = dup;
     markSingles     = sing;
 }
 
 bool Synchronizer::isMarked(TaskType task, bool isDuplicate)
 {
     if ((isDuplicate && !markDuplicates) || (!isDuplicate && !markSingles))
         return false;
 
     switch (task) {
     case TT_EQUALS:
         return markEquals;
     case TT_DIFFERS:
         return markDiffers;
     case TT_COPY_TO_LEFT:
         return markCopyToLeft;
     case TT_COPY_TO_RIGHT:
         return markCopyToRight;
     case TT_DELETE:
         return markDeletable;
     default:
         return false;
     }
 }
 
 bool Synchronizer::markParentDirectories(SynchronizerFileItem *item)
 {
-    if (item->parent() == 0 || item->parent()->isMarked())
+    if (item->parent() == nullptr || item->parent()->isMarked())
         return false;
 
     markParentDirectories(item->parent());
 
     item->parent()->setMarked(true);
 
     fileCount++;
     emit markChanged(item->parent(), false);
     return true;
 }
 
 int Synchronizer::refresh(bool nostatus)
 {
     fileCount = 0;
 
     QListIterator<SynchronizerFileItem *> it(resultList);
     while (it.hasNext()) {
         SynchronizerFileItem * item = it.next();
 
         bool marked = isMarked(item->task(), item->existsInLeft() && item->existsInRight());
         item->setMarked(marked);
 
         if (marked) {
             markParentDirectories(item);
             fileCount++;
         }
     }
 
     it.toFront();
     while (it.hasNext()) {
         SynchronizerFileItem * item = it.next();
         emit markChanged(item, false);
     }
 
     if (!nostatus)
         emit statusInfo(i18n("Number of files: %1", fileCount));
 
     return fileCount;
 }
 
 void Synchronizer::operate(SynchronizerFileItem *item,
                            void (*executeOperation)(SynchronizerFileItem *))
 {
     executeOperation(item);
 
     if (item->isDir()) {
         QString leftDirName = (item->leftDirectory().isEmpty()) ?
                               item->leftName() : item->leftDirectory() + '/' + item->leftName();
         QString rightDirName = (item->rightDirectory().isEmpty()) ?
                                item->rightName() : item->rightDirectory() + '/' + item->rightName();
 
         QListIterator<SynchronizerFileItem *> it(resultList);
         while (it.hasNext()) {
             SynchronizerFileItem * item = it.next();
 
             if (item->leftDirectory() == leftDirName || item->leftDirectory().startsWith(leftDirName + '/') ||
                     item->rightDirectory() == rightDirName || item->rightDirectory().startsWith(rightDirName + '/'))
                 executeOperation(item);
         }
     }
 }
 
 void Synchronizer::excludeOperation(SynchronizerFileItem *item)
 {
     item->setTask(TT_DIFFERS);
 }
 
 void Synchronizer::exclude(SynchronizerFileItem *item)
 {
     if (!item->parent() || item->parent()->task() != TT_DELETE)
         operate(item, excludeOperation);    /* exclude only if the parent task is not DEL */
 }
 
 void Synchronizer::restoreOperation(SynchronizerFileItem *item)
 {
     item->restoreOriginalTask();
 }
 
 void Synchronizer::restore(SynchronizerFileItem *item)
 {
     operate(item, restoreOperation);
 
-    while ((item = item->parent()) != 0)    /* in case of restore, the parent directories */
+    while ((item = item->parent()) != nullptr)    /* in case of restore, the parent directories */
     {                                          /* must be changed for being consistent */
         if (item->task() != TT_DIFFERS)
             break;
 
         if (item->originalTask() == TT_DELETE)  /* if the parent original task is delete */
             break;                                    /* don't touch it */
 
         item->restoreOriginalTask();          /* restore */
     }
 }
 
 void Synchronizer::reverseDirectionOperation(SynchronizerFileItem *item)
 {
     if (item->existsInRight() && item->existsInLeft()) {
         if (item->task() == TT_COPY_TO_LEFT)
             item->setTask(TT_COPY_TO_RIGHT);
         else if (item->task() == TT_COPY_TO_RIGHT)
             item->setTask(TT_COPY_TO_LEFT);
     }
 }
 
 void Synchronizer::reverseDirection(SynchronizerFileItem *item)
 {
     operate(item, reverseDirectionOperation);
 }
 
 void Synchronizer::deleteLeftOperation(SynchronizerFileItem *item)
 {
     if (!item->existsInRight() && item->existsInLeft())
         item->setTask(TT_DELETE);
 }
 
 void Synchronizer::deleteLeft(SynchronizerFileItem *item)
 {
     operate(item, deleteLeftOperation);
 }
 
 void Synchronizer::copyToLeftOperation(SynchronizerFileItem *item)
 {
     if (item->existsInRight()) {
         if (!item->isDir())
             item->setTask(TT_COPY_TO_LEFT);
         else {
             if (item->existsInLeft() && item->existsInRight())
                 item->setTask(TT_EQUALS);
             else if (!item->existsInLeft() && item->existsInRight())
                 item->setTask(TT_COPY_TO_LEFT);
         }
     }
 }
 
 void Synchronizer::copyToLeft(SynchronizerFileItem *item)
 {
     operate(item, copyToLeftOperation);
 
-    while ((item = item->parent()) != 0) {
+    while ((item = item->parent()) != nullptr) {
         if (item->task() != TT_DIFFERS)
             break;
 
         if (item->existsInLeft() && item->existsInRight())
             item->setTask(TT_EQUALS);
         else if (!item->existsInLeft() && item->existsInRight())
             item->setTask(TT_COPY_TO_LEFT);
     }
 }
 
 void Synchronizer::copyToRightOperation(SynchronizerFileItem *item)
 {
     if (item->existsInLeft()) {
         if (!item->isDir())
             item->setTask(TT_COPY_TO_RIGHT);
         else {
             if (item->existsInLeft() && item->existsInRight())
                 item->setTask(TT_EQUALS);
             else if (item->existsInLeft() && !item->existsInRight())
                 item->setTask(TT_COPY_TO_RIGHT);
         }
     }
 }
 
 void Synchronizer::copyToRight(SynchronizerFileItem *item)
 {
     operate(item, copyToRightOperation);
 
-    while ((item = item->parent()) != 0) {
+    while ((item = item->parent()) != nullptr) {
         if (item->task() != TT_DIFFERS && item->task() != TT_DELETE)
             break;
 
         if (item->existsInLeft() && item->existsInRight())
             item->setTask(TT_EQUALS);
         else if (item->existsInLeft() && !item->existsInRight())
             item->setTask(TT_COPY_TO_RIGHT);
     }
 }
 
 bool Synchronizer::totalSizes(int * leftCopyNr, KIO::filesize_t *leftCopySize, int * rightCopyNr,
                               KIO::filesize_t *rightCopySize, int *deleteNr, KIO::filesize_t *deletableSize)
 {
     bool hasAnythingToDo = false;
 
     *leftCopySize = *rightCopySize = *deletableSize = 0;
     *leftCopyNr = *rightCopyNr = *deleteNr = 0;
 
     QListIterator<SynchronizerFileItem *> it(resultList);
     while (it.hasNext()) {
         SynchronizerFileItem * item = it.next();
 
         if (item->isMarked()) {
             switch (item->task()) {
             case TT_COPY_TO_LEFT:
                 *leftCopySize += item->rightSize();
                 (*leftCopyNr)++;
                 hasAnythingToDo = true;
                 break;
             case TT_COPY_TO_RIGHT:
                 *rightCopySize += item->leftSize();
                 (*rightCopyNr)++;
                 hasAnythingToDo = true;
                 break;
             case TT_DELETE:
                 *deletableSize += item->leftSize();
                 (*deleteNr)++;
                 hasAnythingToDo = true;
                 break;
             default:
                 break;
             }
         }
     }
 
     return hasAnythingToDo;
 }
 
 void Synchronizer::swapSides()
 {
     QString leftTmp = leftBaseDir;
     leftBaseDir = rightBaseDir;
     rightBaseDir = leftTmp;
 
     QListIterator<SynchronizerFileItem *> it(resultList);
     while (it.hasNext()) {
         SynchronizerFileItem * item = it.next();
 
         item->swap(asymmetric);
     }
 }
 
 void Synchronizer::setScrolling(bool scroll)
 {
     autoScroll = scroll;
     if (autoScroll) {
         int oldFileCount = fileCount;
         refresh(true);
         fileCount = oldFileCount;
     }
 }
 
 void Synchronizer::synchronize(QWidget *syncWdg, bool leftCopyEnabled, bool rightCopyEnabled,
                                bool deleteEnabled, bool overWrite, int parThreads)
 {
     this->leftCopyEnabled   = leftCopyEnabled;
     this->rightCopyEnabled  = rightCopyEnabled;
     this->deleteEnabled     = deleteEnabled;
     this->overWrite         = overWrite;
     this->parallelThreads   = parThreads;
     this->syncDlgWidget     = syncWdg;
 
     autoSkip = paused = disableNewTasks = false;
 
     leftCopyNr = rightCopyNr = deleteNr = 0;
     leftCopySize = rightCopySize = deleteSize = 0;
 
     inTaskFinished = 0;
-    lastTask = 0;
+    lastTask = nullptr;
 
     jobMap.clear();
     receivedMap.clear();
 
     resultListIt = resultList;
     synchronizeLoop();
 }
 
 void Synchronizer::synchronizeLoop()
 {
     if (disableNewTasks) {
         if (!resultListIt.hasNext() && jobMap.count() == 0)
             emit synchronizationFinished();
         return;
     }
 
     while ((int)jobMap.count() < parallelThreads) {
         SynchronizerFileItem *task = getNextTask();
-        if (task == 0) {
+        if (task == nullptr) {
             if (jobMap.count() == 0)
                 emit synchronizationFinished();
             return;
         }
         executeTask(task);
         if (disableNewTasks)
             break;
     }
 }
 
 SynchronizerFileItem * Synchronizer::getNextTask()
 {
     TaskType task;
     SynchronizerFileItem * currentTask;
 
     do {
         if (!resultListIt.hasNext())
-            return 0;
+            return nullptr;
 
         currentTask = resultListIt.next();
 
         if (currentTask->isMarked()) {
             task = currentTask->task();
 
             if (leftCopyEnabled && task == TT_COPY_TO_LEFT)
                 break;
             else if (rightCopyEnabled && task == TT_COPY_TO_RIGHT)
                 break;
             else if (deleteEnabled && task == TT_DELETE)
                 break;
         }
     } while (true);
 
     return lastTask = currentTask;
 }
 
 
 void Synchronizer::executeTask(SynchronizerFileItem * task)
 {
     QString leftDirName = task->leftDirectory();
     if (!leftDirName.isEmpty())
         leftDirName += '/';
     QString rightDirName = task->rightDirectory();
     if (!rightDirName.isEmpty())
         rightDirName += '/';
 
     QUrl leftURL = Synchronizer::fsUrl(leftBaseDir + leftDirName + task->leftName());
     QUrl rightURL = Synchronizer::fsUrl(rightBaseDir + rightDirName + task->rightName());
 
     switch (task->task()) {
     case TT_COPY_TO_LEFT:
         if (task->isDir()) {
             KIO::SimpleJob *job = KIO::mkdir(leftURL);
             connect(job, &KIO::MkdirJob::result, this, &Synchronizer::slotTaskFinished);
             jobMap[ job ] = task;
             disableNewTasks = true;
         } else {
             QUrl destURL(leftURL);
             if (!task->destination().isNull())
                 destURL = Synchronizer::fsUrl(task->destination());
 
             if (task->rightLink().isNull()) {
                 KIO::FileCopyJob *job = KIO::file_copy(rightURL, destURL, -1,
                                                        ((overWrite || task->overWrite()) ? KIO::Overwrite : KIO::DefaultFlags) | KIO::HideProgressInfo);
                 connect(job, SIGNAL(processedSize(KJob*,qulonglong)), this,
                         SLOT(slotProcessedSize(KJob*,qulonglong)));
                 connect(job, &KIO::FileCopyJob::result, this, &Synchronizer::slotTaskFinished);
                 jobMap[ job ] = task;
             } else {
                 KIO::SimpleJob *job = KIO::symlink(task->rightLink(), destURL,
                                                    ((overWrite || task->overWrite()) ? KIO::Overwrite : KIO::DefaultFlags) | KIO::HideProgressInfo);
                 connect(job, &KIO::SimpleJob::result, this, &Synchronizer::slotTaskFinished);
                 jobMap[ job ] = task;
             }
         }
         break;
     case TT_COPY_TO_RIGHT:
         if (task->isDir()) {
             KIO::SimpleJob *job = KIO::mkdir(rightURL);
             connect(job, &KIO::SimpleJob::result, this, &Synchronizer::slotTaskFinished);
             jobMap[ job ] = task;
             disableNewTasks = true;
         } else {
             QUrl destURL(rightURL);
             if (!task->destination().isNull())
                 destURL = Synchronizer::fsUrl(task->destination());
 
             if (task->leftLink().isNull()) {
                 KIO::FileCopyJob *job = KIO::file_copy(leftURL, destURL, -1,
                                                        ((overWrite || task->overWrite()) ? KIO::Overwrite : KIO::DefaultFlags) | KIO::HideProgressInfo);
                 connect(job, SIGNAL(processedSize(KJob*,qulonglong)), this,
                         SLOT(slotProcessedSize(KJob*,qulonglong)));
                 connect(job, &KIO::FileCopyJob::result, this, &Synchronizer::slotTaskFinished);
                 jobMap[ job ] = task;
             } else {
                 KIO::SimpleJob *job = KIO::symlink(task->leftLink(), destURL,
                                                    ((overWrite || task->overWrite()) ? KIO::Overwrite : KIO::DefaultFlags) | KIO::HideProgressInfo);
                 connect(job, &KIO::SimpleJob::result, this, &Synchronizer::slotTaskFinished);
                 jobMap[ job ] = task;
             }
         }
         break;
     case TT_DELETE: {
         KIO::DeleteJob *job = KIO::del(leftURL, KIO::DefaultFlags);
         connect(job, &KIO::DeleteJob::result, this, &Synchronizer::slotTaskFinished);
         jobMap[ job ] = task;
     }
     break;
     default:
         break;
     }
 }
 
 void Synchronizer::slotTaskFinished(KJob *job)
 {
     inTaskFinished++;
 
     SynchronizerFileItem * item = jobMap[ job ];
     jobMap.remove(job);
 
     KIO::filesize_t receivedSize = 0;
 
     if (receivedMap.contains(job)) {
         receivedSize = receivedMap[ job ];
         receivedMap.remove(job);
     }
 
     if (disableNewTasks && item == lastTask)
         disableNewTasks = false; // the blocker task finished
 
     QString leftDirName     = item->leftDirectory().isEmpty() ? "" : item->leftDirectory() + '/';
     QString rightDirName     = item->rightDirectory().isEmpty() ? "" : item->rightDirectory() + '/';
     QUrl leftURL = Synchronizer::fsUrl(leftBaseDir + leftDirName + item->leftName());
     QUrl rightURL = Synchronizer::fsUrl(rightBaseDir + rightDirName + item->rightName());
 
     do {
         if (!job->error()) {
             switch (item->task()) {
             case TT_COPY_TO_LEFT:
                 if (leftURL.isLocalFile()) {
                     struct utimbuf timestamp;
 
-                    timestamp.actime = time(0);
+                    timestamp.actime = time(nullptr);
                     timestamp.modtime = item->rightDate() - timeOffset;
 
                     utime((const char *)(leftURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit()), &timestamp);
 
-                    uid_t newOwnerID = (uid_t) - 1; // chown(2) : -1 means no change
+                    auto newOwnerID = (uid_t) - 1; // chown(2) : -1 means no change
                     if (!item->rightOwner().isEmpty()) {
                         struct passwd* pw = getpwnam(QFile::encodeName(item->rightOwner()));
-                        if (pw != 0L)
+                        if (pw != nullptr)
                             newOwnerID = pw->pw_uid;
                     }
-                    gid_t newGroupID = (gid_t) - 1; // chown(2) : -1 means no change
+                    auto newGroupID = (gid_t) - 1; // chown(2) : -1 means no change
                     if (!item->rightGroup().isEmpty()) {
                         struct group* g = getgrnam(QFile::encodeName(item->rightGroup()));
-                        if (g != 0L)
+                        if (g != nullptr)
                             newGroupID = g->gr_gid;
                     }
                     int status1 = chown((const char *)(leftURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit()), newOwnerID, (gid_t) - 1);
                     int status2 = chown((const char *)(leftURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit()), (uid_t) - 1, newGroupID);
                     if (status1 < 0 || status2 < 0) {
                         // synchronizer currently ignores chown errors
                     }
 
                     chmod((const char *)(leftURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit()), item->rightMode() & 07777);
 
 #ifdef HAVE_POSIX_ACL
                     if (!item->rightACL().isNull()) {
                         acl_t acl = acl_from_text(item->rightACL().toLatin1());
                         if (acl && !acl_valid(acl))
                             acl_set_file(leftURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit(), ACL_TYPE_ACCESS, acl);
                         if (acl)
                             acl_free(acl);
                     }
 #endif
                 }
                 break;
             case TT_COPY_TO_RIGHT:
                 if (rightURL.isLocalFile()) {
                     struct utimbuf timestamp;
 
-                    timestamp.actime = time(0);
+                    timestamp.actime = time(nullptr);
                     timestamp.modtime = item->leftDate() + timeOffset;
 
                     utime((const char *)(rightURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit()), &timestamp);
 
-                    uid_t newOwnerID = (uid_t) - 1; // chown(2) : -1 means no change
+                    auto newOwnerID = (uid_t) - 1; // chown(2) : -1 means no change
                     if (!item->leftOwner().isEmpty()) {
                         struct passwd* pw = getpwnam(QFile::encodeName(item->leftOwner()));
-                        if (pw != 0L)
+                        if (pw != nullptr)
                             newOwnerID = pw->pw_uid;
                     }
-                    gid_t newGroupID = (gid_t) - 1; // chown(2) : -1 means no change
+                    auto newGroupID = (gid_t) - 1; // chown(2) : -1 means no change
                     if (!item->leftGroup().isEmpty()) {
                         struct group* g = getgrnam(QFile::encodeName(item->leftGroup()));
-                        if (g != 0L)
+                        if (g != nullptr)
                             newGroupID = g->gr_gid;
                     }
                     int status1 = chown((const char *)(rightURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit()), newOwnerID, (uid_t) - 1);
                     int status2 = chown((const char *)(rightURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit()), (uid_t) - 1, newGroupID);
                     if (status1 < 0 || status2 < 0) {
                         // synchronizer currently ignores chown errors
                     }
 
                     chmod((const char *)(rightURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit()), item->leftMode() & 07777);
 
 #ifdef HAVE_POSIX_ACL
                     if (!item->leftACL().isNull()) {
                         acl_t acl = acl_from_text(item->leftACL().toLatin1());
                         if (acl && !acl_valid(acl))
                             acl_set_file(rightURL.adjusted(QUrl::StripTrailingSlash).path().toLocal8Bit(), ACL_TYPE_ACCESS, acl);
                         if (acl)
                             acl_free(acl);
                     }
 #endif
                 }
                 break;
             default:
                 break;
             }
         } else {
             if (job->error() == KIO::ERR_FILE_ALREADY_EXIST && item->task() != TT_DELETE) {
                 KIO::RenameDialog_Result result;
                 QString newDest;
 
                 if (autoSkip)
                     break;
 
-                KIO::JobUiDelegate *ui = static_cast<KIO::JobUiDelegate*>(job->uiDelegate());
+                auto *ui = dynamic_cast<KIO::JobUiDelegate*>(job->uiDelegate());
                 ui->setWindow(syncDlgWidget);
 
                 if (item->task() == TT_COPY_TO_LEFT) {
                     result =
                         ui->askFileRename(job, i18n("File Already Exists"), rightURL, leftURL,
                                           KIO::RenameDialog_Overwrite | KIO::RenameDialog_Skip |
                                               KIO::RenameDialog_MultipleItems,
                                           newDest, item->rightSize(), item->leftSize(), QDateTime(),
                                           QDateTime(), QDateTime::fromTime_t(item->rightDate()),
                                           QDateTime::fromTime_t(item->leftDate()));
                 } else {
                     result =
                         ui->askFileRename(job, i18n("File Already Exists"), leftURL, rightURL,
                                           KIO::RenameDialog_Overwrite | KIO::RenameDialog_Skip |
                                               KIO::RenameDialog_MultipleItems,
                                           newDest, item->leftSize(), item->rightSize(), QDateTime(),
                                           QDateTime(), QDateTime::fromTime_t(item->leftDate()),
                                           QDateTime::fromTime_t(item->rightDate()));
                 }
 
                 switch (result) {
                 case KIO::R_RENAME:
                     item->setDestination(newDest);
                     executeTask(item);
                     inTaskFinished--;
                     return;
                 case KIO::R_OVERWRITE:
                     item->setOverWrite();
                     executeTask(item);
                     inTaskFinished--;
                     return;
                 case KIO::R_OVERWRITE_ALL:
                     overWrite = true;
                     executeTask(item);
                     inTaskFinished--;
                     return;
                 case KIO::R_AUTO_SKIP:
                     autoSkip = true;
                 case KIO::R_SKIP:
                 default:
                     break;
                 }
                 break;
             }
 
             if (job->error() != KIO::ERR_DOES_NOT_EXIST || item->task() != TT_DELETE) {
                 if (autoSkip)
                     break;
 
                 QString error;
 
                 switch (item->task()) {
                 case TT_COPY_TO_LEFT:
                     error = i18n("Error at copying file %1 to %2.",
                                  rightURL.toDisplayString(QUrl::PreferLocalFile),
                                  leftURL.toDisplayString(QUrl::PreferLocalFile));
                     break;
                 case TT_COPY_TO_RIGHT:
                     error = i18n("Error at copying file %1 to %2.",
                                  leftURL.toDisplayString(QUrl::PreferLocalFile),
                                  rightURL.toDisplayString(QUrl::PreferLocalFile));
                     break;
                 case TT_DELETE:
                     error = i18n("Error at deleting file %1.", leftURL.toDisplayString(QUrl::PreferLocalFile));
                     break;
                 default:
                     break;
                 }
 
-                KIO::JobUiDelegate *ui = static_cast<KIO::JobUiDelegate*>(job->uiDelegate());
+                auto *ui = dynamic_cast<KIO::JobUiDelegate*>(job->uiDelegate());
                 ui->setWindow(syncDlgWidget);
 
                 KIO::SkipDialog_Result result = ui->askSkip(job, KIO::SkipDialog_MultipleItems, error);
 
                 switch (result) {
                 case KIO::S_CANCEL:
                     executeTask(item);    /* simply retry */
                     inTaskFinished--;
                     return;
                 case KIO::S_AUTO_SKIP:
                     autoSkip = true;
                 default:
                     break;
                 }
             }
         }
     } while (false);
 
     switch (item->task()) {
     case TT_COPY_TO_LEFT:
         leftCopyNr++;
         leftCopySize += item->rightSize() - receivedSize;
         break;
     case TT_COPY_TO_RIGHT:
         rightCopyNr++;
         rightCopySize += item->leftSize() - receivedSize;
         break;
     case TT_DELETE:
         deleteNr++;
         deleteSize += item->leftSize() - receivedSize;
         break;
     default:
         break;
     }
 
     emit processedSizes(leftCopyNr, leftCopySize, rightCopyNr, rightCopySize, deleteNr, deleteSize);
 
     if (--inTaskFinished == 0) {
         if (paused)
             emit pauseAccepted();
         else
             synchronizeLoop();
     }
 }
 
 void Synchronizer::slotProcessedSize(KJob * job , qulonglong size)
 {
     KIO::filesize_t dl = 0, dr = 0, dd = 0;
     SynchronizerFileItem * item = jobMap[ job ];
 
     KIO::filesize_t lastProcessedSize = 0;
     if (receivedMap.contains(job))
         lastProcessedSize = receivedMap[ job ];
 
     receivedMap[ job ] = size;
 
     switch (item->task()) {
     case TT_COPY_TO_LEFT:
         dl = size - lastProcessedSize;
         break;
     case TT_COPY_TO_RIGHT:
         dr = size - lastProcessedSize;
         break;
     case TT_DELETE:
         dd = size - lastProcessedSize;
         break;
     default:
         break;
     }
 
     emit processedSizes(leftCopyNr, leftCopySize += dl, rightCopyNr, rightCopySize += dr, deleteNr, deleteSize += dd);
 }
 
 void Synchronizer::pause()
 {
     paused = true;
 }
 
 void Synchronizer::resume()
 {
     paused = false;
     synchronizeLoop();
 }
 
 QString Synchronizer::leftBaseDirectory()
 {
     return leftBaseDir;
 }
 
 QString Synchronizer::rightBaseDirectory()
 {
     return rightBaseDir;
 }
 
 KgetProgressDialog::KgetProgressDialog(QWidget *parent, const QString &caption,
                                        const QString &text, bool modal) : QDialog(parent)
 {
     if (caption.isEmpty())
         setWindowTitle(caption);
     setModal(modal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     mainLayout->addWidget(new QLabel(text));
 
     mProgressBar = new QProgressBar;
     mainLayout->addWidget(mProgressBar);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Cancel);
     mainLayout->addWidget(buttonBox);
 
     mPauseButton = new QPushButton(i18n("Pause"));
     buttonBox->addButton(mPauseButton, QDialogButtonBox::ActionRole);
     buttonBox->button(QDialogButtonBox::Cancel)->setDefault(true);
 
     connect(mPauseButton, &QPushButton::clicked, this, &KgetProgressDialog::slotPause);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KgetProgressDialog::slotCancel);
 
     mCancelled = mPaused = false;
 }
 
 void KgetProgressDialog::slotPause()
 {
     if ((mPaused = !mPaused) == false)
         mPauseButton->setText(i18n("Pause"));
     else
         mPauseButton->setText(i18n("Resume"));
 }
 
 void KgetProgressDialog::slotCancel()
 {
     mCancelled = true;
     reject();
 }
 
 
 void Synchronizer::synchronizeWithKGet()
 {
     bool isLeftLocal = QUrl::fromUserInput(leftBaseDirectory(), QString(), QUrl::AssumeLocalFile).isLocalFile();
-    KgetProgressDialog *progDlg = 0;
+    KgetProgressDialog *progDlg = nullptr;
     int  processedCount = 0, totalCount = 0;
 
     QListIterator<SynchronizerFileItem *> it(resultList);
     while (it.hasNext())
         if (it.next()->isMarked())
             totalCount++;
 
     it.toFront();
     while (it.hasNext()) {
         SynchronizerFileItem * item = it.next();
 
         if (item->isMarked()) {
             QUrl downloadURL;
             QUrl destURL;
             QString destDir;
             QString leftDirName = item->leftDirectory().isEmpty() ? "" : item->leftDirectory() + '/';
             QString rightDirName = item->rightDirectory().isEmpty() ? "" : item->rightDirectory() + '/';
 
-            if (progDlg == 0) {
+            if (progDlg == nullptr) {
                 progDlg = new KgetProgressDialog(krMainWindow, i18n("Krusader::Synchronizer"),
                                                  i18n("Feeding the URLs to KGet"), true);
                 progDlg->progressBar()->setMaximum(totalCount);
                 progDlg->show();
                 qApp->processEvents();
             }
 
             if (item->task() == TT_COPY_TO_RIGHT && !isLeftLocal) {
                 downloadURL = Synchronizer::fsUrl(leftBaseDirectory() + leftDirName + item->leftName());
                 destDir     = rightBaseDirectory() + rightDirName;
                 destURL     = Synchronizer::fsUrl(destDir + item->rightName());
 
                 if (item->isDir())
                     destDir += item->leftName();
             }
             if (item->task() == TT_COPY_TO_LEFT && isLeftLocal) {
                 downloadURL = Synchronizer::fsUrl(rightBaseDirectory() + rightDirName + item->rightName());
                 destDir     = leftBaseDirectory() + leftDirName;
                 destURL     = Synchronizer::fsUrl(destDir + item->leftName());
 
                 if (item->isDir())
                     destDir += item->rightName();
             }
 
             // creating the directory system
             for (int i = 0; i >= 0 ; i = destDir.indexOf('/', i + 1))
                 if (!QDir(destDir.left(i)).exists())
                     QDir().mkdir(destDir.left(i));
 
             if (!item->isDir() && !downloadURL.isEmpty()) {
                 if (QFile(destURL.path()).exists())
                     QFile(destURL.path()).remove();
 
                 QString source = downloadURL.toDisplayString();
                 if (source.indexOf('@') >= 2) {  /* is this an ftp proxy URL? */
                     int lastAt = source.lastIndexOf('@');
                     QString startString = source.left(lastAt);
                     QString endString = source.mid(lastAt);
                     startString.replace('@', "%40");
                     source = startString + endString;
                 }
 
                 KProcess p;
 
                 p << KrServices::fullPathName("kget") << source << destURL.path();
                 if (!p.startDetached())
                     KMessageBox::error(parentWidget, i18n("Error executing %1.", KrServices::fullPathName("kget")));
             }
 
             progDlg->progressBar()->setValue(++processedCount);
 
             QTime t;
             t.start();
             bool canExit = false;
 
             do {
                 qApp->processEvents();
 
                 if (progDlg->wasCancelled())
                     break;
 
                 canExit = (t.elapsed() > 100);
 
                 if (progDlg->isPaused() || !canExit)
                     usleep(10000);
 
             } while (progDlg->isPaused() || !canExit);
 
             if (progDlg->wasCancelled())
                 break;
         }
     }
 
     if (progDlg)
         delete progDlg;
 }
 
 bool Synchronizer::isDir(const FileItem *file)
 {
     if (followSymLinks) {
         return file->isDir();
     } else {
         return file->isDir() && !file->isSymLink();
     }
 }
 
 QString Synchronizer::readLink(const FileItem *file)
 {
     if (file->isSymLink())
         return file->getSymDest();
     else
         return QString();
 }
 
 SynchronizerFileItem *Synchronizer::getItemAt(unsigned ndx)
 {
     if (ndx < (unsigned)resultList.count())
         return resultList.at(ndx);
     else
-        return 0;
+        return nullptr;
 }
 
diff --git a/krusader/Synchronizer/synchronizer.h b/krusader/Synchronizer/synchronizer.h
index 96f8864a..4a2264d2 100644
--- a/krusader/Synchronizer/synchronizer.h
+++ b/krusader/Synchronizer/synchronizer.h
@@ -1,233 +1,233 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SYNCHRONIZER_H
 #define SYNCHRONIZER_H
 
 // QtCore
 #include <QObject>
 #include <QMap>
 #include <QList>
 // QtGui
 #include <QColor>
 // QtWidgets
 #include <QDialog>
 
 #include <KIO/Job>
 
 # include "synchronizertask.h"
 #include "synchronizerfileitem.h"
 
 class KRQuery;
 class FileItem;
 
 class Synchronizer : public QObject
 {
     Q_OBJECT
 
 private:
     int     displayUpdateCount;   // the display is refreshed after every x-th change
 
 public:
     Synchronizer();
-    ~Synchronizer();
+    ~Synchronizer() override;
     int     compare(QString leftURL, QString rightURL, KRQuery *query, bool subDirs, bool symLinks,
                     bool igDate, bool asymm, bool cmpByCnt, bool igCase, bool autoSc, QStringList &selFiles,
                     int equThres, int timeOffs, int parThreads, bool hiddenFiles);
     void    stop() {
         stopped = true;
     }
     void    setMarkFlags(bool left, bool equal, bool differs, bool right, bool dup, bool sing, bool del);
     int     refresh(bool nostatus = false);
     bool    totalSizes(int *, KIO::filesize_t *, int *, KIO::filesize_t *, int *, KIO::filesize_t *);
     void    synchronize(QWidget *, bool leftCopyEnabled, bool rightCopyEnabled, bool deleteEnabled,
                         bool overWrite, int parThreads);
     void    synchronizeWithKGet();
     void    setScrolling(bool scroll);
     void    pause();
     void    resume();
     void    swapSides();
     void    reset();
     void    clearLists();
 
     void    exclude(SynchronizerFileItem *);
     void    restore(SynchronizerFileItem *);
     void    reverseDirection(SynchronizerFileItem *);
     void    copyToLeft(SynchronizerFileItem *);
     void    copyToRight(SynchronizerFileItem *);
     void    deleteLeft(SynchronizerFileItem *);
 
     QString leftBaseDirectory();
     QString rightBaseDirectory();
     static QString getTaskTypeName(TaskType taskType);
-    static QUrl fsUrl(QString strUrl);
+    static QUrl fsUrl(const QString& strUrl);
 
     SynchronizerFileItem *getItemAt(unsigned ndx);
 
     void     setParentWidget(QWidget * widget)    {
         parentWidget = widget;
     }
     void     compareContentResult(SynchronizerFileItem * item, bool result);
 
 signals:
     void    comparedFileData(SynchronizerFileItem *);
     void    markChanged(SynchronizerFileItem *, bool);
     void    synchronizationFinished();
     void    processedSizes(int, KIO::filesize_t, int, KIO::filesize_t, int, KIO::filesize_t);
     void    pauseAccepted();
     void    statusInfo(QString);
 
 public slots:
     void    slotTaskFinished(KJob*);
     void    slotProcessedSize(KJob * , qulonglong);
 
 private:
     bool                  isDir(const FileItem * file);
     QString               readLink(const FileItem * file);
 
     void    compareDirectory(SynchronizerFileItem *, SynchronizerDirList *, SynchronizerDirList *,
                              const QString &leftDir, const QString &rightDir);
     void    addSingleDirectory(SynchronizerFileItem *, SynchronizerDirList *, const QString &, bool);
     SynchronizerFileItem * addItem(SynchronizerFileItem *, const QString &, const QString &,
                                    const QString &, const QString &, bool, bool, KIO::filesize_t,
                                    KIO::filesize_t, time_t, time_t, const QString &, const QString &,
                                    const QString &, const QString &, const QString &, const QString &,
                                    mode_t, mode_t, const QString &, const QString &, TaskType, bool, bool);
     SynchronizerFileItem * addLeftOnlyItem(SynchronizerFileItem *, const QString &, const QString &,
                                            KIO::filesize_t, time_t, const QString &, const QString &,
                                            const QString &, mode_t, const QString &, bool isDir = false, bool isTemp = false);
     SynchronizerFileItem * addRightOnlyItem(SynchronizerFileItem *, const QString &, const QString &,
                                             KIO::filesize_t, time_t, const QString &,  const QString &,
                                             const QString &, mode_t, const QString &, bool isDir = false, bool isTemp = false);
     SynchronizerFileItem * addDuplicateItem(SynchronizerFileItem *, const QString &, const QString &,
                                             const QString &, const QString &, KIO::filesize_t,
                                             KIO::filesize_t, time_t, time_t, const QString &,
                                             const QString &, const QString &, const QString &,
                                             const QString &, const QString &, mode_t, mode_t, const QString &,
                                             const QString &, bool isDir = false, bool isTemp = false);
     bool    isMarked(TaskType task, bool dupl);
     bool    markParentDirectories(SynchronizerFileItem *);
     void    synchronizeLoop();
     SynchronizerFileItem * getNextTask();
     void    executeTask(SynchronizerFileItem * task);
     void    setPermanent(SynchronizerFileItem *);
     void    operate(SynchronizerFileItem *item, void (*)(SynchronizerFileItem *));
     void    compareLoop();
 
     static void excludeOperation(SynchronizerFileItem *item);
     static void restoreOperation(SynchronizerFileItem *item);
     static void reverseDirectionOperation(SynchronizerFileItem *item);
     static void copyToLeftOperation(SynchronizerFileItem *item);
     static void copyToRightOperation(SynchronizerFileItem *item);
     static void deleteLeftOperation(SynchronizerFileItem *item);
 
 protected:
     bool                              recurseSubDirs; // walk through subdirectories also
     bool                              followSymLinks; // follow the symbolic links
     bool                              ignoreDate;     // don't use date info at comparing
     bool                              asymmetric;     // asymmetric directory update
     bool                              cmpByContent;   // compare the files by content
     bool                              ignoreCase;     // case insensitive synchronization for Windows fs
     bool                              autoScroll;     // automatic update of the directory
     QList<SynchronizerFileItem *>     resultList;     // the found files
     QList<SynchronizerFileItem *>     temporaryList;  // temporary files
     QString                           leftBaseDir;    // the left-side base directory
     QString                           rightBaseDir;   // the right-side base directory
     QStringList                       excludedPaths;  // list of the excluded paths
     KRQuery                           *query;         // the filter used for the query
     bool                              stopped;        // 'Stop' button was pressed
 
     int                               equalsThreshold;// threshold to treat files equal
     int                               timeOffset;     // time offset between the left and right sides
     bool                              ignoreHidden;   // ignores the hidden files
 
     bool                              markEquals;     // show the equal files
     bool                              markDiffers;    // show the different files
     bool                              markCopyToLeft; // show the files to copy from right to left
     bool                              markCopyToRight;// show the files to copy from left to right
     bool                              markDeletable;  // show the files to be deleted
     bool                              markDuplicates; // show the duplicated items
     bool                              markSingles;    // show the single items
 
     bool                              leftCopyEnabled;// copy to left is enabled at synchronize
     bool                              rightCopyEnabled;// copy to right is enabled at synchronize
     bool                              deleteEnabled;  // delete is enabled at synchronize
     bool                              overWrite;      // overwrite or query each modification
     bool                              autoSkip;       // automatic skipping
     bool                              paused;         // pause flag
     bool                              disableNewTasks;// at mkdir the further task creation is disabled
 
     int                               leftCopyNr;     // the file number copied to left
     int                               rightCopyNr;    // the file number copied to right
     int                               deleteNr;       // the number of the deleted files
     int                               parallelThreads;// the number of the parallel processing threads
     KIO::filesize_t                   leftCopySize;   // the total size copied to left
     KIO::filesize_t                   rightCopySize;  // the total size copied to right
     KIO::filesize_t                   deleteSize;     // the size of the deleted files
 
     int                               comparedDirs;   // the number of the compared directories
     int                               fileCount;      // the number of counted files
 
 private:
     QList<SynchronizerTask *>         stack;          // stack for comparing
     QMap<KJob *, SynchronizerFileItem *> jobMap;  // job maps
     QMap<KJob *, KIO::filesize_t>      receivedMap;   // the received file size
     SynchronizerFileItem             *lastTask;       // reference to the last stack
     int                               inTaskFinished; // counter of quasy 'threads' in slotTaskFinished
 
     QStringList                       selectedFiles;  // the selected files to compare
     QWidget                          *parentWidget;   // the parent widget
     QWidget                          *syncDlgWidget;  // the synchronizer dialog widget
     QListIterator<SynchronizerFileItem *> resultListIt; // iterator for result list
 };
 
 class QProgressBar;
 
 class KgetProgressDialog : public QDialog
 {
     Q_OBJECT
 
 public:
-    explicit KgetProgressDialog(QWidget *parent = 0, const QString &caption = QString(),
+    explicit KgetProgressDialog(QWidget *parent = nullptr, const QString &caption = QString(),
                        const QString &text = QString(), bool modal = false);
 
     QProgressBar *progressBar() {
         return mProgressBar;
     }
 
 public slots:
     void slotPause();
     void slotCancel();
 
     bool wasCancelled()      {
         return mCancelled;
     }
     bool isPaused()          {
         return mPaused;
     }
 
 private:
     QProgressBar *mProgressBar;
     QPushButton *mPauseButton;
     bool          mCancelled;
     bool          mPaused;
 };
 
 #endif /* __SYNCHRONIZER_H__ */
diff --git a/krusader/Synchronizer/synchronizerdirlist.cpp b/krusader/Synchronizer/synchronizerdirlist.cpp
index d36d658f..a216ebf3 100644
--- a/krusader/Synchronizer/synchronizerdirlist.cpp
+++ b/krusader/Synchronizer/synchronizerdirlist.cpp
@@ -1,181 +1,181 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "synchronizerdirlist.h"
 
 #ifdef HAVE_POSIX_ACL
 #include <sys/acl.h>
 #ifdef HAVE_NON_POSIX_ACL_EXTENSIONS
 #include <acl/libacl.h>
 #endif
 #endif
 
 #include <qplatformdefs.h>
 // QtCore
 #include <QDir>
 // QtWidgets
 #include <QApplication>
 
 #include <KI18n/KLocalizedString>
 #include <KIOCore/KFileItem>
 #include <KIO/JobUiDelegate>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "../FileSystem/filesystem.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../krservices.h"
 
-SynchronizerDirList::SynchronizerDirList(QWidget *w, bool hidden) : QObject(), QHash<QString, FileItem *>(), fileIterator(0),
+SynchronizerDirList::SynchronizerDirList(QWidget *w, bool hidden) : fileIterator(nullptr),
         parentWidget(w), busy(false), result(false), ignoreHidden(hidden), currentUrl()
 {
 }
 
 SynchronizerDirList::~SynchronizerDirList()
 {
     if (fileIterator)
         delete fileIterator;
 
     QHashIterator< QString, FileItem *> lit(*this);
     while (lit.hasNext())
         delete lit.next().value();
 }
 
 FileItem *SynchronizerDirList::search(const QString &name, bool ignoreCase)
 {
     if (!ignoreCase) {
         if (!contains(name))
-            return 0;
+            return nullptr;
         return (*this)[ name ];
     }
 
     QHashIterator<QString, FileItem *> iter(*this);
     iter.toFront();
 
     QString file = name.toLower();
 
     while (iter.hasNext()) {
         FileItem *item = iter.next().value();
         if (file == item->getName().toLower())
             return item;
     }
-    return 0;
+    return nullptr;
 }
 
 FileItem *SynchronizerDirList::first()
 {
-    if (fileIterator == 0)
+    if (fileIterator == nullptr)
         fileIterator = new QHashIterator<QString, FileItem *> (*this);
 
     fileIterator->toFront();
     if (fileIterator->hasNext())
         return fileIterator->next().value();
-    return 0;
+    return nullptr;
 }
 
 FileItem *SynchronizerDirList::next()
 {
-    if (fileIterator == 0)
+    if (fileIterator == nullptr)
         fileIterator = new QHashIterator<QString, FileItem *> (*this);
 
     if (fileIterator->hasNext())
         return fileIterator->next().value();
-    return 0;
+    return nullptr;
 }
 
 bool SynchronizerDirList::load(const QString &urlIn, bool wait)
 {
     if (busy)
         return false;
 
     currentUrl = urlIn;
     const QUrl url = QUrl::fromUserInput(urlIn, QString(), QUrl::AssumeLocalFile);
 
     QHashIterator< QString, FileItem *> lit(*this);
     while (lit.hasNext())
         delete lit.next().value();
     clear();
     if (fileIterator) {
         delete fileIterator;
-        fileIterator = 0;
+        fileIterator = nullptr;
     }
 
     if (url.isLocalFile()) {
         const QString dir = FileSystem::ensureTrailingSlash(url).path();
 
         QT_DIR* qdir = QT_OPENDIR(dir.toLocal8Bit());
         if (!qdir)  {
             KMessageBox::error(parentWidget, i18n("Cannot open the folder %1.", dir), i18n("Error"));
             emit finished(result = false);
             return false;
         }
 
         QT_DIRENT* dirEnt;
 
-        while ((dirEnt = QT_READDIR(qdir)) != NULL) {
+        while ((dirEnt = QT_READDIR(qdir)) != nullptr) {
             const QString name = QString::fromLocal8Bit(dirEnt->d_name);
 
             if (name == "." || name == "..") continue;
             if (ignoreHidden && name.startsWith('.')) continue;
 
             FileItem *item = FileSystem::createLocalFileItem(name, dir);
 
             insert(name, item);
         }
 
         QT_CLOSEDIR(qdir);
         emit finished(result = true);
         return true;
     } else {
         KIO::ListJob *job = KIO::listDir(KrServices::escapeFileUrl(url), KIO::HideProgressInfo, true);
         connect(job, &KIO::ListJob::entries, this, &SynchronizerDirList::slotEntries);
         connect(job, &KIO::ListJob::result, this, &SynchronizerDirList::slotListResult);
         busy = true;
 
         if (!wait)
             return true;
 
         while (busy)
             qApp->processEvents();
         return result;
     }
 }
 
 void SynchronizerDirList::slotEntries(KIO::Job *job, const KIO::UDSEntryList& entries)
 {
-    KIO::ListJob *listJob = static_cast<KIO::ListJob *>(job);
-    for (const KIO::UDSEntry entry : entries) {
+    auto *listJob = dynamic_cast<KIO::ListJob *>(job);
+    for (const KIO::UDSEntry& entry : entries) {
         FileItem *item = FileSystem::createFileItemFromKIO(entry, listJob->url());
         if (item) {
             insert(item->getName(), item);
         }
     }
 }
 
 void SynchronizerDirList::slotListResult(KJob *job)
 {
     busy = false;
     if (job && job->error()) {
         job->uiDelegate()->showErrorMessage();
         emit finished(result = false);
         return;
     }
     emit finished(result = true);
 }
 
diff --git a/krusader/Synchronizer/synchronizerdirlist.h b/krusader/Synchronizer/synchronizerdirlist.h
index 01e4ab08..8299e2ab 100644
--- a/krusader/Synchronizer/synchronizerdirlist.h
+++ b/krusader/Synchronizer/synchronizerdirlist.h
@@ -1,66 +1,66 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SYNCHRONIZERDIRLIST_H
 #define SYNCHRONIZERDIRLIST_H
 
 // QtCore
 #include <QObject>
 #include <QHash>
 
 #include <KIO/Job>
 
 #include "../FileSystem/fileitem.h"
 
 class SynchronizerDirList : public QObject, public QHash<QString, FileItem *>
 {
     Q_OBJECT
 
 public:
     SynchronizerDirList(QWidget *w, bool ignoreHidden);
-    ~SynchronizerDirList();
+    ~SynchronizerDirList() override;
 
     FileItem *search(const QString &name, bool ignoreCase = false);
     FileItem *first();
     FileItem *next();
 
     inline const QString & url() {
         return currentUrl;
     }
     bool load(const QString &urlIn, bool wait = false);
 
 public slots:
 
     void slotEntries(KIO::Job * job, const KIO::UDSEntryList& entries);
     void slotListResult(KJob *job);
 
 signals:
     void finished(bool err);
 
 private:
     QHashIterator<QString, FileItem *> *fileIterator; //< Point to a dictionary of file items
     QWidget *parentWidget;
     bool     busy;
     bool     result;
     bool     ignoreHidden;
     QString  currentUrl;
 };
 
 #endif /* __SYNCHRONIZER_DIR_LIST_H__ */
diff --git a/krusader/Synchronizer/synchronizergui.cpp b/krusader/Synchronizer/synchronizergui.cpp
index 8ecd775c..880113cf 100644
--- a/krusader/Synchronizer/synchronizergui.cpp
+++ b/krusader/Synchronizer/synchronizergui.cpp
@@ -1,1623 +1,1624 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "synchronizergui.h"
 #include "../krglobal.h"
 #include "../filelisticon.h"
 #include "../defaults.h"
 #include "../krusaderview.h"
 #include "../Panel/listpanel.h"
 #include "../Panel/panelfunc.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../KViewer/krviewer.h"
 #include "../Dialogs/krspwidgets.h"
 #include "../FileSystem/krquery.h"
 #include "../krservices.h"
 #include "../krslots.h"
 #include "synchronizedialog.h"
 #include "feedtolistboxdialog.h"
 #include "synchronizercolors.h"
 
 // QtCore
 #include <QEventLoop>
 #include <QRegExp>
 #include <QMimeData>
 #include <QHash>
 // QtGui
 #include <QResizeEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QPixmap>
 #include <QCursor>
 #include <QDrag>
 #include <QClipboard>
 // QtWidgets
 #include <QApplication>
 #include <QLabel>
 #include <QGridLayout>
 #include <QLayout>
 #include <QGroupBox>
 #include <QHBoxLayout>
 #include <QFrame>
 #include <QHeaderView>
 #include <QMenu>
 #include <QSpinBox>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 #include <KIOWidgets/KUrlRequester>
 #include <KGuiAddons/KColorUtils>
+#include <utility>
 
 
 class SynchronizerListView : public KrTreeWidget
 {
 private:
     Synchronizer   *synchronizer;
     bool            isLeft;
 
 public:
     SynchronizerListView(Synchronizer * sync, QWidget * parent) : KrTreeWidget(parent), synchronizer(sync) {
     }
 
     void mouseMoveEvent(QMouseEvent * e) Q_DECL_OVERRIDE {
         isLeft = ((e->modifiers() & Qt::ShiftModifier) == 0);
         KrTreeWidget::mouseMoveEvent(e);
     }
 
     void startDrag(Qt::DropActions /* supportedActs */) Q_DECL_OVERRIDE {
         QList<QUrl> urls;
 
         unsigned              ndx = 0;
         SynchronizerFileItem  *currentItem;
 
-        while ((currentItem = synchronizer->getItemAt(ndx++)) != 0) {
-            SynchronizerGUI::SyncViewItem *viewItem = (SynchronizerGUI::SyncViewItem *)currentItem->userData();
+        while ((currentItem = synchronizer->getItemAt(ndx++)) != nullptr) {
+            auto *viewItem = (SynchronizerGUI::SyncViewItem *)currentItem->userData();
 
             if (!viewItem || !viewItem->isSelected() || viewItem->isHidden())
                 continue;
 
             SynchronizerFileItem *item = viewItem->synchronizerItemRef();
             if (item) {
                 if (isLeft && item->existsInLeft()) {
                     QString leftDirName = item->leftDirectory().isEmpty() ? "" : item->leftDirectory() + '/';
                     QUrl leftURL = Synchronizer::fsUrl(synchronizer->leftBaseDirectory()  + leftDirName + item->leftName());
                     urls.push_back(leftURL);
                 } else if (!isLeft && item->existsInRight()) {
                     QString rightDirName = item->rightDirectory().isEmpty() ? "" : item->rightDirectory() + '/';
                     QUrl rightURL = Synchronizer::fsUrl(synchronizer->rightBaseDirectory()  + rightDirName + item->rightName());
                     urls.push_back(rightURL);
                 }
             }
         }
 
         if (urls.count() == 0)
             return;
 
-        QDrag *drag = new QDrag(this);
-        QMimeData *mimeData = new QMimeData;
+        auto *drag = new QDrag(this);
+        auto *mimeData = new QMimeData;
         mimeData->setImageData(FileListIcon(isLeft ? "arrow-left-double" : "arrow-right-double").pixmap());
         mimeData->setUrls(urls);
         drag->setMimeData(mimeData);
         drag->start();
     }
 };
 
 
 SynchronizerGUI::SynchronizerGUI(QWidget* parent,  QUrl leftURL, QUrl rightURL, QStringList selList) :
         QDialog(parent)
 {
-    initGUI(QString(), leftURL, rightURL, selList);
+    initGUI(QString(), std::move(leftURL), std::move(rightURL), std::move(selList));
 }
 
 SynchronizerGUI::SynchronizerGUI(QWidget* parent,  QString profile) :
         QDialog(parent)
 {
-    initGUI(profile, QUrl(), QUrl(), QStringList());
+    initGUI(std::move(profile), QUrl(), QUrl(), QStringList());
 }
 
-void SynchronizerGUI::initGUI(QString profileName, QUrl leftURL, QUrl rightURL, QStringList selList)
+void SynchronizerGUI::initGUI(const QString& profileName, QUrl leftURL, QUrl rightURL, QStringList selList)
 {
     setAttribute(Qt::WA_DeleteOnClose);
 
-    selectedFiles = selList;
+    selectedFiles = std::move(selList);
     isComparing = wasClosed = wasSync = false;
     firstResize = true;
     sizeX = sizeY = -1;
 
     bool equalSizes = false;
 
     hasSelectedFiles = (selectedFiles.count() != 0);
 
     if (leftURL.isEmpty())
         leftURL = QUrl::fromLocalFile(ROOT_DIR);
     if (rightURL.isEmpty())
         rightURL = QUrl::fromLocalFile(ROOT_DIR);
 
     setWindowTitle(i18n("Krusader::Synchronize Folders"));
-    QGridLayout *synchGrid = new QGridLayout(this);
+    auto *synchGrid = new QGridLayout(this);
     synchGrid->setSpacing(6);
     synchGrid->setContentsMargins(11, 11, 11, 11);
 
     synchronizerTabs = new QTabWidget(this);
 
     /* ============================== Compare groupbox ============================== */
 
     QWidget *synchronizerTab = new QWidget(this);
-    QGridLayout *synchronizerGrid = new QGridLayout(synchronizerTab);
+    auto *synchronizerGrid = new QGridLayout(synchronizerTab);
     synchronizerGrid->setSpacing(6);
     synchronizerGrid->setContentsMargins(11, 11, 11, 11);
 
-    QGroupBox *compareDirs = new QGroupBox(synchronizerTab);
+    auto *compareDirs = new QGroupBox(synchronizerTab);
     compareDirs->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     compareDirs->setTitle(i18n("Folder Comparison"));
 
-    QGridLayout *grid = new QGridLayout(compareDirs);
+    auto *grid = new QGridLayout(compareDirs);
     grid->setSpacing(6);
     grid->setContentsMargins(11, 11, 11, 11);
 
     leftDirLabel = new QLabel(compareDirs);
     leftDirLabel->setAlignment(Qt::AlignHCenter);
     grid->addWidget(leftDirLabel, 0 , 0);
 
     QLabel *filterLabel = new QLabel(compareDirs);
     filterLabel->setText(i18n("File &Filter:"));
     filterLabel->setAlignment(Qt::AlignHCenter);
     grid->addWidget(filterLabel, 0 , 1);
 
     rightDirLabel = new QLabel(compareDirs);
     rightDirLabel->setAlignment(Qt::AlignHCenter);
     grid->addWidget(rightDirLabel, 0 , 2);
 
     KConfigGroup group(krConfig, "Synchronize");
 
     leftLocation = new KHistoryComboBox(false, compareDirs);
     leftLocation->setMaxCount(25);  // remember 25 items
     leftLocation->setDuplicatesEnabled(false);
     leftLocation->setEditable(true);
     leftLocation->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
     QStringList list = group.readEntry("Left Folder History", QStringList());
     leftLocation->setHistoryItems(list);
-    KUrlRequester *leftUrlReq = new KUrlRequester(leftLocation, compareDirs);
+    auto *leftUrlReq = new KUrlRequester(leftLocation, compareDirs);
     leftUrlReq->setUrl(leftURL);
     leftUrlReq->setMode(KFile::Directory);
     leftUrlReq->setMinimumWidth(250);
     grid->addWidget(leftUrlReq, 1 , 0);
     leftLocation->setWhatsThis(i18n("The left base folder used during the synchronization process."));
     leftUrlReq->setEnabled(!hasSelectedFiles);
     leftLocation->setEnabled(!hasSelectedFiles);
     leftDirLabel->setBuddy(leftLocation);
 
     fileFilter = new KHistoryComboBox(false, compareDirs);
     fileFilter->setMaxCount(25);  // remember 25 items
     fileFilter->setDuplicatesEnabled(false);
     fileFilter->setMinimumWidth(100);
     fileFilter->setMaximumWidth(100);
     fileFilter->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     list = group.readEntry("File Filter", QStringList());
     fileFilter->setHistoryItems(list);
     fileFilter->setEditText("*");
     grid->addWidget(fileFilter, 1 , 1);
     filterLabel->setBuddy(fileFilter);
 
     QString wtFilter = "<p><img src='toolbar|find'></p>" + i18n("<p>The filename filtering criteria is defined here.</p><p>You can make use of wildcards. Multiple patterns are separated by space (means logical OR) and patterns are excluded from the search using the pipe symbol.</p><p>If the pattern is ended with a slash (<code>*pattern*/</code>), that means that pattern relates to recursive search of folders.<ul><li><code>pattern</code> - means to search those files/folders that name is <code>pattern</code>, recursive search goes through all subfolders independently of the value of <code>pattern</code></li><li><code>pattern/</code> - means to search all files/folders, but recursive search goes through/excludes the folders that name is <code>pattern</code></li></ul></p><p>It is allowed to use quotation marks for names that contain space. Filter <code>\"Program&nbsp;Files\"</code> searches out those files/folders that name is <code>Program&nbsp;Files</code>.</p><p>Examples:</p><ul><li><code>*.o</code></li><li><code>*.h *.c\?\?</code></li><li><code>*.cpp *.h | *.moc.cpp</code></li><li><code>* | .svn/ .git/</code></li></ul><p><b>Note</b>: the search term '<code>text</code>' is equivalent to '<code>*text*</code>'.</p>");
     fileFilter->setWhatsThis(wtFilter);
     filterLabel->setWhatsThis(wtFilter);
 
     rightLocation = new KHistoryComboBox(compareDirs);
     rightLocation->setMaxCount(25);  // remember 25 items
     rightLocation->setDuplicatesEnabled(false);
     rightLocation->setEditable(true);
     rightLocation->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
     list = group.readEntry("Right Folder History", QStringList());
     rightLocation->setHistoryItems(list);
-    KUrlRequester *rightUrlReq = new KUrlRequester(rightLocation, compareDirs);
+    auto *rightUrlReq = new KUrlRequester(rightLocation, compareDirs);
     rightUrlReq->setUrl(rightURL);
     rightUrlReq->setMode(KFile::Directory);
     rightUrlReq->setMinimumWidth(250);
     grid->addWidget(rightUrlReq, 1 , 2);
     rightLocation->setWhatsThis(i18n("The right base folder used during the synchronization process."));
     rightUrlReq->setEnabled(!hasSelectedFiles);
     rightLocation->setEnabled(!hasSelectedFiles);
     rightDirLabel->setBuddy(rightLocation);
 
     QWidget *optionWidget  = new QWidget(compareDirs);
-    QHBoxLayout *optionBox = new QHBoxLayout(optionWidget);
+    auto *optionBox = new QHBoxLayout(optionWidget);
     optionBox->setContentsMargins(0, 0, 0, 0);
 
     QWidget *optionGridWidget = new QWidget(optionWidget);
-    QGridLayout *optionGrid = new QGridLayout(optionGridWidget);
+    auto *optionGrid = new QGridLayout(optionGridWidget);
 
     optionBox->addWidget(optionGridWidget);
 
     cbSubdirs         = new QCheckBox(i18n("Recurse subfolders"), optionGridWidget);
     cbSubdirs->setChecked(group.readEntry("Recurse Subdirectories", _RecurseSubdirs));
     optionGrid->addWidget(cbSubdirs, 0, 0);
     cbSubdirs->setWhatsThis(i18n("Compare not only the base folders but their subfolders as well."));
     cbSymlinks        = new QCheckBox(i18n("Follow symlinks"), optionGridWidget);
     cbSymlinks->setChecked(group.readEntry("Follow Symlinks", _FollowSymlinks));
     cbSymlinks->setEnabled(cbSubdirs->isChecked());
     optionGrid->addWidget(cbSymlinks, 0, 1);
     cbSymlinks->setWhatsThis(i18n("Follow symbolic links during the compare process."));
     cbByContent       = new QCheckBox(i18n("Compare by content"), optionGridWidget);
     cbByContent->setChecked(group.readEntry("Compare By Content", _CompareByContent));
     optionGrid->addWidget(cbByContent, 0, 2);
     cbByContent->setWhatsThis(i18n("Compare duplicated files with same size by content."));
     cbIgnoreDate      = new QCheckBox(i18n("Ignore Date"), optionGridWidget);
     cbIgnoreDate->setChecked(group.readEntry("Ignore Date", _IgnoreDate));
     optionGrid->addWidget(cbIgnoreDate, 1, 0);
     cbIgnoreDate->setWhatsThis(i18n("<p>Ignore date information during the compare process.</p><p><b>Note</b>: useful if the files are located on network filesystems or in archives.</p>"));
     cbAsymmetric      = new QCheckBox(i18n("Asymmetric"), optionGridWidget);
     cbAsymmetric->setChecked(group.readEntry("Asymmetric", _Asymmetric));
     optionGrid->addWidget(cbAsymmetric, 1, 1);
     cbAsymmetric->setWhatsThis(i18n("<p><b>Asymmetric mode</b></p><p>The left side is the destination, the right is the source folder. Files existing only in the left folder will be deleted, the other differing ones will be copied from right to left.</p><p><b>Note</b>: useful when updating a folder from a file server.</p>"));
     cbIgnoreCase      = new QCheckBox(i18n("Ignore Case"), optionGridWidget);
     cbIgnoreCase->setChecked(group.readEntry("Ignore Case", _IgnoreCase));
     optionGrid->addWidget(cbIgnoreCase, 1, 2);
     cbIgnoreCase->setWhatsThis(i18n("<p>Case insensitive filename compare.</p><p><b>Note</b>: useful when synchronizing Windows filesystems.</p>"));
 
     /* =========================== Show options groupbox ============================= */
 
-    QGroupBox *showOptions  = new QGroupBox(optionWidget);
+    auto *showOptions  = new QGroupBox(optionWidget);
     optionBox->addWidget(showOptions);
 
     showOptions->setTitle(i18n("S&how options"));
     showOptions->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
-    QGridLayout *showOptionsLayout = new QGridLayout(showOptions);
+    auto *showOptionsLayout = new QGridLayout(showOptions);
     showOptionsLayout->setSpacing(4);
     showOptionsLayout->setContentsMargins(11, 11, 11, 11);
 
     bool checked;
     QString description;
 
     checked = group.readEntry("LeftToRight Button", _BtnLeftToRight);
     description = i18n("Show files marked to <i>Copy from left to right</i>.");
     btnLeftToRight =
         createButton(showOptions, "arrow-right", checked, Qt::CTRL + Qt::Key_L, description, ">");
     showOptionsLayout->addWidget(btnLeftToRight, 0, 0);
 
     checked = group.readEntry("Equals Button", _BtnEquals);
     description = i18n("Show files considered to be identical.");
     btnEquals =
         createButton(showOptions, "equals", checked, Qt::CTRL + Qt::Key_E, description, "=");
     showOptionsLayout->addWidget(btnEquals, 0, 1);
 
     checked = group.readEntry("Differents Button", _BtnDifferents);
     description = i18n("Show excluded files.");
     btnDifferents =
         createButton(showOptions, "unequals", checked, Qt::CTRL + Qt::Key_D, description, "!=");
     showOptionsLayout->addWidget(btnDifferents, 0, 2);
 
     checked = group.readEntry("RightToLeft Button", _BtnRightToLeft);
     description = i18n("Show files marked to <i>Copy from right to left</i>.");
     btnRightToLeft =
         createButton(showOptions, "arrow-left", checked, Qt::CTRL + Qt::Key_R, description, "<");
     showOptionsLayout->addWidget(btnRightToLeft, 0, 3);
 
     checked = group.readEntry("Deletable Button", _BtnDeletable);
     description = i18n("Show files marked to delete.");
     btnDeletable =
         createButton(showOptions, "user-trash", checked, Qt::CTRL + Qt::Key_T, description);
     showOptionsLayout->addWidget(btnDeletable, 0, 4);
 
     checked = group.readEntry("Duplicates Button", _BtnDuplicates);
     description = i18n("Show files that exist on both sides.");
     btnDuplicates = createButton(showOptions, "arrow-up", checked, Qt::CTRL + Qt::Key_I,
                                  description, i18n("Duplicates"), true);
     showOptionsLayout->addWidget(btnDuplicates, 0, 5);
 
     checked = group.readEntry("Singles Button", _BtnSingles);
     description = i18n("Show files that exist on one side only.");
     btnSingles = createButton(showOptions, "arrow-down", checked, Qt::CTRL + Qt::Key_N, description,
                               i18n("Singles"), true);
     showOptionsLayout->addWidget(btnSingles, 0, 6);
 
     grid->addWidget(optionWidget, 2, 0, 1, 3);
 
     synchronizerGrid->addWidget(compareDirs, 0, 0);
 
     /* ========================= Synchronization list view ========================== */
     syncList = new SynchronizerListView(&synchronizer, synchronizerTab);  // create the main container
     syncList->setWhatsThis(i18n("The compare results of the synchronizer (Ctrl+M)."));
     syncList->setAutoFillBackground(true);
     syncList->installEventFilter(this);
 
     KConfigGroup gl(krConfig, "Look&Feel");
     syncList->setFont(gl.readEntry("Filelist Font", _FilelistFont));
 
     syncList->setBackgroundRole(QPalette::Window);
     syncList->setAutoFillBackground(true);
 
     QStringList labels;
     labels << i18nc("@title:column file name", "Name");
     labels << i18nc("@title:column", "Size");
     labels << i18nc("@title:column", "Date");
     labels << i18n("<=>");
     labels << i18nc("@title:column", "Date");
     labels << i18nc("@title:column", "Size");
     labels << i18nc("@title:column file name", "Name");
     syncList->setHeaderLabels(labels);
 
     syncList->header()->setSectionResizeMode(QHeaderView::Interactive);
 
     if (group.hasKey("State"))
         syncList->header()->restoreState(group.readEntry("State", QByteArray()));
     else {
         int i = QFontMetrics(syncList->font()).width("W");
         int j = QFontMetrics(syncList->font()).width("0");
         j = (i > j ? i : j);
         int typeWidth = j * 7 / 2;
 
         syncList->setColumnWidth(0, typeWidth * 4);
         syncList->setColumnWidth(1, typeWidth * 2);
         syncList->setColumnWidth(2, typeWidth * 3);
         syncList->setColumnWidth(3, typeWidth * 1);
         syncList->setColumnWidth(4, typeWidth * 3);
         syncList->setColumnWidth(5, typeWidth * 2);
         syncList->setColumnWidth(6, typeWidth * 4);
 
         equalSizes = true;
     }
 
     syncList->setAllColumnsShowFocus(true);
     syncList->setSelectionMode(QAbstractItemView::ExtendedSelection);
     syncList->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     syncList->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     syncList->header()->setSortIndicatorShown(false);
     syncList->setSortingEnabled(false);
     syncList->setRootIsDecorated(true);
     syncList->setIndentation(10);
     syncList->setDragEnabled(true);
     syncList->setAutoFillBackground(true);
 
     synchronizerGrid->addWidget(syncList, 1, 0);
 
     synchronizerTabs->addTab(synchronizerTab, i18n("&Synchronizer"));
     synchGrid->addWidget(synchronizerTabs, 0, 0);
 
     filterTabs = FilterTabs::addTo(synchronizerTabs, FilterTabs::HasDontSearchIn);
     generalFilter = (GeneralFilter *)filterTabs->get("GeneralFilter");
     generalFilter->searchFor->setEditText(fileFilter->currentText());
     generalFilter->searchForCase->setChecked(true);
 
     // creating the time shift, equality threshold, hidden files options
 
-    QGroupBox *optionsGroup = new QGroupBox(generalFilter);
+    auto *optionsGroup = new QGroupBox(generalFilter);
     optionsGroup->setTitle(i18n("&Options"));
 
-    QGridLayout *optionsLayout = new QGridLayout(optionsGroup);
+    auto *optionsLayout = new QGridLayout(optionsGroup);
     optionsLayout->setAlignment(Qt::AlignTop);
     optionsLayout->setSpacing(6);
     optionsLayout->setContentsMargins(11, 11, 11, 11);
 
     QLabel * parallelThreadsLabel = new QLabel(i18n("Parallel threads:"), optionsGroup);
     optionsLayout->addWidget(parallelThreadsLabel, 0, 0);
     parallelThreadsSpinBox = new QSpinBox(optionsGroup);
     parallelThreadsSpinBox->setMinimum(1);
     parallelThreadsSpinBox->setMaximum(15);
     int parThreads = group.readEntry("Parallel Threads", 1);
     parallelThreadsSpinBox->setValue(parThreads);
 
     optionsLayout->addWidget(parallelThreadsSpinBox, 0, 1);
 
     QLabel * equalityLabel = new QLabel(i18n("Equality threshold:"), optionsGroup);
     optionsLayout->addWidget(equalityLabel, 1, 0);
 
     equalitySpinBox = new QSpinBox(optionsGroup);
     equalitySpinBox->setMaximum(9999);
     optionsLayout->addWidget(equalitySpinBox, 1, 1);
 
     equalityUnitCombo = new QComboBox(optionsGroup);
     equalityUnitCombo->addItem(i18n("sec"));
     equalityUnitCombo->addItem(i18n("min"));
     equalityUnitCombo->addItem(i18n("hour"));
     equalityUnitCombo->addItem(i18n("day"));
     optionsLayout->addWidget(equalityUnitCombo, 1, 2);
 
     QLabel * timeShiftLabel = new QLabel(i18n("Time shift (right-left):"), optionsGroup);
     optionsLayout->addWidget(timeShiftLabel, 2, 0);
 
     timeShiftSpinBox = new QSpinBox(optionsGroup);
     timeShiftSpinBox->setMinimum(-9999);
     timeShiftSpinBox->setMaximum(9999);
     optionsLayout->addWidget(timeShiftSpinBox, 2, 1);
 
     timeShiftUnitCombo = new QComboBox(optionsGroup);
     timeShiftUnitCombo->addItem(i18n("sec"));
     timeShiftUnitCombo->addItem(i18n("min"));
     timeShiftUnitCombo->addItem(i18n("hour"));
     timeShiftUnitCombo->addItem(i18n("day"));
     optionsLayout->addWidget(timeShiftUnitCombo, 2, 2);
 
     QFrame *line = new QFrame(optionsGroup);
     line->setFrameStyle(QFrame::HLine | QFrame::Sunken);
     optionsLayout->addWidget(line, 3, 0, 1, 3);
 
     ignoreHiddenFilesCB = new QCheckBox(i18n("Ignore hidden files"), optionsGroup);
     optionsLayout->addWidget(ignoreHiddenFilesCB, 4, 0, 1, 3);
 
     generalFilter->middleLayout->addWidget(optionsGroup);
 
 
     /* ================================== Buttons =================================== */
 
-    QHBoxLayout *buttons = new QHBoxLayout;
+    auto *buttons = new QHBoxLayout;
     buttons->setSpacing(6);
     buttons->setContentsMargins(0, 0, 0, 0);
 
     profileManager = new ProfileManager("SynchronizerProfile", this);
     profileManager->setShortcut(Qt::CTRL + Qt::Key_P);
     profileManager->setWhatsThis(i18n("Profile manager (Ctrl+P)."));
     buttons->addWidget(profileManager);
 
     btnSwapSides = new QPushButton(this);
     btnSwapSides->setIcon(Icon("document-swap"));
     btnSwapSides->setShortcut(Qt::CTRL + Qt::Key_S);
     btnSwapSides->setWhatsThis(i18n("Swap sides (Ctrl+S)."));
     buttons->addWidget(btnSwapSides);
 
     statusLabel = new QLabel(this);
     buttons->addWidget(statusLabel);
 
-    QSpacerItem* spacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
+    auto* spacer = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     buttons->addItem(spacer);
 
     btnCompareDirs = new QPushButton(this);
     btnCompareDirs->setText(i18n("Compare"));
     btnCompareDirs->setIcon(Icon("kr_comparedirs"));
     btnCompareDirs->setDefault(true);
     buttons->addWidget(btnCompareDirs);
 
     btnScrollResults = new QPushButton(this);
     btnScrollResults->setCheckable(true);
     btnScrollResults->setChecked(group.readEntry("Scroll Results", _ScrollResults));
     btnScrollResults->hide();
     if (btnScrollResults->isChecked())
         btnScrollResults->setText(i18n("Quiet"));
     else
         btnScrollResults->setText(i18n("Scroll Results"));
     buttons->addWidget(btnScrollResults);
 
     btnStopComparing = new QPushButton(this);
     btnStopComparing->setText(i18n("Stop"));
     btnStopComparing->setIcon(Icon("process-stop"));
     btnStopComparing->setEnabled(false);
     buttons->addWidget(btnStopComparing);
 
     btnFeedToListBox = new QPushButton(this);
     btnFeedToListBox->setText(i18n("Feed to listbox"));
     btnFeedToListBox->setIcon(Icon("list-add"));
     btnFeedToListBox->setEnabled(false);
     btnFeedToListBox->hide();
     buttons->addWidget(btnFeedToListBox);
 
     btnSynchronize = new QPushButton(this);
     btnSynchronize->setText(i18n("Synchronize"));
     btnSynchronize->setIcon(Icon("folder-sync"));
     btnSynchronize->setEnabled(false);
     buttons->addWidget(btnSynchronize);
 
-    QPushButton *btnCloseSync = new QPushButton(this);
+    auto *btnCloseSync = new QPushButton(this);
     btnCloseSync->setText(i18n("Close"));
     btnCloseSync->setIcon(Icon("dialog-close"));
     buttons->addWidget(btnCloseSync);
 
     synchGrid->addLayout(buttons, 1, 0);
 
     /* =============================== Connect table ================================ */
 
     connect(syncList, &KrTreeWidget::itemRightClicked, this, &SynchronizerGUI::rightMouseClicked);
     connect(syncList, &KrTreeWidget::itemActivated, this, &SynchronizerGUI::doubleClicked);
 
     connect(profileManager, &ProfileManager::loadFromProfile, this, &SynchronizerGUI::loadFromProfile);
     connect(profileManager, &ProfileManager::saveToProfile, this, &SynchronizerGUI::saveToProfile);
 
     connect(btnSwapSides,      &QPushButton::clicked, this, &SynchronizerGUI::swapSides);
     connect(btnCompareDirs,    &QPushButton::clicked, this, &SynchronizerGUI::compare);
     connect(btnStopComparing,  &QPushButton::clicked, this, &SynchronizerGUI::stop);
     connect(btnFeedToListBox,  &QPushButton::clicked, this, &SynchronizerGUI::feedToListBox);
     connect(btnSynchronize,    &QPushButton::clicked, this, &SynchronizerGUI::synchronize);
     connect(btnScrollResults,  &QPushButton::toggled, this, &SynchronizerGUI::setScrolling);
     connect(btnCloseSync,      &QPushButton::clicked, this, &SynchronizerGUI::closeDialog);
 
     connect(cbSubdirs,         &QCheckBox::toggled, this, &SynchronizerGUI::subdirsChecked);
     connect(cbAsymmetric,      &QCheckBox::toggled, this, &SynchronizerGUI::setPanelLabels);
 
     connect(&synchronizer,     &Synchronizer::comparedFileData, this, &SynchronizerGUI::addFile);
     connect(&synchronizer,     &Synchronizer::markChanged, this, &SynchronizerGUI::markChanged);
     connect(&synchronizer,     &Synchronizer::statusInfo, this, &SynchronizerGUI::statusInfo);
 
     connect(btnLeftToRight,    &QPushButton::toggled, this, &SynchronizerGUI::refresh);
     connect(btnEquals,         &QPushButton::toggled, this, &SynchronizerGUI::refresh);
     connect(btnDifferents,     &QPushButton::toggled, this, &SynchronizerGUI::refresh);
     connect(btnRightToLeft,    &QPushButton::toggled, this, &SynchronizerGUI::refresh);
     connect(btnDeletable,      &QPushButton::toggled, this, &SynchronizerGUI::refresh);
     connect(btnDuplicates,     &QPushButton::toggled, this, &SynchronizerGUI::refresh);
     connect(btnSingles,        &QPushButton::toggled, this, &SynchronizerGUI::refresh);
 
     connect(fileFilter,        &KHistoryComboBox::currentTextChanged, this, &SynchronizerGUI::connectFilters);
     connect(generalFilter->searchFor, &KHistoryComboBox::currentTextChanged, this, &SynchronizerGUI::connectFilters);
     connect(generalFilter->searchFor, &KHistoryComboBox::currentTextChanged, this, &SynchronizerGUI::setCompletion);
     connect(generalFilter->dontSearchIn, &KURLListRequester::checkValidity, this, &SynchronizerGUI::checkExcludeURLValidity);
 
     connect(profileManager, &ProfileManager::loadFromProfile, filterTabs, &FilterTabs::loadFromProfile);
     connect(profileManager, &ProfileManager::saveToProfile, filterTabs, &FilterTabs::saveToProfile);
 
     setPanelLabels();
     setCompletion();
 
     /* =============================== Loading the colors ================================ */
 
     KConfigGroup gc(krConfig, "Colors");
 
     QString COLOR_NAMES[] = { "Equals", "Differs", "LeftCopy", "RightCopy", "Delete" };
     QPalette defaultPalette = QGuiApplication::palette();
 
     DECLARE_SYNCHRONIZER_BACKGROUND_DEFAULTS;
     DECLARE_SYNCHRONIZER_FOREGROUND_DEFAULTS;
 
     for (int clr = 0; clr != TT_MAX; clr ++) {
         QString colorName = clr > 4 ? "Equals" : COLOR_NAMES[ clr ];
         QColor backgroundDefault = clr > 4 ? defaultPalette.color(QPalette::Active, QPalette::Base) : SYNCHRONIZER_BACKGROUND_DEFAULTS[ clr ];
         QColor foregroundDefault = clr > 4 ? defaultPalette.color(QPalette::Active, QPalette::Text) : SYNCHRONIZER_FOREGROUND_DEFAULTS[ clr ];
 
         QString foreEntry = QString("Synchronizer ") + colorName + QString(" Foreground");
         QString bckgEntry = QString("Synchronizer ") + colorName + QString(" Background");
 
         if (gc.readEntry(foreEntry, QString()) == "KDE default")
             foreGrounds[ clr ] = QColor();
         else if (gc.readEntry(foreEntry, QString()).isEmpty())    // KDE4 workaround, default color doesn't work
             foreGrounds[ clr ] = foregroundDefault;
         else
             foreGrounds[ clr ] = gc.readEntry(foreEntry, foregroundDefault);
 
         if (gc.readEntry(bckgEntry, QString()) == "KDE default")
             backGrounds[ clr ] = QColor();
         else if (gc.readEntry(foreEntry, QString()).isEmpty())    // KDE4 workaround, default color doesn't work
             backGrounds[ clr ] = backgroundDefault;
         else
             backGrounds[ clr ] = gc.readEntry(bckgEntry, backgroundDefault);
     }
     if (backGrounds[ TT_EQUALS ].isValid()) {
         QPalette pal = syncList->palette();
         pal.setColor(QPalette::Base, backGrounds[ TT_EQUALS ]);
         syncList->setPalette(pal);
     }
 
     int sx = group.readEntry("Window Width",  -1);
     int sy = group.readEntry("Window Height",  -1);
 
     if (sx != -1 && sy != -1)
         resize(sx, sy);
 
     if (group.readEntry("Window Maximized",  false)) {
         setWindowState(windowState() | Qt::WindowMaximized);
     }
 
     if (equalSizes) {
         int newSize6 = syncList->header()->sectionSize(6);
         int newSize0 = syncList->header()->sectionSize(0);
         int delta = newSize6 - newSize0 + (newSize6 & 1);
 
         newSize0 += (delta / 2);
 
         if (newSize0 > 20)
             syncList->header()->resizeSection(0, newSize0);
     }
 
     if (!profileName.isNull())
         profileManager->loadProfile(profileName);
 
     synchronizer.setParentWidget(this);
 }
 
 SynchronizerGUI::~SynchronizerGUI()
 {
     syncList->clear(); // for sanity: deletes the references to the synchronizer list
 }
 
 void SynchronizerGUI::setPanelLabels()
 {
     if (hasSelectedFiles && cbAsymmetric->isChecked()) {
         leftDirLabel->setText(i18n("Selected files from targ&et folder:"));
         rightDirLabel->setText(i18n("Selected files from sou&rce folder:"));
     } else if (hasSelectedFiles && !cbAsymmetric->isChecked()) {
         leftDirLabel->setText(i18n("Selected files from &left folder:"));
         rightDirLabel->setText(i18n("Selected files from &right folder:"));
     } else if (cbAsymmetric->isChecked()) {
         leftDirLabel->setText(i18n("Targ&et folder:"));
         rightDirLabel->setText(i18n("Sou&rce folder:"));
     } else {
         leftDirLabel->setText(i18n("&Left folder:"));
         rightDirLabel->setText(i18n("&Right folder:"));
     }
 }
 
 void SynchronizerGUI::setCompletion()
 {
     generalFilter->dontSearchIn->setCompletionDir(Synchronizer::fsUrl(rightLocation->currentText()));
 }
 
 void SynchronizerGUI::checkExcludeURLValidity(QString &text, QString &error)
 {
     QUrl url = Synchronizer::fsUrl(text);
     if (url.isRelative())
         return;
 
     QString leftBase = leftLocation->currentText();
     if (!leftBase.endsWith('/'))
         leftBase += '/';
     QUrl leftBaseURL = Synchronizer::fsUrl(leftBase);
     if (leftBaseURL.isParentOf(url) && !url.isParentOf(leftBaseURL)) {
         text = QDir(leftBaseURL.path()).relativeFilePath(url.path());
         return;
     }
 
     QString rightBase = rightLocation->currentText();
     if (!rightBase.endsWith('/'))
         rightBase += '/';
     QUrl rightBaseURL = Synchronizer::fsUrl(rightBase);
     if (rightBaseURL.isParentOf(url) && !url.isParentOf(rightBaseURL)) {
         text = QDir(rightBaseURL.path()).relativeFilePath(url.path());
         return;
     }
 
     error = i18n("URL must be the descendant of either the left or the right base URL.");
 }
 
 void SynchronizerGUI::doubleClicked(QTreeWidgetItem *itemIn)
 {
     if (!itemIn)
         return;
 
-    SyncViewItem *syncItem = (SyncViewItem *)itemIn;
+    auto *syncItem = (SyncViewItem *)itemIn;
     SynchronizerFileItem *item = syncItem->synchronizerItemRef();
     if (item && item->existsInLeft() && item->existsInRight() && !item->isDir()) {
         QString leftDirName     = item->leftDirectory().isEmpty() ? "" : item->leftDirectory() + '/';
         QString rightDirName     = item->rightDirectory().isEmpty() ? "" : item->rightDirectory() + '/';
         QUrl leftURL = Synchronizer::fsUrl(synchronizer.leftBaseDirectory()  + leftDirName + item->leftName());
         QUrl rightURL = Synchronizer::fsUrl(synchronizer.rightBaseDirectory() + rightDirName + item->rightName());
 
         SLOTS->compareContent(leftURL,rightURL);
     } else if (item && item->isDir()) {
         itemIn->setExpanded(!itemIn->isExpanded());
     }
 }
 
 void SynchronizerGUI::rightMouseClicked(QTreeWidgetItem *itemIn, const QPoint &pos)
 {
     // these are the values that will exist in the menu
 #define EXCLUDE_ID          90
 #define RESTORE_ID          91
 #define COPY_TO_LEFT_ID     92
 #define COPY_TO_RIGHT_ID    93
 #define REVERSE_DIR_ID      94
 #define DELETE_ID           95
 #define VIEW_LEFT_FILE_ID   96
 #define VIEW_RIGHT_FILE_ID  97
 #define COMPARE_FILES_ID    98
 #define SELECT_ITEMS_ID     99
 #define DESELECT_ITEMS_ID   100
 #define INVERT_SELECTION_ID 101
 #define SYNCH_WITH_KGET_ID  102
 #define COPY_CLPBD_LEFT_ID  103
 #define COPY_CLPBD_RIGHT_ID 104
     //////////////////////////////////////////////////////////
     if (!itemIn)
         return;
 
-    SyncViewItem *syncItem = (SyncViewItem *)itemIn;
-    if (syncItem == 0)
+    auto *syncItem = (SyncViewItem *)itemIn;
+    if (syncItem == nullptr)
         return;
 
     SynchronizerFileItem *item = syncItem->synchronizerItemRef();
 
     bool    isDuplicate = item->existsInLeft() && item->existsInRight();
     bool    isDir       = item->isDir();
 
     // create the menu
     QMenu popup;
     QAction *myact;
     QHash< QAction *, int > actHash;
 
     popup.setTitle(i18n("Synchronize Folders"));
 
     myact = popup.addAction(i18n("E&xclude"));
     actHash[ myact ] = EXCLUDE_ID;
     myact = popup.addAction(i18n("Restore ori&ginal operation"));
     actHash[ myact ] = RESTORE_ID;
     myact = popup.addAction(i18n("Re&verse direction"));
     actHash[ myact ] = REVERSE_DIR_ID;
     myact = popup.addAction(i18n("Copy from &right to left"));
     actHash[ myact ] = COPY_TO_LEFT_ID;
     myact = popup.addAction(i18n("Copy from &left to right"));
     actHash[ myact ] = COPY_TO_RIGHT_ID;
     myact = popup.addAction(i18n("&Delete (left single)"));
     actHash[ myact ] = DELETE_ID;
 
     popup.addSeparator();
 
     myact = popup.addAction(i18n("V&iew left file"));
     myact->setEnabled(!isDir && item->existsInLeft());
     actHash[ myact ] = VIEW_LEFT_FILE_ID;
     myact = popup.addAction(i18n("Vi&ew right file"));
     myact->setEnabled(!isDir && item->existsInRight());
     actHash[ myact ] = VIEW_RIGHT_FILE_ID;
     myact = popup.addAction(i18n("&Compare Files"));
     myact->setEnabled(!isDir && isDuplicate);
     actHash[ myact ] = COMPARE_FILES_ID;
 
     popup.addSeparator();
 
     myact = popup.addAction(i18n("C&opy selected to clipboard (left)"));
     actHash[ myact ] = COPY_CLPBD_LEFT_ID;
     myact = popup.addAction(i18n("Co&py selected to clipboard (right)"));
     actHash[ myact ] = COPY_CLPBD_RIGHT_ID;
 
     popup.addSeparator();
 
     myact = popup.addAction(i18n("&Select items"));
     actHash[ myact ] = SELECT_ITEMS_ID;
     myact = popup.addAction(i18n("Deselec&t items"));
     actHash[ myact ] = DESELECT_ITEMS_ID;
     myact = popup.addAction(i18n("I&nvert selection"));
     actHash[ myact ] = INVERT_SELECTION_ID;
 
     QUrl leftBDir = Synchronizer::fsUrl(synchronizer.leftBaseDirectory());
     QUrl rightBDir = Synchronizer::fsUrl(synchronizer.rightBaseDirectory());
 
     if (KrServices::cmdExist("kget") &&
             ((!leftBDir.isLocalFile() && rightBDir.isLocalFile() && btnLeftToRight->isChecked()) ||
              (leftBDir.isLocalFile() && !rightBDir.isLocalFile() && btnRightToLeft->isChecked()))) {
         popup.addSeparator();
         myact = popup.addAction(i18n("Synchronize with &KGet"));
         actHash[ myact ] = SYNCH_WITH_KGET_ID;
     }
 
     QAction * res = popup.exec(pos);
 
     int result = -1;
     if (actHash.contains(res))
         result = actHash[ res ];
 
     if (result != -1)
         executeOperation(item, result);
 }
 
 void SynchronizerGUI::executeOperation(SynchronizerFileItem *item, int op)
 {
     // check out the user's option
     QString leftDirName     = item->leftDirectory().isEmpty() ? "" : item->leftDirectory() + '/';
     QString rightDirName     = item->rightDirectory().isEmpty() ? "" : item->rightDirectory() + '/';
 
     QUrl leftURL = Synchronizer::fsUrl(synchronizer.leftBaseDirectory()  + leftDirName + item->leftName());
     QUrl rightURL = Synchronizer::fsUrl(synchronizer.rightBaseDirectory() + rightDirName + item->rightName());
 
     switch (op) {
     case EXCLUDE_ID:
     case RESTORE_ID:
     case COPY_TO_LEFT_ID:
     case COPY_TO_RIGHT_ID:
     case REVERSE_DIR_ID:
     case DELETE_ID: {
         unsigned              ndx = 0;
         SynchronizerFileItem  *currentItem;
 
-        while ((currentItem = synchronizer.getItemAt(ndx++)) != 0) {
-            SyncViewItem *viewItem = (SyncViewItem *)currentItem->userData();
+        while ((currentItem = synchronizer.getItemAt(ndx++)) != nullptr) {
+            auto *viewItem = (SyncViewItem *)currentItem->userData();
 
             if (!viewItem || !viewItem->isSelected() || viewItem->isHidden())
                 continue;
 
             switch (op) {
             case EXCLUDE_ID:
                 synchronizer.exclude(viewItem->synchronizerItemRef());
                 break;
             case RESTORE_ID:
                 synchronizer.restore(viewItem->synchronizerItemRef());
                 break;
             case REVERSE_DIR_ID:
                 synchronizer.reverseDirection(viewItem->synchronizerItemRef());
                 break;
             case COPY_TO_LEFT_ID:
                 synchronizer.copyToLeft(viewItem->synchronizerItemRef());
                 break;
             case COPY_TO_RIGHT_ID:
                 synchronizer.copyToRight(viewItem->synchronizerItemRef());
                 break;
             case DELETE_ID:
                 synchronizer.deleteLeft(viewItem->synchronizerItemRef());
                 break;
             }
         }
 
         refresh();
     }
     break;
     case VIEW_LEFT_FILE_ID:
         KrViewer::view(leftURL, this);   // view the file
         break;
     case VIEW_RIGHT_FILE_ID:
         KrViewer::view(rightURL, this);   // view the file
         break;
     case COMPARE_FILES_ID:
         SLOTS->compareContent(leftURL,rightURL);
         break;
     case SELECT_ITEMS_ID:
     case DESELECT_ITEMS_ID: {
         KRQuery query = KRSpWidgets::getMask((op == SELECT_ITEMS_ID ? i18n("Select items") :
                                               i18n("Deselect items")), true, this);
         if (query.isNull())
             break;
 
         unsigned              ndx = 0;
         SynchronizerFileItem  *currentItem;
 
-        while ((currentItem = synchronizer.getItemAt(ndx++)) != 0) {
-            SyncViewItem *viewItem = (SyncViewItem *)currentItem->userData();
+        while ((currentItem = synchronizer.getItemAt(ndx++)) != nullptr) {
+            auto *viewItem = (SyncViewItem *)currentItem->userData();
 
             if (!viewItem || viewItem->isHidden())
                 continue;
 
             if (query.match(currentItem->leftName()) ||
                     query.match(currentItem->rightName()))
                 viewItem->setSelected(op == SELECT_ITEMS_ID);
         }
     }
     break;
     case INVERT_SELECTION_ID: {
         unsigned              ndx = 0;
         SynchronizerFileItem  *currentItem;
 
-        while ((currentItem = synchronizer.getItemAt(ndx++)) != 0) {
-            SyncViewItem *viewItem = (SyncViewItem *)currentItem->userData();
+        while ((currentItem = synchronizer.getItemAt(ndx++)) != nullptr) {
+            auto *viewItem = (SyncViewItem *)currentItem->userData();
 
             if (!viewItem || viewItem->isHidden())
                 continue;
 
             viewItem->setSelected(!viewItem->isSelected());
         }
     }
     break;
     case SYNCH_WITH_KGET_ID:
         synchronizer.synchronizeWithKGet();
         closeDialog();
         break;
     case COPY_CLPBD_LEFT_ID:
         copyToClipboard(true);
         break;
     case COPY_CLPBD_RIGHT_ID:
         copyToClipboard(false);
         break;
     case -1 : return;     // the user clicked outside of the menu
     }
 }
 
 void SynchronizerGUI::closeDialog()
 {
     if (isComparing) {
         stop();
         wasClosed = true;
         return;
     }
 
     KConfigGroup group(krConfig, "Synchronize");
 
     QStringList list;
 
     foreach(const QString &item, leftLocation->historyItems()) {
         QUrl url(item);
         // make sure no passwords are saved in config
         url.setPassword(QString());
         list << url.toDisplayString(QUrl::PreferLocalFile);
     }
     group.writeEntry("Left Folder History", list);
     list.clear();
     foreach(const QString &item, rightLocation->historyItems()) {
         QUrl url(item);
         // make sure no passwords are saved in config
         url.setPassword(QString());
         list << url.toDisplayString(QUrl::PreferLocalFile);
     }
     group.writeEntry("Right Folder History", list);
 
     list = fileFilter->historyItems();
     group.writeEntry("File Filter", list);
 
     group.writeEntry("Recurse Subdirectories", cbSubdirs->isChecked());
     group.writeEntry("Follow Symlinks", cbSymlinks->isChecked());
     group.writeEntry("Compare By Content", cbByContent->isChecked());
     group.writeEntry("Ignore Date", cbIgnoreDate->isChecked());
     group.writeEntry("Asymmetric", cbAsymmetric->isChecked());
     group.writeEntry("Ignore Case", cbIgnoreCase->isChecked());
     group.writeEntry("LeftToRight Button", btnLeftToRight->isChecked());
     group.writeEntry("Equals Button", btnEquals->isChecked());
     group.writeEntry("Differents Button", btnDifferents->isChecked());
     group.writeEntry("RightToLeft Button", btnRightToLeft->isChecked());
     group.writeEntry("Deletable Button", btnDeletable->isChecked());
     group.writeEntry("Duplicates Button", btnDuplicates->isChecked());
     group.writeEntry("Singles Button", btnSingles->isChecked());
 
     group.writeEntry("Scroll Results", btnScrollResults->isChecked());
 
     group.writeEntry("Parallel Threads", parallelThreadsSpinBox->value());
 
     group.writeEntry("Window Width", sizeX);
     group.writeEntry("Window Height", sizeY);
     group.writeEntry("Window Maximized", isMaximized());
 
     group.writeEntry("State", syncList->header()->saveState());
 
     QDialog::reject();
 
     this->deleteLater();
 
     if (wasSync) {
         LEFT_PANEL->func->refresh();
         RIGHT_PANEL->func->refresh();
         ACTIVE_PANEL->gui->slotFocusOnMe();
     }
 }
 
 void SynchronizerGUI::compare()
 {
     KRQuery query;
 
     if (!filterTabs->fillQuery(&query))
         return;
 
     // perform some previous tests
     QString leftLocationTrimmed = leftLocation->currentText().trimmed();
     QString rightLocationTrimmed = rightLocation->currentText().trimmed();
     if (leftLocationTrimmed.isEmpty()) {
         KMessageBox::error(this, i18n("The target folder must not be empty."));
         leftLocation->setFocus();
         return;
     }
     if (rightLocationTrimmed.isEmpty()) {
         KMessageBox::error(this, i18n("The source folder must not be empty."));
         rightLocation->setFocus();
         return;
     }
 
     if (leftLocationTrimmed == rightLocationTrimmed) {
         if (KMessageBox::warningContinueCancel(this, i18n("Warning: The left and the right side are showing the same folder."))
             != KMessageBox::Continue) {
             return;
         }
     }
 
     query.setNameFilter(fileFilter->currentText(), query.isCaseSensitive());
     synchronizerTabs->setCurrentIndex(0);
 
     syncList->clear();
-    lastItem = 0;
+    lastItem = nullptr;
 
     leftLocation->addToHistory(leftLocation->currentText());
     rightLocation->addToHistory(rightLocation->currentText());
     fileFilter->addToHistory(fileFilter->currentText());
 
     setMarkFlags();
 
     btnCompareDirs->setEnabled(false);
     profileManager->setEnabled(false);
     btnSwapSides->setEnabled(false);
     btnStopComparing->setEnabled(isComparing = true);
     btnStopComparing->show();
     btnFeedToListBox->setEnabled(false);
     btnFeedToListBox->hide();
     btnSynchronize->setEnabled(false);
     btnCompareDirs->hide();
     btnScrollResults->show();
     disableMarkButtons();
 
     int fileCount = synchronizer.compare(leftLocation->currentText(), rightLocation->currentText(),
                                          &query, cbSubdirs->isChecked(), cbSymlinks->isChecked(),
                                          cbIgnoreDate->isChecked(), cbAsymmetric->isChecked(), cbByContent->isChecked(),
                                          cbIgnoreCase->isChecked(), btnScrollResults->isChecked(), selectedFiles,
                                          convertToSeconds(equalitySpinBox->value(), equalityUnitCombo->currentIndex()),
                                          convertToSeconds(timeShiftSpinBox->value(), timeShiftUnitCombo->currentIndex()),
                                          parallelThreadsSpinBox->value(), ignoreHiddenFilesCB->isChecked());
     enableMarkButtons();
     btnStopComparing->setEnabled(isComparing = false);
     btnStopComparing->hide();
     btnFeedToListBox->show();
     btnCompareDirs->setEnabled(true);
     profileManager->setEnabled(true);
     btnSwapSides->setEnabled(true);
     btnCompareDirs->show();
     btnScrollResults->hide();
     if (fileCount) {
         btnSynchronize->setEnabled(true);
         btnFeedToListBox->setEnabled(true);
     }
 
     syncList->setFocus();
 
     if (wasClosed)
         closeDialog();
 }
 
 void SynchronizerGUI::stop()
 {
     synchronizer.stop();
 }
 
 void SynchronizerGUI::feedToListBox()
 {
     FeedToListBoxDialog listBox(this, &synchronizer, syncList, btnEquals->isChecked());
     if (listBox.isAccepted())
         closeDialog();
 }
 
 void SynchronizerGUI::reject()
 {
     closeDialog();
 }
 
 void SynchronizerGUI::addFile(SynchronizerFileItem *item)
 {
     QString leftName = "", rightName = "", leftDate = "", rightDate = "", leftSize = "", rightSize = "";
     bool    isDir = item->isDir();
 
     QColor textColor = foreGrounds[ item->task()];
     QColor baseColor = backGrounds[ item->task()];
 
     if (item->existsInLeft()) {
         leftName = item->leftName();
         leftSize = isDir ? dirLabel() + ' ' : KRpermHandler::parseSize(item->leftSize());
         leftDate = SynchronizerGUI::convertTime(item->leftDate());
     }
 
     if (item->existsInRight()) {
         rightName = item->rightName();
         rightSize = isDir ? dirLabel() + ' ' : KRpermHandler::parseSize(item->rightSize());
         rightDate = SynchronizerGUI::convertTime(item->rightDate());
     }
 
-    SyncViewItem *listItem = 0;
+    SyncViewItem *listItem = nullptr;
     SyncViewItem *dirItem;
 
-    if (item->parent() == 0) {
+    if (item->parent() == nullptr) {
         listItem = new SyncViewItem(item, textColor, baseColor, syncList, lastItem, leftName, leftSize,
                                     leftDate, Synchronizer::getTaskTypeName(item->task()), rightDate,
                                     rightSize, rightName);
         lastItem = listItem;
     } else {
         dirItem = (SyncViewItem *)item->parent()->userData();
         if (dirItem) {
             dirItem->setExpanded(true);
             listItem = new SyncViewItem(item, textColor, baseColor, dirItem, dirItem->lastItem(), leftName,
                                         leftSize, leftDate, Synchronizer::getTaskTypeName(item->task()),
                                         rightDate, rightSize, rightName);
 
             dirItem->setLastItem(listItem);
         }
     }
 
     if (listItem) {
         listItem->setIcon(0, Icon(isDir ? "folder" : "document-new"));
         if (!item->isMarked())
             listItem->setHidden(true);
         else
             syncList->scrollTo(syncList->indexOf(listItem));
     }
 }
 
 void SynchronizerGUI::markChanged(SynchronizerFileItem *item, bool ensureVisible)
 {
-    SyncViewItem *listItem = (SyncViewItem *)item->userData();
+    auto *listItem = (SyncViewItem *)item->userData();
     if (listItem) {
         if (!item->isMarked()) {
             listItem->setHidden(true);
         } else {
             QString leftName = "", rightName = "", leftDate = "", rightDate = "", leftSize = "", rightSize = "";
             bool    isDir = item->isDir();
 
             if (item->existsInLeft()) {
                 leftName = item->leftName();
                 leftSize = isDir ? dirLabel() + ' ' : KRpermHandler::parseSize(item->leftSize());
                 leftDate = SynchronizerGUI::convertTime(item->leftDate());
             }
 
             if (item->existsInRight()) {
                 rightName = item->rightName();
                 rightSize = isDir ? dirLabel() + ' ' : KRpermHandler::parseSize(item->rightSize());
                 rightDate = SynchronizerGUI::convertTime(item->rightDate());
             }
 
             listItem->setHidden(false);
             listItem->setText(0, leftName);
             listItem->setText(1, leftSize);
             listItem->setText(2, leftDate);
             listItem->setText(3, Synchronizer::getTaskTypeName(item->task()));
             listItem->setText(4, rightDate);
             listItem->setText(5, rightSize);
             listItem->setText(6, rightName);
             listItem->setColors(foreGrounds[ item->task()], backGrounds[ item->task()]);
 
             if (ensureVisible)
                 syncList->scrollTo(syncList->indexOf(listItem));
         }
     }
 }
 
 void SynchronizerGUI::subdirsChecked(bool isOn)
 {
     cbSymlinks->setEnabled(isOn);
 }
 
 void SynchronizerGUI::disableMarkButtons()
 {
     btnLeftToRight->setEnabled(false);
     btnEquals->setEnabled(false);
     btnDifferents->setEnabled(false);
     btnRightToLeft->setEnabled(false);
     btnDeletable->setEnabled(false);
     btnDuplicates->setEnabled(false);
     btnSingles->setEnabled(false);
 }
 
 void SynchronizerGUI::enableMarkButtons()
 {
     btnLeftToRight->setEnabled(true);
     btnEquals->setEnabled(true);
     btnDifferents->setEnabled(true);
     btnRightToLeft->setEnabled(true);
     btnDeletable->setEnabled(true);
     btnDuplicates->setEnabled(true);
     btnSingles->setEnabled(true);
 }
 
 QString SynchronizerGUI::convertTime(time_t time) const
 {
     // convert the time_t to struct tm
     struct tm* t = localtime((time_t *) & time);
 
     QDateTime tmp(QDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday), QTime(t->tm_hour, t->tm_min));
     return QLocale().toString(tmp, QLocale::ShortFormat);
 }
 
 void SynchronizerGUI::setMarkFlags()
 {
     synchronizer.setMarkFlags(btnRightToLeft->isChecked(), btnEquals->isChecked(), btnDifferents->isChecked(),
                               btnLeftToRight->isChecked(), btnDuplicates->isChecked(), btnSingles->isChecked(),
                               btnDeletable->isChecked());
 }
 
 void SynchronizerGUI::refresh()
 {
     if (!isComparing) {
         syncList->clearSelection();
         setMarkFlags();
         btnCompareDirs->setEnabled(false);
         profileManager->setEnabled(false);
         btnSwapSides->setEnabled(false);
         btnSynchronize->setEnabled(false);
         btnFeedToListBox->setEnabled(false);
         disableMarkButtons();
         int fileCount = synchronizer.refresh();
         enableMarkButtons();
         btnCompareDirs->setEnabled(true);
         profileManager->setEnabled(true);
         btnSwapSides->setEnabled(true);
         if (fileCount) {
             btnFeedToListBox->setEnabled(true);
             btnSynchronize->setEnabled(true);
         }
     }
 }
 
 void SynchronizerGUI::synchronize()
 {
     int             copyToLeftNr, copyToRightNr, deleteNr;
     KIO::filesize_t copyToLeftSize, copyToRightSize, deleteSize;
 
     if (!synchronizer.totalSizes(&copyToLeftNr, &copyToLeftSize, &copyToRightNr, &copyToRightSize,
                                  &deleteNr, &deleteSize)) {
         KMessageBox::sorry(parentWidget(), i18n("Synchronizer has nothing to do."));
         return;
     }
 
-    SynchronizeDialog *sd = new SynchronizeDialog(this, &synchronizer,
+    auto *sd = new SynchronizeDialog(this, &synchronizer,
             copyToLeftNr, copyToLeftSize, copyToRightNr,
             copyToRightSize, deleteNr, deleteSize,
             parallelThreadsSpinBox->value());
 
     wasSync = sd->wasSyncronizationStarted();
     delete sd;
 
     if (wasSync)
         closeDialog();
 }
 
 void SynchronizerGUI::resizeEvent(QResizeEvent *e)
 {
     if (!isMaximized()) {
         sizeX = e->size().width();
         sizeY = e->size().height();
     }
 
     if (!firstResize) {
         int delta = e->size().width() - e->oldSize().width() + (e->size().width() & 1);
         int newSize = syncList->header()->sectionSize(0) + delta / 2;
 
         if (newSize > 20)
             syncList->header()->resizeSection(0, newSize);
     }
     firstResize = false;
     QDialog::resizeEvent(e);
 }
 
-void SynchronizerGUI::statusInfo(QString info)
+void SynchronizerGUI::statusInfo(const QString& info)
 {
     statusLabel->setText(info);
     qApp->processEvents();
 }
 
 void SynchronizerGUI::swapSides()
 {
     if (btnCompareDirs->isEnabled()) {
         QString leftCurrent = leftLocation->currentText();
         leftLocation->lineEdit()->setText(rightLocation->currentText());
         rightLocation->lineEdit()->setText(leftCurrent);
         synchronizer.swapSides();
         refresh();
     }
 }
 
 void SynchronizerGUI::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_M : {
         if (e->modifiers() == Qt::ControlModifier) {
             syncList->setFocus();
             e->accept();
         }
         break;
     }
     case Qt::Key_F3 :
     case Qt::Key_F4 : {
         e->accept();
         syncList->setFocus();
         QTreeWidgetItem *listItem =  syncList->currentItem();
-        if (listItem == 0)
+        if (listItem == nullptr)
             break;
 
         bool isedit = e->key() == Qt::Key_F4;
 
         SynchronizerFileItem *item = ((SyncViewItem *)listItem)->synchronizerItemRef();
         QString leftDirName = item->leftDirectory().isEmpty() ? "" : item->leftDirectory() + '/';
         QString rightDirName = item->rightDirectory().isEmpty() ? "" : item->rightDirectory() + '/';
 
         if (item->isDir())
             return;
 
         if (e->modifiers() == Qt::ShiftModifier && item->existsInRight()) {
             QUrl rightURL = Synchronizer::fsUrl(synchronizer.rightBaseDirectory() + rightDirName + item->rightName());
             if (isedit)
                 KrViewer::edit(rightURL, this);   // view the file
             else
                 KrViewer::view(rightURL, this);   // view the file
             return;
         } else if (e->modifiers() == 0 && item->existsInLeft()) {
             QUrl leftURL = Synchronizer::fsUrl(synchronizer.leftBaseDirectory()  + leftDirName + item->leftName());
             if (isedit)
                 KrViewer::edit(leftURL, this);   // view the file
             else
                 KrViewer::view(leftURL, this);   // view the file
             return;
         }
     }
     break;
     case Qt::Key_U :
         if (e->modifiers() != Qt::ControlModifier)
             break;
         e->accept();
         swapSides();
         return;
     case Qt::Key_Escape:
         if (!btnStopComparing->isHidden() && btnStopComparing->isEnabled()) { // is it comparing?
             e->accept();
             btnStopComparing->animateClick(); // just click the stop button
         } else {
             e->accept();
             if (syncList->topLevelItemCount() != 0) {
                 int result = KMessageBox::warningYesNo(this, i18n("The synchronizer window contains data from a previous compare. If you exit, this data will be lost. Do you really want to exit?"),
                                                        i18n("Krusader::Synchronize Folders"),
                                                        KStandardGuiItem::yes(), KStandardGuiItem::no(), "syncGUIexit");
                 if (result != KMessageBox::Yes)
                     return;
             }
             QDialog::reject();
         }
         return;
     }
 
     QDialog::keyPressEvent(e);
 }
 
 bool SynchronizerGUI::eventFilter(QObject * /* watched */, QEvent * e)
 {
     if (e->type() == QEvent::KeyPress) {
-        QKeyEvent* ke = (QKeyEvent*) e;
+        auto* ke = (QKeyEvent*) e;
         switch (ke->key()) {
         case Qt::Key_Down:
         case Qt::Key_Left:
         case Qt::Key_Right:
         case Qt::Key_Up:
         case Qt::Key_Delete:
         case Qt::Key_W: {
             if (ke->key() == Qt::Key_W) {
                 if (ke->modifiers() != Qt::ControlModifier)
                     return false;
             } else if (ke->modifiers() != Qt::AltModifier)
                 return false;
 
             int op = -1;
             switch (ke->key()) {
             case Qt::Key_Down:
                 op = EXCLUDE_ID;
                 break;
             case Qt::Key_Left:
                 op = COPY_TO_LEFT_ID;
                 break;
             case Qt::Key_Right:
                 op = COPY_TO_RIGHT_ID;
                 break;
             case Qt::Key_Up:
                 op = RESTORE_ID;
                 break;
             case Qt::Key_Delete:
                 op = DELETE_ID;
                 break;
             case Qt::Key_W:
                 op = REVERSE_DIR_ID;
                 break;
             }
 
             ke->accept();
 
             QTreeWidgetItem *listItem =  syncList->currentItem();
-            if (listItem == 0)
+            if (listItem == nullptr)
                 return true;
 
             SynchronizerFileItem *item = ((SyncViewItem *)listItem)->synchronizerItemRef();
 
             bool hasSelected = false;
             QList<QTreeWidgetItem *> selected = syncList->selectedItems();
             for (int i = 0; i != selected.count(); i++)
                 if (selected[ i ]->isSelected() && !selected[ i ]->isHidden())
                     hasSelected = true;
             if (!hasSelected)
                 listItem->setSelected(true);
 
             executeOperation(item, op);
             return true;
         }
         }
     }
     return false;
 }
 
-void SynchronizerGUI::loadFromProfile(QString profile)
+void SynchronizerGUI::loadFromProfile(const QString& profile)
 {
     syncList->clear();
     synchronizer.reset();
     isComparing = wasClosed = false;
     btnSynchronize->setEnabled(false);
     btnFeedToListBox->setEnabled(false);
 
     KConfigGroup pg(krConfig, profile);
 
     if (!hasSelectedFiles) {
         leftLocation->lineEdit()->setText(pg.readEntry("Left Location", QString()));
         rightLocation->lineEdit()->setText(pg.readEntry("Right Location", QString()));
     }
     fileFilter->lineEdit()->setText(pg.readEntry("Search For", QString()));
 
     cbSubdirs->   setChecked(pg.readEntry("Recurse Subdirectories", true));
     cbSymlinks->  setChecked(pg.readEntry("Follow Symlinks", false));
     cbByContent-> setChecked(pg.readEntry("Compare By Content", false));
     cbIgnoreDate->setChecked(pg.readEntry("Ignore Date", false));
     cbAsymmetric->setChecked(pg.readEntry("Asymmetric", false));
     cbIgnoreCase->setChecked(pg.readEntry("Ignore Case", false));
 
     btnScrollResults->setChecked(pg.readEntry("Scroll Results", false));
 
     btnLeftToRight->setChecked(pg.readEntry("Show Left To Right", true));
     btnEquals     ->setChecked(pg.readEntry("Show Equals", true));
     btnDifferents ->setChecked(pg.readEntry("Show Differents", true));
     btnRightToLeft->setChecked(pg.readEntry("Show Right To Left", true));
     btnDeletable  ->setChecked(pg.readEntry("Show Deletable", true));
     btnDuplicates ->setChecked(pg.readEntry("Show Duplicates", true));
     btnSingles    ->setChecked(pg.readEntry("Show Singles", true));
 
     int equalityThreshold = pg.readEntry("Equality Threshold", 0);
     int equalityCombo = 0;
     convertFromSeconds(equalityThreshold, equalityCombo, equalityThreshold);
     equalitySpinBox->setValue(equalityThreshold);
     equalityUnitCombo->setCurrentIndex(equalityCombo);
 
     int timeShift = pg.readEntry("Time Shift", 0);
     int timeShiftCombo = 0;
     convertFromSeconds(timeShift, timeShiftCombo, timeShift);
     timeShiftSpinBox->setValue(timeShift);
     timeShiftUnitCombo->setCurrentIndex(timeShiftCombo);
 
     int parallelThreads = pg.readEntry("Parallel Threads", 1);
     parallelThreadsSpinBox->setValue(parallelThreads);
 
     bool ignoreHidden = pg.readEntry("Ignore Hidden Files", false);
     ignoreHiddenFilesCB->setChecked(ignoreHidden);
 
     refresh();
 }
 
-void SynchronizerGUI::saveToProfile(QString profile)
+void SynchronizerGUI::saveToProfile(const QString& profile)
 {
     KConfigGroup group(krConfig, profile);
 
     group.writeEntry("Left Location", leftLocation->currentText());
     group.writeEntry("Search For", fileFilter->currentText());
     group.writeEntry("Right Location", rightLocation->currentText());
 
     group.writeEntry("Recurse Subdirectories", cbSubdirs->isChecked());
     group.writeEntry("Follow Symlinks", cbSymlinks->isChecked());
     group.writeEntry("Compare By Content", cbByContent->isChecked());
     group.writeEntry("Ignore Date", cbIgnoreDate->isChecked());
     group.writeEntry("Asymmetric", cbAsymmetric->isChecked());
     group.writeEntry("Ignore Case", cbIgnoreCase->isChecked());
 
     group.writeEntry("Scroll Results", btnScrollResults->isChecked());
 
     group.writeEntry("Show Left To Right", btnLeftToRight->isChecked());
     group.writeEntry("Show Equals", btnEquals->isChecked());
     group.writeEntry("Show Differents", btnDifferents->isChecked());
     group.writeEntry("Show Right To Left", btnRightToLeft->isChecked());
     group.writeEntry("Show Deletable", btnDeletable->isChecked());
     group.writeEntry("Show Duplicates", btnDuplicates->isChecked());
     group.writeEntry("Show Singles", btnSingles->isChecked());
 
     group.writeEntry("Equality Threshold", convertToSeconds(equalitySpinBox->value(), equalityUnitCombo->currentIndex()));
     group.writeEntry("Time Shift", convertToSeconds(timeShiftSpinBox->value(), timeShiftUnitCombo->currentIndex()));
     group.writeEntry("Parallel Threads", parallelThreadsSpinBox->value());
 
     group.writeEntry("Ignore Hidden Files", ignoreHiddenFilesCB->isChecked());
 }
 
 void SynchronizerGUI::connectFilters(const QString &newString)
 {
     if (synchronizerTabs->currentIndex())
         fileFilter->setEditText(newString);
     else
         generalFilter->searchFor->setEditText(newString);
 }
 
 void SynchronizerGUI::setScrolling(bool isOn)
 {
     if (isOn)
         btnScrollResults->setText(i18n("Quiet"));
     else
         btnScrollResults->setText(i18n("Scroll Results"));
 
     synchronizer.setScrolling(isOn);
 }
 
 int SynchronizerGUI::convertToSeconds(int time, int unit)
 {
     switch (unit) {
     case 1:
         return time * 60;
     case 2:
         return time * 3600;
     case 3:
         return time * 86400;
     default:
         return time;
     }
 }
 
 void SynchronizerGUI::convertFromSeconds(int &time, int &unit, int second)
 {
     unit = 0;
     time = second;
     int absTime = (time < 0) ? -time : time;
 
     if (absTime >= 86400 && (absTime % 86400) == 0) {
         time /= 86400;
         unit = 3;
     } else if (absTime >= 3600 && (absTime % 3600) == 0) {
         time /= 3600;
         unit = 2;
     } else if (absTime >= 60 && (absTime % 60) == 0) {
         time /= 60;
         unit = 1;
     }
 }
 
 QPushButton *SynchronizerGUI::createButton(QWidget *parent, const QString &iconName, bool checked,
                                            const QKeySequence &shortCut, const QString &description,
                                            const QString &text, bool textAndIcon)
 {
-    QPushButton *button = new QPushButton(parent);
+    auto *button = new QPushButton(parent);
     bool iconExists = Icon::exists(iconName);
     if (!text.isEmpty() && (textAndIcon || !iconExists)) {
         button->setText(text);
     }
     if (iconExists) {
         button->setIcon(Icon(iconName));
     }
     button->setCheckable(true);
     button->setChecked(checked);
     button->setShortcut(shortCut);
     const QString infoText =
         QString("%1 (%2)").arg(description, shortCut.toString(QKeySequence::NativeText));
     button->setWhatsThis(infoText);
     button->setToolTip(infoText);
     return button;
 }
 
 void SynchronizerGUI::copyToClipboard(bool isLeft)
 {
     QList<QUrl> urls;
 
     unsigned              ndx = 0;
     SynchronizerFileItem  *currentItem;
 
-    while ((currentItem = synchronizer.getItemAt(ndx++)) != 0) {
-        SynchronizerGUI::SyncViewItem *viewItem = (SynchronizerGUI::SyncViewItem *)currentItem->userData();
+    while ((currentItem = synchronizer.getItemAt(ndx++)) != nullptr) {
+        auto *viewItem = (SynchronizerGUI::SyncViewItem *)currentItem->userData();
 
         if (!viewItem || !viewItem->isSelected() || viewItem->isHidden())
             continue;
 
         SynchronizerFileItem *item = viewItem->synchronizerItemRef();
         if (item) {
             if (isLeft && item->existsInLeft()) {
                 QString leftDirName = item->leftDirectory().isEmpty() ? "" : item->leftDirectory() + '/';
                 QUrl leftURL = Synchronizer::fsUrl(synchronizer.leftBaseDirectory()  + leftDirName + item->leftName());
                 urls.push_back(leftURL);
             } else if (!isLeft && item->existsInRight()) {
                 QString rightDirName = item->rightDirectory().isEmpty() ? "" : item->rightDirectory() + '/';
                 QUrl rightURL = Synchronizer::fsUrl(synchronizer.rightBaseDirectory()  + rightDirName + item->rightName());
                 urls.push_back(rightURL);
             }
         }
     }
 
     if (urls.count() == 0)
         return;
 
-    QMimeData *mimeData = new QMimeData;
+    auto *mimeData = new QMimeData;
     mimeData->setImageData(FileListIcon(isLeft ? "arrow-left-double" : "arrow-right-double").pixmap());
     mimeData->setUrls(urls);
 
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
 }
 
 QString SynchronizerGUI::dirLabel()
 {
     //HACK add <> brackets AFTER translating - otherwise KUIT thinks it's a tag
     static QString label = QString("<") +
         i18nc("Show the string 'DIR' instead of file size in detailed view (for folders)", "DIR") + '>';
     return label;
 }
 
diff --git a/krusader/Synchronizer/synchronizergui.h b/krusader/Synchronizer/synchronizergui.h
index 63cd2348..eccd9aec 100644
--- a/krusader/Synchronizer/synchronizergui.h
+++ b/krusader/Synchronizer/synchronizergui.h
@@ -1,252 +1,253 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SYNCHRONIZERGUI_H
 #define SYNCHRONIZERGUI_H
 
 // QtCore
 #include <QMap>
 // QtGui
 #include <QResizeEvent>
 #include <QKeyEvent>
 #include <QPixmap>
 // QtWidgets
 #include <QCheckBox>
 #include <QDialog>
 #include <QLabel>
 #include <QTabWidget>
 
 #include <KCompletion/KComboBox>
+#include <utility>
 
 #include "synchronizer.h"
 #include "../GUI/profilemanager.h"
 #include "../GUI/krtreewidget.h"
 #include "../Filter/filtertabs.h"
 #include "../Filter/generalfilter.h"
 
 class QSpinBox;
 
 class SynchronizerGUI : public QDialog
 {
     Q_OBJECT
 
 public:
     class SyncViewItem : public QTreeWidgetItem
     {
     private:
         SynchronizerFileItem *syncItemRef;
         SyncViewItem         *lastItemRef;
 
     public:
-        SyncViewItem(SynchronizerFileItem *item, QColor txt, QColor base, QTreeWidget * parent, QTreeWidgetItem *after, QString label1,
-                     QString label2 = QString(), QString label3 = QString(), QString label4 = QString(),
-                     QString label5 = QString(), QString label6 = QString(),
-                     QString label7 = QString(), QString label8 = QString()) :
-                QTreeWidgetItem(parent, after), syncItemRef(item), lastItemRef(0) {
+        SyncViewItem(SynchronizerFileItem *item, QColor txt, QColor base, QTreeWidget * parent, QTreeWidgetItem *after, const QString& label1,
+                     const QString& label2 = QString(), const QString& label3 = QString(), const QString& label4 = QString(),
+                     const QString& label5 = QString(), const QString& label6 = QString(),
+                     const QString& label7 = QString(), const QString& label8 = QString()) :
+                QTreeWidgetItem(parent, after), syncItemRef(item), lastItemRef(nullptr) {
             setText(0, label1);
             setText(1, label2);
             setText(2, label3);
             setText(3, label4);
             setText(4, label5);
             setText(5, label6);
             setText(6, label7);
             setText(7, label8);
 
             setTextAlignment(1, Qt::AlignRight);
             setTextAlignment(3, Qt::AlignHCenter);
             setTextAlignment(5, Qt::AlignRight);
             item->setUserData((void *)this);
 
-            setColors(txt, base);
+            setColors(std::move(txt), std::move(base));
         }
 
-        SyncViewItem(SynchronizerFileItem *item, QColor txt, QColor base, QTreeWidgetItem * parent, QTreeWidgetItem *after, QString label1,
-                     QString label2 = QString(), QString label3 = QString(), QString label4 = QString(),
-                     QString label5 = QString(), QString label6 = QString(),
-                     QString label7 = QString(), QString label8 = QString()) :
-                QTreeWidgetItem(parent, after), syncItemRef(item), lastItemRef(0) {
+        SyncViewItem(SynchronizerFileItem *item, QColor txt, QColor base, QTreeWidgetItem * parent, QTreeWidgetItem *after, const QString& label1,
+                     const QString& label2 = QString(), const QString& label3 = QString(), const QString& label4 = QString(),
+                     const QString& label5 = QString(), const QString& label6 = QString(),
+                     const QString& label7 = QString(), const QString& label8 = QString()) :
+                QTreeWidgetItem(parent, after), syncItemRef(item), lastItemRef(nullptr) {
             setText(0, label1);
             setText(1, label2);
             setText(2, label3);
             setText(3, label4);
             setText(4, label5);
             setText(5, label6);
             setText(6, label7);
             setText(7, label8);
 
             setTextAlignment(1, Qt::AlignRight);
             setTextAlignment(3, Qt::AlignHCenter);
             setTextAlignment(5, Qt::AlignRight);
             item->setUserData((void *)this);
 
-            setColors(txt, base);
+            setColors(std::move(txt), std::move(base));
         }
 
-        ~SyncViewItem() {
-            syncItemRef->setUserData(0);
+        ~SyncViewItem() override {
+            syncItemRef->setUserData(nullptr);
         }
 
         inline SynchronizerFileItem * synchronizerItemRef()       {
             return syncItemRef;
         }
         inline SyncViewItem         * lastItem()                  {
             return lastItemRef;
         }
         inline void                   setLastItem(SyncViewItem*s) {
             lastItemRef = s;
         }
 
-        void setColors(QColor fore, QColor back) {
+        void setColors(const QColor& fore, const QColor& back) {
             QBrush textColor(fore);
             QBrush baseColor(back);
 
             for (int i = 0; i != columnCount(); i++) {
                 if (back.isValid())
                     setBackground(i, baseColor);
                 if (fore.isValid())
                     setForeground(i, textColor);
             }
         }
     };
 
 public:
     // if rightDirectory is null, leftDirectory is actually the profile name to load
     SynchronizerGUI(QWidget* parent,  QUrl leftDirectory, QUrl rightDirectory = QUrl(), QStringList selList = QStringList());
     SynchronizerGUI(QWidget* parent,  QString profile);
-    ~SynchronizerGUI();
+    ~SynchronizerGUI() override;
 
     inline bool wasSynchronization()    {
         return wasSync;
     }
 
 public slots:
     void rightMouseClicked(QTreeWidgetItem *, const QPoint &);
     void doubleClicked(QTreeWidgetItem *);
     void compare();
     void synchronize();
     void stop();
     void feedToListBox();
     void closeDialog();
     void refresh();
     void swapSides();
-    void loadFromProfile(QString);
-    void saveToProfile(QString);
+    void loadFromProfile(const QString&);
+    void saveToProfile(const QString&);
 
 protected slots:
     void reject() Q_DECL_OVERRIDE;
     void addFile(SynchronizerFileItem *);
     void markChanged(SynchronizerFileItem *, bool);
     void setScrolling(bool);
-    void statusInfo(QString);
+    void statusInfo(const QString&);
     void subdirsChecked(bool);
     void setPanelLabels();
     void setCompletion();
     void checkExcludeURLValidity(QString &text, QString &error);
     void connectFilters(const QString &);
 
 private:
-    void initGUI(QString profile, QUrl leftURL, QUrl rightURL, QStringList selList);
+    void initGUI(const QString& profile, QUrl leftURL, QUrl rightURL, QStringList selList);
 
     QString convertTime(time_t time) const;
     void    setMarkFlags();
     void    disableMarkButtons();
     void    enableMarkButtons();
     void    copyToClipboard(bool isLeft);
 
     int     convertToSeconds(int time, int unit);
     void    convertFromSeconds(int &time, int &unit, int second);
 
     static QPushButton *createButton(QWidget *parent, const QString &iconName, bool checked,
                                      const QKeySequence &shortCut, const QString &description,
                                      const QString &text = QString(), bool textAndIcon = false);
 
 protected:
-    virtual void keyPressEvent(QKeyEvent *) Q_DECL_OVERRIDE;
-    virtual void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
-    virtual bool eventFilter(QObject *, QEvent *) Q_DECL_OVERRIDE;
+    void keyPressEvent(QKeyEvent *) Q_DECL_OVERRIDE;
+    void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
+    bool eventFilter(QObject *, QEvent *) Q_DECL_OVERRIDE;
 
     void executeOperation(SynchronizerFileItem *item, int op);
 
     ProfileManager *profileManager;
     FilterTabs     *filterTabs;
     GeneralFilter  *generalFilter;
 
     QTabWidget    *synchronizerTabs;
 
     KHistoryComboBox *leftLocation;
     KHistoryComboBox *rightLocation;
     KHistoryComboBox *fileFilter;
 
     KrTreeWidget  *syncList;
     Synchronizer   synchronizer;
 
     QCheckBox     *cbSubdirs;
     QCheckBox     *cbSymlinks;
     QCheckBox     *cbByContent;
     QCheckBox     *cbIgnoreDate;
     QCheckBox     *cbAsymmetric;
     QCheckBox     *cbIgnoreCase;
 
     QPushButton   *btnSwapSides;
     QPushButton   *btnCompareDirs;
     QPushButton   *btnStopComparing;
     QPushButton   *btnSynchronize;
     QPushButton   *btnFeedToListBox;
     QPushButton   *btnScrollResults;
 
     QPushButton   *btnLeftToRight;
     QPushButton   *btnEquals;
     QPushButton   *btnDifferents;
     QPushButton   *btnRightToLeft;
     QPushButton   *btnDeletable;
     QPushButton   *btnDuplicates;
     QPushButton   *btnSingles;
 
     QLabel        *statusLabel;
     QLabel        *leftDirLabel;
     QLabel        *rightDirLabel;
 
     QStringList    selectedFiles;
 
     QSpinBox      *parallelThreadsSpinBox;
     QSpinBox      *equalitySpinBox;
     QComboBox     *equalityUnitCombo;
     QSpinBox      *timeShiftSpinBox;
     QComboBox     *timeShiftUnitCombo;
     QCheckBox     *ignoreHiddenFilesCB;
 
 private:
     static QString dirLabel(); // returns translated '<DIR>'
 
     bool           isComparing;
     bool           wasClosed;
     bool           wasSync;
     bool           firstResize;
     bool           hasSelectedFiles;
     SyncViewItem  *lastItem;
 
     int            sizeX;
     int            sizeY;
 
     QColor         foreGrounds[ TT_MAX ];
     QColor         backGrounds[ TT_MAX ];
 };
 
 #endif /* __SYNCHRONIZERGUI_H__ */
diff --git a/krusader/Synchronizer/synchronizertask.cpp b/krusader/Synchronizer/synchronizertask.cpp
index 549e23af..b4bd6168 100644
--- a/krusader/Synchronizer/synchronizertask.cpp
+++ b/krusader/Synchronizer/synchronizertask.cpp
@@ -1,341 +1,341 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "synchronizertask.h"
 
 // QtCore
 #include <QTimer>
 #include <QFile>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "synchronizer.h"
 #include "synchronizerfileitem.h"
 #include "synchronizerdirlist.h"
 #include "../FileSystem/filesystem.h"
 
 CompareTask::CompareTask(SynchronizerFileItem *parentIn, const QString &leftURL,
                          const QString &rightURL, const QString &leftDir,
-                         const QString &rightDir, bool hidden) : SynchronizerTask(),  m_parent(parentIn),
+                         const QString &rightDir, bool hidden) :  m_parent(parentIn),
         m_url(leftURL), m_dir(leftDir), m_otherUrl(rightURL),
         m_otherDir(rightDir), m_duplicate(true),
-        m_dirList(0), m_otherDirList(0)
+        m_dirList(nullptr), m_otherDirList(nullptr)
 {
     ignoreHidden = hidden;
 }
 
 CompareTask::CompareTask(SynchronizerFileItem *parentIn, const QString &urlIn,
-                         const QString &dirIn, bool isLeftIn, bool hidden) : SynchronizerTask(),
+                         const QString &dirIn, bool isLeftIn, bool hidden) :
         m_parent(parentIn), m_url(urlIn), m_dir(dirIn),
         m_isLeft(isLeftIn), m_duplicate(false),
-        m_dirList(0), m_otherDirList(0)
+        m_dirList(nullptr), m_otherDirList(nullptr)
 {
     ignoreHidden = hidden;
 }
 
 CompareTask::~CompareTask()
 {
     if (m_dirList) {
         delete m_dirList;
-        m_dirList = 0;
+        m_dirList = nullptr;
     }
     if (m_otherDirList) {
         delete m_otherDirList;
-        m_otherDirList = 0;
+        m_otherDirList = nullptr;
     }
 }
 
 void CompareTask::start()
 {
     if (m_state == ST_STATE_NEW) {
         m_state = ST_STATE_PENDING;
         m_loadFinished = m_otherLoadFinished = false;
 
         m_dirList = new SynchronizerDirList(parentWidget, ignoreHidden);
         connect(m_dirList, &SynchronizerDirList::finished, this, &CompareTask::slotFinished);
         m_dirList->load(m_url, false);
 
         if (m_duplicate) {
             m_otherDirList = new SynchronizerDirList(parentWidget, ignoreHidden);
             connect(m_otherDirList, &SynchronizerDirList::finished, this, &CompareTask::slotOtherFinished);
             m_otherDirList->load(m_otherUrl, false);
         }
     }
 }
 
 void CompareTask::slotFinished(bool result)
 {
     if (!result) {
         m_state = ST_STATE_ERROR;
         return;
     }
     m_loadFinished = true;
 
     if (m_otherLoadFinished || !m_duplicate)
         m_state = ST_STATE_READY;
 }
 
 
 void CompareTask::slotOtherFinished(bool result)
 {
     if (!result) {
         m_state = ST_STATE_ERROR;
         return;
     }
     m_otherLoadFinished = true;
 
     if (m_loadFinished)
         m_state = ST_STATE_READY;
 }
 
 CompareContentTask::CompareContentTask(Synchronizer *syn, SynchronizerFileItem *itemIn, const QUrl &leftURLIn,
-                                       const QUrl &rightURLIn, KIO::filesize_t sizeIn) : SynchronizerTask(),
+                                       const QUrl &rightURLIn, KIO::filesize_t sizeIn) :
         leftURL(leftURLIn), rightURL(rightURLIn),
-        size(sizeIn), errorPrinted(false), leftReadJob(0),
-        rightReadJob(0), compareArray(), owner(-1), item(itemIn), timer(0),
-        leftFile(0), rightFile(0), received(0), sync(syn)
+        size(sizeIn), errorPrinted(false), leftReadJob(nullptr),
+        rightReadJob(nullptr), compareArray(), owner(-1), item(itemIn), timer(nullptr),
+        leftFile(nullptr), rightFile(nullptr), received(0), sync(syn)
 {
 }
 
 CompareContentTask::~CompareContentTask()
 {
     abortContentComparing();
 
     if (timer)
         delete timer;
     if (leftFile)
         delete leftFile;
     if (rightFile)
         delete rightFile;
 }
 
 void CompareContentTask::start()
 {
     m_state = ST_STATE_PENDING;
 
     if (leftURL.isLocalFile() && rightURL.isLocalFile()) {
         leftFile = new QFile(leftURL.path());
         if (!leftFile->open(QIODevice::ReadOnly)) {
             KMessageBox::error(parentWidget, i18n("Error at opening %1.", leftURL.path()));
             m_state = ST_STATE_ERROR;
             return;
         }
 
         rightFile = new QFile(rightURL.path());
         if (!rightFile->open(QIODevice::ReadOnly)) {
             KMessageBox::error(parentWidget, i18n("Error at opening %1.", rightURL.path()));
             m_state = ST_STATE_ERROR;
             return;
         }
 
         timer = new QTimer(this);
         connect(timer, &QTimer::timeout, this, &CompareContentTask::sendStatusMessage);
         timer->setSingleShot(true);
         timer->start(1000);
 
         localFileCompareCycle();
     } else {
         leftReadJob = KIO::get(leftURL, KIO::NoReload, KIO::HideProgressInfo);
         rightReadJob = KIO::get(rightURL, KIO::NoReload, KIO::HideProgressInfo);
 
         connect(leftReadJob, &KIO::TransferJob::data, this, &CompareContentTask::slotDataReceived);
         connect(rightReadJob, &KIO::TransferJob::data, this, &CompareContentTask::slotDataReceived);
         connect(leftReadJob, &KIO::TransferJob::result, this, &CompareContentTask::slotFinished);
         connect(rightReadJob, &KIO::TransferJob::result, this, &CompareContentTask::slotFinished);
 
         rightReadJob->suspend();
 
         timer = new QTimer(this);
         connect(timer, &QTimer::timeout, this, &CompareContentTask::sendStatusMessage);
         timer->setSingleShot(true);
         timer->start(1000);
     }
 }
 
 void CompareContentTask::localFileCompareCycle()
 {
 
     bool different = false;
 
     char leftBuffer[ 1440 ];
     char rightBuffer[ 1440 ];
 
     QTime timer;
     timer.start();
 
     int cnt = 0;
 
     while (!leftFile->atEnd() && !rightFile->atEnd()) {
         int leftBytes = leftFile->read(leftBuffer, sizeof(leftBuffer));
         int rightBytes = rightFile->read(rightBuffer, sizeof(rightBuffer));
 
         if (leftBytes != rightBytes) {
             different = true;
             break;
         }
 
         if (leftBytes <= 0)
             break;
 
         received += leftBytes;
 
         if (memcmp(leftBuffer, rightBuffer, leftBytes)) {
             different = true;
             break;
         }
 
         if ((++cnt % 16) == 0 && timer.elapsed() >= 250)
             break;
     }
 
     if (different) {
         sync->compareContentResult(item, false);
         m_state = ST_STATE_READY;
         return;
     }
 
     if (leftFile->atEnd() && rightFile->atEnd()) {
         sync->compareContentResult(item, true);
         m_state = ST_STATE_READY;
         return;
     }
 
     QTimer::singleShot(0, this, &CompareContentTask::localFileCompareCycle);
 }
 
 
 void CompareContentTask::slotDataReceived(KIO::Job *job, const QByteArray &data)
 {
     int jobowner = (job == leftReadJob) ? 1 : 0;
     int bufferLen = compareArray.size();
     int dataLen   = data.size();
 
     if (job == leftReadJob)
         received += dataLen;
 
     if (jobowner == owner) {
         compareArray.append(data);
         return;
     }
 
     do {
         if (bufferLen == 0) {
             compareArray = QByteArray(data.data(), dataLen);
             owner = jobowner;
             break;
         }
 
         int minSize   = (dataLen < bufferLen) ? dataLen : bufferLen;
 
         for (int i = 0; i != minSize; i++)
             if (data[i] != compareArray[i]) {
                 abortContentComparing();
                 return;
             }
 
         if (minSize == bufferLen) {
             compareArray = QByteArray(data.data() + bufferLen, dataLen - bufferLen);
             if (dataLen == bufferLen) {
                 owner = -1;
                 return;
             }
             owner = jobowner;
             break;
         } else {
             compareArray = QByteArray(compareArray.data() + dataLen, bufferLen - dataLen);
             return;
         }
 
     } while (false);
 
     KIO::TransferJob *otherJob = (job == leftReadJob) ? rightReadJob : leftReadJob;
 
-    if (otherJob == 0) {
+    if (otherJob == nullptr) {
         if (compareArray.size())
             abortContentComparing();
     } else {
         if (!((KIO::TransferJob *)job)->isSuspended()) {
             ((KIO::TransferJob *)job)->suspend();
             otherJob->resume();
         }
     }
 }
 
 void CompareContentTask::slotFinished(KJob *job)
 {
     KIO::TransferJob *otherJob = (job == leftReadJob) ? rightReadJob : leftReadJob;
 
     if (job == leftReadJob)
-        leftReadJob = 0;
+        leftReadJob = nullptr;
     else
-        rightReadJob = 0;
+        rightReadJob = nullptr;
 
     if (otherJob)
         otherJob->resume();
 
     if (job->error()) {
         timer->stop();
         abortContentComparing();
     }
 
     if (job->error() && job->error() != KIO::ERR_USER_CANCELED && !errorPrinted) {
         errorPrinted = true;
         KMessageBox::error(parentWidget, i18n("I/O error while comparing file %1 with %2.",
                                               leftURL.toDisplayString(QUrl::PreferLocalFile),
                                               rightURL.toDisplayString(QUrl::PreferLocalFile)));
     }
 
-    if (leftReadJob == 0 && rightReadJob == 0) {
+    if (leftReadJob == nullptr && rightReadJob == nullptr) {
         if (!compareArray.size())
             sync->compareContentResult(item, true);
         else
             sync->compareContentResult(item, false);
 
         m_state = ST_STATE_READY;
     }
 }
 
 void CompareContentTask::abortContentComparing()
 {
     if (timer)
         timer->stop();
 
     if (leftReadJob)
         leftReadJob->kill(KJob::EmitResult);
     if (rightReadJob)
         rightReadJob->kill(KJob::EmitResult);
 
     if (item->task() >= TT_UNKNOWN)
         sync->compareContentResult(item, false);
 
     m_state = ST_STATE_READY;
 }
 
 void CompareContentTask::sendStatusMessage()
 {
     double perc = (size == 0) ? 1. : (double)received / (double)size;
-    int percent = (int)(perc * 10000. + 0.5);
+    auto percent = (int)(perc * 10000. + 0.5);
     QString statstr = QString("%1.%2%3").arg(percent / 100).arg((percent / 10) % 10).arg(percent % 10) + '%';
     setStatusMessage(i18n("Comparing file %1 (%2)...", leftURL.fileName(), statstr));
     timer->setSingleShot(true);
     timer->start(500);
 }
 
diff --git a/krusader/Synchronizer/synchronizertask.h b/krusader/Synchronizer/synchronizertask.h
index 68e4eeca..b863094e 100644
--- a/krusader/Synchronizer/synchronizertask.h
+++ b/krusader/Synchronizer/synchronizertask.h
@@ -1,190 +1,190 @@
 /*****************************************************************************
  * Copyright (C) 2006 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef SYNCHRONIZERTASK_H
 #define SYNCHRONIZERTASK_H
 
 // QtCore
 #include <QObject>
 
 #include <KIO/Job>
 
 class Synchronizer;
 class SynchronizerDirList;
 class SynchronizerFileItem;
 class QTimer;
 class QFile;
 
 #define ST_STATE_NEW      0
 #define ST_STATE_PENDING  1
 #define ST_STATE_STATUS   2
 #define ST_STATE_READY    3
 #define ST_STATE_ERROR    4
 
 class SynchronizerTask : public QObject
 {
     Q_OBJECT
 
 public:
-    SynchronizerTask() : QObject(), m_state(ST_STATE_NEW), m_statusMessage(QString()) {}
-    virtual ~SynchronizerTask() {}
+    SynchronizerTask() : m_state(ST_STATE_NEW), m_statusMessage(QString()) {}
+    ~SynchronizerTask() override = default;
 
     inline int start(QWidget *parentWidget) {
         this->parentWidget = parentWidget; start(); return state();
     }
 
     inline int  state() {
         return m_state;
     }
 
     void setStatusMessage(const QString & statMsg) {
         if (m_state == ST_STATE_PENDING || m_state == ST_STATE_STATUS)
             m_state = ST_STATE_STATUS;
         m_statusMessage = statMsg;
     }
 
     QString status() {
         if (m_state == ST_STATE_STATUS) {
             m_state = ST_STATE_PENDING;
             return m_statusMessage;
         }
         return QString();
     }
 
 protected:
     virtual void start() {}
     int m_state;
     QString m_statusMessage;
     QWidget *parentWidget;
 };
 
 
 class CompareTask : public SynchronizerTask
 {
     Q_OBJECT
 
 public:
     CompareTask(SynchronizerFileItem *parentIn, const QString &leftURL,
                 const QString &rightURL, const QString &leftDir,
                 const QString &rightDir, bool ignoreHidden);
     CompareTask(SynchronizerFileItem *parentIn, const QString &urlIn,
                 const QString &dirIn, bool isLeftIn, bool ignoreHidden);
-    virtual ~CompareTask();
+    ~CompareTask() override;
 
     inline bool isDuplicate()                      {
         return m_duplicate;
     }
     inline bool isLeft()                           {
         return !m_duplicate && m_isLeft;
     }
     inline const QString & leftURL()               {
         return m_url;
     }
     inline const QString & rightURL()              {
         return m_otherUrl;
     }
     inline const QString & leftDir()               {
         return m_dir;
     }
     inline const QString & rightDir()              {
         return m_otherDir;
     }
     inline const QString & url()                   {
         return m_url;
     }
     inline const QString & dir()                   {
         return m_dir;
     }
     inline SynchronizerFileItem * parent()         {
         return m_parent;
     }
     inline SynchronizerDirList * leftDirList()     {
         return m_dirList;
     }
     inline SynchronizerDirList * rightDirList()    {
         return m_otherDirList;
     }
     inline SynchronizerDirList * dirList()         {
         return m_dirList;
     }
 
 protected slots:
-    virtual void start() Q_DECL_OVERRIDE;
+    void start() Q_DECL_OVERRIDE;
     void slotFinished(bool result);
     void slotOtherFinished(bool result);
 
 private:
     SynchronizerFileItem * m_parent;
     QString m_url;
     QString m_dir;
     QString m_otherUrl;
     QString m_otherDir;
     bool m_isLeft;
     bool m_duplicate;
     SynchronizerDirList * m_dirList;
     SynchronizerDirList * m_otherDirList;
     bool m_loadFinished;
     bool m_otherLoadFinished;
     bool ignoreHidden;
 };
 
 
 class CompareContentTask : public SynchronizerTask
 {
     Q_OBJECT
 
 public:
     CompareContentTask(Synchronizer *, SynchronizerFileItem *, const QUrl &, const QUrl &, KIO::filesize_t);
-    virtual ~CompareContentTask();
+    ~CompareContentTask() override;
 
 public slots:
     void    slotDataReceived(KIO::Job *job, const QByteArray &data);
     void    slotFinished(KJob *job);
     void    sendStatusMessage();
 
 protected:
-    virtual void start() Q_DECL_OVERRIDE;
+    void start() Q_DECL_OVERRIDE;
 
 protected slots:
     void    localFileCompareCycle();
 
 private:
     void    abortContentComparing();
 
     QUrl                   leftURL;        // the currently processed URL (left)
     QUrl                   rightURL;       // the currently processed URL (right)
     KIO::filesize_t        size;           // the size of the compared files
 
     bool                   errorPrinted;   // flag indicates error
     KIO::TransferJob      *leftReadJob;    // compare left read job
     KIO::TransferJob      *rightReadJob;   // compare right read job
     QByteArray             compareArray;   // the array for comparing
     int                    owner;          // the owner of the compare array
     SynchronizerFileItem  *item;           // the item for content compare
     QTimer                *timer;          // timer to show the process dialog at compare by content
 
     QFile                 *leftFile;       // the left side local file
     QFile                 *rightFile;      // the right side local file
 
     KIO::filesize_t        received;       // the received size
     Synchronizer          *sync;
 };
 
 #endif /* __SYNCHRONIZER_TASK_H__ */
diff --git a/krusader/UserAction/expander.cpp b/krusader/UserAction/expander.cpp
index d57e3bde..239c0197 100644
--- a/krusader/UserAction/expander.cpp
+++ b/krusader/UserAction/expander.cpp
@@ -1,1223 +1,1222 @@
 /*****************************************************************************
  * Copyright (C) 2004 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2004 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "expander.h"
 
 #include "../krusader.h"
 #include "../krusaderview.h"
 #include "../panelmanager.h"
 #include "../Panel/listpanel.h"
 #include "../Panel/panelfunc.h"
 #include "../Panel/PanelView/krview.h"
 #include "../Search/krsearchdialog.h"
 #include "../GUI/profilemanager.h"
 #include "../FileSystem/filesystemprovider.h"
 #include "../KViewer/krviewer.h"
 #include "../krservices.h"
 
 #ifdef SYNCHRONIZER_ENABLED
 #include "../Synchronizer/synchronizergui.h"
 #endif
 
 #ifdef __KJSEMBED__
 #include "../KrJS/krjs.h"
 #endif
 
 // QtCore
 #include <QDebug>
 #include <QStringList>
 #include <QTextStream>
 #include <QList>
 #include <QTemporaryFile>
 // QtGui
 #include <QClipboard>
 // QtWidgets
 #include <QApplication>
 #include <QInputDialog>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include <functional>
 #include <algorithm>
 using namespace std;
 
 #define NEED_PANEL if (panel==0) { panelMissingError(_expression,exp); return QString(); }
 
 
 inline void exp_placeholder::setError(Expander& exp, const Error& e)
 {
     exp.setError(e);
 }
 inline QStringList exp_placeholder::splitEach(const TagString& s)
 {
     return Expander::splitEach(s);
 }
 inline exp_placeholder::exp_placeholder()
-{
-}
+= default;
 
 void exp_placeholder::panelMissingError(const QString &s, Expander& exp)
 {
     exp.setError(Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Needed panel specification missing in expander %1", s)));
 }
 
 QStringList exp_placeholder::fileList(const KrPanel* const panel, const QString& type, const QString& mask, const bool omitPath, const bool useUrl, Expander& exp, const QString& error)
 {
     QStringList items;
     if (type.isEmpty() || type == "all")
         panel->view->getItemsByMask(mask, &items);
     else if (type == "files")
         panel->view->getItemsByMask(mask, &items, false, true);
     else if (type == "dirs")
         panel->view->getItemsByMask(mask, &items, true, false);
     else if (type == "selected")
         panel->view->getSelectedItems(&items);
     else {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: Bad argument to %1: %2 is not valid item specifier", error, type)));
         return QStringList();
     }
     if (!omitPath) {    // add the current path
         // translate to urls using filesystem
         QList<QUrl> list = panel->func->files()->getUrls(items);
         items.clear();
         // parse everything to a single qstring
         foreach(const QUrl &url, list) {
             items.push_back(useUrl ? url.url() : url.path());
         }
     }
 
     return items;
 }
 
 namespace
 {
 
 class exp_simpleplaceholder : public exp_placeholder
 {
 public:
     EXP_FUNC Q_DECL_OVERRIDE;
     virtual TagString expFunc(const KrPanel*, const QStringList&, const bool&, Expander&) const = 0;
 };
 
 
 #define PLACEHOLDER_CLASS(name) \
     class name : public exp_placeholder { \
     public: \
         name(); \
         virtual TagString expFunc ( const KrPanel*, const TagStringList&, const bool&, Expander& ) const Q_DECL_OVERRIDE; \
     };
 
 #define SIMPLE_PLACEHOLDER_CLASS(name) \
     class name : public exp_simpleplaceholder { \
     public: \
         using exp_simpleplaceholder::expFunc; \
         name(); \
         virtual TagString expFunc ( const KrPanel*, const QStringList&, const bool&, Expander& ) const Q_DECL_OVERRIDE; \
     };
 
 
 /**
   * expands %_Path% ('_' is replaced by 'a', 'o', 'r' or 'l' to indicate the active, other, right or left panel) with the path of the specified panel
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Path)
 
 /**
   * expands %_Count% ('_' is replaced by 'a', 'o', 'r' or 'l' to indicate the active, other, right or left panel) with the number of items, which type is specified by the first Parameter
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Count)
 
 /**
   * expands %_Filter% ('_' is replaced by 'a', 'o', 'r' or 'l' to indicate the active, other, right or left panel) with the correspondent filter (ie: "*.cpp")
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Filter)
 
 /**
   * expands %_Current% ('_' is replaced by 'a', 'o', 'r' or 'l' to indicate the active, other, right or left panel) with the current item ( != the selected ones)
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Current);
 
 /**
   * expands %_List% ('_' is replaced by 'a', 'o', 'r' or 'l' to indicate the active, other, right or left panel) with a list of items, which type is specified by the first Parameter
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_List);
 
 /**
  * expands %_ListFile% ('_' is replaced by 'a', 'o', 'r' or 'l' to indicate
  * the active, other, right or left panel) with the name of a temporary file,
  * containing a list of items, which type is specified by the first Parameter
  */
 SIMPLE_PLACEHOLDER_CLASS(exp_ListFile);
 
 /**
  * expands %_Ask% ('_' is necessary because there is no panel needed)
  * with the return of an input-dialog
  */
 SIMPLE_PLACEHOLDER_CLASS(exp_Ask);
 
 /**
  * This copies it's first Parameter to the clipboard
  */
 PLACEHOLDER_CLASS(exp_Clipboard);
 
 /**
   * This selects all items by the mask given with the first Parameter
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Select);
 
 /**
   * This changes the panel'spath to the value given with the first Parameter.
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Goto);
 
 /**
   * This is equal to 'cp <first Parameter> <second Parameter>'.
   */
 PLACEHOLDER_CLASS(exp_Copy);
 
 /**
   * This is equal to 'mv <first Parameter> <second Parameter>'.
   */
 PLACEHOLDER_CLASS(exp_Move);
 
 #ifdef SYNCHRONIZER_ENABLED
 /**
   * This opens the synchronizer with a given profile
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Sync);
 #endif
 
 /**
   * This opens the searchmodule with a given profile
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_NewSearch);
 
 /**
   * This loads the panel-profile with a given name
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Profile);
 
 /**
   * This is setting marks in the string where he is later split up for each {all, selected, files, dirs}
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Each);
 
 /**
   * This sets the sorting on a specific column
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_ColSort);
 
 /**
   * This sets relation between the left and right panel
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_PanelSize);
 
 #ifdef __KJSEMBED__
 /**
   * This sets relation between the left and right panel
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_Script);
 
 #endif
 
 /**
   * This loads a file in the internal viewer
   */
 SIMPLE_PLACEHOLDER_CLASS(exp_View);
 
 ////////////////////////////////////////////////////////////
 //////////////////////// utils ////////////////////////
 ////////////////////////////////////////////////////////////
 
 /**
  * escapes everything that confuses bash in filenames
  * @param s String to manipulate
  * @return escaped string
  */
 QString bashquote(QString s)
 {
     /*
     // we _can_not_ use this function because it _encloses_ the sting in single-quotes!
     // In this case quotes strings could not be concatenated anymore
     return KrServices::quote(s);
     */
 
     static const QString evilstuff = "\\\"'`()[]{}!?;$&<>| \t\r\n";  // stuff that should get escaped
 
-    for (int i = 0; i < evilstuff.length(); ++i)
-        s.replace(evilstuff[ i ], ('\\' + evilstuff[ i ]));
+    for (auto i : evilstuff)
+        s.replace(i, ('\\' + i));
 
     return s;
 }
 
 QString separateAndQuote(QStringList list, const QString& separator, const bool quote)
 {
     if (quote)
         transform(list.begin(), list.end(), list.begin(), bashquote);
 
     // QLineEdit::text() always escapes special characters, revert this for newline and tab
     QString decodedSeparator = separator;
     decodedSeparator.replace("\\n", "\n").replace("\\t", "\t");
     return list.join(decodedSeparator);
 }
 /////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////// expander classes ////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 exp_Path::exp_Path()
 {
     _expression = "Path";
     _description = i18n("Panel's Path...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Automatically escape spaces"), "__yes", false));
 }
 TagString exp_Path::expFunc(const KrPanel* panel, const QStringList& parameter, const bool& useUrl, Expander& exp) const
 {
     NEED_PANEL
 
     QString result;
 
     if (useUrl)
         result = panel->func->files()->currentDirectory().url() + '/';
     else
         result = panel->func->files()->currentDirectory().path() + '/';
 
     if (parameter.count() > 0 && parameter[0].toLower() == "no")    // don't escape spaces
         return TagString(result);
     else
         return TagString(bashquote(result));
 }
 
 exp_Count::exp_Count()
 {
     _expression = "Count";
     _description = i18n("Number of...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Count:"), "__choose:All;Files;Dirs;Selected", false));
 }
 TagString exp_Count::expFunc(const KrPanel* panel, const QStringList& parameter, const bool&, Expander& exp) const
 {
     NEED_PANEL
 
     int n = -1;
     if (parameter.count() == 0 || parameter[ 0 ].isEmpty() || parameter[ 0 ].toLower() == "all")
         n = panel->view->numDirs() + panel->view->numFiles();
     else if (parameter[ 0 ].toLower() == "files")
         n = panel->view->numFiles();
     else if (parameter[ 0 ].toLower() == "dirs")
         n = panel->view->numDirs();
     else if (parameter[ 0 ].toLower() == "selected")
         n = panel->view->numSelected();
     else {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: Bad argument to Count: %1 is not valid item specifier", parameter[0])));
         return QString();
     }
 
     return TagString(QString("%1").arg(n));
 }
 
 exp_Filter::exp_Filter()
 {
     _expression = "Filter";
     _description = i18n("Filter Mask (*.h, *.cpp, etc.)");
     _needPanel = true;
 }
 TagString exp_Filter::expFunc(const KrPanel* panel, const QStringList&, const bool&, Expander& exp) const
 {
     NEED_PANEL
 
     return panel->view->filterMask().nameFilter();
 }
 
 exp_Current::exp_Current()
 {
     _expression = "Current";
     _description = i18n("Current File (!= Selected File)...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Omit the current path (optional)"), "__no", false));
     addParameter(exp_parameter(i18n("Automatically escape spaces"), "__yes", false));
 }
 TagString exp_Current::expFunc(const KrPanel* panel, const QStringList& parameter, const bool& useUrl, Expander& exp) const
 {
     NEED_PANEL
 
     QString item = panel->view->getCurrentItem();
     if (item == "..") {
         // if ".." is current, treat this as nothing is current
         return QString();
     }
 
     QString result;
     if (parameter.count() > 0 && parameter[0].toLower() == "yes")    // omit the current path
         result = item;
     else {
         const QUrl url = panel->func->files()->getUrl(item);
         result = useUrl ? url.url() : url.path();
     }
 
     const bool escapeSpaces = parameter.count() < 2 || parameter[1].toLower() != "no";
     return escapeSpaces ? bashquote(result) : result;
 }
 
 exp_List::exp_List()
 {
     _expression = "List";
     _description = i18n("Item List of...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Which items:"), "__choose:All;Files;Dirs;Selected", false));
     addParameter(exp_parameter(i18n("Separator between the items (optional):"), " ", false));
     addParameter(exp_parameter(i18n("Omit the current path (optional)"), "__no", false));
     addParameter(exp_parameter(i18n("Mask (optional, all but 'Selected'):"), "__select", false));
     addParameter(exp_parameter(i18n("Automatically escape spaces"), "__yes", false));
 }
 TagString exp_List::expFunc(const KrPanel* panel, const QStringList& parameter, const bool& useUrl, Expander& exp) const
 {
     NEED_PANEL
 
     // get selected items from view
     QStringList items;
     QString mask;
 
     if (parameter.count() <= 3 || parameter[3].isEmpty())
         mask = '*';
     else
         mask = parameter[3];
 
     return separateAndQuote(
                fileList(panel,
                         parameter.isEmpty() ? QString() : parameter[0].toLower(),
                         mask, parameter.count() > 2 ? parameter[2].toLower() == "yes" : false,
                         useUrl, exp, "List"),
                parameter.count() > 1 ? parameter[1] : " ",
                parameter.count() > 4 ? parameter[4].toLower() == "yes" : true);
 }
 
 exp_ListFile::exp_ListFile()
 {
     _expression = "ListFile";
     _description = i18n("Filename of an Item List...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Which items:"), "__choose:All;Files;Dirs;Selected", false));
     addParameter(exp_parameter(i18n("Separator between the items (optional)"), "\n", false));
     addParameter(exp_parameter(i18n("Omit the current path (optional)"), "__no", false));
     addParameter(exp_parameter(i18n("Mask (optional, all but 'Selected'):"), "__select", false));
     addParameter(exp_parameter(i18n("Automatically escape spaces"), "__no", false));
 }
 TagString exp_ListFile::expFunc(const KrPanel* panel, const QStringList& parameter, const bool& useUrl, Expander& exp) const
 {
     NEED_PANEL
 
     // get selected items from view
     QStringList items;
     QString mask;
 
     if (parameter.count() <= 3 || parameter[3].isEmpty())
         mask = '*';
     else
         mask = parameter[3];
     QTemporaryFile tmpFile(QDir::tempPath() + QLatin1String("/krusader_XXXXXX.itemlist"));
     tmpFile.setAutoRemove(false);
 
     if (!tmpFile.open()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_WORLD, i18n("Expander: temporary file could not be opened (%1)", tmpFile.errorString())));
         return QString();
     }
 
     QTextStream stream(&tmpFile);
     stream << separateAndQuote(
         fileList(panel,
                  parameter.isEmpty() ? QString() : parameter[0].toLower(),
                  mask, parameter.count() > 2 ? parameter[2].toLower() == "yes" : false,
                  useUrl, exp, "ListFile"),
         parameter.count() > 1 ? parameter[1] : "\n",
         parameter.count() > 4 ? parameter[4].toLower() == "yes" : true)
     << "\n";
     tmpFile.close();
 
     return tmpFile.fileName();
 }
 
 exp_Select::exp_Select()
 {
     _expression = "Select";
     _description = i18n("Manipulate the Selection...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Selection mask:"), "__select", true));
     addParameter(exp_parameter(i18n("Manipulate in which way:"), "__choose:Set;Add;Remove", false));
 }
 TagString exp_Select::expFunc(const KrPanel* panel, const QStringList& parameter, const bool& , Expander& exp) const
 {
     NEED_PANEL
 
     KRQuery mask;
     if (parameter.count() <= 0 || parameter[0].isEmpty())
         mask = KRQuery("*");
     else
         mask = KRQuery(parameter[0]);
 
     if (parameter.count() > 1 && parameter[1].toLower() == "list-add")
         panel->view->select(mask);
     else if (parameter.count() > 1 && parameter[1].toLower() == "list-remove")
         panel->view->unselect(mask);
     else { // parameter[1].toLower() == "set" or isEmpty() or whatever
         panel->view->unselect(KRQuery("*"));
         panel->view->select(mask);
     }
 
     return QString();  // this doesn't return anything, that's normal!
 }
 
 exp_Goto::exp_Goto()
 {
     _expression = "Goto";
     _description = i18n("Jump to a Location...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Choose a path:"), "__goto", true));
     addParameter(exp_parameter(i18n("Open location in a new tab"), "__no", false));
 }
 TagString exp_Goto::expFunc(const KrPanel* panel, const QStringList& parameter, const bool&, Expander& exp) const
 {
     NEED_PANEL
 
     bool newTab = false;
     if (parameter.count() > 1 && parameter[1].toLower() == "yes")
         newTab = true;
 
     if (parameter.count() == 0) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: at least 1 parameter is required for Goto.")));
         return QString();
     }
 
     QUrl url = QUrl::fromUserInput(parameter[0], QString(), QUrl::AssumeLocalFile);
     if (newTab) {
         if (panel == LEFT_PANEL)
             MAIN_VIEW->leftManager()->slotNewTab(url);
         else
             MAIN_VIEW->rightManager()->slotNewTab(url);
     } else {
         panel->func->openUrl(url, "");
         panel->gui->slotFocusOnMe();
     }
 
     return QString();  // this doesn't return anything, that's normal!
 }
 
 /*
 exp_Search::exp_Search() {
    _expression = "Search";
    _description = i18n("Search for files");
    _needPanel = true;
 
    addParameter( new exp_parameter( i18n("please choose the setting"), "__searchprofile", true ) );
    addParameter( new exp_parameter( i18n("open the search in a new tab"), "__yes", false ) );  //TODO: add this also to panel-dependent as soon as filesystem support the display of search-results
 }
 */
 
 exp_Ask::exp_Ask()
 {
     _expression = "Ask";
     _description = i18n("Ask Parameter from User...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("Question:"), "Where do you want do go today?", true));
     addParameter(exp_parameter(i18n("Preset (optional):"), "", false));
     addParameter(exp_parameter(i18n("Caption (optional):"), "", false));
 }
 TagString exp_Ask::expFunc(const KrPanel*, const QStringList& parameter, const bool&, Expander& exp) const
 {
     QString caption, preset, result;
 
     if (parameter.count() == 0) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: at least 1 parameter is required for Ask.")));
         return QString();
     }
 
     if (parameter.count() <= 2 || parameter[2].isEmpty())
         caption = i18n("User Action");
     else
         caption = parameter[2];
     if (parameter.count() <= 1 || parameter[1].isEmpty())
         preset.clear();
     else
         preset = parameter[1];
 
     bool ok;
     result = QInputDialog::getText(krMainWindow, caption, parameter[0], QLineEdit::Normal, preset, &ok);
 
     if (ok)
         return result;
     else {
         // user cancelled
         setError(exp, Error(Error::exp_S_ERROR, Error::exp_C_USER));
         return QString();
     }
 }
 
 exp_Clipboard::exp_Clipboard()
 {
     _expression = "Clipboard";
     _description = i18n("Copy to Clipboard...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("What to copy:"), "__placeholder", true));
     addParameter(exp_parameter(i18n("Append to current clipboard content with this separator (optional):"), "", false));
 }
 TagString exp_Clipboard::expFunc(const KrPanel*, const TagStringList& parameter, const bool&, Expander& exp) const
 {
 //    qDebug() << "Expander::exp_Clipboard, parameter[0]: '" << parameter[0] << "', Clipboard: " << QApplication::clipboard()->text();
     if (parameter.count() == 0) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: at least 1 parameter is required for Clipboard.")));
         return QString();
     }
 
     QStringList lst = splitEach(parameter[0]);
     if (parameter.count() > 1 && !parameter[1].isSimple()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_SYNTAX, i18n("Expander: %Each% may not be in the second argument of %Clipboard%")));
         return QString();
     }
     if (parameter.count() <= 1 || parameter[1].string().isEmpty() || QApplication::clipboard()->text().isEmpty())
         QApplication::clipboard()->setText(lst.join("\n"));
     else
         QApplication::clipboard()->setText(QApplication::clipboard()->text() + parameter[1].string() + lst.join("\n"));
 
     return QString();  // this doesn't return anything, that's normal!
 }
 
 exp_Copy::exp_Copy()
 {
     _expression = "Copy";
     _description = i18n("Copy a File/Folder...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("What to copy:"), "__placeholder", true));
     addParameter(exp_parameter(i18n("Where to copy:"), "__placeholder", true));
 }
 TagString exp_Copy::expFunc(const KrPanel*, const TagStringList& parameter, const bool&, Expander& exp) const
 {
     if (parameter.count() < 2) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: at least 2 parameter is required for Copy.")));
         return QString();
     }
 
     // basically the parameter can already be used as URL, but since QUrl has problems with ftp-proxy-urls (like ftp://username@proxyusername@url...) this is necessary:
     const QStringList sourceList = splitEach(parameter[0]);
     QList<QUrl> sourceURLs;
-    for (const QString source : sourceList) {
+    for (const QString& source : sourceList) {
         sourceURLs.append(QUrl::fromUserInput(source, QString(), QUrl::AssumeLocalFile));
     }
 
     if (!parameter[1].isSimple()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_SYNTAX, i18n("Expander: %Each% may not be in the second argument of %Copy%")));
         return QString();
     }
 
     // or transform(...) ?
     const QUrl dest = QUrl::fromUserInput(parameter[1].string(), QString(), QUrl::AssumeLocalFile);
 
     if (!dest.isValid() ||
         find_if(sourceURLs.constBegin(),
                 sourceURLs.constEnd(),
                 not1(mem_fun_ref(&QUrl::isValid))) != sourceURLs.constEnd()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: invalid URLs in %_Copy(\"src\", \"dest\")%")));
         return QString();
     }
 
     FileSystemProvider::instance().startCopyFiles(sourceURLs, dest);
 
     return QString();  // this doesn't return everything, that's normal!
 }
 
 exp_Move::exp_Move()
 {
     _expression = "Move";
     _description = i18n("Move/Rename a File/Folder...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("What to move/rename:"), "__placeholder", true));
     addParameter(exp_parameter(i18n("New target/name:"), "__placeholder", true));
 }
 TagString exp_Move::expFunc(const KrPanel*, const TagStringList& parameter, const bool& , Expander& exp) const
 {
     if (parameter.count() < 2) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: at least 2 parameter is required for Move.")));
         return QString();
     }
 
     // basically the parameter can already be used as URL, but since QUrl has problems with ftp-proxy-urls (like ftp://username@proxyusername@url...) this is necessary:
     QStringList lst = splitEach(parameter[0]);
     if (!parameter[1].isSimple()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_SYNTAX, i18n("%Each% may not be in the second argument of %Move%")));
         return QString();
     }
     QList<QUrl> src;
     for (QStringList::const_iterator it = lst.constBegin(), end = lst.constEnd();it != end;++it)
         src.push_back(QUrl::fromUserInput(*it, QString(), QUrl::AssumeLocalFile));
     // or transform(...) ?
     QUrl dest = QUrl::fromUserInput(parameter[1].string(), QString(), QUrl::AssumeLocalFile);
 
     if (!dest.isValid() || find_if(src.constBegin(), src.constEnd(), not1(mem_fun_ref(&QUrl::isValid))) != src.constEnd()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: invalid URLs in %_Move(\"src\", \"dest\")%")));
         return QString();
     }
 
     FileSystemProvider::instance().startCopyFiles(src, dest, KIO::CopyJob::Move);
 
     return QString();  // this doesn't return anything, that's normal!
 }
 
 #ifdef SYNCHRONIZER_ENABLED
 exp_Sync::exp_Sync()
 {
     _expression = "Sync";
     _description = i18n("Load a Synchronizer Profile...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("Choose a profile:"), "__syncprofile", true));
 }
 TagString exp_Sync::expFunc(const KrPanel*, const QStringList& parameter, const bool&, Expander& exp) const
 {
     if (parameter.count() == 0 || parameter[0].isEmpty()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: no profile specified for %_Sync(profile)%")));
         return QString();
     }
 
     SynchronizerGUI *synchronizerDialog = new SynchronizerGUI(MAIN_VIEW, parameter[0]);
     synchronizerDialog->show(); // destroyed on close
 
     return QString();  // this doesn't return everything, that's normal!
 }
 #endif
 
 exp_NewSearch::exp_NewSearch()
 {
     _expression = "NewSearch";
     _description = i18n("Load a Searchmodule Profile...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("Choose a profile:"), "__searchprofile", true));
 }
 TagString exp_NewSearch::expFunc(const KrPanel*, const QStringList& parameter, const bool&, Expander& exp) const
 {
     if (parameter.count() == 0 || parameter[0].isEmpty()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: no profile specified for %_NewSearch(profile)%")));
         return QString();
     }
 
     new KrSearchDialog(parameter[0], krApp);
 
     return QString();  // this doesn't return everything, that's normal!
 }
 
 exp_Profile::exp_Profile()
 {
     _expression = "Profile";
     _description = i18n("Load a Panel Profile...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("Choose a profile:"), "__panelprofile", true));
 }
 TagString exp_Profile::expFunc(const KrPanel*, const QStringList& parameter, const bool&, Expander& exp) const
 {
     if (parameter.count() == 0 || parameter[0].isEmpty()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: no profile specified for %_Profile(profile)%; abort...")));
         return QString();
     }
 
     MAIN_VIEW->profiles(parameter[0]);
 
     return QString();  // this doesn't return everything, that's normal!
 }
 
 exp_Each::exp_Each()
 {
     _expression = "Each";
     _description = i18n("Separate Program Call for Each...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Which items:"), "__choose:All;Files;Dirs;Selected", false));
     addParameter(exp_parameter(i18n("Omit the current path (optional)"), "__no", false));
     addParameter(exp_parameter(i18n("Mask (optional, all but 'Selected'):"), "__select", false));
     addParameter(exp_parameter(i18n("Automatically escape spaces"), "__yes", false));
 }
 TagString exp_Each::expFunc(const KrPanel* panel, const QStringList& parameter, const bool& useUrl, Expander& exp) const
 {
     NEED_PANEL
 
     QString mask;
     if (parameter.count() <= 2 || parameter[2].isEmpty())
         mask = '*';
     else
         mask = parameter[2];
 
     TagString ret;
     QStringList l = fileList(panel,
                              parameter.empty() ? QString() : parameter[0].toLower(),
                              mask, parameter.count() > 1 && parameter[1].toLower() == "yes",
                              useUrl, exp, "Each");
 
     if (!(parameter.count() <= 3 || parameter[3].toLower() != "yes"))
         transform(l.begin(), l.end(), l.begin(), bashquote);
 
     ret.insertTag(0, l);
     return ret;
 }
 
 exp_ColSort::exp_ColSort()
 {
     _expression = "ColSort";
     _description = i18n("Set Sorting for This Panel...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Choose a column:"), "__choose:Name;Ext;Type;Size;Modified;Perms;rwx;Owner;Group", true));
     addParameter(exp_parameter(i18n("Choose a sort sequence:"), "__choose:Toggle;Asc;Desc", false));
 }
 TagString exp_ColSort::expFunc(const KrPanel* panel, const QStringList& parameter, const bool&, Expander& exp) const
 {
     NEED_PANEL
 
     if (parameter.count() == 0 || parameter[0].isEmpty()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: no column specified for %_ColSort(column)%")));
         return QString();
     }
 
     KrViewProperties::ColumnType oldColumn = panel->view->properties()->sortColumn;
     KrViewProperties::ColumnType column = oldColumn;
 
     if (parameter[0].toLower() == "name") {
         column = KrViewProperties::Name;
     } else if (parameter[0].toLower() == "ext") {
         column = KrViewProperties::Ext;
     } else if (parameter[0].toLower() == "type") {
         column = KrViewProperties::Type;
     } else if (parameter[0].toLower() == "size") {
         column = KrViewProperties::Size;
     } else if (parameter[0].toLower() == "modified") {
         column = KrViewProperties::Modified;
     } else if (parameter[0].toLower() == "changed") {
         column = KrViewProperties::Changed;
     } else if (parameter[0].toLower() == "accessed") {
         column = KrViewProperties::Accessed;
     } else if (parameter[0].toLower() == "perms") {
         column = KrViewProperties::Permissions;
     } else if (parameter[0].toLower() == "rwx") {
         column = KrViewProperties::KrPermissions;
     } else if (parameter[0].toLower() == "owner") {
         column = KrViewProperties::Owner;
     } else if (parameter[0].toLower() == "group") {
         column = KrViewProperties::Group;
     } else {
         setError(exp, Error(Error::exp_S_WARNING, Error::exp_C_ARGUMENT,
                             i18n("Expander: unknown column specified for %_ColSort(%1)%",
                                  parameter[0])));
         return QString();
     }
 
     bool descending = panel->view->properties()->sortOptions & KrViewProperties::Descending;
 
     if (parameter.count() <= 1 || (parameter[1].toLower() != "asc" && parameter[1].toLower() != "desc")) { // no sortdir parameter
         if(column == oldColumn) // reverse direction if column is unchanged
             descending = !descending;
         else // otherwise set to ascending
             descending = false;
     } else { // sortdir specified
         if (parameter[1].toLower() == "asc")
             descending = false;
         else // == desc
             descending = true;
     }
 
     panel->view->setSortMode(column, descending);
 
     return QString();  // this doesn't return anything, that's normal!
 }
 
 exp_PanelSize::exp_PanelSize()
 {
     _expression = "PanelSize";
     _description = i18n("Set Relation Between the Panels...");
     _needPanel = true;
 
     addParameter(exp_parameter(i18n("Set the new size in percent:"), "__int:0;100;5;50", true));
 }
 TagString exp_PanelSize::expFunc(const KrPanel* panel, const QStringList& parameter, const bool&, Expander& exp) const
 {
     NEED_PANEL
     int newSize;
 
     if (parameter.count() == 0 || parameter[0].isEmpty())
         newSize = 50; //default is 50%
     else
         newSize = parameter[0].toInt();
 
     if (newSize < 0 || newSize > 100) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: Value %1 out of range for %_PanelSize(percent)%. The first parameter has to be >0 and <100", newSize)));
         return QString();
     }
 
     MAIN_VIEW->setPanelSize(panel->isLeft(), newSize);
 
     return QString();  // this doesn't return everything, that's normal!
 }
 
 #ifdef __KJSEMBED__
 exp_Script::exp_Script()
 {
     _expression = "Script";
     _description = i18n("Execute a JavaScript Extension...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("Location of the script"), "", true));
     addParameter(exp_parameter(i18n("Set some variables for the execution (optional).\ni.e. \"return=return_var;foo=bar\", consult the handbook for more information"), "", false));
 }
 TagString exp_Script::expFunc(const KrPanel*, const QStringList& parameter, const bool&, Expander& exp) const
 {
     if (parameter.count() == 0 || parameter[0].isEmpty()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: no script specified for %_Script(script)%")));
         return QString();
     }
 
     QString filename = parameter[0];
     if (filename.find('/') && QUrl::isRelativeUrl(filename)) {
         // this return the local version of the file if this exists. else the global one is returnd
         filename = locate("data", "krusader/js/" + filename);
     }
 
     if (! krJS)
         krJS = new KrJS();
 
     KJS::ExecState *exec = krJS->globalExec();
 
     QString jsReturn;
     if (parameter[1].toLower() == "yes")   // to stay compatible with the old-style parameter
         jsReturn = "cmd";
     else {
         QStringList jsVariables = parameter[1].split(';');
         QString jsVariable, jsValue;
         for (QStringList::Iterator it = jsVariables.begin(); it != jsVariables.end(); ++it) {
             jsVariable = (*it).section('=', 0, 0).trimmed();
             jsValue = (*it).section('=', 1);
             if (jsVariable == "return")
                 jsReturn = jsValue.trimmed();
             else
                 krJS->putValue(jsVariable, KJSEmbed::convertToValue(exec, jsValue));
         }
     }
 
     krJS->runFile(filename);
 
     if (! jsReturn.isEmpty())
         return krJS->getValue(jsReturn).toString(krJS->globalExec()).qstring();
     else
         return QString();
 }
 #endif
 
 exp_View::exp_View()
 {
     _expression = "View";
     _description = i18n("View File with Krusader's Internal Viewer...");
     _needPanel = false;
 
     addParameter(exp_parameter(i18n("Which file to view (normally '%aCurrent%'):"), "__placeholder", true));
     addParameter(exp_parameter(i18n("Choose a view mode:"), "__choose:generic;text;hex", false));
     //addParameter( exp_parameter( i18n("Choose a window-mode"), "__choose:tab;window;panel", false ) );
     //TODO: window-mode 'panel' should open the file in the third-hand viewer
     addParameter(exp_parameter(i18n("Choose a window mode:"), "__choose:tab;window", false));
 }
 TagString exp_View::expFunc(const KrPanel*, const QStringList& parameter, const bool&, Expander& exp) const
 {
     if (parameter.count() == 0 || parameter[0].isEmpty()) {
         setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_ARGUMENT, i18n("Expander: no file to view in %_View(filename)%")));
         return QString();
     }
 
     QString viewMode, windowMode;
     if (parameter.count() <= 1 || parameter[1].isEmpty())
         viewMode = "generic";
     else
         viewMode = parameter[1];
 
     if (parameter.count() <= 2 || parameter[2].isEmpty())
         windowMode = "tab";
     else
         windowMode = parameter[2];
 
     KrViewer::Mode mode = KrViewer::Generic;
     if (viewMode == "text") mode = KrViewer::Text;
     else if (viewMode == "hex") mode = KrViewer::Hex;
 
     QUrl url = QUrl::fromUserInput(parameter[0], QString(), QUrl::AssumeLocalFile);
     KrViewer::view(url, mode, (windowMode == "window"));
     //TODO: Call the viewer with viewMode and windowMode. Filename is in parameter[0].
     // It would be nice if parameter[0] could also be a space-separated filename-list (provided if the first parameter is %aList(selected)%)
 
     return QString();  // this doesn't return everything, that's normal!
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////// end of expander classes ////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 TagString exp_simpleplaceholder::expFunc(const KrPanel* p, const TagStringList& parameter, const bool& useUrl, Expander& exp) const
 {
     QStringList lst;
-    for (TagStringList::const_iterator it = parameter.begin(), end = parameter.end();it != end;++it)
-        if ((*it).isSimple())
-            lst.push_back((*it).string());
+    for (const auto & it : parameter)
+        if (it.isSimple())
+            lst.push_back(it.string());
         else {
             setError(exp, Error(Error::exp_S_FATAL, Error::exp_C_SYNTAX, i18n("%Each% is not allowed in parameter to %1", description())));
             return QString();
         }
     return expFunc(p, lst, useUrl, exp);
 }
 
 }
 
 KrPanel* Expander::getPanel(const char panelIndicator, const exp_placeholder* pl, Expander& exp)
 {
     switch (panelIndicator) {
     case 'a':
         return ACTIVE_PANEL;
     case 'o':
         return OTHER_PANEL;
     case 'l':
         return LEFT_PANEL;
     case 'r':
         return RIGHT_PANEL;
     case '_':
-        return 0;
+        return nullptr;
     default:
         exp.setError(Error(Error::exp_S_FATAL, Error::exp_C_SYNTAX, i18n("Expander: Bad panel specifier %1 in placeholder %2", panelIndicator, pl->description())));
-        return 0;
+        return nullptr;
     }
 }
 
 void Expander::expand(const QString& stringToExpand, bool useUrl)
 {
     TagString result = expandCurrent(stringToExpand, useUrl);
     if (error())
         return;
 
     if (!result.isSimple())
         resultList = splitEach(result);
     else
         resultList.append(result.string());
 
 //    qWarning() << resultList[0];
 }
 
 TagString Expander::expandCurrent(const QString& stringToExpand, bool useUrl)
 {
     TagString result;
     QString exp;
     TagString tmpResult;
     int begin, end, i;
 //    int brackets = 0;
 //    bool inQuotes = false;
     int idx = 0;
     while (idx < stringToExpand.length()) {
         if ((begin = stringToExpand.indexOf('%', idx)) == -1) break;
         if ((end = findEnd(stringToExpand, begin)) == -1) {
             // xgettext:no-c-format
             setError(Error(Error::exp_S_FATAL, Error::exp_C_SYNTAX, i18n("Error: unterminated % in Expander")));
             return QString();
         }
 
         result += stringToExpand.mid(idx, begin - idx);   // copy until the start of %exp%
 
         // get the expression, and expand it using the correct expander function
         exp = stringToExpand.mid(begin + 1, end - begin - 1);
 //       qDebug() << "------------- exp: '" << exp << "'";
         if (exp.isEmpty())
             result += QString(QChar('%'));
         else {
             TagStringList parameter = separateParameter(&exp, useUrl);
             if (error())
                 return QString();
             char panelIndicator = exp.toLower()[0].toLatin1();
             exp.replace(0, 1, "");
             for (i = 0; i < placeholderCount(); ++i)
                 if (exp == placeholder(i)->expression()) {
 //               qDebug() << "---------------------------------------";
                     tmpResult = placeholder(i)->expFunc(getPanel(panelIndicator, placeholder(i), *this), parameter, useUrl, *this);
                     if (error()) {
                         return QString();
                     } else
                         result += tmpResult;
 //               qDebug() << "---------------------------------------";
                     break;
                 }
             if (i == placeholderCount()) {   // didn't find an expander
                 setError(Error(Error::exp_S_FATAL, Error::exp_C_SYNTAX, i18n("Error: unrecognized %%%1%2%% in Expander", panelIndicator, exp)));
                 return QString();
             }
         } //else
         idx = end + 1;
     }
     // copy the rest of the string
     result += stringToExpand.mid(idx);
 //    qDebug() << "============== result '" << result << "'";
     return result;
 }
 
 QStringList Expander::splitEach(TagString stringToSplit)
 {
     if (stringToSplit.isSimple()) {
 //   qWarning() << stringToSplit.string();
         QStringList l;
         l << stringToSplit.string();
         return l;
     }
     pair<uint, QStringList> pl = *stringToSplit.tagsBegin();
     stringToSplit.eraseTag(stringToSplit.tagsBegin());
     QStringList ret;
     for (QStringList::const_iterator it = pl.second.constBegin(), end = pl.second.constEnd();it != end;++it) {
         TagString s = stringToSplit;
         s.insert(pl.first, *it);
         ret += splitEach(s);
     }
     return ret;
 //    qDebug() << "stringToSplit: " << stringToSplit;
 }
 
 TagStringList Expander::separateParameter(QString* const exp, bool useUrl)
 {
     TagStringList parameter;
     QStringList parameter1;
     QString result;
     int begin, end;
     if ((begin = exp->indexOf('(')) != -1) {
         if ((end = exp->lastIndexOf(')')) == -1) {
             setError(Error(Error::exp_S_FATAL, Error::exp_C_SYNTAX, i18n("Error: missing ')' in Expander")));
             return TagStringList();
         }
         result = exp->mid(begin + 1, end - begin - 1);
         *exp = exp->left(begin);
 
         bool inQuotes = false;
         int idx = 0;
         begin = 0;
         while (idx < result.length()) {
             if (result[ idx ].toLatin1() == '\\') {
                 if (result[ idx+1 ].toLatin1() == '"')
                     result.replace(idx, 1, "");
             }
             if (result[ idx ].toLatin1() == '"')
                 inQuotes = !inQuotes;
             if (result[ idx ].toLatin1() == ',' && !inQuotes) {
                 parameter1.append(result.mid(begin, idx - begin));
                 begin = idx + 1;
 //             qWarning() << " ---- parameter: " << parameter.join(";");
             }
             idx++;
         }
         parameter1.append(result.mid(begin, idx - begin));     //don't forget the last one
 
-        for (QStringList::Iterator it = parameter1.begin(); it != parameter1.end(); ++it) {
-            *it = (*it).trimmed();
-            if ((*it).left(1) == "\"")
-                *it = (*it).mid(1, (*it).length() - 2);
-            parameter.push_back(expandCurrent(*it, useUrl));
+        for (auto & it : parameter1) {
+            it = it.trimmed();
+            if (it.left(1) == "\"")
+                it = it.mid(1, it.length() - 2);
+            parameter.push_back(expandCurrent(it, useUrl));
             if (error())
                 return TagStringList();
         }
     }
 
 //    qWarning() << "------- exp: " << *exp << " ---- parameter: " << parameter.join(";");
     return parameter;
 }
 
 int Expander::findEnd(const QString& str, int start)
 {
     int end = str.indexOf('%', start + 1);
     if (end == -1)
         return end;
     int bracket = str.indexOf('(', start + 1);
     if (end < bracket || bracket == -1)
         return end;
 
     int idx = bracket + 1;
     bool inQuotes = false;
     int depth = 1;
     while (idx < str.length()) {
         switch (str[ idx ].toLatin1()) {
         case '\\':
             idx ++;
             break;
         case '"':
             inQuotes = !inQuotes;
             break;
         case '(':
             if (!inQuotes)
                 depth++;
             break;
         case ')':
             if (!inQuotes)
                 --depth;
             break;
         case '%':
             if (depth == 0)
                 return idx;
         } //switch
         idx++;
     } //while
     // failsafe
     return -1;
 }
 
 QList<const exp_placeholder*>& Expander::_placeholder()
 {
     static QList<const exp_placeholder*> ret;
     if(!ret.count()) {
         ret << new exp_View;
         ret << new exp_PanelSize;
         ret << new exp_ColSort;
         ret << new exp_Each;
         ret << new exp_Profile;
         ret << new exp_NewSearch;
 #ifdef SYNCHRONIZER_ENABLED
         ret << new exp_Sync;
 #endif
         ret << new exp_Move;
         ret << new exp_Copy;
         ret << new exp_Goto;
         ret << new exp_Select;
         ret << new exp_Clipboard;
         ret << new exp_Ask;
         ret << new exp_ListFile;
         ret << new exp_List;
         ret << new exp_Current;
         ret << new exp_Filter;
         ret << new exp_Count;
         ret << new exp_Path;
 #ifdef __KJSEMBED__
         ret << new exp_Script;
 #endif
     }
     return ret;
 }
diff --git a/krusader/UserAction/kraction.cpp b/krusader/UserAction/kraction.cpp
index 5fd606b7..2109454a 100644
--- a/krusader/UserAction/kraction.cpp
+++ b/krusader/UserAction/kraction.cpp
@@ -1,699 +1,699 @@
 /*****************************************************************************
  * Copyright (C) 2004 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2004 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2006 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kraction.h"
 
 // QtCore
 #include <QDebug>
 #include <QEvent>
 #include <QFile>
 #include <QMimeDatabase>
 #include <QMimeType>
 #include <QRegExp>
 #include <QTextStream>
 // QtGui
 #include <QKeyEvent>
 // QtWidgets
 #include <QAction>
 #include <QBoxLayout>
 #include <QCheckBox>
 #include <QDialogButtonBox>
 #include <QFileDialog>
 #include <QLabel>
 #include <QLayout>
 #include <QPushButton>
 #include <QSplitter>
 // QtXml
 #include <QDomElement>
 
 #include <KConfigCore/KSharedConfig>
 #include <KXmlGui/KActionCollection>
 #include <KWidgetsAddons/KMessageBox>
 #include <KCoreAddons/KShell>
 #include <KI18n/KLocalizedString>
 #include <KParts/ReadOnlyPart>
 
 #include "expander.h"
 #include "useraction.h"
 #include "../GUI/terminaldock.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../krusaderview.h"
 #include "../krservices.h"
 #include "../defaults.h"
 
 // KrActionProcDlg
-KrActionProcDlg::KrActionProcDlg(QString caption, bool enableStderr, QWidget *parent) :
-        QDialog(parent), _stdout(0), _stderr(0), _currentTextEdit(0)
+KrActionProcDlg::KrActionProcDlg(const QString& caption, bool enableStderr, QWidget *parent) :
+        QDialog(parent), _stdout(nullptr), _stderr(nullptr), _currentTextEdit(nullptr)
 {
     setWindowTitle(caption);
     setWindowModality(Qt::NonModal);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     // do we need to separate stderr and stdout?
     if (enableStderr) {
-        QSplitter *splitt = new QSplitter(Qt::Horizontal, this);
+        auto *splitt = new QSplitter(Qt::Horizontal, this);
         mainLayout->addWidget(splitt);
         // create stdout
         QWidget *stdoutWidget = new QWidget(splitt);
-        QVBoxLayout *stdoutBox = new QVBoxLayout(stdoutWidget);
+        auto *stdoutBox = new QVBoxLayout(stdoutWidget);
 
         stdoutBox->addWidget(new QLabel(i18n("Standard Output (stdout)"), stdoutWidget));
         _stdout = new KTextEdit(stdoutWidget);
         _stdout->setReadOnly(true);
         stdoutBox->addWidget(_stdout);
         // create stderr
         QWidget *stderrWidget = new QWidget(splitt);
-        QVBoxLayout *stderrBox = new QVBoxLayout(stderrWidget);
+        auto *stderrBox = new QVBoxLayout(stderrWidget);
 
         stderrBox->addWidget(new QLabel(i18n("Standard Error (stderr)"), stderrWidget));
         _stderr = new KTextEdit(stderrWidget);
         _stderr->setReadOnly(true);
         stderrBox->addWidget(_stderr);
     } else {
         // create stdout
         mainLayout->addWidget(new QLabel(i18n("Output")));
         _stdout = new KTextEdit;
         _stdout->setReadOnly(true);
         mainLayout->addWidget(_stdout);
     }
 
     _currentTextEdit = _stdout;
     connect(_stdout, &KTextEdit::textChanged, this, &KrActionProcDlg::currentTextEditChanged);
     if (_stderr)
         connect(_stderr, &KTextEdit::textChanged, this, &KrActionProcDlg::currentTextEditChanged);
 
     KConfigGroup group(krConfig, "UserActions");
     normalFont = group.readEntry("Normal Font", _UserActions_NormalFont);
     fixedFont = group.readEntry("Fixed Font", _UserActions_FixedFont);
     bool startupState = group.readEntry("Use Fixed Font", _UserActions_UseFixedFont);
     toggleFixedFont(startupState);
 
-    QHBoxLayout *hbox = new QHBoxLayout;
+    auto *hbox = new QHBoxLayout;
     QCheckBox* useFixedFont = new QCheckBox(i18n("Use font with fixed width"));
     useFixedFont->setChecked(startupState);
     hbox->addWidget(useFixedFont);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     hbox->addWidget(buttonBox);
 
     mainLayout->addLayout(hbox);
 
     closeButton = buttonBox->button(QDialogButtonBox::Close);
     closeButton->setEnabled(false);
 
-    QPushButton *saveAsButton = new QPushButton;
+    auto *saveAsButton = new QPushButton;
     KGuiItem::assign(saveAsButton, KStandardGuiItem::saveAs());
     buttonBox->addButton(saveAsButton, QDialogButtonBox::ActionRole);
 
     killButton = new QPushButton(i18n("Kill"));
     killButton->setToolTip(i18n("Kill the running process"));
     killButton->setDefault(true);
     buttonBox->addButton(killButton, QDialogButtonBox::ActionRole);
 
     connect(killButton, &QPushButton::clicked, this, &KrActionProcDlg::killClicked);
     connect(saveAsButton, &QPushButton::clicked, this, &KrActionProcDlg::slotSaveAs);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KrActionProcDlg::reject);
     connect(useFixedFont, &QCheckBox::toggled, this, &KrActionProcDlg::toggleFixedFont);
 
     resize(sizeHint() * 2);
 }
 
 void KrActionProcDlg::addStderr(const QString& str)
 {
     if (_stderr)
         _stderr->append(str);
     else {
         _stdout->setFontItalic(true);
         _stdout->append(str);
         _stdout->setFontItalic(false);
     }
 }
 
 void KrActionProcDlg::addStdout(const QString& str)
 {
     _stdout->append(str);
 }
 
 void KrActionProcDlg::toggleFixedFont(bool state)
 {
     if (state) {
         _stdout->setFont(fixedFont);
         if (_stderr)
             _stderr->setFont(fixedFont);
     } else {
         _stdout->setFont(normalFont);
         if (_stderr)
             _stderr->setFont(normalFont);
     }
 }
 
 void KrActionProcDlg::slotSaveAs()
 {
     QString filename = QFileDialog::getSaveFileName(this, QString(), QString(), i18n("*.txt|Text files\n*|All files"));
     if (filename.isEmpty())
         return;
     QFile file(filename);
     int answer = KMessageBox::Yes;
     if (file.exists())
         answer = KMessageBox::warningYesNoCancel(this,  //parent
                  i18n("This file already exists.\nDo you want to overwrite it or append the output?"), //text
                  i18n("Overwrite or append?"), //caption
                  KStandardGuiItem::overwrite(),   //label for Yes-Button
                  KGuiItem(i18n("Append"))   //label for No-Button
                                                 );
     if (answer == KMessageBox::Cancel)
         return;
     bool open;
     if (answer == KMessageBox::No)   // this means to append
         open = file.open(QIODevice::WriteOnly | QIODevice::Append);
     else
         open = file.open(QIODevice::WriteOnly);
 
     if (! open) {
         KMessageBox::error(this,
                            i18n("Cannot open %1 for writing.\nNothing exported.", filename),
                            i18n("Export failed")
                           );
         return;
     }
 
     QTextStream stream(&file);
     stream << _currentTextEdit->toPlainText();
     file.close();
 }
 
 void KrActionProcDlg::slotProcessFinished()
 {
     closeButton->setEnabled(true);
     killButton->setEnabled(false);
 }
 
 void KrActionProcDlg::currentTextEditChanged()
 {
     if (_stderr && _stderr->hasFocus())
         _currentTextEdit = _stderr;
     else
         _currentTextEdit = _stdout;
 }
 
 // KrActionProc
-KrActionProc::KrActionProc(KrActionBase* action) : QObject(), _action(action), _proc(0), _output(0)
+KrActionProc::KrActionProc(KrActionBase* action) : _action(action), _proc(nullptr), _output(nullptr)
 {
 }
 
 KrActionProc::~KrActionProc()
 {
     delete _proc;
 }
 
-void KrActionProc::start(QString cmdLine)
+void KrActionProc::start(const QString& cmdLine)
 {
     QStringList list;
     list << cmdLine;
     start(list);
 }
 
 void KrActionProc::start(QStringList cmdLineList)
 {
     QString cmd; // this is the command which is really executed (with  maybe kdesu, maybe konsole, ...)
     // in case no specific working directory has been requested, execute in a relatively safe place
     QString workingDir = QDir::tempPath();
 
     if (! _action->startpath().isEmpty())
         workingDir = _action->startpath();
 
     if (!_action->user().isEmpty()) {
         if (!KrServices::isExecutable(KDESU_PATH)) {
-            KMessageBox::sorry(0,
+            KMessageBox::sorry(nullptr,
                 i18n("Cannot run user action, %1 not found or not executable. "
                      "Please verify that kde-cli-tools are installed.", QString(KDESU_PATH)));
             return;
         }
     }
 
     if (_action->execType() == KrAction::RunInTE
             && (! MAIN_VIEW->terminalDock()->initialise())) {
-        KMessageBox::sorry(0, i18n("Embedded terminal emulator does not work, using output collection instead."));
+        KMessageBox::sorry(nullptr, i18n("Embedded terminal emulator does not work, using output collection instead."));
     }
 
     for (QStringList::Iterator it = cmdLineList.begin(); it != cmdLineList.end(); ++it) {
         if (! cmd.isEmpty())
             cmd += " ; "; //TODO make this separator configurable (users may want && or ||)
         //TODO: read header fom config or action-properties and place it on top of each command
         if (cmdLineList.count() > 1)
             cmd += "echo --------------------------------------- ; ";
         cmd += *it;
     }
 
     // make sure the command gets executed in the right directory
     cmd = "(cd " + KrServices::quote(workingDir) + " && (" + cmd + "))";
 
     if (_action->execType() == KrAction::RunInTE
         && MAIN_VIEW->terminalDock()->isInitialised()) {  //send the commandline contents to the terminal emulator
             if (!_action->user().isEmpty()) {
                 // "-t" is necessary that kdesu displays the terminal-output of the command
                 cmd = KrServices::quote(KDESU_PATH) +
                       " -t -u " + _action->user() + " -c " + KrServices::quote(cmd);
             }
             MAIN_VIEW->terminalDock()->sendInput(cmd + '\n');
             deleteLater();
     }
     else { // will start a new process
         _proc = new KProcess(this);
         _proc->clearProgram(); // this clears the arglist too
         _proc->setWorkingDirectory(workingDir);
         connect(_proc, QOverload<int, QProcess::ExitStatus>::of(&KProcess::finished), this, &KrActionProc::processExited);
 
         if (_action->execType() == KrAction::Normal || _action->execType() == KrAction::Terminal) { // not collect output
             if (_action->execType() == KrAction::Terminal) { // run in terminal
                 KConfigGroup group(krConfig, "UserActions");
                 QString term = group.readEntry("Terminal", _UserActions_Terminal);
                 QStringList termArgs = KShell::splitArgs(term, KShell::TildeExpand);
                 if (termArgs.isEmpty()) {
-                    KMessageBox::error(0, i18nc("Arg is a string containing the bad quoting.",
+                    KMessageBox::error(nullptr, i18nc("Arg is a string containing the bad quoting.",
                                                 "Bad quoting in terminal command:\n%1", term));
                     deleteLater();
                     return;
                 }
                 for (int i = 0; i != termArgs.size(); i++) {
                     if (termArgs[i] == "%t")
                         termArgs[i] = cmdLineList.join(" ; ");
                     else if (termArgs[i] == "%d")
                         termArgs[i] = workingDir;
                 }
                 termArgs << "sh" << "-c" << cmd;
                 cmd = KrServices::quote(termArgs).join(" ");
             }
             if (!_action->user().isEmpty()) {
                 cmd = KrServices::quote(KDESU_PATH) + " -u " + _action->user() +
                       " -c " + KrServices::quote(cmd);
             }
         }
         else { // collect output
             bool separateStderr = false;
             if (_action->execType() == KrAction::CollectOutputSeparateStderr)
                 separateStderr = true;
             _output = new KrActionProcDlg(_action->text(), separateStderr);
             // connect the output to the dialog
             _proc->setOutputChannelMode(KProcess::SeparateChannels);
             connect(_proc, &KProcess::readyReadStandardError, this, &KrActionProc::addStderr);
             connect(_proc, &KProcess::readyReadStandardOutput, this, &KrActionProc::addStdout);
             connect(_output, &KrActionProcDlg::killClicked, this, &KrActionProc::kill);
             _output->show();
 
             if (!_action->user().isEmpty()) {
                 // "-t" is necessary that kdesu displays the terminal-output of the command
                 cmd = KrServices::quote(KDESU_PATH) +
                       " -t -u " + _action->user() +
                       " -c " + KrServices::quote(cmd);
             }
         }
         //printf("cmd: %s\n", cmd.toAscii().data());
         _proc->setShellCommand(cmd);
         _proc->start();
     }
 }
 
 void KrActionProc::processExited(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/)
 {
     // enable the 'close' button on the dialog (if active), disable 'kill' button
     if (_output) {
         // TODO tell the user the program exit code
         _output->slotProcessFinished();
     }
     delete this; // banzai!!
 }
 
 void KrActionProc::addStderr()
 {
     if (_output) {
         _output->addStderr(QString::fromLocal8Bit(_proc->readAllStandardError().data()));
     }
 }
 
 void KrActionProc::addStdout()
 {
     if (_output) {
         _output->addStdout(QString::fromLocal8Bit(_proc->readAllStandardOutput().data()));
     }
 }
 
 
 // KrAction
-KrAction::KrAction(KActionCollection *parent, QString name) : QAction((QObject *)parent)
+KrAction::KrAction(KActionCollection *parent, const QString& name) : QAction((QObject *)parent)
 {
     _actionCollection = parent;
     setObjectName(name);
     parent->addAction(name, this);
 
     connect(this, &KrAction::triggered, this, &KrAction::exec);
 }
 
 KrAction::~KrAction()
 {
     foreach(QWidget *w, associatedWidgets())
     w->removeAction(this);
     krUserAction->removeKrAction(this);   // Importent! Else Krusader will crash when writing the actions to file
 }
 
 bool KrAction::isAvailable(const QUrl &currentURL)
 {
     bool available = true; //show per default (FIXME: make the default an attribute of <availability>)
 
     //check protocol
     if (! _showonlyProtocol.empty()) {
         available = false;
-        for (QStringList::Iterator it = _showonlyProtocol.begin(); it != _showonlyProtocol.end(); ++it) {
+        for (auto & it : _showonlyProtocol) {
             //qDebug() << "KrAction::isAvailable currentProtocol: " << currentURL.scheme() << " =?= " << *it;
-            if (currentURL.scheme() == *it) {    // FIXME remove trailing slashes at the xml-parsing (faster because done only once)
+            if (currentURL.scheme() == it) {    // FIXME remove trailing slashes at the xml-parsing (faster because done only once)
                 available = true;
                 break;
             }
         }
     } //check protocol: done
 
     //check the Path-list:
     if (available && ! _showonlyPath.empty()) {
         available = false;
-        for (QStringList::Iterator it = _showonlyPath.begin(); it != _showonlyPath.end(); ++it) {
-            if ((*it).right(1) == "*") {
-                if (currentURL.path().indexOf((*it).left((*it).length() - 1)) == 0) {
+        for (auto & it : _showonlyPath) {
+            if (it.right(1) == "*") {
+                if (currentURL.path().indexOf(it.left(it.length() - 1)) == 0) {
                     available = true;
                     break;
                 }
             } else
-                if (currentURL.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path() == *it) {    // FIXME remove trailing slashes at the xml-parsing (faster because done only once)
+                if (currentURL.adjusted(QUrl::RemoveFilename|QUrl::StripTrailingSlash).path() == it) {    // FIXME remove trailing slashes at the xml-parsing (faster because done only once)
                     available = true;
                     break;
                 }
         }
     } //check the Path-list: done
 
     //check mime-type
     if (available && ! _showonlyMime.empty()) {
         available = false;
         QMimeDatabase db;
         QMimeType mime = db.mimeTypeForUrl(currentURL);
         if (mime.isValid()) {
-            for (QStringList::Iterator it = _showonlyMime.begin(); it != _showonlyMime.end(); ++it) {
-                if ((*it).contains("/")) {
-                    if (mime.inherits(*it)) {      // don't use ==; use 'inherits()' instead, which is aware of inheritance (ie: text/x-makefile is also text/plain)
+            for (auto & it : _showonlyMime) {
+                if (it.contains("/")) {
+                    if (mime.inherits(it)) {      // don't use ==; use 'inherits()' instead, which is aware of inheritance (ie: text/x-makefile is also text/plain)
                         available = true;
                         break;
                     }
                 } else {
-                    if (mime.name().indexOf(*it) == 0) {      // 0 is the beginning, -1 is not found
+                    if (mime.name().indexOf(it) == 0) {      // 0 is the beginning, -1 is not found
                         available = true;
                         break;
                     }
                 }
             } //for
         }
     } //check the mime-type: done
 
     //check filename
     if (available && ! _showonlyFile.empty()) {
         available = false;
-        for (QStringList::Iterator it = _showonlyFile.begin(); it != _showonlyFile.end(); ++it) {
-            QRegExp regex = QRegExp(*it, Qt::CaseInsensitive, QRegExp::Wildcard);   // case-sensitive = false; wildcards = true
+        for (auto & it : _showonlyFile) {
+            QRegExp regex = QRegExp(it, Qt::CaseInsensitive, QRegExp::Wildcard);   // case-sensitive = false; wildcards = true
             if (regex.exactMatch(currentURL.fileName())) {
                 available = true;
                 break;
             }
         }
     } //check the filename: done
 
     return available;
 }
 
 
 bool KrAction::xmlRead(const QDomElement& element)
 {
     /*
        This has to be done elsewhere!!
 
        if ( element.tagName() != "action" )
           return false;
 
        Also the name has to be checked before the action is created!
 
        setName( element.attribute( "name" ).toLatin1() );
     */
     QString attr;
 
     attr = element.attribute("enabled", "true");   // default: "true"
     if (attr == "false") {
         setEnabled(false);
         setVisible(false);
     }
 
     for (QDomNode node = element.firstChild(); !node.isNull(); node = node.nextSibling()) {
         QDomElement e = node.toElement();
         if (e.isNull())
             continue; // this should skip nodes which are not elements ( i.e. comments, <!-- -->, or text nodes)
 
         if (e.tagName() == "title")
             setText(i18n(e.text().toUtf8().constData()));
         else
             if (e.tagName() == "tooltip")
                 setToolTip(i18n(e.text().toUtf8().constData()));
             else
                 if (e.tagName() == "icon")
                     setIcon(Icon(_iconName = e.text()));
                 else
                     if (e.tagName() == "category")
                         setCategory(i18n(e.text().toUtf8().constData()));
                     else
                         if (e.tagName() == "description")
                             setWhatsThis(i18n(e.text().toUtf8().constData()));
                         else
                             if (e.tagName() == "command")
                                 readCommand(e);
                             else
                                 if (e.tagName() == "startpath")
                                     setStartpath(e.text());
                                 else
                                     if (e.tagName() == "availability")
                                         readAvailability(e);
                                     else
                                         if (e.tagName() == "defaultshortcut")
                                             _actionCollection->setDefaultShortcut(this, QKeySequence(e.text()));
                                         else
 
                                             // unknown but not empty
                                             if (! e.tagName().isEmpty())
                                                 qWarning() << "KrAction::xmlRead() - unrecognized tag found: <action name=\"" << objectName() << "\"><" << e.tagName() << ">";
 
     } // for ( QDomNode node = action->firstChild(); !node.isNull(); node = node.nextSibling() )
 
     return true;
 } //KrAction::xmlRead
 
 QDomElement KrAction::xmlDump(QDomDocument& doc) const
 {
     QDomElement actionElement = doc.createElement("action");
     actionElement.setAttribute("name", objectName());
 
     if (! isVisible()) {
         actionElement.setAttribute("enabled", "false");
     }
 
 #define TEXT_ELEMENT( TAGNAME, TEXT ) \
     { \
         QDomElement e = doc.createElement( TAGNAME ); \
         e.appendChild( doc.createTextNode( TEXT ) ); \
         actionElement.appendChild( e ); \
     }
 
     TEXT_ELEMENT("title", text())
 
     if (! toolTip().isEmpty())
         TEXT_ELEMENT("tooltip", toolTip())
 
     if (! _iconName.isEmpty())
         TEXT_ELEMENT("icon", _iconName)
 
     if (! category().isEmpty())
         TEXT_ELEMENT("category", category())
 
     if (! whatsThis().isEmpty())
         TEXT_ELEMENT("description", whatsThis())
 
     actionElement.appendChild(dumpCommand(doc));
 
     if (! startpath().isEmpty())
         TEXT_ELEMENT("startpath", startpath())
 
     QDomElement availabilityElement = dumpAvailability(doc);
 
     if (availabilityElement.hasChildNodes())
         actionElement.appendChild(availabilityElement);
 
     if (! shortcut().isEmpty())
         TEXT_ELEMENT("defaultshortcut", shortcut().toString())    //.toString() would return a localised string which can't be read again
 
     return actionElement;
 } //KrAction::xmlDump
 
 void KrAction::readCommand(const QDomElement& element)
 {
     QString attr;
 
     attr = element.attribute("executionmode", "normal");   // default: "normal"
     if (attr == "normal")
         setExecType(Normal);
     else
         if (attr == "terminal")
             setExecType(Terminal);
         else if (attr == "collect_output")
             setExecType(CollectOutput);
         else if (attr == "collect_output_separate_stderr")
             setExecType(CollectOutputSeparateStderr);
         else if (attr == "embedded_terminal")
             setExecType(RunInTE);
         else
             qWarning() << "KrAction::readCommand() - unrecognized attribute value found: <action name=\"" << objectName() << "\"><command executionmode=\"" << attr << "\"";
 
     attr = element.attribute("accept", "local");   // default: "local"
     if (attr == "local")
         setAcceptURLs(false);
     else if (attr == "url")
         setAcceptURLs(true);
     else
         qWarning() << "KrAction::readCommand() - unrecognized attribute value found: <action name=\"" << objectName() << "\"><command accept=\"" << attr << "\"";
 
     attr = element.attribute("confirmexecution", "false");   // default: "false"
     if (attr == "true")
         setConfirmExecution(true);
     else
         setConfirmExecution(false);
 
     setUser(element.attribute("run_as"));
 
     setCommand(element.text());
 
 } //KrAction::readCommand
 
 QDomElement KrAction::dumpCommand(QDomDocument& doc) const
 {
     QDomElement commandElement = doc.createElement("command");
 
     switch (execType()) {
     case Terminal:
         commandElement.setAttribute("executionmode", "terminal");
         break;
     case CollectOutput:
         commandElement.setAttribute("executionmode", "collect_output");
         break;
     case CollectOutputSeparateStderr:
         commandElement.setAttribute("executionmode", "collect_output_separate_stderr");
         break;
     case RunInTE:
         commandElement.setAttribute("executionmode", "embedded_terminal");
         break;
     default:
         // don't write the default to file
         break;
     }
 
     if (acceptURLs())
         commandElement.setAttribute("accept", "url");
 
     if (confirmExecution())
         commandElement.setAttribute("confirmexecution", "true");
 
     if (! user().isEmpty())
         commandElement.setAttribute("run_as", user());
 
     commandElement.appendChild(doc.createTextNode(command()));
 
     return commandElement;
 } //KrAction::dumpCommand
 
 void KrAction::readAvailability(const QDomElement& element)
 {
     for (QDomNode node = element.firstChild(); ! node.isNull(); node = node.nextSibling()) {
         QDomElement e = node.toElement();
         if (e.isNull())
             continue; // this should skip nodes which are not elements ( i.e. comments, <!-- -->, or text nodes)
 
-        QStringList* showlist = 0;
+        QStringList* showlist = nullptr;
 
         if (e.tagName() == "protocol")
             showlist = &_showonlyProtocol;
         else
             if (e.tagName() == "path")
                 showlist = &_showonlyPath;
             else
                 if (e.tagName() == "mimetype")
                     showlist = & _showonlyMime;
                 else
                     if (e.tagName() == "filename")
                         showlist = & _showonlyFile;
                     else {
                         qWarning() << "KrAction::readAvailability() - unrecognized element found: <action name=\"" << objectName() << "\"><availability><" << e.tagName() << ">";
-                        showlist = 0;
+                        showlist = nullptr;
                     }
 
         if (showlist) {
             for (QDomNode subnode = e.firstChild(); ! subnode.isNull(); subnode = subnode.nextSibling()) {
                 QDomElement subelement = subnode.toElement();
                 if (subelement.tagName() == "show")
                     showlist->append(subelement.text());
             } // for
         } // if ( showlist )
 
     } // for
 } //KrAction::readAvailability
 
 QDomElement KrAction::dumpAvailability(QDomDocument& doc) const
 {
     QDomElement availabilityElement = doc.createElement("availability");
 
 # define LIST_ELEMENT( TAGNAME, LIST ) \
     { \
         QDomElement e = doc.createElement( TAGNAME ); \
         for ( QStringList::const_iterator it = LIST.constBegin(); it != LIST.constEnd(); ++it ) { \
             QDomElement show = doc.createElement( "show" ); \
             show.appendChild( doc.createTextNode( *it ) ); \
             e.appendChild( show ); \
         } \
         availabilityElement.appendChild( e ); \
     }
 
     if (! _showonlyProtocol.isEmpty())
         LIST_ELEMENT("protocol", _showonlyProtocol)
 
         if (! _showonlyPath.isEmpty())
             LIST_ELEMENT("path", _showonlyPath)
 
             if (! _showonlyMime.isEmpty())
                 LIST_ELEMENT("mimetype", _showonlyMime)
 
                 if (! _showonlyFile.isEmpty())
                     LIST_ELEMENT("filename", _showonlyFile)
 
                     return availabilityElement;
 } //KrAction::dumpAvailability
diff --git a/krusader/UserAction/kraction.h b/krusader/UserAction/kraction.h
index 2d1fd03e..6df65cfc 100644
--- a/krusader/UserAction/kraction.h
+++ b/krusader/UserAction/kraction.h
@@ -1,250 +1,250 @@
 /*****************************************************************************
  * Copyright (C) 2004 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2004 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2006 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRACTION_H
 #define KRACTION_H
 
 // QtCore
 #include <QByteArray>
 #include <QUrl>
 // QtGui
 #include <QFont>
 // QtWidgets
 #include <QAction>
 #include <QDialog>
 
 #include <KCoreAddons/KProcess>
 #include <KTextWidgets/KTextEdit>
 
 #include "kractionbase.h"
 
 class QDomDocument;
 class QDomElement;
 class KActionCollection;
 
 /**
  * This subclass of QAction extends it with an individual executor and
  * a struct UserActionProperties.
  * It is used to integrate useractions into KDE's QAction-System
  */
 class KrAction: public QAction, public KrActionBase
 {
     Q_OBJECT
 public:
-    explicit KrAction(KActionCollection *parent, QString name = QString());
-    ~KrAction();
+    explicit KrAction(KActionCollection *parent, const QString& name = QString());
+    ~KrAction() override;
 
     /**
      * This chekcs if the KrAction is for a specific file / location available
      * @param currentURL Check for this file
      * @return true if the KrAction if available
      */
     bool isAvailable(const QUrl &currentURL);
 
     const QString& iconName() const {
         return _iconName;
     } // TODO: added for kde4 porting (functionality is missing)
     void setIconName(const QString& name) {
         _iconName = name;
     }
 
     bool xmlRead(const QDomElement& element);
     QDomElement xmlDump(QDomDocument& doc) const;
 
     QString category() const {
         return _category;
     };
     void setCategory(const QString& category) {
         _category = category;
     };
 
     QString command() const Q_DECL_OVERRIDE {
         return _command;
     };
     void setCommand(const QString& command) {
         _command = command;
     };
 
     QString user() const Q_DECL_OVERRIDE {
         return _user;
     };
     void setUser(const QString& user) {
         _user = user;
     };
 
     QString startpath() const Q_DECL_OVERRIDE {
         return _startpath;
     };
     void setStartpath(const QString& startpath) {
         _startpath = startpath;
     };
 
     ExecType execType() const Q_DECL_OVERRIDE {
         return _execType;
     };
     void setExecType(ExecType execType) {
         _execType = execType;
     };
 
     bool acceptURLs() const Q_DECL_OVERRIDE {
         return _acceptURLs;
     };
     void setAcceptURLs(const bool& acceptURLs) {
         _acceptURLs = acceptURLs;
     };
 
     bool confirmExecution() const Q_DECL_OVERRIDE {
         return _confirmExecution;
     };
     void setConfirmExecution(const bool& confirmExecution) {
         _confirmExecution = confirmExecution;
     };
 
     QStringList showonlyProtocol() const {
         return _showonlyProtocol;
     };
     void setShowonlyProtocol(const QStringList& showonlyProtocol) {
         _showonlyProtocol = showonlyProtocol;
     };
 
     QStringList showonlyPath() const {
         return _showonlyPath;
     };
     void setShowonlyPath(const QStringList& showonlyPath) {
         _showonlyPath = showonlyPath;
     };
 
     QStringList showonlyMime() const {
         return _showonlyMime;
     };
     void setShowonlyMime(const QStringList& showonlyMime) {
         _showonlyMime = showonlyMime;
     };
 
     QStringList showonlyFile() const {
         return _showonlyFile;
     };
     void setShowonlyFile(const QStringList& showonlyFile) {
         _showonlyFile = showonlyFile;
     };
 
     bool doSubstitution() const Q_DECL_OVERRIDE {
         return true;
     }
 
     QString text() const Q_DECL_OVERRIDE {
         return QAction::text();
     }
 
 public slots:
     void exec() {
         KrActionBase::exec();
     }
 
 
 private:
     void readCommand(const QDomElement& element);
     QDomElement dumpCommand(QDomDocument& doc) const;
 
     void readAvailability(const QDomElement& element);
     QDomElement dumpAvailability(QDomDocument& doc) const;
 
     QString _iconName;
     QString _category;
     QString _command;
     QString _user;
     QString _startpath;
     ExecType _execType;
     bool _acceptURLs;
     bool _confirmExecution;
     QStringList _showonlyProtocol;
     QStringList _showonlyPath;
     QStringList _showonlyMime;
     QStringList _showonlyFile;
     KActionCollection *_actionCollection;
 };
 
 /**
  * This displays the output of a process
  */
 class KrActionProcDlg: public QDialog
 {
     Q_OBJECT
 public:
-    explicit KrActionProcDlg(QString caption, bool enableStderr = false, QWidget *parent = 0);
+    explicit KrActionProcDlg(const QString& caption, bool enableStderr = false, QWidget *parent = nullptr);
 
 public slots:
     void addStderr(const QString& str);
     void addStdout(const QString& str);
     void slotProcessFinished();
 
 protected slots:
     void toggleFixedFont(bool state);
     void slotSaveAs();
 
 
 signals:
     void killClicked();
 
 private:
     KTextEdit *_stdout;
     KTextEdit *_stderr;
     KTextEdit *_currentTextEdit;
     QFont normalFont;
     QFont fixedFont;
     QPushButton *closeButton;
     QPushButton *killButton;
 private slots:
     void currentTextEditChanged();
 };
 
 /**
  * This executes a command of a UserAction
  */
 // TODO jonas: call a list of commands separately (I began it but it doesn't work)
 class KrActionProc: public QObject
 {
     Q_OBJECT
 public:
 
     explicit KrActionProc(KrActionBase* action);
-    virtual ~KrActionProc();
-    void start(QString cmdLine);
+    ~KrActionProc() override;
+    void start(const QString& cmdLine);
     void start(QStringList cmdLineList);
 
 protected slots:
     void kill() {
         _proc->kill();
     }
     void processExited(int exitCode, QProcess::ExitStatus exitStatus);
     void addStderr();
     void addStdout();
 
 private:
     KrActionBase* _action;
     KProcess *_proc;
     QString _stdout;
     QString _stderr;
     KrActionProcDlg *_output;
 };
 
 #endif //KRACTION_H
diff --git a/krusader/UserAction/kractionbase.cpp b/krusader/UserAction/kractionbase.cpp
index 996aabaa..0c40f593 100644
--- a/krusader/UserAction/kractionbase.cpp
+++ b/krusader/UserAction/kractionbase.cpp
@@ -1,90 +1,89 @@
 /*****************************************************************************
  * Copyright (C) 2006 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2006 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kractionbase.h"
 
 // QtWidgets
 #include <QInputDialog>
 
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "kraction.h"
 #include "../krglobal.h"
 
 KrActionBase::~KrActionBase()
-{
-}
+= default;
 
 void KrActionBase::exec()
 {
-    KrActionProc *proc = 0;
+    KrActionProc *proc = nullptr;
 
     // replace %% and prepare string
     QStringList commandList;
     if (doSubstitution()) {
         Expander exp;
         exp.expand(command(), acceptURLs());
         if (exp.error()) {
             handleError(exp.error());
             return;
         }
         commandList = exp.result();
     } else
         commandList << command();
     //TODO: query expander for status and may skip the rest of the function
 
     // stop here if the commandline is empty
     if (commandList.count() == 1 && commandList[0].trimmed().isEmpty())
         return;
 
     if (confirmExecution()) {
-        for (QStringList::iterator it = commandList.begin(); it != commandList.end(); ++it) {
+        for (auto & it : commandList) {
             bool exec = true;
-            *it = QInputDialog::getText(krMainWindow, i18n("Confirm Execution"), i18n("Command being executed:"),
-                      QLineEdit::Normal, *it, &exec);
+            it = QInputDialog::getText(krMainWindow, i18n("Confirm Execution"), i18n("Command being executed:"),
+                      QLineEdit::Normal, it, &exec);
             if (exec) {
                 proc = actionProcFactoryMethod();
-                proc->start(*it);
+                proc->start(it);
             }
         } //for
     } // if ( _properties->confirmExecution() )
     else {
         proc = actionProcFactoryMethod();
         proc->start(commandList);
     }
 
 }
 
 void KrActionBase::handleError(const Error& err)
 {
     // once qtHandler is instantiated, it keeps on showing all qDebug() messages
     //QErrorMessage::qtHandler()->showMessage(err.what());
-    const QString errorMessage = err.description();
+    const QString& errorMessage = err.description();
     if (!errorMessage.isEmpty()) {
         KMessageBox::error(krMainWindow, errorMessage);
     }
 }
 
 KrActionProc* KrActionBase::actionProcFactoryMethod()
 {
     return new KrActionProc(this);
 }
diff --git a/krusader/UserAction/useraction.cpp b/krusader/UserAction/useraction.cpp
index b7ffaa7b..04bef95f 100644
--- a/krusader/UserAction/useraction.cpp
+++ b/krusader/UserAction/useraction.cpp
@@ -1,306 +1,306 @@
 /*****************************************************************************
  * Copyright (C) 2004 Jonas Bähr <jonas.baehr@web.de>                        *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "useraction.h"
 
 // QtCore
 #include <QDebug>
 #include <QFile>
 #include <QHash>
 #include <QStandardPaths>
 #include <QTextStream>
 #include <QUrl>
 // QtXml
 #include <QDomDocument>
 #include <QDomElement>
 // QtWidgets
 #include <QMenu>
 
 #include <KI18n/KLocalizedString>
 #include <KXmlGui/KActionCollection>
 #include <KWidgetsAddons/KActionMenu>
 #include <KWidgetsAddons/KMessageBox>
 
 #include "kraction.h"
 #include "../FileSystem/filesystem.h"
 #include "../Panel/PanelView/krview.h"
 #include "../Panel/krpanel.h"
 #include "../Panel/panelfunc.h"
 #include "../krusader.h"
 #include "../krusaderview.h"
 
 UserAction::UserAction()
 {
     readAllFiles();
 }
 
 UserAction::~UserAction()
 {
     // KrActions are deleted by Krusader's KActionCollection
 }
 
 void UserAction::removeKrAction(KrAction* action)
 {
     _actions.removeAll(action);
     if (_defaultActions.contains(action->objectName()))
         _deletedActions.insert(action->objectName());
 }
 
 void UserAction::setAvailability()
 {
     setAvailability(ACTIVE_FUNC->files()->getUrl(ACTIVE_PANEL->view->getCurrentItem()));
 }
 
 void UserAction::setAvailability(const QUrl &currentURL)
 {
     //qDebug() << "UserAction::setAvailability currentFile: " << currentURL.url();
     // disable the entries that should not appear in this folder
     QListIterator<KrAction *> it(_actions);
     while (it.hasNext()) {
         KrAction * action = it.next();
         action->setEnabled(action->isAvailable(currentURL));
     }
 }
 
 void UserAction::populateMenu(KActionMenu* menu, const QUrl *currentURL)
 {
     // I have not found any method in Qt/KDE
     // for non-recursive searching of children by name ...
     QMap<QString, KActionMenu *> categoryMap;
     QList<KrAction *> uncategorised;
 
     foreach(KrAction* action, _actions) {
         const QString category = action->category();
         if (! action->isEnabled())
             continue;
-        if (currentURL != NULL && ! action->isAvailable(*currentURL))
+        if (currentURL != nullptr && ! action->isAvailable(*currentURL))
             continue;
         if (category.isEmpty()) {
             uncategorised.append(action);
         } else {
             if (! categoryMap.contains(category)) {
-                KActionMenu *categoryMenu = new KActionMenu(category, menu);
+                auto *categoryMenu = new KActionMenu(category, menu);
                 categoryMenu->setObjectName(category);
                 categoryMap.insert(category, categoryMenu);
             }
             KActionMenu *targetMenu = categoryMap.value(category);
             targetMenu->addAction(action);
         }
     }
 
     QMutableMapIterator<QString, KActionMenu *> mapIter(categoryMap);
     while (mapIter.hasNext()) {
         mapIter.next();
         menu->addAction(mapIter.value());
     }
 
     foreach(KrAction* action, uncategorised) {
         menu->addAction(action);
     };
 }
 
 QStringList UserAction::allCategories()
 {
     QStringList actionCategories;
 
     QListIterator<KrAction *> it(_actions);
     while (it.hasNext()) {
         KrAction * action = it.next();
         if (actionCategories.indexOf(action->category()) == -1)
             actionCategories.append(action->category());
     }
 
     return actionCategories;
 }
 
 QStringList UserAction::allNames()
 {
     QStringList actionNames;
 
     QListIterator<KrAction *> it(_actions);
     while (it.hasNext()) {
         KrAction * action = it.next();
         actionNames.append(action->objectName());
     }
 
     return actionNames;
 }
 
 void UserAction::readAllFiles()
 {
     QString filename = QStandardPaths::locate(QStandardPaths::GenericDataLocation, ACTION_XML);   // locate returns the local file if it exists, else the global one is retrieved.
     if (! filename.isEmpty())
         readFromFile(QStandardPaths::locate(QStandardPaths::GenericDataLocation, ACTION_XML), renameDoublicated);
 
     filename = QStandardPaths::locate(QStandardPaths::GenericDataLocation, ACTION_XML_EXAMPLES);
     if (! filename.isEmpty())
         readFromFile(QStandardPaths::locate(QStandardPaths::GenericDataLocation, ACTION_XML_EXAMPLES), ignoreDoublicated);     // ignore samples which are already in the normal file
 }
 
 void UserAction::readFromFile(const QString& filename, ReadMode mode, KrActionList* list)
 {
     QDomDocument* doc = new QDomDocument(ACTION_DOCTYPE);
     QFile file(filename);
     if (file.open(QIODevice::ReadOnly)) {
         //qDebug() << "UserAction::readFromFile - " << filename << "could be opened";
         if (! doc->setContent(&file)) {
             //qDebug() << "UserAction::readFromFile - content set - failed";
             // if the file doesn't exist till now, the content CAN be set but is empty.
             // if the content can't be set, the file exists and is NOT an xml-file.
             file.close();
-            delete doc; doc = 0;
+            delete doc; doc = nullptr;
             KMessageBox::error(MAIN_VIEW,
                                i18n("The file %1 does not contain valid UserActions.\n", filename),   // text
                                i18n("UserActions - cannot read from file") // caption
                               );
         }
         file.close();
 
         if (doc) {
             QDomElement root = doc->documentElement();
             // check if the file has got the right root-element (ACTION_ROOT)
             // this finds out if the xml-file read to the DOM is really a krusader
             // useraction-file
             if (root.tagName() != ACTION_ROOT) {
                 KMessageBox::error(MAIN_VIEW,
                                    i18n("The actionfile's root element is not called %1, using %2", QString::fromLatin1(ACTION_ROOT),  filename),
                                    i18n("UserActions - cannot read from file")
                                   );
-                delete doc; doc = 0;
+                delete doc; doc = nullptr;
             }
             readFromElement(root, mode, list);
             delete doc;
         }
 
     } // if ( file.open( QIODevice::ReadOnly ) )
     else {
         KMessageBox::error(MAIN_VIEW,
                            i18n("Unable to open actions file %1", filename),
                            i18n("UserActions - cannot read from file")
                           );
     }
 
 }
 
 void UserAction::readFromElement(const QDomElement& element, ReadMode mode, KrActionList* list)
 {
     for (QDomNode node = element.firstChild(); ! node.isNull(); node = node.nextSibling()) {
         QDomElement e = node.toElement();
         if (e.isNull())
             continue; // this should skip nodes which are not elements ( i.e. comments, <!-- -->, or text nodes)
 
         if (e.tagName() == "action") {
             QString name = e.attribute("name");
             if (name.isEmpty()) {
                 KMessageBox::error(MAIN_VIEW,
                                    i18n("Action without name detected. This action will not be imported.\nThis is an error in the file, you may want to correct it."),
                                    i18n("UserActions - invalid action")
                                   );
                 continue;
             }
 
             if (mode == ignoreDoublicated) {
                 _defaultActions.insert(name);
                 if (krApp->actionCollection()->action(name) || _deletedActions.contains(name))
                     continue;
             }
 
             QString basename = name + "_%1";
             int i = 0;
             // append a counter till the name is unique... (this checks every action, not only useractions)
             while (krApp->actionCollection()->action(name))
                 name = basename.arg(++i);
 
             KrAction* act = new KrAction(krApp->actionCollection(), name);
             if (act->xmlRead(e)) {
                 _actions.append(act);
                 if (list)
                     list->append(act);
             } else
                 delete act;
         } else
             if (e.tagName() == "deletedAction") {
                 QString name = e.attribute("name");
                 if (name.isEmpty()) {
                     qWarning() << "A deleted action without name detected! \nThis is an error in the file.";
                     continue;
                 }
                 _deletedActions.insert(name);
             }
     } // for
 }
 
 QDomDocument UserAction::createEmptyDoc()
 {
     QDomDocument doc = QDomDocument(ACTION_DOCTYPE);
     // adding: <?xml version="1.0" encoding="UTF-8" ?>
     doc.appendChild(doc.createProcessingInstruction("xml", ACTION_PROCESSINSTR));
     //adding root-element
     doc.appendChild(doc.createElement(ACTION_ROOT));     // create new actionfile by adding a root-element ACTION_ROOT
     return doc;
 }
 
 bool UserAction::writeActionFile()
 {
     QString filename = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1Char('/') + ACTION_XML;
 
     QDomDocument doc = createEmptyDoc();
     QDomElement root = doc.documentElement();
 
     foreach(const QString &name, _deletedActions) {
         QDomElement element = doc.createElement("deletedAction");
         element.setAttribute("name", name);
         root.appendChild(element);
     }
 
     QListIterator<KrAction *> it(_actions);
     while (it.hasNext()) {
         KrAction * action = it.next();
         root.appendChild(action->xmlDump(doc));
     }
 
     return writeToFile(doc, filename);
 }
 
 bool UserAction::writeToFile(const QDomDocument& doc, const QString& filename)
 {
     QFile file(filename);
     if (! file.open(QIODevice::WriteOnly))
         return false;
 
     /* // This is not needed, because each DomDocument created with UserAction::createEmptyDoc already contains the processinstruction
        if ( ! doc.firstChild().isProcessingInstruction() ) {
           // adding: <?xml version="1.0" encoding="UTF-8" ?> if not already present
           QDomProcessingInstruction instr = doc.createProcessingInstruction( "xml", ACTION_PROCESSINSTR );
           doc.insertBefore( instr, doc.firstChild() );
        }
     */
 
     QTextStream ts(&file);
     ts.setCodec("UTF-8");
     ts << doc.toString();
 
     file.close();
     return true;
 }
 
 
 
 
diff --git a/krusader/actionsbase.cpp b/krusader/actionsbase.cpp
index e37b38ca..670366c1 100644
--- a/krusader/actionsbase.cpp
+++ b/krusader/actionsbase.cpp
@@ -1,119 +1,120 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "actionsbase.h"
 
 #include "krmainwindow.h"
 #include "icon.h"
 
 // QtWidgets
 #include <QAction>
 
 #include <KXmlGui/KActionCollection>
 #include <KWidgetsAddons/KToggleAction>
+#include <utility>
 
 void ActionsBase::ActionGroup::reconnect(QObject *recv)
 {
     foreach(QAction *action, _slots.keys()) {
-        disconnect(action, 0, 0, 0);
+        disconnect(action, nullptr, nullptr, nullptr);
         connect(action, SIGNAL(triggered(bool)), recv, _slots[action]);
     }
 }
 
 void ActionsBase::ActionGroup::addAction(QAction *action, const char *slot)
 {
     _slots.insert(action, slot);
 }
 
 
-QAction *ActionsBase::createAction(QString text, QString icon, bool isToggleAction)
+QAction *ActionsBase::createAction(const QString& text, const QString& icon, bool isToggleAction)
 {
     if(isToggleAction) {
-        if (icon == 0)
+        if (icon == nullptr)
             return (QAction *)(new KToggleAction(text, this));
         else
             return (QAction *)(new KToggleAction(Icon(icon), text, this));
     } else {
-        if (icon == 0)
+        if (icon == nullptr)
             return new QAction(text, this);
         else
             return new QAction(Icon(icon), text, this);
     }
 }
 
-QAction *ActionsBase::action(QString text, QString icon, QKeySequence shortcut,
-                                 QObject *recv, const char *slot, QString name, bool isToggleAction)
+QAction *ActionsBase::action(QString text, QString icon, const QKeySequence& shortcut,
+                                 QObject *recv, const char *slot, const QString& name, bool isToggleAction)
 {
-    QAction *a = createAction(text, icon, isToggleAction);
+    QAction *a = createAction(std::move(text), std::move(icon), isToggleAction);
 
     connect(a, SIGNAL(triggered(bool)), recv, slot);
     _mainWindow->actions()->addAction(name, a);
     _mainWindow->actions()->setDefaultShortcut(a, shortcut);
 
     return a;
 }
 
 QAction *ActionsBase::action(QString text, QString icon, const QList<QKeySequence> &shortcuts,
-                             QObject *recv, const char *slot, QString name, bool isToggleAction)
+                             QObject *recv, const char *slot, const QString& name, bool isToggleAction)
 {
-    QAction *a = createAction(text, icon, isToggleAction);
+    QAction *a = createAction(std::move(text), std::move(icon), isToggleAction);
 
     connect(a, SIGNAL(triggered(bool)), recv, slot);
     _mainWindow->actions()->addAction(name, a);
     _mainWindow->actions()->setDefaultShortcuts(a, shortcuts);
 
     return a;
 }
 
-QAction *ActionsBase::action(QString text, QString icon, QKeySequence shortcut,
-                             ActionGroup &group, const char *slot, QString name, bool isToggleAction)
+QAction *ActionsBase::action(QString text, QString icon, const QKeySequence& shortcut,
+                             ActionGroup &group, const char *slot, const QString& name, bool isToggleAction)
 {
-    QAction *action = createAction(text, icon, isToggleAction);
+    QAction *action = createAction(std::move(text), std::move(icon), isToggleAction);
 
     group.addAction(action, slot);
     _mainWindow->actions()->addAction(name, action);
     _mainWindow->actions()->setDefaultShortcut(action, shortcut);
 
     return action;
 }
 
-KToggleAction *ActionsBase::toggleAction(QString text, QString icon, QKeySequence shortcut,
+KToggleAction *ActionsBase::toggleAction(QString text, QString icon, const QKeySequence& shortcut,
                                 QObject *recv, const char *slot, QString name)
 {
-    return (KToggleAction *)(action(text, icon, shortcut, recv, slot, name, true));
+    return (KToggleAction *)(action(std::move(text), std::move(icon), shortcut, recv, slot, std::move(name), true));
 }
 
-KToggleAction *ActionsBase::toggleAction(QString text, QString icon, QKeySequence shortcut,
+KToggleAction *ActionsBase::toggleAction(QString text, QString icon, const QKeySequence& shortcut,
                                          ActionGroup &group, const char *slot, QString name)
 {
-    return (KToggleAction *)(action(text, icon, shortcut, group, slot, name, true));
+    return (KToggleAction *)(action(std::move(text), std::move(icon), shortcut, group, slot, std::move(name), true));
 }
 
 QAction *ActionsBase::stdAction(KStandardAction::StandardAction id, QObject *recv, const char *slot)
 {
     return KStandardAction::create(id, recv, slot, _mainWindow->actions());
 }
 
 QAction *ActionsBase::stdAction(KStandardAction::StandardAction id, ActionGroup &group, const char *slot)
 {
-    QAction *action = KStandardAction::create(id, 0, 0, _mainWindow->actions());
+    QAction *action = KStandardAction::create(id, nullptr, nullptr, _mainWindow->actions());
     group.addAction(action, slot);
     return action;
 }
diff --git a/krusader/actionsbase.h b/krusader/actionsbase.h
index f50db4bd..200790b2 100644
--- a/krusader/actionsbase.h
+++ b/krusader/actionsbase.h
@@ -1,82 +1,82 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef ACTIONSBASE_H
 #define ACTIONSBASE_H
 
 // QtCore
 #include <QObject>
 #include <QHash>
 // QtGui
 #include <QKeySequence>
 // QtWidgets
 #include <QAction>
 
 #include <KConfigWidgets/KStandardAction>
 
 class KrMainWindow;
 
 class ActionsBase : public QObject
 {
     Q_OBJECT
 protected:
     ActionsBase(QObject *parent, KrMainWindow *mainWindow) : QObject(parent),
                 _mainWindow(mainWindow) {}
     class ActionGroup
     {
         QHash<QAction*, const char*> _slots;
     public:
         void reconnect(QObject *recv);
         void addAction(QAction *action, const char *slot);
     };
 
-    QAction *createAction(QString text, QString icon, bool isToggleAction);
+    QAction *createAction(const QString& text, const QString& icon, bool isToggleAction);
 
-    QAction *action(QString text, QString icon, QKeySequence shortcut,
-                    QObject *recv, const char *slot, QString name, bool isToggleAction = false);
+    QAction *action(QString text, QString icon, const QKeySequence& shortcut,
+                    QObject *recv, const char *slot, const QString& name, bool isToggleAction = false);
     QAction *action(QString text, QString icon, QKeySequence shortcut,
                     const char *slot, QString name) {
         return action(text, icon, shortcut, this, slot, name);
     }
     QAction *action(QString text, QString icon, const QList<QKeySequence> &shortcuts,
-                    QObject *recv, const char *slot, QString name, bool isToggleAction = false);
-    QAction *action(QString text, QString icon, QKeySequence shortcut,
-                    ActionGroup &group, const char *slot, QString name, bool isToggleAction = false);
+                    QObject *recv, const char *slot, const QString& name, bool isToggleAction = false);
+    QAction *action(QString text, QString icon, const QKeySequence& shortcut,
+                    ActionGroup &group, const char *slot, const QString& name, bool isToggleAction = false);
 
-    KToggleAction *toggleAction(QString text, QString icon, QKeySequence shortcut,
+    KToggleAction *toggleAction(QString text, QString icon, const QKeySequence& shortcut,
                                 QObject *recv, const char *slot, QString name);
     KToggleAction *toggleAction(QString text, QString icon, QKeySequence shortcut,
                                 const char *slot, QString name) {
         return toggleAction(text, icon, shortcut, this, slot, name);
     }
-    KToggleAction *toggleAction(QString text, QString icon, QKeySequence shortcut,
+    KToggleAction *toggleAction(QString text, QString icon, const QKeySequence& shortcut,
                                 ActionGroup &group, const char *slot, QString name);
 
     QAction *stdAction(KStandardAction::StandardAction id, QObject *recv, const char *slot);
     QAction *stdAction(KStandardAction::StandardAction id, const char *slot) {
         return stdAction(id, this, slot);
     }
     QAction *stdAction(KStandardAction::StandardAction id,
                        ActionGroup &group, const char *slot);
 
     KrMainWindow *_mainWindow;
 };
 
 #endif // ACTIONSBASE_H
diff --git a/krusader/icon.cpp b/krusader/icon.cpp
index d7e259d6..587c2a53 100644
--- a/krusader/icon.cpp
+++ b/krusader/icon.cpp
@@ -1,310 +1,311 @@
 /*****************************************************************************
  * Copyright (C) 2018 Nikita Melnichenko <nikita+kde@melnichenko.name>       *
  * Copyright (C) 2018 Krusader Krew [https://krusader.org]                   *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "icon.h"
 
 #include "krglobal.h"
 
 // QtCore
 #include <QCache>
 #include <QPair>
 #include <QDir>
 #include <QDebug>
 // QtGui
 #include <QPainter>
 #include <QPixmap>
 #include <QPalette>
 
 #include <KConfigCore/KSharedConfig>
 #include <KIconThemes/KIconLoader>
+#include <utility>
 
 
 static const int cacheSize = 500;
 static const char *missingIconPath = ":/icons/icon-missing.svgz";
 
 
 static inline QStringList getThemeFallbackList()
 {
     QStringList themes;
 
     // add user fallback theme if set
     if (krConfig) {
         const KConfigGroup group(krConfig, QStringLiteral("Startup"));
         QString userFallbackTheme = group.readEntry("Fallback Icon Theme", QString());
         if (!userFallbackTheme.isEmpty()) {
             themes << userFallbackTheme;
         }
     }
 
     // Breeze and Oxygen are weak dependencies of Krusader,
     // i.e. each of the themes provide a complete set of icons used in the interface
     const QString breeze(Icon::isLightWindowThemeActive() ? "breeze" : "breeze-dark");
     themes << breeze << "oxygen";
 
     return themes;
 }
 
 
 class IconEngine : public QIconEngine
 {
 public:
     IconEngine(QString iconName, QIcon fallbackIcon, QStringList overlays = QStringList()) :
-        _iconName(iconName), _fallbackIcon(fallbackIcon), _overlays(overlays)
+        _iconName(std::move(iconName)), _fallbackIcon(std::move(fallbackIcon)), _overlays(std::move(overlays))
     {
         _themeFallbackList = getThemeFallbackList();
     }
 
-    virtual void paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state) override;
-    virtual QPixmap pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) override;
+    void paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state) override;
+    QPixmap pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) override;
 
-    virtual IconEngine *clone() const override
+    IconEngine *clone() const override
     {
         return new IconEngine(*this);
     }
 
 private:
     QString _iconName;
     QStringList _themeFallbackList;
     QIcon _fallbackIcon;
     QStringList _overlays;
 };
 
-Icon::Icon() : QIcon()
+Icon::Icon()
 {
 }
 
 Icon::Icon(QString name, QStringList overlays) :
-    QIcon(new IconEngine(name, QIcon(missingIconPath), overlays))
+    QIcon(new IconEngine(std::move(name), QIcon(missingIconPath), std::move(overlays)))
 {
 }
 
 Icon::Icon(QString name, QIcon fallbackIcon, QStringList overlays) :
-    QIcon(new IconEngine(name, fallbackIcon, overlays))
+    QIcon(new IconEngine(std::move(name), std::move(fallbackIcon), std::move(overlays)))
 {
 }
 
 struct IconSearchResult
 {
     QIcon icon; ///< icon returned by search; null icon if not found
     QString originalThemeName; ///< original theme name if theme is modified by search
 
     IconSearchResult(QIcon icon, QString originalThemeName) :
-        icon(icon), originalThemeName(originalThemeName) {}
+        icon(std::move(icon)), originalThemeName(std::move(originalThemeName)) {}
 };
 
 // Search icon in the configured themes.
 // If this call modifies active theme, the original theme name will be specified in the result.
-static inline IconSearchResult searchIcon(QString iconName, QStringList themeFallbackList)
+static inline IconSearchResult searchIcon(const QString& iconName, QStringList themeFallbackList)
 {
     if (QDir::isAbsolutePath(iconName)) {
         // a path is used - directly load the icon
         return IconSearchResult(QIcon(iconName), QString());
     } else if (QIcon::hasThemeIcon(iconName)) {
         // current theme has the icon - load seamlessly
         return IconSearchResult(QIcon::fromTheme(iconName), QString());
     } else if (KIconLoader::global()->hasIcon(iconName)) {
         // KF icon loader does a wider search and helps with mime icons
         return IconSearchResult(KDE::icon(iconName), QString());
     } else {
         // search the icon in fallback themes
         auto currentTheme = QIcon::themeName();
-        for (auto fallbackThemeName : themeFallbackList) {
+        for (const auto& fallbackThemeName : themeFallbackList) {
             QIcon::setThemeName(fallbackThemeName);
             if (QIcon::hasThemeIcon(iconName)) {
                 return IconSearchResult(QIcon::fromTheme(iconName), currentTheme);
             }
         }
         QIcon::setThemeName(currentTheme);
 
         // not found
         return IconSearchResult(QIcon(), QString());
     }
 }
 
-bool Icon::exists(QString iconName)
+bool Icon::exists(const QString& iconName)
 {
     static QCache<QString, bool> cache(cacheSize);
     static QString cachedTheme;
 
     // invalidate cache if system theme is changed
     if (cachedTheme != QIcon::themeName()) {
         cache.clear();
         cachedTheme = QIcon::themeName();
     }
 
     // return cached result when possible
     if (cache.contains(iconName)) {
         return *cache.object(iconName);
     }
 
     auto searchResult = searchIcon(iconName, getThemeFallbackList());
     if (!searchResult.originalThemeName.isNull()) {
         QIcon::setThemeName(searchResult.originalThemeName);
     }
 
-    bool *result = new bool(!searchResult.icon.isNull());
+    auto *result = new bool(!searchResult.icon.isNull());
 
     // update the cache; the cache takes ownership over the result
     cache.insert(iconName, result);
 
     return *result;
 }
 
 void Icon::applyOverlays(QPixmap *pixmap, QStringList overlays)
 {
     auto iconLoader = KIconLoader::global();
 
     // Since KIconLoader loadIcon is not virtual method, we can't redefine loadIcon
     // that is called by drawOverlays. The best we can do is to go over the overlays
     // and ensure they exist from the icon loader point of view.
     // If not, we replace the overlay with "emblem-unreadable" which should be available
     // per freedesktop icon name specification:
     // https://specifications.freedesktop.org/icon-naming-spec/icon-naming-spec-latest.html
     QStringList fixedOverlays;
-    for (auto overlay : overlays) {
+    for (const auto& overlay : overlays) {
         if (overlay.isEmpty() || iconLoader->hasIcon(overlay)) {
             fixedOverlays << overlay;
         } else {
             fixedOverlays << "emblem-unreadable";
         }
     }
 
     iconLoader->drawOverlays(fixedOverlays, *pixmap, KIconLoader::Desktop);
 }
 
 bool Icon::isLightWindowThemeActive()
 {
     const QColor textColor = QPalette().brush(QPalette::Text).color();
     return (textColor.red() + textColor.green() + textColor.blue()) / 3 < 128;
 }
 
 
 class IconCacheKey
 {
 public:
-    IconCacheKey(const QString &name, QStringList overlays,
+    IconCacheKey(const QString &name, const QStringList& overlays,
                  const QSize &size, QIcon::Mode mode, QIcon::State state) :
         name(name), overlays(overlays), size(size), mode(mode), state(state)
     {
 
         auto repr = QString("%1 [%2] %3x%4 %5 %6").arg(name).arg(overlays.join(';'))
                                                   .arg(size.width()).arg(size.height())
                                                   .arg((int)mode).arg((int)state);
         _hash = qHash(repr);
     }
 
     bool operator ==(const IconCacheKey &x) const
     {
         return name == x.name && overlays == x.overlays
             && size == x.size && mode == x.mode && state == x.state;
     }
 
     uint hash() const
     {
         return _hash;
     }
 
     QString name;
     QStringList overlays;
     QSize size;
     QIcon::Mode mode;
     QIcon::State state;
 
 private:
     uint _hash;
 };
 
 uint qHash(const IconCacheKey &key)
 {
     return key.hash();
 }
 
 QPixmap IconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
 {
     static QCache<IconCacheKey, QPixmap> cache(cacheSize);
     static QString cachedTheme;
 
     QString systemTheme = QIcon::themeName();
 
     // [WORKAROUND] If system theme is Breeze, pick light or dark variant of the theme explicitly
     // This type of selection works implicitly when QIcon::fromTheme is used,
     // however after QIcon::setThemeName it stops working for unknown reason.
     if (systemTheme == "breeze" || systemTheme == "breeze-dark") {
         const QString pickedSystemTheme(Icon::isLightWindowThemeActive() ? "breeze" : "breeze-dark");
         if (systemTheme != pickedSystemTheme) {
             qDebug() << "System icon theme variant changed:" << systemTheme << "->" << pickedSystemTheme;
             systemTheme = pickedSystemTheme;
             QIcon::setThemeName(systemTheme);
         }
     }
 
     // invalidate cache if system theme is changed
     if (cachedTheme != systemTheme) {
         if (!cachedTheme.isEmpty()) {
             qDebug() << "System icon theme changed:" << cachedTheme << "->" << systemTheme;
         }
 
         cache.clear();
         cachedTheme = systemTheme;
     }
 
     // an empty icon name is a special case - we don't apply any fallback
     if (_iconName.isEmpty()) {
         return QPixmap();
     }
 
     auto key = IconCacheKey(_iconName, _overlays, size, mode, state);
 
     // return cached icon when possible
     if (cache.contains(key)) {
         return *cache.object(key);
     }
 
     // search icon and extract pixmap
     auto pixmap = new QPixmap;
     auto searchResult = searchIcon(_iconName, _themeFallbackList);
     if (!searchResult.icon.isNull()) {
         *pixmap = searchResult.icon.pixmap(size, mode, state);
     }
     if (!searchResult.originalThemeName.isNull()) {
         QIcon::setThemeName(searchResult.originalThemeName);
     }
 
     // can't find the icon neither in system theme nor in fallback themes - load fallback icon
     if (pixmap->isNull()) {
         qWarning() << "Unable to find icon" << _iconName << "of size" << size << "in any configured theme";
         *pixmap = _fallbackIcon.pixmap(size, mode, state);
     }
 
     // apply overlays in a safe manner
     Icon::applyOverlays(pixmap, _overlays);
 
     // update the cache; the cache takes ownership over the pixmap
     cache.insert(key, pixmap);
 
     return *pixmap;
 }
 
 void IconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)
 {
     QSize pixmapSize = rect.size();
     QPixmap px = pixmap(pixmapSize, mode, state);
     painter->drawPixmap(rect, px);
 }
diff --git a/krusader/icon.h b/krusader/icon.h
index 58d32949..b66d9e71 100644
--- a/krusader/icon.h
+++ b/krusader/icon.h
@@ -1,55 +1,55 @@
 /*****************************************************************************
  * Copyright (C) 2018 Nikita Melnichenko <nikita+kde@melnichenko.name>       *
  * Copyright (C) 2018 Krusader Krew [https://krusader.org]                   *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef ICON_H
 #define ICON_H
 
 // QtGui
 #include <QIcon>
 #include <QIconEngine>
 
 /**
  * @class Icon
  *
  * Universal icon class for Krusader.
  *
  * There is a list of configured themes that Icon searches in.
  * The order of themes is the following: active theme, theme specified by user,
  * fallback themes that provide complete icon set for Krusader.
  * If icon is not found in any configured theme, the fallback icon is used.
  */
 class Icon : public QIcon
 {
 public:
     Icon();
     explicit Icon(QString name, QStringList overlays = QStringList());
     explicit Icon(QString name, QIcon fallbackIcon, QStringList overlays = QStringList());
 
     /// Check if icon exists in any configured theme
-    static bool exists(QString iconName);
+    static bool exists(const QString& iconName);
 
     /// Apply overlays to the pixmap with fallbacks to standard emblems
     static void applyOverlays(QPixmap *pixmap, QStringList overlays);
 
     /// Determine if light window theme is currently enabled
     static bool isLightWindowThemeActive();
 };
 
 #endif // ICON_H
diff --git a/krusader/kractions.cpp b/krusader/kractions.cpp
index e2802ad5..bc3d97be 100644
--- a/krusader/kractions.cpp
+++ b/krusader/kractions.cpp
@@ -1,325 +1,325 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kractions.h"
 
 // QtWidgets
 #include <QMenu>
 #include <QAction>
 
 #include <KI18n/KLocalizedString>
 #include <KXmlGui/KActionCollection>
 #include <KWidgetsAddons/KToggleAction>
 #include <KWidgetsAddons/KToolBarPopupAction>
 #include <KXmlGui/KToggleToolBarAction>
 #include <KXmlGui/KXMLGUIFactory>
 
 #include "defaults.h"
 #include "krusader.h"
 #include "icon.h"
 #include "krusaderview.h"
 #include "krslots.h"
 #include "krtrashhandler.h"
 #include "Dialogs/popularurls.h"
 #include "GUI/krremoteencodingmenu.h"
 #include "JobMan/jobman.h"
 #include "MountMan/kmountman.h"
 #include "Panel/PanelView/krviewfactory.h"
 #include "UserAction/useraction.h"
 
-QAction *KrActions::actCompare = 0;
-QAction *KrActions::actDiskUsage = 0;
-QAction *KrActions::actHomeTerminal = 0;
-QAction *KrActions::actRemoteEncoding = 0;
-QAction *KrActions::actProfiles = 0;
-QAction *KrActions::actMultiRename = 0;
-QAction *KrActions::actMountMan = 0;
-QAction *KrActions::actNewTool = 0;
-QAction *KrActions::actKonfigurator = 0;
-QAction *KrActions::actToolsSetup = 0;
-QAction *KrActions::actSwapPanels = 0;
-QAction *KrActions::actSwapSides = 0;
-QAction *KrActions::actFind = 0;
-QAction *KrActions::actLocate = 0;
-QAction *KrActions::actSwitchFullScreenTE = 0;
-QAction *KrActions::actAddBookmark = 0;
-QAction *KrActions::actSavePosition = 0;
-QAction *KrActions::actSelectColorMask = 0;
-QAction *KrActions::actOpenLeftBm = 0;
-QAction *KrActions::actOpenRightBm = 0;
-QAction *KrActions::actCmdlinePopup = 0;
-QAction *KrActions::actSplit = 0;
-QAction *KrActions::actCombine = 0;
-QAction *KrActions::actUserMenu = 0;
-QAction *KrActions::actManageUseractions = 0;
+QAction *KrActions::actCompare = nullptr;
+QAction *KrActions::actDiskUsage = nullptr;
+QAction *KrActions::actHomeTerminal = nullptr;
+QAction *KrActions::actRemoteEncoding = nullptr;
+QAction *KrActions::actProfiles = nullptr;
+QAction *KrActions::actMultiRename = nullptr;
+QAction *KrActions::actMountMan = nullptr;
+QAction *KrActions::actNewTool = nullptr;
+QAction *KrActions::actKonfigurator = nullptr;
+QAction *KrActions::actToolsSetup = nullptr;
+QAction *KrActions::actSwapPanels = nullptr;
+QAction *KrActions::actSwapSides = nullptr;
+QAction *KrActions::actFind = nullptr;
+QAction *KrActions::actLocate = nullptr;
+QAction *KrActions::actSwitchFullScreenTE = nullptr;
+QAction *KrActions::actAddBookmark = nullptr;
+QAction *KrActions::actSavePosition = nullptr;
+QAction *KrActions::actSelectColorMask = nullptr;
+QAction *KrActions::actOpenLeftBm = nullptr;
+QAction *KrActions::actOpenRightBm = nullptr;
+QAction *KrActions::actCmdlinePopup = nullptr;
+QAction *KrActions::actSplit = nullptr;
+QAction *KrActions::actCombine = nullptr;
+QAction *KrActions::actUserMenu = nullptr;
+QAction *KrActions::actManageUseractions = nullptr;
 #ifdef SYNCHRONIZER_ENABLED
-QAction *KrActions::actSyncDirs = 0;
+QAction *KrActions::actSyncDirs = nullptr;
 #endif
-QAction *KrActions::actF10Quit = 0;
-QAction *KrActions::actEmptyTrash = 0;
-QAction *KrActions::actTrashBin = 0;
-QAction *KrActions::actPopularUrls = 0;
-
-KToggleAction *KrActions::actToggleTerminal = 0;
-QAction  *KrActions::actVerticalMode = 0;
-QAction  *KrActions::actSelectNewerAndSingle = 0;
-QAction  *KrActions::actSelectSingle = 0;
-QAction  *KrActions::actSelectNewer = 0;
-QAction  *KrActions::actSelectDifferentAndSingle = 0;
-QAction  *KrActions::actSelectDifferent = 0;
+QAction *KrActions::actF10Quit = nullptr;
+QAction *KrActions::actEmptyTrash = nullptr;
+QAction *KrActions::actTrashBin = nullptr;
+QAction *KrActions::actPopularUrls = nullptr;
+
+KToggleAction *KrActions::actToggleTerminal = nullptr;
+QAction  *KrActions::actVerticalMode = nullptr;
+QAction  *KrActions::actSelectNewerAndSingle = nullptr;
+QAction  *KrActions::actSelectSingle = nullptr;
+QAction  *KrActions::actSelectNewer = nullptr;
+QAction  *KrActions::actSelectDifferentAndSingle = nullptr;
+QAction  *KrActions::actSelectDifferent = nullptr;
 QAction  **KrActions::compareArray[] = {&actSelectNewerAndSingle, &actSelectNewer, &actSelectSingle,
-                                       &actSelectDifferentAndSingle, &actSelectDifferent, 0
+                                       &actSelectDifferentAndSingle, &actSelectDifferent, nullptr
                                       };
-QAction *KrActions::actExecStartAndForget = 0;
-QAction *KrActions::actExecCollectSeparate = 0;
-QAction *KrActions::actExecCollectTogether = 0;
-QAction *KrActions::actExecTerminalExternal = 0;
-QAction *KrActions::actExecTerminalEmbedded = 0;
+QAction *KrActions::actExecStartAndForget = nullptr;
+QAction *KrActions::actExecCollectSeparate = nullptr;
+QAction *KrActions::actExecCollectTogether = nullptr;
+QAction *KrActions::actExecTerminalExternal = nullptr;
+QAction *KrActions::actExecTerminalEmbedded = nullptr;
 QAction **KrActions::execTypeArray[] = {&actExecStartAndForget, &actExecCollectSeparate, &actExecCollectTogether,
-                                       &actExecTerminalExternal, &actExecTerminalEmbedded, 0
+                                       &actExecTerminalExternal, &actExecTerminalEmbedded, nullptr
                                       };
-KToggleAction *KrActions::actToggleFnkeys = 0;
-KToggleAction *KrActions::actToggleCmdline = 0;
-KToggleAction *KrActions::actShowStatusBar = 0;
-KToggleAction *KrActions::actToggleHidden = 0;
-KToggleAction *KrActions::actCompareDirs = 0;
+KToggleAction *KrActions::actToggleFnkeys = nullptr;
+KToggleAction *KrActions::actToggleCmdline = nullptr;
+KToggleAction *KrActions::actShowStatusBar = nullptr;
+KToggleAction *KrActions::actToggleHidden = nullptr;
+KToggleAction *KrActions::actCompareDirs = nullptr;
 
-QAction *KrActions::actJobProgress = 0;
-QAction *KrActions::actJobControl = 0;
-QAction *KrActions::actJobMode = 0;
-QAction *KrActions::actJobUndo = 0;
+QAction *KrActions::actJobProgress = nullptr;
+QAction *KrActions::actJobControl = nullptr;
+QAction *KrActions::actJobMode = nullptr;
+QAction *KrActions::actJobUndo = nullptr;
 
 #ifdef __KJSEMBED__
     static QAction *actShowJSConsole;
 #endif
 
 
-QAction *createAction(QString text, QString iconName, QKeySequence shortcut,
-                      QObject *recv, const char *slot, QString name, Krusader *krusaderApp)
+QAction *createAction(const QString& text, const QString& iconName, const QKeySequence& shortcut,
+                      QObject *recv, const char *slot, const QString& name, Krusader *krusaderApp)
 {
     QAction *a;
     if (iconName.isEmpty())
         a = new QAction(text, krusaderApp);
     else
         a = new QAction(Icon(iconName), text, krusaderApp);
     krusaderApp->connect(a, SIGNAL(triggered(bool)), recv, slot);
     krusaderApp->actionCollection()->addAction(name, a);
     krusaderApp->actionCollection()->setDefaultShortcut(a, shortcut);
     return a;
 }
 
-QAction *createAction(QString text, QString iconName, QList<QKeySequence> shortcuts,
-                      QObject *recv, const char *slot, QString name, Krusader *krusaderApp)
+QAction *createAction(const QString& text, const QString& iconName, const QList<QKeySequence>& shortcuts,
+                      QObject *recv, const char *slot, const QString& name, Krusader *krusaderApp)
 {
     QAction *a;
     if (iconName.isEmpty())
         a = new QAction(text, krusaderApp);
     else
         a = new QAction(Icon(iconName), text, krusaderApp);
     krusaderApp->connect(a, SIGNAL(triggered(bool)), recv, slot);
     krusaderApp->actionCollection()->addAction(name, a);
     krusaderApp->actionCollection()->setDefaultShortcuts(a, shortcuts);
     return a;
 }
 
 
-KToggleAction *createToggleAction(QString text, QString iconName, QKeySequence shortcut,
-                                 QObject *recv, const char *slot, QString name, Krusader *krusaderApp)
+KToggleAction *createToggleAction(const QString& text, const QString& iconName, const QKeySequence& shortcut,
+                                 QObject *recv, const char *slot, const QString& name, Krusader *krusaderApp)
 {
     KToggleAction *a;
-    if (iconName == 0)
+    if (iconName == nullptr)
         a = new KToggleAction(text, krusaderApp);
     else
         a = new KToggleAction(Icon(iconName), text, krusaderApp);
     krusaderApp->connect(a, SIGNAL(triggered(bool)), recv, slot);
     krusaderApp->actionCollection()->addAction(name, a);
     krusaderApp->actionCollection()->setDefaultShortcut(a, shortcut);
     return a;
 }
 
 
 void KrActions::setupActions(Krusader *krusaderApp)
 {
 
 #define NEW_KACTION(VAR, TEXT, ICON_NAME, SHORTCUT, RECV_OBJ, SLOT_NAME, NAME) \
     VAR = createAction(TEXT, ICON_NAME, SHORTCUT, RECV_OBJ, SLOT_NAME, NAME, krusaderApp);
 
 #define NEW_KTOGGLEACTION(VAR, TEXT, ICON_NAME, SHORTCUT, RECV_OBJ, SLOT_NAME, NAME) \
     VAR = createToggleAction(TEXT, ICON_NAME, SHORTCUT, RECV_OBJ, SLOT_NAME, NAME, krusaderApp);
 
 
     // first come the TODO actions
     //actSync =       0;//new QAction(i18n("S&ynchronize Dirs"),                         0, krusaderApp, 0, actionCollection(), "sync dirs");
     //actNewTool =    0;//new QAction(i18n("&Add a new tool"),                          0, krusaderApp, 0, actionCollection(), "add tool");
     //actToolsSetup = 0;//new QAction(i18n("&Tools Menu Setup"),                        0, 0, krusaderApp, 0, actionCollection(), "tools setup");
     //KStandardAction::print(SLOTS, 0,actionCollection(),"std_print");
     //KStandardAction::showMenubar( SLOTS, SLOT(showMenubar()), actionCollection(), "std_menubar" );
 
     /* Shortcut disabled because of the Terminal Emulator bug. */
     KConfigGroup group(krConfig, "Private");
     int compareMode = group.readEntry("Compare Mode", 0);
     int cmdExecMode =  group.readEntry("Command Execution Mode", 0);
     QAction *tmp;
     Q_UNUSED(tmp);
 
-    NEW_KACTION(tmp, i18n("Tab-Switch panel"), 0, Qt::Key_Tab, MAIN_VIEW, SLOT(panelSwitch()), "tab");
+    NEW_KACTION(tmp, i18n("Tab-Switch panel"), nullptr, Qt::Key_Tab, MAIN_VIEW, SLOT(panelSwitch()), "tab");
 
     KToggleToolBarAction *actShowToolBar = new KToggleToolBarAction(krusaderApp->toolBar(), i18n("Show Main Toolbar"), krusaderApp);
     krusaderApp->actionCollection()->addAction(KStandardAction::name(KStandardAction::ShowToolbar), actShowToolBar);
 
     KToggleToolBarAction *actShowJobToolBar = new KToggleToolBarAction(krusaderApp->toolBar("jobToolBar"), i18n("Show Job Toolbar"), krusaderApp);
     krusaderApp->actionCollection()->addAction("toggle show jobbar", actShowJobToolBar);
 
     KToggleToolBarAction *actShowActionsToolBar = new KToggleToolBarAction(krusaderApp->toolBar("actionsToolBar"), i18n("Show Actions Toolbar"), krusaderApp);
     krusaderApp->actionCollection()->addAction("toggle actions toolbar", actShowActionsToolBar);
 
     actShowStatusBar = KStandardAction::showStatusbar(SLOTS, SLOT(updateStatusbarVisibility()), krusaderApp->actionCollection());
     KStandardAction::quit(krusaderApp, SLOT(quit()), krusaderApp->actionCollection());
     KStandardAction::configureToolbars(krusaderApp, SLOT(configureToolbars()), krusaderApp->actionCollection());
     KStandardAction::keyBindings(krusaderApp->guiFactory(), SLOT(configureShortcuts()), krusaderApp->actionCollection());
 
     // the toggle actions
-    NEW_KTOGGLEACTION(actToggleFnkeys, i18n("Show &FN Keys Bar"), 0, 0, SLOTS,  SLOT(toggleFnkeys()), "toggle fn bar");
+    NEW_KTOGGLEACTION(actToggleFnkeys, i18n("Show &FN Keys Bar"), nullptr, 0, SLOTS,  SLOT(toggleFnkeys()), "toggle fn bar");
 
-    NEW_KTOGGLEACTION(actToggleCmdline, i18n("Show &Command Line"), 0, 0, SLOTS, SLOT(toggleCmdline()), "toggle command line");
+    NEW_KTOGGLEACTION(actToggleCmdline, i18n("Show &Command Line"), nullptr, 0, SLOTS, SLOT(toggleCmdline()), "toggle command line");
 
-    NEW_KTOGGLEACTION(actToggleTerminal, i18n("Show &Embedded Terminal"), 0, Qt::ALT + Qt::CTRL + Qt::Key_T, SLOTS, SLOT(toggleTerminal()), "toggle terminal emulator");
+    NEW_KTOGGLEACTION(actToggleTerminal, i18n("Show &Embedded Terminal"), nullptr, Qt::ALT + Qt::CTRL + Qt::Key_T, SLOTS, SLOT(toggleTerminal()), "toggle terminal emulator");
 
 
-    NEW_KTOGGLEACTION(actToggleHidden, i18n("Show &Hidden Files"), 0, Qt::ALT + Qt::Key_Period, SLOTS, SLOT(showHiddenFiles(bool)), "toggle hidden files");
+    NEW_KTOGGLEACTION(actToggleHidden, i18n("Show &Hidden Files"), nullptr, Qt::ALT + Qt::Key_Period, SLOTS, SLOT(showHiddenFiles(bool)), "toggle hidden files");
 
-    NEW_KACTION(actSwapPanels, i18n("S&wap Panels"), 0, Qt::CTRL + Qt::Key_U, SLOTS, SLOT(swapPanels()), "swap panels");
+    NEW_KACTION(actSwapPanels, i18n("S&wap Panels"), nullptr, Qt::CTRL + Qt::Key_U, SLOTS, SLOT(swapPanels()), "swap panels");
 
     NEW_KACTION(actEmptyTrash, i18n("Empty Trash"), "trash-empty", 0, SLOTS, SLOT(emptyTrash()), "emptytrash");
 
     NEW_KACTION(actTrashBin, i18n("Trash Popup Menu"), KrTrashHandler::trashIconName(), 0, SLOTS, SLOT(trashPopupMenu()), "trashbin");
 
-    NEW_KACTION(actSwapSides, i18n("Sw&ap Sides"), 0, Qt::CTRL + Qt::SHIFT + Qt::Key_U, SLOTS, SLOT(toggleSwapSides()), "toggle swap sides");
+    NEW_KACTION(actSwapSides, i18n("Sw&ap Sides"), nullptr, Qt::CTRL + Qt::SHIFT + Qt::Key_U, SLOTS, SLOT(toggleSwapSides()), "toggle swap sides");
     actToggleHidden->setChecked(KConfigGroup(krConfig, "Look&Feel").readEntry("Show Hidden", _ShowHidden));
 
     // and then the DONE actions
-    NEW_KACTION(actCmdlinePopup, i18n("popup cmdline"), 0, Qt::CTRL + Qt::Key_Slash, SLOTS, SLOT(cmdlinePopup()), "cmdline popup");
+    NEW_KACTION(actCmdlinePopup, i18n("popup cmdline"), nullptr, Qt::CTRL + Qt::Key_Slash, SLOTS, SLOT(cmdlinePopup()), "cmdline popup");
 
 
     NEW_KACTION(tmp, i18n("Start &Root Mode Krusader"), "krusader_root", Qt::ALT + Qt::SHIFT + Qt::Key_K, SLOTS, SLOT(rootKrusader()), "root krusader");
     NEW_KACTION(actProfiles, i18n("Pro&files"), "user-identity", Qt::ALT + Qt::SHIFT + Qt::Key_L, MAIN_VIEW, SLOT(profiles()), "profile");
     NEW_KACTION(actSplit, i18n("Sp&lit File..."), "split", Qt::CTRL + Qt::Key_P, SLOTS, SLOT(slotSplit()), "split");
     NEW_KACTION(actCombine, i18n("Com&bine Files..."), "kr_combine", 0, SLOTS, SLOT(slotCombine()), "combine");
-    NEW_KACTION(actSelectNewerAndSingle, i18n("&Select Newer and Single"), 0, 0, SLOTS, SLOT(compareSetup()), "select_newer_and_single");
-    NEW_KACTION(actSelectNewer, i18n("Select &Newer"), 0, 0, SLOTS, SLOT(compareSetup()), "select_newer");
-    NEW_KACTION(actSelectSingle, i18n("Select &Single"), 0, 0, SLOTS, SLOT(compareSetup()), "select_single");
-    NEW_KACTION(actSelectDifferentAndSingle, i18n("Select Different &and Single"), 0, 0, SLOTS, SLOT(compareSetup()), "select_different_and_single");
-    NEW_KACTION(actSelectDifferent,  i18n("Select &Different"), 0, 0, SLOTS, SLOT(compareSetup()), "select_different");
+    NEW_KACTION(actSelectNewerAndSingle, i18n("&Select Newer and Single"), nullptr, 0, SLOTS, SLOT(compareSetup()), "select_newer_and_single");
+    NEW_KACTION(actSelectNewer, i18n("Select &Newer"), nullptr, 0, SLOTS, SLOT(compareSetup()), "select_newer");
+    NEW_KACTION(actSelectSingle, i18n("Select &Single"), nullptr, 0, SLOTS, SLOT(compareSetup()), "select_single");
+    NEW_KACTION(actSelectDifferentAndSingle, i18n("Select Different &and Single"), nullptr, 0, SLOTS, SLOT(compareSetup()), "select_different_and_single");
+    NEW_KACTION(actSelectDifferent,  i18n("Select &Different"), nullptr, 0, SLOTS, SLOT(compareSetup()), "select_different");
     actSelectNewerAndSingle->setCheckable(true);
     actSelectNewer->setCheckable(true);
     actSelectSingle->setCheckable(true);
     actSelectDifferentAndSingle->setCheckable(true);
     actSelectDifferent->setCheckable(true);
-    QActionGroup *selectGroup = new QActionGroup(krusaderApp);
+    auto *selectGroup = new QActionGroup(krusaderApp);
     selectGroup->setExclusive(true);
     selectGroup->addAction(actSelectNewerAndSingle);
     selectGroup->addAction(actSelectNewer);
     selectGroup->addAction(actSelectSingle);
     selectGroup->addAction(actSelectDifferentAndSingle);
     selectGroup->addAction(actSelectDifferent);
     if (compareMode < (int)(sizeof(compareArray) / sizeof(QAction **)) - 1)
         (*compareArray[ compareMode ])->setChecked(true);
-    NEW_KACTION(actExecStartAndForget, i18n("Start and &Forget"), 0, 0, SLOTS, SLOT(execTypeSetup()), "exec_start_and_forget");
-    NEW_KACTION(actExecCollectSeparate, i18n("Display &Separated Standard and Error Output"), 0, 0, SLOTS, SLOT(execTypeSetup()), "exec_collect_separate");
-    NEW_KACTION(actExecCollectTogether, i18n("Display &Mixed Standard and Error Output"), 0, 0, SLOTS, SLOT(execTypeSetup()), "exec_collect_together");
-    NEW_KACTION(actExecTerminalExternal, i18n("Start in &New Terminal"), 0, 0, SLOTS, SLOT(execTypeSetup()), "exec_terminal_external");
-    NEW_KACTION(actExecTerminalEmbedded, i18n("Send to &Embedded Terminal Emulator"), 0, 0, SLOTS, SLOT(execTypeSetup()), "exec_terminal_embedded");
+    NEW_KACTION(actExecStartAndForget, i18n("Start and &Forget"), nullptr, 0, SLOTS, SLOT(execTypeSetup()), "exec_start_and_forget");
+    NEW_KACTION(actExecCollectSeparate, i18n("Display &Separated Standard and Error Output"), nullptr, 0, SLOTS, SLOT(execTypeSetup()), "exec_collect_separate");
+    NEW_KACTION(actExecCollectTogether, i18n("Display &Mixed Standard and Error Output"), nullptr, 0, SLOTS, SLOT(execTypeSetup()), "exec_collect_together");
+    NEW_KACTION(actExecTerminalExternal, i18n("Start in &New Terminal"), nullptr, 0, SLOTS, SLOT(execTypeSetup()), "exec_terminal_external");
+    NEW_KACTION(actExecTerminalEmbedded, i18n("Send to &Embedded Terminal Emulator"), nullptr, 0, SLOTS, SLOT(execTypeSetup()), "exec_terminal_embedded");
     actExecStartAndForget->setCheckable(true);
     actExecCollectSeparate->setCheckable(true);
     actExecCollectTogether->setCheckable(true);
     actExecTerminalExternal->setCheckable(true);
     actExecTerminalEmbedded->setCheckable(true);
-    QActionGroup *actionGroup = new QActionGroup(krusaderApp);
+    auto *actionGroup = new QActionGroup(krusaderApp);
     actionGroup->setExclusive(true);
     actionGroup->addAction(actExecStartAndForget);
     actionGroup->addAction(actExecCollectSeparate);
     actionGroup->addAction(actExecCollectTogether);
     actionGroup->addAction(actExecTerminalExternal);
     actionGroup->addAction(actExecTerminalEmbedded);
     if (cmdExecMode < (int)(sizeof(execTypeArray) / sizeof(QAction **)) - 1)
         (*execTypeArray[ cmdExecMode ])->setChecked(true);
 
 
     NEW_KACTION(actHomeTerminal, i18n("Start &Terminal"), "utilities-terminal", 0, SLOTS, SLOT(homeTerminal()), "terminal@home");
 
     actMountMan = krMtMan.action();
     krusaderApp->actionCollection()->addAction("mountman", actMountMan);
     krusaderApp->actionCollection()->setDefaultShortcut(actMountMan, Qt::ALT + Qt::Key_Slash);
 
     NEW_KACTION(actFind, i18n("&Search..."), "system-search", Qt::CTRL + Qt::Key_S, SLOTS, SLOT(search()), "find");
     NEW_KACTION(actLocate, i18n("&Locate..."), "edit-find", Qt::SHIFT + Qt::CTRL + Qt::Key_L, SLOTS, SLOT(locate()), "locate");
 #ifdef SYNCHRONIZER_ENABLED
     NEW_KACTION(actSyncDirs, i18n("Synchronize Fol&ders..."), "folder-sync", Qt::CTRL + Qt::Key_Y, SLOTS, SLOT(slotSynchronizeDirs()), "sync dirs");
 #endif
     NEW_KACTION(actDiskUsage, i18n("D&isk Usage..."), "kr_diskusage", Qt::ALT + Qt::SHIFT + Qt::Key_S, SLOTS, SLOT(slotDiskUsage()), "disk usage");
     NEW_KACTION(actKonfigurator, i18n("Configure &Krusader..."), "configure", 0, SLOTS, SLOT(startKonfigurator()), "konfigurator");
-    NEW_KACTION(actSavePosition, i18n("Save &Position"), 0, 0, krusaderApp, SLOT(savePosition()), "save position");
+    NEW_KACTION(actSavePosition, i18n("Save &Position"), nullptr, 0, krusaderApp, SLOT(savePosition()), "save position");
     NEW_KACTION(actCompare, i18n("Compare b&y Content..."), "kr_comparedirs", 0, SLOTS, SLOT(compareContent()), "compare");
     NEW_KACTION(actMultiRename, i18n("Multi &Rename..."), "edit-rename", Qt::SHIFT + Qt::Key_F2, SLOTS, SLOT(multiRename()), "multirename");
 
     NEW_KACTION(actAddBookmark, i18n("Add Bookmark"), "bookmark-new", KStandardShortcut::addBookmark(), SLOTS, SLOT(addBookmark()), "add bookmark");
     NEW_KACTION(actVerticalMode, i18n("Vertical Mode"), "view-split-top-bottom", Qt::ALT + Qt::CTRL + Qt::Key_R, MAIN_VIEW, SLOT(toggleVerticalMode()), "toggle vertical mode");
     actUserMenu = new KActionMenu(i18n("User&actions"), krusaderApp);
     krusaderApp->actionCollection()->addAction("useractionmenu", actUserMenu);
-    NEW_KACTION(actManageUseractions, i18n("Manage User Actions..."), 0, 0, SLOTS, SLOT(manageUseractions()), "manage useractions");
+    NEW_KACTION(actManageUseractions, i18n("Manage User Actions..."), nullptr, 0, SLOTS, SLOT(manageUseractions()), "manage useractions");
 
     actRemoteEncoding = new KrRemoteEncodingMenu(i18n("Select Remote Charset"), "character-set", krusaderApp->actionCollection());
 
-    NEW_KACTION(actF10Quit, i18n("Quit"), 0, Qt::Key_F10, krusaderApp, SLOT(quit()) , "F10_Quit");
+    NEW_KACTION(actF10Quit, i18n("Quit"), nullptr, Qt::Key_F10, krusaderApp, SLOT(quit()) , "F10_Quit");
     actF10Quit->setToolTip(i18n("Quit Krusader."));
 
-    NEW_KACTION(actPopularUrls, i18n("Popular URLs..."), 0, Qt::CTRL + Qt::Key_Z, krusaderApp->popularUrls(), SLOT(showDialog()), "Popular_Urls");
-    NEW_KACTION(actSwitchFullScreenTE, i18n("Toggle Fullscreen Embedded Terminal"), 0,
+    NEW_KACTION(actPopularUrls, i18n("Popular URLs..."), nullptr, Qt::CTRL + Qt::Key_Z, krusaderApp->popularUrls(), SLOT(showDialog()), "Popular_Urls");
+    NEW_KACTION(actSwitchFullScreenTE, i18n("Toggle Fullscreen Embedded Terminal"), nullptr,
                 Qt::CTRL + Qt::ALT + Qt::Key_F, MAIN_VIEW, SLOT(toggleFullScreenTerminalEmulator()),
                 "switch_fullscreen_te");
 
-    NEW_KACTION(tmp, i18n("Move Focus Up"), 0, Qt::CTRL + Qt::SHIFT + Qt::Key_Up, MAIN_VIEW, SLOT(focusUp()), "move_focus_up");
-    NEW_KACTION(tmp, i18n("Move Focus Down"), 0, Qt::CTRL + Qt::SHIFT + Qt::Key_Down, MAIN_VIEW, SLOT(focusDown()), "move_focus_down");
+    NEW_KACTION(tmp, i18n("Move Focus Up"), nullptr, Qt::CTRL + Qt::SHIFT + Qt::Key_Up, MAIN_VIEW, SLOT(focusUp()), "move_focus_up");
+    NEW_KACTION(tmp, i18n("Move Focus Down"), nullptr, Qt::CTRL + Qt::SHIFT + Qt::Key_Down, MAIN_VIEW, SLOT(focusDown()), "move_focus_down");
 
     // job manager actions
     actJobControl = krJobMan->controlAction();
     krusaderApp->actionCollection()->addAction("job control", actJobControl);
     krusaderApp->actionCollection()->setDefaultShortcut(actJobControl, Qt::CTRL + Qt::ALT + Qt::Key_P);
     actJobProgress = krJobMan->progressAction();
     krusaderApp->actionCollection()->addAction("job progress", actJobProgress);
     actJobMode = krJobMan->modeAction();
     krusaderApp->actionCollection()->addAction("job mode", actJobMode);
     actJobUndo = krJobMan->undoAction();
     krusaderApp->actionCollection()->addAction("job undo", actJobUndo);
     krusaderApp->actionCollection()->setDefaultShortcut(actJobUndo, Qt::CTRL + Qt::ALT + Qt::Key_Z);
 
     // and at last we can set the tool-tips
     actKonfigurator->setToolTip(i18n("Setup Krusader the way you like it"));
     actFind->setToolTip(i18n("Search for files"));
 
     // setup all UserActions
     krUserAction = new UserAction();
 
 #ifdef __KJSEMBED__
     actShowJSConsole = new QAction(i18n("JavaScript Console..."), Qt::ALT + Qt::CTRL + Qt::Key_J, SLOTS, SLOT(jsConsole()), krusaderApp->actionCollection(), "JS_Console");
 #endif
 
 }
diff --git a/krusader/krglobal.cpp b/krusader/krglobal.cpp
index 6b49fbbf..85991219 100644
--- a/krusader/krglobal.cpp
+++ b/krusader/krglobal.cpp
@@ -1,62 +1,62 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krglobal.h"
 
 #include "krusader.h"
 #include "krusaderview.h"
 
 // QtCore
 #include <QtGlobal>
 
 #include <KXmlGui/KActionCollection>
 
-KConfig *KrGlobal::config = 0;
-KMountMan *KrGlobal::mountMan = 0;
-KrBookmarkHandler *KrGlobal::bookman = 0;
-KRslots* KrGlobal::slot = 0;
-KrusaderView *KrGlobal::mainView = 0;
-QWidget *KrGlobal::mainWindow = 0;
-UserAction *KrGlobal::userAction = 0;
-JobMan *KrGlobal::jobMan = 0;
+KConfig *KrGlobal::config = nullptr;
+KMountMan *KrGlobal::mountMan = nullptr;
+KrBookmarkHandler *KrGlobal::bookman = nullptr;
+KRslots* KrGlobal::slot = nullptr;
+KrusaderView *KrGlobal::mainView = nullptr;
+QWidget *KrGlobal::mainWindow = nullptr;
+UserAction *KrGlobal::userAction = nullptr;
+JobMan *KrGlobal::jobMan = nullptr;
 // ListPanel *KrGlobal::activePanel = 0;
 QKeySequence KrGlobal::copyShortcut;
 
 const int KrGlobal::sConfigVersion;
 int KrGlobal::sCurrentConfigVersion;
 
 KrPanel *KrGlobal::activePanel()
 {
     return mainView->activePanel();
 }
 
 // void KrGlobal::enableAction(const char *name, bool enable)
 // {
 //     getAction(name)->setEnabled(enable);
 // }
 // 
 // QAction* KrGlobal::getAction(const char *name)
 // {
 //     QAction *act = krApp->actionCollection()->action(name);
 //     if(!act)
 //         qFatal("no such action: %s", name);
 //     return act;
 // }
diff --git a/krusader/krservices.cpp b/krusader/krservices.cpp
index 94bff9df..81ea9eea 100644
--- a/krusader/krservices.cpp
+++ b/krusader/krservices.cpp
@@ -1,319 +1,320 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krservices.h"
 
 // QtCore
 #include <QDir>
 #include <QSet>
 #include <QTextStream>
 #include <QtGlobal>
 
 #include <KConfigCore/KSharedConfig>
 #include <KIOCore/KProtocolManager>
+#include <utility>
 
 #include "krglobal.h"
 #include "defaults.h"
 
-QMap<QString, QString>* KrServices::slaveMap = 0;
+QMap<QString, QString>* KrServices::slaveMap = nullptr;
 QSet<QString> KrServices::krarcArchiveMimetypes = KrServices::generateKrarcArchiveMimetypes();
 #ifdef KRARC_QUERY_ENABLED
 QSet<QString> KrServices::isoArchiveMimetypes = QSet<QString>::fromList(KProtocolInfo::archiveMimetypes("iso"));
 #else
 QSet<QString> KrServices::isoArchiveMimetypes;
 #endif
 
 QString KrServices::GLOBAL_MESSAGE_PATTERN = "%{time hh:mm:ss.zzz}-%{type} %{category} %{function}@%{line} # %{message}";
 
 QSet<QString> KrServices::generateKrarcArchiveMimetypes()
 {
     // Hard-code these proven mimetypes openable by krarc protocol.
     // They cannot be listed in krarc.protocol itself
     // because it would baffle other file managers (like Dolphin).
     QSet<QString> mimes;
     mimes += QString("application/x-deb");
     mimes += QString("application/x-debian-package");
     mimes += QString("application/vnd.debian.binary-package");
     mimes += QString("application/x-java-archive");
     mimes += QString("application/x-rpm");
     mimes += QString("application/x-source-rpm");
     mimes += QString("application/vnd.oasis.opendocument.chart");
     mimes += QString("application/vnd.oasis.opendocument.database");
     mimes += QString("application/vnd.oasis.opendocument.formula");
     mimes += QString("application/vnd.oasis.opendocument.graphics");
     mimes += QString("application/vnd.oasis.opendocument.presentation");
     mimes += QString("application/vnd.oasis.opendocument.spreadsheet");
     mimes += QString("application/vnd.oasis.opendocument.text");
     mimes += QString("application/vnd.openxmlformats-officedocument.presentationml.presentation");
     mimes += QString("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
     mimes += QString("application/vnd.openxmlformats-officedocument.wordprocessingml.document");
     mimes += QString("application/x-cbz");
     mimes += QString("application/x-cbr");
     mimes += QString("application/epub+zip");
     mimes += QString("application/x-webarchive");
     mimes += QString("application/x-plasma");
     mimes += QString("application/vnd.rar");
 
     #ifdef KRARC_QUERY_ENABLED
     mimes += QSet<QString>::fromList(KProtocolInfo::archiveMimetypes("krarc"));
     #endif
 
     return mimes;
 }
 
-bool KrServices::cmdExist(QString cmdName)
+bool KrServices::cmdExist(const QString& cmdName)
 {
     KConfigGroup group(krConfig, "Dependencies");
     if (QFile(group.readEntry(cmdName, QString())).exists())
         return true;
 
     return !QStandardPaths::findExecutable(cmdName).isEmpty();
 }
 
-QString KrServices::fullPathName(QString name, QString confName)
+QString KrServices::fullPathName(const QString& name, QString confName)
 {
     QString supposedName;
 
     if (confName.isNull())
         confName = name;
 
     KConfigGroup config(krConfig, "Dependencies");
     if (QFile(supposedName = config.readEntry(confName, QString())).exists())
         return supposedName;
 
     if ((supposedName = QStandardPaths::findExecutable(name)).isEmpty())
         return "";
 
     config.writeEntry(confName, supposedName);
     return supposedName;
 }
 
-QString KrServices::chooseFullPathName(QStringList names, QString confName)
+QString KrServices::chooseFullPathName(QStringList names, const QString& confName)
 {
     foreach(const QString &name, names) {
         QString foundTool = KrServices::fullPathName(name, confName);
         if (! foundTool.isEmpty()) {
             return foundTool;
         }
     }
 
     return "";
 }
 
 bool KrServices::isExecutable(const QString &path)
 {
     QFileInfo info(path);
     return info.isFile() && info.isExecutable();
 }
 
-QString KrServices::registeredProtocol(QString mimetype)
+QString KrServices::registeredProtocol(const QString& mimetype)
 {
-    if (slaveMap == 0) {
+    if (slaveMap == nullptr) {
         slaveMap = new QMap<QString, QString>();
 
         KConfigGroup group(krConfig, "Protocols");
         QStringList protList = group.readEntry("Handled Protocols", QStringList());
-        for (QStringList::Iterator it = protList.begin(); it != protList.end(); ++it) {
-            QStringList mimes = group.readEntry(QString("Mimes For %1").arg(*it), QStringList());
-            for (QStringList::Iterator it2 = mimes.begin(); it2 != mimes.end(); ++it2)
-                (*slaveMap)[*it2] = *it;
+        for (auto & it : protList) {
+            QStringList mimes = group.readEntry(QString("Mimes For %1").arg(it), QStringList());
+            for (auto & mime : mimes)
+                (*slaveMap)[mime] = it;
         }
     }
     QString protocol = (*slaveMap)[mimetype];
     if (protocol.isEmpty()) {
         if (krarcArchiveMimetypes.contains(mimetype)) {
             return "krarc";
         }
         protocol = KProtocolManager::protocolForArchiveMimetype(mimetype);
     }
     return protocol;
 }
 
-bool KrServices::isoSupported(QString mimetype)
+bool KrServices::isoSupported(const QString& mimetype)
 {
     return isoArchiveMimetypes.contains(mimetype);
 }
 
 void KrServices::clearProtocolCache()
 {
     if (slaveMap)
         delete slaveMap;
-    slaveMap = 0;
+    slaveMap = nullptr;
 }
 
 bool KrServices::fileToStringList(QTextStream *stream, QStringList& target, bool keepEmptyLines)
 {
     if (!stream) return false;
     QString line;
     while (!stream->atEnd()) {
         line = stream->readLine().trimmed();
         if (keepEmptyLines || !line.isEmpty()) target.append(line);
     }
     return true;
 }
 
 bool KrServices::fileToStringList(QFile *file, QStringList& target, bool keepEmptyLines)
 {
     QTextStream stream(file);
     return fileToStringList(&stream, target, keepEmptyLines);
 }
 
-QString KrServices::quote(QString name)
+QString KrServices::quote(const QString& name)
 {
     if (!name.contains('\''))
         return '\'' + name + '\'';
     if (!name.contains('"') && !name.contains('$'))
         return '\"' + name + '\"';
     return escape(name);
 }
 
 QStringList KrServices::quote(const QStringList& names)
 {
     QStringList result;
     for (int i = 0; i < names.size(); ++i)
         result.append(quote(names[i]));
     return result;
 }
 
 QList<QUrl> KrServices::toUrlList(const QStringList &list)
 {
     QList<QUrl> result;
     for (QStringList::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it) {
         result.append(QUrl::fromUserInput(*it, QDir::currentPath(), QUrl::AssumeLocalFile));
     }
     return result;
 }
 
 QStringList KrServices::toStringList(const QList<QUrl> &list)
 {
     QStringList result;
     for(QList<QUrl>::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it) {
         result.append(it->toString());
     }
     return result;
 }
 
 // Adds one tool to the list in the supportedTools method
-void supportedTool(QStringList &tools, QString toolType,
+void supportedTool(QStringList &tools, const QString& toolType,
                    QStringList names, QString confName) {
-    QString foundTool = KrServices::chooseFullPathName(names, confName);
+    QString foundTool = KrServices::chooseFullPathName(std::move(names), std::move(confName));
     if (! foundTool.isEmpty()) {
         tools.append(toolType);
         tools.append(foundTool);
     }
 }
 
 // return a list in the format of TOOLS,PATH. for example
 // DIFF,kdiff,TERMINAL,konsole,...
 //
 // currently supported tools: DIFF, MAIL, RENAME
 //
 // to use it: QStringList lst = supportedTools();
 //            int i = lst.indexOf("DIFF");
 //            if (i!=-1) pathToDiff=lst[i+1];
 QStringList KrServices::supportedTools() {
     QStringList tools;
 
     // first, a diff program: kdiff
     supportedTool(tools, "DIFF",
                   QStringList() << "kdiff3" << "kompare" << "xxdiff",
                   "diff utility");
 
     // a mailer: kmail or thunderbird
     supportedTool(tools, "MAIL",
                   QStringList() << "thunderbird" << "kmail",
                   "mailer");
 
     // rename tool: krename
     supportedTool(tools, "RENAME",
                   QStringList() << "krename",
                   "krename");
 
     // checksum utility
     supportedTool(tools, "MD5",
                   QStringList() << "md5sum",
                   "checksum utility");
 
     return tools;
 }
 
 
 QString KrServices::escape(QString name)
 {
     const QString evilstuff = "\\\"'`()[]{}!?;$&<>| \t\r\n";  // stuff that should get escaped
 
-    for (int i = 0; i < evilstuff.length(); ++i)
-        name.replace(evilstuff[ i ], ('\\' + evilstuff[ i ]));
+    for (auto i : evilstuff)
+        name.replace(i, ('\\' + i));
 
     return name;
 }
 
 QString KrServices::escapeFileUrl(QString urlString)
 {
     // Avoid that if a path contains a '#' then what follows the '#' be interpreted as the fragment identifier of
     // the URL and not a part of the file path; for more information https://bugs.kde.org/show_bug.cgi?id=270150 can be seen
     return urlString.replace('#', "%23").replace('?', "%3F");
 }
 
 QUrl KrServices::escapeFileUrl(const QUrl &url)
 {
     return QUrl(KrServices::escapeFileUrl(url.toString()));
 }
 
 QString KrServices::urlToLocalPath(const QUrl &url)
 {
     QUrl fileUrl = QUrl(url);
     // QUrl::toLocalFile() does not work if the protocol is "file" e.g. when opening an archive
     fileUrl.setScheme("file");
     QString path = fileUrl.toLocalFile();
     REPLACE_DIR_SEP2(path);
 
 #ifdef Q_WS_WIN
     if (path.startsWith(DIR_SEPARATOR)) {
         int p = 1;
         while (p < path.length() && path[ p ] == DIR_SEPARATOR_CHAR)
             p++;
         /* /C:/Folder */
         if (p + 2 <= path.length() && path[ p ].isLetter() && path[ p + 1 ] == ':') {
             path = path.mid(p);
         }
     }
 #endif
     return path;
 }
 
 static bool s_withDebugMessages;
 static QtMessageHandler s_defaultMessageHandler;
 
 void KrServices::setGlobalKrMessageHandler(bool withDebugMessages)
 {
     s_withDebugMessages = withDebugMessages;
-    s_defaultMessageHandler = qInstallMessageHandler(0);
+    s_defaultMessageHandler = qInstallMessageHandler(nullptr);
     qInstallMessageHandler(&krMessageHandler);
 }
 
 void KrServices::krMessageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 {
     // filter debug if not enabled
     if (type != QtDebugMsg || s_withDebugMessages) {
         s_defaultMessageHandler(type, context, msg);
     }
 }
diff --git a/krusader/krservices.h b/krusader/krservices.h
index 6ee5d21e..fb5b3b68 100644
--- a/krusader/krservices.h
+++ b/krusader/krservices.h
@@ -1,79 +1,79 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRSERVICES_H
 #define KRSERVICES_H
 
 // QtCore
 #include <QString>
 #include <QStringList>
 #include <QMap>
 #include <QUrl>
 
 class QTextStream;
 class QFile;
 
 /**
  * Global static utility functions.
  */
 class KrServices
 {
 public:
-    static bool         cmdExist(QString cmdName);
-    static QString      chooseFullPathName(QStringList names, QString confName);
-    static QString      fullPathName(QString name, QString confName = QString());
+    static bool         cmdExist(const QString& cmdName);
+    static QString      chooseFullPathName(QStringList names, const QString& confName);
+    static QString      fullPathName(const QString& name, QString confName = QString());
     static bool         isExecutable(const QString &path);
-    static QString      registeredProtocol(QString mimetype);
-    static bool         isoSupported(QString mimetype);
+    static QString      registeredProtocol(const QString& mimetype);
+    static bool         isoSupported(const QString& mimetype);
     static QString      urlToLocalPath(const QUrl &url);
     static void         clearProtocolCache();
     static bool         fileToStringList(QTextStream *stream, QStringList& target, bool keepEmptyLines = false);
     static bool         fileToStringList(QFile *file, QStringList& target, bool keepEmptyLines = false);
-    static QString      quote(QString name);
+    static QString      quote(const QString& name);
     static QStringList  quote(const QStringList& names);
     static QList<QUrl>  toUrlList(const QStringList &list);
     static QStringList  toStringList(const QList<QUrl> &list);
     static QStringList  supportedTools(); // find supported tools
     static QString      escapeFileUrl(QString urlString);
     static QUrl         escapeFileUrl(const QUrl &url);
     /**
      * Sets the global logging message handler for qDebug(), qWarning()... messages to a custom one
      * with the ability to filter debug messages.
      */
     static void setGlobalKrMessageHandler(bool withDebugMessages);
     static QString GLOBAL_MESSAGE_PATTERN;
 
 protected:
     static QString    escape(QString name);
 
 private:
     KrServices() {}
     ~KrServices() {}
     static QSet<QString> generateKrarcArchiveMimetypes();
     static QMap<QString, QString>* slaveMap;
     static QSet<QString> krarcArchiveMimetypes;
     static QSet<QString> isoArchiveMimetypes;
     static void krMessageHandler(QtMsgType type, const QMessageLogContext &context, const QString &msg);
 };
 
 // TODO: make KrServices a namespace and move it there
 
 #endif
diff --git a/krusader/krslots.cpp b/krusader/krslots.cpp
index 3d450217..ecadf3d4 100644
--- a/krusader/krslots.cpp
+++ b/krusader/krslots.cpp
@@ -1,747 +1,748 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krslots.h"
 
 // QtCore
 #include <QDir>
 #include <QPoint>
 #include <QStringList>
 #include <QList>
 #include <QEvent>
 #include <QTemporaryFile>
 // QtGui
 #include <QPixmapCache>
 #include <QKeyEvent>
 // QtWidgets
 #include <QApplication>
 
 #include <KConfigCore/KSharedConfig>
 #include <KCoreAddons/KShell>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KToggleAction>
 #include <KWidgetsAddons/KMessageBox>
+#include <utility>
 
 #ifdef __KJSEMBED__
 #include <kjsembed/jsconsolewidget.h>
 #include "KrJS/krjs.h"
 #endif
 
 #include "defaults.h"
 #include "icon.h"
 #include "kractions.h"
 #include "krservices.h"
 #include "krtrashhandler.h"
 #include "krusader.h"
 #include "krusaderview.h"
 #include "panelmanager.h"
 
 #include "ActionMan/actionman.h"
 #include "BookMan/krbookmarkbutton.h"
 #include "BookMan/krbookmarkhandler.h"
 #include "Dialogs/krdialogs.h"
 #include "Dialogs/krspecialwidgets.h"
 #include "Dialogs/krspwidgets.h"
 #include "DiskUsage/diskusagegui.h"
 #include "FileSystem/fileitem.h"
 #include "FileSystem/filesystem.h"
 #include "FileSystem/krquery.h"
 #include "GUI/dirhistorybutton.h"
 #include "GUI/kcmdline.h"
 #include "GUI/kfnkeys.h"
 #include "GUI/krusaderstatus.h"
 #include "GUI/mediabutton.h"
 #include "GUI/terminaldock.h"
 #include "KViewer/krviewer.h"
 #include "Konfigurator/konfigurator.h"
 #include "Locate/locate.h"
 #include "MountMan/kmountman.h"
 #include "Panel/PanelView/krselectionmode.h"
 #include "Panel/PanelView/krview.h"
 #include "Panel/PanelView/krviewfactory.h"
 #include "Panel/PanelView/krviewitem.h"
 #include "Panel/listpanel.h"
 #include "Panel/panelfunc.h"
 #include "Panel/sidebar.h"
 #include "Search/krsearchdialog.h"
 #include "Search/krsearchmod.h"
 #include "Splitter/combiner.h"
 #include "Splitter/splitter.h"
 #include "Splitter/splittergui.h"
 
 #ifdef SYNCHRONIZER_ENABLED
     #include "Synchronizer/synchronizergui.h"
 #endif
 
 
 #define ACTIVE_VIEW _mainWindow->activeView()
 
 
 KRslots::KRslots(QObject *parent) : QObject(parent), _mainWindow(krApp)
 {
 }
 
 void KRslots::sendFileByEmail(const QList<QUrl> &urls)
 {
     if (urls.count() == 0) {
-        KMessageBox::error(0, i18n("No selected files to send."));
+        KMessageBox::error(nullptr, i18n("No selected files to send."));
         return;
     }
 
     QString mailProg;
     QStringList lst = KrServices::supportedTools();
     if (lst.contains("MAIL")) mailProg = lst[lst.indexOf("MAIL") + 1];
     else {
-        KMessageBox::error(0, i18n("Krusader cannot find a supported mail client. Please install one to your path. Hint: Krusader supports KMail."));
+        KMessageBox::error(nullptr, i18n("Krusader cannot find a supported mail client. Please install one to your path. Hint: Krusader supports KMail."));
         return;
     }
 
     QString subject, separator;
     foreach(const QUrl &url, urls) {
         subject += separator + url.fileName();
         separator = ',';
     }
     subject = i18np("Sending file: %2", "Sending files: %2", urls.count(), subject);
 
     KProcess proc;
 
     QString executable = QUrl::fromLocalFile(mailProg).fileName();
     if (executable == QStringLiteral("kmail")) {
         proc << mailProg << "--subject"
         << subject;
         foreach(const QUrl &url2, urls)
         proc << "--attach" << url2.toDisplayString();
     } else if (executable == QStringLiteral("thunderbird")) {
         QString param = "attachment=\'";
         separator = "";
         foreach(const QUrl &url2, urls) {
             param += separator + url2.toDisplayString();
             separator = ',';
         }
         param += "\',subject=\'" + subject + "\'";
         proc << mailProg << "--compose" << param;
     } else if (executable == QStringLiteral("evolution")) {
         QString param = "mailto:?cc=&subject=" + subject + "&attach=";
         separator = "";
         foreach(const QUrl &url2, urls) {
             param += separator + url2.toDisplayString();
             separator = "&attach=";
         }
         proc << mailProg << param + "";
     }
 
     if (!proc.startDetached())
-        KMessageBox::error(0, i18n("Error executing %1.", mailProg));
+        KMessageBox::error(nullptr, i18n("Error executing %1.", mailProg));
 }
 
 void KRslots::compareContent()
 {
     const QStringList lstLeft = LEFT_PANEL->getSelectedNames();
     const QStringList lstRight = RIGHT_PANEL->getSelectedNames();
     const QStringList lstActive = ACTIVE_PANEL->gui->isLeft() ? lstLeft : lstRight;
     QUrl name1, name2;
 
     if (lstLeft.count() == 1 && lstRight.count() == 1) {
         // first, see if we've got exactly 1 selected file in each panel:
         name1 = LEFT_PANEL->func->files()->getUrl(lstLeft[0]);
         name2 = RIGHT_PANEL->func->files()->getUrl(lstRight[0]);
     } else if (lstActive.count() == 2) {
         // next try: are in the current panel exactly 2 files selected?
         name1 = ACTIVE_PANEL->func->files()->getUrl(lstActive[0]);
         name2 = ACTIVE_PANEL->func->files()->getUrl(lstActive[1]);
     } else if (ACTIVE_PANEL->otherPanel()->func->files()->getFileItem(ACTIVE_VIEW->getCurrentItem())) {
         // next try: is in the other panel a file with the same name?
         name1 = ACTIVE_PANEL->func->files()->getUrl(ACTIVE_VIEW->getCurrentItem());
         name2 = ACTIVE_PANEL->otherPanel()->func->files()->getUrl(ACTIVE_VIEW->getCurrentItem());
     } else  {
         // if we got here, then we can't be sure what file to diff
-        KMessageBox::sorry(0, "<qt>" + i18n("Do not know which files to compare.") + "<br/><br/>" + i18n("To compare two files by content, you can either:<ul><li>Select one file in the left panel, and one in the right panel.</li><li>Select exactly two files in the active panel.</li><li>Make sure there is a file in the other panel, with the same name as the current file in the active panel.</li></ul>") + "</qt>");
+        KMessageBox::sorry(nullptr, "<qt>" + i18n("Do not know which files to compare.") + "<br/><br/>" + i18n("To compare two files by content, you can either:<ul><li>Select one file in the left panel, and one in the right panel.</li><li>Select exactly two files in the active panel.</li><li>Make sure there is a file in the other panel, with the same name as the current file in the active panel.</li></ul>") + "</qt>");
 
         return;
     }
 
     // else implied: all ok, let's call an external program to compare files
     // but if any of the files isn't local, download it first
     compareContent(name1, name2);
 }
 
 bool downloadToTemp(const QUrl &url, QString &dest) {
     QTemporaryFile tmpFile;
     tmpFile.setAutoRemove(false);
     if (tmpFile.open()) {
         dest = tmpFile.fileName();
         KIO::Job* job = KIO::file_copy(url, QUrl::fromLocalFile(dest), -1,
                                        KIO::Overwrite | KIO::HideProgressInfo);
         if(!job->exec()) {
             KMessageBox::error(krApp, i18n("Krusader is unable to download %1", url.fileName()));
             return false;
         }
         return true;
     }
     return false;
 }
 
-void KRslots::compareContent(QUrl url1, QUrl url2)
+void KRslots::compareContent(const QUrl& url1, const QUrl& url2)
 {
     QString diffProg;
     QStringList lst = KrServices::supportedTools();
     if (lst.contains("DIFF")) diffProg = lst[lst.indexOf("DIFF") + 1];
     else {
-        KMessageBox::error(0, i18n("Krusader cannot find any of the supported diff-frontends. Please install one to your path. Hint: Krusader supports Kompare, KDiff3 and Xxdiff."));
+        KMessageBox::error(nullptr, i18n("Krusader cannot find any of the supported diff-frontends. Please install one to your path. Hint: Krusader supports Kompare, KDiff3 and Xxdiff."));
         return;
     }
 
     QString tmp1;
     QString tmp2;
 
     // kdiff3 sucks with spaces
     if (QUrl::fromLocalFile(diffProg).fileName() == "kdiff3" && !url1.toDisplayString().contains(" ") && !url2.toDisplayString().contains(" ")) {
         tmp1 = url1.toDisplayString();
         tmp2 = url2.toDisplayString();
     } else {
         if (!url1.isLocalFile()) {
             if (!downloadToTemp(url1, tmp1)) {
                 return;
             }
         } else tmp1 = url1.path();
         if (!url2.isLocalFile()) {
             if (!downloadToTemp(url2, tmp2)) {
                 if (tmp1 != url1.path())
                     QFile::remove(tmp1);
                 return;
             }
         } else tmp2 = url2.path();
     }
 
     KrProcess *p = new KrProcess(tmp1 != url1.path() ? tmp1 : QString(),
                                  tmp2 != url2.path() ? tmp2 : QString());
     *p << diffProg << tmp1 << tmp2;
     p->start();
     if (!p->waitForStarted())
-        KMessageBox::error(0, i18n("Error executing %1.", diffProg));
+        KMessageBox::error(nullptr, i18n("Error executing %1.", diffProg));
 }
 
 // GUI toggle slots
 void KRslots::toggleFnkeys()
 {
     if (MAIN_VIEW->fnKeys()->isVisible())
         MAIN_VIEW->fnKeys()->hide();
     else MAIN_VIEW->fnKeys()->show();
 }
 
 void KRslots::toggleCmdline()
 {
     if (MAIN_VIEW->cmdLine()->isVisible()) MAIN_VIEW->cmdLine()->hide();
     else MAIN_VIEW->cmdLine()->show();
 }
 
 void KRslots::updateStatusbarVisibility()
 {
     krApp->statusBar()->setVisible(KrActions::actShowStatusBar->isChecked());
 }
 
 void KRslots::toggleTerminal()
 {
     MAIN_VIEW->setTerminalEmulator(KrActions::actToggleTerminal->isChecked());
 }
 
 void KRslots::insertFileName(bool fullPath)
 {
     QString filename = ACTIVE_VIEW->getCurrentItem();
     if (filename.isEmpty()) {
         return;
     }
 
     if (fullPath) {
         const QString path = FileSystem::ensureTrailingSlash(ACTIVE_PANEL->virtualPath())
                                  .toDisplayString(QUrl::PreferLocalFile);
         filename = path + filename;
     }
 
     filename = KrServices::quote(filename);
 
     if (MAIN_VIEW->cmdLine()->isVisible() || !MAIN_VIEW->terminalDock()->isTerminalVisible()) {
         QString current = MAIN_VIEW->cmdLine()->text();
         if (current.length() != 0 && !current.endsWith(' '))
             current += ' ';
         MAIN_VIEW->cmdLine()->setText(current + filename);
         MAIN_VIEW->cmdLine()->setFocus();
     } else if (MAIN_VIEW->terminalDock()->isTerminalVisible()) {
         filename = ' ' + filename + ' ';
         MAIN_VIEW->terminalDock()->sendInput(filename, false);
         MAIN_VIEW->terminalDock()->setFocus();
     }
 }
 
 void KRslots::refresh(const QUrl &u)
 {
     ACTIVE_FUNC->openUrl(u);
 }
 
 void KRslots::runKonfigurator(bool firstTime)
 {
-    Konfigurator *konfigurator = new Konfigurator(firstTime);
+    auto *konfigurator = new Konfigurator(firstTime);
     connect(konfigurator, &Konfigurator::configChanged, this, &KRslots::configChanged);
 
     //FIXME - no need to exec
     konfigurator->exec();
 
     delete konfigurator;
 }
 
 void KRslots::configChanged(bool isGUIRestartNeeded)
 {
     krConfig->sync();
 
     if (isGUIRestartNeeded) {
         krApp->setUpdatesEnabled(false);
         KConfigGroup group(krConfig, "Look&Feel");
         FileItem::loadUserDefinedFolderIcons(group.readEntry("Load User Defined Folder Icons", _UserDefinedFolderIcons));
 
         bool leftActive = ACTIVE_PANEL->gui->isLeft();
         MAIN_VIEW->leftManager()->slotRecreatePanels();
         MAIN_VIEW->rightManager()->slotRecreatePanels();
         if(leftActive)
             LEFT_PANEL->slotFocusOnMe();
         else
             RIGHT_PANEL->slotFocusOnMe();
         MAIN_VIEW->fnKeys()->updateShortcuts();
         KrSelectionMode::resetSelectionHandler();
         krApp->setUpdatesEnabled(true);
     }
 
     krApp->setTray();
 
     // really ugly, but reload the Fn keys just in case - csaba: any better idea?
     MAIN_VIEW->fnKeys()->updateShortcuts();
 
     const bool showHidden = KConfigGroup(krConfig, "Look&Feel")
                                 .readEntry("Show Hidden", KrActions::actToggleHidden->isChecked());
 
     if (showHidden != KrActions::actToggleHidden->isChecked()) {
         KrActions::actToggleHidden->setChecked(showHidden);
         MAIN_VIEW->leftManager()->reloadConfig();
         MAIN_VIEW->rightManager()->reloadConfig();
     }
 }
 
 void KRslots::showHiddenFiles(bool show)
 {
     KConfigGroup group(krConfig, "Look&Feel");
     group.writeEntry("Show Hidden", show);
 
     MAIN_VIEW->leftManager()->reloadConfig();
     MAIN_VIEW->rightManager()->reloadConfig();
 }
 
 void KRslots::swapPanels()
 {
     QUrl leftURL = LEFT_PANEL->virtualPath();
     QUrl rightURL = RIGHT_PANEL->virtualPath();
 
     LEFT_PANEL->func->openUrl(rightURL);
     RIGHT_PANEL->func->openUrl(leftURL);
 }
 
 void KRslots::toggleSwapSides()
 {
     MAIN_VIEW->swapSides();
 }
 
 void KRslots::search()
 {
-    if (KrSearchDialog::SearchDialog != 0) {
+    if (KrSearchDialog::SearchDialog != nullptr) {
         KConfigGroup group(krConfig, "Search");
         if (group.readEntry("Window Maximized",  false))
             KrSearchDialog::SearchDialog->showMaximized();
         else
             KrSearchDialog::SearchDialog->showNormal();
 
         KrSearchDialog::SearchDialog->raise();
         KrSearchDialog::SearchDialog->activateWindow();
     } else
         KrSearchDialog::SearchDialog = new KrSearchDialog();
 }
 
 void KRslots::locate()
 {
     if (!KrServices::cmdExist("locate")) {
         KMessageBox::error(krApp, i18n("Cannot find the 'locate' command. Please install the "
                                        "findutils-locate package of GNU, or set its dependencies in "
                                        "Konfigurator"));
         return;
     }
 
     if (LocateDlg::LocateDialog != nullptr) {
         LocateDlg::LocateDialog->showNormal();
         LocateDlg::LocateDialog->raise();
         LocateDlg::LocateDialog->activateWindow();
         LocateDlg::LocateDialog->reset();
     } else
         LocateDlg::LocateDialog = new LocateDlg(krApp);
 }
 
 void KRslots::runTerminal(const QString & dir)
 {
     KProcess proc;
     proc.setWorkingDirectory(dir);
     KConfigGroup group(krConfig, "General");
     QString term = group.readEntry("Terminal", _Terminal);
     QStringList sepdArgs = KShell::splitArgs(term, KShell::TildeExpand);
     if (sepdArgs.isEmpty()) {
         KMessageBox::error(krMainWindow,
                            i18nc("Arg is a string containing the bad quoting.",
                                  "Bad quoting in terminal command:\n%1", term));
         return;
     }
     for (int i = 0; i < sepdArgs.size(); i++) {
         if (sepdArgs[i] == "%d") {
             sepdArgs[i] = dir;
         }
     }
     proc << sepdArgs;
     if (!proc.startDetached())
         KMessageBox::sorry(krApp, i18n("Error executing %1.", term));
 }
 
 void KRslots::homeTerminal()
 {
     runTerminal(QDir::homePath());
 }
 
 void KRslots::multiRename()
 {
     QStringList lst = KrServices::supportedTools();
     int i = lst.indexOf("RENAME");
     if (i == -1) {
         KMessageBox::sorry(krApp, i18n("Cannot find a batch rename tool.\nYou can get KRename at %1", QLatin1String("https://www.kde.org/applications/utilities/krename/")));
         return;
     }
     QString pathToRename = lst[i+1];
 
     const QStringList names = ACTIVE_PANEL->gui->getSelectedNames();
     if (names.isEmpty()) {
         return;
     }
 
     KProcess proc;
     proc << pathToRename;
 
-    for (const QString name: names) {
+    for (const QString& name: names) {
         FileItem *file = ACTIVE_FUNC->files()->getFileItem(name);
         if (!file)
             continue;
         const QUrl url = file->getUrl();
         // KRename only supports the recursive option combined with a local directory path
         if (file->isDir() && url.scheme() == "file") {
             proc << "-r" << url.path();
         } else {
             proc << url.toString();
         }
     }
 
     if (!proc.startDetached())
-        KMessageBox::error(0, i18n("Error executing '%1'.", proc.program().join(" ")));
+        KMessageBox::error(nullptr, i18n("Error executing '%1'.", proc.program().join(" ")));
 }
 
 void KRslots::rootKrusader()
 {
     if (KMessageBox::warningContinueCancel(
             krApp, i18n("Improper operations in root mode can damage your operating system. "
                         "<p>Furthermore, running UI applications as root is insecure and can "
                         "allow attackers to gain root access."),
             QString(), KStandardGuiItem::cont(), KStandardGuiItem::cancel(), "Confirm Root Mode",
             KMessageBox::Notify | KMessageBox::Dangerous) != KMessageBox::Continue)
         return;
 
     if (!KrServices::isExecutable(KDESU_PATH)) {
         KMessageBox::sorry(krApp,
             i18n("Cannot start root mode Krusader, %1 not found or not executable. "
                  "Please verify that kde-cli-tools are installed.", QString(KDESU_PATH)));
         return;
     }
 
     KProcess proc;
     proc << KDESU_PATH << "-c" << QApplication::instance()->applicationFilePath()
     + " --left=" + KrServices::quote(LEFT_PANEL->virtualPath().toDisplayString(QUrl::PreferLocalFile))
     + " --right=" + KrServices::quote(RIGHT_PANEL->virtualPath().toDisplayString(QUrl::PreferLocalFile));
 
     if (!proc.startDetached())
-        KMessageBox::error(0, i18n("Error executing %1.", proc.program()[0]));
+        KMessageBox::error(nullptr, i18n("Error executing %1.", proc.program()[0]));
 }
 
 void KRslots::slotSplit()
 {
     const QStringList list = ACTIVE_PANEL->gui->getSelectedNames();
     QString name;
 
     // first, see if we've got exactly 1 selected file, if not, try the current one
     if (list.count() == 1) name = list[0];
 
     if (name.isEmpty()) {
         // if we got here, then one of the panel can't be sure what file to diff
-        KMessageBox::error(0, i18n("Do not know which file to split."));
+        KMessageBox::error(nullptr, i18n("Do not know which file to split."));
         return;
     }
 
     QUrl fileURL = ACTIVE_FUNC->files()->getUrl(name);
     if (fileURL.isEmpty())
         return;
 
     if (ACTIVE_FUNC->files()->getFileItem(name)->isDir()) {
         KMessageBox::sorry(krApp, i18n("You cannot split a folder."));
         return;
     }
 
     const QUrl destDir = ACTIVE_PANEL->otherPanel()->virtualPath();
 
     SplitterGUI splitterGUI(MAIN_VIEW, fileURL, destDir);
 
     if (splitterGUI.exec() == QDialog::Accepted) {
         bool splitToOtherPanel = splitterGUI.getDestinationDir().matches(ACTIVE_PANEL->otherPanel()->virtualPath(),
                                                                          QUrl::StripTrailingSlash);
 
         Splitter split(MAIN_VIEW, fileURL, splitterGUI.getDestinationDir(), splitterGUI.overWriteFiles());
         split.split(splitterGUI.getSplitSize());
 
         if (splitToOtherPanel)
             ACTIVE_PANEL->otherPanel()->func->refresh();
     }
 }
 
 void KRslots::slotCombine()
 {
     const QStringList list = ACTIVE_PANEL->gui->getSelectedNames();
     if (list.isEmpty()) {
-        KMessageBox::error(0, i18n("Do not know which files to combine."));
+        KMessageBox::error(nullptr, i18n("Do not know which files to combine."));
         return;
     }
 
     QUrl          baseURL;
     bool          unixStyle = false;
     bool          windowsStyle = false;
     QString       commonName;
     int           commonLength = 0;
 
     /* checking splitter names */
-    for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it) {
-        QUrl url = ACTIVE_FUNC->files()->getUrl(*it);
+    for (const auto & it : list) {
+        QUrl url = ACTIVE_FUNC->files()->getUrl(it);
         if (url.isEmpty())
             return;
 
-        if (ACTIVE_FUNC->files()->getFileItem(*it)->isDir()) {
+        if (ACTIVE_FUNC->files()->getFileItem(it)->isDir()) {
             KMessageBox::sorry(krApp, i18n("You cannot combine a folder."));
             return;
         }
 
         if (!unixStyle) {
             QString name = url.fileName();
             int extPos = name.lastIndexOf('.');
             QString ext = name.mid(extPos + 1);
             name.truncate(extPos);
             url = url.adjusted(QUrl::RemoveFilename);
             url.setPath(url.path() + name);
 
             bool isExtInt;
             ext.toInt(&isExtInt, 10);
 
             if (extPos < 1 || ext.isEmpty() || (ext != "crc" && !isExtInt)) {
                 if (windowsStyle) {
-                    KMessageBox::error(0, i18n("Not a split file: %1.", url.toDisplayString(QUrl::PreferLocalFile)));
+                    KMessageBox::error(nullptr, i18n("Not a split file: %1.", url.toDisplayString(QUrl::PreferLocalFile)));
                     return;
                 }
                 unixStyle = true;
             } else {
 
                 if (ext != "crc")
                     windowsStyle = true;
 
                 if (baseURL.isEmpty())
                     baseURL = url;
                 else if (baseURL != url) {
-                    KMessageBox::error(0, i18n("Select only one split file."));
+                    KMessageBox::error(nullptr, i18n("Select only one split file."));
                     return;
                 }
             }
         }
 
         if (unixStyle) {
             bool error = true;
 
             do {
-                QString shortName   = *it;
+                const QString& shortName   = it;
                 QChar   lastChar  = shortName.at(shortName.length() - 1);
 
                 if (lastChar.isLetter()) {
                     char fillLetter = (lastChar.toUpper() == lastChar) ? 'A' : 'a';
 
                     if (commonName.isNull()) {
                         commonLength = shortName.length();
                         commonName = shortName;
 
                         while (commonName.length()) {
                             QString shorter  = commonName.left(commonName.length() - 1);
                             QString testFile = shorter.leftJustified(commonLength, fillLetter);
 
-                            if (ACTIVE_FUNC->files()->getFileItem(testFile) == 0)
+                            if (ACTIVE_FUNC->files()->getFileItem(testFile) == nullptr)
                                 break;
                             else {
                                 commonName = shorter;
                                 baseURL = ACTIVE_PANEL->virtualPath().adjusted(QUrl::StripTrailingSlash);
                                 baseURL.setPath(baseURL.path() + '/' + (testFile));
                             }
                         }
 
                         error = (commonName == shortName);
                     } else if (commonLength == shortName.length() && shortName.startsWith(commonName))
                         error = false;
                 }
             } while (false);
 
             if (error) {
-                KMessageBox::error(0, i18n("Not a split file: %1.", url.toDisplayString(QUrl::PreferLocalFile)));
+                KMessageBox::error(nullptr, i18n("Not a split file: %1.", url.toDisplayString(QUrl::PreferLocalFile)));
                 return;
             }
         }
     }
 
     // ask the user for the copy dest
     QUrl dest = KChooseDir::getDir(i18n("Combining %1.* to folder:", baseURL.toDisplayString(QUrl::PreferLocalFile)),
                                    ACTIVE_PANEL->otherPanel()->virtualPath(), ACTIVE_PANEL->virtualPath());
     if (dest.isEmpty()) return ;   // the user canceled
 
     bool combineToOtherPanel = (dest.matches(ACTIVE_PANEL->otherPanel()->virtualPath(), QUrl::StripTrailingSlash));
 
     Combiner combine(MAIN_VIEW, baseURL, dest, unixStyle);
     combine.combine();
 
     if (combineToOtherPanel)
         ACTIVE_PANEL->otherPanel()->func->refresh();
 }
 
 void KRslots::manageUseractions()
 {
     ActionMan actionMan(MAIN_VIEW);
 }
 
 #ifdef SYNCHRONIZER_ENABLED
 void KRslots::slotSynchronizeDirs(QStringList selected)
 {
     SynchronizerGUI *synchronizerDialog = new SynchronizerGUI(MAIN_VIEW, LEFT_PANEL->virtualPath(),
-                                                              RIGHT_PANEL->virtualPath(), selected);
+                                                              RIGHT_PANEL->virtualPath(), std::move(selected));
     synchronizerDialog->show(); // destroyed on close
 }
 #endif
 
 void KRslots::compareSetup()
 {
-    for (int i = 0; KrActions::compareArray[i] != 0; i++)
+    for (int i = 0; KrActions::compareArray[i] != nullptr; i++)
         if ((*KrActions::compareArray[i])->isChecked()) {
             KConfigGroup group(krConfig, "Private");
             group.writeEntry("Compare Mode", i);
             break;
         }
 }
 
 /** called by actions actExec* to choose the built-in command line mode  */
 void KRslots::execTypeSetup()
 {
-    for (int i = 0; KrActions::execTypeArray[i] != 0; i++)
+    for (int i = 0; KrActions::execTypeArray[i] != nullptr; i++)
         if ((*KrActions::execTypeArray[i])->isChecked()) {
             if (*KrActions::execTypeArray[i] == KrActions::actExecTerminalEmbedded) {
                 // if commands are to be executed in the TE, it must be loaded
                 MAIN_VIEW->terminalDock()->initialise();
             }
             KConfigGroup grp(krConfig,  "Private");
             grp.writeEntry("Command Execution Mode", i);
             break;
         }
 }
 
 void KRslots::slotDiskUsage()
 {
     DiskUsageGUI *diskUsageDialog = new DiskUsageGUI(ACTIVE_PANEL->virtualPath());
     diskUsageDialog->askDirAndShow();
 }
 
 void KRslots::applicationStateChanged()
 {
-    if (MAIN_VIEW == 0) {  /* CRASH FIX: it's possible that the method is called after destroying the main view */
+    if (MAIN_VIEW == nullptr) {  /* CRASH FIX: it's possible that the method is called after destroying the main view */
         return;
     }
     if(qApp->applicationState() == Qt::ApplicationActive ||
        qApp->applicationState() == Qt::ApplicationInactive) {
         LEFT_PANEL->panelVisible();
         RIGHT_PANEL->panelVisible();
     } else {
         LEFT_PANEL->panelHidden();
         RIGHT_PANEL->panelHidden();
     }
 }
 
 void KRslots::emptyTrash()
 {
     KrTrashHandler::emptyTrash();
 }
 
 #define OPEN_ID        100001
 #define EMPTY_TRASH_ID 100002
 
 void KRslots::trashPopupMenu()
 {
     QMenu trashMenu(krApp);
     QAction * act = trashMenu.addAction(Icon("document-open"), i18n("Open trash bin"));
     act->setData(QVariant(OPEN_ID));
     act = trashMenu.addAction(Icon("trash-empty"), i18n("Empty trash bin"));
     act->setData(QVariant(EMPTY_TRASH_ID));
 
     int result = -1;
     QAction *res = trashMenu.exec(QCursor::pos());
     if (res && res->data().canConvert<int> ())
         result = res->data().toInt();
 
     if (result == OPEN_ID) {
         ACTIVE_FUNC->openUrl(QUrl(QStringLiteral("trash:/")));
     } else if (result == EMPTY_TRASH_ID) {
         KrTrashHandler::emptyTrash();
     }
 }
 
 //shows the JavaScript-Console
 void KRslots::jsConsole()
 {
 #ifdef __KJSEMBED__
     if (! krJS)
         krJS = new KrJS();
     krJS->view()->show();
 #endif
 }
 
 void KRslots::addBookmark()
 {
     krBookMan->bookmarkCurrent(ACTIVE_PANEL->virtualPath());
 }
 
 void KRslots::cmdlinePopup()
 {
     MAIN_VIEW->cmdLine()->popup();
 }
 
diff --git a/krusader/krslots.h b/krusader/krslots.h
index 37dea0fe..c379bc98 100644
--- a/krusader/krslots.h
+++ b/krusader/krslots.h
@@ -1,117 +1,118 @@
 /*****************************************************************************
  * Copyright (C) 2001 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2001 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 
 #ifndef KRSLOTS_H
 #define KRSLOTS_H
 
 // QtCore
 #include <QFile>
 #include <QObject>
 #include <QUrl>
 
 #include <KCoreAddons/KProcess>
+#include <utility>
 
 class KrMainWindow;
 class QUrl;
 
 class KrProcess: public KProcess
 {
     Q_OBJECT
 
     QString tmp1, tmp2;
 
 public:
     KrProcess(QString in1, QString in2) {
-        tmp1 = in1;
-        tmp2 = in2;
+        tmp1 = std::move(in1);
+        tmp2 = std::move(in2);
         connect(this, QOverload<int, QProcess::ExitStatus>::of(&KrProcess::finished), this, &KrProcess::processHasExited);
     }
 
 public slots:
     void processHasExited() {
         if (!tmp1.isEmpty())
             QFile::remove(tmp1);
         if (!tmp2.isEmpty())
             QFile::remove(tmp2);
         deleteLater();
     }
 };
 
 class KRslots : public QObject
 {
     Q_OBJECT
 
 public:
     enum compareMode { full };
 
     explicit KRslots(QObject *parent);
-    ~KRslots() {}
+    ~KRslots() override = default;
 
 public slots:
     void sendFileByEmail(const QList<QUrl> &filename);
     void compareContent();
-    void compareContent(QUrl, QUrl);
+    void compareContent(const QUrl&, const QUrl&);
     void insertFileName(bool fullPath);
     void rootKrusader();
     void swapPanels();
     void showHiddenFiles(bool show);
     void toggleSwapSides();
     void updateStatusbarVisibility();
     void toggleTerminal();
     void compareSetup();
     void emptyTrash();
     void trashPopupMenu();
     /** called by actExec* actions to choose the built-in command line mode */
     void execTypeSetup();
     void refresh(const QUrl &u);
     void runKonfigurator(bool firstTime = false);
     void startKonfigurator() {
         runKonfigurator(false);
     }
     void search();           // call the search module
     void locate();
     void runTerminal(const QString & dir);
     void homeTerminal();
     void addBookmark();
     void toggleFnkeys();
     void toggleCmdline();
     void multiRename();
     void cmdlinePopup();
     void slotSplit();
     void slotCombine();
     void manageUseractions();
 #ifdef SYNCHRONIZER_ENABLED
     void slotSynchronizeDirs(QStringList selected = QStringList());
 #endif
     void slotDiskUsage();
     void applicationStateChanged();
     void jsConsole();
 
 protected slots:
     void configChanged(bool isGUIRestartNeeded);
 
 protected:
     KrMainWindow *_mainWindow;
 };
 
 #endif
diff --git a/krusader/krusader.cpp b/krusader/krusader.cpp
index 6122a6ce..f2e34bfd 100644
--- a/krusader/krusader.cpp
+++ b/krusader/krusader.cpp
@@ -1,639 +1,640 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krusader.h"
 
 // QtCore
 #include <QDir>
 #include <QDateTime>
 #include <QStringList>
 #include <QStandardPaths>
 // QtGui
 #include <QMoveEvent>
 #include <QResizeEvent>
 // QtWidgets
 #include <QApplication>
 #include <QMenuBar>
 #include <QDesktopWidget>
 // QtDBus
 #include <QDBusInterface>
 
 #include <KCoreAddons/KRandom>
 #include <KConfigCore/KSharedConfig>
 #include <KConfigGui/KWindowConfig>
 #include <KI18n/KLocalizedString>
 #include <KXmlGui/KActionCollection>
 #include <KXmlGui/KXMLGUIFactory>
 #include <KXmlGui/KToolBar>
 #include <KWidgetsAddons/KAcceleratorManager>
 #include <KWidgetsAddons/KCursor>
 #include <KWidgetsAddons/KMessageBox>
 #include <KWidgetsAddons/KToggleAction>
 #include <KWidgetsAddons/KToolBarPopupAction>
 #include <KWindowSystem/KStartupInfo>
 #include <KWindowSystem/KWindowSystem>
+#include <utility>
 
 #include "defaults.h"
 #include "kractions.h"
 #include "krglobal.h"
 #include "krservices.h"
 #include "krslots.h"
 #include "krtrashhandler.h"
 #include "krusaderversion.h"
 #include "krusaderview.h"
 #include "panelmanager.h"
 #include "tabactions.h"
 
 #include "BookMan/krbookmarkhandler.h"
 #include "Dialogs/checksumdlg.h"
 #include "Dialogs/krpleasewait.h"
 #include "Dialogs/popularurls.h"
 #include "FileSystem/fileitem.h"
 #include "FileSystem/krpermhandler.h"
 #include "GUI/kcmdline.h"
 #include "GUI/kfnkeys.h"
 #include "GUI/krremoteencodingmenu.h"
 #include "GUI/krusaderstatus.h"
 #include "GUI/terminaldock.h"
 #include "JobMan/jobman.h"
 #include "KViewer/krviewer.h"
 #include "Konfigurator/kgprotocols.h"
 #include "MountMan/kmountman.h"
 #include "Panel/PanelView/krview.h"
 #include "Panel/PanelView/krviewfactory.h"
 #include "Panel/krcolorcache.h"
 #include "Panel/krpanel.h"
 #include "Panel/listpanelactions.h"
 #include "Panel/viewactions.h"
 #include "UserAction/expander.h"
 // This makes gcc-4.1 happy. Warning about possible problem with KrAction's dtor not called
 #include "UserAction/kraction.h"
 #include "UserAction/useraction.h"
 
 #ifdef __KJSEMBED__
 #include "KrJS/krjs.h"
 #endif
 
 
 // define the static members
-Krusader *Krusader::App = 0;
+Krusader *Krusader::App = nullptr;
 QString   Krusader::AppName;
 // KrBookmarkHandler *Krusader::bookman = 0;
 //QTextOStream *Krusader::_krOut = QTextOStream(::stdout);
 
 #ifdef __KJSEMBED__
 KrJS *Krusader::js = 0;
 QAction *Krusader::actShowJSConsole = 0;
 #endif
 
 // construct the views, statusbar and menu bars and prepare Krusader to start
-Krusader::Krusader(const QCommandLineParser &parser) : KParts::MainWindow(0,
+Krusader::Krusader(const QCommandLineParser &parser) : KParts::MainWindow(nullptr,
                 Qt::Window | Qt::WindowTitleHint | Qt::WindowContextHelpButtonHint),
-        _listPanelActions(0), isStarting(true), isExiting(false), _quit(false)
+        _listPanelActions(nullptr), isStarting(true), isExiting(false), _quit(false)
 {
     // create the "krusader"
     App = this;
     krMainWindow = this;
     SLOTS = new KRslots(this);
     setXMLFile("krusaderui.rc");   // kpart-related xml file
 
     plzWait = new KRPleaseWaitHandler(this);
 
     const bool runKonfig = versionControl();
 
     QString message;
     switch (krConfig->accessMode()) {
     case KConfigBase::NoAccess :
         message = "Krusader's configuration file can't be found. Default values will be used.";
         break;
     case KConfigBase::ReadOnly :
         message = "Krusader's configuration file is in READ ONLY mode (why is that!?) Changed values will not be saved";
         break;
     case KConfigBase::ReadWrite :
         message = "";
         break;
     }
     if (!message.isEmpty()) {
         KMessageBox::error(krApp, message);
     }
 
     // create MountMan
     KrGlobal::mountMan = new KMountMan(this);
     connect(KrGlobal::mountMan, &KMountMan::refreshPanel, SLOTS, &KRslots::refresh);
 
     // create popular URLs container
     _popularUrls = new PopularUrls(this);
 
     // create bookman
     krBookMan = new KrBookmarkHandler(this);
 
     // create job manager
     krJobMan = new JobMan(this);
 
     // create the main view
     MAIN_VIEW = new KrusaderView(this);
 
     // setup all the krusader's actions
     setupActions();
 
     // init the permission handler class
     KRpermHandler::init();
 
     // init the protocol handler
     KgProtocols::init();
 
     const KConfigGroup lookFeelGroup(krConfig, "Look&Feel");
     FileItem::loadUserDefinedFolderIcons(lookFeelGroup.readEntry("Load User Defined Folder Icons",
                                                                  _UserDefinedFolderIcons));
 
     const KConfigGroup startupGroup(krConfig, "Startup");
     QString startProfile = startupGroup.readEntry("Starter Profile Name", QString());
 
     QList<QUrl> leftTabs;
     QList<QUrl> rightTabs;
 
     // get command-line arguments
     if (parser.isSet("left")) {
         leftTabs = KrServices::toUrlList(parser.value("left").split(','));
         startProfile.clear();
     }
     if (parser.isSet("right")) {
         rightTabs = KrServices::toUrlList(parser.value("right").split(','));
         startProfile.clear();
     }
     if (parser.isSet("profile"))
         startProfile = parser.value("profile");
 
     if (!startProfile.isEmpty()) {
         leftTabs.clear();
         rightTabs.clear();
     }
     // starting the panels
     MAIN_VIEW->start(startupGroup, startProfile.isEmpty(), leftTabs, rightTabs);
 
     // create a status bar
-    KrusaderStatus *status = new KrusaderStatus(this);
+    auto *status = new KrusaderStatus(this);
     setStatusBar(status);
     status->setWhatsThis(i18n("Statusbar will show basic information "
                               "about file below mouse pointer."));
 
     // create tray icon (if needed)
     const bool startToTray = startupGroup.readEntry("Start To Tray", _StartToTray);
     setTray(startToTray);
 
     setCentralWidget(MAIN_VIEW);
 
     // manage our keyboard short-cuts
     //KAcceleratorManager::manage(this,true);
 
     setCursor(Qt::ArrowCursor);
 
     if (! startProfile.isEmpty())
         MAIN_VIEW->profiles(startProfile);
 
     // restore gui settings
     {
         // now, check if we need to create a konsole_part
         // call the XML GUI function to draw the UI
         createGUI(MAIN_VIEW->terminalDock()->part());
 
         // this needs to be called AFTER createGUI() !!!
         updateUserActions();
         _listPanelActions->guiUpdated();
 
         // not using this. See savePosition()
         //applyMainWindowSettings();
 
         const KConfigGroup cfgToolbar(krConfig, "Main Toolbar");
         toolBar()->applySettings(cfgToolbar);
 
         const KConfigGroup cfgJobBar(krConfig, "Job Toolbar");
         toolBar("jobToolBar")->applySettings(cfgJobBar);
 
         const KConfigGroup cfgActionsBar(krConfig, "Actions Toolbar");
         toolBar("actionsToolBar")->applySettings(cfgActionsBar);
 
         // restore toolbars position and visibility
         restoreState(startupGroup.readEntry("State", QByteArray()));
 
         statusBar()->setVisible(startupGroup.readEntry("Show status bar", _ShowStatusBar));
 
         MAIN_VIEW->updateGUI(startupGroup);
 
         // popular urls
         _popularUrls->load();
     }
 
     if (runKonfig)
         SLOTS->runKonfigurator(true);
 
     KConfigGroup viewerModuleGrp(krConfig, "ViewerModule");
     if (viewerModuleGrp.readEntry("FirstRun", true)) {
         KrViewer::configureDeps();
         viewerModuleGrp.writeEntry("FirstRun", false);
     }
 
     if (!runKonfig) {
         KConfigGroup cfg(krConfig, "Private");
         move(cfg.readEntry("Start Position", _StartPosition));
         resize(cfg.readEntry("Start Size", _StartSize));
     }
 
     // view initialized; show window or only tray
     if (!startToTray) {
         show();
     }
 
     KrTrashHandler::startWatcher();
     isStarting = false;
 
     //HACK - used by [ListerTextArea|KrSearchDialog|LocateDlg]:keyPressEvent()
     KrGlobal::copyShortcut = _listPanelActions->actCopy->shortcut();
 
     //HACK: make sure the active view becomes focused
     // for some reason sometimes the active view cannot be focused immediately at this point,
     // so queue it for the main loop
     QTimer::singleShot(0, ACTIVE_PANEL->view->widget(), QOverload<>::of(&QWidget::setFocus));
 
     _openUrlTimer.setSingleShot(true);
     connect(&_openUrlTimer, &QTimer::timeout, this, &Krusader::doOpenUrl);
 
-    KStartupInfo *startupInfo = new KStartupInfo(0, this);
+    auto *startupInfo = new KStartupInfo(0, this);
     connect(startupInfo, &KStartupInfo::gotNewStartup,
             this, &Krusader::slotGotNewStartup);
     connect(startupInfo, &KStartupInfo::gotRemoveStartup,
             this, &Krusader::slotGotRemoveStartup);
 }
 
 Krusader::~Krusader()
 {
     KrTrashHandler::stopWatcher();
     if (!isExiting) // save the settings if it was not saved (SIGTERM received)
         saveSettings();
 
     delete MAIN_VIEW;
-    MAIN_VIEW = 0;
-    App = 0;
+    MAIN_VIEW = nullptr;
+    App = nullptr;
 }
 
 void Krusader::setTray(bool forceCreation)
 {
     const bool trayIsNeeded = forceCreation || KConfigGroup(krConfig, "Look&Feel")
                                                .readEntry("Minimize To Tray", _ShowTrayIcon);
     if (!sysTray && trayIsNeeded) {
         sysTray = new KStatusNotifierItem(this);
         sysTray->setIconByName(appIconName());
         // we have our own "quit" method, re-connect
         QAction *quitAction = sysTray->action(QStringLiteral("quit"));
         if (quitAction) {
             disconnect(quitAction, &QAction::triggered, nullptr, nullptr);
             connect(quitAction, &QAction::triggered, this, &Krusader::quit);
         }
     } else if (sysTray && !trayIsNeeded) {
         // user does not want tray anymore :(
         sysTray->deleteLater();
     }
 }
 
 bool Krusader::versionControl()
 {
     // create config file
     krConfig = KSharedConfig::openConfig().data();
     KConfigGroup nogroup(krConfig, QString());
     const bool firstRun = nogroup.readEntry("First Time", true);
     KrGlobal::sCurrentConfigVersion = nogroup.readEntry("Config Version", -1);
 
     // first installation of krusader
     if (firstRun) {
         KMessageBox::information(
             krApp, i18n("<qt><b>Welcome to Krusader.</b><p>As this is your first run, your machine "
                         "will now be checked for external applications. Then the Konfigurator will "
                         "be launched where you can customize Krusader to your needs.</p></qt>"));
     }
     nogroup.writeEntry("Version", VERSION);
     nogroup.writeEntry("First Time", false);
     krConfig->sync();
 
     QDir().mkpath(QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) +
                   QStringLiteral("/krusader/"));
 
     return firstRun;
 }
 
 void Krusader::statusBarUpdate(const QString& mess)
 {
     // change the message on the statusbar for 5 seconds
     if (statusBar()->isVisible())
         statusBar()->showMessage(mess, 5000);
 }
 
 bool Krusader::event(QEvent *e) {
     if(e->type() == QEvent::ApplicationPaletteChange) {
         KrColorCache::getColorCache().refreshColors();
     }
     return KParts::MainWindow::event(e);
 }
 
 // <patch> Moving from Pixmap actions to generic filenames - thanks to Carsten Pfeiffer
 void Krusader::setupActions() {
     QAction *bringToTopAct = new QAction(i18n("Bring Main Window to Top"), this);
     actionCollection()->addAction("bring_main_window_to_top", bringToTopAct);
     connect(bringToTopAct, &QAction::triggered, this, &Krusader::moveToTop);
 
     KrActions::setupActions(this);
     _krActions = new KrActions(this);
     _viewActions = new ViewActions(this, this);
     _listPanelActions = new ListPanelActions(this, this);
     _tabActions = new TabActions(this, this);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 //////////////////// implementation of slots //////////////////////////////
 ///////////////////////////////////////////////////////////////////////////
 
 void Krusader::savePosition() {
     KConfigGroup cfg(krConfig, "Private");
     cfg.writeEntry("Start Position", pos());
     cfg.writeEntry("Start Size", size());
 
     cfg = krConfig->group("Startup");
     MAIN_VIEW->saveSettings(cfg);
 
     // NOTE: this would save current window state/size, statusbar and settings for each toolbar.
     // We are not using this and saving everything manually because
     // - it does not save window position
     // - window size save/restore does sometimes not work (multi-monitor setup)
     // - saving the statusbar visibility should be independent from window position and restoring it
     //   does not work properly.
     //KConfigGroup cfg = KConfigGroup(&cfg, "MainWindowSettings");
     //saveMainWindowSettings(cfg);
     //statusBar()->setVisible(cfg.readEntry("StatusBar", "Enabled") != "Disabled");
 
     krConfig->sync();
 }
 
 void Krusader::saveSettings() {
     // workaround: revert terminal fullscreen mode before saving widget and toolbar visibility
     if (MAIN_VIEW->isTerminalEmulatorFullscreen()) {
         MAIN_VIEW->setTerminalEmulator(false, true);
     }
 
     KConfigGroup noGroup(krConfig, QString());
     noGroup.writeEntry("Config Version", KrGlobal::sConfigVersion);
 
     // save toolbar settings
     KConfigGroup cfg(krConfig, "Main Toolbar");
     toolBar()->saveSettings(cfg);
 
     cfg = krConfig->group("Job Toolbar");
     toolBar("jobToolBar")->saveSettings(cfg);
 
     cfg = krConfig->group("Actions Toolbar");
     toolBar("actionsToolBar")->saveSettings(cfg);
 
     cfg = krConfig->group("Startup");
     // save toolbar visibility and position
     cfg.writeEntry("State", saveState());
     cfg.writeEntry("Show status bar", statusBar()->isVisible());
 
     // save panel and window settings
     if (cfg.readEntry("Remember Position", _RememberPos))
         savePosition();
 
     // save the gui components visibility
     if (cfg.readEntry("UI Save Settings", _UiSave)) {
         cfg.writeEntry("Show FN Keys", KrActions::actToggleFnkeys->isChecked());
         cfg.writeEntry("Show Cmd Line", KrActions::actToggleCmdline->isChecked());
         cfg.writeEntry("Show Terminal Emulator", KrActions::actToggleTerminal->isChecked());
     }
 
     // save popular links
     _popularUrls->save();
 
     krConfig->sync();
 }
 
 void Krusader::closeEvent(QCloseEvent *event)
 {
     if (!sysTray || _quit) {
         _quit = false; // in case quit will be aborted
         KParts::MainWindow::closeEvent(event); // (may) quit, continues with queryClose()...
     } else {
         // close window to tray
         event->ignore();
         hide();
     }
 }
 
 void Krusader::showEvent(QShowEvent *event)
 {
     const KConfigGroup lookFeelGroup(krConfig, "Look&Feel");
     if (sysTray && !lookFeelGroup.readEntry("Minimize To Tray", _ShowTrayIcon)) {
         // restoring from "start to tray", tray icon is not needed anymore
         sysTray->deleteLater();
     }
 
     KParts::MainWindow::showEvent(event);
 }
 
 bool Krusader::queryClose() {
     if (isStarting || isExiting)
         return false;
 
     if (qApp->isSavingSession()) { // KDE is logging out, accept the close
         acceptClose();
         return true;
     }
 
     const KConfigGroup cfg = krConfig->group("Look&Feel");
     const bool confirmExit = cfg.readEntry("Warn On Exit", _WarnOnExit);
 
     // ask user and wait until all KIO::job operations are terminated. Krusader won't exit before
     // that anyway
     if (!krJobMan->waitForJobs(confirmExit))
         return false;
 
     /* First try to close the child windows, because it's the safer
        way to avoid crashes, then close the main window.
        If closing a child is not successful, then we cannot let the
        main window close. */
 
     for (;;) {
         QWidgetList list = QApplication::topLevelWidgets();
         QWidget *activeModal = QApplication::activeModalWidget();
         QWidget *w = list.at(0);
 
         if (activeModal &&
                 activeModal != this &&
                 activeModal != menuBar() &&
                 list.contains(activeModal) &&
                 !activeModal->isHidden()) {
             w = activeModal;
         } else {
             int i = 1;
             for (; i < list.count(); ++i) {
                 w = list.at(i);
                 if (!(w && (w == this || w->isHidden() || w == menuBar())))
                     break;
             }
 
             if (i == list.count())
-                w = 0;
+                w = nullptr;
         }
 
         if (!w) break;
 
         if (!w->close()) {
             if (w->inherits("QDialog")) {
                 fprintf(stderr, "Failed to close: %s\n", w->metaObject()->className());
             }
             return false;
         }
     }
 
     acceptClose();
     return true;
 }
 
 void Krusader::acceptClose() {
     saveSettings();
 
     emit shutdown();
 
     // Removes the DBUS registration of the application. Single instance mode requires unique appid.
     // As Krusader is exiting, we release that unique appid, so new Krusader instances
     // can be started.
 
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.unregisterObject("/Instances/" + Krusader::AppName);
 
     isExiting = true;
 }
 
 // the please wait dialog functions
 void Krusader::startWaiting(QString msg, int count , bool cancel) {
-    plzWait->startWaiting(msg , count, cancel);
+    plzWait->startWaiting(std::move(msg) , count, cancel);
 }
 
 bool Krusader::wasWaitingCancelled() const {
     return plzWait->wasCancelled();
 }
 
 void Krusader::stopWait() {
     plzWait->stopWait();
 }
 
 void Krusader::updateUserActions() {
-    KActionMenu *userActionMenu = (KActionMenu *) KrActions::actUserMenu;
+    auto *userActionMenu = (KActionMenu *) KrActions::actUserMenu;
     if (userActionMenu) {
         userActionMenu->menu()->clear();
 
         userActionMenu->addAction(KrActions::actManageUseractions);
         userActionMenu->addSeparator();
-        krUserAction->populateMenu(userActionMenu, NULL);
+        krUserAction->populateMenu(userActionMenu, nullptr);
     }
 }
 
 const char* Krusader::appIconName() {
     if (geteuid())
         return "krusader_user";
     else
         return "krusader_root";
 }
 
 void Krusader::quit()
 {
     _quit = true; // remember that we want to quit and not close to tray
     close(); // continues with closeEvent()...
 }
 
 void Krusader::moveToTop() {
     if (isHidden())
         show();
 
     KWindowSystem::forceActiveWindow(winId());
 }
 
 bool Krusader::isRunning() {
     moveToTop(); //FIXME - doesn't belong here
     return true;
 }
 
 bool Krusader::isLeftActive()  {
     return MAIN_VIEW->isLeftActive();
 }
 
 bool Krusader::openUrl(QString url)
 {
-    _urlToOpen = url;
+    _urlToOpen = std::move(url);
     _openUrlTimer.start(0);
     return true;
 }
 
 void Krusader::doOpenUrl()
 {
     QUrl url = QUrl::fromUserInput(_urlToOpen, QDir::currentPath(), QUrl::AssumeLocalFile);
     _urlToOpen.clear();
     int tab = ACTIVE_MNG->findTab(url);
     if(tab >= 0)
         ACTIVE_MNG->setActiveTab(tab);
     else if((tab = OTHER_MNG->findTab(url)) >= 0) {
         OTHER_MNG->setActiveTab(tab);
         OTHER_MNG->currentPanel()->view->widget()->setFocus();
     } else
         ACTIVE_MNG->slotNewTab(url);
 }
 
 void Krusader::slotGotNewStartup(const KStartupInfoId &id, const KStartupInfoData &data)
 {
     Q_UNUSED(id)
     Q_UNUSED(data)
     // This is here to show busy mouse cursor when _other_ applications are launched, not for krusader itself.
     qApp->setOverrideCursor(Qt::BusyCursor);
 }
 
 void Krusader::slotGotRemoveStartup(const KStartupInfoId &id, const KStartupInfoData &data)
 {
     Q_UNUSED(id)
     Q_UNUSED(data)
     qApp->restoreOverrideCursor();
 }
 
 KrView *Krusader::activeView()
 {
     return ACTIVE_PANEL->view;
 }
 
 AbstractPanelManager *Krusader::activeManager()
 {
     return MAIN_VIEW->activeManager();
 }
 
 AbstractPanelManager *Krusader::leftManager()
 {
     return MAIN_VIEW->leftManager();
 }
 
 AbstractPanelManager *Krusader::rightManager()
 {
     return MAIN_VIEW->rightManager();
 }
 
diff --git a/krusader/krusader.h b/krusader/krusader.h
index 276e90f4..69b60181 100644
--- a/krusader/krusader.h
+++ b/krusader/krusader.h
@@ -1,188 +1,188 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRUSADER_H
 #define KRUSADER_H
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
 
 #include "krmainwindow.h"
 
 // QtCore
 #include <QCommandLineParser>
 #include <QEvent>
 #include <QPointer>
 #include <QStringList>
 #include <QTimer>
 // QtGui
 #include <QHideEvent>
 #include <QMoveEvent>
 #include <QResizeEvent>
 #include <QShowEvent>
 // QtWidgets
 #include <QAction>
 
 #include <KConfigCore/KConfig>
 #include <KConfigCore/KConfigGroup>
 #include <KConfigWidgets/KStandardAction>
 #include <KNotifications/KStatusNotifierItem>
 #include <KParts/MainWindow>
 
 #ifdef __KJSEMBED__
 class KrJS;
 #endif
 
 class KStartupInfoData;
 class KStartupInfoId;
 
 class KrusaderStatus;
 class KRPleaseWaitHandler;
 class PopularUrls;
 class ViewActions;
 class ListPanelActions;
 class TabActions;
 class KrView;
 
 /**
  * @brief The main window of this file manager
  */
 class Krusader : public KParts::MainWindow, public KrMainWindow
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.krusader.Instance")
 
 public:
     explicit Krusader(const QCommandLineParser &parser);
-    virtual ~Krusader();
+    ~Krusader() override;
 
     void setTray(bool forceCreation = false);
 
     // KrMainWindow implementation
-    virtual QWidget *widget() Q_DECL_OVERRIDE {
+    QWidget *widget() Q_DECL_OVERRIDE {
         return this;
     }
-    virtual KrView *activeView() Q_DECL_OVERRIDE;
+    KrView *activeView() Q_DECL_OVERRIDE;
     ViewActions *viewActions() Q_DECL_OVERRIDE {
         return _viewActions;
     }
-    virtual KActionCollection *actions() Q_DECL_OVERRIDE {
+    KActionCollection *actions() Q_DECL_OVERRIDE {
         return actionCollection();
     }
-    virtual AbstractPanelManager *activeManager() Q_DECL_OVERRIDE;
-    virtual AbstractPanelManager *leftManager() Q_DECL_OVERRIDE;
-    virtual AbstractPanelManager *rightManager() Q_DECL_OVERRIDE;
-    virtual PopularUrls *popularUrls() Q_DECL_OVERRIDE {
+    AbstractPanelManager *activeManager() Q_DECL_OVERRIDE;
+    AbstractPanelManager *leftManager() Q_DECL_OVERRIDE;
+    AbstractPanelManager *rightManager() Q_DECL_OVERRIDE;
+    PopularUrls *popularUrls() Q_DECL_OVERRIDE {
         return _popularUrls;
     }
-    virtual KrActions *krActions() Q_DECL_OVERRIDE {
+    KrActions *krActions() Q_DECL_OVERRIDE {
         return _krActions;
     }
-    virtual ListPanelActions *listPanelActions() Q_DECL_OVERRIDE {
+    ListPanelActions *listPanelActions() Q_DECL_OVERRIDE {
         return _listPanelActions;
     }
-    virtual TabActions *tabActions() Q_DECL_OVERRIDE {
+    TabActions *tabActions() Q_DECL_OVERRIDE {
         return _tabActions;
     }
-    virtual void plugActionList(const char *name, QList<QAction*> &list) Q_DECL_OVERRIDE {
+    void plugActionList(const char *name, QList<QAction*> &list) Q_DECL_OVERRIDE {
         KParts::MainWindow::plugActionList(name, list);
     }
 
     /**
      * Icon name that depends on whether krusader runs with root-privileges or not
      *
      * @return icon name
      */
     static const char* appIconName();
 
 public slots:
     void quit();
     void moveToTop();
     void statusBarUpdate(const QString& mess);
     // in use by Krusader only
     void saveSettings();
     void savePosition();
     void updateUserActions();
 
 protected slots:
     void doOpenUrl();
     void slotGotNewStartup(const KStartupInfoId &id, const KStartupInfoData &data);
     void slotGotRemoveStartup(const KStartupInfoId &id, const KStartupInfoData &data);
 
 protected:
     void closeEvent(QCloseEvent *event) Q_DECL_OVERRIDE;
     void showEvent(QShowEvent *event) Q_DECL_OVERRIDE;
     bool queryClose() Q_DECL_OVERRIDE;
     void setupActions();
     bool versionControl();  // handle version differences in krusaderrc
     bool event(QEvent *) Q_DECL_OVERRIDE;
 
 public Q_SLOTS:
     Q_SCRIPTABLE bool isRunning();
     Q_SCRIPTABLE bool isLeftActive();
     Q_SCRIPTABLE bool openUrl(QString url);
 
 public:
     static Krusader *App;       // a kApp style pointer
     static QString   AppName;   // the name of the application
     PopularUrls *_popularUrls; // holds a sorted list of the most popular urls visited
 
     // the internal progress bar variales + functions
     KRPleaseWaitHandler* plzWait;
     void startWaiting(QString msg = "Please Wait", int count = 0 , bool cancel = false);
     void stopWait();
     bool wasWaitingCancelled() const;
 
 #ifdef __KJSEMBED__
     static KrJS *js;
 #endif
 
 signals:
     void changeMessage(QString);
     // emitted when we are about to quit
     void shutdown();
 
 private:
     void acceptClose();
 
 private:
     KrActions *_krActions;
     ViewActions *_viewActions;
     ListPanelActions *_listPanelActions;
     TabActions *_tabActions;
     QPointer<KStatusNotifierItem> sysTray;
     bool         isStarting;
     bool         isExiting;
     QTimer      _openUrlTimer;
     QString     _urlToOpen;
     bool        _quit;
 };
 
 
 // main modules
 #define krApp        Krusader::App
 
 #ifdef __KJSEMBED__
 #define krJS   Krusader::App->js
 #endif
 
 #endif
diff --git a/krusader/krusaderview.cpp b/krusader/krusaderview.cpp
index d6441bb5..d228987d 100644
--- a/krusader/krusaderview.cpp
+++ b/krusader/krusaderview.cpp
@@ -1,530 +1,530 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krusaderview.h"
 
 // QtCore
 #include <QDebug>
 #include <QList>
 #include <QEvent>
 // QtGui
 #include <QKeyEvent>
 #include <QClipboard>
 // QtWidgets
 #include <QApplication>
 #include <QGridLayout>
 #include <QMenuBar>
 #include <QStatusBar>
 
 #include <KI18n/KLocalizedString>
 #include <KXmlGui/KToolBar>
 #include <KWidgetsAddons/KToggleAction>
 
 #include "krusader.h"
 #include "icon.h"
 #include "kractions.h"
 #include "krslots.h"
 #include "defaults.h"
 #include "Panel/listpanel.h"
 #include "Panel/panelfunc.h"
 #include "GUI/kcmdline.h"
 #include "GUI/kfnkeys.h"
 #include "GUI/terminaldock.h"
 #include "panelmanager.h"
 #include "GUI/profilemanager.h"
 #include "Dialogs/percentalsplitter.h"
 #include "krservices.h"
 
 KrusaderView::KrusaderView(QWidget *parent) : QWidget(parent),
-    activeMng(0)
+    activeMng(nullptr)
 {
 }
 
 void KrusaderView::start(const KConfigGroup &cfg, bool restoreSettings,
                          const QList<QUrl> &leftTabs, const QList<QUrl> &rightTabs)
 {
     ////////////////////////////////
     // make a 1x1 mainLayout, it will auto-expand:
     mainLayout = new QGridLayout(this);
     mainLayout->setContentsMargins(0, 0, 0, 0);
     mainLayout->setSpacing(0);
     // vertical splitter
     vert_splitter = new QSplitter(this);   // splits between panels and terminal/cmdline
     vert_splitter->setOrientation(Qt::Vertical);
     // horizontal splitter
     horiz_splitter = new PercentalSplitter(vert_splitter);
     (_terminalDock = new TerminalDock(vert_splitter, krApp))->hide();     // create it hidden
 
     // create a command line thing
     _cmdLine = new KCMDLine(this);
 
     // add a panel manager for each side of the splitter
     leftMng  = createManager(true);
     rightMng = createManager(false);
     leftMng->setOtherManager(rightMng);
     rightMng->setOtherManager(leftMng);
 
     // make the left panel focused at program start
     activeMng = leftMng;
 
     // create the function keys widget
     _fnKeys = new KFnKeys(this, krApp);
     _fnKeys->hide();
     _fnKeys->setWhatsThis(i18n("Function keys allow performing fast "
                               "operations on files."));
 
     // and insert the whole thing into the main layout... at last
     mainLayout->addWidget(vert_splitter, 0, 0);    //<>
     mainLayout->addWidget(_cmdLine, 1, 0);
     mainLayout->addWidget(_fnKeys, 2, 0);
     mainLayout->activate();
 
     // get the last saved sizes of the splitter
 
     QList<int> lst = cfg.readEntry("Splitter Sizes", QList<int>());
     if (lst.count() != 2) {
         lst.clear();
         lst.push_back(100);
         lst.push_back(100);
     } else if (lst[0] < 1 && lst[1] < 1) {
         lst[ 0 ] = 100;
         lst[ 1 ] = 100;
     }
 
     horiz_splitter->setSizes(lst);
 
     verticalSplitterSizes = cfg.readEntry("Terminal Emulator Splitter Sizes", QList<int> ());
     if (verticalSplitterSizes.count() != 2 ||
         (verticalSplitterSizes[0] < 1 && verticalSplitterSizes[1] < 1)) {
         verticalSplitterSizes.clear();
         verticalSplitterSizes << 100 << 100;
     }
 
     leftPanel()->start(leftTabs.isEmpty() ? QUrl::fromLocalFile(QDir::homePath()) : leftTabs.at(0));
     rightPanel()->start(rightTabs.isEmpty() ? QUrl::fromLocalFile(QDir::homePath()) : rightTabs.at(0));
 
     activePanel()->gui->slotFocusOnMe();  // left starts out active
 
     for (int i = 1; i < leftTabs.count(); i++)
         leftMng->slotNewTab(leftTabs.at(i), false);
 
     for (int j = 1; j < rightTabs.count(); j++)
         rightMng->slotNewTab(rightTabs.at(j), false);
 
     // this is needed so that all tab labels get updated
     leftMng->layoutTabs();
     rightMng->layoutTabs();
 
     if(restoreSettings) {
         if(leftTabs.isEmpty())
             leftMng->loadSettings(KConfigGroup(&cfg, "Left Tab Bar"));
         if(rightTabs.isEmpty())
             rightMng->loadSettings(KConfigGroup(&cfg, "Right Tab Bar"));
         if (cfg.readEntry("Left Side Is Active", false))
             leftPanel()->slotFocusOnMe();
         else
             rightPanel()->slotFocusOnMe();
     }
 }
 
 void KrusaderView::updateGUI(const KConfigGroup &cfg)
 {
     if (!cfg.readEntry("Show Cmd Line", _ShowCmdline)) {
         cmdLine()->hide();
         KrActions::actToggleCmdline->setChecked(false);
     } else {
         cmdLine()->show();
         KrActions::actToggleCmdline->setChecked(true);
     }
     // update the Fn bar to the shortcuts selected by the user
     fnKeys()->updateShortcuts();
     if (!cfg.readEntry("Show FN Keys", _ShowFNkeys)) {
         fnKeys()->hide();
         KrActions::actToggleFnkeys->setChecked(false);
     } else {
         fnKeys()->show();
         KrActions::actToggleFnkeys->setChecked(true);
     }
     // set vertical mode
     if (cfg.readEntry("Vertical Mode", false)) {
         toggleVerticalMode();
     }
     if (cfg.readEntry("Show Terminal Emulator", _ShowTerminalEmulator)) {
         setTerminalEmulator(true);   // create konsole_part
     };
 }
 
 void KrusaderView::setPanelSize(bool leftPanel, int percent)
 {
     QList<int> panelSizes = horiz_splitter->sizes();
     int totalSize = panelSizes[0] + panelSizes[1];
 
     if (leftPanel) {
         panelSizes[0] = totalSize * percent / 100;
         panelSizes[1] = totalSize * (100 - percent) / 100;
     } else { // == RIGHT_PANEL
         panelSizes[0] = totalSize * (100 - percent) / 100;
         panelSizes[1] = totalSize * percent / 100;
     }
 
     horiz_splitter->setSizes(panelSizes);
 }
 
 PanelManager *KrusaderView::createManager(bool left)
 {
-    PanelManager *panelManager = new PanelManager(horiz_splitter, krApp, left);
+    auto *panelManager = new PanelManager(horiz_splitter, krApp, left);
     connect(panelManager, &PanelManager::draggingTab, this, &KrusaderView::draggingTab);
     connect(panelManager, &PanelManager::draggingTabFinished, this, &KrusaderView::draggingTabFinished);
     connect(panelManager, &PanelManager::pathChanged, this, &KrusaderView::slotPathChanged);
     connect(panelManager, &PanelManager::setActiveManager, this, &KrusaderView::slotSetActiveManager);
 
     return panelManager;
 }
 
 void KrusaderView::updateCurrentActivePath()
 {
     const QString path = activePanel()->gui->lastLocalPath();
 
     _cmdLine->setCurrent(path);
     KConfigGroup cfg = krConfig->group("General");
     if (_terminalDock->isInitialised() && cfg.readEntry("Send CDs", _SendCDs)) {
         _terminalDock->sendCd(path);
     }
 }
 
 KrPanel *KrusaderView::activePanel() const
 {
     // active manager might not be set yet
     return activeMng ? activeMng->currentPanel() : nullptr;
 }
 
 ListPanel *KrusaderView::leftPanel() const { return leftMng->currentPanel()->gui; }
 
 ListPanel *KrusaderView::rightPanel() const { return rightMng->currentPanel()->gui; }
 
 // updates the command line whenever current panel or its path changes
 void KrusaderView::slotPathChanged(ListPanel *listPanel)
 {
     if (listPanel == activePanel()) {
         updateCurrentActivePath();
     }
 }
 
 int KrusaderView::getFocusCandidates(QVector<QWidget*> &widgets)
 {
     activePanel()->gui->getFocusCandidates(widgets);
     if(_terminalDock->isTerminalVisible())
         widgets << _terminalDock;
     if(_cmdLine->isVisible())
         widgets << _cmdLine;
 
     for(int i = 0; i < widgets.count(); i++) {
         if(widgets[i] == focusWidget() || widgets[i]->focusWidget() == focusWidget())
             return i;
     }
     return -1;
 }
 
 void KrusaderView::focusUp()
 {
     qDebug() << "focus UP";
     QVector<QWidget*> widgets;
     int currentFocus = getFocusCandidates(widgets);
 
     if(currentFocus < 0)
         return;
     currentFocus--;
 
     if(currentFocus >= 0 && currentFocus < widgets.count())
         widgets[currentFocus]->setFocus();
 }
 
 void KrusaderView::focusDown()
 {
     qDebug() << "focus DOWN";
     QVector<QWidget*> widgets;
     int currentFocus = getFocusCandidates(widgets);
 
     if(currentFocus < 0)
         return;
     currentFocus++;
 
     if(currentFocus < widgets.count())
         widgets[currentFocus]->setFocus();
 }
 
 void KrusaderView::cmdLineFocus()    // command line receives keyboard focus
 {
     _cmdLine->setFocus();
 }
 
 void KrusaderView::cmdLineUnFocus()   // return focus to the active panel
 {
     activePanel()->gui->slotFocusOnMe();
 }
 
 // Tab - switch focus
 void KrusaderView::panelSwitch()
 {
     activePanel()->otherPanel()->gui->slotFocusOnMe();
 }
 
 void KrusaderView::slotSetActiveManager(PanelManager *manager)
 {
     activeMng = manager;
     updateCurrentActivePath();
 }
 
 void KrusaderView::swapSides()
 {
     QList<int> lst = horiz_splitter->sizes();
 
     horiz_splitter->addWidget(leftMng);
 
     int old = lst[ 0 ];
     lst[ 0 ] = lst [ 1 ];
     lst[ 1 ] = old;
 
     horiz_splitter->setSizes(lst);
 
     PanelManager *tmpMng = leftMng;
     leftMng = rightMng;
     rightMng = tmpMng;
 
     leftMng->setLeft(true);
     rightMng->setLeft(false);
 
     leftPanel()->updateGeometry();
     rightPanel()->updateGeometry();
 }
 
 void KrusaderView::setTerminalEmulator(bool show, bool fullscreen)
 {
     qDebug() << "show=" << show << " fullscreen=" << fullscreen;
 
     static bool fnKeysShown = true; // first time init. should be overridden
     static bool cmdLineShown = true;
     static bool statusBarShown = true;
     static bool mainToolBarShown = true;
     static bool jobToolBarShown = true;
     static bool actionToolBarShown = true;
     static bool menuBarShown = true;
     static bool terminalEmulatorShown = true;
 
     if (show) {
         if (fullscreen) {
             // save what is shown
             fnKeysShown = !_fnKeys->isHidden();
             cmdLineShown = !_cmdLine->isHidden();
             statusBarShown = !krApp->statusBar()->isHidden();
             mainToolBarShown = !krApp->toolBar()->isHidden();
             jobToolBarShown = !krApp->toolBar("jobToolBar")->isHidden();
             actionToolBarShown = !krApp->toolBar("actionToolBar")->isHidden();
             menuBarShown = !krApp->menuBar()->isHidden();
             terminalEmulatorShown = _terminalDock->isTerminalVisible();
         }
 
         if(!_terminalDock->isTerminalVisible()) {
             // show terminal
             const bool isInitialized = _terminalDock->initialise();
             if (!isInitialized) {
                 _terminalDock->hide();
                 KrActions::actToggleTerminal->setChecked(false);
                 return;
             }
 
             _terminalDock->show();
             _terminalDock->setFocus();
             updateCurrentActivePath();
             KrActions::actToggleTerminal->setChecked(true);
         } else if (fullscreen) {
             // save current terminal size before going to fullscreen
             verticalSplitterSizes = vert_splitter->sizes();
         }
 
         if (fullscreen) {
             // hide everything else
             leftMng->hide();
             rightMng->hide();
             _fnKeys->hide();
             _cmdLine->hide();
             krApp->statusBar()->hide();
             krApp->toolBar()->hide();
             krApp->toolBar("jobToolBar")->hide();
             krApp->toolBar("actionToolBar")->hide();
             krApp->menuBar()->hide();
             // fix showing nothing if terminal is open but splitter widget size is zero
             vert_splitter->setSizes(QList<int>() << 0 << vert_splitter->height());
         } else {
             vert_splitter->setSizes(verticalSplitterSizes);
         }
     } else { // hide
         const bool isFullscreen = isTerminalEmulatorFullscreen();
         if (!(fullscreen && terminalEmulatorShown)) {
             // hide terminal emulator
             activePanel()->gui->slotFocusOnMe();
             if (_terminalDock->isTerminalVisible() && !isFullscreen) {
                 verticalSplitterSizes = vert_splitter->sizes();
             }
             _terminalDock->hide();
             KrActions::actToggleTerminal->setChecked(false);
         } else {
             // not fullscreen anymore but terminal is still visible
             vert_splitter->setSizes(verticalSplitterSizes);
         }
         if (isFullscreen) {
             // restore: unhide everything that was hidden before
             leftMng->show();
             rightMng->show();
             if (fnKeysShown) _fnKeys->show();
             if (cmdLineShown) _cmdLine->show();
             if (statusBarShown) krApp->statusBar()->show();
             if (mainToolBarShown) krApp->toolBar()->show();
             if (jobToolBarShown) krApp->toolBar("jobToolBar")->show();
             if (actionToolBarShown) krApp->toolBar("actionToolBar")->show();
             if (menuBarShown) krApp->menuBar()->show();
         }
     }
 }
 
 void KrusaderView::focusTerminalEmulator()
 {
     if (_terminalDock->isTerminalVisible())
         _terminalDock->setFocus();
 }
 
 void KrusaderView::toggleFullScreenTerminalEmulator()
 {
     setTerminalEmulator(!isTerminalEmulatorFullscreen(), true);
 }
 
 bool KrusaderView::isTerminalEmulatorFullscreen() {
     return leftMng->isHidden() && rightMng->isHidden();
 }
 
-void KrusaderView::profiles(QString profileName)
+void KrusaderView::profiles(const QString& profileName)
 {
     ProfileManager profileManager("Panel", this);
     profileManager.hide();
     connect(&profileManager, &ProfileManager::saveToProfile, this, &KrusaderView::savePanelProfiles);
     connect(&profileManager, &ProfileManager::loadFromProfile, this, &KrusaderView::loadPanelProfiles);
     if (profileName.isEmpty())
         profileManager.profilePopup();
     else
         profileManager.loadProfile(profileName);
 }
 
-void KrusaderView::loadPanelProfiles(QString group)
+void KrusaderView::loadPanelProfiles(const QString& group)
 {
     KConfigGroup ldg(krConfig, group);
     leftMng->loadSettings(KConfigGroup(&ldg, "Left Tabs"));
     rightMng->loadSettings(KConfigGroup(&ldg, "Right Tabs"));
     if (ldg.readEntry("Left Side Is Active", true))
         leftPanel()->slotFocusOnMe();
     else
         rightPanel()->slotFocusOnMe();
 }
 
-void KrusaderView::savePanelProfiles(QString group)
+void KrusaderView::savePanelProfiles(const QString& group)
 {
     KConfigGroup svr(krConfig, group);
 
     svr.writeEntry("Vertical Mode", isVertical());
     svr.writeEntry("Left Side Is Active", activePanel()->gui->isLeft());
     leftMng->saveSettings(KConfigGroup(&svr, "Left Tabs"), false);
     rightMng->saveSettings(KConfigGroup(&svr, "Right Tabs"), false);
 }
 
 void KrusaderView::toggleVerticalMode()
 {
     if (horiz_splitter->orientation() == Qt::Vertical) {
         horiz_splitter->setOrientation(Qt::Horizontal);
         KrActions::actVerticalMode->setText(i18n("Vertical Mode"));
         KrActions::actVerticalMode->setIcon(Icon("view-split-top-bottom"));
     } else {
         horiz_splitter->setOrientation(Qt::Vertical);
         KrActions::actVerticalMode->setText(i18n("Horizontal Mode"));
         KrActions::actVerticalMode->setIcon(Icon("view-split-left-right"));
     }
 }
 
 void KrusaderView::saveSettings(KConfigGroup &cfg)
 {
     QList<int> lst = horiz_splitter->sizes();
     cfg.writeEntry("Splitter Sizes", lst);
     QList<int> vertSplitterSizes = _terminalDock->isVisible() && !isTerminalEmulatorFullscreen()
                                    // fix sizes() not returning correct values on fullscreen+shutdown
                                    && vert_splitter->sizes().first() != 0 ?
                                        vert_splitter->sizes() : verticalSplitterSizes;
     cfg.writeEntry("Terminal Emulator Splitter Sizes", vertSplitterSizes);
     cfg.writeEntry("Vertical Mode", isVertical());
     cfg.writeEntry("Left Side Is Active", activePanel()->gui->isLeft());
     leftMng->saveSettings(KConfigGroup(&cfg, "Left Tab Bar"), true);
     rightMng->saveSettings(KConfigGroup(&cfg, "Right Tab Bar"), true);
 }
 
 bool KrusaderView::cursorIsOnOtherSide(PanelManager *of, const QPoint &globalPos)
 {
     int border = -1;
     int pos = -1;
 
     if (horiz_splitter->orientation() == Qt::Horizontal) {
         pos = globalPos.x();
         if(of == leftMng)
             border = leftMng->mapToGlobal(QPoint(leftMng->width(), 0)).x();
         else
             border = rightMng->mapToGlobal(QPoint(0, 0)).x();
     } else {
         pos = globalPos.y();
         if(of == leftMng)
             border = leftMng->mapToGlobal(QPoint(0, leftMng->height())).y();
         else
             border = rightMng->mapToGlobal(QPoint(0, 0)).y();
     }
 
     return (of == leftMng) ? pos > border : pos < border;
 }
 
 void KrusaderView::draggingTab(PanelManager *from, QMouseEvent *e)
 {
     QString icon;
     if (horiz_splitter->orientation() == Qt::Horizontal)
         icon = (from == leftMng) ? "arrow-right" : "arrow-left";
     else
         icon = (from == leftMng) ? "arrow-down" : "arrow-up";
 
     QCursor cursor(Icon(icon).pixmap(22));
 
     if (cursorIsOnOtherSide(from, e->globalPos())) {
         if(!qApp->overrideCursor())
             qApp->setOverrideCursor(cursor);
     } else
         qApp->restoreOverrideCursor();
 }
 
 void KrusaderView::draggingTabFinished(PanelManager *from, QMouseEvent *e)
 {
     qApp->restoreOverrideCursor();
 
     if (cursorIsOnOtherSide(from, e->globalPos()))
         from->moveTabToOtherSide();
 }
 
diff --git a/krusader/krusaderview.h b/krusader/krusaderview.h
index 102ac800..30683089 100644
--- a/krusader/krusaderview.h
+++ b/krusader/krusaderview.h
@@ -1,112 +1,112 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef KRUSADERVIEW_H
 #define KRUSADERVIEW_H
 
 // QtCore
 #include <QEvent>
 // QtWidgets
 #include <QGridLayout>
 #include <QLayout>
 #include <QPushButton>
 #include <QSplitter>
 #include <QWidget>
 
 #include "krglobal.h"
 
 class PanelManager;
 class ListPanel;
 class KFnKeys;
 class KCMDLine;
 class TerminalDock;
 
 class KrusaderView : public QWidget
 {
     Q_OBJECT
 
 public:
-    explicit KrusaderView(QWidget *parent = 0);
-    virtual ~KrusaderView() {}
+    explicit KrusaderView(QWidget *parent = nullptr);
+    ~KrusaderView() override = default;
     void start(const KConfigGroup &cfg, bool restoreSettings, const QList<QUrl> &leftTabs, const QList<QUrl> &rightTabs);
     void updateGUI(const KConfigGroup &cfg);
     void saveSettings(KConfigGroup &cfg);
     void cmdLineFocus();  // command line receives keyboard focus
     void cmdLineUnFocus();// return focus from command line to active panel
 
     bool isLeftActive() const { return leftMng == activeMng; }
 
     // used by krGlobal macros
     PanelManager *activeManager() const { return activeMng; }
     PanelManager *inactiveManager() const { return activeMng == leftMng ? rightMng : leftMng; }
     PanelManager *leftManager() const { return leftMng; }
     PanelManager *rightManager() const { return rightMng; }
     KrPanel *activePanel() const;
     ListPanel *leftPanel() const;
     ListPanel *rightPanel() const;
 
     KFnKeys *fnKeys() const { return _fnKeys; }
     KCMDLine *cmdLine() const { return _cmdLine; }
     TerminalDock *terminalDock() const { return _terminalDock; }
     bool isVertical() const {
-        return horiz_splitter != 0 ? horiz_splitter->orientation() == Qt::Vertical : false;
+        return horiz_splitter != nullptr ? horiz_splitter->orientation() == Qt::Vertical : false;
     }
     void swapSides();
     void setPanelSize(bool leftPanel, int percent);
     bool isTerminalEmulatorFullscreen();
 
 public slots:
     void slotSetActiveManager(PanelManager *manager);
     void slotPathChanged(ListPanel *listPanel);
     // Tab - switch focus
     void panelSwitch();
     void toggleVerticalMode();
 
     void setTerminalEmulator(bool show, bool fullscreen = false);
     void focusTerminalEmulator();
     void toggleFullScreenTerminalEmulator();
 
     void focusUp();
     void focusDown();
 
-    void profiles(QString profileName = QString());
-    void loadPanelProfiles(QString group);
-    void savePanelProfiles(QString group);
+    void profiles(const QString& profileName = QString());
+    void loadPanelProfiles(const QString& group);
+    void savePanelProfiles(const QString& group);
 
     void draggingTab(PanelManager *from, QMouseEvent *e);
     void draggingTabFinished(PanelManager *from, QMouseEvent *e);
 
 private:
     int getFocusCandidates(QVector<QWidget*> &widgets);
     bool cursorIsOnOtherSide(PanelManager *of, const QPoint &globalPos);
     PanelManager *createManager(bool left);
     void updateCurrentActivePath();
 
     KFnKeys *_fnKeys;            // function keys
     KCMDLine *_cmdLine;          // command line widget
     TerminalDock *_terminalDock; // docking widget for terminal emulator
     QSplitter *horiz_splitter, *vert_splitter;
     QList<int> verticalSplitterSizes;
     PanelManager *activeMng, *leftMng, *rightMng; // saving them for panel swaps
     QGridLayout *mainLayout, *terminal_layout;
 };
 
 #endif
diff --git a/krusader/main.cpp b/krusader/main.cpp
index 0c857df1..b2e6ec63 100644
--- a/krusader/main.cpp
+++ b/krusader/main.cpp
@@ -1,317 +1,317 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include <csignal>
 #include <unistd.h>
 
 // QtCore
 #include <QAbstractEventDispatcher>
 #include <QCommandLineOption>
 #include <QCommandLineParser>
 #include <QDebug>
 #include <QDir>
 #include <QEventLoop>
 #include <QStandardPaths>
 // QtGui
 #include <QPixmap>
 // QtDBus
 #include <QDBusInterface>
 #include <QDBusConnectionInterface>
 // QtWidgets
 #include <QApplication>
 #include <QSplashScreen>
 
 #include <KCoreAddons/KAboutData>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KActionMenu>
 #include <KWindowSystem/KStartupInfo>
 
 #include "../Archive/krarchandler.h"
 
 #include "defaults.h"
 #include "krservices.h"
 #include "krslots.h"
 #include "krusader.h"
 #include "icon.h"
 #include "krusaderversion.h"
 #include "krusaderview.h"
 #include "panelmanager.h"
 
 static const char *description = I18N_NOOP("Krusader\nTwin-Panel File Manager by KDE");
 
 static void sigterm_handler(int i)
 {
     fprintf(stderr, "Signal: %d\n", i);
 
     QAbstractEventDispatcher *instance = QAbstractEventDispatcher::instance();
     if (instance)
         instance->wakeUp();
     QApplication::exit(- 15);
 }
 
-void openTabsRemote(QStringList tabs, bool left, QString appName)
+void openTabsRemote(QStringList tabs, bool left, const QString& appName)
 {
     // make sure left or right are not relative paths
     for (int i = 0; i != tabs.count(); i++) {
         tabs[ i ] = tabs[ i ].trimmed();
         if (!tabs[ i ].startsWith('/') && tabs[ i ].indexOf(":/") < 0)
             tabs[ i ] = QDir::currentPath() + '/' + tabs[ i ];
     }
 
     QDBusInterface remoteApp("org.krusader", "/Instances/" + appName + (left ? "/left_manager" : "/right_manager"),
                              "org.krusader.PanelManager", QDBusConnection::sessionBus());
     QDBusReply<void> reply;
     if (remoteApp.isValid())
         reply = remoteApp.call("newTabs", tabs);
 
     if (!reply.isValid())
         fprintf(stderr, "DBus Error: %s, %s\n", reply.error().name().toLocal8Bit().constData(), reply.error().message().toLocal8Bit().constData());
 }
 
 //! An object that manages archives in several parts of the source code.
 KRarcHandler arcHandler;
 
 int main(int argc, char *argv[])
 {
     // set global log message format
     qSetMessagePattern(KrServices::GLOBAL_MESSAGE_PATTERN);
 
     // prevent qt5-webengine crashing
     QApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
 
     // create the application and set application domain so that calls to i18n get strings from right place.
     QApplication app(argc, argv);
     KLocalizedString::setApplicationDomain("krusader");
 
     // init icon theme
     qDebug() << "System icon theme:" << QIcon::themeName();
     // [WORKAROUND] setThemeName sets user theme in QIconLoader and allows to avoid Qt issues with invalid icon caching later
     // IMPORTANT: this must be done before the first QIcon::fromTheme / QIcon::hasThemeIcon call
     QIcon::setThemeName(QIcon::themeName());
 
     // ABOUT data information
 #ifdef RELEASE_NAME
     QString versionName = QString("%1 \"%2\"").arg(VERSION).arg(RELEASE_NAME);
 #else
     QString versionName = VERSION;
 #endif
 
     KAboutData aboutData(QStringLiteral("krusader"),
         (geteuid() ? i18n("Krusader") : i18n("Krusader - ROOT PRIVILEGES")), versionName,
         i18n(description), KAboutLicense::GPL_V2,
         i18n("© 2000-2003 Shie Erlich, Rafi Yanai\n© 2004-2018 Krusader Krew"),
         i18n("Feedback:\nhttps://forum.kde.org/viewforum.php?f=225\n\nIRC\nserver: "
              "irc.freenode.net, channel: #krusader"),
         QStringLiteral("https://krusader.org"));
 
     aboutData.setOrganizationDomain(QByteArray("kde.org"));
     aboutData.setDesktopFileName(QStringLiteral("org.kde.krusader"));
 
-    aboutData.addAuthor(i18n("Davide Gianforte"), i18n("Developer"), QStringLiteral("davide@gengisdave.org"), 0);
-    aboutData.addAuthor(i18n("Toni Asensi Esteve"), i18n("Developer"), QStringLiteral("toni.asensi@kdemail.net"), 0);
-    aboutData.addAuthor(i18n("Alexander Bikadorov"), i18n("Developer"), QStringLiteral("alex.bikadorov@kdemail.net"), 0);
-    aboutData.addAuthor(i18n("Martin Kostolný"), i18n("Developer"), QStringLiteral("clearmartin@gmail.com"), 0);
-    aboutData.addAuthor(i18n("Nikita Melnichenko"), i18n("Developer"), QStringLiteral("nikita+kde@melnichenko.name"), 0);
-    aboutData.addAuthor(i18n("Yuri Chornoivan"), i18n("Documentation"), QStringLiteral("yurchor@ukr.net"), 0);
+    aboutData.addAuthor(i18n("Davide Gianforte"), i18n("Developer"), QStringLiteral("davide@gengisdave.org"), nullptr);
+    aboutData.addAuthor(i18n("Toni Asensi Esteve"), i18n("Developer"), QStringLiteral("toni.asensi@kdemail.net"), nullptr);
+    aboutData.addAuthor(i18n("Alexander Bikadorov"), i18n("Developer"), QStringLiteral("alex.bikadorov@kdemail.net"), nullptr);
+    aboutData.addAuthor(i18n("Martin Kostolný"), i18n("Developer"), QStringLiteral("clearmartin@gmail.com"), nullptr);
+    aboutData.addAuthor(i18n("Nikita Melnichenko"), i18n("Developer"), QStringLiteral("nikita+kde@melnichenko.name"), nullptr);
+    aboutData.addAuthor(i18n("Yuri Chornoivan"), i18n("Documentation"), QStringLiteral("yurchor@ukr.net"), nullptr);
     aboutData.addAuthor(i18n("Rafi Yanai"), i18n("Author (retired)"), QStringLiteral("yanai@users.sourceforge.net"));
     aboutData.addAuthor(i18n("Shie Erlich"), i18n("Author (retired)"), QStringLiteral("erlich@users.sourceforge.net"));
-    aboutData.addAuthor(i18n("Csaba Karai"), i18n("Developer (retired)"), QStringLiteral("ckarai@users.sourceforge.net"), 0);
-    aboutData.addAuthor(i18n("Heiner Eichmann"), i18n("Developer (retired)"), QStringLiteral("h.eichmann@gmx.de"), 0);
-    aboutData.addAuthor(i18n("Jonas Bähr"), i18n("Developer (retired)"), QStringLiteral("jonas.baehr@web.de"), 0);
-    aboutData.addAuthor(i18n("Václav Jůza"), i18n("Developer (retired)"), QStringLiteral("vaclavjuza@gmail.com"), 0);
-    aboutData.addAuthor(i18n("Jan Lepper"), i18n("Developer (retired)"), QStringLiteral("jan_lepper@gmx.de"), 0);
-    aboutData.addAuthor(i18n("Andrey Matveyakin"), i18n("Developer (retired)"), QStringLiteral("a.matveyakin@gmail.com"), 0);
-    aboutData.addAuthor(i18n("Simon Persson"), i18n("Developer (retired)"), QStringLiteral("simon.persson@mykolab.com"), 0);
-    aboutData.addAuthor(i18n("Dirk Eschler"), i18n("Webmaster (retired)"), QStringLiteral("deschler@users.sourceforge.net"), 0);
-    aboutData.addAuthor(i18n("Frank Schoolmeesters"), i18n("Documentation and marketing coordinator (retired)"), QStringLiteral("frank_schoolmeesters@yahoo.com"), 0);
-    aboutData.addAuthor(i18n("Richard Holt"), i18n("Documentation & Proofing (retired)"), QStringLiteral("richard.holt@gmail.com"), 0);
-    aboutData.addAuthor(i18n("Matej Urbancic"), i18n("Marketing & Product Research (retired)"), QStringLiteral("matej.urban@gmail.com"), 0);
-    aboutData.addCredit(i18n("kde.org"), i18n("Everyone involved in KDE"), 0, 0);
-    aboutData.addCredit(i18n("l10n.kde.org"), i18n("KDE Translation Teams"), 0, 0);
-    aboutData.addCredit(i18n("Jiří Paleček"), i18n("QA, bug-hunting, patches and general help"), QStringLiteral("jpalecek@web.de"), 0);
-    aboutData.addCredit(i18n("Jiří Klement"), i18n("Important help in KDE 4 porting"), 0, 0);
-    aboutData.addCredit(i18n("Andrew Neupokoev"), i18n("Killer Logo and Icons for Krusader (contest winner)"), QStringLiteral("doom-blue@yandex.ru"), 0);
-    aboutData.addCredit(i18n("The UsefulArts Organization"), i18n("Icon for Krusader"), QStringLiteral("mail@usefularts.org"), 0);
-    aboutData.addCredit(i18n("Gábor Lehel"), i18n("Viewer module for 3rd Hand"), QStringLiteral("illissius@gmail.com"), 0);
-    aboutData.addCredit(i18n("Mark Eatough"), i18n("Handbook Proof-Reader"), QStringLiteral("markeatough@yahoo.com"), 0);
-    aboutData.addCredit(i18n("Jan Halasa"), i18n("The old Bookmark Module"), QStringLiteral("xhalasa@fi.muni.cz"), 0);
-    aboutData.addCredit(i18n("Hans Löffler"), i18n("Dir history button"), 0, 0);
-    aboutData.addCredit(i18n("Szombathelyi György"), i18n("ISO KIO slave"), 0, 0);
-    aboutData.addCredit(i18n("Jan Willem van de Meent (Adios)"), i18n("Icons for Krusader"), QStringLiteral("janwillem@lorentz.leidenuniv.nl"), 0);
-    aboutData.addCredit(i18n("Mikolaj Machowski"), i18n("Usability and QA"), QStringLiteral("<mikmach@wp.pl>"), 0);
-    aboutData.addCredit(i18n("Cristi Dumitrescu"), i18n("QA, bug-hunting, patches and general help"), QStringLiteral("cristid@chip.ro"), 0);
-    aboutData.addCredit(i18n("Aurelien Gateau"), i18n("patch for KViewer"), QStringLiteral("aurelien.gateau@free.fr"), 0);
-    aboutData.addCredit(i18n("Milan Brabec"), i18n("the first patch ever!"), QStringLiteral("mbrabec@volny.cz"), 0);
-    aboutData.addCredit(i18n("Asim Husanovic"), i18n("Bosnian translation"), QStringLiteral("asim@megatel.ba"), 0);
-    aboutData.addCredit(i18n("Doutor Zero"), i18n("Brazilian Portuguese translation"), QStringLiteral("doutor.zero@gmail.com"), 0);
-    aboutData.addCredit(i18n("Milen Ivanov"), i18n("Bulgarian translation"), QStringLiteral("milen.ivanov@abv.bg"), 0);
-    aboutData.addCredit(i18n("Quim Perez"), i18n("Catalan translation"), QStringLiteral("noguer@osona.com"), 0);
-    aboutData.addCredit(i18n("Jinghua Luo"), i18n("Chinese Simplified translation"), QStringLiteral("luojinghua@msn.com"), 0);
-    aboutData.addCredit(i18n("Mitek"), i18n("Old Czech translation"), QStringLiteral("mitek@email.cz"), 0);
-    aboutData.addCredit(i18n("Martin Sixta"), i18n("Old Czech translation"), QStringLiteral("lukumo84@seznam.cz"), 0);
-    aboutData.addCredit(i18n("Vaclav Jůza"), i18n("Czech translation"), QStringLiteral("VaclavJuza@gmail.com"), 0);
-    aboutData.addCredit(i18n("Anders Bruun Olsen"), i18n("Old Danish translation"), QStringLiteral("anders@bruun-olsen.net"), 0);
-    aboutData.addCredit(i18n("Peter H. Sorensen"), i18n("Danish translation"), QStringLiteral("peters@skydebanen.net"), 0);
-    aboutData.addCredit(i18n("Frank Schoolmeesters"), i18n("Dutch translation"), QStringLiteral("frank_schoolmeesters@yahoo.com"), 0);
-    aboutData.addCredit(i18n("Rene-Pierre Lehmann"), i18n("Old French translation"), QStringLiteral("ripi@lepi.org"), 0);
-    aboutData.addCredit(i18n("David Guillerm"), i18n("French translation"), QStringLiteral("dguillerm@gmail.com"), 0);
-    aboutData.addCredit(i18n("Christoph Thielecke"), i18n("Old German translation"), QStringLiteral("crissi99@gmx.de"), 0);
-    aboutData.addCredit(i18n("Dirk Eschler"), i18n("German translation"), QStringLiteral("deschler@users.sourceforge.net"), 0);
-    aboutData.addCredit(i18n("Spiros Georgaras"), i18n("Greek translation"), QStringLiteral("sngeorgaras@gmail.com"), 0);
-    aboutData.addCredit(i18n("Kukk Zoltan"), i18n("Old Hungarian translation"), QStringLiteral("kukkzoli@freemail.hu"), 0);
-    aboutData.addCredit(i18n("Arpad Biro"), i18n("Hungarian translation"), QStringLiteral("biro_arpad@yahoo.com"), 0);
-    aboutData.addCredit(i18n("Giuseppe Bordoni"), i18n("Italian translation"), QStringLiteral("geppo@geppozone.com"), 0);
-    aboutData.addCredit(i18n("Hideki Kimura"), i18n("Japanese translation"), QStringLiteral("hangyo1973@gmail.com"), 0);
-    aboutData.addCredit(i18n("UTUMI Hirosi"), i18n("Old Japanese translation"), QStringLiteral("utuhiro@mx12.freecom.ne.jp"), 0);
-    aboutData.addCredit(i18n("Dovydas Sankauskas"), i18n("Lithuanian translation"), QStringLiteral("laisve@gmail.com"), 0);
-    aboutData.addCredit(i18n("Bruno Queiros"), i18n("Portuguese translation"), QStringLiteral("brunoqueiros@portugalmail.com"), 0);
-    aboutData.addCredit(i18n("Lukasz Janyst"), i18n("Old Polish translation"), QStringLiteral("ljan@wp.pl"), 0);
-    aboutData.addCredit(i18n("Pawel Salawa"), i18n("Polish translation"), QStringLiteral("boogie@myslenice.one.pl"), 0);
-    aboutData.addCredit(i18n("Tomek Grzejszczyk"), i18n("Polish translation"), QStringLiteral("tgrzej@onet.eu"), 0);
-    aboutData.addCredit(i18n("Dmitry A. Bugay"), i18n("Russian translation"), QStringLiteral("sam@vhnet.ru"), 0);
-    aboutData.addCredit(i18n("Dmitry Chernyak"), i18n("Old Russian translation"), QStringLiteral("chernyak@mail.ru"), 0);
-    aboutData.addCredit(i18n("Sasa Tomic"), i18n("Serbian translation"), QStringLiteral("stomic@gmx.net"), 0);
-    aboutData.addCredit(i18n("Zdenko Podobný and Ondrej Pačay (Yogi)"), i18n("Slovak translation"), QStringLiteral("zdenop@gmail.com"), 0);
-    aboutData.addCredit(i18n("Matej Urbancic"), i18n("Slovenian translation"), QStringLiteral("matej.urban@gmail.com"), 0);
-    aboutData.addCredit(i18n("Rafael Munoz"), i18n("Old Spanish translation"), QStringLiteral("muror@hotpop.com"), 0);
-    aboutData.addCredit(i18n("Alejandro Araiza Alvarado"), i18n("Spanish translation"), QStringLiteral("mebrelith@gmail.com"), 0);
-    aboutData.addCredit(i18n("Erik Johanssen"), i18n("Old Swedish translation"), QStringLiteral("erre@telia.com"), 0);
-    aboutData.addCredit(i18n("Anders Linden"), i18n("Old Swedish translation"), QStringLiteral("connyosis@gmx.net"), 0);
-    aboutData.addCredit(i18n("Peter Landgren"), i18n("Swedish translation"), QStringLiteral("peter.talken@telia.com"), 0);
-    aboutData.addCredit(i18n("Bekir Sonat"), i18n("Turkish translation"), QStringLiteral("bekirsonat@kde.org.tr"), 0);
-    aboutData.addCredit(i18n("Ivan Petrouchtchak"), i18n("Ukrainian translation"), QStringLiteral("connyosis@gmx.net"), 0);
-    aboutData.addCredit(i18n("Seongnam Jee"), i18n("Korean translation"), QStringLiteral("snjee@intellicam.com"), 0);
+    aboutData.addAuthor(i18n("Csaba Karai"), i18n("Developer (retired)"), QStringLiteral("ckarai@users.sourceforge.net"), nullptr);
+    aboutData.addAuthor(i18n("Heiner Eichmann"), i18n("Developer (retired)"), QStringLiteral("h.eichmann@gmx.de"), nullptr);
+    aboutData.addAuthor(i18n("Jonas Bähr"), i18n("Developer (retired)"), QStringLiteral("jonas.baehr@web.de"), nullptr);
+    aboutData.addAuthor(i18n("Václav Jůza"), i18n("Developer (retired)"), QStringLiteral("vaclavjuza@gmail.com"), nullptr);
+    aboutData.addAuthor(i18n("Jan Lepper"), i18n("Developer (retired)"), QStringLiteral("jan_lepper@gmx.de"), nullptr);
+    aboutData.addAuthor(i18n("Andrey Matveyakin"), i18n("Developer (retired)"), QStringLiteral("a.matveyakin@gmail.com"), nullptr);
+    aboutData.addAuthor(i18n("Simon Persson"), i18n("Developer (retired)"), QStringLiteral("simon.persson@mykolab.com"), nullptr);
+    aboutData.addAuthor(i18n("Dirk Eschler"), i18n("Webmaster (retired)"), QStringLiteral("deschler@users.sourceforge.net"), nullptr);
+    aboutData.addAuthor(i18n("Frank Schoolmeesters"), i18n("Documentation and marketing coordinator (retired)"), QStringLiteral("frank_schoolmeesters@yahoo.com"), nullptr);
+    aboutData.addAuthor(i18n("Richard Holt"), i18n("Documentation & Proofing (retired)"), QStringLiteral("richard.holt@gmail.com"), nullptr);
+    aboutData.addAuthor(i18n("Matej Urbancic"), i18n("Marketing & Product Research (retired)"), QStringLiteral("matej.urban@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("kde.org"), i18n("Everyone involved in KDE"), nullptr, nullptr);
+    aboutData.addCredit(i18n("l10n.kde.org"), i18n("KDE Translation Teams"), nullptr, nullptr);
+    aboutData.addCredit(i18n("Jiří Paleček"), i18n("QA, bug-hunting, patches and general help"), QStringLiteral("jpalecek@web.de"), nullptr);
+    aboutData.addCredit(i18n("Jiří Klement"), i18n("Important help in KDE 4 porting"), nullptr, nullptr);
+    aboutData.addCredit(i18n("Andrew Neupokoev"), i18n("Killer Logo and Icons for Krusader (contest winner)"), QStringLiteral("doom-blue@yandex.ru"), nullptr);
+    aboutData.addCredit(i18n("The UsefulArts Organization"), i18n("Icon for Krusader"), QStringLiteral("mail@usefularts.org"), nullptr);
+    aboutData.addCredit(i18n("Gábor Lehel"), i18n("Viewer module for 3rd Hand"), QStringLiteral("illissius@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Mark Eatough"), i18n("Handbook Proof-Reader"), QStringLiteral("markeatough@yahoo.com"), nullptr);
+    aboutData.addCredit(i18n("Jan Halasa"), i18n("The old Bookmark Module"), QStringLiteral("xhalasa@fi.muni.cz"), nullptr);
+    aboutData.addCredit(i18n("Hans Löffler"), i18n("Dir history button"), nullptr, nullptr);
+    aboutData.addCredit(i18n("Szombathelyi György"), i18n("ISO KIO slave"), nullptr, nullptr);
+    aboutData.addCredit(i18n("Jan Willem van de Meent (Adios)"), i18n("Icons for Krusader"), QStringLiteral("janwillem@lorentz.leidenuniv.nl"), nullptr);
+    aboutData.addCredit(i18n("Mikolaj Machowski"), i18n("Usability and QA"), QStringLiteral("<mikmach@wp.pl>"), nullptr);
+    aboutData.addCredit(i18n("Cristi Dumitrescu"), i18n("QA, bug-hunting, patches and general help"), QStringLiteral("cristid@chip.ro"), nullptr);
+    aboutData.addCredit(i18n("Aurelien Gateau"), i18n("patch for KViewer"), QStringLiteral("aurelien.gateau@free.fr"), nullptr);
+    aboutData.addCredit(i18n("Milan Brabec"), i18n("the first patch ever!"), QStringLiteral("mbrabec@volny.cz"), nullptr);
+    aboutData.addCredit(i18n("Asim Husanovic"), i18n("Bosnian translation"), QStringLiteral("asim@megatel.ba"), nullptr);
+    aboutData.addCredit(i18n("Doutor Zero"), i18n("Brazilian Portuguese translation"), QStringLiteral("doutor.zero@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Milen Ivanov"), i18n("Bulgarian translation"), QStringLiteral("milen.ivanov@abv.bg"), nullptr);
+    aboutData.addCredit(i18n("Quim Perez"), i18n("Catalan translation"), QStringLiteral("noguer@osona.com"), nullptr);
+    aboutData.addCredit(i18n("Jinghua Luo"), i18n("Chinese Simplified translation"), QStringLiteral("luojinghua@msn.com"), nullptr);
+    aboutData.addCredit(i18n("Mitek"), i18n("Old Czech translation"), QStringLiteral("mitek@email.cz"), nullptr);
+    aboutData.addCredit(i18n("Martin Sixta"), i18n("Old Czech translation"), QStringLiteral("lukumo84@seznam.cz"), nullptr);
+    aboutData.addCredit(i18n("Vaclav Jůza"), i18n("Czech translation"), QStringLiteral("VaclavJuza@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Anders Bruun Olsen"), i18n("Old Danish translation"), QStringLiteral("anders@bruun-olsen.net"), nullptr);
+    aboutData.addCredit(i18n("Peter H. Sorensen"), i18n("Danish translation"), QStringLiteral("peters@skydebanen.net"), nullptr);
+    aboutData.addCredit(i18n("Frank Schoolmeesters"), i18n("Dutch translation"), QStringLiteral("frank_schoolmeesters@yahoo.com"), nullptr);
+    aboutData.addCredit(i18n("Rene-Pierre Lehmann"), i18n("Old French translation"), QStringLiteral("ripi@lepi.org"), nullptr);
+    aboutData.addCredit(i18n("David Guillerm"), i18n("French translation"), QStringLiteral("dguillerm@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Christoph Thielecke"), i18n("Old German translation"), QStringLiteral("crissi99@gmx.de"), nullptr);
+    aboutData.addCredit(i18n("Dirk Eschler"), i18n("German translation"), QStringLiteral("deschler@users.sourceforge.net"), nullptr);
+    aboutData.addCredit(i18n("Spiros Georgaras"), i18n("Greek translation"), QStringLiteral("sngeorgaras@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Kukk Zoltan"), i18n("Old Hungarian translation"), QStringLiteral("kukkzoli@freemail.hu"), nullptr);
+    aboutData.addCredit(i18n("Arpad Biro"), i18n("Hungarian translation"), QStringLiteral("biro_arpad@yahoo.com"), nullptr);
+    aboutData.addCredit(i18n("Giuseppe Bordoni"), i18n("Italian translation"), QStringLiteral("geppo@geppozone.com"), nullptr);
+    aboutData.addCredit(i18n("Hideki Kimura"), i18n("Japanese translation"), QStringLiteral("hangyo1973@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("UTUMI Hirosi"), i18n("Old Japanese translation"), QStringLiteral("utuhiro@mx12.freecom.ne.jp"), nullptr);
+    aboutData.addCredit(i18n("Dovydas Sankauskas"), i18n("Lithuanian translation"), QStringLiteral("laisve@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Bruno Queiros"), i18n("Portuguese translation"), QStringLiteral("brunoqueiros@portugalmail.com"), nullptr);
+    aboutData.addCredit(i18n("Lukasz Janyst"), i18n("Old Polish translation"), QStringLiteral("ljan@wp.pl"), nullptr);
+    aboutData.addCredit(i18n("Pawel Salawa"), i18n("Polish translation"), QStringLiteral("boogie@myslenice.one.pl"), nullptr);
+    aboutData.addCredit(i18n("Tomek Grzejszczyk"), i18n("Polish translation"), QStringLiteral("tgrzej@onet.eu"), nullptr);
+    aboutData.addCredit(i18n("Dmitry A. Bugay"), i18n("Russian translation"), QStringLiteral("sam@vhnet.ru"), nullptr);
+    aboutData.addCredit(i18n("Dmitry Chernyak"), i18n("Old Russian translation"), QStringLiteral("chernyak@mail.ru"), nullptr);
+    aboutData.addCredit(i18n("Sasa Tomic"), i18n("Serbian translation"), QStringLiteral("stomic@gmx.net"), nullptr);
+    aboutData.addCredit(i18n("Zdenko Podobný and Ondrej Pačay (Yogi)"), i18n("Slovak translation"), QStringLiteral("zdenop@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Matej Urbancic"), i18n("Slovenian translation"), QStringLiteral("matej.urban@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Rafael Munoz"), i18n("Old Spanish translation"), QStringLiteral("muror@hotpop.com"), nullptr);
+    aboutData.addCredit(i18n("Alejandro Araiza Alvarado"), i18n("Spanish translation"), QStringLiteral("mebrelith@gmail.com"), nullptr);
+    aboutData.addCredit(i18n("Erik Johanssen"), i18n("Old Swedish translation"), QStringLiteral("erre@telia.com"), nullptr);
+    aboutData.addCredit(i18n("Anders Linden"), i18n("Old Swedish translation"), QStringLiteral("connyosis@gmx.net"), nullptr);
+    aboutData.addCredit(i18n("Peter Landgren"), i18n("Swedish translation"), QStringLiteral("peter.talken@telia.com"), nullptr);
+    aboutData.addCredit(i18n("Bekir Sonat"), i18n("Turkish translation"), QStringLiteral("bekirsonat@kde.org.tr"), nullptr);
+    aboutData.addCredit(i18n("Ivan Petrouchtchak"), i18n("Ukrainian translation"), QStringLiteral("connyosis@gmx.net"), nullptr);
+    aboutData.addCredit(i18n("Seongnam Jee"), i18n("Korean translation"), QStringLiteral("snjee@intellicam.com"), nullptr);
 
     // This will call QCoreApplication::setApplicationName, etc for us by using info in the KAboutData instance.
     // The only thing not called for us is setWindowIcon(), which is why we do it ourselves here.
     KAboutData::setApplicationData(aboutData);
     app.setWindowIcon(Icon(Krusader::appIconName()));
 
     // Command line arguments ...
     QCommandLineParser parser;
     aboutData.setupCommandLine(&parser);
     parser.addOption(QCommandLineOption(QStringList() << QLatin1String("left"), i18n("Start left panel at <path>"), QLatin1String("path")));
     parser.addOption(QCommandLineOption(QStringList() << QLatin1String("right"), i18n("Start right panel at <path>"), QLatin1String("path")));
     parser.addOption(QCommandLineOption(QStringList() << QLatin1String("profile"), i18n("Load this profile on startup"), QLatin1String("panel-profile")));
     parser.addOption(QCommandLineOption(QStringList() << "d" << QLatin1String("debug"), i18n("Enable debug output")));
     parser.addPositionalArgument(QLatin1String("url"), i18n("URL to open"));
 
     // check for command line arguments
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     // set global message handler
     KrServices::setGlobalKrMessageHandler(parser.isSet("debug"));
 
     KConfigGroup cfg(KSharedConfig::openConfig(), QStringLiteral("Look&Feel"));
     bool singleInstanceMode = cfg.readEntry("Single Instance Mode", _SingleInstanceMode);
 
     QString url;
     if(!parser.positionalArguments().isEmpty()) {
         url = parser.positionalArguments().first();
     }
 
     QString appName = "krusader";
     if (!singleInstanceMode)
         appName += QString("%1").arg(getpid());
 
     if (!QDBusConnection::sessionBus().isConnected()) {
         fprintf(stderr, "Cannot connect to the D-BUS session bus.\n"
                 "To start it, run:\n"
                 "\teval `dbus-launch --auto-syntax`\n");
     }
 
     if (singleInstanceMode) {
         QDBusInterface remoteApp("org.krusader", "/Instances/" + appName,
                                 "org.krusader.Instance", QDBusConnection::sessionBus());
         QDBusReply<bool> reply;
         if (remoteApp.isValid())
             reply = remoteApp.call("isRunning");
 
         if (!reply.isValid() && reply.error().type() != QDBusError::ServiceUnknown &&
                 reply.error().type() != QDBusError::UnknownObject)
             fprintf(stderr, "DBus Error: %s, %s\n", reply.error().name().toLocal8Bit().constData(), reply.error().message().toLocal8Bit().constData());
 
         if (reply.isValid() && (bool)reply) {
             KStartupInfo::appStarted();
             if (parser.isSet("left"))
                 openTabsRemote(parser.value("left").split(','), true, appName);
             if (parser.isSet("right"))
                 openTabsRemote(parser.value("right").split(','), false, appName);
             if(!url.isEmpty()) {
                 reply = remoteApp.call("openUrl", url);
                 if (!reply.isValid())
                     fprintf(stderr, "DBus Error: %s, %s\n", reply.error().name().toLocal8Bit().constData(), reply.error().message().toLocal8Bit().constData());
             }
             return 0;
         }
     }
 
     // splash screen - if the user wants one
-    QSplashScreen *splash = 0;
+    QSplashScreen *splash = nullptr;
     { // don't remove bracket
         KConfigGroup cfg(KSharedConfig::openConfig(), QStringLiteral("Look&Feel"));
         if (cfg.readEntry("Show splashscreen", _ShowSplashScreen)) {
             QString splashFilename = QStandardPaths::locate(QStandardPaths::DataLocation, QStringLiteral("splash.png"));
             QPixmap pixmap(splashFilename);
             if (!pixmap.isNull()) {
                 splash = new QSplashScreen(pixmap);
                 splash->show();
             }
         }
     } // don't remove bracket
 
     Krusader::AppName = appName;
-    Krusader *krusader = new Krusader(parser);
+    auto *krusader = new Krusader(parser);
 
     if(!url.isEmpty())
         krusader->openUrl(url);
 
     QDBusConnection dbus = QDBusConnection::sessionBus();
     if (!dbus.interface()->isServiceRegistered("org.krusader") && !dbus.registerService("org.krusader")) {
         fprintf(stderr, "DBus Error: %s, %s\n", dbus.lastError().name().toLocal8Bit().constData(), dbus.lastError().message().toLocal8Bit().constData());
     }
     if (!dbus.registerObject("/Instances/" + appName, krusader, QDBusConnection::ExportScriptableSlots)) {
         fprintf(stderr, "DBus Error: %s, %s\n", dbus.lastError().name().toLocal8Bit().constData(), dbus.lastError().message().toLocal8Bit().constData());
     }
     if (!dbus.registerObject("/Instances/" + appName + "/left_manager", LEFT_MNG, QDBusConnection::ExportScriptableSlots)) {
         fprintf(stderr, "DBus Error: %s, %s\n", dbus.lastError().name().toLocal8Bit().constData(), dbus.lastError().message().toLocal8Bit().constData());
     }
     if (!dbus.registerObject("/Instances/" + appName + "/right_manager", RIGHT_MNG, QDBusConnection::ExportScriptableSlots)) {
         fprintf(stderr, "DBus Error: %s, %s\n", dbus.lastError().name().toLocal8Bit().constData(), dbus.lastError().message().toLocal8Bit().constData());
     }
 
     // catching SIGTERM, SIGHUP, SIGQUIT
     signal(SIGTERM, sigterm_handler);
     signal(SIGPIPE, sigterm_handler);
     signal(SIGHUP, sigterm_handler);
 
     QObject::connect(&app, &QGuiApplication::applicationStateChanged, SLOTS, &KRslots::applicationStateChanged);
 
     // hide splashscreen
     if (splash) {
         splash->finish(krusader);
         delete splash;
     }
     // let's go.
     return app.exec();
 }
diff --git a/krusader/panelmanager.cpp b/krusader/panelmanager.cpp
index de6f6381..73454244 100644
--- a/krusader/panelmanager.cpp
+++ b/krusader/panelmanager.cpp
@@ -1,462 +1,462 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "panelmanager.h"
 
 #include "defaults.h"
 #include "icon.h"
 #include "tabactions.h"
 #include "krusaderview.h"
 #include "krmainwindow.h"
 #include "Panel/listpanel.h"
 #include "Panel/panelfunc.h"
 #include "Panel/PanelView/krviewfactory.h"
 
 #include <assert.h>
 
 // QtGui
 #include <QImage>
 // QtWidgets
 #include <QStackedWidget>
 #include <QToolButton>
 #include <QGridLayout>
 
 #include <KConfigCore/KConfig>
 #include <KI18n/KLocalizedString>
 
 
 PanelManager::PanelManager(QWidget *parent, KrMainWindow* mainWindow, bool left) :
         QWidget(parent),
-        _otherManager(0),
+        _otherManager(nullptr),
         _actions(mainWindow->tabActions()),
-        _layout(0),
+        _layout(nullptr),
         _left(left),
-        _currentPanel(0)
+        _currentPanel(nullptr)
 {
     _layout = new QGridLayout(this);
     _layout->setContentsMargins(0, 0, 0, 0);
     _layout->setSpacing(0);
     _stack = new QStackedWidget(this);
 
     // new tab button
     _newTab = new QToolButton(this);
     _newTab->setAutoRaise(true);
     _newTab->setText(i18n("Open a new tab in home"));
     _newTab->setToolTip(i18n("Open a new tab in home"));
     _newTab->setIcon(Icon("tab-new"));
     _newTab->adjustSize();
     connect(_newTab, &QToolButton::clicked, this, QOverload<>::of(&PanelManager::slotNewTab));
 
     // tab-bar
     _tabbar = new PanelTabBar(this, _actions);
     connect(_tabbar, &PanelTabBar::currentChanged, this, &PanelManager::slotCurrentTabChanged);
     connect(_tabbar, &PanelTabBar::tabCloseRequested, this, QOverload<int>::of(&PanelManager::slotCloseTab));
     connect(_tabbar, &PanelTabBar::closeCurrentTab, this, QOverload<>::of(&PanelManager::slotCloseTab));
     connect(_tabbar, &PanelTabBar::newTab, this, [=] (const QUrl &url) { slotNewTab(url); });
     connect(_tabbar, &PanelTabBar::draggingTab, this, &PanelManager::slotDraggingTab);
     connect(_tabbar, &PanelTabBar::draggingTabFinished, this, &PanelManager::slotDraggingTabFinished);
 
-    QHBoxLayout *tabbarLayout = new QHBoxLayout;
+    auto *tabbarLayout = new QHBoxLayout;
     tabbarLayout->setSpacing(0);
     tabbarLayout->setContentsMargins(0, 0, 0, 0);
 
     tabbarLayout->addWidget(_tabbar);
     tabbarLayout->addWidget(_newTab);
 
     _layout->addWidget(_stack, 0, 0);
     _layout->addLayout(tabbarLayout, 1, 0);
 
     updateTabbarPos();
 
     setLayout(_layout);
 
     addPanel(true);
 
     tabsCountChanged();
 }
 
 void PanelManager::tabsCountChanged()
 {
     const KConfigGroup cfg(krConfig, "Look&Feel");
     const bool showTabbar = _tabbar->count() > 1 || cfg.readEntry("Show Tab Bar On Single Tab", true);
     const bool showButtons = showTabbar && cfg.readEntry("Show Tab Buttons", true);
 
     _tabbar->setVisible(showTabbar);
     _newTab->setVisible(showButtons);
 
     // disable close button if only 1 tab is left
     _tabbar->setTabsClosable(showButtons && _tabbar->count() > 1);
 
     _actions->refreshActions();
 }
 
 void PanelManager::activate()
 {
     assert(sender() == (currentPanel()->gui));
     emit setActiveManager(this);
     _actions->refreshActions();
 }
 
 void PanelManager::slotCurrentTabChanged(int index)
 {
     ListPanel *panel = _tabbar->getPanel(index);
 
     if (!panel || panel == _currentPanel)
         return;
 
     ListPanel *previousPanel = _currentPanel;
     _currentPanel = panel;
 
     _stack->setCurrentWidget(_currentPanel);
 
     if (previousPanel) {
         previousPanel->slotFocusOnMe(false); // FIXME - necessary ?
     }
     _currentPanel->slotFocusOnMe(this == ACTIVE_MNG);
 
     emit pathChanged(panel);
 
     if (otherManager()) {
         otherManager()->currentPanel()->otherPanelChanged();
     }
 
     // go back to pinned url if tab is pinned and switched back to active
     if (panel->isPinned()) {
         panel->func->openUrl(panel->pinnedUrl());
     }
 }
 
-ListPanel* PanelManager::createPanel(KConfigGroup cfg)
+ListPanel* PanelManager::createPanel(const KConfigGroup& cfg)
 {
     ListPanel * p = new ListPanel(_stack, this, cfg);
     connectPanel(p);
     return p;
 }
 
 void PanelManager::connectPanel(ListPanel *p)
 {
     connect(p, &ListPanel::activate, this, &PanelManager::activate);
     connect(p, &ListPanel::pathChanged, this, [=]() { pathChanged(p); });
     connect(p, &ListPanel::pathChanged, this, [=]() { _tabbar->updateTab(p); });
 }
 
 void PanelManager::disconnectPanel(ListPanel *p)
 {
     disconnect(p, &ListPanel::activate, this, nullptr);
     disconnect(p, &ListPanel::pathChanged, this, nullptr);
 }
 
-ListPanel* PanelManager::addPanel(bool setCurrent, KConfigGroup cfg, KrPanel *nextTo)
+ListPanel* PanelManager::addPanel(bool setCurrent, const KConfigGroup& cfg, KrPanel *nextTo)
 {
     // create the panel and add it into the widgetstack
     ListPanel * p = createPanel(cfg);
     _stack->addWidget(p);
 
     // now, create the corresponding tab
     int index = _tabbar->addPanel(p, setCurrent, nextTo);
     tabsCountChanged();
 
     if (setCurrent)
         slotCurrentTabChanged(index);
 
     return p;
 }
 
 void PanelManager::saveSettings(KConfigGroup config, bool saveHistory)
 {
     config.writeEntry("ActiveTab", activeTab());
 
     KConfigGroup grpTabs(&config, "Tabs");
     foreach(const QString &grpTab, grpTabs.groupList())
         grpTabs.deleteGroup(grpTab);
 
     for(int i = 0; i < _tabbar->count(); i++) {
         ListPanel *panel = _tabbar->getPanel(i);
         KConfigGroup grpTab(&grpTabs, "Tab" + QString::number(i));
         panel->saveSettings(grpTab, saveHistory);
     }
 }
 
 void PanelManager::loadSettings(KConfigGroup config)
 {
     KConfigGroup grpTabs(&config, "Tabs");
     int numTabsOld = _tabbar->count();
     int numTabsNew = grpTabs.groupList().count();
 
     for(int i = 0;  i < numTabsNew; i++) {
         KConfigGroup grpTab(&grpTabs, "Tab" + QString::number(i));
         // TODO workaround for bug 371453. Remove this when bug is fixed
         if (grpTab.keyList().isEmpty())
             continue;
 
         ListPanel *panel = i < numTabsOld ? _tabbar->getPanel(i) : addPanel(false, grpTab);
         panel->restoreSettings(grpTab);
         _tabbar->updateTab(panel);
     }
 
     for(int i = numTabsOld - 1; i >= numTabsNew && i > 0; i--)
         slotCloseTab(i);
 
     setActiveTab(config.readEntry("ActiveTab", 0));
 
     // this is needed so that all tab labels get updated
     layoutTabs();
 }
 
 void PanelManager::layoutTabs()
 {
     // delayed url refreshes may be pending -
     // delay the layout too so it happens after them
     QTimer::singleShot(0, _tabbar, &PanelTabBar::layoutTabs);
 }
 
 KrPanel *PanelManager::currentPanel() const {
     return _currentPanel;
 }
 
 void PanelManager::moveTabToOtherSide()
 {
     if (tabCount() < 2)
         return;
 
     ListPanel *p;
     _tabbar->removeCurrentPanel(p);
     _stack->removeWidget(p);
     disconnectPanel(p);
 
     p->reparent(_otherManager->_stack, _otherManager);
     _otherManager->connectPanel(p);
     _otherManager->_stack->addWidget(p);
     _otherManager->_tabbar->addPanel(p, true);
 
     _otherManager->tabsCountChanged();
     tabsCountChanged();
 
     p->slotFocusOnMe();
 }
 
 void PanelManager::slotNewTab(const QUrl &url, bool setCurrent, KrPanel *nextTo)
 {
     ListPanel *p = addPanel(setCurrent, KConfigGroup(), nextTo);
     if(nextTo && nextTo->gui) {
         // We duplicate tab settings by writing original settings to a temporary
         // group and making the new tab read settings from it. Duplicating
         // settings directly would add too much complexity.
         QString grpName = "PanelManager_" + QString::number(qApp->applicationPid());
         krConfig->deleteGroup(grpName); // make sure the group is empty
         KConfigGroup cfg(krConfig, grpName);
 
         nextTo->gui->saveSettings(cfg, true);
         // reset undesired duplicated settings
         cfg.writeEntry("Properties", 0);
         p->restoreSettings(cfg);
         krConfig->deleteGroup(grpName);
     }
     p->start(url);
 }
 
 void PanelManager::slotNewTab()
 {
     slotNewTab(QUrl::fromLocalFile(QDir::home().absolutePath()));
     _currentPanel->slotFocusOnMe();
 }
 
 void PanelManager::slotCloseTab()
 {
     slotCloseTab(_tabbar->currentIndex());
 }
 
 void PanelManager::slotCloseTab(int index)
 {
     if (_tabbar->count() <= 1)    /* if this is the last tab don't close it */
         return;
 
     ListPanel *oldp;
 
     _tabbar->removePanel(index, oldp); //this automatically changes the current panel
 
     _stack->removeWidget(oldp);
     deletePanel(oldp);
     tabsCountChanged();
 }
 
 void PanelManager::updateTabbarPos()
 {
     KConfigGroup group(krConfig, "Look&Feel");
     if(group.readEntry("Tab Bar Position", "bottom") == "top") {
         _layout->addWidget(_stack, 2, 0);
         _tabbar->setShape(QTabBar::RoundedNorth);
     } else {
         _layout->addWidget(_stack, 0, 0);
         _tabbar->setShape(QTabBar::RoundedSouth);
     }
 }
 
 int PanelManager::activeTab()
 {
     return _tabbar->currentIndex();
 }
 
 void PanelManager::setActiveTab(int index)
 {
     _tabbar->setCurrentIndex(index);
 }
 
 void PanelManager::slotRecreatePanels()
 {
     updateTabbarPos();
 
     for (int i = 0; i != _tabbar->count(); i++) {
         QString grpName = "PanelManager_" + QString::number(qApp->applicationPid());
         krConfig->deleteGroup(grpName); // make sure the group is empty
         KConfigGroup cfg(krConfig, grpName);
 
         ListPanel *oldPanel = _tabbar->getPanel(i);
         oldPanel->saveSettings(cfg, true);
         disconnect(oldPanel);
 
         ListPanel *newPanel = createPanel(cfg);
         _stack->insertWidget(i, newPanel);
         _tabbar->changePanel(i, newPanel);
 
         if (_currentPanel == oldPanel) {
             _currentPanel = newPanel;
             _stack->setCurrentWidget(_currentPanel);
         }
 
         _stack->removeWidget(oldPanel);
         deletePanel(oldPanel);
 
         newPanel->restoreSettings(cfg);
 
         _tabbar->updateTab(newPanel);
 
         krConfig->deleteGroup(grpName);
     }
     tabsCountChanged();
     _currentPanel->slotFocusOnMe(this == ACTIVE_MNG);
     emit pathChanged(_currentPanel);
 }
 
 void PanelManager::slotNextTab()
 {
     int currTab = _tabbar->currentIndex();
     int nextInd = (currTab == _tabbar->count() - 1 ? 0 : currTab + 1);
     _tabbar->setCurrentIndex(nextInd);
 }
 
 
 void PanelManager::slotPreviousTab()
 {
     int currTab = _tabbar->currentIndex();
     int nextInd = (currTab == 0 ? _tabbar->count() - 1 : currTab - 1);
     _tabbar->setCurrentIndex(nextInd);
 }
 
 void PanelManager::reloadConfig()
 {
     for (int i = 0; i < _tabbar->count(); i++) {
         ListPanel *panel = _tabbar->getPanel(i);
         if (panel) {
             panel->func->refresh();
         }
     }
 }
 
 void PanelManager::deletePanel(ListPanel * p)
 {
     disconnect(p);
     delete p;
 }
 
 void PanelManager::slotCloseInactiveTabs()
 {
     int i = 0;
     while (i < _tabbar->count()) {
         if (i == activeTab())
             i++;
         else
             slotCloseTab(i);
     }
 }
 
 void PanelManager::slotCloseDuplicatedTabs()
 {
     int i = 0;
     while (i < _tabbar->count() - 1) {
         ListPanel * panel1 = _tabbar->getPanel(i);
-        if (panel1 != 0) {
+        if (panel1 != nullptr) {
             for (int j = i + 1; j < _tabbar->count(); j++) {
                 ListPanel * panel2 = _tabbar->getPanel(j);
-                if (panel2 != 0 && panel1->virtualPath().matches(panel2->virtualPath(), QUrl::StripTrailingSlash)) {
+                if (panel2 != nullptr && panel1->virtualPath().matches(panel2->virtualPath(), QUrl::StripTrailingSlash)) {
                     if (j == activeTab()) {
                         slotCloseTab(i);
                         i--;
                         break;
                     } else {
                         slotCloseTab(j);
                         j--;
                     }
                 }
             }
         }
         i++;
     }
 }
 
 int PanelManager::findTab(QUrl url)
 {
     url.setPath(QDir::cleanPath(url.path()));
     for(int i = 0; i < _tabbar->count(); i++) {
         if(_tabbar->getPanel(i)) {
             QUrl panelUrl = _tabbar->getPanel(i)->virtualPath();
             panelUrl.setPath(QDir::cleanPath(panelUrl.path()));
             if(panelUrl.matches(url, QUrl::StripTrailingSlash))
                 return i;
         }
     }
     return -1;
 }
 
 void PanelManager::slotLockTab()
 {
     ListPanel *panel = _currentPanel;
     panel->gui->setTabState(panel->gui->isLocked() ? ListPanel::TabState::DEFAULT : ListPanel::TabState::LOCKED);
     _actions->refreshActions();
     _tabbar->updateTab(panel);
 }
 
 void PanelManager::slotPinTab()
 {
     ListPanel *panel = _currentPanel;
     panel->gui->setTabState(panel->gui->isPinned() ? ListPanel::TabState::DEFAULT : ListPanel::TabState::PINNED);
     if (panel->gui->isPinned()) {
         QUrl virtualPath = panel->virtualPath();
         panel->setPinnedUrl(virtualPath);
     }
     _actions->refreshActions();
     _tabbar->updateTab(panel);
 }
 
 void PanelManager::newTabs(const QStringList& urls) {
     for(int i = 0; i < urls.count(); i++)
         slotNewTab(QUrl::fromUserInput(urls[i], QString(), QUrl::AssumeLocalFile));
 }
diff --git a/krusader/panelmanager.h b/krusader/panelmanager.h
index 690287fc..9793aa92 100644
--- a/krusader/panelmanager.h
+++ b/krusader/panelmanager.h
@@ -1,147 +1,147 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef PANELMANAGER_H
 #define PANELMANAGER_H
 
 #include "abstractpanelmanager.h"
 
 // QtWidgets
 #include <QWidget>
 #include <QLayout>
 #include <QGridLayout>
 #include <QHBoxLayout>
 
 #include <KConfigCore/KConfigGroup>
 
 #include "paneltabbar.h"
 
 class QStackedWidget;
 class QToolButton;
 class ListPanel;
 class KrMainWindow;
 class TabActions;
 
 /**
  * Implements tabbed-browsing by managing a list of tabs and corresponding panels.
  */
 class PanelManager: public QWidget, public AbstractPanelManager
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.krusader.PanelManager")
 
 public:
     /**
      * PanelManager is created where once panels were created. It accepts three references to pointers
      * (self, other, active), which enables it to manage pointers held by the panels transparently.
      * It also receives a bool (left) which is true if the manager is the left one, or false otherwise.
      */
     PanelManager(QWidget *parent, KrMainWindow* mainWindow, bool left);
 
     void saveSettings(KConfigGroup config, bool saveHistory);
     void loadSettings(KConfigGroup config);
     int findTab(QUrl url);
     int tabCount() {
         return _tabbar->count();
     }
     int activeTab();
     void setActiveTab(int index);
     void moveTabToOtherSide();
     /** Refresh all tabs after config changes. */
     void reloadConfig();
     void layoutTabs();
     void setLeft(bool left) {
         _left = left;
     }
     void setOtherManager(PanelManager *other) {
         _otherManager = other;
     }
 
     // AbstractPanelManager implementation
-    virtual bool isLeft() const Q_DECL_OVERRIDE { return _left; }
-    virtual AbstractPanelManager *otherManager() const Q_DECL_OVERRIDE { return _otherManager; }
-    virtual KrPanel *currentPanel() const Q_DECL_OVERRIDE;
-    virtual void newTab(const QUrl &url, KrPanel *nextTo) Q_DECL_OVERRIDE {
+    bool isLeft() const Q_DECL_OVERRIDE { return _left; }
+    AbstractPanelManager *otherManager() const Q_DECL_OVERRIDE { return _otherManager; }
+    KrPanel *currentPanel() const Q_DECL_OVERRIDE;
+    void newTab(const QUrl &url, KrPanel *nextTo) Q_DECL_OVERRIDE {
         slotNewTab(url, true, nextTo);
     }
 
 signals:
     void draggingTab(PanelManager *from, QMouseEvent*);
     void draggingTabFinished(PanelManager *from, QMouseEvent*);
     void setActiveManager(PanelManager *manager);
     void pathChanged(ListPanel *panel);
 
 public slots:
     /**
      * Called externally to start a new tab. Example of usage would be the "open in a new tab"
      * action, from the context-menu.
      */
 
     Q_SCRIPTABLE void newTab(const QString& url) {
         slotNewTab(QUrl::fromUserInput(url, QString(), QUrl::AssumeLocalFile));
     }
     Q_SCRIPTABLE void newTabs(const QStringList& urls);
 
-    void slotNewTab(const QUrl &url, bool setCurrent = true, KrPanel *nextTo = 0);
+    void slotNewTab(const QUrl &url, bool setCurrent = true, KrPanel *nextTo = nullptr);
     void slotNewTab();
     void slotLockTab();
     void slotPinTab();
     void slotNextTab();
 
     void slotPreviousTab();
     void slotCloseTab();
     void slotCloseTab(int index);
     void slotRecreatePanels();
     void slotCloseInactiveTabs();
     void slotCloseDuplicatedTabs();
 
 protected slots:
     void slotCurrentTabChanged(int index);
     void activate();
     void slotDraggingTab(QMouseEvent *e) {
         emit draggingTab(this, e);
     }
     void slotDraggingTabFinished(QMouseEvent* e) {
         emit draggingTabFinished(this, e);
     }
 
 private:
     void deletePanel(ListPanel *p);
     void updateTabbarPos();
     void tabsCountChanged();
-    ListPanel* addPanel(bool setCurrent = true, KConfigGroup cfg = KConfigGroup(), KrPanel *nextTo = 0);
-    ListPanel* createPanel(KConfigGroup cfg);
+    ListPanel* addPanel(bool setCurrent = true, const KConfigGroup& cfg = KConfigGroup(), KrPanel *nextTo = nullptr);
+    ListPanel* createPanel(const KConfigGroup& cfg);
     void connectPanel(ListPanel *p);
     void disconnectPanel(ListPanel *p);
 
     PanelManager *_otherManager;
     TabActions *_actions;
     QGridLayout *_layout;
     QHBoxLayout *_barLayout;
     bool _left;
     PanelTabBar *_tabbar;
     QStackedWidget *_stack;
     QToolButton *_newTab;
     ListPanel *_currentPanel;
 };
 
 
 #endif // _PANEL_MANAGER_H
diff --git a/krusader/paneltabbar.cpp b/krusader/paneltabbar.cpp
index b683d59e..d1bf9d31 100644
--- a/krusader/paneltabbar.cpp
+++ b/krusader/paneltabbar.cpp
@@ -1,339 +1,339 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * Based on original code from Sebastian Trueg <trueg@kde.org>               *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "paneltabbar.h"
 
 #include "defaults.h"
 #include "tabactions.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "Panel/listpanel.h"
 #include "Panel/panelfunc.h"
 
 // QtCore
 #include <QEvent>
 // QtGui
 #include <QFontMetrics>
 #include <QResizeEvent>
 #include <QMouseEvent>
 // QtWidgets
 #include <QAction>
 #include <QMenu>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KActionMenu>
 
 
 static const int sDragEnterDelay = 500; // msec
 
 PanelTabBar::PanelTabBar(QWidget *parent, TabActions *actions): QTabBar(parent),
     _maxTabLength(0), _tabClicked(false), _draggingTab(false), _dragTabIndex(-1)
 {
     _panelActionMenu = new KActionMenu(i18n("Panel"), this);
 
     setAcceptDrops(true);
 
     insertAction(actions->actNewTab);
     insertAction(actions->actLockTab);
     insertAction(actions->actPinTab);
     insertAction(actions->actDupTab);
     insertAction(actions->actMoveTabToOtherSide);
     insertAction(actions->actCloseTab);
     insertAction(actions->actCloseInactiveTabs);
     insertAction(actions->actCloseDuplicatedTabs);
 
     setMovable(true); // enable drag'n'drop
     _dragTimer = new QTimer(this);
     _dragTimer->setSingleShot(true);
     _dragTimer->setInterval(sDragEnterDelay);
     connect(_dragTimer, &QTimer::timeout, this, [=]() {
         if (_dragTabIndex != -1 && _dragTabIndex != currentIndex()) {
             setCurrentIndex(_dragTabIndex);
         }
         _dragTabIndex = -1;
     });
 
     setShape(QTabBar::TriangularSouth);
 }
 
 void PanelTabBar::insertAction(QAction* action)
 {
     _panelActionMenu->addAction(action);
 }
 
 int PanelTabBar::addPanel(ListPanel *panel, bool setCurrent, KrPanel *nextTo)
 {
     int insertIndex = -1;
 
     if (nextTo) {
         for (int i = 0; i < count(); i++) {
             if (getPanel(i) == nextTo) {
                 insertIndex = i + 1;
                 break;
             }
         }
     }
 
     QUrl virtualPath = panel->virtualPath();
     panel->setPinnedUrl(virtualPath);
     const QString text = squeeze(virtualPath);
     const int index = insertIndex != -1 ? insertTab(insertIndex, text) : addTab(text);
 
     setTabData(index, QVariant((long long) panel));
 
     setIcon(index, panel);
 
     // make sure all tabs lengths are correct
     layoutTabs();
 
     if (setCurrent)
         setCurrentIndex(index);
 
     return index;
 }
 
 ListPanel* PanelTabBar::getPanel(int tabIdx)
 {
     QVariant v = tabData(tabIdx);
-    if (v.isNull()) return 0;
+    if (v.isNull()) return nullptr;
     return (ListPanel*)v.toLongLong();
 }
 
 void PanelTabBar::changePanel(int tabIdx, ListPanel *panel)
 {
     setTabData(tabIdx, QVariant((long long) panel));
 }
 
 ListPanel* PanelTabBar::removePanel(int index, ListPanel* &panelToDelete)
 {
     panelToDelete = getPanel(index); // old panel to kill later
-    disconnect(panelToDelete, 0, this, 0);
+    disconnect(panelToDelete, nullptr, this, nullptr);
 
     removeTab(index);
     layoutTabs();
 
     return getPanel(currentIndex());
 }
 
 ListPanel* PanelTabBar::removeCurrentPanel(ListPanel* &panelToDelete)
 {
     return removePanel(currentIndex(), panelToDelete);
 }
 
 void PanelTabBar::updateTab(ListPanel *panel)
 {
     // find which is the correct tab
     for (int i = 0; i < count(); i++) {
         if ((ListPanel*)tabData(i).toLongLong() == panel) {
             setPanelTextToTab(i, panel);
             setIcon(i, panel);
             break;
         }
     }
 }
 
 void PanelTabBar::duplicateTab()
 {
     int id = currentIndex();
     emit newTab(((ListPanel*)tabData(id).toLongLong())->virtualPath());
 }
 
 void PanelTabBar::setIcon(int index, ListPanel *panel)
 {
     Icon tabIcon;
     if (panel->isLocked()) {
         tabIcon = Icon("lock");
     } else if (panel->isPinned()) {
         tabIcon = Icon("pin");
     }
     setTabIcon(index, tabIcon);
 }
 
 QString PanelTabBar::squeeze(const QUrl &url, int tabIndex)
 {
     const QString longText = url.isEmpty() ? i18n("[invalid]") :
                                              url.isLocalFile() ? url.path() : url.toDisplayString();
     if (tabIndex >= 0)
         setTabToolTip(tabIndex, longText);
 
     const KConfigGroup group(krConfig, "Look&Feel");
     const bool showLongNames = group.readEntry("Fullpath Tab Names", _FullPathTabNames);
 
     QString text;
     if (!showLongNames) {
         const QString scheme = url.scheme().isEmpty() || url.isLocalFile() ? "" : (url.scheme() + ':');
         const QString host = url.host().isEmpty() ? "" : (url.host() + ':');
         const QString name = url.isLocalFile() && url.fileName().isEmpty() ? "/" : url.fileName();
         text = scheme + host + name;
     } else {
         text = longText;
     }
 
     if (text.isEmpty())
         text = i18nc("invalid URL path", "?");
 
     // set the real max length
     QFontMetrics fm(fontMetrics());
-    _maxTabLength = (static_cast<QWidget*>(parent())->width() - (6 * fm.width("W"))) / fm.width("W");
+    _maxTabLength = (dynamic_cast<QWidget*>(parent())->width() - (6 * fm.width("W"))) / fm.width("W");
     // each tab gets a fair share of the max tab length
     const int effectiveTabLength = _maxTabLength / (count() == 0 ? 1 : count());
     const int labelWidth = fm.width("W") * effectiveTabLength;
     const int textWidth = fm.width(text);
     if (textWidth <= labelWidth)
         return text;
 
     // squeeze text - start with the dots only
     QString squeezedText = "...";
     int squeezedWidth = fm.width(squeezedText);
 
     int letters = text.length() * (labelWidth - squeezedWidth) / textWidth / 2;
     if (labelWidth < squeezedWidth)
         letters = 1;
     squeezedText = text.left(letters) + "..." + text.right(letters);
     squeezedWidth = fm.width(squeezedText);
 
     if (squeezedWidth < labelWidth) {
         // we estimated too short
         // add letters while text < label
         do {
             letters++;
             squeezedText = text.left(letters) + "..." + text.right(letters);
             squeezedWidth = fm.width(squeezedText);
         } while (squeezedWidth < labelWidth);
         letters--;
         squeezedText = text.left(letters) + "..." + text.right(letters);
     } else if (squeezedWidth > labelWidth) {
         // we estimated too long
         // remove letters while text > label
         do {
             letters--;
             squeezedText = text.left(letters) + "..." + text.right(letters);
             squeezedWidth = fm.width(squeezedText);
         } while (letters && squeezedWidth > labelWidth);
     }
 
     return squeezedText;
 }
 
 void PanelTabBar::resizeEvent(QResizeEvent *e)
 {
     QTabBar::resizeEvent(e);
 
     layoutTabs();
 }
 
 void PanelTabBar::mouseMoveEvent(QMouseEvent* e)
 {
     QTabBar::mouseMoveEvent(e);
     if(_tabClicked) {
         _draggingTab = true;
         emit draggingTab(e);
     }
 }
 
 void PanelTabBar::mousePressEvent(QMouseEvent* e)
 {
     int clickedTab = tabAt(e->pos());
 
     if (-1 == clickedTab) { // clicked on nothing ...
         QTabBar::mousePressEvent(e);
         return;
     }
 
     _tabClicked = true;
 
     setCurrentIndex(clickedTab);
 
     ListPanel *p = getPanel(clickedTab);
     if (p)
         p->slotFocusOnMe();
 
     if (e->button() == Qt::RightButton) {
         // show the popup menu
         _panelActionMenu->menu()->popup(e->globalPos());
     } else {
         if (e->button() == Qt::MidButton)// close the current tab
             emit closeCurrentTab();
     }
 
     QTabBar::mousePressEvent(e);
 }
 
 void PanelTabBar::mouseReleaseEvent(QMouseEvent* e)
 {
     QTabBar::mouseReleaseEvent(e);
     if(_draggingTab)
         emit draggingTabFinished(e);
     _draggingTab = false;
     _tabClicked = false;
 }
 
 void PanelTabBar::dragEnterEvent(QDragEnterEvent *e)
 {
     e->accept();
     handleDragEvent(tabAt(e->pos()));
     QTabBar::dragEnterEvent(e);
 }
 
 void PanelTabBar::dragLeaveEvent(QDragLeaveEvent *)
 {
     handleDragEvent(-1);
 }
 
 void PanelTabBar::dragMoveEvent(QDragMoveEvent *e)
 {
     e->ignore();
     handleDragEvent(tabAt(e->pos()));
     QTabBar::dragMoveEvent(e);
 }
 
 void PanelTabBar::handleDragEvent(int tabIndex)
 {
     if (_dragTabIndex == tabIndex)
         return;
 
     _dragTabIndex = tabIndex;
     if (_dragTabIndex == -1) {
         _dragTimer->stop();
     } else {
         _dragTimer->start();
     }
 }
 
 void PanelTabBar::layoutTabs()
 {
     for (int i = 0; i < count(); i++) {
         setPanelTextToTab(i, (ListPanel*) tabData(i).toLongLong());
     }
 }
 
 void PanelTabBar::setPanelTextToTab(int tabIndex, ListPanel *panel)
 {
     // update tab text from pinnedUrl in case the tab is pinned
     if (panel->isPinned()) {
         setTabText(tabIndex, squeeze(panel->pinnedUrl(), tabIndex));
     } else {
         setTabText(tabIndex, squeeze(panel->virtualPath(), tabIndex));
     }
 }
diff --git a/krusader/paneltabbar.h b/krusader/paneltabbar.h
index 0440080b..02913386 100644
--- a/krusader/paneltabbar.h
+++ b/krusader/paneltabbar.h
@@ -1,117 +1,117 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * Based on original code from Sebastian Trueg <trueg@kde.org>               *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef PANELTABBAR_H
 #define PANELTABBAR_H
 
 // QtCore
 #include <QTimer>
 #include <QUrl>
 // QtGui
 #include <QDragMoveEvent>
 #include <QDragEnterEvent>
 // QtWidgets
 #include <QTabBar>
 
 class QMouseEvent;
 class QAction;
 class KActionMenu;
 class KrPanel;
 class ListPanel;
 class TabActions;
 
 /**
  * This class extends QTabBar such that right-clicking on a tab pops-up a menu
  * containing relevant actions for the tab. It also emits signals (caught by PanelManager)
  * to create a new tab, close the current tab and change a panel when a tab was clicked
  */
 class PanelTabBar : public QTabBar
 {
     Q_OBJECT
 public:
     PanelTabBar(QWidget *parent, TabActions *actions);
 
 public slots:
     /**
      * called by PanelManager with an already created panel, and creates the corresponding tab
      */
-    int addPanel(ListPanel *panel, bool setCurrent = true, KrPanel *nextTo = 0);
+    int addPanel(ListPanel *panel, bool setCurrent = true, KrPanel *nextTo = nullptr);
 
     ListPanel* getPanel(int tabIdx);
     void changePanel(int tabIdx, ListPanel *panel);
     void layoutTabs();
 
     /**
      * when the user changes the current path in a panel, this method updates the tab accordingly
      */
     void updateTab(ListPanel *panel);
     /**
      * actually removes the current tab WITHOUT actually deleting the panel.
      * returns a pointer to the panel which is going to be displayed next.
      * panelToDelete returns a reference to the pointer of the soon-to-die panel, to
      * be used by PanelManager.
      */
     ListPanel* removeCurrentPanel(ListPanel* &panelToDelete); // returns the panel focused after removing the current
     ListPanel* removePanel(int index, ListPanel* &panelToDelete);
 
 signals:
     /**
      * emitted when the user right-clicks and selected "close"
      */
     void closeCurrentTab();
     /**
      * emitted when the user right-clicks and selects an action that creates a new tab
      */
     void newTab(const QUrl &path);
 
     void draggingTab(QMouseEvent*);
     void draggingTabFinished(QMouseEvent*);
 
 protected:
-    virtual void mouseMoveEvent(QMouseEvent*e) Q_DECL_OVERRIDE;
-    virtual void mousePressEvent(QMouseEvent*) Q_DECL_OVERRIDE;
-    virtual void mouseReleaseEvent(QMouseEvent*) Q_DECL_OVERRIDE;
+    void mouseMoveEvent(QMouseEvent*e) Q_DECL_OVERRIDE;
+    void mousePressEvent(QMouseEvent*) Q_DECL_OVERRIDE;
+    void mouseReleaseEvent(QMouseEvent*) Q_DECL_OVERRIDE;
     void insertAction(QAction*);
     QString squeeze(const QUrl &url, int tabIndex = -1);
-    virtual void dragEnterEvent(QDragEnterEvent *) Q_DECL_OVERRIDE;
-    virtual void dragLeaveEvent(QDragLeaveEvent *) Q_DECL_OVERRIDE;
-    virtual void dragMoveEvent(QDragMoveEvent *) Q_DECL_OVERRIDE;
-    virtual void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
+    void dragEnterEvent(QDragEnterEvent *) Q_DECL_OVERRIDE;
+    void dragLeaveEvent(QDragLeaveEvent *) Q_DECL_OVERRIDE;
+    void dragMoveEvent(QDragMoveEvent *) Q_DECL_OVERRIDE;
+    void resizeEvent(QResizeEvent *e) Q_DECL_OVERRIDE;
 
 protected slots:
     void duplicateTab();
 
 private:
     void setIcon(int index, ListPanel *panel);
     void handleDragEvent(int tabIndex);
     void setPanelTextToTab(int tabIndex, ListPanel *panel);
     KActionMenu *_panelActionMenu;
     bool _left;
     int _maxTabLength;
     bool _tabClicked, _draggingTab;
 
     QTimer *_dragTimer;
     int _dragTabIndex;
 };
 
 #endif
diff --git a/krusader/tabactions.cpp b/krusader/tabactions.cpp
index fd0d5792..1a9bfd74 100644
--- a/krusader/tabactions.cpp
+++ b/krusader/tabactions.cpp
@@ -1,120 +1,120 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2000 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2011 Jan Lepper <jan_lepper@gmx.de>                         *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "tabactions.h"
 
 #include "krmainwindow.h"
 #include "panelmanager.h"
 #include "Panel/listpanel.h"
 
 // QtWidgets
 #include <QAction>
 
 #include <KI18n/KLocalizedString>
 
 TabActions::TabActions(QObject *parent, KrMainWindow *mainWindow) : ActionsBase(parent, mainWindow)
 {
     actNewTab = action(i18n("New Tab"), "tab-new", QKeySequence::keyBindings(QKeySequence::AddTab), this, SLOT(newTab()), "new tab");
     actDupTab = action(i18n("Duplicate Current Tab"), "tab-duplicate", Qt::ALT + Qt::CTRL + Qt::SHIFT + Qt::Key_N, SLOT(duplicateTab()), "duplicate tab");
-    actMoveTabToOtherSide = action(i18n("Move Current Tab to Other Side"), 0, Qt::CTRL + Qt::SHIFT + Qt::Key_O, SLOT(moveTabToOtherSide()), "move_tab_to_other_side");
+    actMoveTabToOtherSide = action(i18n("Move Current Tab to Other Side"), nullptr, Qt::CTRL + Qt::SHIFT + Qt::Key_O, SLOT(moveTabToOtherSide()), "move_tab_to_other_side");
     actCloseTab = action(i18n("Close Current Tab"), "tab-close", KStandardShortcut::close(), this, SLOT(closeTab()), "close tab");
     actNextTab = action(i18n("Next Tab"), QString(), KStandardShortcut::tabNext(), this, SLOT(nextTab()), "next tab");
     actPreviousTab = action(i18n("Previous Tab"), QString(), KStandardShortcut::tabPrev(), this, SLOT(previousTab()), "previous tab");
-    actCloseInactiveTabs = action(i18n("Close Inactive Tabs"), 0, 0, SLOT(closeInactiveTabs()), "close inactive tabs");
-    actCloseDuplicatedTabs = action(i18n("Close Duplicated Tabs"), 0, 0, SLOT(closeDuplicatedTabs()), "close duplicated tabs");
+    actCloseInactiveTabs = action(i18n("Close Inactive Tabs"), nullptr, 0, SLOT(closeInactiveTabs()), "close inactive tabs");
+    actCloseDuplicatedTabs = action(i18n("Close Duplicated Tabs"), nullptr, 0, SLOT(closeDuplicatedTabs()), "close duplicated tabs");
     actLockTab = action(i18n("Lock Tab"), "lock", 0, SLOT(lockTab()), "lock tab");
     actPinTab = action(i18n("Pin Tab"), "pin", 0, SLOT(pinTab()), "pin tab");
 }
 
 inline PanelManager *TabActions::activeManager()
 {
-    return static_cast<PanelManager*>(
+    return dynamic_cast<PanelManager*>(
         static_cast<KrMainWindow*>(_mainWindow)->activeManager());
 }
 
 void TabActions::refreshActions()
 {
     if (!activeManager())
         return;
     int tabCount = activeManager()->tabCount();
     actCloseTab->setEnabled(tabCount > 1);
     actCloseInactiveTabs->setEnabled(tabCount > 1);
     actCloseDuplicatedTabs->setEnabled(tabCount > 1);
     actMoveTabToOtherSide->setEnabled(tabCount > 1);
     actNextTab->setEnabled(tabCount > 1);
     actPreviousTab->setEnabled(tabCount > 1);
     bool locked = activeManager()->currentPanel()->gui->isLocked();
     actLockTab->setText(locked ? i18n("Unlock Tab") : i18n("Lock Tab"));
     bool pinned = activeManager()->currentPanel()->gui->isPinned();
     actPinTab->setText(pinned ? i18n("Unpin Tab") : i18n("Pin Tab"));
 }
 
 void TabActions::newTab()
 {
     activeManager()->slotNewTab();
 }
 
 void TabActions::duplicateTab()
 {
     KrPanel *activePanel = static_cast<KrMainWindow*>(_mainWindow)->activePanel();
     activeManager()->newTab(activePanel->virtualPath(), activePanel);
 }
 
 void TabActions::moveTabToOtherSide()
 {
     activeManager()->moveTabToOtherSide();
 }
 
 void TabActions::nextTab()
 {
     activeManager()->slotNextTab();
 }
 
 void TabActions::previousTab()
 {
     activeManager()->slotPreviousTab();
 }
 
 void TabActions::closeTab()
 {
     activeManager()->slotCloseTab();
 }
 
 void TabActions::closeInactiveTabs()
 {
     activeManager()->slotCloseInactiveTabs();
 }
 
 void TabActions::closeDuplicatedTabs()
 {
     activeManager()->slotCloseDuplicatedTabs();
 }
 
 void TabActions::lockTab()
 {
     activeManager()->slotLockTab();
 }
 
 void TabActions::pinTab()
 {
     activeManager()->slotPinTab();
 }