diff --git a/krusader/Dialogs/krsqueezedtextlabel.cpp b/krusader/Dialogs/krsqueezedtextlabel.cpp
index 2a1464b9..464c84c3 100644
--- a/krusader/Dialogs/krsqueezedtextlabel.cpp
+++ b/krusader/Dialogs/krsqueezedtextlabel.cpp
@@ -1,102 +1,104 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krsqueezedtextlabel.h"
 
 // QtGui
 #include <QDragEnterEvent>
 #include <QPainter>
 // QtWidgets
 #include <QToolTip>
 #include <QLabel>
 
 #include <KCoreAddons/KUrlMimeData>
 #include <KCoreAddons/KStringHandler>
 
+#include "../compat.h"
+
 KrSqueezedTextLabel::KrSqueezedTextLabel(QWidget *parent):
         KSqueezedTextLabel(parent), _index(-1), _length(-1)
 {
     setAutoFillBackground(true);
 }
 
 
 KrSqueezedTextLabel::~KrSqueezedTextLabel()
 = default;
 
 void KrSqueezedTextLabel::mousePressEvent(QMouseEvent *e)
 {
     e->ignore();
     emit clicked(e);
 }
 
 void KrSqueezedTextLabel::squeezeTextToLabel(int index, int length)
 {
     if (index == -1 || length == -1)
         KSqueezedTextLabel::squeezeTextToLabel();
     else {
         QString sqtext = fullText;
         QFontMetrics fm(fontMetrics());
         int labelWidth = size().width();
-        int textWidth = fm.width(sqtext);
+        int textWidth = fm.QFONTMETRICS_WIDTH(sqtext);
         if (textWidth > labelWidth) {
             int avgCharSize = textWidth / sqtext.length();
             int numOfExtraChars = (textWidth - labelWidth) / avgCharSize;
             int delta;
 
             // remove as much as possible from the left, and then from the right
             if (index > 3) {
                 delta = qMin(index, numOfExtraChars);
                 numOfExtraChars -= delta;
                 sqtext.replace(0, delta, "...");
             }
 
             if (numOfExtraChars > 0 && ((int)sqtext.length() > length + 3)) {
                 delta = qMin(numOfExtraChars, (int)sqtext.length() - (length + 3));
                 sqtext.replace(sqtext.length() - delta, delta, "...");
             }
             QLabel::setText(sqtext);
 
             setToolTip(QString());
             setToolTip(fullText);
         } else {
             QLabel::setText(fullText);
 
             setToolTip(QString());
             QToolTip::hideText();
         }
     }
 }
 
 void KrSqueezedTextLabel::setText(const QString &text, int index, int length)
 {
     _index = index;
     _length = length;
     fullText = text;
     KSqueezedTextLabel::setText(fullText);
     squeezeTextToLabel(_index, _length);
 }
 
 void KrSqueezedTextLabel::paintEvent(QPaintEvent * e)
 {
     KSqueezedTextLabel::paintEvent(e);
 }
 
 
diff --git a/krusader/DiskUsage/diskusage.cpp b/krusader/DiskUsage/diskusage.cpp
index 78f73828..b2e9ec29 100644
--- a/krusader/DiskUsage/diskusage.cpp
+++ b/krusader/DiskUsage/diskusage.cpp
@@ -1,1134 +1,1135 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more 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"
+#include "../compat.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->setMinimumWidth(width = QFontMetrics(searchedDirectory->font()).QFONTMETRICS_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)) {
         // 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/DiskUsage/diskusagegui.cpp b/krusader/DiskUsage/diskusagegui.cpp
index f122bae3..719f9ea1 100644
--- a/krusader/DiskUsage/diskusagegui.cpp
+++ b/krusader/DiskUsage/diskusagegui.cpp
@@ -1,242 +1,243 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "diskusagegui.h"
 
 // QtCore
 #include <QTimer>
 // QtGui
 #include <QResizeEvent>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QGridLayout>
 #include <QHBoxLayout>
 #include <QLabel>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../FileSystem/filesystem.h"
 #include "../Dialogs/krdialogs.h"
+#include "../compat.h"
 
 DiskUsageGUI::DiskUsageGUI(const QUrl &openDir)
         : QDialog(nullptr), exitAtFailure(true)
 {
     setWindowTitle(i18n("Krusader::Disk Usage"));
     setAttribute(Qt::WA_DeleteOnClose);
 
     baseDirectory = openDir;
 
     auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     auto *duGrid = new QGridLayout();
     duGrid->setSpacing(6);
     duGrid->setContentsMargins(11, 11, 11, 11);
 
     QWidget *duTools = new QWidget(this);
     auto *duHBox = new QHBoxLayout(duTools);
     duHBox->setContentsMargins(0, 0, 0, 0);
     duTools->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     btnNewSearch = new QToolButton(duTools);
     btnNewSearch->setIcon(Icon("document-open"));
     duHBox->addWidget(btnNewSearch);
     btnNewSearch->setToolTip(i18n("Start new disk usage search"));
 
     btnRefresh = new QToolButton(duTools);
     btnRefresh->setIcon(Icon("view-refresh"));
     duHBox->addWidget(btnRefresh);
     btnRefresh->setToolTip(i18n("Refresh"));
 
     btnDirUp = new QToolButton(duTools);
     btnDirUp->setIcon(Icon("go-up"));
     duHBox->addWidget(btnDirUp);
     btnDirUp->setToolTip(i18n("Parent folder"));
 
     QWidget *separatorWidget = new QWidget(duTools);
     separatorWidget->setMinimumWidth(10);
     duHBox->addWidget(separatorWidget);
 
     btnLines = new QToolButton(duTools);
     btnLines->setIcon(Icon("view-list-details"));
     btnLines->setCheckable(true);
     duHBox->addWidget(btnLines);
     btnLines->setToolTip(i18n("Line view"));
 
     btnDetailed = new QToolButton(duTools);
     btnDetailed->setIcon(Icon("view-list-tree"));
     btnDetailed->setCheckable(true);
     duHBox->addWidget(btnDetailed);
     btnDetailed->setToolTip(i18n("Detailed view"));
 
     btnFilelight = new QToolButton(duTools);
     btnFilelight->setIcon(Icon("kr_diskusage"));
     btnFilelight->setCheckable(true);
     duHBox->addWidget(btnFilelight);
     btnFilelight->setToolTip(i18n("Filelight view"));
 
     QWidget *spacerWidget = new QWidget(duTools);
     duHBox->addWidget(spacerWidget);
     auto *hboxlayout = new QHBoxLayout(spacerWidget);
     auto* spacer = new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Fixed);
     hboxlayout->addItem(spacer);
 
     duGrid->addWidget(duTools, 0, 0);
 
     diskUsage = new DiskUsage("DiskUsage", this);
     duGrid->addWidget(diskUsage, 1, 0);
 
     status = new KSqueezedTextLabel(this);
     duGrid->addWidget(status, 2, 0);
 
     mainLayout->addLayout(duGrid);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &DiskUsageGUI::close);
     connect(diskUsage, &DiskUsage::status, this, &DiskUsageGUI::slotStatus);
     connect(diskUsage, &DiskUsage::viewChanged, this, &DiskUsageGUI::slotViewChanged);
     connect(diskUsage, &DiskUsage::newSearch, this, &DiskUsageGUI::askDir);
     connect(diskUsage, &DiskUsage::loadFinished, this, &DiskUsageGUI::slotLoadFinished);
     connect(btnNewSearch, &QToolButton::clicked, this, &DiskUsageGUI::askDir);
     connect(btnRefresh, &QToolButton::clicked, this, &DiskUsageGUI::slotLoadUsageInfo);
     connect(btnDirUp, &QToolButton::clicked, diskUsage, &DiskUsage::dirUp);
     connect(btnLines, &QToolButton::clicked, this, &DiskUsageGUI::slotSelectLinesView);
     connect(btnDetailed, &QToolButton::clicked, this, &DiskUsageGUI::slotSelectListView);
     connect(btnFilelight, &QToolButton::clicked, this, &DiskUsageGUI::slotSelectFilelightView);
 
     KConfigGroup group(krConfig, "DiskUsage");
 
     int view = group.readEntry("View",  VIEW_LINES);
     if (view < VIEW_LINES || view > VIEW_FILELIGHT)
         view = VIEW_LINES;
 
     diskUsage->setView(view);
 
-    sizeX = group.readEntry("Window Width",  QFontMetrics(font()).width("W") * 70);
+    sizeX = group.readEntry("Window Width",  QFontMetrics(font()).QFONTMETRICS_WIDTH("W") * 70);
     sizeY = group.readEntry("Window Height", QFontMetrics(font()).height() * 25);
     resize(sizeX, sizeY);
 
     if (group.readEntry("Window Maximized",  false)) {
         setWindowState(windowState() | Qt::WindowMaximized);
     }
 }
 
 void DiskUsageGUI::askDirAndShow()
 {
     if (askDir()) {
         show();
     }
 }
 
 void DiskUsageGUI::slotLoadFinished(bool result)
 {
     if (exitAtFailure && !result) {
         close();
     } else {
         exitAtFailure = false;
     }
 }
 
 void DiskUsageGUI::enableButtons(bool isOn)
 {
     btnNewSearch->setEnabled(isOn);
     btnRefresh->setEnabled(isOn);
     btnDirUp->setEnabled(isOn);
     btnLines->setEnabled(isOn);
     btnDetailed->setEnabled(isOn);
     btnFilelight->setEnabled(isOn);
 }
 
 void DiskUsageGUI::resizeEvent(QResizeEvent *e)
 {
     if (!isMaximized()) {
         sizeX = e->size().width();
         sizeY = e->size().height();
     }
     QDialog::resizeEvent(e);
 }
 
 void DiskUsageGUI::closeEvent(QCloseEvent *event)
 {
     KConfigGroup group(krConfig, "DiskUsage");
     group.writeEntry("Window Width", sizeX);
     group.writeEntry("Window Height", sizeY);
     group.writeEntry("Window Maximized", isMaximized());
     group.writeEntry("View", diskUsage->getActiveView());
 
     event->accept();
 }
 
 void DiskUsageGUI::slotLoadUsageInfo()
 {
     diskUsage->load(baseDirectory);
 }
 
 void DiskUsageGUI::slotStatus(const QString& stat)
 {
     status->setText(stat);
 }
 
 void DiskUsageGUI::slotViewChanged(int view)
 {
     if (view == VIEW_LOADER) {
         enableButtons(false);
         return;
     }
     enableButtons(true);
 
     btnLines->setChecked(false);
     btnDetailed->setChecked(false);
     btnFilelight->setChecked(false);
 
     switch (view) {
     case VIEW_LINES:
         btnLines->setChecked(true);
         break;
     case VIEW_DETAILED:
         btnDetailed->setChecked(true);
         break;
     case VIEW_FILELIGHT:
         btnFilelight->setChecked(true);
         break;
     case VIEW_LOADER:
         break;
     }
 }
 
 bool DiskUsageGUI::askDir()
 {
     // ask the user for the copy destX
     const QUrl newDir =
         KChooseDir::getDir(i18n("Viewing the usage of folder:"), baseDirectory, baseDirectory);
 
     if (newDir.isEmpty())
         return false;
 
     baseDirectory = newDir;
 
     QTimer::singleShot(0, this, &DiskUsageGUI::slotLoadUsageInfo);
     return true;
 }
diff --git a/krusader/DiskUsage/dulines.cpp b/krusader/DiskUsage/dulines.cpp
index 63e19e44..a20aca11 100644
--- a/krusader/DiskUsage/dulines.cpp
+++ b/krusader/DiskUsage/dulines.cpp
@@ -1,534 +1,535 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "dulines.h"
 
 #include "../icon.h"
 #include "../krglobal.h"
 #include "../FileSystem/krpermhandler.h"
 
 // QtCore
 #include <QTimer>
 // QtGui
 #include <QMouseEvent>
 #include <QPixmap>
 #include <QKeyEvent>
 #include <QPen>
 #include <QPainter>
 #include <QFontMetrics>
 // QtWidgets
 #include <QToolTip>
 #include <QApplication>
 #include <QHeaderView>
 #include <QItemDelegate>
 #include <QMenu>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
+#include "../compat.h"
 
 class DULinesItemDelegate : public QItemDelegate
 {
 public:
 
     explicit DULinesItemDelegate(QObject *parent = nullptr) : QItemDelegate(parent) {}
 
     void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const Q_DECL_OVERRIDE {
         QItemDelegate::paint(painter, option, index);
 
         QVariant value = index.data(Qt::UserRole);
         if (value.isValid()) {
             QString text = value.toString();
 
             value = index.data(Qt::DisplayRole);
             QString display;
             if (value.isValid())
                 display = value.toString();
 
             QSize iconSize;
             value = index.data(Qt::DecorationRole);
             if (value.isValid())
                 iconSize = qvariant_cast<QIcon>(value).actualSize(option.decorationSize);
 
             painter->save();
             painter->setClipRect(option.rect);
 
             QPalette::ColorGroup cg = option.state & QStyle::State_Enabled
                                       ? QPalette::Normal : QPalette::Disabled;
             if (cg == QPalette::Normal && !(option.state & QStyle::State_Active))
                 cg = QPalette::Inactive;
             if (option.state & QStyle::State_Selected) {
                 painter->setPen(option.palette.color(cg, QPalette::HighlightedText));
             } else {
                 painter->setPen(option.palette.color(cg, QPalette::Text));
             }
 
             QFont fnt = option.font;
             fnt.setItalic(true);
             painter->setFont(fnt);
 
             QFontMetrics fm(fnt);
             QString renderedText = text;
 
             int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin);
-            int pos = 3 * textMargin + option.fontMetrics.width(display) + iconSize.width();
+            int pos = 3 * textMargin + option.fontMetrics.QFONTMETRICS_WIDTH(display) + iconSize.width();
 
             bool truncd = false;
 
             QRect rct = option.rect;
             if (rct.width() > pos) {
                 rct.setX(rct.x() + pos);
 
-                if (fm.width(renderedText) > rct.width()) {
+                if (fm.QFONTMETRICS_WIDTH(renderedText) > rct.width()) {
                     truncd = true;
 
-                    int points = fm.width("...");
+                    int points = fm.QFONTMETRICS_WIDTH("...");
 
-                    while (!renderedText.isEmpty() && (fm.width(renderedText) + points > rct.width()))
+                    while (!renderedText.isEmpty() && (fm.QFONTMETRICS_WIDTH(renderedText) + points > rct.width()))
                         renderedText.truncate(renderedText.length() - 1);
 
                     renderedText += "...";
                 }
 
                 painter->drawText(rct, Qt::AlignLeft, renderedText);
             } else
                 truncd = true;
 
             if (truncd)
                 ((QAbstractItemModel *)index.model())->setData(index, QVariant(display + "  " + text), Qt::ToolTipRole);
             else
                 ((QAbstractItemModel *)index.model())->setData(index, QVariant(), Qt::ToolTipRole);
 
             painter->restore();
         }
     }
 };
 
 class DULinesItem : public QTreeWidgetItem
 {
 public:
     DULinesItem(DiskUsage *diskUsageIn, File *fileItem, QTreeWidget * parent, const QString& label1,
                 const QString& label2, const QString& label3) : QTreeWidgetItem(parent),
             diskUsage(diskUsageIn), file(fileItem) {
         setText(0, label1);
         setText(1, label2);
         setText(2, label3);
 
         setTextAlignment(1, Qt::AlignRight);
     }
     DULinesItem(DiskUsage *diskUsageIn, File *fileItem, QTreeWidget * parent, QTreeWidgetItem * after,
                 const QString& label1, const QString& label2, const QString& label3) : QTreeWidgetItem(parent, after),
             diskUsage(diskUsageIn), file(fileItem) {
         setText(0, label1);
         setText(1, label2);
         setText(2, label3);
 
         setTextAlignment(1, Qt::AlignRight);
     }
 
     bool operator<(const QTreeWidgetItem &other) const Q_DECL_OVERRIDE {
         int column = treeWidget() ? treeWidget()->sortColumn() : 0;
 
         if (text(0) == "..")
             return true;
 
         const auto *compWith = dynamic_cast< const DULinesItem * >(&other);
         if (compWith == nullptr)
             return false;
 
         switch (column) {
         case 0:
         case 1:
             return file->size() > compWith->file->size();
         default:
             return text(column) < other.text(column);
         }
     }
 
     inline File * getFile() {
         return file;
     }
 
 private:
     DiskUsage *diskUsage;
     File *file;
 };
 
 DULines::DULines(DiskUsage *usage)
         : KrTreeWidget(usage), diskUsage(usage), refreshNeeded(false), started(false)
 {
     setItemDelegate(itemDelegate = new DULinesItemDelegate());
 
     setAllColumnsShowFocus(true);
     setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setIndentation(10);
 
-    int defaultSize = QFontMetrics(font()).width("W");
+    int defaultSize = QFontMetrics(font()).QFONTMETRICS_WIDTH("W");
 
     QStringList labels;
     labels << i18n("Line View");
     labels << i18n("Percent");
     labels << i18n("Name");
     setHeaderLabels(labels);
 
     header()->setSectionResizeMode(QHeaderView::Interactive);
 
     KConfigGroup group(krConfig, diskUsage->getConfigGroup());
 
     showFileSize = group.readEntry("L Show File Size", true);
 
     if (group.hasKey("L State"))
         header()->restoreState(group.readEntry("L State", QByteArray()));
     else {
         setColumnWidth(0, defaultSize * 20);
         setColumnWidth(1, defaultSize * 6);
         setColumnWidth(2, defaultSize * 20);
     }
 
     setStretchingColumn(0);
 
     header()->setSortIndicatorShown(true);
     sortItems(1, Qt::AscendingOrder);
 
 //  toolTip = new DULinesToolTip( diskUsage, viewport(), this );
 
     connect(diskUsage, &DiskUsage::enteringDirectory, this, &DULines::slotDirChanged);
     connect(diskUsage, &DiskUsage::clearing, this, &DULines::clear);
 
     connect(header(), &QHeaderView::sectionResized, this, &DULines::sectionResized);
 
     connect(this, &DULines::itemRightClicked, this, &DULines::slotRightClicked);
     connect(diskUsage, &DiskUsage::changed, this, &DULines::slotChanged);
     connect(diskUsage, &DiskUsage::deleted, this, &DULines::slotDeleted);
 
     started = true;
 }
 
 DULines::~DULines()
 {
     KConfigGroup group(krConfig, diskUsage->getConfigGroup());
     group.writeEntry("L State", header()->saveState());
 
     delete itemDelegate;
 }
 
 bool DULines::event(QEvent * event)
 {
     switch (event->type()) {
     case QEvent::ToolTip: {
         auto *he = dynamic_cast<QHelpEvent*>(event);
 
         if (viewport()) {
             QPoint pos = viewport()->mapFromGlobal(he->globalPos());
 
             QTreeWidgetItem * item = itemAt(pos);
 
             int column = columnAt(pos.x());
 
             if (item && column == 1) {
                 File *fileItem = ((DULinesItem *)item)->getFile();
                 QToolTip::showText(he->globalPos(), diskUsage->getToolTip(fileItem), this);
                 return true;
             }
         }
     }
     break;
     default:
         break;
     }
     return KrTreeWidget::event(event);
 }
 
 void DULines::slotDirChanged(Directory *dirEntry)
 {
     clear();
 
     QTreeWidgetItem * lastItem = nullptr;
 
     if (!(dirEntry->parent() == nullptr)) {
         lastItem = new QTreeWidgetItem(this);
         lastItem->setText(0, "..");
         lastItem->setIcon(0, Icon("go-up"));
         lastItem->setFlags(lastItem->flags() & (~Qt::ItemIsSelectable));
     }
 
     int maxPercent = -1;
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it) {
         File *item = *it;
         if (!item->isExcluded() && item->intPercent() > maxPercent)
             maxPercent = item->intPercent();
     }
 
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it) {
         File *item = *it;
 
         QString fileName = item->name();
 
         if (lastItem == nullptr)
             lastItem = new DULinesItem(diskUsage, item, this, "", item->percent() + "  ", fileName);
         else
             lastItem = new DULinesItem(diskUsage, item, this, lastItem, "", item->percent() + "  ", fileName);
 
         if (item->isExcluded())
             lastItem->setHidden(true);
 
         int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
 
         lastItem->setIcon(2, diskUsage->getIcon(item->mime()));
         lastItem->setData(0, Qt::DecorationRole, createPixmap(item->intPercent(), maxPercent, header()->sectionSize(0) - 2 * textMargin));
 
         if (showFileSize)
             lastItem->setData(2, Qt::UserRole, "  [" + KIO::convertSize(item->size()) + ']');
 
         QSize size = lastItem->sizeHint(0);
         size.setWidth(16);
         lastItem->setSizeHint(0, size);
     }
 
     if (topLevelItemCount() > 0) {
         setCurrentItem(topLevelItem(0));
     }
 }
 
 QPixmap DULines::createPixmap(int percent, int maxPercent, int maxWidth)
 {
     if (percent < 0 || percent > maxPercent || maxWidth < 2 || maxPercent == 0)
         return QPixmap();
     maxWidth -= 2;
 
     int actualWidth = maxWidth * percent / maxPercent;
     if (actualWidth == 0)
         return QPixmap();
 
     QPen pen;
     pen.setColor(Qt::black);
     QPainter painter;
 
     int size = QFontMetrics(font()).height() - 2;
     QRect rect(0, 0, actualWidth, size);
     QRect frameRect(0, 0, actualWidth - 1, size - 1);
     QPixmap pixmap(rect.width(), rect.height());
 
     painter.begin(&pixmap);
     painter.setPen(pen);
 
     for (int i = 1; i < actualWidth - 1; i++) {
         int color = (511 * i / (maxWidth - 1));
         if (color < 256)
             pen.setColor(QColor(255 - color, 255, 0));
         else
             pen.setColor(QColor(color - 256, 511 - color, 0));
 
         painter.setPen(pen);
         painter.drawLine(i, 1, i, size - 1);
     }
 
     pen.setColor(Qt::black);
     painter.setPen(pen);
 
     if (actualWidth != 1)
         painter.drawRect(frameRect);
     else
         painter.drawLine(0, 0, 0, size);
 
     painter.end();
     pixmap.detach();
     return pixmap;
 }
 
 void DULines::resizeEvent(QResizeEvent * re)
 {
     KrTreeWidget::resizeEvent(re);
 
     if (started && (re->oldSize() != re->size()))
         sectionResized(0);
 }
 
 void DULines::sectionResized(int column)
 {
     if (topLevelItemCount() == 0 || column != 0)
         return;
 
     Directory * currentDir = diskUsage->getCurrentDir();
     if (currentDir == nullptr)
         return;
 
     int maxPercent = -1;
     for (Iterator<File> it = currentDir->iterator(); it != currentDir->end(); ++it) {
         File *item = *it;
 
         if (!item->isExcluded() && item->intPercent() > maxPercent)
             maxPercent = item->intPercent();
     }
 
     QTreeWidgetItemIterator it2(this);
     while (*it2) {
         QTreeWidgetItem *lvitem = *it2;
         if (lvitem->text(0) != "..") {
             auto *duItem = dynamic_cast< DULinesItem *>(lvitem);
             if (duItem) {
                 int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
                 duItem->setData(0, Qt::DecorationRole, createPixmap(duItem->getFile()->intPercent(), maxPercent, header()->sectionSize(0) - 2 * textMargin));
                 QSize size = duItem->sizeHint(0);
                 size.setWidth(16);
                 duItem->setSizeHint(0, size);
             }
         }
         it2++;
     }
 }
 
 bool DULines::doubleClicked(QTreeWidgetItem * item)
 {
     if (item) {
         if (item->text(0) != "..") {
             File *fileItem = ((DULinesItem *)item)->getFile();
             if (fileItem->isDir())
                 diskUsage->changeDirectory(dynamic_cast<Directory *>(fileItem));
             return true;
         } else {
             auto *upDir = (Directory *)diskUsage->getCurrentDir()->parent();
 
             if (upDir)
                 diskUsage->changeDirectory(upDir);
             return true;
         }
     }
     return false;
 }
 
 void DULines::mouseDoubleClickEvent(QMouseEvent * e)
 {
     if (e || e->button() == Qt::LeftButton) {
         QPoint vp = viewport()->mapFromGlobal(e->globalPos());
         QTreeWidgetItem * item = itemAt(vp);
 
         if (doubleClicked(item))
             return;
 
     }
     KrTreeWidget::mouseDoubleClickEvent(e);
 }
 
 
 void DULines::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Return :
     case Qt::Key_Enter :
         if (doubleClicked(currentItem()))
             return;
         break;
     case Qt::Key_Left :
     case Qt::Key_Right :
     case Qt::Key_Up :
     case Qt::Key_Down :
         if (e->modifiers() == Qt::ShiftModifier) {
             e->ignore();
             return;
         }
         break;
     case Qt::Key_Delete :
         e->ignore();
         return;
     }
     KrTreeWidget::keyPressEvent(e);
 }
 
 void DULines::slotRightClicked(QTreeWidgetItem *item, const QPoint &pos)
 {
     File * file = nullptr;
 
     if (item && item->text(0) != "..")
         file = ((DULinesItem *)item)->getFile();
 
     QMenu linesPopup;
     QAction *act = linesPopup.addAction(i18n("Show file sizes"), this, SLOT(slotShowFileSizes()));
     act->setChecked(showFileSize);
 
     diskUsage->rightClickMenu(pos, file, &linesPopup, i18n("Lines"));
 }
 
 void DULines::slotShowFileSizes()
 {
     showFileSize = !showFileSize;
     slotDirChanged(diskUsage->getCurrentDir());
 }
 
 File * DULines::getCurrentFile()
 {
     QTreeWidgetItem *item = currentItem();
 
     if (item == nullptr || item->text(0) == "..")
         return nullptr;
 
     return ((DULinesItem *)item)->getFile();
 }
 
 void DULines::slotChanged(File * item)
 {
     QTreeWidgetItemIterator it(this);
     while (*it) {
         QTreeWidgetItem *lvitem = *it;
         it++;
 
         if (lvitem->text(0) != "..") {
             auto *duItem = (DULinesItem *)(lvitem);
             if (duItem->getFile() == item) {
                 setSortingEnabled(false);
                 duItem->setHidden(item->isExcluded());
                 duItem->setText(1, item->percent());
                 if (!refreshNeeded) {
                     refreshNeeded = true;
                     QTimer::singleShot(0, this, &DULines::slotRefresh);
                 }
                 break;
             }
         }
     }
 }
 
 void DULines::slotDeleted(File * item)
 {
     QTreeWidgetItemIterator it(this);
     while (*it) {
         QTreeWidgetItem *lvitem = *it;
         it++;
 
         if (lvitem->text(0) != "..") {
             auto *duItem = (DULinesItem *)(lvitem);
             if (duItem->getFile() == item) {
                 delete duItem;
                 break;
             }
         }
     }
 }
 
 void DULines::slotRefresh()
 {
     if (refreshNeeded) {
         refreshNeeded = false;
         setSortingEnabled(true);
         sortItems(1, Qt::AscendingOrder);
     }
 }
 
diff --git a/krusader/DiskUsage/dulistview.cpp b/krusader/DiskUsage/dulistview.cpp
index 95bbf828..06c51c65 100644
--- a/krusader/DiskUsage/dulistview.cpp
+++ b/krusader/DiskUsage/dulistview.cpp
@@ -1,271 +1,273 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "dulistview.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../FileSystem/krpermhandler.h"
 
 // QtCore
 #include <QMimeDatabase>
 #include <QMimeType>
 // QtGui
 #include <QMouseEvent>
 #include <QFontMetrics>
 #include <QKeyEvent>
 // QtWidgets
 #include <QHeaderView>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 
