diff --git a/src/filewidgets/kdiroperator.cpp b/src/filewidgets/kdiroperator.cpp
index 27f20e31..8b6cf956 100644
--- a/src/filewidgets/kdiroperator.cpp
+++ b/src/filewidgets/kdiroperator.cpp
@@ -1,2724 +1,2724 @@
 /* This file is part of the KDE libraries
     Copyright (C) 1999,2000 Stephan Kulow <coolo@kde.org>
                   1999,2000,2001,2002,2003 Carsten Pfeiffer <pfeiffer@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "kdiroperator.h"
 #include <kprotocolmanager.h>
 #include <kiconloader.h>
 #include "kdirmodel.h"
 #include "kdiroperatordetailview_p.h"
 #include "kdirsortfilterproxymodel.h"
 #include "kfileitem.h"
 #include "kfilemetapreview_p.h"
 #include "kpreviewwidgetbase.h"
 #include "knewfilemenu.h"
 #include "../pathhelpers_p.h"
 
 #include <config-kiofilewidgets.h>
 #include <defaults-kfile.h> // ConfigGroup, DefaultShowHidden, DefaultDirsFirst, DefaultSortReversed
 
 #include <QApplication>
 #include <QHeaderView>
 #include <QListView>
 #include <QMenu>
 #include <QMimeData>
 #include <QProgressBar>
 #include <QScrollBar>
 #include <QSplitter>
 #include <QWheelEvent>
 #include <QTimer>
 #include <QDebug>
 #include <QMimeDatabase>
 
 #include <kdirlister.h>
 #include <kfileitemdelegate.h>
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 #include <kjobwidgets.h>
 #include <kio/deletejob.h>
 #include <kio/copyjob.h>
 #include <kio/jobuidelegate.h>
 #include <kio/previewjob.h>
 #include <KIO/OpenFileManagerWindowJob>
 #include <kfilepreviewgenerator.h>
 #include <krun.h>
 #include <kpropertiesdialog.h>
 #include <kactioncollection.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 template class QHash<QString, KFileItem>;
 
 // QDir::SortByMask is not only undocumented, it also omits QDir::Type which  is another
 // sorting mode.
 static const int QDirSortMask = QDir::SortByMask | QDir::Type;
 
 /**
  * Default icon view for KDirOperator using
  * custom view options.
  */
 class KDirOperatorIconView : public QListView
 {
     Q_OBJECT
 public:
     KDirOperatorIconView(KDirOperator *dirOperator, QWidget *parent = nullptr);
     virtual ~KDirOperatorIconView();
 
 protected:
     QStyleOptionViewItem viewOptions() const override;
     void dragEnterEvent(QDragEnterEvent *event) override;
     void mousePressEvent(QMouseEvent *event) override;
     void wheelEvent(QWheelEvent *event) override;
 
 private:
     KDirOperator *ops;
 };
 
 KDirOperatorIconView::KDirOperatorIconView(KDirOperator *dirOperator, QWidget *parent) :
     QListView(parent),
     ops(dirOperator)
 {
     setViewMode(QListView::IconMode);
     setFlow(QListView::TopToBottom);
     setResizeMode(QListView::Adjust);
     setSpacing(0);
     setMovement(QListView::Static);
     setDragDropMode(QListView::DragOnly);
     setVerticalScrollMode(QListView::ScrollPerPixel);
     setHorizontalScrollMode(QListView::ScrollPerPixel);
     setEditTriggers(QAbstractItemView::NoEditTriggers);
     setWordWrap(true);
     setIconSize(QSize(KIconLoader::SizeSmall, KIconLoader::SizeSmall));
 }
 
 KDirOperatorIconView::~KDirOperatorIconView()
 {
 }
 
 QStyleOptionViewItem KDirOperatorIconView::viewOptions() const
 {
     QStyleOptionViewItem viewOptions = QListView::viewOptions();
     viewOptions.showDecorationSelected = true;
     viewOptions.decorationPosition = ops->decorationPosition();
     if (viewOptions.decorationPosition == QStyleOptionViewItem::Left) {
         viewOptions.displayAlignment = Qt::AlignLeft | Qt::AlignVCenter;
     } else {
         viewOptions.displayAlignment = Qt::AlignCenter;
     }
 
     return viewOptions;
 }
 
 void KDirOperatorIconView::dragEnterEvent(QDragEnterEvent *event)
 {
     if (event->mimeData()->hasUrls()) {
         event->acceptProposedAction();
     }
 }
 
 void KDirOperatorIconView::mousePressEvent(QMouseEvent *event)
 {
     if (!indexAt(event->pos()).isValid()) {
         const Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
         if (!(modifiers & Qt::ShiftModifier) && !(modifiers & Qt::ControlModifier)) {
             clearSelection();
         }
     }
 
     QListView::mousePressEvent(event);
 }
 
 void KDirOperatorIconView::wheelEvent(QWheelEvent *event)
 {
     QListView::wheelEvent(event);
 
     // apply the vertical wheel event to the horizontal scrollbar, as
     // the items are aligned from left to right
     if (event->orientation() == Qt::Vertical) {
         QWheelEvent horizEvent(event->pos(),
                                event->delta(),
                                event->buttons(),
                                event->modifiers(),
                                Qt::Horizontal);
         QApplication::sendEvent(horizontalScrollBar(), &horizEvent);
     }
 }
 
 void KDirOperator::keyPressEvent(QKeyEvent *e)
 {
     if (!(e->key() == Qt::Key_Return || e->key() == Qt::Key_Enter)) {
         QWidget::keyPressEvent(e);
     }
 }
 
 class Q_DECL_HIDDEN KDirOperator::Private
 {
 public:
     explicit Private(KDirOperator *parent);
     ~Private();
 
     enum InlinePreviewState {
         ForcedToFalse = 0,
         ForcedToTrue,
         NotForced
     };
 
     // private methods
     bool checkPreviewInternal() const;
     void checkPath(const QString &txt, bool takeFiles = false);
     bool openUrl(const QUrl &url, KDirLister::OpenUrlFlags flags = KDirLister::NoFlags);
     int sortColumn() const;
     Qt::SortOrder sortOrder() const;
     void updateSorting(QDir::SortFlags sort);
 
     static bool isReadable(const QUrl &url);
     bool isSchemeSupported(const QString &scheme) const;
 
     KFile::FileView allViews();
 
     // private slots
     void _k_slotDetailedView();
     void _k_slotSimpleView();
     void _k_slotTreeView();
     void _k_slotDetailedTreeView();
     void _k_slotToggleHidden(bool);
     void _k_togglePreview(bool);
     void _k_toggleInlinePreviews(bool);
     void _k_slotOpenFileManager();
     void _k_slotSortByName();
     void _k_slotSortBySize();
     void _k_slotSortByDate();
     void _k_slotSortByType();
     void _k_slotSortReversed(bool doReverse);
     void _k_slotToggleDirsFirst();
     void _k_slotToggleIgnoreCase();
     void _k_slotStarted();
     void _k_slotProgress(int);
     void _k_slotShowProgress();
     void _k_slotIOFinished();
     void _k_slotCanceled();
     void _k_slotRedirected(const QUrl &);
     void _k_slotProperties();
     void _k_slotActivated(const QModelIndex &);
     void _k_slotSelectionChanged();
     void _k_openContextMenu(const QPoint &);
     void _k_triggerPreview(const QModelIndex &);
     void _k_showPreview();
     void _k_slotSplitterMoved(int, int);
     void _k_assureVisibleSelection();
     void _k_synchronizeSortingState(int, Qt::SortOrder);
     void _k_slotChangeDecorationPosition();
     void _k_slotExpandToUrl(const QModelIndex &);
     void _k_slotItemsChanged();
     void _k_slotDirectoryCreated(const QUrl &);
 
     void updateListViewGrid();
     void updatePreviewActionState();
     int iconSizeForViewType(QAbstractItemView *itemView) const;
 
     // private members
     KDirOperator * const parent;
     QStack<QUrl *> backStack;   ///< Contains all URLs you can reach with the back button.
     QStack<QUrl *> forwardStack; ///< Contains all URLs you can reach with the forward button.
 
     QModelIndex lastHoveredIndex;
 
     KDirLister *dirLister;
     QUrl currUrl;
 
     KCompletion completion;
     KCompletion dirCompletion;
     bool completeListDirty;
     QDir::SortFlags sorting;
     QStyleOptionViewItem::Position decorationPosition;
 
     QSplitter *splitter;
 
     QAbstractItemView *itemView;
     KDirModel *dirModel;
     KDirSortFilterProxyModel *proxyModel;
 
     KFileItemList pendingMimeTypes;
 
     // the enum KFile::FileView as an int
     int viewKind;
     int defaultView;
 
     KFile::Modes mode;
     QProgressBar *progressBar;
 
     KPreviewWidgetBase *preview;
     QUrl previewUrl;
     int previewWidth;
 
     bool dirHighlighting;
     bool onlyDoubleClickSelectsFiles;
     QString lastURL; // used for highlighting a directory on cdUp
     QTimer *progressDelayTimer;
     int dropOptions;
 
     KActionMenu *actionMenu;
     KActionCollection *actionCollection;
 
     KNewFileMenu *newFileMenu;
 
     KConfigGroup *configGroup;
 
     KFilePreviewGenerator *previewGenerator;
 
     bool showPreviews;
     bool calledFromUpdatePreviewActionState;
     bool showPreviewsConfigEntry;
 
     int iconsZoom;
 
     bool isSaving;
 
     KActionMenu *decorationMenu;
     KToggleAction *leftAction;
     QList<QUrl> itemsToBeSetAsCurrent;
     bool shouldFetchForItems;
     InlinePreviewState inlinePreviewState;
     QStringList supportedSchemes;
 };
 
 KDirOperator::Private::Private(KDirOperator *_parent) :
     parent(_parent),
     dirLister(nullptr),
     decorationPosition(QStyleOptionViewItem::Left),
     splitter(nullptr),
     itemView(nullptr),
     dirModel(nullptr),
     proxyModel(nullptr),
     progressBar(nullptr),
     preview(nullptr),
     previewUrl(),
     previewWidth(0),
     dirHighlighting(false),
     onlyDoubleClickSelectsFiles(!qApp->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick)),
     progressDelayTimer(nullptr),
     dropOptions(0),
     actionMenu(nullptr),
     actionCollection(nullptr),
     newFileMenu(nullptr),
     configGroup(nullptr),
     previewGenerator(nullptr),
     showPreviews(false),
     calledFromUpdatePreviewActionState(false),
     showPreviewsConfigEntry(false),
     iconsZoom(0),
     isSaving(false),
     decorationMenu(nullptr),
     leftAction(nullptr),
     shouldFetchForItems(false),
     inlinePreviewState(NotForced)
 {
 }
 
 KDirOperator::Private::~Private()
 {
     delete itemView;
     itemView = nullptr;
 
     // TODO:
     // if (configGroup) {
     //     itemView->writeConfig(configGroup);
     // }
 
     qDeleteAll(backStack);
     qDeleteAll(forwardStack);
     delete preview;
     preview = nullptr;
 
     delete proxyModel;
     proxyModel = nullptr;
     delete dirModel;
     dirModel = nullptr;
     dirLister = nullptr; // deleted by KDirModel
     delete configGroup;
     configGroup = nullptr;
 
     delete progressDelayTimer;
     progressDelayTimer = nullptr;
 }
 
 KDirOperator::KDirOperator(const QUrl &_url, QWidget *parent) :
     QWidget(parent),
     d(new Private(this))
 {
     d->splitter = new QSplitter(this);
     d->splitter->setChildrenCollapsible(false);
     connect(d->splitter, SIGNAL(splitterMoved(int,int)),
             this, SLOT(_k_slotSplitterMoved(int,int)));
 
     d->preview = nullptr;
 
     d->mode = KFile::File;
     d->viewKind = KFile::Simple;
 
     if (_url.isEmpty()) { // no dir specified -> current dir
         QString strPath = QDir::currentPath();
         strPath.append(QLatin1Char('/'));
         d->currUrl = QUrl::fromLocalFile(strPath);
     } else {
         d->currUrl = _url;
         if (d->currUrl.scheme().isEmpty()) {
             d->currUrl.setScheme(QStringLiteral("file"));
         }
 
         QString path = d->currUrl.path();
         if (!path.endsWith(QLatin1Char('/'))) {
             path.append(QLatin1Char('/')); // make sure we have a trailing slash!
         }
         d->currUrl.setPath(path);
     }
 
     // We set the direction of this widget to LTR, since even on RTL desktops
     // viewing directory listings in RTL mode makes people's head explode.
     // Is this the correct place? Maybe it should be in some lower level widgets...?
     setLayoutDirection(Qt::LeftToRight);
     setDirLister(new KDirLister());
 
     connect(&d->completion, SIGNAL(match(QString)),
             SLOT(slotCompletionMatch(QString)));
 
     d->progressBar = new QProgressBar(this);
     d->progressBar->setObjectName(QStringLiteral("d->progressBar"));
     d->progressBar->adjustSize();
     d->progressBar->move(2, height() - d->progressBar->height() - 2);
 
     d->progressDelayTimer = new QTimer(this);
     d->progressDelayTimer->setObjectName(QStringLiteral("d->progressBar delay timer"));
     connect(d->progressDelayTimer, SIGNAL(timeout()),
             SLOT(_k_slotShowProgress()));
 
     d->completeListDirty = false;
 
     // action stuff
     setupActions();
     setupMenu();
 
     d->sorting = QDir::NoSort;  //so updateSorting() doesn't think nothing has changed
     d->updateSorting(QDir::Name | QDir::DirsFirst);
 
     setFocusPolicy(Qt::WheelFocus);
 }
 
 KDirOperator::~KDirOperator()
 {
     resetCursor();
     disconnect(d->dirLister, nullptr, this, nullptr);
     delete d;
 }
 
 void KDirOperator::setSorting(QDir::SortFlags spec)
 {
     d->updateSorting(spec);
 }
 
 QDir::SortFlags KDirOperator::sorting() const
 {
     return d->sorting;
 }
 
 bool KDirOperator::isRoot() const
 {
 #ifdef Q_OS_WIN
     if (url().isLocalFile()) {
         const QString path = url().toLocalFile();
         if (path.length() == 3) {
             return (path[0].isLetter() && path[1] == ':' && path[2] == '/');
         }
         return false;
     } else
 #endif
         return url().path() == QString(QLatin1Char('/'));
 }
 
 KDirLister *KDirOperator::dirLister() const
 {
     return d->dirLister;
 }
 
 void KDirOperator::resetCursor()
 {
     if (qApp) {
         QApplication::restoreOverrideCursor();
     }
     d->progressBar->hide();
 }
 
 void KDirOperator::sortByName()
 {
     d->updateSorting((d->sorting & ~QDirSortMask) | QDir::Name);
 }
 
 void KDirOperator::sortBySize()
 {
     d->updateSorting((d->sorting & ~QDirSortMask) | QDir::Size);
 }
 
 void KDirOperator::sortByDate()
 {
     d->updateSorting((d->sorting & ~QDirSortMask) | QDir::Time);
 }
 
 void KDirOperator::sortByType()
 {
     d->updateSorting((d->sorting & ~QDirSortMask) | QDir::Type);
 }
 
 void KDirOperator::sortReversed()
 {
     // toggle it, hence the inversion of current state
     d->_k_slotSortReversed(!(d->sorting & QDir::Reversed));
 }
 
 void KDirOperator::toggleDirsFirst()
 {
     d->_k_slotToggleDirsFirst();
 }
 
 void KDirOperator::toggleIgnoreCase()
 {
     if (d->proxyModel != nullptr) {
         Qt::CaseSensitivity cs = d->proxyModel->sortCaseSensitivity();
         cs = (cs == Qt::CaseSensitive) ? Qt::CaseInsensitive : Qt::CaseSensitive;
         d->proxyModel->setSortCaseSensitivity(cs);
     }
 }
 
 void KDirOperator::updateSelectionDependentActions()
 {
     const bool hasSelection = (d->itemView != nullptr) &&
                               d->itemView->selectionModel()->hasSelection();
     d->actionCollection->action(QStringLiteral("trash"))->setEnabled(hasSelection);
     d->actionCollection->action(QStringLiteral("delete"))->setEnabled(hasSelection);
     d->actionCollection->action(QStringLiteral("properties"))->setEnabled(hasSelection);
 }
 
 void KDirOperator::setPreviewWidget(KPreviewWidgetBase *w)
 {
     const bool showPreview = (w != nullptr);
     if (showPreview) {
         d->viewKind = (d->viewKind | KFile::PreviewContents);
     } else {
         d->viewKind = (d->viewKind & ~KFile::PreviewContents);
     }
 
     delete d->preview;
     d->preview = w;
 
     if (w) {
         d->splitter->addWidget(w);
     }
 
     KToggleAction *previewAction = static_cast<KToggleAction *>(d->actionCollection->action(QStringLiteral("preview")));
     previewAction->setEnabled(showPreview);
     previewAction->setChecked(showPreview);
     setView(static_cast<KFile::FileView>(d->viewKind));
 }
 
 KFileItemList KDirOperator::selectedItems() const
 {
     KFileItemList itemList;
     if (d->itemView == nullptr) {
         return itemList;
     }
 
     const QItemSelection selection = d->proxyModel->mapSelectionToSource(d->itemView->selectionModel()->selection());
 
     const QModelIndexList indexList = selection.indexes();
     foreach (const QModelIndex &index, indexList) {
         KFileItem item = d->dirModel->itemForIndex(index);
         if (!item.isNull()) {
             itemList.append(item);
         }
     }
 
     return itemList;
 }
 
 bool KDirOperator::isSelected(const KFileItem &item) const
 {
     if ((item.isNull()) || (d->itemView == nullptr)) {
         return false;
     }
 
     const QModelIndex dirIndex = d->dirModel->indexForItem(item);
     const QModelIndex proxyIndex = d->proxyModel->mapFromSource(dirIndex);
     return d->itemView->selectionModel()->isSelected(proxyIndex);
 }
 
 int KDirOperator::numDirs() const
 {
     return (d->dirLister == nullptr) ? 0 : d->dirLister->directories().count();
 }
 
 int KDirOperator::numFiles() const
 {
     return (d->dirLister == nullptr) ? 0 : d->dirLister->items().count() - numDirs();
 }
 
 KCompletion *KDirOperator::completionObject() const
 {
     return const_cast<KCompletion *>(&d->completion);
 }
 
 KCompletion *KDirOperator::dirCompletionObject() const
 {
     return const_cast<KCompletion *>(&d->dirCompletion);
 }
 
 KActionCollection *KDirOperator::actionCollection() const
 {
     return d->actionCollection;
 }
 
 KFile::FileView KDirOperator::Private::allViews()
 {
     return static_cast<KFile::FileView>(KFile::Simple | KFile::Detail | KFile::Tree | KFile::DetailTree);
 }
 
 void KDirOperator::Private::_k_slotDetailedView()
 {
     KFile::FileView view = static_cast<KFile::FileView>((viewKind & ~allViews()) | KFile::Detail);
     parent->setView(view);
 }
 
 void KDirOperator::Private::_k_slotSimpleView()
 {
     KFile::FileView view = static_cast<KFile::FileView>((viewKind & ~allViews()) | KFile::Simple);
     parent->setView(view);
 }
 
 void KDirOperator::Private::_k_slotTreeView()
 {
     KFile::FileView view = static_cast<KFile::FileView>((viewKind & ~allViews()) | KFile::Tree);
     parent->setView(view);
 }
 
 void KDirOperator::Private::_k_slotDetailedTreeView()
 {
     KFile::FileView view = static_cast<KFile::FileView>((viewKind & ~allViews()) | KFile::DetailTree);
     parent->setView(view);
 }
 
 void KDirOperator::Private::_k_slotToggleHidden(bool show)
 {
     dirLister->setShowingDotFiles(show);
     parent->updateDir();
     _k_assureVisibleSelection();
 }
 
 void KDirOperator::Private::_k_togglePreview(bool on)
 {
     if (on) {
         viewKind = viewKind | KFile::PreviewContents;
         if (preview == nullptr) {
             preview = new KFileMetaPreview(parent);
             actionCollection->action(QStringLiteral("preview"))->setChecked(true);
             splitter->addWidget(preview);
         }
 
         preview->show();
 
         QMetaObject::invokeMethod(parent, "_k_assureVisibleSelection", Qt::QueuedConnection);
         if (itemView != nullptr) {
             const QModelIndex index = itemView->selectionModel()->currentIndex();
             if (index.isValid()) {
                 _k_triggerPreview(index);
             }
         }
     } else if (preview != nullptr) {
         viewKind = viewKind & ~KFile::PreviewContents;
         preview->hide();
     }
 }
 
 void KDirOperator::Private::_k_toggleInlinePreviews(bool show)
 {
     if (showPreviews == show) {
         return;
     }
 
     showPreviews = show;
 
     if (!calledFromUpdatePreviewActionState) {
         showPreviewsConfigEntry = show;
     }
 
     if (!previewGenerator) {
         return;
     }
 
     previewGenerator->setPreviewShown(show);
 }
 
 void KDirOperator::Private::_k_slotOpenFileManager()
 {
     const KFileItemList list = parent->selectedItems();
     if (list.isEmpty()) {
         KIO::highlightInFileManager({currUrl.adjusted(QUrl::StripTrailingSlash)});
     } else {
         KIO::highlightInFileManager(list.urlList());
     }
 }
 
 void KDirOperator::Private::_k_slotSortByName()
 {
     parent->sortByName();
 }
 
 void KDirOperator::Private::_k_slotSortBySize()
 {
     parent->sortBySize();
 }
 
 void KDirOperator::Private::_k_slotSortByDate()
 {
     parent->sortByDate();
 }
 
 void KDirOperator::Private::_k_slotSortByType()
 {
     parent->sortByType();
 }
 
 void KDirOperator::Private::_k_slotSortReversed(bool doReverse)
 {
     QDir::SortFlags s = sorting & ~QDir::Reversed;
     if (doReverse) {
         s |= QDir::Reversed;
     }
     updateSorting(s);
 }
 
 void KDirOperator::Private::_k_slotToggleDirsFirst()
 {
     QDir::SortFlags s = (sorting ^ QDir::DirsFirst);
     updateSorting(s);
 }
 
 void KDirOperator::Private::_k_slotToggleIgnoreCase()
 {
     // TODO: port to Qt4's QAbstractItemView
     /*if ( !d->fileView )
       return;
 
     QDir::SortFlags sorting = d->fileView->sorting();
     if ( !KFile::isSortCaseInsensitive( sorting ) )
         d->fileView->setSorting( sorting | QDir::IgnoreCase );
     else
         d->fileView->setSorting( sorting & ~QDir::IgnoreCase );
     d->sorting = d->fileView->sorting();*/
 }
 
 void KDirOperator::mkdir()
 {
     d->newFileMenu->setPopupFiles(QList<QUrl>() << url());
     d->newFileMenu->setViewShowsHiddenFiles(showHiddenFiles());
     d->newFileMenu->createDirectory();
 }
 
 bool KDirOperator::mkdir(const QString &directory, bool enterDirectory)
 {
     // Creates "directory", relative to the current directory (d->currUrl).
     // The given path may contain any number directories, existent or not.
     // They will all be created, if possible.
 
     // TODO: very similar to KDirSelectDialog::Private::slotMkdir
 
     bool writeOk = false;
     bool exists = false;
     QUrl folderurl(d->currUrl);
 
     const QStringList dirs = directory.split(QLatin1Char('/'), QString::SkipEmptyParts);
     QStringList::ConstIterator it = dirs.begin();
 
     for (; it != dirs.end(); ++it) {
         folderurl.setPath(concatPaths(folderurl.path(), *it));
         if (folderurl.isLocalFile()) {
             exists = QFile::exists(folderurl.toLocalFile());
         } else {
             KIO::StatJob *job = KIO::stat(folderurl);
             KJobWidgets::setWindow(job, this);
             job->setDetails(0); //We only want to know if it exists, 0 == that.
             job->setSide(KIO::StatJob::DestinationSide);
             exists = job->exec();
         }
 
         if (!exists) {
             KIO::Job *job = KIO::mkdir(folderurl);
             KJobWidgets::setWindow(job, this);
             writeOk = job->exec();
         }
     }
 
     if (exists) { // url was already existent
         KMessageBox::sorry(d->itemView, i18n("A file or folder named %1 already exists.",
                                              folderurl.toDisplayString(QUrl::PreferLocalFile)));
     } else if (!writeOk) {
         KMessageBox::sorry(d->itemView, i18n("You do not have permission to "
                                              "create that folder."));
     } else if (enterDirectory) {
         setUrl(folderurl, true);
     }
 
     return writeOk;
 }
 
 KIO::DeleteJob *KDirOperator::del(const KFileItemList &items,
                                   QWidget *parent,
                                   bool ask, bool showProgress)
 {
     if (items.isEmpty()) {
         KMessageBox::information(parent,
                                  i18n("You did not select a file to delete."),
                                  i18n("Nothing to Delete"));
         return nullptr;
     }
 
     if (parent == nullptr) {
         parent = this;
     }
 
     const QList<QUrl> urls = items.urlList();
 
     bool doIt = !ask;
     if (ask) {
         KIO::JobUiDelegate uiDelegate;
         uiDelegate.setWindow(parent);
         doIt = uiDelegate.askDeleteConfirmation(urls, KIO::JobUiDelegate::Delete, KIO::JobUiDelegate::DefaultConfirmation);
     }
 
     if (doIt) {
         KIO::JobFlags flags = showProgress ? KIO::DefaultFlags : KIO::HideProgressInfo;
         KIO::DeleteJob *job = KIO::del(urls, flags);
         KJobWidgets::setWindow(job, this);
         job->uiDelegate()->setAutoErrorHandlingEnabled(true);
         return job;
     }
 
     return nullptr;
 }
 
 void KDirOperator::deleteSelected()
 {
     const KFileItemList list = selectedItems();
     if (!list.isEmpty()) {
         del(list, this);
     }
 }
 
 KIO::CopyJob *KDirOperator::trash(const KFileItemList &items,
                                   QWidget *parent,
                                   bool ask, bool showProgress)
 {
     if (items.isEmpty()) {
         KMessageBox::information(parent,
                                  i18n("You did not select a file to trash."),
                                  i18n("Nothing to Trash"));
         return nullptr;
     }
 
     const QList<QUrl> urls = items.urlList();
 
     bool doIt = !ask;
     if (ask) {
         KIO::JobUiDelegate uiDelegate;
         uiDelegate.setWindow(parent);
         doIt = uiDelegate.askDeleteConfirmation(urls, KIO::JobUiDelegate::Trash, KIO::JobUiDelegate::DefaultConfirmation);
     }
 
     if (doIt) {
         KIO::JobFlags flags = showProgress ? KIO::DefaultFlags : KIO::HideProgressInfo;
         KIO::CopyJob *job = KIO::trash(urls, flags);
         KJobWidgets::setWindow(job, this);
         job->uiDelegate()->setAutoErrorHandlingEnabled(true);
         return job;
     }
 
     return nullptr;
 }
 
 KFilePreviewGenerator *KDirOperator::previewGenerator() const
 {
     return d->previewGenerator;
 }
 
 void KDirOperator::setInlinePreviewShown(bool show)
 {
     d->inlinePreviewState = show ? Private::ForcedToTrue : Private::ForcedToFalse;
 }
 
 bool KDirOperator::isInlinePreviewShown() const
 {
     return d->showPreviews;
 }
 
 int KDirOperator::iconsZoom() const
 {
     return d->iconsZoom;
 }
 
 void KDirOperator::setIsSaving(bool isSaving)
 {
     d->isSaving = isSaving;
 }
 
 bool KDirOperator::isSaving() const
 {
     return d->isSaving;
 }
 
 void KDirOperator::trashSelected()
 {
     if (d->itemView == nullptr) {
         return;
     }
 
     if (QApplication::keyboardModifiers() & Qt::ShiftModifier) {
         deleteSelected();
         return;
     }
 
     const KFileItemList list = selectedItems();
     if (!list.isEmpty()) {
         trash(list, this);
     }
 }
 
 void KDirOperator::setIconsZoom(int _value)
 {
     if (d->iconsZoom == _value) {
         return;
     }
 
     int value = _value;
     value = qMin(100, value);
     value = qMax(0, value);
 
     d->iconsZoom = value;
 
     if (!d->previewGenerator) {
         return;
     }
 
     const int maxSize = KIconLoader::SizeEnormous - KIconLoader::SizeSmall;
     const int val = (maxSize * value / 100) + KIconLoader::SizeSmall;
     d->itemView->setIconSize(QSize(val, val));
     d->updateListViewGrid();
     d->previewGenerator->updatePreviews();
 
     emit currentIconSizeChanged(value);
 }
 
 void KDirOperator::close()
 {
     resetCursor();
     d->pendingMimeTypes.clear();
     d->completion.clear();
     d->dirCompletion.clear();
     d->completeListDirty = true;
     d->dirLister->stop();
 }
 
 void KDirOperator::Private::checkPath(const QString &, bool /*takeFiles*/) // SLOT
 {
 #if 0
     // copy the argument in a temporary string
     QString text = _txt;
     // it's unlikely to happen, that at the beginning are spaces, but
     // for the end, it happens quite often, I guess.
     text = text.trimmed();
     // if the argument is no URL (the check is quite fragil) and it's
     // no absolute path, we add the current directory to get a correct url
     if (text.find(':') < 0 && text[0] != '/') {
         text.insert(0, d->currUrl);
     }
 
     // in case we have a selection defined and someone patched the file-
     // name, we check, if the end of the new name is changed.
     if (!selection.isNull()) {
         int position = text.lastIndexOf('/');
         ASSERT(position >= 0); // we already inserted the current d->dirLister in case
         QString filename = text.mid(position + 1, text.length());
         if (filename != selection) {
             selection.clear();
         }
     }
 
     QUrl u(text); // I have to take care of entered URLs
     bool filenameEntered = false;
 
     if (u.isLocalFile()) {
         // the empty path is kind of a hack
         KFileItem i("", u.toLocalFile());
         if (i.isDir()) {
             setUrl(text, true);
         } else {
             if (takeFiles)
                 if (acceptOnlyExisting && !i.isFile()) {
                     warning("you entered an invalid URL");
                 } else {
                     filenameEntered = true;
                 }
         }
     } else {
         setUrl(text, true);
     }
 
     if (filenameEntered) {
         filename_ = u.url();
         emit fileSelected(filename_);
 
         QApplication::restoreOverrideCursor();
 
         accept();
     }
 #endif
     // qDebug() << "TODO KDirOperator::checkPath()";
 }
 
 void KDirOperator::setUrl(const QUrl &_newurl, bool clearforward)
 {
     QUrl newurl;
 
     if (!_newurl.isValid()) {
         newurl = QUrl::fromLocalFile(QDir::homePath());
     } else {
         newurl = _newurl.adjusted(QUrl::NormalizePathSegments);
     }
 
     if (!newurl.path().isEmpty() && !newurl.path().endsWith(QLatin1Char('/'))) {
         newurl.setPath(newurl.path() + QLatin1Char('/'));
     }
 
     // already set
     if (newurl.matches(d->currUrl, QUrl::StripTrailingSlash)) {
         return;
     }
 
     if (!d->isSchemeSupported(newurl.scheme()))
         return;
 
     if (!Private::isReadable(newurl)) {
         // maybe newurl is a file? check its parent directory
         newurl = newurl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
         if (newurl.matches(d->currUrl, QUrl::StripTrailingSlash)) {
             return;    // parent is current dir, nothing to do (fixes #173454, too)
         }
         KIO::StatJob *job = KIO::stat(newurl);
         KJobWidgets::setWindow(job, this);
         bool res = job->exec();
 
         KIO::UDSEntry entry = job->statResult();
         KFileItem i(entry, newurl);
         if ((!res || !Private::isReadable(newurl)) && i.isDir()) {
             resetCursor();
             KMessageBox::error(d->itemView,
                                i18n("The specified folder does not exist "
                                     "or was not readable."));
             return;
         } else if (!i.isDir()) {
             return;
         }
     }
 
     if (clearforward) {
         // autodelete should remove this one
         d->backStack.push(new QUrl(d->currUrl));
         qDeleteAll(d->forwardStack);
         d->forwardStack.clear();
     }
 
     d->lastURL = d->currUrl.toString(QUrl::StripTrailingSlash);
     d->currUrl = newurl;
 
     pathChanged();
     emit urlEntered(newurl);
 
     // enable/disable actions
     QAction *forwardAction = d->actionCollection->action(QStringLiteral("forward"));
     forwardAction->setEnabled(!d->forwardStack.isEmpty());
 
     QAction *backAction = d->actionCollection->action(QStringLiteral("back"));
     backAction->setEnabled(!d->backStack.isEmpty());
 
     QAction *upAction = d->actionCollection->action(QStringLiteral("up"));
     upAction->setEnabled(!isRoot());
 
     d->openUrl(newurl);
 }
 
 void KDirOperator::updateDir()
 {
     QApplication::setOverrideCursor(Qt::WaitCursor);
     d->dirLister->emitChanges();
     QApplication::restoreOverrideCursor();
 }
 
 void KDirOperator::rereadDir()
 {
     pathChanged();
     d->openUrl(d->currUrl, KDirLister::Reload);
 }
 
 bool KDirOperator::Private::isSchemeSupported(const QString &scheme) const
 {
     return supportedSchemes.isEmpty() || supportedSchemes.contains(scheme);
 }
 
 bool KDirOperator::Private::openUrl(const QUrl &url, KDirLister::OpenUrlFlags flags)
 {
     const bool result = KProtocolManager::supportsListing(url)
                         && isSchemeSupported(url.scheme())
                         && dirLister->openUrl(url, flags);
     if (!result) { // in that case, neither completed() nor canceled() will be emitted by KDL
         _k_slotCanceled();
     }
 
     return result;
 }
 
 int KDirOperator::Private::sortColumn() const
 {
     int column = KDirModel::Name;
     if (KFile::isSortByDate(sorting)) {
         column = KDirModel::ModifiedTime;
     } else if (KFile::isSortBySize(sorting)) {
         column = KDirModel::Size;
     } else if (KFile::isSortByType(sorting)) {
         column = KDirModel::Type;
     } else {
         Q_ASSERT(KFile::isSortByName(sorting));
     }
 
     return column;
 }
 
 Qt::SortOrder KDirOperator::Private::sortOrder() const
 {
     return (sorting & QDir::Reversed) ? Qt::DescendingOrder :
            Qt::AscendingOrder;
 }
 
 void KDirOperator::Private::updateSorting(QDir::SortFlags sort)
 {
     // qDebug() << "changing sort flags from"  << sorting << "to" << sort;
     if (sort == sorting) {
         return;
     }
 
     if ((sorting ^ sort) & QDir::DirsFirst) {
         // The "Folders First" setting has been changed.
         // We need to make sure that the files and folders are really re-sorted.
         // Without the following intermediate "fake resorting",
         // QSortFilterProxyModel::sort(int column, Qt::SortOrder order)
         // would do nothing because neither the column nor the sort order have been changed.
         Qt::SortOrder tmpSortOrder = (sortOrder() == Qt::AscendingOrder ? Qt::DescendingOrder : Qt::AscendingOrder);
         proxyModel->sort(sortOrder(), tmpSortOrder);
         proxyModel->setSortFoldersFirst(sort & QDir::DirsFirst);
     }
 
     sorting = sort;
     parent->updateSortActions();
     proxyModel->sort(sortColumn(), sortOrder());
 
     // TODO: The headers from QTreeView don't take care about a sorting
     // change of the proxy model hence they must be updated the manually.
     // This is done here by a qobject_cast, but it would be nicer to:
     // - provide a signal 'sortingChanged()'
     // - connect KDirOperatorDetailView() with this signal and update the
     //   header internally
     QTreeView *treeView = qobject_cast<QTreeView *>(itemView);
     if (treeView != nullptr) {
         QHeaderView *headerView = treeView->header();
         headerView->blockSignals(true);
         headerView->setSortIndicator(sortColumn(), sortOrder());
         headerView->blockSignals(false);
     }
 
     _k_assureVisibleSelection();
 }
 
 // Protected
 void KDirOperator::pathChanged()
 {
     if (d->itemView == nullptr) {
         return;
     }
 
     d->pendingMimeTypes.clear();
     //d->fileView->clear(); TODO
     d->completion.clear();
     d->dirCompletion.clear();
 
     // it may be, that we weren't ready at this time
     QApplication::restoreOverrideCursor();
 
     // when KIO::Job emits finished, the slot will restore the cursor
     QApplication::setOverrideCursor(Qt::WaitCursor);
 
     if (!Private::isReadable(d->currUrl)) {
         KMessageBox::error(d->itemView,
                            i18n("The specified folder does not exist "
                                 "or was not readable."));
         if (d->backStack.isEmpty()) {
             home();
         } else {
             back();
         }
     }
 }
 
 void KDirOperator::Private::_k_slotRedirected(const QUrl &newURL)
 {
     currUrl = newURL;
     pendingMimeTypes.clear();
     completion.clear();
     dirCompletion.clear();
     completeListDirty = true;
     emit parent->urlEntered(newURL);
 }
 
 // Code pinched from kfm then hacked
 void KDirOperator::back()
 {
     if (d->backStack.isEmpty()) {
         return;
     }
 
     d->forwardStack.push(new QUrl(d->currUrl));
 
     QUrl *s = d->backStack.pop();
 
     setUrl(*s, false);
     delete s;
 }
 
 // Code pinched from kfm then hacked
 void KDirOperator::forward()
 {
     if (d->forwardStack.isEmpty()) {
         return;
     }
 
     d->backStack.push(new QUrl(d->currUrl));
 
     QUrl *s = d->forwardStack.pop();
     setUrl(*s, false);
     delete s;
 }
 
 QUrl KDirOperator::url() const
 {
     return d->currUrl;
 }
 
 void KDirOperator::cdUp()
 {
     // Allow /d/c// to go up to /d/ instead of /d/c/
     QUrl tmp(d->currUrl.adjusted(QUrl::NormalizePathSegments));
     setUrl(tmp.resolved(QUrl(QStringLiteral(".."))), true);
 }
 
 void KDirOperator::home()
 {
     setUrl(QUrl::fromLocalFile(QDir::homePath()), true);
 }
 
 void KDirOperator::clearFilter()
 {
     d->dirLister->setNameFilter(QString());
     d->dirLister->clearMimeFilter();
     checkPreviewSupport();
 }
 
 void KDirOperator::setNameFilter(const QString &filter)
 {
     d->dirLister->setNameFilter(filter);
     checkPreviewSupport();
 }
 
 QString KDirOperator::nameFilter() const
 {
     return d->dirLister->nameFilter();
 }
 
 void KDirOperator::setMimeFilter(const QStringList &mimetypes)
 {
     d->dirLister->setMimeFilter(mimetypes);
     checkPreviewSupport();
 }
 
 QStringList KDirOperator::mimeFilter() const
 {
     return d->dirLister->mimeFilters();
 }
 
 void KDirOperator::setNewFileMenuSupportedMimeTypes(const QStringList &mimeTypes)
 {
     d->newFileMenu->setSupportedMimeTypes(mimeTypes);
 }
 
 QStringList KDirOperator::newFileMenuSupportedMimeTypes() const
 {
     return d->newFileMenu->supportedMimeTypes();
 }
 
 bool KDirOperator::checkPreviewSupport()
 {
     KToggleAction *previewAction = static_cast<KToggleAction *>(d->actionCollection->action(QStringLiteral("preview")));
 
     bool hasPreviewSupport = false;
     KConfigGroup cg(KSharedConfig::openConfig(), ConfigGroup);
     if (cg.readEntry("Show Default Preview", true)) {
         hasPreviewSupport = d->checkPreviewInternal();
     }
 
     previewAction->setEnabled(hasPreviewSupport);
     return hasPreviewSupport;
 }
 
 void KDirOperator::activatedMenu(const KFileItem &item, const QPoint &pos)
 {
     updateSelectionDependentActions();
 
     d->newFileMenu->setPopupFiles(QList<QUrl>() << item.url());
     d->newFileMenu->setViewShowsHiddenFiles(showHiddenFiles());
     d->newFileMenu->checkUpToDate();
 
     emit contextMenuAboutToShow(item, d->actionMenu->menu());
 
     d->actionMenu->menu()->exec(pos);
 }
 
 void KDirOperator::changeEvent(QEvent *event)
 {
     QWidget::changeEvent(event);
 }
 
 bool KDirOperator::eventFilter(QObject *watched, QEvent *event)
 {
     Q_UNUSED(watched);
 
     // If we are not hovering any items, check if there is a current index
     // set. In that case, we show the preview of that item.
     switch (event->type()) {
     case QEvent::MouseMove: {
         if (d->preview && !d->preview->isHidden()) {
             const QModelIndex hoveredIndex = d->itemView->indexAt(d->itemView->viewport()->mapFromGlobal(QCursor::pos()));
 
             if (d->lastHoveredIndex == hoveredIndex) {
                 return QWidget::eventFilter(watched, event);
             }
 
             d->lastHoveredIndex = hoveredIndex;
 
             const QModelIndex focusedIndex = d->itemView->selectionModel() ? d->itemView->selectionModel()->currentIndex()
                                              : QModelIndex();
 
             if (!hoveredIndex.isValid() && focusedIndex.isValid() &&
                     d->itemView->selectionModel()->isSelected(focusedIndex) &&
                     (d->lastHoveredIndex != focusedIndex)) {
                 const QModelIndex sourceFocusedIndex = d->proxyModel->mapToSource(focusedIndex);
                 const KFileItem item = d->dirModel->itemForIndex(sourceFocusedIndex);
                 if (!item.isNull()) {
                     d->preview->showPreview(item.url());
                 }
             }
         }
     }
     break;
     case QEvent::MouseButtonRelease: {
         if (d->preview != nullptr && !d->preview->isHidden()) {
             const QModelIndex hoveredIndex = d->itemView->indexAt(d->itemView->viewport()->mapFromGlobal(QCursor::pos()));
             const QModelIndex focusedIndex = d->itemView->selectionModel() ? d->itemView->selectionModel()->currentIndex()
                                              : QModelIndex();
 
             if (((!focusedIndex.isValid()) ||
                     !d->itemView->selectionModel()->isSelected(focusedIndex)) &&
                     (!hoveredIndex.isValid())) {
                 d->preview->clearPreview();
             }
         }
         QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(event);
         if (mouseEvent) {
             switch (mouseEvent->button()) {
             case Qt::BackButton:
                 back();
                 break;
             case Qt::ForwardButton:
                 forward();
                 break;
             default:
                 break;
             }
         }
     }
     break;
     case QEvent::Wheel: {
         QWheelEvent *evt = static_cast<QWheelEvent *>(event);
         if (evt->modifiers() & Qt::ControlModifier) {
             if (evt->delta() > 0) {
                 setIconsZoom(d->iconsZoom + 10);
             } else {
                 setIconsZoom(d->iconsZoom - 10);
             }
             return true;
         }
     }
     break;
     default:
         break;
     }
 
     return QWidget::eventFilter(watched, event);
 }
 
 bool KDirOperator::Private::checkPreviewInternal() const
 {
     const QStringList supported = KIO::PreviewJob::supportedMimeTypes();
     // no preview support for directories?
     if (parent->dirOnlyMode() && supported.indexOf(QStringLiteral("inode/directory")) == -1) {
         return false;
     }
 
     QStringList mimeTypes = dirLister->mimeFilters();
     const QStringList nameFilter = dirLister->nameFilter().split(QLatin1Char(' '), QString::SkipEmptyParts);
     QMimeDatabase db;
 
     if (mimeTypes.isEmpty() && nameFilter.isEmpty() && !supported.isEmpty()) {
         return true;
     } else {
         QRegExp r;
         r.setPatternSyntax(QRegExp::Wildcard);   // the "mimetype" can be "image/*"
 
         if (!mimeTypes.isEmpty()) {
             QStringList::ConstIterator it = supported.begin();
 
             for (; it != supported.end(); ++it) {
                 r.setPattern(*it);
 
                 QStringList result = mimeTypes.filter(r);
                 if (!result.isEmpty()) {   // matches! -> we want previews
                     return true;
                 }
             }
         }
 
         if (!nameFilter.isEmpty()) {
             // find the mimetypes of all the filter-patterns
             QStringList::const_iterator it1 = nameFilter.begin();
             for (; it1 != nameFilter.end(); ++it1) {
                 if ((*it1) == QLatin1String("*")) {
                     return true;
                 }
 
                 QMimeType mt = db.mimeTypeForFile(*it1, QMimeDatabase::MatchExtension /*fast mode, no file contents exist*/);
                 if (!mt.isValid()) {
                     continue;
                 }
                 QString mime = mt.name();
 
                 // the "mimetypes" we get from the PreviewJob can be "image/*"
                 // so we need to check in wildcard mode
                 QStringList::ConstIterator it2 = supported.begin();
                 for (; it2 != supported.end(); ++it2) {
                     r.setPattern(*it2);
                     if (r.indexIn(mime) != -1) {
                         return true;
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 QAbstractItemView *KDirOperator::createView(QWidget *parent, KFile::FileView viewKind)
 {
     QAbstractItemView *itemView = nullptr;
     if (KFile::isDetailView(viewKind) || KFile::isTreeView(viewKind) || KFile::isDetailTreeView(viewKind)) {
         KDirOperatorDetailView *detailView = new KDirOperatorDetailView(parent);
         detailView->setViewMode(viewKind);
         itemView = detailView;
     } else {
         itemView = new KDirOperatorIconView(this, parent);
     }
 
     return itemView;
 }
 
 void KDirOperator::setAcceptDrops(bool b)
 {
     // TODO:
     //if (d->fileView)
     //   d->fileView->widget()->setAcceptDrops(b);
     QWidget::setAcceptDrops(b);
 }
 
 void KDirOperator::setDropOptions(int options)
 {
     d->dropOptions = options;
     // TODO:
     //if (d->fileView)
     //   d->fileView->setDropOptions(options);
 }
 
 void KDirOperator::setView(KFile::FileView viewKind)
 {
     bool preview = (KFile::isPreviewInfo(viewKind) || KFile::isPreviewContents(viewKind));
 
     if (viewKind == KFile::Default) {
         if (KFile::isDetailView((KFile::FileView)d->defaultView)) {
             viewKind = KFile::Detail;
         } else if (KFile::isTreeView((KFile::FileView)d->defaultView)) {
             viewKind = KFile::Tree;
         } else if (KFile::isDetailTreeView((KFile::FileView)d->defaultView)) {
             viewKind = KFile::DetailTree;
         } else {
             viewKind = KFile::Simple;
         }
 
         const KFile::FileView defaultViewKind = static_cast<KFile::FileView>(d->defaultView);
         preview = (KFile::isPreviewInfo(defaultViewKind) || KFile::isPreviewContents(defaultViewKind))
                   && d->actionCollection->action(QStringLiteral("preview"))->isEnabled();
     }
 
     d->viewKind = static_cast<int>(viewKind);
     viewKind = static_cast<KFile::FileView>(d->viewKind);
 
     QAbstractItemView *newView = createView(this, viewKind);
     setView(newView);
 
     d->_k_togglePreview(preview);
 }
 
 KFile::FileView KDirOperator::viewMode() const
 {
     return static_cast<KFile::FileView>(d->viewKind);
 }
 
 QAbstractItemView *KDirOperator::view() const
 {
     return d->itemView;
 }
 
 KFile::Modes KDirOperator::mode() const
 {
     return d->mode;
 }
 
 void KDirOperator::setMode(KFile::Modes mode)
 {
     if (d->mode == mode) {
         return;
     }
 
     d->mode = mode;
 
     d->dirLister->setDirOnlyMode(dirOnlyMode());
 
     // reset the view with the different mode
     if (d->itemView != nullptr) {
         setView(static_cast<KFile::FileView>(d->viewKind));
     }
 }
 
 void KDirOperator::setView(QAbstractItemView *view)
 {
     if (view == d->itemView) {
         return;
     }
 
     // TODO: do a real timer and restart it after that
     d->pendingMimeTypes.clear();
     const bool listDir = (d->itemView == nullptr);
 
     if (d->mode & KFile::Files) {
         view->setSelectionMode(QAbstractItemView::ExtendedSelection);
     } else {
         view->setSelectionMode(QAbstractItemView::SingleSelection);
     }
 
     QItemSelectionModel *selectionModel = nullptr;
     if ((d->itemView != nullptr) && d->itemView->selectionModel()->hasSelection()) {
         // remember the selection of the current item view and apply this selection
         // to the new view later
         const QItemSelection selection = d->itemView->selectionModel()->selection();
         selectionModel = new QItemSelectionModel(d->proxyModel, this);
         selectionModel->select(selection, QItemSelectionModel::Select);
     }
 
     setFocusProxy(nullptr);
     delete d->itemView;
     d->itemView = view;
     d->itemView->setModel(d->proxyModel);
     setFocusProxy(d->itemView);
 
     view->viewport()->installEventFilter(this);
 
     KFileItemDelegate *delegate = new KFileItemDelegate(d->itemView);
     d->itemView->setItemDelegate(delegate);
     d->itemView->viewport()->setAttribute(Qt::WA_Hover);
     d->itemView->setContextMenuPolicy(Qt::CustomContextMenu);
     d->itemView->setMouseTracking(true);
     //d->itemView->setDropOptions(d->dropOptions);
 
     // first push our settings to the view, then listen for changes from the view
     QTreeView *treeView = qobject_cast<QTreeView *>(d->itemView);
     if (treeView) {
         QHeaderView *headerView = treeView->header();
         headerView->setSortIndicator(d->sortColumn(), d->sortOrder());
         connect(headerView, SIGNAL(sortIndicatorChanged(int,Qt::SortOrder)),
                 this, SLOT(_k_synchronizeSortingState(int,Qt::SortOrder)));
     }
 
     connect(d->itemView, SIGNAL(activated(QModelIndex)),
             this, SLOT(_k_slotActivated(QModelIndex)));
     connect(d->itemView, SIGNAL(customContextMenuRequested(QPoint)),
             this, SLOT(_k_openContextMenu(QPoint)));
     connect(d->itemView, SIGNAL(entered(QModelIndex)),
             this, SLOT(_k_triggerPreview(QModelIndex)));
 
     updateViewActions();
     d->splitter->insertWidget(0, d->itemView);
 
     d->splitter->resize(size());
     d->itemView->show();
 
     if (listDir) {
         QApplication::setOverrideCursor(Qt::WaitCursor);
         d->openUrl(d->currUrl);
     }
 
     if (selectionModel != nullptr) {
         d->itemView->setSelectionModel(selectionModel);
         QMetaObject::invokeMethod(this, "_k_assureVisibleSelection", Qt::QueuedConnection);
     }
 
     connect(d->itemView->selectionModel(),
             SIGNAL(currentChanged(QModelIndex,QModelIndex)),
             this, SLOT(_k_triggerPreview(QModelIndex)));
     connect(d->itemView->selectionModel(),
             SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
             this, SLOT(_k_slotSelectionChanged()));
 
     // if we cannot cast it to a QListView, disable the "Icon Position" menu. Note that this check
     // needs to be done here, and not in createView, since we can be set an external view
     d->decorationMenu->setEnabled(qobject_cast<QListView *>(d->itemView));
 
     d->shouldFetchForItems = qobject_cast<QTreeView *>(view);
     if (d->shouldFetchForItems) {
         connect(d->dirModel, SIGNAL(expand(QModelIndex)), this, SLOT(_k_slotExpandToUrl(QModelIndex)));
     } else {
         d->itemsToBeSetAsCurrent.clear();
     }
 
     const bool previewForcedToTrue = d->inlinePreviewState == Private::ForcedToTrue;
     const bool previewShown = d->inlinePreviewState == Private::NotForced ? d->showPreviews : previewForcedToTrue;
     d->previewGenerator = new KFilePreviewGenerator(d->itemView);
     const int maxSize = KIconLoader::SizeEnormous - KIconLoader::SizeSmall;
     const int val = (maxSize * d->iconsZoom / 100) + KIconLoader::SizeSmall;
     d->itemView->setIconSize(previewForcedToTrue ? QSize(KIconLoader::SizeHuge, KIconLoader::SizeHuge) : QSize(val, val));
     d->previewGenerator->setPreviewShown(previewShown);
     d->actionCollection->action(QStringLiteral("inline preview"))->setChecked(previewShown);
 
     // ensure we change everything needed
     d->_k_slotChangeDecorationPosition();
 
     emit viewChanged(view);
 
     const int zoom = previewForcedToTrue ? (KIconLoader::SizeHuge - KIconLoader::SizeSmall + 1) * 100 / maxSize : d->iconSizeForViewType(view);
 
     // this will make d->iconsZoom be updated, since setIconsZoom slot will be called
     emit currentIconSizeChanged(zoom);
 }
 
 void KDirOperator::setDirLister(KDirLister *lister)
 {
     if (lister == d->dirLister) { // sanity check
         return;
     }
 
     delete d->dirModel;
     d->dirModel = nullptr;
 
     delete d->proxyModel;
     d->proxyModel = nullptr;
 
     //delete d->dirLister; // deleted by KDirModel already, which took ownership
     d->dirLister = lister;
 
     d->dirModel = new KDirModel();
     d->dirModel->setDirLister(d->dirLister);
     d->dirModel->setDropsAllowed(KDirModel::DropOnDirectory);
 
     d->shouldFetchForItems = qobject_cast<QTreeView *>(d->itemView);
     if (d->shouldFetchForItems) {
         connect(d->dirModel, SIGNAL(expand(QModelIndex)), this, SLOT(_k_slotExpandToUrl(QModelIndex)));
     } else {
         d->itemsToBeSetAsCurrent.clear();
     }
 
     d->proxyModel = new KDirSortFilterProxyModel(this);
     d->proxyModel->setSourceModel(d->dirModel);
 
     d->dirLister->setDelayedMimeTypes(true);
 
     QWidget *mainWidget = topLevelWidget();
     d->dirLister->setMainWindow(mainWidget);
     // qDebug() << "mainWidget=" << mainWidget;
 
     connect(d->dirLister, SIGNAL(percent(int)),
             SLOT(_k_slotProgress(int)));
     connect(d->dirLister, SIGNAL(started(QUrl)), SLOT(_k_slotStarted()));
     connect(d->dirLister, SIGNAL(completed()), SLOT(_k_slotIOFinished()));
     connect(d->dirLister, SIGNAL(canceled()), SLOT(_k_slotCanceled()));
     connect(d->dirLister, SIGNAL(redirection(QUrl)),
             SLOT(_k_slotRedirected(QUrl)));
     connect(d->dirLister, SIGNAL(newItems(KFileItemList)), SLOT(_k_slotItemsChanged()));
     connect(d->dirLister, SIGNAL(itemsDeleted(KFileItemList)), SLOT(_k_slotItemsChanged()));
     connect(d->dirLister, SIGNAL(itemsFilteredByMime(KFileItemList)), SLOT(_k_slotItemsChanged()));
     connect(d->dirLister, SIGNAL(clear()), SLOT(_k_slotItemsChanged()));
 }
 
 void KDirOperator::selectDir(const KFileItem &item)
 {
     setUrl(item.targetUrl(), true);
 }
 
 void KDirOperator::selectFile(const KFileItem &item)
 {
     QApplication::restoreOverrideCursor();
 
     emit fileSelected(item);
 }
 
 void KDirOperator::highlightFile(const KFileItem &item)
 {
     if ((d->preview != nullptr && !d->preview->isHidden()) && !item.isNull()) {
         d->preview->showPreview(item.url());
     }
 
     emit fileHighlighted(item);
 }
 
 void KDirOperator::setCurrentItem(const QUrl &url)
 {
     // qDebug();
 
     KFileItem item = d->dirLister->findByUrl(url);
     if (d->shouldFetchForItems && item.isNull()) {
         d->itemsToBeSetAsCurrent << url;
         d->dirModel->expandToUrl(url);
         return;
     }
 
     setCurrentItem(item);
 }
 
 void KDirOperator::setCurrentItem(const KFileItem &item)
 {
     // qDebug();
 
     if (!d->itemView) {
         return;
     }
 
     QItemSelectionModel *selModel = d->itemView->selectionModel();
     if (selModel) {
         selModel->clear();
         if (!item.isNull()) {
             const QModelIndex dirIndex = d->dirModel->indexForItem(item);
             const QModelIndex proxyIndex = d->proxyModel->mapFromSource(dirIndex);
             selModel->setCurrentIndex(proxyIndex, QItemSelectionModel::Select);
         }
     }
 }
 
 void KDirOperator::setCurrentItems(const QList<QUrl> &urls)
 {
     // qDebug();
 
     if (!d->itemView) {
         return;
     }
 
     KFileItemList itemList;
     foreach (const QUrl &url, urls) {
         KFileItem item = d->dirLister->findByUrl(url);
         if (d->shouldFetchForItems && item.isNull()) {
             d->itemsToBeSetAsCurrent << url;
             d->dirModel->expandToUrl(url);
             continue;
         }
         itemList << item;
     }
 
     setCurrentItems(itemList);
 }
 
 void KDirOperator::setCurrentItems(const KFileItemList &items)
 {
     // qDebug();
 
     if (d->itemView == nullptr) {
         return;
     }
 
     QItemSelectionModel *selModel = d->itemView->selectionModel();
     if (selModel) {
         selModel->clear();
         QModelIndex proxyIndex;
         foreach (const KFileItem &item, items) {
             if (!item.isNull()) {
                 const QModelIndex dirIndex = d->dirModel->indexForItem(item);
                 proxyIndex = d->proxyModel->mapFromSource(dirIndex);
                 selModel->select(proxyIndex, QItemSelectionModel::Select);
             }
         }
         if (proxyIndex.isValid()) {
             selModel->setCurrentIndex(proxyIndex, QItemSelectionModel::NoUpdate);
         }
     }
 }
 
 QString KDirOperator::makeCompletion(const QString &string)
 {
     if (string.isEmpty()) {
         d->itemView->selectionModel()->clear();
         return QString();
     }
 
     prepareCompletionObjects();
     return d->completion.makeCompletion(string);
 }
 
 QString KDirOperator::makeDirCompletion(const QString &string)
 {
     if (string.isEmpty()) {
         d->itemView->selectionModel()->clear();
         return QString();
     }
 
     prepareCompletionObjects();
     return d->dirCompletion.makeCompletion(string);
 }
 
 void KDirOperator::prepareCompletionObjects()
 {
     if (d->itemView == nullptr) {
         return;
     }
 
     if (d->completeListDirty) {   // create the list of all possible completions
         const KFileItemList itemList = d->dirLister->items();
         foreach (const KFileItem &item, itemList) {
             d->completion.addItem(item.name());
             if (item.isDir()) {
                 d->dirCompletion.addItem(item.name());
             }
         }
         d->completeListDirty = false;
     }
 }
 
 void KDirOperator::slotCompletionMatch(const QString &match)
 {
     QUrl url(match);
     if (url.isRelative()) {
         url = d->currUrl.resolved(url);
     }
     setCurrentItem(url);
     emit completion(match);
 }
 
 void KDirOperator::setupActions()
 {
     d->actionCollection = new KActionCollection(this);
     d->actionCollection->setObjectName(QStringLiteral("KDirOperator::actionCollection"));
 
     d->actionMenu = new KActionMenu(i18n("Menu"), this);
     d->actionCollection->addAction(QStringLiteral("popupMenu"), d->actionMenu);
 
     QAction *upAction = d->actionCollection->addAction(KStandardAction::Up, QStringLiteral("up"), this, SLOT(cdUp()));
     upAction->setText(i18n("Parent Folder"));
 
     d->actionCollection->addAction(KStandardAction::Back, QStringLiteral("back"), this, SLOT(back()));
 
     d->actionCollection->addAction(KStandardAction::Forward, QStringLiteral("forward"), this, SLOT(forward()));
 
     QAction *homeAction = d->actionCollection->addAction(KStandardAction::Home, QStringLiteral("home"), this, SLOT(home()));
     homeAction->setText(i18n("Home Folder"));
 
     QAction *reloadAction = d->actionCollection->addAction(KStandardAction::Redisplay, QStringLiteral("reload"), this, SLOT(rereadDir()));
     reloadAction->setText(i18n("Reload"));
     reloadAction->setShortcuts(KStandardShortcut::shortcut(KStandardShortcut::Reload));
 
     QAction *mkdirAction = new QAction(i18n("New Folder..."), this);
     d->actionCollection->addAction(QStringLiteral("mkdir"), mkdirAction);
     mkdirAction->setIcon(QIcon::fromTheme(QStringLiteral("folder-new")));
     connect(mkdirAction, SIGNAL(triggered(bool)), this, SLOT(mkdir()));
 
     QAction *trash = new QAction(i18n("Move to Trash"), this);
     d->actionCollection->addAction(QStringLiteral("trash"), trash);
     trash->setIcon(QIcon::fromTheme(QStringLiteral("user-trash")));
     trash->setShortcut(Qt::Key_Delete);
     connect(trash, SIGNAL(triggered(bool)), SLOT(trashSelected()));
 
     QAction *action = new QAction(i18n("Delete"), this);
     d->actionCollection->addAction(QStringLiteral("delete"), action);
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
     action->setShortcut(Qt::SHIFT + Qt::Key_Delete);
     connect(action, SIGNAL(triggered(bool)), this, SLOT(deleteSelected()));
 
     // the sort menu actions
     KActionMenu *sortMenu = new KActionMenu(i18n("Sorting"), this);
     d->actionCollection->addAction(QStringLiteral("sorting menu"),  sortMenu);
 
     KToggleAction *byNameAction = new KToggleAction(i18n("By Name"), this);
     d->actionCollection->addAction(QStringLiteral("by name"), byNameAction);
     connect(byNameAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortByName()));
 
     KToggleAction *bySizeAction = new KToggleAction(i18n("By Size"), this);
     d->actionCollection->addAction(QStringLiteral("by size"), bySizeAction);
     connect(bySizeAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortBySize()));
 
     KToggleAction *byDateAction = new KToggleAction(i18n("By Date"), this);
     d->actionCollection->addAction(QStringLiteral("by date"), byDateAction);
     connect(byDateAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortByDate()));
 
     KToggleAction *byTypeAction = new KToggleAction(i18n("By Type"), this);
     d->actionCollection->addAction(QStringLiteral("by type"), byTypeAction);
     connect(byTypeAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortByType()));
 
     KToggleAction *descendingAction = new KToggleAction(i18n("Descending"), this);
     d->actionCollection->addAction(QStringLiteral("descending"), descendingAction);
     connect(descendingAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotSortReversed(bool)));
 
     KToggleAction *dirsFirstAction = new KToggleAction(i18n("Folders First"), this);
     d->actionCollection->addAction(QStringLiteral("dirs first"), dirsFirstAction);
     connect(dirsFirstAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotToggleDirsFirst()));
 
     QActionGroup *sortGroup = new QActionGroup(this);
     byNameAction->setActionGroup(sortGroup);
     bySizeAction->setActionGroup(sortGroup);
     byDateAction->setActionGroup(sortGroup);
     byTypeAction->setActionGroup(sortGroup);
 
     d->decorationMenu = new KActionMenu(i18n("Icon Position"), this);
     d->actionCollection->addAction(QStringLiteral("decoration menu"), d->decorationMenu);
 
     d->leftAction = new KToggleAction(i18n("Next to File Name"), this);
     d->actionCollection->addAction(QStringLiteral("decorationAtLeft"), d->leftAction);
     connect(d->leftAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotChangeDecorationPosition()));
 
     KToggleAction *topAction = new KToggleAction(i18n("Above File Name"), this);
     d->actionCollection->addAction(QStringLiteral("decorationAtTop"), topAction);
     connect(topAction, SIGNAL(triggered(bool)), this, SLOT(_k_slotChangeDecorationPosition()));
 
     d->decorationMenu->addAction(d->leftAction);
     d->decorationMenu->addAction(topAction);
 
     QActionGroup *decorationGroup = new QActionGroup(this);
     d->leftAction->setActionGroup(decorationGroup);
     topAction->setActionGroup(decorationGroup);
 
     KToggleAction *shortAction = new KToggleAction(i18n("Short View"), this);
     d->actionCollection->addAction(QStringLiteral("short view"),  shortAction);
     shortAction->setIcon(QIcon::fromTheme(QStringLiteral("view-list-icons")));
     connect(shortAction, SIGNAL(triggered()), SLOT(_k_slotSimpleView()));
 
     KToggleAction *detailedAction = new KToggleAction(i18n("Detailed View"), this);
     d->actionCollection->addAction(QStringLiteral("detailed view"), detailedAction);
     detailedAction->setIcon(QIcon::fromTheme(QStringLiteral("view-list-details")));
     connect(detailedAction, SIGNAL(triggered()), SLOT(_k_slotDetailedView()));
 
     KToggleAction *treeAction = new KToggleAction(i18n("Tree View"), this);
     d->actionCollection->addAction(QStringLiteral("tree view"), treeAction);
     treeAction->setIcon(QIcon::fromTheme(QStringLiteral("view-list-tree")));
     connect(treeAction, SIGNAL(triggered()), SLOT(_k_slotTreeView()));
 
     KToggleAction *detailedTreeAction = new KToggleAction(i18n("Detailed Tree View"), this);
     d->actionCollection->addAction(QStringLiteral("detailed tree view"), detailedTreeAction);
     detailedTreeAction->setIcon(QIcon::fromTheme(QStringLiteral("view-list-tree")));
     connect(detailedTreeAction, SIGNAL(triggered()), SLOT(_k_slotDetailedTreeView()));
 
     QActionGroup *viewGroup = new QActionGroup(this);
     shortAction->setActionGroup(viewGroup);
     detailedAction->setActionGroup(viewGroup);
     treeAction->setActionGroup(viewGroup);
     detailedTreeAction->setActionGroup(viewGroup);
 
     KToggleAction *showHiddenAction = new KToggleAction(i18n("Show Hidden Files"), this);
     d->actionCollection->addAction(QStringLiteral("show hidden"), showHiddenAction);
     showHiddenAction->setShortcuts({Qt::ALT + Qt::Key_Period, Qt::CTRL + Qt::Key_H, Qt::Key_F8});
     connect(showHiddenAction, SIGNAL(toggled(bool)), SLOT(_k_slotToggleHidden(bool)));
 
     KToggleAction *previewAction = new KToggleAction(i18n("Show Aside Preview"), this);
     d->actionCollection->addAction(QStringLiteral("preview"), previewAction);
     previewAction->setShortcut(Qt::Key_F11);
     connect(previewAction, SIGNAL(toggled(bool)),
             SLOT(_k_togglePreview(bool)));
 
     KToggleAction *inlinePreview = new KToggleAction(QIcon::fromTheme(QStringLiteral("view-preview")),
             i18n("Show Preview"), this);
     d->actionCollection->addAction(QStringLiteral("inline preview"), inlinePreview);
     inlinePreview->setShortcut(Qt::Key_F12);
     connect(inlinePreview, SIGNAL(toggled(bool)), SLOT(_k_toggleInlinePreviews(bool)));
 
     QAction *fileManager = new QAction(i18n("Open Containing Folder"), this);
     d->actionCollection->addAction(QStringLiteral("file manager"), fileManager);
     fileManager->setIcon(QIcon::fromTheme(QStringLiteral("system-file-manager")));
     connect(fileManager, SIGNAL(triggered()), SLOT(_k_slotOpenFileManager()));
 
     action = new QAction(i18n("Properties"), this);
     d->actionCollection->addAction(QStringLiteral("properties"), action);
     action->setIcon(QIcon::fromTheme(QStringLiteral("document-properties")));
     action->setShortcut(Qt::ALT + Qt::Key_Return);
     connect(action, SIGNAL(triggered(bool)), this, SLOT(_k_slotProperties()));
 
     // the view menu actions
     KActionMenu *viewMenu = new KActionMenu(i18n("&View"), this);
     d->actionCollection->addAction(QStringLiteral("view menu"), viewMenu);
     viewMenu->addAction(shortAction);
     viewMenu->addAction(detailedAction);
     // Comment following lines to hide the extra two modes
     viewMenu->addAction(treeAction);
     viewMenu->addAction(detailedTreeAction);
     // TODO: QAbstractItemView does not offer an action collection. Provide
     // an interface to add a custom action collection.
 
     d->newFileMenu = new KNewFileMenu(d->actionCollection, QStringLiteral("new"), this);
     connect(d->newFileMenu, SIGNAL(directoryCreated(QUrl)), this, SLOT(_k_slotDirectoryCreated(QUrl)));
 
     d->actionCollection->addAssociatedWidget(this);
     foreach (QAction *action, d->actionCollection->actions()) {
         action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     }
 }
 
 void KDirOperator::setupMenu()
 {
     setupMenu(SortActions | ViewActions | FileActions);
 }
 
 void KDirOperator::setupMenu(int whichActions)
 {
     // first fill the submenus (sort and view)
     KActionMenu *sortMenu = static_cast<KActionMenu *>(d->actionCollection->action(QStringLiteral("sorting menu")));
     sortMenu->menu()->clear();
     sortMenu->addAction(d->actionCollection->action(QStringLiteral("by name")));
     sortMenu->addAction(d->actionCollection->action(QStringLiteral("by size")));
     sortMenu->addAction(d->actionCollection->action(QStringLiteral("by date")));
     sortMenu->addAction(d->actionCollection->action(QStringLiteral("by type")));
     sortMenu->addSeparator();
     sortMenu->addAction(d->actionCollection->action(QStringLiteral("descending")));
     sortMenu->addAction(d->actionCollection->action(QStringLiteral("dirs first")));
 
     // now plug everything into the popupmenu
     d->actionMenu->menu()->clear();
     if (whichActions & NavActions) {
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("up")));
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("back")));
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("forward")));
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("home")));
         d->actionMenu->addSeparator();
     }
 
     if (whichActions & FileActions) {
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("new")));
         if (d->currUrl.isLocalFile() && !(QApplication::keyboardModifiers() & Qt::ShiftModifier)) {
             d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("trash")));
         }
         KConfigGroup cg(KSharedConfig::openConfig(), QStringLiteral("KDE"));
         const bool del = !d->currUrl.isLocalFile() ||
                          (QApplication::keyboardModifiers() & Qt::ShiftModifier) ||
                          cg.readEntry("ShowDeleteCommand", false);
         if (del) {
             d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("delete")));
         }
         d->actionMenu->addSeparator();
     }
 
     if (whichActions & SortActions) {
         d->actionMenu->addAction(sortMenu);
         if (!(whichActions & ViewActions)) {
             d->actionMenu->addSeparator();
         }
     }
 
     if (whichActions & ViewActions) {
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("view menu")));
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("reload")));
         d->actionMenu->addSeparator();
     }
 
     if (whichActions & FileActions) {
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("file manager")));
         d->actionMenu->addAction(d->actionCollection->action(QStringLiteral("properties")));
     }
 }
 
 void KDirOperator::updateSortActions()
 {
     if (KFile::isSortByName(d->sorting)) {
         d->actionCollection->action(QStringLiteral("by name"))->setChecked(true);
     } else if (KFile::isSortByDate(d->sorting)) {
         d->actionCollection->action(QStringLiteral("by date"))->setChecked(true);
     } else if (KFile::isSortBySize(d->sorting)) {
         d->actionCollection->action(QStringLiteral("by size"))->setChecked(true);
     } else if (KFile::isSortByType(d->sorting)) {
         d->actionCollection->action(QStringLiteral("by type"))->setChecked(true);
     }
     d->actionCollection->action(QStringLiteral("descending"))->setChecked(d->sorting & QDir::Reversed);
     d->actionCollection->action(QStringLiteral("dirs first"))->setChecked(d->sorting & QDir::DirsFirst);
 }
 
 void KDirOperator::updateViewActions()
 {
     KFile::FileView fv = static_cast<KFile::FileView>(d->viewKind);
 
     //QAction *separateDirs = d->actionCollection->action("separate dirs");
     //separateDirs->setChecked(KFile::isSeparateDirs(fv) &&
     //                         separateDirs->isEnabled());
 
     d->actionCollection->action(QStringLiteral("short view"))->setChecked(KFile::isSimpleView(fv));
     d->actionCollection->action(QStringLiteral("detailed view"))->setChecked(KFile::isDetailView(fv));
     d->actionCollection->action(QStringLiteral("tree view"))->setChecked(KFile::isTreeView(fv));
     d->actionCollection->action(QStringLiteral("detailed tree view"))->setChecked(KFile::isDetailTreeView(fv));
 }
 
 void KDirOperator::readConfig(const KConfigGroup &configGroup)
 {
     d->defaultView = 0;
     QString viewStyle = configGroup.readEntry("View Style", "Simple");
     if (viewStyle == QLatin1String("Detail")) {
         d->defaultView |= KFile::Detail;
     } else if (viewStyle == QLatin1String("Tree")) {
         d->defaultView |= KFile::Tree;
     } else if (viewStyle == QLatin1String("DetailTree")) {
         d->defaultView |= KFile::DetailTree;
     } else {
         d->defaultView |= KFile::Simple;
     }
     //if (configGroup.readEntry(QLatin1String("Separate Directories"),
     //                          DefaultMixDirsAndFiles)) {
     //    d->defaultView |= KFile::SeparateDirs;
     //}
     if (configGroup.readEntry(QStringLiteral("Show Preview"), false)) {
         d->defaultView |= KFile::PreviewContents;
     }
 
     d->previewWidth = configGroup.readEntry(QStringLiteral("Preview Width"), 100);
 
     if (configGroup.readEntry(QStringLiteral("Show hidden files"),
                               DefaultShowHidden)) {
         d->actionCollection->action(QStringLiteral("show hidden"))->setChecked(true);
         d->dirLister->setShowingDotFiles(true);
     }
 
     QDir::SortFlags sorting = QDir::Name;
     if (configGroup.readEntry(QStringLiteral("Sort directories first"),
                               DefaultDirsFirst)) {
         sorting |= QDir::DirsFirst;
     }
     QString name = QStringLiteral("Name");
     QString sortBy = configGroup.readEntry(QStringLiteral("Sort by"), name);
     if (sortBy == name) {
         sorting |= QDir::Name;
     } else if (sortBy == QLatin1String("Size")) {
         sorting |= QDir::Size;
     } else if (sortBy == QLatin1String("Date")) {
         sorting |= QDir::Time;
     } else if (sortBy == QLatin1String("Type")) {
         sorting |= QDir::Type;
     }
     if (configGroup.readEntry(QStringLiteral("Sort reversed"), DefaultSortReversed)) {
         sorting |= QDir::Reversed;
     }
     d->updateSorting(sorting);
 
     if (d->inlinePreviewState == Private::NotForced) {
         d->showPreviews = configGroup.readEntry(QStringLiteral("Show Inline Previews"), true);
         d->showPreviewsConfigEntry = d->showPreviews;
     }
     QStyleOptionViewItem::Position pos = (QStyleOptionViewItem::Position) configGroup.readEntry(QStringLiteral("Decoration position"), (int) QStyleOptionViewItem::Left);
     setDecorationPosition(pos);
 }
 
 void KDirOperator::writeConfig(KConfigGroup &configGroup)
 {
     QString sortBy = QStringLiteral("Name");
     if (KFile::isSortBySize(d->sorting)) {
         sortBy = QStringLiteral("Size");
     } else if (KFile::isSortByDate(d->sorting)) {
         sortBy = QStringLiteral("Date");
     } else if (KFile::isSortByType(d->sorting)) {
         sortBy = QStringLiteral("Type");
     }
 
     configGroup.writeEntry(QStringLiteral("Sort by"), sortBy);
 
     configGroup.writeEntry(QStringLiteral("Sort reversed"),
                            d->actionCollection->action(QStringLiteral("descending"))->isChecked());
 
     configGroup.writeEntry(QStringLiteral("Sort directories first"),
                            d->actionCollection->action(QStringLiteral("dirs first"))->isChecked());
 
     // don't save the preview when an application specific preview is in use.
     bool appSpecificPreview = false;
     if (d->preview) {
         KFileMetaPreview *tmp = dynamic_cast<KFileMetaPreview *>(d->preview);
         appSpecificPreview = (tmp == nullptr);
     }
 
     if (!appSpecificPreview) {
         KToggleAction *previewAction = static_cast<KToggleAction *>(d->actionCollection->action(QStringLiteral("preview")));
         if (previewAction->isEnabled()) {
             bool hasPreview = previewAction->isChecked();
             configGroup.writeEntry(QStringLiteral("Show Preview"), hasPreview);
 
             if (hasPreview) {
                 // remember the width of the preview widget
                 QList<int> sizes = d->splitter->sizes();
                 Q_ASSERT(sizes.count() == 2);
                 configGroup.writeEntry(QStringLiteral("Preview Width"), sizes[1]);
             }
         }
     }
 
     configGroup.writeEntry(QStringLiteral("Show hidden files"),
                            d->actionCollection->action(QStringLiteral("show hidden"))->isChecked());
 
     KFile::FileView fv = static_cast<KFile::FileView>(d->viewKind);
     QString style;
     if (KFile::isDetailView(fv)) {
         style = QStringLiteral("Detail");
     } else if (KFile::isSimpleView(fv)) {
         style = QStringLiteral("Simple");
     } else if (KFile::isTreeView(fv)) {
         style = QStringLiteral("Tree");
     } else if (KFile::isDetailTreeView(fv)) {
         style = QStringLiteral("DetailTree");
     }
     configGroup.writeEntry(QStringLiteral("View Style"), style);
 
     if (d->inlinePreviewState == Private::NotForced) {
         configGroup.writeEntry(QStringLiteral("Show Inline Previews"), d->showPreviewsConfigEntry);
         if (qobject_cast<QListView *>(d->itemView)) {
             configGroup.writeEntry(QStringLiteral("listViewIconSize"), d->iconsZoom);
         } else {
             configGroup.writeEntry(QStringLiteral("detailedViewIconSize"), d->iconsZoom);
         }
     }
 
     configGroup.writeEntry(QStringLiteral("Decoration position"), (int) d->decorationPosition);
 }
 
 void KDirOperator::resizeEvent(QResizeEvent *)
 {
     // resize the splitter and assure that the width of
     // the preview widget is restored
     QList<int> sizes = d->splitter->sizes();
     const bool hasPreview = (sizes.count() == 2);
 
     d->splitter->resize(size());
     sizes = d->splitter->sizes();
 
     const bool restorePreviewWidth = hasPreview && (d->previewWidth != sizes[1]);
     if (restorePreviewWidth) {
         const int availableWidth = sizes[0] + sizes[1];
         sizes[0] = availableWidth - d->previewWidth;
         sizes[1] = d->previewWidth;
         d->splitter->setSizes(sizes);
     }
     if (hasPreview) {
         d->previewWidth = sizes[1];
     }
 
     if (d->progressBar->parent() == this) {
         // might be reparented into a statusbar
         d->progressBar->move(2, height() - d->progressBar->height() - 2);
     }
 
     d->updateListViewGrid();
 }
 
 void KDirOperator::setOnlyDoubleClickSelectsFiles(bool enable)
 {
     d->onlyDoubleClickSelectsFiles = enable;
     // TODO: port to QAbstractItemModel
     //if (d->itemView != 0) {
     //    d->itemView->setOnlyDoubleClickSelectsFiles(enable);
     //}
 }
 
 bool KDirOperator::onlyDoubleClickSelectsFiles() const
 {
     return d->onlyDoubleClickSelectsFiles;
 }
 
 void KDirOperator::Private::_k_slotStarted()
 {
     progressBar->setValue(0);
     // delay showing the progressbar for one second
     progressDelayTimer->setSingleShot(true);
     progressDelayTimer->start(1000);
 }
 
 void KDirOperator::Private::_k_slotShowProgress()
 {
     progressBar->raise();
     progressBar->show();
     QApplication::flush();
 }
 
 void KDirOperator::Private::_k_slotProgress(int percent)
 {
     progressBar->setValue(percent);
     // we have to redraw this as fast as possible
     if (progressBar->isVisible()) {
         QApplication::flush();
     }
 }
 
 void KDirOperator::Private::_k_slotIOFinished()
 {
     progressDelayTimer->stop();
     _k_slotProgress(100);
     progressBar->hide();
     emit parent->finishedLoading();
     parent->resetCursor();
 
     if (preview) {
         preview->clearPreview();
     }
 }
 
 void KDirOperator::Private::_k_slotCanceled()
 {
     emit parent->finishedLoading();
     parent->resetCursor();
 }
 
 QProgressBar *KDirOperator::progressBar() const
 {
     return d->progressBar;
 }
 
 void KDirOperator::clearHistory()
 {
     qDeleteAll(d->backStack);
     d->backStack.clear();
     d->actionCollection->action(QStringLiteral("back"))->setEnabled(false);
 
     qDeleteAll(d->forwardStack);
     d->forwardStack.clear();
     d->actionCollection->action(QStringLiteral("forward"))->setEnabled(false);
 }
 
 void KDirOperator::setEnableDirHighlighting(bool enable)
 {
     d->dirHighlighting = enable;
 }
 
 bool KDirOperator::dirHighlighting() const
 {
     return d->dirHighlighting;
 }
 
 bool KDirOperator::dirOnlyMode() const
 {
     return dirOnlyMode(d->mode);
 }
 
 bool KDirOperator::dirOnlyMode(uint mode)
 {
     return ((mode & KFile::Directory) &&
             (mode & (KFile::File | KFile::Files)) == 0);
 }
 
 void KDirOperator::Private::_k_slotProperties()
 {
     if (itemView == nullptr) {
         return;
     }
 
     const KFileItemList list = parent->selectedItems();
     if (!list.isEmpty()) {
         KPropertiesDialog dialog(list, parent);
         dialog.exec();
     }
 }
 
 void KDirOperator::Private::_k_slotActivated(const QModelIndex &index)
 {
     const QModelIndex dirIndex = proxyModel->mapToSource(index);
     KFileItem item = dirModel->itemForIndex(dirIndex);
 
     const Qt::KeyboardModifiers modifiers = QApplication::keyboardModifiers();
     if (item.isNull() || (modifiers & Qt::ShiftModifier) || (modifiers & Qt::ControlModifier)) {
         return;
     }
 
     if (item.isDir()) {
         parent->selectDir(item);
     } else {
         parent->selectFile(item);
     }
 }
 
 void KDirOperator::Private::_k_slotSelectionChanged()
 {
     if (itemView == nullptr) {
         return;
     }
 
     // In the multiselection mode each selection change is indicated by
     // emitting a null item. Also when the selection has been cleared, a
     // null item must be emitted.
     const bool multiSelectionMode = (itemView->selectionMode() == QAbstractItemView::ExtendedSelection);
     const bool hasSelection = itemView->selectionModel()->hasSelection();
     if (multiSelectionMode || !hasSelection) {
         KFileItem nullItem;
         parent->highlightFile(nullItem);
     } else {
-        KFileItem selectedItem = parent->selectedItems().first();
+        const KFileItem selectedItem = parent->selectedItems().constFirst();
         parent->highlightFile(selectedItem);
     }
 }
 
 void KDirOperator::Private::_k_openContextMenu(const QPoint &pos)
 {
     const QModelIndex proxyIndex = itemView->indexAt(pos);
     const QModelIndex dirIndex = proxyModel->mapToSource(proxyIndex);
     KFileItem item = dirModel->itemForIndex(dirIndex);
 
     if (item.isNull()) {
         return;
     }
 
     parent->activatedMenu(item, QCursor::pos());
 }
 
 void KDirOperator::Private::_k_triggerPreview(const QModelIndex &index)
 {
     if ((preview != nullptr && !preview->isHidden()) && index.isValid() && (index.column() == KDirModel::Name)) {
         const QModelIndex dirIndex = proxyModel->mapToSource(index);
         const KFileItem item = dirModel->itemForIndex(dirIndex);
 
         if (item.isNull()) {
             return;
         }
 
         if (!item.isDir()) {
             previewUrl = item.url();
             _k_showPreview();
         } else {
             preview->clearPreview();
         }
     }
 }
 
 void KDirOperator::Private::_k_showPreview()
 {
     if (preview != nullptr) {
         preview->showPreview(previewUrl);
     }
 }
 
 void KDirOperator::Private::_k_slotSplitterMoved(int, int)
 {
     const QList<int> sizes = splitter->sizes();
     if (sizes.count() == 2) {
         // remember the width of the preview widget (see KDirOperator::resizeEvent())
         previewWidth = sizes[1];
     }
 }
 
 void KDirOperator::Private::_k_assureVisibleSelection()
 {
     if (itemView == nullptr) {
         return;
     }
 
     QItemSelectionModel *selModel = itemView->selectionModel();
     if (selModel->hasSelection()) {
         const QModelIndex index = selModel->currentIndex();
         itemView->scrollTo(index, QAbstractItemView::EnsureVisible);
         _k_triggerPreview(index);
     }
 }
 
 void KDirOperator::Private::_k_synchronizeSortingState(int logicalIndex, Qt::SortOrder order)
 {
     QDir::SortFlags newSort = sorting & ~(QDirSortMask | QDir::Reversed);
 
     switch (logicalIndex) {
     case KDirModel::Name:
         newSort |= QDir::Name;
         break;
     case KDirModel::Size:
         newSort |= QDir::Size;
         break;
     case KDirModel::ModifiedTime:
         newSort |= QDir::Time;
         break;
     case KDirModel::Type:
         newSort |= QDir::Type;
         break;
     default:
         Q_ASSERT(false);
     }
 
     if (order == Qt::DescendingOrder) {
         newSort |= QDir::Reversed;
     }
 
     updateSorting(newSort);
 
     QMetaObject::invokeMethod(parent, "_k_assureVisibleSelection", Qt::QueuedConnection);
 }
 
 void KDirOperator::Private::_k_slotChangeDecorationPosition()
 {
     if (!itemView) {
         return;
     }
 
     QListView *view = qobject_cast<QListView *>(itemView);
 
     if (!view) {
         return;
     }
 
     const bool leftChecked = actionCollection->action(QStringLiteral("decorationAtLeft"))->isChecked();
 
     if (leftChecked) {
         decorationPosition = QStyleOptionViewItem::Left;
         view->setFlow(QListView::TopToBottom);
     } else {
         decorationPosition = QStyleOptionViewItem::Top;
         view->setFlow(QListView::LeftToRight);
     }
 
     updateListViewGrid();
 
     itemView->update();
 }
 
 void KDirOperator::Private::_k_slotExpandToUrl(const QModelIndex &index)
 {
     QTreeView *treeView = qobject_cast<QTreeView *>(itemView);
 
     if (!treeView) {
         return;
     }
 
     const KFileItem item = dirModel->itemForIndex(index);
 
     if (item.isNull()) {
         return;
     }
 
     if (!item.isDir()) {
         const QModelIndex proxyIndex = proxyModel->mapFromSource(index);
 
         QList<QUrl>::Iterator it = itemsToBeSetAsCurrent.begin();
         while (it != itemsToBeSetAsCurrent.end()) {
             const QUrl url = *it;
             if (url.matches(item.url(), QUrl::StripTrailingSlash) || url.isParentOf(item.url())) {
                 const KFileItem _item = dirLister->findByUrl(url);
                 if (!_item.isNull() && _item.isDir()) {
                     const QModelIndex _index = dirModel->indexForItem(_item);
                     const QModelIndex _proxyIndex = proxyModel->mapFromSource(_index);
                     treeView->expand(_proxyIndex);
 
                     // if we have expanded the last parent of this item, select it
                     if (item.url().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash) == url.adjusted(QUrl::StripTrailingSlash)) {
                         treeView->selectionModel()->select(proxyIndex, QItemSelectionModel::Select);
                     }
                 }
                 it = itemsToBeSetAsCurrent.erase(it);
             } else {
                 ++it;
             }
         }
     } else if (!itemsToBeSetAsCurrent.contains(item.url())) {
         itemsToBeSetAsCurrent << item.url();
     }
 }
 
 void KDirOperator::Private::_k_slotItemsChanged()
 {
     completeListDirty = true;
 }
 
 void KDirOperator::Private::updatePreviewActionState()
 {
     if (!itemView) {
         return;
     }
 
     const QFontMetrics metrics(itemView->viewport()->font());
 
     // hide icon previews when they are too small
     const bool iconSizeBigEnoughForPreview = itemView->iconSize().height() > metrics.height() * 2;
 
     KToggleAction *previewAction = qobject_cast<KToggleAction *>(actionCollection->action(QStringLiteral("inline preview")));
     previewAction->setEnabled(iconSizeBigEnoughForPreview);
 
     if (iconSizeBigEnoughForPreview) {
         previewAction->setToolTip(i18n("Show Preview"));
     } else {
         previewAction->setToolTip(i18n("Automatically disabled for small icon sizes; increase icon size to see previews"));
     }
 
     calledFromUpdatePreviewActionState = true;
     previewAction->setChecked(iconSizeBigEnoughForPreview && showPreviewsConfigEntry);
     calledFromUpdatePreviewActionState = false;
 }
 
 void KDirOperator::Private::updateListViewGrid()
 {
     if (!itemView) {
         return;
     }
 
     updatePreviewActionState();
 
     QListView *view = qobject_cast<QListView *>(itemView);
 
     if (!view) {
         return;
     }
 
     const bool leftChecked = actionCollection->action(QStringLiteral("decorationAtLeft"))->isChecked();
 
     if (leftChecked) {
         view->setGridSize(QSize());
         KFileItemDelegate *delegate = qobject_cast<KFileItemDelegate *>(view->itemDelegate());
         if (delegate) {
             delegate->setMaximumSize(QSize());
         }
     } else {
         const QFontMetrics metrics(itemView->viewport()->font());
 
         const int height = itemView->iconSize().height() + metrics.height() * 2.5;
         const int minWidth = qMax(height, metrics.height() * 5);
 
         const int scrollBarWidth = itemView->verticalScrollBar()->sizeHint().width();
 
         // Subtract 1 px to prevent flickering when resizing the window
         // For Oxygen a column is missing after showing the dialog without resizing it,
         // therefore subtract 4 more (scaled) pixels
         const int viewPortWidth = itemView->contentsRect().width() - scrollBarWidth - 1 - 4 * itemView->devicePixelRatioF();
         const int itemsInRow = qMax(1, viewPortWidth / minWidth);
         const int remainingWidth = viewPortWidth - (minWidth * itemsInRow);
         const int width = minWidth + (remainingWidth / itemsInRow);
 
         const QSize itemSize(width, height);
 
         view->setGridSize(itemSize);
         KFileItemDelegate *delegate = qobject_cast<KFileItemDelegate *>(view->itemDelegate());
         if (delegate) {
             delegate->setMaximumSize(itemSize);
         }
     }
 }
 
 int KDirOperator::Private::iconSizeForViewType(QAbstractItemView *itemView) const
 {
     if (!itemView || !configGroup) {
         return 0;
     }
 
     if (qobject_cast<QListView *>(itemView)) {
         return configGroup->readEntry("listViewIconSize", 0);
     } else {
         return configGroup->readEntry("detailedViewIconSize", 0);
     }
 }
 
 void KDirOperator::setViewConfig(KConfigGroup &configGroup)
 {
     delete d->configGroup;
     d->configGroup = new KConfigGroup(configGroup);
 }
 
 KConfigGroup *KDirOperator::viewConfigGroup() const
 {
     return d->configGroup;
 }
 
 void KDirOperator::setShowHiddenFiles(bool s)
 {
     d->actionCollection->action(QStringLiteral("show hidden"))->setChecked(s);
 }
 
 bool KDirOperator::showHiddenFiles() const
 {
     return d->actionCollection->action(QStringLiteral("show hidden"))->isChecked();
 }
 
 QStyleOptionViewItem::Position KDirOperator::decorationPosition() const
 {
     return d->decorationPosition;
 }
 
 void KDirOperator::setDecorationPosition(QStyleOptionViewItem::Position position)
 {
     d->decorationPosition = position;
     const bool decorationAtLeft = d->decorationPosition == QStyleOptionViewItem::Left;
     d->actionCollection->action(QStringLiteral("decorationAtLeft"))->setChecked(decorationAtLeft);
     d->actionCollection->action(QStringLiteral("decorationAtTop"))->setChecked(!decorationAtLeft);
 }
 
 bool KDirOperator::Private::isReadable(const QUrl &url)
 {
     if (!url.isLocalFile()) {
         return true; // what else can we say?
     }
     return QDir(url.toLocalFile()).isReadable();
 }
 
 void KDirOperator::Private::_k_slotDirectoryCreated(const QUrl &url)
 {
     parent->setUrl(url, true);
 }
 
 void KDirOperator::setSupportedSchemes(const QStringList &schemes)
 {
     d->supportedSchemes = schemes;
     rereadDir();
 }
 
 QStringList KDirOperator::supportedSchemes() const
 {
     return d->supportedSchemes;
 }
 
 #include "moc_kdiroperator.cpp"
 #include "kdiroperator.moc"
diff --git a/src/filewidgets/kfilewidget.cpp b/src/filewidgets/kfilewidget.cpp
index 38154e18..8d7a73bb 100644
--- a/src/filewidgets/kfilewidget.cpp
+++ b/src/filewidgets/kfilewidget.cpp
@@ -1,2885 +1,2885 @@
 // -*- c++ -*-
 /* This file is part of the KDE libraries
     Copyright (C) 1997, 1998 Richard Moore <rich@kde.org>
                   1998 Stephan Kulow <coolo@kde.org>
                   1998 Daniel Grana <grana@ie.iwi.unibe.ch>
                   1999,2000,2001,2002,2003 Carsten Pfeiffer <pfeiffer@kde.org>
                   2003 Clarence Dang <dang@kde.org>
                   2007 David Faure <faure@kde.org>
                   2008 Rafael Fernández López <ereslibre@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "kfilewidget.h"
 #include "../pathhelpers_p.h"
 
 #include "kfileplacesview.h"
 #include "kfileplacesmodel.h"
 #include "kfilebookmarkhandler_p.h"
 #include "kurlcombobox.h"
 #include "kurlnavigator.h"
 #include "kfilepreviewgenerator.h"
 #include "kfilewidgetdocktitlebar_p.h"
 #include <config-kiofilewidgets.h>
 #include <defaults-kfile.h>
 
 #include <kactioncollection.h>
 #include <kactionmenu.h>
 #include <kconfiggroup.h>
 #include <kdiroperator.h>
 #include <kfilefiltercombo.h>
 #include <kimagefilepreview.h>
 #include <krecentdocument.h>
 #include <ktoolbar.h>
 #include <kurlcompletion.h>
 #include <kprotocolmanager.h>
 #include <kio/pixmaploader.h>
 #include <kio/job.h>
 #include <kio/jobuidelegate.h>
 #include <kio/scheduler.h>
 #include <krecentdirs.h>
 #include <QDebug>
 #include <klocalizedstring.h>
 #include <kfileitemdelegate.h>
 #include <ksharedconfig.h>
 
 #include <QCheckBox>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QSplitter>
 #include <QAbstractProxyModel>
 #include <QHelpEvent>
 #include <QApplication>
 #include <QPushButton>
 #include <QStandardPaths>
 #include <qmimedatabase.h>
 
 #include <kshell.h>
 #include <kmessagebox.h>
 #include <kurlauthorized.h>
 #include <kjobwidgets.h>
 
 class KFileWidgetPrivate
 {
 public:
     explicit KFileWidgetPrivate(KFileWidget *widget)
         : q(widget),
           boxLayout(nullptr),
           placesDock(nullptr),
           placesView(nullptr),
           placesViewSplitter(nullptr),
           placesViewWidth(-1),
           labeledCustomWidget(nullptr),
           bottomCustomWidget(nullptr),
           autoSelectExtCheckBox(nullptr),
           operationMode(KFileWidget::Opening),
           bookmarkHandler(nullptr),
           toolbar(nullptr),
           locationEdit(nullptr),
           ops(nullptr),
           filterWidget(nullptr),
           autoSelectExtChecked(false),
           keepLocation(false),
           hasView(false),
           hasDefaultFilter(false),
           inAccept(false),
           dummyAdded(false),
           confirmOverwrite(false),
           differentHierarchyLevelItemsEntered(false),
           iconSizeSlider(nullptr),
           zoomOutAction(nullptr),
           zoomInAction(nullptr)
     {
     }
 
     ~KFileWidgetPrivate()
     {
         delete bookmarkHandler; // Should be deleted before ops!
         delete ops;
     }
 
     void updateLocationWhatsThis();
     void updateAutoSelectExtension();
     void initSpeedbar();
     void setPlacesViewSplitterSizes();
     void setLafBoxColumnWidth();
     void initGUI();
     void readViewConfig();
     void writeViewConfig();
     void setNonExtSelection();
     void setLocationText(const QUrl &);
     void setLocationText(const QList<QUrl> &);
     void appendExtension(QUrl &url);
     void updateLocationEditExtension(const QString &);
     void updateFilter();
     QList<QUrl> &parseSelectedUrls();
     /**
      * Parses the string "line" for files. If line doesn't contain any ", the
      * whole line will be interpreted as one file. If the number of " is odd,
      * an empty list will be returned. Otherwise, all items enclosed in " "
      * will be returned as correct urls.
      */
     QList<QUrl> tokenize(const QString &line) const;
     /**
      * Reads the recent used files and inserts them into the location combobox
      */
     void readRecentFiles();
     /**
      * Saves the entries from the location combobox.
      */
     void saveRecentFiles();
     /**
      * called when an item is highlighted/selected in multiselection mode.
      * handles setting the locationEdit.
      */
     void multiSelectionChanged();
 
     /**
      * Returns the absolute version of the URL specified in locationEdit.
      */
     QUrl getCompleteUrl(const QString &) const;
 
     /**
      * Sets the dummy entry on the history combo box. If the dummy entry
      * already exists, it is overwritten with this information.
      */
     void setDummyHistoryEntry(const QString &text, const QPixmap &icon = QPixmap(),
                               bool usePreviousPixmapIfNull = true);
 
     /**
      * Removes the dummy entry of the history combo box.
      */
     void removeDummyHistoryEntry();
 
     /**
      * Asks for overwrite confirmation using a KMessageBox and returns
      * true if the user accepts.
      *
      * @since 4.2
      */
     bool toOverwrite(const QUrl &);
 
     // private slots
     void _k_slotLocationChanged(const QString &);
     void _k_urlEntered(const QUrl &);
     void _k_enterUrl(const QUrl &);
     void _k_enterUrl(const QString &);
     void _k_locationAccepted(const QString &);
     void _k_slotFilterChanged();
     void _k_fileHighlighted(const KFileItem &);
     void _k_fileSelected(const KFileItem &);
     void _k_slotLoadingFinished();
     void _k_fileCompletion(const QString &);
     void _k_toggleSpeedbar(bool);
     void _k_toggleBookmarks(bool);
     void _k_slotAutoSelectExtClicked();
     void _k_placesViewSplitterMoved(int, int);
     void _k_activateUrlNavigator();
     void _k_zoomOutIconsSize();
     void _k_zoomInIconsSize();
     void _k_slotIconSizeSliderMoved(int);
     void _k_slotIconSizeChanged(int);
     void _k_slotViewDoubleClicked(const QModelIndex&);
 
     void addToRecentDocuments();
 
     QString locationEditCurrentText() const;
 
     /**
      * KIO::NetAccess::mostLocalUrl local replacement.
      * This method won't show any progress dialogs for stating, since
      * they are very annoying when stating.
      */
     QUrl mostLocalUrl(const QUrl &url);
 
     void setInlinePreviewShown(bool show);
 
     KFileWidget * const q;
 
     // the last selected url
     QUrl url;
 
     // the selected filenames in multiselection mode -- FIXME
     QString filenames;
 
     // now following all kind of widgets, that I need to rebuild
     // the geometry management
     QBoxLayout *boxLayout;
     QGridLayout *lafBox;
     QVBoxLayout *vbox;
 
     QLabel *locationLabel;
     QWidget *opsWidget;
     QWidget *pathSpacer;
 
     QLabel *filterLabel;
     KUrlNavigator *urlNavigator;
     QPushButton *okButton, *cancelButton;
     QDockWidget *placesDock;
     KFilePlacesView *placesView;
     QSplitter *placesViewSplitter;
     // caches the places view width. This value will be updated when the splitter
     // is moved. This allows us to properly set a value when the dialog itself
     // is resized
     int placesViewWidth;
 
     QWidget *labeledCustomWidget;
     QWidget *bottomCustomWidget;
 
     // Automatically Select Extension stuff
     QCheckBox *autoSelectExtCheckBox;
     QString extension; // current extension for this filter
 
     QList<KIO::StatJob *> statJobs;
 
     QList<QUrl> urlList; //the list of selected urls
 
     KFileWidget::OperationMode operationMode;
 
     // The file class used for KRecentDirs
     QString fileClass;
 
     KFileBookmarkHandler *bookmarkHandler;
 
     KActionMenu *bookmarkButton;
 
     KToolBar *toolbar;
     KUrlComboBox *locationEdit;
     KDirOperator *ops;
     KFileFilterCombo *filterWidget;
     QTimer filterDelayTimer;
 
     KFilePlacesModel *model;
 
     // whether or not the _user_ has checked the above box
     bool autoSelectExtChecked : 1;
 
     // indicates if the location edit should be kept or cleared when changing
     // directories
     bool keepLocation : 1;
 
     // the KDirOperators view is set in KFileWidget::show(), so to avoid
     // setting it again and again, we have this nice little boolean :)
     bool hasView : 1;
 
     bool hasDefaultFilter : 1; // necessary for the operationMode
     bool autoDirectoryFollowing : 1;
     bool inAccept : 1; // true between beginning and end of accept()
     bool dummyAdded : 1; // if the dummy item has been added. This prevents the combo from having a
     // blank item added when loaded
     bool confirmOverwrite : 1;
     bool differentHierarchyLevelItemsEntered;
 
     QSlider *iconSizeSlider;
     QAction *zoomOutAction;
     QAction *zoomInAction;
 
     // The group which stores app-specific settings. These settings are recent
     // files and urls. Visual settings (view mode, sorting criteria...) are not
     // app-specific and are stored in kdeglobals
     KConfigGroup configGroup;
 };
 
 Q_GLOBAL_STATIC(QUrl, lastDirectory) // to set the start path
 
 static const char autocompletionWhatsThisText[] = I18N_NOOP("<qt>While typing in the text area, you may be presented "
         "with possible matches. "
         "This feature can be controlled by clicking with the right mouse button "
         "and selecting a preferred mode from the <b>Text Completion</b> menu.</qt>");
 
 // returns true if the string contains "<a>:/" sequence, where <a> is at least 2 alpha chars
 static bool containsProtocolSection(const QString &string)
 {
     int len = string.length();
     static const char prot[] = ":/";
     for (int i = 0; i < len;) {
         i = string.indexOf(QLatin1String(prot), i);
         if (i == -1) {
             return false;
         }
         int j = i - 1;
         for (; j >= 0; j--) {
             const QChar &ch(string[j]);
             if (ch.toLatin1() == 0 || !ch.isLetter()) {
                 break;
             }
             if (ch.isSpace() && (i - j - 1) >= 2) {
                 return true;
             }
         }
         if (j < 0 && i >= 2) {
             return true;    // at least two letters before ":/"
         }
         i += 3; // skip : and / and one char
     }
     return false;
 }
 
 // this string-to-url conversion function handles relative paths, full paths and URLs
 // without the http-prepending that QUrl::fromUserInput does.
 static QUrl urlFromString(const QString& str)
 {
     if (QDir::isAbsolutePath(str)) {
         return QUrl::fromLocalFile(str);
     }
     QUrl url(str);
     if (url.isRelative()) {
         url.clear();
         url.setPath(str);
     }
     return url;
 }
 
 
 KFileWidget::KFileWidget(const QUrl &_startDir, QWidget *parent)
     : QWidget(parent), d(new KFileWidgetPrivate(this))
 {
     QUrl startDir(_startDir);
     // qDebug() << "startDir" << startDir;
     QString filename;
 
     d->okButton = new QPushButton(this);
     KGuiItem::assign(d->okButton, KStandardGuiItem::ok());
     d->okButton->setDefault(true);
     d->cancelButton = new QPushButton(this);
     KGuiItem::assign(d->cancelButton, KStandardGuiItem::cancel());
     // The dialog shows them
     d->okButton->hide();
     d->cancelButton->hide();
 
     d->opsWidget = new QWidget(this);
     QVBoxLayout *opsWidgetLayout = new QVBoxLayout(d->opsWidget);
     opsWidgetLayout->setMargin(0);
     opsWidgetLayout->setSpacing(0);
     //d->toolbar = new KToolBar(this, true);
     d->toolbar = new KToolBar(d->opsWidget, true);
     d->toolbar->setObjectName(QStringLiteral("KFileWidget::toolbar"));
     d->toolbar->setMovable(false);
     opsWidgetLayout->addWidget(d->toolbar);
 
     d->model = new KFilePlacesModel(this);
 
     // Resolve this now so that a 'kfiledialog:' URL, if specified,
     // does not get inserted into the urlNavigator history.
     d->url = getStartUrl(startDir, d->fileClass, filename);
     startDir = d->url;
 
     // Don't pass startDir to the KUrlNavigator at this stage: as well as
     // the above, it may also contain a file name which should not get
     // inserted in that form into the old-style navigation bar history.
     // Wait until the KIO::stat has been done later.
     //
     // The stat cannot be done before this point, bug 172678.
     d->urlNavigator = new KUrlNavigator(d->model, QUrl(), d->opsWidget); //d->toolbar);
     d->urlNavigator->setPlacesSelectorVisible(false);
     opsWidgetLayout->addWidget(d->urlNavigator);
 
     QUrl u;
     KUrlComboBox *pathCombo = d->urlNavigator->editor();
 #ifdef Q_OS_WIN
 #if 0
     foreach (const QFileInfo &drive, QFSFileEngine::drives()) {
         u = QUrl::fromLocalFile(drive.filePath());
         pathCombo->addDefaultUrl(u,
                                  KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                                  i18n("Drive: %1",  u.toLocalFile()));
     }
 #else
 #pragma message("QT5 PORT")
 #endif
 #else
     u = QUrl::fromLocalFile(QDir::rootPath());
     pathCombo->addDefaultUrl(u,
                              KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 #endif
 
     u = QUrl::fromLocalFile(QDir::homePath());
     pathCombo->addDefaultUrl(u, KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 
     QUrl docPath = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
     if (u.adjusted(QUrl::StripTrailingSlash) != docPath.adjusted(QUrl::StripTrailingSlash) &&
             QDir(docPath.toLocalFile()).exists()) {
         pathCombo->addDefaultUrl(docPath,
                                  KIO::pixmapForUrl(docPath, 0, KIconLoader::Small),
                                  docPath.toLocalFile());
     }
 
     u = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation));
     pathCombo->addDefaultUrl(u,
                              KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 
     d->ops = new KDirOperator(QUrl(), d->opsWidget);
     d->ops->setObjectName(QStringLiteral("KFileWidget::ops"));
     d->ops->setIsSaving(d->operationMode == Saving);
     opsWidgetLayout->addWidget(d->ops);
     connect(d->ops, SIGNAL(urlEntered(QUrl)),
             SLOT(_k_urlEntered(QUrl)));
     connect(d->ops, SIGNAL(fileHighlighted(KFileItem)),
             SLOT(_k_fileHighlighted(KFileItem)));
     connect(d->ops, SIGNAL(fileSelected(KFileItem)),
             SLOT(_k_fileSelected(KFileItem)));
     connect(d->ops, SIGNAL(finishedLoading()),
             SLOT(_k_slotLoadingFinished()));
 
     d->ops->setupMenu(KDirOperator::SortActions |
                       KDirOperator::FileActions |
                       KDirOperator::ViewActions);
     KActionCollection *coll = d->ops->actionCollection();
     coll->addAssociatedWidget(this);
 
     // add nav items to the toolbar
     //
     // NOTE:  The order of the button icons here differs from that
     // found in the file manager and web browser, but has been discussed
     // and agreed upon on the kde-core-devel mailing list:
     //
     // http://lists.kde.org/?l=kde-core-devel&m=116888382514090&w=2
 
     coll->action(QStringLiteral("up"))->setWhatsThis(i18n("<qt>Click this button to enter the parent folder.<br /><br />"
                                           "For instance, if the current location is file:/home/konqi clicking this "
                                           "button will take you to file:/home.</qt>"));
 
     coll->action(QStringLiteral("back"))->setWhatsThis(i18n("Click this button to move backwards one step in the browsing history."));
     coll->action(QStringLiteral("forward"))->setWhatsThis(i18n("Click this button to move forward one step in the browsing history."));
 
     coll->action(QStringLiteral("reload"))->setWhatsThis(i18n("Click this button to reload the contents of the current location."));
     coll->action(QStringLiteral("mkdir"))->setShortcut(QKeySequence(Qt::Key_F10));
     coll->action(QStringLiteral("mkdir"))->setWhatsThis(i18n("Click this button to create a new folder."));
 
     QAction *goToNavigatorAction = coll->addAction(QStringLiteral("gotonavigator"), this, SLOT(_k_activateUrlNavigator()));
     goToNavigatorAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_L));
 
     KToggleAction *showSidebarAction =
         new KToggleAction(i18n("Show Places Navigation Panel"), this);
     coll->addAction(QStringLiteral("toggleSpeedbar"), showSidebarAction);
     showSidebarAction->setShortcut(QKeySequence(Qt::Key_F9));
     connect(showSidebarAction, SIGNAL(toggled(bool)),
             SLOT(_k_toggleSpeedbar(bool)));
 
     KToggleAction *showBookmarksAction =
         new KToggleAction(i18n("Show Bookmarks"), this);
     coll->addAction(QStringLiteral("toggleBookmarks"), showBookmarksAction);
     connect(showBookmarksAction, SIGNAL(toggled(bool)),
             SLOT(_k_toggleBookmarks(bool)));
 
     KActionMenu *menu = new KActionMenu(QIcon::fromTheme(QStringLiteral("configure")), i18n("Options"), this);
     coll->addAction(QStringLiteral("extra menu"), menu);
     menu->setWhatsThis(i18n("<qt>This is the preferences menu for the file dialog. "
                             "Various options can be accessed from this menu including: <ul>"
                             "<li>how files are sorted in the list</li>"
                             "<li>types of view, including icon and list</li>"
                             "<li>showing of hidden files</li>"
                             "<li>the Places navigation panel</li>"
                             "<li>file previews</li>"
                             "<li>separating folders from files</li></ul></qt>"));
     menu->addAction(coll->action(QStringLiteral("sorting menu")));
     menu->addAction(coll->action(QStringLiteral("view menu")));
     menu->addSeparator();
     menu->addAction(coll->action(QStringLiteral("decoration menu")));
     menu->addSeparator();
     menu->addAction(coll->action(QStringLiteral("show hidden")));
     menu->addAction(showSidebarAction);
     menu->addAction(showBookmarksAction);
     coll->action(QStringLiteral("inline preview"));
     menu->addAction(coll->action(QStringLiteral("preview")));
 
     menu->setDelayed(false);
     connect(menu->menu(), SIGNAL(aboutToShow()),
             d->ops, SLOT(updateSelectionDependentActions()));
 
     d->iconSizeSlider = new QSlider(this);
     d->iconSizeSlider->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
     d->iconSizeSlider->setMinimumWidth(40);
     d->iconSizeSlider->setOrientation(Qt::Horizontal);
     d->iconSizeSlider->setMinimum(0);
     d->iconSizeSlider->setMaximum(100);
     d->iconSizeSlider->installEventFilter(this);
     connect(d->iconSizeSlider, SIGNAL(valueChanged(int)),
             d->ops, SLOT(setIconsZoom(int)));
     connect(d->iconSizeSlider, SIGNAL(valueChanged(int)),
             this, SLOT(_k_slotIconSizeChanged(int)));
     connect(d->iconSizeSlider, SIGNAL(sliderMoved(int)),
             this, SLOT(_k_slotIconSizeSliderMoved(int)));
     connect(d->ops, &KDirOperator::currentIconSizeChanged, [this](int value) {
         d->iconSizeSlider->setValue(value);
         d->zoomOutAction->setDisabled(value <= d->iconSizeSlider->minimum());
         d->zoomInAction->setDisabled(value >= d->iconSizeSlider->maximum());
     });
 
     d->zoomOutAction = new QAction(QIcon::fromTheme(QStringLiteral("file-zoom-out")), i18n("Zoom out"), this);
     connect(d->zoomOutAction, SIGNAL(triggered()), SLOT(_k_zoomOutIconsSize()));
     d->zoomInAction = new QAction(QIcon::fromTheme(QStringLiteral("file-zoom-in")), i18n("Zoom in"), this);
     connect(d->zoomInAction, SIGNAL(triggered()), SLOT(_k_zoomInIconsSize()));
 
     QWidget *midSpacer = new QWidget(this);
     midSpacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
     d->toolbar->addAction(coll->action(QStringLiteral("back")));
     d->toolbar->addAction(coll->action(QStringLiteral("forward")));
     d->toolbar->addAction(coll->action(QStringLiteral("up")));
     d->toolbar->addAction(coll->action(QStringLiteral("reload")));
     d->toolbar->addSeparator();
     d->toolbar->addAction(coll->action(QStringLiteral("inline preview")));
     d->toolbar->addWidget(midSpacer);
     d->toolbar->addAction(d->zoomOutAction);
     d->toolbar->addWidget(d->iconSizeSlider);
     d->toolbar->addAction(d->zoomInAction);
     d->toolbar->addSeparator();
     d->toolbar->addAction(coll->action(QStringLiteral("mkdir")));
     d->toolbar->addAction(menu);
 
     d->toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
     d->toolbar->setMovable(false);
 
     KUrlCompletion *pathCompletionObj = new KUrlCompletion(KUrlCompletion::DirCompletion);
     pathCombo->setCompletionObject(pathCompletionObj);
     pathCombo->setAutoDeleteCompletionObject(true);
 
     connect(d->urlNavigator, SIGNAL(urlChanged(QUrl)),
             this,  SLOT(_k_enterUrl(QUrl)));
     connect(d->urlNavigator, SIGNAL(returnPressed()),
             d->ops,  SLOT(setFocus()));
 
     QString whatsThisText;
 
     // the Location label/edit
     d->locationLabel = new QLabel(i18n("&Name:"), this);
     d->locationEdit = new KUrlComboBox(KUrlComboBox::Files, true, this);
     d->locationEdit->installEventFilter(this);
     // Properly let the dialog be resized (to smaller). Otherwise we could have
     // huge dialogs that can't be resized to smaller (it would be as big as the longest
     // item in this combo box). (ereslibre)
     d->locationEdit->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
     connect(d->locationEdit, SIGNAL(editTextChanged(QString)),
             SLOT(_k_slotLocationChanged(QString)));
 
     d->updateLocationWhatsThis();
     d->locationLabel->setBuddy(d->locationEdit);
 
     KUrlCompletion *fileCompletionObj = new KUrlCompletion(KUrlCompletion::FileCompletion);
     d->locationEdit->setCompletionObject(fileCompletionObj);
     d->locationEdit->setAutoDeleteCompletionObject(true);
     connect(fileCompletionObj, SIGNAL(match(QString)),
             SLOT(_k_fileCompletion(QString)));
 
     connect(d->locationEdit, SIGNAL(returnPressed(QString)),
             this,  SLOT(_k_locationAccepted(QString)));
 
     // the Filter label/edit
     whatsThisText = i18n("<qt>This is the filter to apply to the file list. "
                          "File names that do not match the filter will not be shown.<p>"
                          "You may select from one of the preset filters in the "
                          "drop down menu, or you may enter a custom filter "
                          "directly into the text area.</p><p>"
                          "Wildcards such as * and ? are allowed.</p></qt>");
     d->filterLabel = new QLabel(i18n("&Filter:"), this);
     d->filterLabel->setWhatsThis(whatsThisText);
     d->filterWidget = new KFileFilterCombo(this);
     // Properly let the dialog be resized (to smaller). Otherwise we could have
     // huge dialogs that can't be resized to smaller (it would be as big as the longest
     // item in this combo box). (ereslibre)
     d->filterWidget->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
     d->filterWidget->setWhatsThis(whatsThisText);
     d->filterLabel->setBuddy(d->filterWidget);
     connect(d->filterWidget, SIGNAL(filterChanged()), SLOT(_k_slotFilterChanged()));
 
     d->filterDelayTimer.setSingleShot(true);
     d->filterDelayTimer.setInterval(300);
     connect(d->filterWidget, SIGNAL(editTextChanged(QString)), &d->filterDelayTimer, SLOT(start()));
     connect(&d->filterDelayTimer, SIGNAL(timeout()), SLOT(_k_slotFilterChanged()));
 
     // the Automatically Select Extension checkbox
     // (the text, visibility etc. is set in updateAutoSelectExtension(), which is called by readConfig())
     d->autoSelectExtCheckBox = new QCheckBox(this);
     const int spacingHint = style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
     d->autoSelectExtCheckBox->setStyleSheet(QStringLiteral("QCheckBox { padding-top: %1px; }").arg(spacingHint));
     connect(d->autoSelectExtCheckBox, SIGNAL(clicked()), SLOT(_k_slotAutoSelectExtClicked()));
 
     d->initGUI(); // activate GM
 
     // read our configuration
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup group(config, ConfigGroup);
     readConfig(group);
 
     coll->action(QStringLiteral("inline preview"))->setChecked(d->ops->isInlinePreviewShown());
     d->iconSizeSlider->setValue(d->ops->iconsZoom());
 
     KFilePreviewGenerator *pg = d->ops->previewGenerator();
     if (pg) {
         coll->action(QStringLiteral("inline preview"))->setChecked(pg->isPreviewShown());
     }
 
     // getStartUrl() above will have resolved the startDir parameter into
     // a directory and file name in the two cases: (a) where it is a
     // special "kfiledialog:" URL, or (b) where it is a plain file name
     // only without directory or protocol.  For any other startDir
     // specified, it is not possible to resolve whether there is a file name
     // present just by looking at the URL; the only way to be sure is
     // to stat it.
     bool statRes = false;
     if (filename.isEmpty()) {
         KIO::StatJob *statJob = KIO::stat(startDir, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, this);
         statRes = statJob->exec();
         // qDebug() << "stat of" << startDir << "-> statRes" << statRes << "isDir" << statJob->statResult().isDir();
         if (!statRes || !statJob->statResult().isDir()) {
             filename = startDir.fileName();
             startDir = startDir.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
             // qDebug() << "statJob -> startDir" << startDir << "filename" << filename;
         }
     }
 
     d->ops->setUrl(startDir, true);
     d->urlNavigator->setLocationUrl(startDir);
     if (d->placesView) {
         d->placesView->setUrl(startDir);
     }
 
     // We have a file name either explicitly specified, or have checked that
     // we could stat it and it is not a directory.  Set it.
     if (!filename.isEmpty()) {
         QLineEdit *lineEdit = d->locationEdit->lineEdit();
         // qDebug() << "selecting filename" << filename;
         if (statRes) {
             d->setLocationText(QUrl(filename));
         } else {
             lineEdit->setText(filename);
             // Preserve this filename when clicking on the view (cf _k_fileHighlighted)
             lineEdit->setModified(true);
         }
         lineEdit->selectAll();
     }
 
     d->locationEdit->setFocus();
 }
 
 KFileWidget::~KFileWidget()
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     config->sync();
 
     delete d;
 }
 
 void KFileWidget::setLocationLabel(const QString &text)
 {
     d->locationLabel->setText(text);
 }
 
 void KFileWidget::setFilter(const QString &filter)
 {
     int pos = filter.indexOf(QLatin1Char('/'));
 
     // Check for an un-escaped '/', if found
     // interpret as a MIME filter.
 
     if (pos > 0 && filter[pos - 1] != QLatin1Char('\\')) {
         QStringList filters = filter.split(QLatin1Char(' '), QString::SkipEmptyParts);
         setMimeFilter(filters);
         return;
     }
 
     // Strip the escape characters from
     // escaped '/' characters.
 
     QString copy(filter);
     for (pos = 0; (pos = copy.indexOf(QStringLiteral("\\/"), pos)) != -1; ++pos) {
         copy.remove(pos, 1);
     }
 
     d->ops->clearFilter();
     d->filterWidget->setFilter(copy);
     d->ops->setNameFilter(d->filterWidget->currentFilter());
     d->ops->updateDir();
     d->hasDefaultFilter = false;
     d->filterWidget->setEditable(true);
 
     d->updateAutoSelectExtension();
 }
 
 QString KFileWidget::currentFilter() const
 {
     return d->filterWidget->currentFilter();
 }
 
 void KFileWidget::setMimeFilter(const QStringList &mimeTypes,
                                 const QString &defaultType)
 {
     d->filterWidget->setMimeFilter(mimeTypes, defaultType);
 
     QStringList types = d->filterWidget->currentFilter().split(QLatin1Char(' '), QString::SkipEmptyParts); //QStringList::split(" ", d->filterWidget->currentFilter());
     types.append(QStringLiteral("inode/directory"));
     d->ops->clearFilter();
     d->ops->setMimeFilter(types);
     d->hasDefaultFilter = !defaultType.isEmpty();
     d->filterWidget->setEditable(!d->hasDefaultFilter ||
                                  d->operationMode != Saving);
 
     d->updateAutoSelectExtension();
 }
 
 void KFileWidget::clearFilter()
 {
     d->filterWidget->setFilter(QString());
     d->ops->clearFilter();
     d->hasDefaultFilter = false;
     d->filterWidget->setEditable(true);
 
     d->updateAutoSelectExtension();
 }
 
 QString KFileWidget::currentMimeFilter() const
 {
     int i = d->filterWidget->currentIndex();
     if (d->filterWidget->showsAllTypes() && i == 0) {
         return QString();    // The "all types" item has no mimetype
     }
 
     return d->filterWidget->filters()[i];
 }
 
 QMimeType KFileWidget::currentFilterMimeType()
 {
     QMimeDatabase db;
     return db.mimeTypeForName(currentMimeFilter());
 }
 
 void KFileWidget::setPreviewWidget(KPreviewWidgetBase *w)
 {
     d->ops->setPreviewWidget(w);
     d->ops->clearHistory();
     d->hasView = true;
 }
 
 QUrl KFileWidgetPrivate::getCompleteUrl(const QString &_url) const
 {
 //     qDebug() << "got url " << _url;
 
     const QString url = KShell::tildeExpand(_url);
     QUrl u;
 
     if (QDir::isAbsolutePath(url)) {
         u = QUrl::fromLocalFile(url);
     } else {
         QUrl relativeUrlTest(ops->url());
         relativeUrlTest.setPath(concatPaths(relativeUrlTest.path(), url));
         if (!ops->dirLister()->findByUrl(relativeUrlTest).isNull() ||
                 !KProtocolInfo::isKnownProtocol(relativeUrlTest)) {
             u = relativeUrlTest;
         } else {
             u = QUrl(url); // keep it relative
         }
     }
 
     return u;
 }
 
 QSize KFileWidget::sizeHint() const
 {
     int fontSize = fontMetrics().height();
     const QSize goodSize(48 * fontSize, 30 * fontSize);
     const QSize screenSize = QApplication::desktop()->availableGeometry(this).size();
     const QSize minSize(screenSize / 2);
     const QSize maxSize(screenSize * qreal(0.9));
     return (goodSize.expandedTo(minSize).boundedTo(maxSize));
 }
 
 static QString relativePathOrUrl(const QUrl &baseUrl, const QUrl &url);
 
 // Called by KFileDialog
 void KFileWidget::slotOk()
 {
 //     qDebug() << "slotOk\n";
 
     const QString locationEditCurrentText(KShell::tildeExpand(d->locationEditCurrentText()));
 
     QList<QUrl> locationEditCurrentTextList(d->tokenize(locationEditCurrentText));
     KFile::Modes mode = d->ops->mode();
 
     // if there is nothing to do, just return from here
     if (!locationEditCurrentTextList.count()) {
         return;
     }
 
     // Make sure that one of the modes was provided
     if (!((mode & KFile::File) || (mode & KFile::Directory) || (mode & KFile::Files))) {
         mode |= KFile::File;
         // qDebug() << "No mode() provided";
     }
 
     // if we are on file mode, and the list of provided files/folder is greater than one, inform
     // the user about it
     if (locationEditCurrentTextList.count() > 1) {
         if (mode & KFile::File) {
             KMessageBox::sorry(this,
                                i18n("You can only select one file"),
                                i18n("More than one file provided"));
             return;
         }
 
         /**
           * Logic of the next part of code (ends at "end multi relative urls").
           *
           * We allow for instance to be at "/" and insert '"home/foo/bar.txt" "boot/grub/menu.lst"'.
           * Why we need to support this ? Because we provide tree views, which aren't plain.
           *
           * Now, how does this logic work. It will get the first element on the list (with no filename),
           * following the previous example say "/home/foo" and set it as the top most url.
           *
           * After this, it will iterate over the rest of items and check if this URL (topmost url)
           * contains the url being iterated.
           *
           * As you might have guessed it will do "/home/foo" against "/boot/grub" (again stripping
           * filename), and a false will be returned. Then we upUrl the top most url, resulting in
           * "/home" against "/boot/grub", what will again return false, so we upUrl again. Now we
           * have "/" against "/boot/grub", what returns true for us, so we can say that the closest
           * common ancestor of both is "/".
           *
           * This example has been written for 2 urls, but this works for any number of urls.
           */
         if (!d->differentHierarchyLevelItemsEntered) {     // avoid infinite recursion. running this
             int start = 0;
             QUrl topMostUrl;
             KIO::StatJob *statJob = nullptr;
             bool res = false;
 
             // we need to check for a valid first url, so in theory we only iterate one time over
             // this loop. However it can happen that the user did
             // "home/foo/nonexistantfile" "boot/grub/menu.lst", so we look for a good first
             // candidate.
             while (!res && start < locationEditCurrentTextList.count()) {
                 topMostUrl = locationEditCurrentTextList.at(start);
                 statJob = KIO::stat(topMostUrl, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(statJob, this);
                 res = statJob->exec();
                 start++;
             }
 
             Q_ASSERT(statJob);
 
             // if this is not a dir, strip the filename. after this we have an existent and valid
             // dir (we stated correctly the file).
             if (!statJob->statResult().isDir()) {
                 topMostUrl = topMostUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
             }
 
             // now the funny part. for the rest of filenames, go and look for the closest ancestor
             // of all them.
             for (int i = start; i < locationEditCurrentTextList.count(); ++i) {
                 QUrl currUrl = locationEditCurrentTextList.at(i);
                 KIO::StatJob *statJob = KIO::stat(currUrl, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(statJob, this);
                 int res = statJob->exec();
                 if (res) {
                     // again, we don't care about filenames
                     if (!statJob->statResult().isDir()) {
                         currUrl = currUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
                     }
 
                     // iterate while this item is contained on the top most url
                     while (!topMostUrl.matches(currUrl, QUrl::StripTrailingSlash) && !topMostUrl.isParentOf(currUrl)) {
                         topMostUrl = KIO::upUrl(topMostUrl);
                     }
                 }
             }
 
             // now recalculate all paths for them being relative in base of the top most url
             QStringList stringList;
             for (int i = 0; i < locationEditCurrentTextList.count(); ++i) {
                 Q_ASSERT(topMostUrl.isParentOf(locationEditCurrentTextList[i]));
                 stringList << relativePathOrUrl(topMostUrl, locationEditCurrentTextList[i]);
             }
 
             d->ops->setUrl(topMostUrl, true);
             const bool signalsBlocked = d->locationEdit->lineEdit()->blockSignals(true);
             d->locationEdit->lineEdit()->setText(QStringLiteral("\"%1\"").arg(stringList.join(QStringLiteral("\" \""))));
             d->locationEdit->lineEdit()->blockSignals(signalsBlocked);
 
             d->differentHierarchyLevelItemsEntered = true;
             slotOk();
             return;
         }
         /**
           * end multi relative urls
           */
     } else if (locationEditCurrentTextList.count()) {
         // if we are on file or files mode, and we have an absolute url written by
         // the user, convert it to relative
         if (!locationEditCurrentText.isEmpty() && !(mode & KFile::Directory) &&
                 (QDir::isAbsolutePath(locationEditCurrentText) ||
                  containsProtocolSection(locationEditCurrentText))) {
 
             QString fileName;
             QUrl url = urlFromString(locationEditCurrentText);
             if (d->operationMode == Opening) {
                 KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(statJob, this);
                 int res = statJob->exec();
                 if (res) {
                     if (!statJob->statResult().isDir()) {
                         fileName = url.fileName();
                         url = url.adjusted(QUrl::RemoveFilename); // keeps trailing slash
                     } else {
                         if (!url.path().endsWith(QLatin1Char('/'))) {
                             url.setPath(url.path() + QLatin1Char('/'));
                         }
                     }
                 }
             } else {
                 const QUrl directory = url.adjusted(QUrl::RemoveFilename);
                 //Check if the folder exists
                 KIO::StatJob *statJob = KIO::stat(directory, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(statJob, this);
                 int res = statJob->exec();
                 if (res) {
                     if (statJob->statResult().isDir()) {
                         url = url.adjusted(QUrl::StripTrailingSlash);
                         fileName = url.fileName();
                         url = url.adjusted(QUrl::RemoveFilename);
                     }
                 }
             }
             d->ops->setUrl(url, true);
             const bool signalsBlocked = d->locationEdit->lineEdit()->blockSignals(true);
             d->locationEdit->lineEdit()->setText(fileName);
             d->locationEdit->lineEdit()->blockSignals(signalsBlocked);
             slotOk();
             return;
         }
     }
 
     // restore it
     d->differentHierarchyLevelItemsEntered = false;
 
     // locationEditCurrentTextList contains absolute paths
     // this is the general loop for the File and Files mode. Obviously we know
     // that the File mode will iterate only one time here
     bool directoryMode = (mode & KFile::Directory);
     bool onlyDirectoryMode = directoryMode && !(mode & KFile::File) && !(mode & KFile::Files);
     QList<QUrl>::ConstIterator it = locationEditCurrentTextList.constBegin();
     bool filesInList = false;
     while (it != locationEditCurrentTextList.constEnd()) {
         QUrl url(*it);
 
         if (d->operationMode == Saving && !directoryMode) {
             d->appendExtension(url);
         }
 
         d->url = url;
         KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, this);
         int res = statJob->exec();
 
         if (!KUrlAuthorized::authorizeUrlAction(QStringLiteral("open"), QUrl(), url)) {
             QString msg = KIO::buildErrorString(KIO::ERR_ACCESS_DENIED, d->url.toDisplayString());
             KMessageBox::error(this, msg);
             return;
         }
 
         // if we are on local mode, make sure we haven't got a remote base url
         if ((mode & KFile::LocalOnly) && !d->mostLocalUrl(d->url).isLocalFile()) {
             KMessageBox::sorry(this,
                                i18n("You can only select local files"),
                                i18n("Remote files not accepted"));
             return;
         }
 
         const auto &supportedSchemes = d->model->supportedSchemes();
         if (!supportedSchemes.isEmpty() && !supportedSchemes.contains(d->url.scheme())) {
             KMessageBox::sorry(this,
                                i18np("The selected URL uses an unsupported scheme. "
                                      "Please use the following scheme: %2",
                                      "The selected URL uses an unsupported scheme. "
                                      "Please use one of the following schemes: %2",
                                      supportedSchemes.size(),
                                      supportedSchemes.join(QLatin1String(", "))),
                                i18n("Unsupported URL scheme"));
             return;
         }
 
         // if we are given a folder when not on directory mode, let's get into it
         if (res && !directoryMode && statJob->statResult().isDir()) {
             // check if we were given more than one folder, in that case we don't know to which one
             // cd
             ++it;
             while (it != locationEditCurrentTextList.constEnd()) {
                 QUrl checkUrl(*it);
                 KIO::StatJob *checkStatJob = KIO::stat(checkUrl, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(checkStatJob, this);
                 bool res = checkStatJob->exec();
                 if (res && checkStatJob->statResult().isDir()) {
                     KMessageBox::sorry(this, i18n("More than one folder has been selected and this dialog does not accept folders, so it is not possible to decide which one to enter. Please select only one folder to list it."), i18n("More than one folder provided"));
                     return;
                 } else if (res) {
                     filesInList = true;
                 }
                 ++it;
             }
             if (filesInList) {
                 KMessageBox::information(this, i18n("At least one folder and one file has been selected. Selected files will be ignored and the selected folder will be listed"), i18n("Files and folders selected"));
             }
             d->ops->setUrl(url, true);
             const bool signalsBlocked = d->locationEdit->lineEdit()->blockSignals(true);
             d->locationEdit->lineEdit()->setText(QString());
             d->locationEdit->lineEdit()->blockSignals(signalsBlocked);
             return;
         } else if (res && onlyDirectoryMode && !statJob->statResult().isDir()) {
             // if we are given a file when on directory only mode, reject it
             return;
         } else if (!(mode & KFile::ExistingOnly) || res) {
             // if we don't care about ExistingOnly flag, add the file even if
             // it doesn't exist. If we care about it, don't add it to the list
             if (!onlyDirectoryMode || (res && statJob->statResult().isDir())) {
                 d->urlList << url;
             }
             filesInList = true;
         } else {
             KMessageBox::sorry(this, i18n("The file \"%1\" could not be found", url.toDisplayString(QUrl::PreferLocalFile)), i18n("Cannot open file"));
             return; // do not emit accepted() if we had ExistingOnly flag and stat failed
         }
 
         if ((d->operationMode == Saving) && d->confirmOverwrite && !d->toOverwrite(url)) {
             return;
         }
 
         ++it;
     }
 
     // if we have reached this point and we didn't return before, that is because
     // we want this dialog to be accepted
     emit accepted();
 }
 
 void KFileWidget::accept()
 {
     d->inAccept = true; // parseSelectedUrls() checks that
 
     *lastDirectory() = d->ops->url();
     if (!d->fileClass.isEmpty()) {
         KRecentDirs::add(d->fileClass, d->ops->url().toString());
     }
 
     // clear the topmost item, we insert it as full path later on as item 1
     d->locationEdit->setItemText(0, QString());
 
     const QList<QUrl> list = selectedUrls();
     QList<QUrl>::const_iterator it = list.begin();
     int atmost = d->locationEdit->maxItems(); //don't add more items than necessary
     for (; it != list.end() && atmost > 0; ++it) {
         const QUrl &url = *it;
         // we strip the last slash (-1) because KUrlComboBox does that as well
         // when operating in file-mode. If we wouldn't , dupe-finding wouldn't
         // work.
         QString file = url.isLocalFile() ? url.toLocalFile() : url.toDisplayString();
 
         // remove dupes
         for (int i = 1; i < d->locationEdit->count(); i++) {
             if (d->locationEdit->itemText(i) == file) {
                 d->locationEdit->removeItem(i--);
                 break;
             }
         }
         //FIXME I don't think this works correctly when the KUrlComboBox has some default urls.
         //KUrlComboBox should provide a function to add an url and rotate the existing ones, keeping
         //track of maxItems, and we shouldn't be able to insert items as we please.
         d->locationEdit->insertItem(1, file);
         atmost--;
     }
 
     d->writeViewConfig();
     d->saveRecentFiles();
 
     d->addToRecentDocuments();
 
     if (!(mode() & KFile::Files)) { // single selection
         emit fileSelected(d->url);
     }
 
     d->ops->close();
 }
 
 void KFileWidgetPrivate::_k_fileHighlighted(const KFileItem &i)
 {
     if ((!i.isNull() && i.isDir()) ||
             (locationEdit->hasFocus() && !locationEdit->currentText().isEmpty())) { // don't disturb
         return;
     }
 
     const bool modified = locationEdit->lineEdit()->isModified();
 
     if (!(ops->mode() & KFile::Files)) {
         if (i.isNull()) {
             if (!modified) {
                 setLocationText(QUrl());
             }
             return;
         }
 
         url = i.url();
 
         if (!locationEdit->hasFocus()) { // don't disturb while editing
             setLocationText(url);
         }
 
         emit q->fileHighlighted(url);
     } else {
         multiSelectionChanged();
         emit q->selectionChanged();
     }
 
     locationEdit->lineEdit()->setModified(false);
 }
 
 void KFileWidgetPrivate::_k_fileSelected(const KFileItem &i)
 {
     if (!i.isNull() && i.isDir()) {
         return;
     }
 
     if (!(ops->mode() & KFile::Files)) {
         if (i.isNull()) {
             setLocationText(QUrl());
             return;
         }
         setLocationText(i.url());
     } else {
         multiSelectionChanged();
         emit q->selectionChanged();
     }
 
     // If we are saving, let another chance to the user before accepting the dialog (or trying to
     // accept). This way the user can choose a file and add a "_2" for instance to the filename.
     // Double clicking however will override this, regardless of single/double click mouse setting,
     // see: _k_slotViewDoubleClicked
     if (operationMode == KFileWidget::Saving) {
         locationEdit->setFocus();
     } else {
         q->slotOk();
     }
 }
 
 // I know it's slow to always iterate thru the whole filelist
 // (d->ops->selectedItems()), but what can we do?
 void KFileWidgetPrivate::multiSelectionChanged()
 {
     if (locationEdit->hasFocus() && !locationEdit->currentText().isEmpty()) { // don't disturb
         return;
     }
 
     const KFileItemList list = ops->selectedItems();
 
     if (list.isEmpty()) {
         setLocationText(QUrl());
         return;
     }
 
     setLocationText(list.urlList());
 }
 
 void KFileWidgetPrivate::setDummyHistoryEntry(const QString &text, const QPixmap &icon,
         bool usePreviousPixmapIfNull)
 {
     // setCurrentItem() will cause textChanged() being emitted,
     // so slotLocationChanged() will be called. Make sure we don't clear
     // the KDirOperator's view-selection in there
     QObject::disconnect(locationEdit, SIGNAL(editTextChanged(QString)),
                         q, SLOT(_k_slotLocationChanged(QString)));
 
     bool dummyExists = dummyAdded;
 
     int cursorPosition = locationEdit->lineEdit()->cursorPosition();
 
     if (dummyAdded) {
         if (!icon.isNull()) {
             locationEdit->setItemIcon(0, icon);
             locationEdit->setItemText(0, text);
         } else {
             if (!usePreviousPixmapIfNull) {
                 locationEdit->setItemIcon(0, QPixmap());
             }
             locationEdit->setItemText(0, text);
         }
     } else {
         if (!text.isEmpty()) {
             if (!icon.isNull()) {
                 locationEdit->insertItem(0, icon, text);
             } else {
                 if (!usePreviousPixmapIfNull) {
                     locationEdit->insertItem(0, QPixmap(), text);
                 } else {
                     locationEdit->insertItem(0, text);
                 }
             }
             dummyAdded = true;
             dummyExists = true;
         }
     }
 
     if (dummyExists && !text.isEmpty()) {
         locationEdit->setCurrentIndex(0);
     }
 
     locationEdit->lineEdit()->setCursorPosition(cursorPosition);
 
     QObject::connect(locationEdit, SIGNAL(editTextChanged(QString)),
                      q, SLOT(_k_slotLocationChanged(QString)));
 }
 
 void KFileWidgetPrivate::removeDummyHistoryEntry()
 {
     if (!dummyAdded) {
         return;
     }
 
     // setCurrentItem() will cause textChanged() being emitted,
     // so slotLocationChanged() will be called. Make sure we don't clear
     // the KDirOperator's view-selection in there
     QObject::disconnect(locationEdit, SIGNAL(editTextChanged(QString)),
                         q, SLOT(_k_slotLocationChanged(QString)));
 
     if (locationEdit->count()) {
         locationEdit->removeItem(0);
     }
     locationEdit->setCurrentIndex(-1);
     dummyAdded = false;
 
     QObject::connect(locationEdit, SIGNAL(editTextChanged(QString)),
                      q, SLOT(_k_slotLocationChanged(QString)));
 }
 
 void KFileWidgetPrivate::setLocationText(const QUrl &url)
 {
     if (!url.isEmpty()) {
         QPixmap mimeTypeIcon = KIconLoader::global()->loadMimeTypeIcon(KIO::iconNameForUrl(url), KIconLoader::Small);
         if (!url.isRelative()) {
             const QUrl directory = url.adjusted(QUrl::RemoveFilename);
             if (!directory.path().isEmpty()) {
                 q->setUrl(directory, false);
             } else {
                 q->setUrl(url, false);
             }
         }
         setDummyHistoryEntry(url.fileName(), mimeTypeIcon);
     } else {
         removeDummyHistoryEntry();
     }
 
     if (operationMode == KFileWidget::Saving) {
         setNonExtSelection();
     }
 }
 
 static QString relativePathOrUrl(const QUrl &baseUrl, const QUrl &url)
 {
     if (baseUrl.isParentOf(url)) {
         const QString basePath(QDir::cleanPath(baseUrl.path()));
         QString relPath(QDir::cleanPath(url.path()));
         relPath.remove(0, basePath.length());
         if (relPath.startsWith(QLatin1Char('/'))) {
             relPath = relPath.mid(1);
         }
         return relPath;
     } else {
         return url.toDisplayString();
     }
 }
 
 void KFileWidgetPrivate::setLocationText(const QList<QUrl> &urlList)
 {
     const QUrl currUrl = ops->url();
 
     if (urlList.count() > 1) {
         QString urls;
         foreach (const QUrl &url, urlList) {
             urls += QStringLiteral("\"%1\"").arg(relativePathOrUrl(currUrl, url)) + QLatin1Char(' ');
         }
         urls = urls.left(urls.size() - 1);
 
         setDummyHistoryEntry(urls, QPixmap(), false);
     } else if (urlList.count() == 1) {
         const QPixmap mimeTypeIcon = KIconLoader::global()->loadMimeTypeIcon(KIO::iconNameForUrl(urlList[0]),  KIconLoader::Small);
         setDummyHistoryEntry(relativePathOrUrl(currUrl, urlList[0]), mimeTypeIcon);
     } else {
         removeDummyHistoryEntry();
     }
 
     if (operationMode == KFileWidget::Saving) {
         setNonExtSelection();
     }
 }
 
 void KFileWidgetPrivate::updateLocationWhatsThis()
 {
     QString whatsThisText;
     if (operationMode == KFileWidget::Saving) {
         whatsThisText = QLatin1String("<qt>") + i18n("This is the name to save the file as.") +
                         i18n(autocompletionWhatsThisText);
     } else if (ops->mode() & KFile::Files) {
         whatsThisText = QLatin1String("<qt>") + i18n("This is the list of files to open. More than "
                                       "one file can be specified by listing several "
                                       "files, separated by spaces.") +
                         i18n(autocompletionWhatsThisText);
     } else {
         whatsThisText = QLatin1String("<qt>") + i18n("This is the name of the file to open.") +
                         i18n(autocompletionWhatsThisText);
     }
 
     locationLabel->setWhatsThis(whatsThisText);
     locationEdit->setWhatsThis(whatsThisText);
 }
 
 void KFileWidgetPrivate::initSpeedbar()
 {
     if (placesDock) {
         return;
     }
 
     placesDock = new QDockWidget(i18nc("@title:window", "Places"), q);
     placesDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
     placesDock->setTitleBarWidget(new KDEPrivate::KFileWidgetDockTitleBar(placesDock));
 
     placesView = new KFilePlacesView(placesDock);
     placesView->setModel(model);
     placesView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
     placesView->setObjectName(QStringLiteral("url bar"));
     QObject::connect(placesView, SIGNAL(urlChanged(QUrl)),
                      q, SLOT(_k_enterUrl(QUrl)));
 
     // need to set the current url of the urlbar manually (not via urlEntered()
     // here, because the initial url of KDirOperator might be the same as the
     // one that will be set later (and then urlEntered() won't be emitted).
     // TODO: KDE5 ### REMOVE THIS when KDirOperator's initial URL (in the c'tor) is gone.
     placesView->setUrl(url);
 
     placesDock->setWidget(placesView);
     placesViewSplitter->insertWidget(0, placesDock);
 
     // initialize the size of the splitter
     placesViewWidth = configGroup.readEntry(SpeedbarWidth, placesView->sizeHint().width());
 
     // Needed for when the dialog is shown with the places panel initially hidden
     setPlacesViewSplitterSizes();
 
     QObject::connect(placesDock, SIGNAL(visibilityChanged(bool)),
                      q, SLOT(_k_toggleSpeedbar(bool)));
 }
 
 void KFileWidgetPrivate::setPlacesViewSplitterSizes()
 {
     if (placesViewWidth > 0) {
         QList<int> sizes = placesViewSplitter->sizes();
         sizes[0] = placesViewWidth;
         sizes[1] = q->width() - placesViewWidth - placesViewSplitter->handleWidth();
         placesViewSplitter->setSizes(sizes);
     }
 }
 
 void KFileWidgetPrivate::setLafBoxColumnWidth()
 {
     // In order to perfectly align the filename widget with KDirOperator's icon view
     // - placesViewWidth needs to account for the size of the splitter handle
     // - the lafBox grid layout spacing should only affect the label, but not the line edit
     const int adjustment = placesViewSplitter->handleWidth() - lafBox->horizontalSpacing();
     lafBox->setColumnMinimumWidth(0, placesViewWidth + adjustment);
 }
 
 void KFileWidgetPrivate::initGUI()
 {
     delete boxLayout; // deletes all sub layouts
 
     boxLayout = new QVBoxLayout(q);
     boxLayout->setMargin(0); // no additional margin to the already existing
 
     placesViewSplitter = new QSplitter(q);
     placesViewSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     placesViewSplitter->setChildrenCollapsible(false);
     boxLayout->addWidget(placesViewSplitter);
 
     QObject::connect(placesViewSplitter, SIGNAL(splitterMoved(int,int)),
                      q, SLOT(_k_placesViewSplitterMoved(int,int)));
     placesViewSplitter->insertWidget(0, opsWidget);
 
     vbox = new QVBoxLayout();
     vbox->setMargin(0);
     boxLayout->addLayout(vbox);
 
     lafBox = new QGridLayout();
 
     lafBox->addWidget(locationLabel, 0, 0, Qt::AlignVCenter | Qt::AlignRight);
     lafBox->addWidget(locationEdit, 0, 1, Qt::AlignVCenter);
     lafBox->addWidget(okButton, 0, 2, Qt::AlignVCenter);
 
     lafBox->addWidget(filterLabel, 1, 0, Qt::AlignVCenter | Qt::AlignRight);
     lafBox->addWidget(filterWidget, 1, 1, Qt::AlignVCenter);
     lafBox->addWidget(cancelButton, 1, 2, Qt::AlignVCenter);
 
     lafBox->setColumnStretch(1, 4);
 
     vbox->addLayout(lafBox);
 
     // add the Automatically Select Extension checkbox
     vbox->addWidget(autoSelectExtCheckBox);
 
     q->setTabOrder(ops, autoSelectExtCheckBox);
     q->setTabOrder(autoSelectExtCheckBox, locationEdit);
     q->setTabOrder(locationEdit, filterWidget);
     q->setTabOrder(filterWidget, okButton);
     q->setTabOrder(okButton, cancelButton);
     q->setTabOrder(cancelButton, urlNavigator);
     q->setTabOrder(urlNavigator, ops);
 }
 
 void KFileWidgetPrivate::_k_slotFilterChanged()
 {
 //     qDebug();
 
     filterDelayTimer.stop();
 
     QString filter = filterWidget->currentFilter();
     ops->clearFilter();
 
     if (filter.contains(QLatin1Char('/'))) {
         QStringList types = filter.split(QLatin1Char(' '), QString::SkipEmptyParts);
         types.prepend(QStringLiteral("inode/directory"));
         ops->setMimeFilter(types);
     } else if (filter.contains(QLatin1Char('*')) || filter.contains(QLatin1Char('?')) || filter.contains(QLatin1Char('['))) {
         ops->setNameFilter(filter);
     } else {
         ops->setNameFilter(QLatin1Char('*') + filter.replace(QLatin1Char(' '), QLatin1Char('*')) + QLatin1Char('*'));
     }
 
     updateAutoSelectExtension();
 
     ops->updateDir();
 
     emit q->filterChanged(filter);
 }
 
 void KFileWidget::setUrl(const QUrl &url, bool clearforward)
 {
 //     qDebug();
 
     d->ops->setUrl(url, clearforward);
 }
 
 // Protected
 void KFileWidgetPrivate::_k_urlEntered(const QUrl &url)
 {
 //     qDebug();
 
     QString filename = locationEditCurrentText();
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     if (pathCombo->count() != 0) { // little hack
         pathCombo->setUrl(url);
     }
 
     bool blocked = locationEdit->blockSignals(true);
     if (keepLocation) {
         QUrl currentUrl = urlFromString(filename);
         locationEdit->changeUrl(0, QIcon::fromTheme(KIO::iconNameForUrl(currentUrl)), currentUrl);
         locationEdit->lineEdit()->setModified(true);
     }
 
     locationEdit->blockSignals(blocked);
 
     urlNavigator->setLocationUrl(url);
 
     // is trigged in ctor before completion object is set
     KUrlCompletion *completion = dynamic_cast<KUrlCompletion *>(locationEdit->completionObject());
     if (completion) {
         completion->setDir(url);
     }
 
     if (placesView) {
         placesView->setUrl(url);
     }
 }
 
 void KFileWidgetPrivate::_k_locationAccepted(const QString &url)
 {
     Q_UNUSED(url);
 //     qDebug();
     q->slotOk();
 }
 
 void KFileWidgetPrivate::_k_enterUrl(const QUrl &url)
 {
 //     qDebug();
 
     // append '/' if needed: url combo does not add it
     // tokenize() expects it because it uses QUrl::adjusted(QUrl::RemoveFilename)
     QUrl u(url);
     if (!u.path().isEmpty() && !u.path().endsWith(QLatin1Char('/'))) {
         u.setPath(u.path() + QLatin1Char('/'));
     }
     q->setUrl(u);
 
     // We need to check window()->focusWidget() instead of locationEdit->hasFocus
     // because when the window is showing up locationEdit
     // may still not have focus but it'll be the one that will have focus when the window
     // gets it and we don't want to steal its focus either
     if (q->window()->focusWidget() != locationEdit) {
         ops->setFocus();
     }
 }
 
 void KFileWidgetPrivate::_k_enterUrl(const QString &url)
 {
 //     qDebug();
 
     _k_enterUrl(urlFromString(KUrlCompletion::replacedPath(url, true, true)));
 }
 
 bool KFileWidgetPrivate::toOverwrite(const QUrl &url)
 {
 //     qDebug();
 
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     KJobWidgets::setWindow(statJob, q);
     bool res = statJob->exec();
 
     if (res) {
         int ret = KMessageBox::warningContinueCancel(q,
                   i18n("The file \"%1\" already exists. Do you wish to overwrite it?",
                        url.fileName()), i18n("Overwrite File?"), KStandardGuiItem::overwrite(),
                   KStandardGuiItem::cancel(), QString(), KMessageBox::Notify | KMessageBox::Dangerous);
 
         if (ret != KMessageBox::Continue) {
             return false;
         }
         return true;
     }
 
     return true;
 }
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KFileWidget::setSelection(const QString &url)
 {
 //     qDebug() << "setSelection " << url;
 
     if (url.isEmpty()) {
         return;
     }
 
     QUrl u = d->getCompleteUrl(url);
     if (!u.isValid()) { // if it still is
         qWarning() << url << " is not a correct argument for setSelection!";
         return;
     }
 
     setSelectedUrl(urlFromString(url));
 }
 #endif
 
 void KFileWidget::setSelectedUrl(const QUrl &url)
 {
     // Honor protocols that do not support directory listing
     if (!url.isRelative() && !KProtocolManager::supportsListing(url)) {
         return;
     }
     d->setLocationText(url);
 }
 
 void KFileWidgetPrivate::_k_slotLoadingFinished()
 {
     const QString currentText = locationEdit->currentText();
     if (currentText.isEmpty()) {
         return;
     }
 
     ops->blockSignals(true);
     QUrl u(ops->url());
     if (currentText.startsWith(QLatin1Char('/')))
         u.setPath(currentText);
     else
         u.setPath(concatPaths(ops->url().path(), currentText));
     ops->setCurrentItem(u);
     ops->blockSignals(false);
 }
 
 void KFileWidgetPrivate::_k_fileCompletion(const QString &match)
 {
 //     qDebug();
 
     if (match.isEmpty() || locationEdit->currentText().contains(QLatin1Char('"'))) {
         return;
     }
 
     const QUrl url = urlFromString(match);
     const QPixmap pix = KIconLoader::global()->loadMimeTypeIcon(KIO::iconNameForUrl(url), KIconLoader::Small);
     setDummyHistoryEntry(locationEdit->currentText(), pix, !locationEdit->currentText().isEmpty());
 }
 
 void KFileWidgetPrivate::_k_slotLocationChanged(const QString &text)
 {
 //     qDebug();
 
     locationEdit->lineEdit()->setModified(true);
 
     if (text.isEmpty() && ops->view()) {
         ops->view()->clearSelection();
     }
 
     if (text.isEmpty()) {
         removeDummyHistoryEntry();
     } else {
         setDummyHistoryEntry(text);
     }
 
     if (!locationEdit->lineEdit()->text().isEmpty()) {
         const QList<QUrl> urlList(tokenize(text));
         ops->setCurrentItems(urlList);
     }
 
     updateFilter();
 }
 
 QUrl KFileWidget::selectedUrl() const
 {
 //     qDebug();
 
     if (d->inAccept) {
         return d->url;
     } else {
         return QUrl();
     }
 }
 
 QList<QUrl> KFileWidget::selectedUrls() const
 {
 //     qDebug();
 
     QList<QUrl> list;
     if (d->inAccept) {
         if (d->ops->mode() & KFile::Files) {
             list = d->parseSelectedUrls();
         } else {
             list.append(d->url);
         }
     }
     return list;
 }
 
 QList<QUrl> &KFileWidgetPrivate::parseSelectedUrls()
 {
 //     qDebug();
 
     if (filenames.isEmpty()) {
         return urlList;
     }
 
     urlList.clear();
     if (filenames.contains(QLatin1Char('/'))) {    // assume _one_ absolute filename
         QUrl u;
         if (containsProtocolSection(filenames)) {
             u = QUrl(filenames);
         } else {
             u.setPath(filenames);
         }
 
         if (u.isValid()) {
             urlList.append(u);
         } else
             KMessageBox::error(q,
                                i18n("The chosen filenames do not\n"
                                     "appear to be valid."),
                                i18n("Invalid Filenames"));
     }
 
     else {
         urlList = tokenize(filenames);
     }
 
     filenames.clear(); // indicate that we parsed that one
 
     return urlList;
 }
 
 // FIXME: current implementation drawback: a filename can't contain quotes
 QList<QUrl> KFileWidgetPrivate::tokenize(const QString &line) const
 {
 //     qDebug();
 
     QList<QUrl> urls;
     QUrl u(ops->url());
     if (!u.path().endsWith(QLatin1Char('/'))) {
         u.setPath(u.path() + QLatin1Char('/'));
     }
     QString name;
 
     const int count = line.count(QLatin1Char('"'));
     if (count == 0) {   // no " " -> assume one single file
         if (!QDir::isAbsolutePath(line)) {
             u = u.adjusted(QUrl::RemoveFilename);
             u.setPath(u.path() + line);
             if (u.isValid()) {
                 urls.append(u);
             }
         } else {
             urls << QUrl::fromLocalFile(line);
         }
 
         return urls;
     }
 
     int start = 0;
     int index1 = -1, index2 = -1;
     while (true) {
         index1 = line.indexOf(QLatin1Char('"'), start);
         index2 = line.indexOf(QLatin1Char('"'), index1 + 1);
 
         if (index1 < 0 || index2 < 0) {
             break;
         }
 
         // get everything between the " "
         name = line.mid(index1 + 1, index2 - index1 - 1);
 
         // since we use setPath we need to do this under a temporary url
         QUrl _u(u);
         QUrl currUrl(name);
 
         if (!QDir::isAbsolutePath(currUrl.url())) {
             _u = _u.adjusted(QUrl::RemoveFilename);
             _u.setPath(_u.path() + name);
         } else {
             // we allow to insert various absolute paths like:
             // "/home/foo/bar.txt" "/boot/grub/menu.lst"
             _u = currUrl;
         }
 
         if (_u.isValid()) {
             urls.append(_u);
         }
 
         start = index2 + 1;
     }
 
     return urls;
 }
 
 QString KFileWidget::selectedFile() const
 {
 //     qDebug();
 
     if (d->inAccept) {
         const QUrl url = d->mostLocalUrl(d->url);
         if (url.isLocalFile()) {
             return url.toLocalFile();
         } else {
             KMessageBox::sorry(const_cast<KFileWidget *>(this),
                                i18n("You can only select local files."),
                                i18n("Remote Files Not Accepted"));
         }
     }
     return QString();
 }
 
 QStringList KFileWidget::selectedFiles() const
 {
 //     qDebug();
 
     QStringList list;
 
     if (d->inAccept) {
         if (d->ops->mode() & KFile::Files) {
             const QList<QUrl> urls = d->parseSelectedUrls();
             QList<QUrl>::const_iterator it = urls.begin();
             while (it != urls.end()) {
                 QUrl url = d->mostLocalUrl(*it);
                 if (url.isLocalFile()) {
                     list.append(url.toLocalFile());
                 }
                 ++it;
             }
         }
 
         else { // single-selection mode
             if (d->url.isLocalFile()) {
                 list.append(d->url.toLocalFile());
             }
         }
     }
 
     return list;
 }
 
 QUrl KFileWidget::baseUrl() const
 {
     return d->ops->url();
 }
 
 void KFileWidget::resizeEvent(QResizeEvent *event)
 {
     QWidget::resizeEvent(event);
 
     if (d->placesDock) {
         // we don't want our places dock actually changing size when we resize
         // and qt doesn't make it easy to enforce such a thing with QSplitter
         d->setPlacesViewSplitterSizes();
     }
 }
 
 void KFileWidget::showEvent(QShowEvent *event)
 {
     if (!d->hasView) {   // delayed view-creation
         Q_ASSERT(d);
         Q_ASSERT(d->ops);
         d->ops->setView(KFile::Default);
         d->ops->view()->setSizePolicy(QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
         d->hasView = true;
 
         connect(d->ops->view(), SIGNAL(doubleClicked(QModelIndex)), this, SLOT(_k_slotViewDoubleClicked(QModelIndex)));
     }
     d->ops->clearHistory();
 
     QWidget::showEvent(event);
 }
 
 bool KFileWidget::eventFilter(QObject *watched, QEvent *event)
 {
     const bool res = QWidget::eventFilter(watched, event);
 
     QKeyEvent *keyEvent = dynamic_cast<QKeyEvent *>(event);
     if (watched == d->iconSizeSlider && keyEvent) {
         if (keyEvent->key() == Qt::Key_Left || keyEvent->key() == Qt::Key_Up ||
                 keyEvent->key() == Qt::Key_Right || keyEvent->key() == Qt::Key_Down) {
             d->_k_slotIconSizeSliderMoved(d->iconSizeSlider->value());
         }
     } else if (watched == d->locationEdit && event->type() == QEvent::KeyPress) {
         if (keyEvent->modifiers() & Qt::AltModifier) {
             switch (keyEvent->key()) {
             case Qt::Key_Up:
                 d->ops->actionCollection()->action(QStringLiteral("up"))->trigger();
                 break;
             case Qt::Key_Left:
                 d->ops->actionCollection()->action(QStringLiteral("back"))->trigger();
                 break;
             case Qt::Key_Right:
                 d->ops->actionCollection()->action(QStringLiteral("forward"))->trigger();
                 break;
             default:
                 break;
             }
         }
     }
 
     return res;
 }
 
 void KFileWidget::setMode(KFile::Modes m)
 {
 //     qDebug();
 
     d->ops->setMode(m);
     if (d->ops->dirOnlyMode()) {
         d->filterWidget->setDefaultFilter(i18n("*|All Folders"));
     } else {
         d->filterWidget->setDefaultFilter(i18n("*|All Files"));
     }
 
     d->updateAutoSelectExtension();
 }
 
 KFile::Modes KFileWidget::mode() const
 {
     return d->ops->mode();
 }
 
 void KFileWidgetPrivate::readViewConfig()
 {
     ops->setViewConfig(configGroup);
     ops->readConfig(configGroup);
     KUrlComboBox *combo = urlNavigator->editor();
 
     autoDirectoryFollowing = configGroup.readEntry(AutoDirectoryFollowing,
                              DefaultDirectoryFollowing);
 
     KCompletion::CompletionMode cm = (KCompletion::CompletionMode)
                                      configGroup.readEntry(PathComboCompletionMode,
                                              static_cast<int>(KCompletion::CompletionPopup));
     if (cm != KCompletion::CompletionPopup) {
         combo->setCompletionMode(cm);
     }
 
     cm = (KCompletion::CompletionMode)
          configGroup.readEntry(LocationComboCompletionMode,
                                static_cast<int>(KCompletion::CompletionPopup));
     if (cm != KCompletion::CompletionPopup) {
         locationEdit->setCompletionMode(cm);
     }
 
     // show or don't show the speedbar
     _k_toggleSpeedbar(configGroup.readEntry(ShowSpeedbar, true));
 
     // show or don't show the bookmarks
     _k_toggleBookmarks(configGroup.readEntry(ShowBookmarks, false));
 
     // does the user want Automatically Select Extension?
     autoSelectExtChecked = configGroup.readEntry(AutoSelectExtChecked, DefaultAutoSelectExtChecked);
     updateAutoSelectExtension();
 
     // should the URL navigator use the breadcrumb navigation?
     urlNavigator->setUrlEditable(!configGroup.readEntry(BreadcrumbNavigation, true));
 
     // should the URL navigator show the full path?
     urlNavigator->setShowFullPath(configGroup.readEntry(ShowFullPath, false));
 
     int w1 = q->minimumSize().width();
     int w2 = toolbar->sizeHint().width();
     if (w1 < w2) {
         q->setMinimumWidth(w2);
     }
 }
 
 void KFileWidgetPrivate::writeViewConfig()
 {
     // these settings are global settings; ALL instances of the file dialog
     // should reflect them.
     // There is no way to tell KFileOperator::writeConfig() to write to
     // kdeglobals so we write settings to a temporary config group then copy
     // them all to kdeglobals
     KConfig tmp(QString(), KConfig::SimpleConfig);
     KConfigGroup tmpGroup(&tmp, ConfigGroup);
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     //saveDialogSize( tmpGroup, KConfigGroup::Persistent | KConfigGroup::Global );
     tmpGroup.writeEntry(PathComboCompletionMode, static_cast<int>(pathCombo->completionMode()));
     tmpGroup.writeEntry(LocationComboCompletionMode, static_cast<int>(locationEdit->completionMode()));
 
     const bool showSpeedbar = placesDock && !placesDock->isHidden();
     tmpGroup.writeEntry(ShowSpeedbar, showSpeedbar);
     if (placesViewWidth > 0) {
         tmpGroup.writeEntry(SpeedbarWidth, placesViewWidth);
     }
 
     tmpGroup.writeEntry(ShowBookmarks, bookmarkHandler != nullptr);
     tmpGroup.writeEntry(AutoSelectExtChecked, autoSelectExtChecked);
     tmpGroup.writeEntry(BreadcrumbNavigation, !urlNavigator->isUrlEditable());
     tmpGroup.writeEntry(ShowFullPath, urlNavigator->showFullPath());
 
     ops->writeConfig(tmpGroup);
 
     // Copy saved settings to kdeglobals
     tmpGroup.copyTo(&configGroup, KConfigGroup::Persistent | KConfigGroup::Global);
 }
 
 void KFileWidgetPrivate::readRecentFiles()
 {
 //     qDebug();
 
     QObject::disconnect(locationEdit, SIGNAL(editTextChanged(QString)),
                         q, SLOT(_k_slotLocationChanged(QString)));
 
     locationEdit->setMaxItems(configGroup.readEntry(RecentFilesNumber, DefaultRecentURLsNumber));
     locationEdit->setUrls(configGroup.readPathEntry(RecentFiles, QStringList()),
                           KUrlComboBox::RemoveBottom);
     locationEdit->setCurrentIndex(-1);
 
     QObject::connect(locationEdit, SIGNAL(editTextChanged(QString)),
                      q, SLOT(_k_slotLocationChanged(QString)));
 
     KUrlComboBox *combo = urlNavigator->editor();
     combo->setUrls(configGroup.readPathEntry(RecentURLs, QStringList()), KUrlComboBox::RemoveTop);
     combo->setMaxItems(configGroup.readEntry(RecentURLsNumber, DefaultRecentURLsNumber));
     combo->setUrl(ops->url());
     // since we delayed this moment, initialize the directory of the completion object to
     // our current directory (that was very probably set on the constructor)
     KUrlCompletion *completion = dynamic_cast<KUrlCompletion *>(locationEdit->completionObject());
     if (completion) {
         completion->setDir(ops->url());
     }
 
 }
 
 void KFileWidgetPrivate::saveRecentFiles()
 {
 //     qDebug();
     configGroup.writePathEntry(RecentFiles, locationEdit->urls());
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     configGroup.writePathEntry(RecentURLs, pathCombo->urls());
 }
 
 QPushButton *KFileWidget::okButton() const
 {
     return d->okButton;
 }
 
 QPushButton *KFileWidget::cancelButton() const
 {
     return d->cancelButton;
 }
 
 // Called by KFileDialog
 void KFileWidget::slotCancel()
 {
     d->writeViewConfig();
     d->ops->close();
 }
 
 void KFileWidget::setKeepLocation(bool keep)
 {
     d->keepLocation = keep;
 }
 
 bool KFileWidget::keepsLocation() const
 {
     return d->keepLocation;
 }
 
 void KFileWidget::setOperationMode(OperationMode mode)
 {
 //     qDebug();
 
     d->operationMode = mode;
     d->keepLocation = (mode == Saving);
     d->filterWidget->setEditable(!d->hasDefaultFilter || mode != Saving);
     if (mode == Opening) {
         // don't use KStandardGuiItem::open() here which has trailing ellipsis!
         d->okButton->setText(i18n("&Open"));
         d->okButton->setIcon(QIcon::fromTheme(QStringLiteral("document-open")));
         // hide the new folder actions...usability team says they shouldn't be in open file dialog
         actionCollection()->removeAction(actionCollection()->action(QStringLiteral("mkdir")));
     } else if (mode == Saving) {
         KGuiItem::assign(d->okButton, KStandardGuiItem::save());
         d->setNonExtSelection();
     } else {
         KGuiItem::assign(d->okButton, KStandardGuiItem::ok());
     }
     d->updateLocationWhatsThis();
     d->updateAutoSelectExtension();
 
     if (d->ops) {
         d->ops->setIsSaving(mode == Saving);
     }
 }
 
 KFileWidget::OperationMode KFileWidget::operationMode() const
 {
     return d->operationMode;
 }
 
 void KFileWidgetPrivate::_k_slotAutoSelectExtClicked()
 {
 //     qDebug() << "slotAutoSelectExtClicked(): "
 //                          << autoSelectExtCheckBox->isChecked() << endl;
 
     // whether the _user_ wants it on/off
     autoSelectExtChecked = autoSelectExtCheckBox->isChecked();
 
     // update the current filename's extension
     updateLocationEditExtension(extension /* extension hasn't changed */);
 }
 
 void KFileWidgetPrivate::_k_placesViewSplitterMoved(int pos, int index)
 {
 //     qDebug();
 
     // we need to record the size of the splitter when the splitter changes size
     // so we can keep the places box the right size!
     if (placesDock && index == 1) {
         placesViewWidth = pos;
 //         qDebug() << "setting lafBox minwidth to" << placesViewWidth;
         setLafBoxColumnWidth();
     }
 }
 
 void KFileWidgetPrivate::_k_activateUrlNavigator()
 {
 //     qDebug();
 
     urlNavigator->setUrlEditable(!urlNavigator->isUrlEditable());
     if (urlNavigator->isUrlEditable()) {
         urlNavigator->setFocus();
         urlNavigator->editor()->lineEdit()->selectAll();
     }
 }
 
 void KFileWidgetPrivate::_k_zoomOutIconsSize()
 {
     const int currValue = ops->iconsZoom();
     const int futValue = qMax(0, currValue - 10);
     iconSizeSlider->setValue(futValue);
     _k_slotIconSizeSliderMoved(futValue);
 }
 
 void KFileWidgetPrivate::_k_zoomInIconsSize()
 {
     const int currValue = ops->iconsZoom();
     const int futValue = qMin(100, currValue + 10);
     iconSizeSlider->setValue(futValue);
     _k_slotIconSizeSliderMoved(futValue);
 }
 
 void KFileWidgetPrivate::_k_slotIconSizeChanged(int _value)
 {
     int maxSize = KIconLoader::SizeEnormous - KIconLoader::SizeSmall;
     int value = (maxSize * _value / 100) + KIconLoader::SizeSmall;
     switch (value) {
     case KIconLoader::SizeSmall:
     case KIconLoader::SizeSmallMedium:
     case KIconLoader::SizeMedium:
     case KIconLoader::SizeLarge:
     case KIconLoader::SizeHuge:
     case KIconLoader::SizeEnormous:
         iconSizeSlider->setToolTip(i18n("Icon size: %1 pixels (standard size)", value));
         break;
     default:
         iconSizeSlider->setToolTip(i18n("Icon size: %1 pixels", value));
         break;
     }
 }
 
 void KFileWidgetPrivate::_k_slotIconSizeSliderMoved(int _value)
 {
     // Force this to be called in case this slot is called first on the
     // slider move.
     _k_slotIconSizeChanged(_value);
 
     QPoint global(iconSizeSlider->rect().topLeft());
     global.ry() += iconSizeSlider->height() / 2;
     QHelpEvent toolTipEvent(QEvent::ToolTip, QPoint(0, 0), iconSizeSlider->mapToGlobal(global));
     QApplication::sendEvent(iconSizeSlider, &toolTipEvent);
 }
 
 void KFileWidgetPrivate::_k_slotViewDoubleClicked(const QModelIndex &index)
 {
     // double clicking to save should only work on files
-    if (operationMode == KFileWidget::Saving && index.isValid() && ops->selectedItems().first().isFile()) {
+    if (operationMode == KFileWidget::Saving && index.isValid() && ops->selectedItems().constFirst().isFile()) {
         q->slotOk();
     }
 }
 
 static QString getExtensionFromPatternList(const QStringList &patternList)
 {
 //     qDebug();
 
     QString ret;
 //     qDebug() << "\tgetExtension " << patternList;
 
     QStringList::ConstIterator patternListEnd = patternList.end();
     for (QStringList::ConstIterator it = patternList.begin();
             it != patternListEnd;
             ++it) {
 //         qDebug() << "\t\ttry: \'" << (*it) << "\'";
 
         // is this pattern like "*.BMP" rather than useless things like:
         //
         // README
         // *.
         // *.*
         // *.JP*G
         // *.JP?
         if ((*it).startsWith(QLatin1String("*.")) &&
                 (*it).length() > 2 &&
                 (*it).indexOf(QLatin1Char('*'), 2) < 0 && (*it).indexOf(QLatin1Char('?'), 2) < 0) {
             ret = (*it).mid(1);
             break;
         }
     }
 
     return ret;
 }
 
 static QString stripUndisplayable(const QString &string)
 {
     QString ret = string;
 
     ret.remove(QLatin1Char(':'));
     ret = KLocalizedString::removeAcceleratorMarker(ret);
 
     return ret;
 }
 
 //QString KFileWidget::currentFilterExtension()
 //{
 //    return d->extension;
 //}
 
 void KFileWidgetPrivate::updateAutoSelectExtension()
 {
     if (!autoSelectExtCheckBox) {
         return;
     }
 
     QMimeDatabase db;
     //
     // Figure out an extension for the Automatically Select Extension thing
     // (some Windows users apparently don't know what to do when confronted
     // with a text file called "COPYING" but do know what to do with
     // COPYING.txt ...)
     //
 
 //     qDebug() << "Figure out an extension: ";
     QString lastExtension = extension;
     extension.clear();
 
     // Automatically Select Extension is only valid if the user is _saving_ a _file_
     if ((operationMode == KFileWidget::Saving) && (ops->mode() & KFile::File)) {
         //
         // Get an extension from the filter
         //
 
         QString filter = filterWidget->currentFilter();
         if (!filter.isEmpty()) {
             // if the currently selected filename already has an extension which
             // is also included in the currently allowed extensions, keep it
             // otherwise use the default extension
             QString currentExtension = db.suffixForFileName(locationEditCurrentText());
             if (currentExtension.isEmpty()) {
                 currentExtension = locationEditCurrentText().section(QLatin1Char('.'), -1, -1);
             }
             // qDebug() << "filter:" << filter << "locationEdit:" << locationEditCurrentText() << "currentExtension:" << currentExtension;
 
             QString defaultExtension;
             QStringList extensionList;
 
             // e.g. "*.cpp"
             if (filter.indexOf(QLatin1Char('/')) < 0) {
                 extensionList = filter.split(QLatin1Char(' '), QString::SkipEmptyParts);
                 defaultExtension = getExtensionFromPatternList(extensionList);
             }
             // e.g. "text/html"
             else {
                 QMimeType mime = db.mimeTypeForName(filter);
                 if (mime.isValid()) {
                     extensionList = mime.globPatterns();
                     defaultExtension = mime.preferredSuffix();
                     if (!defaultExtension.isEmpty()) {
                         defaultExtension.prepend(QLatin1Char('.'));
                     }
                 }
             }
 
             if ((!currentExtension.isEmpty() && extensionList.contains(QLatin1String("*.") + currentExtension))
                     || filter == QStringLiteral("application/octet-stream")) {
                 extension = QLatin1Char('.') + currentExtension;
             } else {
                 extension = defaultExtension;
             }
 
             // qDebug() << "List:" << extensionList << "auto-selected extension:" << extension;
         }
 
         //
         // GUI: checkbox
         //
 
         QString whatsThisExtension;
         if (!extension.isEmpty()) {
             // remember: sync any changes to the string with below
             autoSelectExtCheckBox->setText(i18n("Automatically select filename e&xtension (%1)",  extension));
             whatsThisExtension = i18n("the extension <b>%1</b>",  extension);
 
             autoSelectExtCheckBox->setEnabled(true);
             autoSelectExtCheckBox->setChecked(autoSelectExtChecked);
         } else {
             // remember: sync any changes to the string with above
             autoSelectExtCheckBox->setText(i18n("Automatically select filename e&xtension"));
             whatsThisExtension = i18n("a suitable extension");
 
             autoSelectExtCheckBox->setChecked(false);
             autoSelectExtCheckBox->setEnabled(false);
         }
 
         const QString locationLabelText = stripUndisplayable(locationLabel->text());
         autoSelectExtCheckBox->setWhatsThis(QLatin1String("<qt>") +
                                             i18n(
                                                 "This option enables some convenient features for "
                                                 "saving files with extensions:<br />"
                                                 "<ol>"
                                                 "<li>Any extension specified in the <b>%1</b> text "
                                                 "area will be updated if you change the file type "
                                                 "to save in.<br />"
                                                 "<br /></li>"
                                                 "<li>If no extension is specified in the <b>%2</b> "
                                                 "text area when you click "
                                                 "<b>Save</b>, %3 will be added to the end of the "
                                                 "filename (if the filename does not already exist). "
                                                 "This extension is based on the file type that you "
                                                 "have chosen to save in.<br />"
                                                 "<br />"
                                                 "If you do not want KDE to supply an extension for the "
                                                 "filename, you can either turn this option off or you "
                                                 "can suppress it by adding a period (.) to the end of "
                                                 "the filename (the period will be automatically "
                                                 "removed)."
                                                 "</li>"
                                                 "</ol>"
                                                 "If unsure, keep this option enabled as it makes your "
                                                 "files more manageable."
                                                 ,
                                                 locationLabelText,
                                                 locationLabelText,
                                                 whatsThisExtension)
                                             + QLatin1String("</qt>")
                                            );
 
         autoSelectExtCheckBox->show();
 
         // update the current filename's extension
         updateLocationEditExtension(lastExtension);
     }
     // Automatically Select Extension not valid
     else {
         autoSelectExtCheckBox->setChecked(false);
         autoSelectExtCheckBox->hide();
     }
 }
 
 // Updates the extension of the filename specified in d->locationEdit if the
 // Automatically Select Extension feature is enabled.
 // (this prevents you from accidently saving "file.kwd" as RTF, for example)
 void KFileWidgetPrivate::updateLocationEditExtension(const QString &lastExtension)
 {
     if (!autoSelectExtCheckBox->isChecked() || extension.isEmpty()) {
         return;
     }
 
     QString urlStr = locationEditCurrentText();
     if (urlStr.isEmpty()) {
         return;
     }
 
     QUrl url = getCompleteUrl(urlStr);
 //     qDebug() << "updateLocationEditExtension (" << url << ")";
 
     const int fileNameOffset = urlStr.lastIndexOf(QLatin1Char('/')) + 1;
     QString fileName = urlStr.mid(fileNameOffset);
 
     const int dot = fileName.lastIndexOf(QLatin1Char('.'));
     const int len = fileName.length();
     if (dot > 0 && // has an extension already and it's not a hidden file
             // like ".hidden" (but we do accept ".hidden.ext")
             dot != len - 1 // and not deliberately suppressing extension
        ) {
         // exists?
         KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, q);
         bool result = statJob->exec();
         if (result) {
 //             qDebug() << "\tfile exists";
 
             if (statJob->statResult().isDir()) {
 //                 qDebug() << "\tisDir - won't alter extension";
                 return;
             }
 
             // --- fall through ---
         }
 
         //
         // try to get rid of the current extension
         //
 
         // catch "double extensions" like ".tar.gz"
         if (lastExtension.length() && fileName.endsWith(lastExtension)) {
             fileName.truncate(len - lastExtension.length());
         } else if (extension.length() && fileName.endsWith(extension)) {
             fileName.truncate(len - extension.length());
         }
         // can only handle "single extensions"
         else {
             fileName.truncate(dot);
         }
 
         // add extension
         const QString newText = urlStr.left(fileNameOffset) + fileName + extension;
         if (newText != locationEditCurrentText()) {
             locationEdit->setItemText(locationEdit->currentIndex(), urlStr.left(fileNameOffset) + fileName + extension);
             locationEdit->lineEdit()->setModified(true);
         }
     }
 }
 
 // Updates the filter if the extension of the filename specified in d->locationEdit is changed
 // (this prevents you from accidently saving "file.kwd" as RTF, for example)
 void KFileWidgetPrivate::updateFilter()
 {
 //     qDebug();
 
     if ((operationMode == KFileWidget::Saving) && (ops->mode() & KFile::File)) {
         QString urlStr = locationEditCurrentText();
         if (urlStr.isEmpty()) {
             return;
         }
 
         if (filterWidget->isMimeFilter()) {
             QMimeDatabase db;
             QMimeType mime = db.mimeTypeForFile(urlStr, QMimeDatabase::MatchExtension);
             if (mime.isValid() && !mime.isDefault()) {
                 if (filterWidget->currentFilter() != mime.name() &&
                         filterWidget->filters().indexOf(mime.name()) != -1) {
                     filterWidget->setCurrentFilter(mime.name());
                 }
             }
         } else {
             QString filename = urlStr.mid(urlStr.lastIndexOf(QLatin1Char('/')) + 1);     // only filename
             foreach (const QString &filter, filterWidget->filters()) {
                 QStringList patterns = filter.left(filter.indexOf(QLatin1Char('|'))).split(QLatin1Char(' '), QString::SkipEmptyParts);       // '*.foo *.bar|Foo type' -> '*.foo', '*.bar'
                 foreach (const QString &p, patterns) {
                     QRegExp rx(p);
                     rx.setPatternSyntax(QRegExp::Wildcard);
                     if (rx.exactMatch(filename)) {
                         if (p != QLatin1String("*")) {   // never match the catch-all filter
                             filterWidget->setCurrentFilter(filter);
                         }
                         return; // do not repeat, could match a later filter
                     }
                 }
             }
         }
     }
 }
 
 // applies only to a file that doesn't already exist
 void KFileWidgetPrivate::appendExtension(QUrl &url)
 {
 //     qDebug();
 
     if (!autoSelectExtCheckBox->isChecked() || extension.isEmpty()) {
         return;
     }
 
     QString fileName = url.fileName();
     if (fileName.isEmpty()) {
         return;
     }
 
 //     qDebug() << "appendExtension(" << url << ")";
 
     const int len = fileName.length();
     const int dot = fileName.lastIndexOf(QLatin1Char('.'));
 
     const bool suppressExtension = (dot == len - 1);
     const bool unspecifiedExtension = (dot <= 0);
 
     // don't KIO::Stat if unnecessary
     if (!(suppressExtension || unspecifiedExtension)) {
         return;
     }
 
     // exists?
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     KJobWidgets::setWindow(statJob, q);
     bool res = statJob->exec();
     if (res) {
 //         qDebug() << "\tfile exists - won't append extension";
         return;
     }
 
     // suppress automatically append extension?
     if (suppressExtension) {
         //
         // Strip trailing dot
         // This allows lazy people to have autoSelectExtCheckBox->isChecked
         // but don't want a file extension to be appended
         // e.g. "README." will make a file called "README"
         //
         // If you really want a name like "README.", then type "README.."
         // and the trailing dot will be removed (or just stop being lazy and
         // turn off this feature so that you can type "README.")
         //
 //         qDebug() << "\tstrip trailing dot";
         QString path = url.path();
         path.chop(1);
         url.setPath(path);
     }
     // evilmatically append extension :) if the user hasn't specified one
     else if (unspecifiedExtension) {
 //         qDebug() << "\tappending extension \'" << extension << "\'...";
         url = url.adjusted(QUrl::RemoveFilename); // keeps trailing slash
         url.setPath(url.path() + fileName + extension);
 //         qDebug() << "\tsaving as \'" << url << "\'";
     }
 }
 
 // adds the selected files/urls to 'recent documents'
 void KFileWidgetPrivate::addToRecentDocuments()
 {
     int m = ops->mode();
     int atmost = KRecentDocument::maximumItems();
     //don't add more than we need. KRecentDocument::add() is pretty slow
 
     if (m & KFile::LocalOnly) {
         const QStringList files = q->selectedFiles();
         QStringList::ConstIterator it = files.begin();
         for (; it != files.end() && atmost > 0; ++it) {
             KRecentDocument::add(QUrl::fromLocalFile(*it));
             atmost--;
         }
     }
 
     else { // urls
         const QList<QUrl> urls = q->selectedUrls();
         QList<QUrl>::ConstIterator it = urls.begin();
         for (; it != urls.end() && atmost > 0; ++it) {
             if ((*it).isValid()) {
                 KRecentDocument::add(*it);
                 atmost--;
             }
         }
     }
 }
 
 KUrlComboBox *KFileWidget::locationEdit() const
 {
     return d->locationEdit;
 }
 
 KFileFilterCombo *KFileWidget::filterWidget() const
 {
     return d->filterWidget;
 }
 
 KActionCollection *KFileWidget::actionCollection() const
 {
     return d->ops->actionCollection();
 }
 
 void KFileWidgetPrivate::_k_toggleSpeedbar(bool show)
 {
     if (show) {
         initSpeedbar();
         placesDock->show();
         setLafBoxColumnWidth();
 
         // check to see if they have a home item defined, if not show the home button
         QUrl homeURL;
         homeURL.setPath(QDir::homePath());
         KFilePlacesModel *model = static_cast<KFilePlacesModel *>(placesView->model());
         for (int rowIndex = 0; rowIndex < model->rowCount(); rowIndex++) {
             QModelIndex index = model->index(rowIndex, 0);
             QUrl url = model->url(index);
 
             if (homeURL.matches(url, QUrl::StripTrailingSlash)) {
                 toolbar->removeAction(ops->actionCollection()->action(QStringLiteral("home")));
                 break;
             }
         }
     } else {
         if (q->sender() == placesDock && placesDock && placesDock->isVisibleTo(q)) {
             // we didn't *really* go away! the dialog was simply hidden or
             // we changed virtual desktops or ...
             return;
         }
 
         if (placesDock) {
             placesDock->hide();
         }
 
         QAction *homeAction = ops->actionCollection()->action(QStringLiteral("home"));
         QAction *reloadAction = ops->actionCollection()->action(QStringLiteral("reload"));
         if (!toolbar->actions().contains(homeAction)) {
             toolbar->insertAction(reloadAction, homeAction);
         }
 
         // reset the lafbox to not follow the width of the splitter
         lafBox->setColumnMinimumWidth(0, 0);
     }
 
     static_cast<KToggleAction *>(q->actionCollection()->action(QStringLiteral("toggleSpeedbar")))->setChecked(show);
 
     // if we don't show the places panel, at least show the places menu
     urlNavigator->setPlacesSelectorVisible(!show);
 }
 
 void KFileWidgetPrivate::_k_toggleBookmarks(bool show)
 {
     if (show) {
         if (bookmarkHandler) {
             return;
         }
 
         bookmarkHandler = new KFileBookmarkHandler(q);
         q->connect(bookmarkHandler, SIGNAL(openUrl(QString)),
                    SLOT(_k_enterUrl(QString)));
 
         bookmarkButton = new KActionMenu(QIcon::fromTheme(QStringLiteral("bookmarks")), i18n("Bookmarks"), q);
         bookmarkButton->setDelayed(false);
         q->actionCollection()->addAction(QStringLiteral("bookmark"), bookmarkButton);
         bookmarkButton->setMenu(bookmarkHandler->menu());
         bookmarkButton->setWhatsThis(i18n("<qt>This button allows you to bookmark specific locations. "
                                           "Click on this button to open the bookmark menu where you may add, "
                                           "edit or select a bookmark.<br /><br />"
                                           "These bookmarks are specific to the file dialog, but otherwise operate "
                                           "like bookmarks elsewhere in KDE.</qt>"));
         toolbar->addAction(bookmarkButton);
     } else if (bookmarkHandler) {
         delete bookmarkHandler;
         bookmarkHandler = nullptr;
         delete bookmarkButton;
         bookmarkButton = nullptr;
     }
 
     static_cast<KToggleAction *>(q->actionCollection()->action(QStringLiteral("toggleBookmarks")))->setChecked(show);
 }
 
 // static, overloaded
 QUrl KFileWidget::getStartUrl(const QUrl &startDir,
                               QString &recentDirClass)
 {
     QString fileName;                   // result discarded
     return getStartUrl(startDir, recentDirClass, fileName);
 }
 
 // static, overloaded
 QUrl KFileWidget::getStartUrl(const QUrl &startDir,
                               QString &recentDirClass,
                               QString &fileName)
 {
     recentDirClass.clear();
     fileName.clear();
     QUrl ret;
 
     bool useDefaultStartDir = startDir.isEmpty();
     if (!useDefaultStartDir) {
         if (startDir.scheme() == QLatin1String("kfiledialog")) {
 
 //  The startDir URL with this protocol may be in the format:
 //                                                    directory()   fileName()
 //  1.  kfiledialog:///keyword                           "/"         keyword
 //  2.  kfiledialog:///keyword?global                    "/"         keyword
 //  3.  kfiledialog:///keyword/                          "/"         keyword
 //  4.  kfiledialog:///keyword/?global                   "/"         keyword
 //  5.  kfiledialog:///keyword/filename                /keyword      filename
 //  6.  kfiledialog:///keyword/filename?global         /keyword      filename
 
             QString keyword;
             QString urlDir = startDir.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path();
             QString urlFile = startDir.fileName();
             if (urlDir == QLatin1String("/")) {         // '1'..'4' above
                 keyword = urlFile;
                 fileName.clear();
             } else {                // '5' or '6' above
                 keyword = urlDir.mid(1);
                 fileName = urlFile;
             }
 
             if (startDir.query() == QLatin1String("global")) {
                 recentDirClass = QStringLiteral("::%1").arg(keyword);
             } else {
                 recentDirClass = QStringLiteral(":%1").arg(keyword);
             }
 
             ret = QUrl::fromLocalFile(KRecentDirs::dir(recentDirClass));
         } else {                    // not special "kfiledialog" URL
             // "foo.png" only gives us a file name, the default start dir will be used.
             // "file:foo.png" (from KHTML/webkit, due to fromPath()) means the same
             //   (and is the reason why we don't just use QUrl::isRelative()).
 
             // In all other cases (startDir contains a directory path, or has no
             // fileName for us anyway, such as smb://), startDir is indeed a dir url.
 
             if (!startDir.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path().isEmpty() ||
                     startDir.fileName().isEmpty()) {
                 // can use start directory
                 ret = startDir;             // will be checked by stat later
                 // If we won't be able to list it (e.g. http), then use default
                 if (!KProtocolManager::supportsListing(ret)) {
                     useDefaultStartDir = true;
                     fileName = startDir.fileName();
                 }
             } else {                // file name only
                 fileName = startDir.fileName();
                 useDefaultStartDir = true;
             }
         }
     }
 
     if (useDefaultStartDir) {
         if (lastDirectory()->isEmpty()) {
             *lastDirectory() = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
             const QUrl home(QUrl::fromLocalFile(QDir::homePath()));
             // if there is no docpath set (== home dir), we prefer the current
             // directory over it. We also prefer the homedir when our CWD is
             // different from our homedirectory or when the document dir
             // does not exist
             if (lastDirectory()->adjusted(QUrl::StripTrailingSlash) == home.adjusted(QUrl::StripTrailingSlash) ||
                     QDir::currentPath() != QDir::homePath() ||
                     !QDir(lastDirectory()->toLocalFile()).exists()) {
                 *lastDirectory() = QUrl::fromLocalFile(QDir::currentPath());
             }
         }
         ret = *lastDirectory();
     }
 
     // qDebug() << "for" << startDir << "->" << ret << "recentDirClass" << recentDirClass << "fileName" << fileName;
     return ret;
 }
 
 void KFileWidget::setStartDir(const QUrl &directory)
 {
     if (directory.isValid()) {
         *lastDirectory() = directory;
     }
 }
 
 void KFileWidgetPrivate::setNonExtSelection()
 {
     // Enhanced rename: Don't highlight the file extension.
     QString filename = locationEditCurrentText();
     QMimeDatabase db;
     QString extension = db.suffixForFileName(filename);
 
     if (!extension.isEmpty()) {
         locationEdit->lineEdit()->setSelection(0, filename.length() - extension.length() - 1);
     } else {
         int lastDot = filename.lastIndexOf(QLatin1Char('.'));
         if (lastDot > 0) {
             locationEdit->lineEdit()->setSelection(0, lastDot);
         } else {
             locationEdit->lineEdit()->selectAll();
         }
     }
 }
 
 KToolBar *KFileWidget::toolBar() const
 {
     return d->toolbar;
 }
 
 void KFileWidget::setCustomWidget(QWidget *widget)
 {
     delete d->bottomCustomWidget;
     d->bottomCustomWidget = widget;
 
     // add it to the dialog, below the filter list box.
 
     // Change the parent so that this widget is a child of the main widget
     d->bottomCustomWidget->setParent(this);
 
     d->vbox->addWidget(d->bottomCustomWidget);
     //d->vbox->addSpacing(3); // can't do this every time...
 
     // FIXME: This should adjust the tab orders so that the custom widget
     // comes after the Cancel button. The code appears to do this, but the result
     // somehow screws up the tab order of the file path combo box. Not a major
     // problem, but ideally the tab order with a custom widget should be
     // the same as the order without one.
     setTabOrder(d->cancelButton, d->bottomCustomWidget);
     setTabOrder(d->bottomCustomWidget, d->urlNavigator);
 }
 
 void KFileWidget::setCustomWidget(const QString &text, QWidget *widget)
 {
     delete d->labeledCustomWidget;
     d->labeledCustomWidget = widget;
 
     QLabel *label = new QLabel(text, this);
     label->setAlignment(Qt::AlignRight);
     d->lafBox->addWidget(label, 2, 0, Qt::AlignVCenter);
     d->lafBox->addWidget(widget, 2, 1, Qt::AlignVCenter);
 }
 
 KDirOperator *KFileWidget::dirOperator()
 {
     return d->ops;
 }
 
 void KFileWidget::readConfig(KConfigGroup &group)
 {
     d->configGroup = group;
     d->readViewConfig();
     d->readRecentFiles();
 }
 
 QString KFileWidgetPrivate::locationEditCurrentText() const
 {
     return QDir::fromNativeSeparators(locationEdit->currentText());
 }
 
 QUrl KFileWidgetPrivate::mostLocalUrl(const QUrl &url)
 {
     if (url.isLocalFile()) {
         return url;
     }
 
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     KJobWidgets::setWindow(statJob, q);
     bool res = statJob->exec();
 
     if (!res) {
         return url;
     }
 
     const QString path = statJob->statResult().stringValue(KIO::UDSEntry::UDS_LOCAL_PATH);
     if (!path.isEmpty()) {
         QUrl newUrl;
         newUrl.setPath(path);
         return newUrl;
     }
 
     return url;
 }
 
 void KFileWidgetPrivate::setInlinePreviewShown(bool show)
 {
     ops->setInlinePreviewShown(show);
 }
 
 void KFileWidget::setConfirmOverwrite(bool enable)
 {
     d->confirmOverwrite = enable;
 }
 
 void KFileWidget::setInlinePreviewShown(bool show)
 {
     d->setInlinePreviewShown(show);
 }
 
 QSize KFileWidget::dialogSizeHint() const
 {
     int fontSize = fontMetrics().height();
     QSize goodSize(48 * fontSize, 30 * fontSize);
     QSize screenSize = QApplication::desktop()->availableGeometry(this).size();
     QSize minSize(screenSize / 2);
     QSize maxSize(screenSize * qreal(0.9));
     return (goodSize.expandedTo(minSize).boundedTo(maxSize));
 }
 
 void KFileWidget::setViewMode(KFile::FileView mode)
 {
     d->ops->setView(mode);
     d->hasView = true;
 }
 
 void KFileWidget::setSupportedSchemes(const QStringList &schemes)
 {
     d->model->setSupportedSchemes(schemes);
     d->ops->setSupportedSchemes(schemes);
     d->urlNavigator->setCustomProtocols(schemes);
 }
 
 QStringList KFileWidget::supportedSchemes() const
 {
     return d->model->supportedSchemes();
 }
 
 #include "moc_kfilewidget.cpp"
diff --git a/src/kpac/proxyscout.cpp b/src/kpac/proxyscout.cpp
index 47471742..662035c0 100644
--- a/src/kpac/proxyscout.cpp
+++ b/src/kpac/proxyscout.cpp
@@ -1,363 +1,363 @@
 /*
    Copyright (c) 2003 Malte Starostik <malte@kde.org>
    Copyright (c) 2011 Dawit Alemayehu <adawit@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "proxyscout.h"
 
 #include "config-kpac.h"
 
 #include "discovery.h"
 #include "script.h"
 
 #include <QDebug>
 #include <klocalizedstring.h>
 #include <kprotocolmanager.h>
 #include <kpluginfactory.h>
 #include <kpluginloader.h>
 
 #ifdef HAVE_KF5NOTIFICATIONS
 #include <knotification.h>
 #endif
 
 #include <QNetworkConfigurationManager>
 
 #include <QFileSystemWatcher>
 #include <QDBusConnection>
 
 #include <cstdlib>
 #include <ctime>
 
 K_PLUGIN_FACTORY_WITH_JSON(ProxyScoutFactory,
                            "proxyscout.json",
                            registerPlugin<KPAC::ProxyScout>();)
 
 namespace KPAC
 {
 enum ProxyType {
     Unknown = -1,
     Proxy,
     Socks,
     Direct
 };
 
 static ProxyType proxyTypeFor(const QString &mode)
 {
     if (mode.compare(QLatin1String("PROXY"), Qt::CaseInsensitive) == 0) {
         return Proxy;
     }
 
     if (mode.compare(QLatin1String("DIRECT"), Qt::CaseInsensitive) == 0) {
         return Direct;
     }
 
     if (mode.compare(QLatin1String("SOCKS"), Qt::CaseInsensitive) == 0 ||
             mode.compare(QLatin1String("SOCKS5"), Qt::CaseInsensitive) == 0) {
         return Socks;
     }
 
     return Unknown;
 }
 
 ProxyScout::QueuedRequest::QueuedRequest(const QDBusMessage &reply, const QUrl &u, bool sendall)
     : transaction(reply), url(u), sendAll(sendall)
 {
 }
 
 ProxyScout::ProxyScout(QObject *parent, const QList<QVariant> &)
     : KDEDModule(parent),
       m_componentName(QStringLiteral("proxyscout")),
       m_downloader(nullptr),
       m_script(nullptr),
       m_suspendTime(0),
       m_watcher(nullptr),
       m_networkConfig(new QNetworkConfigurationManager(this))
 {
     connect(m_networkConfig, SIGNAL(configurationChanged(QNetworkConfiguration)), SLOT(disconnectNetwork(QNetworkConfiguration)));
 }
 
 ProxyScout::~ProxyScout()
 {
     delete m_script;
 }
 
 QStringList ProxyScout::proxiesForUrl(const QString &checkUrl, const QDBusMessage &msg)
 {
     QUrl url(checkUrl);
 
     if (m_suspendTime) {
         if (std::time(nullptr) - m_suspendTime < 300) {
             return QStringList(QStringLiteral("DIRECT"));
         }
         m_suspendTime = 0;
     }
 
     // Never use a proxy for the script itself
     if (m_downloader && url.matches(m_downloader->scriptUrl(), QUrl::StripTrailingSlash)) {
         return QStringList(QStringLiteral("DIRECT"));
     }
 
     if (m_script) {
         return handleRequest(url);
     }
 
     if (m_downloader || startDownload()) {
         msg.setDelayedReply(true);
         m_requestQueue.append(QueuedRequest(msg, url, true));
         return QStringList();   // return value will be ignored
     }
 
     return QStringList(QStringLiteral("DIRECT"));
 }
 
 QString ProxyScout::proxyForUrl(const QString &checkUrl, const QDBusMessage &msg)
 {
     QUrl url(checkUrl);
 
     if (m_suspendTime) {
         if (std::time(nullptr) - m_suspendTime < 300) {
             return QStringLiteral("DIRECT");
         }
         m_suspendTime = 0;
     }
 
     // Never use a proxy for the script itself
     if (m_downloader && url.matches(m_downloader->scriptUrl(), QUrl::StripTrailingSlash)) {
         return QStringLiteral("DIRECT");
     }
 
     if (m_script) {
-        return handleRequest(url).first();
+        return handleRequest(url).constFirst();
     }
 
     if (m_downloader || startDownload()) {
         msg.setDelayedReply(true);
         m_requestQueue.append(QueuedRequest(msg, url));
         return QString();   // return value will be ignored
     }
 
     return QStringLiteral("DIRECT");
 }
 
 void ProxyScout::blackListProxy(const QString &proxy)
 {
     m_blackList[ proxy ] = std::time(nullptr);
 }
 
 void ProxyScout::reset()
 {
     delete m_script;
     m_script = nullptr;
     delete m_downloader;
     m_downloader = nullptr;
     delete m_watcher;
     m_watcher = nullptr;
     m_blackList.clear();
     m_suspendTime = 0;
     KProtocolManager::reparseConfiguration();
 }
 
 bool ProxyScout::startDownload()
 {
     switch (KProtocolManager::proxyType()) {
     case KProtocolManager::WPADProxy:
         if (m_downloader && !qobject_cast<Discovery *>(m_downloader)) {
             delete m_downloader;
             m_downloader = nullptr;
         }
         if (!m_downloader) {
             m_downloader = new Discovery(this);
             connect(m_downloader, SIGNAL(result(bool)), this, SLOT(downloadResult(bool)));
         }
         break;
     case KProtocolManager::PACProxy: {
         if (m_downloader && !qobject_cast<Downloader *>(m_downloader)) {
             delete m_downloader;
             m_downloader = nullptr;
         }
         if (!m_downloader) {
             m_downloader = new Downloader(this);
             connect(m_downloader, SIGNAL(result(bool)), this, SLOT(downloadResult(bool)));
         }
 
         const QUrl url(KProtocolManager::proxyConfigScript());
         if (url.isLocalFile()) {
             if (!m_watcher) {
                 m_watcher = new QFileSystemWatcher(this);
                 connect(m_watcher, SIGNAL(fileChanged(QString)), SLOT(proxyScriptFileChanged(QString)));
             }
             proxyScriptFileChanged(url.path());
         } else {
             delete m_watcher;
             m_watcher = nullptr;
             m_downloader->download(url);
         }
         break;
     }
     default:
         return false;
     }
 
     return true;
 }
 
 void ProxyScout::disconnectNetwork(const QNetworkConfiguration &config)
 {
     // NOTE: We only care of Defined state because we only want
     //to redo WPAD when a network interface is brought out of
     //hibernation or restarted for whatever reason.
     if (config.state() == QNetworkConfiguration::Defined) {
         reset();
     }
 }
 
 void ProxyScout::downloadResult(bool success)
 {
     if (success) {
         try {
             if (!m_script) {
                 m_script = new Script(m_downloader->script());
             }
         } catch (const Script::Error &e) {
             qWarning() << "Error:" << e.message();
 #ifdef HAVE_KF5NOTIFICATIONS
             KNotification *notify = new KNotification(QStringLiteral("script-error"));
             notify->setText(i18n("The proxy configuration script is invalid:\n%1", e.message()));
             notify->setComponentName(m_componentName);
             notify->sendEvent();
 #endif
             success = false;
         }
     } else {
 #ifdef HAVE_KF5NOTIFICATIONS
         KNotification *notify = new KNotification(QStringLiteral("download-error"));
         notify->setText(m_downloader->error());
         notify->setComponentName(m_componentName);
         notify->sendEvent();
 #endif
     }
 
     if (success) {
         for (RequestQueue::Iterator it = m_requestQueue.begin(), itEnd = m_requestQueue.end(); it != itEnd; ++it) {
             if ((*it).sendAll) {
                 const QVariant result(handleRequest((*it).url));
                 QDBusConnection::sessionBus().send((*it).transaction.createReply(result));
             } else {
-                const QVariant result(handleRequest((*it).url).first());
+                const QVariant result(handleRequest((*it).url).constFirst());
                 QDBusConnection::sessionBus().send((*it).transaction.createReply(result));
             }
         }
     } else {
         for (RequestQueue::Iterator it = m_requestQueue.begin(), itEnd = m_requestQueue.end(); it != itEnd; ++it) {
             QDBusConnection::sessionBus().send((*it).transaction.createReply(QLatin1String("DIRECT")));
         }
     }
 
     m_requestQueue.clear();
 
     // Suppress further attempts for 5 minutes
     if (!success) {
         m_suspendTime = std::time(nullptr);
     }
 }
 
 void ProxyScout::proxyScriptFileChanged(const QString &path)
 {
     // Should never get called if we do not have a watcher...
     Q_ASSERT(m_watcher);
 
     // Remove the current file being watched...
     if (!m_watcher->files().isEmpty()) {
         m_watcher->removePaths(m_watcher->files());
     }
 
     // NOTE: QFileSystemWatcher only adds a path if it either exists or
     // is not already being monitored.
     m_watcher->addPath(path);
 
     // Reload...
     m_downloader->download(QUrl::fromLocalFile(path));
 }
 
 QStringList ProxyScout::handleRequest(const QUrl &url)
 {
     try {
         QStringList proxyList;
         const QString result = m_script->evaluate(url).trimmed();
         const QStringList proxies = result.split(QLatin1Char(';'), QString::SkipEmptyParts);
         const int size = proxies.count();
 
         for (int i = 0; i < size; ++i) {
             QString mode, address;
             const QString proxy = proxies.at(i).trimmed();
             const int index = proxy.indexOf(QLatin1Char(' '));
             if (index == -1) { // Only "DIRECT" should match this!
                 mode = proxy;
                 address = proxy;
             } else {
                 mode = proxy.left(index);
                 address = proxy.mid(index + 1).trimmed();
             }
 
             const ProxyType type = proxyTypeFor(mode);
             if (type == Unknown) {
                 continue;
             }
 
             if (type == Proxy || type == Socks) {
                 const int index = address.indexOf(QLatin1Char(':'));
                 if (index == -1 || !KProtocolInfo::isKnownProtocol(address.left(index))) {
                     const QString protocol((type == Proxy ? QStringLiteral("http://") : QStringLiteral("socks://")));
                     const QUrl url(protocol + address);
                     if (url.isValid()) {
                         address = url.toString();
                     } else {
                         continue;
                     }
                 }
             }
 
             if (type == Direct || !m_blackList.contains(address)) {
                 proxyList << address;
             } else if (std::time(nullptr) - m_blackList[address] > 1800) { // 30 minutes
                 // black listing expired
                 m_blackList.remove(address);
                 proxyList << address;
             }
         }
 
         if (!proxyList.isEmpty()) {
             // qDebug() << proxyList;
             return proxyList;
         }
         // FIXME: blacklist
     } catch (const Script::Error &e) {
         qCritical() << e.message();
 #ifdef HAVE_KF5NOTIFICATIONS
         KNotification *n = new KNotification(QStringLiteral("evaluation-error"));
         n->setText(i18n("The proxy configuration script returned an error:\n%1", e.message()));
         n->setComponentName(m_componentName);
         n->sendEvent();
 #endif
     }
 
     return QStringList(QStringLiteral("DIRECT"));
 }
 }
 
 #include "proxyscout.moc"
diff --git a/src/widgets/kfileitemactions.cpp b/src/widgets/kfileitemactions.cpp
index 6312e60f..e00c3013 100644
--- a/src/widgets/kfileitemactions.cpp
+++ b/src/widgets/kfileitemactions.cpp
@@ -1,822 +1,822 @@
 /* This file is part of the KDE project
    Copyright (C) 1998-2009 David Faure <faure@kde.org>
 
    This library is free software; you can redistribute it and/or modify
    it under the terms of the GNU Library General Public License as published
    by the Free Software Foundation; either version 2 of the License or
    ( at your option ) version 3 or, at the discretion of KDE e.V.
    ( which shall act as a proxy as in section 14 of the GPLv3 ), any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "kfileitemactions.h"
 #include "kfileitemactions_p.h"
 #include <krun.h>
 #include <kmimetypetrader.h>
 #include <kdesktopfileactions.h>
 #include <klocalizedstring.h>
 #include <kurlauthorized.h>
 #include <kconfiggroup.h>
 #include <kdesktopfile.h>
 #include <kservicetypetrader.h>
 #include <KAbstractFileItemActionPlugin>
 #include <KPluginMetaData>
 
 #include <QFile>
 #include <QMenu>
 #include <qmimedatabase.h>
 #include <QtAlgorithms>
 
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusInterface>
 #include <QDBusMessage>
 
 static bool KIOSKAuthorizedAction(const KConfigGroup &cfg)
 {
     if (!cfg.hasKey("X-KDE-AuthorizeAction")) {
         return true;
     }
     const QStringList list = cfg.readEntry("X-KDE-AuthorizeAction", QStringList());
     for (QStringList::ConstIterator it = list.constBegin();
             it != list.constEnd(); ++it) {
         if (!KAuthorized::authorize((*it).trimmed())) {
             return false;
         }
     }
     return true;
 }
 
 static bool mimeTypeListContains(const QStringList &list, const KFileItem &item)
 {
     const QString itemMimeType = item.mimetype();
 
     foreach (const QString &i, list) {
 
         if (i == itemMimeType || i == QLatin1String("all/all")) {
             return true;
         }
 
         if (item.isFile() && (i == QLatin1String("allfiles") ||
             i == QLatin1String("all/allfiles") || i == QLatin1String("application/octet-stream"))) {
             return true;
         }
 
         if (item.currentMimeType().inherits(i)) {
             return true;
         }
 
         const int iSlashPos = i.indexOf(QLatin1Char(QLatin1Char('/')));
         Q_ASSERT(iSlashPos > 0);
         const QStringRef iSubType = i.midRef(iSlashPos+1);
 
         if (iSubType == QLatin1String("*")) {
             const int itemSlashPos = itemMimeType.indexOf(QLatin1Char('/'));
             Q_ASSERT(itemSlashPos > 0);
             const QStringRef iTopLevelType = i.midRef(0, iSlashPos);
             const QStringRef itemTopLevelType = itemMimeType.midRef(0, itemSlashPos);
 
             if (itemTopLevelType == iTopLevelType) {
                 return true;
             }
         }
     }
     return false;
 }
 
 
 
 // This helper class stores the .desktop-file actions and the servicemenus
 // in order to support X-KDE-Priority and X-KDE-Submenu.
 namespace KIO
 {
 class PopupServices
 {
 public:
     ServiceList &selectList(const QString &priority, const QString &submenuName);
 
     ServiceList builtin;
     ServiceList user, userToplevel, userPriority;
     QMap<QString, ServiceList> userSubmenus, userToplevelSubmenus, userPrioritySubmenus;
 };
 
 ServiceList &PopupServices::selectList(const QString &priority, const QString &submenuName)
 {
     // we use the categories .desktop entry to define submenus
     // if none is defined, we just pop it in the main menu
     if (submenuName.isEmpty()) {
         if (priority == QLatin1String("TopLevel")) {
             return userToplevel;
         } else if (priority == QLatin1String("Important")) {
             return userPriority;
         }
     } else if (priority == QLatin1String("TopLevel")) {
         return userToplevelSubmenus[submenuName];
     } else if (priority == QLatin1String("Important")) {
         return userPrioritySubmenus[submenuName];
     } else {
         return userSubmenus[submenuName];
     }
     return user;
 }
 } // namespace
 
 ////
 
 KFileItemActionsPrivate::KFileItemActionsPrivate(KFileItemActions *qq)
     : QObject(),
       q(qq),
       m_executeServiceActionGroup(static_cast<QWidget *>(nullptr)),
       m_runApplicationActionGroup(static_cast<QWidget *>(nullptr)),
       m_parentWidget(nullptr),
       m_config(QStringLiteral("kservicemenurc"), KConfig::NoGlobals)
 {
     QObject::connect(&m_executeServiceActionGroup, SIGNAL(triggered(QAction*)),
                      this, SLOT(slotExecuteService(QAction*)));
     QObject::connect(&m_runApplicationActionGroup, SIGNAL(triggered(QAction*)),
                      this, SLOT(slotRunApplication(QAction*)));
 }
 
 KFileItemActionsPrivate::~KFileItemActionsPrivate()
 {
 }
 
 int KFileItemActionsPrivate::insertServicesSubmenus(const QMap<QString, ServiceList> &submenus,
         QMenu *menu,
         bool isBuiltin)
 {
     int count = 0;
     QMap<QString, ServiceList>::ConstIterator it;
     for (it = submenus.begin(); it != submenus.end(); ++it) {
         if (it.value().isEmpty()) {
             //avoid empty sub-menus
             continue;
         }
 
         QMenu *actionSubmenu = new QMenu(menu);
         actionSubmenu->setTitle(it.key());
         actionSubmenu->menuAction()->setObjectName(QStringLiteral("services_submenu")); // for the unittest
         menu->addMenu(actionSubmenu);
         count += insertServices(it.value(), actionSubmenu, isBuiltin);
     }
 
     return count;
 }
 
 int KFileItemActionsPrivate::insertServices(const ServiceList &list,
         QMenu *menu,
         bool isBuiltin)
 {
     int count = 0;
     ServiceList::const_iterator it = list.begin();
     for (; it != list.end(); ++it) {
         if ((*it).isSeparator()) {
             const QList<QAction *> actions = menu->actions();
             if (!actions.isEmpty() && !actions.last()->isSeparator()) {
                 menu->addSeparator();
             }
             continue;
         }
 
         if (isBuiltin || !(*it).noDisplay()) {
             QAction *act = new QAction(q);
             act->setObjectName(QStringLiteral("menuaction")); // for the unittest
             QString text = (*it).text();
             text.replace(QLatin1Char('&'), QLatin1String("&&"));
             act->setText(text);
             if (!(*it).icon().isEmpty()) {
                 act->setIcon(QIcon::fromTheme((*it).icon()));
             }
             act->setData(QVariant::fromValue(*it));
             m_executeServiceActionGroup.addAction(act);
 
             menu->addAction(act); // Add to toplevel menu
             ++count;
         }
     }
 
     return count;
 }
 
 void KFileItemActionsPrivate::slotExecuteService(QAction *act)
 {
     KServiceAction serviceAction = act->data().value<KServiceAction>();
     if (KAuthorized::authorizeAction(serviceAction.name())) {
         KDesktopFileActions::executeService(m_props.urlList(), serviceAction);
     }
 }
 
 ////
 
 KFileItemActions::KFileItemActions(QObject *parent)
     : QObject(parent), d(new KFileItemActionsPrivate(this))
 {
 }
 
 KFileItemActions::~KFileItemActions()
 {
     delete d;
 }
 
 void KFileItemActions::setItemListProperties(const KFileItemListProperties &itemListProperties)
 {
     d->m_props = itemListProperties;
 
     d->m_mimeTypeList.clear();
     const KFileItemList items = d->m_props.items();
     KFileItemList::const_iterator kit = items.constBegin();
     const KFileItemList::const_iterator kend = items.constEnd();
     for (; kit != kend; ++kit) {
         if (!d->m_mimeTypeList.contains((*kit).mimetype())) {
             d->m_mimeTypeList << (*kit).mimetype();
         }
     }
 }
 
 int KFileItemActions::addServiceActionsTo(QMenu *mainMenu)
 {
     const KFileItemList items = d->m_props.items();
     const KFileItem firstItem = items.first();
     const QString protocol = firstItem.url().scheme(); // assumed to be the same for all items
     const bool isLocal = !firstItem.localPath().isEmpty();
     const bool isSingleLocal = items.count() == 1 && isLocal;
     const QList<QUrl> urlList = d->m_props.urlList();
 
     KIO::PopupServices s;
 
     // 1 - Look for builtin and user-defined services
     if (isSingleLocal && (d->m_props.mimeType() == QLatin1String("application/x-desktop") || // .desktop file
                           d->m_props.mimeType() == QLatin1String("inode/blockdevice"))) { // dev file
         // get builtin services, like mount/unmount
         const QString path = firstItem.localPath();
         s.builtin = KDesktopFileActions::builtinServices(QUrl::fromLocalFile(path));
         KDesktopFile desktopFile(path);
         KConfigGroup cfg = desktopFile.desktopGroup();
         const QString priority = cfg.readEntry("X-KDE-Priority");
         const QString submenuName = cfg.readEntry("X-KDE-Submenu");
 #if 0
         if (cfg.readEntry("Type") == "Link") {
             d->m_url = cfg.readEntry("URL");
             // TODO: Do we want to make all the actions apply on the target
             // of the .desktop file instead of the .desktop file itself?
         }
 #endif
         ServiceList &list = s.selectList(priority, submenuName);
         list = KDesktopFileActions::userDefinedServices(path, desktopFile, true /*isLocal*/);
     }
 
     // 2 - Look for "servicemenus" bindings (user-defined services)
 
     // first check the .directory if this is a directory
     if (d->m_props.isDirectory() && isSingleLocal) {
         QString dotDirectoryFile = QUrl::fromLocalFile(firstItem.localPath()).path().append(QLatin1String("/.directory"));
         if (QFile::exists(dotDirectoryFile)) {
             const KDesktopFile desktopFile(dotDirectoryFile);
             const KConfigGroup cfg = desktopFile.desktopGroup();
 
             if (KIOSKAuthorizedAction(cfg)) {
                 const QString priority = cfg.readEntry("X-KDE-Priority");
                 const QString submenuName = cfg.readEntry("X-KDE-Submenu");
                 ServiceList &list = s.selectList(priority, submenuName);
                 list += KDesktopFileActions::userDefinedServices(dotDirectoryFile, desktopFile, true);
             }
         }
     }
 
     const KConfigGroup showGroup = d->m_config.group("Show");
 
     const QMimeDatabase db;
     const KService::List entries = KServiceTypeTrader::self()->query(QStringLiteral("KonqPopupMenu/Plugin"));
     KService::List::const_iterator eEnd = entries.end();
     for (KService::List::const_iterator it2 = entries.begin(); it2 != eEnd; ++it2) {
         QString file = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QLatin1String("kservices5/") + (*it2)->entryPath());
         KDesktopFile desktopFile(file);
         const KConfigGroup cfg = desktopFile.desktopGroup();
 
         if (!KIOSKAuthorizedAction(cfg)) {
             continue;
         }
 
         if (cfg.hasKey("X-KDE-ShowIfRunning")) {
             const QString app = cfg.readEntry("X-KDE-ShowIfRunning");
             if (QDBusConnection::sessionBus().interface()->isServiceRegistered(app)) {
                 continue;
             }
         }
         if (cfg.hasKey("X-KDE-ShowIfDBusCall")) {
             QString calldata = cfg.readEntry("X-KDE-ShowIfDBusCall");
             const QStringList parts = calldata.split(QLatin1Char(' '));
             const QString &app = parts.at(0);
             const QString &obj = parts.at(1);
             QString interface = parts.at(2);
             QString method;
             int pos = interface.lastIndexOf(QLatin1Char('.'));
             if (pos != -1) {
                 method = interface.mid(pos + 1);
                 interface.truncate(pos);
             }
 
             //if (!QDBus::sessionBus().busService()->nameHasOwner(app))
             //    continue; //app does not exist so cannot send call
 
             QDBusMessage reply = QDBusInterface(app, obj, interface).
                                  call(method, QUrl::toStringList(urlList));
             if (reply.arguments().count() < 1 || reply.arguments().at(0).type() != QVariant::Bool || !reply.arguments().at(0).toBool()) {
                 continue;
             }
 
         }
         if (cfg.hasKey("X-KDE-Protocol")) {
             const QString theProtocol = cfg.readEntry("X-KDE-Protocol");
             if (theProtocol.startsWith(QLatin1Char('!'))) {
                 const QString excludedProtocol = theProtocol.mid(1);
                 if (excludedProtocol == protocol) {
                     continue;
                 }
             } else if (protocol != theProtocol) {
                 continue;
             }
         } else if (cfg.hasKey("X-KDE-Protocols")) {
             const QStringList protocols = cfg.readEntry("X-KDE-Protocols", QStringList());
             if (!protocols.contains(protocol)) {
                 continue;
             }
         } else if (protocol == QLatin1String("trash")) {
             // Require servicemenus for the trash to ask for protocol=trash explicitly.
             // Trashed files aren't supposed to be available for actions.
             // One might want a servicemenu for trash.desktop itself though.
             continue;
         }
 
         if (cfg.hasKey("X-KDE-Require")) {
             const QStringList capabilities = cfg.readEntry("X-KDE-Require", QStringList());
             if (capabilities.contains(QStringLiteral("Write")) && !d->m_props.supportsWriting()) {
                 continue;
             }
         }
 
         if (cfg.hasKey("X-KDE-RequiredNumberOfUrls")) {
             const QStringList requiredNumberOfUrls = cfg.readEntry("X-KDE-RequiredNumberOfUrls", QStringList());
 
             bool matchesAtLeastOneCriterion = false;
 
             for (const QString &criterion : requiredNumberOfUrls) {
                 const int number = criterion.toInt();
                 if (number < 1) {
                     continue;
                 }
 
                 if (urlList.count() == number) {
                     matchesAtLeastOneCriterion = true;
                     break;
                 }
             }
 
             if (!matchesAtLeastOneCriterion) {
                 continue;
             }
         }
 
         if (cfg.hasKey("Actions") || cfg.hasKey("X-KDE-GetActionMenu")) {
             // Like KService, we support ServiceTypes, X-KDE-ServiceTypes, and MimeType.
             const QStringList types = cfg.readEntry("ServiceTypes", QStringList())
                     << cfg.readEntry("X-KDE-ServiceTypes", QStringList())
                     << cfg.readXdgListEntry("MimeType");
 
             if (types.isEmpty()) {
                 continue;
             }
 
             const QStringList excludeTypes = cfg.readEntry("ExcludeServiceTypes", QStringList());
 
             const bool ok = std::all_of(items.constBegin(),
                                         items.constEnd(),
                                         [&types, &excludeTypes, this](const KFileItem &i)
             {
                 return mimeTypeListContains(types, i) && !mimeTypeListContains(excludeTypes, i);
             });
 
 
             if (ok) {
                 const QString priority = cfg.readEntry("X-KDE-Priority");
                 const QString submenuName = cfg.readEntry("X-KDE-Submenu");
 
                 ServiceList &list = s.selectList(priority, submenuName);
                 const ServiceList userServices = KDesktopFileActions::userDefinedServices(*(*it2), isLocal, urlList);
                 foreach (const KServiceAction &action, userServices) {
                     if (showGroup.readEntry(action.name(), true)) {
                         list += action;
                     }
                 }
             }
         }
     }
 
     QMenu *actionMenu = mainMenu;
     int userItemCount = 0;
     if (s.user.count() + s.userSubmenus.count() +
             s.userPriority.count() + s.userPrioritySubmenus.count() > 1) {
         // we have more than one item, so let's make a submenu
         actionMenu = new QMenu(i18nc("@title:menu", "&Actions"), mainMenu);
         actionMenu->menuAction()->setObjectName(QStringLiteral("actions_submenu")); // for the unittest
         mainMenu->addMenu(actionMenu);
     }
 
     userItemCount += d->insertServicesSubmenus(s.userPrioritySubmenus, actionMenu, false);
     userItemCount += d->insertServices(s.userPriority, actionMenu, false);
 
     // see if we need to put a separator between our priority items and our regular items
     if (userItemCount > 0 &&
             (s.user.count() > 0 ||
              s.userSubmenus.count() > 0 ||
              s.builtin.count() > 0) &&
-            !actionMenu->actions().last()->isSeparator()) {
+            !actionMenu->actions().constLast()->isSeparator()) {
         actionMenu->addSeparator();
     }
     userItemCount += d->insertServicesSubmenus(s.userSubmenus, actionMenu, false);
     userItemCount += d->insertServices(s.user, actionMenu, false);
     userItemCount += d->insertServices(s.builtin, mainMenu, true);
     userItemCount += d->insertServicesSubmenus(s.userToplevelSubmenus, mainMenu, false);
     userItemCount += d->insertServices(s.userToplevel, mainMenu, false);
 
     return userItemCount;
 }
 
 int KFileItemActions::addPluginActionsTo(QMenu *mainMenu)
 {
     QString commonMimeType = d->m_props.mimeType();
     if (commonMimeType.isEmpty() && d->m_props.isFile()) {
         commonMimeType = QStringLiteral("application/octet-stream");
     }
 
     QStringList addedPlugins;
     int itemCount = 0;
 
     const KConfigGroup showGroup = d->m_config.group("Show");
     const KService::List fileItemPlugins = KMimeTypeTrader::self()->query(commonMimeType, QStringLiteral("KFileItemAction/Plugin"), QStringLiteral("exist Library"));
     for(const auto &service : fileItemPlugins) {
         if (!showGroup.readEntry(service->desktopEntryName(), true)) {
             // The plugin has been disabled
             continue;
         }
 
         KAbstractFileItemActionPlugin *abstractPlugin = service->createInstance<KAbstractFileItemActionPlugin>();
         if (abstractPlugin) {
             abstractPlugin->setParent(mainMenu);
             auto actions = abstractPlugin->actions(d->m_props, d->m_parentWidget);
             itemCount += actions.count();
             mainMenu->addActions(actions);
             addedPlugins.append(service->desktopEntryName());
         }
     }
 
     const QMimeDatabase db;
     const auto jsonPlugins = KPluginLoader::findPlugins(QStringLiteral("kf5/kfileitemaction"), [&db, commonMimeType](const KPluginMetaData& metaData) {
         if (!metaData.serviceTypes().contains(QStringLiteral("KFileItemAction/Plugin"))) {
             return false;
         }
 
         auto mimeType = db.mimeTypeForName(commonMimeType);
         foreach (const auto& supportedMimeType, metaData.mimeTypes()) {
             if (mimeType.inherits(supportedMimeType)) {
                 return true;
             }
         }
 
         return false;
     });
 
     foreach (const auto& jsonMetadata, jsonPlugins) {
         // The plugin has been disabled
         if (!showGroup.readEntry(jsonMetadata.pluginId(), true)) {
             continue;
         }
 
         // The plugin also has a .desktop file and has already been added.
         if (addedPlugins.contains(jsonMetadata.pluginId())) {
             continue;
         }
 
         KPluginFactory *factory = KPluginLoader(jsonMetadata.fileName()).factory();
         if (!factory) {
             continue;
         }
         KAbstractFileItemActionPlugin* abstractPlugin = factory->create<KAbstractFileItemActionPlugin>();
         if (abstractPlugin) {
             abstractPlugin->setParent(this);
             auto actions = abstractPlugin->actions(d->m_props, d->m_parentWidget);
             itemCount += actions.count();
             mainMenu->addActions(actions);
             addedPlugins.append(jsonMetadata.pluginId());
         }
     }
 
     return itemCount;
 }
 
 // static
 KService::List KFileItemActions::associatedApplications(const QStringList &mimeTypeList, const QString &traderConstraint)
 {
     if (!KAuthorized::authorizeAction(QStringLiteral("openwith")) || mimeTypeList.isEmpty()) {
         return KService::List();
     }
 
     const KService::List firstOffers = KMimeTypeTrader::self()->query(mimeTypeList.first(), QStringLiteral("Application"), traderConstraint);
 
     QList<KFileItemActionsPrivate::ServiceRank> rankings;
     QStringList serviceList;
 
     // This section does two things.  First, it determines which services are common to all the given mimetypes.
     // Second, it ranks them based on their preference level in the associated applications list.
     // The more often a service appear near the front of the list, the LOWER its score.
 
     rankings.reserve(firstOffers.count());
     serviceList.reserve(firstOffers.count());
     for (int i = 0; i < firstOffers.count(); ++i) {
         KFileItemActionsPrivate::ServiceRank tempRank;
         tempRank.service = firstOffers[i];
         tempRank.score = i;
         rankings << tempRank;
         serviceList << tempRank.service->storageId();
     }
 
     for (int j = 1; j < mimeTypeList.count(); ++j) {
         QStringList subservice; // list of services that support this mimetype
         const KService::List offers = KMimeTypeTrader::self()->query(mimeTypeList[j], QStringLiteral("Application"), traderConstraint);
         subservice.reserve(offers.count());
         for (int i = 0; i != offers.count(); ++i) {
             const QString serviceId = offers[i]->storageId();
             subservice << serviceId;
             const int idPos = serviceList.indexOf(serviceId);
             if (idPos != -1) {
                 rankings[idPos].score += i;
             } // else: we ignore the services that didn't support the previous mimetypes
         }
 
         // Remove services which supported the previous mimetypes but don't support this one
         for (int i = 0; i < serviceList.count(); ++i) {
             if (!subservice.contains(serviceList[i])) {
                 serviceList.removeAt(i);
                 rankings.removeAt(i);
                 --i;
             }
         }
         // Nothing left -> there is no common application for these mimetypes
         if (rankings.isEmpty()) {
             return KService::List();
         }
     }
 
     std::sort(rankings.begin(), rankings.end(), KFileItemActionsPrivate::lessRank);
 
     KService::List result;
     Q_FOREACH (const KFileItemActionsPrivate::ServiceRank &tempRank, rankings) {
         result << tempRank.service;
     }
 
     return result;
 }
 
 // KMimeTypeTrader::preferredService doesn't take a constraint
 static KService::Ptr preferredService(const QString &mimeType, const QString &constraint)
 {
     const KService::List services = KMimeTypeTrader::self()->query(mimeType, QStringLiteral("Application"), constraint);
     return !services.isEmpty() ? services.first() : KService::Ptr();
 }
 
 void KFileItemActions::addOpenWithActionsTo(QMenu *topMenu, const QString &traderConstraint)
 {
     if (!KAuthorized::authorizeAction(QStringLiteral("openwith"))) {
         return;
     }
 
     d->m_traderConstraint = traderConstraint;
     KService::List offers = associatedApplications(d->m_mimeTypeList, traderConstraint);
 
     //// Ok, we have everything, now insert
 
     const KFileItemList items = d->m_props.items();
     const KFileItem firstItem = items.first();
     const bool isLocal = firstItem.url().isLocalFile();
     // "Open With..." for folders is really not very useful, especially for remote folders.
     // (media:/something, or trash:/, or ftp://...)
     if (!d->m_props.isDirectory() || isLocal) {
 
         QAction *runAct = new QAction(this);
         QString runActionName;
 
         const QStringList serviceIdList = d->listPreferredServiceIds(d->m_mimeTypeList, traderConstraint);
         //qDebug() << "serviceIdList=" << serviceIdList;
 
         // When selecting files with multiple mimetypes, offer either "open with <app for all>"
         // or a generic <open> (if there are any apps associated).
         if (d->m_mimeTypeList.count() > 1
                 && !serviceIdList.isEmpty()
                 && !(serviceIdList.count() == 1 && serviceIdList.first().isEmpty())) { // empty means "no apps associated"
 
             if (serviceIdList.count() == 1) {
                 const KService::Ptr app = preferredService(d->m_mimeTypeList.first(), traderConstraint);
                 runActionName = i18n("&Open with %1", app->name());
                 runAct->setIcon(QIcon::fromTheme(app->icon()));
 
                 // Remove that app from the offers list (#242731)
                 for (int i = 0; i < offers.count(); ++i) {
                     if (offers[i]->storageId() == app->storageId()) {
                         offers.removeAt(i);
                         break;
                     }
                 }
             } else {
                 runActionName = i18n("&Open");
             }
 
             runAct->setText(runActionName);
 
             d->m_traderConstraint = traderConstraint;
             d->m_fileOpenList = d->m_props.items();
             QObject::connect(runAct, SIGNAL(triggered()), d, SLOT(slotRunPreferredApplications()));
             topMenu->addAction(runAct);
         }
 
         if (!offers.isEmpty()) {
             QMenu *menu = topMenu;
 
             // Show the top app inline for files, but not folders
             if (!d->m_props.isDirectory()) {
                 QAction *act = d->createAppAction(offers.takeFirst(), true);
                 menu->addAction(act);
             }
 
             // If there are still more apps, show them in a sub-menu
             if (!offers.isEmpty()) { // submenu 'open with'
                 menu = new QMenu(i18nc("@title:menu", "&Open With"), topMenu);
                 menu->menuAction()->setObjectName(QStringLiteral("openWith_submenu")); // for the unittest
                 topMenu->addMenu(menu);
 
                 // Add other apps to the sub-menu
                 KService::List::ConstIterator it = offers.constBegin();
                 for (; it != offers.constEnd(); it++) {
                     QAction *act = d->createAppAction(*it,
                                                       // no submenu -> prefix single offer
                                                       menu == topMenu);
                     menu->addAction(act);
                 }
                 topMenu->addSeparator();
             }
 
             QString openWithActionName;
             if (menu != topMenu) { // submenu
                 menu->addSeparator();
                 openWithActionName = i18nc("@action:inmenu Open With", "&Other Application...");
             } else {
                 openWithActionName = i18nc("@title:menu", "&Open With...");
             }
             QAction *openWithAct = new QAction(this);
             openWithAct->setText(openWithActionName);
             openWithAct->setObjectName(QStringLiteral("openwith_browse")); // for the unittest
             QObject::connect(openWithAct, SIGNAL(triggered()), d, SLOT(slotOpenWithDialog()));
             menu->addAction(openWithAct);
             menu->addSeparator();
         } else { // no app offers -> Open With...
             QAction *act = new QAction(this);
             act->setText(i18nc("@title:menu", "&Open With..."));
             act->setObjectName(QStringLiteral("openwith")); // for the unittest
             QObject::connect(act, SIGNAL(triggered()), d, SLOT(slotOpenWithDialog()));
             topMenu->addAction(act);
         }
 
     }
 }
 
 void KFileItemActionsPrivate::slotRunPreferredApplications()
 {
     const KFileItemList fileItems = m_fileOpenList;
 
     const QStringList mimeTypeList = listMimeTypes(fileItems);
     const QStringList serviceIdList = listPreferredServiceIds(mimeTypeList, m_traderConstraint);
 
     foreach (const QString& serviceId, serviceIdList) {
         KFileItemList serviceItems;
         foreach (const KFileItem &item, fileItems) {
             const KService::Ptr serv = preferredService(item.mimetype(), m_traderConstraint);
             const QString preferredServiceId = serv ? serv->storageId() : QString();
             if (preferredServiceId == serviceId) {
                 serviceItems << item;
             }
         }
 
         if (serviceId.isEmpty()) { // empty means: no associated app for this mimetype
             openWithByMime(serviceItems);
             continue;
         }
 
         const KService::Ptr servicePtr = KService::serviceByStorageId(serviceId);
         if (!servicePtr) {
             KRun::displayOpenWithDialog(serviceItems.urlList(), m_parentWidget);
             continue;
         }
         KRun::runService(*servicePtr, serviceItems.urlList(), m_parentWidget);
     }
 }
 
 void KFileItemActions::runPreferredApplications(const KFileItemList &fileOpenList, const QString &traderConstraint)
 {
     d->m_fileOpenList = fileOpenList;
     d->m_traderConstraint = traderConstraint;
     d->slotRunPreferredApplications();
 }
 
 void KFileItemActionsPrivate::openWithByMime(const KFileItemList &fileItems)
 {
     const QStringList mimeTypeList = listMimeTypes(fileItems);
     foreach (const QString& mimeType, mimeTypeList) {
         KFileItemList mimeItems;
         foreach (const KFileItem &item, fileItems) {
             if (item.mimetype() == mimeType) {
                 mimeItems << item;
             }
         }
         KRun::displayOpenWithDialog(mimeItems.urlList(), m_parentWidget);
     }
 }
 
 void KFileItemActionsPrivate::slotRunApplication(QAction *act)
 {
     // Is it an application, from one of the "Open With" actions
     KService::Ptr app = act->data().value<KService::Ptr>();
     Q_ASSERT(app);
     if (app) {
         KRun::runService(*app, m_props.urlList(), m_parentWidget);
     }
 }
 
 void KFileItemActionsPrivate::slotOpenWithDialog()
 {
     // The item 'Other...' or 'Open With...' has been selected
     emit q->openWithDialogAboutToBeShown();
     KRun::displayOpenWithDialog(m_props.urlList(), m_parentWidget);
 }
 
 QStringList KFileItemActionsPrivate::listMimeTypes(const KFileItemList &items)
 {
     QStringList mimeTypeList;
     foreach (const KFileItem &item, items) {
         if (!mimeTypeList.contains(item.mimetype())) {
             mimeTypeList << item.mimetype();
         }
     }
     return mimeTypeList;
 }
 
 QStringList KFileItemActionsPrivate::listPreferredServiceIds(const QStringList &mimeTypeList, const QString &traderConstraint)
 {
     QStringList serviceIdList;
     Q_FOREACH (const QString &mimeType, mimeTypeList) {
         const KService::Ptr serv = preferredService(mimeType, traderConstraint);
         const QString newOffer = serv ? serv->storageId() : QString();
         serviceIdList << newOffer;
     }
     serviceIdList.removeDuplicates();
     return serviceIdList;
 }
 
 QAction *KFileItemActionsPrivate::createAppAction(const KService::Ptr &service, bool singleOffer)
 {
     QString actionName(service->name().replace(QLatin1Char('&'), QLatin1String("&&")));
     if (singleOffer) {
         actionName = i18n("Open &with %1", actionName);
     } else {
         actionName = i18nc("@item:inmenu Open With, %1 is application name", "%1", actionName);
     }
 
     QAction *act = new QAction(q);
     act->setObjectName(QStringLiteral("openwith")); // for the unittest
     act->setIcon(QIcon::fromTheme(service->icon()));
     act->setText(actionName);
     act->setData(QVariant::fromValue(service));
     m_runApplicationActionGroup.addAction(act);
     return act;
 }
 
 QAction *KFileItemActions::preferredOpenWithAction(const QString &traderConstraint)
 {
     const KService::List offers = associatedApplications(d->m_mimeTypeList, traderConstraint);
     if (offers.isEmpty()) {
         return nullptr;
     }
     return d->createAppAction(offers.first(), true);
 }
 
 void KFileItemActions::setParentWidget(QWidget *widget)
 {
     d->m_parentWidget = widget;
 }
diff --git a/src/widgets/kpropertiesdialog.cpp b/src/widgets/kpropertiesdialog.cpp
index 9002903b..34bd7790 100644
--- a/src/widgets/kpropertiesdialog.cpp
+++ b/src/widgets/kpropertiesdialog.cpp
@@ -1,3924 +1,3924 @@
 /* This file is part of the KDE project
 
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (c) 1999, 2000 Preston Brown <pbrown@kde.org>
    Copyright (c) 2000 Simon Hausmann <hausmann@kde.org>
    Copyright (c) 2000 David Faure <faure@kde.org>
    Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 /*
  * kpropertiesdialog.cpp
  * View/Edit Properties of files, locally or remotely
  *
  * some FilePermissionsPropsPlugin-changes by
  *  Henner Zeller <zeller@think.de>
  * some layout management by
  *  Bertrand Leconte <B.Leconte@mail.dotcom.fr>
  * the rest of the layout management, bug fixes, adaptation to libkio,
  * template feature by
  *  David Faure <faure@kde.org>
  * More layout, cleanups, and fixes by
  *  Preston Brown <pbrown@kde.org>
  * Plugin capability, cleanups and port to KDialog by
  *  Simon Hausmann <hausmann@kde.org>
  * KDesktopPropsPlugin by
  *  Waldo Bastian <bastian@kde.org>
  */
 
 #include "kpropertiesdialog.h"
 #include "kpropertiesdialog_p.h"
 #include "kio_widgets_debug.h"
 #include "../pathhelpers_p.h"
 
 #include <config-kiowidgets.h>
 
 #include <qplatformdefs.h>
 #include <algorithm>
 #include <functional>
 
 #include <QCheckBox>
 #include <QClipboard>
 #include <QDebug>
 #include <QDBusConnection>
 #include <QDBusInterface>
 #include <QDBusReply>
 #include <QDir>
 #include <QDialogButtonBox>
 #include <QFile>
 #include <QFileDialog>
 #include <QFileInfo>
 #include <QFileSystemWatcher>
 #include <QFutureWatcher>
 #include <QLabel>
 #include <QLayout>
 #include <QLocale>
 #include <QMimeDatabase>
 #include <QMutableStringListIterator>
 #include <QPainter>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QRegularExpression>
 #include <QStandardPaths>
 #include <QStyle>
 #include <QtConcurrentRun>
 #include <QTextStream>
 #include <QUrl>
 #include <QVector>
 
 #if HAVE_POSIX_ACL
 extern "C" {
 #  include <errno.h>
 #  include <sys/xattr.h>
 }
 #endif
 
 #include <kauthorized.h>
 #include <KColorScheme>
 #include <kdirnotify.h>
 #include <kdiskfreespaceinfo.h>
 #include <kdesktopfile.h>
 #include <kiconbutton.h>
 #include <kurlrequester.h>
 #include <klocalizedstring.h>
 #include <kjobuidelegate.h>
 #include <kio/global.h>
 #include <kio/job.h>
 #include <kio/copyjob.h>
 #include <kio/chmodjob.h>
 #include <kio/directorysizejob.h>
 #include <KIO/FileSystemFreeSpaceJob>
 #include <kio/renamedialog.h>
 #include <kio/jobuidelegate.h>
 #include <kjobwidgets.h>
 #include <kmountpoint.h>
 #include <kmessagebox.h>
 #include <kservice.h>
 #include <ksharedconfig.h>
 #include <kcombobox.h>
 #include <kcompletion.h>
 #include <klineedit.h>
 #include <kseparator.h>
 #include <ksqueezedtextlabel.h>
 #include <kmimetypetrader.h>
 #include <krun.h>
 #include <kio/desktopexecparser.h>
 #include <kacl.h>
 #include <kconfiggroup.h>
 #include <kmimetypeeditor.h>
 #include <kshell.h>
 #include <kcapacitybar.h>
 #include <kfileitemlistproperties.h>
 #include <kwindowconfig.h>
 #include <kioglobal_p.h>
 
 #include "ui_checksumswidget.h"
 #include "ui_kpropertiesdesktopbase.h"
 #include "ui_kpropertiesdesktopadvbase.h"
 #if HAVE_POSIX_ACL
 #include "kacleditwidget.h"
 #endif
 
 #include <kbuildsycocaprogressdialog.h>
 #include <kmimetypechooser.h>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 #include <shellapi.h>
 #include <process.h>
 #ifdef __GNUC__
 # warning TODO: port completely to win32
 #endif
 #endif
 
 using namespace KDEPrivate;
 
 static QString nameFromFileName(QString nameStr)
 {
     if (nameStr.endsWith(QLatin1String(".desktop"))) {
         nameStr.truncate(nameStr.length() - 8);
     }
     if (nameStr.endsWith(QLatin1String(".kdelnk"))) {
         nameStr.truncate(nameStr.length() - 7);
     }
     // Make it human-readable (%2F => '/', ...)
     nameStr = KIO::decodeFileName(nameStr);
     return nameStr;
 }
 
 const mode_t KFilePermissionsPropsPlugin::fperm[3][4] = {
     {S_IRUSR, S_IWUSR, S_IXUSR, S_ISUID},
     {S_IRGRP, S_IWGRP, S_IXGRP, S_ISGID},
     {S_IROTH, S_IWOTH, S_IXOTH, S_ISVTX}
 };
 
 class Q_DECL_HIDDEN KPropertiesDialog::KPropertiesDialogPrivate
 {
 public:
     explicit KPropertiesDialogPrivate(KPropertiesDialog *qq)
         : q(qq)
         , m_aborted(false)
         , fileSharePage(nullptr)
     {
     }
     ~KPropertiesDialogPrivate()
     {
     }
 
     /**
      * Common initialization for all constructors
      */
     void init();
     /**
      * Inserts all pages in the dialog.
      */
     void insertPages();
 
     KPropertiesDialog * const q;
     bool m_aborted;
     QWidget *fileSharePage;
     /**
      * The URL of the props dialog (when shown for only one file)
      */
     QUrl m_singleUrl;
     /**
      * List of items this props dialog is shown for
      */
     KFileItemList m_items;
     /**
      * For templates
      */
     QString m_defaultName;
     QUrl m_currentDir;
     /**
      * List of all plugins inserted ( first one first )
      */
     QList<KPropertiesDialogPlugin *> m_pageList;
 };
 
 KPropertiesDialog::KPropertiesDialog(const KFileItem &item,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(item.name())));
 
     Q_ASSERT(!item.isNull());
     d->m_items.append(item);
 
     d->m_singleUrl = item.url();
     Q_ASSERT(!d->m_singleUrl.isEmpty());
 
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const QString &title,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     setWindowTitle(i18n("Properties for %1", title));
 
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const KFileItemList &_items,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     if (_items.count() > 1) {
         setWindowTitle(i18np("Properties for 1 item", "Properties for %1 Selected Items", _items.count()));
     } else {
         setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(_items.first().name())));
     }
 
     Q_ASSERT(!_items.isEmpty());
     d->m_singleUrl = _items.first().url();
     Q_ASSERT(!d->m_singleUrl.isEmpty());
 
     d->m_items = _items;
 
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const QUrl &_url,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(_url.fileName())));
 
     d->m_singleUrl = _url;
 
     KIO::StatJob *job = KIO::stat(_url);
     KJobWidgets::setWindow(job, parent);
     job->exec();
     KIO::UDSEntry entry = job->statResult();
 
     d->m_items.append(KFileItem(entry, _url));
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const QList<QUrl>& urls,
                                      QWidget* parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     if (urls.count() > 1) {
         setWindowTitle(i18np("Properties for 1 item", "Properties for %1 Selected Items", urls.count()));
     } else {
         setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(urls.first().fileName())));
     }
 
     Q_ASSERT(!urls.isEmpty());
     d->m_singleUrl = urls.first();
     Q_ASSERT(!d->m_singleUrl.isEmpty());
 
     foreach (const QUrl& url, urls) {
         KIO::StatJob *job = KIO::stat(url);
         KJobWidgets::setWindow(job, parent);
         job->exec();
         KIO::UDSEntry entry = job->statResult();
 
         d->m_items.append(KFileItem(entry, url));
     }
 
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const QUrl &_tempUrl, const QUrl &_currentDir,
                                      const QString &_defaultName,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(_tempUrl.fileName())));
 
     d->m_singleUrl = _tempUrl;
     d->m_defaultName = _defaultName;
     d->m_currentDir = _currentDir;
     Q_ASSERT(!d->m_singleUrl.isEmpty());
 
     // Create the KFileItem for the _template_ file, in order to read from it.
     d->m_items.append(KFileItem(d->m_singleUrl));
     d->init();
 }
 
 #ifdef Q_OS_WIN
 bool showWin32FilePropertyDialog(const QString &fileName)
 {
     QString path_ = QDir::toNativeSeparators(QFileInfo(fileName).absoluteFilePath());
 
 #ifndef _WIN32_WCE
     SHELLEXECUTEINFOW execInfo;
 #else
     SHELLEXECUTEINFO execInfo;
 #endif
     memset(&execInfo, 0, sizeof(execInfo));
     execInfo.cbSize = sizeof(execInfo);
 #ifndef _WIN32_WCE
     execInfo.fMask = SEE_MASK_INVOKEIDLIST | SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI;
 #else
     execInfo.fMask = SEE_MASK_NOCLOSEPROCESS | SEE_MASK_FLAG_NO_UI;
 #endif
     const QString verb(QLatin1String("properties"));
     execInfo.lpVerb = (LPCWSTR)verb.utf16();
     execInfo.lpFile = (LPCWSTR)path_.utf16();
 #ifndef _WIN32_WCE
     return ShellExecuteExW(&execInfo);
 #else
     return ShellExecuteEx(&execInfo);
     //There is no native file property dialog in wince
     // return false;
 #endif
 }
 #endif
 
 bool KPropertiesDialog::showDialog(const KFileItem &item, QWidget *parent,
                                    bool modal)
 {
     // TODO: do we really want to show the win32 property dialog?
     // This means we lose metainfo, support for .desktop files, etc. (DF)
 #ifdef Q_OS_WIN
     QString localPath = item.localPath();
     if (!localPath.isEmpty()) {
         return showWin32FilePropertyDialog(localPath);
     }
 #endif
     KPropertiesDialog *dlg = new KPropertiesDialog(item, parent);
     if (modal) {
         dlg->exec();
     } else {
         dlg->show();
     }
 
     return true;
 }
 
 bool KPropertiesDialog::showDialog(const QUrl &_url, QWidget *parent,
                                    bool modal)
 {
 #ifdef Q_OS_WIN
     if (_url.isLocalFile()) {
         return showWin32FilePropertyDialog(_url.toLocalFile());
     }
 #endif
     KPropertiesDialog *dlg = new KPropertiesDialog(_url, parent);
     if (modal) {
         dlg->exec();
     } else {
         dlg->show();
     }
 
     return true;
 }
 
 bool KPropertiesDialog::showDialog(const KFileItemList &_items, QWidget *parent,
                                    bool modal)
 {
     if (_items.count() == 1) {
         const KFileItem item = _items.first();
         if (item.entry().count() == 0 && item.localPath().isEmpty()) // this remote item wasn't listed by a slave
             // Let's stat to get more info on the file
         {
             return KPropertiesDialog::showDialog(item.url(), parent, modal);
         } else {
             return KPropertiesDialog::showDialog(_items.first(), parent, modal);
         }
     }
     KPropertiesDialog *dlg = new KPropertiesDialog(_items, parent);
     if (modal) {
         dlg->exec();
     } else {
         dlg->show();
     }
     return true;
 }
 
 bool KPropertiesDialog::showDialog(const QList<QUrl> &urls, QWidget* parent,
                                    bool modal)
 {
     KPropertiesDialog *dlg = new KPropertiesDialog(urls, parent);
     if (modal) {
         dlg->exec();
     } else {
         dlg->show();
     }
     return true;
 }
 
 void KPropertiesDialog::KPropertiesDialogPrivate::init()
 {
     q->setFaceType(KPageDialog::Tabbed);
 
     insertPages();
 
     KConfigGroup group(KSharedConfig::openConfig(), "KPropertiesDialog");
     KWindowConfig::restoreWindowSize(q->windowHandle(), group);
 }
 
 void KPropertiesDialog::showFileSharingPage()
 {
     if (d->fileSharePage) {
         // FIXME: this showFileSharingPage thingy looks broken! (tokoe)
         // showPage( pageIndex( d->fileSharePage));
     }
 }
 
 void KPropertiesDialog::setFileSharingPage(QWidget *page)
 {
     d->fileSharePage = page;
 }
 
 void KPropertiesDialog::setFileNameReadOnly(bool ro)
 {
     foreach (KPropertiesDialogPlugin *it, d->m_pageList) {
         if (auto *filePropsPlugin = qobject_cast<KFilePropsPlugin *>(it)) {
             filePropsPlugin->setFileNameReadOnly(ro);
         } else if (auto *urlPropsPlugin = qobject_cast<KUrlPropsPlugin *>(it)) {
             urlPropsPlugin->setFileNameReadOnly(ro);
         }
     }
 }
 
 KPropertiesDialog::~KPropertiesDialog()
 {
     qDeleteAll(d->m_pageList);
     delete d;
 
     KConfigGroup group(KSharedConfig::openConfig(), "KPropertiesDialog");
     KWindowConfig::saveWindowSize(windowHandle(), group, KConfigBase::Persistent);
 }
 
 void KPropertiesDialog::insertPlugin(KPropertiesDialogPlugin *plugin)
 {
     connect(plugin, SIGNAL(changed()),
             plugin, SLOT(setDirty()));
 
     d->m_pageList.append(plugin);
 }
 
 QUrl KPropertiesDialog::url() const
 {
     return d->m_singleUrl;
 }
 
 KFileItem &KPropertiesDialog::item()
 {
     return d->m_items.first();
 }
 
 KFileItemList KPropertiesDialog::items() const
 {
     return d->m_items;
 }
 
 QUrl KPropertiesDialog::currentDir() const
 {
     return d->m_currentDir;
 }
 
 QString KPropertiesDialog::defaultName() const
 {
     return d->m_defaultName;
 }
 
 bool KPropertiesDialog::canDisplay(const KFileItemList &_items)
 {
     // TODO: cache the result of those calls. Currently we parse .desktop files far too many times
     return KFilePropsPlugin::supports(_items) ||
            KFilePermissionsPropsPlugin::supports(_items) ||
            KDesktopPropsPlugin::supports(_items) ||
            KUrlPropsPlugin::supports(_items) ||
            KDevicePropsPlugin::supports(_items) /* ||
             KPreviewPropsPlugin::supports( _items )*/;
 }
 
 void KPropertiesDialog::slotOk()
 {
     accept();
 }
 
 void KPropertiesDialog::accept()
 {
     QList<KPropertiesDialogPlugin *>::const_iterator pageListIt;
     d->m_aborted = false;
 
     KFilePropsPlugin *filePropsPlugin = qobject_cast<KFilePropsPlugin *>(d->m_pageList.first());
 
     // If any page is dirty, then set the main one (KFilePropsPlugin) as
     // dirty too. This is what makes it possible to save changes to a global
     // desktop file into a local one. In other cases, it doesn't hurt.
     for (pageListIt = d->m_pageList.constBegin(); pageListIt != d->m_pageList.constEnd(); ++pageListIt) {
         if ((*pageListIt)->isDirty() && filePropsPlugin) {
             filePropsPlugin->setDirty();
             break;
         }
     }
 
     // Apply the changes in the _normal_ order of the tabs now
     // This is because in case of renaming a file, KFilePropsPlugin will call
     // KPropertiesDialog::rename, so other tab will be ok with whatever order
     // BUT for file copied from templates, we need to do the renaming first !
     for (pageListIt = d->m_pageList.constBegin(); pageListIt != d->m_pageList.constEnd() && !d->m_aborted; ++pageListIt) {
         if ((*pageListIt)->isDirty()) {
             // qDebug() << "applying changes for " << (*pageListIt)->metaObject()->className();
             (*pageListIt)->applyChanges();
             // applyChanges may change d->m_aborted.
         } else {
             // qDebug() << "skipping page " << (*pageListIt)->metaObject()->className();
         }
     }
 
     if (!d->m_aborted && filePropsPlugin) {
         filePropsPlugin->postApplyChanges();
     }
 
     if (!d->m_aborted) {
         emit applied();
         emit propertiesClosed();
         deleteLater(); // somewhat like Qt::WA_DeleteOnClose would do.
         KPageDialog::accept();
     } // else, keep dialog open for user to fix the problem.
 }
 
 void KPropertiesDialog::slotCancel()
 {
     reject();
 }
 
 void KPropertiesDialog::reject()
 {
     emit canceled();
     emit propertiesClosed();
 
     deleteLater();
     KPageDialog::reject();
 }
 
 void KPropertiesDialog::KPropertiesDialogPrivate::insertPages()
 {
     if (m_items.isEmpty()) {
         return;
     }
 
     if (KFilePropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KFilePropsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KFilePermissionsPropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KFilePermissionsPropsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KChecksumsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KChecksumsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KDesktopPropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KDesktopPropsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KUrlPropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KUrlPropsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KDevicePropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KDevicePropsPlugin(q);
         q->insertPlugin(p);
     }
 
 //     if ( KPreviewPropsPlugin::supports( m_items ) ) {
 //         KPropertiesDialogPlugin *p = new KPreviewPropsPlugin(q);
 //         q->insertPlugin(p);
 //     }
 
     //plugins
 
     if (m_items.count() != 1) {
         return;
     }
 
     const KFileItem item = m_items.first();
     const QString mimetype = item.mimetype();
 
     if (mimetype.isEmpty()) {
         return;
     }
 
     QString query = QStringLiteral(
         "(((not exist [X-KDE-Protocol]) and (not exist [X-KDE-Protocols])) or ([X-KDE-Protocol] == '%1') or ('%1' in [X-KDE-Protocols]))"
     ).arg(item.url().scheme());
 
     // qDebug() << "trader query: " << query;
     const KService::List offers = KMimeTypeTrader::self()->query(mimetype, QStringLiteral("KPropertiesDialog/Plugin"), query);
     foreach (const KService::Ptr &ptr, offers) {
         KPropertiesDialogPlugin *plugin = ptr->createInstance<KPropertiesDialogPlugin>(q);
         if (!plugin) {
             continue;
         }
         plugin->setObjectName(ptr->name());
 
         q->insertPlugin(plugin);
     }
 }
 
 void KPropertiesDialog::updateUrl(const QUrl &_newUrl)
 {
     Q_ASSERT(d->m_items.count() == 1);
     // qDebug() << "KPropertiesDialog::updateUrl (pre)" << _newUrl;
     QUrl newUrl = _newUrl;
     emit saveAs(d->m_singleUrl, newUrl);
     // qDebug() << "KPropertiesDialog::updateUrl (post)" << newUrl;
 
     d->m_singleUrl = newUrl;
     d->m_items.first().setUrl(newUrl);
     Q_ASSERT(!d->m_singleUrl.isEmpty());
     // If we have an Desktop page, set it dirty, so that a full file is saved locally
     // Same for a URL page (because of the Name= hack)
     foreach (KPropertiesDialogPlugin *it, d->m_pageList) {
         if (qobject_cast<KUrlPropsPlugin *>(it) ||
                 qobject_cast<KDesktopPropsPlugin *>(it)) {
             //qDebug() << "Setting page dirty";
             it->setDirty();
             break;
         }
     }
 }
 
 void KPropertiesDialog::rename(const QString &_name)
 {
     Q_ASSERT(d->m_items.count() == 1);
     // qDebug() << "KPropertiesDialog::rename " << _name;
     QUrl newUrl;
     // if we're creating from a template : use currentdir
     if (!d->m_currentDir.isEmpty()) {
         newUrl = d->m_currentDir;
         newUrl.setPath(concatPaths(newUrl.path(), _name));
     } else {
         // It's a directory, so strip the trailing slash first
         newUrl = d->m_singleUrl.adjusted(QUrl::StripTrailingSlash);
         // Now change the filename
         newUrl = newUrl.adjusted(QUrl::RemoveFilename); // keep trailing slash
         newUrl.setPath(concatPaths(newUrl.path(), _name));
     }
     updateUrl(newUrl);
 }
 
 void KPropertiesDialog::abortApplying()
 {
     d->m_aborted = true;
 }
 
 class Q_DECL_HIDDEN KPropertiesDialogPlugin::KPropertiesDialogPluginPrivate
 {
 public:
     KPropertiesDialogPluginPrivate()
     {
     }
     ~KPropertiesDialogPluginPrivate()
     {
     }
 
     bool m_bDirty;
     int fontHeight;
 };
 
 KPropertiesDialogPlugin::KPropertiesDialogPlugin(KPropertiesDialog *_props)
     : QObject(_props), d(new KPropertiesDialogPluginPrivate)
 {
     properties = _props;
     d->fontHeight = 2 * properties->fontMetrics().height();
     d->m_bDirty = false;
 }
 
 KPropertiesDialogPlugin::~KPropertiesDialogPlugin()
 {
     delete d;
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 bool KPropertiesDialogPlugin::isDesktopFile(const KFileItem &_item)
 {
     return _item.isDesktopFile();
 }
 #endif
 
 void KPropertiesDialogPlugin::setDirty(bool b)
 {
     d->m_bDirty = b;
 }
 
 void KPropertiesDialogPlugin::setDirty()
 {
     d->m_bDirty = true;
 }
 
 bool KPropertiesDialogPlugin::isDirty() const
 {
     return d->m_bDirty;
 }
 
 void KPropertiesDialogPlugin::applyChanges()
 {
     qCWarning(KIO_WIDGETS) << "applyChanges() not implemented in page !";
 }
 
 int KPropertiesDialogPlugin::fontHeight() const
 {
     return d->fontHeight;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class KFilePropsPlugin::KFilePropsPluginPrivate
 {
 public:
     KFilePropsPluginPrivate()
     {
         dirSizeJob = nullptr;
         dirSizeUpdateTimer = nullptr;
         m_lined = nullptr;
         m_capacityBar = nullptr;
         m_linkTargetLineEdit = nullptr;
     }
     ~KFilePropsPluginPrivate()
     {
         if (dirSizeJob) {
             dirSizeJob->kill();
         }
     }
 
     KIO::DirectorySizeJob *dirSizeJob;
     QTimer *dirSizeUpdateTimer;
     QFrame *m_frame;
     bool bMultiple;
     bool bIconChanged;
     bool bKDesktopMode;
     bool bDesktopFile;
     KCapacityBar *m_capacityBar;
     QString mimeType;
     QString oldFileName;
     KLineEdit *m_lined;
     QLabel *m_fileNameLabel = nullptr;
     QGridLayout *m_grid = nullptr;
 
     QWidget *iconArea;
 
     QLabel *m_sizeLabel;
     QPushButton *m_sizeDetermineButton;
     QPushButton *m_sizeStopButton;
     KLineEdit *m_linkTargetLineEdit;
 
     QString m_sRelativePath;
     bool m_bFromTemplate;
 
     /**
     * The initial filename
     */
     QString oldName;
 };
 
 KFilePropsPlugin::KFilePropsPlugin(KPropertiesDialog *_props)
     : KPropertiesDialogPlugin(_props), d(new KFilePropsPluginPrivate)
 {
     d->bMultiple = (properties->items().count() > 1);
     d->bIconChanged = false;
     d->bDesktopFile = KDesktopPropsPlugin::supports(properties->items());
     // qDebug() << "KFilePropsPlugin::KFilePropsPlugin bMultiple=" << d->bMultiple;
 
     // We set this data from the first item, and we'll
     // check that the other items match against it, resetting when not.
     bool isLocal;
     const KFileItem item = properties->item();
     QUrl url = item.mostLocalUrl(isLocal);
     bool isReallyLocal = item.url().isLocalFile();
     bool bDesktopFile = item.isDesktopFile();
     mode_t mode = item.mode();
     bool hasDirs = item.isDir() && !item.isLink();
     bool hasRoot = url.path() == QLatin1String("/");
     QString iconStr = item.iconName();
     QString directory = properties->url().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path();
     QString protocol = properties->url().scheme();
     d->bKDesktopMode = protocol == QLatin1String("desktop") ||
                        properties->currentDir().scheme() == QLatin1String("desktop");
     QString mimeComment = item.mimeComment();
     d->mimeType = item.mimetype();
     KIO::filesize_t totalSize = item.size();
     QString magicMimeComment;
     QMimeDatabase db;
     if (isLocal) {
         QMimeType magicMimeType = db.mimeTypeForFile(url.toLocalFile(), QMimeDatabase::MatchContent);
         if (magicMimeType.isValid() && !magicMimeType.isDefault()) {
             magicMimeComment = magicMimeType.comment();
         }
     }
 #ifdef Q_OS_WIN
     if (isReallyLocal) {
         directory = QDir::toNativeSeparators(directory.mid(1));
     }
 #endif
 
     // Those things only apply to 'single file' mode
     QString filename;
     bool isTrash = false;
     d->m_bFromTemplate = false;
 
     // And those only to 'multiple' mode
     uint iDirCount = hasDirs ? 1 : 0;
     uint iFileCount = 1 - iDirCount;
 
     d->m_frame = new QFrame();
     properties->addPage(d->m_frame, i18nc("@title:tab File properties", "&General"));
 
     QVBoxLayout *vbl = new QVBoxLayout(d->m_frame);
     vbl->setMargin(0);
     vbl->setObjectName(QStringLiteral("vbl"));
     QGridLayout *grid = new QGridLayout(); // unknown rows
     d->m_grid = grid;
     grid->setColumnStretch(0, 0);
     grid->setColumnStretch(1, 0);
     grid->setColumnStretch(2, 1);
     const int spacingHint = d->m_frame->style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
     grid->addItem(new QSpacerItem(spacingHint, 0), 0, 1);
     vbl->addLayout(grid);
     int curRow = 0;
 
     if (!d->bMultiple) {
         QString path;
         if (!d->m_bFromTemplate) {
             isTrash = (properties->url().scheme() == QLatin1String("trash"));
             // Extract the full name, but without file: for local files
             path = properties->url().toDisplayString(QUrl::PreferLocalFile);
         } else {
             path = concatPaths(properties->currentDir().path(), properties->defaultName());
             directory = properties->currentDir().toDisplayString(QUrl::PreferLocalFile);
         }
 
         if (d->bDesktopFile) {
             determineRelativePath(path);
         }
 
         // Extract the file name only
         filename = properties->defaultName();
         if (filename.isEmpty()) {   // no template
             const QFileInfo finfo(item.name());  // this gives support for UDS_NAME, e.g. for kio_trash or kio_system
             filename = finfo.fileName(); // Make sure only the file's name is displayed (#160964).
         } else {
             d->m_bFromTemplate = true;
             setDirty(); // to enforce that the copy happens
         }
         d->oldFileName = filename;
 
         // Make it human-readable
         filename = nameFromFileName(filename);
 
         if (d->bKDesktopMode && d->bDesktopFile) {
             KDesktopFile config(url.toLocalFile());
             if (config.desktopGroup().hasKey("Name")) {
                 filename = config.readName();
             }
         }
 
         d->oldName = filename;
     } else {
         // Multiple items: see what they have in common
         const KFileItemList items = properties->items();
         KFileItemList::const_iterator kit = items.begin();
         const KFileItemList::const_iterator kend = items.end();
         for (++kit /*no need to check the first one again*/; kit != kend; ++kit) {
             const QUrl url = (*kit).url();
             // qDebug() << "KFilePropsPlugin::KFilePropsPlugin " << url.toDisplayString();
             // The list of things we check here should match the variables defined
             // at the beginning of this method.
             if (url.isLocalFile() != isLocal) {
                 isLocal = false;    // not all local
             }
             if (bDesktopFile && (*kit).isDesktopFile() != bDesktopFile) {
                 bDesktopFile = false;    // not all desktop files
             }
             if ((*kit).mode() != mode) {
                 mode = (mode_t)0;
             }
             if (KIO::iconNameForUrl(url) != iconStr) {
                 iconStr = QStringLiteral("document-multiple");
             }
             if (url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path() != directory) {
                 directory.clear();
             }
             if (url.scheme() != protocol) {
                 protocol.clear();
             }
             if (!mimeComment.isNull() && (*kit).mimeComment() != mimeComment) {
                 mimeComment.clear();
             }
             if (isLocal && !magicMimeComment.isNull()) {
                 QMimeType magicMimeType = db.mimeTypeForFile(url.toLocalFile(), QMimeDatabase::MatchContent);
                 if (magicMimeType.isValid() && magicMimeType.comment() != magicMimeComment) {
                     magicMimeComment.clear();
                 }
             }
 
             if (isLocal && url.path() == QLatin1String("/")) {
                 hasRoot = true;
             }
             if ((*kit).isDir() && !(*kit).isLink()) {
                 iDirCount++;
                 hasDirs = true;
             } else {
                 iFileCount++;
                 totalSize += (*kit).size();
             }
         }
     }
 
     if (!isReallyLocal && !protocol.isEmpty()) {
         directory += QLatin1String(" (") + protocol + QLatin1Char(')');
     }
 
     if (!isTrash && (bDesktopFile || ((mode & QT_STAT_MASK) == QT_STAT_DIR))
             && !d->bMultiple // not implemented for multiple
             && enableIconButton()) { // #56857
         KIconButton *iconButton = new KIconButton(d->m_frame);
         int bsize = 66 + 2 * iconButton->style()->pixelMetric(QStyle::PM_ButtonMargin);
         iconButton->setFixedSize(bsize, bsize);
         iconButton->setIconSize(48);
         iconButton->setStrictIconSize(false);
         if (bDesktopFile && isLocal) {
             const KDesktopFile config(url.toLocalFile());
             if (config.hasDeviceType()) {
                 iconButton->setIconType(KIconLoader::Desktop, KIconLoader::Device);
             } else {
                 iconButton->setIconType(KIconLoader::Desktop, KIconLoader::Application);
             }
         } else {
             iconButton->setIconType(KIconLoader::Desktop, KIconLoader::Place);
         }
         iconButton->setIcon(iconStr);
         d->iconArea = iconButton;
         connect(iconButton, SIGNAL(iconChanged(QString)),
                 this, SLOT(slotIconChanged()));
     } else {
         QLabel *iconLabel = new QLabel(d->m_frame);
         iconLabel->setAlignment(Qt::AlignCenter);
         int bsize = 66 + 2 * iconLabel->style()->pixelMetric(QStyle::PM_ButtonMargin);
         iconLabel->setFixedSize(bsize, bsize);
         iconLabel->setPixmap(QIcon::fromTheme(iconStr).pixmap(48));
         d->iconArea = iconLabel;
     }
     grid->addWidget(d->iconArea, curRow, 0, Qt::AlignCenter);
 
     KFileItemListProperties itemList(KFileItemList() << item);
     if (d->bMultiple || isTrash || hasRoot || !(d->m_bFromTemplate || itemList.supportsMoving())) {
         setFileNameReadOnly(true);
         if (d->bMultiple) {
             d->m_fileNameLabel->setText(KIO::itemsSummaryString(iFileCount + iDirCount, iFileCount, iDirCount, 0, false));
         }
 
     } else {
         d->m_lined = new KLineEdit(d->m_frame);
         d->m_lined->setObjectName(QStringLiteral("KFilePropsPlugin::nameLineEdit"));
         d->m_lined->setText(filename);
         d->m_lined->setFocus();
 
         // Enhanced rename: Don't highlight the file extension.
         QString extension = db.suffixForFileName(filename);
         if (!extension.isEmpty()) {
             d->m_lined->setSelection(0, filename.length() - extension.length() - 1);
         } else {
             int lastDot = filename.lastIndexOf(QLatin1Char('.'));
             if (lastDot > 0) {
                 d->m_lined->setSelection(0, lastDot);
             }
         }
 
         connect(d->m_lined, SIGNAL(textChanged(QString)),
                 this, SLOT(nameFileChanged(QString)));
         grid->addWidget(d->m_lined, curRow, 2);
     }
     ++curRow;
 
     KSeparator *sep = new KSeparator(Qt::Horizontal, d->m_frame);
     grid->addWidget(sep, curRow, 0, 1, 3);
     ++curRow;
 
     QLabel *l;
     if (!mimeComment.isEmpty() && !isTrash) {
         l = new QLabel(i18n("Type:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight | Qt::AlignTop);
 
         QFrame *box = new QFrame(d->m_frame);
         QVBoxLayout *boxLayout = new QVBoxLayout(box);
         boxLayout->setSpacing(2); // without that spacing the button literally “sticks” to the label ;)
         boxLayout->setMargin(0);
 
         l = new QLabel(mimeComment, box);
         l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
         grid->addWidget(box, curRow++, 2);
 
         QPushButton *button = new QPushButton(box);
         button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);  // Minimum still makes the button grow to the entire layout width
         button->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
 
         boxLayout->addWidget(l);
         boxLayout->addWidget(button);
 
         if (d->mimeType == QLatin1String("application/octet-stream")) {
             button->setText(i18n("Create New File Type"));
         } else {
             button->setText(i18n("File Type Options"));
         }
 
         connect(button, SIGNAL(clicked()), SLOT(slotEditFileType()));
 
         if (!KAuthorized::authorizeAction(QStringLiteral("editfiletype"))) {
             button->hide();
         }
     }
 
     if (!magicMimeComment.isEmpty() && magicMimeComment != mimeComment) {
         l = new QLabel(i18n("Contents:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
         l = new QLabel(magicMimeComment, d->m_frame);
         grid->addWidget(l, curRow++, 2);
     }
 
     if (!directory.isEmpty()) {
         l = new QLabel(i18n("Location:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
         l = new KSqueezedTextLabel(directory, d->m_frame);
         // force the layout direction to be always LTR
         l->setLayoutDirection(Qt::LeftToRight);
         // but if we are in RTL mode, align the text to the right
         // otherwise the text is on the wrong side of the dialog
         if (properties->layoutDirection() == Qt::RightToLeft) {
             l->setAlignment(Qt::AlignRight);
         }
         l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
         grid->addWidget(l, curRow++, 2);
     }
 
     l = new QLabel(i18n("Size:"), d->m_frame);
     grid->addWidget(l, curRow, 0, Qt::AlignRight | Qt::AlignTop);
 
     d->m_sizeLabel = new QLabel(d->m_frame);
     d->m_sizeLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
     grid->addWidget(d->m_sizeLabel, curRow++, 2);
 
     if (!hasDirs) { // Only files [and symlinks]
         d->m_sizeLabel->setText(QStringLiteral("%1 (%2)").arg(KIO::convertSize(totalSize),
            QLocale().toString(totalSize)));
         d->m_sizeDetermineButton = nullptr;
         d->m_sizeStopButton = nullptr;
     } else { // Directory
         QHBoxLayout *sizelay = new QHBoxLayout();
         grid->addLayout(sizelay, curRow++, 2);
 
         // buttons
         d->m_sizeDetermineButton = new QPushButton(i18n("Calculate"), d->m_frame);
         d->m_sizeStopButton = new QPushButton(i18n("Stop"), d->m_frame);
         connect(d->m_sizeDetermineButton, SIGNAL(clicked()), this, SLOT(slotSizeDetermine()));
         connect(d->m_sizeStopButton, SIGNAL(clicked()), this, SLOT(slotSizeStop()));
         sizelay->addWidget(d->m_sizeDetermineButton, 0);
         sizelay->addWidget(d->m_sizeStopButton, 0);
         sizelay->addStretch(10); // so that the buttons don't grow horizontally
 
         // auto-launch for local dirs only, and not for '/'
         if (isLocal && !hasRoot) {
             d->m_sizeDetermineButton->setText(i18n("Refresh"));
             slotSizeDetermine();
         } else {
             d->m_sizeStopButton->setEnabled(false);
         }
     }
 
     if (!d->bMultiple && item.isLink()) {
         l = new QLabel(i18n("Points to:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
         d->m_linkTargetLineEdit = new KLineEdit(item.linkDest(), d->m_frame);
         grid->addWidget(d->m_linkTargetLineEdit, curRow++, 2);
         connect(d->m_linkTargetLineEdit, SIGNAL(textChanged(QString)), this, SLOT(setDirty()));
     }
 
     if (!d->bMultiple) { // Dates for multiple don't make much sense...
         QDateTime dt = item.time(KFileItem::CreationTime);
         if (!dt.isNull()) {
             l = new QLabel(i18n("Created:"), d->m_frame);
             grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
             l = new QLabel(dt.toString(Qt::DefaultLocaleLongDate), d->m_frame);
             grid->addWidget(l, curRow++, 2);
         }
 
         dt = item.time(KFileItem::ModificationTime);
         if (!dt.isNull()) {
             l = new QLabel(i18n("Modified:"), d->m_frame);
             grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
             l = new QLabel(dt.toString(Qt::DefaultLocaleLongDate), d->m_frame);
             l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
             grid->addWidget(l, curRow++, 2);
         }
 
         dt = item.time(KFileItem::AccessTime);
         if (!dt.isNull()) {
             l = new QLabel(i18n("Accessed:"), d->m_frame);
             grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
             l = new QLabel(dt.toString(Qt::DefaultLocaleLongDate), d->m_frame);
             l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
             grid->addWidget(l, curRow++, 2);
         }
     }
 
     if (hasDirs) {  // only for directories
         sep = new KSeparator(Qt::Horizontal, d->m_frame);
         grid->addWidget(sep, curRow, 0, 1, 3);
         ++curRow;
 
         if (isLocal) {
             KMountPoint::Ptr mp = KMountPoint::currentMountPoints().findByPath(url.toLocalFile());
 
             l = new QLabel(i18n("File System:"), d->m_frame);
             grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
             l = new QLabel(d->m_frame);
             grid->addWidget(l, curRow++, 2);
             l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
             l->setText(mp->mountType());
 
             if (mp) {
                 l = new QLabel(i18n("Mounted on:"), d->m_frame);
                 grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
                 l = new KSqueezedTextLabel(mp->mountPoint(), d->m_frame);
                 l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
                 grid->addWidget(l, curRow++, 2);
 
                 l = new QLabel(i18n("Mounted from:"), d->m_frame);
                 grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
                 l = new QLabel(d->m_frame);
                 grid->addWidget(l, curRow++, 2);
                 l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
                 l->setText(mp->mountedFrom());
             }
         }
 
         l = new QLabel(i18n("Device usage:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
         d->m_capacityBar = new KCapacityBar(KCapacityBar::DrawTextOutline, d->m_frame);
         d->m_capacityBar->setText(i18nc("@info:status", "Unknown size"));
         grid->addWidget(d->m_capacityBar, curRow++, 2);
 
         KIO::FileSystemFreeSpaceJob *job = KIO::fileSystemFreeSpace(url);
         connect(job, &KIO::FileSystemFreeSpaceJob::result, this, &KFilePropsPlugin::slotFreeSpaceResult);
     }
 
     vbl->addStretch(1);
 }
 
 bool KFilePropsPlugin::enableIconButton() const
 {
     bool iconEnabled = false;
     const KFileItem item = properties->item();
     // If the current item is a directory, check if it's writable,
     // so we can create/update a .directory
     // Current item is a file, same thing: check if it is writable
     if (item.isWritable()) {
         iconEnabled = true;
     }
     return iconEnabled;
 }
 
 // QString KFilePropsPlugin::tabName () const
 // {
 //   return i18n ("&General");
 // }
 
 void KFilePropsPlugin::setFileNameReadOnly(bool ro)
 {
     Q_ASSERT(ro); // false isn't supported
     if (ro && !d->m_fileNameLabel) {
         Q_ASSERT(!d->m_bFromTemplate);
         delete d->m_lined;
         d->m_lined = nullptr;
         d->m_fileNameLabel = new QLabel(d->m_frame);
         d->m_fileNameLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
         d->m_fileNameLabel->setText(d->oldName); // will get overwritten if d->bMultiple
         d->m_grid->addWidget(d->m_fileNameLabel, 0, 2);
     }
 }
 
 void KFilePropsPlugin::slotEditFileType()
 {
     QString mime;
     if (d->mimeType == QLatin1String("application/octet-stream")) {
         const int pos = d->oldFileName.lastIndexOf(QLatin1Char('.'));
         if (pos != -1) {
             mime = QLatin1Char('*') + d->oldFileName.mid(pos);
         } else {
             mime = QStringLiteral("*");
         }
     }  else {
         mime = d->mimeType;
     }
     KMimeTypeEditor::editMimeType(mime, properties->window());
 }
 
 void KFilePropsPlugin::slotIconChanged()
 {
     d->bIconChanged = true;
     emit changed();
 }
 
 void KFilePropsPlugin::nameFileChanged(const QString &text)
 {
     properties->buttonBox()->button(QDialogButtonBox::Ok)->setEnabled(!text.isEmpty());
     emit changed();
 }
 
 static QString relativeAppsLocation(const QString &file)
 {
     const QString canonical = QFileInfo(file).canonicalFilePath();
     Q_FOREACH (const QString &base, QStandardPaths::standardLocations(QStandardPaths::ApplicationsLocation)) {
         QDir base_dir = QDir(base);
         if (base_dir.exists() && canonical.startsWith(base_dir.canonicalPath())) {
             return canonical.mid(base.length() + 1);
         }
     }
     return QString(); // return empty if the file is not in apps
 }
 
 void KFilePropsPlugin::determineRelativePath(const QString &path)
 {
     // now let's make it relative
     d->m_sRelativePath = relativeAppsLocation(path);
 }
 
 void KFilePropsPlugin::slotFreeSpaceResult(KIO::Job *job, KIO::filesize_t size, KIO::filesize_t available)
 {
     if (!job->error()) {
         const quint64 used = size - available;
         const int percentUsed = qRound(100.0 * qreal(used) / qreal(size));
 
         d->m_capacityBar->setText(
         i18nc("Available space out of total partition size (percent used)", "%1 free of %2 (%3% used)",
               KIO::convertSize(available),
               KIO::convertSize(size),
               percentUsed));
 
         d->m_capacityBar->setValue(percentUsed);
     } else {
         d->m_capacityBar->setText(i18nc("@info:status", "Unknown size"));
         d->m_capacityBar->setValue(0);
     }
 }
 
 void KFilePropsPlugin::slotDirSizeUpdate()
 {
     KIO::filesize_t totalSize = d->dirSizeJob->totalSize();
     KIO::filesize_t totalFiles = d->dirSizeJob->totalFiles();
     KIO::filesize_t totalSubdirs = d->dirSizeJob->totalSubdirs();
     d->m_sizeLabel->setText(
         i18n("Calculating... %1 (%2)\n%3, %4",
              KIO::convertSize(totalSize),
              QLocale().toString(totalSize),
              i18np("1 file", "%1 files", totalFiles),
              i18np("1 sub-folder", "%1 sub-folders", totalSubdirs)));
 }
 
 void KFilePropsPlugin::slotDirSizeFinished(KJob *job)
 {
     if (job->error()) {
         d->m_sizeLabel->setText(job->errorString());
     } else {
         KIO::filesize_t totalSize = d->dirSizeJob->totalSize();
         KIO::filesize_t totalFiles = d->dirSizeJob->totalFiles();
         KIO::filesize_t totalSubdirs = d->dirSizeJob->totalSubdirs();
         d->m_sizeLabel->setText(QStringLiteral("%1 (%2)\n%3, %4")
                                 .arg(KIO::convertSize(totalSize),
                                 QLocale().toString(totalSize),
                                 i18np("1 file", "%1 files", totalFiles),
                                 i18np("1 sub-folder", "%1 sub-folders", totalSubdirs)));
     }
     d->m_sizeStopButton->setEnabled(false);
     // just in case you change something and try again :)
     d->m_sizeDetermineButton->setText(i18n("Refresh"));
     d->m_sizeDetermineButton->setEnabled(true);
     d->dirSizeJob = nullptr;
     delete d->dirSizeUpdateTimer;
     d->dirSizeUpdateTimer = nullptr;
 }
 
 void KFilePropsPlugin::slotSizeDetermine()
 {
     d->m_sizeLabel->setText(i18n("Calculating..."));
     // qDebug() << "properties->item()=" << properties->item() << "URL=" << properties->item().url();
 
     d->dirSizeJob = KIO::directorySize(properties->items());
     d->dirSizeUpdateTimer = new QTimer(this);
     connect(d->dirSizeUpdateTimer, SIGNAL(timeout()),
             SLOT(slotDirSizeUpdate()));
     d->dirSizeUpdateTimer->start(500);
     connect(d->dirSizeJob, SIGNAL(result(KJob*)),
             SLOT(slotDirSizeFinished(KJob*)));
     d->m_sizeStopButton->setEnabled(true);
     d->m_sizeDetermineButton->setEnabled(false);
 
     // also update the "Free disk space" display
     if (d->m_capacityBar) {
         const KFileItem item = properties->item();
         KIO::FileSystemFreeSpaceJob *job = KIO::fileSystemFreeSpace(item.url());
         connect(job, &KIO::FileSystemFreeSpaceJob::result, this, &KFilePropsPlugin::slotFreeSpaceResult);
     }
 }
 
 void KFilePropsPlugin::slotSizeStop()
 {
     if (d->dirSizeJob) {
         KIO::filesize_t totalSize = d->dirSizeJob->totalSize();
         d->m_sizeLabel->setText(i18n("At least %1",
                                      KIO::convertSize(totalSize)));
         d->dirSizeJob->kill();
         d->dirSizeJob = nullptr;
     }
     if (d->dirSizeUpdateTimer) {
         d->dirSizeUpdateTimer->stop();
     }
 
     d->m_sizeStopButton->setEnabled(false);
     d->m_sizeDetermineButton->setEnabled(true);
 }
 
 KFilePropsPlugin::~KFilePropsPlugin()
 {
     delete d;
 }
 
 bool KFilePropsPlugin::supports(const KFileItemList & /*_items*/)
 {
     return true;
 }
 
 void KFilePropsPlugin::applyChanges()
 {
     if (d->dirSizeJob) {
         slotSizeStop();
     }
 
     // qDebug() << "KFilePropsPlugin::applyChanges";
 
     if (d->m_lined) {
         QString n = d->m_lined->text();
         // Remove trailing spaces (#4345)
         while (! n.isEmpty() && n[n.length() - 1].isSpace()) {
             n.truncate(n.length() - 1);
         }
         if (n.isEmpty()) {
             KMessageBox::sorry(properties, i18n("The new file name is empty."));
             properties->abortApplying();
             return;
         }
 
         // Do we need to rename the file ?
         // qDebug() << "oldname = " << d->oldName;
         // qDebug() << "newname = " << n;
         if (d->oldName != n || d->m_bFromTemplate) {   // true for any from-template file
             KIO::Job *job = nullptr;
             QUrl oldurl = properties->url();
 
             QString newFileName = KIO::encodeFileName(n);
             if (d->bDesktopFile && !newFileName.endsWith(QLatin1String(".desktop")) &&
                     !newFileName.endsWith(QLatin1String(".kdelnk"))) {
                 newFileName += QLatin1String(".desktop");
             }
 
             // Tell properties. Warning, this changes the result of properties->url() !
             properties->rename(newFileName);
 
             // Update also relative path (for apps)
             if (!d->m_sRelativePath.isEmpty()) {
                 determineRelativePath(properties->url().toLocalFile());
             }
 
             // qDebug() << "New URL = " << properties->url();
             // qDebug() << "old = " << oldurl.url();
 
             // Don't remove the template !!
             if (!d->m_bFromTemplate) { // (normal renaming)
                 job = KIO::moveAs(oldurl, properties->url());
             } else { // Copying a template
                 job = KIO::copyAs(oldurl, properties->url());
             }
 
             connect(job, SIGNAL(result(KJob*)),
                     SLOT(slotCopyFinished(KJob*)));
             connect(job, SIGNAL(renamed(KIO::Job*,QUrl,QUrl)),
                     SLOT(slotFileRenamed(KIO::Job*,QUrl,QUrl)));
             // wait for job
             QEventLoop eventLoop;
             connect(this, SIGNAL(leaveModality()),
                     &eventLoop, SLOT(quit()));
             eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
             return;
         }
         properties->updateUrl(properties->url());
         // Update also relative path (for apps)
         if (!d->m_sRelativePath.isEmpty()) {
             determineRelativePath(properties->url().toLocalFile());
         }
     }
 
     // No job, keep going
     slotCopyFinished(nullptr);
 }
 
 void KFilePropsPlugin::slotCopyFinished(KJob *job)
 {
     // qDebug() << "KFilePropsPlugin::slotCopyFinished";
     if (job) {
         // allow apply() to return
         emit leaveModality();
         if (job->error()) {
             job->uiDelegate()->showErrorMessage();
             // Didn't work. Revert the URL to the old one
-            properties->updateUrl(static_cast<KIO::CopyJob *>(job)->srcUrls().first());
+            properties->updateUrl(static_cast<KIO::CopyJob *>(job)->srcUrls().constFirst());
             properties->abortApplying(); // Don't apply the changes to the wrong file !
             return;
         }
     }
 
     Q_ASSERT(!properties->item().isNull());
     Q_ASSERT(!properties->item().url().isEmpty());
 
     // Save the file locally
     if (d->bDesktopFile && !d->m_sRelativePath.isEmpty()) {
         // qDebug() << "KFilePropsPlugin::slotCopyFinished " << d->m_sRelativePath;
         const QString newPath = QStandardPaths::writableLocation(QStandardPaths::ApplicationsLocation) + QLatin1Char('/') + d->m_sRelativePath;
         const QUrl newURL = QUrl::fromLocalFile(newPath);
         // qDebug() << "KFilePropsPlugin::slotCopyFinished path=" << newURL;
         properties->updateUrl(newURL);
     }
 
     if (d->bKDesktopMode && d->bDesktopFile) {
         // Renamed? Update Name field
         // Note: The desktop ioslave does this as well, but not when
         //       the file is copied from a template.
         if (d->m_bFromTemplate) {
             KIO::StatJob *job = KIO::stat(properties->url());
             job->exec();
             KIO::UDSEntry entry = job->statResult();
 
             KFileItem item(entry, properties->url());
             KDesktopFile config(item.localPath());
             KConfigGroup cg = config.desktopGroup();
             QString nameStr = nameFromFileName(properties->url().fileName());
             cg.writeEntry("Name", nameStr);
             cg.writeEntry("Name", nameStr, KConfigGroup::Persistent | KConfigGroup::Localized);
         }
     }
 
     if (d->m_linkTargetLineEdit && !d->bMultiple) {
         const KFileItem item = properties->item();
         const QString newTarget = d->m_linkTargetLineEdit->text();
         if (newTarget != item.linkDest()) {
             // qDebug() << "Updating target of symlink to" << newTarget;
             KIO::Job *job = KIO::symlink(newTarget, item.url(), KIO::Overwrite);
             job->uiDelegate()->setAutoErrorHandlingEnabled(true);
             job->exec();
         }
     }
 
     // "Link to Application" templates need to be made executable
     // Instead of matching against a filename we check if the destination
     // is an Application now.
     if (d->m_bFromTemplate) {
         // destination is not necessarily local, use the src template
-        KDesktopFile templateResult(static_cast<KIO::CopyJob *>(job)->srcUrls().first().toLocalFile());
+        KDesktopFile templateResult(static_cast<KIO::CopyJob *>(job)->srcUrls().constFirst().toLocalFile());
         if (templateResult.hasApplicationType()) {
             // We can either stat the file and add the +x bit or use the larger chmod() job
             // with a umask designed to only touch u+x.  This is only one KIO job, so let's
             // do that.
 
             KFileItem appLink(properties->item());
             KFileItemList fileItemList;
             fileItemList << appLink;
 
             // first 0100 adds u+x, second 0100 only allows chmod to change u+x
             KIO::Job *chmodJob = KIO::chmod(fileItemList, 0100, 0100, QString(), QString(), KIO::HideProgressInfo);
             chmodJob->exec();
         }
     }
 }
 
 void KFilePropsPlugin::applyIconChanges()
 {
     KIconButton *iconButton = qobject_cast<KIconButton *>(d->iconArea);
     if (!iconButton || !d->bIconChanged) {
         return;
     }
     // handle icon changes - only local files (or pseudo-local) for now
     // TODO: Use KTempFile and KIO::file_copy with overwrite = true
     QUrl url = properties->url();
     KIO::StatJob *job = KIO::mostLocalUrl(url);
     KJobWidgets::setWindow(job, properties);
     job->exec();
     url = job->mostLocalUrl();
 
     if (url.isLocalFile()) {
         QString path;
 
         if ((properties->item().mode() & QT_STAT_MASK) == QT_STAT_DIR) {
             path = url.toLocalFile() + QLatin1String("/.directory");
             // don't call updateUrl because the other tabs (i.e. permissions)
             // apply to the directory, not the .directory file.
         } else {
             path = url.toLocalFile();
         }
 
         // Get the default image
         QMimeDatabase db;
         QString str = db.mimeTypeForFile(url.toLocalFile(), QMimeDatabase::MatchExtension).iconName();
         // Is it another one than the default ?
         QString sIcon;
         if (str != iconButton->icon()) {
             sIcon = iconButton->icon();
         }
         // (otherwise write empty value)
 
         // qDebug() << "**" << path << "**";
 
         // If default icon and no .directory file -> don't create one
         if (!sIcon.isEmpty() || QFile::exists(path)) {
             KDesktopFile cfg(path);
             // qDebug() << "sIcon = " << (sIcon);
             // qDebug() << "str = " << (str);
             cfg.desktopGroup().writeEntry("Icon", sIcon);
             cfg.sync();
 
             cfg.reparseConfiguration();
             if (cfg.desktopGroup().readEntry("Icon") != sIcon) {
                 KMessageBox::sorry(nullptr, i18n("<qt>Could not save properties. You do not "
                                            "have sufficient access to write to <b>%1</b>.</qt>", path));
             }
         }
     }
 }
 
 void KFilePropsPlugin::slotFileRenamed(KIO::Job *, const QUrl &, const QUrl &newUrl)
 {
     // This is called in case of an existing local file during the copy/move operation,
     // if the user chooses Rename.
     properties->updateUrl(newUrl);
 }
 
 void KFilePropsPlugin::postApplyChanges()
 {
     // Save the icon only after applying the permissions changes (#46192)
     applyIconChanges();
 
     const KFileItemList items = properties->items();
     const QList<QUrl> lst = items.urlList();
     org::kde::KDirNotify::emitFilesChanged(QList<QUrl>(lst));
 }
 
 class KFilePermissionsPropsPlugin::KFilePermissionsPropsPluginPrivate
 {
 public:
     KFilePermissionsPropsPluginPrivate()
     {
     }
     ~KFilePermissionsPropsPluginPrivate()
     {
     }
 
     QFrame *m_frame;
     QCheckBox *cbRecursive;
     QLabel *explanationLabel;
     KComboBox *ownerPermCombo, *groupPermCombo, *othersPermCombo;
     QCheckBox *extraCheckbox;
     mode_t partialPermissions;
     KFilePermissionsPropsPlugin::PermissionsMode pmode;
     bool canChangePermissions;
     bool isIrregular;
     bool hasExtendedACL;
     KACL extendedACL;
     KACL defaultACL;
     bool fileSystemSupportsACLs;
 
     KComboBox *grpCombo;
 
     KLineEdit *usrEdit;
     KLineEdit *grpEdit;
 
     // Old permissions
     mode_t permissions;
     // Old group
     QString strGroup;
     // Old owner
     QString strOwner;
 };
 
 #define UniOwner    (S_IRUSR|S_IWUSR|S_IXUSR)
 #define UniGroup    (S_IRGRP|S_IWGRP|S_IXGRP)
 #define UniOthers   (S_IROTH|S_IWOTH|S_IXOTH)
 #define UniRead     (S_IRUSR|S_IRGRP|S_IROTH)
 #define UniWrite    (S_IWUSR|S_IWGRP|S_IWOTH)
 #define UniExec     (S_IXUSR|S_IXGRP|S_IXOTH)
 #define UniSpecial  (S_ISUID|S_ISGID|S_ISVTX)
 
 // synced with PermissionsTarget
 const mode_t KFilePermissionsPropsPlugin::permissionsMasks[3] = {UniOwner, UniGroup, UniOthers};
 const mode_t KFilePermissionsPropsPlugin::standardPermissions[4] = { 0, UniRead, UniRead | UniWrite, (mode_t) - 1 };
 
 // synced with PermissionsMode and standardPermissions
 const char *const KFilePermissionsPropsPlugin::permissionsTexts[4][4] = {
     {
         I18N_NOOP("No Access"),
         I18N_NOOP("Can Only View"),
         I18N_NOOP("Can View & Modify"),
         nullptr
     },
     {
         I18N_NOOP("No Access"),
         I18N_NOOP("Can Only View Content"),
         I18N_NOOP("Can View & Modify Content"),
         nullptr
     },
     { nullptr, nullptr, nullptr, nullptr}, // no texts for links
     {
         I18N_NOOP("No Access"),
         I18N_NOOP("Can Only View/Read Content"),
         I18N_NOOP("Can View/Read & Modify/Write"),
         nullptr
     }
 };
 
 KFilePermissionsPropsPlugin::KFilePermissionsPropsPlugin(KPropertiesDialog *_props)
     : KPropertiesDialogPlugin(_props), d(new KFilePermissionsPropsPluginPrivate)
 {
     d->cbRecursive = nullptr;
     d->grpCombo = nullptr; d->grpEdit = nullptr;
     d->usrEdit = nullptr;
     bool isLocal = properties->url().isLocalFile();
     bool isTrash = (properties->url().scheme() == QLatin1String("trash"));
     KUser myself(KUser::UseEffectiveUID);
     const bool IamRoot = myself.isSuperUser();
 
     const KFileItem item = properties->item();
     bool isLink = item.isLink();
     bool isDir = item.isDir(); // all dirs
     bool hasDir = item.isDir(); // at least one dir
     d->permissions = item.permissions(); // common permissions to all files
     d->partialPermissions = d->permissions; // permissions that only some files have (at first we take everything)
     d->isIrregular = isIrregular(d->permissions, isDir, isLink);
     d->strOwner = item.user();
     d->strGroup = item.group();
     d->hasExtendedACL = item.ACL().isExtended() || item.defaultACL().isValid();
     d->extendedACL = item.ACL();
     d->defaultACL = item.defaultACL();
     d->fileSystemSupportsACLs = false;
 
     if (properties->items().count() > 1) {
         // Multiple items: see what they have in common
         const KFileItemList items = properties->items();
         KFileItemList::const_iterator it = items.begin();
         const KFileItemList::const_iterator kend = items.end();
         for (++it /*no need to check the first one again*/; it != kend; ++it) {
             if (!d->isIrregular)
                 d->isIrregular |= isIrregular((*it).permissions(),
                                               (*it).isDir() == isDir,
                                               (*it).isLink() == isLink);
             d->hasExtendedACL = d->hasExtendedACL || (*it).hasExtendedACL();
             if ((*it).isLink() != isLink) {
                 isLink = false;
             }
             if ((*it).isDir() != isDir) {
                 isDir = false;
             }
             hasDir |= (*it).isDir();
             if ((*it).permissions() != d->permissions) {
                 d->permissions &= (*it).permissions();
                 d->partialPermissions |= (*it).permissions();
             }
             if ((*it).user() != d->strOwner) {
                 d->strOwner.clear();
             }
             if ((*it).group() != d->strGroup) {
                 d->strGroup.clear();
             }
         }
     }
 
     if (isLink) {
         d->pmode = PermissionsOnlyLinks;
     } else if (isDir) {
         d->pmode = PermissionsOnlyDirs;
     } else if (hasDir) {
         d->pmode = PermissionsMixed;
     } else {
         d->pmode = PermissionsOnlyFiles;
     }
 
     // keep only what's not in the common permissions
     d->partialPermissions = d->partialPermissions & ~d->permissions;
 
     bool isMyFile = false;
 
     if (isLocal && !d->strOwner.isEmpty()) { // local files, and all owned by the same person
         if (myself.isValid()) {
             isMyFile = (d->strOwner == myself.loginName());
         } else {
             qCWarning(KIO_WIDGETS) << "I don't exist ?! geteuid=" << KUserId::currentEffectiveUserId().toString();
         }
     } else {
         //We don't know, for remote files, if they are ours or not.
         //So we let the user change permissions, and
         //KIO::chmod will tell, if he had no right to do it.
         isMyFile = true;
     }
 
     d->canChangePermissions = (isMyFile || IamRoot) && (!isLink);
 
     // create GUI
 
     d->m_frame = new QFrame();
     properties->addPage(d->m_frame, i18n("&Permissions"));
 
     QBoxLayout *box = new QVBoxLayout(d->m_frame);
     box->setMargin(0);
 
     QWidget *l;
     QLabel *lbl;
     QGroupBox *gb;
     QGridLayout *gl;
     QPushButton *pbAdvancedPerm = nullptr;
 
     /* Group: Access Permissions */
     gb = new QGroupBox(i18n("Access Permissions"), d->m_frame);
     box->addWidget(gb);
 
     gl = new QGridLayout(gb);
     gl->setColumnStretch(1, 1);
 
     l = d->explanationLabel = new QLabel(gb);
     if (isLink)
         d->explanationLabel->setText(i18np("This file is a link and does not have permissions.",
                                            "All files are links and do not have permissions.",
                                            properties->items().count()));
     else if (!d->canChangePermissions) {
         d->explanationLabel->setText(i18n("Only the owner can change permissions."));
     }
     gl->addWidget(l, 0, 0, 1, 2);
 
     lbl = new QLabel(i18n("O&wner:"), gb);
     gl->addWidget(lbl, 1, 0, Qt::AlignRight);
     l = d->ownerPermCombo = new KComboBox(gb);
     lbl->setBuddy(l);
     gl->addWidget(l, 1, 1);
     connect(l, SIGNAL(activated(int)), this, SIGNAL(changed()));
     l->setWhatsThis(i18n("Specifies the actions that the owner is allowed to do."));
 
     lbl = new QLabel(i18n("Gro&up:"), gb);
     gl->addWidget(lbl, 2, 0, Qt::AlignRight);
     l = d->groupPermCombo = new KComboBox(gb);
     lbl->setBuddy(l);
     gl->addWidget(l, 2, 1);
     connect(l, SIGNAL(activated(int)), this, SIGNAL(changed()));
     l->setWhatsThis(i18n("Specifies the actions that the members of the group are allowed to do."));
 
     lbl = new QLabel(i18n("O&thers:"), gb);
     gl->addWidget(lbl, 3, 0, Qt::AlignRight);
     l = d->othersPermCombo = new KComboBox(gb);
     lbl->setBuddy(l);
     gl->addWidget(l, 3, 1);
     connect(l, SIGNAL(activated(int)), this, SIGNAL(changed()));
     l->setWhatsThis(i18n("Specifies the actions that all users, who are neither "
                          "owner nor in the group, are allowed to do."));
 
     if (!isLink) {
         l = d->extraCheckbox = new QCheckBox(hasDir ?
                                              i18n("Only own&er can rename and delete folder content") :
                                              i18n("Is &executable"),
                                              gb);
         connect(d->extraCheckbox, SIGNAL(clicked()), this, SIGNAL(changed()));
         gl->addWidget(l, 4, 1);
         l->setWhatsThis(hasDir ? i18n("Enable this option to allow only the folder's owner to "
                                       "delete or rename the contained files and folders. Other "
                                       "users can only add new files, which requires the 'Modify "
                                       "Content' permission.")
                         : i18n("Enable this option to mark the file as executable. This only makes "
                                "sense for programs and scripts. It is required when you want to "
                                "execute them."));
 
         QLayoutItem *spacer = new QSpacerItem(0, 20, QSizePolicy::Minimum, QSizePolicy::Expanding);
         gl->addItem(spacer, 5, 0, 1, 3);
 
         pbAdvancedPerm = new QPushButton(i18n("A&dvanced Permissions"), gb);
         gl->addWidget(pbAdvancedPerm, 6, 0, 1, 2, Qt::AlignRight);
         connect(pbAdvancedPerm, SIGNAL(clicked()), this, SLOT(slotShowAdvancedPermissions()));
     } else {
         d->extraCheckbox = nullptr;
     }
 
     /**** Group: Ownership ****/
     gb = new QGroupBox(i18n("Ownership"), d->m_frame);
     box->addWidget(gb);
 
     gl = new QGridLayout(gb);
     gl->addItem(new QSpacerItem(0, 10), 0, 0);
 
     /*** Set Owner ***/
     l = new QLabel(i18n("User:"), gb);
     gl->addWidget(l, 1, 0, Qt::AlignRight);
 
     /* GJ: Don't autocomplete more than 1000 users. This is a kind of random
     * value. Huge sites having 10.000+ user have a fair chance of using NIS,
     * (possibly) making this unacceptably slow.
     * OTOH, it is nice to offer this functionality for the standard user.
     */
     int maxEntries = 1000;
 
     /* File owner: For root, offer a KLineEdit with autocompletion.
     * For a user, who can never chown() a file, offer a QLabel.
     */
     if (IamRoot && isLocal) {
         d->usrEdit = new KLineEdit(gb);
         KCompletion *kcom = d->usrEdit->completionObject();
         kcom->setOrder(KCompletion::Sorted);
         QStringList userNames = KUser::allUserNames(maxEntries);
         kcom->setItems(userNames);
         d->usrEdit->setCompletionMode((userNames.size() < maxEntries) ? KCompletion::CompletionAuto :
                                       KCompletion::CompletionNone);
         d->usrEdit->setText(d->strOwner);
         gl->addWidget(d->usrEdit, 1, 1);
         connect(d->usrEdit, SIGNAL(textChanged(QString)),
                 this, SIGNAL(changed()));
     } else {
         l = new QLabel(d->strOwner, gb);
         gl->addWidget(l, 1, 1);
     }
 
     /*** Set Group ***/
 
     QStringList groupList;
     KUser user(KUser::UseEffectiveUID);
     const bool isMyGroup = user.groupNames().contains(d->strGroup);
 
     /* add the group the file currently belongs to ..
     * .. if it is not there already
     */
     if (!isMyGroup) {
         groupList += d->strGroup;
     }
 
     l = new QLabel(i18n("Group:"), gb);
     gl->addWidget(l, 2, 0, Qt::AlignRight);
 
     /* Set group: if possible to change:
     * - Offer a KLineEdit for root, since he can change to any group.
     * - Offer a KComboBox for a normal user, since he can change to a fixed
     *   (small) set of groups only.
     * If not changeable: offer a QLabel.
     */
     if (IamRoot && isLocal) {
         d->grpEdit = new KLineEdit(gb);
         KCompletion *kcom = new KCompletion;
         kcom->setItems(groupList);
         d->grpEdit->setCompletionObject(kcom, true);
         d->grpEdit->setAutoDeleteCompletionObject(true);
         d->grpEdit->setCompletionMode(KCompletion::CompletionAuto);
         d->grpEdit->setText(d->strGroup);
         gl->addWidget(d->grpEdit, 2, 1);
         connect(d->grpEdit, SIGNAL(textChanged(QString)),
                 this, SIGNAL(changed()));
     } else if ((groupList.count() > 1) && isMyFile && isLocal) {
         d->grpCombo = new KComboBox(gb);
         d->grpCombo->setObjectName(QStringLiteral("combogrouplist"));
         d->grpCombo->addItems(groupList);
         d->grpCombo->setCurrentIndex(groupList.indexOf(d->strGroup));
         gl->addWidget(d->grpCombo, 2, 1);
         connect(d->grpCombo, SIGNAL(activated(int)),
                 this, SIGNAL(changed()));
     } else {
         l = new QLabel(d->strGroup, gb);
         gl->addWidget(l, 2, 1);
     }
 
     gl->setColumnStretch(2, 10);
 
     // "Apply recursive" checkbox
     if (hasDir && !isLink && !isTrash) {
         d->cbRecursive = new QCheckBox(i18n("Apply changes to all subfolders and their contents"), d->m_frame);
         connect(d->cbRecursive, SIGNAL(clicked()), this, SIGNAL(changed()));
         box->addWidget(d->cbRecursive);
     }
 
     updateAccessControls();
 
     if (isTrash) {
         //don't allow to change properties for file into trash
         enableAccessControls(false);
         if (pbAdvancedPerm) {
             pbAdvancedPerm->setEnabled(false);
         }
     }
 
     box->addStretch(10);
 }
 
 #if HAVE_POSIX_ACL
 static bool fileSystemSupportsACL(const QByteArray &path)
 {
     bool fileSystemSupportsACLs = false;
 #ifdef Q_OS_FREEBSD
     struct statfs buf;
     fileSystemSupportsACLs = (statfs(path.data(), &buf) == 0) && (buf.f_flags & MNT_ACLS);
 #elif defined Q_OS_MACOS
     fileSystemSupportsACLs =
         getxattr(path.data(), "system.posix_acl_access", nullptr, 0, 0, XATTR_NOFOLLOW) >= 0 || errno == ENODATA;
 #else
     fileSystemSupportsACLs =
         getxattr(path.data(), "system.posix_acl_access", nullptr, 0) >= 0 || errno == ENODATA;
 #endif
     return fileSystemSupportsACLs;
 }
 #endif
 
 void KFilePermissionsPropsPlugin::slotShowAdvancedPermissions()
 {
 
     bool isDir = (d->pmode == PermissionsOnlyDirs) || (d->pmode == PermissionsMixed);
     QDialog dlg(properties);
     dlg.setModal(true);
     dlg.setWindowTitle(i18n("Advanced Permissions"));
 
     QLabel *l, *cl[3];
     QGroupBox *gb;
     QGridLayout *gl;
 
     QVBoxLayout *vbox = new QVBoxLayout;
     dlg.setLayout(vbox);
     // Group: Access Permissions
     gb = new QGroupBox(i18n("Access Permissions"), &dlg);
     vbox->addWidget(gb);
 
     gl = new QGridLayout(gb);
     gl->addItem(new QSpacerItem(0, 10), 0, 0);
 
     QVector<QWidget *> theNotSpecials;
 
     l = new QLabel(i18n("Class"), gb);
     gl->addWidget(l, 1, 0);
     theNotSpecials.append(l);
 
     QString readWhatsThis;
     QString readLabel;
     if (isDir) {
         readLabel = i18n("Show\nEntries");
         readWhatsThis = i18n("This flag allows viewing the content of the folder.");
     } else {
         readLabel = i18n("Read");
         readWhatsThis = i18n("The Read flag allows viewing the content of the file.");
     }
 
     QString writeWhatsThis;
     QString writeLabel;
     if (isDir) {
         writeLabel = i18n("Write\nEntries");
         writeWhatsThis = i18n("This flag allows adding, renaming and deleting of files. "
                               "Note that deleting and renaming can be limited using the Sticky flag.");
     } else {
         writeLabel = i18n("Write");
         writeWhatsThis = i18n("The Write flag allows modifying the content of the file.");
     }
 
     QString execLabel;
     QString execWhatsThis;
     if (isDir) {
         execLabel = i18nc("Enter folder", "Enter");
         execWhatsThis = i18n("Enable this flag to allow entering the folder.");
     } else {
         execLabel = i18n("Exec");
         execWhatsThis = i18n("Enable this flag to allow executing the file as a program.");
     }
     // GJ: Add space between normal and special modes
     QSize size = l->sizeHint();
     size.setWidth(size.width() + 15);
     l->setFixedSize(size);
     gl->addWidget(l, 1, 3);
 
     l = new QLabel(i18n("Special"), gb);
     gl->addWidget(l, 1, 4, 1, 1);
     QString specialWhatsThis;
     if (isDir)
         specialWhatsThis = i18n("Special flag. Valid for the whole folder, the exact "
                                 "meaning of the flag can be seen in the right hand column.");
     else
         specialWhatsThis = i18n("Special flag. The exact meaning of the flag can be seen "
                                 "in the right hand column.");
     l->setWhatsThis(specialWhatsThis);
 
     cl[0] = new QLabel(i18n("User"), gb);
     gl->addWidget(cl[0], 2, 0);
     theNotSpecials.append(cl[0]);
 
     cl[1] = new QLabel(i18n("Group"), gb);
     gl->addWidget(cl[1], 3, 0);
     theNotSpecials.append(cl[1]);
 
     cl[2] = new QLabel(i18n("Others"), gb);
     gl->addWidget(cl[2], 4, 0);
     theNotSpecials.append(cl[2]);
 
     QString setUidWhatsThis;
     if (isDir)
         setUidWhatsThis = i18n("If this flag is set, the owner of this folder will be "
                                "the owner of all new files.");
     else
         setUidWhatsThis = i18n("If this file is an executable and the flag is set, it will "
                                "be executed with the permissions of the owner.");
 
     QString setGidWhatsThis;
     if (isDir)
         setGidWhatsThis = i18n("If this flag is set, the group of this folder will be "
                                "set for all new files.");
     else
         setGidWhatsThis = i18n("If this file is an executable and the flag is set, it will "
                                "be executed with the permissions of the group.");
 
     QString stickyWhatsThis;
     if (isDir)
         stickyWhatsThis = i18n("If the Sticky flag is set on a folder, only the owner "
                                "and root can delete or rename files. Otherwise everybody "
                                "with write permissions can do this.");
     else
         stickyWhatsThis = i18n("The Sticky flag on a file is ignored on Linux, but may "
                                "be used on some systems");
     mode_t aPermissions, aPartialPermissions;
     mode_t dummy1, dummy2;
 
     if (!d->isIrregular) {
         switch (d->pmode) {
         case PermissionsOnlyFiles:
             getPermissionMasks(aPartialPermissions,
                                dummy1,
                                aPermissions,
                                dummy2);
             break;
         case PermissionsOnlyDirs:
         case PermissionsMixed:
             getPermissionMasks(dummy1,
                                aPartialPermissions,
                                dummy2,
                                aPermissions);
             break;
         case PermissionsOnlyLinks:
             aPermissions = UniRead | UniWrite | UniExec | UniSpecial;
             aPartialPermissions = 0;
             break;
         }
     } else {
         aPermissions = d->permissions;
         aPartialPermissions = d->partialPermissions;
     }
 
     // Draw Checkboxes
     QCheckBox *cba[3][4];
     for (int row = 0; row < 3; ++row) {
         for (int col = 0; col < 4; ++col) {
             QCheckBox *cb = new QCheckBox(gb);
             if (col != 3) {
                 theNotSpecials.append(cb);
             }
             cba[row][col] = cb;
             cb->setChecked(aPermissions & fperm[row][col]);
             if (aPartialPermissions & fperm[row][col]) {
                 cb->setTristate();
                 cb->setCheckState(Qt::PartiallyChecked);
             } else if (d->cbRecursive && d->cbRecursive->isChecked()) {
                 cb->setTristate();
             }
 
             cb->setEnabled(d->canChangePermissions);
             gl->addWidget(cb, row + 2, col + 1);
             switch (col) {
             case 0:
                 cb->setText(readLabel);
                 cb->setWhatsThis(readWhatsThis);
                 break;
             case 1:
                 cb->setText(writeLabel);
                 cb->setWhatsThis(writeWhatsThis);
                 break;
             case 2:
                 cb->setText(execLabel);
                 cb->setWhatsThis(execWhatsThis);
                 break;
             case 3:
                 switch (row) {
                 case 0:
                     cb->setText(i18n("Set UID"));
                     cb->setWhatsThis(setUidWhatsThis);
                     break;
                 case 1:
                     cb->setText(i18n("Set GID"));
                     cb->setWhatsThis(setGidWhatsThis);
                     break;
                 case 2:
                     cb->setText(i18nc("File permission", "Sticky"));
                     cb->setWhatsThis(stickyWhatsThis);
                     break;
                 }
                 break;
             }
         }
     }
     gl->setColumnStretch(6, 10);
 
 #if HAVE_POSIX_ACL
     KACLEditWidget *extendedACLs = nullptr;
 
     // FIXME make it work with partial entries
     if (properties->items().count() == 1) {
         QByteArray path = QFile::encodeName(properties->item().url().toLocalFile());
         d->fileSystemSupportsACLs = fileSystemSupportsACL(path);
     }
     if (d->fileSystemSupportsACLs) {
         std::for_each(theNotSpecials.begin(), theNotSpecials.end(), std::mem_fun(&QWidget::hide));
         extendedACLs = new KACLEditWidget(&dlg);
         extendedACLs->setEnabled(d->canChangePermissions);
         vbox->addWidget(extendedACLs);
         if (d->extendedACL.isValid() && d->extendedACL.isExtended()) {
             extendedACLs->setACL(d->extendedACL);
         } else {
             extendedACLs->setACL(KACL(aPermissions));
         }
 
         if (d->defaultACL.isValid()) {
             extendedACLs->setDefaultACL(d->defaultACL);
         }
 
-        if (properties->items().first().isDir()) {
+        if (properties->items().constFirst().isDir()) {
             extendedACLs->setAllowDefaults(true);
         }
     }
 #endif
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(&dlg);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     connect(buttonBox, SIGNAL(accepted()), &dlg, SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), &dlg, SLOT(reject()));
     vbox->addWidget(buttonBox);
 
     if (dlg.exec() != QDialog::Accepted) {
         return;
     }
 
     mode_t andPermissions = mode_t(~0);
     mode_t orPermissions = 0;
     for (int row = 0; row < 3; ++row)
         for (int col = 0; col < 4; ++col) {
             switch (cba[row][col]->checkState()) {
             case Qt::Checked:
                 orPermissions |= fperm[row][col];
             //fall through
             case Qt::Unchecked:
                 andPermissions &= ~fperm[row][col];
                 break;
             case Qt::PartiallyChecked:
                 break;
             }
         }
 
     d->isIrregular = false;
     const KFileItemList items = properties->items();
     KFileItemList::const_iterator it = items.begin();
     const KFileItemList::const_iterator kend = items.end();
     for (; it != kend; ++it) {
         if (isIrregular(((*it).permissions() & andPermissions) | orPermissions,
                         (*it).isDir(), (*it).isLink())) {
             d->isIrregular = true;
             break;
         }
     }
 
     d->permissions = orPermissions;
     d->partialPermissions = andPermissions;
 
 #if HAVE_POSIX_ACL
     // override with the acls, if present
     if (extendedACLs) {
         d->extendedACL = extendedACLs->getACL();
         d->defaultACL = extendedACLs->getDefaultACL();
         d->hasExtendedACL = d->extendedACL.isExtended() || d->defaultACL.isValid();
         d->permissions = d->extendedACL.basePermissions();
         d->permissions |= (andPermissions | orPermissions) & (S_ISUID | S_ISGID | S_ISVTX);
     }
 #endif
 
     updateAccessControls();
     emit changed();
 }
 
 // QString KFilePermissionsPropsPlugin::tabName () const
 // {
 //   return i18n ("&Permissions");
 // }
 
 KFilePermissionsPropsPlugin::~KFilePermissionsPropsPlugin()
 {
     delete d;
 }
 
 bool KFilePermissionsPropsPlugin::supports(const KFileItemList & /*_items*/)
 {
     return true;
 }
 
 // sets a combo box in the Access Control frame
 void KFilePermissionsPropsPlugin::setComboContent(QComboBox *combo, PermissionsTarget target,
         mode_t permissions, mode_t partial)
 {
     combo->clear();
     if (d->isIrregular) { //#176876
         return;
     }
 
     if (d->pmode == PermissionsOnlyLinks) {
         combo->addItem(i18n("Link"));
         combo->setCurrentIndex(0);
         return;
     }
 
     mode_t tMask = permissionsMasks[target];
     int textIndex;
     for (textIndex = 0; standardPermissions[textIndex] != (mode_t) - 1; textIndex++) {
         if ((standardPermissions[textIndex]&tMask) == (permissions & tMask & (UniRead | UniWrite))) {
             break;
         }
     }
     Q_ASSERT(standardPermissions[textIndex] != (mode_t) - 1); // must not happen, would be irreglar
 
     for (int i = 0; permissionsTexts[(int)d->pmode][i]; i++) {
         combo->addItem(i18n(permissionsTexts[(int)d->pmode][i]));
     }
 
     if (partial & tMask & ~UniExec) {
         combo->addItem(i18n("Varying (No Change)"));
         combo->setCurrentIndex(3);
     } else {
         combo->setCurrentIndex(textIndex);
     }
 }
 
 // permissions are irregular if they cant be displayed in a combo box.
 bool KFilePermissionsPropsPlugin::isIrregular(mode_t permissions, bool isDir, bool isLink)
 {
     if (isLink) {                           // links are always ok
         return false;
     }
 
     mode_t p = permissions;
     if (p & (S_ISUID | S_ISGID)) { // setuid/setgid -> irregular
         return true;
     }
     if (isDir) {
         p &= ~S_ISVTX;          // ignore sticky on dirs
 
         // check supported flag combinations
         mode_t p0 = p & UniOwner;
         if ((p0 != 0) && (p0 != (S_IRUSR | S_IXUSR)) && (p0 != UniOwner)) {
             return true;
         }
         p0 = p & UniGroup;
         if ((p0 != 0) && (p0 != (S_IRGRP | S_IXGRP)) && (p0 != UniGroup)) {
             return true;
         }
         p0 = p & UniOthers;
         if ((p0 != 0) && (p0 != (S_IROTH | S_IXOTH)) && (p0 != UniOthers)) {
             return true;
         }
         return false;
     }
     if (p & S_ISVTX) { // sticky on file -> irregular
         return true;
     }
 
     // check supported flag combinations
     mode_t p0 = p & UniOwner;
     bool usrXPossible = !p0; // true if this file could be an executable
     if (p0 & S_IXUSR) {
         if ((p0 == S_IXUSR) || (p0 == (S_IWUSR | S_IXUSR))) {
             return true;
         }
         usrXPossible = true;
     } else if (p0 == S_IWUSR) {
         return true;
     }
 
     p0 = p & UniGroup;
     bool grpXPossible = !p0; // true if this file could be an executable
     if (p0 & S_IXGRP) {
         if ((p0 == S_IXGRP) || (p0 == (S_IWGRP | S_IXGRP))) {
             return true;
         }
         grpXPossible = true;
     } else if (p0 == S_IWGRP) {
         return true;
     }
     if (p0 == 0) {
         grpXPossible = true;
     }
 
     p0 = p & UniOthers;
     bool othXPossible = !p0; // true if this file could be an executable
     if (p0 & S_IXOTH) {
         if ((p0 == S_IXOTH) || (p0 == (S_IWOTH | S_IXOTH))) {
             return true;
         }
         othXPossible = true;
     } else if (p0 == S_IWOTH) {
         return true;
     }
 
     // check that there either all targets are executable-compatible, or none
     return (p & UniExec) && !(usrXPossible && grpXPossible && othXPossible);
 }
 
 // enables/disabled the widgets in the Access Control frame
 void KFilePermissionsPropsPlugin::enableAccessControls(bool enable)
 {
     d->ownerPermCombo->setEnabled(enable);
     d->groupPermCombo->setEnabled(enable);
     d->othersPermCombo->setEnabled(enable);
     if (d->extraCheckbox) {
         d->extraCheckbox->setEnabled(enable);
     }
     if (d->cbRecursive) {
         d->cbRecursive->setEnabled(enable);
     }
 }
 
 // updates all widgets in the Access Control frame
 void KFilePermissionsPropsPlugin::updateAccessControls()
 {
     setComboContent(d->ownerPermCombo, PermissionsOwner,
                     d->permissions, d->partialPermissions);
     setComboContent(d->groupPermCombo, PermissionsGroup,
                     d->permissions, d->partialPermissions);
     setComboContent(d->othersPermCombo, PermissionsOthers,
                     d->permissions, d->partialPermissions);
 
     switch (d->pmode) {
     case PermissionsOnlyLinks:
         enableAccessControls(false);
         break;
     case PermissionsOnlyFiles:
         enableAccessControls(d->canChangePermissions && !d->isIrregular && !d->hasExtendedACL);
         if (d->canChangePermissions)
             d->explanationLabel->setText(d->isIrregular || d->hasExtendedACL ?
                                          i18np("This file uses advanced permissions",
                                                "These files use advanced permissions.",
                                                properties->items().count()) : QString());
         if (d->partialPermissions & UniExec) {
             d->extraCheckbox->setTristate();
             d->extraCheckbox->setCheckState(Qt::PartiallyChecked);
         } else {
             d->extraCheckbox->setTristate(false);
             d->extraCheckbox->setChecked(d->permissions & UniExec);
         }
         break;
     case PermissionsOnlyDirs:
         enableAccessControls(d->canChangePermissions && !d->isIrregular && !d->hasExtendedACL);
         // if this is a dir, and we can change permissions, don't dis-allow
         // recursive, we can do that for ACL setting.
         if (d->cbRecursive) {
             d->cbRecursive->setEnabled(d->canChangePermissions && !d->isIrregular);
         }
 
         if (d->canChangePermissions)
             d->explanationLabel->setText(d->isIrregular || d->hasExtendedACL ?
                                          i18np("This folder uses advanced permissions.",
                                                "These folders use advanced permissions.",
                                                properties->items().count()) : QString());
         if (d->partialPermissions & S_ISVTX) {
             d->extraCheckbox->setTristate();
             d->extraCheckbox->setCheckState(Qt::PartiallyChecked);
         } else {
             d->extraCheckbox->setTristate(false);
             d->extraCheckbox->setChecked(d->permissions & S_ISVTX);
         }
         break;
     case PermissionsMixed:
         enableAccessControls(d->canChangePermissions && !d->isIrregular && !d->hasExtendedACL);
         if (d->canChangePermissions)
             d->explanationLabel->setText(d->isIrregular || d->hasExtendedACL ?
                                          i18n("These files use advanced permissions.") : QString());
         if (d->partialPermissions & S_ISVTX) {
             d->extraCheckbox->setTristate();
             d->extraCheckbox->setCheckState(Qt::PartiallyChecked);
         } else {
             d->extraCheckbox->setTristate(false);
             d->extraCheckbox->setChecked(d->permissions & S_ISVTX);
         }
         break;
     }
 }
 
 // gets masks for files and dirs from the Access Control frame widgets
 void KFilePermissionsPropsPlugin::getPermissionMasks(mode_t &andFilePermissions,
         mode_t &andDirPermissions,
         mode_t &orFilePermissions,
         mode_t &orDirPermissions)
 {
     andFilePermissions = mode_t(~UniSpecial);
     andDirPermissions = mode_t(~(S_ISUID | S_ISGID));
     orFilePermissions = 0;
     orDirPermissions = 0;
     if (d->isIrregular) {
         return;
     }
 
     mode_t m = standardPermissions[d->ownerPermCombo->currentIndex()];
     if (m != (mode_t) - 1) {
         orFilePermissions |= m & UniOwner;
         if ((m & UniOwner) &&
                 ((d->pmode == PermissionsMixed) ||
                  ((d->pmode == PermissionsOnlyFiles) && (d->extraCheckbox->checkState() == Qt::PartiallyChecked)))) {
             andFilePermissions &= ~(S_IRUSR | S_IWUSR);
         } else {
             andFilePermissions &= ~(S_IRUSR | S_IWUSR | S_IXUSR);
             if ((m & S_IRUSR) && (d->extraCheckbox->checkState() == Qt::Checked)) {
                 orFilePermissions |= S_IXUSR;
             }
         }
 
         orDirPermissions |= m & UniOwner;
         if (m & S_IRUSR) {
             orDirPermissions |= S_IXUSR;
         }
         andDirPermissions &= ~(S_IRUSR | S_IWUSR | S_IXUSR);
     }
 
     m = standardPermissions[d->groupPermCombo->currentIndex()];
     if (m != (mode_t) - 1) {
         orFilePermissions |= m & UniGroup;
         if ((m & UniGroup) &&
                 ((d->pmode == PermissionsMixed) ||
                  ((d->pmode == PermissionsOnlyFiles) && (d->extraCheckbox->checkState() == Qt::PartiallyChecked)))) {
             andFilePermissions &= ~(S_IRGRP | S_IWGRP);
         } else {
             andFilePermissions &= ~(S_IRGRP | S_IWGRP | S_IXGRP);
             if ((m & S_IRGRP) && (d->extraCheckbox->checkState() == Qt::Checked)) {
                 orFilePermissions |= S_IXGRP;
             }
         }
 
         orDirPermissions |= m & UniGroup;
         if (m & S_IRGRP) {
             orDirPermissions |= S_IXGRP;
         }
         andDirPermissions &= ~(S_IRGRP | S_IWGRP | S_IXGRP);
     }
 
     m = d->othersPermCombo->currentIndex() >= 0 ? standardPermissions[d->othersPermCombo->currentIndex()] : (mode_t) - 1;
     if (m != (mode_t) - 1) {
         orFilePermissions |= m & UniOthers;
         if ((m & UniOthers) &&
                 ((d->pmode == PermissionsMixed) ||
                  ((d->pmode == PermissionsOnlyFiles) && (d->extraCheckbox->checkState() == Qt::PartiallyChecked)))) {
             andFilePermissions &= ~(S_IROTH | S_IWOTH);
         } else {
             andFilePermissions &= ~(S_IROTH | S_IWOTH | S_IXOTH);
             if ((m & S_IROTH) && (d->extraCheckbox->checkState() == Qt::Checked)) {
                 orFilePermissions |= S_IXOTH;
             }
         }
 
         orDirPermissions |= m & UniOthers;
         if (m & S_IROTH) {
             orDirPermissions |= S_IXOTH;
         }
         andDirPermissions &= ~(S_IROTH | S_IWOTH | S_IXOTH);
     }
 
     if (((d->pmode == PermissionsMixed) || (d->pmode == PermissionsOnlyDirs)) &&
             (d->extraCheckbox->checkState() != Qt::PartiallyChecked)) {
         andDirPermissions &= ~S_ISVTX;
         if (d->extraCheckbox->checkState() == Qt::Checked) {
             orDirPermissions |= S_ISVTX;
         }
     }
 }
 
 void KFilePermissionsPropsPlugin::applyChanges()
 {
     mode_t orFilePermissions;
     mode_t orDirPermissions;
     mode_t andFilePermissions;
     mode_t andDirPermissions;
 
     if (!d->canChangePermissions) {
         return;
     }
 
     if (!d->isIrregular)
         getPermissionMasks(andFilePermissions,
                            andDirPermissions,
                            orFilePermissions,
                            orDirPermissions);
     else {
         orFilePermissions = d->permissions;
         andFilePermissions = d->partialPermissions;
         orDirPermissions = d->permissions;
         andDirPermissions = d->partialPermissions;
     }
 
     QString owner, group;
     if (d->usrEdit) {
         owner = d->usrEdit->text();
     }
     if (d->grpEdit) {
         group = d->grpEdit->text();
     } else if (d->grpCombo) {
         group = d->grpCombo->currentText();
     }
 
     if (owner == d->strOwner) {
         owner.clear();    // no change
     }
 
     if (group == d->strGroup) {
         group.clear();
     }
 
     bool recursive = d->cbRecursive && d->cbRecursive->isChecked();
     bool permissionChange = false;
 
     KFileItemList files, dirs;
     const KFileItemList items = properties->items();
     KFileItemList::const_iterator it = items.begin();
     const KFileItemList::const_iterator kend = items.end();
     for (; it != kend; ++it) {
         if ((*it).isDir()) {
             dirs.append(*it);
             if ((*it).permissions() != (((*it).permissions() & andDirPermissions) | orDirPermissions)) {
                 permissionChange = true;
             }
         } else if ((*it).isFile()) {
             files.append(*it);
             if ((*it).permissions() != (((*it).permissions() & andFilePermissions) | orFilePermissions)) {
                 permissionChange = true;
             }
         }
     }
 
     const bool ACLChange = (d->extendedACL !=  properties->item().ACL());
     const bool defaultACLChange = (d->defaultACL != properties->item().defaultACL());
 
     if (owner.isEmpty() && group.isEmpty() && !recursive
             && !permissionChange && !ACLChange && !defaultACLChange) {
         return;
     }
 
     KIO::Job *job;
     if (files.count() > 0) {
         job = KIO::chmod(files, orFilePermissions, ~andFilePermissions,
                          owner, group, false);
         if (ACLChange && d->fileSystemSupportsACLs) {
             job->addMetaData(QStringLiteral("ACL_STRING"), d->extendedACL.isValid() ? d->extendedACL.asString() : QStringLiteral("ACL_DELETE"));
         }
         if (defaultACLChange && d->fileSystemSupportsACLs) {
             job->addMetaData(QStringLiteral("DEFAULT_ACL_STRING"), d->defaultACL.isValid() ? d->defaultACL.asString() : QStringLiteral("ACL_DELETE"));
         }
 
         connect(job, SIGNAL(result(KJob*)),
                 SLOT(slotChmodResult(KJob*)));
         QEventLoop eventLoop;
         connect(this, SIGNAL(leaveModality()),
                 &eventLoop, SLOT(quit()));
         eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
     }
     if (dirs.count() > 0) {
         job = KIO::chmod(dirs, orDirPermissions, ~andDirPermissions,
                          owner, group, recursive);
         if (ACLChange && d->fileSystemSupportsACLs) {
             job->addMetaData(QStringLiteral("ACL_STRING"), d->extendedACL.isValid() ? d->extendedACL.asString() : QStringLiteral("ACL_DELETE"));
         }
         if (defaultACLChange && d->fileSystemSupportsACLs) {
             job->addMetaData(QStringLiteral("DEFAULT_ACL_STRING"), d->defaultACL.isValid() ? d->defaultACL.asString() : QStringLiteral("ACL_DELETE"));
         }
 
         connect(job, SIGNAL(result(KJob*)),
                 SLOT(slotChmodResult(KJob*)));
         QEventLoop eventLoop;
         connect(this, SIGNAL(leaveModality()),
                 &eventLoop, SLOT(quit()));
         eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
     }
 }
 
 void KFilePermissionsPropsPlugin::slotChmodResult(KJob *job)
 {
     // qDebug() << "KFilePermissionsPropsPlugin::slotChmodResult";
     if (job->error()) {
         job->uiDelegate()->showErrorMessage();
     }
     // allow apply() to return
     emit leaveModality();
 }
 
 class KChecksumsPlugin::KChecksumsPluginPrivate
 {
 public:
     KChecksumsPluginPrivate()
     {
     }
 
     ~KChecksumsPluginPrivate()
     {
     }
 
     QWidget m_widget;
     Ui::ChecksumsWidget m_ui;
 
     QFileSystemWatcher fileWatcher;
     QString m_md5;
     QString m_sha1;
     QString m_sha256;
 };
 
 KChecksumsPlugin::KChecksumsPlugin(KPropertiesDialog *dialog)
     : KPropertiesDialogPlugin(dialog), d(new KChecksumsPluginPrivate)
 {
     d->m_ui.setupUi(&d->m_widget);
     properties->addPage(&d->m_widget, i18nc("@title:tab", "C&hecksums"));
 
     d->m_ui.md5CopyButton->hide();
     d->m_ui.sha1CopyButton->hide();
     d->m_ui.sha256CopyButton->hide();
 
     connect(d->m_ui.lineEdit, &QLineEdit::textChanged, this, [=](const QString &text) {
         slotVerifyChecksum(text.toLower());
     });
 
     connect(d->m_ui.md5Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowMd5);
     connect(d->m_ui.sha1Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowSha1);
     connect(d->m_ui.sha256Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowSha256);
 
     d->fileWatcher.addPath(properties->item().localPath());
     connect(&d->fileWatcher, &QFileSystemWatcher::fileChanged, this, &KChecksumsPlugin::slotInvalidateCache);
 
     auto clipboard = QApplication::clipboard();
     connect(d->m_ui.md5CopyButton, &QPushButton::clicked, this, [=]() {
         clipboard->setText(d->m_md5);
     });
 
     connect(d->m_ui.sha1CopyButton, &QPushButton::clicked, this, [=]() {
         clipboard->setText(d->m_sha1);
     });
 
     connect(d->m_ui.sha256CopyButton, &QPushButton::clicked, this, [=]() {
         clipboard->setText(d->m_sha256);
     });
 
     connect(d->m_ui.pasteButton, &QPushButton::clicked, this, [=]() {
         d->m_ui.lineEdit->setText(clipboard->text());
     });
 
     setDefaultState();
 }
 
 KChecksumsPlugin::~KChecksumsPlugin()
 {
     delete d;
 }
 
 bool KChecksumsPlugin::supports(const KFileItemList &items)
 {
     if (items.count() != 1) {
         return false;
     }
 
     const KFileItem item = items.first();
     return item.isFile() && !item.localPath().isEmpty() && item.isReadable() && !item.isDesktopFile() && !item.isLink();
 }
 
 void KChecksumsPlugin::slotInvalidateCache()
 {
     d->m_md5 = QString();
     d->m_sha1 = QString();
     d->m_sha256 = QString();
 }
 
 void KChecksumsPlugin::slotShowMd5()
 {
     auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget);
     label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
 
     d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.md5Button, label);
     d->m_ui.md5Button->hide();
 
     showChecksum(QCryptographicHash::Md5, label, d->m_ui.md5CopyButton);
 }
 
 void KChecksumsPlugin::slotShowSha1()
 {
     auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget);
     label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
 
     d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.sha1Button, label);
     d->m_ui.sha1Button->hide();
 
     showChecksum(QCryptographicHash::Sha1, label, d->m_ui.sha1CopyButton);
 }
 
 void KChecksumsPlugin::slotShowSha256()
 {
     auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget);
     label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
 
     d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.sha256Button, label);
     d->m_ui.sha256Button->hide();
 
     showChecksum(QCryptographicHash::Sha256, label, d->m_ui.sha256CopyButton);
 }
 
 void KChecksumsPlugin::slotVerifyChecksum(const QString &input)
 {
     auto algorithm = detectAlgorithm(input);
 
     // Input is not a supported hash algorithm.
     if (algorithm == QCryptographicHash::Md4) {
         if (input.isEmpty()) {
             setDefaultState();
         } else {
             setInvalidChecksumState();
         }
         return;
     }
 
     const QString checksum = cachedChecksum(algorithm);
 
     // Checksum already in cache.
     if (!checksum.isEmpty()) {
         const bool isMatch = (checksum == input);
         if (isMatch) {
             setMatchState();
         } else {
             setMismatchState();
         }
 
         return;
     }
 
     // Calculate checksum in another thread.
     auto futureWatcher = new QFutureWatcher<QString>(this);
     connect(futureWatcher, &QFutureWatcher<QString>::finished, this, [=]() {
 
         const QString checksum = futureWatcher->result();
         futureWatcher->deleteLater();
 
         cacheChecksum(checksum, algorithm);
 
         switch (algorithm) {
         case QCryptographicHash::Md5:
             slotShowMd5();
             break;
         case QCryptographicHash::Sha1:
             slotShowSha1();
             break;
         case QCryptographicHash::Sha256:
             slotShowSha256();
             break;
         default:
             break;
         }
 
         const bool isMatch = (checksum == input);
         if (isMatch) {
             setMatchState();
         } else {
             setMismatchState();
         }
     });
 
     // Notify the user about the background computation.
     setVerifyState();
 
     auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath());
     futureWatcher->setFuture(future);
 }
 
 bool KChecksumsPlugin::isMd5(const QString &input)
 {
     QRegularExpression regex(QStringLiteral("^[a-f0-9]{32}$"));
     return regex.match(input).hasMatch();
 }
 
 bool KChecksumsPlugin::isSha1(const QString &input)
 {
     QRegularExpression regex(QStringLiteral("^[a-f0-9]{40}$"));
     return regex.match(input).hasMatch();
 }
 
 bool KChecksumsPlugin::isSha256(const QString &input)
 {
     QRegularExpression regex(QStringLiteral("^[a-f0-9]{64}$"));
     return regex.match(input).hasMatch();
 }
 
 QString KChecksumsPlugin::computeChecksum(QCryptographicHash::Algorithm algorithm, const QString &path)
 {
     QFile file(path);
     if (!file.open(QIODevice::ReadOnly)) {
         return QString();
     }
 
     QCryptographicHash hash(algorithm);
     hash.addData(&file);
 
     return QString::fromLatin1(hash.result().toHex());
 }
 
 QCryptographicHash::Algorithm KChecksumsPlugin::detectAlgorithm(const QString &input)
 {
     if (isMd5(input)) {
         return QCryptographicHash::Md5;
     }
 
     if (isSha1(input)) {
         return QCryptographicHash::Sha1;
     }
 
     if (isSha256(input)) {
         return QCryptographicHash::Sha256;
     }
 
     // Md4 used as negative error code.
     return QCryptographicHash::Md4;
 }
 
 void KChecksumsPlugin::setDefaultState()
 {
     QColor defaultColor = d->m_widget.palette().color(QPalette::Base);
 
     QPalette palette = d->m_widget.palette();
     palette.setColor(QPalette::Base, defaultColor);
 
     d->m_ui.feedbackLabel->hide();
     d->m_ui.lineEdit->setPalette(palette);
     d->m_ui.lineEdit->setToolTip(QString());
 }
 
 void KChecksumsPlugin::setInvalidChecksumState()
 {
     KColorScheme colorScheme(QPalette::Active, KColorScheme::View);
     QColor warningColor = colorScheme.background(KColorScheme::NegativeBackground).color();
 
     QPalette palette = d->m_widget.palette();
     palette.setColor(QPalette::Base, warningColor);
 
     d->m_ui.feedbackLabel->setText(i18n("Invalid checksum."));
     d->m_ui.feedbackLabel->show();
     d->m_ui.lineEdit->setPalette(palette);
     d->m_ui.lineEdit->setToolTip(i18nc("@info:tooltip", "The given input is not a valid MD5, SHA1 or SHA256 checksum."));
 }
 
 void KChecksumsPlugin::setMatchState()
 {
     KColorScheme colorScheme(QPalette::Active, KColorScheme::View);
     QColor positiveColor = colorScheme.background(KColorScheme::PositiveBackground).color();
 
     QPalette palette = d->m_widget.palette();
     palette.setColor(QPalette::Base, positiveColor);
 
     d->m_ui.feedbackLabel->setText(i18n("Checksums match."));
     d->m_ui.feedbackLabel->show();
     d->m_ui.lineEdit->setPalette(palette);
     d->m_ui.lineEdit->setToolTip(i18nc("@info:tooltip", "The computed checksum and the expected checksum match."));
 }
 
 void KChecksumsPlugin::setMismatchState()
 {
     KColorScheme colorScheme(QPalette::Active, KColorScheme::View);
     QColor warningColor = colorScheme.background(KColorScheme::NegativeBackground).color();
 
     QPalette palette = d->m_widget.palette();
     palette.setColor(QPalette::Base, warningColor);
 
     d->m_ui.feedbackLabel->setText(i18n("<p>Checksums do not match.</p>"
                                         "This may be due to a faulty download. Try re-downloading the file.<br/>"
                                         "If the verification still fails, contact the source of the file."));
     d->m_ui.feedbackLabel->show();
     d->m_ui.lineEdit->setPalette(palette);
     d->m_ui.lineEdit->setToolTip(i18nc("@info:tooltip", "The computed checksum and the expected checksum differ."));
 }
 
 void KChecksumsPlugin::setVerifyState()
 {
     // Users can paste a checksum at any time, so reset to default.
     setDefaultState();
 
     d->m_ui.feedbackLabel->setText(i18nc("notify the user about a computation in the background",  "Verifying checksum..."));
     d->m_ui.feedbackLabel->show();
 }
 
 void KChecksumsPlugin::showChecksum(QCryptographicHash::Algorithm algorithm, QLabel *label, QPushButton *copyButton)
 {
     const QString checksum = cachedChecksum(algorithm);
 
     // Checksum in cache, nothing else to do.
     if (!checksum.isEmpty()) {
         label->setText(checksum);
         return;
     }
 
     // Calculate checksum in another thread.
     auto futureWatcher = new QFutureWatcher<QString>(this);
     connect(futureWatcher, &QFutureWatcher<QString>::finished, this, [=]() {
         const QString checksum = futureWatcher->result();
         futureWatcher->deleteLater();
 
         label->setText(checksum);
         cacheChecksum(checksum, algorithm);
 
         copyButton->show();
     });
 
     auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath());
     futureWatcher->setFuture(future);
 }
 
 QString KChecksumsPlugin::cachedChecksum(QCryptographicHash::Algorithm algorithm) const
 {
     switch (algorithm) {
     case QCryptographicHash::Md5:
         return d->m_md5;
     case QCryptographicHash::Sha1:
         return d->m_sha1;
     case QCryptographicHash::Sha256:
         return d->m_sha256;
     default:
         break;
     }
 
     return QString();
 }
 
 void KChecksumsPlugin::cacheChecksum(const QString &checksum, QCryptographicHash::Algorithm algorithm)
 {
     switch (algorithm) {
     case QCryptographicHash::Md5:
         d->m_md5 = checksum;
         break;
     case QCryptographicHash::Sha1:
         d->m_sha1 = checksum;
         break;
     case QCryptographicHash::Sha256:
         d->m_sha256 = checksum;
         break;
     default:
         return;
     }
 }
 
 class KUrlPropsPlugin::KUrlPropsPluginPrivate
 {
 public:
     KUrlPropsPluginPrivate()
     {
     }
     ~KUrlPropsPluginPrivate()
     {
     }
 
     QFrame *m_frame;
     KUrlRequester *URLEdit;
     QString URLStr;
     bool fileNameReadOnly = false;
 };
 
 KUrlPropsPlugin::KUrlPropsPlugin(KPropertiesDialog *_props)
     : KPropertiesDialogPlugin(_props), d(new KUrlPropsPluginPrivate)
 {
     d->m_frame = new QFrame();
     properties->addPage(d->m_frame, i18n("U&RL"));
     QVBoxLayout *layout = new QVBoxLayout(d->m_frame);
     layout->setMargin(0);
 
     QLabel *l;
     l = new QLabel(d->m_frame);
     l->setObjectName(QStringLiteral("Label_1"));
     l->setText(i18n("URL:"));
     layout->addWidget(l, Qt::AlignRight);
 
     d->URLEdit = new KUrlRequester(d->m_frame);
     layout->addWidget(d->URLEdit);
 
     KIO::StatJob *job = KIO::mostLocalUrl(properties->url());
     KJobWidgets::setWindow(job, properties);
     job->exec();
     QUrl url = job->mostLocalUrl();
 
     if (url.isLocalFile()) {
         QString path = url.toLocalFile();
 
         QFile f(path);
         if (!f.open(QIODevice::ReadOnly)) {
             return;
         }
         f.close();
 
         KDesktopFile config(path);
         const KConfigGroup dg = config.desktopGroup();
         d->URLStr = dg.readPathEntry("URL", QString());
 
         if (!d->URLStr.isEmpty()) {
             d->URLEdit->setUrl(QUrl(d->URLStr));
         }
     }
 
     connect(d->URLEdit, SIGNAL(textChanged(QString)),
             this, SIGNAL(changed()));
 
     layout->addStretch(1);
 }
 
 KUrlPropsPlugin::~KUrlPropsPlugin()
 {
     delete d;
 }
 
 void KUrlPropsPlugin::setFileNameReadOnly(bool ro)
 {
     d->fileNameReadOnly = ro;
 }
 
 // QString KUrlPropsPlugin::tabName () const
 // {
 //   return i18n ("U&RL");
 // }
 
 bool KUrlPropsPlugin::supports(const KFileItemList &_items)
 {
     if (_items.count() != 1) {
         return false;
     }
     const KFileItem item = _items.first();
     // check if desktop file
     if (!item.isDesktopFile()) {
         return false;
     }
 
     // open file and check type
     bool isLocal;
     QUrl url = item.mostLocalUrl(isLocal);
     if (!isLocal) {
         return false;
     }
 
     KDesktopFile config(url.toLocalFile());
     return config.hasLinkType();
 }
 
 void KUrlPropsPlugin::applyChanges()
 {
     KIO::StatJob *job = KIO::mostLocalUrl(properties->url());
     KJobWidgets::setWindow(job, properties);
     job->exec();
     const QUrl url = job->mostLocalUrl();
 
     if (!url.isLocalFile()) {
         KMessageBox::sorry(nullptr, i18n("Could not save properties. Only entries on local file systems are supported."));
         return;
     }
 
     QString path = url.toLocalFile();
     QFile f(path);
     if (!f.open(QIODevice::ReadWrite)) {
         KMessageBox::sorry(nullptr, i18n("<qt>Could not save properties. You do not have "
                                    "sufficient access to write to <b>%1</b>.</qt>", path));
         return;
     }
     f.close();
 
     KDesktopFile config(path);
     KConfigGroup dg = config.desktopGroup();
     dg.writeEntry("Type", QStringLiteral("Link"));
     dg.writePathEntry("URL", d->URLEdit->url().toString());
     // Users can't create a Link .desktop file with a Name field,
     // but distributions can. Update the Name field in that case,
     // if the file name could have been changed.
     if (!d->fileNameReadOnly && dg.hasKey("Name")) {
         const QString nameStr = nameFromFileName(properties->url().fileName());
         dg.writeEntry("Name", nameStr);
         dg.writeEntry("Name", nameStr, KConfigBase::Persistent | KConfigBase::Localized);
 
     }
 }
 
 /* ----------------------------------------------------
  *
  * KDevicePropsPlugin
  *
  * -------------------------------------------------- */
 
 class KDevicePropsPlugin::KDevicePropsPluginPrivate
 {
 public:
     KDevicePropsPluginPrivate()
     {
     }
     ~KDevicePropsPluginPrivate()
     {
     }
 
     bool isMounted() const
     {
         const QString dev = device->currentText();
         return !dev.isEmpty() && KMountPoint::currentMountPoints().findByDevice(dev);
     }
 
     QFrame *m_frame;
     QStringList mountpointlist;
     QLabel *m_freeSpaceText;
     QLabel *m_freeSpaceLabel;
     QProgressBar *m_freeSpaceBar;
 
     KComboBox *device;
     QLabel *mountpoint;
     QCheckBox *readonly;
 
     QStringList m_devicelist;
 };
 
 KDevicePropsPlugin::KDevicePropsPlugin(KPropertiesDialog *_props) : KPropertiesDialogPlugin(_props), d(new KDevicePropsPluginPrivate)
 {
     d->m_frame = new QFrame();
     properties->addPage(d->m_frame, i18n("De&vice"));
 
     QStringList devices;
     const KMountPoint::List mountPoints = KMountPoint::possibleMountPoints();
 
     for (KMountPoint::List::ConstIterator it = mountPoints.begin();
             it != mountPoints.end(); ++it) {
         const KMountPoint::Ptr mp = (*it);
         QString mountPoint = mp->mountPoint();
         QString device = mp->mountedFrom();
         // qDebug()<<"mountPoint :"<<mountPoint<<" device :"<<device<<" mp->mountType() :"<<mp->mountType();
 
         if ((mountPoint != QLatin1String("-")) && (mountPoint != QLatin1String("none")) && !mountPoint.isEmpty()
                 && device != QLatin1String("none")) {
             devices.append(device + QLatin1String(" (")
                            + mountPoint + QLatin1String(")"));
             d->m_devicelist.append(device);
             d->mountpointlist.append(mountPoint);
         }
     }
 
     QGridLayout *layout = new QGridLayout(d->m_frame);
 
     layout->setMargin(0);
     layout->setColumnStretch(1, 1);
 
     QLabel *label;
     label = new QLabel(d->m_frame);
     label->setText(devices.count() == 0 ?
                    i18n("Device (/dev/fd0):") : // old style
                    i18n("Device:"));  // new style (combobox)
     layout->addWidget(label, 0, 0, Qt::AlignRight);
 
     d->device = new KComboBox(d->m_frame);
     d->device->setObjectName(QStringLiteral("ComboBox_device"));
     d->device->setEditable(true);
     d->device->addItems(devices);
     layout->addWidget(d->device, 0, 1);
     connect(d->device, SIGNAL(activated(int)),
             this, SLOT(slotActivated(int)));
 
     d->readonly = new QCheckBox(d->m_frame);
     d->readonly->setObjectName(QStringLiteral("CheckBox_readonly"));
     d->readonly->setText(i18n("Read only"));
     layout->addWidget(d->readonly, 1, 1);
 
     label = new QLabel(d->m_frame);
     label->setText(i18n("File system:"));
     layout->addWidget(label, 2, 0, Qt::AlignRight);
 
     QLabel *fileSystem = new QLabel(d->m_frame);
     layout->addWidget(fileSystem, 2, 1);
 
     label = new QLabel(d->m_frame);
     label->setText(devices.count() == 0 ?
                    i18n("Mount point (/mnt/floppy):") : // old style
                    i18n("Mount point:")); // new style (combobox)
     layout->addWidget(label, 3, 0, Qt::AlignRight);
 
     d->mountpoint = new QLabel(d->m_frame);
     d->mountpoint->setObjectName(QStringLiteral("LineEdit_mountpoint"));
 
     layout->addWidget(d->mountpoint, 3, 1);
 
     // show disk free
     d->m_freeSpaceText = new QLabel(i18n("Device usage:"), d->m_frame);
     layout->addWidget(d->m_freeSpaceText, 4, 0, Qt::AlignRight);
 
     d->m_freeSpaceLabel = new QLabel(d->m_frame);
     layout->addWidget(d->m_freeSpaceLabel, 4, 1);
 
     d->m_freeSpaceBar = new QProgressBar(d->m_frame);
     d->m_freeSpaceBar->setObjectName(QStringLiteral("freeSpaceBar"));
     layout->addWidget(d->m_freeSpaceBar, 5, 0, 1, 2);
 
     // we show it in the slot when we know the values
     d->m_freeSpaceText->hide();
     d->m_freeSpaceLabel->hide();
     d->m_freeSpaceBar->hide();
 
     KSeparator *sep = new KSeparator(Qt::Horizontal, d->m_frame);
     layout->addWidget(sep, 6, 0, 1, 2);
 
     layout->setRowStretch(7, 1);
 
     KIO::StatJob *job = KIO::mostLocalUrl(_props->url());
     KJobWidgets::setWindow(job, _props);
     job->exec();
     QUrl url = job->mostLocalUrl();
 
     if (!url.isLocalFile()) {
         return;
     }
     QString path = url.toLocalFile();
 
     QFile f(path);
     if (!f.open(QIODevice::ReadOnly)) {
         return;
     }
     f.close();
 
     const KDesktopFile _config(path);
     const KConfigGroup config = _config.desktopGroup();
     QString deviceStr = config.readEntry("Dev");
     QString mountPointStr = config.readEntry("MountPoint");
     bool ro = config.readEntry("ReadOnly", false);
 
     fileSystem->setText(config.readEntry("FSType"));
 
     d->device->setEditText(deviceStr);
     if (!deviceStr.isEmpty()) {
         // Set default options for this device (first matching entry)
         int index = d->m_devicelist.indexOf(deviceStr);
         if (index != -1) {
             //qDebug() << "found it" << index;
             slotActivated(index);
         }
     }
 
     if (!mountPointStr.isEmpty()) {
         d->mountpoint->setText(mountPointStr);
         updateInfo();
     }
 
     d->readonly->setChecked(ro);
 
     connect(d->device, SIGNAL(activated(int)),
             this, SIGNAL(changed()));
     connect(d->device, SIGNAL(textChanged(QString)),
             this, SIGNAL(changed()));
     connect(d->readonly, SIGNAL(toggled(bool)),
             this, SIGNAL(changed()));
 
     connect(d->device, SIGNAL(textChanged(QString)),
             this, SLOT(slotDeviceChanged()));
 }
 
 KDevicePropsPlugin::~KDevicePropsPlugin()
 {
     delete d;
 }
 
 // QString KDevicePropsPlugin::tabName () const
 // {
 //   return i18n ("De&vice");
 // }
 
 void KDevicePropsPlugin::updateInfo()
 {
     // we show it in the slot when we know the values
     d->m_freeSpaceText->hide();
     d->m_freeSpaceLabel->hide();
     d->m_freeSpaceBar->hide();
 
     if (!d->mountpoint->text().isEmpty() && d->isMounted()) {
         KDiskFreeSpaceInfo info = KDiskFreeSpaceInfo::freeSpaceInfo(d->mountpoint->text());
         slotFoundMountPoint(info.mountPoint(), info.size() / 1024, info.used() / 1024, info.available() / 1024);
     }
 }
 
 void KDevicePropsPlugin::slotActivated(int index)
 {
     // index can be more than the number of known devices, when the user types
     // a "custom" device.
     if (index < d->m_devicelist.count()) {
         // Update mountpoint so that it matches the device that was selected in the combo
         d->device->setEditText(d->m_devicelist[index]);
         d->mountpoint->setText(d->mountpointlist[index]);
     }
 
     updateInfo();
 }
 
 void KDevicePropsPlugin::slotDeviceChanged()
 {
     // Update mountpoint so that it matches the typed device
     int index = d->m_devicelist.indexOf(d->device->currentText());
     if (index != -1) {
         d->mountpoint->setText(d->mountpointlist[index]);
     } else {
         d->mountpoint->setText(QString());
     }
 
     updateInfo();
 }
 
 void KDevicePropsPlugin::slotFoundMountPoint(const QString &,
         quint64 kibSize,
         quint64 /*kibUsed*/,
         quint64 kibAvail)
 {
     d->m_freeSpaceText->show();
     d->m_freeSpaceLabel->show();
 
     const int percUsed = kibSize != 0 ? (100 - (int)(100.0 * kibAvail / kibSize)) : 100;
 
     d->m_freeSpaceLabel->setText(
         i18nc("Available space out of total partition size (percent used)", "%1 free of %2 (%3% used)",
               KIO::convertSizeFromKiB(kibAvail),
               KIO::convertSizeFromKiB(kibSize),
               percUsed));
 
     d->m_freeSpaceBar->setRange(0, 100);
     d->m_freeSpaceBar->setValue(percUsed);
     d->m_freeSpaceBar->show();
 }
 
 bool KDevicePropsPlugin::supports(const KFileItemList &_items)
 {
     if (_items.count() != 1) {
         return false;
     }
     const KFileItem item = _items.first();
     // check if desktop file
     if (!item.isDesktopFile()) {
         return false;
     }
 
     // open file and check type
     bool isLocal;
     QUrl url = item.mostLocalUrl(isLocal);
     if (!isLocal) {
         return false;
     }
 
     KDesktopFile config(url.toLocalFile());
     return config.hasDeviceType();
 }
 
 void KDevicePropsPlugin::applyChanges()
 {
     KIO::StatJob *job = KIO::mostLocalUrl(properties->url());
     KJobWidgets::setWindow(job, properties);
     job->exec();
     const QUrl url = job->mostLocalUrl();
 
     if (!url.isLocalFile()) {
         return;
     }
     const QString path = url.toLocalFile();
     QFile f(path);
     if (!f.open(QIODevice::ReadWrite)) {
         KMessageBox::sorry(nullptr, i18n("<qt>Could not save properties. You do not have sufficient "
                                    "access to write to <b>%1</b>.</qt>", path));
         return;
     }
     f.close();
 
     KDesktopFile _config(path);
     KConfigGroup config = _config.desktopGroup();
     config.writeEntry("Type", QStringLiteral("FSDevice"));
 
     config.writeEntry("Dev", d->device->currentText());
     config.writeEntry("MountPoint", d->mountpoint->text());
 
     config.writeEntry("ReadOnly", d->readonly->isChecked());
 
     config.sync();
 }
 
 /* ----------------------------------------------------
  *
  * KDesktopPropsPlugin
  *
  * -------------------------------------------------- */
 
 class KDesktopPropsPlugin::KDesktopPropsPluginPrivate
 {
 public:
     KDesktopPropsPluginPrivate()
         : w(new Ui_KPropertiesDesktopBase)
         , m_frame(new QFrame())
     {
     }
     ~KDesktopPropsPluginPrivate()
     {
         delete w;
     }
     Ui_KPropertiesDesktopBase *w;
     QWidget *m_frame;
 
     QString m_origCommandStr;
     QString m_terminalOptionStr;
     QString m_suidUserStr;
     QString m_dbusStartupType;
     QString m_dbusServiceName;
     QString m_origDesktopFile;
     bool m_terminalBool;
     bool m_suidBool;
     bool m_hasDiscreteGpuBool;
     bool m_runOnDiscreteGpuBool;
     bool m_startupBool;
 };
 
 KDesktopPropsPlugin::KDesktopPropsPlugin(KPropertiesDialog *_props)
     : KPropertiesDialogPlugin(_props), d(new KDesktopPropsPluginPrivate)
 {
     QMimeDatabase db;
 
     d->w->setupUi(d->m_frame);
 
     properties->addPage(d->m_frame, i18n("&Application"));
 
     bool bKDesktopMode = properties->url().scheme() == QLatin1String("desktop") ||
                          properties->currentDir().scheme() == QLatin1String("desktop");
 
     if (bKDesktopMode) {
         // Hide Name entry
         d->w->nameEdit->hide();
         d->w->nameLabel->hide();
     }
 
     d->w->pathEdit->setMode(KFile::Directory | KFile::LocalOnly);
     d->w->pathEdit->lineEdit()->setAcceptDrops(false);
 
     connect(d->w->nameEdit, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
     connect(d->w->genNameEdit, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
     connect(d->w->commentEdit, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
     connect(d->w->commandEdit, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
     connect(d->w->pathEdit, SIGNAL(textChanged(QString)), this, SIGNAL(changed()));
 
     connect(d->w->browseButton, SIGNAL(clicked()), this, SLOT(slotBrowseExec()));
     connect(d->w->addFiletypeButton, SIGNAL(clicked()), this, SLOT(slotAddFiletype()));
     connect(d->w->delFiletypeButton, SIGNAL(clicked()), this, SLOT(slotDelFiletype()));
     connect(d->w->advancedButton, SIGNAL(clicked()), this, SLOT(slotAdvanced()));
 
     enum DiscreteGpuCheck { NotChecked, Present, Absent };
     static DiscreteGpuCheck s_gpuCheck = NotChecked;
 
     if (s_gpuCheck == NotChecked) {
         // Check whether we have a discrete gpu
         bool hasDiscreteGpu = false;
         QDBusInterface iface(QStringLiteral("org.kde.Solid.PowerManagement"),
                              QStringLiteral("/org/kde/Solid/PowerManagement"),
                              QStringLiteral("org.kde.Solid.PowerManagement"),
                              QDBusConnection::sessionBus());
         if (iface.isValid()) {
             QDBusReply<bool> reply = iface.call(QStringLiteral("hasDualGpu"));
             if (reply.isValid()) {
                 hasDiscreteGpu = reply.value();
             }
         }
 
         s_gpuCheck = hasDiscreteGpu ? Present : Absent;
     }
 
     d->m_hasDiscreteGpuBool = s_gpuCheck == Present;
 
     // now populate the page
 
     KIO::StatJob *job = KIO::mostLocalUrl(_props->url());
     KJobWidgets::setWindow(job, _props);
     job->exec();
     QUrl url = job->mostLocalUrl();
 
     if (!url.isLocalFile()) {
         return;
     }
 
     d->m_origDesktopFile = url.toLocalFile();
 
     QFile f(d->m_origDesktopFile);
     if (!f.open(QIODevice::ReadOnly)) {
         return;
     }
     f.close();
 
     KDesktopFile  _config(d->m_origDesktopFile);
     KConfigGroup config = _config.desktopGroup();
     QString nameStr = _config.readName();
     QString genNameStr = _config.readGenericName();
     QString commentStr = _config.readComment();
     QString commandStr = config.readEntry("Exec", QString());
 
     d->m_origCommandStr = commandStr;
     QString pathStr = config.readEntry("Path", QString());   // not readPathEntry, see kservice.cpp
     d->m_terminalBool = config.readEntry("Terminal", false);
     d->m_terminalOptionStr = config.readEntry("TerminalOptions");
     d->m_suidBool = config.readEntry("X-KDE-SubstituteUID", false);
     d->m_suidUserStr = config.readEntry("X-KDE-Username");
     if (d->m_hasDiscreteGpuBool) {
         d->m_runOnDiscreteGpuBool = config.readEntry("X-KDE-RunOnDiscreteGpu", false);
     }
     if (config.hasKey("StartupNotify")) {
         d->m_startupBool = config.readEntry("StartupNotify", true);
     } else {
         d->m_startupBool = config.readEntry("X-KDE-StartupNotify", true);
     }
     d->m_dbusStartupType = config.readEntry("X-DBUS-StartupType").toLower();
     // ### should there be a GUI for this setting?
     // At least we're copying it over to the local file, to avoid side effects (#157853)
     d->m_dbusServiceName = config.readEntry("X-DBUS-ServiceName");
 
     const QStringList mimeTypes = config.readXdgListEntry("MimeType");
 
     if (nameStr.isEmpty() || bKDesktopMode) {
         // We'll use the file name if no name is specified
         // because we _need_ a Name for a valid file.
         // But let's do it in apply, not here, so that we pick up the right name.
         setDirty();
     }
     if (!bKDesktopMode) {
         d->w->nameEdit->setText(nameStr);
     }
 
     d->w->genNameEdit->setText(genNameStr);
     d->w->commentEdit->setText(commentStr);
     d->w->commandEdit->setText(commandStr);
     d->w->pathEdit->lineEdit()->setText(pathStr);
 
     // was: d->w->filetypeList->setFullWidth(true);
     //  d->w->filetypeList->header()->setStretchEnabled(true, d->w->filetypeList->columns()-1);
 
     for (QStringList::ConstIterator it = mimeTypes.begin();
             it != mimeTypes.end();) {
         QMimeType p = db.mimeTypeForName(*it);
         ++it;
         QString preference;
         if (it != mimeTypes.end()) {
             bool numeric;
             (*it).toInt(&numeric);
             if (numeric) {
                 preference = *it;
                 ++it;
             }
         }
         if (p.isValid()) {
             QTreeWidgetItem *item = new QTreeWidgetItem();
             item->setText(0, p.name());
             item->setText(1, p.comment());
             item->setText(2, preference);
             d->w->filetypeList->addTopLevelItem(item);
         }
     }
     d->w->filetypeList->resizeColumnToContents(0);
 
 }
 
 KDesktopPropsPlugin::~KDesktopPropsPlugin()
 {
     delete d;
 }
 
 void KDesktopPropsPlugin::slotAddFiletype()
 {
     QMimeDatabase db;
     KMimeTypeChooserDialog dlg(i18n("Add File Type for %1", properties->url().fileName()),
                                i18n("Select one or more file types to add:"),
                                QStringList(), // no preselected mimetypes
                                QString(),
                                QStringList(),
                                KMimeTypeChooser::Comments | KMimeTypeChooser::Patterns,
                                d->m_frame);
 
     if (dlg.exec() == QDialog::Accepted) {
         foreach (const QString &mimetype, dlg.chooser()->mimeTypes()) {
             QMimeType p = db.mimeTypeForName(mimetype);
             if (!p.isValid()) {
                 continue;
             }
 
             bool found = false;
             int count = d->w->filetypeList->topLevelItemCount();
             for (int i = 0; !found && i < count; ++i) {
                 if (d->w->filetypeList->topLevelItem(i)->text(0) == mimetype) {
                     found = true;
                 }
             }
             if (!found) {
                 QTreeWidgetItem *item = new QTreeWidgetItem();
                 item->setText(0, p.name());
                 item->setText(1, p.comment());
                 d->w->filetypeList->addTopLevelItem(item);
             }
             d->w->filetypeList->resizeColumnToContents(0);
         }
     }
     emit changed();
 }
 
 void KDesktopPropsPlugin::slotDelFiletype()
 {
     QTreeWidgetItem *cur = d->w->filetypeList->currentItem();
     if (cur) {
         delete cur;
         emit changed();
     }
 }
 
 void KDesktopPropsPlugin::checkCommandChanged()
 {
     if (KIO::DesktopExecParser::executableName(d->w->commandEdit->text()) !=
             KIO::DesktopExecParser::executableName(d->m_origCommandStr)) {
         d->m_origCommandStr = d->w->commandEdit->text();
         d->m_dbusStartupType.clear(); // Reset
         d->m_dbusServiceName.clear();
     }
 }
 
 void KDesktopPropsPlugin::applyChanges()
 {
     // qDebug();
     KIO::StatJob *job = KIO::mostLocalUrl(properties->url());
     KJobWidgets::setWindow(job, properties);
     job->exec();
     const QUrl url = job->mostLocalUrl();
 
     if (!url.isLocalFile()) {
         KMessageBox::sorry(nullptr, i18n("Could not save properties. Only entries on local file systems are supported."));
         return;
     }
 
     const QString path(url.toLocalFile());
 
     // make sure the directory exists
     QDir().mkpath(QFileInfo(path).absolutePath());
     QFile f(path);
     if (!f.open(QIODevice::ReadWrite)) {
         KMessageBox::sorry(nullptr, i18n("<qt>Could not save properties. You do not have "
                                    "sufficient access to write to <b>%1</b>.</qt>", path));
         return;
     }
     f.close();
 
     // If the command is changed we reset certain settings that are strongly
     // coupled to the command.
     checkCommandChanged();
 
     KDesktopFile origConfig(d->m_origDesktopFile);
     QScopedPointer<KDesktopFile> _config(origConfig.copyTo(path));
     KConfigGroup config = _config->desktopGroup();
     config.writeEntry("Type", QStringLiteral("Application"));
     config.writeEntry("Comment", d->w->commentEdit->text());
     config.writeEntry("Comment", d->w->commentEdit->text(), KConfigGroup::Persistent | KConfigGroup::Localized); // for compat
     config.writeEntry("GenericName", d->w->genNameEdit->text());
     config.writeEntry("GenericName", d->w->genNameEdit->text(), KConfigGroup::Persistent | KConfigGroup::Localized); // for compat
     config.writeEntry("Exec", d->w->commandEdit->text());
     config.writeEntry("Path", d->w->pathEdit->lineEdit()->text());   // not writePathEntry, see kservice.cpp
 
     // Write mimeTypes
     QStringList mimeTypes;
     int count = d->w->filetypeList->topLevelItemCount();
     for (int i = 0; i < count; ++i) {
         QTreeWidgetItem *item = d->w->filetypeList->topLevelItem(i);
         QString preference = item->text(2);
         mimeTypes.append(item->text(0));
         if (!preference.isEmpty()) {
             mimeTypes.append(preference);
         }
     }
 
     // qDebug() << mimeTypes;
     config.writeXdgListEntry("MimeType", mimeTypes);
 
     if (!d->w->nameEdit->isHidden()) {
         QString nameStr = d->w->nameEdit->text();
         config.writeEntry("Name", nameStr);
         config.writeEntry("Name", nameStr, KConfigGroup::Persistent | KConfigGroup::Localized);
     }
 
     config.writeEntry("Terminal", d->m_terminalBool);
     config.writeEntry("TerminalOptions", d->m_terminalOptionStr);
     config.writeEntry("X-KDE-SubstituteUID", d->m_suidBool);
     config.writeEntry("X-KDE-Username", d->m_suidUserStr);
     if (d->m_hasDiscreteGpuBool) {
         config.writeEntry("X-KDE-RunOnDiscreteGpu", d->m_runOnDiscreteGpuBool);
     }
     config.writeEntry("StartupNotify", d->m_startupBool);
     config.writeEntry("X-DBUS-StartupType", d->m_dbusStartupType);
     config.writeEntry("X-DBUS-ServiceName", d->m_dbusServiceName);
     config.sync();
 
     // KSycoca update needed?
     bool updateNeeded = !relativeAppsLocation(path).isEmpty();
     if (updateNeeded) {
         KBuildSycocaProgressDialog::rebuildKSycoca(d->m_frame);
     }
 }
 
 void KDesktopPropsPlugin::slotBrowseExec()
 {
     QUrl f = QFileDialog::getOpenFileUrl(d->m_frame);
     if (f.isEmpty()) {
         return;
     }
 
     if (!f.isLocalFile()) {
         KMessageBox::sorry(d->m_frame, i18n("Only executables on local file systems are supported."));
         return;
     }
 
     QString path = f.toLocalFile();
     path = KShell::quoteArg(path);
     d->w->commandEdit->setText(path);
 }
 
 void KDesktopPropsPlugin::slotAdvanced()
 {
     QDialog dlg(d->m_frame);
     dlg.setObjectName(QStringLiteral("KPropertiesDesktopAdv"));
     dlg.setModal(true);
     dlg.setWindowTitle(i18n("Advanced Options for %1", properties->url().fileName()));
 
     Ui_KPropertiesDesktopAdvBase w;
     QWidget *mainWidget = new QWidget(&dlg);
     w.setupUi(mainWidget);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(&dlg);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     connect(buttonBox, SIGNAL(accepted()), &dlg, SLOT(accept()));
     connect(buttonBox, SIGNAL(rejected()), &dlg, SLOT(reject()));
 
     QVBoxLayout *layout = new QVBoxLayout;
     layout->addWidget(mainWidget);
     layout->addWidget(buttonBox);
     dlg.setLayout(layout);
 
     // If the command is changed we reset certain settings that are strongly
     // coupled to the command.
     checkCommandChanged();
 
     // check to see if we use konsole if not do not add the nocloseonexit
     // because we don't know how to do this on other terminal applications
     KConfigGroup confGroup(KSharedConfig::openConfig(), QStringLiteral("General"));
     QString preferredTerminal = confGroup.readPathEntry("TerminalApplication",
                                 QStringLiteral("konsole"));
 
     bool terminalCloseBool = false;
 
     if (preferredTerminal == QLatin1String("konsole")) {
         terminalCloseBool = d->m_terminalOptionStr.contains(QStringLiteral("--noclose"));
         w.terminalCloseCheck->setChecked(terminalCloseBool);
         d->m_terminalOptionStr.remove(QStringLiteral("--noclose"));
     } else {
         w.terminalCloseCheck->hide();
     }
 
     w.terminalCheck->setChecked(d->m_terminalBool);
     w.terminalEdit->setText(d->m_terminalOptionStr);
     w.terminalCloseCheck->setEnabled(d->m_terminalBool);
     w.terminalEdit->setEnabled(d->m_terminalBool);
     w.terminalEditLabel->setEnabled(d->m_terminalBool);
 
     w.suidCheck->setChecked(d->m_suidBool);
     w.suidEdit->setText(d->m_suidUserStr);
     w.suidEdit->setEnabled(d->m_suidBool);
     w.suidEditLabel->setEnabled(d->m_suidBool);
 
     if (d->m_hasDiscreteGpuBool) {
         w.discreteGpuCheck->setChecked(d->m_runOnDiscreteGpuBool);
     } else {
         w.discreteGpuGroupBox->hide();
     }
 
     w.startupInfoCheck->setChecked(d->m_startupBool);
 
     if (d->m_dbusStartupType == QLatin1String("unique")) {
         w.dbusCombo->setCurrentIndex(2);
     } else if (d->m_dbusStartupType == QLatin1String("multi")) {
         w.dbusCombo->setCurrentIndex(1);
     } else if (d->m_dbusStartupType == QLatin1String("wait")) {
         w.dbusCombo->setCurrentIndex(3);
     } else {
         w.dbusCombo->setCurrentIndex(0);
     }
 
     // Provide username completion up to 1000 users.
     const int maxEntries = 1000;
     QStringList userNames = KUser::allUserNames(maxEntries);
     if (userNames.size() < maxEntries) {
         KCompletion *kcom = new KCompletion;
         kcom->setOrder(KCompletion::Sorted);
         w.suidEdit->setCompletionObject(kcom, true);
         w.suidEdit->setAutoDeleteCompletionObject(true);
         w.suidEdit->setCompletionMode(KCompletion::CompletionAuto);
         kcom->setItems(userNames);
     }
 
     connect(w.terminalEdit, SIGNAL(textChanged(QString)),
             this, SIGNAL(changed()));
     connect(w.terminalCloseCheck, SIGNAL(toggled(bool)),
             this, SIGNAL(changed()));
     connect(w.terminalCheck, SIGNAL(toggled(bool)),
             this, SIGNAL(changed()));
     connect(w.suidCheck, SIGNAL(toggled(bool)),
             this, SIGNAL(changed()));
     connect(w.suidEdit, SIGNAL(textChanged(QString)),
             this, SIGNAL(changed()));
     connect(w.discreteGpuCheck, SIGNAL(toggled(bool)),
             this, SIGNAL(changed()));
     connect(w.startupInfoCheck, SIGNAL(toggled(bool)),
             this, SIGNAL(changed()));
     connect(w.dbusCombo, SIGNAL(activated(int)),
             this, SIGNAL(changed()));
 
     if (dlg.exec() == QDialog::Accepted) {
         d->m_terminalOptionStr = w.terminalEdit->text().trimmed();
         d->m_terminalBool = w.terminalCheck->isChecked();
         d->m_suidBool = w.suidCheck->isChecked();
         d->m_suidUserStr = w.suidEdit->text().trimmed();
         if (d->m_hasDiscreteGpuBool) {
             d->m_runOnDiscreteGpuBool = w.discreteGpuCheck->isChecked();
         }
         d->m_startupBool = w.startupInfoCheck->isChecked();
 
         if (w.terminalCloseCheck->isChecked()) {
             d->m_terminalOptionStr.append(QLatin1String(" --noclose"));
         }
 
         switch (w.dbusCombo->currentIndex()) {
         case 1:  d->m_dbusStartupType = QStringLiteral("multi"); break;
         case 2:  d->m_dbusStartupType = QStringLiteral("unique"); break;
         case 3:  d->m_dbusStartupType = QStringLiteral("wait"); break;
         default: d->m_dbusStartupType = QStringLiteral("none"); break;
         }
     }
 }
 
 bool KDesktopPropsPlugin::supports(const KFileItemList &_items)
 {
     if (_items.count() != 1) {
         return false;
     }
 
     const KFileItem item = _items.first();
 
     // check if desktop file
     if (!item.isDesktopFile()) {
         return false;
     }
 
     // open file and check type
     bool isLocal;
     QUrl url = item.mostLocalUrl(isLocal);
     if (!isLocal) {
         return false;
     }
 
     KDesktopFile config(url.toLocalFile());
     return config.hasApplicationType() &&
            KAuthorized::authorize(QStringLiteral("run_desktop_files")) &&
            KAuthorized::authorize(QStringLiteral("shell_access"));
 }
 
 #include "moc_kpropertiesdialog.cpp"
 #include "moc_kpropertiesdialog_p.cpp"
diff --git a/src/widgets/kurlrequester.cpp b/src/widgets/kurlrequester.cpp
index cbf4a93f..dc1dccba 100644
--- a/src/widgets/kurlrequester.cpp
+++ b/src/widgets/kurlrequester.cpp
@@ -1,673 +1,673 @@
 /* This file is part of the KDE libraries
     Copyright (C) 1999,2000,2001 Carsten Pfeiffer <pfeiffer@kde.org>
     Copyright (C) 2013           Teo Mrnjavac <teo@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License version 2, as published by the Free Software Foundation.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "kurlrequester.h"
 #include "kio_widgets_debug.h"
 #include "../pathhelpers_p.h"
 
 #include <kcombobox.h>
 #include <kdragwidgetdecorator.h>
 #include <klineedit.h>
 #include <klocalizedstring.h>
 #include <kprotocolmanager.h>
 #include <kurlcompletion.h>
 
 #include <QAction>
 #include <QApplication>
 #include <QDebug>
 #include <QDrag>
 #include <QEvent>
 #include <QKeySequence>
 #include <QHBoxLayout>
 #include <QMimeData>
 #include <QtGlobal>
 
 class KUrlDragPushButton : public QPushButton
 {
     Q_OBJECT
 public:
     explicit KUrlDragPushButton(QWidget *parent)
         : QPushButton(parent)
     {
         new DragDecorator(this);
     }
     ~KUrlDragPushButton() {}
 
     void setURL(const QUrl &url)
     {
         m_urls.clear();
         m_urls.append(url);
     }
 
 private:
     class DragDecorator : public KDragWidgetDecoratorBase
     {
     public:
         explicit DragDecorator(KUrlDragPushButton *button)
             : KDragWidgetDecoratorBase(button), m_button(button) {}
 
     protected:
         QDrag *dragObject() override
         {
             if (m_button->m_urls.isEmpty()) {
                 return nullptr;
             }
 
             QDrag *drag = new QDrag(m_button);
             QMimeData *mimeData = new QMimeData;
             mimeData->setUrls(m_button->m_urls);
             drag->setMimeData(mimeData);
             return drag;
         }
 
     private:
         KUrlDragPushButton *m_button;
     };
 
     QList<QUrl> m_urls;
 };
 
 class Q_DECL_HIDDEN KUrlRequester::KUrlRequesterPrivate
 {
 public:
     explicit KUrlRequesterPrivate(KUrlRequester *parent)
         : m_parent(parent),
           edit(nullptr),
           combo(nullptr),
           fileDialogMode(KFile::File | KFile::ExistingOnly | KFile::LocalOnly),
           fileDialogAcceptMode(QFileDialog::AcceptOpen)
     {
     }
 
     ~KUrlRequesterPrivate()
     {
         delete myCompletion;
         delete myFileDialog;
     }
 
     void init();
 
     void setText(const QString &text)
     {
         if (combo) {
             if (combo->isEditable()) {
                 combo->setEditText(text);
             } else {
                 int i = combo->findText(text);
                 if (i == -1) {
                     combo->addItem(text);
                     combo->setCurrentIndex(combo->count() - 1);
                 } else {
                     combo->setCurrentIndex(i);
                 }
             }
         } else {
             edit->setText(text);
         }
     }
 
     void connectSignals(KUrlRequester *receiver)
     {
         if (combo) {
             connect(combo, &QComboBox::currentTextChanged,
                     receiver, &KUrlRequester::textChanged);
             connect(combo, &QComboBox::editTextChanged,
                     receiver, &KUrlRequester::textEdited);
 
             connect(combo, QOverload<>::of(&KComboBox::returnPressed),
                     receiver, QOverload<>::of(&KUrlRequester::returnPressed));
             connect(combo, QOverload<const QString&>::of(&KComboBox::returnPressed),
                     receiver, QOverload<const QString&>::of(&KUrlRequester::returnPressed));
         } else if (edit) {
             connect(edit, &QLineEdit::textChanged,
                     receiver, &KUrlRequester::textChanged);
             connect(edit, &QLineEdit::textEdited,
                     receiver, &KUrlRequester::textEdited);
 
             connect(edit, QOverload<>::of(&QLineEdit::returnPressed),
                     receiver, QOverload<>::of(&KUrlRequester::returnPressed));
 
             if (auto kline = qobject_cast<KLineEdit*>(edit)) {
                 connect(kline, QOverload<const QString&>::of(&KLineEdit::returnPressed),
                         receiver, QOverload<const QString&>::of(&KUrlRequester::returnPressed));
             }
         }
     }
 
     void setCompletionObject(KCompletion *comp)
     {
         if (combo) {
             combo->setCompletionObject(comp);
         } else {
             edit->setCompletionObject(comp);
         }
     }
 
     void updateCompletionStartDir(const QUrl &newStartDir)
     {
         myCompletion->setDir(newStartDir);
     }
 
 
     QString text() const
     {
         return combo ? combo->currentText() : edit->text();
     }
 
     /**
      * replaces ~user or $FOO, if necessary
      * if text() is a relative path, make it absolute using startDir()
      */
     QUrl url() const
     {
         const QString txt = text();
         KUrlCompletion *comp;
         if (combo) {
             comp = qobject_cast<KUrlCompletion *>(combo->completionObject());
         } else {
             comp = qobject_cast<KUrlCompletion *>(edit->completionObject());
         }
 
         QString enteredPath;
         if (comp)
             enteredPath = comp->replacedPath(txt);
         else
             enteredPath = txt;
 
         if (QDir::isAbsolutePath(enteredPath)) {
             return QUrl::fromLocalFile(enteredPath);
         }
 
         const QUrl enteredUrl = QUrl(enteredPath); // absolute or relative
         if (enteredUrl.isRelative() && !txt.isEmpty()) {
             QUrl finalUrl(m_startDir);
             finalUrl.setPath(concatPaths(finalUrl.path(), enteredPath));
             return finalUrl;
         } else {
             return enteredUrl;
         }
     }
 
     static void applyFileMode(QFileDialog *dlg, KFile::Modes m, QFileDialog::AcceptMode acceptMode)
     {
         QFileDialog::FileMode fileMode;
         if (m & KFile::Directory) {
             fileMode = QFileDialog::Directory;
             if ((m & KFile::File) == 0 &&
                     (m & KFile::Files) == 0) {
                 dlg->setOption(QFileDialog::ShowDirsOnly, true);
             }
         } else if (m & KFile::Files &&
                    m & KFile::ExistingOnly) {
             fileMode = QFileDialog::ExistingFiles;
         } else if (m & KFile::File &&
                    m & KFile::ExistingOnly) {
             fileMode = QFileDialog::ExistingFile;
         } else {
             fileMode = QFileDialog::AnyFile;
         }
 
         dlg->setFileMode(fileMode);
         dlg->setAcceptMode(acceptMode);
     }
 
     // Converts from "*.foo *.bar|Comment" to "Comment (*.foo *.bar)"
     QStringList kToQFilters(const QString &filters) const
     {
         QStringList qFilters = filters.split(QLatin1Char('\n'), QString::SkipEmptyParts);
 
         for (QStringList::iterator it = qFilters.begin(); it != qFilters.end(); ++it) {
             int sep = it->indexOf(QLatin1Char('|'));
             QString globs = it->left(sep);
             QString desc  = it->mid(sep + 1);
             *it = QStringLiteral("%1 (%2)").arg(desc, globs);
         }
 
         return qFilters;
     }
 
     QUrl getDirFromFileDialog(const QUrl &openUrl) const
     {
         return QFileDialog::getExistingDirectoryUrl(m_parent, QString(), openUrl, QFileDialog::ShowDirsOnly);
     }
 
     // slots
     void _k_slotUpdateUrl();
     void _k_slotOpenDialog();
     void _k_slotFileDialogAccepted();
 
     QUrl m_startDir;
     bool m_startDirCustomized;
     KUrlRequester * const m_parent; // TODO: rename to 'q'
     KLineEdit *edit;
     KComboBox *combo;
     KFile::Modes fileDialogMode;
     QFileDialog::AcceptMode fileDialogAcceptMode;
     QString fileDialogFilter;
     QStringList mimeTypeFilters;
     KEditListWidget::CustomEditor editor;
     KUrlDragPushButton *myButton;
     QFileDialog *myFileDialog;
     KUrlCompletion *myCompletion;
     Qt::WindowModality fileDialogModality;
 };
 
 KUrlRequester::KUrlRequester(QWidget *editWidget, QWidget *parent)
     : QWidget(parent), d(new KUrlRequesterPrivate(this))
 {
     // must have this as parent
     editWidget->setParent(this);
     d->combo = qobject_cast<KComboBox *>(editWidget);
     d->edit = qobject_cast<KLineEdit *>(editWidget);
     if (d->edit) {
         d->edit->setClearButtonEnabled(true);
     }
 
     d->init();
 }
 
 KUrlRequester::KUrlRequester(QWidget *parent)
     : QWidget(parent), d(new KUrlRequesterPrivate(this))
 {
     d->init();
 }
 
 KUrlRequester::KUrlRequester(const QUrl &url, QWidget *parent)
     : QWidget(parent), d(new KUrlRequesterPrivate(this))
 {
     d->init();
     setUrl(url);
 }
 
 KUrlRequester::~KUrlRequester()
 {
     delete d;
 }
 
 void KUrlRequester::KUrlRequesterPrivate::init()
 {
     myFileDialog = nullptr;
     fileDialogModality = Qt::ApplicationModal;
 
     if (!combo && !edit) {
         edit = new KLineEdit(m_parent);
         edit->setClearButtonEnabled(true);
     }
 
     QWidget *widget = combo ? static_cast<QWidget *>(combo) : static_cast<QWidget *>(edit);
 
     QHBoxLayout *topLayout = new QHBoxLayout(m_parent);
     topLayout->setMargin(0);
     topLayout->setSpacing(-1); // use default spacing
     topLayout->addWidget(widget);
 
     myButton = new KUrlDragPushButton(m_parent);
     myButton->setIcon(QIcon::fromTheme(QStringLiteral("document-open")));
     int buttonSize = myButton->sizeHint().expandedTo(widget->sizeHint()).height();
     myButton->setFixedSize(buttonSize, buttonSize);
     myButton->setToolTip(i18n("Open file dialog"));
 
     connect(myButton, SIGNAL(pressed()), m_parent, SLOT(_k_slotUpdateUrl()));
 
     widget->installEventFilter(m_parent);
     m_parent->setFocusProxy(widget);
     m_parent->setFocusPolicy(Qt::StrongFocus);
     topLayout->addWidget(myButton);
 
     connectSignals(m_parent);
     connect(myButton, SIGNAL(clicked()), m_parent, SLOT(_k_slotOpenDialog()));
 
     m_startDir = QUrl::fromLocalFile(QDir::currentPath());
     m_startDirCustomized = false;
 
     myCompletion = new KUrlCompletion();
     updateCompletionStartDir(m_startDir);
 
     setCompletionObject(myCompletion);
 
     QAction *openAction = new QAction(m_parent);
     openAction->setShortcut(QKeySequence::Open);
     m_parent->connect(openAction, SIGNAL(triggered(bool)), SLOT(_k_slotOpenDialog()));
 }
 
 void KUrlRequester::setUrl(const QUrl &url)
 {
     d->setText(url.toDisplayString(QUrl::PreferLocalFile));
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 void KUrlRequester::setPath(const QString &path)
 {
     d->setText(path);
 }
 #endif
 
 void KUrlRequester::setText(const QString &text)
 {
     d->setText(text);
 }
 
 void KUrlRequester::setStartDir(const QUrl &startDir)
 {
     d->m_startDir = startDir;
     d->m_startDirCustomized = true;
     d->updateCompletionStartDir(startDir);
 }
 
 void KUrlRequester::changeEvent(QEvent *e)
 {
     if (e->type() == QEvent::WindowTitleChange) {
         if (d->myFileDialog) {
             d->myFileDialog->setWindowTitle(windowTitle());
         }
     }
     QWidget::changeEvent(e);
 }
 
 QUrl KUrlRequester::url() const
 {
     return d->url();
 }
 
 QUrl KUrlRequester::startDir() const
 {
     return d->m_startDir;
 }
 
 QString KUrlRequester::text() const
 {
     return d->text();
 }
 
 void KUrlRequester::KUrlRequesterPrivate::_k_slotOpenDialog()
 {
     if (myFileDialog)
         if (myFileDialog->isVisible()) {
             //The file dialog is already being shown, raise it and exit
             myFileDialog->raise();
             myFileDialog->activateWindow();
             return;
         }
 
     if (((fileDialogMode & KFile::Directory) && !(fileDialogMode & KFile::File)) ||
             /* catch possible fileDialog()->setMode( KFile::Directory ) changes */
             (myFileDialog && (myFileDialog->fileMode() == QFileDialog::Directory &&
                               myFileDialog->testOption(QFileDialog::ShowDirsOnly)))) {
         const QUrl openUrl = (!m_parent->url().isEmpty() && !m_parent->url().isRelative())
                              ? m_parent->url() : m_startDir;
 
         /* FIXME We need a new abstract interface for using KDirSelectDialog in a non-modal way */
 
         QUrl newUrl;
         if (fileDialogMode & KFile::LocalOnly) {
             newUrl = QFileDialog::getExistingDirectoryUrl(m_parent, QString(), openUrl, QFileDialog::ShowDirsOnly, QStringList() << QStringLiteral("file"));
         } else {
             newUrl = getDirFromFileDialog(openUrl);
         }
 
         if (newUrl.isValid()) {
             m_parent->setUrl(newUrl);
             emit m_parent->urlSelected(url());
         }
     } else {
         emit m_parent->openFileDialog(m_parent);
 
         //Creates the fileDialog if it doesn't exist yet
         QFileDialog *dlg = m_parent->fileDialog();
 
         if (!url().isEmpty() && !url().isRelative()) {
             QUrl u(url());
             // If we won't be able to list it (e.g. http), then don't try :)
             if (KProtocolManager::supportsListing(u)) {
                 dlg->selectUrl(u);
             }
         } else {
             dlg->setDirectoryUrl(m_startDir);
         }
 
         dlg->setAcceptMode(fileDialogAcceptMode);
 
         //Update the file dialog window modality
         if (dlg->windowModality() != fileDialogModality) {
             dlg->setWindowModality(fileDialogModality);
         }
 
         if (fileDialogModality == Qt::NonModal) {
             dlg->show();
         } else {
             dlg->exec();
         }
     }
 }
 
 void KUrlRequester::KUrlRequesterPrivate::_k_slotFileDialogAccepted()
 {
     if (!myFileDialog) {
         return;
     }
 
-    QUrl newUrl = myFileDialog->selectedUrls().first();
+    const QUrl newUrl = myFileDialog->selectedUrls().constFirst();
     if (newUrl.isValid()) {
         m_parent->setUrl(newUrl);
         emit m_parent->urlSelected(url());
         // remember url as defaultStartDir and update startdir for autocompletion
         if (newUrl.isLocalFile() && !m_startDirCustomized) {
             m_startDir = newUrl.adjusted(QUrl::RemoveFilename);
             updateCompletionStartDir(m_startDir);
         }
     }
 }
 
 void KUrlRequester::setMode(KFile::Modes mode)
 {
     Q_ASSERT((mode & KFile::Files) == 0);
     d->fileDialogMode = mode;
     if ((mode & KFile::Directory) && !(mode & KFile::File)) {
         d->myCompletion->setMode(KUrlCompletion::DirCompletion);
     }
 
     if (d->myFileDialog) {
         d->applyFileMode(d->myFileDialog, mode, d->fileDialogAcceptMode);
     }
 }
 
 KFile::Modes KUrlRequester::mode() const
 {
     return d->fileDialogMode;
 }
 
 void KUrlRequester::setAcceptMode(QFileDialog::AcceptMode mode)
 {
     d->fileDialogAcceptMode = mode;
 
     if (d->myFileDialog) {
         d->applyFileMode(d->myFileDialog, d->fileDialogMode, mode);
     }
 }
 
 QFileDialog::AcceptMode KUrlRequester::acceptMode() const
 {
     return d->fileDialogAcceptMode;
 }
 
 void KUrlRequester::setFilter(const QString &filter)
 {
     d->fileDialogFilter = filter;
 
     if (d->myFileDialog) {
         d->myFileDialog->setNameFilters(d->kToQFilters(d->fileDialogFilter));
     }
 }
 
 QString KUrlRequester::filter() const
 {
     return d->fileDialogFilter;
 }
 
 void KUrlRequester::setMimeTypeFilters(const QStringList &mimeTypes)
 {
     d->mimeTypeFilters = mimeTypes;
 
     if (d->myFileDialog) {
         d->myFileDialog->setMimeTypeFilters(d->mimeTypeFilters);
     }
     d->myCompletion->setMimeTypeFilters(d->mimeTypeFilters);
 }
 
 QStringList KUrlRequester::mimeTypeFilters() const
 {
     return d->mimeTypeFilters;
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 QFileDialog *KUrlRequester::fileDialog() const
 {
     if (!d->myFileDialog) {
         d->myFileDialog = new QFileDialog(window(), windowTitle());
         if (!d->mimeTypeFilters.isEmpty()) {
             d->myFileDialog->setMimeTypeFilters(d->mimeTypeFilters);
         } else {
             d->myFileDialog->setNameFilters(d->kToQFilters(d->fileDialogFilter));
         }
 
         d->applyFileMode(d->myFileDialog, d->fileDialogMode, d->fileDialogAcceptMode);
 
         d->myFileDialog->setWindowModality(d->fileDialogModality);
         connect(d->myFileDialog, SIGNAL(accepted()), SLOT(_k_slotFileDialogAccepted()));
     }
 
     return d->myFileDialog;
 }
 #endif
 
 void KUrlRequester::clear()
 {
     d->setText(QString());
 }
 
 KLineEdit *KUrlRequester::lineEdit() const
 {
     return d->edit;
 }
 
 KComboBox *KUrlRequester::comboBox() const
 {
     return d->combo;
 }
 
 void KUrlRequester::KUrlRequesterPrivate::_k_slotUpdateUrl()
 {
     const QUrl visibleUrl = url();
     QUrl u = visibleUrl;
     if (visibleUrl.isRelative()) {
         u = QUrl::fromLocalFile(QDir::currentPath() + QLatin1Char('/')).resolved(visibleUrl);
     }
     myButton->setURL(u);
 }
 
 bool KUrlRequester::eventFilter(QObject *obj, QEvent *ev)
 {
     if ((d->edit == obj) || (d->combo == obj)) {
         if ((ev->type() == QEvent::FocusIn) || (ev->type() == QEvent::FocusOut))
             // Forward focusin/focusout events to the urlrequester; needed by file form element in khtml
         {
             QApplication::sendEvent(this, ev);
         }
     }
     return QWidget::eventFilter(obj, ev);
 }
 
 QPushButton *KUrlRequester::button() const
 {
     return d->myButton;
 }
 
 KUrlCompletion *KUrlRequester::completionObject() const
 {
     return d->myCompletion;
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 void KUrlRequester::setClickMessage(const QString &msg)
 {
     setPlaceholderText(msg);
 }
 #endif
 
 void KUrlRequester::setPlaceholderText(const QString &msg)
 {
     if (d->edit) {
         d->edit->setPlaceholderText(msg);
     }
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 QString KUrlRequester::clickMessage() const
 {
     return placeholderText();
 }
 #endif
 
 QString KUrlRequester::placeholderText() const
 {
     if (d->edit) {
         return d->edit->placeholderText();
     } else {
         return QString();
     }
 }
 
 Qt::WindowModality KUrlRequester::fileDialogModality() const
 {
     return d->fileDialogModality;
 }
 
 void KUrlRequester::setFileDialogModality(Qt::WindowModality modality)
 {
     d->fileDialogModality = modality;
 }
 
 const KEditListWidget::CustomEditor &KUrlRequester::customEditor()
 {
     setSizePolicy(QSizePolicy(QSizePolicy::Preferred,
                               QSizePolicy::Fixed));
 
     KLineEdit *edit = d->edit;
     if (!edit && d->combo) {
         edit = qobject_cast<KLineEdit *>(d->combo->lineEdit());
     }
 
 #ifndef NDEBUG
     if (!edit) {
         qCWarning(KIO_WIDGETS) << "KUrlRequester's lineedit is not a KLineEdit!??\n";
     }
 #endif
 
     d->editor.setRepresentationWidget(this);
     d->editor.setLineEdit(edit);
     return d->editor;
 }
 
 KUrlComboRequester::KUrlComboRequester(QWidget *parent)
     : KUrlRequester(new KComboBox(false), parent), d(nullptr)
 {
 }
 
 #include "moc_kurlrequester.cpp"
 #include "kurlrequester.moc"