diff --git a/src/filewidgets/kdiroperator.cpp b/src/filewidgets/kdiroperator.cpp
index 06f60bcf..fb22b495 100644
--- a/src/filewidgets/kdiroperator.cpp
+++ b/src/filewidgets/kdiroperator.cpp
@@ -1,2632 +1,2632 @@
 /* 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 <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 <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 Q_DECL_OVERRIDE;
     void dragEnterEvent(QDragEnterEvent *event) Q_DECL_OVERRIDE;
     void mousePressEvent(QMouseEvent *event) Q_DECL_OVERRIDE;
     void wheelEvent(QWheelEvent *event) Q_DECL_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 KDirOperator::Private
 {
 public:
     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);
 
     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();
     int iconSizeForViewType(QAbstractItemView *itemView) const;
 
     // private members
     KDirOperator *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;
     int iconsZoom;
 
     bool isSaving;
 
     KActionMenu *decorationMenu;
     KToggleAction *leftAction;
     QList<QUrl> itemsToBeSetAsCurrent;
     bool shouldFetchForItems;
     InlinePreviewState inlinePreviewState;
 };
 
 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),
     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(QChar('/'));
         d->currUrl = QUrl::fromLocalFile(strPath);
     } else {
         d->currUrl = _url;
         if (d->currUrl.scheme().isEmpty()) {
             d->currUrl.setScheme(QStringLiteral("file"));
         }
 
         d->currUrl.setPath(d->currUrl.path() + "/"); // make sure we have a trailing slash!
     }
 
     // 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 (!previewGenerator) {
         return;
     }
 
     previewGenerator->setPreviewShown(show);
 }
 
 void KDirOperator::Private::_k_slotOpenFileManager()
 {
     new KRun(currUrl, parent);
 }
 
 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('/', QString::SkipEmptyParts);
     QStringList::ConstIterator it = dirs.begin();
 
     for (; it != dirs.end(); ++it) {
         folderurl.setPath(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->ui()->setAutoErrorHandlingEnabled(true);
+        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->ui()->setAutoErrorHandlingEnabled(true);
+        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;
     }
 
     if (!newurl.path().isEmpty() && !newurl.path().endsWith(QLatin1Char('/'))) {
         newurl.setPath(newurl.path() + QLatin1Char('/'));
     }
 
     // already set
     if (newurl.matches(d->currUrl, QUrl::StripTrailingSlash)) {
         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::openUrl(const QUrl &url, KDirLister::OpenUrlFlags flags)
 {
     const bool result = KProtocolManager::supportsListing(url) && 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()
 {
     QUrl tmp(d->currUrl);
     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)
 {
     Q_UNUSED(item);
     updateSelectionDependentActions();
 
     d->newFileMenu->setPopupFiles(QList<QUrl>() << 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(' ', 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);
     connect(showHiddenAction, SIGNAL(toggled(bool)), SLOT(_k_slotToggleHidden(bool)));
 
     KToggleAction *previewAction = new KToggleAction(i18n("Show Aside Preview"), this);
     d->actionCollection->addAction(QStringLiteral("preview"), previewAction);
     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);
     connect(inlinePreview, SIGNAL(toggled(bool)), SLOT(_k_toggleInlinePreviews(bool)));
 
     QAction *fileManager = new QAction(i18n("Open File Manager"), 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->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("Previews"), false);
     }
     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("Previews"), d->showPreviews);
         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);
     }
 }
 
 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();
         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::updateListViewGrid()
 {
     if (!itemView) {
         return;
     }
 
     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());
         int size = itemView->iconSize().height() + metrics.height() * 2;
         // some heuristics for good looking. let's guess width = height * (3 / 2) is nice
         view->setGridSize(QSize(size * (3.0 / 2.0), size + metrics.height()));
         KFileItemDelegate *delegate = qobject_cast<KFileItemDelegate *>(view->itemDelegate());
         if (delegate) {
             delegate->setMaximumSize(QSize(size * (3.0 / 2.0), size + metrics.height()));
         }
     }
 }
 
 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);
 }
 
 #include "moc_kdiroperator.cpp"
 #include "kdiroperator.moc"
diff --git a/src/filewidgets/kfilecopytomenu.cpp b/src/filewidgets/kfilecopytomenu.cpp
index 549f3ce5..dc0c4dc7 100644
--- a/src/filewidgets/kfilecopytomenu.cpp
+++ b/src/filewidgets/kfilecopytomenu.cpp
@@ -1,268 +1,268 @@
 /* Copyright 2008, 2009, 2015 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 "kfilecopytomenu.h"
 #include "kfilecopytomenu_p.h"
 #include <QAction>
 #include <QDebug>
 #include <QDir>
 #include <QIcon>
 #include <QFileDialog>
 #include <QMimeDatabase>
 #include <QMimeType>
 
 #include <KIO/FileUndoManager>
 #include <KIO/CopyJob>
 #include <KIO/JobUiDelegate>
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KStringHandler>
 #include <KJobWidgets>
 
 #ifdef Q_OS_WIN
 #include "windows.h"
 #endif
 
 KFileCopyToMenuPrivate::KFileCopyToMenuPrivate(KFileCopyToMenu *qq, QWidget *parentWidget)
     : q(qq),
       m_urls(),
       m_parentWidget(parentWidget),
       m_readOnly(false),
       m_autoErrorHandling(false)
 {
 }
 
 ////
 
 KFileCopyToMenu::KFileCopyToMenu(QWidget *parentWidget)
     : QObject(parentWidget), d(new KFileCopyToMenuPrivate(this, parentWidget))
 {
 }
 
 KFileCopyToMenu::~KFileCopyToMenu()
 {
     delete d;
 }
 
 void KFileCopyToMenu::setUrls(const QList<QUrl> &urls)
 {
     d->m_urls = urls;
 }
 
 void KFileCopyToMenu::setReadOnly(bool ro)
 {
     d->m_readOnly = ro;
 }
 
 void KFileCopyToMenu::setAutoErrorHandlingEnabled(bool b)
 {
     d->m_autoErrorHandling = b;
 }
 
 void KFileCopyToMenu::addActionsTo(QMenu *menu) const
 {
     QMenu *mainCopyMenu = new KFileCopyToMainMenu(menu, d, Copy);
     mainCopyMenu->setTitle(i18nc("@title:menu", "Copy To"));
     mainCopyMenu->menuAction()->setObjectName(QStringLiteral("copyTo_submenu"));   // for the unittest
     menu->addMenu(mainCopyMenu);
 
     if (!d->m_readOnly) {
         QMenu *mainMoveMenu = new KFileCopyToMainMenu(menu, d, Move);
         mainMoveMenu->setTitle(i18nc("@title:menu", "Move To"));
         mainMoveMenu->menuAction()->setObjectName(QStringLiteral("moveTo_submenu"));   // for the unittest
         menu->addMenu(mainMoveMenu);
     }
 }
 
 ////
 
 KFileCopyToMainMenu::KFileCopyToMainMenu(QMenu *parent, KFileCopyToMenuPrivate *_d, MenuType menuType)
     : QMenu(parent), m_menuType(menuType),
       m_actionGroup(static_cast<QWidget *>(nullptr)),
       d(_d),
       m_recentDirsGroup(KSharedConfig::openConfig(), m_menuType == Copy ? "kuick-copy" : "kuick-move")
 {
     connect(this, &KFileCopyToMainMenu::aboutToShow, this, &KFileCopyToMainMenu::slotAboutToShow);
     connect(&m_actionGroup, &QActionGroup::triggered, this, &KFileCopyToMainMenu::slotTriggered);
 }
 
 void KFileCopyToMainMenu::slotAboutToShow()
 {
     clear();
     KFileCopyToDirectoryMenu *subMenu;
     // Home Folder
     subMenu = new KFileCopyToDirectoryMenu(this, this, QDir::homePath());
     subMenu->setTitle(i18nc("@title:menu", "Home Folder"));
     subMenu->setIcon(QIcon::fromTheme(QStringLiteral("go-home")));
     QAction *act = addMenu(subMenu);
     act->setObjectName(QStringLiteral("home"));
 
     // Root Folder
 #ifndef Q_OS_WIN
     subMenu = new KFileCopyToDirectoryMenu(this, this, QDir::rootPath());
     subMenu->setTitle(i18nc("@title:menu", "Root Folder"));
     subMenu->setIcon(QIcon::fromTheme(QStringLiteral("folder-red")));
     act = addMenu(subMenu);
     act->setObjectName(QStringLiteral("root"));
 #else
     foreach (const QFileInfo &info, QDir::drives()) {
         QString driveIcon = "drive-harddisk";
         const uint type = GetDriveTypeW((wchar_t *)info.absoluteFilePath().utf16());
         switch (type) {
         case DRIVE_REMOVABLE:
             driveIcon = "drive-removable-media";
             break;
         case DRIVE_FIXED:
             driveIcon = "drive-harddisk";
             break;
         case DRIVE_REMOTE:
             driveIcon = "network-server";
             break;
         case DRIVE_CDROM:
             driveIcon = "drive-optical";
             break;
         case DRIVE_RAMDISK:
         case DRIVE_UNKNOWN:
         case DRIVE_NO_ROOT_DIR:
         default:
             driveIcon = "drive-harddisk";
         }
         subMenu = new KFileCopyToDirectoryMenu(this, this, info.absoluteFilePath());
         subMenu->setTitle(info.absoluteFilePath());
         subMenu->setIcon(QIcon::fromTheme(driveIcon));
         addMenu(subMenu);
     }
 #endif
 
     // Browse... action, shows a file dialog
     QAction *browseAction = new QAction(i18nc("@title:menu in Copy To or Move To submenu", "Browse..."), this);
     browseAction->setObjectName(QStringLiteral("browse"));
     connect(browseAction, &QAction::triggered, this, &KFileCopyToMainMenu::slotBrowse);
     addAction(browseAction);
 
     addSeparator(); // Qt handles removing it automatically if it's last in the menu, nice.
 
     // Recent Destinations
     const QStringList recentDirs = m_recentDirsGroup.readPathEntry("Paths", QStringList());
     Q_FOREACH (const QString &recentDir, recentDirs) {
         const QUrl url = QUrl::fromLocalFile(recentDir);
         const QString text = KStringHandler::csqueeze(url.toDisplayString(QUrl::PreferLocalFile), 60); // shorten very long paths (#61386)
         QAction *act = new QAction(text, this);
         act->setObjectName(recentDir);
         act->setData(url);
         m_actionGroup.addAction(act);
         addAction(act);
     }
 }
 
 void KFileCopyToMainMenu::slotBrowse()
 {
     const QUrl dest = QFileDialog::getExistingDirectoryUrl(d->m_parentWidget ? d->m_parentWidget : this);
     if (!dest.isEmpty()) {
         copyOrMoveTo(dest);
     }
 }
 
 void KFileCopyToMainMenu::slotTriggered(QAction *action)
 {
     const QUrl url = action->data().toUrl();
     Q_ASSERT(!url.isEmpty());
     copyOrMoveTo(url);
 }
 
 void KFileCopyToMainMenu::copyOrMoveTo(const QUrl &dest)
 {
     // Insert into the recent destinations list
     QStringList recentDirs = m_recentDirsGroup.readPathEntry("Paths", QStringList());
     const QString niceDest = dest.toDisplayString(QUrl::PreferLocalFile);
     if (!recentDirs.contains(niceDest)) { // don't change position if already there, moving stuff is bad usability
         recentDirs.prepend(niceDest);
         while (recentDirs.size() > 10) { // hardcoded max size
             recentDirs.removeLast();
         }
         m_recentDirsGroup.writePathEntry("Paths", recentDirs);
     }
 
     // #199549: add a trailing slash to avoid unexpected results when the
     // dest doesn't exist anymore: it was creating a file with the name of
     // the now non-existing dest.
     QUrl dirDest = dest;
     if (!dirDest.path().endsWith('/')) {
         dirDest.setPath(dirDest.path() + '/');
     }
 
     // And now let's do the copy or move -- with undo/redo support.
     KIO::CopyJob *job = m_menuType == Copy ? KIO::copy(d->m_urls, dirDest) : KIO::move(d->m_urls, dirDest);
     KIO::FileUndoManager::self()->recordCopyJob(job);
     KJobWidgets::setWindow(job, d->m_parentWidget ? d->m_parentWidget : this);
-    job->ui()->setAutoErrorHandlingEnabled(d->m_autoErrorHandling);
+    job->uiDelegate()->setAutoErrorHandlingEnabled(d->m_autoErrorHandling);
     connect(job, &KIO::CopyJob::result, this, [this](KJob * job) {
         emit d->q->error(job->error(), job->errorString());
     });
 }
 
 ////
 
 KFileCopyToDirectoryMenu::KFileCopyToDirectoryMenu(QMenu *parent, KFileCopyToMainMenu *mainMenu, const QString &path)
     : QMenu(parent), m_mainMenu(mainMenu), m_path(path)
 {
     if (!m_path.endsWith('/')) {
         m_path.append('/');
     }
     connect(this, &KFileCopyToDirectoryMenu::aboutToShow, this, &KFileCopyToDirectoryMenu::slotAboutToShow);
 }
 
 void KFileCopyToDirectoryMenu::slotAboutToShow()
 {
     clear();
     QAction *act = new QAction(m_mainMenu->menuType() == Copy
                                ? i18nc("@title:menu", "Copy Here")
                                : i18nc("@title:menu", "Move Here"), this);
     act->setData(QUrl::fromLocalFile(m_path));
     act->setEnabled(QFileInfo(m_path).isWritable());
     m_mainMenu->actionGroup().addAction(act);
     addAction(act);
 
     addSeparator(); // Qt handles removing it automatically if it's last in the menu, nice.
 
     // List directory
     // All we need is sub folder names, their permissions, their icon.
     // KDirLister or KIO::listDir would fetch much more info, and would be async,
     // and we only care about local directories so we use QDir directly.
     QDir dir(m_path);
     const QStringList entries = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::LocaleAware);
     const QMimeDatabase db;
     const QMimeType dirMime = db.mimeTypeForName(QStringLiteral("inode/directory"));
     Q_FOREACH (const QString &subDir, entries) {
         QString subPath = m_path + subDir;
         KFileCopyToDirectoryMenu *subMenu = new KFileCopyToDirectoryMenu(this, m_mainMenu, subPath);
         QString menuTitle(subDir);
         // Replace '&' by "&&" to make sure that '&' inside the directory name is displayed
         // correctly and not misinterpreted as an indicator for a keyboard shortcut
         subMenu->setTitle(menuTitle.replace('&', QLatin1String("&&")));
         const QString iconName = dirMime.iconName();
         subMenu->setIcon(QIcon::fromTheme(iconName));
         if (QFileInfo(subPath).isSymLink()) {
             QFont font = subMenu->menuAction()->font();
             font.setItalic(true);
             subMenu->menuAction()->setFont(font);
         }
         addMenu(subMenu);
     }
 }
diff --git a/src/filewidgets/kfileplacesview.cpp b/src/filewidgets/kfileplacesview.cpp
index f1330b7f..9bd13ea1 100644
--- a/src/filewidgets/kfileplacesview.cpp
+++ b/src/filewidgets/kfileplacesview.cpp
@@ -1,1206 +1,1206 @@
 /*  This file is part of the KDE project
     Copyright (C) 2007 Kevin Ottens <ervin@kde.org>
     Copyright (C) 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 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 "kfileplacesview.h"
 #include "kfileplacesview_p.h"
 
 #include <QtCore/QTimeLine>
 #include <QtCore/QTimer>
 #include <QPainter>
 #include <QAbstractItemDelegate>
 #include <QKeyEvent>
 #include <QApplication>
 #include <QMenu>
 #include <QScrollBar>
 
 #include <QDebug>
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <kdirnotify.h>
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 #include <kio/emptytrashjob.h>
 #include <kio/jobuidelegate.h>
 #include <kjob.h>
 #include <kjobwidgets.h>
 #include <kcapacitybar.h>
 #include <kdiskfreespaceinfo.h>
 #include <solid/storageaccess.h>
 #include <solid/storagedrive.h>
 #include <solid/storagevolume.h>
 #include <solid/opticaldrive.h>
 #include <solid/opticaldisc.h>
 
 #include "kfileplaceeditdialog.h"
 #include "kfileplacesmodel.h"
 
 #define LATERAL_MARGIN 4
 #define CAPACITYBAR_HEIGHT 6
 
 class KFilePlacesViewDelegate : public QAbstractItemDelegate
 {
     Q_OBJECT
 public:
     KFilePlacesViewDelegate(KFilePlacesView *parent);
     virtual ~KFilePlacesViewDelegate();
     virtual QSize sizeHint(const QStyleOptionViewItem &option,
                            const QModelIndex &index) const Q_DECL_OVERRIDE;
     virtual void paint(QPainter *painter,
                        const QStyleOptionViewItem &option,
                        const QModelIndex &index) const Q_DECL_OVERRIDE;
 
     int iconSize() const;
     void setIconSize(int newSize);
 
     void addAppearingItem(const QModelIndex &index);
     void setAppearingItemProgress(qreal value);
     void addDisappearingItem(const QModelIndex &index);
     void setDisappearingItemProgress(qreal value);
 
     void setShowHoverIndication(bool show);
 
     void addFadeAnimation(const QModelIndex &index, QTimeLine *timeLine);
     void removeFadeAnimation(const QModelIndex &index);
     QModelIndex indexForFadeAnimation(QTimeLine *timeLine) const;
     QTimeLine *fadeAnimationForIndex(const QModelIndex &index) const;
 
     qreal contentsOpacity(const QModelIndex &index) const;
 
 private:
     KFilePlacesView *m_view;
     int m_iconSize;
 
     QList<QPersistentModelIndex> m_appearingItems;
     int m_appearingIconSize;
     qreal m_appearingOpacity;
 
     QList<QPersistentModelIndex> m_disappearingItems;
     int m_disappearingIconSize;
     qreal m_disappearingOpacity;
 
     bool m_showHoverIndication;
 
     QMap<QPersistentModelIndex, QTimeLine *> m_timeLineMap;
     QMap<QTimeLine *, QPersistentModelIndex> m_timeLineInverseMap;
 };
 
 KFilePlacesViewDelegate::KFilePlacesViewDelegate(KFilePlacesView *parent) :
     QAbstractItemDelegate(parent),
     m_view(parent),
     m_iconSize(48),
     m_appearingIconSize(0),
     m_appearingOpacity(0.0),
     m_disappearingIconSize(0),
     m_disappearingOpacity(0.0),
     m_showHoverIndication(true)
 {
 }
 
 KFilePlacesViewDelegate::~KFilePlacesViewDelegate()
 {
 }
 
 QSize KFilePlacesViewDelegate::sizeHint(const QStyleOptionViewItem &option,
                                         const QModelIndex &index) const
 {
     int iconSize = m_iconSize;
     if (m_appearingItems.contains(index)) {
         iconSize = m_appearingIconSize;
     } else if (m_disappearingItems.contains(index)) {
         iconSize = m_disappearingIconSize;
     }
 
     const KFilePlacesModel *filePlacesModel = static_cast<const KFilePlacesModel *>(index.model());
     Solid::Device device = filePlacesModel->deviceForIndex(index);
 
     return QSize(option.rect.width(), option.fontMetrics.height() / 2 + qMax(iconSize, option.fontMetrics.height()));
 }
 
 void KFilePlacesViewDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
     painter->save();
 
     if (m_appearingItems.contains(index)) {
         painter->setOpacity(m_appearingOpacity);
     } else if (m_disappearingItems.contains(index)) {
         painter->setOpacity(m_disappearingOpacity);
     }
 
     QStyleOptionViewItem opt = option;
     if (!m_showHoverIndication) {
         opt.state &= ~QStyle::State_MouseOver;
     }
     QApplication::style()->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, painter);
     const KFilePlacesModel *placesModel = static_cast<const KFilePlacesModel *>(index.model());
 
     bool isLTR = option.direction == Qt::LeftToRight;
 
     QIcon icon = index.model()->data(index, Qt::DecorationRole).value<QIcon>();
     QPixmap pm = icon.pixmap(m_iconSize, m_iconSize, (option.state & QStyle::State_Selected) && (option.state & QStyle::State_Active) ? QIcon::Selected : QIcon::Normal);
     QPoint point(isLTR ? option.rect.left() + LATERAL_MARGIN
                  : option.rect.right() - LATERAL_MARGIN - m_iconSize, option.rect.top() + (option.rect.height() - m_iconSize) / 2);
     painter->drawPixmap(point, pm);
 
     if (option.state & QStyle::State_Selected) {
         QPalette::ColorGroup cg = QPalette::Active;
         if (!(option.state & QStyle::State_Enabled)) {
             cg = QPalette::Disabled;
         } else if (!(option.state & QStyle::State_Active)) {
             cg = QPalette::Inactive;
         }
         painter->setPen(option.palette.color(cg, QPalette::HighlightedText));
     }
 
     QRect rectText;
 
     const QUrl url = placesModel->url(index);
     bool drawCapacityBar = false;
     if (url.isLocalFile()) {
         const QString mountPointPath = placesModel->url(index).toLocalFile();
         const KDiskFreeSpaceInfo info = KDiskFreeSpaceInfo::freeSpaceInfo(mountPointPath);
         drawCapacityBar = info.size() != 0 &&
                           placesModel->data(index, KFilePlacesModel::CapacityBarRecommendedRole).toBool();
 
         if (drawCapacityBar && contentsOpacity(index) > 0) {
             painter->save();
             painter->setOpacity(painter->opacity() * contentsOpacity(index));
 
             int height = option.fontMetrics.height() + CAPACITYBAR_HEIGHT;
             rectText = QRect(isLTR ? m_iconSize + LATERAL_MARGIN * 2 + option.rect.left()
                              : 0, option.rect.top() + (option.rect.height() / 2 - height / 2), option.rect.width() - m_iconSize - LATERAL_MARGIN * 2, option.fontMetrics.height());
             painter->drawText(rectText, Qt::AlignLeft | Qt::AlignTop, option.fontMetrics.elidedText(index.model()->data(index).toString(), Qt::ElideRight, rectText.width()));
             QRect capacityRect(isLTR ? rectText.x() : LATERAL_MARGIN, rectText.bottom() - 1, rectText.width() - LATERAL_MARGIN, CAPACITYBAR_HEIGHT);
             KCapacityBar capacityBar(KCapacityBar::DrawTextInline);
             capacityBar.setValue((info.used() * 100) / info.size());
             capacityBar.drawCapacityBar(painter, capacityRect);
 
             painter->restore();
 
             painter->save();
             painter->setOpacity(painter->opacity() * (1 - contentsOpacity(index)));
         }
     }
 
     rectText = QRect(isLTR ? m_iconSize + LATERAL_MARGIN * 2 + option.rect.left()
                      : 0, option.rect.top(), option.rect.width() - m_iconSize - LATERAL_MARGIN * 2, option.rect.height());
     painter->drawText(rectText, Qt::AlignLeft | Qt::AlignVCenter, option.fontMetrics.elidedText(index.model()->data(index).toString(), Qt::ElideRight, rectText.width()));
 
     if (drawCapacityBar && contentsOpacity(index) > 0) {
         painter->restore();
     }
 
     painter->restore();
 }
 
 int KFilePlacesViewDelegate::iconSize() const
 {
     return m_iconSize;
 }
 
 void KFilePlacesViewDelegate::setIconSize(int newSize)
 {
     m_iconSize = newSize;
 }
 
 void KFilePlacesViewDelegate::addAppearingItem(const QModelIndex &index)
 {
     m_appearingItems << index;
 }
 
 void KFilePlacesViewDelegate::setAppearingItemProgress(qreal value)
 {
     if (value <= 0.25) {
         m_appearingOpacity = 0.0;
         m_appearingIconSize = iconSize() * value * 4;
 
         if (m_appearingIconSize >= m_iconSize) {
             m_appearingIconSize = m_iconSize;
         }
     } else {
         m_appearingIconSize = m_iconSize;
         m_appearingOpacity = (value - 0.25) * 4 / 3;
 
         if (value >= 1.0) {
             m_appearingItems.clear();
         }
     }
 }
 
 void KFilePlacesViewDelegate::addDisappearingItem(const QModelIndex &index)
 {
     m_disappearingItems << index;
 }
 
 void KFilePlacesViewDelegate::setDisappearingItemProgress(qreal value)
 {
     value = 1.0 - value;
 
     if (value <= 0.25) {
         m_disappearingOpacity = 0.0;
         m_disappearingIconSize = iconSize() * value * 4;
 
         if (m_disappearingIconSize >= m_iconSize) {
             m_disappearingIconSize = m_iconSize;
         }
 
         if (value <= 0.0) {
             m_disappearingItems.clear();
         }
     } else {
         m_disappearingIconSize = m_iconSize;
         m_disappearingOpacity = (value - 0.25) * 4 / 3;
     }
 }
 
 void KFilePlacesViewDelegate::setShowHoverIndication(bool show)
 {
     m_showHoverIndication = show;
 }
 
 void KFilePlacesViewDelegate::addFadeAnimation(const QModelIndex &index, QTimeLine *timeLine)
 {
     m_timeLineMap.insert(index, timeLine);
     m_timeLineInverseMap.insert(timeLine, index);
 }
 
 void KFilePlacesViewDelegate::removeFadeAnimation(const QModelIndex &index)
 {
     QTimeLine *timeLine = m_timeLineMap.value(index, nullptr);
     m_timeLineMap.remove(index);
     m_timeLineInverseMap.remove(timeLine);
 }
 
 QModelIndex KFilePlacesViewDelegate::indexForFadeAnimation(QTimeLine *timeLine) const
 {
     return m_timeLineInverseMap.value(timeLine, QModelIndex());
 }
 
 QTimeLine *KFilePlacesViewDelegate::fadeAnimationForIndex(const QModelIndex &index) const
 {
     return m_timeLineMap.value(index, nullptr);
 }
 
 qreal KFilePlacesViewDelegate::contentsOpacity(const QModelIndex &index) const
 {
     QTimeLine *timeLine = fadeAnimationForIndex(index);
     if (timeLine) {
         return timeLine->currentValue();
     }
     return 0;
 }
 
 class KFilePlacesView::Private
 {
 public:
     Private(KFilePlacesView *parent) : q(parent), watcher(new KFilePlacesEventWatcher(q)) { }
 
     enum FadeType {
         FadeIn = 0,
         FadeOut
     };
 
     KFilePlacesView *const q;
 
     QUrl currentUrl;
     bool autoResizeItems;
     bool showAll;
     bool smoothItemResizing;
     bool dropOnPlace;
     bool dragging;
     Solid::StorageAccess *lastClickedStorage;
     QPersistentModelIndex lastClickedIndex;
 
     QRect dropRect;
 
     void setCurrentIndex(const QModelIndex &index);
     void adaptItemSize();
     void updateHiddenRows();
     bool insertAbove(const QRect &itemRect, const QPoint &pos) const;
     bool insertBelow(const QRect &itemRect, const QPoint &pos) const;
     int insertIndicatorHeight(int itemHeight) const;
     void fadeCapacityBar(const QModelIndex &index, FadeType fadeType);
 
     void _k_placeClicked(const QModelIndex &index);
     void _k_placeEntered(const QModelIndex &index);
     void _k_placeLeft(const QModelIndex &index);
     void _k_storageSetupDone(const QModelIndex &index, bool success);
     void _k_adaptItemsUpdate(qreal value);
     void _k_itemAppearUpdate(qreal value);
     void _k_itemDisappearUpdate(qreal value);
     void _k_enableSmoothItemResizing();
     void _k_capacityBarFadeValueChanged();
     void _k_triggerDevicePolling();
 
     QTimeLine adaptItemsTimeline;
     int oldSize, endSize;
 
     QTimeLine itemAppearTimeline;
     QTimeLine itemDisappearTimeline;
 
     KFilePlacesEventWatcher *const watcher;
     KFilePlacesViewDelegate *delegate;
     QTimer pollDevices;
     int pollingRequestCount;
 };
 
 KFilePlacesView::KFilePlacesView(QWidget *parent)
     : QListView(parent), d(new Private(this))
 {
     d->showAll = false;
     d->smoothItemResizing = false;
     d->dropOnPlace = false;
     d->autoResizeItems = true;
     d->dragging = false;
     d->lastClickedStorage = nullptr;
     d->pollingRequestCount = 0;
     d->delegate = new KFilePlacesViewDelegate(this);
 
     setSelectionRectVisible(false);
     setSelectionMode(SingleSelection);
 
     setDragEnabled(true);
     setAcceptDrops(true);
     setMouseTracking(true);
     setDropIndicatorShown(false);
     setFrameStyle(QFrame::NoFrame);
 
     setResizeMode(Adjust);
     setItemDelegate(d->delegate);
 
     QPalette palette = viewport()->palette();
     palette.setColor(viewport()->backgroundRole(), Qt::transparent);
     palette.setColor(viewport()->foregroundRole(), palette.color(QPalette::WindowText));
     viewport()->setPalette(palette);
 
     connect(this, SIGNAL(clicked(QModelIndex)),
             this, SLOT(_k_placeClicked(QModelIndex)));
     // Note: Don't connect to the activated() signal, as the behavior when it is
     // committed depends on the used widget style. The click behavior of
     // KFilePlacesView should be style independent.
 
     connect(&d->adaptItemsTimeline, SIGNAL(valueChanged(qreal)),
             this, SLOT(_k_adaptItemsUpdate(qreal)));
     d->adaptItemsTimeline.setDuration(500);
     d->adaptItemsTimeline.setUpdateInterval(5);
     d->adaptItemsTimeline.setCurveShape(QTimeLine::EaseInOutCurve);
 
     connect(&d->itemAppearTimeline, SIGNAL(valueChanged(qreal)),
             this, SLOT(_k_itemAppearUpdate(qreal)));
     d->itemAppearTimeline.setDuration(500);
     d->itemAppearTimeline.setUpdateInterval(5);
     d->itemAppearTimeline.setCurveShape(QTimeLine::EaseInOutCurve);
 
     connect(&d->itemDisappearTimeline, SIGNAL(valueChanged(qreal)),
             this, SLOT(_k_itemDisappearUpdate(qreal)));
     d->itemDisappearTimeline.setDuration(500);
     d->itemDisappearTimeline.setUpdateInterval(5);
     d->itemDisappearTimeline.setCurveShape(QTimeLine::EaseInOutCurve);
 
     viewport()->installEventFilter(d->watcher);
     connect(d->watcher, SIGNAL(entryEntered(QModelIndex)),
             this, SLOT(_k_placeEntered(QModelIndex)));
     connect(d->watcher, SIGNAL(entryLeft(QModelIndex)),
             this, SLOT(_k_placeLeft(QModelIndex)));
 
     d->pollDevices.setInterval(5000);
     connect(&d->pollDevices, SIGNAL(timeout()), this, SLOT(_k_triggerDevicePolling()));
 
     // FIXME: this is necessary to avoid flashes of black with some widget styles.
     // could be a bug in Qt (e.g. QAbstractScrollArea) or KFilePlacesView, but has not
     // yet been tracked down yet. until then, this works and is harmlessly enough.
     // in fact, some QStyle (Oxygen, Skulpture, others?) do this already internally.
     // See br #242358 for more information
     verticalScrollBar()->setAttribute(Qt::WA_OpaquePaintEvent, false);
 }
 
 KFilePlacesView::~KFilePlacesView()
 {
     delete d;
 }
 
 void KFilePlacesView::setDropOnPlaceEnabled(bool enabled)
 {
     d->dropOnPlace = enabled;
 }
 
 bool KFilePlacesView::isDropOnPlaceEnabled() const
 {
     return d->dropOnPlace;
 }
 
 void KFilePlacesView::setAutoResizeItemsEnabled(bool enabled)
 {
     d->autoResizeItems = enabled;
 }
 
 bool KFilePlacesView::isAutoResizeItemsEnabled() const
 {
     return d->autoResizeItems;
 }
 
 void KFilePlacesView::setUrl(const QUrl &url)
 {
     QUrl oldUrl = d->currentUrl;
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(model());
 
     if (placesModel == nullptr) {
         return;
     }
 
     QModelIndex index = placesModel->closestItem(url);
     QModelIndex current = selectionModel()->currentIndex();
 
     if (index.isValid()) {
         if (current != index && placesModel->isHidden(current) && !d->showAll) {
             KFilePlacesViewDelegate *delegate = static_cast<KFilePlacesViewDelegate *>(itemDelegate());
             delegate->addDisappearingItem(current);
 
             if (d->itemDisappearTimeline.state() != QTimeLine::Running) {
                 delegate->setDisappearingItemProgress(0.0);
                 d->itemDisappearTimeline.start();
             }
         }
 
         if (current != index && placesModel->isHidden(index) && !d->showAll) {
             KFilePlacesViewDelegate *delegate = static_cast<KFilePlacesViewDelegate *>(itemDelegate());
             delegate->addAppearingItem(index);
 
             if (d->itemAppearTimeline.state() != QTimeLine::Running) {
                 delegate->setAppearingItemProgress(0.0);
                 d->itemAppearTimeline.start();
             }
 
             setRowHidden(index.row(), false);
         }
 
         d->currentUrl = url;
         selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
     } else {
         d->currentUrl = QUrl();
         selectionModel()->clear();
     }
 
     if (!current.isValid()) {
         d->updateHiddenRows();
     }
 }
 
 void KFilePlacesView::setShowAll(bool showAll)
 {
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(model());
 
     if (placesModel == nullptr) {
         return;
     }
 
     d->showAll = showAll;
 
     KFilePlacesViewDelegate *delegate = static_cast<KFilePlacesViewDelegate *>(itemDelegate());
 
     int rowCount = placesModel->rowCount();
     QModelIndex current = placesModel->closestItem(d->currentUrl);
 
     if (showAll) {
         d->updateHiddenRows();
 
         for (int i = 0; i < rowCount; ++i) {
             QModelIndex index = placesModel->index(i, 0);
             if (index != current && placesModel->isHidden(index)) {
                 delegate->addAppearingItem(index);
             }
         }
 
         if (d->itemAppearTimeline.state() != QTimeLine::Running) {
             delegate->setAppearingItemProgress(0.0);
             d->itemAppearTimeline.start();
         }
     } else {
         for (int i = 0; i < rowCount; ++i) {
             QModelIndex index = placesModel->index(i, 0);
             if (index != current && placesModel->isHidden(index)) {
                 delegate->addDisappearingItem(index);
             }
         }
 
         if (d->itemDisappearTimeline.state() != QTimeLine::Running) {
             delegate->setDisappearingItemProgress(0.0);
             d->itemDisappearTimeline.start();
         }
     }
 }
 
 void KFilePlacesView::keyPressEvent(QKeyEvent *event)
 {
     QListView::keyPressEvent(event);
     if ((event->key() == Qt::Key_Return) || (event->key() == Qt::Key_Enter)) {
         d->_k_placeClicked(currentIndex());
     }
 }
 
 void KFilePlacesView::contextMenuEvent(QContextMenuEvent *event)
 {
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(model());
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(itemDelegate());
 
     if (placesModel == nullptr) {
         return;
     }
 
     QModelIndex index = indexAt(event->pos());
     QString label = placesModel->text(index).replace('&', QLatin1String("&&"));
 
     QMenu menu;
 
     QAction *edit = nullptr;
     QAction *hide = nullptr;
     QAction *emptyTrash = nullptr;
     QAction *eject = nullptr;
     QAction *teardown = nullptr;
     QAction *add = nullptr;
     QAction *mainSeparator = nullptr;
 
     if (index.isValid()) {
         if (!placesModel->isDevice(index)) {
             if (placesModel->url(index).toString() == QLatin1String("trash:/")) {
                 emptyTrash = menu.addAction(QIcon::fromTheme(QStringLiteral("trash-empty")), i18nc("@action:inmenu", "Empty Trash"));
                 KConfig trashConfig(QStringLiteral("trashrc"), KConfig::SimpleConfig);
                 emptyTrash->setEnabled(!trashConfig.group("Status").readEntry("Empty", true));
                 menu.addSeparator();
             }
             add = menu.addAction(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Add Entry..."));
             mainSeparator = menu.addSeparator();
             edit = menu.addAction(QIcon::fromTheme(QStringLiteral("document-properties")), i18n("&Edit Entry '%1'...", label));
         } else {
             eject = placesModel->ejectActionForIndex(index);
             if (eject != nullptr) {
                 eject->setParent(&menu);
                 menu.addAction(eject);
             }
 
             teardown = placesModel->teardownActionForIndex(index);
             if (teardown != nullptr) {
                 teardown->setParent(&menu);
                 menu.addAction(teardown);
             }
 
             if (teardown != nullptr || eject != nullptr) {
                 mainSeparator = menu.addSeparator();
             }
         }
         if (add == nullptr) {
             add = menu.addAction(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Add Entry..."));
         }
 
         hide = menu.addAction(i18n("&Hide Entry '%1'", label));
         hide->setCheckable(true);
         hide->setChecked(placesModel->isHidden(index));
     } else {
         add = menu.addAction(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Add Entry..."));
     }
 
     QAction *showAll = nullptr;
     if (placesModel->hiddenCount() > 0) {
         showAll = new QAction(i18n("&Show All Entries"), &menu);
         showAll->setCheckable(true);
         showAll->setChecked(d->showAll);
         if (mainSeparator == nullptr) {
             mainSeparator = menu.addSeparator();
         }
         menu.insertAction(mainSeparator, showAll);
     }
 
     QAction *remove = nullptr;
     if (index.isValid() && !placesModel->isDevice(index)) {
         remove = menu.addAction(QIcon::fromTheme(QStringLiteral("edit-delete")), i18n("&Remove Entry '%1'", label));
     }
 
     menu.addActions(actions());
 
     if (menu.isEmpty()) {
         return;
     }
 
     QAction *result = menu.exec(event->globalPos());
 
     if (emptyTrash != nullptr && result == emptyTrash) {
 
         KIO::JobUiDelegate uiDelegate;
         uiDelegate.setWindow(window());
         if (uiDelegate.askDeleteConfirmation(QList<QUrl>(), KIO::JobUiDelegate::EmptyTrash, KIO::JobUiDelegate::DefaultConfirmation)) {
             KIO::Job* job = KIO::emptyTrash();
             KJobWidgets::setWindow(job, window());
-            job->ui()->setAutoErrorHandlingEnabled(true);
+            job->uiDelegate()->setAutoErrorHandlingEnabled(true);
         }
     } else if (edit != nullptr && result == edit) {
         KBookmark bookmark = placesModel->bookmarkForIndex(index);
         QUrl url = bookmark.url();
         QString label = bookmark.text();
         QString iconName = bookmark.icon();
         bool appLocal = !bookmark.metaDataItem(QStringLiteral("OnlyInApp")).isEmpty();
 
         if (KFilePlaceEditDialog::getInformation(true, url, label,
                 iconName, false, appLocal, 64, this)) {
             QString appName;
             if (appLocal) {
                 appName = QCoreApplication::instance()->applicationName();
             }
 
             placesModel->editPlace(index, label, url, iconName, appName);
         }
 
     } else if (remove != nullptr && result == remove) {
         placesModel->removePlace(index);
     } else if (hide != nullptr && result == hide) {
         placesModel->setPlaceHidden(index, hide->isChecked());
         QModelIndex current = placesModel->closestItem(d->currentUrl);
 
         if (index != current && !d->showAll && hide->isChecked()) {
             delegate->addDisappearingItem(index);
 
             if (d->itemDisappearTimeline.state() != QTimeLine::Running) {
                 delegate->setDisappearingItemProgress(0.0);
                 d->itemDisappearTimeline.start();
             }
         }
     } else if (showAll != nullptr && result == showAll) {
         setShowAll(showAll->isChecked());
     } else if (teardown != nullptr && result == teardown) {
         placesModel->requestTeardown(index);
     } else if (eject != nullptr && result == eject) {
         placesModel->requestEject(index);
     } else if (add != nullptr && result == add) {
         QUrl url = d->currentUrl;
         QString label;
         QString iconName = QStringLiteral("folder");
         bool appLocal = true;
         if (KFilePlaceEditDialog::getInformation(true, url, label,
                 iconName, true, appLocal, 64, this)) {
             QString appName;
             if (appLocal) {
                 appName = QCoreApplication::instance()->applicationName();
             }
 
             placesModel->addPlace(label, url, iconName, appName, index);
         }
     }
 
     index = placesModel->closestItem(d->currentUrl);
     selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
 }
 
 void KFilePlacesView::resizeEvent(QResizeEvent *event)
 {
     QListView::resizeEvent(event);
     d->adaptItemSize();
 }
 
 void KFilePlacesView::showEvent(QShowEvent *event)
 {
     QListView::showEvent(event);
     QTimer::singleShot(100, this, SLOT(_k_enableSmoothItemResizing()));
 }
 
 void KFilePlacesView::hideEvent(QHideEvent *event)
 {
     QListView::hideEvent(event);
     d->smoothItemResizing = false;
 }
 
 void KFilePlacesView::dragEnterEvent(QDragEnterEvent *event)
 {
     QListView::dragEnterEvent(event);
     d->dragging = true;
 
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(itemDelegate());
     delegate->setShowHoverIndication(false);
 
     d->dropRect = QRect();
 }
 
 void KFilePlacesView::dragLeaveEvent(QDragLeaveEvent *event)
 {
     QListView::dragLeaveEvent(event);
     d->dragging = false;
 
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(itemDelegate());
     delegate->setShowHoverIndication(true);
 
     setDirtyRegion(d->dropRect);
 }
 
 void KFilePlacesView::dragMoveEvent(QDragMoveEvent *event)
 {
     QListView::dragMoveEvent(event);
 
     // update the drop indicator
     const QPoint pos = event->pos();
     const QModelIndex index = indexAt(pos);
     setDirtyRegion(d->dropRect);
     if (index.isValid()) {
         const QRect rect = visualRect(index);
         const int gap = d->insertIndicatorHeight(rect.height());
         if (d->insertAbove(rect, pos)) {
             // indicate that the item will be inserted above the current place
             d->dropRect = QRect(rect.left(), rect.top() - gap / 2,
                                 rect.width(), gap);
         } else if (d->insertBelow(rect, pos)) {
             // indicate that the item will be inserted below the current place
             d->dropRect = QRect(rect.left(), rect.bottom() + 1 -  gap / 2,
                                 rect.width(), gap);
         } else {
             // indicate that the item be dropped above the current place
             d->dropRect = rect;
         }
     }
 
     setDirtyRegion(d->dropRect);
 }
 
 void KFilePlacesView::dropEvent(QDropEvent *event)
 {
     const QPoint pos = event->pos();
     const QModelIndex index = indexAt(pos);
     if (index.isValid()) {
         const QRect rect = visualRect(index);
         if (!d->insertAbove(rect, pos) && !d->insertBelow(rect, pos)) {
             KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(model());
             Q_ASSERT(placesModel != nullptr);
             emit urlsDropped(placesModel->url(index), event, this);
             event->acceptProposedAction();
         }
     }
 
     QListView::dropEvent(event);
     d->dragging = false;
 
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(itemDelegate());
     delegate->setShowHoverIndication(true);
 }
 
 void KFilePlacesView::paintEvent(QPaintEvent *event)
 {
     QListView::paintEvent(event);
     if (d->dragging && !d->dropRect.isEmpty()) {
         // draw drop indicator
         QPainter painter(viewport());
 
         const QModelIndex index = indexAt(d->dropRect.topLeft());
         const QRect itemRect = visualRect(index);
         const bool drawInsertIndicator = !d->dropOnPlace ||
                                          d->dropRect.height() <= d->insertIndicatorHeight(itemRect.height());
 
         if (drawInsertIndicator) {
             // draw indicator for inserting items
             QBrush blendedBrush = viewOptions().palette.brush(QPalette::Normal, QPalette::Highlight);
             QColor color = blendedBrush.color();
 
             const int y = (d->dropRect.top() + d->dropRect.bottom()) / 2;
             const int thickness = d->dropRect.height() / 2;
             Q_ASSERT(thickness >= 1);
             int alpha = 255;
             const int alphaDec = alpha / (thickness + 1);
             for (int i = 0; i < thickness; i++) {
                 color.setAlpha(alpha);
                 alpha -= alphaDec;
                 painter.setPen(color);
                 painter.drawLine(d->dropRect.left(), y - i, d->dropRect.right(), y - i);
                 painter.drawLine(d->dropRect.left(), y + i, d->dropRect.right(), y + i);
             }
         } else {
             // draw indicator for copying/moving/linking to items
             QStyleOptionViewItem opt;
             opt.initFrom(this);
             opt.rect = itemRect;
             opt.state = QStyle::State_Enabled | QStyle::State_MouseOver;
             style()->drawPrimitive(QStyle::PE_PanelItemViewItem, &opt, &painter, this);
         }
     }
 }
 
 void KFilePlacesView::setModel(QAbstractItemModel *model)
 {
     QListView::setModel(model);
     d->updateHiddenRows();
     // Uses Qt::QueuedConnection to delay the time when the slot will be
     // called. In case of an item move the remove+add will be done before
     // we adapt the item size (otherwise we'd get it wrong as we'd execute
     // it after the remove only).
     connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)),
             this, SLOT(adaptItemSize()), Qt::QueuedConnection);
     connect(selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)),
             d->watcher, SLOT(currentIndexChanged(QModelIndex)));
 }
 
 void KFilePlacesView::rowsInserted(const QModelIndex &parent, int start, int end)
 {
     QListView::rowsInserted(parent, start, end);
     setUrl(d->currentUrl);
 
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(itemDelegate());
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(model());
 
     for (int i = start; i <= end; ++i) {
         QModelIndex index = placesModel->index(i, 0, parent);
         if (d->showAll || !placesModel->isHidden(index)) {
             delegate->addAppearingItem(index);
         } else {
             setRowHidden(i, true);
         }
     }
 
     if (d->itemAppearTimeline.state() != QTimeLine::Running) {
         delegate->setAppearingItemProgress(0.0);
         d->itemAppearTimeline.start();
     }
 
     d->adaptItemSize();
 }
 
 QSize KFilePlacesView::sizeHint() const
 {
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(model());
     if (!placesModel) {
         return QListView::sizeHint();
     }
     const int height = QListView::sizeHint().height();
     QFontMetrics fm = d->q->fontMetrics();
     int textWidth = 0;
 
     for (int i = 0; i < placesModel->rowCount(); ++i) {
         QModelIndex index = placesModel->index(i, 0);
         if (!placesModel->isHidden(index)) {
             textWidth = qMax(textWidth, fm.width(index.data(Qt::DisplayRole).toString()));
         }
     }
 
     const int iconSize = KIconLoader::global()->currentSize(KIconLoader::Small) + 3 * LATERAL_MARGIN;
     return QSize(iconSize + textWidth + fm.height() / 2, height);
 }
 
 void KFilePlacesView::Private::setCurrentIndex(const QModelIndex &index)
 {
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(q->model());
 
     if (placesModel == nullptr) {
         return;
     }
 
     QUrl url = placesModel->url(index);
 
     if (url.isValid()) {
         currentUrl = url;
         updateHiddenRows();
         emit q->urlChanged(url);
         if (showAll) {
             q->setShowAll(false);
         }
     } else {
         q->setUrl(currentUrl);
     }
 }
 
 void KFilePlacesView::Private::adaptItemSize()
 {
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(q->itemDelegate());
     if (!delegate) {
         return;
     }
 
     if (!autoResizeItems) {
         int size = q->iconSize().width(); // Assume width == height
         delegate->setIconSize(size);
         q->scheduleDelayedItemsLayout();
         return;
     }
 
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(q->model());
 
     if (placesModel == nullptr) {
         return;
     }
 
     int rowCount = placesModel->rowCount();
 
     if (!showAll) {
         rowCount -= placesModel->hiddenCount();
 
         QModelIndex current = placesModel->closestItem(currentUrl);
 
         if (placesModel->isHidden(current)) {
             rowCount++;
         }
     }
 
     if (rowCount == 0) {
         return;    // We've nothing to display anyway
     }
 
     const int minSize = IconSize(KIconLoader::Small);
     const int maxSize = 64;
 
     int textWidth = 0;
     QFontMetrics fm = q->fontMetrics();
     for (int i = 0; i < placesModel->rowCount(); ++i) {
         QModelIndex index = placesModel->index(i, 0);
 
         if (!placesModel->isHidden(index)) {
             textWidth = qMax(textWidth, fm.width(index.data(Qt::DisplayRole).toString()));
         }
     }
 
     const int margin = q->style()->pixelMetric(QStyle::PM_FocusFrameHMargin, nullptr, q) + 1;
     const int maxWidth = q->viewport()->width() - textWidth - 4 * margin - 1;
     const int maxHeight = ((q->height() - (fm.height() / 2) * rowCount) / rowCount) - 1;
 
     int size = qMin(maxHeight, maxWidth);
 
     if (size < minSize) {
         size = minSize;
     } else if (size > maxSize) {
         size = maxSize;
     } else {
         // Make it a multiple of 16
         size &= ~0xf;
     }
 
     if (size == delegate->iconSize()) {
         return;
     }
 
     if (smoothItemResizing) {
         oldSize = delegate->iconSize();
         endSize = size;
         if (adaptItemsTimeline.state() != QTimeLine::Running) {
             adaptItemsTimeline.start();
         }
     } else {
         delegate->setIconSize(size);
         q->scheduleDelayedItemsLayout();
     }
 }
 
 void KFilePlacesView::Private::updateHiddenRows()
 {
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(q->model());
 
     if (placesModel == nullptr) {
         return;
     }
 
     int rowCount = placesModel->rowCount();
     QModelIndex current = placesModel->closestItem(currentUrl);
 
     for (int i = 0; i < rowCount; ++i) {
         QModelIndex index = placesModel->index(i, 0);
         if (index != current && placesModel->isHidden(index) && !showAll) {
             q->setRowHidden(i, true);
         } else {
             q->setRowHidden(i, false);
         }
     }
 
     adaptItemSize();
 }
 
 bool KFilePlacesView::Private::insertAbove(const QRect &itemRect, const QPoint &pos) const
 {
     if (dropOnPlace) {
         return pos.y() < itemRect.top() + insertIndicatorHeight(itemRect.height()) / 2;
     }
 
     return pos.y() < itemRect.top() + (itemRect.height() / 2);
 }
 
 bool KFilePlacesView::Private::insertBelow(const QRect &itemRect, const QPoint &pos) const
 {
     if (dropOnPlace) {
         return pos.y() > itemRect.bottom() - insertIndicatorHeight(itemRect.height()) / 2;
     }
 
     return pos.y() >= itemRect.top() + (itemRect.height() / 2);
 }
 
 int KFilePlacesView::Private::insertIndicatorHeight(int itemHeight) const
 {
     const int min = 4;
     const int max = 12;
 
     int height = itemHeight / 4;
     if (height < min) {
         height = min;
     } else if (height > max) {
         height = max;
     }
     return height;
 }
 
 void KFilePlacesView::Private::fadeCapacityBar(const QModelIndex &index, FadeType fadeType)
 {
     QTimeLine *timeLine = delegate->fadeAnimationForIndex(index);
     delete timeLine;
     delegate->removeFadeAnimation(index);
     timeLine = new QTimeLine(250, q);
     connect(timeLine, SIGNAL(valueChanged(qreal)), q, SLOT(_k_capacityBarFadeValueChanged()));
     if (fadeType == FadeIn) {
         timeLine->setDirection(QTimeLine::Forward);
         timeLine->setCurrentTime(0);
     } else {
         timeLine->setDirection(QTimeLine::Backward);
         timeLine->setCurrentTime(250);
     }
     delegate->addFadeAnimation(index, timeLine);
     timeLine->start();
 }
 
 void KFilePlacesView::Private::_k_placeClicked(const QModelIndex &index)
 {
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(q->model());
 
     if (placesModel == nullptr) {
         return;
     }
 
     lastClickedIndex = QPersistentModelIndex();
 
     if (placesModel->setupNeeded(index)) {
         QObject::connect(placesModel, SIGNAL(setupDone(QModelIndex,bool)),
                          q, SLOT(_k_storageSetupDone(QModelIndex,bool)));
 
         lastClickedIndex = index;
         placesModel->requestSetup(index);
         return;
     }
 
     setCurrentIndex(index);
 }
 
 void KFilePlacesView::Private::_k_placeEntered(const QModelIndex &index)
 {
     fadeCapacityBar(index, FadeIn);
     pollingRequestCount++;
     if (pollingRequestCount == 1) {
         pollDevices.start();
     }
 }
 
 void KFilePlacesView::Private::_k_placeLeft(const QModelIndex &index)
 {
     fadeCapacityBar(index, FadeOut);
     pollingRequestCount--;
     if (!pollingRequestCount) {
         pollDevices.stop();
     }
 }
 
 void KFilePlacesView::Private::_k_storageSetupDone(const QModelIndex &index, bool success)
 {
     if (index != lastClickedIndex) {
         return;
     }
 
     KFilePlacesModel *placesModel = qobject_cast<KFilePlacesModel *>(q->model());
 
     QObject::disconnect(placesModel, SIGNAL(setupDone(QModelIndex,bool)),
                         q, SLOT(_k_storageSetupDone(QModelIndex,bool)));
 
     if (success) {
         setCurrentIndex(lastClickedIndex);
     } else {
         q->setUrl(currentUrl);
     }
 
     lastClickedIndex = QPersistentModelIndex();
 }
 
 void KFilePlacesView::Private::_k_adaptItemsUpdate(qreal value)
 {
     int add = (endSize - oldSize) * value;
 
     int size = oldSize + add;
 
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(q->itemDelegate());
     delegate->setIconSize(size);
     q->scheduleDelayedItemsLayout();
 }
 
 void KFilePlacesView::Private::_k_itemAppearUpdate(qreal value)
 {
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(q->itemDelegate());
 
     delegate->setAppearingItemProgress(value);
     q->scheduleDelayedItemsLayout();
 }
 
 void KFilePlacesView::Private::_k_itemDisappearUpdate(qreal value)
 {
     KFilePlacesViewDelegate *delegate = dynamic_cast<KFilePlacesViewDelegate *>(q->itemDelegate());
 
     delegate->setDisappearingItemProgress(value);
 
     if (value >= 1.0) {
         updateHiddenRows();
     }
 
     q->scheduleDelayedItemsLayout();
 }
 
 void KFilePlacesView::Private::_k_enableSmoothItemResizing()
 {
     smoothItemResizing = true;
 }
 
 void KFilePlacesView::Private::_k_capacityBarFadeValueChanged()
 {
     const QModelIndex index = delegate->indexForFadeAnimation(static_cast<QTimeLine *>(q->sender()));
     if (!index.isValid()) {
         return;
     }
     q->update(index);
 }
 
 void KFilePlacesView::Private::_k_triggerDevicePolling()
 {
     const QModelIndex hoveredIndex = watcher->hoveredIndex();
     if (hoveredIndex.isValid()) {
         const KFilePlacesModel *placesModel = static_cast<const KFilePlacesModel *>(hoveredIndex.model());
         if (placesModel->isDevice(hoveredIndex)) {
             q->update(hoveredIndex);
         }
     }
     const QModelIndex focusedIndex = watcher->focusedIndex();
     if (focusedIndex.isValid() && focusedIndex != hoveredIndex) {
         const KFilePlacesModel *placesModel = static_cast<const KFilePlacesModel *>(focusedIndex.model());
         if (placesModel->isDevice(focusedIndex)) {
             q->update(focusedIndex);
         }
     }
 }
 
 void KFilePlacesView::dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight,
                                   const QVector<int> &roles)
 {
     QListView::dataChanged(topLeft, bottomRight, roles);
     d->adaptItemSize();
 }
 
 #include "moc_kfileplacesview.cpp"
 #include "moc_kfileplacesview_p.cpp"
 #include "kfileplacesview.moc"
\ No newline at end of file
diff --git a/src/filewidgets/knewfilemenu.cpp b/src/filewidgets/knewfilemenu.cpp
index 52dd05f7..474c8b3c 100644
--- a/src/filewidgets/knewfilemenu.cpp
+++ b/src/filewidgets/knewfilemenu.cpp
@@ -1,1269 +1,1269 @@
 /* This file is part of the KDE project
    Copyright (C) 1998-2009 David Faure <faure@kde.org>
                  2003      Sven Leiber <s.leiber@web.de>
 
    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 or at your option version 3.
 
    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 "knewfilemenu.h"
 #include "knameandurlinputdialog.h"
 
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QDir>
 #include <QVBoxLayout>
 #include <QList>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QStandardPaths>
 
 #include <qtemporaryfile.h>
 #include <kactioncollection.h>
 #include <kconfiggroup.h>
 #include <QDebug>
 #include <kdesktopfile.h>
 #include <kdirwatch.h>
 #include <kjobwidgets.h>
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 #include <kprotocolinfo.h>
 #include <kprotocolmanager.h>
 #include <krun.h>
 #include <kshell.h>
 #include <kio/job.h>
 #include <kio/copyjob.h>
 #include <kio/jobuidelegate.h>
 #include <kio/fileundomanager.h>
 #include <kio/mkpathjob.h>
 #include <kurifilter.h>
 
 #include <kpropertiesdialog.h>
 #include <qmimedatabase.h>
 #ifdef Q_OS_WIN
 #include <sys/utime.h>
 #else
 #include <utime.h>
 #endif
 
 static QString expandTilde(const QString &name, bool isfile = false)
 {
     if (!name.isEmpty() && (!isfile || name[0] == '\\')) {
         const QString expandedName = KShell::tildeExpand(name);
         // When a tilde mark cannot be properly expanded, the above call
         // returns an empty string...
         if (!expandedName.isEmpty()) {
             return expandedName;
         }
     }
 
     return name;
 }
 
 // Singleton, with data shared by all KNewFileMenu instances
 class KNewFileMenuSingleton
 {
 public:
     KNewFileMenuSingleton()
         : dirWatch(nullptr),
           filesParsed(false),
           templatesList(nullptr),
           templatesVersion(0)
     {
     }
 
     ~KNewFileMenuSingleton()
     {
         delete dirWatch;
         delete templatesList;
     }
 
     /**
      * Opens the desktop files and completes the Entry list
      * Input: the entry list. Output: the entry list ;-)
      */
     void parseFiles();
 
     /**
      * For entryType
      * LINKTOTEMPLATE: a desktop file that points to a file or dir to copy
      * TEMPLATE: a real file to copy as is (the KDE-1.x solution)
      * SEPARATOR: to put a separator in the menu
      * 0 means: not parsed, i.e. we don't know
      */
     enum EntryType { Unknown, LinkToTemplate = 1, Template, Separator };
 
     KDirWatch *dirWatch;
 
     struct Entry {
         QString text;
         QString filePath; // empty for Separator
         QString templatePath; // same as filePath for Template
         QString icon;
         EntryType entryType;
         QString comment;
         QString mimeType;
     };
     // NOTE: only filePath is known before we call parseFiles
 
     /**
      * List of all template files. It is important that they are in
      * the same order as the 'New' menu.
      */
     typedef QList<Entry> EntryList;
 
     /**
      * Set back to false each time new templates are found,
      * and to true on the first call to parseFiles
      */
     bool filesParsed;
     EntryList *templatesList;
 
     /**
      * Is increased when templatesList has been updated and
      * menu needs to be re-filled. Menus have their own version and compare it
      * to templatesVersion before showing up
      */
     int templatesVersion;
 };
 
 void KNewFileMenuSingleton::parseFiles()
 {
     //qDebug();
     filesParsed = true;
     QMutableListIterator<KNewFileMenuSingleton::Entry> templIter(*templatesList);
     while (templIter.hasNext()) {
         KNewFileMenuSingleton::Entry &templ = templIter.next();
         const QString filePath = templ.filePath;
         if (!filePath.isEmpty()) {
             QString text;
             QString templatePath;
             // If a desktop file, then read the name from it.
             // Otherwise (or if no name in it?) use file name
             if (KDesktopFile::isDesktopFile(filePath)) {
                 KDesktopFile desktopFile(filePath);
                 if (desktopFile.noDisplay()) {
                     templIter.remove();
                     continue;
                 }
                 text = desktopFile.readName();
                 templ.icon = desktopFile.readIcon();
                 templ.comment = desktopFile.readComment();
                 QString type = desktopFile.readType();
                 if (type == QLatin1String("Link")) {
                     templatePath = desktopFile.desktopGroup().readPathEntry("URL", QString());
                     if (templatePath[0] != '/' && !templatePath.startsWith(QLatin1String("__"))) {
                         if (templatePath.startsWith(QLatin1String("file:/"))) {
                             templatePath = QUrl(templatePath).toLocalFile();
                         } else {
                             // A relative path, then (that's the default in the files we ship)
                             QString linkDir = filePath.left(filePath.lastIndexOf('/') + 1 /*keep / */);
                             //qDebug() << "linkDir=" << linkDir;
                             templatePath = linkDir + templatePath;
                         }
                     }
                 }
                 if (templatePath.isEmpty()) {
                     // No URL key, this is an old-style template
                     templ.entryType = KNewFileMenuSingleton::Template;
                     templ.templatePath = templ.filePath; // we'll copy the file
                 } else {
                     templ.entryType = KNewFileMenuSingleton::LinkToTemplate;
                     templ.templatePath = templatePath;
                 }
 
             }
             if (text.isEmpty()) {
                 text = QUrl(filePath).fileName();
                 if (text.endsWith(QLatin1String(".desktop"))) {
                     text.truncate(text.length() - 8);
                 }
             }
             templ.text = text;
             /*// qDebug() << "Updating entry with text=" << text
                           << "entryType=" << templ.entryType
                           << "templatePath=" << templ.templatePath;*/
         } else {
             templ.entryType = KNewFileMenuSingleton::Separator;
         }
     }
 }
 
 Q_GLOBAL_STATIC(KNewFileMenuSingleton, kNewMenuGlobals)
 
 class KNewFileMenuCopyData
 {
 public:
     KNewFileMenuCopyData()
     {
         m_isSymlink = false;
     }
     QString chosenFileName() const
     {
         return m_chosenFileName;
     }
 
     // If empty, no copy is performed.
     QString sourceFileToCopy() const
     {
         return m_src;
     }
     QString tempFileToDelete() const
     {
         return m_tempFileToDelete;
     }
     bool m_isSymlink;
 
     QString m_chosenFileName;
     QString m_src;
     QString m_tempFileToDelete;
     QString m_templatePath;
 };
 
 class KNewFileMenuPrivate
 {
 public:
     KNewFileMenuPrivate(KNewFileMenu *qq)
         : m_menuItemsVersion(0),
           m_modal(true),
           m_viewShowsHiddenFiles(false),
           q(qq)
     {}
 
     bool checkSourceExists(const QString &src);
 
     /**
       * Asks user whether to create a hidden directory with a dialog
       */
     void confirmCreatingHiddenDir(const QString &name);
 
     /**
       * The strategy used for other desktop files than Type=Link. Example: Application, Device.
       */
     void executeOtherDesktopFile(const KNewFileMenuSingleton::Entry &entry);
 
     /**
       * The strategy used for "real files or directories" (the common case)
       */
     void executeRealFileOrDir(const KNewFileMenuSingleton::Entry &entry);
 
     /**
       * Actually performs file handling. Reads in m_copyData for needed data, that has been collected by execute*() before
       */
     void executeStrategy();
 
     /**
       * The strategy used when creating a symlink
       */
     void executeSymLink(const KNewFileMenuSingleton::Entry &entry);
 
     /**
       * The strategy used for "url" desktop files
       */
     void executeUrlDesktopFile(const KNewFileMenuSingleton::Entry &entry);
 
     /**
      * Fills the menu from the templates list.
      */
     void fillMenu();
 
     /**
      * Tries to map a local URL for the given URL.
      */
     QUrl mostLocalUrl(const QUrl &url);
 
     /**
       * Just clears the string buffer d->m_text, but I need a slot for this to occur
       */
     void _k_slotAbortDialog();
 
     /**
      * Called when New->* is clicked
      */
     void _k_slotActionTriggered(QAction *action);
 
     /**
      * Callback function that reads in directory name from dialog and processes it
      */
     void _k_slotCreateDirectory(bool writeHiddenDir = false);
 
     /**
      * Callback function that reads in directory name from dialog and processes it. This will wirte
      * a hidden directory without further questions
      */
     void _k_slotCreateHiddenDirectory();
 
     /**
      * Fills the templates list.
      */
     void _k_slotFillTemplates();
 
     /**
       * Called when accepting the KPropertiesDialog (for "other desktop files")
       */
     void _k_slotOtherDesktopFile();
 
     /**
      * Called when closing the KPropertiesDialog is closed (whichever way, accepted and rejected)
      */
     void _k_slotOtherDesktopFileClosed();
 
     /**
       * Callback in KNewFileMenu for the RealFile Dialog. Handles dialog input and gives over
       * to executeStrategy()
       */
     void _k_slotRealFileOrDir();
 
     /**
       * Dialogs use this slot to write the changed string into KNewFile menu when the user
       * changes touches them
       */
     void _k_slotTextChanged(const QString &text);
 
     /**
       * Callback in KNewFileMenu for the Symlink Dialog. Handles dialog input and gives over
       * to executeStrategy()
       */
     void _k_slotSymLink();
 
     /**
       * Callback in KNewFileMenu for the Url/Desktop Dialog. Handles dialog input and gives over
       * to executeStrategy()
       */
     void _k_slotUrlDesktopFile();
 
     KActionCollection *m_actionCollection;
     QDialog *m_fileDialog;
 
     KActionMenu *m_menuDev;
     int m_menuItemsVersion;
     bool m_modal;
     QAction *m_newDirAction;
 
     /**
      * The action group that our actions belong to
      */
     QActionGroup *m_newMenuGroup;
     QWidget *m_parentWidget;
 
     /**
      * When the user pressed the right mouse button over an URL a popup menu
      * is displayed. The URL belonging to this popup menu is stored here.
      */
     QList<QUrl> m_popupFiles;
 
     QStringList m_supportedMimeTypes;
     QString m_tempFileToDelete; // set when a tempfile was created for a Type=URL desktop file
     QString m_text;
     bool m_viewShowsHiddenFiles;
 
     KNewFileMenu *q;
 
     KNewFileMenuCopyData m_copyData;
 };
 
 bool KNewFileMenuPrivate::checkSourceExists(const QString &src)
 {
     if (!QFile::exists(src)) {
         qWarning() << src << "doesn't exist";
 
         QDialog *dialog = new QDialog(m_parentWidget);
         dialog->setWindowTitle(i18n("Sorry"));
         dialog->setObjectName(QStringLiteral("sorry"));
         dialog->setModal(q->isModal());
         dialog->setAttribute(Qt::WA_DeleteOnClose);
 
         QDialogButtonBox *buttonBox = new QDialogButtonBox(dialog);
         buttonBox->setStandardButtons(QDialogButtonBox::Ok);
 
         KMessageBox::createKMessageBox(dialog, buttonBox, QMessageBox::Warning,
                                        i18n("<qt>The template file <b>%1</b> does not exist.</qt>", src),
                                        QStringList(), QString(), nullptr, KMessageBox::NoExec,
                                        QString());
 
         dialog->show();
 
         return false;
     }
     return true;
 }
 
 void KNewFileMenuPrivate::confirmCreatingHiddenDir(const QString &name)
 {
     if (!KMessageBox::shouldBeShownContinue(QStringLiteral("confirm_create_hidden_dir"))) {
         _k_slotCreateHiddenDirectory();
         return;
     }
 
     KGuiItem continueGuiItem(KStandardGuiItem::cont());
     continueGuiItem.setText(i18nc("@action:button", "Create directory"));
     KGuiItem cancelGuiItem(KStandardGuiItem::cancel());
     cancelGuiItem.setText(i18nc("@action:button", "Enter a different name"));
 
     QDialog *confirmDialog = new QDialog(m_parentWidget);
     confirmDialog->setWindowTitle(i18n("Create hidden directory?"));
     confirmDialog->setModal(m_modal);
     confirmDialog->setAttribute(Qt::WA_DeleteOnClose);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(confirmDialog);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     KGuiItem::assign(buttonBox->button(QDialogButtonBox::Ok), continueGuiItem);
     KGuiItem::assign(buttonBox->button(QDialogButtonBox::Cancel), cancelGuiItem);
 
     KMessageBox::createKMessageBox(confirmDialog, buttonBox, QMessageBox::Warning,
                                    i18n("The name \"%1\" starts with a dot, so the directory will be hidden by default.", name),
                                    QStringList(),
                                    i18n("Do not ask again"),
                                    nullptr,
                                    KMessageBox::NoExec,
                                    QString());
 
     QObject::connect(buttonBox, SIGNAL(accepted()), q, SLOT(_k_slotCreateHiddenDirectory()));
     QObject::connect(buttonBox, SIGNAL(rejected()), q, SLOT(createDirectory()));
 
     m_fileDialog = confirmDialog;
     confirmDialog->show();
 
 }
 
 void KNewFileMenuPrivate::executeOtherDesktopFile(const KNewFileMenuSingleton::Entry &entry)
 {
     if (!checkSourceExists(entry.templatePath)) {
         return;
     }
 
     QList<QUrl>::const_iterator it = m_popupFiles.constBegin();
     for (; it != m_popupFiles.constEnd(); ++it) {
         QString text = entry.text;
         text.remove(QStringLiteral("...")); // the ... is fine for the menu item but not for the default filename
         text = text.trimmed(); // In some languages, there is a space in front of "...", see bug 268895
         // KDE5 TODO: remove the "..." from link*.desktop files and use i18n("%1...") when making
         // the action.
         QString name = text;
         text.append(QStringLiteral(".desktop"));
 
         const QUrl directory = mostLocalUrl(*it);
         const QUrl defaultFile = QUrl::fromLocalFile(directory.toLocalFile() + '/' + KIO::encodeFileName(text));
         if (defaultFile.isLocalFile() && QFile::exists(defaultFile.toLocalFile())) {
             text = KIO::suggestName(directory, text);
         }
 
         QUrl templateUrl;
         bool usingTemplate = false;
         if (entry.templatePath.startsWith(QLatin1String(":/"))) {
             QTemporaryFile *tmpFile = QTemporaryFile::createNativeFile(entry.templatePath);
             tmpFile->setAutoRemove(false);
             QString tempFileName = tmpFile->fileName();
             tmpFile->close();
 
             KDesktopFile df(tempFileName);
             KConfigGroup group = df.desktopGroup();
             group.writeEntry("Name", name);
             templateUrl = QUrl::fromLocalFile(tempFileName);
             m_tempFileToDelete = tempFileName;
             usingTemplate = true;
         } else {
             templateUrl = QUrl::fromLocalFile(entry.templatePath);
         }
         QDialog *dlg = new KPropertiesDialog(templateUrl, directory, text, m_parentWidget);
         dlg->setModal(q->isModal());
         dlg->setAttribute(Qt::WA_DeleteOnClose);
         QObject::connect(dlg, SIGNAL(applied()), q, SLOT(_k_slotOtherDesktopFile()));
         if (usingTemplate) {
             QObject::connect(dlg, SIGNAL(propertiesClosed()), q, SLOT(_k_slotOtherDesktopFileClosed()));
         }
         dlg->show();
     }
     // We don't set m_src here -> there will be no copy, we are done.
 }
 
 void KNewFileMenuPrivate::executeRealFileOrDir(const KNewFileMenuSingleton::Entry &entry)
 {
     // The template is not a desktop file
     // Show the small dialog for getting the destination filename
     QString text = entry.text;
     text.remove(QStringLiteral("...")); // the ... is fine for the menu item but not for the default filename
     text = text.trimmed(); // In some languages, there is a space in front of "...", see bug 268895
     m_copyData.m_src = entry.templatePath;
 
     const QUrl directory = mostLocalUrl(m_popupFiles.first());
     const QUrl defaultFile = QUrl::fromLocalFile(directory.toLocalFile() + '/' + KIO::encodeFileName(text));
     if (defaultFile.isLocalFile() && QFile::exists(defaultFile.toLocalFile())) {
         text = KIO::suggestName(directory, text);
     }
 
     QDialog *fileDialog = new QDialog(m_parentWidget);
     fileDialog->setAttribute(Qt::WA_DeleteOnClose);
     fileDialog->setModal(q->isModal());
 
     QVBoxLayout *layout = new QVBoxLayout;
     QLabel *label = new QLabel(entry.comment, fileDialog);
 
     QLineEdit *lineEdit = new QLineEdit(fileDialog);
     lineEdit->setClearButtonEnabled(true);
     lineEdit->setText(text);
 
     _k_slotTextChanged(text);
     QObject::connect(lineEdit, SIGNAL(textChanged(QString)), q, SLOT(_k_slotTextChanged(QString)));
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(fileDialog);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     QObject::connect(buttonBox, SIGNAL(accepted()), fileDialog, SLOT(accept()));
     QObject::connect(buttonBox, SIGNAL(rejected()), fileDialog, SLOT(reject()));
 
     layout->addWidget(label);
     layout->addWidget(lineEdit);
     layout->addWidget(buttonBox);
 
     fileDialog->setLayout(layout);
     QObject::connect(fileDialog, SIGNAL(accepted()), q, SLOT(_k_slotRealFileOrDir()));
     QObject::connect(fileDialog, SIGNAL(rejected()), q, SLOT(_k_slotAbortDialog()));
 
     fileDialog->show();
     lineEdit->selectAll();
     lineEdit->setFocus();
 }
 
 void KNewFileMenuPrivate::executeSymLink(const KNewFileMenuSingleton::Entry &entry)
 {
     KNameAndUrlInputDialog *dlg = new KNameAndUrlInputDialog(i18n("File name:"), entry.comment, m_popupFiles.first(), m_parentWidget);
     dlg->setModal(q->isModal());
     dlg->setAttribute(Qt::WA_DeleteOnClose);
     dlg->setWindowTitle(i18n("Create Symlink"));
     m_fileDialog = dlg;
     QObject::connect(dlg, SIGNAL(accepted()), q, SLOT(_k_slotSymLink()));
     dlg->show();
 }
 
 void KNewFileMenuPrivate::executeStrategy()
 {
     m_tempFileToDelete = m_copyData.tempFileToDelete();
     const QString src = m_copyData.sourceFileToCopy();
     QString chosenFileName = expandTilde(m_copyData.chosenFileName(), true);
 
     if (src.isEmpty()) {
         return;
     }
     QUrl uSrc(QUrl::fromLocalFile(src));
 
     // In case the templates/.source directory contains symlinks, resolve
     // them to the target files. Fixes bug #149628.
     KFileItem item(uSrc, QString(), KFileItem::Unknown);
     if (item.isLink()) {
         uSrc.setPath(item.linkDest());
     }
 
     if (!m_copyData.m_isSymlink) {
         // If the file is not going to be detected as a desktop file, due to a
         // known extension (e.g. ".pl"), append ".desktop". #224142.
         QFile srcFile(uSrc.toLocalFile());
         if (srcFile.open(QIODevice::ReadOnly)) {
             QMimeDatabase db;
             QMimeType wantedMime = db.mimeTypeForUrl(uSrc);
             QMimeType mime = db.mimeTypeForFileNameAndData(m_copyData.m_chosenFileName, srcFile.read(1024));
             //qDebug() << "mime=" << mime->name() << "wantedMime=" << wantedMime->name();
             if (!mime.inherits(wantedMime.name()))
                 if (!wantedMime.preferredSuffix().isEmpty()) {
                     chosenFileName += QLatin1Char('.') + wantedMime.preferredSuffix();
                 }
         }
     }
 
     // The template is not a desktop file [or it's a URL one]
     // Copy it.
     QList<QUrl>::const_iterator it = m_popupFiles.constBegin();
     for (; it != m_popupFiles.constEnd(); ++it) {
         QUrl dest = *it;
         dest.setPath(dest.path() + '/' + KIO::encodeFileName(chosenFileName));
 
         QList<QUrl> lstSrc;
         lstSrc.append(uSrc);
         KIO::Job *kjob;
         if (m_copyData.m_isSymlink) {
             KIO::CopyJob *linkJob = KIO::linkAs(uSrc, dest);
             kjob = linkJob;
             KIO::FileUndoManager::self()->recordCopyJob(linkJob);
         } else if (src.startsWith(QLatin1String(":/"))) {
             QFile srcFile(src);
             if (!srcFile.open(QIODevice::ReadOnly)) {
                 return;
             }
             // The QFile won't live long enough for the job, so let's buffer the contents
             const QByteArray srcBuf(srcFile.readAll());
             KIO::StoredTransferJob* putJob = KIO::storedPut(srcBuf, dest, -1);
             kjob = putJob;
             KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Put, QList<QUrl>(), dest, putJob);
         } else {
             //qDebug() << "KIO::copyAs(" << uSrc.url() << "," << dest.url() << ")";
             KIO::CopyJob *job = KIO::copyAs(uSrc, dest);
             job->setDefaultPermissions(true);
             kjob = job;
             KIO::FileUndoManager::self()->recordCopyJob(job);
         }
         KJobWidgets::setWindow(kjob, m_parentWidget);
         QObject::connect(kjob, SIGNAL(result(KJob*)), q, SLOT(slotResult(KJob*)));
     }
 }
 
 void KNewFileMenuPrivate::executeUrlDesktopFile(const KNewFileMenuSingleton::Entry &entry)
 {
     KNameAndUrlInputDialog *dlg = new KNameAndUrlInputDialog(i18n("File name:"), entry.comment, m_popupFiles.first(), m_parentWidget);
     m_copyData.m_templatePath = entry.templatePath;
     dlg->setModal(q->isModal());
     dlg->setAttribute(Qt::WA_DeleteOnClose);
     dlg->setWindowTitle(i18n("Create link to URL"));
     m_fileDialog = dlg;
     QObject::connect(dlg, SIGNAL(accepted()), q, SLOT(_k_slotUrlDesktopFile()));
     dlg->show();
 }
 
 void KNewFileMenuPrivate::fillMenu()
 {
     QMenu *menu = q->menu();
     menu->clear();
     m_menuDev->menu()->clear();
     m_newDirAction = nullptr;
 
     QSet<QString> seenTexts;
     // these shall be put at special positions
     QAction *linkURL = nullptr;
     QAction *linkApp = nullptr;
     QAction *linkPath = nullptr;
 
     KNewFileMenuSingleton *s = kNewMenuGlobals();
     int i = 1;
     KNewFileMenuSingleton::EntryList::iterator templ = s->templatesList->begin();
     const KNewFileMenuSingleton::EntryList::iterator templ_end = s->templatesList->end();
     for (; templ != templ_end; ++templ, ++i) {
         KNewFileMenuSingleton::Entry &entry = *templ;
         if (entry.entryType != KNewFileMenuSingleton::Separator) {
             // There might be a .desktop for that one already, if it's a kdelnk
             // This assumes we read .desktop files before .kdelnk files ...
 
             // In fact, we skip any second item that has the same text as another one.
             // Duplicates in a menu look bad in any case.
 
             const bool bSkip = seenTexts.contains(entry.text);
             if (bSkip) {
                 // qDebug() << "skipping" << entry.filePath;
             } else {
                 seenTexts.insert(entry.text);
                 //const KNewFileMenuSingleton::Entry entry = templatesList->at(i-1);
 
                 const QString templatePath = entry.templatePath;
                 // The best way to identify the "Create Directory", "Link to Location", "Link to Application" was the template
                 if (templatePath.endsWith(QLatin1String("emptydir"))) {
                     QAction *act = new QAction(q);
                     m_newDirAction = act;
                     act->setIcon(QIcon::fromTheme(entry.icon));
                     act->setText(i18nc("@item:inmenu Create New", "%1", entry.text));
                     act->setActionGroup(m_newMenuGroup);
 
                     // If there is a shortcut available in the action collection, use it.
                     QAction *act2 = m_actionCollection->action(QStringLiteral("create_dir"));
                     if (act2) {
                         act->setShortcuts(act2->shortcuts());
                         // Both actions have now the same shortcut, so this will prevent the "Ambiguous shortcut detected" dialog.
                         act->setShortcutContext(Qt::WidgetShortcut);
                         // We also need to react to shortcut changes.
                         QObject::connect(act2, &QAction::changed, act, [=]() {
                             act->setShortcuts(act2->shortcuts());
                         });
                     }
 
                     menu->addAction(act);
 
                     QAction *sep = new QAction(q);
                     sep->setSeparator(true);
                     menu->addAction(sep);
                 } else {
 
                     if (!m_supportedMimeTypes.isEmpty()) {
                         bool keep = false;
 
                         // We need to do mimetype filtering, for real files.
                         const bool createSymlink = entry.templatePath == QLatin1String("__CREATE_SYMLINK__");
                         if (createSymlink) {
                             keep = true;
                         } else if (!KDesktopFile::isDesktopFile(entry.templatePath)) {
 
                             // Determine mimetype on demand
                             QMimeDatabase db;
                             QMimeType mime;
                             if (entry.mimeType.isEmpty()) {
                                 mime = db.mimeTypeForFile(entry.templatePath);
                                 //qDebug() << entry.templatePath << "is" << mime.name();
                                 entry.mimeType = mime.name();
                             } else {
                                 mime = db.mimeTypeForName(entry.mimeType);
                             }
                             Q_FOREACH (const QString &supportedMime, m_supportedMimeTypes) {
                                 if (mime.inherits(supportedMime)) {
                                     keep = true;
                                     break;
                                 }
                             }
                         }
 
                         if (!keep) {
                             //qDebug() << "Not keeping" << entry.templatePath;
                             continue;
                         }
                     }
 
                     QAction *act = new QAction(q);
                     act->setData(i);
                     act->setIcon(QIcon::fromTheme(entry.icon));
                     act->setText(i18nc("@item:inmenu Create New", "%1", entry.text));
                     act->setActionGroup(m_newMenuGroup);
 
                     //qDebug() << templatePath << entry.filePath;
 
                     if (templatePath.endsWith(QLatin1String("/URL.desktop"))) {
                         linkURL = act;
                     } else if (templatePath.endsWith(QLatin1String("/Program.desktop"))) {
                         linkApp = act;
                     } else if (entry.filePath.endsWith(QLatin1String("/linkPath.desktop"))) {
                         linkPath = act;
                     } else if (KDesktopFile::isDesktopFile(templatePath)) {
                         KDesktopFile df(templatePath);
                         if (df.readType() == QLatin1String("FSDevice")) {
                             m_menuDev->menu()->addAction(act);
                         } else {
                             menu->addAction(act);
                         }
                     } else {
                         menu->addAction(act);
                     }
                 }
             }
         } else { // Separate system from personal templates
             Q_ASSERT(entry.entryType != 0);
 
             QAction *sep = new QAction(q);
             sep->setSeparator(true);
             menu->addAction(sep);
         }
     }
 
     if (m_supportedMimeTypes.isEmpty()) {
         QAction *sep = new QAction(q);
         sep->setSeparator(true);
         menu->addAction(sep);
         if (linkURL) {
             menu->addAction(linkURL);
         }
         if (linkPath) {
             menu->addAction(linkPath);
         }
         if (linkApp) {
             menu->addAction(linkApp);
         }
         Q_ASSERT(m_menuDev);
         if (!m_menuDev->menu()->isEmpty()) {
             menu->addAction(m_menuDev);
         }
     }
 }
 
 QUrl KNewFileMenuPrivate::mostLocalUrl(const QUrl &url)
 {
     if (url.isLocalFile()) {
         return url;
     }
 
     KIO::StatJob *job = KIO::stat(url);
     KJobWidgets::setWindow(job, m_parentWidget);
 
     if (!job->exec()) {
         return url;
     }
 
     KIO::UDSEntry entry = job->statResult();
     const QString path = entry.stringValue(KIO::UDSEntry::UDS_LOCAL_PATH);
 
     return path.isEmpty() ? url : QUrl::fromLocalFile(path);
 }
 
 void KNewFileMenuPrivate::_k_slotAbortDialog()
 {
     m_text = QString();
 }
 
 void KNewFileMenuPrivate::_k_slotActionTriggered(QAction *action)
 {
     q->trigger(); // was for kdesktop's slotNewMenuActivated() in kde3 times. Can't hurt to keep it...
 
     if (action == m_newDirAction) {
         q->createDirectory();
         return;
     }
     const int id = action->data().toInt();
     Q_ASSERT(id > 0);
 
     KNewFileMenuSingleton *s = kNewMenuGlobals();
     const KNewFileMenuSingleton::Entry entry = s->templatesList->at(id - 1);
 
     const bool createSymlink = entry.templatePath == QLatin1String("__CREATE_SYMLINK__");
 
     m_copyData = KNewFileMenuCopyData();
 
     if (createSymlink) {
         m_copyData.m_isSymlink = true;
         executeSymLink(entry);
     } else if (KDesktopFile::isDesktopFile(entry.templatePath)) {
         KDesktopFile df(entry.templatePath);
         if (df.readType() == QLatin1String("Link")) {
             executeUrlDesktopFile(entry);
         } else { // any other desktop file (Device, App, etc.)
             executeOtherDesktopFile(entry);
         }
     } else {
         executeRealFileOrDir(entry);
     }
 
 }
 
 void KNewFileMenuPrivate::_k_slotCreateDirectory(bool writeHiddenDir)
 {
     QUrl url;
     QUrl baseUrl = m_popupFiles.first();
     bool askAgain = false;
 
     QString name = expandTilde(m_text);
 
     if (!name.isEmpty()) {
         if (QDir::isAbsolutePath(name)) {
             url = QUrl::fromLocalFile(name);
         } else {
             if (!m_viewShowsHiddenFiles && name.startsWith('.')) {
                 if (!writeHiddenDir) {
                     confirmCreatingHiddenDir(name);
                     return;
                 }
             }
             url = baseUrl;
             url.setPath(url.path() + '/' + name);
         }
     }
 
     if (!askAgain) {
         KIO::Job *job = KIO::mkpath(url, baseUrl);
         job->setProperty("mkpathUrl", url);
         KJobWidgets::setWindow(job, m_parentWidget);
-        job->ui()->setAutoErrorHandlingEnabled(true);
+        job->uiDelegate()->setAutoErrorHandlingEnabled(true);
         KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Mkpath, QList<QUrl>(), url, job);
 
         if (job) {
             // We want the error handling to be done by slotResult so that subclasses can reimplement it
-            job->ui()->setAutoErrorHandlingEnabled(false);
+            job->uiDelegate()->setAutoErrorHandlingEnabled(false);
             QObject::connect(job, SIGNAL(result(KJob*)), q, SLOT(slotResult(KJob*)));
         }
     } else {
         q->createDirectory(); // ask again for the name
     }
     _k_slotAbortDialog();
 }
 
 void KNewFileMenuPrivate::_k_slotCreateHiddenDirectory()
 {
     _k_slotCreateDirectory(true);
 }
 
 struct EntryWithName {
     QString key;
     KNewFileMenuSingleton::Entry entry;
 };
 
 void KNewFileMenuPrivate::_k_slotFillTemplates()
 {
     KNewFileMenuSingleton *s = kNewMenuGlobals();
     //qDebug();
 
     QStringList dirs = { QStringLiteral(":/kio5/newfile-templates") };
     dirs += QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("templates"), QStandardPaths::LocateDirectory);
 
     // Ensure any changes in the templates dir will call this
     if (! s->dirWatch) {
         s->dirWatch = new KDirWatch;
         for (QStringList::const_iterator it = dirs.constBegin(); it != dirs.constEnd(); ++it) {
             //qDebug() << "Templates resource dir:" << *it;
             s->dirWatch->addDir(*it);
         }
         QObject::connect(s->dirWatch, SIGNAL(dirty(QString)),
                          q, SLOT(_k_slotFillTemplates()));
         QObject::connect(s->dirWatch, SIGNAL(created(QString)),
                          q, SLOT(_k_slotFillTemplates()));
         QObject::connect(s->dirWatch, SIGNAL(deleted(QString)),
                          q, SLOT(_k_slotFillTemplates()));
         // Ok, this doesn't cope with new dirs in XDG_DATA_DIRS, but that's another story
     }
     ++s->templatesVersion;
     s->filesParsed = false;
 
     s->templatesList->clear();
 
     // Look into "templates" dirs.
     QStringList files;
     QDir dir;
 
     Q_FOREACH (const QString &path, dirs) {
         dir.setPath(path);
         const QStringList &entryList(dir.entryList(QStringList() << QStringLiteral("*.desktop"), QDir::Files));
         Q_FOREACH (const QString &entry, entryList) {
             const QString file = dir.path() + QLatin1Char('/') + entry;
             files.append(file);
         }
     }
 
     QMap<QString, KNewFileMenuSingleton::Entry> slist; // used for sorting
     QMap<QString, EntryWithName> ulist; // entries with unique URLs
     Q_FOREACH (const QString &file, files) {
         //qDebug() << file;
         if (file[0] != '.') {
             KNewFileMenuSingleton::Entry e;
             e.filePath = file;
             e.entryType = KNewFileMenuSingleton::Unknown; // not parsed yet
 
             // Put Directory first in the list (a bit hacky),
             // and TextFile before others because it's the most used one.
             // This also sorts by user-visible name.
             // The rest of the re-ordering is done in fillMenu.
             const KDesktopFile config(file);
             QString url = config.desktopGroup().readEntry("URL");
             QString key = config.desktopGroup().readEntry("Name");
             if (file.endsWith(QLatin1String("Directory.desktop"))) {
                 key.prepend('0');
             } else if (file.endsWith(QLatin1String("TextFile.desktop"))) {
                 key.prepend('1');
             } else {
                 key.prepend('2');
             }
             EntryWithName en = { key, e };
             if (ulist.contains(url)) {
                 ulist.remove(url);
             }
             ulist.insert(url, en);
         }
     }
     QMap<QString, EntryWithName>::iterator it = ulist.begin();
     for (; it != ulist.end(); ++it) {
         EntryWithName ewn = *it;
         slist.insert(ewn.key, ewn.entry);
     }
     (*s->templatesList) += slist.values();
 }
 
 void KNewFileMenuPrivate::_k_slotOtherDesktopFile()
 {
     // The properties dialog took care of the copying, so we're done
     KPropertiesDialog *dialog = qobject_cast<KPropertiesDialog *>(q->sender());
     emit q->fileCreated(dialog->url());
 }
 
 void KNewFileMenuPrivate::_k_slotOtherDesktopFileClosed()
 {
     QFile::remove(m_tempFileToDelete);
 }
 
 void KNewFileMenuPrivate::_k_slotRealFileOrDir()
 {
     m_copyData.m_chosenFileName = m_text;
     _k_slotAbortDialog();
     executeStrategy();
 }
 
 void KNewFileMenuPrivate::_k_slotSymLink()
 {
     KNameAndUrlInputDialog *dlg = static_cast<KNameAndUrlInputDialog *>(m_fileDialog);
 
     m_copyData.m_chosenFileName = dlg->name(); // no path
     const QString linkTarget = dlg->urlText();
 
     if (m_copyData.m_chosenFileName.isEmpty() || linkTarget.isEmpty()) {
         return;
     }
 
     m_copyData.m_src = linkTarget;
     executeStrategy();
 }
 
 void KNewFileMenuPrivate::_k_slotTextChanged(const QString &text)
 {
     m_text = text;
 }
 
 void KNewFileMenuPrivate::_k_slotUrlDesktopFile()
 {
     KNameAndUrlInputDialog *dlg = static_cast<KNameAndUrlInputDialog *>(m_fileDialog);
 
     m_copyData.m_chosenFileName = dlg->name(); // no path
     QUrl linkUrl = dlg->url();
 
     // Filter user input so that short uri entries, e.g. www.kde.org, are
     // handled properly. This not only makes the icon detection below work
     // properly, but opening the URL link where the short uri will not be
     // sent to the application (opening such link Konqueror fails).
     KUriFilterData uriData;
     uriData.setData(linkUrl); // the url to put in the file
     uriData.setCheckForExecutables(false);
 
     if (KUriFilter::self()->filterUri(uriData, QStringList() << QStringLiteral("kshorturifilter"))) {
         linkUrl = uriData.uri();
     }
 
     if (m_copyData.m_chosenFileName.isEmpty() || linkUrl.isEmpty()) {
         return;
     }
 
     // It's a "URL" desktop file; we need to make a temp copy of it, to modify it
     // before copying it to the final destination [which could be a remote protocol]
     QTemporaryFile tmpFile;
     tmpFile.setAutoRemove(false); // done below
     if (!tmpFile.open()) {
         qCritical() << "Couldn't create temp file!";
         return;
     }
 
     if (!checkSourceExists(m_copyData.m_templatePath)) {
         return;
     }
 
     // First copy the template into the temp file
     QFile file(m_copyData.m_templatePath);
     if (!file.open(QIODevice::ReadOnly)) {
         qCritical() << "Couldn't open template" << m_copyData.m_templatePath;
         return;
     }
     const QByteArray data = file.readAll();
     tmpFile.write(data);
     const QString tempFileName = tmpFile.fileName();
     Q_ASSERT(!tempFileName.isEmpty());
     tmpFile.close();
     file.close();
 
     KDesktopFile df(tempFileName);
     KConfigGroup group = df.desktopGroup();
     group.writeEntry("Icon", KProtocolInfo::icon(linkUrl.scheme()));
     group.writePathEntry("URL", linkUrl.toDisplayString());
     df.sync();
 
     m_copyData.m_src = tempFileName;
     m_copyData.m_tempFileToDelete = tempFileName;
 
     executeStrategy();
 }
 
 KNewFileMenu::KNewFileMenu(KActionCollection *collection, const QString &name, QObject *parent)
     : KActionMenu(QIcon::fromTheme(QStringLiteral("document-new")), i18n("Create New"), parent),
       d(new KNewFileMenuPrivate(this))
 {
     // Don't fill the menu yet
     // We'll do that in checkUpToDate (should be connected to aboutToShow)
     d->m_newMenuGroup = new QActionGroup(this);
     connect(d->m_newMenuGroup, SIGNAL(triggered(QAction*)), this, SLOT(_k_slotActionTriggered(QAction*)));
     d->m_actionCollection = collection;
     d->m_parentWidget = qobject_cast<QWidget *>(parent);
     d->m_newDirAction = nullptr;
 
     if (d->m_actionCollection) {
         d->m_actionCollection->addAction(name, this);
     }
 
     d->m_menuDev = new KActionMenu(QIcon::fromTheme(QStringLiteral("drive-removable-media")), i18n("Link to Device"), this);
 }
 
 KNewFileMenu::~KNewFileMenu()
 {
     //qDebug() << this;
     delete d;
 }
 
 void KNewFileMenu::checkUpToDate()
 {
     KNewFileMenuSingleton *s = kNewMenuGlobals();
     //qDebug() << this << "m_menuItemsVersion=" << d->m_menuItemsVersion
     //              << "s->templatesVersion=" << s->templatesVersion;
     if (d->m_menuItemsVersion < s->templatesVersion || s->templatesVersion == 0) {
         //qDebug() << "recreating actions";
         // We need to clean up the action collection
         // We look for our actions using the group
         foreach (QAction *action, d->m_newMenuGroup->actions()) {
             delete action;
         }
 
         if (!s->templatesList) { // No templates list up to now
             s->templatesList = new KNewFileMenuSingleton::EntryList;
             d->_k_slotFillTemplates();
             s->parseFiles();
         }
 
         // This might have been already done for other popupmenus,
         // that's the point in s->filesParsed.
         if (!s->filesParsed) {
             s->parseFiles();
         }
 
         d->fillMenu();
 
         d->m_menuItemsVersion = s->templatesVersion;
     }
 }
 
 void KNewFileMenu::createDirectory()
 {
     if (d->m_popupFiles.isEmpty()) {
         return;
     }
 
     QUrl baseUrl = d->m_popupFiles.first();
 
     KIO::StatJob *job = KIO::mostLocalUrl(baseUrl);
 
     if (job->exec()) {
         baseUrl = job->mostLocalUrl();
     }
 
     QString name = d->m_text.isEmpty() ? i18nc("Default name for a new folder", "New Folder") :
                    d->m_text;
 
     if (baseUrl.isLocalFile() && QFileInfo(baseUrl.toLocalFile() + '/' + name).exists()) {
         name = KIO::suggestName(baseUrl, name);
     }
 
     QDialog *fileDialog = new QDialog(d->m_parentWidget);
     fileDialog->setModal(isModal());
     fileDialog->setAttribute(Qt::WA_DeleteOnClose);
     fileDialog->setWindowTitle(i18nc("@title:window", "New Folder"));
 
     QVBoxLayout *layout = new QVBoxLayout;
     QLabel *label = new QLabel(i18n("Create new folder in:\n%1", baseUrl.toDisplayString(QUrl::PreferLocalFile)), fileDialog);
 
     QLineEdit *lineEdit = new QLineEdit(fileDialog);
     lineEdit->setClearButtonEnabled(true);
     lineEdit->setText(name);
 
     d->_k_slotTextChanged(name); // have to save string in d->m_text in case user does not touch dialog
     connect(lineEdit, SIGNAL(textChanged(QString)), this, SLOT(_k_slotTextChanged(QString)));
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(fileDialog);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     QObject::connect(buttonBox, SIGNAL(accepted()), fileDialog, SLOT(accept()));
     QObject::connect(buttonBox, SIGNAL(rejected()), fileDialog, SLOT(reject()));
 
     layout->addWidget(label);
     layout->addWidget(lineEdit);
     layout->addWidget(buttonBox);
 
     fileDialog->setLayout(layout);
     connect(fileDialog, SIGNAL(accepted()), this, SLOT(_k_slotCreateDirectory()));
     connect(fileDialog, SIGNAL(rejected()), this, SLOT(_k_slotAbortDialog()));
 
     d->m_fileDialog = fileDialog;
 
     fileDialog->show();
     lineEdit->selectAll();
     lineEdit->setFocus();
 }
 
 bool KNewFileMenu::isModal() const
 {
     return d->m_modal;
 }
 
 QList<QUrl> KNewFileMenu::popupFiles() const
 {
     return d->m_popupFiles;
 }
 
 void KNewFileMenu::setModal(bool modal)
 {
     d->m_modal = modal;
 }
 
 void KNewFileMenu::setPopupFiles(const QList<QUrl> &files)
 {
     d->m_popupFiles = files;
     if (files.isEmpty()) {
         d->m_newMenuGroup->setEnabled(false);
     } else {
         QUrl firstUrl = files.first();
         if (KProtocolManager::supportsWriting(firstUrl)) {
             d->m_newMenuGroup->setEnabled(true);
             if (d->m_newDirAction) {
                 d->m_newDirAction->setEnabled(KProtocolManager::supportsMakeDir(firstUrl)); // e.g. trash:/
             }
         } else {
             d->m_newMenuGroup->setEnabled(true);
         }
     }
 }
 
 void KNewFileMenu::setParentWidget(QWidget *parentWidget)
 {
     d->m_parentWidget = parentWidget;
 }
 
 void KNewFileMenu::setSupportedMimeTypes(const QStringList &mime)
 {
     d->m_supportedMimeTypes = mime;
 }
 
 void KNewFileMenu::setViewShowsHiddenFiles(bool b)
 {
     d->m_viewShowsHiddenFiles = b;
 }
 
 void KNewFileMenu::slotResult(KJob *job)
 {
     if (job->error()) {
-        static_cast<KIO::Job *>(job)->ui()->showErrorMessage();
+        static_cast<KIO::Job *>(job)->uiDelegate()->showErrorMessage();
     } else {
         // Was this a copy or a mkdir?
         KIO::CopyJob *copyJob = ::qobject_cast<KIO::CopyJob *>(job);
         if (copyJob) {
             const QUrl destUrl = copyJob->destUrl();
             const QUrl localUrl = d->mostLocalUrl(destUrl);
             if (localUrl.isLocalFile()) {
                 // Normal (local) file. Need to "touch" it, kio_file copied the mtime.
                 (void) ::utime(QFile::encodeName(localUrl.toLocalFile()).constData(), nullptr);
             }
             emit fileCreated(destUrl);
         } else if (KIO::SimpleJob *simpleJob = ::qobject_cast<KIO::SimpleJob *>(job)) {
             // Called in the storedPut() case
             emit fileCreated(simpleJob->url());
         }  else {
             // Can be mkdir
             QUrl mkpathUrl = job->property("mkpathUrl").toUrl();
             if (mkpathUrl.isValid()) {
                 emit directoryCreated(mkpathUrl);
             } else {
                 qWarning() << "Neither copy, put nor mkdir, internal error";
             }
         }
     }
     if (!d->m_tempFileToDelete.isEmpty()) {
         QFile::remove(d->m_tempFileToDelete);
     }
 }
 
 QStringList KNewFileMenu::supportedMimeTypes() const
 {
     return d->m_supportedMimeTypes;
 }
 
 #include "moc_knewfilemenu.cpp"
 