+#include "../compat.h"
+
 DUListView::DUListView(DiskUsage *usage)
         : KrTreeWidget(usage), diskUsage(usage)
 {
     setAllColumnsShowFocus(true);
     setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     setRootIsDecorated(true);
     setIndentation(10);
     setItemsExpandable(true);
 
     QStringList labels;
     labels << i18n("Name");
     labels << i18n("Percent");
     labels << i18n("Total size");
     labels << i18n("Own size");
     labels << i18n("Type");
     labels << i18n("Date");
     labels << i18n("Permissions");
     labels << i18n("Owner");
     labels << i18n("Group");
     setHeaderLabels(labels);
 
     header()->setSectionResizeMode(QHeaderView::Interactive);
 
     KConfigGroup group(krConfig, diskUsage->getConfigGroup());
 
     if (group.hasKey("D State"))
         header()->restoreState(group.readEntry("D State", QByteArray()));
     else {
-        int defaultSize = QFontMetrics(font()).width("W");
+        int defaultSize = QFontMetrics(font()).QFONTMETRICS_WIDTH("W");
 
         setColumnWidth(0, defaultSize * 20);
         setColumnWidth(1, defaultSize * 5);
         setColumnWidth(2, defaultSize * 10);
         setColumnWidth(3, defaultSize * 10);
         setColumnWidth(4, defaultSize * 10);
         setColumnWidth(5, defaultSize * 10);
         setColumnWidth(6, defaultSize * 6);
         setColumnWidth(7, defaultSize * 5);
         setColumnWidth(8, defaultSize * 5);
     }
 
     header()->setSortIndicatorShown(true);
     sortItems(2, Qt::AscendingOrder);
 
     connect(diskUsage, &DiskUsage::enteringDirectory, this, &DUListView::slotDirChanged);
     connect(diskUsage, &DiskUsage::clearing, this, &DUListView::clear);
     connect(diskUsage, &DiskUsage::changed, this, &DUListView::slotChanged);
     connect(diskUsage, &DiskUsage::deleted, this, &DUListView::slotDeleted);
 
     connect(this, &DUListView::itemRightClicked, this, &DUListView::slotRightClicked);
     connect(this, &DUListView::itemExpanded, this, &DUListView::slotExpanded);
 }
 
 DUListView::~ DUListView()
 {
     KConfigGroup group(krConfig, diskUsage->getConfigGroup());
     group.writeEntry("D State", header()->saveState());
 }
 
 void DUListView::addDirectory(Directory *dirEntry, QTreeWidgetItem *parent)
 {
     QTreeWidgetItem * lastItem = nullptr;
 
     if (parent == nullptr && !(dirEntry->parent() == nullptr)) {
         lastItem = new QTreeWidgetItem(this);
         lastItem->setText(0, "..");
         lastItem->setIcon(0, Icon("go-up"));
         lastItem->setFlags(Qt::ItemIsEnabled);
     }
 
     for (Iterator<File> it = dirEntry->iterator(); it != dirEntry->end(); ++it) {
         File *item = *it;
 
         QMimeDatabase db;
         QMimeType mt = db.mimeTypeForName(item->mime());
         QString mime;
         if (mt.isValid())
             mime = mt.comment();
 
         time_t tma = item->time();
         struct tm* t = localtime((time_t *) & tma);
         QDateTime tmp(QDate(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday), QTime(t->tm_hour, t->tm_min));
         QString date = QLocale().toString(tmp, QLocale::ShortFormat);
 
         QString totalSize = KRpermHandler::parseSize(item->size()) + ' ';
         QString ownSize = KRpermHandler::parseSize(item->ownSize()) + ' ';
         QString percent = item->percent();
 
         if (lastItem == nullptr && parent == nullptr)
             lastItem = new DUListViewItem(diskUsage, item, this, item->name(), percent, totalSize, ownSize,
                                           mime, date, item->perm(), item->owner(), item->group());
         else if (lastItem == nullptr)
             lastItem = new DUListViewItem(diskUsage, item, parent, item->name(), percent, totalSize, ownSize,
                                           mime, date, item->perm(), item->owner(), item->group());
         else if (parent == nullptr)
             lastItem = new DUListViewItem(diskUsage, item, this, lastItem, item->name(), percent, totalSize,
                                           ownSize, mime, date, item->perm(), item->owner(), item->group());
         else
             lastItem = new DUListViewItem(diskUsage, item, parent, lastItem, item->name(), percent, totalSize,
                                           ownSize, mime, date, item->perm(), item->owner(), item->group());
 
         if (item->isExcluded())
             lastItem->setHidden(true);
 
         lastItem->setIcon(0, diskUsage->getIcon(item->mime()));
 
         if (item->isDir() && !item->isSymLink())
             lastItem->setChildIndicatorPolicy(QTreeWidgetItem::ShowIndicator);
     }
 
     if (topLevelItemCount() > 0) {
         setCurrentItem(topLevelItem(0));
     }
 }
 
 void DUListView::slotDirChanged(Directory *dirEntry)
 {
     clear();
     addDirectory(dirEntry, nullptr);
 }
 
 File * DUListView::getCurrentFile()
 {
     QTreeWidgetItem *item = currentItem();
 
     if (item == nullptr || item->text(0) == "..")
         return nullptr;
 
     return ((DUListViewItem *)item)->getFile();
 }
 
 void DUListView::slotChanged(File * item)
 {
     void * itemPtr = diskUsage->getProperty(item, "ListView-Ref");
     if (itemPtr == nullptr)
         return;
 
     auto *duItem = (DUListViewItem *)itemPtr;
     duItem->setHidden(item->isExcluded());
     duItem->setText(1, item->percent());
     duItem->setText(2, KRpermHandler::parseSize(item->size()) + ' ');
     duItem->setText(3, KRpermHandler::parseSize(item->ownSize()) + ' ');
 }
 
 void DUListView::slotDeleted(File * item)
 {
     void * itemPtr = diskUsage->getProperty(item, "ListView-Ref");
     if (itemPtr == nullptr)
         return;
 
     auto *duItem = (DUListViewItem *)itemPtr;
     delete duItem;
 }
 
 void DUListView::slotRightClicked(QTreeWidgetItem *item, const QPoint & pos)
 {
     File * file = nullptr;
 
     if (item && item->text(0) != "..")
         file = ((DUListViewItem *)item)->getFile();
 
     diskUsage->rightClickMenu(pos, file);
 }
 
 bool DUListView::doubleClicked(QTreeWidgetItem * item)
 {
     if (item) {
         if (item->text(0) != "..") {
             File *fileItem = ((DUListViewItem *)item)->getFile();
             if (fileItem->isDir())
                 diskUsage->changeDirectory(dynamic_cast<Directory *>(fileItem));
             return true;
         } else {
             auto *upDir = (Directory *)diskUsage->getCurrentDir()->parent();
 
             if (upDir)
                 diskUsage->changeDirectory(upDir);
             return true;
         }
     }
     return false;
 }
 
 void DUListView::mouseDoubleClickEvent(QMouseEvent * e)
 {
     if (e || e->button() == Qt::LeftButton) {
         QPoint vp = viewport()->mapFromGlobal(e->globalPos());
         QTreeWidgetItem * item = itemAt(vp);
 
         if (doubleClicked(item))
             return;
 
     }
     KrTreeWidget::mouseDoubleClickEvent(e);
 }
 
 void DUListView::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Return :
     case Qt::Key_Enter :
         if (doubleClicked(currentItem()))
             return;
         break;
     case Qt::Key_Left :
     case Qt::Key_Right :
     case Qt::Key_Up :
     case Qt::Key_Down :
         if (e->modifiers() == Qt::ShiftModifier) {
             e->ignore();
             return;
         }
         break;
     case Qt::Key_Delete :
         e->ignore();
         return;
     }
     KrTreeWidget::keyPressEvent(e);
 }
 
 void DUListView::slotExpanded(QTreeWidgetItem * item)
 {
     if (item == nullptr || item->text(0) == "..")
         return;
 
     if (item->childCount() == 0) {
         File *fileItem = ((DUListViewItem *)item)->getFile();
         if (fileItem->isDir())
             addDirectory(dynamic_cast<Directory *>(fileItem), item);
     }
 }
 
diff --git a/krusader/DiskUsage/radialMap/labels.cpp b/krusader/DiskUsage/radialMap/labels.cpp
index e418b96a..fa8ca917 100644
--- a/krusader/DiskUsage/radialMap/labels.cpp
+++ b/krusader/DiskUsage/radialMap/labels.cpp
@@ -1,366 +1,367 @@
 /*****************************************************************************
  * Copyright (C) 2003-2004 Max Howell <max.howell@methylblue.com>            *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 // QtCore
 #include <QList>
 // QtGui
 #include <QFont>
 #include <QFontMetrics>
 #include <QPainter>
 
 #include <KCoreAddons/KStringHandler>
 
 #include "Config.h"
 #include "fileTree.h"
 #include "radialMap.h"
 #include "sincos.h"
 #include "widget.h"
+#include "../compat.h"
 
 namespace RadialMap
 {
 struct Label {
     Label(const RadialMap::Segment *s, int l) : segment(s), lvl(l), a(segment->start() + (segment->length() / 2)) { }
 
     bool tooClose(const int &aa) const {
         return (a > aa - LABEL_ANGLE_MARGIN && a < aa + LABEL_ANGLE_MARGIN);
     }
 
     const RadialMap::Segment *segment;
     const unsigned int lvl;
     const int a;
 
     int x1, y1, x2, y2, x3;
     int tx, ty;
 
     QString qs;
 };
 
 class LabelList : public QList<Label *>
 {
 
 public:
     ~LabelList() {
         QListIterator<Label *> it(*this);
         while (it.hasNext())
             delete it.next();
     }
 
     void inSort(Label * label1) {
         for (QList<Label *>::iterator it(begin()); it != end(); ++it) {
             Label * label2 = *it;
             bool ins = false;
 
             //you add 1440 to work round the fact that later you want the circle split vertically
             //and as it is you start at 3 o' clock. It's to do with rightPrevY, stops annoying bug
 
             int a1 = label1->a + 1440;
             int a2 = label2->a + 1440;
 
             if (a1 == a2)
                 ins = true;
 
             if (a1 > 5760) a1 -= 5760;
             if (a2 > 5760) a2 -= 5760;
 
             if (a1 < a2)
                 ins = true;
 
             if (ins) {
                 insert(it, label1);
                 return;
             }
         }
 
         append(label1);
     }
 };
 }
 
 
 void
 RadialMap::Widget::paintExplodedLabels(QPainter &paint) const
 {
     //we are a friend of RadialMap::Map
 
     LabelList list;
     unsigned int startLevel = 0;
 
 
     //1. Create list of labels  sorted in the order they will be rendered
 
     if (m_focus != nullptr && m_focus->file() != m_tree) { //separate behavior for selected vs unselected segments
         //don't bother with files
         if (m_focus->file() == nullptr || !m_focus->file()->isDir()) return;
 
         //find the range of levels we will be potentially drawing labels for
         for (const auto *p = (const Directory *)m_focus->file();
                 p != m_tree;
                 ++startLevel) { //startLevel is the level above whatever m_focus is in
             p = p->parent();
         }
 
         //range=2 means 2 levels to draw labels for
 
         unsigned int a1, a2, minAngle;
 
         a1 = m_focus->start();
         a2 = m_focus->end();  // boundary angles
         minAngle = int(m_focus->length() * LABEL_MIN_ANGLE_FACTOR);
 
 
 #define segment (*it)
 #define ring (m_map.m_signature + i)
 
         //**** Levels should be on a scale starting with 0
         //**** range is a useless parameter
         //**** keep a topblock var which is the lowestLevel OR startLevel for indentation purposes
         for (unsigned int i = startLevel; i <= m_map.m_visibleDepth; ++i) {
             for (Iterator<Segment> it = ring->iterator(); it != ring->end(); ++it)
                 if (segment->start() >= a1 && segment->end() <= a2)
                     if (segment->length() > minAngle)
                         list.inSort(new Label(segment, i));
         }
 
 #undef ring
 #undef segment
 
     } else {
 
 #define ring m_map.m_signature
 
         for (Iterator<Segment> it = ring->iterator(); it != ring->end(); ++it)
             if ((*it)->length() > 288)
                 list.inSort(new Label((*it), 0));
 
 #undef ring
 
     }
 
     //2. Check to see if any adjacent labels are too close together
     //   if so, remove the least significant labels
 
     int itn = 0;
     int jtn = 1;
 
     while (jtn < list.count()) {
         //this method is fairly efficient
 
         if (list[ itn ]->tooClose(list[ jtn ]->a)) {
             if (list[ itn ]->lvl > list[ jtn ]->lvl) {
                 delete list[ itn ];
                 list.removeAt(itn);
                 jtn--;
                 itn = jtn;
             } else {
                 delete list[ jtn ];
                 list.removeAt(jtn);
             }
         } else
             ++itn;
 
         jtn = itn;
         ++jtn;
     }
 
     LabelList::iterator it = list.begin();
 
     //used in next two steps
     bool varySizes;
     //**** should perhaps use doubles
     auto  *sizes = new int [ m_map.m_visibleDepth + 1 ]; //**** make sizes an array of floats I think instead (or doubles)
 
     do {
         //3. Calculate font sizes
 
         {
             //determine current range of levels to draw for
             unsigned int range = 0;
 
             for (it = list.begin(); it != list.end(); ++it) {
                 unsigned int lvl = (*it)->lvl;
                 if (lvl > range)
                     range = lvl;
 
                 //**** better way would just be to assign if nothing is range
             }
 
             range -= startLevel; //range 0 means 1 level of labels
 
             varySizes = Config::varyLabelFontSizes && (range != 0);
 
             if (varySizes) {
                 //create an array of font sizes for various levels
                 //will exceed normal font pitch automatically if necessary, but not minPitch
                 //**** this needs to be checked lots
 
                 //**** what if this is negative (min size gtr than default size)
                 unsigned int step = (paint.font().pointSize() - Config::minFontPitch) / range;
                 if (step == 0) step = 1;
 
                 for (unsigned int x = range + startLevel, y = Config::minFontPitch;
                         x >= startLevel;
                         y += step, --x) {
                     sizes[x] = y;
                 }
             }
         }
 
         //4. determine label co-ordinates
 
         int x1, y1, x2, y2, x3, tx, ty; //coords
         double sinra, cosra, ra;  //angles
 
         int cx = m_map.width()  / 2 + m_offset.x();  //centre relative to canvas
         int cy = m_map.height() / 2 + m_offset.y();
 
         int spacer, preSpacer = int(m_map.m_ringBreadth * 0.5) + m_map.m_innerRadius;
         int fullStrutLength = (m_map.width() - m_map.MAP_2MARGIN) / 2 + LABEL_MAP_SPACER;   //full length of a strut from map center
 
         int prevLeftY  = 0;
         int prevRightY = height();
 
         bool rightSide;
 
         QFont font;
 
         for (it = list.begin(); it != list.end(); ++it) {
             //** bear in mind that text is drawn with QPoint param as BOTTOM left corner of text box
             if (varySizes) font.setPointSize(sizes[(*it)->lvl]);
             QFontMetrics fm(font);
             int fmh  = fm.height(); //used to ensure label texts don't overlap
             int fmhD4 = fmh / 4;
 
             fmh += LABEL_TEXT_VMARGIN;
 
             rightSide = ((*it)->a < 1440 || (*it)->a > 4320);
 
             ra = M_PI / 2880 * (*it)->a; //convert to radians
 #if 0
             sincos(ra, &sinra, &cosra);
 #endif
             sinra = sin(ra); cosra = cos(ra);
 
             spacer = preSpacer + m_map.m_ringBreadth * (*it)->lvl;
 
             x1 = cx + (int)(cosra * spacer);
             y1 = cy - (int)(sinra * spacer);
             y2 = y1 - (int)(sinra * (fullStrutLength - spacer));
 
             if (rightSide) {  //righthand side, going upwards
 
                 if (y2 > prevRightY /*- fmh*/)  //then it is too low, needs to be drawn higher
                     y2 = prevRightY /*- fmh*/;
 
             } else { //lefthand side, going downwards
 
                 if (y2 < prevLeftY/* + fmh*/)  //then we're too high, need to be drawn lower
                     y2 = prevLeftY /*+ fmh*/;
             }
 
             x2 = x1 - int(double(y2 - y1) / tan(ra));
             ty = y2 + fmhD4;
 
             QString qs;
             if (rightSide) {
 
                 if (x2 > width() || ty < fmh || x2 < x1) {
                     //skip this strut
                     //**** don't duplicate this code
                     delete *it;
                     it = list.erase(it);   //will delete the label and set it to list.current() which _should_ be the next ptr
                     break;
                 }
 
                 prevRightY = ty - fmh - fmhD4; //must be after above's "continue"
 
                 qs = fm.elidedText((*it)->segment->file()->name(), Qt::ElideMiddle, width() - x2);
 
-                x3 = width() - fm.width(qs)
+                x3 = width() - fm.QFONTMETRICS_WIDTH(qs)
                      - LABEL_HMARGIN //outer margin
                      - LABEL_TEXT_HMARGIN //margin between strut and text
                      //- ((*it)->lvl - startLevel) * LABEL_HMARGIN //indentation
                      ;
                 if (x3 < x2) x3 = x2;
                 tx = x3 + LABEL_TEXT_HMARGIN;
 
             } else {
 
                 if (x2 < 0 || ty > height() || x2 > x1) {
                     //skip this strut
                     delete *it;
                     it = list.erase(it);   //will delete the label and set it to list.current() which _should_ be the next ptr
                     break;
                 }
 
                 prevLeftY = ty + fmh - fmhD4;
 
                 qs = fm.elidedText((*it)->segment->file()->name(), Qt::ElideMiddle, x2);
 
                 //**** needs a little tweaking:
 
-                tx = fm.width(qs) + LABEL_HMARGIN/* + ((*it)->lvl - startLevel) * LABEL_HMARGIN*/;
+                tx = fm.QFONTMETRICS_WIDTH(qs) + LABEL_HMARGIN/* + ((*it)->lvl - startLevel) * LABEL_HMARGIN*/;
                 if (tx > x2) {  //text is too long
                     tx = LABEL_HMARGIN + x2 - tx; //some text will be lost from sight
                     x3 = x2; //no text margin (right side of text here)
                 } else {
                     x3 = tx + LABEL_TEXT_HMARGIN;
                     tx = LABEL_HMARGIN /* + ((*it)->lvl - startLevel) * LABEL_HMARGIN*/;
                 }
             }
 
             (*it)->x1 = x1;
             (*it)->y1 = y1;
             (*it)->x2 = x2;
             (*it)->y2 = y2;
             (*it)->x3 = x3;
             (*it)->tx = tx;
             (*it)->ty = ty;
             (*it)->qs = qs;
         }
 
         //if an element is deleted at this stage, we need to do this whole
         //iteration again, thus the following loop
         //**** in rare case that deleted label was last label in top level
         //     and last in labelList too, this will not work as expected (not critical)
 
     } while (it != list.end());
 
 
     //5. Render labels
 
     paint.setPen(QPen(Qt::black, 1));
 
     for (it = list.begin(); it != list.end(); ++it) {
         if (varySizes) {
             //**** how much overhead in making new QFont each time?
             //     (implicate sharing remember)
             QFont font = paint.font();
             font.setPointSize(sizes[(*it)->lvl]);
             paint.setFont(font);
         }
 
         paint.drawEllipse((*it)->x1 - 3, (*it)->y1 - 3, 7, 7);   //**** CPU intensive! better to use a pixmap
         paint.drawLine((*it)->x1, (*it)->y1, (*it)->x2, (*it)->y2);
         paint.drawLine((*it)->x2, (*it)->y2, (*it)->x3, (*it)->y2);
         paint.drawText((*it)->tx, (*it)->ty, (*it)->qs);
     }
 
     delete [] sizes;
 }
diff --git a/krusader/DiskUsage/radialMap/segmentTip.cpp b/krusader/DiskUsage/radialMap/segmentTip.cpp
index 9c33b835..d392f907 100644
--- a/krusader/DiskUsage/radialMap/segmentTip.cpp
+++ b/krusader/DiskUsage/radialMap/segmentTip.cpp
@@ -1,187 +1,188 @@
 /*****************************************************************************
  * Copyright (C) 2003-2004 Max Howell <max.howell@methylblue.com>            *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "segmentTip.h"
 
 // QtCore
 #include <QEvent>
 // QtGui
 #include <QPainter>
 // QtWidgets
 #include <QApplication>                           //installing eventFilters
 #include <QDesktopWidget>
 #include <QToolTip>                               //for its palette
 
 #include <KI18n/KLocalizedString>
 
 #include "fileTree.h"
+#include "../compat.h"
 
 namespace RadialMap
 {
 
 SegmentTip::SegmentTip(uint h)
         : QWidget(nullptr, Qt::FramelessWindowHint | Qt::Tool | Qt::WindowStaysOnTopHint | Qt::X11BypassWindowManagerHint)
         , m_cursorHeight(-h)
 {
     setAttribute(Qt::WA_NoSystemBackground, true);
 }
 
 void
 SegmentTip::moveto(QPoint p, QWidget &canvas, bool placeAbove)
 {
     //**** this function is very slow and seems to be visibly influenced by operations like mapFromGlobal() (who knows why!)
     //  ** so any improvements are much desired
 
     //TODO uints could improve the class
     p.rx() -= rect().center().x();
     p.ry() -= (placeAbove ? 8 + height() : m_cursorHeight - 8);
 
     const QRect screen = QApplication::desktop()->screenGeometry(parentWidget());
 
     const int x  = p.x();
     const int y  = p.y();
     const int x2 = x + width();
     const int y2 = y + height(); //how's it ever gunna get below screen height?! (well you never know I spose)
     const int sw = screen.width();
     const int sh = screen.height();
 
     if (x  < 0) p.setX(0);
     if (y  < 0) p.setY(0);
     if (x2 > sw) p.rx() -= x2 - sw;
     if (y2 > sh) p.ry() -= y2 - sh;
 
 
     //I'm using this QPoint to determine where to offset the bitBlt in m_pixmap
     QPoint offset = canvas.mapToGlobal(QPoint()) - p;
     if (offset.x() < 0) offset.setX(0);
     if (offset.y() < 0) offset.setY(0);
 
 
     const QRect alphaMaskRect(canvas.mapFromGlobal(p), size());
     const QRect intersection(alphaMaskRect.intersected(canvas.rect()));
 
     m_pixmap = QPixmap(size());   //move to updateTip once you are sure it can never be null
     //bitBlt( &m_pixmap, offset, &canvas, intersection, Qt::CopyROP );
     QPainter(&m_pixmap).drawPixmap(offset, canvas.grab(intersection));
 
     QColor col = QToolTip::palette().color(QPalette::Active, QPalette::Window);
     col.setAlpha(153);   // 0.6
 
     QRect rct = rect();
     if (rct.width())
         rct.setWidth(rct.width() - 1);
     if (rct.height())
         rct.setHeight(rct.height() - 1);
 
     QPainter paint(&m_pixmap);
     paint.setPen(Qt::black);
     paint.setBrush(col);
     paint.drawRect(rct);
     paint.end();
 
     paint.begin(&m_pixmap);
     paint.drawText(rect(), Qt::AlignCenter, m_text);
     paint.end();
 
     p += screen.topLeft(); //for Xinerama users
 
     move(x, y);
     show();
     repaint();
 }
 
 void
 SegmentTip::updateTip(const File* const file, const Directory* const root)
 {
     const QString s1  = file->fullPath(root);
     QString s2        = file->humanReadableSize();
     QLocale loc;
     const uint MARGIN = 3;
     const uint pc     = 100 * file->size() / root->size();
     uint maxw         = 0;
     uint h            = fontMetrics().height() * 2 + 2 * MARGIN;
 
     if (pc > 0) s2 += QString(" (%1%)").arg(loc.toString(pc));
 
     m_text  = s1;
     m_text += '\n';
     m_text += s2;
 
     if (file->isDir()) {
         double files  = dynamic_cast<const Directory*>(file)->fileCount();
         const auto pc = uint((100 * files) / (double)root->fileCount());
         QString s3    = i18n("Files: %1", loc.toString(files, 'f', 0));
 
         if (pc > 0) s3 += QString(" (%1%)").arg(loc.toString(pc));
 
-        maxw    = fontMetrics().width(s3);
+        maxw    = fontMetrics().QFONTMETRICS_WIDTH(s3);
         h      += fontMetrics().height();
         m_text += '\n';
         m_text += s3;
     }
 
     uint
-    w = fontMetrics().width(s1); if (w > maxw) maxw = w;
-    w = fontMetrics().width(s2); if (w > maxw) maxw = w;
+    w = fontMetrics().QFONTMETRICS_WIDTH(s1); if (w > maxw) maxw = w;
+    w = fontMetrics().QFONTMETRICS_WIDTH(s2); if (w > maxw) maxw = w;
 
     resize(maxw + 2 * MARGIN, h);
 }
 
 bool
 SegmentTip::event(QEvent *e)
 {
     switch (e->type()) {
     case QEvent::Show:
         qApp->installEventFilter(this);
         break;
     case QEvent::Hide:
         qApp->removeEventFilter(this);
         break;
     case QEvent::Paint: {
         // bitBlt( this, 0, 0, &m_pixmap );
         QPainter(this).drawPixmap(0, 0, m_pixmap);
         return true;
     }
     default:
         ;
     }
 
     return false/*QWidget::event( e )*/;
 }
 
 bool
 SegmentTip::eventFilter(QObject*, QEvent *e)
 {
     switch (e->type()) {
     case QEvent::Leave:
 //    case QEvent::MouseButtonPress:
 //    case QEvent::MouseButtonRelease:
     case QEvent::KeyPress:
     case QEvent::KeyRelease:
     case QEvent::FocusIn:
     case QEvent::FocusOut:
     case QEvent::Wheel:
         hide(); //FALL THROUGH
     default:
         return false; //allow this event to passed to target
     }
 }
 
 } //namespace RadialMap
diff --git a/krusader/GUI/kcmdline.cpp b/krusader/GUI/kcmdline.cpp
index 6d50f683..419128ac 100644
--- a/krusader/GUI/kcmdline.cpp
+++ b/krusader/GUI/kcmdline.cpp
@@ -1,316 +1,316 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kcmdline.h"
 
 // QtCore
 #include <QDir>
 #include <QStringList>
 #include <QUrl>
 // QtGui
 #include <QKeyEvent>
 #include <QIcon>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QImage>
 // QtWidgets
 #include <QSizePolicy>
 #include <QGridLayout>
 #include <QFrame>
 #include <QLabel>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <utility>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../krslots.h"
 #include "../defaults.h"
 #include "../krusaderview.h"
 #include "../krservices.h"
 #include "../ActionMan/addplaceholderpopup.h"
 #include "kcmdmodebutton.h"
