diff --git a/krusader/DiskUsage/diskusage.cpp b/krusader/DiskUsage/diskusage.cpp
index 312b3a07..efdb2229 100644
--- a/krusader/DiskUsage/diskusage.cpp
+++ b/krusader/DiskUsage/diskusage.cpp
@@ -1,1134 +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);
 
     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);
 
     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);
     auto * hbox = new QHBoxLayout(hboxWidget);
 
     auto* spacer = new QSpacerItem(0, 0, QSizePolicy::Minimum, QSizePolicy::Expanding);
     hbox->addItem(spacer);
     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(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 = nullptr;
     }
     searchFileSystem = FileSystemProvider::instance().getFilesystem(baseDir);
     if (searchFileSystem == nullptr) {
         qWarning() << "could not get filesystem for directory=" << baseDir;
         loading = abortLoading = clearAfterAbort = false;
         emit loadFinished(false);
         return;
     }
 
     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 == nullptr && directoryStack.isEmpty()) || loaderView->wasCancelled() || abortLoading) {
         if (searchFileSystem)
             delete searchFileSystem;
 
         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 == 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 = 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->getModificationTime(), 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->getModificationTime(), 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 != 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 nullptr;
     return contentMap[ dir ];
 }
 
 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 == nullptr)
         return nullptr;
 
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it)
         if ((*it)->name() == file)
             return *it;
 
     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 = nullptr;
 }
 
 int DiskUsage::calculateSizes(Directory *dirEntry, bool emitSig, int depth)
 {
     int changeNr = 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()) {
             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 == 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()) {
         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() != 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, const QString& key)
 {
     QHash< File *, Properties *>::iterator itr = propertyMap.find(item);
     if (itr == propertyMap.end())
         return nullptr;
 
     QHash<QString, void *>::iterator it = (*itr)->find(key);
     if (it == (*itr)->end())
         return nullptr;
 
     return it.value();
 }
 
 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, 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 == 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, const QString& addPopupName)
 {
     QMenu popup(this);
 
     popup.setTitle(i18n("Disk Usage"));
 
     QHash<void *, int> actionHash;
 
     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 != 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(const QString& mime)
 {
     QPixmap icon;
 
-    if (!QPixmapCache::find(mime, 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 == 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 = 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) {
         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/GUI/krstyleproxy.cpp b/krusader/GUI/krstyleproxy.cpp
index 4ccc507b..777c9ad9 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 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.setColor(option->palette.windowText().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/Panel/PanelView/krsort.cpp b/krusader/Panel/PanelView/krsort.cpp
index 49f7962d..c544db39 100644
--- a/krusader/Panel/PanelView/krsort.cpp
+++ b/krusader/Panel/PanelView/krsort.cpp
@@ -1,335 +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 = 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 (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->getModificationTime(), file2->getModificationTime(), sp, sp2);
     case KrViewProperties::Changed:
             return compareTime(file1->getChangeTime(), file2->getChangeTime(), 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, std::move(customData));
     _items << &_itemStore.last();
 }
 
 void Sorter::sort()
 {
-    qStableSort(_items.begin(), _items.end(),
+    std::stable_sort(_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, std::move(customData));
     const QVector<SortProps*>::iterator it =
-        qLowerBound(_items.begin(), _items.end(), &props,
+        std::lower_bound(_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 12077e2c..3f6b818a 100644
--- a/krusader/Panel/PanelView/krview.cpp
+++ b/krusader/Panel/PanelView/krview.cpp
@@ -1,1226 +1,1226 @@
 /*****************************************************************************
  * 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 = 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() == 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 = nullptr;
 }
 
 // ----------------------------- krview
 
 const KrView::IconSizes KrView::iconSizes;
 
 KrView::KrView(KrViewInstance &instance, KConfig *cfg)
     : _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 = nullptr;
     delete _dummyFileItem;
     _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;
     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 = 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)) {
+    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(const QString& mask, QStringList* names, bool dirs, bool files)
 {
     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 != 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);
         }
     }
 }
 
 KrViewItemList KrView::getSelectedKrViewItems()
 {
     KrViewItemList items;
     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
     if (items.empty()) {
         KrViewItem *currentItem = getCurrentKrViewItem();
         if (currentItem && !currentItem->isDummy()) {
             items.append(getCurrentKrViewItem());
         }
     }
 
     return items;
 }
 
 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 = 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 == nullptr)
             continue;
 
         if (filter.match(file)) {
             it->setSelected(select);
             if (!firstMatch) firstMatch = it;
         }
     }
 
     if (op()) op()->setMassSelectionUpdate(false);
     updateView();
     if (ensureVisibilityAfterSelect() && temp != nullptr) {
         makeItemVisible(temp);
     } else if (makeVisible && firstMatch != nullptr) {
         // if no selected item is visible...
         const KrViewItemList selectedItems = getSelectedKrViewItems();
         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 != 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 != 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 != nullptr)
         makeItemVisible(temp);
 }
 
 QString KrView::firstUnmarkedBelowCurrent(const bool skipCurrent)
 {
     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 = 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 == 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 != 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 == 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 == 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 == 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 == 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(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(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, nullptr, op(), nullptr);
         _files = files;
     }
 
     if(!_files)
         return;
 
     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, 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(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/listpanelactions.cpp b/krusader/Panel/listpanelactions.cpp
index 57bd6332..1b86b66e 100644
--- a/krusader/Panel/listpanelactions.cpp
+++ b/krusader/Panel/listpanelactions.cpp
@@ -1,219 +1,214 @@
 /*****************************************************************************
  * 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
-    auto *mapper = new QSignalMapper(this);
-    connect(mapper, QOverload<int>::of(&QSignalMapper::mapped), this, &ListPanelActions::setView);
     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());
+        connect(action, &QAction::triggered, this, [=] {setView(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"), nullptr, Qt::Key_F3, _func, SLOT(view()), "F3_View");
     actEditFileF4 = action(i18n("Edit File"), nullptr, Qt::Key_F4, _func, SLOT(editFile()), "F4_Edit");
     actNewFileShiftF4 = action(i18n("&New Text File..."), "document-new", Qt::SHIFT + Qt::Key_F4, _func, SLOT(editNewFile()), "edit_new_file");
     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("F3 View Dialog"), nullptr, Qt::SHIFT + Qt::Key_F3, _func, SLOT(viewDlg()), "F3_ViewDlg");
 
     // file operations
     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..."), 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"), 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"), 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"), 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..."), 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/Synchronizer/synchronizergui.cpp b/krusader/Synchronizer/synchronizergui.cpp
index 880113cf..66929c9d 100644
--- a/krusader/Synchronizer/synchronizergui.cpp
+++ b/krusader/Synchronizer/synchronizergui.cpp
@@ -1,1624 +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++)) != 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;
 
         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();
+        drag->exec();
     }
 };
 
 
 SynchronizerGUI::SynchronizerGUI(QWidget* parent,  QUrl leftURL, QUrl rightURL, QStringList selList) :
         QDialog(parent)
 {
     initGUI(QString(), std::move(leftURL), std::move(rightURL), std::move(selList));
 }
 
 SynchronizerGUI::SynchronizerGUI(QWidget* parent,  QString profile) :
         QDialog(parent)
 {
     initGUI(std::move(profile), QUrl(), QUrl(), QStringList());
 }
 
 void SynchronizerGUI::initGUI(const QString& profileName, QUrl leftURL, QUrl rightURL, QStringList selList)
 {
     setAttribute(Qt::WA_DeleteOnClose);
 
     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"));
     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);
     auto *synchronizerGrid = new QGridLayout(synchronizerTab);
     synchronizerGrid->setSpacing(6);
     synchronizerGrid->setContentsMargins(11, 11, 11, 11);
 
     auto *compareDirs = new QGroupBox(synchronizerTab);
     compareDirs->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     compareDirs->setTitle(i18n("Folder Comparison"));
 
     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);
     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);
     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);
     auto *optionBox = new QHBoxLayout(optionWidget);
     optionBox->setContentsMargins(0, 0, 0, 0);
 
     QWidget *optionGridWidget = new QWidget(optionWidget);
     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 ============================= */
 
     auto *showOptions  = new QGroupBox(optionWidget);
     optionBox->addWidget(showOptions);
 
     showOptions->setTitle(i18n("S&how options"));
     showOptions->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     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
 
     auto *optionsGroup = new QGroupBox(generalFilter);
     optionsGroup->setTitle(i18n("&Options"));
 
     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 =================================== */
 
     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);
 
     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);
 
     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;
 
     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;
 
     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++)) != 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++)) != 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++)) != 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 = 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 = nullptr;
     SyncViewItem *dirItem;
 
     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)
 {
     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;
     }
 
     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(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 == 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) {
         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 == 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(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(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)
 {
     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++)) != 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;
 
     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;
 }