diff --git a/src/widgets/fileundomanager.cpp b/src/widgets/fileundomanager.cpp
index 6470e138..5e9b1a24 100644
--- a/src/widgets/fileundomanager.cpp
+++ b/src/widgets/fileundomanager.cpp
@@ -1,752 +1,752 @@
 /* This file is part of the KDE project
    Copyright (C) 2000 Simon Hausmann <hausmann@kde.org>
    Copyright (C) 2006, 2008 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) 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 "fileundomanager.h"
 #include "fileundomanager_p.h"
 #include "clipboardupdater_p.h"
 #include "fileundomanager_adaptor.h"
 
 #include <kdirnotify.h>
 #include <kio/copyjob.h>
 #include <kio/job.h>
 #include <kio/mkdirjob.h>
 #include <kio/mkpathjob.h>
 #include <kjobwidgets.h>
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 #include <kjobtrackerinterface.h>
 #include <kio/jobuidelegate.h>
 
 #include <QDateTime>
 #include <QDBusConnection>
 
 #include <assert.h>
 
 using namespace KIO;
 
 #if 0
 static const char *undoStateToString(UndoState state)
 {
     static const char *const s_undoStateToString[] = { "MAKINGDIRS", "MOVINGFILES", "STATINGFILE", "REMOVINGDIRS", "REMOVINGLINKS" };
     return s_undoStateToString[state];
 }
 #endif
 
 static QDataStream &operator<<(QDataStream &stream, const KIO::BasicOperation &op)
 {
     stream << op.m_valid << (qint8)op.m_type << op.m_renamed
            << op.m_src << op.m_dst << op.m_target << qint64(op.m_mtime.toMSecsSinceEpoch() / 1000);
     return stream;
 }
 static QDataStream &operator>>(QDataStream &stream, BasicOperation &op)
 {
     qint8 type;
     qint64 mtime;
     stream >> op.m_valid >> type >> op.m_renamed
            >> op.m_src >> op.m_dst >> op.m_target >> mtime;
     op.m_type = static_cast<BasicOperation::Type>(type);
     op.m_mtime = QDateTime::fromMSecsSinceEpoch(1000 * mtime);
     return stream;
 }
 
 static QDataStream &operator<<(QDataStream &stream, const UndoCommand &cmd)
 {
     stream << cmd.m_valid << (qint8)cmd.m_type << cmd.m_opStack << cmd.m_src << cmd.m_dst;
     return stream;
 }
 
 static QDataStream &operator>>(QDataStream &stream, UndoCommand &cmd)
 {
     qint8 type;
     stream >> cmd.m_valid >> type >> cmd.m_opStack >> cmd.m_src >> cmd.m_dst;
     cmd.m_type = static_cast<FileUndoManager::CommandType>(type);
     return stream;
 }
 
 /**
  * checklist:
  * copy dir -> overwrite -> works
  * move dir -> overwrite -> works
  * copy dir -> rename -> works
  * move dir -> rename -> works
  *
  * copy dir -> works
  * move dir -> works
  *
  * copy files -> works
  * move files -> works (TODO: optimize (change FileCopyJob to use the renamed arg for copyingDone)
  *
  * copy files -> overwrite -> works (sorry for your overwritten file...)
  * move files -> overwrite -> works (sorry for your overwritten file...)
  *
  * copy files -> rename -> works
  * move files -> rename -> works
  *
  * -> see also fileundomanagertest, which tests some of the above (but not renaming).
  *
  */
 
 class KIO::UndoJob : public KIO::Job
 {
     Q_OBJECT
 public:
     UndoJob(bool showProgressInfo) : KIO::Job()
     {
         if (showProgressInfo) {
             KIO::getJobTracker()->registerJob(this);
         }
     }
     virtual ~UndoJob() {}
 
     virtual void kill(bool)
     {
         FileUndoManager::self()->d->stopUndo(true);
         KIO::Job::doKill();
     }
 
     void emitCreatingDir(const QUrl &dir)
     {
         emit description(this, i18n("Creating directory"),
                          qMakePair(i18n("Directory"), dir.toDisplayString()));
     }
     void emitMoving(const QUrl &src, const QUrl &dest)
     {
         emit description(this, i18n("Moving"),
                          qMakePair(i18nc("The source of a file operation", "Source"), src.toDisplayString()),
                          qMakePair(i18nc("The destination of a file operation", "Destination"), dest.toDisplayString()));
     }
     void emitDeleting(const QUrl &url)
     {
         emit description(this, i18n("Deleting"),
                          qMakePair(i18n("File"), url.toDisplayString()));
     }
     void emitResult()
     {
         KIO::Job::emitResult();
     }
 };
 
 CommandRecorder::CommandRecorder(FileUndoManager::CommandType op, const QList<QUrl> &src, const QUrl &dst, KIO::Job *job)
     : QObject(job)
 {
     m_cmd.m_type = op;
     m_cmd.m_valid = true;
     m_cmd.m_serialNumber = FileUndoManager::self()->newCommandSerialNumber();
     m_cmd.m_src = src;
     m_cmd.m_dst = dst;
     connect(job, SIGNAL(result(KJob*)),
             this, SLOT(slotResult(KJob*)));
 
     if (qobject_cast<KIO::CopyJob *>(job)) {
         connect(job, SIGNAL(copyingDone(KIO::Job*,QUrl,QUrl,QDateTime,bool,bool)),
                 this, SLOT(slotCopyingDone(KIO::Job*,QUrl,QUrl,QDateTime,bool,bool)));
         connect(job, SIGNAL(copyingLinkDone(KIO::Job*,QUrl,QString,QUrl)),
                 this, SLOT(slotCopyingLinkDone(KIO::Job*,QUrl,QString,QUrl)));
     } else if (KIO::MkpathJob *mkpathJob = qobject_cast<KIO::MkpathJob *>(job)) {
         connect(mkpathJob, &KIO::MkpathJob::directoryCreated,
                 this, &CommandRecorder::slotDirectoryCreated);
     }
 }
 
 CommandRecorder::~CommandRecorder()
 {
 }
 
 void CommandRecorder::slotResult(KJob *job)
 {
     if (job->error()) {
         return;
     }
 
     FileUndoManager::self()->d->addCommand(m_cmd);
 }
 
 void CommandRecorder::slotCopyingDone(KIO::Job *, const QUrl &from, const QUrl &to, const QDateTime &mtime, bool directory, bool renamed)
 {
     BasicOperation op;
     op.m_valid = true;
     op.m_type = directory ? BasicOperation::Directory : BasicOperation::File;
     op.m_renamed = renamed;
     op.m_src = from;
     op.m_dst = to;
     op.m_mtime = mtime;
     m_cmd.m_opStack.prepend(op);
 }
 
 // TODO merge the signals?
 void CommandRecorder::slotCopyingLinkDone(KIO::Job *, const QUrl &from, const QString &target, const QUrl &to)
 {
     BasicOperation op;
     op.m_valid = true;
     op.m_type = BasicOperation::Link;
     op.m_renamed = false;
     op.m_src = from;
     op.m_target = target;
     op.m_dst = to;
     op.m_mtime = QDateTime();
     m_cmd.m_opStack.prepend(op);
 }
 
 void CommandRecorder::slotDirectoryCreated(const QUrl &dir)
 {
     BasicOperation op;
     op.m_valid = true;
     op.m_type = BasicOperation::Directory;
     op.m_renamed = false;
     op.m_src = QUrl();
     op.m_dst = dir;
     op.m_mtime = QDateTime();
     m_cmd.m_opStack.prepend(op);
 }
 
 ////
 
 class KIO::FileUndoManagerSingleton
 {
 public:
     FileUndoManager self;
 };
 Q_GLOBAL_STATIC(KIO::FileUndoManagerSingleton, globalFileUndoManager)
 
 FileUndoManager *FileUndoManager::self()
 {
     return &globalFileUndoManager()->self;
 }
 
 // m_nextCommandIndex is initialized to a high number so that konqueror can
 // assign low numbers to closed items loaded "on-demand" from a config file
 // in KonqClosedWindowsManager::readConfig and thus maintaining the real
 // order of the undo items.
 FileUndoManagerPrivate::FileUndoManagerPrivate(FileUndoManager *qq)
     : m_uiInterface(new FileUndoManager::UiInterface()),
       m_undoJob(nullptr), m_nextCommandIndex(1000), q(qq)
 {
     (void) new KIOFileUndoManagerAdaptor(this);
     const QString dbusPath = QStringLiteral("/FileUndoManager");
     const QString dbusInterface = QStringLiteral("org.kde.kio.FileUndoManager");
 
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(dbusPath, this);
     dbus.connect(QString(), dbusPath, dbusInterface, QStringLiteral("lock"), this, SLOT(slotLock()));
     dbus.connect(QString(), dbusPath, dbusInterface, QStringLiteral("pop"), this, SLOT(slotPop()));
     dbus.connect(QString(), dbusPath, dbusInterface, QStringLiteral("push"), this, SLOT(slotPush(QByteArray)));
     dbus.connect(QString(), dbusPath, dbusInterface, QStringLiteral("unlock"), this, SLOT(slotUnlock()));
 }
 
 FileUndoManager::FileUndoManager()
 {
     d = new FileUndoManagerPrivate(this);
     d->m_lock = false;
     d->m_currentJob = nullptr;
 }
 
 FileUndoManager::~FileUndoManager()
 {
     delete d;
 }
 
 void FileUndoManager::recordJob(CommandType op, const QList<QUrl> &src, const QUrl &dst, KIO::Job *job)
 {
     // This records what the job does and calls addCommand when done
     (void) new CommandRecorder(op, src, dst, job);
     emit jobRecordingStarted(op);
 }
 
 void FileUndoManager::recordCopyJob(KIO::CopyJob *copyJob)
 {
     CommandType commandType;
     switch (copyJob->operationMode()) {
     case CopyJob::Copy:
         commandType = Copy;
         break;
     case CopyJob::Move:
         commandType = Move;
         break;
     case CopyJob::Link:
     default: // prevent "wrong" compiler warning because of possibly uninitialized variable
         commandType = Link;
         break;
     }
     recordJob(commandType, copyJob->srcUrls(), copyJob->destUrl(), copyJob);
 }
 
 void FileUndoManagerPrivate::addCommand(const UndoCommand &cmd)
 {
     pushCommand(cmd);
     emit q->jobRecordingFinished(cmd.m_type);
 }
 
 bool FileUndoManager::undoAvailable() const
 {
     return (d->m_commands.count() > 0) && !d->m_lock;
 }
 
 QString FileUndoManager::undoText() const
 {
     if (d->m_commands.isEmpty()) {
         return i18n("Und&o");
     }
 
     FileUndoManager::CommandType t = d->m_commands.last().m_type;
     switch (t) {
     case FileUndoManager::Copy:
         return i18n("Und&o: Copy");
     case FileUndoManager::Link:
         return i18n("Und&o: Link");
     case FileUndoManager::Move:
         return i18n("Und&o: Move");
     case FileUndoManager::Rename:
         return i18n("Und&o: Rename");
     case FileUndoManager::Trash:
         return i18n("Und&o: Trash");
     case FileUndoManager::Mkdir:
         return i18n("Und&o: Create Folder");
     case FileUndoManager::Mkpath:
         return i18n("Und&o: Create Folder(s)");
     case FileUndoManager::Put:
         return i18n("Und&o: Create File");
     }
     /* NOTREACHED */
     return QString();
 }
 
 quint64 FileUndoManager::newCommandSerialNumber()
 {
     return ++(d->m_nextCommandIndex);
 }
 
 quint64 FileUndoManager::currentCommandSerialNumber() const
 {
     if (!d->m_commands.isEmpty()) {
         const UndoCommand &cmd = d->m_commands.last();
         assert(cmd.m_valid);
         return cmd.m_serialNumber;
     } else {
         return 0;
     }
 }
 
 void FileUndoManager::undo()
 {
     // Make a copy of the command to undo before slotPop() pops it.
     UndoCommand cmd = d->m_commands.last();
     assert(cmd.m_valid);
     d->m_current = cmd;
     const CommandType commandType = cmd.m_type;
 
     BasicOperation::Stack &opStack = d->m_current.m_opStack;
     // Note that opStack is empty for simple operations like Mkdir.
 
     // Let's first ask for confirmation if we need to delete any file (#99898)
     QList<QUrl> itemsToDelete;
     BasicOperation::Stack::Iterator it = opStack.begin();
     for (; it != opStack.end(); ++it) {
         BasicOperation::Type type = (*it).m_type;
         if (type == BasicOperation::File && commandType == FileUndoManager::Copy) {
             itemsToDelete.append((*it).m_dst);
         } else if (commandType == FileUndoManager::Mkpath) {
             itemsToDelete.append((*it).m_dst);
         }
     }
     if (commandType == FileUndoManager::Mkdir || commandType == FileUndoManager::Put) {
         itemsToDelete.append(d->m_current.m_dst);
     }
     if (!itemsToDelete.isEmpty()) {
         if (!d->m_uiInterface->confirmDeletion(itemsToDelete)) {
             return;
         }
     }
 
     d->slotPop();
     d->slotLock();
 
     d->m_dirCleanupStack.clear();
     d->m_dirStack.clear();
     d->m_dirsToUpdate.clear();
 
     d->m_undoState = MOVINGFILES;
 
     // Let's have a look at the basic operations we need to undo.
     // While we're at it, collect all links that should be deleted.
 
     it = opStack.begin();
     while (it != opStack.end()) { // don't cache end() here, erase modifies it
         bool removeBasicOperation = false;
         BasicOperation::Type type = (*it).m_type;
         if (type == BasicOperation::Directory && !(*it).m_renamed) {
             // If any directory has to be created/deleted, we'll start with that
             d->m_undoState = MAKINGDIRS;
             // Collect all the dirs that have to be created in case of a move undo.
             if (d->m_current.isMoveCommand()) {
                 d->m_dirStack.push((*it).m_src);
             }
             // Collect all dirs that have to be deleted
             // from the destination in both cases (copy and move).
             d->m_dirCleanupStack.prepend((*it).m_dst);
             removeBasicOperation = true;
         } else if (type == BasicOperation::Link) {
             d->m_fileCleanupStack.prepend((*it).m_dst);
 
             removeBasicOperation = !d->m_current.isMoveCommand();
         }
 
         if (removeBasicOperation) {
             it = opStack.erase(it);
         } else {
             ++it;
         }
     }
 
     if (commandType == FileUndoManager::Put) {
         d->m_fileCleanupStack.append(d->m_current.m_dst);
     }
 
     //qDebug() << "starting with" << undoStateToString(d->m_undoState);
     d->m_undoJob = new UndoJob(d->m_uiInterface->showProgressInfo());
     QMetaObject::invokeMethod(d, "undoStep", Qt::QueuedConnection);
 }
 
 void FileUndoManagerPrivate::stopUndo(bool step)
 {
     m_current.m_opStack.clear();
     m_dirCleanupStack.clear();
     m_fileCleanupStack.clear();
     m_undoState = REMOVINGDIRS;
     m_undoJob = nullptr;
 
     if (m_currentJob) {
         m_currentJob->kill();
     }
 
     m_currentJob = nullptr;
 
     if (step) {
         undoStep();
     }
 }
 
 void FileUndoManagerPrivate::slotResult(KJob *job)
 {
     m_currentJob = nullptr;
     if (job->error()) {
         m_uiInterface->jobError(static_cast<KIO::Job *>(job));
         delete m_undoJob;
         stopUndo(false);
     } else if (m_undoState == STATINGFILE) {
         BasicOperation op = m_current.m_opStack.last();
         //qDebug() << "stat result for " << op.m_dst;
         KIO::StatJob *statJob = static_cast<KIO::StatJob *>(job);
         const QDateTime mtime = QDateTime::fromMSecsSinceEpoch(1000 * statJob->statResult().numberValue(KIO::UDSEntry::UDS_MODIFICATION_TIME, -1));
         if (mtime != op.m_mtime) {
             //qDebug() << op.m_dst << " was modified after being copied!";
             QDateTime srcTime = op.m_mtime.toLocalTime();
             QDateTime destTime = mtime.toLocalTime();
             if (!m_uiInterface->copiedFileWasModified(op.m_src, op.m_dst, srcTime, destTime)) {
                 stopUndo(false);
             }
         }
     }
 
     undoStep();
 }
 
 void FileUndoManagerPrivate::addDirToUpdate(const QUrl &url)
 {
     if (!m_dirsToUpdate.contains(url)) {
         m_dirsToUpdate.prepend(url);
     }
 }
 
 void FileUndoManagerPrivate::undoStep()
 {
     m_currentJob = nullptr;
 
     if (m_undoState == MAKINGDIRS) {
         stepMakingDirectories();
     }
 
     if (m_undoState == MOVINGFILES || m_undoState == STATINGFILE) {
         stepMovingFiles();
     }
 
     if (m_undoState == REMOVINGLINKS) {
         stepRemovingLinks();
     }
 
     if (m_undoState == REMOVINGDIRS) {
         stepRemovingDirectories();
     }
 
     if (m_currentJob) {
         if (m_uiInterface) {
             KJobWidgets::setWindow(m_currentJob, m_uiInterface->parentWidget());
         }
         QObject::connect(m_currentJob, SIGNAL(result(KJob*)),
                          this, SLOT(slotResult(KJob*)));
     }
 }
 
 void FileUndoManagerPrivate::stepMakingDirectories()
 {
     if (!m_dirStack.isEmpty()) {
         QUrl dir = m_dirStack.pop();
         //qDebug() << "creatingDir" << dir;
         m_currentJob = KIO::mkdir(dir);
         m_undoJob->emitCreatingDir(dir);
     } else {
         m_undoState = MOVINGFILES;
     }
 }
 
 // Misnamed method: It moves files back, but it also
 // renames directories back, recreates symlinks,
 // deletes copied files, and restores trashed files.
 void FileUndoManagerPrivate::stepMovingFiles()
 {
     if (!m_current.m_opStack.isEmpty()) {
         BasicOperation op = m_current.m_opStack.last();
         BasicOperation::Type type = op.m_type;
 
         assert(op.m_valid);
         if (type == BasicOperation::Directory) {
             if (op.m_renamed) {
                 //qDebug() << "rename" << op.m_dst << op.m_src;
                 m_currentJob = KIO::rename(op.m_dst, op.m_src, KIO::HideProgressInfo);
                 m_undoJob->emitMoving(op.m_dst, op.m_src);
             } else {
                 assert(0);    // this should not happen!
             }
         } else if (type == BasicOperation::Link) {
             //qDebug() << "symlink" << op.m_target << op.m_src;
             m_currentJob = KIO::symlink(op.m_target, op.m_src, KIO::Overwrite | KIO::HideProgressInfo);
         } else if (m_current.m_type == FileUndoManager::Copy) {
             if (m_undoState == MOVINGFILES) { // dest not stat'ed yet
                 // Before we delete op.m_dst, let's check if it was modified (#20532)
                 //qDebug() << "stat" << op.m_dst;
                 m_currentJob = KIO::stat(op.m_dst, KIO::HideProgressInfo);
                 m_undoState = STATINGFILE; // temporarily
                 return; // no pop() yet, we'll finish the work in slotResult
             } else { // dest was stat'ed, and the deletion was approved in slotResult
                 m_currentJob = KIO::file_delete(op.m_dst, KIO::HideProgressInfo);
                 m_undoJob->emitDeleting(op.m_dst);
                 m_undoState = MOVINGFILES;
             }
         } else if (m_current.isMoveCommand()
                    || m_current.m_type == FileUndoManager::Trash) {
             //qDebug() << "file_move" << op.m_dst << op.m_src;
             m_currentJob = KIO::file_move(op.m_dst, op.m_src, -1, KIO::Overwrite | KIO::HideProgressInfo);
             m_currentJob->uiDelegateExtension()->createClipboardUpdater(m_currentJob, JobUiDelegateExtension::UpdateContent);
             m_undoJob->emitMoving(op.m_dst, op.m_src);
         }
 
         m_current.m_opStack.removeLast();
         // The above KIO jobs are lowlevel, they don't trigger KDirNotify notification
         // So we need to do it ourselves (but schedule it to the end of the undo, to compress them)
         QUrl url = op.m_dst.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
         addDirToUpdate(url);
 
         url = op.m_src.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
         addDirToUpdate(url);
     } else {
         m_undoState = REMOVINGLINKS;
     }
 }
 
 void FileUndoManagerPrivate::stepRemovingLinks()
 {
     //qDebug() << "REMOVINGLINKS";
     if (!m_fileCleanupStack.isEmpty()) {
         QUrl file = m_fileCleanupStack.pop();
         //qDebug() << "file_delete" << file;
         m_currentJob = KIO::file_delete(file, KIO::HideProgressInfo);
         m_undoJob->emitDeleting(file);
 
         QUrl url = file.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
         addDirToUpdate(url);
     } else {
         m_undoState = REMOVINGDIRS;
 
         if (m_dirCleanupStack.isEmpty() && m_current.m_type == FileUndoManager::Mkdir) {
             m_dirCleanupStack << m_current.m_dst;
         }
     }
 }
 
 void FileUndoManagerPrivate::stepRemovingDirectories()
 {
     if (!m_dirCleanupStack.isEmpty()) {
         QUrl dir = m_dirCleanupStack.pop();
         //qDebug() << "rmdir" << dir;
         m_currentJob = KIO::rmdir(dir);
         m_undoJob->emitDeleting(dir);
         addDirToUpdate(dir);
     } else {
         m_current.m_valid = false;
         m_currentJob = nullptr;
         if (m_undoJob) {
             //qDebug() << "deleting undojob";
             m_undoJob->emitResult();
             m_undoJob = nullptr;
         }
         QList<QUrl>::ConstIterator it = m_dirsToUpdate.constBegin();
         for (; it != m_dirsToUpdate.constEnd(); ++it) {
             //qDebug() << "Notifying FilesAdded for " << *it;
             org::kde::KDirNotify::emitFilesAdded((*it));
         }
         emit q->undoJobFinished();
         slotUnlock();
     }
 }
 
 // const ref doesn't work due to QDataStream
 void FileUndoManagerPrivate::slotPush(QByteArray data)
 {
     QDataStream strm(&data, QIODevice::ReadOnly);
     UndoCommand cmd;
     strm >> cmd;
     pushCommand(cmd);
 }
 
 void FileUndoManagerPrivate::pushCommand(const UndoCommand &cmd)
 {
     m_commands.append(cmd);
     emit q->undoAvailable(true);
     emit q->undoTextChanged(q->undoText());
 }
 
 void FileUndoManagerPrivate::slotPop()
 {
     m_commands.removeLast();
     emit q->undoAvailable(q->undoAvailable());
     emit q->undoTextChanged(q->undoText());
 }
 
 void FileUndoManagerPrivate::slotLock()
 {
 //  assert(!m_lock);
     m_lock = true;
     emit q->undoAvailable(q->undoAvailable());
 }
 
 void FileUndoManagerPrivate::slotUnlock()
 {
 //  assert(m_lock);
     m_lock = false;
     emit q->undoAvailable(q->undoAvailable());
 }
 
 QByteArray FileUndoManagerPrivate::get() const
 {
     QByteArray data;
     QDataStream stream(&data, QIODevice::WriteOnly);
     stream << m_commands;
     return data;
 }
 
 void FileUndoManager::setUiInterface(UiInterface *ui)
 {
     delete d->m_uiInterface;
     d->m_uiInterface = ui;
 }
 
 FileUndoManager::UiInterface *FileUndoManager::uiInterface() const
 {
     return d->m_uiInterface;
 }
 
 ////
 
 class FileUndoManager::UiInterface::UiInterfacePrivate
 {
 public:
     UiInterfacePrivate()
         : m_parentWidget(nullptr), m_showProgressInfo(true)
     {}
     QWidget *m_parentWidget;
     bool m_showProgressInfo;
 };
 
 FileUndoManager::UiInterface::UiInterface()
     : d(new UiInterfacePrivate)
 {
 }
 
 FileUndoManager::UiInterface::~UiInterface()
 {
     delete d;
 }
 
 void FileUndoManager::UiInterface::jobError(KIO::Job *job)
 {
-    job->ui()->showErrorMessage();
+    job->uiDelegate()->showErrorMessage();
 }
 
 bool FileUndoManager::UiInterface::copiedFileWasModified(const QUrl &src, const QUrl &dest, const QDateTime &srcTime, const QDateTime &destTime)
 {
     Q_UNUSED(srcTime); // not sure it should appear in the msgbox
     // Possible improvement: only show the time if date is today
     const QString timeStr = destTime.toString(Qt::DefaultLocaleShortDate);
     return KMessageBox::warningContinueCancel(
                d->m_parentWidget,
                i18n("The file %1 was copied from %2, but since then it has apparently been modified at %3.\n"
                     "Undoing the copy will delete the file, and all modifications will be lost.\n"
                     "Are you sure you want to delete %4?", dest.toDisplayString(QUrl::PreferLocalFile), src.toDisplayString(QUrl::PreferLocalFile), timeStr, dest.toDisplayString(QUrl::PreferLocalFile)),
                i18n("Undo File Copy Confirmation"),
                KStandardGuiItem::cont(),
                KStandardGuiItem::cancel(),
                QString(),
                KMessageBox::Options(KMessageBox::Notify) | KMessageBox::Dangerous) == KMessageBox::Continue;
 }
 
 bool FileUndoManager::UiInterface::confirmDeletion(const QList<QUrl> &files)
 {
     KIO::JobUiDelegate uiDelegate;
     uiDelegate.setWindow(d->m_parentWidget);
     // Because undo can happen with an accidental Ctrl-Z, we want to always confirm.
     return uiDelegate.askDeleteConfirmation(files, KIO::JobUiDelegate::Delete, KIO::JobUiDelegate::ForceConfirmation);
 }
 
 QWidget *FileUndoManager::UiInterface::parentWidget() const
 {
     return d->m_parentWidget;
 }
 
 void FileUndoManager::UiInterface::setParentWidget(QWidget *parentWidget)
 {
     d->m_parentWidget = parentWidget;
 }
 
 void FileUndoManager::UiInterface::setShowProgressInfo(bool b)
 {
     d->m_showProgressInfo = b;
 }
 
 bool FileUndoManager::UiInterface::showProgressInfo() const
 {
     return d->m_showProgressInfo;
 }
 
 void FileUndoManager::UiInterface::virtual_hook(int, void *)
 {
 }
 
 #include "moc_fileundomanager_p.cpp"
 #include "moc_fileundomanager.cpp"
 #include "fileundomanager.moc"