-
+#include "../compat.h"
 
 CmdLineCombo::CmdLineCombo(QWidget *parent) : KHistoryComboBox(parent), _handlingLineEditResize(false)
 {
     lineEdit()->installEventFilter(this);
     _pathLabel = new QLabel(this);
     _pathLabel->setWhatsThis(i18n("Name of folder where command will be processed."));
     _pathLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
 }
 
 bool CmdLineCombo::eventFilter(QObject *watched, QEvent *e)
 {
     if(watched == lineEdit() && (e->type() == QEvent::Move || e->type() == QEvent::Resize)) {
         if(!_handlingLineEditResize) { // avoid infinite recursion
             _handlingLineEditResize = true;
             updateLineEditGeometry();
             _handlingLineEditResize = false;
         }
     }
     return false;
 }
 
 void CmdLineCombo::setPath(QString path)
 {
     _path = std::move(path);
     doLayout();
 }
 
 void CmdLineCombo::updateLineEditGeometry()
 {
     QRect r = lineEdit()->geometry();
     r.setLeft(_pathLabel->geometry().right());
     lineEdit()->setGeometry(r);
 }
 
 void CmdLineCombo::doLayout()
 {
     QString pathNameLabel = _path;
     QFontMetrics fm(_pathLabel->fontMetrics());
-    int textWidth = fm.width(_path);
+    int textWidth = fm.QFONTMETRICS_WIDTH(_path);
     int maxWidth = (width() + _pathLabel->width()) * 2 / 5;
     int letters = _path.length() / 2;
 
     while (letters && textWidth > maxWidth) {
         pathNameLabel = _path.left(letters) + "..." + _path.right(letters);
         letters--;
-        textWidth = fm.width(pathNameLabel);
+        textWidth = fm.QFONTMETRICS_WIDTH(pathNameLabel);
     }
 
     _pathLabel->setText(pathNameLabel + "> ");
     _pathLabel->adjustSize();
 
     QStyleOptionComboBox opt;
     initStyleOption(&opt);
     QRect labelRect = style()->subControlRect(QStyle::CC_ComboBox, &opt,
                                             QStyle::SC_ComboBoxEditField, this);
     labelRect.adjust(2, 0, 0, 0);
     labelRect.setWidth(_pathLabel->width());
     _pathLabel->setGeometry(labelRect);
 
     updateLineEditGeometry();
 }
 
 void CmdLineCombo::resizeEvent(QResizeEvent *e)
 {
     KHistoryComboBox::resizeEvent(e);
     doLayout();
 }
 
 void CmdLineCombo::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Enter:
     case Qt::Key_Return:
         if (e->modifiers() & Qt::ControlModifier) {
             SLOTS->insertFileName((e->modifiers()&Qt::ShiftModifier)!=0);
             break;
         }
         KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Down:
         if (e->modifiers()  == (Qt::ControlModifier | Qt::ShiftModifier)) {
             MAIN_VIEW->focusTerminalEmulator();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Up:
         if (e->modifiers() == Qt::ControlModifier || e->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {
             emit returnToPanel();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Escape:
         if (e->modifiers() == 0) {
             emit returnToPanel();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     default:
         KHistoryComboBox::keyPressEvent(e);
     }
 }
 
 
 KCMDLine::KCMDLine(QWidget *parent) : QWidget(parent)
 {
     auto * layout = new QGridLayout(this);
     layout->setSpacing(0);
     layout->setContentsMargins(0, 0, 0, 0);
 
     int height = QFontMetrics(QFontDatabase::systemFont(QFontDatabase::GeneralFont)).height();
     height =  height + 5 * (height > 14) + 6;
 
     // and editable command line
     completion.setMode(KUrlCompletion::FileCompletion);
     cmdLine = new CmdLineCombo(this);
     cmdLine->setMaxCount(100);  // remember 100 commands
     cmdLine->setMinimumContentsLength(10);
     cmdLine->setDuplicatesEnabled(false);
     cmdLine->setMaximumHeight(height);
     cmdLine->setCompletionObject(&completion);
     cmdLine->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
     // load the history
     KConfigGroup grpSvr(krConfig, "Private");
     QStringList list = grpSvr.readEntry("cmdline history", QStringList());
     cmdLine->setHistoryItems(list);
 
     connect(cmdLine, QOverload<const QString &>::of(&CmdLineCombo::returnPressed), this, &KCMDLine::slotRun);
     connect(cmdLine, QOverload<const QString &>::of(&CmdLineCombo::returnPressed), cmdLine->lineEdit(), &QLineEdit::clear);
     connect(cmdLine, &CmdLineCombo::returnToPanel, this, &KCMDLine::slotReturnFocus);
 
     cmdLine->setWhatsThis(i18n("<qt><p>Well, it is actually quite simple: you type your command here and Krusader obeys.</p><p><b>Tip</b>: move within command line history with &lt;Up&gt; and &lt;Down&gt; arrows.</p></qt>"));
     layout->addWidget(cmdLine, 0, 1);
 
     buttonAddPlaceholder = new QToolButton(this);
     buttonAddPlaceholder->setAutoRaise(true);
     buttonAddPlaceholder->setIcon(Icon("list-add"));
     connect(buttonAddPlaceholder, &QToolButton::clicked, this, &KCMDLine::addPlaceholder);
     buttonAddPlaceholder->setWhatsThis(i18n("Add <b>Placeholders</b> for the selected files in the panel."));
 
     layout->addWidget(buttonAddPlaceholder, 0, 2);
 
     // a run in terminal button
     terminal = new KCMDModeButton(this);
     terminal->setAutoRaise(true);
     layout->addWidget(terminal, 0, 3);
 
     layout->activate();
 }
 
 KCMDLine::~KCMDLine()
 {
     KConfigGroup grpSvr(krConfig, "Private");
     QStringList list = cmdLine->historyItems();
     //qWarning() << list[0];
     grpSvr.writeEntry("cmdline history", list);
     krConfig->sync();
 }
 
 void KCMDLine::addPlaceholder()
 {
     AddPlaceholderPopup popup(this);
     QString exp = popup.getPlaceholder(
                       buttonAddPlaceholder->mapToGlobal(QPoint(0, 0))
                   );
     this->addText(exp);
 }
 
 void KCMDLine::setCurrent(const QString &path)
 {
     cmdLine->setPath(path);
 
     completion.setDir(QUrl::fromLocalFile(path));
     // make sure our command is executed in the right directory
     // This line is important for Krusader overall functions -> do not remove !
     QDir::setCurrent(path);
 }
 
 void KCMDLine::slotRun()
 {
     const QString command1(cmdLine->currentText());
     if (command1.isEmpty())
         return;
 
     cmdLine->addToHistory(command1);
     // bugfix by aardvark: current editline is destroyed by addToHistory() in some cases
     cmdLine->setEditText(command1);
 
     if (command1.simplified().left(3) == "cd ") {     // cd command effect the active panel
         QString dir = command1.right(command1.length() - command1.indexOf(" ")).trimmed();
         if (dir == "~")
             dir = QDir::homePath();
         else if (dir.left(1) != "/" && !dir.contains(":/"))
             dir = cmdLine->path() + (cmdLine->path() == "/" ? "" : "/") + dir;
         SLOTS->refresh(QUrl::fromUserInput(dir,QDir::currentPath(),QUrl::AssumeLocalFile));
     } else {
         exec();
         cmdLine->clearEditText();
     }
 }
 
 
 void KCMDLine::slotReturnFocus()
 {
     MAIN_VIEW->cmdLineUnFocus();
 }
 
 static const KrActionBase::ExecType execModesMenu[] = {
     KrActionBase::Normal,
     KrActionBase::CollectOutputSeparateStderr,
     KrActionBase::CollectOutput,
     KrActionBase::Terminal,
     KrActionBase::RunInTE,
 };
 
 QString KCMDLine::command() const
 {
     return cmdLine->currentText();
 }
 
 KrActionBase::ExecType KCMDLine::execType() const
 {
     KConfigGroup grp(krConfig, "Private");
     int i = grp.readEntry("Command Execution Mode", (int)0);
     return execModesMenu[i];
 }
 
 QString KCMDLine::startpath() const
 {
     return cmdLine->path();
 //     return path->text().left(path->text().length() - 1);
 }
 
 QString KCMDLine::user() const
 {
     return QString();
 }
 
 QString KCMDLine::text() const
 {
     return cmdLine->currentText();
 }
 
 bool KCMDLine::acceptURLs() const
 {
     return false;
 }
 
 bool KCMDLine::confirmExecution() const
 {
     return false;
 }
 
 bool KCMDLine::doSubstitution() const
 {
     return true;
 }
 
 void KCMDLine::setText(const QString& text)
 {
     cmdLine->lineEdit()->setText(text);
 }
diff --git a/krusader/GUI/krtreewidget.cpp b/krusader/GUI/krtreewidget.cpp
index b0a63518..dbad73a5 100644
--- a/krusader/GUI/krtreewidget.cpp
+++ b/krusader/GUI/krtreewidget.cpp
@@ -1,202 +1,203 @@
 /*****************************************************************************
  * Copyright (C) 2008 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2008-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krtreewidget.h"
 #include "krstyleproxy.h"
+#include "../compat.h"
 
 // QtGui
 #include <QContextMenuEvent>
 // QtWidgets
 #include <QStyleOptionViewItem>
 #include <QToolTip>
 #include <QHeaderView>
 #include <QApplication>
 
 KrTreeWidget::KrTreeWidget(QWidget * parent) : QTreeWidget(parent), _inResize(false)
 {
     setRootIsDecorated(false);
     setSortingEnabled(true);
     setAllColumnsShowFocus(true);
 
     _stretchingColumn = -1;
 
     auto *krstyle = new KrStyleProxy();
     krstyle->setParent(this);
     setStyle(krstyle);
 }
 
 bool KrTreeWidget::event(QEvent * event)
 {
     switch (event->type()) {
         // HACK: QT 4 Context menu key isn't handled properly
     case QEvent::ContextMenu: {
         auto* ce = (QContextMenuEvent*) event;
 
         if (ce->reason() == QContextMenuEvent::Mouse) {
             QPoint pos = viewport()->mapFromGlobal(ce->globalPos());
 
             QTreeWidgetItem * item = itemAt(pos);
             int column = columnAt(pos.x());
 
             emit itemRightClicked(item, ce->globalPos(), column);
             return true;
         } else {
             if (currentItem()) {
                 QRect r = visualItemRect(currentItem());
                 QPoint p = viewport()->mapToGlobal(QPoint(r.x() + 5, r.y() + 5));
 
                 emit itemRightClicked(currentItem(), p, currentColumn());
                 return true;
             }
         }
     }
     break;
     case QEvent::KeyPress: {
         // HACK: QT 4 Ctrl+A bug fix: Ctrl+A doesn't work if QTreeWidget contains parent / child items
         //       Insert doesn't change the selections for multi selection modes
         auto* ke = (QKeyEvent*) event;
         switch (ke->key()) {
         case Qt::Key_Insert: {
             if (ke->modifiers() != 0)
                 break;
 
             QAbstractItemView::SelectionMode mode = selectionMode();
 
             if (mode != QAbstractItemView::ContiguousSelection && mode != QAbstractItemView::ExtendedSelection &&
                     mode != QAbstractItemView::MultiSelection)
                 break;
 
             ke->accept();
 
             if (currentItem() == nullptr)
                 return true;
 
             currentItem()->setSelected(!currentItem()->isSelected());
             return true;
         }
         case Qt::Key_A:
             if (ke->modifiers() == Qt::ControlModifier) {
                 QAbstractItemView::SelectionMode mode = selectionMode();
 
                 if (mode == QAbstractItemView::ContiguousSelection || mode == QAbstractItemView::ExtendedSelection ||
                         mode == QAbstractItemView::MultiSelection) {
                     selectAll();
                     ke->accept();
                     return true;
                 }
             }
             break;
         default:
             break;
         }
     }
     break;
     case QEvent::Resize: {
         auto * re = (QResizeEvent *)event;
         if (!_inResize && re->oldSize() != re->size()) {
             if (_stretchingColumn != -1 && columnCount()) {
                 QList< int > columnsSizes;
                 int oldSize = 0;
 
                 for (int i = 0; i != header()->count(); i++) {
                     columnsSizes.append(header()->sectionSize(i));
                     oldSize += header()->sectionSize(i);
                 }
 
                 bool res = QTreeWidget::event(event);
 
                 int newSize = viewport()->width();
                 int delta = newSize - oldSize;
 
                 if (delta) {
                     _inResize = true;
 
                     for (int i = 0; i != header()->count(); i++) {
                         if (i == _stretchingColumn) {
                             int newNs = columnsSizes[ i ] + delta;
                             if (newNs < 8)
                                 newNs = 8;
                             header()->resizeSection(i, newNs);
                         } else if (header()->sectionSize(i) != columnsSizes[ i ]) {
                             header()->resizeSection(i, columnsSizes[ i ]);
                         }
                     }
                     _inResize = false;
                 }
                 return res;
             }
         }
         break;
     }
     case QEvent::ToolTip: {
         auto *he = dynamic_cast<QHelpEvent*>(event);
 
         if (viewport()) {
             QPoint pos = viewport()->mapFromGlobal(he->globalPos());
 
             QTreeWidgetItem * item = itemAt(pos);
 
             int column = columnAt(pos.x());
 
             if (item) {
                 if (!item->toolTip(column).isEmpty())
                     break;
 
                 QString tip = item->text(column);
 
                 int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
-                int requiredWidth = QFontMetrics(font()).width(tip) + 2 * textMargin;
+                int requiredWidth = QFontMetrics(font()).QFONTMETRICS_WIDTH(tip) + 2 * textMargin;
 
                 if (column == 0 && indentation()) {
                     int level = 0;
 
                     QTreeWidgetItem *parent = item;
 
                     while ((parent = parent->parent()))
                         level++;
 
                     if (rootIsDecorated())
                         level++;
 
                     requiredWidth += level * indentation();
                 }
 
                 QIcon icon = item->icon(column);
                 if (!icon.isNull()) {
                     QStyleOptionViewItem opts = viewOptions();
                     QSize iconSize = icon.actualSize(opts.decorationSize);
                     requiredWidth += iconSize.width();
 
                     int pixmapMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin, nullptr, this) + 1;
                     requiredWidth += 2 * pixmapMargin;
                 }
 
                 if (!tip.isEmpty() && (columnWidth(column) < requiredWidth))
                     QToolTip::showText(he->globalPos(), tip, this);
                 return true;
             }
         }
     }
     break;
     default:
         break;
     }
     return QTreeWidget::event(event);
 }
diff --git a/krusader/KViewer/lister.cpp b/krusader/KViewer/lister.cpp
index 915566c6..96e81ae9 100644
--- a/krusader/KViewer/lister.cpp
+++ b/krusader/KViewer/lister.cpp
@@ -1,2276 +1,2277 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2009-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "lister.h"
 
 // QtCore
 #include <QFile>
 #include <QRect>
 #include <QDate>
 #include <QTemporaryFile>
 #include <QTextStream>
 // QtGui
 #include <QPainter>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QClipboard>
 #include <QKeyEvent>
 // QtWidgets
 #include <QApplication>
 #include <QFileDialog>
 #include <QHBoxLayout>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QSpacerItem>
 #include <QScrollBar>
 #include <QToolButton>
 // QtPrintSupport
 #include <QPrintDialog>
 #include <QPrinter>
 
 #include <KCodecs/KCharsets>
 #include <KConfigCore/KSharedConfig>
 #include <KCoreAddons/KJobTrackerInterface>
 #include <KI18n/KLocalizedString>
 #include <KIO/CopyJob>
 #include <KIO/TransferJob>
 #include <KIO/JobUiDelegate>
 #include <KParts/GUIActivateEvent>
 #include <KWidgetsAddons/KMessageBox>
 #include <KXmlGui/KActionCollection>
 
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../kractions.h"
 #include "../GUI/krremoteencodingmenu.h"
+#include "../compat.h"
 
 #define  SEARCH_CACHE_CHARS 100000
 #define  SEARCH_MAX_ROW_LEN 4000
 #define  CONTROL_CHAR       752
 #define  CACHE_SIZE         1048576 // cache size set to 1MiB
 
 
 ListerTextArea::ListerTextArea(Lister *lister, QWidget *parent) : KTextEdit(parent), _lister(lister)
 {
     connect(this, &QTextEdit::cursorPositionChanged, this, &ListerTextArea::slotCursorPositionChanged);
     _tabWidth = 4;
     setWordWrapMode(QTextOption::NoWrap);
     setLineWrapMode(QTextEdit::NoWrap);
 
     // zoom shortcuts
     connect(new QShortcut(QKeySequence("Ctrl++"), this), &QShortcut::activated, this, [=]() { zoomIn(); });
     connect(new QShortcut(QKeySequence("Ctrl+-"), this), &QShortcut::activated, this, [=]() { zoomOut(); });
 
     // start cursor blinking
     connect(&_blinkTimer, &QTimer::timeout, this, [=] {
         if (!_cursorBlinkMutex.tryLock()) {
             return;
         }
         setCursorWidth(cursorWidth() == 0 ? 2 : 0);
         _cursorBlinkMutex.unlock();
     });
     _blinkTimer.start(500);
 }
 
 void ListerTextArea::reset()
 {
     _screenStartPos = 0;
     _cursorPos = 0;
     _cursorAnchorPos = -1;
     _cursorAtFirstColumn = true;
     calculateText();
 }
 
 void ListerTextArea::sizeChanged()
 {
     if (_cursorAnchorPos > _lister->fileSize())
         _cursorAnchorPos = -1;
     if (_cursorPos > _lister->fileSize())
         _cursorPos = _lister->fileSize();
 
     redrawTextArea(true);
 }
 
 void ListerTextArea::resizeEvent(QResizeEvent * event)
 {
     KTextEdit::resizeEvent(event);
     redrawTextArea();
 }
 
 void ListerTextArea::calculateText(const bool forcedUpdate)
 {
     const QRect contentRect = viewport()->contentsRect();
     const QFontMetrics fm(font());
 
     const int fontHeight = std::max(fm.height(), 1);
 
     // This is quite accurate (although not perfect) way of getting
     // a single character width along with its surrounding space.
-    const float fontWidth = (fm.width("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW") - fm.width("W")) / 99.0;
+    const float fontWidth = (fm.QFONTMETRICS_WIDTH("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW") - fm.QFONTMETRICS_WIDTH("W")) / 99.0;
 
     const int sizeY = contentRect.height() / fontHeight;
     _pageSize = sizeY;
 
     const int textViewportWidth = std::max(contentRect.width() - (int) fontWidth, 0);
 
     setTabStopWidth(fontWidth * _tabWidth);
 
     const int sizeX = textViewportWidth / fontWidth;
 
     _sizeChanged = (_sizeY != sizeY) || (_sizeX != sizeX) || forcedUpdate;
     _sizeY = sizeY;
     _sizeX = sizeX;
 
     QList<qint64> rowStarts;
 
     QStringList list = readLines(_screenStartPos, _screenEndPos, _sizeY, &rowStarts);
 
     if (_sizeChanged) {
         _averagePageSize = _screenEndPos - _screenStartPos;
         setUpScrollBar();
     }
 
     const QStringList listRemn = readLines(_screenEndPos, _screenEndPos, 1);
     list << listRemn;
 
     if (list != _rowContent) {
 
         _cursorBlinkMutex.lock();
         _blinkTimer.stop();
         setCursorWidth(0);
 
         setPlainText(list.join("\n"));
 
         if (_cursorAnchorPos == -1 || _cursorAnchorPos == _cursorPos) {
             clearSelection();
             _blinkTimer.start(500);
         }
 
         _cursorBlinkMutex.unlock();
 
         _rowContent = list;
         _rowStarts = rowStarts;
         if (_rowStarts.size() < _sizeY) {
             _rowStarts << _screenEndPos;
         }
     }
 }
 
 qint64 ListerTextArea::textToFilePositionOnScreen(const int x, const int y, bool &isfirst)
 {
     isfirst = (x == 0);
     if (y >= _rowStarts.count()) {
         return 0;
     }
     const qint64 rowStart = _rowStarts[ y ];
     if (x == 0) {
         return rowStart;
     }
 
     if (_hexMode) {
         const qint64 pos = rowStart + _lister->hexPositionToIndex(_sizeX, x);
         if (pos > _lister->fileSize()) {
             return _lister->fileSize();
         }
         return pos;
     }
 
     // we can't use fromUnicode because of the invalid encoded chars
     const int maxBytes = 2 * _sizeX * MAX_CHAR_LENGTH;
     QByteArray chunk = _lister->cacheChunk(rowStart, maxBytes);
 
     QTextStream stream(&chunk);
     stream.setCodec(_lister->codec());
     stream.read(x);
     return rowStart + stream.pos();
 }
 
 void ListerTextArea::fileToTextPositionOnScreen(const qint64 p, const bool isfirst, int &x, int &y)
 {
     // check if cursor is outside of visible area
     if (p < _screenStartPos || p > _screenEndPos || _rowStarts.count() < 1) {
         x = -1;
         y = (p > _screenEndPos) ? -2 : -1;
         return;
     }
 
     // find row
     y = 0;
     while (y < _rowStarts.count() && _rowStarts[ y ] <= p) {
         y++;
     }
     y--;
     if (y < 0) {
         x = y = -1;
         return;
     }
 
     const qint64 rowStart = _rowStarts[ y ];
     if (_hexMode) {
         x = _lister->hexIndexToPosition(_sizeX, (int)(p - rowStart));
         return;
     }
 
     // find column
     const int maxBytes = 2 * _sizeX * MAX_CHAR_LENGTH;
     x = 0;
     if (rowStart >= p) {
         if ((rowStart == p) && !isfirst && y > 0) {
             const qint64 previousRow = _rowStarts[ y - 1 ];
             const QByteArray chunk = _lister->cacheChunk(previousRow, maxBytes);
             QByteArray cachedBuffer = chunk.left(p - previousRow);
 
             QTextStream stream(&cachedBuffer);
             stream.setCodec(_lister->codec());
             stream.read(_rowContent[ y - 1].length());
             if (previousRow + stream.pos() == p) {
                 y--;
                 x = _rowContent[ y ].length();
             }
         }
         return;
     }
 
     const QByteArray chunk = _lister->cacheChunk(rowStart, maxBytes);
     const QByteArray cachedBuffer = chunk.left(p - rowStart);
 
     x = _lister->codec()->toUnicode(cachedBuffer).length();
 }
 
 void ListerTextArea::getCursorPosition(int &x, int &y)
 {
     getScreenPosition(textCursor().position(), x, y);
 }
 
 void ListerTextArea::getScreenPosition(const int position, int &x, int &y)
 {
     x = position;
     y = 0;
     foreach (const QString &row, _rowContent) {
         const int rowLen = row.length() + 1;
         if (x < rowLen) {
             return;
         }
         x -= rowLen;
         y++;
     }
 }
 
 void ListerTextArea::setCursorPositionOnScreen(const int x, const int y, const int anchorX, const int anchorY)
 {
     setCursorWidth(0);
 
     int finalX = x;
     int finalY = y;
 
     if (finalX == -1 || finalY < 0) {
         if (anchorY == -1) {
             return;
         }
 
         if (finalY == -2) {
             finalY = _sizeY;
             finalX = (_rowContent.count() > _sizeY) ? _rowContent[ _sizeY ].length() : 0;
         } else
             finalX = finalY = 0;
     }
 
     const int realSizeY = std::min(_sizeY + 1, _rowContent.count());
 
     const auto setUpCursor = [&] (const int cursorX, const int cursorY, const QTextCursor::MoveMode mode) -> bool {
         if (cursorY > realSizeY) {
             return false;
         }
 
         _skipCursorChangedListener = true;
 
         moveCursor(QTextCursor::Start, mode);
         for (int i = 0; i < cursorY; i++) {
             moveCursor(QTextCursor::Down, mode);
         }
 
         int finalCursorX = cursorX;
         if (_rowContent.count() > cursorY && finalCursorX > _rowContent[ cursorY ].length()) {
             finalCursorX = _rowContent[ cursorY ].length();
         }
 
         for (int i = 0; i < finalCursorX; i++) {
             moveCursor(QTextCursor::Right, mode);
         }
 
         _skipCursorChangedListener = false;
 
         return true;
     };
 
     QTextCursor::MoveMode mode = QTextCursor::MoveAnchor;
 
     // set cursor anchor
     if (anchorX != -1 && anchorY != -1) {
 
         const bool canContinue = setUpCursor(anchorX, anchorY, mode);
         if (!canContinue) {
             return;
         }
 
         mode = QTextCursor::KeepAnchor;
     }
 
     // set cursor position
     setUpCursor(finalX, finalY, mode);
 }
 
 qint64 ListerTextArea::getCursorPosition(bool &isfirst)
 {
     if (cursorWidth() == 0) {
         isfirst = _cursorAtFirstColumn;
         return _cursorPos;
     }
 
     int x, y;
     getCursorPosition(x, y);
     return textToFilePositionOnScreen(x, y, isfirst);
 }
 
 void ListerTextArea::setCursorPositionInDocument(const qint64 p, const bool isfirst)
 {
     _cursorPos = p;
     int x, y;
     fileToTextPositionOnScreen(p, isfirst, x, y);
 
     bool startBlinkTimer = _screenStartPos <= _cursorPos && _cursorPos <= _screenEndPos;
     int anchorX = -1, anchorY = -1;
     if (_cursorAnchorPos != -1 && _cursorAnchorPos != p) {
         int anchPos = _cursorAnchorPos;
         bool anchorBelow = false, anchorAbove = false;
         if (anchPos < _screenStartPos) {
             anchPos = _screenStartPos;
             anchorY = -2;
             anchorAbove = true;
         }
         if (anchPos > _screenEndPos) {
             anchPos = _screenEndPos;
             anchorY = -3;
             anchorBelow = true;
         }
 
         fileToTextPositionOnScreen(anchPos, isfirst, anchorX, anchorY);
 
         if (_hexMode) {
             if (anchorAbove) {
                 anchorX = 0;
             }
             if (anchorBelow && _rowContent.count() > 0) {
                 anchorX = _rowContent[ 0 ].length();
             }
         }
 
         startBlinkTimer = startBlinkTimer && !anchorAbove && !anchorBelow;
     }
     if (startBlinkTimer) {
         _blinkTimer.start(500);
     }
     setCursorPositionOnScreen(x, y, anchorX, anchorY);
     _lister->slotUpdate();
 }
 
 void ListerTextArea::slotCursorPositionChanged()
 {
     if (_skipCursorChangedListener) {
         return;
     }
     int cursorX, cursorY;
     getCursorPosition(cursorX, cursorY);
     _cursorAtFirstColumn = (cursorX == 0);
     _cursorPos = textToFilePositionOnScreen(cursorX, cursorY, _cursorAtFirstColumn);
     _lister->slotUpdate();
 }
 
 QString ListerTextArea::readSection(const qint64 p1, const qint64 p2)
 {
     if (p1 == p2)
         return QString();
 
     qint64 sel1 = p1;
     qint64 sel2 = p2;
     if (sel1 > sel2) {
         std::swap(sel1, sel2);
     }
 
     QString section;
 
     if (_hexMode) {
         while (sel1 != sel2) {
             const QStringList list = _lister->readHexLines(sel1, sel2, _sizeX, 1);
             if (list.isEmpty()) {
                 break;
             }
             if (!section.isEmpty()) {
                 section += QChar('\n');
             }
             section += list.at(0);
         }
         return section;
     }
 
     qint64 pos = sel1;
 
     QScopedPointer<QTextDecoder> decoder(_lister->codec()->makeDecoder());
 
     do {
         const int maxBytes = std::min(_sizeX * _sizeY * MAX_CHAR_LENGTH, (int) (sel2 - pos));
         const QByteArray chunk = _lister->cacheChunk(pos, maxBytes);
         if (chunk.isEmpty())
             break;
         section += decoder->toUnicode(chunk);
         pos += chunk.size();
     } while (pos < sel2);
 
     return section;
 }
 
 QStringList ListerTextArea::readLines(qint64 filePos, qint64 &endPos, const int lines, QList<qint64> * locs)
 {
     QStringList list;
 
     if (_hexMode) {
         endPos = _lister->fileSize();
         if (filePos >= endPos) {
             return list;
         }
         const int bytes = _lister->hexBytesPerLine(_sizeX);
         qint64 startPos = (filePos / bytes) * bytes;
         qint64 shiftPos = startPos;
         list = _lister->readHexLines(shiftPos, endPos, _sizeX, lines);
         endPos = shiftPos;
         if (locs) {
             for (int i = 0; i < list.count(); i++) {
                 (*locs) << startPos;
                 startPos += bytes;
             }
         }
         return list;
     }
 
     endPos = filePos;
     const int maxBytes = _sizeX * _sizeY * MAX_CHAR_LENGTH;
     const QByteArray chunk = _lister->cacheChunk(filePos, maxBytes);
     if (chunk.isEmpty())
         return list;
 
     int byteCounter = 0;
     QString row = "";
     int effLength = 0;
     if (locs)
         (*locs) << filePos;
     bool skipImmediateNewline = false;
 
     const auto performNewline = [&] (qint64 nextRowStartOffset) {
         list << row;
         effLength = 0;
         row = "";
         if (locs) {
             (*locs) << (filePos + nextRowStartOffset);
         }
     };
 
     QScopedPointer<QTextDecoder> decoder(_lister->codec()->makeDecoder());
 
     while (byteCounter < chunk.size() && list.size() < lines) {
         const int lastCnt = byteCounter;
         QString chr = decoder->toUnicode(chunk.mid(byteCounter++, 1));
         if (chr.isEmpty()) {
             continue;
         }
 
         if ((chr[ 0 ] < 32) && (chr[ 0 ] != '\n') && (chr[ 0 ] != '\t')) {
             chr = QChar(CONTROL_CHAR);
         }
 
         if (chr == "\n") {
             if (!skipImmediateNewline) {
                 performNewline(byteCounter);
             }
             skipImmediateNewline = false;
             continue;
         }
 
         skipImmediateNewline = false;
 
         if (chr == "\t") {
             effLength += _tabWidth - (effLength % _tabWidth) - 1;
             if (effLength > _sizeX) {
                 performNewline(lastCnt);
             }
         }
         row += chr;
         effLength++;
         if (effLength >= _sizeX) {
             performNewline(byteCounter);
             skipImmediateNewline = true;
         }
     }
 
     if (list.size() < lines)
         list << row;
 
     endPos = filePos + byteCounter;
 
     return list;
 }
 
 void ListerTextArea::setUpScrollBar()
 {
     if (_averagePageSize == _lister->fileSize()) {
         _lister->scrollBar()->setPageStep(0);
         _lister->scrollBar()->setMaximum(0);
         _lister->scrollBar()->hide();
         _lastPageStartPos = 0;
     } else {
         const int maxPage = MAX_CHAR_LENGTH * _sizeX * _sizeY;
         qint64 pageStartPos = _lister->fileSize() - maxPage;
         qint64 endPos;
         if (pageStartPos < 0)
             pageStartPos = 0;
         QStringList list = readLines(pageStartPos, endPos, maxPage);
         if (list.count() <= _sizeY) {
             _lastPageStartPos = 0;
         } else {
             readLines(pageStartPos, _lastPageStartPos, list.count() - _sizeY);
         }
 
         const int maximum = (_lastPageStartPos > SLIDER_MAX) ? SLIDER_MAX : _lastPageStartPos;
         int pageSize = (_lastPageStartPos > SLIDER_MAX) ? SLIDER_MAX * _averagePageSize / _lastPageStartPos : _averagePageSize;
         if (pageSize == 0)
             pageSize++;
 
         _lister->scrollBar()->setPageStep(pageSize);
         _lister->scrollBar()->setMaximum(maximum);
         _lister->scrollBar()->show();
     }
 }
 
 void ListerTextArea::keyPressEvent(QKeyEvent * ke)
 {
     if (KrGlobal::copyShortcut == QKeySequence(ke->key() | ke->modifiers())) {
         copySelectedToClipboard();
         ke->accept();
         return;
     }
 
     if (ke->modifiers() == Qt::NoModifier || ke->modifiers() & Qt::ShiftModifier) {
         qint64 newAnchor = -1;
         if (ke->modifiers() & Qt::ShiftModifier) {
             newAnchor = _cursorAnchorPos;
             if (_cursorAnchorPos == -1)
                 newAnchor = _cursorPos;
         }
 
         switch (ke->key()) {
         case Qt::Key_F3:
             ke->accept();
             if (ke->modifiers() == Qt::ShiftModifier)
                 _lister->searchPrev();
             else
                 _lister->searchNext();
             return;
         case Qt::Key_Home:
         case Qt::Key_End:
             _cursorAnchorPos = newAnchor;
             break;
         case Qt::Key_Left: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             int x, y;
             getCursorPosition(x, y);
             if (y == 0 && x == 0)
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
         }
         break;
         case Qt::Key_Right: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             if (textCursor().position() == toPlainText().length())
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
         }
         break;
         case Qt::Key_Up: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             int x, y;
             getCursorPosition(x, y);
             if (y == 0)
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
         }
         break;
         case Qt::Key_Down: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             int x, y;
             getCursorPosition(x, y);
             if (y >= _sizeY-1)
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
         }
         break;
         case Qt::Key_PageDown: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             ke->accept();
             int x, y;
             getCursorPosition(x, y);
             slotActionTriggered(QAbstractSlider::SliderPageStepAdd);
             y += _sizeY - _skippedLines;
             if (y > _rowContent.count()) {
                 y = _rowContent.count() - 1;
                 if (y > 0)
                     x = _rowContent[ y - 1 ].length();
                 else
                     x = 0;
             }
             _cursorPos = textToFilePositionOnScreen(x, y, _cursorAtFirstColumn);
             setCursorPositionInDocument(_cursorPos, _cursorAtFirstColumn);
         }
         return;
         case Qt::Key_PageUp: {
             _cursorAnchorPos = newAnchor;
             ensureVisibleCursor();
             ke->accept();
             int x, y;
             getCursorPosition(x, y);
             slotActionTriggered(QAbstractSlider::SliderPageStepSub);
             y -= _sizeY - _skippedLines;
             if (y < 0) {
                 y = 0;
                 x = 0;
             }
             _cursorPos = textToFilePositionOnScreen(x, y, _cursorAtFirstColumn);
             setCursorPositionInDocument(_cursorPos, _cursorAtFirstColumn);
         }
         return;
         }
     }
     if (ke->modifiers() == Qt::ControlModifier) {
         switch (ke->key()) {
         case Qt::Key_G:
             ke->accept();
             _lister->jumpToPosition();
             return;
         case Qt::Key_F:
             ke->accept();
             _lister->enableSearch(true);
             return;
         case Qt::Key_Home:
             _cursorAnchorPos = -1;
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderToMinimum);
             setCursorPositionInDocument((qint64)0, true);
             return;
         case Qt::Key_A:
         case Qt::Key_End: {
             _cursorAnchorPos = (ke->key() == Qt::Key_A) ? 0 : -1;
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderToMaximum);
             const qint64 endPos = _lister->fileSize();
             setCursorPositionInDocument(endPos, false);
             return;
         }
         case Qt::Key_Down:
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
             return;
         case Qt::Key_Up:
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
             return;
         case Qt::Key_PageDown:
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderPageStepAdd);
             return;
         case Qt::Key_PageUp:
             ke->accept();
             slotActionTriggered(QAbstractSlider::SliderPageStepSub);
             return;
         }
     }
     const int oldAnchor = textCursor().anchor();
     KTextEdit::keyPressEvent(ke);
     handleAnchorChange(oldAnchor);
 }
 
 void ListerTextArea::mousePressEvent(QMouseEvent * e)
 {
     KTextEdit::mousePressEvent(e);
     // do change anchor only when shift is not pressed
     if (!(QGuiApplication::keyboardModifiers() & Qt::ShiftModifier)) {
         performAnchorChange(textCursor().anchor());
     }
 }
 
 void ListerTextArea::mouseDoubleClickEvent(QMouseEvent * e)
 {
     _cursorAnchorPos = -1;
     const int oldAnchor = textCursor().anchor();
     KTextEdit::mouseDoubleClickEvent(e);
     handleAnchorChange(oldAnchor);
 }
 
 void ListerTextArea::mouseMoveEvent(QMouseEvent * e)
 {
     if (e->pos().y() < 0) {
         slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
     } else if (e->pos().y() > height()) {
         slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
     }
     KTextEdit::mouseMoveEvent(e);
 }
 
 void ListerTextArea::wheelEvent(QWheelEvent * e)
 {
     int delta = e->delta();
     if (delta) {
 
         // zooming
         if (e->modifiers() & Qt::ControlModifier) {
             e->accept();
             if (delta > 0) {
                 zoomIn();
             } else {
                 zoomOut();
             }
             return;
         }
 
         if (delta > 0) {
             e->accept();
             while (delta > 0) {
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
                 slotActionTriggered(QAbstractSlider::SliderSingleStepSub);
                 delta -= 120;
             }
         } else {
             e->accept();
             while (delta < 0) {
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
                 slotActionTriggered(QAbstractSlider::SliderSingleStepAdd);
                 delta += 120;
             }
         }
 
         setCursorPositionInDocument(_cursorPos, false);
     }
 }
 
 void ListerTextArea::slotActionTriggered(int action)
 {
     switch (action) {
     case QAbstractSlider::SliderSingleStepAdd: {
         qint64 endPos;
         readLines(_screenStartPos, endPos, 1);
         if (endPos <= _lastPageStartPos) {
             _screenStartPos = endPos;
         }
     }
     break;
     case QAbstractSlider::SliderSingleStepSub: {
         if (_screenStartPos == 0) {
             break;
         }
 
         if (_hexMode) {
             int bytesPerRow = _lister->hexBytesPerLine(_sizeX);
             _screenStartPos = (_screenStartPos / bytesPerRow) * bytesPerRow;
             _screenStartPos -= bytesPerRow;
             if (_screenStartPos < 0) {
                 _screenStartPos = 0;
             }
             break;
         }
 
         int maxSize = _sizeX * _sizeY * MAX_CHAR_LENGTH;
         const QByteArray encodedEnter = _lister->codec()->fromUnicode(QString("\n"));
 
         qint64 readPos = _screenStartPos - maxSize;
         if (readPos < 0) {
             readPos = 0;
         }
         maxSize = _screenStartPos - readPos;
 
         const QByteArray chunk = _lister->cacheChunk(readPos, maxSize);
 
         int from = chunk.size();
         while (from > 0) {
             from--;
             from = chunk.lastIndexOf(encodedEnter, from);
             if (from == -1) {
                 from = 0;
                 break;
             }
             const int backRef = std::max(from - 20, 0);
             const int size = from - backRef + encodedEnter.size();
             const QString decoded = _lister->codec()->toUnicode(chunk.mid(backRef, size));
             if (decoded.endsWith(QLatin1String("\n"))) {
                 if (from < (chunk.size() - encodedEnter.size())) {
                     from += encodedEnter.size();
                     break;
                 }
             }
         }
 
         readPos += from;
         qint64 previousPos = readPos;
         while (readPos < _screenStartPos) {
             previousPos = readPos;
             readLines(readPos, readPos, 1);
         }
         _screenStartPos = previousPos;
     }
     break;
     case QAbstractSlider::SliderPageStepAdd: {
         _skippedLines = 0;
 
         qint64 endPos;
         for (int i = 0; i < _sizeY; i++) {
             readLines(_screenStartPos, endPos, 1);
             if (endPos <= _lastPageStartPos) {
                 _screenStartPos = endPos;
                 _skippedLines++;
             } else {
                 break;
             }
         }
     }
     break;
     case QAbstractSlider::SliderPageStepSub: {
         _skippedLines = 0;
 
         if (_screenStartPos == 0) {
             break;
         }
 
         if (_hexMode) {
             const int bytesPerRow = _lister->hexBytesPerLine(_sizeX);
             _screenStartPos = (_screenStartPos / bytesPerRow) * bytesPerRow;
             _screenStartPos -= _sizeY * bytesPerRow;
             if (_screenStartPos < 0) {
                 _screenStartPos = 0;
             }
             break;
         }
 
         // text lister mode
         int maxSize = 2 * _sizeX * _sizeY * MAX_CHAR_LENGTH;
         const QByteArray encodedEnter = _lister->codec()->fromUnicode(QString("\n"));
 
         qint64 readPos = _screenStartPos - maxSize;
         if (readPos < 0)
             readPos = 0;
         maxSize = _screenStartPos - readPos;
 
         const QByteArray chunk = _lister->cacheChunk(readPos, maxSize);
         maxSize = chunk.size();
 
         int sizeY = _sizeY + 1;
         int origSizeY = sizeY;
         int from = maxSize;
         int lastEnter = maxSize;
 
         bool readNext = true;
         while (readNext) {
             readNext = false;
             while (from > 0) {
                 from--;
                 from = chunk.lastIndexOf(encodedEnter, from);
                 if (from == -1) {
                     from = 0;
                     break;
                 }
                 const int backRef = std::max(from - 20, 0);
                 const int size = from - backRef + encodedEnter.size();
                 QString decoded = _lister->codec()->toUnicode(chunk.mid(backRef, size));
                 if (decoded.endsWith(QLatin1String("\n"))) {
                     if (from < (maxSize - encodedEnter.size())) {
                         int arrayStart = from + encodedEnter.size();
                         decoded = _lister->codec()->toUnicode(chunk.mid(arrayStart, lastEnter - arrayStart));
                         sizeY -= ((decoded.length() / (_sizeX + 1)) + 1);
                         if (sizeY < 0) {
                             from = arrayStart;
                             break;
                         }
                     }
                     lastEnter = from;
                 }
             }
 
             qint64 searchPos = readPos + from;
             QList<qint64> locs;
             while (searchPos < _screenStartPos) {
                 locs << searchPos;
                 readLines(searchPos, searchPos, 1);
             }
 
             if (locs.count() >= _sizeY) {
                 _screenStartPos = locs[ locs.count() - _sizeY ];
             } else if (from != 0) {
                 origSizeY += locs.count() + 1;
                 sizeY = origSizeY;
                 readNext = true;
             } else if (readPos == 0) {
                 _screenStartPos = 0;
             }
         }
 
     }
     break;
     case QAbstractSlider::SliderToMinimum:
         _screenStartPos = 0;
         break;
     case QAbstractSlider::SliderToMaximum:
         _screenStartPos = _lastPageStartPos;
         break;
     case QAbstractSlider::SliderMove: {
         if (_inSliderOp)  // self created call?
             return;
         qint64 pos = _lister->scrollBar()->sliderPosition();
 
         if (pos == SLIDER_MAX) {
             _screenStartPos = _lastPageStartPos;
             break;
         } else if (pos == 0) {
             _screenStartPos = 0;
             break;
         }
 
         if (_lastPageStartPos > SLIDER_MAX)
             pos = _lastPageStartPos * pos / SLIDER_MAX;
 
         if (pos != 0) {
             if (_hexMode) {
                 const int bytesPerRow = _lister->hexBytesPerLine(_sizeX);
                 pos = (pos / bytesPerRow) * bytesPerRow;
             } else {
                 const int maxSize = _sizeX * _sizeY * MAX_CHAR_LENGTH;
                 qint64 readPos = pos - maxSize;
                 if (readPos < 0)
                     readPos = 0;
                 qint64 previousPos = readPos;
 
                 while (readPos <= pos) {
                     previousPos = readPos;
                     readLines(readPos, readPos, 1);
                 }
 
                 pos = previousPos;
             }
         }
 
         _screenStartPos = pos;
     }
     break;
     case QAbstractSlider::SliderNoAction:
         break;
     };
 
     _inSliderOp = true;
     const int value = (_lastPageStartPos > SLIDER_MAX) ? SLIDER_MAX * _screenStartPos / _lastPageStartPos : _screenStartPos;
     _lister->scrollBar()->setSliderPosition(value);
     _inSliderOp = false;
 
     redrawTextArea();
 }
 
 void ListerTextArea::redrawTextArea(bool forcedUpdate)
 {
     if (_redrawing) {
         return;
     }
     _redrawing = true;
     bool isfirst;
     const qint64 pos = getCursorPosition(isfirst);
     calculateText(forcedUpdate);
     setCursorPositionInDocument(pos, isfirst);
     _redrawing = false;
 }
 
 void ListerTextArea::ensureVisibleCursor()
 {
     if (_screenStartPos <= _cursorPos && _cursorPos <= _screenEndPos) {
         return;
     }
 
     int delta = _sizeY / 2;
     if (delta == 0)
         delta++;
 
     qint64 newScreenStart = _cursorPos;
     while (delta) {
         const int maxSize = _sizeX * MAX_CHAR_LENGTH;
         qint64 readPos = newScreenStart - maxSize;
         if (readPos < 0)
             readPos = 0;
 
         qint64 previousPos = readPos;
 
         while (readPos < newScreenStart) {
             previousPos = readPos;
             readLines(readPos, readPos, 1);
             if (readPos == previousPos)
                 break;
         }
 
         newScreenStart = previousPos;
         delta--;
     }
     if (newScreenStart > _lastPageStartPos) {
         newScreenStart = _lastPageStartPos;
     }
 
     _screenStartPos = newScreenStart;
     slotActionTriggered(QAbstractSlider::SliderNoAction);
 }
 
 void ListerTextArea::setAnchorAndCursor(qint64 anchor, qint64 cursor)
 {
     _cursorPos = cursor;
     _cursorAnchorPos = anchor;
     ensureVisibleCursor();
     setCursorPositionInDocument(cursor, false);
 }
 
 QString ListerTextArea::getSelectedText()
 {
     if (_cursorAnchorPos != -1 && _cursorAnchorPos != _cursorPos) {
         return readSection(_cursorAnchorPos, _cursorPos);
     }
     return QString();
 }
 
 void ListerTextArea::copySelectedToClipboard()
 {
     const QString selection = getSelectedText();
     if (!selection.isEmpty()) {
         QApplication::clipboard()->setText(selection);
     }
 }
 
 void ListerTextArea::clearSelection()
 {
     QTextCursor cursor = textCursor();
     cursor.clearSelection();
     setTextCursor(cursor);
     _cursorAnchorPos = -1;
 }
 
 void ListerTextArea::performAnchorChange(int anchor)
 {
     int x, y;
     bool isfirst;
     getScreenPosition(anchor, x, y);
     _cursorAnchorPos = textToFilePositionOnScreen(x, y, isfirst);
 }
 
 void ListerTextArea::handleAnchorChange(int oldAnchor)
 {
     const int anchor = textCursor().anchor();
 
     if (oldAnchor != anchor) {
         performAnchorChange(anchor);
     }
 }
 
 void ListerTextArea::setHexMode(bool hexMode)
 {
     bool isfirst;
     const qint64 pos = getCursorPosition(isfirst);
     _hexMode = hexMode;
     _screenStartPos = 0;
     calculateText(true);
     setCursorPositionInDocument(pos, isfirst);
     ensureVisibleCursor();
 }
 
 void ListerTextArea::zoomIn(int range)
 {
     KTextEdit::zoomIn(range);
     redrawTextArea();
 }
 
 void ListerTextArea::zoomOut(int range)
 {
     KTextEdit::zoomOut(range);
     redrawTextArea();
 }
 
 ListerPane::ListerPane(Lister *lister, QWidget *parent) : QWidget(parent), _lister(lister)
 {
 }
 
 bool ListerPane::event(QEvent *e)
 {
     const bool handled = ListerPane::handleCloseEvent(e);
     if (!handled) {
         return QWidget::event(e);
     }
     return true;
 }
 
 bool ListerPane::handleCloseEvent(QEvent *e)
 {
     if (e->type() == QEvent::ShortcutOverride) {
         auto *ke = dynamic_cast<QKeyEvent *>(e);
         if (ke->key() == Qt::Key_Escape) {
             if (_lister->isSearchEnabled()) {
                 _lister->searchDelete();
                 _lister->enableSearch(false);
                 ke->accept();
                 return true;
             }
             if (!_lister->textArea()->getSelectedText().isEmpty()) {
                 _lister->textArea()->clearSelection();
                 ke->accept();
                 return true;
             }
         }
     }
     return false;
 }
 
 ListerBrowserExtension::ListerBrowserExtension(Lister * lister) : KParts::BrowserExtension(lister)
 {
     _lister = lister;
 
     emit enableAction("copy", true);
     emit enableAction("print", true);
 }
 
 void ListerBrowserExtension::copy()
 {
     _lister->textArea()->copySelectedToClipboard();
 }
 
 void ListerBrowserExtension::print()
 {
     _lister->print();
 }
 
 class ListerEncodingMenu : public KrRemoteEncodingMenu
 {
 public:
     ListerEncodingMenu(Lister *lister, const QString &text, const QString &icon, KActionCollection *parent) :
             KrRemoteEncodingMenu(text, icon, parent), _lister(lister) {
     }
 
 protected:
     QString currentCharacterSet() Q_DECL_OVERRIDE {
         return _lister->characterSet();
     }
 
     void chooseDefault() Q_DECL_OVERRIDE {
         _lister->setCharacterSet(QString());
     }
 
     void chooseEncoding(QString encodingName) Q_DECL_OVERRIDE {
         QString charset = KCharsets::charsets()->encodingForName(encodingName);
         _lister->setCharacterSet(charset);
     }
 
     Lister * _lister;
 };
 
 Lister::Lister(QWidget *parent) : KParts::ReadOnlyPart(parent)
 {
     setXMLFile("krusaderlisterui.rc");
 
     _actionSaveSelected = new QAction(Icon("document-save"), i18n("Save selection..."), this);
     connect(_actionSaveSelected, &QAction::triggered, this, &Lister::saveSelected);
     actionCollection()->addAction("save_selected", _actionSaveSelected);
 
     _actionSaveAs = new QAction(Icon("document-save-as"), i18n("Save as..."), this);
     connect(_actionSaveAs, &QAction::triggered, this, &Lister::saveAs);
     actionCollection()->addAction("save_as", _actionSaveAs);
 
     _actionPrint = new QAction(Icon("document-print"), i18n("Print..."), this);
     connect(_actionPrint, &QAction::triggered, this, &Lister::print);
     actionCollection()->addAction("print", _actionPrint);
     actionCollection()->setDefaultShortcut(_actionPrint, Qt::CTRL + Qt::Key_P);
 
     _actionSearch = new QAction(Icon("system-search"), i18n("Search"), this);
     connect(_actionSearch, &QAction::triggered, this, &Lister::searchAction);
     actionCollection()->addAction("search", _actionSearch);
     actionCollection()->setDefaultShortcut(_actionSearch, Qt::CTRL + Qt::Key_F);
 
     _actionSearchNext = new QAction(Icon("go-down"), i18n("Search next"), this);
     connect(_actionSearchNext, &QAction::triggered, this, &Lister::searchNext);
     actionCollection()->addAction("search_next", _actionSearchNext);
     actionCollection()->setDefaultShortcut(_actionSearchNext, Qt::Key_F3);
 
     _actionSearchPrev = new QAction(Icon("go-up"), i18n("Search previous"), this);
     connect(_actionSearchPrev, &QAction::triggered, this, &Lister::searchPrev);
     actionCollection()->addAction("search_prev", _actionSearchPrev);
     actionCollection()->setDefaultShortcut(_actionSearchPrev, Qt::SHIFT + Qt::Key_F3);
 
     _actionJumpToPosition = new QAction(Icon("go-jump"), i18n("Jump to position"), this);
     connect(_actionJumpToPosition, &QAction::triggered, this, &Lister::jumpToPosition);
     actionCollection()->addAction("jump_to_position", _actionJumpToPosition);
     actionCollection()->setDefaultShortcut(_actionJumpToPosition, Qt::CTRL + Qt::Key_G);
 
     _actionHexMode = new QAction(Icon("document-preview"), i18n("Hex mode"), this);
     connect(_actionHexMode, &QAction::triggered, this, &Lister::toggleHexMode);
     actionCollection()->addAction("hex_mode", _actionHexMode);
     actionCollection()->setDefaultShortcut(_actionHexMode, Qt::CTRL + Qt::Key_H);
 
     new ListerEncodingMenu(this, i18n("Select charset"), "character-set", actionCollection());
 
     QWidget * widget = new ListerPane(this, parent);
     widget->setFocusPolicy(Qt::StrongFocus);
     auto *grid = new QGridLayout(widget);
     _textArea = new ListerTextArea(this, widget);
     _textArea->setFont(QFontDatabase::systemFont(QFontDatabase::FixedFont));
     _textArea->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
     _textArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     _textArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
     widget->setFocusProxy(_textArea);
     grid->addWidget(_textArea, 0, 0);
     _scrollBar = new QScrollBar(Qt::Vertical, widget);
     grid->addWidget(_scrollBar, 0, 1);
     _scrollBar->hide();
 
     QWidget * statusWidget = new QWidget(widget);
     auto *hbox = new QHBoxLayout(statusWidget);
 
     _listerLabel = new QLabel(i18n("Lister:"), statusWidget);
     hbox->addWidget(_listerLabel);
     _searchProgressBar = new QProgressBar(statusWidget);
     _searchProgressBar->setMinimum(0);
     _searchProgressBar->setMaximum(1000);
     _searchProgressBar->setValue(0);
     _searchProgressBar->hide();
     hbox->addWidget(_searchProgressBar);
 
     _searchStopButton = new QToolButton(statusWidget);
     _searchStopButton->setIcon(Icon("process-stop"));
     _searchStopButton->setToolTip(i18n("Stop search"));
     _searchStopButton->hide();
     connect(_searchStopButton, &QToolButton::clicked, this, &Lister::searchDelete);
     hbox->addWidget(_searchStopButton);
 
     _searchLineEdit = new KLineEdit(statusWidget);
     _searchLineEdit->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     _originalBackground = _searchLineEdit->palette().color(QPalette::Base);
     _originalForeground = _searchLineEdit->palette().color(QPalette::Text);
 
     connect(_searchLineEdit, &KLineEdit::returnPressed, this, &Lister::searchNext);
     connect(_searchLineEdit, &KLineEdit::textChanged, this, &Lister::searchTextChanged);
 
     hbox->addWidget(_searchLineEdit);
     _searchNextButton = new QPushButton(Icon("go-down"), i18n("Next"), statusWidget);
     _searchNextButton->setToolTip(i18n("Jump to next match"));
     connect(_searchNextButton, &QPushButton::clicked, this, &Lister::searchNext);
     hbox->addWidget(_searchNextButton);
     _searchPrevButton = new QPushButton(Icon("go-up"), i18n("Previous"), statusWidget);
     _searchPrevButton->setToolTip(i18n("Jump to previous match"));
     connect(_searchPrevButton, &QPushButton::clicked, this, &Lister::searchPrev);
     hbox->addWidget(_searchPrevButton);
     _searchOptions = new QPushButton(i18n("Options"), statusWidget);
     _searchOptions->setToolTip(i18n("Modify search behavior"));
     auto * menu = new QMenu();
     _fromCursorAction = menu->addAction(i18n("From cursor"));
     _fromCursorAction->setCheckable(true);
     _fromCursorAction->setChecked(true);
     _caseSensitiveAction = menu->addAction(i18n("Case sensitive"));
     _caseSensitiveAction->setCheckable(true);
     _matchWholeWordsOnlyAction = menu->addAction(i18n("Match whole words only"));
     _matchWholeWordsOnlyAction->setCheckable(true);
     _regExpAction = menu->addAction(i18n("RegExp"));
     _regExpAction->setCheckable(true);
     _hexAction = menu->addAction(i18n("Hexadecimal"));
     _hexAction->setCheckable(true);
     _searchOptions->setMenu(menu);
 
     hbox->addWidget(_searchOptions);
 
     hbox->addItem(new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum));
 
     _statusLabel = new QLabel(statusWidget);
     hbox->addWidget(_statusLabel);
 
     grid->addWidget(statusWidget, 1, 0, 1, 2);
     setWidget(widget);
 
     connect(_scrollBar, &QScrollBar::actionTriggered, _textArea, &ListerTextArea::slotActionTriggered);
     connect(&_searchUpdateTimer, &QTimer::timeout, this, &Lister::slotUpdate);
 
     new ListerBrowserExtension(this);
     enableSearch(false);
 
     _tempFile = new QTemporaryFile(this);
     _tempFile->setFileTemplate(QDir::tempPath() + QLatin1String("/krusader_lister.XXXXXX"));
 }
 
 bool Lister::openUrl(const QUrl &listerUrl)
 {
     _downloading = false;
     setUrl(listerUrl);
 
     _fileSize = 0;
 
     if (listerUrl.isLocalFile()) {
         _filePath = listerUrl.path();
         if (!QFile::exists(_filePath))
             return false;
         _fileSize = getFileSize();
     } else {
         if (_tempFile->isOpen()) {
             _tempFile->close();
         }
         _tempFile->open();
 
         _filePath = _tempFile->fileName();
 
         KIO::TransferJob *downloadJob = KIO::get(listerUrl, KIO::NoReload, KIO::HideProgressInfo);
 
         connect(downloadJob, &KIO::TransferJob::data, this, [=](KIO::Job*, QByteArray array) {
             if (array.size() != 0) {
                 _tempFile->write(array);
             } });
         connect(downloadJob, &KIO::TransferJob::result, this, [=](KJob *job) {
             _tempFile->flush();
             if (job->error()) {   /* any error occurred? */
                 auto *kioJob = (KIO::TransferJob *)job;
                 KMessageBox::error(_textArea, i18n("Error reading file %1.", kioJob->url().toDisplayString(QUrl::PreferLocalFile)));
             }
             _downloading = false;
             _downloadUpdateTimer.stop();
             slotUpdate();
         });
         connect(&_downloadUpdateTimer, &QTimer::timeout, this, [&]() {
             slotUpdate();
         });
         _downloadUpdateTimer.start(500);
         _downloading = true;
     }
 
     // invalidate cache
     _cache.clear();
 
     _textArea->reset();
     emit started(nullptr);
     emit setWindowCaption(listerUrl.toDisplayString());
     emit completed();
     return true;
 }
 
 QByteArray Lister::cacheChunk(const qint64 filePos, const int maxSize)
 {
     if (filePos >= _fileSize) {
         return QByteArray();
     }
 
     int size = maxSize;
     if (_fileSize - filePos < size) {
         size = _fileSize - filePos;
     }
 
     if (!_cache.isEmpty() && (filePos >= _cachePos) && (filePos + size <= _cachePos + _cache.size())) {
         return _cache.mid(filePos - _cachePos, size);
     }
 
     const int negativeOffset = CACHE_SIZE * 2 / 5;
     qint64 cachePos = filePos - negativeOffset;
     if (cachePos < 0)
         cachePos = 0;
 
     QFile sourceFile(_filePath);
     if (!sourceFile.open(QIODevice::ReadOnly)) {
         return QByteArray();
     }
 
     if (!sourceFile.seek(cachePos)) {
         return QByteArray();
     }
 
     const QByteArray bytes = sourceFile.read(CACHE_SIZE);
     if (bytes.isEmpty()) {
         return bytes;
     }
 
     _cache = bytes;
     _cachePos = cachePos;
     const qint64 cacheRefIndex = filePos - _cachePos;
     int newSize = bytes.size() - cacheRefIndex;
     if (newSize < size)
         size = newSize;
 
     return _cache.mid(cacheRefIndex, size);
 }
 
 qint64 Lister::getFileSize()
 {
     return QFile(_filePath).size();
 }
 
 void Lister::guiActivateEvent(KParts::GUIActivateEvent * event)
 {
     if (event->activated()) {
         slotUpdate();
         _textArea->redrawTextArea(true);
     } else {
         enableSearch(false);
     }
     KParts::ReadOnlyPart::guiActivateEvent(event);
 }
 
 void Lister::slotUpdate()
 {
     const qint64 oldSize = _fileSize;
     _fileSize = getFileSize();
     if (oldSize != _fileSize)
         _textArea->sizeChanged();
 
     int cursorX = 0, cursorY = 0;
     _textArea->getCursorPosition(cursorX, cursorY);
     bool isfirst = false;
     const qint64 cursor = _textArea->getCursorPosition(isfirst);
 
     const int percent = (_fileSize == 0) ? 0 : (int)((201 * cursor) / _fileSize / 2);
 
     const QString status = i18n("Column: %1, Position: %2 (%3, %4%)", cursorX, cursor, _fileSize, percent);
     _statusLabel->setText(status);
 
     if (_searchProgressCounter)
         _searchProgressCounter--;
 }
 
 bool Lister::isSearchEnabled()
 {
     return !_searchLineEdit->isHidden() || !_searchProgressBar->isHidden();
 }
 
 void Lister::enableSearch(const bool enable)
 {
     if (enable) {
         _listerLabel->setText(i18n("Search:"));
         _searchLineEdit->show();
         _searchNextButton->show();
         _searchPrevButton->show();
         _searchOptions->show();
         if (!_searchLineEdit->hasFocus()) {
             _searchLineEdit->setFocus();
             const QString selection = _textArea->getSelectedText();
             if (!selection.isEmpty()) {
                 _searchLineEdit->setText(selection);
             }
             _searchLineEdit->selectAll();
         }
     } else {
         _listerLabel->setText(i18n("Lister:"));
         _searchLineEdit->hide();
         _searchNextButton->hide();
         _searchPrevButton->hide();
         _searchOptions->hide();
         _textArea->setFocus();
     }
 }
 
 void Lister::searchNext()
 {
     search(true);
 }
 
 void Lister::searchPrev()
 {
     search(false);
 }
 
 void Lister::search(const bool forward, const bool restart)
 {
     _restartFromBeginning = restart;
     if (_searchInProgress || _searchLineEdit->text().isEmpty())
         return;
     if (_searchLineEdit->isHidden())
         enableSearch(true);
 
     _searchPosition = forward ? 0 : _fileSize;
     if (_fromCursorAction->isChecked()) {
         bool isfirst;
         qint64 cursor = _textArea->getCursorPosition(isfirst);
         if (cursor != 0 && !forward)
             cursor--;
         if (_searchLastFailedPosition == -1 || _searchLastFailedPosition != cursor)
             _searchPosition = cursor;
     }
     const bool caseSensitive = _caseSensitiveAction->isChecked();
     const bool matchWholeWord = _matchWholeWordsOnlyAction->isChecked();
     const bool regExp = _regExpAction->isChecked();
     const bool hex = _hexAction->isChecked();
 
     if (hex) {
         QString hexcontent = _searchLineEdit->text();
         hexcontent.remove(QLatin1String("0x"));
         hexcontent.remove(' ');
         hexcontent.remove('\t');
         hexcontent.remove('\n');
         hexcontent.remove('\r');
 
         _searchHexQuery = QByteArray();
 
         if (hexcontent.length() & 1) {
             setColor(false, false);
             return;
         }
 
         while (!hexcontent.isEmpty()) {
             const QString hexData = hexcontent.left(2);
             hexcontent = hexcontent.mid(2);
             bool ok = true;
             const int c = hexData.toUInt(&ok, 16);
             if (!ok) {
                 setColor(false, false);
                 return;
             }
             _searchHexQuery.push_back((char) c);
         }
     } else {
         _searchQuery.setContent(_searchLineEdit->text(), caseSensitive, matchWholeWord, codec()->name(), regExp);
     }
     _searchIsForward = forward;
     _searchHexadecimal = hex;
 
     QTimer::singleShot(0, this, &Lister::slotSearchMore);
     _searchInProgress = true;
     _searchProgressCounter = 3;
 
     enableActions(false);
 }
 
 void Lister::enableActions(const bool state)
 {
     _actionSearch->setEnabled(state);
     _actionSearchNext->setEnabled(state);
     _actionSearchPrev->setEnabled(state);
     _actionJumpToPosition->setEnabled(state);
     if (state) {
         _searchUpdateTimer.stop();
     } else {
         slotUpdate();
     }
 }
 
 void Lister::slotSearchMore()
 {
     if (!_searchInProgress)
         return;
 
     if (!_searchUpdateTimer.isActive()) {
         _searchUpdateTimer.start(200);
     }
 
     updateProgressBar();
     if (!_searchIsForward)
         _searchPosition--;
 
     if (_searchPosition < 0 || _searchPosition >= _fileSize) {
         if (_restartFromBeginning)
             resetSearchPosition();
         else {
             searchFailed();
             return;
         }
     }
 
     int maxCacheSize = SEARCH_CACHE_CHARS;
     qint64 searchPos = _searchPosition;
     bool setPosition = true;
     if (!_searchIsForward) {
         qint64 origSearchPos = _searchPosition;
         searchPos -= maxCacheSize;
         if (searchPos <= 0) {
             searchPos = 0;
             _searchPosition = 0;
             setPosition = false;
         }
         qint64 diff = origSearchPos - searchPos;
         if (diff < maxCacheSize)
             maxCacheSize = diff;
     }
 
     const QByteArray chunk = cacheChunk(searchPos, maxCacheSize);
     if (chunk.isEmpty()) {
         searchFailed();
         return;
     }
 
     const int chunkSize = chunk.size();
 
     qint64 foundAnchor = -1;
     qint64 foundCursor = -1;
     int byteCounter = 0;
 
     if (_searchHexadecimal) {
         const int ndx = _searchIsForward ? chunk.indexOf(_searchHexQuery) : chunk.lastIndexOf(_searchHexQuery);
         if (chunkSize > _searchHexQuery.length()) {
             if (_searchIsForward) {
                 _searchPosition = searchPos + chunkSize;
                 if ((_searchPosition < _fileSize) && (chunkSize > _searchHexQuery.length()))
                     _searchPosition -= _searchHexQuery.length();
                 byteCounter = _searchPosition - searchPos;
             } else {
                 if (_searchPosition > 0)
                     _searchPosition += _searchHexQuery.length();
             }
         }
         if (ndx != -1) {
             foundAnchor = searchPos + ndx;
             foundCursor = foundAnchor + _searchHexQuery.length();
         }
     } else {
         int rowStart = 0;
         QString row = "";
 
         QScopedPointer<QTextDecoder> decoder(_codec->makeDecoder());
 
         while (byteCounter < chunkSize) {
             const QString chr = decoder->toUnicode(chunk.mid(byteCounter++, 1));
             if (chr.isEmpty() && byteCounter < chunkSize) {
                 continue;
             }
 
             if (chr != "\n")
                 row += chr;
 
             if (chr == "\n" || row.length() >= SEARCH_MAX_ROW_LEN || byteCounter >= chunkSize) {
                 if (setPosition) {
                     _searchPosition = searchPos + byteCounter;
                     if (!_searchIsForward) {
                         _searchPosition++;
                         setPosition = false;
                     }
                 }
 
                 if (_searchQuery.checkLine(row, !_searchIsForward)) {
                     QByteArray cachedBuffer = chunk.mid(rowStart, chunkSize - rowStart);
 
                     QTextStream stream(&cachedBuffer);
                     stream.setCodec(_codec);
 
                     stream.read(_searchQuery.matchIndex());
                     foundAnchor = searchPos + rowStart + stream.pos();
 
                     stream.read(_searchQuery.matchLength());
                     foundCursor = searchPos + rowStart + stream.pos();
 
                     if (_searchIsForward)
                         break;
                 }
 
                 row = "";
                 rowStart = byteCounter;
             }
         }
     }
 
     if (foundAnchor != -1 && foundCursor != -1) {
         _textArea->setAnchorAndCursor(foundAnchor, foundCursor);
         searchSucceeded();
         return;
     }
 
     if (_searchIsForward && searchPos + byteCounter >= _fileSize) {
         if (_restartFromBeginning)
             resetSearchPosition();
         else {
             searchFailed();
             return;
         }
     } else if (_searchPosition <= 0 || _searchPosition >= _fileSize) {
         if (_restartFromBeginning)
             resetSearchPosition();
         else {
             searchFailed();
             return;
         }
     }
 
     QTimer::singleShot(0, this, &Lister::slotSearchMore);
 }
 
 void Lister::resetSearchPosition()
 {
     _restartFromBeginning = false;
     _searchPosition = _searchIsForward ? 0 : _fileSize - 1;
 }
 
 void Lister::searchSucceeded()
 {
     _searchInProgress = false;
     setColor(true, false);
     hideProgressBar();
     _searchLastFailedPosition = -1;
 
     enableActions(true);
 }
 
 void Lister::searchFailed()
 {
     _searchInProgress = false;
     setColor(false, false);
     hideProgressBar();
     bool isfirst;
     _searchLastFailedPosition = _textArea->getCursorPosition(isfirst);
     if (!_searchIsForward)
         _searchLastFailedPosition--;
 
     enableActions(true);
 }
 
 void Lister::searchDelete()
 {
     _searchInProgress = false;
     setColor(false, true);
     hideProgressBar();
     _searchLastFailedPosition = -1;
 
     enableActions(true);
 }
 
 void Lister::searchTextChanged()
 {
     searchDelete();
     if (_fileSize < 0x10000) { // autosearch files less than 64k
         if (!_searchLineEdit->text().isEmpty()) {
             bool isfirst;
             const qint64 anchor = _textArea->getCursorAnchor();
             const qint64 cursor = _textArea->getCursorPosition(isfirst);
             if (cursor > anchor && anchor != -1) {
                 _textArea->setCursorPositionInDocument(anchor, true);
             }
             search(true, true);
         }
     }
 }
 
 void Lister::setColor(const bool match, const bool restore)
 {
     QColor fore, back;
 
     if (!restore) {
         const KConfigGroup gc(krConfig, "Colors");
 
         QString foreground, background;
         const QPalette p = QGuiApplication::palette();
 
         if (match) {
             foreground = "Quicksearch Match Foreground";
             background = "Quicksearch Match Background";
             fore = Qt::black;
             back = QColor(192, 255, 192);
         } else {
             foreground = "Quicksearch Non-match Foreground";
             background = "Quicksearch Non-match Background";
             fore = Qt::black;
             back = QColor(255, 192, 192);
         }
 
         if (gc.readEntry(foreground, QString()) == "KDE default")
             fore = p.color(QPalette::Active, QPalette::Text);
         else if (!gc.readEntry(foreground, QString()).isEmpty())
             fore = gc.readEntry(foreground, fore);
 
         if (gc.readEntry(background, QString()) == "KDE default")
             back = p.color(QPalette::Active, QPalette::Base);
         else if (!gc.readEntry(background, QString()).isEmpty())
             back = gc.readEntry(background, back);
     } else {
         back = _originalBackground;
         fore = _originalForeground;
     }
 
     QPalette pal = _searchLineEdit->palette();
     pal.setColor(QPalette::Base, back);
     pal.setColor(QPalette::Text, fore);
     _searchLineEdit->setPalette(pal);
 }
 
 void Lister::hideProgressBar()
 {
     if (!_searchProgressBar->isHidden()) {
         _searchProgressBar->hide();
         _searchStopButton->hide();
         _searchLineEdit->show();
         _searchNextButton->show();
         _searchPrevButton->show();
         _searchOptions->show();
         _listerLabel->setText(i18n("Search:"));
     }
 }
 
 void Lister::updateProgressBar()
 {
     if (_searchProgressCounter)
         return;
 
     if (_searchProgressBar->isHidden()) {
         _searchProgressBar->show();
         _searchStopButton->show();
         _searchOptions->hide();
         _searchLineEdit->hide();
         _searchNextButton->hide();
         _searchPrevButton->hide();
         _listerLabel->setText(i18n("Search position:"));
 
         // otherwise focus is set to document tab
         _textArea->setFocus();
     }
 
     const qint64 pcnt = (_fileSize == 0) ? 1000 : (2001 * _searchPosition) / _fileSize / 2;
     const auto pctInt = (int) pcnt;
     if (_searchProgressBar->value() != pctInt)
         _searchProgressBar->setValue(pctInt);
 }
 
 void Lister::jumpToPosition()
 {
     bool ok = true;
     QString res = QInputDialog::getText(_textArea, i18n("Jump to position"), i18n("Text position:"),
                                         QLineEdit::Normal, "0", &ok);
     if (!ok)
         return;
 
     res = res.trimmed();
     qint64 pos = -1;
     if (res.startsWith(QLatin1String("0x"))) {
         res = res.mid(2);
         bool ok;
         const qulonglong upos = res.toULongLong(&ok, 16);
         if (!ok) {
             KMessageBox::error(_textArea, i18n("Invalid number."), i18n("Jump to position"));
             return;
         }
         pos = (qint64)upos;
     } else {
         bool ok;
         const qulonglong upos = res.toULongLong(&ok);
         if (!ok) {
             KMessageBox::error(_textArea, i18n("Invalid number."), i18n("Jump to position"));
             return;
         }
         pos = (qint64)upos;
     }
 
     if (pos < 0 || pos > _fileSize) {
         KMessageBox::error(_textArea, i18n("Number out of range."), i18n("Jump to position"));
         return;
     }
 
     _textArea->deleteAnchor();
     _textArea->setCursorPositionInDocument(pos, true);
     _textArea->ensureVisibleCursor();
 }
 
 void Lister::saveAs()
 {
     const QUrl url = QFileDialog::getSaveFileUrl(_textArea, i18n("Lister"));
     if (url.isEmpty())
         return;
     QUrl sourceUrl;
     if (!_downloading)
         sourceUrl = QUrl::fromLocalFile(_filePath);
     else
         sourceUrl = this->url();
 
     QList<QUrl> urlList;
     urlList << sourceUrl;
 
     KIO::Job *job = KIO::copy(urlList, url);
     job->setUiDelegate(new KIO::JobUiDelegate());
     KIO::getJobTracker()->registerJob(job);
     job->uiDelegate()->setAutoErrorHandlingEnabled(true);
 }
 
 void Lister::saveSelected()
 {
     bool isfirst;
     const qint64 start = _textArea->getCursorAnchor();
     const qint64 end = _textArea->getCursorPosition(isfirst);
     if (start == -1 || start == end) {
         KMessageBox::error(_textArea, i18n("Nothing is selected."), i18n("Save selection..."));
         return;
     }
     if (start > end) {
         _savePosition = end;
         _saveEnd = start;
     } else {
         _savePosition = start;
         _saveEnd = end;
     }
 
     const QUrl url = QFileDialog::getSaveFileUrl(_textArea, i18n("Lister"));
     if (url.isEmpty())
         return;
 
     KIO::TransferJob *saveJob = KIO::put(url, -1, KIO::Overwrite);
     connect(saveJob, &KIO::TransferJob::dataReq, this, &Lister::slotDataSend);
     connect(saveJob, &KIO::TransferJob::result, this, &Lister::slotSendFinished);
 
     saveJob->setUiDelegate(new KIO::JobUiDelegate());
     KIO::getJobTracker()->registerJob(saveJob);
     saveJob->uiDelegate()->setAutoErrorHandlingEnabled(true);
 
     _actionSaveSelected->setEnabled(false);
 }
 
 void Lister::slotDataSend(KIO::Job *, QByteArray &array)
 {
     if (_savePosition >= _saveEnd) {
         array = QByteArray();
         return;
     }
     qint64 max = _saveEnd - _savePosition;
     if (max > 1000)
         max = 1000;
     array = cacheChunk(_savePosition, (int) max);
     _savePosition += array.size();
 }
 
 void Lister::slotSendFinished(KJob *)
 {
     _actionSaveSelected->setEnabled(true);
 }
 
 void Lister::setCharacterSet(const QString& set)
 {
     _characterSet = set;
     if (_characterSet.isEmpty()) {
         _codec = QTextCodec::codecForLocale();
     } else {
         _codec = KCharsets::charsets()->codecForName(_characterSet);
     }
     _textArea->redrawTextArea(true);
 }
 
 void Lister::print()
 {
     bool isfirst;
     const qint64 anchor = _textArea->getCursorAnchor();
     const qint64 cursor = _textArea->getCursorPosition(isfirst);
     const bool hasSelection = (anchor != -1 && anchor != cursor);
 
     const QString docName = url().fileName();
     QPrinter printer;
     printer.setDocName(docName);
 
     QScopedPointer<QPrintDialog> printDialog(new QPrintDialog(&printer, _textArea));
 
     if (hasSelection) {
         printDialog->addEnabledOption(QAbstractPrintDialog::PrintSelection);
     }
 
     if (!printDialog->exec()) {
         return;
     }
 
     if (printer.pageOrder() == QPrinter::LastPageFirst) {
         switch (KMessageBox::warningContinueCancel(_textArea,
                 i18n("Reverse printing is not supported. Continue with normal printing?"))) {
         case KMessageBox::Continue :
             break;
         default:
             return;
         }
     }
     QPainter painter;
     painter.begin(&printer);
 
     const QString dateString = QDate::currentDate().toString(Qt::SystemLocaleShortDate);
 
     const QRect pageRect = printer.pageRect();
     const QRect drawingRect(0, 0, pageRect.width(), pageRect.height());
 
     const QFont normalFont = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
     const QFont fixedFont  = QFontDatabase::systemFont(QFontDatabase::FixedFont);
 
     const QFontMetrics fmNormal(normalFont);
     const int normalFontHeight = fmNormal.height();
 
     const QFontMetrics fmFixed(fixedFont);
     const int fixedFontHeight = std::max(fmFixed.height(), 1);
-    const int fixedFontWidth = std::max(fmFixed.width("W"), 1);
+    const int fixedFontWidth = std::max(fmFixed.QFONTMETRICS_WIDTH("W"), 1);
 
     const int effPageSize = drawingRect.height() - normalFontHeight - 1;
     const int rowsPerPage = std::max(effPageSize / fixedFontHeight, 1);
     const int columnsPerPage = std::max(drawingRect.width() / fixedFontWidth, 1);
 
     bool firstPage = true;
 
     qint64 startPos = 0;
     qint64 endPos = _fileSize;
     if (printer.printRange() == QPrinter::Selection) {
         if (anchor > cursor)
             startPos = cursor, endPos = anchor;
         else
             startPos = anchor, endPos = cursor;
     }
 
     int page = 0;
     while (startPos < endPos) {
         page++;
 
         QStringList rows = readLines(startPos, endPos, columnsPerPage, rowsPerPage);
 
         // print since set-up fromPage number
         if (printer.fromPage() && page < printer.fromPage()) {
             continue;
         }
 
         // print until set-up toPage number
         if (printer.toPage() && printer.toPage() >= printer.fromPage() && page > printer.toPage())
             break;
 
         if (!firstPage) {
             printer.newPage();
         }
         firstPage = false;
         // Use the painter to draw on the page.
         painter.setFont(normalFont);
 
         painter.drawText(drawingRect, Qt::AlignLeft, dateString);
         painter.drawText(drawingRect, Qt::AlignHCenter, docName);
         painter.drawText(drawingRect, Qt::AlignRight, QString("%1").arg(page));
 
         painter.drawLine(0, normalFontHeight, drawingRect.width(), normalFontHeight);
 
         painter.setFont(fixedFont);
         int yOffset = normalFontHeight + 1;
         foreach (const QString &row, rows) {
             painter.drawText(0, yOffset + fixedFontHeight, row);
             yOffset += fixedFontHeight;
         }
     }
 }
 
 QStringList Lister::readLines(qint64 &filePos, const qint64 endPos, const int columns, const int lines)
 {
     if (_textArea->hexMode()) {
         return readHexLines(filePos, endPos, columns, lines);
     }
     QStringList list;
     const int maxBytes = std::min(columns * lines * MAX_CHAR_LENGTH, (int) (endPos - filePos));
     if (maxBytes <= 0) {
         return list;
     }
     const QByteArray chunk = cacheChunk(filePos, maxBytes);
     if (chunk.isEmpty()) {
         return list;
     }
 
     QScopedPointer<QTextDecoder> decoder(_codec->makeDecoder());
 
     int byteCounter = 0;
     QString row = "";
     bool skipImmediateNewline = false;
     while (byteCounter < chunk.size() && list.size() < lines) {
         QString chr = decoder->toUnicode(chunk.mid(byteCounter++, 1));
         if (chr.isEmpty()) {
             continue;
         }
 
         // replace unreadable characters
         if ((chr[ 0 ] < 32) && (chr[ 0 ] != '\n') && (chr[ 0 ] != '\t')) {
             chr = QChar(' ');
         }
 
         // handle newline
         if (chr == "\n") {
             if (!skipImmediateNewline) {
                 list << row;
                 row = "";
             }
             skipImmediateNewline = false;
             continue;
         }
 
         skipImmediateNewline = false;
 
         // handle tab
         if (chr == "\t") {
             const int tabLength = _textArea->tabWidth() - (row.length() % _textArea->tabWidth());
             if (row.length() + tabLength > columns) {
                 list << row;
                 row = "";
             }
             row += QString(tabLength, QChar(' '));
         } else {
             // normal printable character
             row += chr;
         }
 
         if (row.length() >= columns) {
             list << row;
             row = "";
             skipImmediateNewline = true;
         }
     }
 
     if (list.size() < lines) {
         list << row;
     }
 
     filePos += byteCounter;
 
     return list;
 }
 
 int Lister::hexPositionDigits()
 {
     int positionDigits = 0;
     qint64 checker = _fileSize;
     while (checker) {
         positionDigits++;
         checker /= 16;
     }
     if (positionDigits < 8) {
         return 8;
     }
     return positionDigits;
 }
 
 int Lister::hexBytesPerLine(const int columns)
 {
     const int positionDigits = hexPositionDigits();
     if (columns >= positionDigits + 5 + 128) {
         return 32;
     }
     if (columns >= positionDigits + 5 + 64) {
         return 16;
     }
     return 8;
 }
 
 QStringList Lister::readHexLines(qint64 &filePos, const qint64 endPos, const int columns, const int lines)
 {
     const int positionDigits = hexPositionDigits();
     const int bytesPerRow = hexBytesPerLine(columns);
 
     QStringList list;
 
     const qint64 choppedPos = (filePos / bytesPerRow) * bytesPerRow;
     const int maxBytes = std::min(bytesPerRow * lines, (int) (endPos - choppedPos));
     if (maxBytes <= 0)
         return list;
 
     const QByteArray chunk = cacheChunk(choppedPos, maxBytes);
     if (chunk.isEmpty())
         return list;
 
     int cnt = 0;
     for (int l = 0; l < lines; l++) {
         if (filePos >= endPos) {
             break;
         }
 
         const qint64 printPos = (filePos / bytesPerRow) * bytesPerRow;
         QString pos;
         pos.setNum(printPos, 16);
         while (pos.length() < positionDigits)
             pos = QString("0") + pos;
         pos = QString("0x") + pos;
         pos += QString(": ");
 
         QString charData;
 
         for (int i = 0; i != bytesPerRow; ++i, ++cnt) {
             const qint64 currentPos = printPos + i;
             if (currentPos < filePos || currentPos >= endPos) {
                 pos += QString("   ");
                 charData += QString(" ");
             } else {
                 char c = chunk.at(cnt);
                 auto charCode = (int)c;
                 if (charCode < 0)
                     charCode += 256;
                 QString hex;
                 hex.setNum(charCode, 16);
                 if (hex.length() < 2)
                     hex = QString("0") + hex;
                 pos += hex + QString(" ");
                 if (c < 32)
                     c = '.';
                 charData += QChar(c);
             }
         }
 
         pos += QString(" ") + charData;
         list << pos;
         filePos = printPos + bytesPerRow;
     }
 
     if (filePos > endPos) {
         filePos = endPos;
     }
 
     return list;
 }
 
 int Lister::hexIndexToPosition(const int columns, const int index)
 {
     const int positionDigits = hexPositionDigits();
     const int bytesPerRow = hexBytesPerLine(columns);
     const int finalIndex = std::min(index, bytesPerRow);
 
     return positionDigits + 4 + (3*finalIndex);
 }
 
 int Lister::hexPositionToIndex(const int columns, const int position)
 {
     const int positionDigits = hexPositionDigits();
     const int bytesPerRow = hexBytesPerLine(columns);
 
     int finalPosition = position;
     finalPosition -= 4 + positionDigits;
     if (finalPosition <= 0)
         return 0;
 
     finalPosition /= 3;
     if (finalPosition >= bytesPerRow)
         return bytesPerRow;
     return finalPosition;
 }
 
 void Lister::toggleHexMode()
 {
     setHexMode(!_textArea->hexMode());
 }
 
 void Lister::setHexMode(const bool mode)
 {
     if (mode) {
         _textArea->setHexMode(true);
         _actionHexMode->setText(i18n("Text mode"));
     } else {
         _textArea->setHexMode(false);
         _actionHexMode->setText(i18n("Hex mode"));
     }
 }
