diff --git a/src/filewidgets/kfilemetapreview.cpp b/src/filewidgets/kfilemetapreview.cpp
index 0fa9389d..1192f1e8 100644
--- a/src/filewidgets/kfilemetapreview.cpp
+++ b/src/filewidgets/kfilemetapreview.cpp
@@ -1,199 +1,199 @@
 /*
  * This file is part of the KDE project.
  * Copyright (C) 2003 Carsten Pfeiffer <pfeiffer@kde.org>
  *
  * You can Freely distribute this program under the GNU Library General Public
  * License. See the file "COPYING" for the exact licensing terms.
  */
 
 #include "kfilemetapreview_p.h"
 
 #include <QLayout>
 #include <qmimedatabase.h>
 
 #include <QDebug>
 #include <kio/previewjob.h>
 #include <kpluginloader.h>
 #include <kpluginfactory.h>
 #include <kimagefilepreview.h>
 
 bool KFileMetaPreview::s_tryAudioPreview = true;
 
 KFileMetaPreview::KFileMetaPreview(QWidget *parent)
     : KPreviewWidgetBase(parent),
       haveAudioPreview(false)
 {
     QHBoxLayout *layout = new QHBoxLayout(this);
-    layout->setMargin(0);
+    layout->setContentsMargins(0, 0, 0, 0);
     m_stack = new QStackedWidget(this);
     layout->addWidget(m_stack);
 
     // ###
 //     m_previewProviders.setAutoDelete( true );
     initPreviewProviders();
 }
 
 KFileMetaPreview::~KFileMetaPreview()
 {
 }
 
 void KFileMetaPreview::initPreviewProviders()
 {
     qDeleteAll(m_previewProviders);
     m_previewProviders.clear();
     // hardcoded so far
 
     // image previews
     KImageFilePreview *imagePreview = new KImageFilePreview(m_stack);
     (void) m_stack->addWidget(imagePreview);
     m_stack->setCurrentWidget(imagePreview);
     resize(imagePreview->sizeHint());
 
     const QStringList mimeTypes = imagePreview->supportedMimeTypes();
     QStringList::ConstIterator it = mimeTypes.begin();
     for (; it != mimeTypes.end(); ++it) {
 //         qDebug(".... %s", (*it).toLatin1().constData());
         m_previewProviders.insert(*it, imagePreview);
     }
 }
 
 KPreviewWidgetBase *KFileMetaPreview::findExistingProvider(const QString &mimeType, const QMimeType &mimeInfo) const
 {
     KPreviewWidgetBase *provider = m_previewProviders.value(mimeType);
     if (provider) {
         return provider;
     }
 
     if (mimeInfo.isValid()) {
         // check mime type inheritance
         const QStringList parentMimeTypes = mimeInfo.allAncestors();
         Q_FOREACH (const QString &parentMimeType, parentMimeTypes) {
             provider = m_previewProviders.value(parentMimeType);
             if (provider) {
                 return provider;
             }
         }
     }
 
     // ### mimetype may be image/* for example, try that
     const int index = mimeType.indexOf(QLatin1Char('/'));
     if (index > 0) {
         provider = m_previewProviders.value(mimeType.leftRef(index + 1) + QLatin1Char('*'));
         if (provider) {
             return provider;
         }
     }
 
     return nullptr;
 }
 
 KPreviewWidgetBase *KFileMetaPreview::previewProviderFor(const QString &mimeType)
 {
     QMimeDatabase db;
     QMimeType mimeInfo = db.mimeTypeForName(mimeType);
 
     //     qDebug("### looking for: %s", mimeType.toLatin1().constData());
     // often the first highlighted item, where we can be sure, there is no plugin
     // (this "folders reflect icons" is a konq-specific thing, right?)
     if (mimeInfo.inherits(QStringLiteral("inode/directory"))) {
         return nullptr;
     }
 
     KPreviewWidgetBase *provider = findExistingProvider(mimeType, mimeInfo);
     if (provider) {
         return provider;
     }
 
 //qDebug("#### didn't find anything for: %s", mimeType.toLatin1().constData());
 
     if (s_tryAudioPreview &&
             !mimeType.startsWith(QLatin1String("text/")) &&
             !mimeType.startsWith(QLatin1String("image/"))) {
         if (!haveAudioPreview) {
             KPreviewWidgetBase *audioPreview = createAudioPreview(m_stack);
             if (audioPreview) {
                 haveAudioPreview = true;
                 (void) m_stack->addWidget(audioPreview);
                 const QStringList mimeTypes = audioPreview->supportedMimeTypes();
                 QStringList::ConstIterator it = mimeTypes.begin();
                 for (; it != mimeTypes.end(); ++it) {
                     // only add non already handled mimetypes
                     if (m_previewProviders.constFind(*it) == m_previewProviders.constEnd()) {
                         m_previewProviders.insert(*it, audioPreview);
                     }
                 }
             }
         }
     }
 
     // with the new mimetypes from the audio-preview, try again
     provider = findExistingProvider(mimeType, mimeInfo);
     if (provider) {
         return provider;
     }
 
     // The logic in this code duplicates the logic in PreviewJob.
     // But why do we need multiple KPreviewWidgetBase instances anyway?
 
     return nullptr;
 }
 
 void KFileMetaPreview::showPreview(const QUrl &url)
 {
     QMimeDatabase db;
     QMimeType mt = db.mimeTypeForUrl(url);
     KPreviewWidgetBase *provider = previewProviderFor(mt.name());
     if (provider) {
         if (provider != m_stack->currentWidget()) { // stop the previous preview
             clearPreview();
         }
 
         m_stack->setEnabled(true);
         m_stack->setCurrentWidget(provider);
         provider->showPreview(url);
     } else {
         clearPreview();
         m_stack->setEnabled(false);
     }
 }
 
 void KFileMetaPreview::clearPreview()
 {
     if (m_stack->currentWidget()) {
         static_cast<KPreviewWidgetBase *>(m_stack->currentWidget())->clearPreview();
     }
 }
 
 void KFileMetaPreview::addPreviewProvider(const QString &mimeType,
         KPreviewWidgetBase *provider)
 {
     m_previewProviders.insert(mimeType, provider);
 }
 
 void KFileMetaPreview::clearPreviewProviders()
 {
     QHash<QString, KPreviewWidgetBase *>::const_iterator i = m_previewProviders.constBegin();
     while (i != m_previewProviders.constEnd()) {
         m_stack->removeWidget(i.value());
         ++i;
     }
     qDeleteAll(m_previewProviders);
     m_previewProviders.clear();
 }
 
 // static
 KPreviewWidgetBase *KFileMetaPreview::createAudioPreview(QWidget *parent)
 {
     KPluginLoader loader(QStringLiteral("kfileaudiopreview"));
     KPluginFactory *factory = loader.factory();
     if (!factory) {
         qWarning() << "Couldn't load kfileaudiopreview" << loader.errorString();
         s_tryAudioPreview = false;
         return nullptr;
     }
     KPreviewWidgetBase *w = factory->create<KPreviewWidgetBase>(parent);
     if (w) {
         w->setObjectName(QStringLiteral("kfileaudiopreview"));
     }
     return w;
 }
diff --git a/src/filewidgets/kfilewidget.cpp b/src/filewidgets/kfilewidget.cpp
index e3ee5300..dfa1f786 100644
--- a/src/filewidgets/kfilewidget.cpp
+++ b/src/filewidgets/kfilewidget.cpp
@@ -1,2898 +1,2898 @@
 // -*- c++ -*-
 /* This file is part of the KDE libraries
     Copyright (C) 1997, 1998 Richard Moore <rich@kde.org>
                   1998 Stephan Kulow <coolo@kde.org>
                   1998 Daniel Grana <grana@ie.iwi.unibe.ch>
                   1999,2000,2001,2002,2003 Carsten Pfeiffer <pfeiffer@kde.org>
                   2003 Clarence Dang <dang@kde.org>
                   2007 David Faure <faure@kde.org>
                   2008 Rafael Fernández López <ereslibre@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "kfilewidget.h"
 #include "../pathhelpers_p.h"
 
 #include "kfileplacesview.h"
 #include "kfileplacesmodel.h"
 #include "kfilebookmarkhandler_p.h"
 #include "kurlcombobox.h"
 #include "kurlnavigator.h"
 #include "kfilepreviewgenerator.h"
 #include "kfilewidgetdocktitlebar_p.h"
 #include <config-kiofilewidgets.h>
 #include <defaults-kfile.h>
 
 #include <kactioncollection.h>
 #include <kactionmenu.h>
 #include <kconfiggroup.h>
 #include <kdiroperator.h>
 #include <kfilefiltercombo.h>
 #include <kimagefilepreview.h>
 #include <krecentdocument.h>
 #include <ktoolbar.h>
 #include <kurlcompletion.h>
 #include <kprotocolmanager.h>
 #include <kio/pixmaploader.h>
 #include <kio/job.h>
 #include <kio/jobuidelegate.h>
 #include <kio/scheduler.h>
 #include <krecentdirs.h>
 #include <QDebug>
 #include <klocalizedstring.h>
 #include <kfileitemdelegate.h>
 #include <ksharedconfig.h>
 
 #include <QCheckBox>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QSplitter>
 #include <QAbstractProxyModel>
 #include <QHelpEvent>
 #include <QApplication>
 #include <QPushButton>
 #include <QStandardPaths>
 #include <qmimedatabase.h>
 
 #include <kshell.h>
 #include <kmessagebox.h>
 #include <kurlauthorized.h>
 #include <kjobwidgets.h>
 
 class KFileWidgetPrivate
 {
 public:
     explicit KFileWidgetPrivate(KFileWidget *widget)
         : q(widget),
           boxLayout(nullptr),
           placesDock(nullptr),
           placesView(nullptr),
           placesViewSplitter(nullptr),
           placesViewWidth(-1),
           labeledCustomWidget(nullptr),
           bottomCustomWidget(nullptr),
           autoSelectExtCheckBox(nullptr),
           operationMode(KFileWidget::Opening),
           bookmarkHandler(nullptr),
           toolbar(nullptr),
           locationEdit(nullptr),
           ops(nullptr),
           filterWidget(nullptr),
           autoSelectExtChecked(false),
           keepLocation(false),
           hasView(false),
           hasDefaultFilter(false),
           inAccept(false),
           dummyAdded(false),
           confirmOverwrite(false),
           differentHierarchyLevelItemsEntered(false),
           iconSizeSlider(nullptr),
           zoomOutAction(nullptr),
           zoomInAction(nullptr)
     {
     }
 
     ~KFileWidgetPrivate()
     {
         delete bookmarkHandler; // Should be deleted before ops!
         delete ops;
     }
 
     void updateLocationWhatsThis();
     void updateAutoSelectExtension();
     void initSpeedbar();
     void setPlacesViewSplitterSizes();
     void setLafBoxColumnWidth();
     void initGUI();
     void readViewConfig();
     void writeViewConfig();
     void setNonExtSelection();
     void setLocationText(const QUrl &);
     void setLocationText(const QList<QUrl> &);
     void appendExtension(QUrl &url);
     void updateLocationEditExtension(const QString &);
     void updateFilter();
     QList<QUrl> &parseSelectedUrls();
     /**
      * Parses the string "line" for files. If line doesn't contain any ", the
      * whole line will be interpreted as one file. If the number of " is odd,
      * an empty list will be returned. Otherwise, all items enclosed in " "
      * will be returned as correct urls.
      */
     QList<QUrl> tokenize(const QString &line) const;
     /**
      * Reads the recent used files and inserts them into the location combobox
      */
     void readRecentFiles();
     /**
      * Saves the entries from the location combobox.
      */
     void saveRecentFiles();
     /**
      * called when an item is highlighted/selected in multiselection mode.
      * handles setting the locationEdit.
      */
     void multiSelectionChanged();
 
     /**
      * Returns the absolute version of the URL specified in locationEdit.
      */
     QUrl getCompleteUrl(const QString &) const;
 
     /**
      * Sets the dummy entry on the history combo box. If the dummy entry
      * already exists, it is overwritten with this information.
      */
     void setDummyHistoryEntry(const QString &text, const QPixmap &icon = QPixmap(),
                               bool usePreviousPixmapIfNull = true);
 
     /**
      * Removes the dummy entry of the history combo box.
      */
     void removeDummyHistoryEntry();
 
     /**
      * Asks for overwrite confirmation using a KMessageBox and returns
      * true if the user accepts.
      *
      * @since 4.2
      */
     bool toOverwrite(const QUrl &);
 
     // private slots
     void _k_slotLocationChanged(const QString &);
     void _k_urlEntered(const QUrl &);
     void _k_enterUrl(const QUrl &);
     void _k_enterUrl(const QString &);
     void _k_locationAccepted(const QString &);
     void _k_slotFilterChanged();
     void _k_fileHighlighted(const KFileItem &);
     void _k_fileSelected(const KFileItem &);
     void _k_slotLoadingFinished();
     void _k_fileCompletion(const QString &);
     void _k_toggleSpeedbar(bool);
     void _k_toggleBookmarks(bool);
     void _k_slotAutoSelectExtClicked();
     void _k_placesViewSplitterMoved(int, int);
     void _k_activateUrlNavigator();
     void _k_zoomOutIconsSize();
     void _k_zoomInIconsSize();
     void _k_slotIconSizeSliderMoved(int);
     void _k_slotIconSizeChanged(int);
     void _k_slotViewDoubleClicked(const QModelIndex&);
 
     void addToRecentDocuments();
 
     QString locationEditCurrentText() const;
 
     /**
      * KIO::NetAccess::mostLocalUrl local replacement.
      * This method won't show any progress dialogs for stating, since
      * they are very annoying when stating.
      */
     QUrl mostLocalUrl(const QUrl &url);
 
     void setInlinePreviewShown(bool show);
 
     KFileWidget * const q;
 
     // the last selected url
     QUrl url;
 
     // the selected filenames in multiselection mode -- FIXME
     QString filenames;
 
     // now following all kind of widgets, that I need to rebuild
     // the geometry management
     QBoxLayout *boxLayout;
     QGridLayout *lafBox;
     QVBoxLayout *vbox;
 
     QLabel *locationLabel;
     QWidget *opsWidget;
     QWidget *pathSpacer;
 
     QLabel *filterLabel;
     KUrlNavigator *urlNavigator;
     QPushButton *okButton, *cancelButton;
     QDockWidget *placesDock;
     KFilePlacesView *placesView;
     QSplitter *placesViewSplitter;
     // caches the places view width. This value will be updated when the splitter
     // is moved. This allows us to properly set a value when the dialog itself
     // is resized
     int placesViewWidth;
 
     QWidget *labeledCustomWidget;
     QWidget *bottomCustomWidget;
 
     // Automatically Select Extension stuff
     QCheckBox *autoSelectExtCheckBox;
     QString extension; // current extension for this filter
 
     QList<KIO::StatJob *> statJobs;
 
     QList<QUrl> urlList; //the list of selected urls
 
     KFileWidget::OperationMode operationMode;
 
     // The file class used for KRecentDirs
     QString fileClass;
 
     KFileBookmarkHandler *bookmarkHandler;
 
     KActionMenu *bookmarkButton;
 
     KToolBar *toolbar;
     KUrlComboBox *locationEdit;
     KDirOperator *ops;
     KFileFilterCombo *filterWidget;
     QTimer filterDelayTimer;
 
     KFilePlacesModel *model;
 
     // whether or not the _user_ has checked the above box
     bool autoSelectExtChecked : 1;
 
     // indicates if the location edit should be kept or cleared when changing
     // directories
     bool keepLocation : 1;
 
     // the KDirOperators view is set in KFileWidget::show(), so to avoid
     // setting it again and again, we have this nice little boolean :)
     bool hasView : 1;
 
     bool hasDefaultFilter : 1; // necessary for the operationMode
     bool autoDirectoryFollowing : 1;
     bool inAccept : 1; // true between beginning and end of accept()
     bool dummyAdded : 1; // if the dummy item has been added. This prevents the combo from having a
     // blank item added when loaded
     bool confirmOverwrite : 1;
     bool differentHierarchyLevelItemsEntered;
 
     QSlider *iconSizeSlider;
     QAction *zoomOutAction;
     QAction *zoomInAction;
 
     // The group which stores app-specific settings. These settings are recent
     // files and urls. Visual settings (view mode, sorting criteria...) are not
     // app-specific and are stored in kdeglobals
     KConfigGroup configGroup;
 };
 
 Q_GLOBAL_STATIC(QUrl, lastDirectory) // to set the start path
 
 static const char autocompletionWhatsThisText[] = I18N_NOOP("<qt>While typing in the text area, you may be presented "
         "with possible matches. "
         "This feature can be controlled by clicking with the right mouse button "
         "and selecting a preferred mode from the <b>Text Completion</b> menu.</qt>");
 
 // returns true if the string contains "<a>:/" sequence, where <a> is at least 2 alpha chars
 static bool containsProtocolSection(const QString &string)
 {
     int len = string.length();
     static const char prot[] = ":/";
     for (int i = 0; i < len;) {
         i = string.indexOf(QLatin1String(prot), i);
         if (i == -1) {
             return false;
         }
         int j = i - 1;
         for (; j >= 0; j--) {
             const QChar &ch(string[j]);
             if (ch.toLatin1() == 0 || !ch.isLetter()) {
                 break;
             }
             if (ch.isSpace() && (i - j - 1) >= 2) {
                 return true;
             }
         }
         if (j < 0 && i >= 2) {
             return true;    // at least two letters before ":/"
         }
         i += 3; // skip : and / and one char
     }
     return false;
 }
 
 // this string-to-url conversion function handles relative paths, full paths and URLs
 // without the http-prepending that QUrl::fromUserInput does.
 static QUrl urlFromString(const QString& str)
 {
     if (QDir::isAbsolutePath(str)) {
         return QUrl::fromLocalFile(str);
     }
     QUrl url(str);
     if (url.isRelative()) {
         url.clear();
         url.setPath(str);
     }
     return url;
 }
 
 
 KFileWidget::KFileWidget(const QUrl &_startDir, QWidget *parent)
     : QWidget(parent), d(new KFileWidgetPrivate(this))
 {
     QUrl startDir(_startDir);
     // qDebug() << "startDir" << startDir;
     QString filename;
 
     d->okButton = new QPushButton(this);
     KGuiItem::assign(d->okButton, KStandardGuiItem::ok());
     d->okButton->setDefault(true);
     d->cancelButton = new QPushButton(this);
     KGuiItem::assign(d->cancelButton, KStandardGuiItem::cancel());
     // The dialog shows them
     d->okButton->hide();
     d->cancelButton->hide();
 
     d->opsWidget = new QWidget(this);
     QVBoxLayout *opsWidgetLayout = new QVBoxLayout(d->opsWidget);
-    opsWidgetLayout->setMargin(0);
+    opsWidgetLayout->setContentsMargins(0, 0, 0, 0);
     opsWidgetLayout->setSpacing(0);
     //d->toolbar = new KToolBar(this, true);
     d->toolbar = new KToolBar(d->opsWidget, true);
     d->toolbar->setObjectName(QStringLiteral("KFileWidget::toolbar"));
     d->toolbar->setMovable(false);
     opsWidgetLayout->addWidget(d->toolbar);
 
     d->model = new KFilePlacesModel(this);
 
     // Resolve this now so that a 'kfiledialog:' URL, if specified,
     // does not get inserted into the urlNavigator history.
     d->url = getStartUrl(startDir, d->fileClass, filename);
     startDir = d->url;
 
     // Don't pass startDir to the KUrlNavigator at this stage: as well as
     // the above, it may also contain a file name which should not get
     // inserted in that form into the old-style navigation bar history.
     // Wait until the KIO::stat has been done later.
     //
     // The stat cannot be done before this point, bug 172678.
     d->urlNavigator = new KUrlNavigator(d->model, QUrl(), d->opsWidget); //d->toolbar);
     d->urlNavigator->setPlacesSelectorVisible(false);
     opsWidgetLayout->addWidget(d->urlNavigator);
 
     QUrl u;
     KUrlComboBox *pathCombo = d->urlNavigator->editor();
 #ifdef Q_OS_WIN
 #if 0
     foreach (const QFileInfo &drive, QFSFileEngine::drives()) {
         u = QUrl::fromLocalFile(drive.filePath());
         pathCombo->addDefaultUrl(u,
                                  KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                                  i18n("Drive: %1",  u.toLocalFile()));
     }
 #else
 #pragma message("QT5 PORT")
 #endif
 #else
     u = QUrl::fromLocalFile(QDir::rootPath());
     pathCombo->addDefaultUrl(u,
                              KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 #endif
 
     u = QUrl::fromLocalFile(QDir::homePath());
     pathCombo->addDefaultUrl(u, KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 
     QUrl docPath = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
     if (u.adjusted(QUrl::StripTrailingSlash) != docPath.adjusted(QUrl::StripTrailingSlash) &&
             QDir(docPath.toLocalFile()).exists()) {
         pathCombo->addDefaultUrl(docPath,
                                  KIO::pixmapForUrl(docPath, 0, KIconLoader::Small),
                                  docPath.toLocalFile());
     }
 
     u = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation));
     pathCombo->addDefaultUrl(u,
                              KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 
     d->ops = new KDirOperator(QUrl(), d->opsWidget);
     d->ops->setObjectName(QStringLiteral("KFileWidget::ops"));
     d->ops->setIsSaving(d->operationMode == Saving);
     opsWidgetLayout->addWidget(d->ops);
     connect(d->ops, SIGNAL(urlEntered(QUrl)),
             SLOT(_k_urlEntered(QUrl)));
     connect(d->ops, SIGNAL(fileHighlighted(KFileItem)),
             SLOT(_k_fileHighlighted(KFileItem)));
     connect(d->ops, SIGNAL(fileSelected(KFileItem)),
             SLOT(_k_fileSelected(KFileItem)));
     connect(d->ops, SIGNAL(finishedLoading()),
             SLOT(_k_slotLoadingFinished()));
 
     d->ops->setupMenu(KDirOperator::SortActions |
                       KDirOperator::FileActions |
                       KDirOperator::ViewActions);
     KActionCollection *coll = d->ops->actionCollection();
     coll->addAssociatedWidget(this);
 
     // add nav items to the toolbar
     //
     // NOTE:  The order of the button icons here differs from that
     // found in the file manager and web browser, but has been discussed
     // and agreed upon on the kde-core-devel mailing list:
     //
     // http://lists.kde.org/?l=kde-core-devel&m=116888382514090&w=2
 
     coll->action(QStringLiteral("up"))->setWhatsThis(i18n("<qt>Click this button to enter the parent folder.<br /><br />"
                                           "For instance, if the current location is file:/home/konqi clicking this "
                                           "button will take you to file:/home.</qt>"));
 
     coll->action(QStringLiteral("back"))->setWhatsThis(i18n("Click this button to move backwards one step in the browsing history."));
     coll->action(QStringLiteral("forward"))->setWhatsThis(i18n("Click this button to move forward one step in the browsing history."));
 
     coll->action(QStringLiteral("reload"))->setWhatsThis(i18n("Click this button to reload the contents of the current location."));
     coll->action(QStringLiteral("mkdir"))->setShortcut(QKeySequence(Qt::Key_F10));
     coll->action(QStringLiteral("mkdir"))->setWhatsThis(i18n("Click this button to create a new folder."));
 
     QAction *goToNavigatorAction = coll->addAction(QStringLiteral("gotonavigator"), this, SLOT(_k_activateUrlNavigator()));
     goToNavigatorAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_L));
 
     KToggleAction *showSidebarAction =
         new KToggleAction(i18n("Show Places Navigation Panel"), this);
     coll->addAction(QStringLiteral("toggleSpeedbar"), showSidebarAction);
     showSidebarAction->setShortcut(QKeySequence(Qt::Key_F9));
     connect(showSidebarAction, SIGNAL(toggled(bool)),
             SLOT(_k_toggleSpeedbar(bool)));
 
     KToggleAction *showBookmarksAction =
         new KToggleAction(i18n("Show Bookmarks"), this);
     coll->addAction(QStringLiteral("toggleBookmarks"), showBookmarksAction);
     connect(showBookmarksAction, SIGNAL(toggled(bool)),
             SLOT(_k_toggleBookmarks(bool)));
 
     KActionMenu *menu = new KActionMenu(QIcon::fromTheme(QStringLiteral("configure")), i18n("Options"), this);
     coll->addAction(QStringLiteral("extra menu"), menu);
     menu->setWhatsThis(i18n("<qt>This is the preferences menu for the file dialog. "
                             "Various options can be accessed from this menu including: <ul>"
                             "<li>how files are sorted in the list</li>"
                             "<li>types of view, including icon and list</li>"
                             "<li>showing of hidden files</li>"
                             "<li>the Places navigation panel</li>"
                             "<li>file previews</li>"
                             "<li>separating folders from files</li></ul></qt>"));
     menu->addAction(coll->action(QStringLiteral("view menu")));
     menu->addSeparator();
     menu->addAction(coll->action(QStringLiteral("decoration menu")));
     menu->addSeparator();
     menu->addAction(coll->action(QStringLiteral("show hidden")));
     menu->addAction(showSidebarAction);
     menu->addAction(showBookmarksAction);
     coll->action(QStringLiteral("inline preview"));
     menu->addAction(coll->action(QStringLiteral("preview")));
 
     menu->setDelayed(false);
     connect(menu->menu(), &QMenu::aboutToShow,
             d->ops, &KDirOperator::updateSelectionDependentActions);
 
     d->iconSizeSlider = new QSlider(this);
     d->iconSizeSlider->setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Fixed);
     d->iconSizeSlider->setMinimumWidth(40);
     d->iconSizeSlider->setOrientation(Qt::Horizontal);
     d->iconSizeSlider->setMinimum(0);
     d->iconSizeSlider->setMaximum(100);
     d->iconSizeSlider->installEventFilter(this);
     connect(d->iconSizeSlider, &QAbstractSlider::valueChanged,
             d->ops, &KDirOperator::setIconsZoom);
     connect(d->iconSizeSlider, SIGNAL(valueChanged(int)),
             this, SLOT(_k_slotIconSizeChanged(int)));
     connect(d->iconSizeSlider, SIGNAL(sliderMoved(int)),
             this, SLOT(_k_slotIconSizeSliderMoved(int)));
     connect(d->ops, &KDirOperator::currentIconSizeChanged, [this](int value) {
         d->iconSizeSlider->setValue(value);
         d->zoomOutAction->setDisabled(value <= d->iconSizeSlider->minimum());
         d->zoomInAction->setDisabled(value >= d->iconSizeSlider->maximum());
     });
 
     d->zoomOutAction = new QAction(QIcon::fromTheme(QStringLiteral("file-zoom-out")), i18n("Zoom out"), this);
     connect(d->zoomOutAction, SIGNAL(triggered()), SLOT(_k_zoomOutIconsSize()));
     d->zoomInAction = new QAction(QIcon::fromTheme(QStringLiteral("file-zoom-in")), i18n("Zoom in"), this);
     connect(d->zoomInAction, SIGNAL(triggered()), SLOT(_k_zoomInIconsSize()));
 
     QWidget *midSpacer = new QWidget(this);
     midSpacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 
     d->toolbar->addAction(coll->action(QStringLiteral("back")));
     d->toolbar->addAction(coll->action(QStringLiteral("forward")));
     d->toolbar->addAction(coll->action(QStringLiteral("up")));
     d->toolbar->addAction(coll->action(QStringLiteral("reload")));
     d->toolbar->addSeparator();
     d->toolbar->addAction(coll->action(QStringLiteral("inline preview")));
     d->toolbar->addAction(coll->action(QStringLiteral("sorting menu")));
     d->toolbar->addWidget(midSpacer);
     d->toolbar->addAction(d->zoomOutAction);
     d->toolbar->addWidget(d->iconSizeSlider);
     d->toolbar->addAction(d->zoomInAction);
     d->toolbar->addSeparator();
     d->toolbar->addAction(coll->action(QStringLiteral("mkdir")));
     d->toolbar->addAction(menu);
 
     d->toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
     d->toolbar->setMovable(false);
 
     KUrlCompletion *pathCompletionObj = new KUrlCompletion(KUrlCompletion::DirCompletion);
     pathCombo->setCompletionObject(pathCompletionObj);
     pathCombo->setAutoDeleteCompletionObject(true);
 
     connect(d->urlNavigator, SIGNAL(urlChanged(QUrl)),
             this,  SLOT(_k_enterUrl(QUrl)));
     connect(d->urlNavigator, &KUrlNavigator::returnPressed,
             d->ops, QOverload<>::of(&QWidget::setFocus));
 
     QString whatsThisText;
 
     // the Location label/edit
     d->locationLabel = new QLabel(i18n("&Name:"), this);
     d->locationEdit = new KUrlComboBox(KUrlComboBox::Files, true, this);
     d->locationEdit->installEventFilter(this);
     // Properly let the dialog be resized (to smaller). Otherwise we could have
     // huge dialogs that can't be resized to smaller (it would be as big as the longest
     // item in this combo box). (ereslibre)
     d->locationEdit->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
     connect(d->locationEdit, SIGNAL(editTextChanged(QString)),
             SLOT(_k_slotLocationChanged(QString)));
 
     d->updateLocationWhatsThis();
     d->locationLabel->setBuddy(d->locationEdit);
 
     KUrlCompletion *fileCompletionObj = new KUrlCompletion(KUrlCompletion::FileCompletion);
     d->locationEdit->setCompletionObject(fileCompletionObj);
     d->locationEdit->setAutoDeleteCompletionObject(true);
     connect(fileCompletionObj, SIGNAL(match(QString)),
             SLOT(_k_fileCompletion(QString)));
 
     connect(d->locationEdit, SIGNAL(returnPressed(QString)),
             this,  SLOT(_k_locationAccepted(QString)));
 
     // the Filter label/edit
     whatsThisText = i18n("<qt>This is the filter to apply to the file list. "
                          "File names that do not match the filter will not be shown.<p>"
                          "You may select from one of the preset filters in the "
                          "drop down menu, or you may enter a custom filter "
                          "directly into the text area.</p><p>"
                          "Wildcards such as * and ? are allowed.</p></qt>");
     d->filterLabel = new QLabel(i18n("&Filter:"), this);
     d->filterLabel->setWhatsThis(whatsThisText);
     d->filterWidget = new KFileFilterCombo(this);
     // Properly let the dialog be resized (to smaller). Otherwise we could have
     // huge dialogs that can't be resized to smaller (it would be as big as the longest
     // item in this combo box). (ereslibre)
     d->filterWidget->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
     d->filterWidget->setWhatsThis(whatsThisText);
     d->filterLabel->setBuddy(d->filterWidget);
     connect(d->filterWidget, SIGNAL(filterChanged()), SLOT(_k_slotFilterChanged()));
 
     d->filterDelayTimer.setSingleShot(true);
     d->filterDelayTimer.setInterval(300);
     connect(d->filterWidget, &QComboBox::editTextChanged, &d->filterDelayTimer, QOverload<>::of(&QTimer::start));
     connect(&d->filterDelayTimer, SIGNAL(timeout()), SLOT(_k_slotFilterChanged()));
 
     // the Automatically Select Extension checkbox
     // (the text, visibility etc. is set in updateAutoSelectExtension(), which is called by readConfig())
     d->autoSelectExtCheckBox = new QCheckBox(this);
     const int spacingHint = style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
     d->autoSelectExtCheckBox->setStyleSheet(QStringLiteral("QCheckBox { padding-top: %1px; }").arg(spacingHint));
     connect(d->autoSelectExtCheckBox, SIGNAL(clicked()), SLOT(_k_slotAutoSelectExtClicked()));
 
     d->initGUI(); // activate GM
 
     // read our configuration
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup group(config, ConfigGroup);
     readConfig(group);
 
     coll->action(QStringLiteral("inline preview"))->setChecked(d->ops->isInlinePreviewShown());
     d->iconSizeSlider->setValue(d->ops->iconsZoom());
 
     KFilePreviewGenerator *pg = d->ops->previewGenerator();
     if (pg) {
         coll->action(QStringLiteral("inline preview"))->setChecked(pg->isPreviewShown());
     }
 
     // getStartUrl() above will have resolved the startDir parameter into
     // a directory and file name in the two cases: (a) where it is a
     // special "kfiledialog:" URL, or (b) where it is a plain file name
     // only without directory or protocol.  For any other startDir
     // specified, it is not possible to resolve whether there is a file name
     // present just by looking at the URL; the only way to be sure is
     // to stat it.
     bool statRes = false;
     if (filename.isEmpty()) {
         KIO::StatJob *statJob = KIO::stat(startDir, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, this);
         statRes = statJob->exec();
         // qDebug() << "stat of" << startDir << "-> statRes" << statRes << "isDir" << statJob->statResult().isDir();
         if (!statRes || !statJob->statResult().isDir()) {
             filename = startDir.fileName();
             startDir = startDir.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
             // qDebug() << "statJob -> startDir" << startDir << "filename" << filename;
         }
     }
 
     d->ops->setUrl(startDir, true);
     d->urlNavigator->setLocationUrl(startDir);
     if (d->placesView) {
         d->placesView->setUrl(startDir);
     }
 
     // We have a file name either explicitly specified, or have checked that
     // we could stat it and it is not a directory.  Set it.
     if (!filename.isEmpty()) {
         QLineEdit *lineEdit = d->locationEdit->lineEdit();
         // qDebug() << "selecting filename" << filename;
         if (statRes) {
             d->setLocationText(QUrl(filename));
         } else {
             lineEdit->setText(filename);
             // Preserve this filename when clicking on the view (cf _k_fileHighlighted)
             lineEdit->setModified(true);
         }
         lineEdit->selectAll();
     }
 
     d->locationEdit->setFocus();
 }
 
 KFileWidget::~KFileWidget()
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     config->sync();
 
     delete d;
 }
 
 void KFileWidget::setLocationLabel(const QString &text)
 {
     d->locationLabel->setText(text);
 }
 
 void KFileWidget::setFilter(const QString &filter)
 {
     int pos = filter.indexOf(QLatin1Char('/'));
 
     // Check for an un-escaped '/', if found
     // interpret as a MIME filter.
 
     if (pos > 0 && filter[pos - 1] != QLatin1Char('\\')) {
         QStringList filters = filter.split(QLatin1Char(' '), QString::SkipEmptyParts);
         setMimeFilter(filters);
         return;
     }
 
     // Strip the escape characters from
     // escaped '/' characters.
 
     QString copy(filter);
     for (pos = 0; (pos = copy.indexOf(QStringLiteral("\\/"), pos)) != -1; ++pos) {
         copy.remove(pos, 1);
     }
 
     d->ops->clearFilter();
     d->filterWidget->setFilter(copy);
     d->ops->setNameFilter(d->filterWidget->currentFilter());
     d->ops->updateDir();
     d->hasDefaultFilter = false;
     d->filterWidget->setEditable(true);
 
     d->updateAutoSelectExtension();
 }
 
 QString KFileWidget::currentFilter() const
 {
     return d->filterWidget->currentFilter();
 }
 
 void KFileWidget::setMimeFilter(const QStringList &mimeTypes,
                                 const QString &defaultType)
 {
     d->filterWidget->setMimeFilter(mimeTypes, defaultType);
 
     QStringList types = d->filterWidget->currentFilter().split(QLatin1Char(' '), QString::SkipEmptyParts); //QStringList::split(" ", d->filterWidget->currentFilter());
     types.append(QStringLiteral("inode/directory"));
     d->ops->clearFilter();
     d->ops->setMimeFilter(types);
     d->hasDefaultFilter = !defaultType.isEmpty();
     d->filterWidget->setEditable(!d->hasDefaultFilter ||
                                  d->operationMode != Saving);
 
     d->updateAutoSelectExtension();
 }
 
 void KFileWidget::clearFilter()
 {
     d->filterWidget->setFilter(QString());
     d->ops->clearFilter();
     d->hasDefaultFilter = false;
     d->filterWidget->setEditable(true);
 
     d->updateAutoSelectExtension();
 }
 
 QString KFileWidget::currentMimeFilter() const
 {
     int i = d->filterWidget->currentIndex();
     if (d->filterWidget->showsAllTypes() && i == 0) {
         return QString();    // The "all types" item has no mimetype
     }
 
     return d->filterWidget->filters().at(i);
 }
 
 QMimeType KFileWidget::currentFilterMimeType()
 {
     QMimeDatabase db;
     return db.mimeTypeForName(currentMimeFilter());
 }
 
 void KFileWidget::setPreviewWidget(KPreviewWidgetBase *w)
 {
     d->ops->setPreviewWidget(w);
     d->ops->clearHistory();
     d->hasView = true;
 }
 
 QUrl KFileWidgetPrivate::getCompleteUrl(const QString &_url) const
 {
 //     qDebug() << "got url " << _url;
 
     const QString url = KShell::tildeExpand(_url);
     QUrl u;
 
     if (QDir::isAbsolutePath(url)) {
         u = QUrl::fromLocalFile(url);
     } else {
         QUrl relativeUrlTest(ops->url());
         relativeUrlTest.setPath(concatPaths(relativeUrlTest.path(), url));
         if (!ops->dirLister()->findByUrl(relativeUrlTest).isNull() ||
                 !KProtocolInfo::isKnownProtocol(relativeUrlTest)) {
             u = relativeUrlTest;
         } else {
             u = QUrl(url); // keep it relative
         }
     }
 
     return u;
 }
 
 QSize KFileWidget::sizeHint() const
 {
     int fontSize = fontMetrics().height();
     const QSize goodSize(48 * fontSize, 30 * fontSize);
     const QSize screenSize = QApplication::desktop()->availableGeometry(this).size();
     const QSize minSize(screenSize / 2);
     const QSize maxSize(screenSize * qreal(0.9));
     return (goodSize.expandedTo(minSize).boundedTo(maxSize));
 }
 
 static QString relativePathOrUrl(const QUrl &baseUrl, const QUrl &url);
 
 // Called by KFileDialog
 void KFileWidget::slotOk()
 {
 //     qDebug() << "slotOk\n";
 
     const QString locationEditCurrentText(KShell::tildeExpand(d->locationEditCurrentText()));
 
     QList<QUrl> locationEditCurrentTextList(d->tokenize(locationEditCurrentText));
     KFile::Modes mode = d->ops->mode();
 
     // if there is nothing to do, just return from here
     if (locationEditCurrentTextList.isEmpty()) {
         return;
     }
 
     // Make sure that one of the modes was provided
     if (!((mode & KFile::File) || (mode & KFile::Directory) || (mode & KFile::Files))) {
         mode |= KFile::File;
         // qDebug() << "No mode() provided";
     }
 
     // if we are on file mode, and the list of provided files/folder is greater than one, inform
     // the user about it
     if (locationEditCurrentTextList.count() > 1) {
         if (mode & KFile::File) {
             KMessageBox::sorry(this,
                                i18n("You can only select one file"),
                                i18n("More than one file provided"));
             return;
         }
 
         /**
           * Logic of the next part of code (ends at "end multi relative urls").
           *
           * We allow for instance to be at "/" and insert '"home/foo/bar.txt" "boot/grub/menu.lst"'.
           * Why we need to support this ? Because we provide tree views, which aren't plain.
           *
           * Now, how does this logic work. It will get the first element on the list (with no filename),
           * following the previous example say "/home/foo" and set it as the top most url.
           *
           * After this, it will iterate over the rest of items and check if this URL (topmost url)
           * contains the url being iterated.
           *
           * As you might have guessed it will do "/home/foo" against "/boot/grub" (again stripping
           * filename), and a false will be returned. Then we upUrl the top most url, resulting in
           * "/home" against "/boot/grub", what will again return false, so we upUrl again. Now we
           * have "/" against "/boot/grub", what returns true for us, so we can say that the closest
           * common ancestor of both is "/".
           *
           * This example has been written for 2 urls, but this works for any number of urls.
           */
         if (!d->differentHierarchyLevelItemsEntered) {     // avoid infinite recursion. running this
             int start = 0;
             QUrl topMostUrl;
             KIO::StatJob *statJob = nullptr;
             bool res = false;
 
             // we need to check for a valid first url, so in theory we only iterate one time over
             // this loop. However it can happen that the user did
             // "home/foo/nonexistantfile" "boot/grub/menu.lst", so we look for a good first
             // candidate.
             while (!res && start < locationEditCurrentTextList.count()) {
                 topMostUrl = locationEditCurrentTextList.at(start);
                 statJob = KIO::stat(topMostUrl, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(statJob, this);
                 res = statJob->exec();
                 start++;
             }
 
             Q_ASSERT(statJob);
 
             // if this is not a dir, strip the filename. after this we have an existent and valid
             // dir (we stated correctly the file).
             if (!statJob->statResult().isDir()) {
                 topMostUrl = topMostUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
             }
 
             // now the funny part. for the rest of filenames, go and look for the closest ancestor
             // of all them.
             for (int i = start; i < locationEditCurrentTextList.count(); ++i) {
                 QUrl currUrl = locationEditCurrentTextList.at(i);
                 KIO::StatJob *statJob = KIO::stat(currUrl, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(statJob, this);
                 int res = statJob->exec();
                 if (res) {
                     // again, we don't care about filenames
                     if (!statJob->statResult().isDir()) {
                         currUrl = currUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
                     }
 
                     // iterate while this item is contained on the top most url
                     while (!topMostUrl.matches(currUrl, QUrl::StripTrailingSlash) && !topMostUrl.isParentOf(currUrl)) {
                         topMostUrl = KIO::upUrl(topMostUrl);
                     }
                 }
             }
 
             // now recalculate all paths for them being relative in base of the top most url
             QStringList stringList;
             stringList.reserve(locationEditCurrentTextList.count());
             for (int i = 0; i < locationEditCurrentTextList.count(); ++i) {
                 Q_ASSERT(topMostUrl.isParentOf(locationEditCurrentTextList[i]));
                 stringList << relativePathOrUrl(topMostUrl, locationEditCurrentTextList[i]);
             }
 
             d->ops->setUrl(topMostUrl, true);
             const bool signalsBlocked = d->locationEdit->lineEdit()->blockSignals(true);
             d->locationEdit->lineEdit()->setText(QStringLiteral("\"%1\"").arg(stringList.join(QStringLiteral("\" \""))));
             d->locationEdit->lineEdit()->blockSignals(signalsBlocked);
 
             d->differentHierarchyLevelItemsEntered = true;
             slotOk();
             return;
         }
         /**
           * end multi relative urls
           */
     } else if (!locationEditCurrentTextList.isEmpty()) {
         // if we are on file or files mode, and we have an absolute url written by
         // the user, convert it to relative
         if (!locationEditCurrentText.isEmpty() && !(mode & KFile::Directory) &&
                 (QDir::isAbsolutePath(locationEditCurrentText) ||
                  containsProtocolSection(locationEditCurrentText))) {
 
             QString fileName;
             QUrl url = urlFromString(locationEditCurrentText);
             if (d->operationMode == Opening) {
                 KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(statJob, this);
                 int res = statJob->exec();
                 if (res) {
                     if (!statJob->statResult().isDir()) {
                         fileName = url.fileName();
                         url = url.adjusted(QUrl::RemoveFilename); // keeps trailing slash
                     } else {
                         if (!url.path().endsWith(QLatin1Char('/'))) {
                             url.setPath(url.path() + QLatin1Char('/'));
                         }
                     }
                 }
             } else {
                 const QUrl directory = url.adjusted(QUrl::RemoveFilename);
                 //Check if the folder exists
                 KIO::StatJob *statJob = KIO::stat(directory, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(statJob, this);
                 int res = statJob->exec();
                 if (res) {
                     if (statJob->statResult().isDir()) {
                         url = url.adjusted(QUrl::StripTrailingSlash);
                         fileName = url.fileName();
                         url = url.adjusted(QUrl::RemoveFilename);
                     }
                 }
             }
             d->ops->setUrl(url, true);
             const bool signalsBlocked = d->locationEdit->lineEdit()->blockSignals(true);
             d->locationEdit->lineEdit()->setText(fileName);
             d->locationEdit->lineEdit()->blockSignals(signalsBlocked);
             slotOk();
             return;
         }
     }
 
     // restore it
     d->differentHierarchyLevelItemsEntered = false;
 
     // locationEditCurrentTextList contains absolute paths
     // this is the general loop for the File and Files mode. Obviously we know
     // that the File mode will iterate only one time here
     bool directoryMode = (mode & KFile::Directory);
     bool onlyDirectoryMode = directoryMode && !(mode & KFile::File) && !(mode & KFile::Files);
     QList<QUrl>::ConstIterator it = locationEditCurrentTextList.constBegin();
     bool filesInList = false;
     while (it != locationEditCurrentTextList.constEnd()) {
         QUrl url(*it);
 
         if (d->operationMode == Saving && !directoryMode) {
             d->appendExtension(url);
         }
 
         d->url = url;
         KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, this);
         int res = statJob->exec();
 
         if (!KUrlAuthorized::authorizeUrlAction(QStringLiteral("open"), QUrl(), url)) {
             QString msg = KIO::buildErrorString(KIO::ERR_ACCESS_DENIED, d->url.toDisplayString());
             KMessageBox::error(this, msg);
             return;
         }
 
         // if we are on local mode, make sure we haven't got a remote base url
         if ((mode & KFile::LocalOnly) && !d->mostLocalUrl(d->url).isLocalFile()) {
             KMessageBox::sorry(this,
                                i18n("You can only select local files"),
                                i18n("Remote files not accepted"));
             return;
         }
 
         const auto &supportedSchemes = d->model->supportedSchemes();
         if (!supportedSchemes.isEmpty() && !supportedSchemes.contains(d->url.scheme())) {
             KMessageBox::sorry(this,
                                i18np("The selected URL uses an unsupported scheme. "
                                      "Please use the following scheme: %2",
                                      "The selected URL uses an unsupported scheme. "
                                      "Please use one of the following schemes: %2",
                                      supportedSchemes.size(),
                                      supportedSchemes.join(QLatin1String(", "))),
                                i18n("Unsupported URL scheme"));
             return;
         }
 
         // if we are given a folder when not on directory mode, let's get into it
         if (res && !directoryMode && statJob->statResult().isDir()) {
             // check if we were given more than one folder, in that case we don't know to which one
             // cd
             ++it;
             while (it != locationEditCurrentTextList.constEnd()) {
                 QUrl checkUrl(*it);
                 KIO::StatJob *checkStatJob = KIO::stat(checkUrl, KIO::HideProgressInfo);
                 KJobWidgets::setWindow(checkStatJob, this);
                 bool res = checkStatJob->exec();
                 if (res && checkStatJob->statResult().isDir()) {
                     KMessageBox::sorry(this, i18n("More than one folder has been selected and this dialog does not accept folders, so it is not possible to decide which one to enter. Please select only one folder to list it."), i18n("More than one folder provided"));
                     return;
                 } else if (res) {
                     filesInList = true;
                 }
                 ++it;
             }
             if (filesInList) {
                 KMessageBox::information(this, i18n("At least one folder and one file has been selected. Selected files will be ignored and the selected folder will be listed"), i18n("Files and folders selected"));
             }
             d->ops->setUrl(url, true);
             const bool signalsBlocked = d->locationEdit->lineEdit()->blockSignals(true);
             d->locationEdit->lineEdit()->setText(QString());
             d->locationEdit->lineEdit()->blockSignals(signalsBlocked);
             return;
         } else if (res && onlyDirectoryMode && !statJob->statResult().isDir()) {
             // if we are given a file when on directory only mode, reject it
             return;
         } else if (!(mode & KFile::ExistingOnly) || res) {
             // if we don't care about ExistingOnly flag, add the file even if
             // it doesn't exist. If we care about it, don't add it to the list
             if (!onlyDirectoryMode || (res && statJob->statResult().isDir())) {
                 d->urlList << url;
             }
             filesInList = true;
         } else {
             KMessageBox::sorry(this, i18n("The file \"%1\" could not be found", url.toDisplayString(QUrl::PreferLocalFile)), i18n("Cannot open file"));
             return; // do not emit accepted() if we had ExistingOnly flag and stat failed
         }
 
         if ((d->operationMode == Saving) && d->confirmOverwrite && !d->toOverwrite(url)) {
             return;
         }
 
         ++it;
     }
 
     // if we have reached this point and we didn't return before, that is because
     // we want this dialog to be accepted
     emit accepted();
 }
 
 void KFileWidget::accept()
 {
     d->inAccept = true; // parseSelectedUrls() checks that
 
     *lastDirectory() = d->ops->url();
     if (!d->fileClass.isEmpty()) {
         KRecentDirs::add(d->fileClass, d->ops->url().toString());
     }
 
     // clear the topmost item, we insert it as full path later on as item 1
     d->locationEdit->setItemText(0, QString());
 
     const QList<QUrl> list = selectedUrls();
     QList<QUrl>::const_iterator it = list.begin();
     int atmost = d->locationEdit->maxItems(); //don't add more items than necessary
     for (; it != list.end() && atmost > 0; ++it) {
         const QUrl &url = *it;
         // we strip the last slash (-1) because KUrlComboBox does that as well
         // when operating in file-mode. If we wouldn't , dupe-finding wouldn't
         // work.
         QString file = url.isLocalFile() ? url.toLocalFile() : url.toDisplayString();
 
         // remove dupes
         for (int i = 1; i < d->locationEdit->count(); i++) {
             if (d->locationEdit->itemText(i) == file) {
                 d->locationEdit->removeItem(i--);
                 break;
             }
         }
         //FIXME I don't think this works correctly when the KUrlComboBox has some default urls.
         //KUrlComboBox should provide a function to add an url and rotate the existing ones, keeping
         //track of maxItems, and we shouldn't be able to insert items as we please.
         d->locationEdit->insertItem(1, file);
         atmost--;
     }
 
     d->writeViewConfig();
     d->saveRecentFiles();
 
     d->addToRecentDocuments();
 
     if (!(mode() & KFile::Files)) { // single selection
         emit fileSelected(d->url);
     }
 
     d->ops->close();
 }
 
 void KFileWidgetPrivate::_k_fileHighlighted(const KFileItem &i)
 {
     if ((!i.isNull() && i.isDir()) ||
             (locationEdit->hasFocus() && !locationEdit->currentText().isEmpty())) { // don't disturb
         return;
     }
 
     const bool modified = locationEdit->lineEdit()->isModified();
 
     if (!(ops->mode() & KFile::Files)) {
         if (i.isNull()) {
             if (!modified) {
                 setLocationText(QUrl());
             }
             return;
         }
 
         url = i.url();
 
         if (!locationEdit->hasFocus()) { // don't disturb while editing
             setLocationText(url);
         }
 
         emit q->fileHighlighted(url);
     } else {
         multiSelectionChanged();
         emit q->selectionChanged();
     }
 
     locationEdit->lineEdit()->setModified(false);
 }
 
 void KFileWidgetPrivate::_k_fileSelected(const KFileItem &i)
 {
     if (!i.isNull() && i.isDir()) {
         return;
     }
 
     if (!(ops->mode() & KFile::Files)) {
         if (i.isNull()) {
             setLocationText(QUrl());
             return;
         }
         setLocationText(i.url());
     } else {
         multiSelectionChanged();
         emit q->selectionChanged();
     }
 
     // If we are saving, let another chance to the user before accepting the dialog (or trying to
     // accept). This way the user can choose a file and add a "_2" for instance to the filename.
     // Double clicking however will override this, regardless of single/double click mouse setting,
     // see: _k_slotViewDoubleClicked
     if (operationMode == KFileWidget::Saving) {
         locationEdit->setFocus();
     } else {
         q->slotOk();
     }
 }
 
 // I know it's slow to always iterate thru the whole filelist
 // (d->ops->selectedItems()), but what can we do?
 void KFileWidgetPrivate::multiSelectionChanged()
 {
     if (locationEdit->hasFocus() && !locationEdit->currentText().isEmpty()) { // don't disturb
         return;
     }
 
     const KFileItemList list = ops->selectedItems();
 
     if (list.isEmpty()) {
         setLocationText(QUrl());
         return;
     }
 
     setLocationText(list.urlList());
 }
 
 void KFileWidgetPrivate::setDummyHistoryEntry(const QString &text, const QPixmap &icon,
         bool usePreviousPixmapIfNull)
 {
     // setCurrentItem() will cause textChanged() being emitted,
     // so slotLocationChanged() will be called. Make sure we don't clear
     // the KDirOperator's view-selection in there
     QObject::disconnect(locationEdit, SIGNAL(editTextChanged(QString)),
                         q, SLOT(_k_slotLocationChanged(QString)));
 
     bool dummyExists = dummyAdded;
 
     int cursorPosition = locationEdit->lineEdit()->cursorPosition();
 
     if (dummyAdded) {
         if (!icon.isNull()) {
             locationEdit->setItemIcon(0, icon);
             locationEdit->setItemText(0, text);
         } else {
             if (!usePreviousPixmapIfNull) {
                 locationEdit->setItemIcon(0, QPixmap());
             }
             locationEdit->setItemText(0, text);
         }
     } else {
         if (!text.isEmpty()) {
             if (!icon.isNull()) {
                 locationEdit->insertItem(0, icon, text);
             } else {
                 if (!usePreviousPixmapIfNull) {
                     locationEdit->insertItem(0, QPixmap(), text);
                 } else {
                     locationEdit->insertItem(0, text);
                 }
             }
             dummyAdded = true;
             dummyExists = true;
         }
     }
 
     if (dummyExists && !text.isEmpty()) {
         locationEdit->setCurrentIndex(0);
     }
 
     locationEdit->lineEdit()->setCursorPosition(cursorPosition);
 
     QObject::connect(locationEdit, SIGNAL(editTextChanged(QString)),
                      q, SLOT(_k_slotLocationChanged(QString)));
 }
 
 void KFileWidgetPrivate::removeDummyHistoryEntry()
 {
     if (!dummyAdded) {
         return;
     }
 
     // setCurrentItem() will cause textChanged() being emitted,
     // so slotLocationChanged() will be called. Make sure we don't clear
     // the KDirOperator's view-selection in there
     QObject::disconnect(locationEdit, SIGNAL(editTextChanged(QString)),
                         q, SLOT(_k_slotLocationChanged(QString)));
 
     if (locationEdit->count()) {
         locationEdit->removeItem(0);
     }
     locationEdit->setCurrentIndex(-1);
     dummyAdded = false;
 
     QObject::connect(locationEdit, SIGNAL(editTextChanged(QString)),
                      q, SLOT(_k_slotLocationChanged(QString)));
 }
 
 void KFileWidgetPrivate::setLocationText(const QUrl &url)
 {
     if (!url.isEmpty()) {
         QPixmap mimeTypeIcon = KIconLoader::global()->loadMimeTypeIcon(KIO::iconNameForUrl(url), KIconLoader::Small);
         if (!url.isRelative()) {
             const QUrl directory = url.adjusted(QUrl::RemoveFilename);
             if (!directory.path().isEmpty()) {
                 q->setUrl(directory, false);
             } else {
                 q->setUrl(url, false);
             }
         }
         setDummyHistoryEntry(url.fileName(), mimeTypeIcon);
     } else {
         removeDummyHistoryEntry();
     }
 
     if (operationMode == KFileWidget::Saving) {
         setNonExtSelection();
     }
 }
 
 static QString relativePathOrUrl(const QUrl &baseUrl, const QUrl &url)
 {
     if (baseUrl.isParentOf(url)) {
         const QString basePath(QDir::cleanPath(baseUrl.path()));
         QString relPath(QDir::cleanPath(url.path()));
         relPath.remove(0, basePath.length());
         if (relPath.startsWith(QLatin1Char('/'))) {
             relPath.remove(0, 1);
         }
         return relPath;
     } else {
         return url.toDisplayString();
     }
 }
 
 void KFileWidgetPrivate::setLocationText(const QList<QUrl> &urlList)
 {
     const QUrl currUrl = ops->url();
 
     if (urlList.count() > 1) {
         QString urls;
         foreach (const QUrl &url, urlList) {
             urls += QStringLiteral("\"%1\"").arg(relativePathOrUrl(currUrl, url)) + QLatin1Char(' ');
         }
         urls.chop(1);
 
         setDummyHistoryEntry(urls, QPixmap(), false);
     } else if (urlList.count() == 1) {
         const QPixmap mimeTypeIcon = KIconLoader::global()->loadMimeTypeIcon(KIO::iconNameForUrl(urlList[0]),  KIconLoader::Small);
         setDummyHistoryEntry(relativePathOrUrl(currUrl, urlList[0]), mimeTypeIcon);
     } else {
         removeDummyHistoryEntry();
     }
 
     if (operationMode == KFileWidget::Saving) {
         setNonExtSelection();
     }
 }
 
 void KFileWidgetPrivate::updateLocationWhatsThis()
 {
     QString whatsThisText;
     if (operationMode == KFileWidget::Saving) {
         whatsThisText = QLatin1String("<qt>") + i18n("This is the name to save the file as.") +
                         i18n(autocompletionWhatsThisText);
     } else if (ops->mode() & KFile::Files) {
         whatsThisText = QLatin1String("<qt>") + i18n("This is the list of files to open. More than "
                                       "one file can be specified by listing several "
                                       "files, separated by spaces.") +
                         i18n(autocompletionWhatsThisText);
     } else {
         whatsThisText = QLatin1String("<qt>") + i18n("This is the name of the file to open.") +
                         i18n(autocompletionWhatsThisText);
     }
 
     locationLabel->setWhatsThis(whatsThisText);
     locationEdit->setWhatsThis(whatsThisText);
 }
 
 void KFileWidgetPrivate::initSpeedbar()
 {
     if (placesDock) {
         return;
     }
 
     placesDock = new QDockWidget(i18nc("@title:window", "Places"), q);
     placesDock->setFeatures(QDockWidget::NoDockWidgetFeatures);
     placesDock->setTitleBarWidget(new KDEPrivate::KFileWidgetDockTitleBar(placesDock));
 
     placesView = new KFilePlacesView(placesDock);
     placesView->setModel(model);
     placesView->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
 
     placesView->setObjectName(QStringLiteral("url bar"));
     QObject::connect(placesView, SIGNAL(urlChanged(QUrl)),
                      q, SLOT(_k_enterUrl(QUrl)));
 
     // need to set the current url of the urlbar manually (not via urlEntered()
     // here, because the initial url of KDirOperator might be the same as the
     // one that will be set later (and then urlEntered() won't be emitted).
     // TODO: KDE5 ### REMOVE THIS when KDirOperator's initial URL (in the c'tor) is gone.
     placesView->setUrl(url);
 
     placesDock->setWidget(placesView);
     placesViewSplitter->insertWidget(0, placesDock);
 
     // initialize the size of the splitter
     placesViewWidth = configGroup.readEntry(SpeedbarWidth, placesView->sizeHint().width());
 
     // Needed for when the dialog is shown with the places panel initially hidden
     setPlacesViewSplitterSizes();
 
     QObject::connect(placesDock, SIGNAL(visibilityChanged(bool)),
                      q, SLOT(_k_toggleSpeedbar(bool)));
 }
 
 void KFileWidgetPrivate::setPlacesViewSplitterSizes()
 {
     if (placesViewWidth > 0) {
         QList<int> sizes = placesViewSplitter->sizes();
         sizes[0] = placesViewWidth;
         sizes[1] = q->width() - placesViewWidth - placesViewSplitter->handleWidth();
         placesViewSplitter->setSizes(sizes);
     }
 }
 
 void KFileWidgetPrivate::setLafBoxColumnWidth()
 {
     // In order to perfectly align the filename widget with KDirOperator's icon view
     // - placesViewWidth needs to account for the size of the splitter handle
     // - the lafBox grid layout spacing should only affect the label, but not the line edit
     const int adjustment = placesViewSplitter->handleWidth() - lafBox->horizontalSpacing();
     lafBox->setColumnMinimumWidth(0, placesViewWidth + adjustment);
 }
 
 void KFileWidgetPrivate::initGUI()
 {
     delete boxLayout; // deletes all sub layouts
 
     boxLayout = new QVBoxLayout(q);
-    boxLayout->setMargin(0); // no additional margin to the already existing
+    boxLayout->setContentsMargins(0, 0, 0, 0); // no additional margin to the already existing
 
     placesViewSplitter = new QSplitter(q);
     placesViewSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     placesViewSplitter->setChildrenCollapsible(false);
     boxLayout->addWidget(placesViewSplitter);
 
     QObject::connect(placesViewSplitter, SIGNAL(splitterMoved(int,int)),
                      q, SLOT(_k_placesViewSplitterMoved(int,int)));
     placesViewSplitter->insertWidget(0, opsWidget);
 
     vbox = new QVBoxLayout();
-    vbox->setMargin(0);
+    vbox->setContentsMargins(0, 0, 0, 0);
     boxLayout->addLayout(vbox);
 
     lafBox = new QGridLayout();
 
     lafBox->addWidget(locationLabel, 0, 0, Qt::AlignVCenter | Qt::AlignRight);
     lafBox->addWidget(locationEdit, 0, 1, Qt::AlignVCenter);
     lafBox->addWidget(okButton, 0, 2, Qt::AlignVCenter);
 
     lafBox->addWidget(filterLabel, 1, 0, Qt::AlignVCenter | Qt::AlignRight);
     lafBox->addWidget(filterWidget, 1, 1, Qt::AlignVCenter);
     lafBox->addWidget(cancelButton, 1, 2, Qt::AlignVCenter);
 
     lafBox->setColumnStretch(1, 4);
 
     vbox->addLayout(lafBox);
 
     // add the Automatically Select Extension checkbox
     vbox->addWidget(autoSelectExtCheckBox);
 
     q->setTabOrder(ops, autoSelectExtCheckBox);
     q->setTabOrder(autoSelectExtCheckBox, locationEdit);
     q->setTabOrder(locationEdit, filterWidget);
     q->setTabOrder(filterWidget, okButton);
     q->setTabOrder(okButton, cancelButton);
     q->setTabOrder(cancelButton, urlNavigator);
     q->setTabOrder(urlNavigator, ops);
 }
 
 void KFileWidgetPrivate::_k_slotFilterChanged()
 {
 //     qDebug();
 
     filterDelayTimer.stop();
 
     QString filter = filterWidget->currentFilter();
     ops->clearFilter();
 
     if (filter.contains(QLatin1Char('/'))) {
         QStringList types = filter.split(QLatin1Char(' '), QString::SkipEmptyParts);
         types.prepend(QStringLiteral("inode/directory"));
         ops->setMimeFilter(types);
     } else if (filter.contains(QLatin1Char('*')) || filter.contains(QLatin1Char('?')) || filter.contains(QLatin1Char('['))) {
         ops->setNameFilter(filter);
     } else {
         ops->setNameFilter(QLatin1Char('*') + filter.replace(QLatin1Char(' '), QLatin1Char('*')) + QLatin1Char('*'));
     }
 
     updateAutoSelectExtension();
 
     ops->updateDir();
 
     emit q->filterChanged(filter);
 }
 
 void KFileWidget::setUrl(const QUrl &url, bool clearforward)
 {
 //     qDebug();
 
     d->ops->setUrl(url, clearforward);
 }
 
 // Protected
 void KFileWidgetPrivate::_k_urlEntered(const QUrl &url)
 {
 //     qDebug();
 
     QString filename = locationEditCurrentText();
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     if (pathCombo->count() != 0) { // little hack
         pathCombo->setUrl(url);
     }
 
     bool blocked = locationEdit->blockSignals(true);
     if (keepLocation) {
         QUrl currentUrl = urlFromString(filename);
         locationEdit->changeUrl(0, QIcon::fromTheme(KIO::iconNameForUrl(currentUrl)), currentUrl);
         locationEdit->lineEdit()->setModified(true);
     }
 
     locationEdit->blockSignals(blocked);
 
     urlNavigator->setLocationUrl(url);
 
     // is trigged in ctor before completion object is set
     KUrlCompletion *completion = dynamic_cast<KUrlCompletion *>(locationEdit->completionObject());
     if (completion) {
         completion->setDir(url);
     }
 
     if (placesView) {
         placesView->setUrl(url);
     }
 }
 
 void KFileWidgetPrivate::_k_locationAccepted(const QString &url)
 {
     Q_UNUSED(url);
 //     qDebug();
     q->slotOk();
 }
 
 void KFileWidgetPrivate::_k_enterUrl(const QUrl &url)
 {
 //     qDebug();
 
     // append '/' if needed: url combo does not add it
     // tokenize() expects it because it uses QUrl::adjusted(QUrl::RemoveFilename)
     QUrl u(url);
     if (!u.path().isEmpty() && !u.path().endsWith(QLatin1Char('/'))) {
         u.setPath(u.path() + QLatin1Char('/'));
     }
     q->setUrl(u);
 
     // We need to check window()->focusWidget() instead of locationEdit->hasFocus
     // because when the window is showing up locationEdit
     // may still not have focus but it'll be the one that will have focus when the window
     // gets it and we don't want to steal its focus either
     if (q->window()->focusWidget() != locationEdit) {
         ops->setFocus();
     }
 }
 
 void KFileWidgetPrivate::_k_enterUrl(const QString &url)
 {
 //     qDebug();
 
     _k_enterUrl(urlFromString(KUrlCompletion::replacedPath(url, true, true)));
 }
 
 bool KFileWidgetPrivate::toOverwrite(const QUrl &url)
 {
 //     qDebug();
 
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     KJobWidgets::setWindow(statJob, q);
     bool res = statJob->exec();
 
     if (res) {
         int ret = KMessageBox::warningContinueCancel(q,
                   i18n("The file \"%1\" already exists. Do you wish to overwrite it?",
                        url.fileName()), i18n("Overwrite File?"), KStandardGuiItem::overwrite(),
                   KStandardGuiItem::cancel(), QString(), KMessageBox::Notify | KMessageBox::Dangerous);
 
         if (ret != KMessageBox::Continue) {
             return false;
         }
         return true;
     }
 
     return true;
 }
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KFileWidget::setSelection(const QString &url)
 {
 //     qDebug() << "setSelection " << url;
 
     if (url.isEmpty()) {
         return;
     }
 
     QUrl u = d->getCompleteUrl(url);
     if (!u.isValid()) { // if it still is
         qWarning() << url << " is not a correct argument for setSelection!";
         return;
     }
 
     setSelectedUrl(urlFromString(url));
 }
 #endif
 
 void KFileWidget::setSelectedUrl(const QUrl &url)
 {
     // Honor protocols that do not support directory listing
     if (!url.isRelative() && !KProtocolManager::supportsListing(url)) {
         return;
     }
     d->setLocationText(url);
 }
 
 void KFileWidgetPrivate::_k_slotLoadingFinished()
 {
     const QString currentText = locationEdit->currentText();
     if (currentText.isEmpty()) {
         return;
     }
 
     ops->blockSignals(true);
     QUrl u(ops->url());
     if (currentText.startsWith(QLatin1Char('/')))
         u.setPath(currentText);
     else
         u.setPath(concatPaths(ops->url().path(), currentText));
     ops->setCurrentItem(u);
     ops->blockSignals(false);
 }
 
 void KFileWidgetPrivate::_k_fileCompletion(const QString &match)
 {
 //     qDebug();
 
     if (match.isEmpty() || locationEdit->currentText().contains(QLatin1Char('"'))) {
         return;
     }
 
     const QUrl url = urlFromString(match);
     const QPixmap pix = KIconLoader::global()->loadMimeTypeIcon(KIO::iconNameForUrl(url), KIconLoader::Small);
     setDummyHistoryEntry(locationEdit->currentText(), pix, !locationEdit->currentText().isEmpty());
 }
 
 void KFileWidgetPrivate::_k_slotLocationChanged(const QString &text)
 {
 //     qDebug();
 
     locationEdit->lineEdit()->setModified(true);
 
     if (text.isEmpty() && ops->view()) {
         ops->view()->clearSelection();
     }
 
     if (text.isEmpty()) {
         removeDummyHistoryEntry();
     } else {
         setDummyHistoryEntry(text);
     }
 
     if (!locationEdit->lineEdit()->text().isEmpty()) {
         const QList<QUrl> urlList(tokenize(text));
         ops->setCurrentItems(urlList);
     }
 
     updateFilter();
 }
 
 QUrl KFileWidget::selectedUrl() const
 {
 //     qDebug();
 
     if (d->inAccept) {
         return d->url;
     } else {
         return QUrl();
     }
 }
 
 QList<QUrl> KFileWidget::selectedUrls() const
 {
 //     qDebug();
 
     QList<QUrl> list;
     if (d->inAccept) {
         if (d->ops->mode() & KFile::Files) {
             list = d->parseSelectedUrls();
         } else {
             list.append(d->url);
         }
     }
     return list;
 }
 
 QList<QUrl> &KFileWidgetPrivate::parseSelectedUrls()
 {
 //     qDebug();
 
     if (filenames.isEmpty()) {
         return urlList;
     }
 
     urlList.clear();
     if (filenames.contains(QLatin1Char('/'))) {    // assume _one_ absolute filename
         QUrl u;
         if (containsProtocolSection(filenames)) {
             u = QUrl(filenames);
         } else {
             u.setPath(filenames);
         }
 
         if (u.isValid()) {
             urlList.append(u);
         } else
             KMessageBox::error(q,
                                i18n("The chosen filenames do not\n"
                                     "appear to be valid."),
                                i18n("Invalid Filenames"));
     }
 
     else {
         urlList = tokenize(filenames);
     }
 
     filenames.clear(); // indicate that we parsed that one
 
     return urlList;
 }
 
 // FIXME: current implementation drawback: a filename can't contain quotes
 QList<QUrl> KFileWidgetPrivate::tokenize(const QString &line) const
 {
 //     qDebug();
 
     QList<QUrl> urls;
     QUrl u(ops->url());
     if (!u.path().endsWith(QLatin1Char('/'))) {
         u.setPath(u.path() + QLatin1Char('/'));
     }
     QString name;
 
     const int count = line.count(QLatin1Char('"'));
     if (count == 0) {   // no " " -> assume one single file
         if (!QDir::isAbsolutePath(line)) {
             u = u.adjusted(QUrl::RemoveFilename);
             u.setPath(u.path() + line);
             if (u.isValid()) {
                 urls.append(u);
             }
         } else {
             urls << QUrl::fromLocalFile(line);
         }
 
         return urls;
     }
 
     int start = 0;
     int index1 = -1, index2 = -1;
     while (true) {
         index1 = line.indexOf(QLatin1Char('"'), start);
         index2 = line.indexOf(QLatin1Char('"'), index1 + 1);
 
         if (index1 < 0 || index2 < 0) {
             break;
         }
 
         // get everything between the " "
         name = line.mid(index1 + 1, index2 - index1 - 1);
 
         // since we use setPath we need to do this under a temporary url
         QUrl _u(u);
         QUrl currUrl(name);
 
         if (!QDir::isAbsolutePath(currUrl.url())) {
             _u = _u.adjusted(QUrl::RemoveFilename);
             _u.setPath(_u.path() + name);
         } else {
             // we allow to insert various absolute paths like:
             // "/home/foo/bar.txt" "/boot/grub/menu.lst"
             _u = currUrl;
         }
 
         if (_u.isValid()) {
             urls.append(_u);
         }
 
         start = index2 + 1;
     }
 
     return urls;
 }
 
 QString KFileWidget::selectedFile() const
 {
 //     qDebug();
 
     if (d->inAccept) {
         const QUrl url = d->mostLocalUrl(d->url);
         if (url.isLocalFile()) {
             return url.toLocalFile();
         } else {
             KMessageBox::sorry(const_cast<KFileWidget *>(this),
                                i18n("You can only select local files."),
                                i18n("Remote Files Not Accepted"));
         }
     }
     return QString();
 }
 
 QStringList KFileWidget::selectedFiles() const
 {
 //     qDebug();
 
     QStringList list;
 
     if (d->inAccept) {
         if (d->ops->mode() & KFile::Files) {
             const QList<QUrl> urls = d->parseSelectedUrls();
             QList<QUrl>::const_iterator it = urls.begin();
             while (it != urls.end()) {
                 QUrl url = d->mostLocalUrl(*it);
                 if (url.isLocalFile()) {
                     list.append(url.toLocalFile());
                 }
                 ++it;
             }
         }
 
         else { // single-selection mode
             if (d->url.isLocalFile()) {
                 list.append(d->url.toLocalFile());
             }
         }
     }
 
     return list;
 }
 
 QUrl KFileWidget::baseUrl() const
 {
     return d->ops->url();
 }
 
 void KFileWidget::resizeEvent(QResizeEvent *event)
 {
     QWidget::resizeEvent(event);
 
     if (d->placesDock) {
         // we don't want our places dock actually changing size when we resize
         // and qt doesn't make it easy to enforce such a thing with QSplitter
         d->setPlacesViewSplitterSizes();
     }
 }
 
 void KFileWidget::showEvent(QShowEvent *event)
 {
     if (!d->hasView) {   // delayed view-creation
         Q_ASSERT(d);
         Q_ASSERT(d->ops);
         d->ops->setView(KFile::Default);
         d->ops->view()->setSizePolicy(QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
         d->hasView = true;
 
         connect(d->ops->view(), SIGNAL(doubleClicked(QModelIndex)), this, SLOT(_k_slotViewDoubleClicked(QModelIndex)));
     }
     d->ops->clearHistory();
 
     QWidget::showEvent(event);
 }
 
 bool KFileWidget::eventFilter(QObject *watched, QEvent *event)
 {
     const bool res = QWidget::eventFilter(watched, event);
 
     QKeyEvent *keyEvent = dynamic_cast<QKeyEvent *>(event);
     if (watched == d->iconSizeSlider && keyEvent) {
         if (keyEvent->key() == Qt::Key_Left || keyEvent->key() == Qt::Key_Up ||
                 keyEvent->key() == Qt::Key_Right || keyEvent->key() == Qt::Key_Down) {
             d->_k_slotIconSizeSliderMoved(d->iconSizeSlider->value());
         }
     } else if (watched == d->locationEdit && event->type() == QEvent::KeyPress) {
         if (keyEvent->modifiers() & Qt::AltModifier) {
             switch (keyEvent->key()) {
             case Qt::Key_Up:
                 d->ops->actionCollection()->action(QStringLiteral("up"))->trigger();
                 break;
             case Qt::Key_Left:
                 d->ops->actionCollection()->action(QStringLiteral("back"))->trigger();
                 break;
             case Qt::Key_Right:
                 d->ops->actionCollection()->action(QStringLiteral("forward"))->trigger();
                 break;
             default:
                 break;
             }
         }
     }
 
     return res;
 }
 
 void KFileWidget::setMode(KFile::Modes m)
 {
 //     qDebug();
 
     d->ops->setMode(m);
     if (d->ops->dirOnlyMode()) {
         d->filterWidget->setDefaultFilter(i18n("*|All Folders"));
     } else {
         d->filterWidget->setDefaultFilter(i18n("*|All Files"));
     }
 
     d->updateAutoSelectExtension();
 }
 
 KFile::Modes KFileWidget::mode() const
 {
     return d->ops->mode();
 }
 
 void KFileWidgetPrivate::readViewConfig()
 {
     ops->setViewConfig(configGroup);
     ops->readConfig(configGroup);
     KUrlComboBox *combo = urlNavigator->editor();
 
     autoDirectoryFollowing = configGroup.readEntry(AutoDirectoryFollowing,
                              DefaultDirectoryFollowing);
 
     KCompletion::CompletionMode cm = (KCompletion::CompletionMode)
                                      configGroup.readEntry(PathComboCompletionMode,
                                              static_cast<int>(KCompletion::CompletionPopup));
     if (cm != KCompletion::CompletionPopup) {
         combo->setCompletionMode(cm);
     }
 
     cm = (KCompletion::CompletionMode)
          configGroup.readEntry(LocationComboCompletionMode,
                                static_cast<int>(KCompletion::CompletionPopup));
     if (cm != KCompletion::CompletionPopup) {
         locationEdit->setCompletionMode(cm);
     }
 
     // show or don't show the speedbar
     _k_toggleSpeedbar(configGroup.readEntry(ShowSpeedbar, true));
 
     // show or don't show the bookmarks
     _k_toggleBookmarks(configGroup.readEntry(ShowBookmarks, false));
 
     // does the user want Automatically Select Extension?
     autoSelectExtChecked = configGroup.readEntry(AutoSelectExtChecked, DefaultAutoSelectExtChecked);
     updateAutoSelectExtension();
 
     // should the URL navigator use the breadcrumb navigation?
     urlNavigator->setUrlEditable(!configGroup.readEntry(BreadcrumbNavigation, true));
 
     // should the URL navigator show the full path?
     urlNavigator->setShowFullPath(configGroup.readEntry(ShowFullPath, false));
 
     int w1 = q->minimumSize().width();
     int w2 = toolbar->sizeHint().width();
     if (w1 < w2) {
         q->setMinimumWidth(w2);
     }
 }
 
 void KFileWidgetPrivate::writeViewConfig()
 {
     // these settings are global settings; ALL instances of the file dialog
     // should reflect them.
     // There is no way to tell KFileOperator::writeConfig() to write to
     // kdeglobals so we write settings to a temporary config group then copy
     // them all to kdeglobals
     KConfig tmp(QString(), KConfig::SimpleConfig);
     KConfigGroup tmpGroup(&tmp, ConfigGroup);
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     //saveDialogSize( tmpGroup, KConfigGroup::Persistent | KConfigGroup::Global );
     tmpGroup.writeEntry(PathComboCompletionMode, static_cast<int>(pathCombo->completionMode()));
     tmpGroup.writeEntry(LocationComboCompletionMode, static_cast<int>(locationEdit->completionMode()));
 
     const bool showSpeedbar = placesDock && !placesDock->isHidden();
     tmpGroup.writeEntry(ShowSpeedbar, showSpeedbar);
     if (placesViewWidth > 0) {
         tmpGroup.writeEntry(SpeedbarWidth, placesViewWidth);
     }
 
     tmpGroup.writeEntry(ShowBookmarks, bookmarkHandler != nullptr);
     tmpGroup.writeEntry(AutoSelectExtChecked, autoSelectExtChecked);
     tmpGroup.writeEntry(BreadcrumbNavigation, !urlNavigator->isUrlEditable());
     tmpGroup.writeEntry(ShowFullPath, urlNavigator->showFullPath());
 
     ops->writeConfig(tmpGroup);
 
     // Copy saved settings to kdeglobals
     tmpGroup.copyTo(&configGroup, KConfigGroup::Persistent | KConfigGroup::Global);
 }
 
 void KFileWidgetPrivate::readRecentFiles()
 {
 //     qDebug();
 
     QObject::disconnect(locationEdit, SIGNAL(editTextChanged(QString)),
                         q, SLOT(_k_slotLocationChanged(QString)));
 
     locationEdit->setMaxItems(configGroup.readEntry(RecentFilesNumber, DefaultRecentURLsNumber));
     locationEdit->setUrls(configGroup.readPathEntry(RecentFiles, QStringList()),
                           KUrlComboBox::RemoveBottom);
     locationEdit->setCurrentIndex(-1);
 
     QObject::connect(locationEdit, SIGNAL(editTextChanged(QString)),
                      q, SLOT(_k_slotLocationChanged(QString)));
 
     KUrlComboBox *combo = urlNavigator->editor();
     combo->setUrls(configGroup.readPathEntry(RecentURLs, QStringList()), KUrlComboBox::RemoveTop);
     combo->setMaxItems(configGroup.readEntry(RecentURLsNumber, DefaultRecentURLsNumber));
     combo->setUrl(ops->url());
     // since we delayed this moment, initialize the directory of the completion object to
     // our current directory (that was very probably set on the constructor)
     KUrlCompletion *completion = dynamic_cast<KUrlCompletion *>(locationEdit->completionObject());
     if (completion) {
         completion->setDir(ops->url());
     }
 
 }
 
 void KFileWidgetPrivate::saveRecentFiles()
 {
 //     qDebug();
     configGroup.writePathEntry(RecentFiles, locationEdit->urls());
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     configGroup.writePathEntry(RecentURLs, pathCombo->urls());
 }
 
 QPushButton *KFileWidget::okButton() const
 {
     return d->okButton;
 }
 
 QPushButton *KFileWidget::cancelButton() const
 {
     return d->cancelButton;
 }
 
 // Called by KFileDialog
 void KFileWidget::slotCancel()
 {
     d->writeViewConfig();
     d->ops->close();
 }
 
 void KFileWidget::setKeepLocation(bool keep)
 {
     d->keepLocation = keep;
 }
 
 bool KFileWidget::keepsLocation() const
 {
     return d->keepLocation;
 }
 
 void KFileWidget::setOperationMode(OperationMode mode)
 {
 //     qDebug();
 
     d->operationMode = mode;
     d->keepLocation = (mode == Saving);
     d->filterWidget->setEditable(!d->hasDefaultFilter || mode != Saving);
     if (mode == Opening) {
         // don't use KStandardGuiItem::open() here which has trailing ellipsis!
         d->okButton->setText(i18n("&Open"));
         d->okButton->setIcon(QIcon::fromTheme(QStringLiteral("document-open")));
         // hide the new folder actions...usability team says they shouldn't be in open file dialog
         actionCollection()->removeAction(actionCollection()->action(QStringLiteral("mkdir")));
     } else if (mode == Saving) {
         KGuiItem::assign(d->okButton, KStandardGuiItem::save());
         d->setNonExtSelection();
     } else {
         KGuiItem::assign(d->okButton, KStandardGuiItem::ok());
     }
     d->updateLocationWhatsThis();
     d->updateAutoSelectExtension();
 
     if (d->ops) {
         d->ops->setIsSaving(mode == Saving);
     }
 }
 
 KFileWidget::OperationMode KFileWidget::operationMode() const
 {
     return d->operationMode;
 }
 
 void KFileWidgetPrivate::_k_slotAutoSelectExtClicked()
 {
 //     qDebug() << "slotAutoSelectExtClicked(): "
 //                          << autoSelectExtCheckBox->isChecked() << endl;
 
     // whether the _user_ wants it on/off
     autoSelectExtChecked = autoSelectExtCheckBox->isChecked();
 
     // update the current filename's extension
     updateLocationEditExtension(extension /* extension hasn't changed */);
 }
 
 void KFileWidgetPrivate::_k_placesViewSplitterMoved(int pos, int index)
 {
 //     qDebug();
 
     // we need to record the size of the splitter when the splitter changes size
     // so we can keep the places box the right size!
     if (placesDock && index == 1) {
         placesViewWidth = pos;
 //         qDebug() << "setting lafBox minwidth to" << placesViewWidth;
         setLafBoxColumnWidth();
     }
 }
 
 void KFileWidgetPrivate::_k_activateUrlNavigator()
 {
 //     qDebug();
 
     QLineEdit* lineEdit = urlNavigator->editor()->lineEdit();
 
     // If the text field currently has focus and everything is selected,
     // pressing the keyboard shortcut returns the whole thing to breadcrumb mode
     if (urlNavigator->isUrlEditable()
         && lineEdit->hasFocus()
         && lineEdit->selectedText() == lineEdit->text() ) {
         urlNavigator->setUrlEditable(false);
     } else {
         urlNavigator->setUrlEditable(true);
         urlNavigator->setFocus();
         lineEdit->selectAll();
     }
 }
 
 void KFileWidgetPrivate::_k_zoomOutIconsSize()
 {
     const int currValue = ops->iconsZoom();
     const int futValue = qMax(0, currValue - 10);
     iconSizeSlider->setValue(futValue);
     _k_slotIconSizeSliderMoved(futValue);
 }
 
 void KFileWidgetPrivate::_k_zoomInIconsSize()
 {
     const int currValue = ops->iconsZoom();
     const int futValue = qMin(100, currValue + 10);
     iconSizeSlider->setValue(futValue);
     _k_slotIconSizeSliderMoved(futValue);
 }
 
 void KFileWidgetPrivate::_k_slotIconSizeChanged(int _value)
 {
     int maxSize = KIconLoader::SizeEnormous - KIconLoader::SizeSmall;
     int value = (maxSize * _value / 100) + KIconLoader::SizeSmall;
     switch (value) {
     case KIconLoader::SizeSmall:
     case KIconLoader::SizeSmallMedium:
     case KIconLoader::SizeMedium:
     case KIconLoader::SizeLarge:
     case KIconLoader::SizeHuge:
     case KIconLoader::SizeEnormous:
         iconSizeSlider->setToolTip(i18n("Icon size: %1 pixels (standard size)", value));
         break;
     default:
         iconSizeSlider->setToolTip(i18n("Icon size: %1 pixels", value));
         break;
     }
 }
 
 void KFileWidgetPrivate::_k_slotIconSizeSliderMoved(int _value)
 {
     // Force this to be called in case this slot is called first on the
     // slider move.
     _k_slotIconSizeChanged(_value);
 
     QPoint global(iconSizeSlider->rect().topLeft());
     global.ry() += iconSizeSlider->height() / 2;
     QHelpEvent toolTipEvent(QEvent::ToolTip, QPoint(0, 0), iconSizeSlider->mapToGlobal(global));
     QApplication::sendEvent(iconSizeSlider, &toolTipEvent);
 }
 
 void KFileWidgetPrivate::_k_slotViewDoubleClicked(const QModelIndex &index)
 {
     // double clicking to save should only work on files
     if (operationMode == KFileWidget::Saving && index.isValid() && ops->selectedItems().constFirst().isFile()) {
         q->slotOk();
     }
 }
 
 static QString getExtensionFromPatternList(const QStringList &patternList)
 {
 //     qDebug();
 
     QString ret;
 //     qDebug() << "\tgetExtension " << patternList;
 
     QStringList::ConstIterator patternListEnd = patternList.end();
     for (QStringList::ConstIterator it = patternList.begin();
             it != patternListEnd;
             ++it) {
 //         qDebug() << "\t\ttry: \'" << (*it) << "\'";
 
         // is this pattern like "*.BMP" rather than useless things like:
         //
         // README
         // *.
         // *.*
         // *.JP*G
         // *.JP?
         // *.[Jj][Pp][Gg]
         if ((*it).startsWith(QLatin1String("*.")) &&
                 (*it).length() > 2 &&
                 (*it).indexOf(QLatin1Char('*'), 2) < 0 &&
                 (*it).indexOf(QLatin1Char('?'), 2) < 0 &&
                 (*it).indexOf(QLatin1Char('['), 2) < 0 &&
                 (*it).indexOf(QLatin1Char(']'), 2) < 0) {
             ret = (*it).mid(1);
             break;
         }
     }
 
     return ret;
 }
 
 static QString stripUndisplayable(const QString &string)
 {
     QString ret = string;
 
     ret.remove(QLatin1Char(':'));
     ret = KLocalizedString::removeAcceleratorMarker(ret);
 
     return ret;
 }
 
 //QString KFileWidget::currentFilterExtension()
 //{
 //    return d->extension;
 //}
 
 void KFileWidgetPrivate::updateAutoSelectExtension()
 {
     if (!autoSelectExtCheckBox) {
         return;
     }
 
     QMimeDatabase db;
     //
     // Figure out an extension for the Automatically Select Extension thing
     // (some Windows users apparently don't know what to do when confronted
     // with a text file called "COPYING" but do know what to do with
     // COPYING.txt ...)
     //
 
 //     qDebug() << "Figure out an extension: ";
     QString lastExtension = extension;
     extension.clear();
 
     // Automatically Select Extension is only valid if the user is _saving_ a _file_
     if ((operationMode == KFileWidget::Saving) && (ops->mode() & KFile::File)) {
         //
         // Get an extension from the filter
         //
 
         QString filter = filterWidget->currentFilter();
         if (!filter.isEmpty()) {
             // if the currently selected filename already has an extension which
             // is also included in the currently allowed extensions, keep it
             // otherwise use the default extension
             QString currentExtension = db.suffixForFileName(locationEditCurrentText());
             if (currentExtension.isEmpty()) {
                 currentExtension = locationEditCurrentText().section(QLatin1Char('.'), -1, -1);
             }
             // qDebug() << "filter:" << filter << "locationEdit:" << locationEditCurrentText() << "currentExtension:" << currentExtension;
 
             QString defaultExtension;
             QStringList extensionList;
 
             // e.g. "*.cpp"
             if (filter.indexOf(QLatin1Char('/')) < 0) {
                 extensionList = filter.split(QLatin1Char(' '), QString::SkipEmptyParts);
                 defaultExtension = getExtensionFromPatternList(extensionList);
             }
             // e.g. "text/html"
             else {
                 QMimeType mime = db.mimeTypeForName(filter);
                 if (mime.isValid()) {
                     extensionList = mime.globPatterns();
                     defaultExtension = mime.preferredSuffix();
                     if (!defaultExtension.isEmpty()) {
                         defaultExtension.prepend(QLatin1Char('.'));
                     }
                 }
             }
 
             if ((!currentExtension.isEmpty() && extensionList.contains(QLatin1String("*.") + currentExtension))
                     || filter == QStringLiteral("application/octet-stream")) {
                 extension = QLatin1Char('.') + currentExtension;
             } else {
                 extension = defaultExtension;
             }
 
             // qDebug() << "List:" << extensionList << "auto-selected extension:" << extension;
         }
 
         //
         // GUI: checkbox
         //
 
         QString whatsThisExtension;
         if (!extension.isEmpty()) {
             // remember: sync any changes to the string with below
             autoSelectExtCheckBox->setText(i18n("Automatically select filename e&xtension (%1)",  extension));
             whatsThisExtension = i18n("the extension <b>%1</b>",  extension);
 
             autoSelectExtCheckBox->setEnabled(true);
             autoSelectExtCheckBox->setChecked(autoSelectExtChecked);
         } else {
             // remember: sync any changes to the string with above
             autoSelectExtCheckBox->setText(i18n("Automatically select filename e&xtension"));
             whatsThisExtension = i18n("a suitable extension");
 
             autoSelectExtCheckBox->setChecked(false);
             autoSelectExtCheckBox->setEnabled(false);
         }
 
         const QString locationLabelText = stripUndisplayable(locationLabel->text());
         autoSelectExtCheckBox->setWhatsThis(QLatin1String("<qt>") +
                                             i18n(
                                                 "This option enables some convenient features for "
                                                 "saving files with extensions:<br />"
                                                 "<ol>"
                                                 "<li>Any extension specified in the <b>%1</b> text "
                                                 "area will be updated if you change the file type "
                                                 "to save in.<br />"
                                                 "<br /></li>"
                                                 "<li>If no extension is specified in the <b>%2</b> "
                                                 "text area when you click "
                                                 "<b>Save</b>, %3 will be added to the end of the "
                                                 "filename (if the filename does not already exist). "
                                                 "This extension is based on the file type that you "
                                                 "have chosen to save in.<br />"
                                                 "<br />"
                                                 "If you do not want KDE to supply an extension for the "
                                                 "filename, you can either turn this option off or you "
                                                 "can suppress it by adding a period (.) to the end of "
                                                 "the filename (the period will be automatically "
                                                 "removed)."
                                                 "</li>"
                                                 "</ol>"
                                                 "If unsure, keep this option enabled as it makes your "
                                                 "files more manageable."
                                                 ,
                                                 locationLabelText,
                                                 locationLabelText,
                                                 whatsThisExtension)
                                             + QLatin1String("</qt>")
                                            );
 
         autoSelectExtCheckBox->show();
 
         // update the current filename's extension
         updateLocationEditExtension(lastExtension);
     }
     // Automatically Select Extension not valid
     else {
         autoSelectExtCheckBox->setChecked(false);
         autoSelectExtCheckBox->hide();
     }
 }
 
 // Updates the extension of the filename specified in d->locationEdit if the
 // Automatically Select Extension feature is enabled.
 // (this prevents you from accidentally saving "file.kwd" as RTF, for example)
 void KFileWidgetPrivate::updateLocationEditExtension(const QString &lastExtension)
 {
     if (!autoSelectExtCheckBox->isChecked() || extension.isEmpty()) {
         return;
     }
 
     QString urlStr = locationEditCurrentText();
     if (urlStr.isEmpty()) {
         return;
     }
 
     QUrl url = getCompleteUrl(urlStr);
 //     qDebug() << "updateLocationEditExtension (" << url << ")";
 
     const int fileNameOffset = urlStr.lastIndexOf(QLatin1Char('/')) + 1;
     QString fileName = urlStr.mid(fileNameOffset);
 
     const int dot = fileName.lastIndexOf(QLatin1Char('.'));
     const int len = fileName.length();
     if (dot > 0 && // has an extension already and it's not a hidden file
             // like ".hidden" (but we do accept ".hidden.ext")
             dot != len - 1 // and not deliberately suppressing extension
        ) {
         // exists?
         KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, q);
         bool result = statJob->exec();
         if (result) {
 //             qDebug() << "\tfile exists";
 
             if (statJob->statResult().isDir()) {
 //                 qDebug() << "\tisDir - won't alter extension";
                 return;
             }
 
             // --- fall through ---
         }
 
         //
         // try to get rid of the current extension
         //
 
         // catch "double extensions" like ".tar.gz"
         if (lastExtension.length() && fileName.endsWith(lastExtension)) {
             fileName.chop(lastExtension.length());
         } else if (extension.length() && fileName.endsWith(extension)) {
             fileName.chop(extension.length());
         }
         // can only handle "single extensions"
         else {
             fileName.truncate(dot);
         }
 
         // add extension
         const QString newText = urlStr.leftRef(fileNameOffset) + fileName + extension;
         if (newText != locationEditCurrentText()) {
             locationEdit->setItemText(locationEdit->currentIndex(), newText);
             locationEdit->lineEdit()->setModified(true);
         }
     }
 }
 
 // Updates the filter if the extension of the filename specified in d->locationEdit is changed
 // (this prevents you from accidently saving "file.kwd" as RTF, for example)
 void KFileWidgetPrivate::updateFilter()
 {
 //     qDebug();
 
     if ((operationMode == KFileWidget::Saving) && (ops->mode() & KFile::File)) {
         QString urlStr = locationEditCurrentText();
         if (urlStr.isEmpty()) {
             return;
         }
 
         if (filterWidget->isMimeFilter()) {
             QMimeDatabase db;
             QMimeType mime = db.mimeTypeForFile(urlStr, QMimeDatabase::MatchExtension);
             if (mime.isValid() && !mime.isDefault()) {
                 if (filterWidget->currentFilter() != mime.name() &&
                         filterWidget->filters().indexOf(mime.name()) != -1) {
                     filterWidget->setCurrentFilter(mime.name());
                 }
             }
         } else {
             QString filename = urlStr.mid(urlStr.lastIndexOf(QLatin1Char('/')) + 1);     // only filename
             foreach (const QString &filter, filterWidget->filters()) {
                 QStringList patterns = filter.left(filter.indexOf(QLatin1Char('|'))).split(QLatin1Char(' '), QString::SkipEmptyParts);       // '*.foo *.bar|Foo type' -> '*.foo', '*.bar'
                 foreach (const QString &p, patterns) {
                     QRegExp rx(p);
                     rx.setPatternSyntax(QRegExp::Wildcard);
                     if (rx.exactMatch(filename)) {
                         if (p != QLatin1String("*")) {   // never match the catch-all filter
                             filterWidget->setCurrentFilter(filter);
                         }
                         return; // do not repeat, could match a later filter
                     }
                 }
             }
         }
     }
 }
 
 // applies only to a file that doesn't already exist
 void KFileWidgetPrivate::appendExtension(QUrl &url)
 {
 //     qDebug();
 
     if (!autoSelectExtCheckBox->isChecked() || extension.isEmpty()) {
         return;
     }
 
     QString fileName = url.fileName();
     if (fileName.isEmpty()) {
         return;
     }
 
 //     qDebug() << "appendExtension(" << url << ")";
 
     const int len = fileName.length();
     const int dot = fileName.lastIndexOf(QLatin1Char('.'));
 
     const bool suppressExtension = (dot == len - 1);
     const bool unspecifiedExtension = (dot <= 0);
 
     // don't KIO::Stat if unnecessary
     if (!(suppressExtension || unspecifiedExtension)) {
         return;
     }
 
     // exists?
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     KJobWidgets::setWindow(statJob, q);
     bool res = statJob->exec();
     if (res) {
 //         qDebug() << "\tfile exists - won't append extension";
         return;
     }
 
     // suppress automatically append extension?
     if (suppressExtension) {
         //
         // Strip trailing dot
         // This allows lazy people to have autoSelectExtCheckBox->isChecked
         // but don't want a file extension to be appended
         // e.g. "README." will make a file called "README"
         //
         // If you really want a name like "README.", then type "README.."
         // and the trailing dot will be removed (or just stop being lazy and
         // turn off this feature so that you can type "README.")
         //
 //         qDebug() << "\tstrip trailing dot";
         QString path = url.path();
         path.chop(1);
         url.setPath(path);
     }
     // evilmatically append extension :) if the user hasn't specified one
     else if (unspecifiedExtension) {
 //         qDebug() << "\tappending extension \'" << extension << "\'...";
         url = url.adjusted(QUrl::RemoveFilename); // keeps trailing slash
         url.setPath(url.path() + fileName + extension);
 //         qDebug() << "\tsaving as \'" << url << "\'";
     }
 }
 
 // adds the selected files/urls to 'recent documents'
 void KFileWidgetPrivate::addToRecentDocuments()
 {
     int m = ops->mode();
     int atmost = KRecentDocument::maximumItems();
     //don't add more than we need. KRecentDocument::add() is pretty slow
 
     if (m & KFile::LocalOnly) {
         const QStringList files = q->selectedFiles();
         QStringList::ConstIterator it = files.begin();
         for (; it != files.end() && atmost > 0; ++it) {
             KRecentDocument::add(QUrl::fromLocalFile(*it));
             atmost--;
         }
     }
 
     else { // urls
         const QList<QUrl> urls = q->selectedUrls();
         QList<QUrl>::ConstIterator it = urls.begin();
         for (; it != urls.end() && atmost > 0; ++it) {
             if ((*it).isValid()) {
                 KRecentDocument::add(*it);
                 atmost--;
             }
         }
     }
 }
 
 KUrlComboBox *KFileWidget::locationEdit() const
 {
     return d->locationEdit;
 }
 
 KFileFilterCombo *KFileWidget::filterWidget() const
 {
     return d->filterWidget;
 }
 
 KActionCollection *KFileWidget::actionCollection() const
 {
     return d->ops->actionCollection();
 }
 
 void KFileWidgetPrivate::_k_toggleSpeedbar(bool show)
 {
     if (show) {
         initSpeedbar();
         placesDock->show();
         setLafBoxColumnWidth();
 
         // check to see if they have a home item defined, if not show the home button
         QUrl homeURL;
         homeURL.setPath(QDir::homePath());
         KFilePlacesModel *model = static_cast<KFilePlacesModel *>(placesView->model());
         for (int rowIndex = 0; rowIndex < model->rowCount(); rowIndex++) {
             QModelIndex index = model->index(rowIndex, 0);
             QUrl url = model->url(index);
 
             if (homeURL.matches(url, QUrl::StripTrailingSlash)) {
                 toolbar->removeAction(ops->actionCollection()->action(QStringLiteral("home")));
                 break;
             }
         }
     } else {
         if (q->sender() == placesDock && placesDock && placesDock->isVisibleTo(q)) {
             // we didn't *really* go away! the dialog was simply hidden or
             // we changed virtual desktops or ...
             return;
         }
 
         if (placesDock) {
             placesDock->hide();
         }
 
         QAction *homeAction = ops->actionCollection()->action(QStringLiteral("home"));
         QAction *reloadAction = ops->actionCollection()->action(QStringLiteral("reload"));
         if (!toolbar->actions().contains(homeAction)) {
             toolbar->insertAction(reloadAction, homeAction);
         }
 
         // reset the lafbox to not follow the width of the splitter
         lafBox->setColumnMinimumWidth(0, 0);
     }
 
     static_cast<KToggleAction *>(q->actionCollection()->action(QStringLiteral("toggleSpeedbar")))->setChecked(show);
 
     // if we don't show the places panel, at least show the places menu
     urlNavigator->setPlacesSelectorVisible(!show);
 }
 
 void KFileWidgetPrivate::_k_toggleBookmarks(bool show)
 {
     if (show) {
         if (bookmarkHandler) {
             return;
         }
 
         bookmarkHandler = new KFileBookmarkHandler(q);
         q->connect(bookmarkHandler, SIGNAL(openUrl(QString)),
                    SLOT(_k_enterUrl(QString)));
 
         bookmarkButton = new KActionMenu(QIcon::fromTheme(QStringLiteral("bookmarks")), i18n("Bookmarks"), q);
         bookmarkButton->setDelayed(false);
         q->actionCollection()->addAction(QStringLiteral("bookmark"), bookmarkButton);
         bookmarkButton->setMenu(bookmarkHandler->menu());
         bookmarkButton->setWhatsThis(i18n("<qt>This button allows you to bookmark specific locations. "
                                           "Click on this button to open the bookmark menu where you may add, "
                                           "edit or select a bookmark.<br /><br />"
                                           "These bookmarks are specific to the file dialog, but otherwise operate "
                                           "like bookmarks elsewhere in KDE.</qt>"));
         toolbar->addAction(bookmarkButton);
     } else if (bookmarkHandler) {
         delete bookmarkHandler;
         bookmarkHandler = nullptr;
         delete bookmarkButton;
         bookmarkButton = nullptr;
     }
 
     static_cast<KToggleAction *>(q->actionCollection()->action(QStringLiteral("toggleBookmarks")))->setChecked(show);
 }
 
 // static, overloaded
 QUrl KFileWidget::getStartUrl(const QUrl &startDir,
                               QString &recentDirClass)
 {
     QString fileName;                   // result discarded
     return getStartUrl(startDir, recentDirClass, fileName);
 }
 
 // static, overloaded
 QUrl KFileWidget::getStartUrl(const QUrl &startDir,
                               QString &recentDirClass,
                               QString &fileName)
 {
     recentDirClass.clear();
     fileName.clear();
     QUrl ret;
 
     bool useDefaultStartDir = startDir.isEmpty();
     if (!useDefaultStartDir) {
         if (startDir.scheme() == QLatin1String("kfiledialog")) {
 
 //  The startDir URL with this protocol may be in the format:
 //                                                    directory()   fileName()
 //  1.  kfiledialog:///keyword                           "/"         keyword
 //  2.  kfiledialog:///keyword?global                    "/"         keyword
 //  3.  kfiledialog:///keyword/                          "/"         keyword
 //  4.  kfiledialog:///keyword/?global                   "/"         keyword
 //  5.  kfiledialog:///keyword/filename                /keyword      filename
 //  6.  kfiledialog:///keyword/filename?global         /keyword      filename
 
             QString keyword;
             QString urlDir = startDir.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path();
             QString urlFile = startDir.fileName();
             if (urlDir == QLatin1String("/")) {         // '1'..'4' above
                 keyword = urlFile;
                 fileName.clear();
             } else {                // '5' or '6' above
                 keyword = urlDir.mid(1);
                 fileName = urlFile;
             }
 
             if (startDir.query() == QLatin1String("global")) {
                 recentDirClass = QStringLiteral("::%1").arg(keyword);
             } else {
                 recentDirClass = QStringLiteral(":%1").arg(keyword);
             }
 
             ret = QUrl::fromLocalFile(KRecentDirs::dir(recentDirClass));
         } else {                    // not special "kfiledialog" URL
             // "foo.png" only gives us a file name, the default start dir will be used.
             // "file:foo.png" (from KHTML/webkit, due to fromPath()) means the same
             //   (and is the reason why we don't just use QUrl::isRelative()).
 
             // In all other cases (startDir contains a directory path, or has no
             // fileName for us anyway, such as smb://), startDir is indeed a dir url.
 
             if (!startDir.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path().isEmpty() ||
                     startDir.fileName().isEmpty()) {
                 // can use start directory
                 ret = startDir;             // will be checked by stat later
                 // If we won't be able to list it (e.g. http), then use default
                 if (!KProtocolManager::supportsListing(ret)) {
                     useDefaultStartDir = true;
                     fileName = startDir.fileName();
                 }
             } else {                // file name only
                 fileName = startDir.fileName();
                 useDefaultStartDir = true;
             }
         }
     }
 
     if (useDefaultStartDir) {
         if (lastDirectory()->isEmpty()) {
             *lastDirectory() = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
             const QUrl home(QUrl::fromLocalFile(QDir::homePath()));
             // if there is no docpath set (== home dir), we prefer the current
             // directory over it. We also prefer the homedir when our CWD is
             // different from our homedirectory or when the document dir
             // does not exist
             if (lastDirectory()->adjusted(QUrl::StripTrailingSlash) == home.adjusted(QUrl::StripTrailingSlash) ||
                     QDir::currentPath() != QDir::homePath() ||
                     !QDir(lastDirectory()->toLocalFile()).exists()) {
                 *lastDirectory() = QUrl::fromLocalFile(QDir::currentPath());
             }
         }
         ret = *lastDirectory();
     }
 
     // qDebug() << "for" << startDir << "->" << ret << "recentDirClass" << recentDirClass << "fileName" << fileName;
     return ret;
 }
 
 void KFileWidget::setStartDir(const QUrl &directory)
 {
     if (directory.isValid()) {
         *lastDirectory() = directory;
     }
 }
 
 void KFileWidgetPrivate::setNonExtSelection()
 {
     // Enhanced rename: Don't highlight the file extension.
     QString filename = locationEditCurrentText();
     QMimeDatabase db;
     QString extension = db.suffixForFileName(filename);
 
     if (!extension.isEmpty()) {
         locationEdit->lineEdit()->setSelection(0, filename.length() - extension.length() - 1);
     } else {
         int lastDot = filename.lastIndexOf(QLatin1Char('.'));
         if (lastDot > 0) {
             locationEdit->lineEdit()->setSelection(0, lastDot);
         } else {
             locationEdit->lineEdit()->selectAll();
         }
     }
 }
 
 KToolBar *KFileWidget::toolBar() const
 {
     return d->toolbar;
 }
 
 void KFileWidget::setCustomWidget(QWidget *widget)
 {
     delete d->bottomCustomWidget;
     d->bottomCustomWidget = widget;
 
     // add it to the dialog, below the filter list box.
 
     // Change the parent so that this widget is a child of the main widget
     d->bottomCustomWidget->setParent(this);
 
     d->vbox->addWidget(d->bottomCustomWidget);
     //d->vbox->addSpacing(3); // can't do this every time...
 
     // FIXME: This should adjust the tab orders so that the custom widget
     // comes after the Cancel button. The code appears to do this, but the result
     // somehow screws up the tab order of the file path combo box. Not a major
     // problem, but ideally the tab order with a custom widget should be
     // the same as the order without one.
     setTabOrder(d->cancelButton, d->bottomCustomWidget);
     setTabOrder(d->bottomCustomWidget, d->urlNavigator);
 }
 
 void KFileWidget::setCustomWidget(const QString &text, QWidget *widget)
 {
     delete d->labeledCustomWidget;
     d->labeledCustomWidget = widget;
 
     QLabel *label = new QLabel(text, this);
     label->setAlignment(Qt::AlignRight);
     d->lafBox->addWidget(label, 2, 0, Qt::AlignVCenter);
     d->lafBox->addWidget(widget, 2, 1, Qt::AlignVCenter);
 }
 
 KDirOperator *KFileWidget::dirOperator()
 {
     return d->ops;
 }
 
 void KFileWidget::readConfig(KConfigGroup &group)
 {
     d->configGroup = group;
     d->readViewConfig();
     d->readRecentFiles();
 }
 
 QString KFileWidgetPrivate::locationEditCurrentText() const
 {
     return QDir::fromNativeSeparators(locationEdit->currentText());
 }
 
 QUrl KFileWidgetPrivate::mostLocalUrl(const QUrl &url)
 {
     if (url.isLocalFile()) {
         return url;
     }
 
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     KJobWidgets::setWindow(statJob, q);
     bool res = statJob->exec();
 
     if (!res) {
         return url;
     }
 
     const QString path = statJob->statResult().stringValue(KIO::UDSEntry::UDS_LOCAL_PATH);
     if (!path.isEmpty()) {
         QUrl newUrl;
         newUrl.setPath(path);
         return newUrl;
     }
 
     return url;
 }
 
 void KFileWidgetPrivate::setInlinePreviewShown(bool show)
 {
     ops->setInlinePreviewShown(show);
 }
 
 void KFileWidget::setConfirmOverwrite(bool enable)
 {
     d->confirmOverwrite = enable;
 }
 
 void KFileWidget::setInlinePreviewShown(bool show)
 {
     d->setInlinePreviewShown(show);
 }
 
 QSize KFileWidget::dialogSizeHint() const
 {
     int fontSize = fontMetrics().height();
     QSize goodSize(48 * fontSize, 30 * fontSize);
     QSize screenSize = QApplication::desktop()->availableGeometry(this).size();
     QSize minSize(screenSize / 2);
     QSize maxSize(screenSize * qreal(0.9));
     return (goodSize.expandedTo(minSize).boundedTo(maxSize));
 }
 
 void KFileWidget::setViewMode(KFile::FileView mode)
 {
     d->ops->setView(mode);
     d->hasView = true;
 }
 
 void KFileWidget::setSupportedSchemes(const QStringList &schemes)
 {
     d->model->setSupportedSchemes(schemes);
     d->ops->setSupportedSchemes(schemes);
     d->urlNavigator->setCustomProtocols(schemes);
 }
 
 QStringList KFileWidget::supportedSchemes() const
 {
     return d->model->supportedSchemes();
 }
 
 #include "moc_kfilewidget.cpp"
diff --git a/src/filewidgets/kimagefilepreview.cpp b/src/filewidgets/kimagefilepreview.cpp
index 15097da9..c4c5522a 100644
--- a/src/filewidgets/kimagefilepreview.cpp
+++ b/src/filewidgets/kimagefilepreview.cpp
@@ -1,279 +1,279 @@
 /*
  * This file is part of the KDE project
  * Copyright (C) 2001 Martin R. Jones <mjones@kde.org>
  *               2001 Carsten Pfeiffer <pfeiffer@kde.org>
  *               2008 Rafael Fernández López <ereslibre@kde.org>
  *
  * You can Freely distribute this program under the GNU Library General Public
  * License. See the file "COPYING" for the exact licensing terms.
  */
 
 #include "kimagefilepreview.h"
 
 #include <QLayout>
 #include <QLabel>
 #include <QPainter>
 #include <QComboBox>
 #include <QCheckBox>
 #include <QResizeEvent>
 #include <QTimer>
 #include <QTimeLine>
 
 #include <kconfig.h>
 #include <kiconloader.h>
 #include <QDebug>
 #include <klocalizedstring.h>
 #include <kfileitem.h>
 #include <kio/previewjob.h>
 #include <kconfiggroup.h>
 
 /**** KImageFilePreview ****/
 
 class Q_DECL_HIDDEN KImageFilePreview::KImageFilePreviewPrivate
 {
 public:
     KImageFilePreviewPrivate()
         : m_job(nullptr)
         , clear(true)
     {
         m_timeLine = new QTimeLine(150);
         m_timeLine->setCurveShape(QTimeLine::EaseInCurve);
         m_timeLine->setDirection(QTimeLine::Forward);
         m_timeLine->setFrameRange(0, 100);
     }
 
     ~KImageFilePreviewPrivate()
     {
         delete m_timeLine;
     }
 
     void _k_slotResult(KJob *);
     void _k_slotFailed(const KFileItem &);
     void _k_slotStepAnimation(int frame);
     void _k_slotFinished();
     void _k_slotActuallyClear();
 
     QUrl currentURL;
     QUrl lastShownURL;
     QLabel *imageLabel;
     KIO::PreviewJob *m_job;
     QTimeLine *m_timeLine;
     QPixmap m_pmCurrent;
     QPixmap m_pmTransition;
     float m_pmCurrentOpacity;
     float m_pmTransitionOpacity;
     bool clear;
 };
 
 KImageFilePreview::KImageFilePreview(QWidget *parent)
     : KPreviewWidgetBase(parent), d(new KImageFilePreviewPrivate)
 {
     QVBoxLayout *vb = new QVBoxLayout(this);
-    vb->setMargin(0);
+    vb->setContentsMargins(0, 0, 0, 0);
 
     d->imageLabel = new QLabel(this);
     d->imageLabel->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
     d->imageLabel->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));
     vb->addWidget(d->imageLabel);
 
     setSupportedMimeTypes(KIO::PreviewJob::supportedMimeTypes());
     setMinimumWidth(50);
 
     connect(d->m_timeLine, SIGNAL(frameChanged(int)), this, SLOT(_k_slotStepAnimation(int)));
     connect(d->m_timeLine, SIGNAL(finished()), this, SLOT(_k_slotFinished()));
 }
 
 KImageFilePreview::~KImageFilePreview()
 {
     if (d->m_job) {
         d->m_job->kill();
     }
 
     delete d;
 }
 
 void KImageFilePreview::showPreview()
 {
     // Pass a copy since clearPreview() will clear currentURL
     QUrl url = d->currentURL;
     showPreview(url, true);
 }
 
 // called via KPreviewWidgetBase interface
 void KImageFilePreview::showPreview(const QUrl &url)
 {
     showPreview(url, false);
 }
 
 void KImageFilePreview::showPreview(const QUrl &url, bool force)
 {
     if (!url.isValid() ||
             (d->lastShownURL.isValid() &&
              url.matches(d->lastShownURL, QUrl::StripTrailingSlash) &&
              d->currentURL.isValid())) {
         return;
     }
 
     d->clear = false;
     d->currentURL = url;
     d->lastShownURL = url;
 
     int w = d->imageLabel->contentsRect().width() - 4;
     int h = d->imageLabel->contentsRect().height() - 4;
 
     if (d->m_job) {
         disconnect(d->m_job, SIGNAL(result(KJob*)),
                    this, SLOT(_k_slotResult(KJob*)));
         disconnect(d->m_job, &KIO::PreviewJob::gotPreview,
                    this, &KImageFilePreview::gotPreview);
 
         disconnect(d->m_job, SIGNAL(failed(KFileItem)),
                    this, SLOT(_k_slotFailed(KFileItem)));
 
         d->m_job->kill();
     }
 
     d->m_job = createJob(url, w, h);
     if (force) { // explicitly requested previews shall always be generated!
         d->m_job->setIgnoreMaximumSize(true);
     }
 
     connect(d->m_job, SIGNAL(result(KJob*)),
             this, SLOT(_k_slotResult(KJob*)));
     connect(d->m_job, &KIO::PreviewJob::gotPreview,
             this, &KImageFilePreview::gotPreview);
 
     connect(d->m_job, SIGNAL(failed(KFileItem)),
             this, SLOT(_k_slotFailed(KFileItem)));
 }
 
 void KImageFilePreview::resizeEvent(QResizeEvent *)
 {
     clearPreview();
     d->currentURL = QUrl(); // force this to actually happen
     showPreview(d->lastShownURL);
 }
 
 QSize KImageFilePreview::sizeHint() const
 {
     return QSize(100, 200);
 }
 
 KIO::PreviewJob *KImageFilePreview::createJob(const QUrl &url, int w, int h)
 {
     if (url.isValid()) {
         KFileItemList items;
         items.append(KFileItem(url));
         QStringList plugins = KIO::PreviewJob::availablePlugins();
 
         KIO::PreviewJob *previewJob = KIO::filePreview(items, QSize(w, h), &plugins);
         previewJob->setOverlayIconAlpha(0);
         previewJob->setScaleType(KIO::PreviewJob::Scaled);
         return previewJob;
     } else {
         return nullptr;
     }
 }
 
 void KImageFilePreview::gotPreview(const KFileItem &item, const QPixmap &pm)
 {
     if (item.url() == d->currentURL) {  // should always be the case
         if (style()->styleHint(QStyle::SH_Widget_Animate, nullptr, this)) {
             if (d->m_timeLine->state() == QTimeLine::Running) {
                 d->m_timeLine->setCurrentTime(0);
             }
 
             d->m_pmTransition = pm;
             d->m_pmTransitionOpacity = 0;
             d->m_pmCurrentOpacity = 1;
             d->m_timeLine->setDirection(QTimeLine::Forward);
             d->m_timeLine->start();
         } else {
             d->imageLabel->setPixmap(pm);
         }
     }
 }
 
 void KImageFilePreview::KImageFilePreviewPrivate::_k_slotFailed(const KFileItem &item)
 {
     if (item.isDir()) {
         imageLabel->clear();
     } else if (item.url() == currentURL) // should always be the case
         imageLabel->setPixmap(SmallIcon(QStringLiteral("image-missing"), KIconLoader::SizeLarge,
                                         KIconLoader::DisabledState));
 }
 
 void KImageFilePreview::KImageFilePreviewPrivate::_k_slotResult(KJob *job)
 {
     if (job == m_job) {
         m_job = nullptr;
     }
 }
 
 void KImageFilePreview::KImageFilePreviewPrivate::_k_slotStepAnimation(int frame)
 {
     Q_UNUSED(frame)
 
     QPixmap pm(QSize(qMax(m_pmCurrent.size().width(), m_pmTransition.size().width()),
                      qMax(m_pmCurrent.size().height(), m_pmTransition.size().height())));
     pm.fill(Qt::transparent);
 
     QPainter p(&pm);
     p.setOpacity(m_pmCurrentOpacity);
 
     //If we have a current pixmap
     if (!m_pmCurrent.isNull())
         p.drawPixmap(QPoint(((float) pm.size().width() - m_pmCurrent.size().width()) / 2.0,
                             ((float) pm.size().height() - m_pmCurrent.size().height()) / 2.0), m_pmCurrent);
     if (!m_pmTransition.isNull()) {
         p.setOpacity(m_pmTransitionOpacity);
         p.drawPixmap(QPoint(((float) pm.size().width() - m_pmTransition.size().width()) / 2.0,
                             ((float) pm.size().height() - m_pmTransition.size().height()) / 2.0), m_pmTransition);
     }
     p.end();
 
     imageLabel->setPixmap(pm);
 
     m_pmCurrentOpacity = qMax(m_pmCurrentOpacity - 0.4, 0.0); // krazy:exclude=qminmax
     m_pmTransitionOpacity = qMin(m_pmTransitionOpacity + 0.4, 1.0); //krazy:exclude=qminmax
 }
 
 void KImageFilePreview::KImageFilePreviewPrivate::_k_slotFinished()
 {
     m_pmCurrent = m_pmTransition;
     m_pmTransitionOpacity = 0;
     m_pmCurrentOpacity = 1;
     m_pmTransition = QPixmap();
     // The animation might have lost some frames. Be sure that if the last one
     // was dropped, the last image shown is the opaque one.
     imageLabel->setPixmap(m_pmCurrent);
     clear = false;
 }
 
 void KImageFilePreview::clearPreview()
 {
     if (d->m_job) {
         d->m_job->kill();
         d->m_job = nullptr;
     }
 
     if (d->clear || d->m_timeLine->state() == QTimeLine::Running) {
         return;
     }
 
     if (style()->styleHint(QStyle::SH_Widget_Animate, nullptr, this)) {
         d->m_pmTransition = QPixmap();
         //If we add a previous preview then we run the animation
         if (!d->m_pmCurrent.isNull()) {
             d->m_timeLine->setCurrentTime(0);
             d->m_timeLine->setDirection(QTimeLine::Backward);
             d->m_timeLine->start();
         }
         d->currentURL = QUrl();
         d->clear = true;
     } else {
         d->imageLabel->clear();
     }
 }
 
 #include "moc_kimagefilepreview.cpp"
diff --git a/src/filewidgets/knameandurlinputdialog.cpp b/src/filewidgets/knameandurlinputdialog.cpp
index ffca4dd9..5e9dd324 100644
--- a/src/filewidgets/knameandurlinputdialog.cpp
+++ b/src/filewidgets/knameandurlinputdialog.cpp
@@ -1,154 +1,154 @@
 /*
     Copyright (c) 1998, 2008, 2009 David Faure <faure@kde.org>
 
     This library is free software; you can redistribute it and/or modify
     it under the terms of the GNU Lesser 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 Lesser 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 "knameandurlinputdialog.h"
 
 #include <klineedit.h>
 #include <kurlrequester.h>
 #include <kprotocolmanager.h>
 #include <QDialogButtonBox>
 #include <QFormLayout>
 #include <QLabel>
 #include <QVBoxLayout>
 
 class KNameAndUrlInputDialogPrivate
 {
 public:
     explicit KNameAndUrlInputDialogPrivate(KNameAndUrlInputDialog *qq)
         : m_fileNameEdited(false)
         , q(qq)
     {}
 
     void _k_slotNameTextChanged(const QString &);
     void _k_slotURLTextChanged(const QString &);
 
     /**
      * The line edit widget for the fileName
      */
     QLineEdit *m_leName;
     /**
      * The URL requester for the URL :)
      */
     KUrlRequester *m_urlRequester;
     /**
      * True if the filename was manually edited.
      */
     bool m_fileNameEdited;
 
     QDialogButtonBox *m_buttonBox;
 
     KNameAndUrlInputDialog * const q;
 };
 
 KNameAndUrlInputDialog::KNameAndUrlInputDialog(const QString &nameLabel, const QString &urlLabel, const QUrl &startDir, QWidget *parent)
     : QDialog(parent), d(new KNameAndUrlInputDialogPrivate(this))
 {
     QVBoxLayout *topLayout = new QVBoxLayout;
     setLayout(topLayout);
 
     QFormLayout *formLayout = new QFormLayout;
-    formLayout->setMargin(0);
+    formLayout->setContentsMargins(0, 0, 0, 0);
 
     // First line: filename
     d->m_leName = new QLineEdit(this);
     d->m_leName->setMinimumWidth(d->m_leName->sizeHint().width() * 3);
     d->m_leName->setSelection(0, d->m_leName->text().length()); // autoselect
     connect(d->m_leName, SIGNAL(textChanged(QString)),
             SLOT(_k_slotNameTextChanged(QString)));
     formLayout->addRow(nameLabel, d->m_leName);
 
     // Second line: url
     d->m_urlRequester = new KUrlRequester(this);
     d->m_urlRequester->setStartDir(startDir);
     d->m_urlRequester->setMode(KFile::File | KFile::Directory);
 
     d->m_urlRequester->setMinimumWidth(d->m_urlRequester->sizeHint().width() * 3);
     connect(d->m_urlRequester->lineEdit(), SIGNAL(textChanged(QString)),
             SLOT(_k_slotURLTextChanged(QString)));
     formLayout->addRow(urlLabel, d->m_urlRequester);
 
     topLayout->addLayout(formLayout);
 
     d->m_buttonBox = new QDialogButtonBox(this);
     d->m_buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     connect(d->m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     connect(d->m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
     topLayout->addWidget(d->m_buttonBox);
 
     d->m_fileNameEdited = false;
     d->m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!d->m_leName->text().isEmpty() && !d->m_urlRequester->url().isEmpty());
     d->m_leName->setFocus();
 }
 
 KNameAndUrlInputDialog::~KNameAndUrlInputDialog()
 {
     delete d;
 }
 
 QUrl KNameAndUrlInputDialog::url() const
 {
     return d->m_urlRequester->url();
 }
 
 QString KNameAndUrlInputDialog::urlText() const
 {
     return d->m_urlRequester->text();
 }
 
 QString KNameAndUrlInputDialog::name() const
 {
     return d->m_leName->text();
 }
 
 void KNameAndUrlInputDialogPrivate::_k_slotNameTextChanged(const QString &)
 {
     m_fileNameEdited = true;
     m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!m_leName->text().isEmpty() && !m_urlRequester->url().isEmpty());
 }
 
 void KNameAndUrlInputDialogPrivate::_k_slotURLTextChanged(const QString &)
 {
     if (!m_fileNameEdited) {
         // use URL as default value for the filename
         // (we copy only its filename if protocol supports listing,
         // but for HTTP we don't want tons of index.html links)
         QUrl url(m_urlRequester->url());
         if (KProtocolManager::supportsListing(url) && !url.fileName().isEmpty()) {
             m_leName->setText(url.fileName());
         } else {
             m_leName->setText(url.toString());
         }
         m_fileNameEdited = false; // slotNameTextChanged set it to true erroneously
     }
     m_buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!m_leName->text().isEmpty() && !m_urlRequester->url().isEmpty());
 }
 
 void KNameAndUrlInputDialog::setSuggestedName(const QString &name)
 {
     d->m_leName->setText(name);
     d->m_urlRequester->setFocus();
 }
 
 void KNameAndUrlInputDialog::setSuggestedUrl(const QUrl &url)
 {
     d->m_urlRequester->setUrl(url);
 }
 
 #include "moc_knameandurlinputdialog.cpp"
diff --git a/src/filewidgets/kurlnavigator.cpp b/src/filewidgets/kurlnavigator.cpp
index 26ba586f..2fbeb3da 100644
--- a/src/filewidgets/kurlnavigator.cpp
+++ b/src/filewidgets/kurlnavigator.cpp
@@ -1,1330 +1,1330 @@
 /*****************************************************************************
  * Copyright (C) 2006-2010 by Peter Penz <peter.penz@gmx.at>                 *
  * Copyright (C) 2006 by Aaron J. Seigo <aseigo@kde.org>                     *
  * Copyright (C) 2007 by Kevin Ottens <ervin@kde.org>                        *
  * Copyright (C) 2007 by Urs Wolfer <uwolfer @ 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 "kurlnavigator.h"
 
 #include "kurlnavigatorplacesselector_p.h"
 #include "kurlnavigatorprotocolcombo_p.h"
 #include "kurlnavigatordropdownbutton_p.h"
 #include "kurlnavigatorbutton_p.h"
 #include "kurlnavigatortogglebutton_p.h"
 #include "kurlnavigatorpathselectoreventfilter_p.h"
 #include "urlutil_p.h"
 
 #include <kfileitem.h>
 #include <kfileplacesmodel.h>
 #include <klocalizedstring.h>
 #include <kprotocolinfo.h>
 #include <kurlcombobox.h>
 #include <kurlcompletion.h>
 #include <kurifilter.h>
 
 #include <QDir>
 #include <QLinkedList>
 #include <QTimer>
 #include <QApplication>
 #include <QBoxLayout>
 #include <QClipboard>
 #include <QDropEvent>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QMenu>
 #include <QPainter>
 #include <QStyleOption>
 #include <qmimedatabase.h>
 #include <QMimeData>
 
 using namespace KDEPrivate;
 
 struct LocationData {
     QUrl url;
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
     QUrl rootUrl;      // KDE5: remove after the deprecated methods have been removed
     QPoint pos;        // KDE5: remove after the deprecated methods have been removed
 #endif
     QByteArray state;
 };
 
 class Q_DECL_HIDDEN KUrlNavigator::Private
 {
 public:
     Private(KUrlNavigator *q, KFilePlacesModel *placesModel);
 
     void initialize(const QUrl &url);
 
     /** Applies the edited URL in m_pathBox to the URL navigator */
     void applyUncommittedUrl();
 
     void slotReturnPressed();
     void slotProtocolChanged(const QString &);
     void openPathSelectorMenu();
 
     /**
      * Appends the widget at the end of the URL navigator. It is assured
      * that the filler widget remains as last widget to fill the remaining
      * width.
      */
     void appendWidget(QWidget *widget, int stretch = 0);
 
     /**
      * This slot is connected to the clicked signal of the navigation bar button. It calls switchView().
      * Moreover, if switching from "editable" mode to the breadcrumb view, it calls applyUncommittedUrl().
      */
     void slotToggleEditableButtonPressed();
 
     /**
      * Switches the navigation bar between the breadcrumb view and the
      * traditional view (see setUrlEditable()).
      */
     void switchView();
 
     /** Emits the signal urlsDropped(). */
     void dropUrls(const QUrl &destination, QDropEvent *event);
 
     /**
      * Is invoked when a navigator button has been clicked. Changes the URL
      * of the navigator if the left mouse button has been used. If the middle
      * mouse button has been used, the signal tabRequested() will be emitted.
      */
     void slotNavigatorButtonClicked(const QUrl &url, Qt::MouseButton button, Qt::KeyboardModifiers modifiers);
 
     void openContextMenu(const QPoint &p);
 
     void slotPathBoxChanged(const QString &text);
 
     void updateContent();
 
     /**
      * Updates all buttons to have one button for each part of the
      * current URL. Existing buttons, which are available by m_navButtons,
      * are reused if possible. If the URL is longer, new buttons will be
      * created, if the URL is shorter, the remaining buttons will be deleted.
      * @param startIndex    Start index of URL part (/), where the buttons
      *                      should be created for each following part.
      */
     void updateButtons(int startIndex);
 
     /**
      * Updates the visibility state of all buttons describing the URL. If the
      * width of the URL navigator is too small, the buttons representing the upper
      * paths of the URL will be hidden and moved to a drop down menu.
      */
     void updateButtonVisibility();
 
     /**
      * @return Text for the first button of the URL navigator.
      */
     QString firstButtonText() const;
 
     /**
      * Returns the URL that should be applied for the button with the index \a index.
      */
     QUrl buttonUrl(int index) const;
 
     void switchToBreadcrumbMode();
 
     /**
      * Deletes all URL navigator buttons. m_navButtons is
      * empty after this operation.
      */
     void deleteButtons();
 
     /**
      * Retrieves the place url for the current url.
      * E. g. for the path "fish://root@192.168.0.2/var/lib" the string
      * "fish://root@192.168.0.2" will be returned, which leads to the
      * navigation indication 'Custom Path > var > lib". For e. g.
      * "settings:///System/" the path "settings://" will be returned.
      */
     QUrl retrievePlaceUrl() const;
 
     /**
      * Returns true, if the MIME type of the path represents a
      * compressed file like TAR or ZIP.
      */
     bool isCompressedPath(const QUrl &path) const;
 
     void removeTrailingSlash(QString &url) const;
 
     /**
      * Returns the current history index, if \a historyIndex is
      * smaller than 0. If \a historyIndex is greater or equal than
      * the number of available history items, the largest possible
      * history index is returned. For the other cases just \a historyIndex
      * is returned.
      */
     int adjustedHistoryIndex(int historyIndex) const;
 
     bool m_editable : 1;
     bool m_active : 1;
     bool m_showPlacesSelector : 1;
     bool m_showFullPath : 1;
     int m_historyIndex;
 
     QHBoxLayout *m_layout;
 
     QList<LocationData> m_history;
     KUrlNavigatorPlacesSelector *m_placesSelector;
     KUrlComboBox *m_pathBox;
     KUrlNavigatorProtocolCombo *m_protocols;
     KUrlNavigatorDropDownButton *m_dropDownButton;
     QList<KUrlNavigatorButton *> m_navButtons;
     KUrlNavigatorButtonBase *m_toggleEditableMode;
     QUrl m_homeUrl;
     QStringList m_customProtocols;
     QWidget *m_dropWidget;
     KUrlNavigator * const q;
 };
 
 KUrlNavigator::Private::Private(KUrlNavigator *q, KFilePlacesModel *placesModel) :
     m_editable(false),
     m_active(true),
     m_showPlacesSelector(placesModel != nullptr),
     m_showFullPath(false),
     m_historyIndex(0),
     m_layout(new QHBoxLayout),
     m_placesSelector(nullptr),
     m_pathBox(nullptr),
     m_protocols(nullptr),
     m_dropDownButton(nullptr),
     m_navButtons(),
     m_toggleEditableMode(nullptr),
     m_homeUrl(),
     m_customProtocols(QStringList()),
     m_dropWidget(nullptr),
     q(q)
 {
     m_layout->setSpacing(0);
-    m_layout->setMargin(0);
+    m_layout->setContentsMargins(0, 0, 0, 0);
 
     // initialize the places selector
     q->setAutoFillBackground(false);
 
     if (placesModel != nullptr) {
         m_placesSelector = new KUrlNavigatorPlacesSelector(q, placesModel);
         connect(m_placesSelector, &KUrlNavigatorPlacesSelector::placeActivated,
                 q, &KUrlNavigator::setLocationUrl);
         connect(m_placesSelector, &KUrlNavigatorPlacesSelector::tabRequested,
                 q, &KUrlNavigator::tabRequested);
 
         connect(placesModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
                 q, SLOT(updateContent()));
         connect(placesModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                 q, SLOT(updateContent()));
         connect(placesModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                 q, SLOT(updateContent()));
     }
 
     // create protocol combo
     m_protocols = new KUrlNavigatorProtocolCombo(QString(), q);
     connect(m_protocols, SIGNAL(activated(QString)),
             q, SLOT(slotProtocolChanged(QString)));
 
     // create drop down button for accessing all paths of the URL
     m_dropDownButton = new KUrlNavigatorDropDownButton(q);
     m_dropDownButton->setForegroundRole(QPalette::WindowText);
     m_dropDownButton->installEventFilter(q);
     connect(m_dropDownButton, SIGNAL(clicked()),
             q, SLOT(openPathSelectorMenu()));
 
     // initialize the path box of the traditional view
     m_pathBox = new KUrlComboBox(KUrlComboBox::Directories, true, q);
     m_pathBox->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
     m_pathBox->installEventFilter(q);
 
     KUrlCompletion *kurlCompletion = new KUrlCompletion(KUrlCompletion::DirCompletion);
     m_pathBox->setCompletionObject(kurlCompletion);
     m_pathBox->setAutoDeleteCompletionObject(true);
 
     connect(m_pathBox, SIGNAL(returnPressed()),
             q, SLOT(slotReturnPressed()));
     connect(m_pathBox, &KUrlComboBox::urlActivated,
             q, &KUrlNavigator::setLocationUrl);
     connect(m_pathBox, SIGNAL(editTextChanged(QString)),
             q, SLOT(slotPathBoxChanged(QString)));
 
     // create toggle button which allows to switch between
     // the breadcrumb and traditional view
     m_toggleEditableMode = new KUrlNavigatorToggleButton(q);
     m_toggleEditableMode->installEventFilter(q);
     m_toggleEditableMode->setMinimumWidth(20);
     connect(m_toggleEditableMode, SIGNAL(clicked()),
             q, SLOT(slotToggleEditableButtonPressed()));
 
     if (m_placesSelector != nullptr) {
         m_layout->addWidget(m_placesSelector);
     }
     m_layout->addWidget(m_protocols);
     m_layout->addWidget(m_dropDownButton);
     m_layout->addWidget(m_pathBox, 1);
     m_layout->addWidget(m_toggleEditableMode);
 
     q->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(q, SIGNAL(customContextMenuRequested(QPoint)),
             q, SLOT(openContextMenu(QPoint)));
 }
 
 void KUrlNavigator::Private::initialize(const QUrl &url)
 {
     LocationData data;
     data.url = url.adjusted(QUrl::NormalizePathSegments);
     m_history.prepend(data);
 
     q->setLayoutDirection(Qt::LeftToRight);
 
     const int minHeight = m_pathBox->sizeHint().height();
     q->setMinimumHeight(minHeight);
 
     q->setLayout(m_layout);
     q->setMinimumWidth(100);
 
     updateContent();
 }
 
 void KUrlNavigator::Private::appendWidget(QWidget *widget, int stretch)
 {
     m_layout->insertWidget(m_layout->count() - 1, widget, stretch);
 }
 
 void KUrlNavigator::Private::applyUncommittedUrl()
 {
     // Parts of the following code have been taken
     // from the class KateFileSelector located in
     // kate/app/katefileselector.hpp of Kate.
     // Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
     // Copyright (C) 2001 Joseph Wenninger <jowenn@kde.org>
     // Copyright (C) 2001 Anders Lund <anders.lund@lund.tdcadsl.dk>
 
     const QUrl typedUrl = q->uncommittedUrl();
     QStringList urls = m_pathBox->urls();
     urls.removeAll(typedUrl.toString());
     urls.prepend(typedUrl.toString());
     m_pathBox->setUrls(urls, KUrlComboBox::RemoveBottom);
 
     q->setLocationUrl(typedUrl);
     // The URL might have been adjusted by KUrlNavigator::setUrl(), hence
     // synchronize the result in the path box.
     const QUrl currentUrl = q->locationUrl();
     m_pathBox->setUrl(currentUrl);
 }
 
 void KUrlNavigator::Private::slotReturnPressed()
 {
     applyUncommittedUrl();
 
     emit q->returnPressed();
 
     if (QApplication::keyboardModifiers() & Qt::ControlModifier) {
         // Pressing Ctrl+Return automatically switches back to the breadcrumb mode.
         // The switch must be done asynchronously, as we are in the context of the
         // editor.
         QMetaObject::invokeMethod(q, "switchToBreadcrumbMode", Qt::QueuedConnection);
     }
 }
 
 void KUrlNavigator::Private::slotProtocolChanged(const QString &protocol)
 {
     Q_ASSERT(m_editable);
 
     QUrl url;
     url.setScheme(protocol);
     if (protocol == QLatin1String("file")) {
         url.setPath(QStringLiteral("/"));
     } else {
         // With no authority set we'll get e.g. "ftp:" instead of "ftp://".
         // We want the latter, so let's set an empty authority.
         url.setAuthority(QString());
     }
 
     m_pathBox->setEditUrl(url);
 }
 
 void KUrlNavigator::Private::openPathSelectorMenu()
 {
     if (m_navButtons.count() <= 0) {
         return;
     }
 
     const QUrl firstVisibleUrl = m_navButtons.first()->url();
 
     QString spacer;
     QPointer<QMenu> popup = new QMenu(q);
 
     auto *popupFilter = new KUrlNavigatorPathSelectorEventFilter(popup.data());
     connect(popupFilter, &KUrlNavigatorPathSelectorEventFilter::tabRequested, q, &KUrlNavigator::tabRequested);
     popup->installEventFilter(popupFilter);
 
     popup->setLayoutDirection(Qt::LeftToRight);
 
     const QUrl placeUrl = retrievePlaceUrl();
     int idx = placeUrl.path().count(QLatin1Char('/')); // idx points to the first directory
     // after the place path
 
     const QString path = m_history[m_historyIndex].url.path();
     QString dirName = path.section(QLatin1Char('/'), idx, idx);
     if (dirName.isEmpty()) {
         if (placeUrl.isLocalFile()) {
             dirName = QStringLiteral("/");
         } else {
             dirName = placeUrl.toDisplayString();
         }
     }
     do {
         const QString text = spacer + dirName;
 
         QAction *action = new QAction(text, popup);
         const QUrl currentUrl = buttonUrl(idx);
         if (currentUrl == firstVisibleUrl) {
             popup->addSeparator();
         }
         action->setData(QVariant(currentUrl.toString()));
         popup->addAction(action);
 
         ++idx;
         spacer.append(QLatin1String("  "));
         dirName = path.section(QLatin1Char('/'), idx, idx);
     } while (!dirName.isEmpty());
 
     const QPoint pos = q->mapToGlobal(m_dropDownButton->geometry().bottomRight());
     const QAction *activatedAction = popup->exec(pos);
     if (activatedAction != nullptr) {
         const QUrl url(activatedAction->data().toString());
         q->setLocationUrl(url);
     }
 
     // Delete the menu, unless it has been deleted in its own nested event loop already.
     if (popup) {
         popup->deleteLater();
     }
 }
 
 void KUrlNavigator::Private::slotToggleEditableButtonPressed()
 {
     if (m_editable) {
         applyUncommittedUrl();
     }
 
     switchView();
 }
 
 void KUrlNavigator::Private::switchView()
 {
     m_toggleEditableMode->setFocus();
     m_editable = !m_editable;
     m_toggleEditableMode->setChecked(m_editable);
     updateContent();
     if (q->isUrlEditable()) {
         m_pathBox->setFocus();
     }
 
     q->requestActivation();
     emit q->editableStateChanged(m_editable);
 }
 
 void KUrlNavigator::Private::dropUrls(const QUrl &destination, QDropEvent *event)
 {
     if (event->mimeData()->hasUrls()) {
         m_dropWidget = qobject_cast<QWidget*>(q->sender());
         emit q->urlsDropped(destination, event);
     }
 }
 
 void KUrlNavigator::Private::slotNavigatorButtonClicked(const QUrl &url, Qt::MouseButton button, Qt::KeyboardModifiers modifiers)
 {
     if (button & Qt::MidButton || (button & Qt::LeftButton && modifiers & Qt::ControlModifier)) {
         emit q->tabRequested(url);
     } else if (button & Qt::LeftButton) {
         q->setLocationUrl(url);
     }
 }
 
 void KUrlNavigator::Private::openContextMenu(const QPoint &p)
 {
     q->setActive(true);
 
     QPointer<QMenu> popup = new QMenu(q);
 
     // provide 'Copy' action, which copies the current URL of
     // the URL navigator into the clipboard
     QAction *copyAction = popup->addAction(QIcon::fromTheme(QStringLiteral("edit-copy")), i18n("Copy"));
 
     // provide 'Paste' action, which copies the current clipboard text
     // into the URL navigator
     QAction *pasteAction = popup->addAction(QIcon::fromTheme(QStringLiteral("edit-paste")), i18n("Paste"));
     QClipboard *clipboard = QApplication::clipboard();
     pasteAction->setEnabled(!clipboard->text().isEmpty());
 
     popup->addSeparator();
 
     //We are checking for receivers because it's odd to have a tab entry even if it's not supported, like in the case of the open dialog
     if (q->receivers(SIGNAL(tabRequested(QUrl))) > 0) {
         for (auto button : qAsConst(m_navButtons)) {
             if (button->geometry().contains(p)) {
                 const auto url = button->url();
                 QAction* openInTab = popup->addAction(QIcon::fromTheme(QStringLiteral("tab-new")), i18n("Open %1 in tab", button->text()));
                 q->connect(openInTab, &QAction::triggered, q, [this, url](){ Q_EMIT q->tabRequested(url); });
                 break;
             }
         }
     }
 
     // provide radiobuttons for toggling between the edit and the navigation mode
     QAction *editAction = popup->addAction(i18n("Edit"));
     editAction->setCheckable(true);
 
     QAction *navigateAction = popup->addAction(i18n("Navigate"));
     navigateAction->setCheckable(true);
 
     QActionGroup *modeGroup = new QActionGroup(popup);
     modeGroup->addAction(editAction);
     modeGroup->addAction(navigateAction);
     if (q->isUrlEditable()) {
         editAction->setChecked(true);
     } else {
         navigateAction->setChecked(true);
     }
 
     popup->addSeparator();
 
     // allow showing of the full path
     QAction *showFullPathAction = popup->addAction(i18n("Show Full Path"));
     showFullPathAction->setCheckable(true);
     showFullPathAction->setChecked(q->showFullPath());
 
     QAction *activatedAction = popup->exec(QCursor::pos());
     if (activatedAction == copyAction) {
         QMimeData *mimeData = new QMimeData();
         mimeData->setText(q->locationUrl().toDisplayString(QUrl::PreferLocalFile));
         clipboard->setMimeData(mimeData);
     } else if (activatedAction == pasteAction) {
         q->setLocationUrl(QUrl::fromUserInput(clipboard->text()));
     } else if (activatedAction == editAction) {
         q->setUrlEditable(true);
     } else if (activatedAction == navigateAction) {
         q->setUrlEditable(false);
     } else if (activatedAction == showFullPathAction) {
         q->setShowFullPath(showFullPathAction->isChecked());
     }
 
     // Delete the menu, unless it has been deleted in its own nested event loop already.
     if (popup) {
         popup->deleteLater();
     }
 }
 
 void KUrlNavigator::Private::slotPathBoxChanged(const QString &text)
 {
     if (text.isEmpty()) {
         const QString protocol = q->locationUrl().scheme();
         m_protocols->setProtocol(protocol);
         if (m_customProtocols.count() != 1) {
             m_protocols->show();
         }
     } else {
         m_protocols->hide();
     }
 }
 
 void KUrlNavigator::Private::updateContent()
 {
     const QUrl currentUrl = q->locationUrl();
     if (m_placesSelector != nullptr) {
         m_placesSelector->updateSelection(currentUrl);
     }
 
     if (m_editable) {
         m_protocols->hide();
         m_dropDownButton->hide();
 
         deleteButtons();
         m_toggleEditableMode->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
         q->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
 
         m_pathBox->show();
         m_pathBox->setUrl(currentUrl);
     } else {
         m_pathBox->hide();
 
         m_protocols->hide();
 
         m_toggleEditableMode->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
         q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
         // Calculate the start index for the directories that should be shown as buttons
         // and create the buttons
         QUrl placeUrl;
         if ((m_placesSelector != nullptr) && !m_showFullPath) {
             placeUrl = m_placesSelector->selectedPlaceUrl();
         }
 
         if (!placeUrl.isValid()) {
             placeUrl = retrievePlaceUrl();
         }
         QString placePath = placeUrl.path();
         removeTrailingSlash(placePath);
 
         const int startIndex = placePath.count(QLatin1Char('/'));
         updateButtons(startIndex);
     }
 }
 
 void KUrlNavigator::Private::updateButtons(int startIndex)
 {
     QUrl currentUrl = q->locationUrl();
     if (!currentUrl.isValid()) { // QFileDialog::setDirectory not called yet
         return;
     }
 
     const QString path = currentUrl.path();
 
     bool createButton = false;
     const int oldButtonCount = m_navButtons.count();
 
     int idx = startIndex;
     bool hasNext = true;
     do {
         createButton = (idx - startIndex >= oldButtonCount);
         const bool isFirstButton = (idx == startIndex);
         const QString dirName = path.section(QLatin1Char('/'), idx, idx);
         hasNext = isFirstButton || !dirName.isEmpty();
         if (hasNext) {
             KUrlNavigatorButton *button = nullptr;
             if (createButton) {
                 button = new KUrlNavigatorButton(buttonUrl(idx), q);
                 button->installEventFilter(q);
                 button->setForegroundRole(QPalette::WindowText);
                 connect(button, SIGNAL(urlsDropped(QUrl,QDropEvent*)),
                         q, SLOT(dropUrls(QUrl,QDropEvent*)));
                 connect(button, SIGNAL(clicked(QUrl,Qt::MouseButton,Qt::KeyboardModifiers)),
                         q, SLOT(slotNavigatorButtonClicked(QUrl,Qt::MouseButton,Qt::KeyboardModifiers)));
                 connect(button, SIGNAL(finishedTextResolving()),
                         q, SLOT(updateButtonVisibility()));
                 appendWidget(button);
             } else {
                 button = m_navButtons[idx - startIndex];
                 button->setUrl(buttonUrl(idx));
             }
 
             if (isFirstButton) {
                 button->setText(firstButtonText());
             }
             button->setActive(q->isActive());
 
             if (createButton) {
                 if (!isFirstButton) {
                     setTabOrder(m_navButtons.last(), button);
                 }
                 m_navButtons.append(button);
             }
 
             ++idx;
             button->setActiveSubDirectory(path.section(QLatin1Char('/'), idx, idx));
         }
     } while (hasNext);
 
     // delete buttons which are not used anymore
     const int newButtonCount = idx - startIndex;
     if (newButtonCount < oldButtonCount) {
         const QList<KUrlNavigatorButton *>::iterator itBegin = m_navButtons.begin() + newButtonCount;
         const QList<KUrlNavigatorButton *>::iterator itEnd = m_navButtons.end();
         QList<KUrlNavigatorButton *>::iterator it = itBegin;
         while (it != itEnd) {
             (*it)->hide();
             (*it)->deleteLater();
             ++it;
         }
         m_navButtons.erase(itBegin, itEnd);
     }
 
     setTabOrder(m_dropDownButton, m_navButtons.first());
     setTabOrder(m_navButtons.last(), m_toggleEditableMode);
 
     updateButtonVisibility();
 }
 
 void KUrlNavigator::Private::updateButtonVisibility()
 {
     if (m_editable) {
         return;
     }
 
     const int buttonsCount = m_navButtons.count();
     if (buttonsCount == 0) {
         m_dropDownButton->hide();
         return;
     }
 
     // Subtract all widgets from the available width, that must be shown anyway
     int availableWidth = q->width() - m_toggleEditableMode->minimumWidth();
 
     if ((m_placesSelector != nullptr) && m_placesSelector->isVisible()) {
         availableWidth -= m_placesSelector->width();
     }
 
     if ((m_protocols != nullptr) && m_protocols->isVisible()) {
         availableWidth -= m_protocols->width();
     }
 
     // Check whether buttons must be hidden at all...
     int requiredButtonWidth = 0;
     foreach (const KUrlNavigatorButton *button, m_navButtons) {
         requiredButtonWidth += button->minimumWidth();
     }
 
     if (requiredButtonWidth > availableWidth) {
         // At least one button must be hidden. This implies that the
         // drop-down button must get visible, which again decreases the
         // available width.
         availableWidth -= m_dropDownButton->width();
     }
 
     // Hide buttons...
     QList<KUrlNavigatorButton *>::const_iterator it = m_navButtons.constEnd();
     const QList<KUrlNavigatorButton *>::const_iterator itBegin = m_navButtons.constBegin();
     bool isLastButton = true;
     bool hasHiddenButtons = false;
 
     QLinkedList<KUrlNavigatorButton *> buttonsToShow;
     while (it != itBegin) {
         --it;
         KUrlNavigatorButton *button = (*it);
         availableWidth -= button->minimumWidth();
         if ((availableWidth <= 0) && !isLastButton) {
             button->hide();
             hasHiddenButtons = true;
         } else {
             // Don't show the button immediately, as setActive()
             // might change the size and a relayout gets triggered
             // after showing the button. So the showing of all buttons
             // is postponed until all buttons have the correct
             // activation state.
             buttonsToShow.append(button);
         }
         isLastButton = false;
     }
 
     // All buttons have the correct activation state and
     // can be shown now
     foreach (KUrlNavigatorButton *button, buttonsToShow) {
         button->show();
     }
 
     if (hasHiddenButtons) {
         m_dropDownButton->show();
     } else {
         // Check whether going upwards is possible. If this is the case, show the drop-down button.
         QUrl url(m_navButtons.front()->url());
         const bool visible = !url.matches(KIO::upUrl(url), QUrl::StripTrailingSlash) && (url.scheme() != QLatin1String("nepomuksearch"));
         m_dropDownButton->setVisible(visible);
     }
 }
 
 QString KUrlNavigator::Private::firstButtonText() const
 {
     QString text;
 
     // The first URL navigator button should get the name of the
     // place instead of the directory name
     if ((m_placesSelector != nullptr) && !m_showFullPath) {
         text = m_placesSelector->selectedPlaceText();
     }
 
     if (text.isEmpty()) {
         const QUrl currentUrl = q->locationUrl();
         if (currentUrl.isLocalFile()) {
 #ifdef Q_OS_WIN
             text = currentUrl.path().length() > 1 ? currentUrl.path().left(2) : QDir::rootPath();
 #else
             text = m_showFullPath ? QStringLiteral("/") : i18n("Custom Path");
 #endif
         } else {
             text = currentUrl.scheme() + QLatin1Char(':');
             if (!currentUrl.host().isEmpty()) {
                 text += QLatin1Char(' ') + currentUrl.host();
             }
         }
     }
 
     return text;
 }
 
 QUrl KUrlNavigator::Private::buttonUrl(int index) const
 {
     if (index < 0) {
         index = 0;
     }
 
     // Keep scheme, hostname etc. as this is needed for e. g. browsing
     // FTP directories
     QUrl url = q->locationUrl();
     QString path = url.path();
 
     if (!path.isEmpty()) {
         if (index == 0) {
             // prevent the last "/" from being stripped
             // or we end up with an empty path
 #ifdef Q_OS_WIN
             path = path.length() > 1 ? path.left(2) : QDir::rootPath();
 #else
             path = QStringLiteral("/");
 #endif
         } else {
             path = path.section(QLatin1Char('/'), 0, index);
         }
     }
 
     url.setPath(path);
     return url;
 }
 
 void KUrlNavigator::Private::switchToBreadcrumbMode()
 {
     q->setUrlEditable(false);
 }
 
 void KUrlNavigator::Private::deleteButtons()
 {
     foreach (KUrlNavigatorButton *button, m_navButtons) {
         button->hide();
         button->deleteLater();
     }
     m_navButtons.clear();
 }
 
 QUrl KUrlNavigator::Private::retrievePlaceUrl() const
 {
     QUrl currentUrl = q->locationUrl();
     currentUrl.setPath(QString());
     return currentUrl;
 }
 
 bool KUrlNavigator::Private::isCompressedPath(const QUrl &url) const
 {
     QMimeDatabase db;
     const QMimeType mime = db.mimeTypeForUrl(QUrl(url.toString(QUrl::StripTrailingSlash)));
     // Note: this list of MIME types depends on the protocols implemented by kio_archive
     return  mime.inherits(QStringLiteral("application/x-compressed-tar")) ||
             mime.inherits(QStringLiteral("application/x-bzip-compressed-tar")) ||
             mime.inherits(QStringLiteral("application/x-lzma-compressed-tar")) ||
             mime.inherits(QStringLiteral("application/x-xz-compressed-tar")) ||
             mime.inherits(QStringLiteral("application/x-tar")) ||
             mime.inherits(QStringLiteral("application/x-tarz")) ||
             mime.inherits(QStringLiteral("application/x-tzo")) || // (not sure KTar supports those?)
             mime.inherits(QStringLiteral("application/zip")) ||
             mime.inherits(QStringLiteral("application/x-archive"));
 }
 
 void KUrlNavigator::Private::removeTrailingSlash(QString &url) const
 {
     const int length = url.length();
     if ((length > 0) && (url.at(length - 1) == QLatin1Char('/'))) {
         url.remove(length - 1, 1);
     }
 }
 
 int KUrlNavigator::Private::adjustedHistoryIndex(int historyIndex) const
 {
     if (historyIndex < 0) {
         historyIndex = m_historyIndex;
     } else if (historyIndex >= m_history.size()) {
         historyIndex = m_history.size() - 1;
         Q_ASSERT(historyIndex >= 0); // m_history.size() must always be > 0
     }
     return historyIndex;
 }
 
 // ------------------------------------------------------------------------------------------------
 
 KUrlNavigator::KUrlNavigator(QWidget *parent) :
     QWidget(parent),
     d(new Private(this, nullptr))
 {
     d->initialize(QUrl());
 }
 
 KUrlNavigator::KUrlNavigator(KFilePlacesModel *placesModel,
                              const QUrl &url,
                              QWidget *parent) :
     QWidget(parent),
     d(new Private(this, placesModel))
 {
     d->initialize(url);
 }
 
 KUrlNavigator::~KUrlNavigator()
 {
     delete d;
 }
 
 QUrl KUrlNavigator::locationUrl(int historyIndex) const
 {
     historyIndex = d->adjustedHistoryIndex(historyIndex);
     return d->m_history[historyIndex].url;
 }
 
 void KUrlNavigator::saveLocationState(const QByteArray &state)
 {
     d->m_history[d->m_historyIndex].state = state;
 }
 
 QByteArray KUrlNavigator::locationState(int historyIndex) const
 {
     historyIndex = d->adjustedHistoryIndex(historyIndex);
     return d->m_history[historyIndex].state;
 }
 
 bool KUrlNavigator::goBack()
 {
     const int count = d->m_history.count();
     if (d->m_historyIndex < count - 1) {
         const QUrl newUrl = locationUrl(d->m_historyIndex + 1);
         emit urlAboutToBeChanged(newUrl);
 
         ++d->m_historyIndex;
         d->updateContent();
 
         emit historyChanged();
         emit urlChanged(locationUrl());
         return true;
     }
 
     return false;
 }
 
 bool KUrlNavigator::goForward()
 {
     if (d->m_historyIndex > 0) {
         const QUrl newUrl = locationUrl(d->m_historyIndex - 1);
         emit urlAboutToBeChanged(newUrl);
 
         --d->m_historyIndex;
         d->updateContent();
 
         emit historyChanged();
         emit urlChanged(locationUrl());
         return true;
     }
 
     return false;
 }
 
 bool KUrlNavigator::goUp()
 {
     const QUrl currentUrl = locationUrl();
     const QUrl upUrl = KIO::upUrl(currentUrl);
     if (upUrl != currentUrl) { // TODO use url.matches(KIO::upUrl(url), QUrl::StripTrailingSlash)
         setLocationUrl(upUrl);
         return true;
     }
 
     return false;
 }
 
 void KUrlNavigator::goHome()
 {
     if (d->m_homeUrl.isEmpty() || !d->m_homeUrl.isValid()) {
         setLocationUrl(QUrl::fromLocalFile(QDir::homePath()));
     } else {
         setLocationUrl(d->m_homeUrl);
     }
 }
 
 void KUrlNavigator::setHomeUrl(const QUrl &url)
 {
     d->m_homeUrl = url;
 }
 
 QUrl KUrlNavigator::homeUrl() const
 {
     return d->m_homeUrl;
 }
 
 void KUrlNavigator::setUrlEditable(bool editable)
 {
     if (d->m_editable != editable) {
         d->switchView();
     }
 }
 
 bool KUrlNavigator::isUrlEditable() const
 {
     return d->m_editable;
 }
 
 void KUrlNavigator::setShowFullPath(bool show)
 {
     if (d->m_showFullPath != show) {
         d->m_showFullPath = show;
         d->updateContent();
     }
 }
 
 bool KUrlNavigator::showFullPath() const
 {
     return d->m_showFullPath;
 }
 
 void KUrlNavigator::setActive(bool active)
 {
     if (active != d->m_active) {
         d->m_active = active;
 
         d->m_dropDownButton->setActive(active);
         foreach (KUrlNavigatorButton *button, d->m_navButtons) {
             button->setActive(active);
         }
 
         update();
         if (active) {
             emit activated();
         }
     }
 }
 
 bool KUrlNavigator::isActive() const
 {
     return d->m_active;
 }
 
 void KUrlNavigator::setPlacesSelectorVisible(bool visible)
 {
     if (visible == d->m_showPlacesSelector) {
         return;
     }
 
     if (visible  && (d->m_placesSelector == nullptr)) {
         // the places selector cannot get visible as no
         // places model is available
         return;
     }
 
     d->m_showPlacesSelector = visible;
     d->m_placesSelector->setVisible(visible);
 }
 
 bool KUrlNavigator::isPlacesSelectorVisible() const
 {
     return d->m_showPlacesSelector;
 }
 
 QUrl KUrlNavigator::uncommittedUrl() const
 {
     KUriFilterData filteredData(d->m_pathBox->currentText().trimmed());
     filteredData.setCheckForExecutables(false);
     if (KUriFilter::self()->filterUri(filteredData, QStringList{ QStringLiteral("kshorturifilter"), QStringLiteral("kurisearchfilter")})) {
         return filteredData.uri();
     } else {
         return QUrl::fromUserInput(filteredData.typedString());
     }
 }
 
 void KUrlNavigator::setLocationUrl(const QUrl &newUrl)
 {
     if (newUrl == locationUrl()) {
         return;
     }
 
     QUrl url = newUrl.adjusted(QUrl::NormalizePathSegments);
 
     // This will be used below; we define it here because in the lower part of the
     // code locationUrl() and url become the same URLs
     QUrl firstChildUrl = KIO::UrlUtil::firstChildUrl(locationUrl(), url);
 
     if ((url.scheme() == QLatin1String("tar")) || (url.scheme() == QLatin1String("zip"))) {
         // The URL represents a tar- or zip-file. Check whether
         // the URL is really part of the tar- or zip-file, otherwise
         // replace it by the local path again.
         bool insideCompressedPath = d->isCompressedPath(url);
         if (!insideCompressedPath) {
             QUrl prevUrl = url;
             QUrl parentUrl = KIO::upUrl(url);
             while (parentUrl != prevUrl) {
                 if (d->isCompressedPath(parentUrl)) {
                     insideCompressedPath = true;
                     break;
                 }
                 prevUrl = parentUrl;
                 parentUrl = KIO::upUrl(parentUrl);
             }
         }
         if (!insideCompressedPath) {
             // drop the tar: or zip: protocol since we are not
             // inside the compressed path
             url.setScheme(QStringLiteral("file"));
             firstChildUrl.setScheme(QStringLiteral("file"));
         }
     }
 
     // Check whether current history element has the same URL.
     // If this is the case, just ignore setting the URL.
     const LocationData &data = d->m_history[d->m_historyIndex];
     const bool isUrlEqual = url.matches(locationUrl(), QUrl::StripTrailingSlash) ||
                             (!url.isValid() && url.matches(data.url, QUrl::StripTrailingSlash));
     if (isUrlEqual) {
         return;
     }
 
     emit urlAboutToBeChanged(url);
 
     if (d->m_historyIndex > 0) {
         // If an URL is set when the history index is not at the end (= 0),
         // then clear all previous history elements so that a new history
         // tree is started from the current position.
         QList<LocationData>::iterator begin = d->m_history.begin();
         QList<LocationData>::iterator end = begin + d->m_historyIndex;
         d->m_history.erase(begin, end);
         d->m_historyIndex = 0;
     }
 
     Q_ASSERT(d->m_historyIndex == 0);
     LocationData newData;
     newData.url = url;
     d->m_history.insert(0, newData);
 
     // Prevent an endless growing of the history: remembering
     // the last 100 Urls should be enough...
     const int historyMax = 100;
     if (d->m_history.size() > historyMax) {
         QList<LocationData>::iterator begin = d->m_history.begin() + historyMax;
         QList<LocationData>::iterator end = d->m_history.end();
         d->m_history.erase(begin, end);
     }
 
     emit historyChanged();
     emit urlChanged(url);
 
     if (firstChildUrl.isValid()) {
         emit urlSelectionRequested(firstChildUrl);
     }
 
     d->updateContent();
 
     requestActivation();
 }
 
 void KUrlNavigator::requestActivation()
 {
     setActive(true);
 }
 
 void KUrlNavigator::setFocus()
 {
     if (isUrlEditable()) {
         d->m_pathBox->setFocus();
     } else {
         QWidget::setFocus();
     }
 }
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KUrlNavigator::setUrl(const QUrl &url)
 {
     // deprecated
     setLocationUrl(url);
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KUrlNavigator::saveRootUrl(const QUrl &url)
 {
     // deprecated
     d->m_history[d->m_historyIndex].rootUrl = url;
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KUrlNavigator::savePosition(int x, int y)
 {
     // deprecated
     d->m_history[d->m_historyIndex].pos = QPoint(x, y);
 }
 #endif
 
 void KUrlNavigator::keyPressEvent(QKeyEvent *event)
 {
     if (isUrlEditable() && (event->key() == Qt::Key_Escape)) {
         setUrlEditable(false);
     } else {
         QWidget::keyPressEvent(event);
     }
 }
 
 void KUrlNavigator::keyReleaseEvent(QKeyEvent *event)
 {
     QWidget::keyReleaseEvent(event);
 }
 
 void KUrlNavigator::mousePressEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::MiddleButton) {
         requestActivation();
     }
     QWidget::mousePressEvent(event);
 }
 
 void KUrlNavigator::mouseReleaseEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::MidButton) {
         const QRect bounds = d->m_toggleEditableMode->geometry();
         if (bounds.contains(event->pos())) {
             // The middle mouse button has been clicked above the
             // toggle-editable-mode-button. Paste the clipboard content
             // as location URL.
             QClipboard *clipboard = QApplication::clipboard();
             const QMimeData *mimeData = clipboard->mimeData();
             if (mimeData->hasText()) {
                 const QString text = mimeData->text();
                 setLocationUrl(QUrl::fromUserInput(text));
             }
         }
     }
     QWidget::mouseReleaseEvent(event);
 }
 
 void KUrlNavigator::resizeEvent(QResizeEvent *event)
 {
     QTimer::singleShot(0, this, SLOT(updateButtonVisibility()));
     QWidget::resizeEvent(event);
 }
 
 void KUrlNavigator::wheelEvent(QWheelEvent *event)
 {
     setActive(true);
     QWidget::wheelEvent(event);
 }
 
 bool KUrlNavigator::eventFilter(QObject *watched, QEvent *event)
 {
     switch (event->type()) {
     case QEvent::FocusIn:
         if (watched == d->m_pathBox) {
             requestActivation();
             setFocus();
         }
         foreach (KUrlNavigatorButton *button, d->m_navButtons) {
             button->setShowMnemonic(true);
         }
         break;
 
     case QEvent::FocusOut:
         foreach (KUrlNavigatorButton *button, d->m_navButtons) {
             button->setShowMnemonic(false);
         }
         break;
 
     default:
         break;
     }
 
     return QWidget::eventFilter(watched, event);
 }
 
 int KUrlNavigator::historySize() const
 {
     return d->m_history.count();
 }
 
 int KUrlNavigator::historyIndex() const
 {
     return d->m_historyIndex;
 }
 
 KUrlComboBox *KUrlNavigator::editor() const
 {
     return d->m_pathBox;
 }
 
 void KUrlNavigator::setCustomProtocols(const QStringList &protocols)
 {
     d->m_customProtocols = protocols;
     d->m_protocols->setCustomProtocols(d->m_customProtocols);
 }
 
 QStringList KUrlNavigator::customProtocols() const
 {
     return d->m_customProtocols;
 }
 
 QWidget *KUrlNavigator::dropWidget() const
 {
     return d->m_dropWidget;
 }
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 const QUrl &KUrlNavigator::url() const
 {
     // deprecated
 
     // Workaround required because of flawed interface ('const QUrl&' is returned
     // instead of 'QUrl'): remember the URL to prevent a dangling pointer
     static QUrl url;
     url = locationUrl();
     return url;
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 QUrl KUrlNavigator::url(int index) const
 {
     // deprecated
     return d->buttonUrl(index);
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 QUrl KUrlNavigator::historyUrl(int historyIndex) const
 {
     // deprecated
     return locationUrl(historyIndex);
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 const QUrl &KUrlNavigator::savedRootUrl() const
 {
     // deprecated
 
     // Workaround required because of flawed interface ('const QUrl&' is returned
     // instead of 'QUrl'): remember the root URL to prevent a dangling pointer
     static QUrl rootUrl;
     rootUrl = d->m_history[d->m_historyIndex].rootUrl;
     return rootUrl;
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 QPoint KUrlNavigator::savedPosition() const
 {
     // deprecated
     return d->m_history[d->m_historyIndex].pos;
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KUrlNavigator::setHomeUrl(const QString &homeUrl)
 {
     // deprecated
     setLocationUrl(QUrl::fromUserInput(homeUrl));
 }
 #endif
 
 #include "moc_kurlnavigator.cpp"
diff --git a/src/ioslaves/http/kcookiejar/kcookiewin.cpp b/src/ioslaves/http/kcookiejar/kcookiewin.cpp
index bf4918ba..c8b4a16c 100644
--- a/src/ioslaves/http/kcookiejar/kcookiewin.cpp
+++ b/src/ioslaves/http/kcookiejar/kcookiewin.cpp
@@ -1,387 +1,387 @@
 /*
 This file is part of KDE
 
   Copyright (C) 2000- Waldo Bastian <bastian@kde.org>
   Copyright (C) 2000- Dawit Alemayehu <adawit@kde.org>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 //----------------------------------------------------------------------------
 //
 // KDE File Manager -- HTTP Cookie Dialogs
 
 // The purpose of the QT_NO_TOOLTIP and QT_NO_WHATSTHIS ifdefs is because
 // this file is also used in Konqueror/Embedded. One of the aims of
 // Konqueror/Embedded is to be a small as possible to fit on embedded
 // devices. For this it's also useful to strip out unneeded features of
 // Qt, like for example QToolTip or QWhatsThis. The availability (or the
 // lack thereof) can be determined using these preprocessor defines.
 // The same applies to the QT_NO_ACCEL ifdef below. I hope it doesn't make
 // too much trouble... (Simon)
 
 #include "kcookiewin.h"
 #include "kcookiejar.h"
 
 #include <QDateTime>
 #include <QDialogButtonBox>
 #include <QLabel>
 #include <QLayout>
 #include <QLineEdit>
 #include <QGroupBox>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QShortcut>
 #include <QStyle>
 #include <QUrl>
 
 #include <kwindowsystem.h>
 #include <klocalizedstring.h>
 #include <kusertimestamp.h>
 
 enum {
     AcceptedForSession = QDialog::Accepted + 1
 };
 
 KCookieWin::KCookieWin(QWidget *parent, KHttpCookieList cookieList,
                        int defaultButton, bool showDetails)
     : QDialog(parent)
 {
     setModal(true);
     setObjectName(QStringLiteral("cookiealert"));
     setWindowTitle(i18n("Cookie Alert"));
     setWindowIcon(QIcon::fromTheme(QStringLiteral("preferences-web-browser-cookies")));
     // all cookies in the list should have the same window at this time, so let's take the first
     if (!cookieList.first().windowIds().isEmpty()) {
         KWindowSystem::setMainWindow(this, cookieList.first().windowIds().first());
     } else {
         // No window associated... make sure the user notices our dialog.
         KWindowSystem::setState(winId(), NET::KeepAbove);
         KUserTimestamp::updateUserTimestamp();
     }
 
     const int count = cookieList.count();
     const KHttpCookie &cookie = cookieList.first();
     QString host(cookie.host());
     const int pos = host.indexOf(QLatin1Char(':'));
     if (pos > 0) {
         QString portNum = host.left(pos);
         host.remove(0, pos + 1);
         host += QLatin1Char(':');
         host += portNum;
     }
 
     QString txt = QStringLiteral("<html><body style=\"p {line-height: 150%}; text-align: center;\">");
     txt += i18ncp("%2 hostname, %3 optional cross domain suffix (translated below)",
                   "<p>You received a cookie from<br/>"
                   "<b>%2%3</b><br/>"
                   "Do you want to accept or reject this cookie?</p>",
                   "<p>You received %1 cookies from<br/>"
                   "<b>%2%3</b><br/>"
                   "Do you want to accept or reject these cookies?</p>",
                   count,
                   QUrl::fromAce(host.toLatin1()),
                   cookie.isCrossDomain() ? i18nc("@item:intext cross domain cookie", " [Cross Domain]") : QString());
     txt += QLatin1String("</body></html>");
 
     QVBoxLayout *topLayout = new QVBoxLayout;
     // This may look wrong, but it makes the dialogue automatically
     // shrink when the details are shown and then hidden again.
     topLayout->setSizeConstraint(QLayout::SetFixedSize);
     setLayout(topLayout);
 
     QFrame *vBox1 = new QFrame(this);
     topLayout->addWidget(vBox1);
 
     m_detailsButton = new QPushButton;
     m_detailsButton->setText(i18n("Details") + QLatin1String(" >>"));
     m_detailsButton->setIcon(QIcon::fromTheme(QStringLiteral("dialog-information")));
 #ifndef QT_NO_TOOLTIP
     m_detailsButton->setToolTip(i18n("See or modify the cookie information"));
 #endif
     connect(m_detailsButton, &QAbstractButton::clicked, this, &KCookieWin::slotToggleDetails);
 
     QPushButton *sessionOnlyButton = new QPushButton;
     sessionOnlyButton->setText(i18n("Accept for this &session"));
     sessionOnlyButton->setIcon(QIcon::fromTheme(QStringLiteral("chronometer")));
 #ifndef QT_NO_TOOLTIP
     sessionOnlyButton->setToolTip(i18n("Accept cookie(s) until the end of the current session"));
 #endif
     connect(sessionOnlyButton, &QAbstractButton::clicked, this, &KCookieWin::slotSessionOnlyClicked);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(this);
     buttonBox->addButton(m_detailsButton, QDialogButtonBox::ActionRole);
     buttonBox->addButton(sessionOnlyButton, QDialogButtonBox::ActionRole);
 
     buttonBox->setStandardButtons(QDialogButtonBox::Yes | QDialogButtonBox::No);
     QPushButton *but = buttonBox->button(QDialogButtonBox::Yes);
     but->setText(i18n("&Accept"));
     connect(but, &QAbstractButton::clicked, this, &QDialog::accept);
     but = buttonBox->button(QDialogButtonBox::No);
     but->setText(i18n("&Reject"));
     connect(but, &QAbstractButton::clicked, this, &QDialog::reject);
 
     topLayout->addWidget(buttonBox);
 
     QVBoxLayout *vBox1Layout = new QVBoxLayout(vBox1);
     vBox1Layout->setSpacing(-1);
-    vBox1Layout->setMargin(0);
+    vBox1Layout->setContentsMargins(0, 0, 0, 0);
 
     // Cookie image and message to user
     QFrame *hBox = new QFrame(vBox1);
     vBox1Layout->addWidget(hBox);
     QHBoxLayout *hBoxLayout = new QHBoxLayout(hBox);
     hBoxLayout->setSpacing(0);
-    hBoxLayout->setMargin(0);
+    hBoxLayout->setContentsMargins(0, 0, 0, 0);
     QLabel *icon = new QLabel(hBox);
     hBoxLayout->addWidget(icon);
     icon->setPixmap(QIcon::fromTheme(QStringLiteral("dialog-warning")).pixmap(style()->pixelMetric(QStyle::PM_LargeIconSize)));
     icon->setAlignment(Qt::AlignCenter);
     icon->setFixedSize(2 * icon->sizeHint());
 
     QFrame *vBox = new QFrame(hBox);
     QVBoxLayout *vBoxLayout = new QVBoxLayout(vBox);
     vBoxLayout->setSpacing(0);
-    vBoxLayout->setMargin(0);
+    vBoxLayout->setContentsMargins(0, 0, 0, 0);
     hBoxLayout->addWidget(vBox);
     QLabel *lbl = new QLabel(txt, vBox);
     vBoxLayout->addWidget(lbl);
     lbl->setAlignment(Qt::AlignCenter);
 
     // Cookie Details dialog...
     m_detailView = new KCookieDetail(cookieList, count, vBox1);
     vBox1Layout->addWidget(m_detailView);
     m_detailView->hide();
 
     // Cookie policy choice...
     QGroupBox *m_btnGrp = new QGroupBox(i18n("Apply Choice To"), vBox1);
     vBox1Layout->addWidget(m_btnGrp);
     QVBoxLayout *vbox = new QVBoxLayout;
     txt = (count == 1) ? i18n("&Only this cookie") : i18n("&Only these cookies");
     m_onlyCookies = new QRadioButton(txt, m_btnGrp);
     vbox->addWidget(m_onlyCookies);
 #ifndef QT_NO_WHATSTHIS
     m_onlyCookies->setWhatsThis(i18n("Select this option to only accept or reject this cookie. "
                                      "You will be prompted again if you receive another cookie."));
 #endif
     m_allCookiesDomain = new QRadioButton(i18n("All cookies from this do&main"), m_btnGrp);
     vbox->addWidget(m_allCookiesDomain);
 #ifndef QT_NO_WHATSTHIS
     m_allCookiesDomain->setWhatsThis(i18n("Select this option to accept or reject all cookies from "
                                           "this site. Choosing this option will add a new policy for "
                                           "the site this cookie originated from. This policy will be "
                                           "permanent until you manually change it from the System Settings."));
 #endif
     m_allCookies = new QRadioButton(i18n("All &cookies"), m_btnGrp);
     vbox->addWidget(m_allCookies);
 #ifndef QT_NO_WHATSTHIS
     m_allCookies->setWhatsThis(i18n("Select this option to accept/reject all cookies from "
                                     "anywhere. Choosing this option will change the global "
                                     "cookie policy for all cookies until you manually change "
                                     "it from the System Settings."));
 #endif
     m_btnGrp->setLayout(vbox);
 
     switch (defaultButton) {
     case KCookieJar::ApplyToShownCookiesOnly:
         m_onlyCookies->setChecked(true);
         break;
     case KCookieJar::ApplyToCookiesFromDomain:
         m_allCookiesDomain->setChecked(true);
         break;
     case KCookieJar::ApplyToAllCookies:
         m_allCookies->setChecked(true);
         break;
     default:
         m_onlyCookies->setChecked(true);
         break;
     }
 
     if (showDetails) {
         slotToggleDetails();
     }
 }
 
 KCookieWin::~KCookieWin()
 {
 }
 
 KCookieAdvice KCookieWin::advice(KCookieJar *cookiejar, const KHttpCookie &cookie)
 {
     const int result = exec();
 
     cookiejar->setShowCookieDetails(!m_detailView->isHidden());
 
     KCookieAdvice advice;
 
     switch (result) {
     case QDialog::Accepted:
         advice = KCookieAccept;
         break;
     case AcceptedForSession:
         advice = KCookieAcceptForSession;
         break;
     default:
         advice = KCookieReject;
         break;
     }
 
     KCookieJar::KCookieDefaultPolicy preferredPolicy = KCookieJar::ApplyToShownCookiesOnly;
     if (m_allCookiesDomain->isChecked()) {
         preferredPolicy = KCookieJar::ApplyToCookiesFromDomain;
         cookiejar->setDomainAdvice(cookie, advice);
     } else if (m_allCookies->isChecked()) {
         preferredPolicy = KCookieJar::ApplyToAllCookies;
         cookiejar->setGlobalAdvice(advice);
     }
     cookiejar->setPreferredDefaultPolicy(preferredPolicy);
 
     return advice;
 }
 
 KCookieDetail::KCookieDetail(const KHttpCookieList &cookieList, int cookieCount,
                              QWidget *parent)
     : QGroupBox(parent)
 {
     setTitle(i18n("Cookie Details"));
     QGridLayout *grid = new QGridLayout(this);
     grid->addItem(new QSpacerItem(0, fontMetrics().lineSpacing()), 0, 0);
     grid->setColumnStretch(1, 3);
 
     QLabel *label = new QLabel(i18n("Name:"), this);
     grid->addWidget(label, 1, 0);
     m_name = new QLineEdit(this);
     m_name->setReadOnly(true);
     m_name->setMaximumWidth(fontMetrics().maxWidth() * 25);
     grid->addWidget(m_name, 1, 1);
 
     //Add the value
     label = new QLabel(i18n("Value:"), this);
     grid->addWidget(label, 2, 0);
     m_value = new QLineEdit(this);
     m_value->setReadOnly(true);
     m_value->setMaximumWidth(fontMetrics().maxWidth() * 25);
     grid->addWidget(m_value, 2, 1);
 
     label = new QLabel(i18n("Expires:"), this);
     grid->addWidget(label, 3, 0);
     m_expires = new QLineEdit(this);
     m_expires->setReadOnly(true);
     m_expires->setMaximumWidth(fontMetrics().maxWidth() * 25);
     grid->addWidget(m_expires, 3, 1);
 
     label = new QLabel(i18n("Path:"), this);
     grid->addWidget(label, 4, 0);
     m_path = new QLineEdit(this);
     m_path->setReadOnly(true);
     m_path->setMaximumWidth(fontMetrics().maxWidth() * 25);
     grid->addWidget(m_path, 4, 1);
 
     label = new QLabel(i18n("Domain:"), this);
     grid->addWidget(label, 5, 0);
     m_domain = new QLineEdit(this);
     m_domain->setReadOnly(true);
     m_domain->setMaximumWidth(fontMetrics().maxWidth() * 25);
     grid->addWidget(m_domain, 5, 1);
 
     label = new QLabel(i18n("Exposure:"), this);
     grid->addWidget(label, 6, 0);
     m_secure = new QLineEdit(this);
     m_secure->setReadOnly(true);
     m_secure->setMaximumWidth(fontMetrics().maxWidth() * 25);
     grid->addWidget(m_secure, 6, 1);
 
     if (cookieCount > 1) {
         QPushButton *btnNext = new QPushButton(i18nc("Next cookie", "&Next >>"), this);
         btnNext->setFixedSize(btnNext->sizeHint());
         grid->addWidget(btnNext, 8, 0, 1, 2);
         connect(btnNext, &QAbstractButton::clicked, this, &KCookieDetail::slotNextCookie);
 #ifndef QT_NO_TOOLTIP
         btnNext->setToolTip(i18n("Show details of the next cookie"));
 #endif
     }
     m_cookieList = cookieList;
     m_cookieNumber = 0;
     slotNextCookie();
 }
 
 KCookieDetail::~KCookieDetail()
 {
 }
 
 void KCookieDetail::slotNextCookie()
 {
     if (m_cookieNumber == m_cookieList.count() - 1) {
         m_cookieNumber = 0;
     } else {
         ++m_cookieNumber;
     }
     displayCookieDetails();
 }
 
 void KCookieDetail::displayCookieDetails()
 {
     const KHttpCookie &cookie = m_cookieList.at(m_cookieNumber);
     m_name->setText(cookie.name());
     m_value->setText((cookie.value()));
     if (cookie.domain().isEmpty()) {
         m_domain->setText(i18n("Not specified"));
     } else {
         m_domain->setText(cookie.domain());
     }
     m_path->setText(cookie.path());
     QDateTime cookiedate;
     cookiedate.setTime_t(cookie.expireDate());
     if (cookie.expireDate()) {
         m_expires->setText(cookiedate.toString());
     } else {
         m_expires->setText(i18n("End of Session"));
     }
     QString sec;
     if (cookie.isSecure()) {
         if (cookie.isHttpOnly()) {
             sec = i18n("Secure servers only");
         } else {
             sec = i18n("Secure servers, page scripts");
         }
     } else {
         if (cookie.isHttpOnly()) {
             sec = i18n("Servers");
         } else {
             sec = i18n("Servers, page scripts");
         }
     }
     m_secure->setText(sec);
 }
 
 void KCookieWin::slotSessionOnlyClicked()
 {
     done(AcceptedForSession);
 }
 
 void KCookieWin::slotToggleDetails()
 {
     const QString baseText = i18n("Details");
 
     if (!m_detailView->isHidden()) {
         m_detailsButton->setText(baseText + QLatin1String(" >>"));
         m_detailView->hide();
     } else {
         m_detailsButton->setText(baseText + QLatin1String(" <<"));
         m_detailView->show();
     }
 }
diff --git a/src/kcms/kio/netpref.cpp b/src/kcms/kio/netpref.cpp
index b4d59222..40fb82b4 100644
--- a/src/kcms/kio/netpref.cpp
+++ b/src/kcms/kio/netpref.cpp
@@ -1,181 +1,181 @@
 
 // Own
 #include "netpref.h"
 
 // Qt
 #include <QCheckBox>
 #include <QGroupBox>
 #include <QFormLayout>
 
 // KDE
 #include <ioslave_defaults.h>
 #include <KLocalizedString>
 #include <KPluralHandlingSpinBox>
 #include <QDialog>
 #include <kconfig.h>
 #include <kpluginfactory.h>
 #include <KConfigGroup>
 
 // Local
 #include "ksaveioconfig.h"
 
 #define MAX_TIMEOUT_VALUE  3600
 
 K_PLUGIN_FACTORY_DECLARATION(KioConfigFactory)
 
 KIOPreferences::KIOPreferences(QWidget *parent, const QVariantList &)
                :KCModule(parent)
 {
     QVBoxLayout* mainLayout = new QVBoxLayout( this );
-    mainLayout->setMargin(0);
+    mainLayout->setContentsMargins(0, 0, 0, 0);
     gb_Timeout = new QGroupBox( i18n("Timeout Values"), this );
     gb_Timeout->setWhatsThis( i18np("Here you can set timeout values. "
                                     "You might want to tweak them if your "
                                     "connection is very slow. The maximum "
                                     "allowed value is 1 second." ,
                                     "Here you can set timeout values. "
                                     "You might want to tweak them if your "
                                     "connection is very slow. The maximum "
                                     "allowed value is %1 seconds.", MAX_TIMEOUT_VALUE));
     mainLayout->addWidget( gb_Timeout );
 
     QFormLayout* timeoutLayout = new QFormLayout(gb_Timeout);
     sb_socketRead = new KPluralHandlingSpinBox( this );
     sb_socketRead->setSuffix( ki18np( " second", " seconds" ) );
     connect(sb_socketRead, QOverload<int>::of(&QSpinBox::valueChanged),
             this, &KIOPreferences::configChanged);
     timeoutLayout->addRow(i18n( "Soc&ket read:" ), sb_socketRead);
 
     sb_proxyConnect = new KPluralHandlingSpinBox( this );
     sb_proxyConnect->setValue(0);
     sb_proxyConnect->setSuffix( ki18np( " second", " seconds" ) );
     connect(sb_proxyConnect, QOverload<int>::of(&QSpinBox::valueChanged),
             this, &KIOPreferences::configChanged);
     timeoutLayout->addRow(i18n( "Pro&xy connect:" ), sb_proxyConnect);
 
     sb_serverConnect = new KPluralHandlingSpinBox( this );
     sb_serverConnect->setValue(0);
     sb_serverConnect->setSuffix( ki18np( " second", " seconds" ) );
     connect(sb_serverConnect, QOverload<int>::of(&QSpinBox::valueChanged),
             this, &KIOPreferences::configChanged);
     timeoutLayout->addRow(i18n("Server co&nnect:"), sb_serverConnect);
 
     sb_serverResponse = new KPluralHandlingSpinBox( this );
     sb_serverResponse->setValue(0);
     sb_serverResponse->setSuffix( ki18np( " second", " seconds" ) );
     connect(sb_serverResponse, QOverload<int>::of(&QSpinBox::valueChanged),
             this, &KIOPreferences::configChanged);
     timeoutLayout->addRow(i18n("&Server response:"), sb_serverResponse);
 
     QGroupBox* gb_Global = new QGroupBox( i18n( "Global Options" ), this );
     mainLayout->addWidget( gb_Global );
     QVBoxLayout* globalLayout = new QVBoxLayout(gb_Global);
 
     cb_globalMarkPartial = new QCheckBox( i18n( "Mark &partially uploaded files" ), this );
     cb_globalMarkPartial->setWhatsThis( i18n( "<p>Marks partially uploaded files "
                                            "through SMB, SFTP and other protocols."
                                            "</p><p>When this option is "
                                            "enabled, partially uploaded files "
                                            "will have a \".part\" extension. "
                                            "This extension will be removed "
                                            "once the transfer is complete.</p>") );
     connect(cb_globalMarkPartial, &QAbstractButton::toggled,
             this, &KIOPreferences::configChanged);
     globalLayout->addWidget(cb_globalMarkPartial);
 
     gb_Ftp = new QGroupBox( i18n( "FTP Options" ), this );
     mainLayout->addWidget( gb_Ftp );
     QVBoxLayout* ftpLayout = new QVBoxLayout(gb_Ftp);
 
     cb_ftpEnablePasv = new QCheckBox( i18n( "Enable passive &mode (PASV)" ), this );
     cb_ftpEnablePasv->setWhatsThis( i18n("Enables FTP's \"passive\" mode. "
                                          "This is required to allow FTP to "
                                          "work from behind firewalls.") );
     connect(cb_ftpEnablePasv, &QAbstractButton::toggled,
             this, &KIOPreferences::configChanged);
     ftpLayout->addWidget(cb_ftpEnablePasv);
 
     cb_ftpMarkPartial = new QCheckBox( i18n( "Mark &partially uploaded files" ), this );
     cb_ftpMarkPartial->setWhatsThis( i18n( "<p>Marks partially uploaded FTP "
                                            "files.</p><p>When this option is "
                                            "enabled, partially uploaded files "
                                            "will have a \".part\" extension. "
                                            "This extension will be removed "
                                            "once the transfer is complete.</p>") );
     connect(cb_ftpMarkPartial, &QAbstractButton::toggled,
             this, &KIOPreferences::configChanged);
     ftpLayout->addWidget(cb_ftpMarkPartial);
 
     mainLayout->addStretch( 1 );
 }
 
 KIOPreferences::~KIOPreferences()
 {
 }
 
 void KIOPreferences::load()
 {
   KProtocolManager proto;
 
   sb_socketRead->setRange( MIN_TIMEOUT_VALUE, MAX_TIMEOUT_VALUE );
   sb_serverResponse->setRange( MIN_TIMEOUT_VALUE, MAX_TIMEOUT_VALUE );
   sb_serverConnect->setRange( MIN_TIMEOUT_VALUE, MAX_TIMEOUT_VALUE );
   sb_proxyConnect->setRange( MIN_TIMEOUT_VALUE, MAX_TIMEOUT_VALUE );
 
   sb_socketRead->setValue( proto.readTimeout() );
   sb_serverResponse->setValue( proto.responseTimeout() );
   sb_serverConnect->setValue( proto.connectTimeout() );
   sb_proxyConnect->setValue( proto.proxyConnectTimeout() );
 
   cb_globalMarkPartial->setChecked( proto.markPartial() );
 
   KConfig config( QStringLiteral("kio_ftprc"), KConfig::NoGlobals );
   cb_ftpEnablePasv->setChecked( !config.group("").readEntry( "DisablePassiveMode", false ) );
   cb_ftpMarkPartial->setChecked( config.group("").readEntry( "MarkPartial", true ) );
   emit changed( false );
 }
 
 void KIOPreferences::save()
 {
   KSaveIOConfig::setReadTimeout( sb_socketRead->value() );
   KSaveIOConfig::setResponseTimeout( sb_serverResponse->value() );
   KSaveIOConfig::setConnectTimeout( sb_serverConnect->value() );
   KSaveIOConfig::setProxyConnectTimeout( sb_proxyConnect->value() );
 
   KSaveIOConfig::setMarkPartial( cb_globalMarkPartial->isChecked() );
 
   KConfig config(QStringLiteral("kio_ftprc"), KConfig::NoGlobals);
   config.group("").writeEntry( "DisablePassiveMode", !cb_ftpEnablePasv->isChecked() );
   config.group("").writeEntry( "MarkPartial", cb_ftpMarkPartial->isChecked() );
   config.sync();
 
   KSaveIOConfig::updateRunningIOSlaves(this);
 
   emit changed( false );
 }
 
 void KIOPreferences::defaults()
 {
   sb_socketRead->setValue( DEFAULT_READ_TIMEOUT );
   sb_serverResponse->setValue( DEFAULT_RESPONSE_TIMEOUT );
   sb_serverConnect->setValue( DEFAULT_CONNECT_TIMEOUT );
   sb_proxyConnect->setValue( DEFAULT_PROXY_CONNECT_TIMEOUT );
 
   cb_globalMarkPartial->setChecked( true );
 
   cb_ftpEnablePasv->setChecked( true );
   cb_ftpMarkPartial->setChecked( true );
 
   emit changed(true);
 }
 
 QString KIOPreferences::quickHelp() const
 {
   return i18n("<h1>Network Preferences</h1>Here you can define"
               " the behavior of KDE programs when using Internet"
               " and network connections. If you experience timeouts"
               " or use a modem to connect to the Internet, you might"
               " want to adjust these settings." );
 }
 
 
diff --git a/src/kcms/webshortcuts/main.cpp b/src/kcms/webshortcuts/main.cpp
index 4d930863..8cbc7eb9 100644
--- a/src/kcms/webshortcuts/main.cpp
+++ b/src/kcms/webshortcuts/main.cpp
@@ -1,128 +1,128 @@
 /*
  *  Copyright (c) 2000 Yves Arrouye <yves@realnames.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 // Own
 #include "main.h"
 
 // Qt
 #include <QTabWidget>
 #include <QBoxLayout>
 
 // KDE
 #include <kurifilter.h>
 #include <KAboutData>
 #include <KLocalizedString>
 #include <KPluginMetaData>
 #include <KPluginFactory>
 #include <KPluginLoader>
 
 K_PLUGIN_FACTORY(KURIFilterModuleFactory, registerPlugin<KURIFilterModule>();)
 
 KURIFilterModule::KURIFilterModule(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args),
       m_widget(nullptr)
 {
     KAboutData *about = new KAboutData(QStringLiteral("kcm_webshortcuts"), i18n("Web Shortcuts"),
                                        QStringLiteral("0.1"), i18n("Configure enhanced browsing features"),
                                        KAboutLicense::GPL);
     setAboutData(about);
 
     KCModule::setButtons(KCModule::Buttons(KCModule::Default | KCModule::Apply | KCModule::Help));
 
     filter = KUriFilter::self();
 
     setQuickHelp(i18n("<h1>Enhanced Browsing</h1> In this module you can configure some enhanced browsing"
                       " features of KDE. "
                       "<h2>Web Shortcuts</h2>Web Shortcuts are a quick way of using Web search engines. For example, type \"duckduckgo:frobozz\""
                       " or \"dd:frobozz\" and your web browser will do a search on DuckDuckGo for \"frobozz\"."
                       " Even easier: just press Alt+F2 (if you have not"
                       " changed this keyboard shortcut) and enter the shortcut in the Run Command dialog."));
 
     QVBoxLayout *layout = new QVBoxLayout(this);
 
     QMap<QString, KCModule *> helper;
     // Load the plugins. This saves a public method in KUriFilter just for this.
 
     QVector<KPluginMetaData> plugins = KPluginLoader::findPlugins(QStringLiteral("kf5/urifilters"));
     for (const KPluginMetaData &pluginMetaData : plugins) {
         KPluginFactory *factory = qobject_cast<KPluginFactory *>(pluginMetaData.instantiate());
         if (factory) {
             KUriFilterPlugin *plugin = factory->create<KUriFilterPlugin>(nullptr);
             if (plugin) {
                 KCModule *module = plugin->configModule(this, nullptr);
                 if (module) {
                     modules.append(module);
                     helper.insert(plugin->configName(), module);
                     connect(module, QOverload<bool>::of(&KCModule::changed),
                             this, QOverload<bool>::of(&KCModule::changed));
                 }
             }
         }
     }
 
     if (modules.count() > 1) {
         QTabWidget *tab = new QTabWidget(this);
 
         QMap<QString, KCModule *>::iterator it2;
         for (it2 = helper.begin(); it2 != helper.end(); ++it2) {
             tab->addTab(it2.value(), it2.key());
         }
 
         tab->setCurrentIndex(tab->indexOf(modules.first()));
         m_widget = tab;
     } else if (modules.count() == 1) {
         m_widget = modules.first();
         if (m_widget->layout()) {
-            m_widget->layout()->setMargin(0);
+            m_widget->layout()->setContentsMargins(0, 0, 0, 0);
         }
     }
 
     if (m_widget) {
         layout->addWidget(m_widget);
     }
 }
 
 void KURIFilterModule::load()
 {
 // seems not to be necessary, since modules automatically call load() on show (uwolfer)
 //     foreach( KCModule* module, modules )
 //     {
 //    module->load();
 //     }
 }
 
 void KURIFilterModule::save()
 {
     foreach(KCModule * module, modules) {
         module->save();
     }
 }
 
 void KURIFilterModule::defaults()
 {
     foreach(KCModule * module, modules) {
         module->defaults();
     }
 }
 
 KURIFilterModule::~KURIFilterModule()
 {
     qDeleteAll(modules);
 }
 
 #include "main.moc"
diff --git a/src/widgets/kacleditwidget.cpp b/src/widgets/kacleditwidget.cpp
index 2595c976..666a3081 100644
--- a/src/widgets/kacleditwidget.cpp
+++ b/src/widgets/kacleditwidget.cpp
@@ -1,1191 +1,1191 @@
 /***************************************************************************
  *   Copyright (C) 2005 by Sean Harmer <sh@rama.homelinux.org>             *
  *                 2005 - 2007 Till Adam <adam@kde.org>                    *
  *                                                                         *
  *   This program 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 program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
  ***************************************************************************/
 
 #include "kacleditwidget.h"
 #include "kacleditwidget_p.h"
 #include "kio_widgets_debug.h"
 
 #if HAVE_POSIX_ACL
 
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <qpainter.h>
 #include <qpushbutton.h>
 #include <QButtonGroup>
 #include <QGroupBox>
 #include <qradiobutton.h>
 #include <qcombobox.h>
 #include <qlabel.h>
 #include <qcheckbox.h>
 #include <qlayout.h>
 #include <QStackedWidget>
 #include <QMouseEvent>
 #include <QHeaderView>
 
 #include <klocalizedstring.h>
 #include <kfileitem.h>
 #include <QDebug>
 
 #if HAVE_ACL_LIBACL_H
 # include <acl/libacl.h>
 #endif
 extern "C" {
 #include <pwd.h>
 #include <grp.h>
 }
 #include <assert.h>
 
 static struct {
     const char *label;
     const char *pixmapName;
     QPixmap *pixmap;
 } s_itemAttributes[] = {
     { I18N_NOOP("Owner"), "user-grey", nullptr },
     { I18N_NOOP("Owning Group"), "group-grey", nullptr },
     { I18N_NOOP("Others"), "others-grey", nullptr },
     { I18N_NOOP("Mask"), "mask", nullptr },
     { I18N_NOOP("Named User"), "user", nullptr },
     { I18N_NOOP("Named Group"), "group", nullptr },
 };
 
 class KACLEditWidget::KACLEditWidgetPrivate
 {
 public:
     KACLEditWidgetPrivate()
     {
     }
 
     // slots
     void _k_slotUpdateButtons();
 
     KACLListView *m_listView;
     QPushButton *m_AddBtn;
     QPushButton *m_EditBtn;
     QPushButton *m_DelBtn;
 };
 
 KACLEditWidget::KACLEditWidget(QWidget *parent)
     : QWidget(parent), d(new KACLEditWidgetPrivate)
 {
     QHBoxLayout *hbox = new QHBoxLayout(this);
-    hbox->setMargin(0);
+    hbox->setContentsMargins(0, 0, 0, 0);
     d->m_listView = new KACLListView(this);
     hbox->addWidget(d->m_listView);
     connect(d->m_listView->selectionModel(),
             SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
             this,
             SLOT(_k_slotUpdateButtons()));
     QVBoxLayout *vbox = new QVBoxLayout();
     hbox->addLayout(vbox);
     d->m_AddBtn = new QPushButton(i18n("Add Entry..."), this);
     vbox->addWidget(d->m_AddBtn);
     d->m_AddBtn->setObjectName(QStringLiteral("add_entry_button"));
     connect(d->m_AddBtn, &QAbstractButton::clicked, d->m_listView, &KACLListView::slotAddEntry);
     d->m_EditBtn = new QPushButton(i18n("Edit Entry..."), this);
     vbox->addWidget(d->m_EditBtn);
     d->m_EditBtn->setObjectName(QStringLiteral("edit_entry_button"));
     connect(d->m_EditBtn, &QAbstractButton::clicked, d->m_listView, &KACLListView::slotEditEntry);
     d->m_DelBtn = new QPushButton(i18n("Delete Entry"), this);
     vbox->addWidget(d->m_DelBtn);
     d->m_DelBtn->setObjectName(QStringLiteral("delete_entry_button"));
     connect(d->m_DelBtn, &QAbstractButton::clicked, d->m_listView, &KACLListView::slotRemoveEntry);
     vbox->addItem(new QSpacerItem(10, 10, QSizePolicy::Fixed, QSizePolicy::Expanding));
     d->_k_slotUpdateButtons();
 }
 
 KACLEditWidget::~KACLEditWidget()
 {
     delete d;
 }
 
 void KACLEditWidget::KACLEditWidgetPrivate::_k_slotUpdateButtons()
 {
     bool atLeastOneIsNotDeletable = false;
     bool atLeastOneIsNotAllowedToChangeType = false;
     int selectedCount = 0;
     QList<QTreeWidgetItem *> selected = m_listView->selectedItems();
     QListIterator<QTreeWidgetItem *> it(selected);
     while (it.hasNext()) {
         KACLListViewItem *item = static_cast<KACLListViewItem *>(it.next());
         ++selectedCount;
         if (!item->isDeletable()) {
             atLeastOneIsNotDeletable = true;
         }
         if (!item->isAllowedToChangeType()) {
             atLeastOneIsNotAllowedToChangeType = true;
         }
     }
     m_EditBtn->setEnabled(selectedCount && !atLeastOneIsNotAllowedToChangeType);
     m_DelBtn->setEnabled(selectedCount && !atLeastOneIsNotDeletable);
 }
 
 KACL KACLEditWidget::getACL() const
 {
     return d->m_listView->getACL();
 }
 
 KACL KACLEditWidget::getDefaultACL() const
 {
     return d->m_listView->getDefaultACL();
 }
 
 void KACLEditWidget::setACL(const KACL &acl)
 {
     d->m_listView->setACL(acl);
 }
 
 void KACLEditWidget::setDefaultACL(const KACL &acl)
 {
     d->m_listView->setDefaultACL(acl);
 }
 
 void KACLEditWidget::setAllowDefaults(bool value)
 {
     d->m_listView->setAllowDefaults(value);
 }
 
 KACLListViewItem::KACLListViewItem(QTreeWidget *parent,
                                    KACLListView::EntryType _type,
                                    unsigned short _value, bool defaults,
                                    const QString &_qualifier)
     : QTreeWidgetItem(parent),
       type(_type), value(_value), isDefault(defaults),
       qualifier(_qualifier), isPartial(false)
 {
     m_pACLListView = qobject_cast<KACLListView *>(parent);
     repaint();
 }
 
 KACLListViewItem::~ KACLListViewItem()
 {
 
 }
 
 QString KACLListViewItem::key() const
 {
     QString key;
     if (!isDefault) {
         key = QLatin1Char('A');
     } else {
         key = QLatin1Char('B');
     }
     switch (type) {
     case KACLListView::User:
         key += QLatin1Char('A');
         break;
     case KACLListView::Group:
         key += QLatin1Char('B');
         break;
     case KACLListView::Others:
         key += QLatin1Char('C');
         break;
     case KACLListView::Mask:
         key += QLatin1Char('D');
         break;
     case KACLListView::NamedUser:
         key += QLatin1Char('E') + text(1);
         break;
     case KACLListView::NamedGroup:
         key += QLatin1Char('F') + text(1);
         break;
     default:
         key += text(0);
         break;
     }
     return key;
 }
 
 bool KACLListViewItem::operator< (const QTreeWidgetItem &other) const
 {
     return key() < static_cast<const KACLListViewItem &>(other).key();
 }
 
 #if 0
 void KACLListViewItem::paintCell(QPainter *p, const QColorGroup &cg,
                                  int column, int width, int alignment)
 {
     if (isDefault) {
         setForeground(QColor(0, 0, 255));
     }
     if (isPartial) {
         QFont font = p->font();
         font.setItalic(true);
         setForeground(QColor(100, 100, 100));
         p->setFont(font);
     }
     QTreeWidgetItem::paintCell(p, mycg, column, width, alignment);
 
     KACLListViewItem *below = 0;
     if (itemBelow()) {
         below = static_cast<KACLListViewItem *>(itemBelow());
     }
     const bool lastUser = type == KACLListView::NamedUser && below && below->type == KACLListView::NamedGroup;
     const bool lastNonDefault = !isDefault && below && below->isDefault;
     if (type == KACLListView::Mask || lastUser || lastNonDefault) {
         p->setPen(QPen(Qt::gray, 0, Qt::DotLine));
         if (type == KACLListView::Mask) {
             p->drawLine(0, 0, width - 1, 0);
         }
         p->drawLine(0, height() - 1, width - 1, height() - 1);
     }
 }
 #endif
 
 void KACLListViewItem::updatePermPixmaps()
 {
     unsigned int partialPerms = value;
 
     if (value & ACL_READ) {
         setIcon(2, m_pACLListView->getYesPixmap());
     } else if (partialPerms & ACL_READ) {
         setIcon(2, m_pACLListView->getYesPartialPixmap());
     } else {
         setIcon(2, QIcon());
     }
 
     if (value & ACL_WRITE) {
         setIcon(3, m_pACLListView->getYesPixmap());
     } else if (partialPerms & ACL_WRITE) {
         setIcon(3, m_pACLListView->getYesPartialPixmap());
     } else {
         setIcon(3, QIcon());
     }
 
     if (value & ACL_EXECUTE) {
         setIcon(4, m_pACLListView->getYesPixmap());
     } else if (partialPerms & ACL_EXECUTE) {
         setIcon(4, m_pACLListView->getYesPartialPixmap());
     } else {
         setIcon(4, QIcon());
     }
 }
 
 void KACLListViewItem::repaint()
 {
     int idx = 0;
     switch (type) {
     case KACLListView::User:
         idx = KACLListView::OWNER_IDX;
         break;
     case KACLListView::Group:
         idx = KACLListView::GROUP_IDX;
         break;
     case KACLListView::Others:
         idx = KACLListView::OTHERS_IDX;
         break;
     case KACLListView::Mask:
         idx = KACLListView::MASK_IDX;
         break;
     case KACLListView::NamedUser:
         idx = KACLListView::NAMED_USER_IDX;
         break;
     case KACLListView::NamedGroup:
         idx = KACLListView::NAMED_GROUP_IDX;
         break;
     default:
         idx = KACLListView::OWNER_IDX;
         break;
     }
     setText(0, i18n(s_itemAttributes[idx].label));
     setIcon(0, *s_itemAttributes[idx].pixmap);
     if (isDefault) {
         setText(0, text(0) + i18n(" (Default)"));
     }
     setText(1, qualifier);
     // Set the pixmaps for which of the perms are set
     updatePermPixmaps();
 }
 
 void KACLListViewItem::calcEffectiveRights()
 {
     QString strEffective = QStringLiteral("---");
 
     // Do we need to worry about the mask entry? It applies to named users,
     // owning group, and named groups
     if (m_pACLListView->hasMaskEntry()
             && (type == KACLListView::NamedUser
                 || type == KACLListView::Group
                 || type == KACLListView::NamedGroup)
             && !isDefault) {
 
         strEffective[0] = (m_pACLListView->maskPermissions() & value & ACL_READ) ? 'r' : '-';
         strEffective[1] = (m_pACLListView->maskPermissions() & value & ACL_WRITE) ? 'w' : '-';
         strEffective[2] = (m_pACLListView->maskPermissions() & value & ACL_EXECUTE) ? 'x' : '-';
         /*
                 // What about any partial perms?
                 if ( maskPerms & partialPerms & ACL_READ || // Partial perms on entry
                      maskPartialPerms & perms & ACL_READ || // Partial perms on mask
                      maskPartialPerms & partialPerms & ACL_READ ) // Partial perms on mask and entry
                     strEffective[0] = 'R';
                 if ( maskPerms & partialPerms & ACL_WRITE || // Partial perms on entry
                      maskPartialPerms & perms & ACL_WRITE || // Partial perms on mask
                      maskPartialPerms & partialPerms & ACL_WRITE ) // Partial perms on mask and entry
                     strEffective[1] = 'W';
                 if ( maskPerms & partialPerms & ACL_EXECUTE || // Partial perms on entry
                      maskPartialPerms & perms & ACL_EXECUTE || // Partial perms on mask
                      maskPartialPerms & partialPerms & ACL_EXECUTE ) // Partial perms on mask and entry
                     strEffective[2] = 'X';
         */
     } else {
         // No, the effective value are just the value in this entry
         strEffective[0] = (value & ACL_READ) ? 'r' : '-';
         strEffective[1] = (value & ACL_WRITE) ? 'w' : '-';
         strEffective[2] = (value & ACL_EXECUTE) ? 'x' : '-';
 
         /*
         // What about any partial perms?
         if ( partialPerms & ACL_READ )
             strEffective[0] = 'R';
         if ( partialPerms & ACL_WRITE )
             strEffective[1] = 'W';
         if ( partialPerms & ACL_EXECUTE )
             strEffective[2] = 'X';
             */
     }
     setText(5, strEffective);
 }
 
 bool KACLListViewItem::isDeletable() const
 {
     bool isMaskAndDeletable = false;
     if (type == KACLListView::Mask) {
         if (!isDefault &&  m_pACLListView->maskCanBeDeleted()) {
             isMaskAndDeletable = true;
         } else if (isDefault &&  m_pACLListView->defaultMaskCanBeDeleted()) {
             isMaskAndDeletable = true;
         }
     }
     return type != KACLListView::User &&
            type != KACLListView::Group &&
            type != KACLListView::Others &&
            (type != KACLListView::Mask || isMaskAndDeletable);
 }
 
 bool KACLListViewItem::isAllowedToChangeType() const
 {
     return type != KACLListView::User &&
            type != KACLListView::Group &&
            type != KACLListView::Others &&
            type != KACLListView::Mask;
 }
 
 void KACLListViewItem::togglePerm(acl_perm_t perm)
 {
     value ^= perm; // Toggle the perm
     if (type == KACLListView::Mask && !isDefault) {
         m_pACLListView->setMaskPermissions(value);
     }
     calcEffectiveRights();
     updatePermPixmaps();
     /*
         // If the perm is in the partial perms then remove it. i.e. Once
         // a user changes a partial perm it then applies to all selected files.
         if ( m_pEntry->m_partialPerms & perm )
             m_pEntry->m_partialPerms ^= perm;
 
         m_pEntry->setPartialEntry( false );
         // Make sure that all entries have their effective rights calculated if
         // we are changing the ACL_MASK entry.
         if ( type == Mask )
         {
             m_pACLListView->setMaskPartialPermissions( m_pEntry->m_partialPerms );
             m_pACLListView->setMaskPermissions( value );
             m_pACLListView->calculateEffectiveRights();
         }
     */
 }
 
 EditACLEntryDialog::EditACLEntryDialog(KACLListView *listView, KACLListViewItem *item,
                                        const QStringList &users,
                                        const QStringList &groups,
                                        const QStringList &defaultUsers,
                                        const QStringList &defaultGroups,
                                        int allowedTypes, int allowedDefaultTypes,
                                        bool allowDefaults)
     : QDialog(listView),
       m_listView(listView), m_item(item), m_users(users), m_groups(groups),
       m_defaultUsers(defaultUsers), m_defaultGroups(defaultGroups),
       m_allowedTypes(allowedTypes), m_allowedDefaultTypes(allowedDefaultTypes),
       m_defaultCB(nullptr)
 {
     setObjectName(QStringLiteral("edit_entry_dialog"));
     setModal(true);
     setWindowTitle(i18n("Edit ACL Entry"));
 
     QVBoxLayout *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
     QGroupBox *gb = new QGroupBox(i18n("Entry Type"), this);
     QVBoxLayout *gbLayout = new QVBoxLayout(gb);
 
     m_buttonGroup = new QButtonGroup(this);
 
     if (allowDefaults) {
         m_defaultCB = new QCheckBox(i18n("Default for new files in this folder"), this);
         m_defaultCB->setObjectName(QStringLiteral("defaultCB"));
         mainLayout->addWidget(m_defaultCB);
         connect(m_defaultCB, &QAbstractButton::toggled,
                 this, &EditACLEntryDialog::slotUpdateAllowedUsersAndGroups);
         connect(m_defaultCB, &QAbstractButton::toggled,
                 this, &EditACLEntryDialog::slotUpdateAllowedTypes);
     }
 
     QRadioButton *ownerType = new QRadioButton(i18n("Owner"), gb);
     ownerType->setObjectName(QStringLiteral("ownerType"));
     gbLayout->addWidget(ownerType);
     m_buttonGroup->addButton(ownerType);
     m_buttonIds.insert(ownerType, KACLListView::User);
     QRadioButton *owningGroupType = new QRadioButton(i18n("Owning Group"), gb);
     owningGroupType->setObjectName(QStringLiteral("owningGroupType"));
     gbLayout->addWidget(owningGroupType);
     m_buttonGroup->addButton(owningGroupType);
     m_buttonIds.insert(owningGroupType, KACLListView::Group);
     QRadioButton *othersType = new QRadioButton(i18n("Others"), gb);
     othersType->setObjectName(QStringLiteral("othersType"));
     gbLayout->addWidget(othersType);
     m_buttonGroup->addButton(othersType);
     m_buttonIds.insert(othersType, KACLListView::Others);
     QRadioButton *maskType = new QRadioButton(i18n("Mask"), gb);
     maskType->setObjectName(QStringLiteral("maskType"));
     gbLayout->addWidget(maskType);
     m_buttonGroup->addButton(maskType);
     m_buttonIds.insert(maskType, KACLListView::Mask);
     QRadioButton *namedUserType = new QRadioButton(i18n("Named user"), gb);
     namedUserType->setObjectName(QStringLiteral("namesUserType"));
     gbLayout->addWidget(namedUserType);
     m_buttonGroup->addButton(namedUserType);
     m_buttonIds.insert(namedUserType, KACLListView::NamedUser);
     QRadioButton *namedGroupType = new QRadioButton(i18n("Named group"), gb);
     namedGroupType->setObjectName(QStringLiteral("namedGroupType"));
     gbLayout->addWidget(namedGroupType);
     m_buttonGroup->addButton(namedGroupType);
     m_buttonIds.insert(namedGroupType, KACLListView::NamedGroup);
 
     mainLayout->addWidget(gb);
 
     connect(m_buttonGroup, QOverload<QAbstractButton*>::of(&QButtonGroup::buttonClicked),
             this, &EditACLEntryDialog::slotSelectionChanged);
 
     m_widgetStack = new QStackedWidget(this);
     mainLayout->addWidget(m_widgetStack);
 
     // users box
     QWidget *usersBox = new QWidget(m_widgetStack);
     QHBoxLayout *usersLayout = new QHBoxLayout(usersBox);
     usersBox->setLayout(usersLayout);
     m_widgetStack->addWidget(usersBox);
 
     QLabel *usersLabel = new QLabel(i18n("User: "), usersBox);
     m_usersCombo = new KComboBox(usersBox);
     m_usersCombo->setEditable(false);
     m_usersCombo->setObjectName(QStringLiteral("users"));
     usersLabel->setBuddy(m_usersCombo);
 
     usersLayout->addWidget(usersLabel);
     usersLayout->addWidget(m_usersCombo);
 
     // groups box
     QWidget *groupsBox = new QWidget(m_widgetStack);
     QHBoxLayout *groupsLayout = new QHBoxLayout(usersBox);
     groupsBox->setLayout(groupsLayout);
     m_widgetStack->addWidget(groupsBox);
 
     QLabel *groupsLabel = new QLabel(i18n("Group: "), groupsBox);
     m_groupsCombo = new KComboBox(groupsBox);
     m_groupsCombo->setEditable(false);
     m_groupsCombo->setObjectName(QStringLiteral("groups"));
     groupsLabel->setBuddy(m_groupsCombo);
 
     groupsLayout->addWidget(groupsLabel);
     groupsLayout->addWidget(m_groupsCombo);
 
     if (m_item) {
         m_buttonIds.key(m_item->type)->setChecked(true);
         if (m_defaultCB) {
             m_defaultCB->setChecked(m_item->isDefault);
         }
         slotUpdateAllowedTypes();
         slotSelectionChanged(m_buttonIds.key(m_item->type));
         slotUpdateAllowedUsersAndGroups();
         if (m_item->type == KACLListView::NamedUser) {
             m_usersCombo->setItemText(m_usersCombo->currentIndex(), m_item->qualifier);
         } else if (m_item->type == KACLListView::NamedGroup) {
             m_groupsCombo->setItemText(m_groupsCombo->currentIndex(), m_item->qualifier);
         }
     } else {
         // new entry, preselect "named user", arguably the most common one
         m_buttonIds.key(KACLListView::NamedUser)->setChecked(true);
         slotUpdateAllowedTypes();
         slotSelectionChanged(m_buttonIds.key(KACLListView::NamedUser));
         slotUpdateAllowedUsersAndGroups();
     }
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(this);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &EditACLEntryDialog::slotOk);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
     mainLayout->addWidget(buttonBox);
 
     adjustSize();
 }
 
 void EditACLEntryDialog::slotUpdateAllowedTypes()
 {
     int allowedTypes = m_allowedTypes;
     if (m_defaultCB && m_defaultCB->isChecked()) {
         allowedTypes = m_allowedDefaultTypes;
     }
     for (int i = 1; i < KACLListView::AllTypes; i = i * 2) {
         if (allowedTypes & i) {
             m_buttonIds.key(i)->show();
         } else {
             m_buttonIds.key(i)->hide();
         }
     }
 }
 
 void EditACLEntryDialog::slotUpdateAllowedUsersAndGroups()
 {
     const QString oldUser = m_usersCombo->currentText();
     const QString oldGroup = m_groupsCombo->currentText();
     m_usersCombo->clear();
     m_groupsCombo->clear();
     if (m_defaultCB && m_defaultCB->isChecked()) {
         m_usersCombo->addItems(m_defaultUsers);
         if (m_defaultUsers.contains(oldUser)) {
             m_usersCombo->setItemText(m_usersCombo->currentIndex(), oldUser);
         }
         m_groupsCombo->addItems(m_defaultGroups);
         if (m_defaultGroups.contains(oldGroup)) {
             m_groupsCombo->setItemText(m_groupsCombo->currentIndex(), oldGroup);
         }
     } else {
         m_usersCombo->addItems(m_users);
         if (m_users.contains(oldUser)) {
             m_usersCombo->setItemText(m_usersCombo->currentIndex(), oldUser);
         }
         m_groupsCombo->addItems(m_groups);
         if (m_groups.contains(oldGroup)) {
             m_groupsCombo->setItemText(m_groupsCombo->currentIndex(), oldGroup);
         }
     }
 }
 void EditACLEntryDialog::slotOk()
 {
     KACLListView::EntryType type = static_cast<KACLListView::EntryType>(m_buttonIds[m_buttonGroup->checkedButton()]);
 
     qCWarning(KIO_WIDGETS) << "Type 2: " << type;
 
     QString qualifier;
     if (type == KACLListView::NamedUser) {
         qualifier = m_usersCombo->currentText();
     }
     if (type == KACLListView::NamedGroup) {
         qualifier = m_groupsCombo->currentText();
     }
 
     if (!m_item) {
         m_item = new KACLListViewItem(m_listView, type, ACL_READ | ACL_WRITE | ACL_EXECUTE, false, qualifier);
     } else {
         m_item->type = type;
         m_item->qualifier = qualifier;
     }
     if (m_defaultCB) {
         m_item->isDefault = m_defaultCB->isChecked();
     }
     m_item->repaint();
 
     QDialog::accept();
 }
 
 void EditACLEntryDialog::slotSelectionChanged(QAbstractButton *button)
 {
     switch (m_buttonIds[ button ]) {
     case KACLListView::User:
     case KACLListView::Group:
     case KACLListView::Others:
     case KACLListView::Mask:
         m_widgetStack->setEnabled(false);
         break;
     case KACLListView::NamedUser:
         m_widgetStack->setEnabled(true);
         m_widgetStack->setCurrentIndex(0 /* User */);
         break;
     case KACLListView::NamedGroup:
         m_widgetStack->setEnabled(true);
         m_widgetStack->setCurrentIndex(1 /* Group */);
         break;
     default:
         break;
     }
 }
 
 KACLListView::KACLListView(QWidget *parent)
     : QTreeWidget(parent),
       m_hasMask(false), m_allowDefaults(false)
 {
     // Add the columns
     setColumnCount(6);
     const QStringList headers {
         i18n("Type"),
         i18n("Name"),
         i18nc("read permission", "r"),
         i18nc("write permission", "w"),
         i18nc("execute permission", "x"),
         i18n("Effective"),
     };
     setHeaderLabels(headers);
 
     setSortingEnabled(false);
     setSelectionMode(QAbstractItemView::ExtendedSelection);
     header()->setSectionResizeMode(QHeaderView::ResizeToContents);
     setRootIsDecorated(false);
 
     // Load the avatars
     for (int i = 0; i < LAST_IDX; ++i) {
         s_itemAttributes[i].pixmap = new QPixmap(QLatin1String(":/images/") + QLatin1String(s_itemAttributes[i].pixmapName));
     }
     m_yesPixmap = new QPixmap(QStringLiteral(":/images/yes.png"));
     m_yesPartialPixmap = new QPixmap(QStringLiteral(":/images/yespartial.png"));
 
     // fill the lists of all legal users and groups
     struct passwd *user = nullptr;
     setpwent();
     while ((user = getpwent()) != nullptr) {
         m_allUsers << QString::fromLatin1(user->pw_name);
     }
     endpwent();
 
     struct group *gr = nullptr;
     setgrent();
     while ((gr = getgrent()) != nullptr) {
         m_allGroups << QString::fromLatin1(gr->gr_name);
     }
     endgrent();
     m_allUsers.sort();
     m_allGroups.sort();
 
     connect(this, &QTreeWidget::itemClicked,
             this, &KACLListView::slotItemClicked);
 
     connect(this, &KACLListView::itemDoubleClicked,
             this, &KACLListView::slotItemDoubleClicked);
 }
 
 KACLListView::~KACLListView()
 {
     for (int i = 0; i < LAST_IDX; ++i) {
         delete s_itemAttributes[i].pixmap;
     }
     delete m_yesPixmap;
     delete m_yesPartialPixmap;
 }
 
 QStringList KACLListView::allowedUsers(bool defaults, KACLListViewItem *allowedItem)
 {
     QStringList allowedUsers = m_allUsers;
     QTreeWidgetItemIterator it(this);
     while (*it) {
         const KACLListViewItem *item = static_cast<const KACLListViewItem *>(*it);
         ++it;
         if (item->type != NamedUser || item->isDefault != defaults) {
             continue;
         }
         if (allowedItem && item == allowedItem && allowedItem->isDefault == defaults) {
             continue;
         }
         allowedUsers.removeAll(item->qualifier);
     }
     return allowedUsers;
 }
 
 QStringList KACLListView::allowedGroups(bool defaults, KACLListViewItem *allowedItem)
 {
     QStringList allowedGroups = m_allGroups;
     QTreeWidgetItemIterator it(this);
     while (*it) {
         const KACLListViewItem *item = static_cast<const KACLListViewItem *>(*it);
         ++it;
         if (item->type != NamedGroup || item->isDefault != defaults) {
             continue;
         }
         if (allowedItem && item == allowedItem && allowedItem->isDefault == defaults) {
             continue;
         }
         allowedGroups.removeAll(item->qualifier);
     }
     return allowedGroups;
 }
 
 void KACLListView::fillItemsFromACL(const KACL &pACL, bool defaults)
 {
     // clear out old entries of that ilk
     QTreeWidgetItemIterator it(this);
     while (KACLListViewItem *item = static_cast<KACLListViewItem *>(*it)) {
         ++it;
         if (item->isDefault == defaults) {
             delete item;
         }
     }
 
     new KACLListViewItem(this, User, pACL.ownerPermissions(), defaults);
 
     new KACLListViewItem(this, Group, pACL.owningGroupPermissions(), defaults);
 
     new KACLListViewItem(this, Others, pACL.othersPermissions(), defaults);
 
     bool hasMask = false;
     unsigned short mask = pACL.maskPermissions(hasMask);
     if (hasMask) {
         new KACLListViewItem(this, Mask, mask, defaults);
     }
 
     // read all named user entries
     const ACLUserPermissionsList &userList =  pACL.allUserPermissions();
     ACLUserPermissionsConstIterator itu = userList.begin();
     while (itu != userList.end()) {
         new KACLListViewItem(this, NamedUser, (*itu).second, defaults, (*itu).first);
         ++itu;
     }
 
     // and now all named groups
     const ACLUserPermissionsList &groupList =  pACL.allGroupPermissions();
     ACLUserPermissionsConstIterator itg = groupList.begin();
     while (itg != groupList.end()) {
         new KACLListViewItem(this, NamedGroup, (*itg).second, defaults, (*itg).first);
         ++itg;
     }
 }
 
 void KACLListView::setACL(const KACL &acl)
 {
     if (!acl.isValid()) {
         return;
     }
     // Remove any entries left over from displaying a previous ACL
     m_ACL = acl;
     fillItemsFromACL(m_ACL);
 
     m_mask = acl.maskPermissions(m_hasMask);
     calculateEffectiveRights();
 }
 
 void KACLListView::setDefaultACL(const KACL &acl)
 {
     if (!acl.isValid()) {
         return;
     }
     m_defaultACL = acl;
     fillItemsFromACL(m_defaultACL, true);
     calculateEffectiveRights();
 }
 
 KACL KACLListView::itemsToACL(bool defaults) const
 {
     KACL newACL(0);
     bool atLeastOneEntry = false;
     ACLUserPermissionsList users;
     ACLGroupPermissionsList groups;
     QTreeWidgetItemIterator it(const_cast<KACLListView *>(this));
     while (QTreeWidgetItem *qlvi = *it) {
         ++it;
         const KACLListViewItem *item = static_cast<KACLListViewItem *>(qlvi);
         if (item->isDefault != defaults) {
             continue;
         }
         atLeastOneEntry = true;
         switch (item->type) {
         case User:
             newACL.setOwnerPermissions(item->value);
             break;
         case Group:
             newACL.setOwningGroupPermissions(item->value);
             break;
         case Others:
             newACL.setOthersPermissions(item->value);
             break;
         case Mask:
             newACL.setMaskPermissions(item->value);
             break;
         case NamedUser:
             users.append(qMakePair(item->text(1), item->value));
             break;
         case NamedGroup:
             groups.append(qMakePair(item->text(1), item->value));
             break;
         default:
             break;
         }
     }
     if (atLeastOneEntry) {
         newACL.setAllUserPermissions(users);
         newACL.setAllGroupPermissions(groups);
         if (newACL.isValid()) {
             return newACL;
         }
     }
     return KACL();
 }
 
 KACL KACLListView::getACL()
 {
     return itemsToACL(false);
 }
 
 KACL KACLListView::getDefaultACL()
 {
     return itemsToACL(true);
 }
 
 void KACLListView::contentsMousePressEvent(QMouseEvent * /*e*/)
 {
     /*
     QTreeWidgetItem *clickedItem = itemAt( e->pos() );
     if ( !clickedItem ) return;
     // if the click is on an as yet unselected item, select it first
     if ( !clickedItem->isSelected() )
         QAbstractItemView::contentsMousePressEvent( e );
 
     if ( !currentItem() ) return;
     int column = header()->sectionAt( e->x() );
     acl_perm_t perm;
     switch ( column )
     {
         case 2:
             perm = ACL_READ;
             break;
         case 3:
             perm = ACL_WRITE;
             break;
         case 4:
             perm = ACL_EXECUTE;
             break;
         default:
             return QTreeWidget::contentsMousePressEvent( e );
     }
     KACLListViewItem* referenceItem = static_cast<KACLListViewItem*>( clickedItem );
     unsigned short referenceHadItSet = referenceItem->value & perm;
     QTreeWidgetItemIterator it( this );
     while ( KACLListViewItem* item = static_cast<KACLListViewItem*>( *it ) ) {
         ++it;
         if ( !item->isSelected() ) continue;
         // toggle those with the same value as the clicked item, leave the others
         if ( referenceHadItSet == ( item->value & perm ) )
             item->togglePerm( perm );
     }
      */
 }
 
 void KACLListView::slotItemClicked(QTreeWidgetItem *pItem,  int col)
 {
     if (!pItem) {
         return;
     }
 
     QTreeWidgetItemIterator it(this);
     while (KACLListViewItem *item = static_cast<KACLListViewItem *>(*it)) {
         ++it;
         if (!item->isSelected()) {
             continue;
         }
         switch (col) {
         case 2:
             item->togglePerm(ACL_READ);
             break;
         case 3:
             item->togglePerm(ACL_WRITE);
             break;
         case 4:
             item->togglePerm(ACL_EXECUTE);
             break;
 
         default:
             ; // Do nothing
         }
     }
     /*
     // Has the user changed one of the required entries in a default ACL?
     if ( m_pACL->aclType() == ACL_TYPE_DEFAULT &&
     ( col == 2 || col == 3 || col == 4 ) &&
     ( pACLItem->entryType() == ACL_USER_OBJ ||
     pACLItem->entryType() == ACL_GROUP_OBJ ||
     pACLItem->entryType() == ACL_OTHER ) )
     {
     // Mark the required entries as no longer being partial entries.
     // That is, they will get applied to all selected directories.
     KACLListViewItem* pUserObj = findACLEntryByType( this, ACL_USER_OBJ );
     pUserObj->entry()->setPartialEntry( false );
 
     KACLListViewItem* pGroupObj = findACLEntryByType( this, ACL_GROUP_OBJ );
     pGroupObj->entry()->setPartialEntry( false );
 
     KACLListViewItem* pOther = findACLEntryByType( this, ACL_OTHER );
     pOther->entry()->setPartialEntry( false );
 
     update();
     }
      */
 }
 
 void KACLListView::slotItemDoubleClicked(QTreeWidgetItem *item, int column)
 {
     if (!item) {
         return;
     }
 
     // avoid conflict with clicking to toggle permission
     if (column >= 2 && column <= 4) {
         return;
     }
 
     KACLListViewItem *aclListItem = static_cast<KACLListViewItem *>(item);
     if (!aclListItem->isAllowedToChangeType()) {
         return;
     }
 
     setCurrentItem(item);
     slotEditEntry();
 }
 
 void KACLListView::calculateEffectiveRights()
 {
     QTreeWidgetItemIterator it(this);
     KACLListViewItem *pItem;
     while ((pItem = dynamic_cast<KACLListViewItem *>(*it)) != nullptr) {
         ++it;
         pItem->calcEffectiveRights();
     }
 }
 
 unsigned short KACLListView::maskPermissions() const
 {
     return m_mask;
 }
 
 void KACLListView::setMaskPermissions(unsigned short maskPerms)
 {
     m_mask = maskPerms;
     calculateEffectiveRights();
 }
 
 acl_perm_t KACLListView::maskPartialPermissions() const
 {
     //  return m_pMaskEntry->m_partialPerms;
     return 0;
 }
 
 void KACLListView::setMaskPartialPermissions(acl_perm_t /*maskPartialPerms*/)
 {
     //m_pMaskEntry->m_partialPerms = maskPartialPerms;
     calculateEffectiveRights();
 }
 
 bool KACLListView::hasDefaultEntries() const
 {
     QTreeWidgetItemIterator it(const_cast<KACLListView *>(this));
     while (*it) {
         const KACLListViewItem *item = static_cast<const KACLListViewItem *>(*it);
         ++it;
         if (item->isDefault) {
             return true;
         }
     }
     return false;
 }
 
 const KACLListViewItem *KACLListView::findDefaultItemByType(EntryType type) const
 {
     return findItemByType(type, true);
 }
 
 const KACLListViewItem *KACLListView::findItemByType(EntryType type, bool defaults) const
 {
     QTreeWidgetItemIterator it(const_cast<KACLListView *>(this));
     while (*it) {
         const KACLListViewItem *item = static_cast<const KACLListViewItem *>(*it);
         ++it;
         if (item->isDefault == defaults && item->type == type) {
             return item;
         }
     }
     return nullptr;
 }
 
 unsigned short KACLListView::calculateMaskValue(bool defaults) const
 {
     // KACL auto-adds the relevant maks entries, so we can simply query
     bool dummy;
     return itemsToACL(defaults).maskPermissions(dummy);
 }
 
 void KACLListView::slotAddEntry()
 {
     int allowedTypes = NamedUser | NamedGroup;
     if (!m_hasMask) {
         allowedTypes |= Mask;
     }
     int allowedDefaultTypes = NamedUser | NamedGroup;
     if (!findDefaultItemByType(Mask)) {
         allowedDefaultTypes |=  Mask;
     }
     if (!hasDefaultEntries()) {
         allowedDefaultTypes |= User | Group;
     }
     EditACLEntryDialog dlg(this, nullptr,
                            allowedUsers(false), allowedGroups(false),
                            allowedUsers(true), allowedGroups(true),
                            allowedTypes, allowedDefaultTypes, m_allowDefaults);
     dlg.exec();
     KACLListViewItem *item = dlg.item();
     if (!item) {
         return;    // canceled
     }
     if (item->type == Mask && !item->isDefault) {
         m_hasMask = true;
         m_mask = item->value;
     }
     if (item->isDefault && !hasDefaultEntries()) {
         // first default entry, fill in what is needed
         if (item->type != User) {
             unsigned short v = findDefaultItemByType(User)->value;
             new KACLListViewItem(this, User, v, true);
         }
         if (item->type != Group) {
             unsigned short v = findDefaultItemByType(Group)->value;
             new KACLListViewItem(this, Group, v, true);
         }
         if (item->type != Others) {
             unsigned short v = findDefaultItemByType(Others)->value;
             new KACLListViewItem(this, Others, v, true);
         }
     }
     const KACLListViewItem *defaultMaskItem = findDefaultItemByType(Mask);
     if (item->isDefault && !defaultMaskItem) {
         unsigned short v = calculateMaskValue(true);
         new KACLListViewItem(this, Mask, v, true);
     }
     if (!item->isDefault && !m_hasMask &&
             (item->type == Group
              || item->type == NamedUser
              || item->type == NamedGroup)) {
         // auto-add a mask entry
         unsigned short v = calculateMaskValue(false);
         new KACLListViewItem(this, Mask, v, false);
         m_hasMask = true;
         m_mask = v;
     }
     calculateEffectiveRights();
     sortItems(sortColumn(), Qt::AscendingOrder);
     setCurrentItem(item);
     // QTreeWidget doesn't seem to emit, in this case, and we need to update
     // the buttons...
     if (topLevelItemCount() == 1) {
         emit currentItemChanged(item, item);
     }
 }
 
 void KACLListView::slotEditEntry()
 {
     QTreeWidgetItem *current = currentItem();
     if (!current) {
         return;
     }
     KACLListViewItem *item = static_cast<KACLListViewItem *>(current);
     int allowedTypes = item->type | NamedUser | NamedGroup;
     bool itemWasMask = item->type == Mask;
     if (!m_hasMask || itemWasMask) {
         allowedTypes |= Mask;
     }
     int allowedDefaultTypes = item->type | NamedUser | NamedGroup;
     if (!findDefaultItemByType(Mask)) {
         allowedDefaultTypes |=  Mask;
     }
     if (!hasDefaultEntries()) {
         allowedDefaultTypes |= User | Group;
     }
 
     EditACLEntryDialog dlg(this, item,
                            allowedUsers(false, item), allowedGroups(false, item),
                            allowedUsers(true, item), allowedGroups(true, item),
                            allowedTypes, allowedDefaultTypes, m_allowDefaults);
     dlg.exec();
     if (itemWasMask && item->type != Mask) {
         m_hasMask = false;
         m_mask = 0;
     }
     if (!itemWasMask && item->type == Mask) {
         m_mask = item->value;
         m_hasMask = true;
     }
     calculateEffectiveRights();
     sortItems(sortColumn(), Qt::AscendingOrder);
 }
 
 void KACLListView::slotRemoveEntry()
 {
     QTreeWidgetItemIterator it(this, QTreeWidgetItemIterator::Selected);
     while (*it) {
         KACLListViewItem *item = static_cast<KACLListViewItem *>(*it);
         ++it;
         /* First check if it's a mask entry and if so, make sure that there is
          * either no name user or group entry, which means the mask can be
          * removed, or don't remove it, but reset it. That is allowed. */
         if (item->type == Mask) {
             bool itemWasDefault = item->isDefault;
             if (!itemWasDefault && maskCanBeDeleted()) {
                 m_hasMask = false;
                 m_mask = 0;
                 delete item;
             } else if (itemWasDefault && defaultMaskCanBeDeleted()) {
                 delete item;
             } else {
                 item->value = 0;
                 item->repaint();
             }
             if (!itemWasDefault) {
                 calculateEffectiveRights();
             }
         } else {
             // for the base permissions, disable them, which is what libacl does
             if (!item->isDefault &&
                     (item->type == User
                      || item->type == Group
                      || item->type == Others)) {
                 item->value = 0;
                 item->repaint();
             } else {
                 delete item;
             }
         }
     }
 }
 
 bool KACLListView::maskCanBeDeleted() const
 {
     return !findItemByType(NamedUser) && !findItemByType(NamedGroup);
 }
 
 bool KACLListView::defaultMaskCanBeDeleted() const
 {
     return !findDefaultItemByType(NamedUser) && !findDefaultItemByType(NamedGroup);
 }
 
 #include "moc_kacleditwidget.cpp"
 #include "moc_kacleditwidget_p.cpp"
 #endif
diff --git a/src/widgets/kopenwithdialog.cpp b/src/widgets/kopenwithdialog.cpp
index ecfc2d81..40f703ab 100644
--- a/src/widgets/kopenwithdialog.cpp
+++ b/src/widgets/kopenwithdialog.cpp
@@ -1,1164 +1,1164 @@
 /*  This file is part of the KDE libraries
 
     Copyright (C) 1997 Torben Weis <weis@stud.uni-frankfurt.de>
     Copyright (C) 1999 Dirk Mueller <mueller@kde.org>
     Portions copyright (C) 1999 Preston Brown <pbrown@kde.org>
     Copyright (C) 2007 Pino Toscano <pino@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 "kopenwithdialog.h"
 #include "kopenwithdialog_p.h"
 #include "kio_widgets_debug.h"
 
 #include <QApplication>
 #include <QDesktopWidget>
 #include <QDialogButtonBox>
 #include <QtAlgorithms>
 #include <QList>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QLayout>
 #include <QCheckBox>
 #include <QStyle>
 #include <QStyleOptionButton>
 #include <qstandardpaths.h>
 #include <qmimedatabase.h>
 
 #include <kurlauthorized.h>
 #include <khistorycombobox.h>
 #include <kdesktopfile.h>
 #include <klineedit.h>
 #include <ksharedconfig.h>
 #include <klocalizedstring.h>
 #include <kmessagebox.h>
 #include <kshell.h>
 #include <kio/desktopexecparser.h>
 #include <kstringhandler.h>
 #include <kurlcompletion.h>
 #include <kurlrequester.h>
 #include <kservicegroup.h>
 #include <kcollapsiblegroupbox.h>
 #include <QDebug>
 
 #include <assert.h>
 #include <stdlib.h>
 #include <kbuildsycocaprogressdialog.h>
 #include <kconfiggroup.h>
 
 inline void writeEntry(KConfigGroup &group, const char *key,
                        const KCompletion::CompletionMode &aValue,
                        KConfigBase::WriteConfigFlags flags = KConfigBase::Normal)
 {
     group.writeEntry(key, int(aValue), flags);
 }
 
 namespace KDEPrivate
 {
 
 class AppNode
 {
 public:
     AppNode()
         : isDir(false), parent(nullptr), fetched(false)
     {
     }
     ~AppNode()
     {
         qDeleteAll(children);
     }
     AppNode(const AppNode &) = delete;
     AppNode &operator=(const AppNode &) = delete;
 
     QString icon;
     QString text;
     QString entryPath;
     QString exec;
     bool isDir;
 
     AppNode *parent;
     bool fetched;
 
     QList<AppNode *> children;
 };
 
 static bool AppNodeLessThan(KDEPrivate::AppNode *n1, KDEPrivate::AppNode *n2)
 {
     if (n1->isDir) {
         if (n2->isDir) {
             return n1->text.compare(n2->text, Qt::CaseInsensitive) < 0;
         } else {
             return true;
         }
     } else {
         if (n2->isDir) {
             return false;
         } else {
             return n1->text.compare(n2->text, Qt::CaseInsensitive) < 0;
         }
     }
 }
 
 }
 
 class KApplicationModelPrivate
 {
 public:
     explicit KApplicationModelPrivate(KApplicationModel *qq)
         : q(qq), root(new KDEPrivate::AppNode())
     {
     }
     ~KApplicationModelPrivate()
     {
         delete root;
     }
 
     void fillNode(const QString &entryPath, KDEPrivate::AppNode *node);
 
     KApplicationModel * const q;
 
     KDEPrivate::AppNode *root;
 };
 
 void KApplicationModelPrivate::fillNode(const QString &_entryPath, KDEPrivate::AppNode *node)
 {
     KServiceGroup::Ptr root = KServiceGroup::group(_entryPath);
     if (!root || !root->isValid()) {
         return;
     }
 
     const KServiceGroup::List list = root->entries();
 
     for (KServiceGroup::List::ConstIterator it = list.begin();
             it != list.end(); ++it) {
         QString icon;
         QString text;
         QString entryPath;
         QString exec;
         bool isDir = false;
         const KSycocaEntry::Ptr p = (*it);
         if (p->isType(KST_KService)) {
             const KService::Ptr service(static_cast<KService*>(p.data()));
 
             if (service->noDisplay()) {
                 continue;
             }
 
             icon = service->icon();
             text = service->name();
             exec = service->exec();
             entryPath = service->entryPath();
         } else if (p->isType(KST_KServiceGroup)) {
             const KServiceGroup::Ptr serviceGroup(static_cast<KServiceGroup*>(p.data()));
 
             if (serviceGroup->noDisplay() || serviceGroup->childCount() == 0) {
                 continue;
             }
 
             icon = serviceGroup->icon();
             text = serviceGroup->caption();
             entryPath = serviceGroup->entryPath();
             isDir = true;
         } else {
             qCWarning(KIO_WIDGETS) << "KServiceGroup: Unexpected object in list!";
             continue;
         }
 
         KDEPrivate::AppNode *newnode = new KDEPrivate::AppNode();
         newnode->icon = icon;
         newnode->text = text;
         newnode->entryPath = entryPath;
         newnode->exec = exec;
         newnode->isDir = isDir;
         newnode->parent = node;
         node->children.append(newnode);
     }
     qStableSort(node->children.begin(), node->children.end(), KDEPrivate::AppNodeLessThan);
 }
 
 KApplicationModel::KApplicationModel(QObject *parent)
     : QAbstractItemModel(parent), d(new KApplicationModelPrivate(this))
 {
     d->fillNode(QString(), d->root);
     const int nRows = rowCount();
     for (int i = 0; i < nRows; i++) {
         fetchAll(index(i, 0));
     }
 }
 
 KApplicationModel::~KApplicationModel()
 {
     delete d;
 }
 
 bool KApplicationModel::canFetchMore(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return false;
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(parent.internalPointer());
     return node->isDir && !node->fetched;
 }
 
 int KApplicationModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 1;
 }
 
 QVariant KApplicationModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(index.internalPointer());
 
     switch (role) {
     case Qt::DisplayRole:
         return node->text;
     case Qt::DecorationRole:
         if (!node->icon.isEmpty()) {
             return QIcon::fromTheme(node->icon);
         }
         break;
     default:
         ;
     }
     return QVariant();
 }
 
 void KApplicationModel::fetchMore(const QModelIndex &parent)
 {
     if (!parent.isValid()) {
         return;
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(parent.internalPointer());
     if (!node->isDir) {
         return;
     }
 
     emit layoutAboutToBeChanged();
     d->fillNode(node->entryPath, node);
     node->fetched = true;
     emit layoutChanged();
 }
 
 void KApplicationModel::fetchAll(const QModelIndex &parent)
 {
     if (!parent.isValid() || !canFetchMore(parent)) {
         return;
     }
 
     fetchMore(parent);
 
     int childCount = rowCount(parent);
     for (int i = 0; i < childCount; i++) {
         const QModelIndex &child = parent.child(i, 0);
         // Recursively call the function for each child node.
         fetchAll(child);
     }
 }
 
 bool KApplicationModel::hasChildren(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return true;
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(parent.internalPointer());
     return node->isDir;
 }
 
 QVariant KApplicationModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation != Qt::Horizontal || section != 0) {
         return QVariant();
     }
 
     switch (role) {
     case Qt::DisplayRole:
         return i18n("Known Applications");
     default:
         return QVariant();
     }
 }
 
 QModelIndex KApplicationModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (row < 0 || column != 0) {
         return QModelIndex();
     }
 
     KDEPrivate::AppNode *node = d->root;
     if (parent.isValid()) {
         node = static_cast<KDEPrivate::AppNode *>(parent.internalPointer());
     }
 
     if (row >= node->children.count()) {
         return QModelIndex();
     } else {
         return createIndex(row, 0, node->children.at(row));
     }
 }
 
 QModelIndex KApplicationModel::parent(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return QModelIndex();
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(index.internalPointer());
     if (node->parent->parent) {
         int id = node->parent->parent->children.indexOf(node->parent);
 
         if (id >= 0 && id < node->parent->parent->children.count()) {
             return createIndex(id, 0, node->parent);
         } else {
             return QModelIndex();
         }
     } else {
         return QModelIndex();
     }
 }
 
 int KApplicationModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return d->root->children.count();
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(parent.internalPointer());
     return node->children.count();
 }
 
 QString KApplicationModel::entryPathFor(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return QString();
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(index.internalPointer());
     return node->entryPath;
 }
 
 QString KApplicationModel::execFor(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return QString();
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(index.internalPointer());
     return node->exec;
 }
 
 bool KApplicationModel::isDirectory(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return false;
     }
 
     KDEPrivate::AppNode *node = static_cast<KDEPrivate::AppNode *>(index.internalPointer());
     return node->isDir;
 }
 
 
 QTreeViewProxyFilter::QTreeViewProxyFilter(QObject *parent)
     : QSortFilterProxyModel(parent)
 {
 }
 
 bool QTreeViewProxyFilter::filterAcceptsRow(int sourceRow, const QModelIndex &parent) const
 {
     QModelIndex index = sourceModel()->index(sourceRow, 0, parent);
 
     if (!index.isValid()) {
         return false;
     }
 
     // Match the regexp only on leaf nodes
     if (!sourceModel()->hasChildren(index) && index.data().toString().contains(filterRegExp())) {
         return true;
     }
 
     //Show the non-leaf node also if the regexp matches one of its children
     int rows = sourceModel()->rowCount(index);
     for (int crow = 0; crow < rows; crow++) {
         if (filterAcceptsRow(crow, index)) {
             return true;
         }
     }
 
     return false;
 }
 
 class KApplicationViewPrivate
 {
 public:
     KApplicationViewPrivate()
         : appModel(nullptr),
           m_proxyModel(nullptr)
     {
     }
 
     KApplicationModel *appModel;
     QSortFilterProxyModel *m_proxyModel;
 };
 
 KApplicationView::KApplicationView(QWidget *parent)
     : QTreeView(parent), d(new KApplicationViewPrivate)
 {
     setHeaderHidden(true);
 }
 
 KApplicationView::~KApplicationView()
 {
     delete d;
 }
 
 void KApplicationView::setModels(KApplicationModel *model, QSortFilterProxyModel *proxyModel)
 {
     if (d->appModel) {
         disconnect(selectionModel(), &QItemSelectionModel::selectionChanged,
                    this, &KApplicationView::slotSelectionChanged);
     }
 
     QTreeView::setModel(proxyModel); // Here we set the proxy model
     d->m_proxyModel = proxyModel; // Also store it in a member property to avoid many casts later
 
     d->appModel = model;
     if (d->appModel) {
         connect(selectionModel(), &QItemSelectionModel::selectionChanged,
                 this, &KApplicationView::slotSelectionChanged);
     }
 }
 
 QSortFilterProxyModel* KApplicationView::proxyModel()
 {
     return d->m_proxyModel;
 }
 
 bool KApplicationView::isDirSel() const
 {
     if (d->appModel) {
         QModelIndex index = selectionModel()->currentIndex();
         index = d->m_proxyModel->mapToSource(index);
         return d->appModel->isDirectory(index);
     }
     return false;
 }
 
 void KApplicationView::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTreeView::currentChanged(current, previous);
 
     if (d->appModel) {
         QModelIndex sourceCurrent = d->m_proxyModel->mapToSource(current);
         if(!d->appModel->isDirectory(sourceCurrent)) {
             QString exec = d->appModel->execFor(sourceCurrent);
             if (!exec.isEmpty()) {
                 emit highlighted(d->appModel->entryPathFor(sourceCurrent), exec);
             }
         }
     }
 }
 
 void KApplicationView::slotSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
 {
     Q_UNUSED(deselected)
 
     QItemSelection sourceSelected = d->m_proxyModel->mapSelectionToSource(selected);
 
     const QModelIndexList indexes = sourceSelected.indexes();
     if (indexes.count() == 1) {
         QString exec = d->appModel->execFor(indexes.at(0));
         emit this->selected(d->appModel->entryPathFor(indexes.at(0)), exec);
     }
 }
 
 /***************************************************************
  *
  * KOpenWithDialog
  *
  ***************************************************************/
 class KOpenWithDialogPrivate
 {
 public:
     explicit KOpenWithDialogPrivate(KOpenWithDialog *qq)
         : q(qq), saveNewApps(false)
     {
     }
 
     KOpenWithDialog * const q;
 
     /**
      * Determine mime type from URLs
      */
     void setMimeType(const QList<QUrl> &_urls);
 
     void addToMimeAppsList(const QString &serviceId);
 
     /**
      * Create a dialog that asks for a application to open a given
      * URL(s) with.
      *
      * @param text   appears as a label on top of the entry box.
      * @param value  is the initial value of the line
      */
     void init(const QString &text, const QString &value);
 
     /**
      * Called by checkAccept() in order to save the history of the combobox
      */
     void saveComboboxHistory();
 
     /**
      * Process the choices made by the user, and return true if everything is OK.
      * Called by KOpenWithDialog::accept(), i.e. when clicking on OK or typing Return.
      */
     bool checkAccept();
 
     // slots
     void _k_slotDbClick();
     void _k_slotFileSelected();
 
     bool saveNewApps;
     bool m_terminaldirty;
     KService::Ptr curService;
     KApplicationView *view;
     KUrlRequester *edit;
     QString m_command;
     QLabel *label;
     QString qMimeType;
     QString qMimeTypeComment;
     QCheckBox *terminal;
     QCheckBox *remember;
     QCheckBox *nocloseonexit;
     KService::Ptr m_pService;
     QDialogButtonBox *buttonBox;
 };
 
 KOpenWithDialog::KOpenWithDialog(const QList<QUrl> &_urls, QWidget *parent)
     : QDialog(parent), d(new KOpenWithDialogPrivate(this))
 {
     setObjectName(QStringLiteral("openwith"));
     setModal(true);
     setWindowTitle(i18n("Open With"));
 
     QString text;
     if (_urls.count() == 1) {
         text = i18n("<qt>Select the program that should be used to open <b>%1</b>. "
                     "If the program is not listed, enter the name or click "
                     "the browse button.</qt>",  _urls.first().fileName().toHtmlEscaped());
     } else
         // Should never happen ??
     {
         text = i18n("Choose the name of the program with which to open the selected files.");
     }
     d->setMimeType(_urls);
     d->init(text, QString());
 }
 
 KOpenWithDialog::KOpenWithDialog(const QList<QUrl> &_urls, const QString &_text,
                                  const QString &_value, QWidget *parent)
     : QDialog(parent), d(new KOpenWithDialogPrivate(this))
 {
     setObjectName(QStringLiteral("openwith"));
     setModal(true);
     QString text = _text;
     if (text.isEmpty() && !_urls.isEmpty()) {
         if (_urls.count() == 1) {
             const QString fileName = KStringHandler::csqueeze(_urls.first().fileName());
             text = i18n("<qt>Select the program you want to use to open the file<br/>%1</qt>", fileName.toHtmlEscaped());
         } else {
             text = i18np("<qt>Select the program you want to use to open the file.</qt>",
                          "<qt>Select the program you want to use to open the %1 files.</qt>", _urls.count());
         }
     }
     setWindowTitle(i18n("Choose Application"));
     d->setMimeType(_urls);
     d->init(text, _value);
 }
 
 KOpenWithDialog::KOpenWithDialog(const QString &mimeType, const QString &value,
                                  QWidget *parent)
     : QDialog(parent), d(new KOpenWithDialogPrivate(this))
 {
     setObjectName(QStringLiteral("openwith"));
     setModal(true);
     setWindowTitle(i18n("Choose Application for %1", mimeType));
     QString text = i18n("<qt>Select the program for the file type: <b>%1</b>. "
                         "If the program is not listed, enter the name or click "
                         "the browse button.</qt>", mimeType);
     d->qMimeType = mimeType;
     QMimeDatabase db;
     d->qMimeTypeComment = db.mimeTypeForName(mimeType).comment();
     d->init(text, value);
     if (d->remember) {
         d->remember->hide();
     }
 }
 
 KOpenWithDialog::KOpenWithDialog(QWidget *parent)
     : QDialog(parent), d(new KOpenWithDialogPrivate(this))
 {
     setObjectName(QStringLiteral("openwith"));
     setModal(true);
     setWindowTitle(i18n("Choose Application"));
     QString text = i18n("<qt>Select a program. "
                         "If the program is not listed, enter the name or click "
                         "the browse button.</qt>");
     d->qMimeType.clear();
     d->init(text, QString());
 }
 
 void KOpenWithDialogPrivate::setMimeType(const QList<QUrl> &_urls)
 {
     if (_urls.count() == 1) {
         QMimeDatabase db;
         QMimeType mime = db.mimeTypeForUrl(_urls.first());
         qMimeType = mime.name();
         if (mime.isDefault()) {
             qMimeType.clear();
         } else {
             qMimeTypeComment = mime.comment();
         }
     } else {
         qMimeType.clear();
     }
 }
 
 void KOpenWithDialogPrivate::init(const QString &_text, const QString &_value)
 {
     bool bReadOnly = !KAuthorized::authorize(QStringLiteral("shell_access"));
     m_terminaldirty = false;
     view = nullptr;
     m_pService = nullptr;
     curService = nullptr;
 
     QBoxLayout *topLayout = new QVBoxLayout;
     q->setLayout(topLayout);
     label = new QLabel(_text, q);
     label->setWordWrap(true);
     topLayout->addWidget(label);
 
     if (!bReadOnly) {
         // init the history combo and insert it into the URL-Requester
         KHistoryComboBox *combo = new KHistoryComboBox();
         combo->setToolTip(i18n("Type to filter the applications below, or specify the name of a command.\nPress down arrow to navigate the results."));
         KLineEdit *lineEdit = new KLineEdit(q);
         lineEdit->setClearButtonEnabled(true);
         combo->setLineEdit(lineEdit);
         combo->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLengthWithIcon);
         combo->setDuplicatesEnabled(false);
         KConfigGroup cg(KSharedConfig::openConfig(), QStringLiteral("Open-with settings"));
         int max = cg.readEntry("Maximum history", 15);
         combo->setMaxCount(max);
         int mode = cg.readEntry("CompletionMode", int(KCompletion::CompletionNone));
         combo->setCompletionMode(static_cast<KCompletion::CompletionMode>(mode));
         const QStringList list = cg.readEntry("History", QStringList());
         combo->setHistoryItems(list, true);
         edit = new KUrlRequester(combo, q);
         edit->installEventFilter(q);
     } else {
         edit = new KUrlRequester(q);
         edit->lineEdit()->setReadOnly(true);
         edit->button()->hide();
     }
 
     edit->setText(_value);
     edit->setWhatsThis(i18n(
                            "Following the command, you can have several place holders which will be replaced "
                            "with the actual values when the actual program is run:\n"
                            "%f - a single file name\n"
                            "%F - a list of files; use for applications that can open several local files at once\n"
                            "%u - a single URL\n"
                            "%U - a list of URLs\n"
                            "%d - the directory of the file to open\n"
                            "%D - a list of directories\n"
                            "%i - the icon\n"
                            "%m - the mini-icon\n"
                            "%c - the comment"));
 
     topLayout->addWidget(edit);
 
     if (edit->comboBox()) {
         KUrlCompletion *comp = new KUrlCompletion(KUrlCompletion::ExeCompletion);
         edit->comboBox()->setCompletionObject(comp);
         edit->comboBox()->setAutoDeleteCompletionObject(true);
     }
 
     QObject::connect(edit, &KUrlRequester::textChanged, q, &KOpenWithDialog::slotTextChanged);
     QObject::connect(edit, SIGNAL(urlSelected(QUrl)), q, SLOT(_k_slotFileSelected()));
 
     QTreeViewProxyFilter *proxyModel = new QTreeViewProxyFilter(view);
     KApplicationModel *appModel = new KApplicationModel(proxyModel);
     proxyModel->setSourceModel(appModel);
     proxyModel->setFilterKeyColumn(0);
     proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
     view = new KApplicationView(q);
     view->setModels(appModel, proxyModel);
     topLayout->addWidget(view);
     topLayout->setStretchFactor(view, 1);
 
     QObject::connect(view, &KApplicationView::selected,
                      q, &KOpenWithDialog::slotSelected);
     QObject::connect(view, &KApplicationView::highlighted,
                      q, &KOpenWithDialog::slotHighlighted);
     QObject::connect(view, SIGNAL(doubleClicked(QModelIndex)),
                      q, SLOT(_k_slotDbClick()));
 
     if (!qMimeType.isNull()) {
         remember = new QCheckBox(i18n("&Remember application association for all files of type\n\"%1\" (%2)", qMimeTypeComment, qMimeType));
         //    remember->setChecked(true);
         topLayout->addWidget(remember);
     } else {
         remember = nullptr;
     }
 
     //Advanced options
     KCollapsibleGroupBox *dialogExtension = new KCollapsibleGroupBox(q);
     dialogExtension->setTitle(i18n("Terminal options"));
 
     QVBoxLayout *dialogExtensionLayout = new QVBoxLayout;
-    dialogExtensionLayout->setMargin(0);
+    dialogExtensionLayout->setContentsMargins(0, 0, 0, 0);
 
     terminal = new QCheckBox(i18n("Run in &terminal"), q);
     if (bReadOnly) {
         terminal->hide();
     }
     QObject::connect(terminal, &QAbstractButton::toggled, q, &KOpenWithDialog::slotTerminalToggled);
 
     dialogExtensionLayout->addWidget(terminal);
 
     QStyleOptionButton checkBoxOption;
     checkBoxOption.initFrom(terminal);
     int checkBoxIndentation = terminal->style()->pixelMetric(QStyle::PM_IndicatorWidth, &checkBoxOption, terminal);
     checkBoxIndentation += terminal->style()->pixelMetric(QStyle::PM_CheckBoxLabelSpacing, &checkBoxOption, terminal);
 
     QBoxLayout *nocloseonexitLayout = new QHBoxLayout();
-    nocloseonexitLayout->setMargin(0);
+    nocloseonexitLayout->setContentsMargins(0, 0, 0, 0);
     QSpacerItem *spacer = new QSpacerItem(checkBoxIndentation, 0, QSizePolicy::Fixed, QSizePolicy::Minimum);
     nocloseonexitLayout->addItem(spacer);
 
     nocloseonexit = new QCheckBox(i18n("&Do not close when command exits"), q);
     nocloseonexit->setChecked(false);
     nocloseonexit->setDisabled(true);
 
     // check to see if we use konsole if not disable 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"));
 
     if (bReadOnly || preferredTerminal != QStringLiteral("konsole")) {
         nocloseonexit->hide();
     }
 
     nocloseonexitLayout->addWidget(nocloseonexit);
     dialogExtensionLayout->addLayout(nocloseonexitLayout);
 
     dialogExtension->setLayout(dialogExtensionLayout);
     topLayout->addWidget(dialogExtension);
 
     buttonBox = new QDialogButtonBox(q);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     q->connect(buttonBox, &QDialogButtonBox::accepted, q, &QDialog::accept);
     q->connect(buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject);
     topLayout->addWidget(buttonBox);
 
     q->setMinimumSize(q->minimumSizeHint());
     //edit->setText( _value );
     // The resize is what caused "can't click on items before clicking on Name header" in previous versions.
     // Probably due to the resizeEvent handler using width().
     q->resize( q->minimumWidth(), 0.6*QApplication::desktop()->availableGeometry().height());
     edit->setFocus();
     q->slotTextChanged();
 }
 
 // ----------------------------------------------------------------------
 
 KOpenWithDialog::~KOpenWithDialog()
 {
     delete d;
 }
 
 // ----------------------------------------------------------------------
 
 void KOpenWithDialog::slotSelected(const QString & /*_name*/, const QString &_exec)
 {
     d->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!_exec.isEmpty());
 }
 
 // ----------------------------------------------------------------------
 
 void KOpenWithDialog::slotHighlighted(const QString &entryPath, const QString &)
 {
     d->curService = KService::serviceByDesktopPath(entryPath);
     if (d->curService && !d->m_terminaldirty) {
         // ### indicate that default value was restored
         d->terminal->setChecked(d->curService->terminal());
         QString terminalOptions = d->curService->terminalOptions();
         d->nocloseonexit->setChecked((terminalOptions.contains(QLatin1String("--noclose"))));
         d->m_terminaldirty = false; // slotTerminalToggled changed it
     }
 }
 
 // ----------------------------------------------------------------------
 
 void KOpenWithDialog::slotTextChanged()
 {
     // Forget about the service only when the selection is empty
     // otherwise changing text but hitting the same result clears curService
     bool selectionEmpty = !d->view->currentIndex().isValid();
     if (d->curService && selectionEmpty) {
         d->curService = nullptr;
     }
     d->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(!d->edit->text().isEmpty() || d->curService);
 
     //Update the filter regexp with the new text in the lineedit
     d->view->proxyModel()->setFilterFixedString(d->edit->text());
 
     //Expand all the nodes when the search string is 3 characters long
     //If the search string doesn't match anything there will be no nodes to expand
     if (d->edit->text().size() > 2) {
         d->view->expandAll();
         //Automatically select the first result (first leaf node) when the filter has match
         QModelIndex leafNodeIdx = d->view->model()->index(0, 0);
         while (d->view->model()->hasChildren(leafNodeIdx)) {
             leafNodeIdx = leafNodeIdx.child(0,0);
         }
         d->view->setCurrentIndex(leafNodeIdx);
     } else {
         d->view->collapseAll();
         d->view->setCurrentIndex(d->view->rootIndex()); // Unset and deselect all the elements
         d->curService = nullptr;
     }
 }
 
 // ----------------------------------------------------------------------
 
 void KOpenWithDialog::slotTerminalToggled(bool)
 {
     // ### indicate that default value was overridden
     d->m_terminaldirty = true;
     d->nocloseonexit->setDisabled(!d->terminal->isChecked());
 }
 
 // ----------------------------------------------------------------------
 
 void KOpenWithDialogPrivate::_k_slotDbClick()
 {
     // check if a directory is selected
     if (view->isDirSel()) {
         return;
     }
     q->accept();
 }
 
 void KOpenWithDialogPrivate::_k_slotFileSelected()
 {
     // quote the path to avoid unescaped whitespace, backslashes, etc.
     edit->setText(KShell::quoteArg(edit->text()));
 }
 
 void KOpenWithDialog::setSaveNewApplications(bool b)
 {
     d->saveNewApps = b;
 }
 
 static QString simplifiedExecLineFromService(const QString &fullExec)
 {
     QString exec = fullExec;
     exec.remove(QStringLiteral("%u"), Qt::CaseInsensitive);
     exec.remove(QStringLiteral("%f"), Qt::CaseInsensitive);
     exec.remove(QStringLiteral("-caption %c"));
     exec.remove(QStringLiteral("-caption \"%c\""));
     exec.remove(QStringLiteral("%i"));
     exec.remove(QStringLiteral("%m"));
     return exec.simplified();
 }
 
 void KOpenWithDialogPrivate::addToMimeAppsList(const QString &serviceId /*menu id or storage id*/)
 {
     KSharedConfig::Ptr profile = KSharedConfig::openConfig(QStringLiteral("mimeapps.list"), KConfig::NoGlobals, QStandardPaths::GenericConfigLocation);
 
     // Save the default application according to mime-apps-spec 1.0
     KConfigGroup defaultApp(profile, "Default Applications");
     defaultApp.writeXdgListEntry(qMimeType, QStringList(serviceId));
 
     KConfigGroup addedApps(profile, "Added Associations");
     QStringList apps = addedApps.readXdgListEntry(qMimeType);
     apps.removeAll(serviceId);
     apps.prepend(serviceId); // make it the preferred app
     addedApps.writeXdgListEntry(qMimeType, apps);
 
     profile->sync();
 
     // Also make sure the "auto embed" setting for this mimetype is off
     KSharedConfig::Ptr fileTypesConfig = KSharedConfig::openConfig(QStringLiteral("filetypesrc"), KConfig::NoGlobals);
     fileTypesConfig->group("EmbedSettings").writeEntry(QStringLiteral("embed-") + qMimeType, false);
     fileTypesConfig->sync();
 
     // qDebug() << "rebuilding ksycoca...";
 
     // kbuildsycoca is the one reading mimeapps.list, so we need to run it now
     KBuildSycocaProgressDialog::rebuildKSycoca(q);
 
     // could be nullptr if the user canceled the dialog...
     m_pService = KService::serviceByStorageId(serviceId);
 }
 
 bool KOpenWithDialogPrivate::checkAccept()
 {
     const QString typedExec(edit->text());
     QString fullExec(typedExec);
 
     QString serviceName;
     QString initialServiceName;
     QString preferredTerminal;
     QString configPath;
     QString serviceExec;
     m_pService = curService;
     if (!m_pService) {
         // No service selected - check the command line
 
         // Find out the name of the service from the command line, removing args and paths
         serviceName = KIO::DesktopExecParser::executableName(typedExec);
         if (serviceName.isEmpty()) {
             KMessageBox::error(q, i18n("Could not extract executable name from '%1', please type a valid program name.", serviceName));
             return false;
         }
         initialServiceName = serviceName;
         // Also remember the executableName with a path, if any, for the
         // check that the executable exists.
         // qDebug() << "initialServiceName=" << initialServiceName;
         int i = 1; // We have app, app-2, app-3... Looks better for the user.
         bool ok = false;
         // Check if there's already a service by that name, with the same Exec line
         do {
             // qDebug() << "looking for service" << serviceName;
             KService::Ptr serv = KService::serviceByDesktopName(serviceName);
             ok = !serv; // ok if no such service yet
             // also ok if we find the exact same service (well, "kwrite" == "kwrite %U")
             if (serv && !serv->noDisplay() /* #297720 */) {
                 if (serv->isApplication()) {
                     /*// qDebug() << "typedExec=" << typedExec
                       << "serv->exec=" << serv->exec()
                       << "simplifiedExecLineFromService=" << simplifiedExecLineFromService(fullExec);*/
                     serviceExec = simplifiedExecLineFromService(serv->exec());
                     if (typedExec == serviceExec) {
                         ok = true;
                         m_pService = serv;
                         // qDebug() << "OK, found identical service: " << serv->entryPath();
                     } else {
                         // qDebug() << "Exec line differs, service says:" << serviceExec;
                         configPath = serv->entryPath();
                         serviceExec = serv->exec();
                     }
                 } else {
                     // qDebug() << "Found, but not an application:" << serv->entryPath();
                 }
             }
             if (!ok) { // service was found, but it was different -> keep looking
                 ++i;
                 serviceName = initialServiceName + QLatin1Char('-') + QString::number(i);
             }
         } while (!ok);
     }
     if (m_pService) {
         // Existing service selected
         serviceName = m_pService->name();
         initialServiceName = serviceName;
         fullExec = m_pService->exec();
     } else {
         const QString binaryName = KIO::DesktopExecParser::executablePath(typedExec);
         // qDebug() << "binaryName=" << binaryName;
         // Ensure that the typed binary name actually exists (#81190)
         if (QStandardPaths::findExecutable(binaryName).isEmpty()) {
             KMessageBox::error(q, i18n("'%1' not found, please type a valid program name.", binaryName));
             return false;
         }
     }
 
     if (terminal->isChecked()) {
         KConfigGroup confGroup(KSharedConfig::openConfig(), QStringLiteral("General"));
         preferredTerminal = confGroup.readPathEntry("TerminalApplication", QStringLiteral("konsole"));
         m_command = preferredTerminal;
         // only add --noclose when we are sure it is konsole we're using
         if (preferredTerminal == QStringLiteral("konsole") && nocloseonexit->isChecked()) {
             m_command += QStringLiteral(" --noclose");
         }
         m_command += QLatin1String(" -e ") + edit->text();
         // qDebug() << "Setting m_command to" << m_command;
     }
     if (m_pService && terminal->isChecked() != m_pService->terminal()) {
         m_pService = nullptr;    // It's not exactly this service we're running
     }
 
     const bool bRemember = remember && remember->isChecked();
     // qDebug() << "bRemember=" << bRemember << "service found=" << m_pService;
     if (m_pService) {
         if (bRemember) {
             // Associate this app with qMimeType in mimeapps.list
             Q_ASSERT(!qMimeType.isEmpty()); // we don't show the remember checkbox otherwise
             addToMimeAppsList(m_pService->storageId());
         }
     } else {
         const bool createDesktopFile = bRemember || saveNewApps;
         if (!createDesktopFile) {
             // Create temp service
             if (configPath.isEmpty()) {
                 m_pService = new KService(initialServiceName, fullExec, QString());
             } else {
                 if (!typedExec.contains(QLatin1String("%u"), Qt::CaseInsensitive) &&
                         !typedExec.contains(QLatin1String("%f"), Qt::CaseInsensitive)) {
                     int index = serviceExec.indexOf(QLatin1String("%u"), 0, Qt::CaseInsensitive);
                     if (index == -1) {
                         index = serviceExec.indexOf(QLatin1String("%f"), 0, Qt::CaseInsensitive);
                     }
                     if (index > -1) {
                         fullExec += QLatin1Char(' ') + serviceExec.midRef(index, 2);
                     }
                 }
                 // qDebug() << "Creating service with Exec=" << fullExec;
                 m_pService = new KService(configPath);
                 m_pService->setExec(fullExec);
             }
             if (terminal->isChecked()) {
                 m_pService->setTerminal(true);
                 // only add --noclose when we are sure it is konsole we're using
                 if (preferredTerminal == QLatin1String("konsole") && nocloseonexit->isChecked()) {
                     m_pService->setTerminalOptions(QStringLiteral("--noclose"));
                 }
             }
         } else {
             // If we got here, we can't seem to find a service for what they wanted. Create one.
 
             QString menuId;
 #ifdef Q_OS_WIN32
             // on windows, do not use the complete path, but only the default name.
             serviceName = QFileInfo(serviceName).fileName();
 #endif
             QString newPath = KService::newServicePath(false /* ignored argument */, serviceName, &menuId);
             // qDebug() << "Creating new service" << serviceName << "(" << newPath << ")" << "menuId=" << menuId;
 
             KDesktopFile desktopFile(newPath);
             KConfigGroup cg = desktopFile.desktopGroup();
             cg.writeEntry("Type", "Application");
             cg.writeEntry("Name", initialServiceName);
             cg.writeEntry("Exec", fullExec);
             cg.writeEntry("NoDisplay", true); // don't make it appear in the K menu
             if (terminal->isChecked()) {
                 cg.writeEntry("Terminal", true);
                 // only add --noclose when we are sure it is konsole we're using
                 if (preferredTerminal == QLatin1String("konsole") && nocloseonexit->isChecked()) {
                     cg.writeEntry("TerminalOptions", "--noclose");
                 }
             }
             if (!qMimeType.isEmpty()) {
                 cg.writeXdgListEntry("MimeType", QStringList() << qMimeType);
             }
             cg.sync();
 
             if (!qMimeType.isEmpty()) {
                 addToMimeAppsList(menuId);
             } else {
                 m_pService = new KService(newPath);
             }
         }
     }
 
     saveComboboxHistory();
     return true;
 }
 
 bool KOpenWithDialog::eventFilter(QObject *object, QEvent *event)
 {
     // Detect DownArrow to navigate the results in the QTreeView
     if (object == d->edit && event->type() == QEvent::ShortcutOverride) {
         QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
         if (keyEvent->key() == Qt::Key_Down) {
             KHistoryComboBox *combo = static_cast<KHistoryComboBox *>(d->edit->comboBox());
             // FIXME: Disable arrow down in CompletionPopup and CompletionPopupAuto only when the dropdown list is shown.
             // When popup completion mode is used the down arrow is used to navigate the dropdown list of results
             if (combo->completionMode() != KCompletion::CompletionPopup && combo->completionMode() != KCompletion::CompletionPopupAuto) {
                 QModelIndex leafNodeIdx = d->view->model()->index(0, 0);
                 // Check if we have at least one result or the focus is passed to the empty QTreeView
                 if (d->view->model()->hasChildren(leafNodeIdx)) {
                     d->view->setFocus(Qt::OtherFocusReason);
                     QApplication::sendEvent(d->view, keyEvent);
                     return true;
                 }
             }
         }
     }
     return QDialog::eventFilter(object, event);
 }
 
 void KOpenWithDialog::accept()
 {
     if (d->checkAccept()) {
         QDialog::accept();
     }
 }
 
 QString KOpenWithDialog::text() const
 {
     if (!d->m_command.isEmpty()) {
         return d->m_command;
     } else {
         return d->edit->text();
     }
 }
 
 void KOpenWithDialog::hideNoCloseOnExit()
 {
     // uncheck the checkbox because the value could be used when "Run in Terminal" is selected
     d->nocloseonexit->setChecked(false);
     d->nocloseonexit->hide();
 }
 
 void KOpenWithDialog::hideRunInTerminal()
 {
     d->terminal->hide();
     hideNoCloseOnExit();
 }
 
 KService::Ptr KOpenWithDialog::service() const
 {
     return d->m_pService;
 }
 
 void KOpenWithDialogPrivate::saveComboboxHistory()
 {
     KHistoryComboBox *combo = static_cast<KHistoryComboBox *>(edit->comboBox());
     if (combo) {
         combo->addToHistory(edit->text());
 
         KConfigGroup cg(KSharedConfig::openConfig(), QStringLiteral("Open-with settings"));
         cg.writeEntry("History", combo->historyItems());
         writeEntry(cg, "CompletionMode", combo->completionMode());
         // don't store the completion-list, as it contains all of KUrlCompletion's
         // executables
         cg.sync();
     }
 }
 
 #include "moc_kopenwithdialog.cpp"
 #include "moc_kopenwithdialog_p.cpp"
diff --git a/src/widgets/kpropertiesdialog.cpp b/src/widgets/kpropertiesdialog.cpp
index 5b256db8..feeeaf0f 100644
--- a/src/widgets/kpropertiesdialog.cpp
+++ b/src/widgets/kpropertiesdialog.cpp
@@ -1,3929 +1,3929 @@
 /* This file is part of the KDE project
 
    Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
    Copyright (c) 1999, 2000 Preston Brown <pbrown@kde.org>
    Copyright (c) 2000 Simon Hausmann <hausmann@kde.org>
    Copyright (c) 2000 David Faure <faure@kde.org>
    Copyright (c) 2003 Waldo Bastian <bastian@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 /*
  * kpropertiesdialog.cpp
  * View/Edit Properties of files, locally or remotely
  *
  * some FilePermissionsPropsPlugin-changes by
  *  Henner Zeller <zeller@think.de>
  * some layout management by
  *  Bertrand Leconte <B.Leconte@mail.dotcom.fr>
  * the rest of the layout management, bug fixes, adaptation to libkio,
  * template feature by
  *  David Faure <faure@kde.org>
  * More layout, cleanups, and fixes by
  *  Preston Brown <pbrown@kde.org>
  * Plugin capability, cleanups and port to KDialog by
  *  Simon Hausmann <hausmann@kde.org>
  * KDesktopPropsPlugin by
  *  Waldo Bastian <bastian@kde.org>
  */
 
 #include "kpropertiesdialog.h"
 #include "kpropertiesdialog_p.h"
 #include "kio_widgets_debug.h"
 #include "../pathhelpers_p.h"
 
 #include <config-kiowidgets.h>
 
 #include <qplatformdefs.h>
 #include <algorithm>
 #include <functional>
 
 #include <QCheckBox>
 #include <QClipboard>
 #include <QDebug>
 #include <QDBusConnection>
 #include <QDBusInterface>
 #include <QDBusReply>
 #include <QDir>
 #include <QDialogButtonBox>
 #include <QFile>
 #include <QFileDialog>
 #include <QFileInfo>
 #include <QFileSystemWatcher>
 #include <QFutureWatcher>
 #include <QLabel>
 #include <QLayout>
 #include <QLocale>
 #include <QMimeDatabase>
 #include <QMutableStringListIterator>
 #include <QPainter>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QRegularExpression>
 #include <QStandardPaths>
 #include <QStyle>
 #include <QtConcurrentRun>
 #include <QTextStream>
 #include <QUrl>
 #include <QVector>
 
 #if HAVE_POSIX_ACL
 extern "C" {
 #  include <errno.h>
 #  include <sys/xattr.h>
 }
 #endif
 
 #include <kauthorized.h>
 #include <KColorScheme>
 #include <kdirnotify.h>
 #include <kdiskfreespaceinfo.h>
 #include <kdesktopfile.h>
 #include <kiconbutton.h>
 #include <kurlrequester.h>
 #include <klocalizedstring.h>
 #include <kjobuidelegate.h>
 #include <kio/global.h>
 #include <kio/job.h>
 #include <kio/copyjob.h>
 #include <kio/chmodjob.h>
 #include <kio/directorysizejob.h>
 #include <KIO/FileSystemFreeSpaceJob>
 #include <kio/renamedialog.h>
 #include <kio/jobuidelegate.h>
 #include <kjobwidgets.h>
 #include <kmountpoint.h>
 #include <kmessagebox.h>
 #include <kservice.h>
 #include <ksharedconfig.h>
 #include <kcombobox.h>
 #include <kcompletion.h>
 #include <klineedit.h>
 #include <kseparator.h>
 #include <ksqueezedtextlabel.h>
 #include <kmimetypetrader.h>
 #include <krun.h>
 #include <kio/desktopexecparser.h>
 #include <kacl.h>
 #include <kconfiggroup.h>
 #include <kmimetypeeditor.h>
 #include <kshell.h>
 #include <kcapacitybar.h>
 #include <kfileitemlistproperties.h>
 #include <kwindowconfig.h>
 #include <kioglobal_p.h>
 
 #include "ui_checksumswidget.h"
 #include "ui_kpropertiesdesktopbase.h"
 #include "ui_kpropertiesdesktopadvbase.h"
 #if HAVE_POSIX_ACL
 #include "kacleditwidget.h"
 #endif
 
 #include <kbuildsycocaprogressdialog.h>
 #include <kmimetypechooser.h>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 #include <shellapi.h>
 #include <process.h>
 #ifdef __GNUC__
 # warning TODO: port completely to win32
 #endif
 #endif
 
 using namespace KDEPrivate;
 
 static QString nameFromFileName(QString nameStr)
 {
     if (nameStr.endsWith(QLatin1String(".desktop"))) {
         nameStr.chop(8);
     }
     if (nameStr.endsWith(QLatin1String(".kdelnk"))) {
         nameStr.chop(7);
     }
     // Make it human-readable (%2F => '/', ...)
     nameStr = KIO::decodeFileName(nameStr);
     return nameStr;
 }
 
 const mode_t KFilePermissionsPropsPlugin::fperm[3][4] = {
     {S_IRUSR, S_IWUSR, S_IXUSR, S_ISUID},
     {S_IRGRP, S_IWGRP, S_IXGRP, S_ISGID},
     {S_IROTH, S_IWOTH, S_IXOTH, S_ISVTX}
 };
 
 class Q_DECL_HIDDEN KPropertiesDialog::KPropertiesDialogPrivate
 {
 public:
     explicit KPropertiesDialogPrivate(KPropertiesDialog *qq)
         : q(qq)
         , m_aborted(false)
         , fileSharePage(nullptr)
     {
     }
     ~KPropertiesDialogPrivate()
     {
     }
 
     /**
      * Common initialization for all constructors
      */
     void init();
     /**
      * Inserts all pages in the dialog.
      */
     void insertPages();
 
     KPropertiesDialog * const q;
     bool m_aborted;
     QWidget *fileSharePage;
     /**
      * The URL of the props dialog (when shown for only one file)
      */
     QUrl m_singleUrl;
     /**
      * List of items this props dialog is shown for
      */
     KFileItemList m_items;
     /**
      * For templates
      */
     QString m_defaultName;
     QUrl m_currentDir;
     /**
      * List of all plugins inserted ( first one first )
      */
     QList<KPropertiesDialogPlugin *> m_pageList;
 };
 
 KPropertiesDialog::KPropertiesDialog(const KFileItem &item,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(item.name())));
 
     Q_ASSERT(!item.isNull());
     d->m_items.append(item);
 
     d->m_singleUrl = item.url();
     Q_ASSERT(!d->m_singleUrl.isEmpty());
 
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const QString &title,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     setWindowTitle(i18n("Properties for %1", title));
 
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const KFileItemList &_items,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     if (_items.count() > 1) {
         setWindowTitle(i18np("Properties for 1 item", "Properties for %1 Selected Items", _items.count()));
     } else {
         setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(_items.first().name())));
     }
 
     Q_ASSERT(!_items.isEmpty());
     d->m_singleUrl = _items.first().url();
     Q_ASSERT(!d->m_singleUrl.isEmpty());
 
     d->m_items = _items;
 
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const QUrl &_url,
                                      QWidget *parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(_url.fileName())));
 
     d->m_singleUrl = _url;
 
     KIO::StatJob *job = KIO::stat(_url);
     KJobWidgets::setWindow(job, parent);
     job->exec();
     KIO::UDSEntry entry = job->statResult();
 
     d->m_items.append(KFileItem(entry, _url));
     d->init();
 }
 
 KPropertiesDialog::KPropertiesDialog(const QList<QUrl>& urls,
                                      QWidget* parent)
     : KPageDialog(parent), d(new KPropertiesDialogPrivate(this))
 {
     if (urls.count() > 1) {
         setWindowTitle(i18np("Properties for 1 item", "Properties for %1 Selected Items", urls.count()));
     } else {
         setWindowTitle(i18n("Properties for %1", KIO::decodeFileName(urls.first().fileName())));
     }
 
     Q_ASSERT(!urls.isEmpty());
     d->m_singleUrl = urls.first();
     Q_ASSERT(!d->m_singleUrl.isEmpty());
 
     d->m_items.reserve(urls.size());
     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, &KPropertiesDialogPlugin::changed,
             plugin, QOverload<>::of(&KPropertiesDialogPlugin::setDirty));
 
     d->m_pageList.append(plugin);
 }
 
 QUrl KPropertiesDialog::url() const
 {
     return d->m_singleUrl;
 }
 
 KFileItem &KPropertiesDialog::item()
 {
     return d->m_items.first();
 }
 
 KFileItemList KPropertiesDialog::items() const
 {
     return d->m_items;
 }
 
 QUrl KPropertiesDialog::currentDir() const
 {
     return d->m_currentDir;
 }
 
 QString KPropertiesDialog::defaultName() const
 {
     return d->m_defaultName;
 }
 
 bool KPropertiesDialog::canDisplay(const KFileItemList &_items)
 {
     // TODO: cache the result of those calls. Currently we parse .desktop files far too many times
     return KFilePropsPlugin::supports(_items) ||
            KFilePermissionsPropsPlugin::supports(_items) ||
            KDesktopPropsPlugin::supports(_items) ||
            KUrlPropsPlugin::supports(_items) ||
            KDevicePropsPlugin::supports(_items) /* ||
             KPreviewPropsPlugin::supports( _items )*/;
 }
 
 void KPropertiesDialog::slotOk()
 {
     accept();
 }
 
 void KPropertiesDialog::accept()
 {
     QList<KPropertiesDialogPlugin *>::const_iterator pageListIt;
     d->m_aborted = false;
 
     KFilePropsPlugin *filePropsPlugin = qobject_cast<KFilePropsPlugin *>(d->m_pageList.first());
 
     // If any page is dirty, then set the main one (KFilePropsPlugin) as
     // dirty too. This is what makes it possible to save changes to a global
     // desktop file into a local one. In other cases, it doesn't hurt.
     for (pageListIt = d->m_pageList.constBegin(); pageListIt != d->m_pageList.constEnd(); ++pageListIt) {
         if ((*pageListIt)->isDirty() && filePropsPlugin) {
             filePropsPlugin->setDirty();
             break;
         }
     }
 
     // Apply the changes in the _normal_ order of the tabs now
     // This is because in case of renaming a file, KFilePropsPlugin will call
     // KPropertiesDialog::rename, so other tab will be ok with whatever order
     // BUT for file copied from templates, we need to do the renaming first !
     for (pageListIt = d->m_pageList.constBegin(); pageListIt != d->m_pageList.constEnd() && !d->m_aborted; ++pageListIt) {
         if ((*pageListIt)->isDirty()) {
             // qDebug() << "applying changes for " << (*pageListIt)->metaObject()->className();
             (*pageListIt)->applyChanges();
             // applyChanges may change d->m_aborted.
         } else {
             // qDebug() << "skipping page " << (*pageListIt)->metaObject()->className();
         }
     }
 
     if (!d->m_aborted && filePropsPlugin) {
         filePropsPlugin->postApplyChanges();
     }
 
     if (!d->m_aborted) {
         emit applied();
         emit propertiesClosed();
         deleteLater(); // somewhat like Qt::WA_DeleteOnClose would do.
         KPageDialog::accept();
     } // else, keep dialog open for user to fix the problem.
 }
 
 void KPropertiesDialog::slotCancel()
 {
     reject();
 }
 
 void KPropertiesDialog::reject()
 {
     emit canceled();
     emit propertiesClosed();
 
     deleteLater();
     KPageDialog::reject();
 }
 
 void KPropertiesDialog::KPropertiesDialogPrivate::insertPages()
 {
     if (m_items.isEmpty()) {
         return;
     }
 
     if (KFilePropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KFilePropsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KFilePermissionsPropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KFilePermissionsPropsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KChecksumsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KChecksumsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KDesktopPropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KDesktopPropsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KUrlPropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KUrlPropsPlugin(q);
         q->insertPlugin(p);
     }
 
     if (KDevicePropsPlugin::supports(m_items)) {
         KPropertiesDialogPlugin *p = new KDevicePropsPlugin(q);
         q->insertPlugin(p);
     }
 
 //     if ( KPreviewPropsPlugin::supports( m_items ) ) {
 //         KPropertiesDialogPlugin *p = new KPreviewPropsPlugin(q);
 //         q->insertPlugin(p);
 //     }
 
     //plugins
 
     if (m_items.count() != 1) {
         return;
     }
 
     const KFileItem item = m_items.first();
     const QString mimetype = item.mimetype();
 
     if (mimetype.isEmpty()) {
         return;
     }
 
     QString query = QStringLiteral(
         "(((not exist [X-KDE-Protocol]) and (not exist [X-KDE-Protocols])) or ([X-KDE-Protocol] == '%1') or ('%1' in [X-KDE-Protocols]))"
     ).arg(item.url().scheme());
 
     // qDebug() << "trader query: " << query;
     const KService::List offers = KMimeTypeTrader::self()->query(mimetype, QStringLiteral("KPropertiesDialog/Plugin"), query);
     foreach (const KService::Ptr &ptr, offers) {
         KPropertiesDialogPlugin *plugin = ptr->createInstance<KPropertiesDialogPlugin>(q);
         if (!plugin) {
             continue;
         }
         plugin->setObjectName(ptr->name());
 
         q->insertPlugin(plugin);
     }
 }
 
 void KPropertiesDialog::updateUrl(const QUrl &_newUrl)
 {
     Q_ASSERT(d->m_items.count() == 1);
     // qDebug() << "KPropertiesDialog::updateUrl (pre)" << _newUrl;
     QUrl newUrl = _newUrl;
     emit saveAs(d->m_singleUrl, newUrl);
     // qDebug() << "KPropertiesDialog::updateUrl (post)" << newUrl;
 
     d->m_singleUrl = newUrl;
     d->m_items.first().setUrl(newUrl);
     Q_ASSERT(!d->m_singleUrl.isEmpty());
     // If we have an Desktop page, set it dirty, so that a full file is saved locally
     // Same for a URL page (because of the Name= hack)
     foreach (KPropertiesDialogPlugin *it, d->m_pageList) {
         if (qobject_cast<KUrlPropsPlugin *>(it) ||
                 qobject_cast<KDesktopPropsPlugin *>(it)) {
             //qDebug() << "Setting page dirty";
             it->setDirty();
             break;
         }
     }
 }
 
 void KPropertiesDialog::rename(const QString &_name)
 {
     Q_ASSERT(d->m_items.count() == 1);
     // qDebug() << "KPropertiesDialog::rename " << _name;
     QUrl newUrl;
     // if we're creating from a template : use currentdir
     if (!d->m_currentDir.isEmpty()) {
         newUrl = d->m_currentDir;
         newUrl.setPath(concatPaths(newUrl.path(), _name));
     } else {
         // It's a directory, so strip the trailing slash first
         newUrl = d->m_singleUrl.adjusted(QUrl::StripTrailingSlash);
         // Now change the filename
         newUrl = newUrl.adjusted(QUrl::RemoveFilename); // keep trailing slash
         newUrl.setPath(concatPaths(newUrl.path(), _name));
     }
     updateUrl(newUrl);
 }
 
 void KPropertiesDialog::abortApplying()
 {
     d->m_aborted = true;
 }
 
 class Q_DECL_HIDDEN KPropertiesDialogPlugin::KPropertiesDialogPluginPrivate
 {
 public:
     KPropertiesDialogPluginPrivate()
     {
     }
     ~KPropertiesDialogPluginPrivate()
     {
     }
 
     bool m_bDirty;
     int fontHeight;
 };
 
 KPropertiesDialogPlugin::KPropertiesDialogPlugin(KPropertiesDialog *_props)
     : QObject(_props), d(new KPropertiesDialogPluginPrivate)
 {
     properties = _props;
     d->fontHeight = 2 * properties->fontMetrics().height();
     d->m_bDirty = false;
 }
 
 KPropertiesDialogPlugin::~KPropertiesDialogPlugin()
 {
     delete d;
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 bool KPropertiesDialogPlugin::isDesktopFile(const KFileItem &_item)
 {
     return _item.isDesktopFile();
 }
 #endif
 
 void KPropertiesDialogPlugin::setDirty(bool b)
 {
     d->m_bDirty = b;
 }
 
 void KPropertiesDialogPlugin::setDirty()
 {
     d->m_bDirty = true;
 }
 
 bool KPropertiesDialogPlugin::isDirty() const
 {
     return d->m_bDirty;
 }
 
 void KPropertiesDialogPlugin::applyChanges()
 {
     qCWarning(KIO_WIDGETS) << "applyChanges() not implemented in page !";
 }
 
 int KPropertiesDialogPlugin::fontHeight() const
 {
     return d->fontHeight;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class KFilePropsPlugin::KFilePropsPluginPrivate
 {
 public:
     KFilePropsPluginPrivate()
     {
         dirSizeJob = nullptr;
         dirSizeUpdateTimer = nullptr;
         m_lined = nullptr;
         m_capacityBar = nullptr;
         m_linkTargetLineEdit = nullptr;
     }
     ~KFilePropsPluginPrivate()
     {
         if (dirSizeJob) {
             dirSizeJob->kill();
         }
     }
 
     KIO::DirectorySizeJob *dirSizeJob;
     QTimer *dirSizeUpdateTimer;
     QFrame *m_frame;
     bool bMultiple;
     bool bIconChanged;
     bool bKDesktopMode;
     bool bDesktopFile;
     KCapacityBar *m_capacityBar;
     QString mimeType;
     QString oldFileName;
     KLineEdit *m_lined;
     QLabel *m_fileNameLabel = nullptr;
     QGridLayout *m_grid = nullptr;
 
     QWidget *iconArea;
 
     QLabel *m_sizeLabel;
     QPushButton *m_sizeDetermineButton;
     QPushButton *m_sizeStopButton;
     KLineEdit *m_linkTargetLineEdit;
 
     QString m_sRelativePath;
     bool m_bFromTemplate;
 
     /**
     * The initial filename
     */
     QString oldName;
 };
 
 KFilePropsPlugin::KFilePropsPlugin(KPropertiesDialog *_props)
     : KPropertiesDialogPlugin(_props), d(new KFilePropsPluginPrivate)
 {
     d->bMultiple = (properties->items().count() > 1);
     d->bIconChanged = false;
     d->bDesktopFile = KDesktopPropsPlugin::supports(properties->items());
     // qDebug() << "KFilePropsPlugin::KFilePropsPlugin bMultiple=" << d->bMultiple;
 
     // We set this data from the first item, and we'll
     // check that the other items match against it, resetting when not.
     bool isLocal;
     const KFileItem item = properties->item();
     QUrl url = item.mostLocalUrl(isLocal);
     bool isReallyLocal = item.url().isLocalFile();
     bool bDesktopFile = item.isDesktopFile();
     mode_t mode = item.mode();
     bool hasDirs = item.isDir() && !item.isLink();
     bool hasRoot = url.path() == QLatin1String("/");
     QString iconStr = item.iconName();
     QString directory = properties->url().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path();
     QString protocol = properties->url().scheme();
     d->bKDesktopMode = protocol == QLatin1String("desktop") ||
                        properties->currentDir().scheme() == QLatin1String("desktop");
     QString mimeComment = item.mimeComment();
     d->mimeType = item.mimetype();
     KIO::filesize_t totalSize = item.size();
     QString magicMimeComment;
     QMimeDatabase db;
     if (isLocal) {
         QMimeType magicMimeType = db.mimeTypeForFile(url.toLocalFile(), QMimeDatabase::MatchContent);
         if (magicMimeType.isValid() && !magicMimeType.isDefault()) {
             magicMimeComment = magicMimeType.comment();
         }
     }
 #ifdef Q_OS_WIN
     if (isReallyLocal) {
         directory = QDir::toNativeSeparators(directory.mid(1));
     }
 #endif
 
     // Those things only apply to 'single file' mode
     QString filename;
     bool isTrash = false;
     d->m_bFromTemplate = false;
 
     // And those only to 'multiple' mode
     uint iDirCount = hasDirs ? 1 : 0;
     uint iFileCount = 1 - iDirCount;
 
     d->m_frame = new QFrame();
     properties->addPage(d->m_frame, i18nc("@title:tab File properties", "&General"));
 
     QVBoxLayout *vbl = new QVBoxLayout(d->m_frame);
-    vbl->setMargin(0);
+    vbl->setContentsMargins(0, 0, 0, 0);
     vbl->setObjectName(QStringLiteral("vbl"));
     QGridLayout *grid = new QGridLayout(); // unknown rows
     d->m_grid = grid;
     grid->setColumnStretch(0, 0);
     grid->setColumnStretch(1, 0);
     grid->setColumnStretch(2, 1);
     const int spacingHint = d->m_frame->style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
     grid->addItem(new QSpacerItem(spacingHint, 0), 0, 1);
     vbl->addLayout(grid);
     int curRow = 0;
 
     if (!d->bMultiple) {
         QString path;
         if (!d->m_bFromTemplate) {
             isTrash = (properties->url().scheme() == QLatin1String("trash"));
             // Extract the full name, but without file: for local files
             path = properties->url().toDisplayString(QUrl::PreferLocalFile);
         } else {
             path = concatPaths(properties->currentDir().path(), properties->defaultName());
             directory = properties->currentDir().toDisplayString(QUrl::PreferLocalFile);
         }
 
         if (d->bDesktopFile) {
             determineRelativePath(path);
         }
 
         // Extract the file name only
         filename = properties->defaultName();
         if (filename.isEmpty()) {   // no template
             const QFileInfo finfo(item.name());  // this gives support for UDS_NAME, e.g. for kio_trash or kio_system
             filename = finfo.fileName(); // Make sure only the file's name is displayed (#160964).
         } else {
             d->m_bFromTemplate = true;
             setDirty(); // to enforce that the copy happens
         }
         d->oldFileName = filename;
 
         // Make it human-readable
         filename = nameFromFileName(filename);
 
         if (d->bKDesktopMode && d->bDesktopFile) {
             KDesktopFile config(url.toLocalFile());
             if (config.desktopGroup().hasKey("Name")) {
                 filename = config.readName();
             }
         }
 
         d->oldName = filename;
     } else {
         // Multiple items: see what they have in common
         const KFileItemList items = properties->items();
         KFileItemList::const_iterator kit = items.begin();
         const KFileItemList::const_iterator kend = items.end();
         for (++kit /*no need to check the first one again*/; kit != kend; ++kit) {
             const QUrl url = (*kit).url();
             // qDebug() << "KFilePropsPlugin::KFilePropsPlugin " << url.toDisplayString();
             // The list of things we check here should match the variables defined
             // at the beginning of this method.
             if (url.isLocalFile() != isLocal) {
                 isLocal = false;    // not all local
             }
             if (bDesktopFile && (*kit).isDesktopFile() != bDesktopFile) {
                 bDesktopFile = false;    // not all desktop files
             }
             if ((*kit).mode() != mode) {
                 mode = (mode_t)0;
             }
             if (KIO::iconNameForUrl(url) != iconStr) {
                 iconStr = QStringLiteral("document-multiple");
             }
             if (url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path() != directory) {
                 directory.clear();
             }
             if (url.scheme() != protocol) {
                 protocol.clear();
             }
             if (!mimeComment.isNull() && (*kit).mimeComment() != mimeComment) {
                 mimeComment.clear();
             }
             if (isLocal && !magicMimeComment.isNull()) {
                 QMimeType magicMimeType = db.mimeTypeForFile(url.toLocalFile(), QMimeDatabase::MatchContent);
                 if (magicMimeType.isValid() && magicMimeType.comment() != magicMimeComment) {
                     magicMimeComment.clear();
                 }
             }
 
             if (isLocal && url.path() == QLatin1String("/")) {
                 hasRoot = true;
             }
             if ((*kit).isDir() && !(*kit).isLink()) {
                 iDirCount++;
                 hasDirs = true;
             } else {
                 iFileCount++;
                 totalSize += (*kit).size();
             }
         }
     }
 
     if (!isReallyLocal && !protocol.isEmpty()) {
         directory += QLatin1String(" (") + protocol + QLatin1Char(')');
     }
 
     if (!isTrash && (bDesktopFile || ((mode & QT_STAT_MASK) == QT_STAT_DIR))
             && !d->bMultiple // not implemented for multiple
             && enableIconButton()) { // #56857
         KIconButton *iconButton = new KIconButton(d->m_frame);
         int bsize = 66 + 2 * iconButton->style()->pixelMetric(QStyle::PM_ButtonMargin);
         iconButton->setFixedSize(bsize, bsize);
         iconButton->setIconSize(48);
         iconButton->setStrictIconSize(false);
         if (bDesktopFile && isLocal) {
             const KDesktopFile config(url.toLocalFile());
             if (config.hasDeviceType()) {
                 iconButton->setIconType(KIconLoader::Desktop, KIconLoader::Device);
             } else {
                 iconButton->setIconType(KIconLoader::Desktop, KIconLoader::Application);
             }
         } else {
             iconButton->setIconType(KIconLoader::Desktop, KIconLoader::Place);
         }
         iconButton->setIcon(iconStr);
         d->iconArea = iconButton;
         connect(iconButton, &KIconButton::iconChanged,
                 this, &KFilePropsPlugin::slotIconChanged);
     } else {
         QLabel *iconLabel = new QLabel(d->m_frame);
         iconLabel->setAlignment(Qt::AlignCenter);
         int bsize = 66 + 2 * iconLabel->style()->pixelMetric(QStyle::PM_ButtonMargin);
         iconLabel->setFixedSize(bsize, bsize);
         iconLabel->setPixmap(QIcon::fromTheme(iconStr).pixmap(48));
         d->iconArea = iconLabel;
     }
     grid->addWidget(d->iconArea, curRow, 0, Qt::AlignCenter);
 
     KFileItemListProperties itemList(KFileItemList() << item);
     if (d->bMultiple || isTrash || hasRoot || !(d->m_bFromTemplate || itemList.supportsMoving())) {
         setFileNameReadOnly(true);
         if (d->bMultiple) {
             d->m_fileNameLabel->setText(KIO::itemsSummaryString(iFileCount + iDirCount, iFileCount, iDirCount, 0, false));
         }
 
     } else {
         d->m_lined = new KLineEdit(d->m_frame);
         d->m_lined->setObjectName(QStringLiteral("KFilePropsPlugin::nameLineEdit"));
         d->m_lined->setText(filename);
         d->m_lined->setFocus();
 
         // Enhanced rename: Don't highlight the file extension.
         QString extension = db.suffixForFileName(filename);
         if (!extension.isEmpty()) {
             d->m_lined->setSelection(0, filename.length() - extension.length() - 1);
         } else {
             int lastDot = filename.lastIndexOf(QLatin1Char('.'));
             if (lastDot > 0) {
                 d->m_lined->setSelection(0, lastDot);
             }
         }
 
         connect(d->m_lined, &QLineEdit::textChanged,
                 this, &KFilePropsPlugin::nameFileChanged);
         grid->addWidget(d->m_lined, curRow, 2);
     }
     ++curRow;
 
     KSeparator *sep = new KSeparator(Qt::Horizontal, d->m_frame);
     grid->addWidget(sep, curRow, 0, 1, 3);
     ++curRow;
 
     QLabel *l;
     if (!mimeComment.isEmpty() && !isTrash) {
         l = new QLabel(i18n("Type:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight | Qt::AlignTop);
 
         QFrame *box = new QFrame(d->m_frame);
         QVBoxLayout *boxLayout = new QVBoxLayout(box);
         boxLayout->setSpacing(2); // without that spacing the button literally “sticks” to the label ;)
-        boxLayout->setMargin(0);
+        boxLayout->setContentsMargins(0, 0, 0, 0);
 
         l = new QLabel(mimeComment, box);
         l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
         grid->addWidget(box, curRow++, 2);
 
         QPushButton *button = new QPushButton(box);
         button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);  // Minimum still makes the button grow to the entire layout width
         button->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
 
         boxLayout->addWidget(l);
         boxLayout->addWidget(button);
 
         if (d->mimeType == QLatin1String("application/octet-stream")) {
             button->setText(i18n("Create New File Type"));
         } else {
             button->setText(i18n("File Type Options"));
         }
 
         connect(button, &QAbstractButton::clicked, this, &KFilePropsPlugin::slotEditFileType);
 
         if (!KAuthorized::authorizeAction(QStringLiteral("editfiletype"))) {
             button->hide();
         }
     }
 
     if (!magicMimeComment.isEmpty() && magicMimeComment != mimeComment) {
         l = new QLabel(i18n("Contents:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
         l = new QLabel(magicMimeComment, d->m_frame);
         grid->addWidget(l, curRow++, 2);
     }
 
     if (!directory.isEmpty()) {
         l = new QLabel(i18n("Location:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
         l = new KSqueezedTextLabel(directory, d->m_frame);
         // force the layout direction to be always LTR
         l->setLayoutDirection(Qt::LeftToRight);
         // but if we are in RTL mode, align the text to the right
         // otherwise the text is on the wrong side of the dialog
         if (properties->layoutDirection() == Qt::RightToLeft) {
             l->setAlignment(Qt::AlignRight);
         }
         l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
         grid->addWidget(l, curRow++, 2);
     }
 
     l = new QLabel(i18n("Size:"), d->m_frame);
     grid->addWidget(l, curRow, 0, Qt::AlignRight | Qt::AlignTop);
 
     d->m_sizeLabel = new QLabel(d->m_frame);
     d->m_sizeLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
     grid->addWidget(d->m_sizeLabel, curRow++, 2);
 
     if (!hasDirs) { // Only files [and symlinks]
         d->m_sizeLabel->setText(QStringLiteral("%1 (%2)").arg(KIO::convertSize(totalSize),
            QLocale().toString(totalSize)));
         d->m_sizeDetermineButton = nullptr;
         d->m_sizeStopButton = nullptr;
     } else { // Directory
         QHBoxLayout *sizelay = new QHBoxLayout();
         grid->addLayout(sizelay, curRow++, 2);
 
         // buttons
         d->m_sizeDetermineButton = new QPushButton(i18n("Calculate"), d->m_frame);
         d->m_sizeStopButton = new QPushButton(i18n("Stop"), d->m_frame);
         connect(d->m_sizeDetermineButton, &QAbstractButton::clicked, this, &KFilePropsPlugin::slotSizeDetermine);
         connect(d->m_sizeStopButton, &QAbstractButton::clicked, this, &KFilePropsPlugin::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, &QLineEdit::textChanged,
                 this, QOverload<>::of(&KFilePropsPlugin::setDirty));
     }
 
     if (!d->bMultiple) { // Dates for multiple don't make much sense...
         QDateTime dt = item.time(KFileItem::CreationTime);
         if (!dt.isNull()) {
             l = new QLabel(i18n("Created:"), d->m_frame);
             grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
             l = new QLabel(dt.toString(Qt::DefaultLocaleLongDate), d->m_frame);
             grid->addWidget(l, curRow++, 2);
         }
 
         dt = item.time(KFileItem::ModificationTime);
         if (!dt.isNull()) {
             l = new QLabel(i18n("Modified:"), d->m_frame);
             grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
             l = new QLabel(dt.toString(Qt::DefaultLocaleLongDate), d->m_frame);
             l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
             grid->addWidget(l, curRow++, 2);
         }
 
         dt = item.time(KFileItem::AccessTime);
         if (!dt.isNull()) {
             l = new QLabel(i18n("Accessed:"), d->m_frame);
             grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
             l = new QLabel(dt.toString(Qt::DefaultLocaleLongDate), d->m_frame);
             l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
             grid->addWidget(l, curRow++, 2);
         }
     }
 
     if (hasDirs) {  // only for directories
         sep = new KSeparator(Qt::Horizontal, d->m_frame);
         grid->addWidget(sep, curRow, 0, 1, 3);
         ++curRow;
 
         if (isLocal) {
             KMountPoint::Ptr mp = KMountPoint::currentMountPoints().findByPath(url.toLocalFile());
 
             l = new QLabel(i18n("File System:"), d->m_frame);
             grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
             l = new QLabel(d->m_frame);
             grid->addWidget(l, curRow++, 2);
             l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
             l->setText(mp->mountType());
 
             if (mp) {
                 l = new QLabel(i18n("Mounted on:"), d->m_frame);
                 grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
                 l = new KSqueezedTextLabel(mp->mountPoint(), d->m_frame);
                 l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
                 grid->addWidget(l, curRow++, 2);
 
                 l = new QLabel(i18n("Mounted from:"), d->m_frame);
                 grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
                 l = new QLabel(mp->mountedFrom(), d->m_frame);
                 grid->addWidget(l, curRow++, 2);
                 l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
             }
         }
 
         l = new QLabel(i18n("Device usage:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
         d->m_capacityBar = new KCapacityBar(KCapacityBar::DrawTextOutline, d->m_frame);
         d->m_capacityBar->setText(i18nc("@info:status", "Unknown size"));
         grid->addWidget(d->m_capacityBar, curRow++, 2);
 
         KIO::FileSystemFreeSpaceJob *job = KIO::fileSystemFreeSpace(url);
         connect(job, &KIO::FileSystemFreeSpaceJob::result, this, &KFilePropsPlugin::slotFreeSpaceResult);
     }
 
     vbl->addStretch(1);
 }
 
 bool KFilePropsPlugin::enableIconButton() const
 {
     bool iconEnabled = false;
     const KFileItem item = properties->item();
     // If the current item is a directory, check if it's writable,
     // so we can create/update a .directory
     // Current item is a file, same thing: check if it is writable
     if (item.isWritable()) {
         iconEnabled = true;
     }
     return iconEnabled;
 }
 
 // QString KFilePropsPlugin::tabName () const
 // {
 //   return i18n ("&General");
 // }
 
 void KFilePropsPlugin::setFileNameReadOnly(bool ro)
 {
     Q_ASSERT(ro); // false isn't supported
     if (ro && !d->m_fileNameLabel) {
         Q_ASSERT(!d->m_bFromTemplate);
         delete d->m_lined;
         d->m_lined = nullptr;
         d->m_fileNameLabel = new QLabel(d->m_frame);
         d->m_fileNameLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
         d->m_fileNameLabel->setText(d->oldName); // will get overwritten if d->bMultiple
         d->m_grid->addWidget(d->m_fileNameLabel, 0, 2);
     }
 }
 
 void KFilePropsPlugin::slotEditFileType()
 {
     QString mime;
     if (d->mimeType == QLatin1String("application/octet-stream")) {
         const int pos = d->oldFileName.lastIndexOf(QLatin1Char('.'));
         if (pos != -1) {
             mime = QLatin1Char('*') + d->oldFileName.midRef(pos);
         } else {
             mime = QStringLiteral("*");
         }
     }  else {
         mime = d->mimeType;
     }
     KMimeTypeEditor::editMimeType(mime, properties->window());
 }
 
 void KFilePropsPlugin::slotIconChanged()
 {
     d->bIconChanged = true;
     emit changed();
 }
 
 void KFilePropsPlugin::nameFileChanged(const QString &text)
 {
     properties->buttonBox()->button(QDialogButtonBox::Ok)->setEnabled(!text.isEmpty());
     emit changed();
 }
 
 static QString relativeAppsLocation(const QString &file)
 {
     const QString canonical = QFileInfo(file).canonicalFilePath();
     Q_FOREACH (const QString &base, QStandardPaths::standardLocations(QStandardPaths::ApplicationsLocation)) {
         QDir base_dir = QDir(base);
         if (base_dir.exists() && canonical.startsWith(base_dir.canonicalPath())) {
             return canonical.mid(base.length() + 1);
         }
     }
     return QString(); // return empty if the file is not in apps
 }
 
 void KFilePropsPlugin::determineRelativePath(const QString &path)
 {
     // now let's make it relative
     d->m_sRelativePath = relativeAppsLocation(path);
 }
 
 void KFilePropsPlugin::slotFreeSpaceResult(KIO::Job *job, KIO::filesize_t size, KIO::filesize_t available)
 {
     if (!job->error()) {
         const quint64 used = size - available;
         const int percentUsed = qRound(100.0 * qreal(used) / qreal(size));
 
         d->m_capacityBar->setText(
         i18nc("Available space out of total partition size (percent used)", "%1 free of %2 (%3% used)",
               KIO::convertSize(available),
               KIO::convertSize(size),
               percentUsed));
 
         d->m_capacityBar->setValue(percentUsed);
     } else {
         d->m_capacityBar->setText(i18nc("@info:status", "Unknown size"));
         d->m_capacityBar->setValue(0);
     }
 }
 
 void KFilePropsPlugin::slotDirSizeUpdate()
 {
     KIO::filesize_t totalSize = d->dirSizeJob->totalSize();
     KIO::filesize_t totalFiles = d->dirSizeJob->totalFiles();
     KIO::filesize_t totalSubdirs = d->dirSizeJob->totalSubdirs();
     d->m_sizeLabel->setText(
         i18n("Calculating... %1 (%2)\n%3, %4",
              KIO::convertSize(totalSize),
              QLocale().toString(totalSize),
              i18np("1 file", "%1 files", totalFiles),
              i18np("1 sub-folder", "%1 sub-folders", totalSubdirs)));
 }
 
 void KFilePropsPlugin::slotDirSizeFinished(KJob *job)
 {
     if (job->error()) {
         d->m_sizeLabel->setText(job->errorString());
     } else {
         KIO::filesize_t totalSize = d->dirSizeJob->totalSize();
         KIO::filesize_t totalFiles = d->dirSizeJob->totalFiles();
         KIO::filesize_t totalSubdirs = d->dirSizeJob->totalSubdirs();
         d->m_sizeLabel->setText(QStringLiteral("%1 (%2)\n%3, %4")
                                 .arg(KIO::convertSize(totalSize),
                                 QLocale().toString(totalSize),
                                 i18np("1 file", "%1 files", totalFiles),
                                 i18np("1 sub-folder", "%1 sub-folders", totalSubdirs)));
     }
     d->m_sizeStopButton->setEnabled(false);
     // just in case you change something and try again :)
     d->m_sizeDetermineButton->setText(i18n("Refresh"));
     d->m_sizeDetermineButton->setEnabled(true);
     d->dirSizeJob = nullptr;
     delete d->dirSizeUpdateTimer;
     d->dirSizeUpdateTimer = nullptr;
 }
 
 void KFilePropsPlugin::slotSizeDetermine()
 {
     d->m_sizeLabel->setText(i18n("Calculating..."));
     // qDebug() << "properties->item()=" << properties->item() << "URL=" << properties->item().url();
 
     d->dirSizeJob = KIO::directorySize(properties->items());
     d->dirSizeUpdateTimer = new QTimer(this);
     connect(d->dirSizeUpdateTimer, &QTimer::timeout,
             this, &KFilePropsPlugin::slotDirSizeUpdate);
     d->dirSizeUpdateTimer->start(500);
     connect(d->dirSizeJob, &KJob::result,
             this, &KFilePropsPlugin::slotDirSizeFinished);
     d->m_sizeStopButton->setEnabled(true);
     d->m_sizeDetermineButton->setEnabled(false);
 
     // also update the "Free disk space" display
     if (d->m_capacityBar) {
         const KFileItem item = properties->item();
         KIO::FileSystemFreeSpaceJob *job = KIO::fileSystemFreeSpace(item.url());
         connect(job, &KIO::FileSystemFreeSpaceJob::result, this, &KFilePropsPlugin::slotFreeSpaceResult);
     }
 }
 
 void KFilePropsPlugin::slotSizeStop()
 {
     if (d->dirSizeJob) {
         KIO::filesize_t totalSize = d->dirSizeJob->totalSize();
         d->m_sizeLabel->setText(i18n("At least %1",
                                      KIO::convertSize(totalSize)));
         d->dirSizeJob->kill();
         d->dirSizeJob = nullptr;
     }
     if (d->dirSizeUpdateTimer) {
         d->dirSizeUpdateTimer->stop();
     }
 
     d->m_sizeStopButton->setEnabled(false);
     d->m_sizeDetermineButton->setEnabled(true);
 }
 
 KFilePropsPlugin::~KFilePropsPlugin()
 {
     delete d;
 }
 
 bool KFilePropsPlugin::supports(const KFileItemList & /*_items*/)
 {
     return true;
 }
 
 void KFilePropsPlugin::applyChanges()
 {
     if (d->dirSizeJob) {
         slotSizeStop();
     }
 
     // qDebug() << "KFilePropsPlugin::applyChanges";
 
     if (d->m_lined) {
         QString n = d->m_lined->text();
         // Remove trailing spaces (#4345)
         while (! n.isEmpty() && n[n.length() - 1].isSpace()) {
             n.chop(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::CopyJob *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, &KJob::result,
                     this, &KFilePropsPlugin::slotCopyFinished);
             connect(job, &KIO::CopyJob::renamed,
                     this, &KFilePropsPlugin::slotFileRenamed);
             // wait for job
             QEventLoop eventLoop;
             connect(this, &KFilePropsPlugin::leaveModality,
                     &eventLoop, &QEventLoop::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().constFirst());
             properties->abortApplying(); // Don't apply the changes to the wrong file !
             return;
         }
     }
 
     Q_ASSERT(!properties->item().isNull());
     Q_ASSERT(!properties->item().url().isEmpty());
 
     // Save the file locally
     if (d->bDesktopFile && !d->m_sRelativePath.isEmpty()) {
         // qDebug() << "KFilePropsPlugin::slotCopyFinished " << d->m_sRelativePath;
         const QString newPath = QStandardPaths::writableLocation(QStandardPaths::ApplicationsLocation) + QLatin1Char('/') + d->m_sRelativePath;
         const QUrl newURL = QUrl::fromLocalFile(newPath);
         // qDebug() << "KFilePropsPlugin::slotCopyFinished path=" << newURL;
         properties->updateUrl(newURL);
     }
 
     if (d->bKDesktopMode && d->bDesktopFile) {
         // Renamed? Update Name field
         // Note: The desktop ioslave does this as well, but not when
         //       the file is copied from a template.
         if (d->m_bFromTemplate) {
             KIO::StatJob *job = KIO::stat(properties->url());
             job->exec();
             KIO::UDSEntry entry = job->statResult();
 
             KFileItem item(entry, properties->url());
             KDesktopFile config(item.localPath());
             KConfigGroup cg = config.desktopGroup();
             QString nameStr = nameFromFileName(properties->url().fileName());
             cg.writeEntry("Name", nameStr);
             cg.writeEntry("Name", nameStr, KConfigGroup::Persistent | KConfigGroup::Localized);
         }
     }
 
     if (d->m_linkTargetLineEdit && !d->bMultiple) {
         const KFileItem item = properties->item();
         const QString newTarget = d->m_linkTargetLineEdit->text();
         if (newTarget != item.linkDest()) {
             // qDebug() << "Updating target of symlink to" << newTarget;
             KIO::Job *job = KIO::symlink(newTarget, item.url(), KIO::Overwrite);
             job->uiDelegate()->setAutoErrorHandlingEnabled(true);
             job->exec();
         }
     }
 
     // "Link to Application" templates need to be made executable
     // Instead of matching against a filename we check if the destination
     // is an Application now.
     if (d->m_bFromTemplate) {
         // destination is not necessarily local, use the src template
         KDesktopFile templateResult(static_cast<KIO::CopyJob *>(job)->srcUrls().constFirst().toLocalFile());
         if (templateResult.hasApplicationType()) {
             // We can either stat the file and add the +x bit or use the larger chmod() job
             // with a umask designed to only touch u+x.  This is only one KIO job, so let's
             // do that.
 
             KFileItem appLink(properties->item());
             KFileItemList fileItemList;
             fileItemList << appLink;
 
             // first 0100 adds u+x, second 0100 only allows chmod to change u+x
             KIO::Job *chmodJob = KIO::chmod(fileItemList, 0100, 0100, QString(), QString(), KIO::HideProgressInfo);
             chmodJob->exec();
         }
     }
 }
 
 void KFilePropsPlugin::applyIconChanges()
 {
     KIconButton *iconButton = qobject_cast<KIconButton *>(d->iconArea);
     if (!iconButton || !d->bIconChanged) {
         return;
     }
     // handle icon changes - only local files (or pseudo-local) for now
     // TODO: Use KTempFile and KIO::file_copy with overwrite = true
     QUrl url = properties->url();
     KIO::StatJob *job = KIO::mostLocalUrl(url);
     KJobWidgets::setWindow(job, properties);
     job->exec();
     url = job->mostLocalUrl();
 
     if (url.isLocalFile()) {
         QString path;
 
         if ((properties->item().mode() & QT_STAT_MASK) == QT_STAT_DIR) {
             path = url.toLocalFile() + QLatin1String("/.directory");
             // don't call updateUrl because the other tabs (i.e. permissions)
             // apply to the directory, not the .directory file.
         } else {
             path = url.toLocalFile();
         }
 
         // Get the default image
         QMimeDatabase db;
         QString str = db.mimeTypeForFile(url.toLocalFile(), QMimeDatabase::MatchExtension).iconName();
         // Is it another one than the default ?
         QString sIcon;
         if (str != iconButton->icon()) {
             sIcon = iconButton->icon();
         }
         // (otherwise write empty value)
 
         // qDebug() << "**" << path << "**";
 
         // If default icon and no .directory file -> don't create one
         if (!sIcon.isEmpty() || QFile::exists(path)) {
             KDesktopFile cfg(path);
             // qDebug() << "sIcon = " << (sIcon);
             // qDebug() << "str = " << (str);
             cfg.desktopGroup().writeEntry("Icon", sIcon);
             cfg.sync();
 
             cfg.reparseConfiguration();
             if (cfg.desktopGroup().readEntry("Icon") != sIcon) {
                 KMessageBox::sorry(nullptr, i18n("<qt>Could not save properties. You do not "
                                            "have sufficient access to write to <b>%1</b>.</qt>", path));
             }
         }
     }
 }
 
 void KFilePropsPlugin::slotFileRenamed(KIO::Job *, const QUrl &, const QUrl &newUrl)
 {
     // This is called in case of an existing local file during the copy/move operation,
     // if the user chooses Rename.
     properties->updateUrl(newUrl);
 }
 
 void KFilePropsPlugin::postApplyChanges()
 {
     // Save the icon only after applying the permissions changes (#46192)
     applyIconChanges();
 
     const KFileItemList items = properties->items();
     const QList<QUrl> lst = items.urlList();
     org::kde::KDirNotify::emitFilesChanged(QList<QUrl>(lst));
 }
 
 class KFilePermissionsPropsPlugin::KFilePermissionsPropsPluginPrivate
 {
 public:
     KFilePermissionsPropsPluginPrivate()
     {
     }
     ~KFilePermissionsPropsPluginPrivate()
     {
     }
 
     QFrame *m_frame;
     QCheckBox *cbRecursive;
     QLabel *explanationLabel;
     KComboBox *ownerPermCombo, *groupPermCombo, *othersPermCombo;
     QCheckBox *extraCheckbox;
     mode_t partialPermissions;
     KFilePermissionsPropsPlugin::PermissionsMode pmode;
     bool canChangePermissions;
     bool isIrregular;
     bool hasExtendedACL;
     KACL extendedACL;
     KACL defaultACL;
     bool fileSystemSupportsACLs;
 
     KComboBox *grpCombo;
 
     KLineEdit *usrEdit;
     KLineEdit *grpEdit;
 
     // Old permissions
     mode_t permissions;
     // Old group
     QString strGroup;
     // Old owner
     QString strOwner;
 };
 
 #define UniOwner    (S_IRUSR|S_IWUSR|S_IXUSR)
 #define UniGroup    (S_IRGRP|S_IWGRP|S_IXGRP)
 #define UniOthers   (S_IROTH|S_IWOTH|S_IXOTH)
 #define UniRead     (S_IRUSR|S_IRGRP|S_IROTH)
 #define UniWrite    (S_IWUSR|S_IWGRP|S_IWOTH)
 #define UniExec     (S_IXUSR|S_IXGRP|S_IXOTH)
 #define UniSpecial  (S_ISUID|S_ISGID|S_ISVTX)
 
 // synced with PermissionsTarget
 const mode_t KFilePermissionsPropsPlugin::permissionsMasks[3] = {UniOwner, UniGroup, UniOthers};
 const mode_t KFilePermissionsPropsPlugin::standardPermissions[4] = { 0, UniRead, UniRead | UniWrite, (mode_t) - 1 };
 
 // synced with PermissionsMode and standardPermissions
 const char *const KFilePermissionsPropsPlugin::permissionsTexts[4][4] = {
     {
         I18N_NOOP("No Access"),
         I18N_NOOP("Can Only View"),
         I18N_NOOP("Can View & Modify"),
         nullptr
     },
     {
         I18N_NOOP("No Access"),
         I18N_NOOP("Can Only View Content"),
         I18N_NOOP("Can View & Modify Content"),
         nullptr
     },
     { nullptr, nullptr, nullptr, nullptr}, // no texts for links
     {
         I18N_NOOP("No Access"),
         I18N_NOOP("Can Only View/Read Content"),
         I18N_NOOP("Can View/Read & Modify/Write"),
         nullptr
     }
 };
 
 KFilePermissionsPropsPlugin::KFilePermissionsPropsPlugin(KPropertiesDialog *_props)
     : KPropertiesDialogPlugin(_props), d(new KFilePermissionsPropsPluginPrivate)
 {
     d->cbRecursive = nullptr;
     d->grpCombo = nullptr; d->grpEdit = nullptr;
     d->usrEdit = nullptr;
     bool isLocal = properties->url().isLocalFile();
     bool isTrash = (properties->url().scheme() == QLatin1String("trash"));
     KUser myself(KUser::UseEffectiveUID);
     const bool IamRoot = myself.isSuperUser();
 
     const KFileItem item = properties->item();
     bool isLink = item.isLink();
     bool isDir = item.isDir(); // all dirs
     bool hasDir = item.isDir(); // at least one dir
     d->permissions = item.permissions(); // common permissions to all files
     d->partialPermissions = d->permissions; // permissions that only some files have (at first we take everything)
     d->isIrregular = isIrregular(d->permissions, isDir, isLink);
     d->strOwner = item.user();
     d->strGroup = item.group();
     d->hasExtendedACL = item.ACL().isExtended() || item.defaultACL().isValid();
     d->extendedACL = item.ACL();
     d->defaultACL = item.defaultACL();
     d->fileSystemSupportsACLs = false;
 
     if (properties->items().count() > 1) {
         // Multiple items: see what they have in common
         const KFileItemList items = properties->items();
         KFileItemList::const_iterator it = items.begin();
         const KFileItemList::const_iterator kend = items.end();
         for (++it /*no need to check the first one again*/; it != kend; ++it) {
             if (!d->isIrregular)
                 d->isIrregular |= isIrregular((*it).permissions(),
                                               (*it).isDir() == isDir,
                                               (*it).isLink() == isLink);
             d->hasExtendedACL = d->hasExtendedACL || (*it).hasExtendedACL();
             if ((*it).isLink() != isLink) {
                 isLink = false;
             }
             if ((*it).isDir() != isDir) {
                 isDir = false;
             }
             hasDir |= (*it).isDir();
             if ((*it).permissions() != d->permissions) {
                 d->permissions &= (*it).permissions();
                 d->partialPermissions |= (*it).permissions();
             }
             if ((*it).user() != d->strOwner) {
                 d->strOwner.clear();
             }
             if ((*it).group() != d->strGroup) {
                 d->strGroup.clear();
             }
         }
     }
 
     if (isLink) {
         d->pmode = PermissionsOnlyLinks;
     } else if (isDir) {
         d->pmode = PermissionsOnlyDirs;
     } else if (hasDir) {
         d->pmode = PermissionsMixed;
     } else {
         d->pmode = PermissionsOnlyFiles;
     }
 
     // keep only what's not in the common permissions
     d->partialPermissions = d->partialPermissions & ~d->permissions;
 
     bool isMyFile = false;
 
     if (isLocal && !d->strOwner.isEmpty()) { // local files, and all owned by the same person
         if (myself.isValid()) {
             isMyFile = (d->strOwner == myself.loginName());
         } else {
             qCWarning(KIO_WIDGETS) << "I don't exist ?! geteuid=" << KUserId::currentEffectiveUserId().toString();
         }
     } else {
         //We don't know, for remote files, if they are ours or not.
         //So we let the user change permissions, and
         //KIO::chmod will tell, if he had no right to do it.
         isMyFile = true;
     }
 
     d->canChangePermissions = (isMyFile || IamRoot) && (!isLink);
 
     // create GUI
 
     d->m_frame = new QFrame();
     properties->addPage(d->m_frame, i18n("&Permissions"));
 
     QBoxLayout *box = new QVBoxLayout(d->m_frame);
-    box->setMargin(0);
+    box->setContentsMargins(0, 0, 0, 0);
 
     QWidget *l;
     QLabel *lbl;
     QGroupBox *gb;
     QGridLayout *gl;
     QPushButton *pbAdvancedPerm = nullptr;
 
     /* Group: Access Permissions */
     gb = new QGroupBox(i18n("Access Permissions"), d->m_frame);
     box->addWidget(gb);
 
     gl = new QGridLayout(gb);
     gl->setColumnStretch(1, 1);
 
     l = d->explanationLabel = new QLabel(gb);
     if (isLink)
         d->explanationLabel->setText(i18np("This file is a link and does not have permissions.",
                                            "All files are links and do not have permissions.",
                                            properties->items().count()));
     else if (!d->canChangePermissions) {
         d->explanationLabel->setText(i18n("Only the owner can change permissions."));
     }
     gl->addWidget(l, 0, 0, 1, 2);
 
     lbl = new QLabel(i18n("O&wner:"), gb);
     gl->addWidget(lbl, 1, 0, Qt::AlignRight);
     l = d->ownerPermCombo = new KComboBox(gb);
     lbl->setBuddy(l);
     gl->addWidget(l, 1, 1);
     connect(d->ownerPermCombo, QOverload<int>::of(&QComboBox::activated),
             this, &KPropertiesDialogPlugin::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(d->groupPermCombo, QOverload<int>::of(&QComboBox::activated),
             this, &KPropertiesDialogPlugin::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(d->othersPermCombo, QOverload<int>::of(&QComboBox::activated),
             this, &KPropertiesDialogPlugin::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, &QAbstractButton::clicked, this, &KPropertiesDialogPlugin::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, &QAbstractButton::clicked,
                 this, &KFilePermissionsPropsPlugin::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, &QLineEdit::textChanged,
                 this, &KPropertiesDialogPlugin::changed);
     } else {
         l = new QLabel(d->strOwner, gb);
         gl->addWidget(l, 1, 1);
     }
 
     /*** Set Group ***/
 
     KUser user(KUser::UseEffectiveUID);
     QStringList groupList = user.groupNames();
     const bool isMyGroup = groupList.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, &QLineEdit::textChanged,
                 this, &KPropertiesDialogPlugin::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, QOverload<int>::of(&QComboBox::activated),
                 this, &KPropertiesDialogPlugin::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, &QAbstractButton::clicked, this, &KPropertiesDialogPlugin::changed);
         box->addWidget(d->cbRecursive);
     }
 
     updateAccessControls();
 
     if (isTrash) {
         //don't allow to change properties for file into trash
         enableAccessControls(false);
         if (pbAdvancedPerm) {
             pbAdvancedPerm->setEnabled(false);
         }
     }
 
     box->addStretch(10);
 }
 
 #if HAVE_POSIX_ACL
 static bool fileSystemSupportsACL(const QByteArray &path)
 {
     bool fileSystemSupportsACLs = false;
 #ifdef Q_OS_FREEBSD
     struct statfs buf;
     fileSystemSupportsACLs = (statfs(path.data(), &buf) == 0) && (buf.f_flags & MNT_ACLS);
 #elif defined Q_OS_MACOS
     fileSystemSupportsACLs =
         getxattr(path.data(), "system.posix_acl_access", nullptr, 0, 0, XATTR_NOFOLLOW) >= 0 || errno == ENODATA;
 #else
     fileSystemSupportsACLs =
         getxattr(path.data(), "system.posix_acl_access", nullptr, 0) >= 0 || errno == ENODATA;
 #endif
     return fileSystemSupportsACLs;
 }
 #endif
 
 void KFilePermissionsPropsPlugin::slotShowAdvancedPermissions()
 {
 
     bool isDir = (d->pmode == PermissionsOnlyDirs) || (d->pmode == PermissionsMixed);
     QDialog dlg(properties);
     dlg.setModal(true);
     dlg.setWindowTitle(i18n("Advanced Permissions"));
 
     QLabel *l, *cl[3];
     QGroupBox *gb;
     QGridLayout *gl;
 
     QVBoxLayout *vbox = new QVBoxLayout;
     dlg.setLayout(vbox);
     // Group: Access Permissions
     gb = new QGroupBox(i18n("Access Permissions"), &dlg);
     vbox->addWidget(gb);
 
     gl = new QGridLayout(gb);
     gl->addItem(new QSpacerItem(0, 10), 0, 0);
 
     QVector<QWidget *> theNotSpecials;
 
     l = new QLabel(i18n("Class"), gb);
     gl->addWidget(l, 1, 0);
     theNotSpecials.append(l);
 
     QString readWhatsThis;
     QString readLabel;
     if (isDir) {
         readLabel = i18n("Show\nEntries");
         readWhatsThis = i18n("This flag allows viewing the content of the folder.");
     } else {
         readLabel = i18n("Read");
         readWhatsThis = i18n("The Read flag allows viewing the content of the file.");
     }
 
     QString writeWhatsThis;
     QString writeLabel;
     if (isDir) {
         writeLabel = i18n("Write\nEntries");
         writeWhatsThis = i18n("This flag allows adding, renaming and deleting of files. "
                               "Note that deleting and renaming can be limited using the Sticky flag.");
     } else {
         writeLabel = i18n("Write");
         writeWhatsThis = i18n("The Write flag allows modifying the content of the file.");
     }
 
     QString execLabel;
     QString execWhatsThis;
     if (isDir) {
         execLabel = i18nc("Enter folder", "Enter");
         execWhatsThis = i18n("Enable this flag to allow entering the folder.");
     } else {
         execLabel = i18n("Exec");
         execWhatsThis = i18n("Enable this flag to allow executing the file as a program.");
     }
     // GJ: Add space between normal and special modes
     QSize size = l->sizeHint();
     size.setWidth(size.width() + 15);
     l->setFixedSize(size);
     gl->addWidget(l, 1, 3);
 
     l = new QLabel(i18n("Special"), gb);
     gl->addWidget(l, 1, 4, 1, 1);
     QString specialWhatsThis;
     if (isDir)
         specialWhatsThis = i18n("Special flag. Valid for the whole folder, the exact "
                                 "meaning of the flag can be seen in the right hand column.");
     else
         specialWhatsThis = i18n("Special flag. The exact meaning of the flag can be seen "
                                 "in the right hand column.");
     l->setWhatsThis(specialWhatsThis);
 
     cl[0] = new QLabel(i18n("User"), gb);
     gl->addWidget(cl[0], 2, 0);
     theNotSpecials.append(cl[0]);
 
     cl[1] = new QLabel(i18n("Group"), gb);
     gl->addWidget(cl[1], 3, 0);
     theNotSpecials.append(cl[1]);
 
     cl[2] = new QLabel(i18n("Others"), gb);
     gl->addWidget(cl[2], 4, 0);
     theNotSpecials.append(cl[2]);
 
     QString setUidWhatsThis;
     if (isDir)
         setUidWhatsThis = i18n("If this flag is set, the owner of this folder will be "
                                "the owner of all new files.");
     else
         setUidWhatsThis = i18n("If this file is an executable and the flag is set, it will "
                                "be executed with the permissions of the owner.");
 
     QString setGidWhatsThis;
     if (isDir)
         setGidWhatsThis = i18n("If this flag is set, the group of this folder will be "
                                "set for all new files.");
     else
         setGidWhatsThis = i18n("If this file is an executable and the flag is set, it will "
                                "be executed with the permissions of the group.");
 
     QString stickyWhatsThis;
     if (isDir)
         stickyWhatsThis = i18n("If the Sticky flag is set on a folder, only the owner "
                                "and root can delete or rename files. Otherwise everybody "
                                "with write permissions can do this.");
     else
         stickyWhatsThis = i18n("The Sticky flag on a file is ignored on Linux, but may "
                                "be used on some systems");
     mode_t aPermissions, aPartialPermissions;
     mode_t dummy1, dummy2;
 
     if (!d->isIrregular) {
         switch (d->pmode) {
         case PermissionsOnlyFiles:
             getPermissionMasks(aPartialPermissions,
                                dummy1,
                                aPermissions,
                                dummy2);
             break;
         case PermissionsOnlyDirs:
         case PermissionsMixed:
             getPermissionMasks(dummy1,
                                aPartialPermissions,
                                dummy2,
                                aPermissions);
             break;
         case PermissionsOnlyLinks:
             aPermissions = UniRead | UniWrite | UniExec | UniSpecial;
             aPartialPermissions = 0;
             break;
         }
     } else {
         aPermissions = d->permissions;
         aPartialPermissions = d->partialPermissions;
     }
 
     // Draw Checkboxes
     QCheckBox *cba[3][4];
     for (int row = 0; row < 3; ++row) {
         for (int col = 0; col < 4; ++col) {
             QCheckBox *cb = new QCheckBox(gb);
             if (col != 3) {
                 theNotSpecials.append(cb);
             }
             cba[row][col] = cb;
             cb->setChecked(aPermissions & fperm[row][col]);
             if (aPartialPermissions & fperm[row][col]) {
                 cb->setTristate();
                 cb->setCheckState(Qt::PartiallyChecked);
             } else if (d->cbRecursive && d->cbRecursive->isChecked()) {
                 cb->setTristate();
             }
 
             cb->setEnabled(d->canChangePermissions);
             gl->addWidget(cb, row + 2, col + 1);
             switch (col) {
             case 0:
                 cb->setText(readLabel);
                 cb->setWhatsThis(readWhatsThis);
                 break;
             case 1:
                 cb->setText(writeLabel);
                 cb->setWhatsThis(writeWhatsThis);
                 break;
             case 2:
                 cb->setText(execLabel);
                 cb->setWhatsThis(execWhatsThis);
                 break;
             case 3:
                 switch (row) {
                 case 0:
                     cb->setText(i18n("Set UID"));
                     cb->setWhatsThis(setUidWhatsThis);
                     break;
                 case 1:
                     cb->setText(i18n("Set GID"));
                     cb->setWhatsThis(setGidWhatsThis);
                     break;
                 case 2:
                     cb->setText(i18nc("File permission", "Sticky"));
                     cb->setWhatsThis(stickyWhatsThis);
                     break;
                 }
                 break;
             }
         }
     }
     gl->setColumnStretch(6, 10);
 
 #if HAVE_POSIX_ACL
     KACLEditWidget *extendedACLs = nullptr;
 
     // FIXME make it work with partial entries
     if (properties->items().count() == 1) {
         QByteArray path = QFile::encodeName(properties->item().url().toLocalFile());
         d->fileSystemSupportsACLs = fileSystemSupportsACL(path);
     }
     if (d->fileSystemSupportsACLs) {
         std::for_each(theNotSpecials.begin(), theNotSpecials.end(), std::mem_fun(&QWidget::hide));
         extendedACLs = new KACLEditWidget(&dlg);
         extendedACLs->setEnabled(d->canChangePermissions);
         vbox->addWidget(extendedACLs);
         if (d->extendedACL.isValid() && d->extendedACL.isExtended()) {
             extendedACLs->setACL(d->extendedACL);
         } else {
             extendedACLs->setACL(KACL(aPermissions));
         }
 
         if (d->defaultACL.isValid()) {
             extendedACLs->setDefaultACL(d->defaultACL);
         }
 
         if (properties->items().constFirst().isDir()) {
             extendedACLs->setAllowDefaults(true);
         }
     }
 #endif
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(&dlg);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     connect(buttonBox, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
     vbox->addWidget(buttonBox);
 
     if (dlg.exec() != QDialog::Accepted) {
         return;
     }
 
     mode_t andPermissions = mode_t(~0);
     mode_t orPermissions = 0;
     for (int row = 0; row < 3; ++row)
         for (int col = 0; col < 4; ++col) {
             switch (cba[row][col]->checkState()) {
             case Qt::Checked:
                 orPermissions |= fperm[row][col];
             //fall through
             case Qt::Unchecked:
                 andPermissions &= ~fperm[row][col];
                 break;
             case Qt::PartiallyChecked:
                 break;
             }
         }
 
     d->isIrregular = false;
     const KFileItemList items = properties->items();
     KFileItemList::const_iterator it = items.begin();
     const KFileItemList::const_iterator kend = items.end();
     for (; it != kend; ++it) {
         if (isIrregular(((*it).permissions() & andPermissions) | orPermissions,
                         (*it).isDir(), (*it).isLink())) {
             d->isIrregular = true;
             break;
         }
     }
 
     d->permissions = orPermissions;
     d->partialPermissions = andPermissions;
 
 #if HAVE_POSIX_ACL
     // override with the acls, if present
     if (extendedACLs) {
         d->extendedACL = extendedACLs->getACL();
         d->defaultACL = extendedACLs->getDefaultACL();
         d->hasExtendedACL = d->extendedACL.isExtended() || d->defaultACL.isValid();
         d->permissions = d->extendedACL.basePermissions();
         d->permissions |= (andPermissions | orPermissions) & (S_ISUID | S_ISGID | S_ISVTX);
     }
 #endif
 
     updateAccessControls();
     emit changed();
 }
 
 // QString KFilePermissionsPropsPlugin::tabName () const
 // {
 //   return i18n ("&Permissions");
 // }
 
 KFilePermissionsPropsPlugin::~KFilePermissionsPropsPlugin()
 {
     delete d;
 }
 
 bool KFilePermissionsPropsPlugin::supports(const KFileItemList & /*_items*/)
 {
     return true;
 }
 
 // sets a combo box in the Access Control frame
 void KFilePermissionsPropsPlugin::setComboContent(QComboBox *combo, PermissionsTarget target,
         mode_t permissions, mode_t partial)
 {
     combo->clear();
     if (d->isIrregular) { //#176876
         return;
     }
 
     if (d->pmode == PermissionsOnlyLinks) {
         combo->addItem(i18n("Link"));
         combo->setCurrentIndex(0);
         return;
     }
 
     mode_t tMask = permissionsMasks[target];
     int textIndex;
     for (textIndex = 0; standardPermissions[textIndex] != (mode_t) - 1; textIndex++) {
         if ((standardPermissions[textIndex]&tMask) == (permissions & tMask & (UniRead | UniWrite))) {
             break;
         }
     }
     Q_ASSERT(standardPermissions[textIndex] != (mode_t) - 1); // must not happen, would be irreglar
 
     for (int i = 0; permissionsTexts[(int)d->pmode][i]; i++) {
         combo->addItem(i18n(permissionsTexts[(int)d->pmode][i]));
     }
 
     if (partial & tMask & ~UniExec) {
         combo->addItem(i18n("Varying (No Change)"));
         combo->setCurrentIndex(3);
     } else {
         combo->setCurrentIndex(textIndex);
     }
 }
 
 // permissions are irregular if they cant be displayed in a combo box.
 bool KFilePermissionsPropsPlugin::isIrregular(mode_t permissions, bool isDir, bool isLink)
 {
     if (isLink) {                           // links are always ok
         return false;
     }
 
     mode_t p = permissions;
     if (p & (S_ISUID | S_ISGID)) { // setuid/setgid -> irregular
         return true;
     }
     if (isDir) {
         p &= ~S_ISVTX;          // ignore sticky on dirs
 
         // check supported flag combinations
         mode_t p0 = p & UniOwner;
         if ((p0 != 0) && (p0 != (S_IRUSR | S_IXUSR)) && (p0 != UniOwner)) {
             return true;
         }
         p0 = p & UniGroup;
         if ((p0 != 0) && (p0 != (S_IRGRP | S_IXGRP)) && (p0 != UniGroup)) {
             return true;
         }
         p0 = p & UniOthers;
         if ((p0 != 0) && (p0 != (S_IROTH | S_IXOTH)) && (p0 != UniOthers)) {
             return true;
         }
         return false;
     }
     if (p & S_ISVTX) { // sticky on file -> irregular
         return true;
     }
 
     // check supported flag combinations
     mode_t p0 = p & UniOwner;
     bool usrXPossible = !p0; // true if this file could be an executable
     if (p0 & S_IXUSR) {
         if ((p0 == S_IXUSR) || (p0 == (S_IWUSR | S_IXUSR))) {
             return true;
         }
         usrXPossible = true;
     } else if (p0 == S_IWUSR) {
         return true;
     }
 
     p0 = p & UniGroup;
     bool grpXPossible = !p0; // true if this file could be an executable
     if (p0 & S_IXGRP) {
         if ((p0 == S_IXGRP) || (p0 == (S_IWGRP | S_IXGRP))) {
             return true;
         }
         grpXPossible = true;
     } else if (p0 == S_IWGRP) {
         return true;
     }
     if (p0 == 0) {
         grpXPossible = true;
     }
 
     p0 = p & UniOthers;
     bool othXPossible = !p0; // true if this file could be an executable
     if (p0 & S_IXOTH) {
         if ((p0 == S_IXOTH) || (p0 == (S_IWOTH | S_IXOTH))) {
             return true;
         }
         othXPossible = true;
     } else if (p0 == S_IWOTH) {
         return true;
     }
 
     // check that there either all targets are executable-compatible, or none
     return (p & UniExec) && !(usrXPossible && grpXPossible && othXPossible);
 }
 
 // enables/disabled the widgets in the Access Control frame
 void KFilePermissionsPropsPlugin::enableAccessControls(bool enable)
 {
     d->ownerPermCombo->setEnabled(enable);
     d->groupPermCombo->setEnabled(enable);
     d->othersPermCombo->setEnabled(enable);
     if (d->extraCheckbox) {
         d->extraCheckbox->setEnabled(enable);
     }
     if (d->cbRecursive) {
         d->cbRecursive->setEnabled(enable);
     }
 }
 
 // updates all widgets in the Access Control frame
 void KFilePermissionsPropsPlugin::updateAccessControls()
 {
     setComboContent(d->ownerPermCombo, PermissionsOwner,
                     d->permissions, d->partialPermissions);
     setComboContent(d->groupPermCombo, PermissionsGroup,
                     d->permissions, d->partialPermissions);
     setComboContent(d->othersPermCombo, PermissionsOthers,
                     d->permissions, d->partialPermissions);
 
     switch (d->pmode) {
     case PermissionsOnlyLinks:
         enableAccessControls(false);
         break;
     case PermissionsOnlyFiles:
         enableAccessControls(d->canChangePermissions && !d->isIrregular && !d->hasExtendedACL);
         if (d->canChangePermissions)
             d->explanationLabel->setText(d->isIrregular || d->hasExtendedACL ?
                                          i18np("This file uses advanced permissions",
                                                "These files use advanced permissions.",
                                                properties->items().count()) : QString());
         if (d->partialPermissions & UniExec) {
             d->extraCheckbox->setTristate();
             d->extraCheckbox->setCheckState(Qt::PartiallyChecked);
         } else {
             d->extraCheckbox->setTristate(false);
             d->extraCheckbox->setChecked(d->permissions & UniExec);
         }
         break;
     case PermissionsOnlyDirs:
         enableAccessControls(d->canChangePermissions && !d->isIrregular && !d->hasExtendedACL);
         // if this is a dir, and we can change permissions, don't dis-allow
         // recursive, we can do that for ACL setting.
         if (d->cbRecursive) {
             d->cbRecursive->setEnabled(d->canChangePermissions && !d->isIrregular);
         }
 
         if (d->canChangePermissions)
             d->explanationLabel->setText(d->isIrregular || d->hasExtendedACL ?
                                          i18np("This folder uses advanced permissions.",
                                                "These folders use advanced permissions.",
                                                properties->items().count()) : QString());
         if (d->partialPermissions & S_ISVTX) {
             d->extraCheckbox->setTristate();
             d->extraCheckbox->setCheckState(Qt::PartiallyChecked);
         } else {
             d->extraCheckbox->setTristate(false);
             d->extraCheckbox->setChecked(d->permissions & S_ISVTX);
         }
         break;
     case PermissionsMixed:
         enableAccessControls(d->canChangePermissions && !d->isIrregular && !d->hasExtendedACL);
         if (d->canChangePermissions)
             d->explanationLabel->setText(d->isIrregular || d->hasExtendedACL ?
                                          i18n("These files use advanced permissions.") : QString());
         if (d->partialPermissions & S_ISVTX) {
             d->extraCheckbox->setTristate();
             d->extraCheckbox->setCheckState(Qt::PartiallyChecked);
         } else {
             d->extraCheckbox->setTristate(false);
             d->extraCheckbox->setChecked(d->permissions & S_ISVTX);
         }
         break;
     }
 }
 
 // gets masks for files and dirs from the Access Control frame widgets
 void KFilePermissionsPropsPlugin::getPermissionMasks(mode_t &andFilePermissions,
         mode_t &andDirPermissions,
         mode_t &orFilePermissions,
         mode_t &orDirPermissions)
 {
     andFilePermissions = mode_t(~UniSpecial);
     andDirPermissions = mode_t(~(S_ISUID | S_ISGID));
     orFilePermissions = 0;
     orDirPermissions = 0;
     if (d->isIrregular) {
         return;
     }
 
     mode_t m = standardPermissions[d->ownerPermCombo->currentIndex()];
     if (m != (mode_t) - 1) {
         orFilePermissions |= m & UniOwner;
         if ((m & UniOwner) &&
                 ((d->pmode == PermissionsMixed) ||
                  ((d->pmode == PermissionsOnlyFiles) && (d->extraCheckbox->checkState() == Qt::PartiallyChecked)))) {
             andFilePermissions &= ~(S_IRUSR | S_IWUSR);
         } else {
             andFilePermissions &= ~(S_IRUSR | S_IWUSR | S_IXUSR);
             if ((m & S_IRUSR) && (d->extraCheckbox->checkState() == Qt::Checked)) {
                 orFilePermissions |= S_IXUSR;
             }
         }
 
         orDirPermissions |= m & UniOwner;
         if (m & S_IRUSR) {
             orDirPermissions |= S_IXUSR;
         }
         andDirPermissions &= ~(S_IRUSR | S_IWUSR | S_IXUSR);
     }
 
     m = standardPermissions[d->groupPermCombo->currentIndex()];
     if (m != (mode_t) - 1) {
         orFilePermissions |= m & UniGroup;
         if ((m & UniGroup) &&
                 ((d->pmode == PermissionsMixed) ||
                  ((d->pmode == PermissionsOnlyFiles) && (d->extraCheckbox->checkState() == Qt::PartiallyChecked)))) {
             andFilePermissions &= ~(S_IRGRP | S_IWGRP);
         } else {
             andFilePermissions &= ~(S_IRGRP | S_IWGRP | S_IXGRP);
             if ((m & S_IRGRP) && (d->extraCheckbox->checkState() == Qt::Checked)) {
                 orFilePermissions |= S_IXGRP;
             }
         }
 
         orDirPermissions |= m & UniGroup;
         if (m & S_IRGRP) {
             orDirPermissions |= S_IXGRP;
         }
         andDirPermissions &= ~(S_IRGRP | S_IWGRP | S_IXGRP);
     }
 
     m = d->othersPermCombo->currentIndex() >= 0 ? standardPermissions[d->othersPermCombo->currentIndex()] : (mode_t) - 1;
     if (m != (mode_t) - 1) {
         orFilePermissions |= m & UniOthers;
         if ((m & UniOthers) &&
                 ((d->pmode == PermissionsMixed) ||
                  ((d->pmode == PermissionsOnlyFiles) && (d->extraCheckbox->checkState() == Qt::PartiallyChecked)))) {
             andFilePermissions &= ~(S_IROTH | S_IWOTH);
         } else {
             andFilePermissions &= ~(S_IROTH | S_IWOTH | S_IXOTH);
             if ((m & S_IROTH) && (d->extraCheckbox->checkState() == Qt::Checked)) {
                 orFilePermissions |= S_IXOTH;
             }
         }
 
         orDirPermissions |= m & UniOthers;
         if (m & S_IROTH) {
             orDirPermissions |= S_IXOTH;
         }
         andDirPermissions &= ~(S_IROTH | S_IWOTH | S_IXOTH);
     }
 
     if (((d->pmode == PermissionsMixed) || (d->pmode == PermissionsOnlyDirs)) &&
             (d->extraCheckbox->checkState() != Qt::PartiallyChecked)) {
         andDirPermissions &= ~S_ISVTX;
         if (d->extraCheckbox->checkState() == Qt::Checked) {
             orDirPermissions |= S_ISVTX;
         }
     }
 }
 
 void KFilePermissionsPropsPlugin::applyChanges()
 {
     mode_t orFilePermissions;
     mode_t orDirPermissions;
     mode_t andFilePermissions;
     mode_t andDirPermissions;
 
     if (!d->canChangePermissions) {
         return;
     }
 
     if (!d->isIrregular)
         getPermissionMasks(andFilePermissions,
                            andDirPermissions,
                            orFilePermissions,
                            orDirPermissions);
     else {
         orFilePermissions = d->permissions;
         andFilePermissions = d->partialPermissions;
         orDirPermissions = d->permissions;
         andDirPermissions = d->partialPermissions;
     }
 
     QString owner, group;
     if (d->usrEdit) {
         owner = d->usrEdit->text();
     }
     if (d->grpEdit) {
         group = d->grpEdit->text();
     } else if (d->grpCombo) {
         group = d->grpCombo->currentText();
     }
 
     if (owner == d->strOwner) {
         owner.clear();    // no change
     }
 
     if (group == d->strGroup) {
         group.clear();
     }
 
     bool recursive = d->cbRecursive && d->cbRecursive->isChecked();
     bool permissionChange = false;
 
     KFileItemList files, dirs;
     const KFileItemList items = properties->items();
     KFileItemList::const_iterator it = items.begin();
     const KFileItemList::const_iterator kend = items.end();
     for (; it != kend; ++it) {
         if ((*it).isDir()) {
             dirs.append(*it);
             if ((*it).permissions() != (((*it).permissions() & andDirPermissions) | orDirPermissions)) {
                 permissionChange = true;
             }
         } else if ((*it).isFile()) {
             files.append(*it);
             if ((*it).permissions() != (((*it).permissions() & andFilePermissions) | orFilePermissions)) {
                 permissionChange = true;
             }
         }
     }
 
     const bool ACLChange = (d->extendedACL !=  properties->item().ACL());
     const bool defaultACLChange = (d->defaultACL != properties->item().defaultACL());
 
     if (owner.isEmpty() && group.isEmpty() && !recursive
             && !permissionChange && !ACLChange && !defaultACLChange) {
         return;
     }
 
     KIO::Job *job;
     if (!files.isEmpty()) {
         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, &KJob::result,
                 this, &KFilePermissionsPropsPlugin::slotChmodResult);
         QEventLoop eventLoop;
         connect(this, &KFilePermissionsPropsPlugin::leaveModality,
                 &eventLoop, &QEventLoop::quit);
         eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
     }
     if (!dirs.isEmpty()) {
         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, &KJob::result,
                 this, &KFilePermissionsPropsPlugin::slotChmodResult);
         QEventLoop eventLoop;
         connect(this, &KFilePermissionsPropsPlugin::leaveModality,
                 &eventLoop, &QEventLoop::quit);
         eventLoop.exec(QEventLoop::ExcludeUserInputEvents);
     }
 }
 
 void KFilePermissionsPropsPlugin::slotChmodResult(KJob *job)
 {
     // qDebug() << "KFilePermissionsPropsPlugin::slotChmodResult";
     if (job->error()) {
         job->uiDelegate()->showErrorMessage();
     }
     // allow apply() to return
     emit leaveModality();
 }
 
 class KChecksumsPlugin::KChecksumsPluginPrivate
 {
 public:
     KChecksumsPluginPrivate()
     {
     }
 
     ~KChecksumsPluginPrivate()
     {
     }
 
     QWidget m_widget;
     Ui::ChecksumsWidget m_ui;
 
     QFileSystemWatcher fileWatcher;
     QString m_md5;
     QString m_sha1;
     QString m_sha256;
 };
 
 KChecksumsPlugin::KChecksumsPlugin(KPropertiesDialog *dialog)
     : KPropertiesDialogPlugin(dialog), d(new KChecksumsPluginPrivate)
 {
     d->m_ui.setupUi(&d->m_widget);
     properties->addPage(&d->m_widget, i18nc("@title:tab", "C&hecksums"));
 
     d->m_ui.md5CopyButton->hide();
     d->m_ui.sha1CopyButton->hide();
     d->m_ui.sha256CopyButton->hide();
 
     connect(d->m_ui.lineEdit, &QLineEdit::textChanged, this, [=](const QString &text) {
         slotVerifyChecksum(text.toLower());
     });
 
     connect(d->m_ui.md5Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowMd5);
     connect(d->m_ui.sha1Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowSha1);
     connect(d->m_ui.sha256Button, &QPushButton::clicked, this, &KChecksumsPlugin::slotShowSha256);
 
     d->fileWatcher.addPath(properties->item().localPath());
     connect(&d->fileWatcher, &QFileSystemWatcher::fileChanged, this, &KChecksumsPlugin::slotInvalidateCache);
 
     auto clipboard = QApplication::clipboard();
     connect(d->m_ui.md5CopyButton, &QPushButton::clicked, this, [=]() {
         clipboard->setText(d->m_md5);
     });
 
     connect(d->m_ui.sha1CopyButton, &QPushButton::clicked, this, [=]() {
         clipboard->setText(d->m_sha1);
     });
 
     connect(d->m_ui.sha256CopyButton, &QPushButton::clicked, this, [=]() {
         clipboard->setText(d->m_sha256);
     });
 
     connect(d->m_ui.pasteButton, &QPushButton::clicked, this, [=]() {
         d->m_ui.lineEdit->setText(clipboard->text());
     });
 
     setDefaultState();
 }
 
 KChecksumsPlugin::~KChecksumsPlugin()
 {
     delete d;
 }
 
 bool KChecksumsPlugin::supports(const KFileItemList &items)
 {
     if (items.count() != 1) {
         return false;
     }
 
     const KFileItem item = items.first();
     return item.isFile() && !item.localPath().isEmpty() && item.isReadable() && !item.isDesktopFile() && !item.isLink();
 }
 
 void KChecksumsPlugin::slotInvalidateCache()
 {
     d->m_md5 = QString();
     d->m_sha1 = QString();
     d->m_sha256 = QString();
 }
 
 void KChecksumsPlugin::slotShowMd5()
 {
     auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget);
     label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
 
     d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.md5Button, label);
     d->m_ui.md5Button->hide();
 
     showChecksum(QCryptographicHash::Md5, label, d->m_ui.md5CopyButton);
 }
 
 void KChecksumsPlugin::slotShowSha1()
 {
     auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget);
     label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
 
     d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.sha1Button, label);
     d->m_ui.sha1Button->hide();
 
     showChecksum(QCryptographicHash::Sha1, label, d->m_ui.sha1CopyButton);
 }
 
 void KChecksumsPlugin::slotShowSha256()
 {
     auto label = new QLabel(i18nc("@action:button", "Calculating..."), &d->m_widget);
     label->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
 
     d->m_ui.calculateWidget->layout()->replaceWidget(d->m_ui.sha256Button, label);
     d->m_ui.sha256Button->hide();
 
     showChecksum(QCryptographicHash::Sha256, label, d->m_ui.sha256CopyButton);
 }
 
 void KChecksumsPlugin::slotVerifyChecksum(const QString &input)
 {
     auto algorithm = detectAlgorithm(input);
 
     // Input is not a supported hash algorithm.
     if (algorithm == QCryptographicHash::Md4) {
         if (input.isEmpty()) {
             setDefaultState();
         } else {
             setInvalidChecksumState();
         }
         return;
     }
 
     const QString checksum = cachedChecksum(algorithm);
 
     // Checksum already in cache.
     if (!checksum.isEmpty()) {
         const bool isMatch = (checksum == input);
         if (isMatch) {
             setMatchState();
         } else {
             setMismatchState();
         }
 
         return;
     }
 
     // Calculate checksum in another thread.
     auto futureWatcher = new QFutureWatcher<QString>(this);
     connect(futureWatcher, &QFutureWatcher<QString>::finished, this, [=]() {
 
         const QString checksum = futureWatcher->result();
         futureWatcher->deleteLater();
 
         cacheChecksum(checksum, algorithm);
 
         switch (algorithm) {
         case QCryptographicHash::Md5:
             slotShowMd5();
             break;
         case QCryptographicHash::Sha1:
             slotShowSha1();
             break;
         case QCryptographicHash::Sha256:
             slotShowSha256();
             break;
         default:
             break;
         }
 
         const bool isMatch = (checksum == input);
         if (isMatch) {
             setMatchState();
         } else {
             setMismatchState();
         }
     });
 
     // Notify the user about the background computation.
     setVerifyState();
 
     auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath());
     futureWatcher->setFuture(future);
 }
 
 bool KChecksumsPlugin::isMd5(const QString &input)
 {
     QRegularExpression regex(QStringLiteral("^[a-f0-9]{32}$"));
     return regex.match(input).hasMatch();
 }
 
 bool KChecksumsPlugin::isSha1(const QString &input)
 {
     QRegularExpression regex(QStringLiteral("^[a-f0-9]{40}$"));
     return regex.match(input).hasMatch();
 }
 
 bool KChecksumsPlugin::isSha256(const QString &input)
 {
     QRegularExpression regex(QStringLiteral("^[a-f0-9]{64}$"));
     return regex.match(input).hasMatch();
 }
 
 QString KChecksumsPlugin::computeChecksum(QCryptographicHash::Algorithm algorithm, const QString &path)
 {
     QFile file(path);
     if (!file.open(QIODevice::ReadOnly)) {
         return QString();
     }
 
     QCryptographicHash hash(algorithm);
     hash.addData(&file);
 
     return QString::fromLatin1(hash.result().toHex());
 }
 
 QCryptographicHash::Algorithm KChecksumsPlugin::detectAlgorithm(const QString &input)
 {
     if (isMd5(input)) {
         return QCryptographicHash::Md5;
     }
 
     if (isSha1(input)) {
         return QCryptographicHash::Sha1;
     }
 
     if (isSha256(input)) {
         return QCryptographicHash::Sha256;
     }
 
     // Md4 used as negative error code.
     return QCryptographicHash::Md4;
 }
 
 void KChecksumsPlugin::setDefaultState()
 {
     QColor defaultColor = d->m_widget.palette().color(QPalette::Base);
 
     QPalette palette = d->m_widget.palette();
     palette.setColor(QPalette::Base, defaultColor);
 
     d->m_ui.feedbackLabel->hide();
     d->m_ui.lineEdit->setPalette(palette);
     d->m_ui.lineEdit->setToolTip(QString());
 }
 
 void KChecksumsPlugin::setInvalidChecksumState()
 {
     KColorScheme colorScheme(QPalette::Active, KColorScheme::View);
     QColor warningColor = colorScheme.background(KColorScheme::NegativeBackground).color();
 
     QPalette palette = d->m_widget.palette();
     palette.setColor(QPalette::Base, warningColor);
 
     d->m_ui.feedbackLabel->setText(i18n("Invalid checksum."));
     d->m_ui.feedbackLabel->show();
     d->m_ui.lineEdit->setPalette(palette);
     d->m_ui.lineEdit->setToolTip(i18nc("@info:tooltip", "The given input is not a valid MD5, SHA1 or SHA256 checksum."));
 }
 
 void KChecksumsPlugin::setMatchState()
 {
     KColorScheme colorScheme(QPalette::Active, KColorScheme::View);
     QColor positiveColor = colorScheme.background(KColorScheme::PositiveBackground).color();
 
     QPalette palette = d->m_widget.palette();
     palette.setColor(QPalette::Base, positiveColor);
 
     d->m_ui.feedbackLabel->setText(i18n("Checksums match."));
     d->m_ui.feedbackLabel->show();
     d->m_ui.lineEdit->setPalette(palette);
     d->m_ui.lineEdit->setToolTip(i18nc("@info:tooltip", "The computed checksum and the expected checksum match."));
 }
 
 void KChecksumsPlugin::setMismatchState()
 {
     KColorScheme colorScheme(QPalette::Active, KColorScheme::View);
     QColor warningColor = colorScheme.background(KColorScheme::NegativeBackground).color();
 
     QPalette palette = d->m_widget.palette();
     palette.setColor(QPalette::Base, warningColor);
 
     d->m_ui.feedbackLabel->setText(i18n("<p>Checksums do not match.</p>"
                                         "This may be due to a faulty download. Try re-downloading the file.<br/>"
                                         "If the verification still fails, contact the source of the file."));
     d->m_ui.feedbackLabel->show();
     d->m_ui.lineEdit->setPalette(palette);
     d->m_ui.lineEdit->setToolTip(i18nc("@info:tooltip", "The computed checksum and the expected checksum differ."));
 }
 
 void KChecksumsPlugin::setVerifyState()
 {
     // Users can paste a checksum at any time, so reset to default.
     setDefaultState();
 
     d->m_ui.feedbackLabel->setText(i18nc("notify the user about a computation in the background",  "Verifying checksum..."));
     d->m_ui.feedbackLabel->show();
 }
 
 void KChecksumsPlugin::showChecksum(QCryptographicHash::Algorithm algorithm, QLabel *label, QPushButton *copyButton)
 {
     const QString checksum = cachedChecksum(algorithm);
 
     // Checksum in cache, nothing else to do.
     if (!checksum.isEmpty()) {
         label->setText(checksum);
         return;
     }
 
     // Calculate checksum in another thread.
     auto futureWatcher = new QFutureWatcher<QString>(this);
     connect(futureWatcher, &QFutureWatcher<QString>::finished, this, [=]() {
         const QString checksum = futureWatcher->result();
         futureWatcher->deleteLater();
 
         label->setText(checksum);
         cacheChecksum(checksum, algorithm);
 
         copyButton->show();
     });
 
     auto future = QtConcurrent::run(&KChecksumsPlugin::computeChecksum, algorithm, properties->item().localPath());
     futureWatcher->setFuture(future);
 }
 
 QString KChecksumsPlugin::cachedChecksum(QCryptographicHash::Algorithm algorithm) const
 {
     switch (algorithm) {
     case QCryptographicHash::Md5:
         return d->m_md5;
     case QCryptographicHash::Sha1:
         return d->m_sha1;
     case QCryptographicHash::Sha256:
         return d->m_sha256;
     default:
         break;
     }
 
     return QString();
 }
 
 void KChecksumsPlugin::cacheChecksum(const QString &checksum, QCryptographicHash::Algorithm algorithm)
 {
     switch (algorithm) {
     case QCryptographicHash::Md5:
         d->m_md5 = checksum;
         break;
     case QCryptographicHash::Sha1:
         d->m_sha1 = checksum;
         break;
     case QCryptographicHash::Sha256:
         d->m_sha256 = checksum;
         break;
     default:
         return;
     }
 }
 
 class KUrlPropsPlugin::KUrlPropsPluginPrivate
 {
 public:
     KUrlPropsPluginPrivate()
     {
     }
     ~KUrlPropsPluginPrivate()
     {
     }
 
     QFrame *m_frame;
     KUrlRequester *URLEdit;
     QString URLStr;
     bool fileNameReadOnly = false;
 };
 
 KUrlPropsPlugin::KUrlPropsPlugin(KPropertiesDialog *_props)
     : KPropertiesDialogPlugin(_props), d(new KUrlPropsPluginPrivate)
 {
     d->m_frame = new QFrame();
     properties->addPage(d->m_frame, i18n("U&RL"));
     QVBoxLayout *layout = new QVBoxLayout(d->m_frame);
-    layout->setMargin(0);
+    layout->setContentsMargins(0, 0, 0, 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, &KUrlRequester::textChanged,
             this, &KPropertiesDialogPlugin::changed);
 
     layout->addStretch(1);
 }
 
 KUrlPropsPlugin::~KUrlPropsPlugin()
 {
     delete d;
 }
 
 void KUrlPropsPlugin::setFileNameReadOnly(bool ro)
 {
     d->fileNameReadOnly = ro;
 }
 
 // QString KUrlPropsPlugin::tabName () const
 // {
 //   return i18n ("U&RL");
 // }
 
 bool KUrlPropsPlugin::supports(const KFileItemList &_items)
 {
     if (_items.count() != 1) {
         return false;
     }
     const KFileItem item = _items.first();
     // check if desktop file
     if (!item.isDesktopFile()) {
         return false;
     }
 
     // open file and check type
     bool isLocal;
     QUrl url = item.mostLocalUrl(isLocal);
     if (!isLocal) {
         return false;
     }
 
     KDesktopFile config(url.toLocalFile());
     return config.hasLinkType();
 }
 
 void KUrlPropsPlugin::applyChanges()
 {
     KIO::StatJob *job = KIO::mostLocalUrl(properties->url());
     KJobWidgets::setWindow(job, properties);
     job->exec();
     const QUrl url = job->mostLocalUrl();
 
     if (!url.isLocalFile()) {
         KMessageBox::sorry(nullptr, i18n("Could not save properties. Only entries on local file systems are supported."));
         return;
     }
 
     QString path = url.toLocalFile();
     QFile f(path);
     if (!f.open(QIODevice::ReadWrite)) {
         KMessageBox::sorry(nullptr, i18n("<qt>Could not save properties. You do not have "
                                    "sufficient access to write to <b>%1</b>.</qt>", path));
         return;
     }
     f.close();
 
     KDesktopFile config(path);
     KConfigGroup dg = config.desktopGroup();
     dg.writeEntry("Type", QStringLiteral("Link"));
     dg.writePathEntry("URL", d->URLEdit->url().toString());
     // Users can't create a Link .desktop file with a Name field,
     // but distributions can. Update the Name field in that case,
     // if the file name could have been changed.
     if (!d->fileNameReadOnly && dg.hasKey("Name")) {
         const QString nameStr = nameFromFileName(properties->url().fileName());
         dg.writeEntry("Name", nameStr);
         dg.writeEntry("Name", nameStr, KConfigBase::Persistent | KConfigBase::Localized);
 
     }
 }
 
 /* ----------------------------------------------------
  *
  * KDevicePropsPlugin
  *
  * -------------------------------------------------- */
 
 class KDevicePropsPlugin::KDevicePropsPluginPrivate
 {
 public:
     KDevicePropsPluginPrivate()
     {
     }
     ~KDevicePropsPluginPrivate()
     {
     }
 
     bool isMounted() const
     {
         const QString dev = device->currentText();
         return !dev.isEmpty() && KMountPoint::currentMountPoints().findByDevice(dev);
     }
 
     QFrame *m_frame;
     QStringList mountpointlist;
     QLabel *m_freeSpaceText;
     QLabel *m_freeSpaceLabel;
     QProgressBar *m_freeSpaceBar;
 
     KComboBox *device;
     QLabel *mountpoint;
     QCheckBox *readonly;
 
     QStringList m_devicelist;
 };
 
 KDevicePropsPlugin::KDevicePropsPlugin(KPropertiesDialog *_props) : KPropertiesDialogPlugin(_props), d(new KDevicePropsPluginPrivate)
 {
     d->m_frame = new QFrame();
     properties->addPage(d->m_frame, i18n("De&vice"));
 
     QStringList devices;
     const KMountPoint::List mountPoints = KMountPoint::possibleMountPoints();
 
     for (KMountPoint::List::ConstIterator it = mountPoints.begin();
             it != mountPoints.end(); ++it) {
         const KMountPoint::Ptr mp = (*it);
         QString mountPoint = mp->mountPoint();
         QString device = mp->mountedFrom();
         // qDebug()<<"mountPoint :"<<mountPoint<<" device :"<<device<<" mp->mountType() :"<<mp->mountType();
 
         if ((mountPoint != QLatin1String("-")) && (mountPoint != QLatin1String("none")) && !mountPoint.isEmpty()
                 && device != QLatin1String("none")) {
             devices.append(device + QLatin1String(" (")
                            + mountPoint + QLatin1Char(')'));
             d->m_devicelist.append(device);
             d->mountpointlist.append(mountPoint);
         }
     }
 
     QGridLayout *layout = new QGridLayout(d->m_frame);
 
-    layout->setMargin(0);
+    layout->setContentsMargins(0, 0, 0, 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, QOverload<int>::of(&QComboBox::activated),
             this, &KDevicePropsPlugin::slotActivated);
 
     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, QOverload<int>::of(&QComboBox::activated),
             this, &KPropertiesDialogPlugin::changed);
     connect(d->device, &QComboBox::currentTextChanged,
             this, &KPropertiesDialogPlugin::changed);
     connect(d->readonly, &QAbstractButton::toggled,
             this, &KPropertiesDialogPlugin::changed);
 
     connect(d->device, &QComboBox::currentTextChanged,
             this, &KDevicePropsPlugin::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, &QLineEdit::textChanged, this, &KPropertiesDialogPlugin::changed);
     connect(d->w->genNameEdit, &QLineEdit::textChanged, this, &KPropertiesDialogPlugin::changed);
     connect(d->w->commentEdit, &QLineEdit::textChanged, this, &KPropertiesDialogPlugin::changed);
     connect(d->w->commandEdit, &QLineEdit::textChanged, this, &KPropertiesDialogPlugin::changed);
     connect(d->w->pathEdit, &KUrlRequester::textChanged, this, &KPropertiesDialogPlugin::changed);
 
     connect(d->w->browseButton, &QAbstractButton::clicked, this, &KDesktopPropsPlugin::slotBrowseExec);
     connect(d->w->addFiletypeButton, &QAbstractButton::clicked, this, &KDesktopPropsPlugin::slotAddFiletype);
     connect(d->w->delFiletypeButton, &QAbstractButton::clicked, this, &KDesktopPropsPlugin::slotDelFiletype);
     connect(d->w->advancedButton, &QAbstractButton::clicked, this, &KDesktopPropsPlugin::slotAdvanced);
 
     enum DiscreteGpuCheck { NotChecked, Present, Absent };
     static DiscreteGpuCheck s_gpuCheck = NotChecked;
 
     if (s_gpuCheck == NotChecked) {
         // Check whether we have a discrete gpu
         bool hasDiscreteGpu = false;
         QDBusInterface iface(QStringLiteral("org.kde.Solid.PowerManagement"),
                              QStringLiteral("/org/kde/Solid/PowerManagement"),
                              QStringLiteral("org.kde.Solid.PowerManagement"),
                              QDBusConnection::sessionBus());
         if (iface.isValid()) {
             QDBusReply<bool> reply = iface.call(QStringLiteral("hasDualGpu"));
             if (reply.isValid()) {
                 hasDiscreteGpu = reply.value();
             }
         }
 
         s_gpuCheck = hasDiscreteGpu ? Present : Absent;
     }
 
     d->m_hasDiscreteGpuBool = s_gpuCheck == Present;
 
     // now populate the page
 
     KIO::StatJob *job = KIO::mostLocalUrl(_props->url());
     KJobWidgets::setWindow(job, _props);
     job->exec();
     QUrl url = job->mostLocalUrl();
 
     if (!url.isLocalFile()) {
         return;
     }
 
     d->m_origDesktopFile = url.toLocalFile();
 
     QFile f(d->m_origDesktopFile);
     if (!f.open(QIODevice::ReadOnly)) {
         return;
     }
     f.close();
 
     KDesktopFile  _config(d->m_origDesktopFile);
     KConfigGroup config = _config.desktopGroup();
     QString nameStr = _config.readName();
     QString genNameStr = _config.readGenericName();
     QString commentStr = _config.readComment();
     QString commandStr = config.readEntry("Exec", QString());
 
     d->m_origCommandStr = commandStr;
     QString pathStr = config.readEntry("Path", QString());   // not readPathEntry, see kservice.cpp
     d->m_terminalBool = config.readEntry("Terminal", false);
     d->m_terminalOptionStr = config.readEntry("TerminalOptions");
     d->m_suidBool = config.readEntry("X-KDE-SubstituteUID", false);
     d->m_suidUserStr = config.readEntry("X-KDE-Username");
     if (d->m_hasDiscreteGpuBool) {
         d->m_runOnDiscreteGpuBool = config.readEntry("X-KDE-RunOnDiscreteGpu", false);
     }
     if (config.hasKey("StartupNotify")) {
         d->m_startupBool = config.readEntry("StartupNotify", true);
     } else {
         d->m_startupBool = config.readEntry("X-KDE-StartupNotify", true);
     }
     d->m_dbusStartupType = config.readEntry("X-DBUS-StartupType").toLower();
     // ### should there be a GUI for this setting?
     // At least we're copying it over to the local file, to avoid side effects (#157853)
     d->m_dbusServiceName = config.readEntry("X-DBUS-ServiceName");
 
     const QStringList mimeTypes = config.readXdgListEntry("MimeType");
 
     if (nameStr.isEmpty() || bKDesktopMode) {
         // We'll use the file name if no name is specified
         // because we _need_ a Name for a valid file.
         // But let's do it in apply, not here, so that we pick up the right name.
         setDirty();
     }
     if (!bKDesktopMode) {
         d->w->nameEdit->setText(nameStr);
     }
 
     d->w->genNameEdit->setText(genNameStr);
     d->w->commentEdit->setText(commentStr);
     d->w->commandEdit->setText(commandStr);
     d->w->pathEdit->lineEdit()->setText(pathStr);
 
     // was: d->w->filetypeList->setFullWidth(true);
     //  d->w->filetypeList->header()->setStretchEnabled(true, d->w->filetypeList->columns()-1);
 
     for (QStringList::ConstIterator it = mimeTypes.begin();
             it != mimeTypes.end();) {
         QMimeType p = db.mimeTypeForName(*it);
         ++it;
         QString preference;
         if (it != mimeTypes.end()) {
             bool numeric;
             (*it).toInt(&numeric);
             if (numeric) {
                 preference = *it;
                 ++it;
             }
         }
         if (p.isValid()) {
             QTreeWidgetItem *item = new QTreeWidgetItem();
             item->setText(0, p.name());
             item->setText(1, p.comment());
             item->setText(2, preference);
             d->w->filetypeList->addTopLevelItem(item);
         }
     }
     d->w->filetypeList->resizeColumnToContents(0);
 
 }
 
 KDesktopPropsPlugin::~KDesktopPropsPlugin()
 {
     delete d;
 }
 
 void KDesktopPropsPlugin::slotAddFiletype()
 {
     QMimeDatabase db;
     KMimeTypeChooserDialog dlg(i18n("Add File Type for %1", properties->url().fileName()),
                                i18n("Select one or more file types to add:"),
                                QStringList(), // no preselected mimetypes
                                QString(),
                                QStringList(),
                                KMimeTypeChooser::Comments | KMimeTypeChooser::Patterns,
                                d->m_frame);
 
     if (dlg.exec() == QDialog::Accepted) {
         foreach (const QString &mimetype, dlg.chooser()->mimeTypes()) {
             QMimeType p = db.mimeTypeForName(mimetype);
             if (!p.isValid()) {
                 continue;
             }
 
             bool found = false;
             int count = d->w->filetypeList->topLevelItemCount();
             for (int i = 0; !found && i < count; ++i) {
                 if (d->w->filetypeList->topLevelItem(i)->text(0) == mimetype) {
                     found = true;
                 }
             }
             if (!found) {
                 QTreeWidgetItem *item = new QTreeWidgetItem();
                 item->setText(0, p.name());
                 item->setText(1, p.comment());
                 d->w->filetypeList->addTopLevelItem(item);
             }
             d->w->filetypeList->resizeColumnToContents(0);
         }
     }
     emit changed();
 }
 
 void KDesktopPropsPlugin::slotDelFiletype()
 {
     QTreeWidgetItem *cur = d->w->filetypeList->currentItem();
     if (cur) {
         delete cur;
         emit changed();
     }
 }
 
 void KDesktopPropsPlugin::checkCommandChanged()
 {
     if (KIO::DesktopExecParser::executableName(d->w->commandEdit->text()) !=
             KIO::DesktopExecParser::executableName(d->m_origCommandStr)) {
         d->m_origCommandStr = d->w->commandEdit->text();
         d->m_dbusStartupType.clear(); // Reset
         d->m_dbusServiceName.clear();
     }
 }
 
 void KDesktopPropsPlugin::applyChanges()
 {
     // qDebug();
     KIO::StatJob *job = KIO::mostLocalUrl(properties->url());
     KJobWidgets::setWindow(job, properties);
     job->exec();
     const QUrl url = job->mostLocalUrl();
 
     if (!url.isLocalFile()) {
         KMessageBox::sorry(nullptr, i18n("Could not save properties. Only entries on local file systems are supported."));
         return;
     }
 
     const QString path(url.toLocalFile());
 
     // make sure the directory exists
     QDir().mkpath(QFileInfo(path).absolutePath());
     QFile f(path);
     if (!f.open(QIODevice::ReadWrite)) {
         KMessageBox::sorry(nullptr, i18n("<qt>Could not save properties. You do not have "
                                    "sufficient access to write to <b>%1</b>.</qt>", path));
         return;
     }
     f.close();
 
     // If the command is changed we reset certain settings that are strongly
     // coupled to the command.
     checkCommandChanged();
 
     KDesktopFile origConfig(d->m_origDesktopFile);
     QScopedPointer<KDesktopFile> _config(origConfig.copyTo(path));
     KConfigGroup config = _config->desktopGroup();
     config.writeEntry("Type", QStringLiteral("Application"));
     config.writeEntry("Comment", d->w->commentEdit->text());
     config.writeEntry("Comment", d->w->commentEdit->text(), KConfigGroup::Persistent | KConfigGroup::Localized); // for compat
     config.writeEntry("GenericName", d->w->genNameEdit->text());
     config.writeEntry("GenericName", d->w->genNameEdit->text(), KConfigGroup::Persistent | KConfigGroup::Localized); // for compat
     config.writeEntry("Exec", d->w->commandEdit->text());
     config.writeEntry("Path", d->w->pathEdit->lineEdit()->text());   // not writePathEntry, see kservice.cpp
 
     // Write mimeTypes
     QStringList mimeTypes;
     int count = d->w->filetypeList->topLevelItemCount();
     for (int i = 0; i < count; ++i) {
         QTreeWidgetItem *item = d->w->filetypeList->topLevelItem(i);
         QString preference = item->text(2);
         mimeTypes.append(item->text(0));
         if (!preference.isEmpty()) {
             mimeTypes.append(preference);
         }
     }
 
     // qDebug() << mimeTypes;
     config.writeXdgListEntry("MimeType", mimeTypes);
 
     if (!d->w->nameEdit->isHidden()) {
         QString nameStr = d->w->nameEdit->text();
         config.writeEntry("Name", nameStr);
         config.writeEntry("Name", nameStr, KConfigGroup::Persistent | KConfigGroup::Localized);
     }
 
     config.writeEntry("Terminal", d->m_terminalBool);
     config.writeEntry("TerminalOptions", d->m_terminalOptionStr);
     config.writeEntry("X-KDE-SubstituteUID", d->m_suidBool);
     config.writeEntry("X-KDE-Username", d->m_suidUserStr);
     if (d->m_hasDiscreteGpuBool) {
         config.writeEntry("X-KDE-RunOnDiscreteGpu", d->m_runOnDiscreteGpuBool);
     }
     config.writeEntry("StartupNotify", d->m_startupBool);
     config.writeEntry("X-DBUS-StartupType", d->m_dbusStartupType);
     config.writeEntry("X-DBUS-ServiceName", d->m_dbusServiceName);
     config.sync();
 
     // KSycoca update needed?
     bool updateNeeded = !relativeAppsLocation(path).isEmpty();
     if (updateNeeded) {
         KBuildSycocaProgressDialog::rebuildKSycoca(d->m_frame);
     }
 }
 
 void KDesktopPropsPlugin::slotBrowseExec()
 {
     QUrl f = QFileDialog::getOpenFileUrl(d->m_frame);
     if (f.isEmpty()) {
         return;
     }
 
     if (!f.isLocalFile()) {
         KMessageBox::sorry(d->m_frame, i18n("Only executables on local file systems are supported."));
         return;
     }
 
     QString path = f.toLocalFile();
     path = KShell::quoteArg(path);
     d->w->commandEdit->setText(path);
 }
 
 void KDesktopPropsPlugin::slotAdvanced()
 {
     QDialog dlg(d->m_frame);
     dlg.setObjectName(QStringLiteral("KPropertiesDesktopAdv"));
     dlg.setModal(true);
     dlg.setWindowTitle(i18n("Advanced Options for %1", properties->url().fileName()));
 
     Ui_KPropertiesDesktopAdvBase w;
     QWidget *mainWidget = new QWidget(&dlg);
     w.setupUi(mainWidget);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(&dlg);
     buttonBox->setStandardButtons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     connect(buttonBox, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, &dlg, &QDialog::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, &QLineEdit::textChanged,
             this, &KPropertiesDialogPlugin::changed);
     connect(w.terminalCloseCheck, &QAbstractButton::toggled,
             this, &KPropertiesDialogPlugin::changed);
     connect(w.terminalCheck, &QAbstractButton::toggled,
             this, &KPropertiesDialogPlugin::changed);
     connect(w.suidCheck, &QAbstractButton::toggled,
             this, &KPropertiesDialogPlugin::changed);
     connect(w.suidEdit, &QLineEdit::textChanged,
             this, &KPropertiesDialogPlugin::changed);
     connect(w.discreteGpuCheck, &QAbstractButton::toggled,
             this, &KPropertiesDialogPlugin::changed);
     connect(w.startupInfoCheck, &QAbstractButton::toggled,
             this, &KPropertiesDialogPlugin::changed);
     connect(w.dbusCombo, QOverload<int>::of(&QComboBox::activated),
             this, &KPropertiesDialogPlugin::changed);
 
     if (dlg.exec() == QDialog::Accepted) {
         d->m_terminalOptionStr = w.terminalEdit->text().trimmed();
         d->m_terminalBool = w.terminalCheck->isChecked();
         d->m_suidBool = w.suidCheck->isChecked();
         d->m_suidUserStr = w.suidEdit->text().trimmed();
         if (d->m_hasDiscreteGpuBool) {
             d->m_runOnDiscreteGpuBool = w.discreteGpuCheck->isChecked();
         }
         d->m_startupBool = w.startupInfoCheck->isChecked();
 
         if (w.terminalCloseCheck->isChecked()) {
             d->m_terminalOptionStr.append(QLatin1String(" --noclose"));
         }
 
         switch (w.dbusCombo->currentIndex()) {
         case 1:  d->m_dbusStartupType = QStringLiteral("multi"); break;
         case 2:  d->m_dbusStartupType = QStringLiteral("unique"); break;
         case 3:  d->m_dbusStartupType = QStringLiteral("wait"); break;
         default: d->m_dbusStartupType = QStringLiteral("none"); break;
         }
     }
 }
 
 bool KDesktopPropsPlugin::supports(const KFileItemList &_items)
 {
     if (_items.count() != 1) {
         return false;
     }
 
     const KFileItem item = _items.first();
 
     // check if desktop file
     if (!item.isDesktopFile()) {
         return false;
     }
 
     // open file and check type
     bool isLocal;
     QUrl url = item.mostLocalUrl(isLocal);
     if (!isLocal) {
         return false;
     }
 
     KDesktopFile config(url.toLocalFile());
     return config.hasApplicationType() &&
            KAuthorized::authorize(QStringLiteral("run_desktop_files")) &&
            KAuthorized::authorize(QStringLiteral("shell_access"));
 }
 
 #include "moc_kpropertiesdialog.cpp"
 #include "moc_kpropertiesdialog_p.cpp"
diff --git a/src/widgets/kurlrequester.cpp b/src/widgets/kurlrequester.cpp
index 53fdd671..0e8d9009 100644
--- a/src/widgets/kurlrequester.cpp
+++ b/src/widgets/kurlrequester.cpp
@@ -1,673 +1,673 @@
 /* This file is part of the KDE libraries
     Copyright (C) 1999,2000,2001 Carsten Pfeiffer <pfeiffer@kde.org>
     Copyright (C) 2013           Teo Mrnjavac <teo@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License version 2, as published by the Free Software Foundation.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "kurlrequester.h"
 #include "kio_widgets_debug.h"
 #include "../pathhelpers_p.h"
 
 #include <kcombobox.h>
 #include <kdragwidgetdecorator.h>
 #include <klineedit.h>
 #include <klocalizedstring.h>
 #include <kprotocolmanager.h>
 #include <kurlcompletion.h>
 
 #include <QAction>
 #include <QApplication>
 #include <QDebug>
 #include <QDrag>
 #include <QEvent>
 #include <QKeySequence>
 #include <QHBoxLayout>
 #include <QMimeData>
 #include <QtGlobal>
 
 class KUrlDragPushButton : public QPushButton
 {
     Q_OBJECT
 public:
     explicit KUrlDragPushButton(QWidget *parent)
         : QPushButton(parent)
     {
         new DragDecorator(this);
     }
     ~KUrlDragPushButton() {}
 
     void setURL(const QUrl &url)
     {
         m_urls.clear();
         m_urls.append(url);
     }
 
 private:
     class DragDecorator : public KDragWidgetDecoratorBase
     {
     public:
         explicit DragDecorator(KUrlDragPushButton *button)
             : KDragWidgetDecoratorBase(button), m_button(button) {}
 
     protected:
         QDrag *dragObject() override
         {
             if (m_button->m_urls.isEmpty()) {
                 return nullptr;
             }
 
             QDrag *drag = new QDrag(m_button);
             QMimeData *mimeData = new QMimeData;
             mimeData->setUrls(m_button->m_urls);
             drag->setMimeData(mimeData);
             return drag;
         }
 
     private:
         KUrlDragPushButton *m_button;
     };
 
     QList<QUrl> m_urls;
 };
 
 class Q_DECL_HIDDEN KUrlRequester::KUrlRequesterPrivate
 {
 public:
     explicit KUrlRequesterPrivate(KUrlRequester *parent)
         : m_parent(parent),
           edit(nullptr),
           combo(nullptr),
           fileDialogMode(KFile::File | KFile::ExistingOnly | KFile::LocalOnly),
           fileDialogAcceptMode(QFileDialog::AcceptOpen)
     {
     }
 
     ~KUrlRequesterPrivate()
     {
         delete myCompletion;
         delete myFileDialog;
     }
 
     void init();
 
     void setText(const QString &text)
     {
         if (combo) {
             if (combo->isEditable()) {
                 combo->setEditText(text);
             } else {
                 int i = combo->findText(text);
                 if (i == -1) {
                     combo->addItem(text);
                     combo->setCurrentIndex(combo->count() - 1);
                 } else {
                     combo->setCurrentIndex(i);
                 }
             }
         } else {
             edit->setText(text);
         }
     }
 
     void connectSignals(KUrlRequester *receiver)
     {
         if (combo) {
             connect(combo, &QComboBox::currentTextChanged,
                     receiver, &KUrlRequester::textChanged);
             connect(combo, &QComboBox::editTextChanged,
                     receiver, &KUrlRequester::textEdited);
 
             connect(combo, QOverload<>::of(&KComboBox::returnPressed),
                     receiver, QOverload<>::of(&KUrlRequester::returnPressed));
             connect(combo, QOverload<const QString&>::of(&KComboBox::returnPressed),
                     receiver, QOverload<const QString&>::of(&KUrlRequester::returnPressed));
         } else if (edit) {
             connect(edit, &QLineEdit::textChanged,
                     receiver, &KUrlRequester::textChanged);
             connect(edit, &QLineEdit::textEdited,
                     receiver, &KUrlRequester::textEdited);
 
             connect(edit, QOverload<>::of(&QLineEdit::returnPressed),
                     receiver, QOverload<>::of(&KUrlRequester::returnPressed));
 
             if (auto kline = qobject_cast<KLineEdit*>(edit)) {
                 connect(kline, QOverload<const QString&>::of(&KLineEdit::returnPressed),
                         receiver, QOverload<const QString&>::of(&KUrlRequester::returnPressed));
             }
         }
     }
 
     void setCompletionObject(KCompletion *comp)
     {
         if (combo) {
             combo->setCompletionObject(comp);
         } else {
             edit->setCompletionObject(comp);
         }
     }
 
     void updateCompletionStartDir(const QUrl &newStartDir)
     {
         myCompletion->setDir(newStartDir);
     }
 
 
     QString text() const
     {
         return combo ? combo->currentText() : edit->text();
     }
 
     /**
      * replaces ~user or $FOO, if necessary
      * if text() is a relative path, make it absolute using startDir()
      */
     QUrl url() const
     {
         const QString txt = text();
         KUrlCompletion *comp;
         if (combo) {
             comp = qobject_cast<KUrlCompletion *>(combo->completionObject());
         } else {
             comp = qobject_cast<KUrlCompletion *>(edit->completionObject());
         }
 
         QString enteredPath;
         if (comp)
             enteredPath = comp->replacedPath(txt);
         else
             enteredPath = txt;
 
         if (QDir::isAbsolutePath(enteredPath)) {
             return QUrl::fromLocalFile(enteredPath);
         }
 
         const QUrl enteredUrl = QUrl(enteredPath); // absolute or relative
         if (enteredUrl.isRelative() && !txt.isEmpty()) {
             QUrl finalUrl(m_startDir);
             finalUrl.setPath(concatPaths(finalUrl.path(), enteredPath));
             return finalUrl;
         } else {
             return enteredUrl;
         }
     }
 
     static void applyFileMode(QFileDialog *dlg, KFile::Modes m, QFileDialog::AcceptMode acceptMode)
     {
         QFileDialog::FileMode fileMode;
         if (m & KFile::Directory) {
             fileMode = QFileDialog::Directory;
             if ((m & KFile::File) == 0 &&
                     (m & KFile::Files) == 0) {
                 dlg->setOption(QFileDialog::ShowDirsOnly, true);
             }
         } else if (m & KFile::Files &&
                    m & KFile::ExistingOnly) {
             fileMode = QFileDialog::ExistingFiles;
         } else if (m & KFile::File &&
                    m & KFile::ExistingOnly) {
             fileMode = QFileDialog::ExistingFile;
         } else {
             fileMode = QFileDialog::AnyFile;
         }
 
         dlg->setFileMode(fileMode);
         dlg->setAcceptMode(acceptMode);
     }
 
     // Converts from "*.foo *.bar|Comment" to "Comment (*.foo *.bar)"
     QStringList kToQFilters(const QString &filters) const
     {
         QStringList qFilters = filters.split(QLatin1Char('\n'), QString::SkipEmptyParts);
 
         for (QStringList::iterator it = qFilters.begin(); it != qFilters.end(); ++it) {
             int sep = it->indexOf(QLatin1Char('|'));
             const QStringRef globs = it->leftRef(sep);
             const QStringRef desc  = it->midRef(sep + 1);
             *it = desc + QLatin1String(" (") + globs + QLatin1Char(')');
         }
 
         return qFilters;
     }
 
     QUrl getDirFromFileDialog(const QUrl &openUrl) const
     {
         return QFileDialog::getExistingDirectoryUrl(m_parent, QString(), openUrl, QFileDialog::ShowDirsOnly);
     }
 
     // slots
     void _k_slotUpdateUrl();
     void _k_slotOpenDialog();
     void _k_slotFileDialogAccepted();
 
     QUrl m_startDir;
     bool m_startDirCustomized;
     KUrlRequester * const m_parent; // TODO: rename to 'q'
     KLineEdit *edit;
     KComboBox *combo;
     KFile::Modes fileDialogMode;
     QFileDialog::AcceptMode fileDialogAcceptMode;
     QString fileDialogFilter;
     QStringList mimeTypeFilters;
     KEditListWidget::CustomEditor editor;
     KUrlDragPushButton *myButton;
     QFileDialog *myFileDialog;
     KUrlCompletion *myCompletion;
     Qt::WindowModality fileDialogModality;
 };
 
 KUrlRequester::KUrlRequester(QWidget *editWidget, QWidget *parent)
     : QWidget(parent), d(new KUrlRequesterPrivate(this))
 {
     // must have this as parent
     editWidget->setParent(this);
     d->combo = qobject_cast<KComboBox *>(editWidget);
     d->edit = qobject_cast<KLineEdit *>(editWidget);
     if (d->edit) {
         d->edit->setClearButtonEnabled(true);
     }
 
     d->init();
 }
 
 KUrlRequester::KUrlRequester(QWidget *parent)
     : QWidget(parent), d(new KUrlRequesterPrivate(this))
 {
     d->init();
 }
 
 KUrlRequester::KUrlRequester(const QUrl &url, QWidget *parent)
     : QWidget(parent), d(new KUrlRequesterPrivate(this))
 {
     d->init();
     setUrl(url);
 }
 
 KUrlRequester::~KUrlRequester()
 {
     delete d;
 }
 
 void KUrlRequester::KUrlRequesterPrivate::init()
 {
     myFileDialog = nullptr;
     fileDialogModality = Qt::ApplicationModal;
 
     if (!combo && !edit) {
         edit = new KLineEdit(m_parent);
         edit->setClearButtonEnabled(true);
     }
 
     QWidget *widget = combo ? static_cast<QWidget *>(combo) : static_cast<QWidget *>(edit);
 
     QHBoxLayout *topLayout = new QHBoxLayout(m_parent);
-    topLayout->setMargin(0);
+    topLayout->setContentsMargins(0, 0, 0, 0);
     topLayout->setSpacing(-1); // use default spacing
     topLayout->addWidget(widget);
 
     myButton = new KUrlDragPushButton(m_parent);
     myButton->setIcon(QIcon::fromTheme(QStringLiteral("document-open")));
     int buttonSize = myButton->sizeHint().expandedTo(widget->sizeHint()).height();
     myButton->setFixedSize(buttonSize, buttonSize);
     myButton->setToolTip(i18n("Open file dialog"));
 
     connect(myButton, SIGNAL(pressed()), m_parent, SLOT(_k_slotUpdateUrl()));
 
     widget->installEventFilter(m_parent);
     m_parent->setFocusProxy(widget);
     m_parent->setFocusPolicy(Qt::StrongFocus);
     topLayout->addWidget(myButton);
 
     connectSignals(m_parent);
     connect(myButton, SIGNAL(clicked()), m_parent, SLOT(_k_slotOpenDialog()));
 
     m_startDir = QUrl::fromLocalFile(QDir::currentPath());
     m_startDirCustomized = false;
 
     myCompletion = new KUrlCompletion();
     updateCompletionStartDir(m_startDir);
 
     setCompletionObject(myCompletion);
 
     QAction *openAction = new QAction(m_parent);
     openAction->setShortcut(QKeySequence::Open);
     m_parent->connect(openAction, SIGNAL(triggered(bool)), SLOT(_k_slotOpenDialog()));
 }
 
 void KUrlRequester::setUrl(const QUrl &url)
 {
     d->setText(url.toDisplayString(QUrl::PreferLocalFile));
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 void KUrlRequester::setPath(const QString &path)
 {
     d->setText(path);
 }
 #endif
 
 void KUrlRequester::setText(const QString &text)
 {
     d->setText(text);
 }
 
 void KUrlRequester::setStartDir(const QUrl &startDir)
 {
     d->m_startDir = startDir;
     d->m_startDirCustomized = true;
     d->updateCompletionStartDir(startDir);
 }
 
 void KUrlRequester::changeEvent(QEvent *e)
 {
     if (e->type() == QEvent::WindowTitleChange) {
         if (d->myFileDialog) {
             d->myFileDialog->setWindowTitle(windowTitle());
         }
     }
     QWidget::changeEvent(e);
 }
 
 QUrl KUrlRequester::url() const
 {
     return d->url();
 }
 
 QUrl KUrlRequester::startDir() const
 {
     return d->m_startDir;
 }
 
 QString KUrlRequester::text() const
 {
     return d->text();
 }
 
 void KUrlRequester::KUrlRequesterPrivate::_k_slotOpenDialog()
 {
     if (myFileDialog)
         if (myFileDialog->isVisible()) {
             //The file dialog is already being shown, raise it and exit
             myFileDialog->raise();
             myFileDialog->activateWindow();
             return;
         }
 
     if (((fileDialogMode & KFile::Directory) && !(fileDialogMode & KFile::File)) ||
             /* catch possible fileDialog()->setMode( KFile::Directory ) changes */
             (myFileDialog && (myFileDialog->fileMode() == QFileDialog::Directory &&
                               myFileDialog->testOption(QFileDialog::ShowDirsOnly)))) {
         const QUrl openUrl = (!m_parent->url().isEmpty() && !m_parent->url().isRelative())
                              ? m_parent->url() : m_startDir;
 
         /* FIXME We need a new abstract interface for using KDirSelectDialog in a non-modal way */
 
         QUrl newUrl;
         if (fileDialogMode & KFile::LocalOnly) {
             newUrl = QFileDialog::getExistingDirectoryUrl(m_parent, QString(), openUrl, QFileDialog::ShowDirsOnly, QStringList() << QStringLiteral("file"));
         } else {
             newUrl = getDirFromFileDialog(openUrl);
         }
 
         if (newUrl.isValid()) {
             m_parent->setUrl(newUrl);
             emit m_parent->urlSelected(url());
         }
     } else {
         emit m_parent->openFileDialog(m_parent);
 
         //Creates the fileDialog if it doesn't exist yet
         QFileDialog *dlg = m_parent->fileDialog();
 
         if (!url().isEmpty() && !url().isRelative()) {
             QUrl u(url());
             // If we won't be able to list it (e.g. http), then don't try :)
             if (KProtocolManager::supportsListing(u)) {
                 dlg->selectUrl(u);
             }
         } else {
             dlg->setDirectoryUrl(m_startDir);
         }
 
         dlg->setAcceptMode(fileDialogAcceptMode);
 
         //Update the file dialog window modality
         if (dlg->windowModality() != fileDialogModality) {
             dlg->setWindowModality(fileDialogModality);
         }
 
         if (fileDialogModality == Qt::NonModal) {
             dlg->show();
         } else {
             dlg->exec();
         }
     }
 }
 
 void KUrlRequester::KUrlRequesterPrivate::_k_slotFileDialogAccepted()
 {
     if (!myFileDialog) {
         return;
     }
 
     const QUrl newUrl = myFileDialog->selectedUrls().constFirst();
     if (newUrl.isValid()) {
         m_parent->setUrl(newUrl);
         emit m_parent->urlSelected(url());
         // remember url as defaultStartDir and update startdir for autocompletion
         if (newUrl.isLocalFile() && !m_startDirCustomized) {
             m_startDir = newUrl.adjusted(QUrl::RemoveFilename);
             updateCompletionStartDir(m_startDir);
         }
     }
 }
 
 void KUrlRequester::setMode(KFile::Modes mode)
 {
     Q_ASSERT((mode & KFile::Files) == 0);
     d->fileDialogMode = mode;
     if ((mode & KFile::Directory) && !(mode & KFile::File)) {
         d->myCompletion->setMode(KUrlCompletion::DirCompletion);
     }
 
     if (d->myFileDialog) {
         d->applyFileMode(d->myFileDialog, mode, d->fileDialogAcceptMode);
     }
 }
 
 KFile::Modes KUrlRequester::mode() const
 {
     return d->fileDialogMode;
 }
 
 void KUrlRequester::setAcceptMode(QFileDialog::AcceptMode mode)
 {
     d->fileDialogAcceptMode = mode;
 
     if (d->myFileDialog) {
         d->applyFileMode(d->myFileDialog, d->fileDialogMode, mode);
     }
 }
 
 QFileDialog::AcceptMode KUrlRequester::acceptMode() const
 {
     return d->fileDialogAcceptMode;
 }
 
 void KUrlRequester::setFilter(const QString &filter)
 {
     d->fileDialogFilter = filter;
 
     if (d->myFileDialog) {
         d->myFileDialog->setNameFilters(d->kToQFilters(d->fileDialogFilter));
     }
 }
 
 QString KUrlRequester::filter() const
 {
     return d->fileDialogFilter;
 }
 
 void KUrlRequester::setMimeTypeFilters(const QStringList &mimeTypes)
 {
     d->mimeTypeFilters = mimeTypes;
 
     if (d->myFileDialog) {
         d->myFileDialog->setMimeTypeFilters(d->mimeTypeFilters);
     }
     d->myCompletion->setMimeTypeFilters(d->mimeTypeFilters);
 }
 
 QStringList KUrlRequester::mimeTypeFilters() const
 {
     return d->mimeTypeFilters;
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 QFileDialog *KUrlRequester::fileDialog() const
 {
     if (!d->myFileDialog) {
         d->myFileDialog = new QFileDialog(window(), windowTitle());
         if (!d->mimeTypeFilters.isEmpty()) {
             d->myFileDialog->setMimeTypeFilters(d->mimeTypeFilters);
         } else {
             d->myFileDialog->setNameFilters(d->kToQFilters(d->fileDialogFilter));
         }
 
         d->applyFileMode(d->myFileDialog, d->fileDialogMode, d->fileDialogAcceptMode);
 
         d->myFileDialog->setWindowModality(d->fileDialogModality);
         connect(d->myFileDialog, SIGNAL(accepted()), SLOT(_k_slotFileDialogAccepted()));
     }
 
     return d->myFileDialog;
 }
 #endif
 
 void KUrlRequester::clear()
 {
     d->setText(QString());
 }
 
 KLineEdit *KUrlRequester::lineEdit() const
 {
     return d->edit;
 }
 
 KComboBox *KUrlRequester::comboBox() const
 {
     return d->combo;
 }
 
 void KUrlRequester::KUrlRequesterPrivate::_k_slotUpdateUrl()
 {
     const QUrl visibleUrl = url();
     QUrl u = visibleUrl;
     if (visibleUrl.isRelative()) {
         u = QUrl::fromLocalFile(QDir::currentPath() + QLatin1Char('/')).resolved(visibleUrl);
     }
     myButton->setURL(u);
 }
 
 bool KUrlRequester::eventFilter(QObject *obj, QEvent *ev)
 {
     if ((d->edit == obj) || (d->combo == obj)) {
         if ((ev->type() == QEvent::FocusIn) || (ev->type() == QEvent::FocusOut))
             // Forward focusin/focusout events to the urlrequester; needed by file form element in khtml
         {
             QApplication::sendEvent(this, ev);
         }
     }
     return QWidget::eventFilter(obj, ev);
 }
 
 QPushButton *KUrlRequester::button() const
 {
     return d->myButton;
 }
 
 KUrlCompletion *KUrlRequester::completionObject() const
 {
     return d->myCompletion;
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 void KUrlRequester::setClickMessage(const QString &msg)
 {
     setPlaceholderText(msg);
 }
 #endif
 
 void KUrlRequester::setPlaceholderText(const QString &msg)
 {
     if (d->edit) {
         d->edit->setPlaceholderText(msg);
     }
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 QString KUrlRequester::clickMessage() const
 {
     return placeholderText();
 }
 #endif
 
 QString KUrlRequester::placeholderText() const
 {
     if (d->edit) {
         return d->edit->placeholderText();
     } else {
         return QString();
     }
 }
 
 Qt::WindowModality KUrlRequester::fileDialogModality() const
 {
     return d->fileDialogModality;
 }
 
 void KUrlRequester::setFileDialogModality(Qt::WindowModality modality)
 {
     d->fileDialogModality = modality;
 }
 
 const KEditListWidget::CustomEditor &KUrlRequester::customEditor()
 {
     setSizePolicy(QSizePolicy(QSizePolicy::Preferred,
                               QSizePolicy::Fixed));
 
     KLineEdit *edit = d->edit;
     if (!edit && d->combo) {
         edit = qobject_cast<KLineEdit *>(d->combo->lineEdit());
     }
 
 #ifndef NDEBUG
     if (!edit) {
         qCWarning(KIO_WIDGETS) << "KUrlRequester's lineedit is not a KLineEdit!??\n";
     }
 #endif
 
     d->editor.setRepresentationWidget(this);
     d->editor.setLineEdit(edit);
     return d->editor;
 }
 
 KUrlComboRequester::KUrlComboRequester(QWidget *parent)
     : KUrlRequester(new KComboBox(false), parent), d(nullptr)
 {
 }
 
 #include "moc_kurlrequester.cpp"
 #include "kurlrequester.moc"