diff --git a/src/widgets/kdirlister.cpp b/src/widgets/kdirlister.cpp
index ace16928..cc8f4318 100644
--- a/src/widgets/kdirlister.cpp
+++ b/src/widgets/kdirlister.cpp
@@ -1,103 +1,103 @@
 /* This file is part of the KDE project
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
                  2000 Carsten Pfeiffer <pfeiffer@kde.org>
                  2003-2005 David Faure <faure@kde.org>
                  2001-2006 Michael Brade <brade@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 "kdirlister.h"
 #include <kio/listjob.h>
 #include <kjobwidgets.h>
 #include <kjobuidelegate.h>
 
 #include <kmessagebox.h>
 #include <QWidget>
 
 class KDirLister::Private
 {
 public:
     Private()
         : errorParent(nullptr),
           window(nullptr),
           autoErrorHandling(false)
     {}
 
     QWidget *errorParent;
     QWidget *window; // Main window this lister is associated with
     bool autoErrorHandling;
 
 };
 
 KDirLister::KDirLister(QObject *parent)
     : KCoreDirLister(parent), d(new Private)
 {
     setAutoErrorHandlingEnabled(true, nullptr);
 }
 
 KDirLister::~KDirLister()
 {
     delete d;
 }
 
 bool KDirLister::autoErrorHandlingEnabled() const
 {
     return d->autoErrorHandling;
 }
 
 void KDirLister::setAutoErrorHandlingEnabled(bool enable, QWidget *parent)
 {
     d->autoErrorHandling = enable;
     d->errorParent = parent;
 }
 
 void KDirLister::setMainWindow(QWidget *window)
 {
     d->window = window;
 }
 
 QWidget *KDirLister::mainWindow()
 {
     return d->window;
 }
 
 void KDirLister::handleError(KIO::Job *job)
 {
     if (d->autoErrorHandling) {
-        job->ui()->showErrorMessage();
+        job->uiDelegate()->showErrorMessage();
     } else {
         KCoreDirLister::handleError(job);
     }
 }
 
 void KDirLister::handleErrorMessage(const QString &message)
 {
     if (d->autoErrorHandling) {
         KMessageBox::error(d->errorParent, message);
     } else {
         KCoreDirLister::handleErrorMessage(message);
     }
 }
 
 void KDirLister::jobStarted(KIO::ListJob *job)
 {
     if (d->window) {
         KJobWidgets::setWindow(job, d->window);
     }
 }
 
 #include "moc_kdirlister.cpp"
diff --git a/src/widgets/kdirmodel.cpp b/src/widgets/kdirmodel.cpp
index b5e730d5..b88a1cf7 100644
--- a/src/widgets/kdirmodel.cpp
+++ b/src/widgets/kdirmodel.cpp
@@ -1,1283 +1,1283 @@
 /* This file is part of the KDE project
    Copyright (C) 2006 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) 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 "kdirmodel.h"
 #include "kdirlister.h"
 #include "kfileitem.h"
 #include "kio_widgets_debug.h"
 #include <kiconloader.h>
 #include <klocalizedstring.h>
 #include <kjobuidelegate.h>
 #include <kio/simplejob.h>
 #include <kio/fileundomanager.h>
 #include "joburlcache_p.h"
 #include <kurlmimedata.h>
 #include <kiconloader.h>
 #include <QMimeData>
 #include <QBitArray>
 #include <QDebug>
 #include <QFile>
 #include <QFileInfo>
 #include <QDir>
 #include <QIcon>
 #include <QLocale>
 #include <qplatformdefs.h>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 #endif
 
 class KDirModelNode;
 class KDirModelDirNode;
 
 static QUrl cleanupUrl(const QUrl &url)
 {
     QUrl u = url;
     u.setPath(QDir::cleanPath(u.path())); // remove double slashes in the path, simplify "foo/." to "foo/", etc.
     u = u.adjusted(QUrl::StripTrailingSlash); // KDirLister does this too, so we remove the slash before comparing with the root node url.
     u.setQuery(QString());
     u.setFragment(QString());
     return u;
 }
 
 // We create our own tree behind the scenes to have fast lookup from an item to its parent,
 // and also to get the children of an item fast.
 class KDirModelNode
 {
 public:
     KDirModelNode(KDirModelDirNode *parent, const KFileItem &item) :
         m_item(item),
         m_parent(parent),
         m_preview()
     {
     }
     virtual ~KDirModelNode()
     {
         // Required, code will delete ptrs to this or a subclass.
     }
     // m_item is KFileItem() for the root item
     const KFileItem &item() const
     {
         return m_item;
     }
     void setItem(const KFileItem &item)
     {
         m_item = item;
     }
     KDirModelDirNode *parent() const
     {
         return m_parent;
     }
     // linear search
     int rowNumber() const; // O(n)
     QIcon preview() const
     {
         return m_preview;
     }
     void setPreview(const QPixmap &pix)
     {
         m_preview = QIcon();
         m_preview.addPixmap(pix);
     }
     void setPreview(const QIcon &icn)
     {
         m_preview = icn;
     }
 
 private:
     KFileItem m_item;
     KDirModelDirNode *const m_parent;
     QIcon m_preview;
 };
 
 // Specialization for directory nodes
 class KDirModelDirNode : public KDirModelNode
 {
 public:
     KDirModelDirNode(KDirModelDirNode *parent, const KFileItem &item)
         : KDirModelNode(parent, item),
           m_childNodes(),
           m_childCount(KDirModel::ChildCountUnknown),
           m_populated(false)
     {}
     virtual ~KDirModelDirNode() Q_DECL_OVERRIDE
     {
         qDeleteAll(m_childNodes);
     }
     QList<KDirModelNode *> m_childNodes; // owns the nodes
 
     // If we listed the directory, the child count is known. Otherwise it can be set via setChildCount.
     int childCount() const
     {
         return m_childNodes.isEmpty() ? m_childCount : m_childNodes.count();
     }
     void setChildCount(int count)
     {
         m_childCount = count;
     }
     bool isPopulated() const
     {
         return m_populated;
     }
     void setPopulated(bool populated)
     {
         m_populated = populated;
     }
     bool isSlow() const
     {
         return item().isSlow();
     }
 
     // For removing all child urls from the global hash.
     void collectAllChildUrls(QList<QUrl> &urls) const
     {
         Q_FOREACH (KDirModelNode *node, m_childNodes) {
             const KFileItem &item = node->item();
             urls.append(cleanupUrl(item.url()));
             if (item.isDir()) {
                 static_cast<KDirModelDirNode *>(node)->collectAllChildUrls(urls);
             }
         }
     }
 
 private:
     int m_childCount: 31;
     bool m_populated: 1;
 };
 
 int KDirModelNode::rowNumber() const
 {
     if (!m_parent) {
         return 0;
     }
     return m_parent->m_childNodes.indexOf(const_cast<KDirModelNode *>(this));
 }
 
 ////
 
 class KDirModelPrivate
 {
 public:
     KDirModelPrivate(KDirModel *model)
         : q(model), m_dirLister(nullptr),
           m_rootNode(new KDirModelDirNode(nullptr, KFileItem())),
           m_dropsAllowed(KDirModel::NoDrops), m_jobTransfersVisible(false)
     {
     }
     ~KDirModelPrivate()
     {
         delete m_rootNode;
     }
 
     void _k_slotNewItems(const QUrl &directoryUrl, const KFileItemList &);
     void _k_slotDeleteItems(const KFileItemList &);
     void _k_slotRefreshItems(const QList<QPair<KFileItem, KFileItem> > &);
     void _k_slotClear();
     void _k_slotRedirection(const QUrl &oldUrl, const QUrl &newUrl);
     void _k_slotJobUrlsChanged(const QStringList &urlList);
 
     void clear()
     {
         delete m_rootNode;
         m_rootNode = new KDirModelDirNode(nullptr, KFileItem());
     }
     // Emit expand for each parent and then return the
     // last known parent if there is no node for this url
     KDirModelNode *expandAllParentsUntil(const QUrl &url) const;
 
     // Return the node for a given url, using the hash.
     KDirModelNode *nodeForUrl(const QUrl &url) const;
     KDirModelNode *nodeForIndex(const QModelIndex &index) const;
     QModelIndex indexForNode(KDirModelNode *node, int rowNumber = -1 /*unknown*/) const;
     bool isDir(KDirModelNode *node) const
     {
         return (node == m_rootNode) || node->item().isDir();
     }
     QUrl urlForNode(KDirModelNode *node) const
     {
         /**
          * Queries and fragments are removed from the URL, so that the URL of
          * child items really starts with the URL of the parent.
          *
          * For instance ksvn+http://url?rev=100 is the parent for ksvn+http://url/file?rev=100
          * so we have to remove the query in both to be able to compare the URLs
          */
         QUrl url(node == m_rootNode ? m_dirLister->url() : node->item().url());
         if (url.hasQuery() || url.hasFragment()) { // avoid detach if not necessary.
             url.setQuery(QString());
             url.setFragment(QString()); // kill ref (#171117)
         }
         return url;
     }
     void removeFromNodeHash(KDirModelNode *node, const QUrl &url);
     void clearAllPreviews(KDirModelDirNode *node);
 #ifndef NDEBUG
     void dump();
 #endif
 
     KDirModel *q;
     KDirLister *m_dirLister;
     KDirModelDirNode *m_rootNode;
     KDirModel::DropsAllowed m_dropsAllowed;
     bool m_jobTransfersVisible;
     // key = current known parent node (always a KDirModelDirNode but KDirModelNode is more convenient),
     // value = final url[s] being fetched
     QMap<KDirModelNode *, QList<QUrl> > m_urlsBeingFetched;
     QHash<QUrl, KDirModelNode *> m_nodeHash; // global node hash: url -> node
     QStringList m_allCurrentDestUrls; //list of all dest urls that have jobs on them (e.g. copy, download)
 };
 
 KDirModelNode *KDirModelPrivate::nodeForUrl(const QUrl &_url) const // O(1), well, O(length of url as a string)
 {
     QUrl url = cleanupUrl(_url);
     if (url == urlForNode(m_rootNode)) {
         return m_rootNode;
     }
     return m_nodeHash.value(url);
 }
 
 void KDirModelPrivate::removeFromNodeHash(KDirModelNode *node, const QUrl &url)
 {
     if (node->item().isDir()) {
         QList<QUrl> urls;
         static_cast<KDirModelDirNode *>(node)->collectAllChildUrls(urls);
         Q_FOREACH (const QUrl &u, urls) {
             m_nodeHash.remove(u);
         }
     }
     m_nodeHash.remove(cleanupUrl(url));
 }
 
 KDirModelNode *KDirModelPrivate::expandAllParentsUntil(const QUrl &_url) const // O(depth)
 {
     QUrl url = cleanupUrl(_url);
 
     //qDebug() << url;
     QUrl nodeUrl = urlForNode(m_rootNode);
     if (url == nodeUrl) {
         return m_rootNode;
     }
 
     // Protocol mismatch? Don't even start comparing paths then. #171721
     if (url.scheme() != nodeUrl.scheme()) {
         return nullptr;
     }
 
     const QString pathStr = url.path(); // no trailing slash
     KDirModelDirNode *dirNode = m_rootNode;
 
     if (!pathStr.startsWith(nodeUrl.path())) {
         return nullptr;
     }
 
     for (;;) {
         QString nodePath = nodeUrl.path();
         if (!nodePath.endsWith('/')) {
             nodePath += '/';
         }
         if (!pathStr.startsWith(nodePath)) {
             qCWarning(KIO_WIDGETS) << "The kioslave for" << url.scheme() << "violates the hierarchy structure:"
                        << "I arrived at node" << nodePath << ", but" << pathStr << "does not start with that path.";
             return nullptr;
         }
 
         // E.g. pathStr is /a/b/c and nodePath is /a/. We want to find the node with url /a/b
         const int nextSlash = pathStr.indexOf('/', nodePath.length());
         const QString newPath = pathStr.left(nextSlash); // works even if nextSlash==-1
         nodeUrl.setPath(newPath);
         nodeUrl = nodeUrl.adjusted(QUrl::StripTrailingSlash); // #172508
         KDirModelNode *node = nodeForUrl(nodeUrl);
         if (!node) {
             //qDebug() << "child equal or starting with" << url << "not found";
             // return last parent found:
             return dirNode;
         }
 
         emit q->expand(indexForNode(node));
 
         //qDebug() << " nodeUrl=" << nodeUrl;
         if (nodeUrl == url) {
             //qDebug() << "Found node" << node << "for" << url;
             return node;
         }
         //qDebug() << "going into" << node->item().url();
         Q_ASSERT(isDir(node));
         dirNode = static_cast<KDirModelDirNode *>(node);
     }
     // NOTREACHED
     //return 0;
 }
 
 #ifndef NDEBUG
 void KDirModelPrivate::dump()
 {
     qCDebug(KIO_WIDGETS) << "Dumping contents of KDirModel" << q << "dirLister url:" << m_dirLister->url();
     QHashIterator<QUrl, KDirModelNode *> it(m_nodeHash);
     while (it.hasNext()) {
         it.next();
         qDebug(KIO_WIDGETS) << it.key() << it.value();
     }
 }
 #endif
 
 // node -> index. If rowNumber is set (or node is root): O(1). Otherwise: O(n).
 QModelIndex KDirModelPrivate::indexForNode(KDirModelNode *node, int rowNumber) const
 {
     if (node == m_rootNode) {
         return QModelIndex();
     }
 
     Q_ASSERT(node->parent());
     return q->createIndex(rowNumber == -1 ? node->rowNumber() : rowNumber, 0, node);
 }
 
 // index -> node. O(1)
 KDirModelNode *KDirModelPrivate::nodeForIndex(const QModelIndex &index) const
 {
     return index.isValid()
            ? static_cast<KDirModelNode *>(index.internalPointer())
            : m_rootNode;
 }
 
 /*
  * This model wraps the data held by KDirLister.
  *
  * The internal pointer of the QModelIndex for a given file is the node for that file in our own tree.
  * E.g. index(2,0) returns a QModelIndex with row=2 internalPointer=<KDirModelNode for the 3rd child of the root>
  *
  * Invalid parent index means root of the tree, m_rootNode
  */
 
 #ifndef NDEBUG
 static QString debugIndex(const QModelIndex &index)
 {
     QString str;
     if (!index.isValid()) {
         str = QStringLiteral("[invalid index, i.e. root]");
     } else {
         KDirModelNode *node = static_cast<KDirModelNode *>(index.internalPointer());
         str = "[index for " + node->item().url().toString();
         if (index.column() > 0) {
             str += ", column " + QString::number(index.column());
         }
         str += ']';
     }
     return str;
 }
 #endif
 
 KDirModel::KDirModel(QObject *parent)
     : QAbstractItemModel(parent),
       d(new KDirModelPrivate(this))
 {
     setDirLister(new KDirLister(this));
 }
 
 KDirModel::~KDirModel()
 {
     delete d;
 }
 
 void KDirModel::setDirLister(KDirLister *dirLister)
 {
     if (d->m_dirLister) {
         d->clear();
         delete d->m_dirLister;
     }
     d->m_dirLister = dirLister;
     d->m_dirLister->setParent(this);
     connect(d->m_dirLister, SIGNAL(itemsAdded(QUrl,KFileItemList)),
             this, SLOT(_k_slotNewItems(QUrl,KFileItemList)));
     connect(d->m_dirLister, SIGNAL(itemsDeleted(KFileItemList)),
             this, SLOT(_k_slotDeleteItems(KFileItemList)));
     connect(d->m_dirLister, SIGNAL(refreshItems(QList<QPair<KFileItem,KFileItem> >)),
             this, SLOT(_k_slotRefreshItems(QList<QPair<KFileItem,KFileItem> >)));
     connect(d->m_dirLister, SIGNAL(clear()),
             this, SLOT(_k_slotClear()));
     connect(d->m_dirLister, SIGNAL(redirection(QUrl,QUrl)),
             this, SLOT(_k_slotRedirection(QUrl,QUrl)));
 }
 
 KDirLister *KDirModel::dirLister() const
 {
     return d->m_dirLister;
 }
 
 void KDirModelPrivate::_k_slotNewItems(const QUrl &directoryUrl, const KFileItemList &items)
 {
     //qDebug() << "directoryUrl=" << directoryUrl;
 
     KDirModelNode *result = nodeForUrl(directoryUrl); // O(depth)
     // If the directory containing the items wasn't found, then we have a big problem.
     // Are you calling KDirLister::openUrl(url,true,false)? Please use expandToUrl() instead.
     if (!result) {
         qCWarning(KIO_WIDGETS) << "Items emitted in directory" << directoryUrl
                    << "but that directory isn't in KDirModel!"
                    << "Root directory:" << urlForNode(m_rootNode);
         Q_FOREACH (const KFileItem &item, items) {
             qDebug() << "Item:" << item.url();
         }
 #ifndef NDEBUG
         dump();
 #endif
         Q_ASSERT(result);
     }
     Q_ASSERT(isDir(result));
     KDirModelDirNode *dirNode = static_cast<KDirModelDirNode *>(result);
 
     const QModelIndex index = indexForNode(dirNode); // O(n)
     const int newItemsCount = items.count();
     const int newRowCount = dirNode->m_childNodes.count() + newItemsCount;
 #if 0
 #ifndef NDEBUG // debugIndex only defined in debug mode
     //qDebug() << items.count() << "in" << directoryUrl
             << "index=" << debugIndex(index) << "newRowCount=" << newRowCount;
 #endif
 #endif
 
     q->beginInsertRows(index, newRowCount - newItemsCount, newRowCount - 1);   // parent, first, last
 
     const QList<QUrl> urlsBeingFetched = m_urlsBeingFetched.value(dirNode);
     //qDebug() << "urlsBeingFetched for dir" << dirNode << directoryUrl << ":" << urlsBeingFetched;
 
     QList<QModelIndex> emitExpandFor;
 
     KFileItemList::const_iterator it = items.begin();
     KFileItemList::const_iterator end = items.end();
     for (; it != end; ++it) {
         const bool isDir = it->isDir();
         KDirModelNode *node = isDir
                               ? new KDirModelDirNode(dirNode, *it)
                               : new KDirModelNode(dirNode, *it);
 #ifndef NDEBUG
         // Test code for possible duplication of items in the childnodes list,
         // not sure if/how it ever happened.
         //if (dirNode->m_childNodes.count() &&
         //    dirNode->m_childNodes.last()->item().name() == (*it).name()) {
         //    qCWarning(KIO_WIDGETS) << "Already having" << (*it).name() << "in" << directoryUrl
         //             << "url=" << dirNode->m_childNodes.last()->item().url();
         //    abort();
         //}
 #endif
         dirNode->m_childNodes.append(node);
         const QUrl url = it->url();
         m_nodeHash.insert(cleanupUrl(url), node);
         //qDebug() << url;
 
         if (!urlsBeingFetched.isEmpty()) {
             const QUrl dirUrl(url);
             foreach (const QUrl &urlFetched, urlsBeingFetched) {
                 if (dirUrl.matches(urlFetched, QUrl::StripTrailingSlash) || dirUrl.isParentOf(urlFetched)) {
                     //qDebug() << "Listing found" << dirUrl.url() << "which is a parent of fetched url" << urlFetched;
                     const QModelIndex parentIndex = indexForNode(node, dirNode->m_childNodes.count() - 1);
                     Q_ASSERT(parentIndex.isValid());
                     emitExpandFor.append(parentIndex);
                     if (isDir && dirUrl != urlFetched) {
                         q->fetchMore(parentIndex);
                         m_urlsBeingFetched[node].append(urlFetched);
                     }
                 }
             }
         }
     }
 
     m_urlsBeingFetched.remove(dirNode);
 
     q->endInsertRows();
 
     // Emit expand signal after rowsInserted signal has been emitted,
     // so that any proxy model will have updated its mapping already
     Q_FOREACH (const QModelIndex &idx, emitExpandFor) {
         emit q->expand(idx);
     }
 }
 
 void KDirModelPrivate::_k_slotDeleteItems(const KFileItemList &items)
 {
     //qDebug() << items.count();
 
     // I assume all items are from the same directory.
     // From KDirLister's code, this should be the case, except maybe emitChanges?
     const KFileItem item = items.first();
     Q_ASSERT(!item.isNull());
     QUrl url = item.url();
     KDirModelNode *node = nodeForUrl(url); // O(depth)
     if (!node) {
         qCWarning(KIO_WIDGETS) << "No node found for item that was just removed:" << url;
         return;
     }
 
     KDirModelDirNode *dirNode = node->parent();
     if (!dirNode) {
         return;
     }
 
     QModelIndex parentIndex = indexForNode(dirNode); // O(n)
 
     // Short path for deleting a single item
     if (items.count() == 1) {
         const int r = node->rowNumber();
         q->beginRemoveRows(parentIndex, r, r);
         removeFromNodeHash(node, url);
         delete dirNode->m_childNodes.takeAt(r);
         q->endRemoveRows();
         return;
     }
 
     // We need to make lists of consecutive row numbers, for the beginRemoveRows call.
     // Let's use a bit array where each bit represents a given child node.
     const int childCount = dirNode->m_childNodes.count();
     QBitArray rowNumbers(childCount, false);
     Q_FOREACH (const KFileItem &item, items) {
         if (!node) { // don't lookup the first item twice
             url = item.url();
             node = nodeForUrl(url);
             if (!node) {
                 qCWarning(KIO_WIDGETS) << "No node found for item that was just removed:" << url;
                 continue;
             }
             if (!node->parent()) {
                 // The root node has been deleted, but it was not first in the list 'items'.
                 // see https://bugs.kde.org/show_bug.cgi?id=196695
                 return;
             }
         }
         rowNumbers.setBit(node->rowNumber(), 1); // O(n)
         removeFromNodeHash(node, url);
         node = nullptr;
     }
 
     int start = -1;
     int end = -1;
     bool lastVal = false;
     // Start from the end, otherwise all the row numbers are offset while we go
     for (int i = childCount - 1; i >= 0; --i) {
         const bool val = rowNumbers.testBit(i);
         if (!lastVal && val) {
             end = i;
             //qDebug() << "end=" << end;
         }
         if ((lastVal && !val) || (i == 0 && val)) {
             start = val ? i : i + 1;
             //qDebug() << "beginRemoveRows" << start << end;
             q->beginRemoveRows(parentIndex, start, end);
             for (int r = end; r >= start; --r) { // reverse because takeAt changes indexes ;)
                 //qDebug() << "Removing from m_childNodes at" << r;
                 delete dirNode->m_childNodes.takeAt(r);
             }
             q->endRemoveRows();
         }
         lastVal = val;
     }
 }
 
 void KDirModelPrivate::_k_slotRefreshItems(const QList<QPair<KFileItem, KFileItem> > &items)
 {
     QModelIndex topLeft, bottomRight;
 
     // Solution 1: we could emit dataChanged for one row (if items.size()==1) or all rows
     // Solution 2: more fine-grained, actually figure out the beginning and end rows.
     for (QList<QPair<KFileItem, KFileItem> >::const_iterator fit = items.begin(), fend = items.end(); fit != fend; ++fit) {
         Q_ASSERT(!fit->first.isNull());
         Q_ASSERT(!fit->second.isNull());
         const QUrl oldUrl = fit->first.url();
         const QUrl newUrl = fit->second.url();
         KDirModelNode *node = nodeForUrl(oldUrl); // O(n); maybe we could look up to the parent only once
         //qDebug() << "in model for" << m_dirLister->url() << ":" << oldUrl << "->" << newUrl << "node=" << node;
         if (!node) { // not found [can happen when renaming a dir, redirection was emitted already]
             continue;
         }
         if (node != m_rootNode) { // we never set an item in the rootnode, we use m_dirLister->rootItem instead.
             bool hasNewNode = false;
             // A file became directory (well, it was overwritten)
             if (fit->first.isDir() != fit->second.isDir()) {
                 //qDebug() << "DIR/FILE STATUS CHANGE";
                 const int r = node->rowNumber();
                 removeFromNodeHash(node, oldUrl);
                 KDirModelDirNode *dirNode = node->parent();
                 delete dirNode->m_childNodes.takeAt(r); // i.e. "delete node"
                 node = fit->second.isDir() ? new KDirModelDirNode(dirNode, fit->second)
                        : new KDirModelNode(dirNode, fit->second);
                 dirNode->m_childNodes.insert(r, node); // same position!
                 hasNewNode = true;
             } else {
                 node->setItem(fit->second);
             }
 
             if (oldUrl != newUrl || hasNewNode) {
                 // What if a renamed dir had children? -> kdirlister takes care of emitting for each item
                 //qDebug() << "Renaming" << oldUrl << "to" << newUrl << "in node hash";
                 m_nodeHash.remove(cleanupUrl(oldUrl));
                 m_nodeHash.insert(cleanupUrl(newUrl), node);
             }
             // Mimetype changed -> forget cached icon (e.g. from "cut", #164185 comment #13)
             if (fit->first.determineMimeType().name() != fit->second.determineMimeType().name()) {
                 node->setPreview(QIcon());
             }
 
             const QModelIndex index = indexForNode(node);
             if (!topLeft.isValid() || index.row() < topLeft.row()) {
                 topLeft = index;
             }
             if (!bottomRight.isValid() || index.row() > bottomRight.row()) {
                 bottomRight = index;
             }
         }
     }
 #ifndef NDEBUG // debugIndex only defined in debug mode
     //qDebug() << "dataChanged(" << debugIndex(topLeft) << " - " << debugIndex(bottomRight);
     Q_UNUSED(debugIndex(QModelIndex())); // fix compiler warning
 #endif
     bottomRight = bottomRight.sibling(bottomRight.row(), q->columnCount(QModelIndex()) - 1);
     emit q->dataChanged(topLeft, bottomRight);
 }
 
 // Called when a kioslave redirects (e.g. smb:/Workgroup -> smb://workgroup)
 // and when renaming a directory.
 void KDirModelPrivate::_k_slotRedirection(const QUrl &oldUrl, const QUrl &newUrl)
 {
     KDirModelNode *node = nodeForUrl(oldUrl);
     if (!node) {
         return;
     }
     m_nodeHash.remove(cleanupUrl(oldUrl));
     m_nodeHash.insert(cleanupUrl(newUrl), node);
 
     // Ensure the node's URL is updated. In case of a listjob redirection
     // we won't get a refreshItem, and in case of renaming a directory
     // we'll get it too late (so the hash won't find the old url anymore).
     KFileItem item = node->item();
     if (!item.isNull()) { // null if root item, #180156
         item.setUrl(newUrl);
         node->setItem(item);
     }
 
     // The items inside the renamed directory have been handled before,
     // KDirLister took care of emitting refreshItem for each of them.
 }
 
 void KDirModelPrivate::_k_slotClear()
 {
     const int numRows = m_rootNode->m_childNodes.count();
     if (numRows > 0) {
         q->beginRemoveRows(QModelIndex(), 0, numRows - 1);
         q->endRemoveRows();
     }
 
     m_nodeHash.clear();
     //emit layoutAboutToBeChanged();
     clear();
     //emit layoutChanged();
 }
 
 void KDirModelPrivate::_k_slotJobUrlsChanged(const QStringList &urlList)
 {
     m_allCurrentDestUrls = urlList;
 }
 
 void KDirModelPrivate::clearAllPreviews(KDirModelDirNode *dirNode)
 {
     const int numRows = dirNode->m_childNodes.count();
     if (numRows > 0) {
         KDirModelNode *lastNode = nullptr;
         for (KDirModelNode *node : dirNode->m_childNodes) {
             node->setPreview(QIcon());
             //node->setPreview(QIcon::fromTheme(node->item().iconName()));
             if (isDir(node)) {
                 // recurse into child dirs
                 clearAllPreviews(static_cast<KDirModelDirNode *>(node));
             }
             lastNode = node;
         }
         emit q->dataChanged(indexForNode(dirNode->m_childNodes.at(0), 0),  // O(1)
                             indexForNode(lastNode, numRows - 1));          // O(1)
     }
 
 }
 
 void KDirModel::clearAllPreviews()
 {
     d->clearAllPreviews(d->m_rootNode);
 }
 
 void KDirModel::itemChanged(const QModelIndex &index)
 {
     // This method is really a itemMimeTypeChanged(), it's mostly called by KFilePreviewGenerator.
     // When the mimetype is determined, clear the old "preview" (could be
     // mimetype dependent like when cutting files, #164185)
     KDirModelNode *node = d->nodeForIndex(index);
     if (node) {
         node->setPreview(QIcon());
     }
 
 #ifndef NDEBUG // debugIndex only defined in debug mode
     //qDebug() << "dataChanged(" << debugIndex(index);
 #endif
     emit dataChanged(index, index);
 }
 
 int KDirModel::columnCount(const QModelIndex &) const
 {
     return ColumnCount;
 }
 
 QVariant KDirModel::data(const QModelIndex &index, int role) const
 {
     if (index.isValid()) {
         KDirModelNode *node = static_cast<KDirModelNode *>(index.internalPointer());
         const KFileItem &item(node->item());
         switch (role) {
         case Qt::DisplayRole:
             switch (index.column()) {
             case Name:
                 return item.text();
             case Size:
                 return KIO::convertSize(item.size()); // size formatted as QString
             case ModifiedTime: {
                 QDateTime dt = item.time(KFileItem::ModificationTime);
                 return dt.toString(Qt::SystemLocaleShortDate);
             }
             case Permissions:
                 return item.permissionsString();
             case Owner:
                 return item.user();
             case Group:
                 return item.group();
             case Type:
                 return item.mimeComment();
             }
             break;
         case Qt::EditRole:
             switch (index.column()) {
             case Name:
                 return item.text();
             }
             break;
         case Qt::DecorationRole:
             if (index.column() == Name) {
                 if (!node->preview().isNull()) {
                     //qDebug() << item->url() << " preview found";
                     return node->preview();
                 }
                 Q_ASSERT(!item.isNull());
                 //qDebug() << item->url() << " overlays=" << item->overlays();
                 return KDE::icon(item.iconName(), item.overlays());
             }
             break;
         case Qt::TextAlignmentRole:
             if (index.column() == Size) {
                 // use a right alignment for L2R and R2L languages
                 const Qt::Alignment alignment = Qt::AlignRight | Qt::AlignVCenter;
                 return int(alignment);
             }
             break;
         case Qt::ToolTipRole:
             return item.text();
         case FileItemRole:
             return QVariant::fromValue(item);
         case ChildCountRole:
             if (!item.isDir()) {
                 return ChildCountUnknown;
             } else {
                 KDirModelDirNode *dirNode = static_cast<KDirModelDirNode *>(node);
                 int count = dirNode->childCount();
                 if (count == ChildCountUnknown && item.isReadable() && !dirNode->isSlow()) {
                     const QString path = item.localPath();
                     if (!path.isEmpty()) {
 //                        slow
 //                        QDir dir(path);
 //                        count = dir.entryList(QDir::AllEntries|QDir::NoDotAndDotDot|QDir::System).count();
 #ifdef Q_OS_WIN
                         QString s = path + QLatin1String("\\*.*");
                         s.replace('/', '\\');
                         count = 0;
                         WIN32_FIND_DATA findData;
                         HANDLE hFile = FindFirstFile((LPWSTR)s.utf16(), &findData);
                         if (hFile != INVALID_HANDLE_VALUE) {
                             do {
                                 if (!(findData.cFileName[0] == '.' &&
                                         findData.cFileName[1] == '\0') &&
                                         !(findData.cFileName[0] == '.' &&
                                           findData.cFileName[1] == '.' &&
                                           findData.cFileName[2] == '\0')) {
                                     ++count;
                                 }
                             } while (FindNextFile(hFile, &findData) != 0);
                             FindClose(hFile);
                         }
 #else
                         DIR *dir = QT_OPENDIR(QFile::encodeName(path));
                         if (dir) {
                             count = 0;
                             QT_DIRENT *dirEntry = nullptr;
                             while ((dirEntry = QT_READDIR(dir))) {
                                 if (dirEntry->d_name[0] == '.') {
                                     if (dirEntry->d_name[1] == '\0') { // skip "."
                                         continue;
                                     }
                                     if (dirEntry->d_name[1] == '.' && dirEntry->d_name[2] == '\0') { // skip ".."
                                         continue;
                                     }
                                 }
                                 ++count;
                             }
                             QT_CLOSEDIR(dir);
                         }
 #endif
                         //qDebug() << "child count for " << path << ":" << count;
                         dirNode->setChildCount(count);
                     }
                 }
                 return count;
             }
         case HasJobRole:
             if (d->m_jobTransfersVisible && d->m_allCurrentDestUrls.isEmpty() == false) {
                 KDirModelNode *node = d->nodeForIndex(index);
                 const QString url = node->item().url().toString();
                 //return whether or not there are job dest urls visible in the view, so the delegate knows which ones to paint.
                 return QVariant(d->m_allCurrentDestUrls.contains(url));
             }
         }
     }
     return QVariant();
 }
 
 void KDirModel::sort(int column, Qt::SortOrder order)
 {
     // Not implemented - we should probably use QSortFilterProxyModel instead.
     return QAbstractItemModel::sort(column, order);
 }
 
 bool KDirModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     switch (role) {
     case Qt::EditRole:
         if (index.column() == Name && value.type() == QVariant::String) {
             Q_ASSERT(index.isValid());
             KDirModelNode *node = static_cast<KDirModelNode *>(index.internalPointer());
             const KFileItem &item = node->item();
             const QString newName = value.toString();
             if (newName.isEmpty() || newName == item.text() || (newName == QLatin1String(".")) || (newName == QLatin1String(".."))) {
                 return true;
             }
             QUrl newUrl = item.url().adjusted(QUrl::RemoveFilename);
             newUrl.setPath(newUrl.path() + KIO::encodeFileName(newName));
             KIO::Job *job = KIO::rename(item.url(), newUrl, item.url().isLocalFile() ? KIO::HideProgressInfo : KIO::DefaultFlags);
-            job->ui()->setAutoErrorHandlingEnabled(true);
+            job->uiDelegate()->setAutoErrorHandlingEnabled(true);
             // undo handling
             KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Rename, QList<QUrl>() << item.url(), newUrl, job);
             return true;
         }
         break;
     case Qt::DecorationRole:
         if (index.column() == Name) {
             Q_ASSERT(index.isValid());
             // Set new pixmap - e.g. preview
             KDirModelNode *node = static_cast<KDirModelNode *>(index.internalPointer());
             //qDebug() << "setting icon for " << node->item()->url();
             Q_ASSERT(node);
             if (value.type() == QVariant::Icon) {
                 const QIcon icon(qvariant_cast<QIcon>(value));
                 node->setPreview(icon);
             } else if (value.type() == QVariant::Pixmap) {
                 node->setPreview(qvariant_cast<QPixmap>(value));
             }
             emit dataChanged(index, index);
             return true;
         }
         break;
     default:
         break;
     }
     return false;
 }
 
 int KDirModel::rowCount(const QModelIndex &parent) const
 {
     KDirModelNode *node = d->nodeForIndex(parent);
     if (!node || !d->isDir(node)) { // #176555
         return 0;
     }
 
     KDirModelDirNode *parentNode = static_cast<KDirModelDirNode *>(node);
     Q_ASSERT(parentNode);
     const int count = parentNode->m_childNodes.count();
 #if 0
     QStringList filenames;
     for (int i = 0; i < count; ++i) {
         filenames << d->urlForNode(parentNode->m_childNodes.at(i)).fileName();
     }
     //qDebug() << "rowCount for " << d->urlForNode(parentNode) << ": " << count << filenames;
 #endif
     return count;
 }
 
 QModelIndex KDirModel::parent(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return QModelIndex();
     }
     KDirModelNode *childNode = static_cast<KDirModelNode *>(index.internalPointer());
     Q_ASSERT(childNode);
     KDirModelNode *parentNode = childNode->parent();
     Q_ASSERT(parentNode);
     return d->indexForNode(parentNode); // O(n)
 }
 
 // Reimplemented to avoid the default implementation which calls parent
 // (O(n) for finding the parent's row number for nothing). This implementation is O(1).
 QModelIndex KDirModel::sibling(int row, int column, const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return QModelIndex();
     }
     KDirModelNode *oldChildNode = static_cast<KDirModelNode *>(index.internalPointer());
     Q_ASSERT(oldChildNode);
     KDirModelNode *parentNode = oldChildNode->parent();
     Q_ASSERT(parentNode);
     Q_ASSERT(d->isDir(parentNode));
     KDirModelNode *childNode = static_cast<KDirModelDirNode *>(parentNode)->m_childNodes.value(row); // O(1)
     if (childNode) {
         return createIndex(row, column, childNode);
     }
     return QModelIndex();
 }
 
 static bool lessThan(const QUrl &left, const QUrl &right)
 {
     return left.toString().compare(right.toString()) < 0;
 }
 
 void KDirModel::requestSequenceIcon(const QModelIndex &index, int sequenceIndex)
 {
     emit needSequenceIcon(index, sequenceIndex);
 }
 
 void KDirModel::setJobTransfersVisible(bool value)
 {
     if (value) {
         d->m_jobTransfersVisible = true;
         connect(&JobUrlCache::instance(), SIGNAL(jobUrlsChanged(QStringList)), this, SLOT(_k_slotJobUrlsChanged(QStringList)), Qt::UniqueConnection);
 
         JobUrlCache::instance().requestJobUrlsChanged();
     } else {
         disconnect(this, SLOT(_k_slotJobUrlsChanged(QStringList)));
     }
 
 }
 
 bool KDirModel::jobTransfersVisible() const
 {
     return d->m_jobTransfersVisible;
 }
 
 QList<QUrl> KDirModel::simplifiedUrlList(const QList<QUrl> &urls)
 {
     if (!urls.count()) {
         return urls;
     }
 
     QList<QUrl> ret(urls);
     qSort(ret.begin(), ret.end(), lessThan);
 
     QList<QUrl>::iterator it = ret.begin();
     QUrl url = *it;
     ++it;
     while (it != ret.end()) {
         if (url.isParentOf(*it) || url == *it) {
             it = ret.erase(it);
         } else {
             url = *it;
             ++it;
         }
     }
 
     return ret;
 }
 
 QStringList KDirModel::mimeTypes() const
 {
     return KUrlMimeData::mimeDataTypes();
 }
 
 QMimeData *KDirModel::mimeData(const QModelIndexList &indexes) const
 {
     QList<QUrl> urls, mostLocalUrls;
     bool canUseMostLocalUrls = true;
     foreach (const QModelIndex &index, indexes) {
         const KFileItem &item = d->nodeForIndex(index)->item();
         urls << item.url();
         bool isLocal;
         mostLocalUrls << item.mostLocalUrl(isLocal);
         if (!isLocal) {
             canUseMostLocalUrls = false;
         }
     }
     QMimeData *data = new QMimeData();
     const bool different = canUseMostLocalUrls && (mostLocalUrls != urls);
     urls = simplifiedUrlList(urls);
     if (different) {
         mostLocalUrls = simplifiedUrlList(mostLocalUrls);
         KUrlMimeData::setUrls(urls, mostLocalUrls, data);
     } else {
         data->setUrls(urls);
     }
 
     return data;
 }
 
 // Public API; not much point in calling it internally
 KFileItem KDirModel::itemForIndex(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return d->m_dirLister->rootItem();
     } else {
         return static_cast<KDirModelNode *>(index.internalPointer())->item();
     }
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 QModelIndex KDirModel::indexForItem(const KFileItem *item) const
 {
     // Note that we can only use the URL here, not the pointer.
     // KFileItems can be copied.
     return indexForUrl(item->url()); // O(n)
 }
 #endif
 
 QModelIndex KDirModel::indexForItem(const KFileItem &item) const
 {
     // Note that we can only use the URL here, not the pointer.
     // KFileItems can be copied.
     return indexForUrl(item.url()); // O(n)
 }
 
 // url -> index. O(n)
 QModelIndex KDirModel::indexForUrl(const QUrl &url) const
 {
     KDirModelNode *node = d->nodeForUrl(url); // O(depth)
     if (!node) {
         //qDebug() << url << "not found";
         return QModelIndex();
     }
     return d->indexForNode(node); // O(n)
 }
 
 QModelIndex KDirModel::index(int row, int column, const QModelIndex &parent) const
 {
     KDirModelNode *parentNode = d->nodeForIndex(parent); // O(1)
     Q_ASSERT(parentNode);
     if (d->isDir(parentNode)) {
         KDirModelNode *childNode = static_cast<KDirModelDirNode *>(parentNode)->m_childNodes.value(row); // O(1)
         if (childNode) {
             return createIndex(row, column, childNode);
         }
     }
     return QModelIndex();
 }
 
 QVariant KDirModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal) {
         switch (role) {
         case Qt::DisplayRole:
             switch (section) {
             case Name:
                 return i18nc("@title:column", "Name");
             case Size:
                 return i18nc("@title:column", "Size");
             case ModifiedTime:
                 return i18nc("@title:column", "Date");
             case Permissions:
                 return i18nc("@title:column", "Permissions");
             case Owner:
                 return i18nc("@title:column", "Owner");
             case Group:
                 return i18nc("@title:column", "Group");
             case Type:
                 return i18nc("@title:column", "Type");
             }
         }
     }
     return QVariant();
 }
 
 bool KDirModel::hasChildren(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return true;
     }
 
     const KFileItem &parentItem = static_cast<KDirModelNode *>(parent.internalPointer())->item();
     Q_ASSERT(!parentItem.isNull());
     return parentItem.isDir();
 }
 
 Qt::ItemFlags KDirModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags f = Qt::ItemIsEnabled;
     if (index.column() == Name) {
         f |= Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled;
     }
 
     // Allow dropping onto this item?
     if (d->m_dropsAllowed != NoDrops) {
         if (!index.isValid()) {
             if (d->m_dropsAllowed & DropOnDirectory) {
                 f |= Qt::ItemIsDropEnabled;
             }
         } else {
             KFileItem item = itemForIndex(index);
             if (item.isNull()) {
                 qCWarning(KIO_WIDGETS) << "Invalid item returned for index";
             } else if (item.isDir()) {
                 if (d->m_dropsAllowed & DropOnDirectory) {
                     f |= Qt::ItemIsDropEnabled;
                 }
             } else { // regular file item
                 if (d->m_dropsAllowed & DropOnAnyFile) {
                     f |= Qt::ItemIsDropEnabled;
                 } else if (d->m_dropsAllowed & DropOnLocalExecutable) {
                     if (!item.localPath().isEmpty()) {
                         // Desktop file?
                         if (item.determineMimeType().inherits(QStringLiteral("application/x-desktop"))) {
                             f |= Qt::ItemIsDropEnabled;
                         }
                         // Executable, shell script ... ?
                         else if (QFileInfo(item.localPath()).isExecutable()) {
                             f |= Qt::ItemIsDropEnabled;
                         }
                     }
                 }
             }
         }
     }
 
     return f;
 }
 
 bool KDirModel::canFetchMore(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return false;
     }
 
     // We now have a bool KDirModelNode::m_populated,
     // to avoid calling fetchMore more than once on empty dirs.
     // But this wastes memory, and how often does someone open and re-open an empty dir in a treeview?
     // Maybe we can ask KDirLister "have you listed <url> already"? (to discuss with M. Brade)
 
     KDirModelNode *node = static_cast<KDirModelNode *>(parent.internalPointer());
     const KFileItem &item = node->item();
     return item.isDir() && !static_cast<KDirModelDirNode *>(node)->isPopulated()
            && static_cast<KDirModelDirNode *>(node)->m_childNodes.isEmpty();
 }
 
 void KDirModel::fetchMore(const QModelIndex &parent)
 {
     if (!parent.isValid()) {
         return;
     }
 
     KDirModelNode *parentNode = static_cast<KDirModelNode *>(parent.internalPointer());
 
     KFileItem parentItem = parentNode->item();
     Q_ASSERT(!parentItem.isNull());
     if (!parentItem.isDir()) {
         return;
     }
     KDirModelDirNode *dirNode = static_cast<KDirModelDirNode *>(parentNode);
     if (dirNode->isPopulated()) {
         return;
     }
     dirNode->setPopulated(true);
 
     const QUrl parentUrl = parentItem.url();
     d->m_dirLister->openUrl(parentUrl, KDirLister::Keep);
 }
 
 bool KDirModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     // Not sure we want to implement any drop handling at this level,
     // but for sure the default QAbstractItemModel implementation makes no sense for a dir model.
     Q_UNUSED(data);
     Q_UNUSED(action);
     Q_UNUSED(row);
     Q_UNUSED(column);
     Q_UNUSED(parent);
     return false;
 }
 
 void KDirModel::setDropsAllowed(DropsAllowed dropsAllowed)
 {
     d->m_dropsAllowed = dropsAllowed;
 }
 
 void KDirModel::expandToUrl(const QUrl &url)
 {
     // emit expand for each parent and return last parent
     KDirModelNode *result = d->expandAllParentsUntil(url); // O(depth)
     //qDebug() << url << result;
 
     if (!result) { // doesn't seem related to our base url?
         return;
     }
     if (!(result->item().isNull()) && result->item().url() == url) {
         // We have it already, nothing to do
         //qDebug() << "have it already item=" <<url /*result->item()*/;
         return;
     }
 
     d->m_urlsBeingFetched[result].append(url);
 
     if (result == d->m_rootNode) {
         //qDebug() << "Remembering to emit expand after listing the root url";
         // the root is fetched by default, so it must be currently being fetched
         return;
     }
 
     //qDebug() << "Remembering to emit expand after listing" << result->item().url();
 
     // start a new fetch to look for the next level down the URL
     const QModelIndex parentIndex = d->indexForNode(result); // O(n)
     Q_ASSERT(parentIndex.isValid());
     fetchMore(parentIndex);
 }
 
 bool KDirModel::insertRows(int, int, const QModelIndex &)
 {
     return false;
 }
 
 bool KDirModel::insertColumns(int, int, const QModelIndex &)
 {
     return false;
 }
 
 bool KDirModel::removeRows(int, int, const QModelIndex &)
 {
     return false;
 }
 
 bool KDirModel::removeColumns(int, int, const QModelIndex &)
 {
     return false;
 }
 
 #include "moc_kdirmodel.cpp"