diff --git a/krusader/Locate/locate.cpp b/krusader/Locate/locate.cpp
index f69df8f0..e109212d 100644
--- a/krusader/Locate/locate.cpp
+++ b/krusader/Locate/locate.cpp
@@ -1,689 +1,690 @@
 /*****************************************************************************
  * Copyright (C) 2004 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "locate.h"
 #include "../kractions.h"
 #include "../krglobal.h"
 #include "../filelisticon.h"
 #include "../krslots.h"
 #include "../krusaderview.h"
 #include "../Panel/krpanel.h"
 #include "../Panel/panelfunc.h"
 #include "../GUI/krtreewidget.h"
 #include "../defaults.h"
 #include "../krservices.h"
 #include "../FileSystem/filesystem.h"
 #include "../FileSystem/virtualfilesystem.h"
 #include "../KViewer/krviewer.h"
 #include "../panelmanager.h"
+#include "../compat.h"
 
 // QtCore
 #include <QRegExp>
 #include <QEventLoop>
 #include <QDir>
 #include <QMimeData>
 // QtGui
 #include <QFontMetrics>
 #include <QKeyEvent>
 #include <QCursor>
 #include <QClipboard>
 #include <QFont>
 #include <QDrag>
 // QtWidgets
 #include <QApplication>
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QGridLayout>
 #include <QHeaderView>
 #include <QInputDialog>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QTreeWidget>
 
 #include <KConfigCore/KConfig>
 #include <KCoreAddons/KProcess>
 #include <KI18n/KLocalizedString>
 #include <KIOCore/KFileItem>
 #include <KWidgetsAddons/KMessageBox>
 #include <KCoreAddons/KShell>
 #include <KTextWidgets/KFindDialog>
 #include <KTextWidgets/KFind>
 
 // these are the values that will exist in the menu
 #define VIEW_ID                     90
 #define EDIT_ID                     91
 #define FIND_ID                     92
 #define FIND_NEXT_ID                93
 #define FIND_PREV_ID                94
 #define COPY_SELECTED_TO_CLIPBOARD  95
 #define COMPARE_ID                  96
 //////////////////////////////////////////////////////////
 
 class LocateListView : public KrTreeWidget
 {
 public:
     explicit LocateListView(QWidget * parent) : KrTreeWidget(parent) {
         setAlternatingRowColors(true);
     }
 
     void startDrag(Qt::DropActions supportedActs) Q_DECL_OVERRIDE {
         Q_UNUSED(supportedActs);
 
         QList<QUrl> urls;
         QList<QTreeWidgetItem *> list = selectedItems();
 
         QListIterator<QTreeWidgetItem *> it(list);
 
         while (it.hasNext()) {
             QTreeWidgetItem * item = it.next();
 
             urls.push_back(QUrl::fromLocalFile(item->text(0)));
         }
 
         if (urls.count() == 0)
             return;
 
 
         auto *drag = new QDrag(this);
         auto *mimeData = new QMimeData;
         mimeData->setImageData(FileListIcon("file").pixmap());
         mimeData->setUrls(urls);
         drag->setMimeData(mimeData);
         drag->exec();
     }
 };
 
 KProcess *  LocateDlg::updateProcess = nullptr;
 LocateDlg * LocateDlg::LocateDialog = nullptr;
 
 LocateDlg::LocateDlg(QWidget *parent) : QDialog(parent), isFeedToListBox(false)
 {
     setWindowTitle(i18n("Krusader::Locate"));
     setWindowModality(Qt::NonModal);
 
     auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     auto *grid = new QGridLayout();
     grid->setSpacing(6);
     grid->setContentsMargins(11, 11, 11, 11);
 
     QWidget *hboxWidget = new QWidget(this);
     auto *hbox = new QHBoxLayout(hboxWidget);
     hbox->setContentsMargins(0, 0, 0, 0);
 
     QLabel *label = new QLabel(i18n("Search for:"), hboxWidget);
     hbox->addWidget(label);
 
     locateSearchFor = new KHistoryComboBox(false, hboxWidget);
     locateSearchFor->setMinimumContentsLength(10);
     hbox->addWidget(locateSearchFor);
 
     label->setBuddy(locateSearchFor);
     KConfigGroup group(krConfig, "Locate");
     QStringList list = group.readEntry("Search For", QStringList());
     locateSearchFor->setMaxCount(25);  // remember 25 items
     locateSearchFor->setHistoryItems(list);
     locateSearchFor->setEditable(true);
     locateSearchFor->setDuplicatesEnabled(false);
     locateSearchFor->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
     locateSearchFor->lineEdit()->setFocus();
 
     grid->addWidget(hboxWidget, 0, 0);
 
     QWidget *hboxWidget2 = new QWidget(this);
     auto * hbox2 = new QHBoxLayout(hboxWidget2);
     hbox2->setContentsMargins(0, 0, 0, 0);
 
     auto* spacer = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
     hbox2->addItem(spacer);
 
     dontSearchInPath = new QCheckBox(i18n("Do not search in path"), hboxWidget2);
     hbox2->addWidget(dontSearchInPath);
     dontSearchInPath->setChecked(group.readEntry("Don't Search In Path", false));
 
     existingFiles = new QCheckBox(i18n("Show only the existing files"), hboxWidget2);
     existingFiles->setChecked(group.readEntry("Existing Files", false));
     hbox2->addWidget(existingFiles);
 
     caseSensitive = new QCheckBox(i18n("Case Sensitive"), hboxWidget2);
     caseSensitive->setChecked(group.readEntry("Case Sensitive", false));
     hbox2->addWidget(caseSensitive);
 
     grid->addWidget(hboxWidget2, 1, 0);
 
     QFrame *line1 = new QFrame(this);
     line1->setFrameStyle(QFrame::HLine | QFrame::Sunken);
     grid->addWidget(line1, 2, 0);
 
     resultList = new LocateListView(this);  // create the main container
     resultList->setColumnCount(1);
     resultList->setHeaderLabel(i18n("Results"));
 
-    resultList->setColumnWidth(0, QFontMetrics(resultList->font()).width("W") * 60);
+    resultList->setColumnWidth(0, QFontMetrics(resultList->font()).QFONTMETRICS_WIDTH("W") * 60);
 
     KConfigGroup gl(krConfig, "Look&Feel");
     resultList->setFont(gl.readEntry("Filelist Font", _FilelistFont));
 
     resultList->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     resultList->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     resultList->header()->setSortIndicatorShown(false);
     resultList->setSortingEnabled(false);
     resultList->setSelectionMode(QAbstractItemView::ExtendedSelection);
     resultList->setDragEnabled(true);
 
     connect(resultList, &KrTreeWidget::itemRightClicked, this, &LocateDlg::slotRightClick);
     connect(resultList, &KrTreeWidget::itemDoubleClicked, this, &LocateDlg::slotDoubleClick);
     connect(resultList, &KrTreeWidget::itemActivated, this, &LocateDlg::slotDoubleClick);
 
     grid->addWidget(resultList, 3, 0);
 
     QFrame *line2 = new QFrame(this);
     line2->setFrameStyle(QFrame::HLine | QFrame::Sunken);
     grid->addWidget(line2, 4, 0);
 
     mainLayout->addLayout(grid);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     locateButton = new QPushButton(i18n("Locate"));
     locateButton->setIcon(Icon(QStringLiteral("system-search")));
     locateButton->setDefault(true);
     buttonBox->addButton(locateButton, QDialogButtonBox::ActionRole);
 
     updateDbButton = new QPushButton(i18n("Update DB"));
     updateDbButton->setIcon(Icon(QStringLiteral("view-refresh")));
     buttonBox->addButton(updateDbButton, QDialogButtonBox::ActionRole);
 
     feedStopButton = new QPushButton;
     buttonBox->addButton(feedStopButton, QDialogButtonBox::ActionRole);
 
     connect(buttonBox, &QDialogButtonBox::rejected, this, &LocateDlg::reject);
     connect(locateButton, &QPushButton::clicked, this, &LocateDlg::slotLocate);
     connect(updateDbButton, &QPushButton::clicked, this, &LocateDlg::slotUpdateDb);
     connect(feedStopButton, &QPushButton::clicked, this, &LocateDlg::slotFeedStop);
 
     updateButtons(false);
 
     if (updateProcess) {
         if (updateProcess->state() == QProcess::Running) {
             connect(updateProcess, QOverload<int, QProcess::ExitStatus>::of(&KProcess::finished), this, &LocateDlg::updateFinished);
             updateDbButton->setEnabled(false);
         } else
             updateFinished();
     }
 
     show();
 
     LocateDialog = this;
 }
 
 void LocateDlg::slotFeedStop()   /* The stop / feed to listbox button */
 {
     if (isFeedToListBox)
         feedToListBox();
     else
         locateProc->kill();
 }
 
 void LocateDlg::slotUpdateDb()   /* The Update DB button */
 {
     if (!updateProcess) {
         KConfigGroup group(krConfig, "Locate");
 
         updateProcess = new KProcess(); // don't set the parent to 'this'! That would cause this process to be deleted once the dialog is closed
         *updateProcess << KrServices::fullPathName("updatedb");
         *updateProcess << KShell::splitArgs(group.readEntry("UpdateDB Arguments"));
 
         connect(updateProcess, QOverload<int, QProcess::ExitStatus>::of(&KProcess::finished), this, &LocateDlg::updateFinished);
         updateProcess->start();
         updateDbButton->setEnabled(false);
     }
 }
 
 void LocateDlg::updateFinished()
 {
     delete updateProcess;
     updateProcess = nullptr;
     updateDbButton->setEnabled(true);
 }
 
 void LocateDlg::slotLocate()   /* The locate button */
 {
     locateSearchFor->addToHistory(locateSearchFor->currentText());
     QStringList list = locateSearchFor->historyItems();
     KConfigGroup group(krConfig, "Locate");
     group.writeEntry("Search For", list);
     group.writeEntry("Don't Search In Path", dontSearchPath = dontSearchInPath->isChecked());
     group.writeEntry("Existing Files", onlyExist = existingFiles->isChecked());
     group.writeEntry("Case Sensitive", isCs = caseSensitive->isChecked());
 
     if (!KrServices::cmdExist("locate")) {
         KMessageBox::error(nullptr,
                            i18n("Cannot start 'locate'. Check the 'Dependencies' page in konfigurator."));
         return;
     }
 
     resultList->clear();
     lastItem = nullptr;
     remaining = "";
 
     updateButtons(true);
 
     isFeedToListBox = false;
     resultList->setFocus();
 
     qApp->processEvents(); //FIXME - what's this for ?
 
     locateProc = new KProcess(this);
     locateProc->setOutputChannelMode(KProcess::SeparateChannels); // default is forwarding to the parent channels
     connect(locateProc, &KProcess::readyReadStandardOutput, this, &LocateDlg::processStdout);
     connect(locateProc, &KProcess::readyReadStandardError, this, &LocateDlg::processStderr);
     connect(locateProc, QOverload<int,QProcess::ExitStatus>::of(&KProcess::finished), this, &LocateDlg::locateFinished);
     connect(locateProc, QOverload<QProcess::ProcessError>::of(&KProcess::error), this, &LocateDlg::locateError);
 
     *locateProc << KrServices::fullPathName("locate");
     if (!isCs)
         *locateProc << "-i";
     *locateProc << (pattern = locateSearchFor->currentText());
 
     if (!pattern.startsWith('*'))
         pattern = '*' + pattern;
     if (!pattern.endsWith('*'))
         pattern = pattern + '*';
 
     collectedErr = "";
     locateProc->start();
 }
 
 void LocateDlg::locateError()
 {
     if (locateProc->error() == QProcess::FailedToStart)
         KMessageBox::error(krMainWindow, i18n("Error during the start of 'locate' process."));
 }
 
 void LocateDlg::locateFinished()
 {
     if (locateProc->exitStatus() != QProcess::NormalExit || locateProc->exitStatus()) {
         if (!collectedErr.isEmpty())
             KMessageBox::error(krMainWindow, i18n("Locate produced the following error message:\n\n%1", collectedErr));
     }
 
     if (resultList->topLevelItemCount() == 0) {
         locateSearchFor->setFocus();
         isFeedToListBox = false;
     } else {
         isFeedToListBox = true;
     }
 
     updateButtons(false);
 }
 
 void LocateDlg::processStdout()
 {
     remaining += QString::fromLocal8Bit(locateProc->readAllStandardOutput());
 
     QStringList list = remaining.split('\n');
     int items = list.size();
 
     for (auto & it : list) {
         if (--items == 0 && !remaining.endsWith('\n'))
             remaining = it;
         else {
             if (dontSearchPath) {
                 QRegExp regExp(pattern, isCs ? Qt::CaseSensitive : Qt::CaseInsensitive, QRegExp::Wildcard);
                 QString fileName = it.trimmed();
                 if (fileName.endsWith(QLatin1String("/")) && fileName != "/") {
                     fileName.truncate(fileName.length() - 1);
                 }
                 fileName = fileName.mid(fileName.lastIndexOf('/') + 1);
 
                 if (!regExp.exactMatch(fileName))
                     continue;
             }
             if (onlyExist) {
                 KFileItem file(QUrl::fromLocalFile(it.trimmed()));
                 if (!file.isReadable())
                     continue;
             }
 
             if (lastItem)
                 lastItem = new QTreeWidgetItem(resultList, lastItem);
             else
                 lastItem = new QTreeWidgetItem(resultList);
 
             lastItem->setText(0, it);
         }
     }
 }
 
 void LocateDlg::processStderr()
 {
     collectedErr += QString::fromLocal8Bit(locateProc->readAllStandardError());
 }
 
 void LocateDlg::slotRightClick(QTreeWidgetItem *item, const QPoint &pos)
 {
     if (!item)
         return;
 
     // create the menu
     QMenu popup;
     popup.setTitle(i18nc("@title:menu", "Locate"));
 
     QAction * actView = popup.addAction(i18n("View (F3)"));
     QAction * actEdit = popup.addAction(i18n("Edit (F4)"));
     QAction * actComp = popup.addAction(i18n("Compare by content (F10)"));
     if (resultList->selectedItems().count() != 2)
         actComp->setEnabled(false);
     popup.addSeparator();
 
     QAction * actFind = popup.addAction(i18n("Find (Ctrl+F)"));
     QAction * actNext = popup.addAction(i18n("Find next (Ctrl+N)"));
     QAction * actPrev = popup.addAction(i18n("Find previous (Ctrl+P)"));
     popup.addSeparator();
 
     QAction * actClip = popup.addAction(i18n("Copy selected to clipboard"));
 
 
     QAction * result = popup.exec(pos);
 
     int ret = -1;
 
     if (result == actView)
         ret = VIEW_ID;
     else if (result == actEdit)
         ret = EDIT_ID;
     else if (result == actFind)
         ret = FIND_ID;
     else if (result == actNext)
         ret = FIND_NEXT_ID;
     else if (result == actPrev)
         ret = FIND_PREV_ID;
     else if (result == actClip)
         ret = COPY_SELECTED_TO_CLIPBOARD;
     else if (result == actComp)
         ret = COMPARE_ID;
 
     if (ret != - 1)
         operate(item, ret);
 }
 
 void LocateDlg::slotDoubleClick(QTreeWidgetItem *item)
 {
     if (!item)
         return;
 
     QString dirName = item->text(0);
     QString fileName;
 
     if (!QDir(dirName).exists()) {
         fileName = dirName.mid(dirName.lastIndexOf('/') + 1);
         dirName.truncate(dirName.lastIndexOf('/'));
     }
 
     ACTIVE_FUNC->openUrl(QUrl::fromLocalFile(dirName), fileName);
     QDialog::accept();
 }
 
 void LocateDlg::keyPressEvent(QKeyEvent *e)
 {
     if (KrGlobal::copyShortcut == QKeySequence(e->key() | e->modifiers())) {
         operate(nullptr, COPY_SELECTED_TO_CLIPBOARD);
         e->accept();
         return;
     }
 
     switch (e->key()) {
     case Qt::Key_M :
         if (e->modifiers() == Qt::ControlModifier) {
             resultList->setFocus();
             e->accept();
         }
         break;
     case Qt::Key_F3 :
         if (resultList->currentItem())
             operate(resultList->currentItem(), VIEW_ID);
         break;
     case Qt::Key_F4 :
         if (resultList->currentItem())
             operate(resultList->currentItem(), EDIT_ID);
         break;
     case Qt::Key_F10 :
         operate(nullptr, COMPARE_ID);
         break;
     case Qt::Key_N :
         if (e->modifiers() == Qt::ControlModifier)
             operate(resultList->currentItem(), FIND_NEXT_ID);
         break;
     case Qt::Key_P :
         if (e->modifiers() == Qt::ControlModifier)
             operate(resultList->currentItem(), FIND_PREV_ID);
         break;
     case Qt::Key_F :
         if (e->modifiers() == Qt::ControlModifier)
             operate(resultList->currentItem(), FIND_ID);
         break;
     }
 
     QDialog::keyPressEvent(e);
 }
 
 void LocateDlg::operate(QTreeWidgetItem *item, int task)
 {
     QUrl name;
     if (item != nullptr)
         name = QUrl::fromLocalFile(item->text(0));
 
     switch (task) {
     case VIEW_ID:
         KrViewer::view(name, this);   // view the file
         break;
     case EDIT_ID:
         KrViewer::edit(name, this);   // view the file
         break;
     case COMPARE_ID: {
         QList<QTreeWidgetItem *> list = resultList->selectedItems();
         if (list.count() != 2)
             break;
 
         QUrl url1 = QUrl::fromLocalFile(list[ 0 ]->text(0));
         QUrl url2 = QUrl::fromLocalFile(list[ 1 ]->text(0));
 
         SLOTS->compareContent(url1,url2);
     }
     break;
     case FIND_ID: {
         KConfigGroup group(krConfig, "Locate");
         long options = group.readEntry("Find Options", (long long)0);
         QStringList list = group.readEntry("Find Patterns", QStringList());
 
         QPointer<KFindDialog> dlg = new KFindDialog(this, options, list);
         if (dlg->exec() != QDialog::Accepted) {
             delete dlg;
             return;
         }
 
         QString first;
         if (list.count() != 0) {
             first = list.first();
         }
         if (first != (findPattern = dlg->pattern())) {
             list.push_front(dlg->pattern());
         }
 
         group.writeEntry("Find Options", (long long)(findOptions = dlg->options()));
         group.writeEntry("Find Patterns", list);
 
         if (!(findOptions & KFind::FromCursor) && resultList->topLevelItemCount())
             resultList->setCurrentItem((findOptions & KFind::FindBackwards) ?
                                        resultList->topLevelItem(resultList->topLevelItemCount() - 1) : resultList->topLevelItem(0));
 
         findCurrentItem = resultList->currentItem();
 
         if (find() && findCurrentItem) {
             resultList->selectionModel()->clearSelection(); // HACK: QT 4 is not able to paint the focus frame because of a bug
             resultList->setCurrentItem(findCurrentItem);
         } else {
             KMessageBox::information(this, i18n("Search string not found."));
         }
 
         resultList->scrollTo(resultList->currentIndex());
 
         delete dlg;
     }
     break;
     case FIND_NEXT_ID:
     case FIND_PREV_ID: {
         if (task == FIND_PREV_ID)
             findOptions ^= KFind::FindBackwards;
 
         findCurrentItem = resultList->currentItem();
         nextLine();
 
         if (find() && findCurrentItem) {
             resultList->selectionModel()->clearSelection(); // HACK: QT 4 is not able to paint the focus frame because of a bug
             resultList->setCurrentItem(findCurrentItem);
         } else
             KMessageBox::information(this, i18n("Search string not found."));
 
         resultList->scrollTo(resultList->currentIndex());
 
         if (task == FIND_PREV_ID)
             findOptions ^= KFind::FindBackwards;
     }
     break;
     case COPY_SELECTED_TO_CLIPBOARD: {
         QList<QUrl> urls;
 
         QTreeWidgetItemIterator it(resultList);
         while (*it) {
             if ((*it)->isSelected())
                 urls.push_back(QUrl::fromLocalFile((*it)->text(0)));
 
             it++;
         }
 
         if (urls.count() == 0)
             return;
 
         auto *mimeData = new QMimeData;
         mimeData->setImageData(FileListIcon("file").pixmap());
         mimeData->setUrls(urls);
 
         QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
     }
     break;
     }
 }
 
 void LocateDlg::nextLine()
 {
     if (findOptions & KFind::FindBackwards)
         findCurrentItem = resultList->itemAbove(findCurrentItem);
     else
         findCurrentItem = resultList->itemBelow(findCurrentItem);
 }
 
 bool LocateDlg::find()
 {
     while (findCurrentItem) {
         QString item = findCurrentItem->text(0);
 
         if (findOptions & KFind::RegularExpression) {
             if (item.contains(QRegExp(findPattern, ((findOptions & KFind::CaseSensitive) != 0) ? Qt::CaseSensitive : Qt::CaseInsensitive)))
                 return true;
         } else {
             if (item.contains(findPattern, ((findOptions & KFind::CaseSensitive) != 0) ? Qt::CaseSensitive : Qt::CaseInsensitive))
                 return true;
         }
 
         nextLine();
     }
 
     return false;
 }
 
 void LocateDlg::feedToListBox()
 {
     VirtualFileSystem virtFilesystem;
     virtFilesystem.scanDir(QUrl::fromLocalFile(QStringLiteral("/")));
 
     KConfigGroup group(krConfig, "Locate");
     int listBoxNum = group.readEntry("Feed To Listbox Counter", 1);
     QString queryName;
     do {
         queryName = i18n("Locate results") + QString(" %1").arg(listBoxNum++);
     } while (virtFilesystem.getFileItem(queryName) != nullptr);
     group.writeEntry("Feed To Listbox Counter", listBoxNum);
 
     KConfigGroup ga(krConfig, "Advanced");
     if (ga.readEntry("Confirm Feed to Listbox",  _ConfirmFeedToListbox)) {
         bool ok;
         queryName = QInputDialog::getText(this, i18n("Query Name"), i18n("Here you can name the file collection:"),
                                           QLineEdit::Normal, queryName, &ok);
         if (! ok)
             return;
     }
 
     QList<QUrl> urlList;
     QTreeWidgetItemIterator it(resultList);
     while (*it) {
         QTreeWidgetItem * item = *it;
         urlList.push_back(QUrl::fromLocalFile(item->text(0)));
         it++;
     }
     QUrl url = QUrl(QStringLiteral("virt:/") + queryName);
     virtFilesystem.refresh(url); // create directory if it does not exist
     virtFilesystem.addFiles(urlList);
     //ACTIVE_FUNC->openUrl(url);
     ACTIVE_MNG->slotNewTab(url);
     accept();
 }
 
 void LocateDlg::reset()
 {
     locateSearchFor->lineEdit()->setFocus();
     locateSearchFor->lineEdit()->selectAll();
 }
 
 void LocateDlg::updateButtons(bool locateIsRunning)
 {
     locateButton->setEnabled(!locateIsRunning);
 
     if (locateIsRunning) {
         feedStopButton->setEnabled(true);
         feedStopButton->setText(i18n("Stop"));
         feedStopButton->setIcon(Icon(QStringLiteral("process-stop")));
     } else {
         if (resultList->topLevelItemCount() == 0) {
             feedStopButton->setEnabled(false);
             feedStopButton->setText(i18n("Stop"));
             feedStopButton->setIcon(Icon(QStringLiteral("process-stop")));
         } else {
             feedStopButton->setEnabled(true);
             feedStopButton->setText(i18n("Feed to listbox"));
             feedStopButton->setIcon(Icon(QStringLiteral("list-add")));
         }
     }
 }
 
diff --git a/krusader/MountMan/kmountmangui.cpp b/krusader/MountMan/kmountmangui.cpp
index 1fb605cb..5f00c7f4 100644
--- a/krusader/MountMan/kmountmangui.cpp
+++ b/krusader/MountMan/kmountmangui.cpp
@@ -1,526 +1,527 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 
 #include "kmountmangui.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../Dialogs/krspecialwidgets.h"
 #include "../defaults.h"
 #include "../FileSystem/filesystem.h"
+#include "../compat.h"
 
 // QtCore
 #include <QCryptographicHash>
 #include <QList>
 #include <QFileInfo>
 // QtGui
 #include <QPixmap>
 #include <QBitmap>
 #include <QCursor>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QHeaderView>
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QMenu>
 #include <QPushButton>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 #include <KWidgetsAddons/KGuiItem>
 #include <KIOCore/KDiskFreeSpaceInfo>
 #include <KIOCore/KMountPoint>
 #include <KCodecs/KCodecs>
 
 #include <Solid/StorageVolume>
 
 #ifndef BSD
 #define MTAB "/etc/mtab"
 #endif
 
 KMountManGUI::KMountManGUI(KMountMan *mntMan) : QDialog(mntMan->parentWindow),
     mountMan(mntMan),
     info(nullptr),
     mountList(nullptr),
     cbShowOnlyRemovable(nullptr),
     watcher(nullptr),
     sizeX(-1),
     sizeY(-1)
 {
     setWindowTitle(i18n("MountMan - Your Mount-Manager"));
     setWindowModality(Qt::WindowModal);
 
     auto *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     watcher = new QTimer(this);
     connect(watcher, &QTimer::timeout, this, &KMountManGUI::checkMountChange);
 
     mainLayout->addLayout(createMainPage());
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     ejectButton = new QPushButton(i18n("&Eject"));
     ejectButton->setIcon(Icon(QStringLiteral("media-eject")));
     ejectButton->setEnabled(false);
     buttonBox->addButton(ejectButton, QDialogButtonBox::ActionRole);
 
     mountButton = new QPushButton(i18n("&Unmount"));
     mountButton->setEnabled(false);
     buttonBox->addButton(mountButton, QDialogButtonBox::ActionRole);
 
     // connections
     connect(buttonBox, &QDialogButtonBox::rejected, this, &KMountManGUI::reject);
     connect(ejectButton, &QPushButton::clicked, this, &KMountManGUI::slotEject);
     connect(mountButton, &QPushButton::clicked, this, &KMountManGUI::slotToggleMount);
     connect(mountList, &KrTreeWidget::itemDoubleClicked, this, &KMountManGUI::doubleClicked);
     connect(mountList, &KrTreeWidget::itemRightClicked, this, &KMountManGUI::clicked);
     connect(mountList, &KrTreeWidget::itemClicked, this, QOverload<QTreeWidgetItem *>::of(&KMountManGUI::changeActive));
     connect(mountList, &KrTreeWidget::itemSelectionChanged, this, QOverload<>::of(&KMountManGUI::changeActive));
 
     KConfigGroup group(krConfig, "MountMan");
     int sx = group.readEntry("Window Width", -1);
     int sy = group.readEntry("Window Height", -1);
 
     if (sx != -1 && sy != -1)
         resize(sx, sy);
     else
         resize(600, 300);
 
     if (group.readEntry("Window Maximized",  false))
         showMaximized();
     else
         show();
 
     getSpaceData();
 
     exec();
 }
 
 KMountManGUI::~KMountManGUI()
 {
     watcher->stop();
     delete watcher;
 
     KConfigGroup group(krConfig, "MountMan");
 
     group.writeEntry("Window Width", sizeX);
     group.writeEntry("Window Height", sizeY);
     group.writeEntry("Window Maximized", isMaximized());
     group.writeEntry("Last State", mountList->header()->saveState());
     group.writeEntry("ShowOnlyRemovable", cbShowOnlyRemovable->isChecked());
 }
 
 
 void KMountManGUI::resizeEvent(QResizeEvent *e)
 {
     if (!isMaximized()) {
         sizeX = e->size().width();
         sizeY = e->size().height();
     }
 
     QDialog::resizeEvent(e);
 }
 
 QLayout *KMountManGUI::createMainPage()
 {
     auto *layout = new QGridLayout();
     layout->setSpacing(10);
     mountList = new KrTreeWidget(this);    // create the main container
     KConfigGroup grp(krConfig, "Look&Feel");
     mountList->setFont(grp.readEntry("Filelist Font", _FilelistFont));
     mountList->setSelectionMode(QAbstractItemView::SingleSelection);
     mountList->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     mountList->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
 
     QStringList labels;
     labels << i18n("Name");
     labels << i18n("Type");
     labels << i18n("Mnt.Point");
     labels << i18n("Total Size");
     labels << i18n("Free Size");
     labels << i18n("Free %");
     mountList->setHeaderLabels(labels);
 
     mountList->header()->setSectionResizeMode(QHeaderView::Interactive);
 
     grp = KConfigGroup(krConfig, "MountMan");
     if (grp.hasKey("Last State"))
         mountList->header()->restoreState(grp.readEntry("Last State", QByteArray()));
     else {
-        int i = QFontMetrics(mountList->font()).width("W");
-        int j = QFontMetrics(mountList->font()).width("0");
+        int i = QFontMetrics(mountList->font()).QFONTMETRICS_WIDTH("W");
+        int j = QFontMetrics(mountList->font()).QFONTMETRICS_WIDTH("0");
         j = (i > j ? i : j);
 
         mountList->setColumnWidth(0, j*8);
         mountList->setColumnWidth(1, j*4);
         mountList->setColumnWidth(2, j*8);
         mountList->setColumnWidth(3, j*6);
         mountList->setColumnWidth(4, j*6);
         mountList->setColumnWidth(5, j*5);
     }
 
     mountList->setAllColumnsShowFocus(true);
     mountList->header()->setSortIndicatorShown(true);
 
     mountList->sortItems(0, Qt::AscendingOrder);
 
     // now the list is created, time to fill it with data.
     //=>mountMan->forceUpdate();
 
     QGroupBox *box = new QGroupBox(i18n("MountMan.Info"), this);
     box->setAlignment(Qt::AlignHCenter);
     auto *vboxl = new QVBoxLayout(box);
     info = new KRFSDisplay(box);
     vboxl->addWidget(info);
     info->resize(info->width(), height());
 
     cbShowOnlyRemovable = new QCheckBox(i18n("Show only removable devices"), this);
     cbShowOnlyRemovable->setChecked(grp.readEntry("ShowOnlyRemovable", false));
     connect(cbShowOnlyRemovable , &QCheckBox::stateChanged, this, &KMountManGUI::updateList);
 
     layout->addWidget(box, 0, 0);
     layout->addWidget(cbShowOnlyRemovable, 1, 0);
     layout->addWidget(mountList, 0, 1, 2, 1);
 
     return layout;
 }
 
 void KMountManGUI::getSpaceData()
 {
     fileSystems.clear();
     KrMountDetector::getInstance()->hasMountsChanged();
 
     mounted = KMountPoint::currentMountPoints();
     possible = KMountPoint::possibleMountPoints();
     if (mounted.size() == 0) {   // nothing is mounted
         addNonMounted();
         updateList(); // let's continue
         return;
     }
 
     for (auto & it : mounted) {
         // don't bother with invalid file systems
         if (mountMan->invalidFilesystem(it->mountType())) {
             continue;
         }
         KDiskFreeSpaceInfo info = KDiskFreeSpaceInfo::freeSpaceInfo(it ->mountPoint());
         if(!info.isValid()) {
             continue;
         }
         fsData data;
         data.setMntPoint(it ->mountPoint());
         data.setMounted(true);
         data.setTotalBlks(info.size() / 1024);
         data.setFreeBlks(info.available() / 1024);
         data.setName(it->mountedFrom());
         data.setType(it->mountType());
         fileSystems.append(data);
     }
     addNonMounted();
     updateList();
 }
 
 void KMountManGUI::addNonMounted()
 {
     // handle the non-mounted ones
     for (auto & it : possible) {
         // make sure we don't add things we've already added
         if (KMountMan::findInListByMntPoint(mounted, it->mountPoint())) {
             continue;
         } else {
             fsData data;
             data.setMntPoint(it->mountPoint());
             data.setMounted(false);
             data.setType(it->mountType());
             data.setName(it->mountedFrom());
 
             if (mountMan->invalidFilesystem(data.type()))
                 continue;
 
             fileSystems.append(data);
         }
     }
 }
 
 void KMountManGUI::addItemToMountList(KrTreeWidget *lst, fsData &fs)
 {
     Solid::Device device(mountMan->findUdiForPath(fs.mntPoint(), Solid::DeviceInterface::StorageAccess));
 
     if (cbShowOnlyRemovable->isChecked() && !mountMan->removable(device))
         return;
 
     bool mtd = fs.mounted();
 
     QString tSize = QString("%1").arg(KIO::convertSizeFromKiB(fs.totalBlks()));
     QString fSize = QString("%1").arg(KIO::convertSizeFromKiB(fs.freeBlks()));
     QString sPrct = QString("%1%").arg(100 - (fs.usedPerct()));
     auto *item = new QTreeWidgetItem(lst);
     item->setText(0, fs.name());
     item->setText(1, fs.type());
     item->setText(2, fs.mntPoint());
     item->setText(3, (mtd ? tSize : QString("N/A")));
     item->setText(4, (mtd ? fSize : QString("N/A")));
     item->setText(5, (mtd ? sPrct : QString("N/A")));
 
     auto *vol = device.as<Solid::StorageVolume> ();
     QString iconName;
 
     if(device.isValid())
         iconName = device.icon();
     else if(mountMan->networkFilesystem(fs.type()))
         iconName = "folder-remote";
     QStringList overlays;
     if (mtd) {
         overlays << "emblem-mounted";
     } else {
         overlays << QString(); // We have to guarantee the placement of the next emblem
     }
     if (vol && vol->usage() == Solid::StorageVolume::Encrypted) {
         overlays << "security-high";
     }
     item->setIcon(0, Icon(iconName, overlays));
 }
 
 void KMountManGUI::updateList()
 {
     QString currentMP;
     int currentIdx = 0;
     QTreeWidgetItem *currentItem = mountList->currentItem();
     if(currentItem) {
         currentMP = getMntPoint(currentItem);
         currentIdx = mountList->indexOfTopLevelItem(currentItem);
     }
 
     mountList->clearSelection();
     mountList->clear();
 
     for (auto & fileSystem : fileSystems)
         addItemToMountList(mountList, fileSystem);
 
     currentItem = mountList->topLevelItem(currentIdx);
     for(int i = 0; i < mountList->topLevelItemCount(); i++) {
         QTreeWidgetItem *item = mountList->topLevelItem(i);
         if(getMntPoint(item) == currentMP)
                 currentItem = item;
     }
     if(!currentItem)
         currentItem = mountList->topLevelItem(0);
     mountList->setCurrentItem(currentItem);
     changeActive(currentItem);
 
     mountList->setFocus();
 
     watcher->setSingleShot(true);
     watcher->start(WATCHER_DELAY);     // starting the watch timer ( single shot )
 }
 
 void KMountManGUI::checkMountChange()
 {
     if (KrMountDetector::getInstance()->hasMountsChanged())
         getSpaceData();
     watcher->setSingleShot(true);
     watcher->start(WATCHER_DELAY);     // starting the watch timer ( single shot )
 }
 
 void KMountManGUI::doubleClicked(QTreeWidgetItem *i)
 {
     if (!i)
         return; // we don't want to refresh to swap, do we ?
 
     // change the active panel to this mountpoint
     mountMan->emitRefreshPanel(QUrl::fromLocalFile(getMntPoint(i)));
     close();
 }
 
 void KMountManGUI::changeActive()
 {
     QList<QTreeWidgetItem *> seld = mountList->selectedItems();
     if (seld.count() > 0)
         changeActive(seld[ 0 ]);
 }
 
 // when user clicks on a filesystem, change information
 void KMountManGUI::changeActive(QTreeWidgetItem *i)
 {
     if (!i) {
         if (info) {
             info->setEmpty(true);
             info->update();
         }
         mountButton->setEnabled(false);
         ejectButton->setEnabled(false);
         return;
     }
 
     fsData *system = getFsData(i);
 
     info->setAlias(system->mntPoint());
     info->setRealName(system->name());
     info->setMounted(system->mounted());
     info->setEmpty(false);
     info->setTotalSpace(system->totalBlks());
     info->setFreeSpace(system->freeBlks());
     info->repaint();
 
     if(system->mounted())
         mountButton->setText(i18n("&Unmount"));
     else
         mountButton->setText(i18n("&Mount"));
 
     ejectButton->setEnabled(mountMan->ejectable(system->mntPoint()));
     mountButton->setEnabled(true);
 }
 
 // called when right-clicked on a filesystem
 void KMountManGUI::clicked(QTreeWidgetItem *item, const QPoint & pos)
 {
     // these are the values that will exist in the menu
 #define MOUNT_ID       90
 #define UNMOUNT_ID     91
 #define FORMAT_ID      93
 #define EJECT_ID       94
     //////////////////////////////////////////////////////////
     if (!item) return;
 
     fsData *system = getFsData(item);
     // create the menu
     QMenu popup;
     popup.setTitle(i18n("MountMan"));
     if (!system->mounted()) {
         QAction *mountAct = popup.addAction(i18n("Mount"));
         mountAct->setData(QVariant(MOUNT_ID));
         bool enable = !(mountMan->nonmountFilesystem(system->type(), system->mntPoint()));
         mountAct->setEnabled(enable);
     } else {
         QAction * umountAct =  popup.addAction(i18n("Unmount"));
         umountAct->setData(QVariant(UNMOUNT_ID));
         bool enable = !(mountMan->nonmountFilesystem(system->type(), system->mntPoint()));
         umountAct->setEnabled(enable);
     }
     if (mountMan->ejectable(system->mntPoint()))
         //  if (system->type()=="iso9660" || mountMan->followLink(system->name()).left(2)=="cd")
         popup.addAction(i18n("Eject"))->setData(QVariant(EJECT_ID));
     else {
         QAction *formatAct = popup.addAction(i18n("Format"));
         formatAct->setData(QVariant(FORMAT_ID));
         formatAct->setEnabled(false);
     }
 
     QString mountPoint = system->mntPoint();
 
     QAction * res = popup.exec(pos);
     int result = -1;
 
     if (res && res->data().canConvert<int>())
         result = res->data().toInt();
 
     // check out the user's option
     switch (result) {
     case - 1 : return ;     // the user clicked outside of the menu
     case MOUNT_ID :
     case UNMOUNT_ID :
         mountMan->toggleMount(mountPoint);
         break;
     case FORMAT_ID :
         break;
     case EJECT_ID :
         mountMan->eject(mountPoint);
         break;
     }
 }
 
 void KMountManGUI::slotToggleMount()
 {
     QTreeWidgetItem *item = mountList->currentItem();
     if(item) {
         mountMan->toggleMount(getFsData(item)->mntPoint());
     }
 }
 
 void KMountManGUI::slotEject()
 {
     QTreeWidgetItem *item = mountList->currentItem();
     if(item) {
         mountMan->eject(getFsData(item)->mntPoint());
     }
 }
 
 fsData* KMountManGUI::getFsData(QTreeWidgetItem *item)
 {
     for (auto & fileSystem : fileSystems) {
         // the only thing which is unique is the mount point
         if (fileSystem.mntPoint() == getMntPoint(item)) {
             return & fileSystem;
         }
     }
     //this point shouldn't be reached
     abort();
     return nullptr;
 }
 
 QString KMountManGUI::getMntPoint(QTreeWidgetItem *item)
 {
     return item->text(2); // text(2) ? ugly ugly ugly
 }
 
 
 KrMountDetector::KrMountDetector()
 {
     hasMountsChanged();
 }
 
 bool KrMountDetector::hasMountsChanged()
 {
     bool result = false;
 #ifndef BSD
     QFileInfo mtabInfo(MTAB);
     if (!mtabInfo.exists() || mtabInfo.isSymLink()) { // if mtab is a symlimk to /proc/mounts the mtime is unusable
 #endif
         KMountPoint::List mountPoints = KMountPoint::currentMountPoints(KMountPoint::NeedRealDeviceName);
         QCryptographicHash md5(QCryptographicHash::Md5);
         for (auto & mountPoint : mountPoints) {
             md5.addData(mountPoint->mountedFrom().toUtf8());
             md5.addData(mountPoint->realDeviceName().toUtf8());
             md5.addData(mountPoint->mountPoint().toUtf8());
             md5.addData(mountPoint->mountType().toUtf8());
         }
         QString s = md5.result();
         result = s != checksum;
         checksum = s;
 #ifndef BSD
     } else {
         result = mtabInfo.lastModified() != lastMtab;
         lastMtab = mtabInfo.lastModified();
     }
 #endif
     return result;
 }
 
 KrMountDetector krMountDetector;
 KrMountDetector * KrMountDetector::getInstance()
 {
     return & krMountDetector;
 }
 