diff --git a/src/widgets/kpropertiesdialog.cpp b/src/widgets/kpropertiesdialog.cpp
index 392958da..860ad0ea 100644
--- a/src/widgets/kpropertiesdialog.cpp
+++ b/src/widgets/kpropertiesdialog.cpp
@@ -1,3906 +1,3906 @@
 /* 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 <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>
 #include <qplatformdefs.h>
 
 #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 KPropertiesDialog::KPropertiesDialogPrivate
 {
 public:
     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 *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]) or ([X-KDE-Protocol] == '%1'))"
                     ).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(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(newUrl.path() + _name);
     }
     updateUrl(newUrl);
 }
 
 void KPropertiesDialog::abortApplying()
 {
     d->m_aborted = true;
 }
 
 class 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;
 
     QWidget *iconArea;
     QWidget *nameArea;
 
     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
     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 = 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 += ' ';
         directory += '(';
         directory += protocol;
         directory += ')';
     }
 
     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(KIconLoader::global()->loadIcon(iconStr, KIconLoader::Desktop, 48));
         d->iconArea = iconLabel;
     }
     grid->addWidget(d->iconArea, curRow, 0, Qt::AlignCenter);
 
     if (d->bMultiple || isTrash || hasRoot) {
         QLabel *lab = new QLabel(d->m_frame);
         if (d->bMultiple) {
             lab->setText(KIO::itemsSummaryString(iFileCount + iDirCount, iFileCount, iDirCount, 0, false));
         } else {
             lab->setText(filename);
         }
         d->nameArea = lab;
     } else {
         d->m_lined = new KLineEdit(d->m_frame);
         d->m_lined->setObjectName("KFilePropsPlugin::nameLineEdit");
         d->m_lined->setText(filename);
         d->nameArea = d->m_lined;
         d->m_lined->setFocus();
 
         //if we don't have permissions to rename, we need to make "m_lined" read only.
         KFileItemListProperties itemList(KFileItemList() << item);
         setFileNameReadOnly(!itemList.supportsMoving());
 
         // 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('.');
             if (lastDot > 0) {
                 d->m_lined->setSelection(0, lastDot);
             }
         }
 
         connect(d->m_lined, SIGNAL(textChanged(QString)),
                 this, SLOT(nameFileChanged(QString)));
     }
 
     grid->addWidget(d->nameArea, curRow++, 2);
 
     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);
         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);
 
     d->m_sizeLabel = new QLabel(d->m_frame);
     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);
             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);
             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());
             if (mp && mp->mountPoint() != QLatin1String("/")) {
                 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("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)
 {
     if (d->m_lined && !d->m_bFromTemplate) {
         d->m_lined->setReadOnly(ro);
         if (ro) {
             // Don't put the initial focus on the line edit when it is ro
             properties->buttonBox()->button(QDialogButtonBox::Ok)->setFocus();
         }
     }
 }
 
 void KFilePropsPlugin::slotEditFileType()
 {
     QString mime;
     if (d->mimeType == QLatin1String("application/octet-stream")) {
         const int pos = d->oldFileName.lastIndexOf('.');
         if (pos != -1) {
             mime = '*' + d->oldFileName.mid(pos);
         } else {
             mime = '*';
         }
     }  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),
              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 (qobject_cast<QLineEdit *>(d->nameArea)) {
         QString n = ((QLineEdit *) d->nameArea)->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->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) + '/' + 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->ui()->setAutoErrorHandlingEnabled(true);
+            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());
         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("Forbidden"),
         I18N_NOOP("Can Read"),
         I18N_NOOP("Can Read & Write"),
         nullptr
     },
     {
         I18N_NOOP("Forbidden"),
         I18N_NOOP("Can View Content"),
         I18N_NOOP("Can View & Modify Content"),
         nullptr
     },
     { nullptr, nullptr, nullptr, nullptr}, // no texts for links
     {
         I18N_NOOP("Forbidden"),
         I18N_NOOP("Can View Content & Read"),
         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;
     QString path = properties->url().path();
     QString fname = properties->url().fileName();
     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) {
             const QUrl url = (*it).url();
             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(QLatin1String(""), 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;
     QByteArray strUser;
     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);
 #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()) {
             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()) : QLatin1String(""));
         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()) : QLatin1String(""));
         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.") : QLatin1String(""));
         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.isLocalFile() && 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 alread 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()) {
         //FIXME: 4.2 add this: KMessageBox::sorry(0, 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(QLatin1String("org.kde.Solid.PowerManagement"),
                              QLatin1String("/org/kde/Solid/PowerManagement"),
                              QLatin1String("org.kde.Solid.PowerManagement"),
                              QDBusConnection::sessionBus());
         if (iface.isValid()) {
             QDBusReply<bool> reply = iface.call(QLatin1String("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());
 
     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(" --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"