diff --git a/krusader/Panel/PanelView/krinterbriefview.cpp b/krusader/Panel/PanelView/krinterbriefview.cpp
index c75cadbc..feefdfe5 100644
--- a/krusader/Panel/PanelView/krinterbriefview.cpp
+++ b/krusader/Panel/PanelView/krinterbriefview.cpp
@@ -1,704 +1,705 @@
 /*****************************************************************************
  * Copyright (C) 2009 Csaba Karai <cskarai@freemail.hu>                      *
  * Copyright (C) 2009-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krinterbriefview.h"
 
 // QtCore
 #include <QDir>
 #include <QHashIterator>
 #include <QItemSelection>
 #include <QItemSelectionRange>
 // QtGui
 #include <QFontMetrics>
 #include <QPainter>
 #include <QRegion>
 // QtWidgets
 #include <QDirModel>
 #include <QApplication>
 #include <QMenu>
 #include <QScrollBar>
 
 #include <KConfigCore/KConfig>
 #include <KI18n/KLocalizedString>
 #include <KIOWidgets/KDirLister>
 
 #include "krmousehandler.h"
 #include "krviewfactory.h"
 #include "krviewitemdelegate.h"
 #include "krviewitem.h"
 #include "listmodel.h"
 #include "../krcolorcache.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../defaults.h"
 #include "../GUI/krstyleproxy.h"
+#include "../compat.h"
 
 #define MAX_BRIEF_COLS 5
 
 KrInterBriefView::KrInterBriefView(QWidget *parent, KrViewInstance &instance, KConfig *cfg) :
         QAbstractItemView(parent),
         KrInterView(instance, cfg, this),
         _header(nullptr)
 {
     setWidget(this);
     setModel(_model);
 
     setSelectionMode(QAbstractItemView::NoSelection);
     setSelectionModel(new DummySelectionModel(_model, this));
 
     KConfigGroup grpSvr(_config, "Look&Feel");
     _viewFont = grpSvr.readEntry("Filelist Font", _FilelistFont);
 
     auto *style = new KrStyleProxy();
     style->setParent(this);
     setStyle(style);
     viewport()->setStyle(style); // for custom tooltip delay
     setItemDelegate(new KrViewItemDelegate());
     setMouseTracking(true);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
 
     connect(_mouseHandler, &KrMouseHandler::renameCurrentItem, this, &KrInterBriefView::renameCurrentItem);
 
     _model->setExtensionEnabled(false);
     _model->setAlternatingTable(true);
     connect(_model, &ListModel::layoutChanged, this, &KrInterBriefView::updateGeometries);
 }
 
 KrInterBriefView::~KrInterBriefView()
 {
     delete _properties;
     _properties = nullptr;
 
     delete _operator;
     _operator = nullptr;
 }
 
 void KrInterBriefView::doRestoreSettings(KConfigGroup group)
 {
     _properties->numberOfColumns = group.readEntry("Number Of Brief Columns", _NumberOfBriefColumns);
     if (_properties->numberOfColumns < 1)
         _properties->numberOfColumns = 1;
     else if (_properties->numberOfColumns > MAX_BRIEF_COLS)
         _properties->numberOfColumns = MAX_BRIEF_COLS;
 
     _numOfColumns = _properties->numberOfColumns;
 
     KrInterView::doRestoreSettings(group);
 
     updateGeometries();
 }
 
 void KrInterBriefView::saveSettings(KConfigGroup grp, KrViewProperties::PropertyType properties)
 {
     KrInterView::saveSettings(grp, properties);
     if(properties & KrViewProperties::PropColumns)
         grp.writeEntry("Number Of Brief Columns", _numOfColumns);
 }
 
 int KrInterBriefView::itemsPerPage()
 {
     int height = getItemHeight();
     if (height == 0)
         height ++;
     int numRows = viewport()->height() / height;
     return numRows;
 }
 void KrInterBriefView::updateView()
 {
 }
 
 void KrInterBriefView::setup()
 {
     _header = new QHeaderView(Qt::Horizontal, this);
     _header->setDefaultAlignment(Qt::AlignLeft | Qt::AlignVCenter);
     _header->setParent(this);
     _header->setModel(_model);
     _header->hideSection(KrViewProperties::Type);
     _header->hideSection(KrViewProperties::Permissions);
     _header->hideSection(KrViewProperties::KrPermissions);
     _header->hideSection(KrViewProperties::Owner);
     _header->hideSection(KrViewProperties::Group);
     _header->hideSection(KrViewProperties::Changed);
     _header->hideSection(KrViewProperties::Accessed);
     _header->setStretchLastSection(true);
     _header->setSectionResizeMode(QHeaderView::Fixed);
     _header->setSectionsClickable(true);
     _header->setSortIndicatorShown(true);
     connect(_header, &QHeaderView::sortIndicatorChanged, _model, QOverload<int, Qt::SortOrder>::of(&ListModel::sort));
     _header->installEventFilter(this);
 
     _numOfColumns = _properties->numberOfColumns;
 
     setSortMode(_properties->sortColumn, (_properties->sortOptions & KrViewProperties::Descending));
 }
 
 void KrInterBriefView::keyPressEvent(QKeyEvent *e)
 {
     if (!e || !_model->ready())
         return ; // subclass bug
 
     if (handleKeyEvent(e))
         return;
 
     QAbstractItemView::keyPressEvent(e);
 }
 
 bool KrInterBriefView::handleKeyEvent(QKeyEvent *e)
 {
     if ((e->key() != Qt::Key_Left && e->key() != Qt::Key_Right) && (KrView::handleKeyEvent(e)))
         // did the view class handled the event?
         return true;
 
     switch (e->key()) {
     case Qt::Key_Right : {
         if (e->modifiers() == Qt::ControlModifier) {
             // let the panel handle it
             e->ignore();
             break;
         }
         KrViewItem *i = getCurrentKrViewItem();
         KrViewItem *newCurrent = i;
 
         if (!i)
             break;
 
         int num = itemsPerPage() + 1;
 
         if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
 
         while (i && num > 0) {
             if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
             newCurrent = i;
             i = getNext(i);
             num--;
         }
 
         if (newCurrent) {
             setCurrentKrViewItem(newCurrent);
             makeCurrentVisible();
         }
         if (e->modifiers() & Qt::ShiftModifier)
             op()->emitSelectionChanged();
         return true;
     }
     case Qt::Key_Left : {
         if (e->modifiers() == Qt::ControlModifier) {
             // let the panel handle it
             e->ignore();
             break;
         }
         KrViewItem *i = getCurrentKrViewItem();
         KrViewItem *newCurrent = i;
 
         if (!i)
             break;
 
         int num = itemsPerPage() + 1;
 
         if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
 
         while (i && num > 0) {
             if (e->modifiers() & Qt::ShiftModifier) i->setSelected(!i->isSelected());
             newCurrent = i;
             i = getPrev(i);
             num--;
         }
 
         if (newCurrent) {
             setCurrentKrViewItem(newCurrent);
             makeCurrentVisible();
         }
         if (e->modifiers() & Qt::ShiftModifier)
             op()->emitSelectionChanged();
         return true;
     }
     }
 
     return false;
 }
 
 void KrInterBriefView::wheelEvent(QWheelEvent *ev)
 {
     if (!_mouseHandler->wheelEvent(ev))
         QApplication::sendEvent(horizontalScrollBar(), ev);
 }
 
 bool KrInterBriefView::eventFilter(QObject *object, QEvent *event)
 {
     if (object == _header) {
         if (event->type() == QEvent::ContextMenu) {
             auto *me = (QContextMenuEvent *)event;
             showContextMenu(me->globalPos());
             return true;
         }
     }
     return false;
 }
 
 void KrInterBriefView::showContextMenu(const QPoint & p)
 {
     QMenu popup(this);
     popup.setTitle(i18n("Columns"));
 
     int COL_ID = 14700;
 
     for (int i = 1; i <= MAX_BRIEF_COLS; i++) {
         QAction *act = popup.addAction(QString("%1").arg(i));
         act->setData(QVariant(COL_ID + i));
         act->setCheckable(true);
         act->setChecked(properties()->numberOfColumns == i);
     }
 
     QAction * res = popup.exec(p);
     int result = -1;
     if (res && res->data().canConvert<int>())
         result = res->data().toInt();
 
     if (result > COL_ID && result <= COL_ID + MAX_BRIEF_COLS) {
         _properties->numberOfColumns = result - COL_ID;
         _numOfColumns = _properties->numberOfColumns;
         updateGeometries();
         op()->settingsChanged(KrViewProperties::PropColumns);
     }
 }
 
 QRect KrInterBriefView::visualRect(const QModelIndex&ndx) const
 {
     int width = (viewport()->width()) / _numOfColumns;
     if ((viewport()->width()) % _numOfColumns)
         width++;
     int height = getItemHeight();
     int numRows = viewport()->height() / height;
     if (numRows == 0)
         numRows++;
     int x = width * (ndx.row() / numRows);
     int y = height * (ndx.row() % numRows);
     return mapToViewport(QRect(x, y, width, height));
 }
 
 void KrInterBriefView::scrollTo(const QModelIndex &ndx, QAbstractItemView::ScrollHint hint)
 {
     const QRect rect = visualRect(ndx);
     if (hint == EnsureVisible && viewport()->rect().contains(rect)) {
         setDirtyRegion(rect);
         return;
     }
 
     const QRect area = viewport()->rect();
 
     const bool leftOf = rect.left() < area.left();
     const bool rightOf = rect.right() > area.right();
 
     int horizontalValue = horizontalScrollBar()->value();
 
     if (leftOf)
         horizontalValue -= area.left() - rect.left();
     else if (rightOf)
         horizontalValue += rect.right() - area.right();
 
     horizontalScrollBar()->setValue(horizontalValue);
 }
 
 QModelIndex KrInterBriefView::indexAt(const QPoint& p) const
 {
     int x = p.x() + horizontalOffset();
     int y = p.y() + verticalOffset();
 
     int itemWidth = (viewport()->width()) / _numOfColumns;
     if ((viewport()->width()) % _numOfColumns)
         itemWidth++;
     int itemHeight = getItemHeight();
 
     int numRows = viewport()->height() / itemHeight;
     if (numRows == 0)
         numRows++;
 
     int row = y / itemHeight;
     int col = x / itemWidth;
 
     int numColsTotal = _model->rowCount() / numRows;
     if(_model->rowCount() % numRows)
         numColsTotal++;
 
     if(row < numRows && col < numColsTotal)
         return _model->index((col * numRows) + row, 0);
 
     return QModelIndex();
 }
 
 QModelIndex KrInterBriefView::moveCursor(QAbstractItemView::CursorAction cursorAction, Qt::KeyboardModifiers)
 {
     if (_model->rowCount() == 0)
         return QModelIndex();
 
     QModelIndex current = currentIndex();
     if (!current.isValid())
         return _model->index(0, 0);
 
     switch (cursorAction) {
     case MoveLeft:
     case MovePageDown: {
         int newRow = current.row() - itemsPerPage();
         if (newRow < 0)
             newRow = 0;
         return _model->index(newRow, 0);
     }
     case MoveRight:
     case MovePageUp: {
         int newRow = current.row() + itemsPerPage();
         if (newRow >= _model->rowCount())
             newRow = _model->rowCount() - 1;
         return _model->index(newRow, 0);
     }
     case MovePrevious:
     case MoveUp: {
         int newRow = current.row() - 1;
         if (newRow < 0)
             newRow = 0;
         return _model->index(newRow, 0);
     }
     case MoveNext:
     case MoveDown: {
         int newRow = current.row() + 1;
         if (newRow >= _model->rowCount())
             newRow = _model->rowCount() - 1;
         return _model->index(newRow, 0);
     }
     case MoveHome:
         return _model->index(0, 0);
     case MoveEnd:
         return _model->index(_model->rowCount() - 1, 0);
     }
 
     return current;
 }
 
 int KrInterBriefView::horizontalOffset() const
 {
     return horizontalScrollBar()->value();
 }
 
 int KrInterBriefView::verticalOffset() const
 {
     return 0;
 }
 
 bool KrInterBriefView::isIndexHidden(const QModelIndex&ndx) const
 {
     return ndx.column() != 0;
 }
 #if 0
 QRegion KrInterBriefView::visualRegionForSelection(const QItemSelection &selection) const
 {
     if (selection.isEmpty())
         return QRegion();
 
     QRegion selectionRegion;
     for (int i = 0; i < selection.count(); ++i) {
         QItemSelectionRange range = selection.at(i);
         if (!range.isValid())
             continue;
         QModelIndex leftIndex = range.topLeft();
         if (!leftIndex.isValid())
             continue;
         const QRect leftRect = visualRect(leftIndex);
         int top = leftRect.top();
         QModelIndex rightIndex = range.bottomRight();
         if (!rightIndex.isValid())
             continue;
         const QRect rightRect = visualRect(rightIndex);
         int bottom = rightRect.bottom();
         if (top > bottom)
             qSwap<int>(top, bottom);
         int height = bottom - top + 1;
         QRect combined = leftRect | rightRect;
         combined.setX(range.left());
         selectionRegion += combined;
     }
     return selectionRegion;
 }
 #endif
 void KrInterBriefView::paintEvent(QPaintEvent *e)
 {
     QStyleOptionViewItem option = viewOptions();
     option.widget = this;
     option.decorationSize = QSize(_fileIconSize, _fileIconSize);
     option.decorationPosition = QStyleOptionViewItem::Left;
     QPainter painter(viewport());
 
     QModelIndex curr = currentIndex();
 
     QVector<QModelIndex> intersectVector;
     QRect area = e->rect();
     area.adjust(horizontalOffset(), verticalOffset(), horizontalOffset(), verticalOffset());
     intersectionSet(area, intersectVector);
 
     foreach(const QModelIndex &mndx, intersectVector) {
         option.state = QStyle::State_None;
         option.rect = visualRect(mndx);
         painter.save();
 
         itemDelegate()->paint(&painter, option, mndx);
 
         // (always) draw dashed line border around current item row
         const bool isCurrent = curr.isValid() && curr.row() == mndx.row();
         if (isCurrent && drawCurrent()) {
             QStyleOptionFocusRect o;
             o.QStyleOption::operator=(option);
             QPalette::ColorGroup cg = QPalette::Normal;
             o.backgroundColor = option.palette.color(cg, QPalette::Background);
 
             style()->drawPrimitive(QStyle::PE_FrameFocusRect, &o, &painter);
         }
 
         painter.restore();
     }
 }
 
 int KrInterBriefView::getItemHeight() const
 {
     int textHeight = QFontMetrics(_viewFont).height();
     int height = textHeight;
     int iconSize = 0;
     if (properties()->displayIcons)
         iconSize = _fileIconSize;
     if (iconSize > textHeight)
         height = iconSize;
     if (height == 0)
         height++;
     return height;
 }
 
 void KrInterBriefView::updateGeometries()
 {
     if (_header) {
         QSize hint = _header->sizeHint();
         setViewportMargins(0, hint.height(), 0, 0);
         QRect vg = viewport()->geometry();
         QRect geometryRect(vg.left(), vg.top() - hint.height(), vg.width(), hint.height());
         _header->setGeometry(geometryRect);
 
         int items = 0;
         for (int i = 0;  i != _header->count(); i++)
             if (!_header->isSectionHidden(i))
                 items++;
         if (items == 0)
             items++;
 
         int sectWidth = viewport()->width() / items;
         for (int i = 0;  i != _header->count(); i++)
             if (!_header->isSectionHidden(i))
                 _header->resizeSection(i, sectWidth);
 
         QMetaObject::invokeMethod(_header, "updateGeometries");
     }
 
     if (_model->rowCount() <= 0)
         horizontalScrollBar()->setRange(0, 0);
     else {
         int itemsPerColumn = viewport()->height() / getItemHeight();
         if (itemsPerColumn <= 0)
             itemsPerColumn = 1;
         int columnWidth = (viewport()->width()) / _numOfColumns;
         if ((viewport()->width()) % _numOfColumns)
             columnWidth++;
         int maxWidth = _model->rowCount() / itemsPerColumn;
         if (_model->rowCount() % itemsPerColumn)
             maxWidth++;
         maxWidth *= columnWidth;
         if (maxWidth > viewport()->width()) {
             horizontalScrollBar()->setSingleStep(columnWidth);
             horizontalScrollBar()->setPageStep(columnWidth * _numOfColumns);
             horizontalScrollBar()->setRange(0, maxWidth - viewport()->width());
         } else {
             horizontalScrollBar()->setRange(0, 0);
         }
     }
 
     QAbstractItemView::updateGeometries();
 }
 
 void KrInterBriefView::setSortMode(KrViewProperties::ColumnType sortColumn, bool descending)
 {
     Qt::SortOrder sortDir = descending ? Qt::DescendingOrder : Qt::AscendingOrder;
     _header->setSortIndicator(sortColumn, sortDir);
 }
 
 int KrInterBriefView::elementWidth(const QModelIndex & index)
 {
     QString text = index.data(Qt::DisplayRole).toString();
 
-    int textWidth = QFontMetrics(_viewFont).width(text);
+    int textWidth = QFontMetrics(_viewFont).QFONTMETRICS_WIDTH(text);
 
     const int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
     textWidth += 2 * textMargin;
 
     QVariant decor = index.data(Qt::DecorationRole);
     if (decor.isValid() && decor.type() == QVariant::Pixmap) {
         QPixmap p = decor.value<QPixmap>();
         textWidth += p.width() + 2 * textMargin;
     }
 
     return textWidth;
 }
 
 void KrInterBriefView::intersectionSet(const QRect &rect, QVector<QModelIndex> &ndxList)
 {
     int maxNdx = _model->rowCount();
     int width = (viewport()->width()) / _numOfColumns;
     if ((viewport()->width()) % _numOfColumns)
         width++;
 
     int height = getItemHeight();
     int items = viewport()->height() / height;
     if (items == 0)
         items++;
 
     int xmin = -1;
     int ymin = -1;
     int xmax = -1;
     int ymax = -1;
 
     xmin = rect.x() / width;
     ymin = rect.y() / height;
     xmax = (rect.x() + rect.width()) / width;
     if ((rect.x() + rect.width()) % width)
         xmax++;
     ymax = (rect.y() + rect.height()) / height;
     if ((rect.y() + rect.height()) % height)
         ymax++;
 
     for (int i = ymin; i < ymax; i++)
         for (int j = xmin; j < xmax; j++) {
             int ndx = j * items + i;
             if (ndx < maxNdx)
                 ndxList.append(_model->index(ndx, 0));
         }
 }
 
 QRect KrInterBriefView::itemRect(const FileItem *item)
 {
     return visualRect(_model->fileItemIndex(item));
 }
 
 void KrInterBriefView::copySettingsFrom(KrView *other)
 {
     if(other->instance() == instance()) { // the other view is of the same type
         auto *v = dynamic_cast<KrInterBriefView*>(other);
         int column = v->_model->lastSortOrder();
         Qt::SortOrder sortDir = v->_model->lastSortDir();
         _header->setSortIndicator(column, sortDir);
         _model->sort(column, sortDir);
         setFileIconSize(v->fileIconSize());
     }
 }
 
 
 void KrInterBriefView::setFileIconSize(int size)
 {
     KrView::setFileIconSize(size);
     setIconSize(QSize(fileIconSize(), fileIconSize()));
     updateGeometries();
 }
 
 void KrInterBriefView::currentChanged(const QModelIndex & current, const QModelIndex & previous)
 {
     if (_model->ready()) {
         KrViewItem * item = getKrViewItem(currentIndex());
         op()->emitCurrentChanged(item);
     }
     QAbstractItemView::currentChanged(current, previous);
 }
 
 void KrInterBriefView::renameCurrentItem()
 {
     QModelIndex cIndex = currentIndex();
     QModelIndex nameIndex = _model->index(cIndex.row(), KrViewProperties::Name);
     edit(nameIndex);
     updateEditorData();
     update(nameIndex);
 }
 
 bool KrInterBriefView::event(QEvent * e)
 {
     _mouseHandler->otherEvent(e);
     return QAbstractItemView::event(e);
 }
 
 void KrInterBriefView::mousePressEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mousePressEvent(ev))
         QAbstractItemView::mousePressEvent(ev);
 }
 
 void KrInterBriefView::mouseReleaseEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mouseReleaseEvent(ev))
         QAbstractItemView::mouseReleaseEvent(ev);
 }
 
 void KrInterBriefView::mouseDoubleClickEvent(QMouseEvent *ev)
 {
     if (!_mouseHandler->mouseDoubleClickEvent(ev))
         QAbstractItemView::mouseDoubleClickEvent(ev);
 }
 
 void KrInterBriefView::mouseMoveEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mouseMoveEvent(ev))
         QAbstractItemView::mouseMoveEvent(ev);
 }
 
 void KrInterBriefView::dragEnterEvent(QDragEnterEvent *ev)
 {
     if (!_mouseHandler->dragEnterEvent(ev))
         QAbstractItemView::dragEnterEvent(ev);
 }
 
 void KrInterBriefView::dragMoveEvent(QDragMoveEvent *ev)
 {
     QAbstractItemView::dragMoveEvent(ev);
     _mouseHandler->dragMoveEvent(ev);
 }
 
 void KrInterBriefView::dragLeaveEvent(QDragLeaveEvent *ev)
 {
     if (!_mouseHandler->dragLeaveEvent(ev))
         QAbstractItemView::dragLeaveEvent(ev);
 }
 
 void KrInterBriefView::dropEvent(QDropEvent *ev)
 {
     if (!_mouseHandler->dropEvent(ev))
         QAbstractItemView::dropEvent(ev);
 }
 
 QRect KrInterBriefView::mapToViewport(const QRect &rect) const
 {
     if (!rect.isValid())
         return rect;
 
     QRect result = rect;
 
     int dx = -horizontalOffset();
     int dy = -verticalOffset();
     result.adjust(dx, dy, dx, dy);
     return result;
 }
diff --git a/krusader/Panel/PanelView/krinterdetailedview.cpp b/krusader/Panel/PanelView/krinterdetailedview.cpp
index d42045ef..2818741c 100644
--- a/krusader/Panel/PanelView/krinterdetailedview.cpp
+++ b/krusader/Panel/PanelView/krinterdetailedview.cpp
@@ -1,450 +1,450 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "krinterdetailedview.h"
 
 // QtCore
 #include <QDir>
 #include <QHashIterator>
 // QtWidgets
 #include <QApplication>
 #include <QDirModel>
 #include <QHeaderView>
 #include <QMenu>
 #include <QToolTip>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIOWidgets/KDirLister>
 
 #include "krviewfactory.h"
 #include "krviewitemdelegate.h"
 #include "krviewitem.h"
 #include "listmodel.h"
 #include "../FileSystem/krpermhandler.h"
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "krmousehandler.h"
 #include "../krcolorcache.h"
 #include "../GUI/krstyleproxy.h"
-
+#include "../compat.h"
 
 KrInterDetailedView::KrInterDetailedView(QWidget *parent, KrViewInstance &instance, KConfig *cfg):
         QTreeView(parent),
         KrInterView(instance, cfg, this),
         _autoResizeColumns(true)
 {
     connect(_mouseHandler, &KrMouseHandler::renameCurrentItem, this, &KrInterDetailedView::renameCurrentItem);
     setWidget(this);
 
     KConfigGroup grpSvr(_config, "Look&Feel");
     _viewFont = grpSvr.readEntry("Filelist Font", _FilelistFont);
 
     setModel(_model);
     setRootIsDecorated(false);
     setItemsExpandable(false);
     setAllColumnsShowFocus(true);
     setUniformRowHeights(true);
 
     setMouseTracking(true);
     setAcceptDrops(true);
     setDropIndicatorShown(true);
 
     setSelectionMode(QAbstractItemView::NoSelection);
     setSelectionModel(new DummySelectionModel(_model, this));
 
     header()->installEventFilter(this);
     header()->setSectionResizeMode(QHeaderView::Interactive);
     header()->setStretchLastSection(false);
 
     auto *style = new KrStyleProxy();
     style->setParent(this);
     setStyle(style);
     viewport()->setStyle(style); // for custom tooltip delay
 
     setItemDelegate(new KrViewItemDelegate(this));
 
     connect(header(), &QHeaderView::sectionResized, this, &KrInterDetailedView::sectionResized);
     connect(header(), &QHeaderView::sectionMoved, this, &KrInterDetailedView::sectionMoved);
 }
 
 KrInterDetailedView::~KrInterDetailedView()
 {
     delete _properties;
     _properties = nullptr;
     delete _operator;
     _operator = nullptr;
 }
 
 void KrInterDetailedView::currentChanged(const QModelIndex & current, const QModelIndex & previous)
 {
     if (_model->ready()) {
         KrViewItem * item = getKrViewItem(currentIndex());
         op()->emitCurrentChanged(item);
     }
     QTreeView::currentChanged(current, previous);
 }
 
 void KrInterDetailedView::doRestoreSettings(KConfigGroup grp)
 {
     auto headerView = header();
 
     _autoResizeColumns = grp.readEntry("AutoResizeColumns", true);
 
     QByteArray savedState = grp.readEntry("Saved State", QByteArray());
     if (savedState.isEmpty()) {
         hideColumn(KrViewProperties::Type);
         hideColumn(KrViewProperties::Permissions);
         hideColumn(KrViewProperties::Owner);
         hideColumn(KrViewProperties::Group);
         hideColumn(KrViewProperties::Changed);
         hideColumn(KrViewProperties::Accessed);
-        headerView->resizeSection(KrViewProperties::Ext, QFontMetrics(_viewFont).width("tar.bz2  "));
-        headerView->resizeSection(KrViewProperties::KrPermissions, QFontMetrics(_viewFont).width("rwx  "));
-        headerView->resizeSection(KrViewProperties::Size, QFontMetrics(_viewFont).width("9") * 10);
+        headerView->resizeSection(KrViewProperties::Ext, QFontMetrics(_viewFont).QFONTMETRICS_WIDTH("tar.bz2  "));
+        headerView->resizeSection(KrViewProperties::KrPermissions, QFontMetrics(_viewFont).QFONTMETRICS_WIDTH("rwx  "));
+        headerView->resizeSection(KrViewProperties::Size, QFontMetrics(_viewFont).QFONTMETRICS_WIDTH("9") * 10);
 
         QDateTime tmp(QDate(2099, 12, 29), QTime(23, 59));
         QString desc = QLocale().toString(tmp, QLocale::ShortFormat) + "  ";
 
-        headerView->resizeSection(KrViewProperties::Modified, QFontMetrics(_viewFont).width(desc));
+        headerView->resizeSection(KrViewProperties::Modified, QFontMetrics(_viewFont).QFONTMETRICS_WIDTH(desc));
     } else {
         headerView->restoreState(savedState);
 
         // do not show new columns by default; restoreState() shows columns not saved
         if (KrGlobal::sCurrentConfigVersion < KrGlobal::sConfigVersion) {
             hideColumn(KrViewProperties::Changed);
             hideColumn(KrViewProperties::Accessed);
         }
 
         _model->setExtensionEnabled(!isColumnHidden(KrViewProperties::Ext));
     }
 
     // In case a column is assigned zero size for some reason, it's impossible to fix this from interface.
     // We correct this problem by enforcing the minimum width of the column.
     auto minSize = headerView->minimumSectionSize();
     for (int i = KrViewProperties::Ext; i < KrViewProperties::MAX_COLUMNS; i++) {
         if (!headerView->isSectionHidden(i) && headerView->sectionSize(i) < minSize) {
             headerView->resizeSection(i, minSize);
         }
     }
 
     KrInterView::doRestoreSettings(grp);
 }
 
 void KrInterDetailedView::saveSettings(KConfigGroup grp, KrViewProperties::PropertyType properties)
 {
     KrInterView::saveSettings(grp, properties);
 
     grp.writeEntry("AutoResizeColumns", _autoResizeColumns);
 
     if(properties & KrViewProperties::PropColumns) {
         QByteArray state = header()->saveState();
         grp.writeEntry("Saved State", state);
     }
 }
 
 int KrInterDetailedView::itemsPerPage()
 {
     QRect rect = visualRect(currentIndex());
     if (!rect.isValid()) {
         for (int i = 0; i != _model->rowCount(); i++) {
             rect = visualRect(_model->index(i, 0));
             if (rect.isValid())
                 break;
         }
     }
     if (!rect.isValid())
         return 0;
     int size = (height() - header()->height()) / rect.height();
     if (size < 0)
         size = 0;
     return size;
 }
 
 void KrInterDetailedView::updateView()
 {
 }
 
 void KrInterDetailedView::setup()
 {
     setSortMode(_properties->sortColumn, (_properties->sortOptions & KrViewProperties::Descending));
     setSortingEnabled(true);
 }
 
 void KrInterDetailedView::keyPressEvent(QKeyEvent *e)
 {
     if (!e || !_model->ready())
         return ; // subclass bug
     if (handleKeyEvent(e))    // did the view class handled the event?
         return;
     QTreeView::keyPressEvent(e);
 }
 
 void KrInterDetailedView::mousePressEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mousePressEvent(ev))
         QTreeView::mousePressEvent(ev);
 }
 
 void KrInterDetailedView::mouseReleaseEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mouseReleaseEvent(ev))
         QTreeView::mouseReleaseEvent(ev);
 }
 
 void KrInterDetailedView::mouseDoubleClickEvent(QMouseEvent *ev)
 {
     if (!_mouseHandler->mouseDoubleClickEvent(ev))
         QTreeView::mouseDoubleClickEvent(ev);
 }
 
 void KrInterDetailedView::mouseMoveEvent(QMouseEvent * ev)
 {
     if (!_mouseHandler->mouseMoveEvent(ev))
         QTreeView::mouseMoveEvent(ev);
 }
 
 void KrInterDetailedView::wheelEvent(QWheelEvent *ev)
 {
     if (!_mouseHandler->wheelEvent(ev))
         QTreeView::wheelEvent(ev);
 }
 
 void KrInterDetailedView::dragEnterEvent(QDragEnterEvent *ev)
 {
     if (!_mouseHandler->dragEnterEvent(ev))
         QTreeView::dragEnterEvent(ev);
 }
 
 void KrInterDetailedView::dragMoveEvent(QDragMoveEvent *ev)
 {
     QTreeView::dragMoveEvent(ev);
     _mouseHandler->dragMoveEvent(ev);
 }
 
 void KrInterDetailedView::dragLeaveEvent(QDragLeaveEvent *ev)
 {
     if (!_mouseHandler->dragLeaveEvent(ev))
         QTreeView::dragLeaveEvent(ev);
 }
 
 void KrInterDetailedView::dropEvent(QDropEvent *ev)
 {
     if (!_mouseHandler->dropEvent(ev))
         QTreeView::dropEvent(ev);
 }
 
 bool KrInterDetailedView::event(QEvent * e)
 {
     _mouseHandler->otherEvent(e);
     return QTreeView::event(e);
 }
 
 void KrInterDetailedView::renameCurrentItem()
 {
     QModelIndex cIndex = currentIndex();
     QModelIndex nameIndex = _model->index(cIndex.row(), KrViewProperties::Name);
     edit(nameIndex);
     updateEditorData();
     update(nameIndex);
 }
 
 bool KrInterDetailedView::eventFilter(QObject *object, QEvent *event)
 {
     if (object == header()) {
         if (event->type() == QEvent::ContextMenu) {
             auto *me = (QContextMenuEvent *)event;
             showContextMenu(me->globalPos());
             return true;
         } else if (event->type() == QEvent::Resize) {
             recalculateColumnSizes();
             return false;
         }
     }
     return false;
 }
 
 void KrInterDetailedView::showContextMenu(const QPoint & p)
 {
     QMenu popup(this);
     popup.setTitle(i18n("Columns"));
 
     QVector<QAction*> actions;
 
     for(int i = KrViewProperties::Ext; i < KrViewProperties::MAX_COLUMNS; i++) {
         QString text = (_model->headerData(i, Qt::Horizontal)).toString();
         QAction *act = popup.addAction(text);
         act->setCheckable(true);
         act->setChecked(!header()->isSectionHidden(i));
         act->setData(i);
         actions.append(act);
     }
 
     popup.addSeparator();
     QAction *actAutoResize = popup.addAction(i18n("Automatically Resize Columns"));
     actAutoResize->setCheckable(true);
     actAutoResize->setChecked(_autoResizeColumns);
 
     QAction *res = popup.exec(p);
     if (res == nullptr)
         return;
 
     if(res == actAutoResize) {
         _autoResizeColumns = actAutoResize->isChecked();
         recalculateColumnSizes();
     } else {
         int column = res->data().toInt();
 
         if(header()->isSectionHidden(column))
             header()->showSection(column);
         else
             header()->hideSection(column);
 
         if(KrViewProperties::Ext == column)
             _model->setExtensionEnabled(!header()->isSectionHidden(KrViewProperties::Ext));
     }
     op()->settingsChanged(KrViewProperties::PropColumns);
 }
 
 void KrInterDetailedView::sectionResized(int /*column*/, int oldSize, int newSize)
 {
     // *** taken from dolphin ***
     // If the user changes the size of the headers, the autoresize feature should be
     // turned off. As there is no dedicated interface to find out whether the header
     // section has been resized by the user or by a resize event, another approach is used.
     // Attention: Take care when changing the if-condition to verify that there is no
     // regression in combination with bug 178630 (see fix in comment #8).
     if ((QApplication::mouseButtons() & Qt::LeftButton) && header()->underMouse()) {
         _autoResizeColumns = false;
         op()->settingsChanged(KrViewProperties::PropColumns);
     }
 
     if (oldSize == newSize || !_model->ready())
         return;
 
     recalculateColumnSizes();
 }
 
 void KrInterDetailedView::sectionMoved(int /*logicalIndex*/, int /*oldVisualIndex*/, int /*newVisualIndex*/)
 {
     op()->settingsChanged(KrViewProperties::PropColumns);
 }
 
 void KrInterDetailedView::recalculateColumnSizes()
 {
     if(!_autoResizeColumns)
         return;
     int sum = 0;
     for (int i = 0; i != _model->columnCount(); i++) {
         if (!isColumnHidden(i))
             sum += header()->sectionSize(i);
     }
 
     if (sum != header()->width()) {
         int delta = sum - header()->width();
         int nameSize = header()->sectionSize(KrViewProperties::Name);
         if (nameSize - delta > 20)
             header()->resizeSection(KrViewProperties::Name, nameSize - delta);
     }
 }
 
 bool KrInterDetailedView::viewportEvent(QEvent * event)
 {
     if (event->type() == QEvent::ToolTip) {
         // only show tooltip if column is not wide enough to show all text. In this case the column
         // data text is abbreviated and the full text is shown as tooltip, see ListModel::data().
 
         auto *he = dynamic_cast<QHelpEvent*>(event);
         const QModelIndex index = indexAt(he->pos());
         // name column has a detailed tooltip
         if (index.isValid() && index.column() != KrViewProperties::Name) {
             int width = header()->sectionSize(index.column());
             QString text = index.data(Qt::DisplayRole).toString();
 
-            int textWidth = QFontMetrics(_viewFont).width(text);
+            int textWidth = QFontMetrics(_viewFont).QFONTMETRICS_WIDTH(text);
 
             const int textMargin = QApplication::style()->pixelMetric(QStyle::PM_FocusFrameHMargin) + 1;
             textWidth += 2 * textMargin;
 
             QVariant decor = index.data(Qt::DecorationRole);
             if (decor.isValid() && decor.type() == QVariant::Pixmap) {
                 QPixmap p = decor.value<QPixmap>();
                 textWidth += p.width() + 2 * textMargin;
             }
 
             if (textWidth <= width) {
                 QToolTip::hideText();
                 event->accept();
                 return true;
             }
         }
     }
     return QTreeView::viewportEvent(event);
 }
 
 void KrInterDetailedView::drawRow(QPainter *painter, const QStyleOptionViewItem &options,
                                   const QModelIndex &index) const
 {
     QTreeView::drawRow(painter, options, index);
     // (may) draw dashed line border around current item row. This is done internally in
     // QTreeView::drawRow() only when panel is focused, we have to repeat it here.
     if (index == currentIndex() && drawCurrent()) {
         QStyleOptionFocusRect o;
         o.backgroundColor = options.palette.color(QPalette::Normal, QPalette::Background);
 
         const QRect focusRect(0, options.rect.y(), header()->length(), options.rect.height());
         o.rect = style()->visualRect(layoutDirection(), viewport()->rect(), focusRect);
 
         style()->drawPrimitive(QStyle::PE_FrameFocusRect, &o, painter);
     }
 }
 
 void KrInterDetailedView::setSortMode(KrViewProperties::ColumnType sortColumn, bool descending)
 {
     Qt::SortOrder sortDir = descending ? Qt::DescendingOrder : Qt::AscendingOrder;
     sortByColumn(sortColumn, sortDir);
 }
 
 void KrInterDetailedView::setFileIconSize(int size)
 {
     KrView::setFileIconSize(size);
     setIconSize(QSize(fileIconSize(), fileIconSize()));
 }
 
 QRect KrInterDetailedView::itemRect(const FileItem *item)
 {
     QRect r = visualRect(_model->fileItemIndex(item));
     r.setLeft(0);
     r.setWidth(header()->length());
     return r;
 }
 
 void KrInterDetailedView::copySettingsFrom(KrView *other)
 {
     if(other->instance() == instance()) { // the other view is of the same type
         auto *v = dynamic_cast<KrInterDetailedView*>(other);
         _autoResizeColumns = v->_autoResizeColumns;
         header()->restoreState(v->header()->saveState());
         _model->setExtensionEnabled(!isColumnHidden(KrViewProperties::Ext));
         recalculateColumnSizes();
         setFileIconSize(v->fileIconSize());
     }
 }
diff --git a/krusader/Panel/krfiletreeview.cpp b/krusader/Panel/krfiletreeview.cpp
index 9d505d3f..8791066b 100644
--- a/krusader/Panel/krfiletreeview.cpp
+++ b/krusader/Panel/krfiletreeview.cpp
@@ -1,400 +1,401 @@
 /*****************************************************************************
  * Copyright (C) 2010 Jan Lepper <dehtris@yahoo.de>                          *
  * Copyright (C) 2010-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 #include "krfiletreeview.h"
 
 #include "panelfunc.h"
 
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "../FileSystem/filesystemprovider.h"
+#include "../compat.h"
 
 #include <QAction>
 #include <QApplication>
 #include <QCursor>
 #include <QDir>
 #include <QDropEvent>
 #include <QHeaderView>
 #include <QMenu>
 #include <QMimeData>
 #include <QProxyStyle>
 
 #include <KFileItemListProperties>
 #include <KJobWidgets>
 #include <KUrlMimeData>
 
 #include <KI18n/KLocalizedString>
 #include <KIO/DropJob>
 #include <KIO/Paste>
 #include <KIO/PasteJob>
 #include <KIOCore/KFileItem>
 #include <KIOWidgets/KDirLister>
 #include <KIOWidgets/KFileItemDelegate>
 #include <KIOWidgets/KPropertiesDialog>
 
 
 class KrDirModel : public KDirModel
 {
 public:
     KrDirModel(QWidget *parent, KrFileTreeView *ftv) : KDirModel(parent), fileTreeView(ftv) {}
 
 protected:
     Qt::ItemFlags flags(const QModelIndex &index) const Q_DECL_OVERRIDE
     {
         Qt::ItemFlags itflags = KDirModel::flags(index);
         if (index.column() != KDirModel::Name)
             itflags &= ~Qt::ItemIsDropEnabled;
         return itflags;
     }
 
 private:
     KrFileTreeView *fileTreeView;
 };
 
 class TreeStyle : public QProxyStyle
 {
 public:
     explicit TreeStyle(QStyle *style) : QProxyStyle(style) {}
 
     int styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget,
                   QStyleHintReturn *returnData) const Q_DECL_OVERRIDE
     {
         if (hint == QStyle::SH_ItemView_ActivateItemOnSingleClick) {
             return true;
         }
 
         return QProxyStyle::styleHint(hint, option, widget, returnData);
     }
 };
 
 KrFileTreeView::KrFileTreeView(QWidget *parent)
     : QTreeView(parent), mStartTreeFromCurrent(false), mStartTreeFromPlace(true)
 {
     mSourceModel = new KrDirModel(this, this);
     mSourceModel->dirLister()->setDirOnlyMode(true);
 
     mProxyModel = new KDirSortFilterProxyModel(this);
     mProxyModel->setSourceModel(mSourceModel);
     setModel(mProxyModel);
 
     mFilePlacesModel = new KFilePlacesModel(this);
 
     setItemDelegate(new KFileItemDelegate(this));
     setUniformRowHeights(true);
 
     // drag&drop
     setAcceptDrops(true);
     setDragEnabled(true);
     setDropIndicatorShown(true);
     mSourceModel->setDropsAllowed(KDirModel::DropOnDirectory);
 
     setStyle(new TreeStyle(style()));
     connect(this, &KrFileTreeView::activated, this, &KrFileTreeView::slotActivated);
 
     connect(mSourceModel, &KDirModel::expand, this, &KrFileTreeView::slotExpanded);
 
     QFontMetrics fontMetrics(viewport()->font());
-    header()->resizeSection(KDirModel::Name, fontMetrics.width("WWWWWWWWWWWWWWW"));
+    header()->resizeSection(KDirModel::Name, fontMetrics.QFONTMETRICS_WIDTH("WWWWWWWWWWWWWWW"));
 
     header()->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(header(), &QHeaderView::customContextMenuRequested, this,
             &KrFileTreeView::showHeaderContextMenu);
 
     setBriefMode(true);
 
     setContextMenuPolicy(Qt::CustomContextMenu);
     connect(this, &KrFileTreeView::customContextMenuRequested, this,
             &KrFileTreeView::slotCustomContextMenuRequested);
 
     setTree(mStartTreeFromCurrent, mStartTreeFromPlace);
 }
 
 void KrFileTreeView::setCurrentUrl(const QUrl &url)
 {
     mCurrentUrl = url;
     if (mStartTreeFromCurrent) {
         setTreeRoot(url);
     } else {
         if (mStartTreeFromPlace) {
             const QModelIndex index = mFilePlacesModel->closestItem(url); // magic here
             const QUrl rootBase = index.isValid() ? mFilePlacesModel->url(index) :
                                                     QUrl::fromLocalFile(QDir::root().path());
             setTreeRoot(rootBase);
         }
         if (isVisible(url)) {
             // avoid unwanted scrolling by KDirModel::expandToUrl()
             setCurrentIndex(mProxyModel->mapFromSource(mSourceModel->indexForUrl(url)));
         } else {
             mSourceModel->expandToUrl(url);
         }
     }
 }
 
 QUrl KrFileTreeView::urlForProxyIndex(const QModelIndex &index) const
 {
     const KFileItem item = mSourceModel->itemForIndex(mProxyModel->mapToSource(index));
 
     return !item.isNull() ? item.url() : QUrl();
 }
 
 void KrFileTreeView::slotActivated(const QModelIndex &index)
 {
     const QUrl url = urlForProxyIndex(index);
     if (url.isValid()) {
         emit urlActivated(url);
     }
 }
 
 void KrFileTreeView::dropEvent(QDropEvent *event)
 {
     QUrl destination = urlForProxyIndex(indexAt(event->pos()));
     if (destination.isEmpty()) {
         return;
     }
 
     FileSystemProvider::instance().startDropFiles(event, destination);
 }
 
 void KrFileTreeView::slotExpanded(const QModelIndex &baseIndex)
 {
     const QModelIndex index = mProxyModel->mapFromSource(baseIndex);
 
     expand(index); // expand view now after model was expanded
     selectionModel()->clearSelection();
     selectionModel()->setCurrentIndex(index, QItemSelectionModel::SelectCurrent);
 
     scrollTo(index);
 }
 
 void KrFileTreeView::showHeaderContextMenu()
 {
     QMenu popup(this);
     popup.setToolTipsVisible(true);
 
     QAction *detailAction = popup.addAction(i18n("Show Details"));
     detailAction->setCheckable(true);
     detailAction->setChecked(!briefMode());
     detailAction->setToolTip(i18n("Show columns with details"));
     QAction *showHiddenAction = popup.addAction(i18n("Show Hidden Folders"));
     showHiddenAction->setCheckable(true);
     showHiddenAction->setChecked(mSourceModel->dirLister()->showingDotFiles());
     showHiddenAction->setToolTip(i18n("Show folders starting with a dot"));
 
     popup.addSeparator();
     auto *rootActionGroup = new QActionGroup(this);
 
     QAction *startFromRootAction = popup.addAction(i18n("Start From Root"));
     startFromRootAction->setCheckable(true);
     startFromRootAction->setChecked(!mStartTreeFromCurrent && !mStartTreeFromPlace);
     startFromRootAction->setToolTip(i18n("Set root of the tree to root of filesystem"));
     startFromRootAction->setActionGroup(rootActionGroup);
 
     QAction *startFromCurrentAction = popup.addAction(i18n("Start From Current"));
     startFromCurrentAction->setCheckable(true);
     startFromCurrentAction->setChecked(mStartTreeFromCurrent);
     startFromCurrentAction->setToolTip(i18n("Set root of the tree to the current folder"));
     startFromCurrentAction->setActionGroup(rootActionGroup);
 
     QAction *startFromPlaceAction = popup.addAction(i18n("Start From Place"));
     startFromPlaceAction->setCheckable(true);
     startFromPlaceAction->setChecked(mStartTreeFromPlace);
     startFromPlaceAction->setToolTip(
         i18n("Set root of the tree to closest folder listed in 'Places'"));
     startFromPlaceAction->setActionGroup(rootActionGroup);
 
     QAction *triggeredAction = popup.exec(QCursor::pos());
     if (triggeredAction == detailAction) {
         setBriefMode(!detailAction->isChecked());
     } else if (triggeredAction == showHiddenAction) {
         KDirLister *dirLister = mSourceModel->dirLister();
         dirLister->setShowingDotFiles(showHiddenAction->isChecked());
         dirLister->emitChanges();
     } else if (triggeredAction && triggeredAction->actionGroup() == rootActionGroup) {
         setTree(startFromCurrentAction->isChecked(), startFromPlaceAction->isChecked());
     }
 }
 
 void KrFileTreeView::slotCustomContextMenuRequested(const QPoint &point)
 {
     const QModelIndex index = indexAt(point);
     if (!index.isValid())
         return;
 
     const KFileItem fileItem = mSourceModel->itemForIndex(mProxyModel->mapToSource(index));
     const KFileItemListProperties capabilities(KFileItemList() << fileItem);
 
     auto* popup = new QMenu(this);
 
     // TODO nice to have: "open with"
 
     // cut/copy/paste
     QAction* cutAction = new QAction(Icon(QStringLiteral("edit-cut")), i18nc("@action:inmenu", "Cut"), this);
     cutAction->setEnabled(capabilities.supportsMoving());
     connect(cutAction, &QAction::triggered, this, [=]() { copyToClipBoard(fileItem, true); });
     popup->addAction(cutAction);
 
     QAction* copyAction = new QAction(Icon(QStringLiteral("edit-copy")), i18nc("@action:inmenu", "Copy"), this);
     connect(copyAction, &QAction::triggered, this, [=]() { copyToClipBoard(fileItem, false); });
     popup->addAction(copyAction);
 
     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
     bool canPaste;
     const QString text = KIO::pasteActionText(mimeData, &canPaste, fileItem);
     QAction* pasteAction = new QAction(Icon(QStringLiteral("edit-paste")), text, this);
     connect(pasteAction, &QAction::triggered, this, [=]() {
         KIO::PasteJob *job = KIO::paste(QApplication::clipboard()->mimeData(), fileItem.url());
         KJobWidgets::setWindow(job, this);
     });
     pasteAction->setEnabled(canPaste);
     popup->addAction(pasteAction);
 
     popup->addSeparator();
 
     // TODO nice to have: rename
 
     // trash
     if (KConfigGroup(krConfig, "General").readEntry("Move To Trash", _MoveToTrash)) {
         QAction* moveToTrashAction = new QAction(Icon(QStringLiteral("user-trash")),
                                                 i18nc("@action:inmenu", "Move to Trash"), this);
         const bool enableMoveToTrash = capabilities.isLocal() && capabilities.supportsMoving();
         moveToTrashAction->setEnabled(enableMoveToTrash);
         connect(moveToTrashAction, &QAction::triggered, this, [=]() {
             deleteFile(fileItem, true);
         });
         popup->addAction(moveToTrashAction);
     }
 
     // delete
     QAction *deleteAction = new QAction(Icon(QStringLiteral("edit-delete")),
                                         i18nc("@action:inmenu", "Delete"), this);
     deleteAction->setEnabled(capabilities.supportsDeleting());
     connect(deleteAction, &QAction::triggered, this, [=]() {
         deleteFile(fileItem, false);
     });
     popup->addAction(deleteAction);
 
     popup->addSeparator();
 
     // properties
     if (!fileItem.isNull()) {
         QAction* propertiesAction = new QAction(i18nc("@action:inmenu", "Properties"), this);
         propertiesAction->setIcon(Icon(QStringLiteral("document-properties")));
         connect(propertiesAction, &QAction::triggered, this, [=]() {
             KPropertiesDialog* dialog = new KPropertiesDialog(fileItem.url(), this);
             dialog->setAttribute(Qt::WA_DeleteOnClose);
             dialog->show();
         });
         popup->addAction(propertiesAction);
     }
 
     QPointer<QMenu> popupPtr = popup;
     popup->exec(QCursor::pos());
     if (popupPtr.data()) {
         popupPtr.data()->deleteLater();
     }
 }
 
 void KrFileTreeView::copyToClipBoard(const KFileItem &fileItem, bool cut) const
 {
     auto* mimeData = new QMimeData();
 
     QList<QUrl> kdeUrls;
     kdeUrls.append(fileItem.url());
     QList<QUrl> mostLocalUrls;
     bool dummy;
     mostLocalUrls.append(fileItem.mostLocalUrl(dummy));
 
     KIO::setClipboardDataCut(mimeData, cut);
     KUrlMimeData::setUrls(kdeUrls, mostLocalUrls, mimeData);
 
     QApplication::clipboard()->setMimeData(mimeData);
 }
 
 void KrFileTreeView::deleteFile(const KFileItem &fileItem, bool moveToTrash) const
 {
     const QList<QUrl> confirmedFiles =
         ListPanelFunc::confirmDeletion(QList<QUrl>() << fileItem.url(), moveToTrash, false, true);
     if (confirmedFiles.isEmpty())
         return;
 
     FileSystemProvider::instance().startDeleteFiles(confirmedFiles, moveToTrash);
 }
 
 bool KrFileTreeView::briefMode() const
 {
     return isColumnHidden(mProxyModel->columnCount() - 1); // find out by last column
 }
 
 void KrFileTreeView::setBriefMode(bool brief)
 {
     for (int i=1; i < mProxyModel->columnCount(); i++) { // show only first column
         setColumnHidden(i, brief);
     }
 }
 
 void KrFileTreeView::setTree(bool startFromCurrent, bool startFromPlace)
 {
     mStartTreeFromCurrent = startFromCurrent;
     mStartTreeFromPlace = startFromPlace;
 
     if (!mStartTreeFromCurrent && !mStartTreeFromPlace) {
         setTreeRoot(QUrl::fromLocalFile(QDir::root().path()));
     }
     setCurrentUrl(mCurrentUrl); // refresh
 }
 
 void KrFileTreeView::setTreeRoot(const QUrl &rootBase)
 {
     if (rootBase == mCurrentTreeBase) // avoid collapsing the subdirs in tree
         return;
 
     mCurrentTreeBase = rootBase;
     mSourceModel->dirLister()->openUrl(mCurrentTreeBase);
 }
 
 void KrFileTreeView::saveSettings(KConfigGroup cfg) const
 {
     KConfigGroup group = KConfigGroup(&cfg, "TreeView");
     group.writeEntry("BriefMode", briefMode());
     group.writeEntry("ShowHiddenFolders", mSourceModel->dirLister()->showingDotFiles());
     group.writeEntry("StartFromCurrent", mStartTreeFromCurrent);
     group.writeEntry("StartFromPlace", mStartTreeFromPlace);
 }
 
 void KrFileTreeView::restoreSettings(const KConfigGroup &cfg)
 {
     const KConfigGroup group = KConfigGroup(&cfg, "TreeView");
     setBriefMode(group.readEntry("BriefMode", true));
     mSourceModel->dirLister()->setShowingDotFiles(group.readEntry("ShowHiddenFolders", false));
     setTree(group.readEntry("StartFromCurrent", false),
                 group.readEntry("StartFromPlace", false));
 }
 
 bool KrFileTreeView::isVisible(const QUrl &url)
 {
     QModelIndex index = indexAt(rect().topLeft());
     while (index.isValid()) {
         if (url == urlForProxyIndex(index)) {
             return true;
         }
         index = indexBelow(index);
     }
     return false;
 }
diff --git a/krusader/compat.h b/krusader/compat.h
index 524da8c9..0a64b5a0 100644
--- a/krusader/compat.h
+++ b/krusader/compat.h
@@ -1,31 +1,45 @@
 /*****************************************************************************
  * Copyright (C) 2019 Krusader Krew [https://krusader.org]                   *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #ifndef _COMPAT_H_
 #define _COMPAT_H_
 
 #include <kio_version.h>
 
 #if KIO_VERSION >= QT_VERSION_CHECK(5, 48, 0)
     #define UDS_ENTRY_INSERT(A, B) UDSEntry::fastInsert((A), (B));
 #else
     #define UDS_ENTRY_INSERT(A, B) UDSEntry::insert((A), (B));
 #endif
 
+/**
+ * QFontMetrics::width(const QString&, int) was made obsoleted in QT 5.11 in
+ * favor of QFontMetrics::horizontalAdvance(const QString &, int)
+ *
+ * https://doc.qt.io/archives/qt-5.11/qfontmetrics-obsolete.html#width
+ *
+ * This can be removed when the qt minimum version required will be >= 5.11
+ */
+#if QT_VERSION >= QT_VERSION_CHECK(5, 11, 0)
+    #define QFONTMETRICS_WIDTH(A) horizontalAdvance(A)
+#else
+    #define QFONTMETRICS_WIDTH(A) width(A)
+#endif
+
 #endif
diff --git a/krusader/paneltabbar.cpp b/krusader/paneltabbar.cpp
index b778f66d..95f69212 100644
--- a/krusader/paneltabbar.cpp
+++ b/krusader/paneltabbar.cpp
@@ -1,341 +1,342 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2019 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * Based on original code from Sebastian Trueg <trueg@kde.org>               *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader is free software: you can redistribute it and/or modify          *
  * it under the terms of the GNU General Public License as published by      *
  * the Free Software Foundation, either version 2 of the License, or         *
  * (at your option) any later version.                                       *
  *                                                                           *
  * Krusader is distributed in the hope that it will be useful,               *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *
  * GNU General Public License for more details.                              *
  *                                                                           *
  * You should have received a copy of the GNU General Public License         *
  * along with Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "paneltabbar.h"
 
 #include "defaults.h"
 #include "tabactions.h"
 #include "../krglobal.h"
 #include "../icon.h"
 #include "Panel/listpanel.h"
 #include "Panel/panelfunc.h"
+#include "compat.h"
 
 // QtCore
 #include <QEvent>
 // QtGui
 #include <QFontMetrics>
 #include <QResizeEvent>
 #include <QMouseEvent>
 // QtWidgets
 #include <QAction>
 #include <QMenu>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KActionMenu>
 
 
 static const int sDragEnterDelay = 500; // msec
 
 PanelTabBar::PanelTabBar(QWidget *parent, TabActions *actions): QTabBar(parent),
     _maxTabLength(0), _tabClicked(false), _draggingTab(false), _dragTabIndex(-1)
 {
     _panelActionMenu = new KActionMenu(i18n("Panel"), this);
 
     setAcceptDrops(true);
 
     insertAction(actions->actNewTab);
     insertAction(actions->actLockTab);
     insertAction(actions->actPinTab);
     insertAction(actions->actDupTab);
     insertAction(actions->actMoveTabToOtherSide);
     insertAction(actions->actMoveTabToLeft);
     insertAction(actions->actMoveTabToRight);
     insertAction(actions->actCloseTab);
     insertAction(actions->actCloseInactiveTabs);
     insertAction(actions->actCloseDuplicatedTabs);
 
     setMovable(true); // enable drag'n'drop
     _dragTimer = new QTimer(this);
     _dragTimer->setSingleShot(true);
     _dragTimer->setInterval(sDragEnterDelay);
     connect(_dragTimer, &QTimer::timeout, this, [=]() {
         if (_dragTabIndex != -1 && _dragTabIndex != currentIndex()) {
             setCurrentIndex(_dragTabIndex);
         }
         _dragTabIndex = -1;
     });
 
     setShape(QTabBar::TriangularSouth);
 }
 
 void PanelTabBar::insertAction(QAction* action)
 {
     _panelActionMenu->addAction(action);
 }
 
 int PanelTabBar::addPanel(ListPanel *panel, bool setCurrent, KrPanel *nextTo)
 {
     int insertIndex = -1;
 
     if (nextTo) {
         for (int i = 0; i < count(); i++) {
             if (getPanel(i) == nextTo) {
                 insertIndex = i + 1;
                 break;
             }
         }
     }
 
     QUrl virtualPath = panel->virtualPath();
     panel->setPinnedUrl(virtualPath);
     const QString text = squeeze(virtualPath);
     const int index = insertIndex != -1 ? insertTab(insertIndex, text) : addTab(text);
 
     setTabData(index, QVariant((long long) panel));
 
     setIcon(index, panel);
 
     // make sure all tabs lengths are correct
     layoutTabs();
 
     if (setCurrent)
         setCurrentIndex(index);
 
     return index;
 }
 
 ListPanel* PanelTabBar::getPanel(int tabIdx)
 {
     QVariant v = tabData(tabIdx);
     if (v.isNull()) return nullptr;
     return (ListPanel*)v.toLongLong();
 }
 
 void PanelTabBar::changePanel(int tabIdx, ListPanel *panel)
 {
     setTabData(tabIdx, QVariant((long long) panel));
 }
 
 ListPanel* PanelTabBar::removePanel(int index, ListPanel* &panelToDelete)
 {
     panelToDelete = getPanel(index); // old panel to kill later
     disconnect(panelToDelete, nullptr, this, nullptr);
 
     removeTab(index);
     layoutTabs();
 
     return getPanel(currentIndex());
 }
 
 ListPanel* PanelTabBar::removeCurrentPanel(ListPanel* &panelToDelete)
 {
     return removePanel(currentIndex(), panelToDelete);
 }
 
 void PanelTabBar::updateTab(ListPanel *panel)
 {
     // find which is the correct tab
     for (int i = 0; i < count(); i++) {
         if ((ListPanel*)tabData(i).toLongLong() == panel) {
             setPanelTextToTab(i, panel);
             setIcon(i, panel);
             break;
         }
     }
 }
 
 void PanelTabBar::duplicateTab()
 {
     int id = currentIndex();
     emit newTab(((ListPanel*)tabData(id).toLongLong())->virtualPath());
 }
 
 void PanelTabBar::setIcon(int index, ListPanel *panel)
 {
     Icon tabIcon;
     if (panel->isLocked()) {
         tabIcon = Icon("lock");
     } else if (panel->isPinned()) {
         tabIcon = Icon("pin");
     }
     setTabIcon(index, tabIcon);
 }
 
 QString PanelTabBar::squeeze(const QUrl &url, int tabIndex)
 {
     const QString longText = url.isEmpty() ? i18n("[invalid]") :
                                              url.isLocalFile() ? url.path() : url.toDisplayString();
     if (tabIndex >= 0)
         setTabToolTip(tabIndex, longText);
 
     const KConfigGroup group(krConfig, "Look&Feel");
     const bool showLongNames = group.readEntry("Fullpath Tab Names", _FullPathTabNames);
 
     QString text;
     if (!showLongNames) {
         const QString scheme = url.scheme().isEmpty() || url.isLocalFile() ? "" : (url.scheme() + ':');
         const QString host = url.host().isEmpty() ? "" : (url.host() + ':');
         const QString name = url.isLocalFile() && url.fileName().isEmpty() ? "/" : url.fileName();
         text = scheme + host + name;
     } else {
         text = longText;
     }
 
     if (text.isEmpty())
         text = i18nc("invalid URL path", "?");
 
     // set the real max length
     QFontMetrics fm(fontMetrics());
-    _maxTabLength = (dynamic_cast<QWidget*>(parent())->width() - (6 * fm.width("W"))) / fm.width("W");
+    _maxTabLength = (dynamic_cast<QWidget*>(parent())->width() - (6 * fm.QFONTMETRICS_WIDTH("W"))) / fm.QFONTMETRICS_WIDTH("W");
     // each tab gets a fair share of the max tab length
     const int effectiveTabLength = _maxTabLength / (count() == 0 ? 1 : count());
-    const int labelWidth = fm.width("W") * effectiveTabLength;
-    const int textWidth = fm.width(text);
+    const int labelWidth = fm.QFONTMETRICS_WIDTH("W") * effectiveTabLength;
+    const int textWidth = fm.QFONTMETRICS_WIDTH(text);
     if (textWidth <= labelWidth)
         return text;
 
     // squeeze text - start with the dots only
     QString squeezedText = "...";
-    int squeezedWidth = fm.width(squeezedText);
+    int squeezedWidth = fm.QFONTMETRICS_WIDTH(squeezedText);
 
     int letters = text.length() * (labelWidth - squeezedWidth) / textWidth / 2;
     if (labelWidth < squeezedWidth)
         letters = 1;
     squeezedText = text.left(letters) + "..." + text.right(letters);
-    squeezedWidth = fm.width(squeezedText);
+    squeezedWidth = fm.QFONTMETRICS_WIDTH(squeezedText);
 
     if (squeezedWidth < labelWidth) {
         // we estimated too short
         // add letters while text < label
         do {
             letters++;
             squeezedText = text.left(letters) + "..." + text.right(letters);
-            squeezedWidth = fm.width(squeezedText);
+            squeezedWidth = fm.QFONTMETRICS_WIDTH(squeezedText);
         } while (squeezedWidth < labelWidth);
         letters--;
         squeezedText = text.left(letters) + "..." + text.right(letters);
     } else if (squeezedWidth > labelWidth) {
         // we estimated too long
         // remove letters while text > label
         do {
             letters--;
             squeezedText = text.left(letters) + "..." + text.right(letters);
-            squeezedWidth = fm.width(squeezedText);
+            squeezedWidth = fm.QFONTMETRICS_WIDTH(squeezedText);
         } while (letters && squeezedWidth > labelWidth);
     }
 
     return squeezedText;
 }
 
 void PanelTabBar::resizeEvent(QResizeEvent *e)
 {
     QTabBar::resizeEvent(e);
 
     layoutTabs();
 }
 
 void PanelTabBar::mouseMoveEvent(QMouseEvent* e)
 {
     QTabBar::mouseMoveEvent(e);
     if(_tabClicked) {
         _draggingTab = true;
         emit draggingTab(e);
     }
 }
 
 void PanelTabBar::mousePressEvent(QMouseEvent* e)
 {
     int clickedTab = tabAt(e->pos());
 
     if (-1 == clickedTab) { // clicked on nothing ...
         QTabBar::mousePressEvent(e);
         return;
     }
 
     _tabClicked = true;
 
     setCurrentIndex(clickedTab);
 
     ListPanel *p = getPanel(clickedTab);
     if (p)
         p->slotFocusOnMe();
 
     if (e->button() == Qt::RightButton) {
         // show the popup menu
         _panelActionMenu->menu()->popup(e->globalPos());
     } else {
         if (e->button() == Qt::MidButton)// close the current tab
             emit closeCurrentTab();
     }
 
     QTabBar::mousePressEvent(e);
 }
 
 void PanelTabBar::mouseReleaseEvent(QMouseEvent* e)
 {
     QTabBar::mouseReleaseEvent(e);
     if(_draggingTab)
         emit draggingTabFinished(e);
     _draggingTab = false;
     _tabClicked = false;
 }
 
 void PanelTabBar::dragEnterEvent(QDragEnterEvent *e)
 {
     e->accept();
     handleDragEvent(tabAt(e->pos()));
     QTabBar::dragEnterEvent(e);
 }
 
 void PanelTabBar::dragLeaveEvent(QDragLeaveEvent *)
 {
     handleDragEvent(-1);
 }
 
 void PanelTabBar::dragMoveEvent(QDragMoveEvent *e)
 {
     e->ignore();
     handleDragEvent(tabAt(e->pos()));
     QTabBar::dragMoveEvent(e);
 }
 
 void PanelTabBar::handleDragEvent(int tabIndex)
 {
     if (_dragTabIndex == tabIndex)
         return;
 
     _dragTabIndex = tabIndex;
     if (_dragTabIndex == -1) {
         _dragTimer->stop();
     } else {
         _dragTimer->start();
     }
 }
 
 void PanelTabBar::layoutTabs()
 {
     for (int i = 0; i < count(); i++) {
         setPanelTextToTab(i, (ListPanel*) tabData(i).toLongLong());
     }
 }
 
 void PanelTabBar::setPanelTextToTab(int tabIndex, ListPanel *panel)
 {
     // update tab text from pinnedUrl in case the tab is pinned
     if (panel->isPinned()) {
         setTabText(tabIndex, squeeze(panel->pinnedUrl(), tabIndex));
     } else {
         setTabText(tabIndex, squeeze(panel->virtualPath(), tabIndex));
     }
 }