diff --git a/autotests/kdirmodeltest.cpp b/autotests/kdirmodeltest.cpp
index 05b43729..6b9d9578 100644
--- a/autotests/kdirmodeltest.cpp
+++ b/autotests/kdirmodeltest.cpp
@@ -1,1521 +1,1521 @@
 /* This file is part of the KDE project
    Copyright 2006 - 2007 David Faure <faure@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "kdirmodeltest.h"
 #include <kdirnotify.h>
 #include <kio/copyjob.h>
 #include <kio/chmodjob.h>
 #include <kprotocolinfo.h>
 #include <kdirmodel.h>
 #include <kdirlister.h>
 //TODO #include "../../kdeui/tests/proxymodeltestsuite/modelspy.h"
 
 #include <qtest.h>
 
 #ifdef Q_OS_UNIX
 #include <utime.h>
 #endif
 #include <QDebug>
 #include <kio/deletejob.h>
 #include <kio/job.h>
 #include <kdirwatch.h>
 #include "kiotesthelper.h"
 #include <QUrl>
 
 QTEST_MAIN(KDirModelTest)
 
 #ifndef USE_QTESTEVENTLOOP
 #define exitLoop quit
 #endif
 
 #define checkedConnect(a,b,c,d) QVERIFY(QObject::connect(a,b,c,d))
 
 #ifndef Q_OS_WIN
 #define SPECIALCHARS " special chars%:.pdf"
 #else
 #define SPECIALCHARS " special chars%.pdf"
 #endif
 
 Q_DECLARE_METATYPE(KFileItemList)
 
 void KDirModelTest::initTestCase()
 {
     qputenv("LC_ALL", "en_US.UTF-8");
     // To avoid a runtime dependency on klauncher
     qputenv("KDE_FORK_SLAVES", "yes");
 
     qRegisterMetaType<KFileItemList>("KFileItemList");
 
     m_dirModelForExpand = nullptr;
     m_dirModel = nullptr;
     s_referenceTimeStamp = QDateTime::currentDateTime().addSecs(-30);   // 30 seconds ago
     m_tempDir = nullptr;
     m_topLevelFileNames << QStringLiteral("toplevelfile_1")
                         << QStringLiteral("toplevelfile_2")
                         << QStringLiteral("toplevelfile_3")
                         << SPECIALCHARS
                         ;
     recreateTestData();
 
     fillModel(false);
 }
 
 void KDirModelTest::recreateTestData()
 {
     if (m_tempDir) {
         qDebug() << "Deleting old tempdir" << m_tempDir->path();
         delete m_tempDir;
         qApp->processEvents(); // process inotify events so they don't pollute us later on
     }
 
     m_tempDir = new QTemporaryDir;
     qDebug() << "new tmp dir:" << m_tempDir->path();
     // Create test data:
     /*
      * PATH/toplevelfile_1
      * PATH/toplevelfile_2
      * PATH/toplevelfile_3
      * PATH/special chars%:.pdf
      * PATH/.hiddenfile
      * PATH/.hiddenfile2
      * PATH/subdir
      * PATH/subdir/testfile
      * PATH/subdir/testsymlink
      * PATH/subdir/subsubdir
      * PATH/subdir/subsubdir/testfile
      */
     const QString path = m_tempDir->path() + '/';
     foreach (const QString &f, m_topLevelFileNames) {
         createTestFile(path + f);
     }
     createTestFile(path + ".hiddenfile");
     createTestFile(path + ".hiddenfile2");
     createTestDirectory(path + "subdir");
     createTestDirectory(path + "subdir/subsubdir", NoSymlink);
 
     m_dirIndex = QModelIndex();
     m_fileIndex = QModelIndex();
     m_secondFileIndex = QModelIndex();
 }
 
 void KDirModelTest::cleanupTestCase()
 {
     delete m_tempDir;
     m_tempDir = nullptr;
     delete m_dirModel;
     m_dirModel = nullptr;
     delete m_dirModelForExpand;
     m_dirModelForExpand = nullptr;
 }
 
 void KDirModelTest::fillModel(bool reload, bool expectAllIndexes)
 {
     if (!m_dirModel) {
         m_dirModel = new KDirModel;
     }
     m_dirModel->dirLister()->setAutoErrorHandlingEnabled(false, nullptr);
     const QString path = m_tempDir->path() + '/';
     KDirLister *dirLister = m_dirModel->dirLister();
     qDebug() << "Calling openUrl";
     dirLister->openUrl(QUrl::fromLocalFile(path), reload ? KDirLister::Reload : KDirLister::NoFlags);
     checkedConnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
     qDebug() << "enterLoop, waiting for completed()";
     enterLoop();
 
     if (expectAllIndexes) {
         collectKnownIndexes();
     }
     disconnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
 }
 
 // Called after test function
 void KDirModelTest::cleanup()
 {
     if (m_dirModel) {
         disconnect(m_dirModel, nullptr, &m_eventLoop, nullptr);
         disconnect(m_dirModel->dirLister(), nullptr, this, nullptr);
         m_dirModel->dirLister()->setNameFilter(QString());
         m_dirModel->dirLister()->setMimeFilter(QStringList());
         m_dirModel->dirLister()->emitChanges();
     }
 }
 
 void KDirModelTest::collectKnownIndexes()
 {
     m_dirIndex = QModelIndex();
     m_fileIndex = QModelIndex();
     m_secondFileIndex = QModelIndex();
     // Create the indexes once and for all
     // The trouble is that the order of listing is undefined, one can get 1/2/3/subdir or subdir/3/2/1 for instance.
     for (int row = 0; row < m_topLevelFileNames.count() + 1 /*subdir*/; ++row) {
         QModelIndex idx = m_dirModel->index(row, 0, QModelIndex());
         QVERIFY(idx.isValid());
         KFileItem item = m_dirModel->itemForIndex(idx);
         qDebug() << item.url() << "isDir=" << item.isDir();
         QString fileName = item.url().fileName();
         if (item.isDir()) {
             m_dirIndex = idx;
         } else if (fileName == QLatin1String("toplevelfile_1")) {
             m_fileIndex = idx;
         } else if (fileName == QLatin1String("toplevelfile_2")) {
             m_secondFileIndex = idx;
         } else if (fileName.startsWith(QLatin1String(" special"))) {
             m_specialFileIndex = idx;
         }
     }
     QVERIFY(m_dirIndex.isValid());
     QVERIFY(m_fileIndex.isValid());
     QVERIFY(m_secondFileIndex.isValid());
     QVERIFY(m_specialFileIndex.isValid());
 
     // Now list subdir/
     QVERIFY(m_dirModel->canFetchMore(m_dirIndex));
     m_dirModel->fetchMore(m_dirIndex);
     qDebug() << "Listing subdir/";
     enterLoop();
 
     // Index of a file inside a directory (subdir/testfile)
     QModelIndex subdirIndex;
     m_fileInDirIndex = QModelIndex();
     for (int row = 0; row < 3; ++row) {
         QModelIndex idx = m_dirModel->index(row, 0, m_dirIndex);
         if (m_dirModel->itemForIndex(idx).isDir()) {
             subdirIndex = idx;
         } else if (m_dirModel->itemForIndex(idx).name() == QLatin1String("testfile")) {
             m_fileInDirIndex = idx;
         }
     }
 
     // List subdir/subsubdir
     QVERIFY(m_dirModel->canFetchMore(subdirIndex));
     qDebug() << "Listing subdir/subsubdir";
     m_dirModel->fetchMore(subdirIndex);
     enterLoop();
 
     // Index of ... well, subdir/subsubdir/testfile
     m_fileInSubdirIndex = m_dirModel->index(0, 0, subdirIndex);
 }
 
 void KDirModelTest::enterLoop()
 {
 #ifdef USE_QTESTEVENTLOOP
     m_eventLoop.enterLoop(10 /*seconds max*/);
     QVERIFY(!m_eventLoop.timeout());
 #else
     m_eventLoop.exec();
 #endif
 }
 
 void KDirModelTest::slotListingCompleted()
 {
     qDebug();
 #ifdef USE_QTESTEVENTLOOP
     m_eventLoop.exitLoop();
 #else
     m_eventLoop.quit();
 #endif
 }
 
 void KDirModelTest::testRowCount()
 {
     const int topLevelRowCount = m_dirModel->rowCount();
     QCOMPARE(topLevelRowCount, m_topLevelFileNames.count() + 1 /*subdir*/);
     const int subdirRowCount = m_dirModel->rowCount(m_dirIndex);
     QCOMPARE(subdirRowCount, 3);
 
     QVERIFY(m_fileIndex.isValid());
     const int fileRowCount = m_dirModel->rowCount(m_fileIndex); // #176555
     QCOMPARE(fileRowCount, 0);
 }
 
 void KDirModelTest::testIndex()
 {
     QVERIFY(m_dirModel->hasChildren());
 
     // Index of the first file
     QVERIFY(m_fileIndex.isValid());
     QCOMPARE(m_fileIndex.model(), static_cast<const QAbstractItemModel *>(m_dirModel));
     //QCOMPARE(m_fileIndex.row(), 0);
     QCOMPARE(m_fileIndex.column(), 0);
     QVERIFY(!m_fileIndex.parent().isValid());
     QVERIFY(!m_dirModel->hasChildren(m_fileIndex));
 
     // Index of a directory
     QVERIFY(m_dirIndex.isValid());
     QCOMPARE(m_dirIndex.model(), static_cast<const QAbstractItemModel *>(m_dirModel));
     //QCOMPARE(m_dirIndex.row(), 3); // ordering isn't guaranteed
     QCOMPARE(m_dirIndex.column(), 0);
     QVERIFY(!m_dirIndex.parent().isValid());
     QVERIFY(m_dirModel->hasChildren(m_dirIndex));
 
     // Index of a file inside a directory (subdir/testfile)
     QVERIFY(m_fileInDirIndex.isValid());
     QCOMPARE(m_fileInDirIndex.model(), static_cast<const QAbstractItemModel *>(m_dirModel));
     //QCOMPARE(m_fileInDirIndex.row(), 0); // ordering isn't guaranteed
     QCOMPARE(m_fileInDirIndex.column(), 0);
     QVERIFY(m_fileInDirIndex.parent() == m_dirIndex);
     QVERIFY(!m_dirModel->hasChildren(m_fileInDirIndex));
 
     // Index of subdir/subsubdir/testfile
     QVERIFY(m_fileInSubdirIndex.isValid());
     QCOMPARE(m_fileInSubdirIndex.model(), static_cast<const QAbstractItemModel *>(m_dirModel));
     QCOMPARE(m_fileInSubdirIndex.row(), 0); // we can check it because it's the only file there
     QCOMPARE(m_fileInSubdirIndex.column(), 0);
     QVERIFY(m_fileInSubdirIndex.parent().parent() == m_dirIndex);
     QVERIFY(!m_dirModel->hasChildren(m_fileInSubdirIndex));
 
     // Test sibling() by going from subdir/testfile to subdir/subsubdir
     const QModelIndex subsubdirIndex = m_fileInSubdirIndex.parent();
     QVERIFY(subsubdirIndex.isValid());
     QModelIndex sibling1 = m_dirModel->sibling(subsubdirIndex.row(), 0, m_fileInDirIndex);
     QVERIFY(sibling1.isValid());
     QVERIFY(sibling1 == subsubdirIndex);
 
     // Invalid sibling call
     QVERIFY(!m_dirModel->sibling(1, 0, m_fileInSubdirIndex).isValid());
 
     // Test index() with a valid parent (dir).
     QModelIndex index2 = m_dirModel->index(m_fileInSubdirIndex.row(), m_fileInSubdirIndex.column(), subsubdirIndex);
     QVERIFY(index2.isValid());
     QVERIFY(index2 == m_fileInSubdirIndex);
 
     // Test index() with a non-parent (file).
     QModelIndex index3 = m_dirModel->index(m_fileInSubdirIndex.row(), m_fileInSubdirIndex.column(), m_fileIndex);
     QVERIFY(!index3.isValid());
 }
 
 void KDirModelTest::testNames()
 {
     QString fileName = m_dirModel->data(m_fileIndex, Qt::DisplayRole).toString();
     QCOMPARE(fileName, QString("toplevelfile_1"));
 
     QString specialFileName = m_dirModel->data(m_specialFileIndex, Qt::DisplayRole).toString();
     QCOMPARE(specialFileName, QString(SPECIALCHARS));
 
     QString dirName = m_dirModel->data(m_dirIndex, Qt::DisplayRole).toString();
     QCOMPARE(dirName, QString("subdir"));
 
     QString fileInDirName = m_dirModel->data(m_fileInDirIndex, Qt::DisplayRole).toString();
     QCOMPARE(fileInDirName, QString("testfile"));
 
     QString fileInSubdirName = m_dirModel->data(m_fileInSubdirIndex, Qt::DisplayRole).toString();
     QCOMPARE(fileInSubdirName, QString("testfile"));
 }
 
 void KDirModelTest::testItemForIndex()
 {
     // root item
     KFileItem rootItem = m_dirModel->itemForIndex(QModelIndex());
     QVERIFY(!rootItem.isNull());
     QCOMPARE(rootItem.name(), QString("."));
 
     KFileItem fileItem = m_dirModel->itemForIndex(m_fileIndex);
     QVERIFY(!fileItem.isNull());
     QCOMPARE(fileItem.name(), QString("toplevelfile_1"));
     QVERIFY(!fileItem.isDir());
     QCOMPARE(fileItem.url().toLocalFile(), QString(m_tempDir->path() + "/toplevelfile_1"));
 
     KFileItem dirItem = m_dirModel->itemForIndex(m_dirIndex);
     QVERIFY(!dirItem.isNull());
     QCOMPARE(dirItem.name(), QString("subdir"));
     QVERIFY(dirItem.isDir());
     QCOMPARE(dirItem.url().toLocalFile(), QString(m_tempDir->path() + "/subdir"));
 
     KFileItem fileInDirItem = m_dirModel->itemForIndex(m_fileInDirIndex);
     QVERIFY(!fileInDirItem.isNull());
     QCOMPARE(fileInDirItem.name(), QString("testfile"));
     QVERIFY(!fileInDirItem.isDir());
     QCOMPARE(fileInDirItem.url().toLocalFile(), QString(m_tempDir->path() + "/subdir/testfile"));
 
     KFileItem fileInSubdirItem = m_dirModel->itemForIndex(m_fileInSubdirIndex);
     QVERIFY(!fileInSubdirItem.isNull());
     QCOMPARE(fileInSubdirItem.name(), QString("testfile"));
     QVERIFY(!fileInSubdirItem.isDir());
     QCOMPARE(fileInSubdirItem.url().toLocalFile(), QString(m_tempDir->path() + "/subdir/subsubdir/testfile"));
 }
 
 void KDirModelTest::testIndexForItem()
 {
     KFileItem rootItem = m_dirModel->itemForIndex(QModelIndex());
     QModelIndex rootIndex = m_dirModel->indexForItem(rootItem);
     QVERIFY(!rootIndex.isValid());
 
     KFileItem fileItem = m_dirModel->itemForIndex(m_fileIndex);
     QModelIndex fileIndex = m_dirModel->indexForItem(fileItem);
     QCOMPARE(fileIndex, m_fileIndex);
 
     KFileItem dirItem = m_dirModel->itemForIndex(m_dirIndex);
     QModelIndex dirIndex = m_dirModel->indexForItem(dirItem);
     QCOMPARE(dirIndex, m_dirIndex);
 
     KFileItem fileInDirItem = m_dirModel->itemForIndex(m_fileInDirIndex);
     QModelIndex fileInDirIndex = m_dirModel->indexForItem(fileInDirItem);
     QCOMPARE(fileInDirIndex, m_fileInDirIndex);
 
     KFileItem fileInSubdirItem = m_dirModel->itemForIndex(m_fileInSubdirIndex);
     QModelIndex fileInSubdirIndex = m_dirModel->indexForItem(fileInSubdirItem);
     QCOMPARE(fileInSubdirIndex, m_fileInSubdirIndex);
 }
 
 void KDirModelTest::testData()
 {
     // First file
     QModelIndex idx1col0 = m_dirModel->index(m_fileIndex.row(), 0, QModelIndex());
     QCOMPARE(idx1col0.data().toString(), QString("toplevelfile_1"));
     QModelIndex idx1col1 = m_dirModel->index(m_fileIndex.row(), 1, QModelIndex());
     QString size1 = m_dirModel->data(idx1col1, Qt::DisplayRole).toString();
     QCOMPARE(size1, QString("11 B"));
 
     KFileItem item = m_dirModel->data(m_fileIndex, KDirModel::FileItemRole).value<KFileItem>();
     KFileItem fileItem = m_dirModel->itemForIndex(m_fileIndex);
     QCOMPARE(item, fileItem);
 
     QCOMPARE(m_dirModel->data(m_fileIndex, KDirModel::ChildCountRole).toInt(), (int)KDirModel::ChildCountUnknown);
 
     // Second file
     QModelIndex idx2col0 = m_dirModel->index(m_secondFileIndex.row(), 0, QModelIndex());
     QString display2 = m_dirModel->data(idx2col0, Qt::DisplayRole).toString();
     QCOMPARE(display2, QString("toplevelfile_2"));
 
     // Subdir: check child count
     QCOMPARE(m_dirModel->data(m_dirIndex, KDirModel::ChildCountRole).toInt(), 3);
 
     // Subsubdir: check child count
     QCOMPARE(m_dirModel->data(m_fileInSubdirIndex.parent(), KDirModel::ChildCountRole).toInt(), 1);
 }
 
 void KDirModelTest::testReload()
 {
     fillModel(true);
     testItemForIndex();
 }
 
 // We want more info than just "the values differ", if they do.
 #define COMPARE_INDEXES(a, b) \
     QCOMPARE(a.row(), b.row()); \
     QCOMPARE(a.column(), b.column()); \
     QCOMPARE(a.model(), b.model()); \
     QCOMPARE(a.parent().isValid(), b.parent().isValid()); \
     QCOMPARE(a, b);
 
 void KDirModelTest::testModifyFile()
 {
     const QString file = m_tempDir->path() + "/toplevelfile_2";
     const QUrl url = QUrl::fromLocalFile(file);
 
 #if 1
     QSignalSpy spyDataChanged(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
 #else
     ModelSpy modelSpy(m_dirModel);
 #endif
     checkedConnect(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     // "Touch" the file
     setTimeStamp(file, s_referenceTimeStamp.addSecs(20));
 
     // In stat mode, kdirwatch doesn't notice file changes; we need to trigger it
     // by creating a file.
     //createTestFile(m_tempDir->path() + "/toplevelfile_5");
     KDirWatch::self()->setDirty(m_tempDir->path());
 
     // Wait for KDirWatch to notify the change (especially when using Stat)
     enterLoop();
 
     // If we come here, then dataChanged() was emitted - all good.
 #if 0
     QCOMPARE(modelSpy.count(), 1);
     const QVariantList dataChanged = modelSpy.first();
 #else
     const QVariantList dataChanged = spyDataChanged[0];
 #endif
     QModelIndex receivedIndex = dataChanged[0].value<QModelIndex>();
     COMPARE_INDEXES(receivedIndex, m_secondFileIndex);
     receivedIndex = dataChanged[1].value<QModelIndex>();
     QCOMPARE(receivedIndex.row(), m_secondFileIndex.row()); // only compare row; column is count-1
 
     disconnect(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                &m_eventLoop, SLOT(exitLoop()));
 }
 
 void KDirModelTest::testRenameFile()
 {
     const QUrl url = QUrl::fromLocalFile(m_tempDir->path() + "/toplevelfile_2");
     const QUrl newUrl = QUrl::fromLocalFile(m_tempDir->path() + "/toplevelfile_2_renamed");
 
     QSignalSpy spyDataChanged(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
     checkedConnect(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     KIO::SimpleJob *job = KIO::rename(url, newUrl, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers dataChanged
     enterLoop();
 
     // If we come here, then dataChanged() was emitted - all good.
     QCOMPARE(spyDataChanged.count(), 1);
     COMPARE_INDEXES(spyDataChanged[0][0].value<QModelIndex>(), m_secondFileIndex);
     QModelIndex receivedIndex = spyDataChanged[0][1].value<QModelIndex>();
     QCOMPARE(receivedIndex.row(), m_secondFileIndex.row()); // only compare row; column is count-1
 
     // check renaming happened
     QCOMPARE(m_dirModel->itemForIndex(m_secondFileIndex).url().toString(), newUrl.toString());
 
     // check that KDirLister::cachedItemForUrl won't give a bad name if copying that item (#195385)
     KFileItem cachedItem = KDirLister::cachedItemForUrl(newUrl);
     QVERIFY(!cachedItem.isNull());
     QCOMPARE(cachedItem.name(), QString("toplevelfile_2_renamed"));
     QCOMPARE(cachedItem.entry().stringValue(KIO::UDSEntry::UDS_NAME), QString("toplevelfile_2_renamed"));
 
     // Put things back to normal
     job = KIO::rename(newUrl, url, KIO::HideProgressInfo);
     QVERIFY(job->exec());
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers dataChanged
     enterLoop();
     QCOMPARE(m_dirModel->itemForIndex(m_secondFileIndex).url().toString(), url.toString());
 
     disconnect(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                &m_eventLoop, SLOT(exitLoop()));
 }
 
 void KDirModelTest::testMoveDirectory()
 {
     testMoveDirectory(QStringLiteral("subdir"));
 }
 
 void KDirModelTest::testMoveDirectory(const QString &dir /*just a dir name, no slash*/)
 {
     const QString path = m_tempDir->path() + '/';
     const QString srcdir = path + dir;
     QVERIFY(QDir(srcdir).exists());
     QTemporaryDir destDir;
     const QString dest = destDir.path() + '/';
     QVERIFY(QDir(dest).exists());
 
     checkedConnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     // Move
     qDebug() << "Moving" << srcdir << "to" << dest;
     KIO::CopyJob *job = KIO::move(QUrl::fromLocalFile(srcdir), QUrl::fromLocalFile(dest), KIO::HideProgressInfo);
     job->setUiDelegate(nullptr);
     job->setUiDelegateExtension(nullptr);
     QVERIFY(job->exec());
 
     // wait for kdirnotify
     enterLoop();
 
     disconnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                &m_eventLoop, SLOT(exitLoop()));
 
     QVERIFY(!m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir")).isValid());
     QVERIFY(!m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed")).isValid());
 
     checkedConnect(m_dirModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     // Move back
     qDebug() << "Moving" << dest + dir << "back to" << srcdir;
     job = KIO::move(QUrl::fromLocalFile(dest + dir), QUrl::fromLocalFile(srcdir), KIO::HideProgressInfo);
     job->setUiDelegate(nullptr);
     job->setUiDelegateExtension(nullptr);
     QVERIFY(job->exec());
 
     enterLoop();
 
     QVERIFY(QDir(srcdir).exists());
     disconnect(m_dirModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
                &m_eventLoop, SLOT(exitLoop()));
 
     // m_dirIndex is invalid after the above...
     fillModel(true);
 }
 
 void KDirModelTest::testRenameDirectory() // #172945, #174703, (and #180156)
 {
     const QString path = m_tempDir->path() + '/';
     const QUrl url = QUrl::fromLocalFile(path + "subdir");
     const QUrl newUrl = QUrl::fromLocalFile(path + "subdir_renamed");
 
     // For #180156 we need a second kdirmodel, viewing the subdir being renamed.
     // I'm abusing m_dirModelForExpand for that purpose.
     delete m_dirModelForExpand;
     m_dirModelForExpand = new KDirModel;
     KDirLister *dirListerForExpand = m_dirModelForExpand->dirLister();
     checkedConnect(dirListerForExpand, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
     dirListerForExpand->openUrl(url); // async
     enterLoop();
 
     // Now do the renaming
     QSignalSpy spyDataChanged(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
     checkedConnect(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                    &m_eventLoop, SLOT(exitLoop()));
     KIO::SimpleJob *job = KIO::rename(url, newUrl, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers dataChanged
     enterLoop();
 
     // If we come here, then dataChanged() was emitted - all good.
     //QCOMPARE(spyDataChanged.count(), 1); // it was in fact emitted 5 times...
     //COMPARE_INDEXES(spyDataChanged[0][0].value<QModelIndex>(), m_dirIndex);
     //QModelIndex receivedIndex = spyDataChanged[0][1].value<QModelIndex>();
     //QCOMPARE(receivedIndex.row(), m_dirIndex.row()); // only compare row; column is count-1
 
     // check renaming happened
     QCOMPARE(m_dirModel->itemForIndex(m_dirIndex).url().toString(), newUrl.toString());
     qDebug() << newUrl << "indexForUrl=" << m_dirModel->indexForUrl(newUrl) << "m_dirIndex=" << m_dirIndex;
     QCOMPARE(m_dirModel->indexForUrl(newUrl), m_dirIndex);
     QVERIFY(m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed")).isValid());
     QVERIFY(m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed/testfile")).isValid());
     QVERIFY(m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed/subsubdir")).isValid());
     QVERIFY(m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed/subsubdir/testfile")).isValid());
 
     // Check the other kdirmodel got redirected
     QCOMPARE(dirListerForExpand->url().toLocalFile(), QString(path + "subdir_renamed"));
 
     qDebug() << "calling testMoveDirectory(subdir_renamed)";
 
     // Test moving the renamed directory; if something inside KDirModel
     // wasn't properly updated by the renaming, this would detect it and crash (#180673)
     testMoveDirectory(QStringLiteral("subdir_renamed"));
 
     // Put things back to normal
     job = KIO::rename(newUrl, url, KIO::HideProgressInfo);
     QVERIFY(job->exec());
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers dataChanged
     enterLoop();
     QCOMPARE(m_dirModel->itemForIndex(m_dirIndex).url().toString(), url.toString());
 
     disconnect(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                &m_eventLoop, SLOT(exitLoop()));
 
     QCOMPARE(m_dirModel->itemForIndex(m_dirIndex).url().toString(), url.toString());
     QCOMPARE(m_dirModel->indexForUrl(url), m_dirIndex);
     QVERIFY(m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir")).isValid());
     QVERIFY(m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir/testfile")).isValid());
     QVERIFY(m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir/subsubdir")).isValid());
     QVERIFY(m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir/subsubdir/testfile")).isValid());
     QVERIFY(!m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed")).isValid());
     QVERIFY(!m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed/testfile")).isValid());
     QVERIFY(!m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed/subsubdir")).isValid());
     QVERIFY(!m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir_renamed/subsubdir/testfile")).isValid());
 
     // TODO INVESTIGATE
     // QCOMPARE(dirListerForExpand->url().toLocalFile(), path+"subdir");
 
     delete m_dirModelForExpand;
     m_dirModelForExpand = nullptr;
 }
 
 void KDirModelTest::testRenameDirectoryInCache() // #188807
 {
     // Ensure the stuff is in cache.
     fillModel(true);
     const QString path = m_tempDir->path() + '/';
     QVERIFY(!m_dirModel->dirLister()->findByUrl(QUrl::fromLocalFile(path)).isNull());
 
     // No more dirmodel nor dirlister.
     delete m_dirModel;
     m_dirModel = nullptr;
 
     // Now let's rename a directory that is in KCoreDirListerCache
     const QUrl url = QUrl::fromLocalFile(path);
     QUrl newUrl = url.adjusted(QUrl::StripTrailingSlash);
     newUrl.setPath(newUrl.path() + "_renamed");
     qDebug() << newUrl;
     KIO::SimpleJob *job = KIO::rename(url, newUrl, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     // Put things back to normal
     job = KIO::rename(newUrl, url, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     // KDirNotify emits FileRenamed for each rename() above, which in turn
     // re-lists the directory. We need to wait for both signals to be emitted
     // otherwise the dirlister will not be in the state we expect.
     QTest::qWait(200);
 
     fillModel(true);
 
     QVERIFY(m_dirIndex.isValid());
     KFileItem rootItem = m_dirModel->dirLister()->findByUrl(QUrl::fromLocalFile(path));
     QVERIFY(!rootItem.isNull());
 }
 
 void KDirModelTest::testChmodDirectory() // #53397
 {
     QSignalSpy spyDataChanged(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
     checkedConnect(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                    &m_eventLoop, SLOT(exitLoop()));
     const QString path = m_tempDir->path() + '/';
     KFileItem rootItem = m_dirModel->itemForIndex(QModelIndex());
     const mode_t origPerm = rootItem.permissions();
     mode_t newPerm = origPerm ^ S_IWGRP;
     //const QFile::Permissions origPerm = rootItem.filePermissions();
     //QVERIFY(origPerm & QFile::ReadOwner);
     //const QFile::Permissions newPerm = origPerm ^ QFile::WriteGroup;
     QVERIFY(newPerm != origPerm);
     KFileItemList items; items << rootItem;
     KIO::Job *job = KIO::chmod(items, newPerm, S_IWGRP /*TODO: QFile::WriteGroup*/, QString(), QString(), false, KIO::HideProgressInfo);
     job->setUiDelegate(nullptr);
     QVERIFY(job->exec());
     // ChmodJob doesn't talk to KDirNotify, kpropertiesdialog does.
     // [this allows to group notifications after all the changes one can make in the dialog]
     org::kde::KDirNotify::emitFilesChanged(QList<QUrl>() << QUrl::fromLocalFile(path));
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers rowsRemoved
     enterLoop();
 
     // If we come here, then dataChanged() was emitted - all good.
     QCOMPARE(spyDataChanged.count(), 1);
     QModelIndex receivedIndex = spyDataChanged[0][0].value<QModelIndex>();
     qDebug() << receivedIndex;
     QVERIFY(!receivedIndex.isValid());
 
     const KFileItem newRootItem = m_dirModel->itemForIndex(QModelIndex());
     QVERIFY(!newRootItem.isNull());
     QCOMPARE(QString::number(newRootItem.permissions(), 16), QString::number(newPerm, 16));
 
     disconnect(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                &m_eventLoop, SLOT(exitLoop()));
 }
 
 enum {
     NoFlag = 0,
     NewDir = 1, // whether to re-create a new QTemporaryDir completely, to avoid cached fileitems
     ListFinalDir = 2, // whether to list the target dir at the same time, like k3b, for #193364
     Recreate = 4,
     CacheSubdir = 8, // put subdir in the cache before expandToUrl
     // flags, next item is 16!
 };
 
 void KDirModelTest::testExpandToUrl_data()
 {
     QTest::addColumn<int>("flags"); // see enum above
     QTest::addColumn<QString>("expandToPath"); // relative path
     QTest::addColumn<QStringList>("expectedExpandSignals");
 
     QTest::newRow("the root, nothing to do")
             << int(NoFlag) << QString() << QStringList();
     QTest::newRow(".")
             << int(NoFlag) << "." << (QStringList());
     QTest::newRow("subdir")
             << int(NoFlag) << "subdir" << (QStringList() << QStringLiteral("subdir"));
     QTest::newRow("subdir/.")
             << int(NoFlag) << "subdir/." << (QStringList() << QStringLiteral("subdir"));
 
     const QString subsubdir = QStringLiteral("subdir/subsubdir");
     // Must list root, emit expand for subdir, list subdir, emit expand for subsubdir.
     QTest::newRow("subdir/subsubdir")
             << int(NoFlag) << subsubdir << (QStringList() << QStringLiteral("subdir") << subsubdir);
 
     // Must list root, emit expand for subdir, list subdir, emit expand for subsubdir, list subsubdir.
     const QString subsubdirfile = subsubdir + "/testfile";
     QTest::newRow("subdir/subsubdir/testfile sync")
             << int(NoFlag) << subsubdirfile << (QStringList() << QStringLiteral("subdir") << subsubdir << subsubdirfile);
 
 #ifndef Q_OS_WIN
     // Expand a symlink to a directory (#219547)
     const QString dirlink = m_tempDir->path() + "/dirlink";
     createTestSymlink(dirlink, "/");
     QTest::newRow("dirlink")
             << int(NoFlag) << "dirlink/tmp" << (QStringList() << QStringLiteral("dirlink") << QStringLiteral("dirlink/tmp"));
 #endif
 
     // Do a cold-cache test too, but nowadays it doesn't change anything anymore,
     // apart from testing different code paths inside KDirLister.
     QTest::newRow("subdir/subsubdir/testfile with reload")
             << int(NewDir) << subsubdirfile << (QStringList() << QStringLiteral("subdir") << subsubdir << subsubdirfile);
 
     QTest::newRow("hold dest dir") // #193364
             << int(NewDir | ListFinalDir) << subsubdirfile << (QStringList() << QStringLiteral("subdir") << subsubdir << subsubdirfile);
 
     // Put subdir in cache too (#175035)
     QTest::newRow("hold subdir and dest dir")
             << int(NewDir | CacheSubdir | ListFinalDir | Recreate) << subsubdirfile
             << (QStringList() << QStringLiteral("subdir") << subsubdir << subsubdirfile);
 
     // Make sure the last test has the Recreate option set, for the subsequent test methods.
 }
 
 void KDirModelTest::testExpandToUrl()
 {
     QFETCH(int, flags);
     QFETCH(QString, expandToPath); // relative
     QFETCH(QStringList, expectedExpandSignals);
 
     if (flags & NewDir) {
         recreateTestData();
         // WARNING! m_dirIndex, m_fileIndex, m_secondFileIndex etc. are not valid anymore after this point!
 
     }
 
     const QString path = m_tempDir->path() + '/';
     if (flags & CacheSubdir) {
         // This way, the listDir for subdir will find items in cache, and will schedule a CachedItemsJob
         m_dirModel->dirLister()->openUrl(QUrl::fromLocalFile(path + "subdir"));
         QSignalSpy completedSpy(m_dirModel->dirLister(), SIGNAL(completed()));
         QVERIFY(completedSpy.wait(2000));
     }
     if (flags & ListFinalDir) {
         // This way, the last listDir will find items in cache, and will schedule a CachedItemsJob
         m_dirModel->dirLister()->openUrl(QUrl::fromLocalFile(path + "subdir/subsubdir"));
         QSignalSpy completedSpy(m_dirModel->dirLister(), SIGNAL(completed()));
         QVERIFY(completedSpy.wait(2000));
     }
 
     if (!m_dirModelForExpand || (flags & NewDir)) {
         delete m_dirModelForExpand;
         m_dirModelForExpand = new KDirModel;
         checkedConnect(m_dirModelForExpand, SIGNAL(expand(QModelIndex)),
                        this, SLOT(slotExpand(QModelIndex)));
         checkedConnect(m_dirModelForExpand, SIGNAL(rowsInserted(QModelIndex,int,int)),
                        this, SLOT(slotRowsInserted(QModelIndex,int,int)));
         KDirLister *dirListerForExpand = m_dirModelForExpand->dirLister();
         dirListerForExpand->openUrl(QUrl::fromLocalFile(path), KDirLister::NoFlags); // async
     }
     m_rowsInsertedEmitted = false;
     m_expectedExpandSignals = expectedExpandSignals;
     m_nextExpectedExpandSignals = 0;
     QSignalSpy spyExpand(m_dirModelForExpand, SIGNAL(expand(QModelIndex)));
     m_urlToExpandTo = QUrl::fromLocalFile(path + expandToPath);
     // If KDirModel doesn't know this URL yet, then we want to see rowsInserted signals
     // being emitted, so that the slots can get the index to that url then.
     m_expectRowsInserted = !expandToPath.isEmpty() && !m_dirModelForExpand->indexForUrl(m_urlToExpandTo).isValid();
     m_dirModelForExpand->expandToUrl(m_urlToExpandTo);
     if (expectedExpandSignals.isEmpty()) {
         QTest::qWait(20); // to make sure we process queued connection calls, otherwise spyExpand.count() is always 0 even if there's a bug...
         QCOMPARE(spyExpand.count(), 0);
     } else {
         if (spyExpand.count() < expectedExpandSignals.count()) {
             enterLoop();
             QCOMPARE(spyExpand.count(), expectedExpandSignals.count());
         }
         if (m_expectRowsInserted) {
             QVERIFY(m_rowsInsertedEmitted);
         }
     }
 
     // Now it should exist
     if (!expandToPath.isEmpty() && expandToPath != QLatin1String(".")) {
         qDebug() << "Do I know" << m_urlToExpandTo << "?";
         QVERIFY(m_dirModelForExpand->indexForUrl(m_urlToExpandTo).isValid());
     }
 
     if (flags & ListFinalDir) {
         testUpdateParentAfterExpand();
     }
 
     if (flags & Recreate) {
         // Clean up, for the next tests
         recreateTestData();
         fillModel(false);
     }
 }
 
 void KDirModelTest::slotExpand(const QModelIndex &index)
 {
     QVERIFY(index.isValid());
     const QString path = m_tempDir->path() + '/';
     KFileItem item = m_dirModelForExpand->itemForIndex(index);
     QVERIFY(!item.isNull());
     qDebug() << item.url().toLocalFile();
     QCOMPARE(item.url().toLocalFile(), QString(path + m_expectedExpandSignals[m_nextExpectedExpandSignals++]));
 
     // if rowsInserted wasn't emitted yet, then any proxy model would be unable to do anything with index at this point
     if (item.url() == m_urlToExpandTo) {
         QVERIFY(m_dirModelForExpand->indexForUrl(m_urlToExpandTo).isValid());
         if (m_expectRowsInserted) {
             QVERIFY(m_rowsInsertedEmitted);
         }
     }
 
     if (m_nextExpectedExpandSignals == m_expectedExpandSignals.count()) {
         m_eventLoop.exitLoop();    // done
     }
 }
 
 void KDirModelTest::slotRowsInserted(const QModelIndex &, int, int)
 {
     m_rowsInsertedEmitted = true;
 }
 
 // This code is called by testExpandToUrl
 void KDirModelTest::testUpdateParentAfterExpand() // #193364
 {
     const QString path = m_tempDir->path() + '/';
     const QString file = path + "subdir/aNewFile";
     qDebug() << "Creating" << file;
     QVERIFY(!QFile::exists(file));
     createTestFile(file);
     QSignalSpy spyRowsInserted(m_dirModelForExpand, SIGNAL(rowsInserted(QModelIndex,int,int)));
     QVERIFY(spyRowsInserted.wait(1000));
 }
 
 void KDirModelTest::testFilter()
 {
     QVERIFY(m_dirIndex.isValid());
     const int oldTopLevelRowCount = m_dirModel->rowCount();
     const int oldSubdirRowCount = m_dirModel->rowCount(m_dirIndex);
     QSignalSpy spyItemsFilteredByMime(m_dirModel->dirLister(), SIGNAL(itemsFilteredByMime(KFileItemList)));
     QSignalSpy spyItemsDeleted(m_dirModel->dirLister(), SIGNAL(itemsDeleted(KFileItemList)));
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
     m_dirModel->dirLister()->setNameFilter(QStringLiteral("toplevel*"));
     QCOMPARE(m_dirModel->rowCount(), oldTopLevelRowCount); // no change yet
     QCOMPARE(m_dirModel->rowCount(m_dirIndex), oldSubdirRowCount); // no change yet
     m_dirModel->dirLister()->emitChanges();
 
     QCOMPARE(m_dirModel->rowCount(), 4); // 3 toplevel* files, one subdir
     QCOMPARE(m_dirModel->rowCount(m_dirIndex), 1); // the files get filtered out, the subdir remains
 
     // In the subdir, we can get rowsRemoved signals like (1,2) or (0,0)+(2,2),
     // depending on the order of the files in the model.
     // So QCOMPARE(spyRowsRemoved.count(), 3) is fragile, we rather need
     // to sum up the removed rows per parent directory.
     QMap<QString, int> rowsRemovedPerDir;
     for (int i = 0; i < spyRowsRemoved.count(); ++i) {
         const QVariantList args = spyRowsRemoved[i];
         const QModelIndex parentIdx = args[0].value<QModelIndex>();
         QString dirName;
         if (parentIdx.isValid()) {
             const KFileItem item = m_dirModel->itemForIndex(parentIdx);
             dirName = item.name();
         } else {
             dirName = QStringLiteral("root");
         }
         rowsRemovedPerDir[dirName] += args[2].toInt() - args[1].toInt() + 1;
         //qDebug() << parentIdx << args[1].toInt() << args[2].toInt();
     }
     QCOMPARE(rowsRemovedPerDir.count(), 3); // once for every dir
     QCOMPARE(rowsRemovedPerDir.value("root"), 1);      // one from toplevel ('special chars')
     QCOMPARE(rowsRemovedPerDir.value("subdir"), 2);    // two from subdir
     QCOMPARE(rowsRemovedPerDir.value("subsubdir"), 1); // one from subsubdir
     QCOMPARE(spyItemsDeleted.count(), 3); // once for every dir
     QCOMPARE(spyItemsDeleted[0][0].value<KFileItemList>().count(), 1); // one from toplevel ('special chars')
     QCOMPARE(spyItemsDeleted[1][0].value<KFileItemList>().count(), 2); // two from subdir
     QCOMPARE(spyItemsDeleted[2][0].value<KFileItemList>().count(), 1); // one from subsubdir
     QCOMPARE(spyItemsFilteredByMime.count(), 0);
     spyItemsDeleted.clear();
     spyItemsFilteredByMime.clear();
 
     // Reset the filter
     qDebug() << "reset to no filter";
     m_dirModel->dirLister()->setNameFilter(QString());
     m_dirModel->dirLister()->emitChanges();
 
     QCOMPARE(m_dirModel->rowCount(), oldTopLevelRowCount);
     QCOMPARE(m_dirModel->rowCount(m_dirIndex), oldSubdirRowCount);
     QCOMPARE(spyItemsDeleted.count(), 0);
     QCOMPARE(spyItemsFilteredByMime.count(), 0);
 
     // The order of things changed because of filtering.
     // Fill again, so that m_fileIndex etc. are correct again.
     fillModel(true);
 }
 
 void KDirModelTest::testMimeFilter()
 {
     QVERIFY(m_dirIndex.isValid());
     const int oldTopLevelRowCount = m_dirModel->rowCount();
     const int oldSubdirRowCount = m_dirModel->rowCount(m_dirIndex);
     QSignalSpy spyItemsFilteredByMime(m_dirModel->dirLister(), SIGNAL(itemsFilteredByMime(KFileItemList)));
     QSignalSpy spyItemsDeleted(m_dirModel->dirLister(), SIGNAL(itemsDeleted(KFileItemList)));
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
     m_dirModel->dirLister()->setMimeFilter(QStringList() << QStringLiteral("application/pdf"));
     QCOMPARE(m_dirModel->rowCount(), oldTopLevelRowCount); // no change yet
     QCOMPARE(m_dirModel->rowCount(m_dirIndex), oldSubdirRowCount); // no change yet
     m_dirModel->dirLister()->emitChanges();
 
     QCOMPARE(m_dirModel->rowCount(), 1); // 1 pdf files, no subdir anymore
 
     QVERIFY(spyRowsRemoved.count() >= 1); // depends on contiguity...
     QVERIFY(spyItemsDeleted.count() >= 1); // once for every dir
     // Maybe it would make sense to have those items in itemsFilteredByMime,
     // but well, for the only existing use of that signal (mime filter plugin),
     // it's not really necessary, the plugin has seen those files before anyway.
     // The signal is mostly useful for the case of listing a dir with a mime filter set.
     //QCOMPARE(spyItemsFilteredByMime.count(), 1);
     //QCOMPARE(spyItemsFilteredByMime[0][0].value<KFileItemList>().count(), 4);
     spyItemsDeleted.clear();
     spyItemsFilteredByMime.clear();
 
     // Reset the filter
     qDebug() << "reset to no filter";
     m_dirModel->dirLister()->setMimeFilter(QStringList());
     m_dirModel->dirLister()->emitChanges();
 
     QCOMPARE(m_dirModel->rowCount(), oldTopLevelRowCount);
     QCOMPARE(spyItemsDeleted.count(), 0);
     QCOMPARE(spyItemsFilteredByMime.count(), 0);
 
     // The order of things changed because of filtering.
     // Fill again, so that m_fileIndex etc. are correct again.
     fillModel(true);
 }
 
 void KDirModelTest::testShowHiddenFiles() // #174788
 {
     KDirLister *dirLister = m_dirModel->dirLister();
 
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
     QSignalSpy spyNewItems(dirLister, SIGNAL(newItems(KFileItemList)));
     QSignalSpy spyRowsInserted(m_dirModel, SIGNAL(rowsInserted(QModelIndex,int,int)));
     dirLister->setShowingDotFiles(true);
     dirLister->emitChanges();
     const int numberOfDotFiles = 2;
     QCOMPARE(spyNewItems.count(), 1);
     QCOMPARE(spyNewItems[0][0].value<KFileItemList>().count(), numberOfDotFiles);
     QCOMPARE(spyRowsInserted.count(), 1);
     QCOMPARE(spyRowsRemoved.count(), 0);
     spyNewItems.clear();
     spyRowsInserted.clear();
 
     dirLister->setShowingDotFiles(false);
     dirLister->emitChanges();
     QCOMPARE(spyNewItems.count(), 0);
     QCOMPARE(spyRowsInserted.count(), 0);
     QCOMPARE(spyRowsRemoved.count(), 1);
 }
 
 void KDirModelTest::testMultipleSlashes()
 {
     const QString path = m_tempDir->path() + '/';
 
     QModelIndex index = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir//testfile"));
     QVERIFY(index.isValid());
 
     index = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir//subsubdir//"));
     QVERIFY(index.isValid());
 
     index = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir///subsubdir////testfile"));
     QVERIFY(index.isValid());
 }
 
 void KDirModelTest::testUrlWithRef() // #171117
 {
     const QString path = m_tempDir->path() + '/';
     KDirLister *dirLister = m_dirModel->dirLister();
     QUrl url = QUrl::fromLocalFile(path);
     url.setFragment(QStringLiteral("ref"));
     QVERIFY(url.url().endsWith(QLatin1String("#ref")));
     dirLister->openUrl(url, KDirLister::NoFlags);
     checkedConnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
     enterLoop();
 
     QCOMPARE(dirLister->url().toString(), url.toString(QUrl::StripTrailingSlash));
     collectKnownIndexes();
     disconnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
 }
 
 //void KDirModelTest::testFontUrlWithHost() // #160057 --> moved to kio_fonts (kfontinst/kio/autotests)
 
 void KDirModelTest::testRemoteUrlWithHost() // #178416
 {
     if (!KProtocolInfo::isKnownProtocol(QStringLiteral("remote"))) {
         QSKIP("kio_remote not installed");
     }
     QUrl url(QStringLiteral("remote://foo"));
     KDirLister *dirLister = m_dirModel->dirLister();
     dirLister->openUrl(url, KDirLister::NoFlags);
     checkedConnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
     enterLoop();
 
     QCOMPARE(dirLister->url().toString(), QString("remote:"));
 }
 
 void KDirModelTest::testZipFile() // # 171721
 {
     const QString path = QFileInfo(QFINDTESTDATA("wronglocalsizes.zip")).absolutePath();
     KDirLister *dirLister = m_dirModel->dirLister();
     dirLister->openUrl(QUrl::fromLocalFile(path), KDirLister::NoFlags);
     checkedConnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
     enterLoop();
     disconnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
 
     QUrl zipUrl(QUrl::fromLocalFile(path));
     zipUrl.setPath(zipUrl.path() + "/wronglocalsizes.zip"); // just a zip file lying here for other reasons
 
     QVERIFY(QFile::exists(zipUrl.toLocalFile()));
     zipUrl.setScheme(QStringLiteral("zip"));
     QModelIndex index = m_dirModel->indexForUrl(zipUrl);
     QVERIFY(!index.isValid()); // protocol mismatch, can't find it!
     zipUrl.setScheme(QStringLiteral("file"));
     index = m_dirModel->indexForUrl(zipUrl);
     QVERIFY(index.isValid());
 }
 
 void KDirModelTest::testSmb()
 {
     const QUrl smbUrl(QStringLiteral("smb:/"));
     // TODO: feed a KDirModel without using a KDirLister.
     // Calling the slots directly.
     // This requires that KDirModel does not ask the KDirLister for its rootItem anymore,
     // but that KDirLister emits the root item whenever it changes.
     if (!KProtocolInfo::isKnownProtocol(QStringLiteral("smb"))) {
         QSKIP("kio_smb not installed");
     }
     KDirLister *dirLister = m_dirModel->dirLister();
     dirLister->openUrl(smbUrl, KDirLister::NoFlags);
     checkedConnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
     checkedConnect(dirLister, SIGNAL(canceled()), this, SLOT(slotListingCompleted()));
     QSignalSpy spyCanceled(dirLister, SIGNAL(canceled()));
     enterLoop(); // wait for completed signal
 
-    if (spyCanceled.count() > 0) {
+    if (!spyCanceled.isEmpty()) {
         QSKIP("smb:/ returns an error, probably no network available");
     }
 
     QModelIndex index = m_dirModel->index(0, 0);
     if (index.isValid()) {
         QVERIFY(m_dirModel->canFetchMore(index));
         m_dirModel->fetchMore(index);
         enterLoop(); // wait for completed signal
         disconnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
     }
 }
 
 class MyDirLister : public KDirLister
 {
 public:
     void emitItemsDeleted(const KFileItemList &items)
     {
         emit itemsDeleted(items);
     }
 };
 
 void KDirModelTest::testBug196695()
 {
     KFileItem rootItem(QUrl::fromLocalFile(m_tempDir->path()), QString(), KFileItem::Unknown);
     KFileItem childItem(QUrl::fromLocalFile(QString(m_tempDir->path() + "/toplevelfile_1")), QString(), KFileItem::Unknown);
 
     KFileItemList list;
     // Important: the root item must not be first in the list to trigger bug 196695
     list << childItem << rootItem;
 
     MyDirLister *dirLister = static_cast<MyDirLister *>(m_dirModel->dirLister());
     dirLister->emitItemsDeleted(list);
 
     fillModel(true);
 }
 
 void KDirModelTest::testMimeData()
 {
     QModelIndex index0 = m_dirModel->index(0, 0);
     QVERIFY(index0.isValid());
     QModelIndex index1 = m_dirModel->index(1, 0);
     QVERIFY(index1.isValid());
     QList<QModelIndex> indexes;
     indexes << index0 << index1;
     QMimeData *mimeData = m_dirModel->mimeData(indexes);
     QVERIFY(mimeData);
     QVERIFY(mimeData->hasUrls());
     const QList<QUrl> urls = mimeData->urls();
     QCOMPARE(urls.count(), indexes.count());
     delete mimeData;
 }
 
 void KDirModelTest::testDotHiddenFile_data()
 {
     QTest::addColumn<QStringList>("fileContents");
     QTest::addColumn<QStringList>("expectedListing");
 
     QStringList allItems; allItems << QStringLiteral("toplevelfile_1") << QStringLiteral("toplevelfile_2") << QStringLiteral("toplevelfile_3") << SPECIALCHARS << QStringLiteral("subdir");
     QTest::newRow("empty_file") << QStringList() << allItems;
 
     QTest::newRow("simple_name") << (QStringList() << QStringLiteral("toplevelfile_1")) << QStringList(allItems.mid(1));
 
     QStringList allButSpecialChars = allItems; allButSpecialChars.removeAt(3);
     QTest::newRow("special_chars") << (QStringList() << SPECIALCHARS) << allButSpecialChars;
 
     QStringList allButSubdir = allItems; allButSubdir.removeAt(4);
     QTest::newRow("subdir") << (QStringList() << QStringLiteral("subdir")) << allButSubdir;
 
     QTest::newRow("many_lines") << (QStringList() << QStringLiteral("subdir") << QStringLiteral("toplevelfile_1") << QStringLiteral("toplevelfile_3") << QStringLiteral("toplevelfile_2"))
                                 << (QStringList() << SPECIALCHARS);
 }
 
 void KDirModelTest::testDotHiddenFile()
 {
     QFETCH(QStringList, fileContents);
     QFETCH(QStringList, expectedListing);
 
     const QString path = m_tempDir->path() + '/';
     const QString dotHiddenFile = path + ".hidden";
     QTest::qWait(1000); // mtime-based cache, so we need to wait for 1 second
     QFile dh(dotHiddenFile);
     QVERIFY(dh.open(QIODevice::WriteOnly));
     dh.write(fileContents.join('\n').toUtf8());
     dh.close();
 
     // Do it twice: once to read from the file and once to use the cache
     for (int i = 0; i < 2; ++i) {
         fillModel(true, false);
         QStringList files;
         for (int row = 0; row < m_dirModel->rowCount(); ++row) {
             files.append(m_dirModel->index(row, KDirModel::Name).data().toString());
         }
         files.sort();
         expectedListing.sort();
         QCOMPARE(files, expectedListing);
     }
 
     dh.remove();
 }
 
 void KDirModelTest::testDeleteFile()
 {
     fillModel(true);
 
     QVERIFY(m_fileIndex.isValid());
     const int oldTopLevelRowCount = m_dirModel->rowCount();
     const QString path = m_tempDir->path() + '/';
     const QString file = path + "toplevelfile_1";
     const QUrl url = QUrl::fromLocalFile(file);
 
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
     checkedConnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     KIO::DeleteJob *job = KIO::del(url, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers rowsRemoved
     enterLoop();
 
     // If we come here, then rowsRemoved() was emitted - all good.
     const int topLevelRowCount = m_dirModel->rowCount();
     QCOMPARE(topLevelRowCount, oldTopLevelRowCount - 1); // one less than before
     QCOMPARE(spyRowsRemoved.count(), 1);
     QCOMPARE(spyRowsRemoved[0][1].toInt(), m_fileIndex.row());
     QCOMPARE(spyRowsRemoved[0][2].toInt(), m_fileIndex.row());
     disconnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                &m_eventLoop, SLOT(exitLoop()));
 
     QModelIndex fileIndex = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "toplevelfile_1"));
     QVERIFY(!fileIndex.isValid());
 
     // Recreate the file, for consistency in the next tests
     // So the second part of this test is a "testCreateFile"
     createTestFile(file);
     // Tricky problem - KDirLister::openUrl will emit items from cache
     // and then schedule an update; so just calling fillModel would
     // not wait enough, it would abort due to not finding toplevelfile_1
     // in the items from cache. This progressive-emitting behavior is fine
     // for GUIs but not for unit tests ;-)
     fillModel(true, false);
     fillModel(false);
 }
 
 void KDirModelTest::testDeleteFileWhileListing() // doesn't really test that yet, the kdirwatch deleted signal comes too late
 {
     const int oldTopLevelRowCount = m_dirModel->rowCount();
     const QString path = m_tempDir->path() + '/';
     const QString file = path + "toplevelfile_1";
     const QUrl url = QUrl::fromLocalFile(file);
 
     KDirLister *dirLister = m_dirModel->dirLister();
     QSignalSpy spyCompleted(dirLister, SIGNAL(completed()));
     checkedConnect(dirLister, SIGNAL(completed()), this, SLOT(slotListingCompleted()));
     dirLister->openUrl(QUrl::fromLocalFile(path), KDirLister::NoFlags);
     if (!spyCompleted.isEmpty()) {
         QSKIP("listing completed too early");
     }
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
     KIO::DeleteJob *job = KIO::del(url, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     if (spyCompleted.isEmpty()) {
         enterLoop();
     }
     QVERIFY(spyRowsRemoved.wait(1000));
 
     const int topLevelRowCount = m_dirModel->rowCount();
     QCOMPARE(topLevelRowCount, oldTopLevelRowCount - 1); // one less than before
     QCOMPARE(spyRowsRemoved.count(), 1);
     QCOMPARE(spyRowsRemoved[0][1].toInt(), m_fileIndex.row());
     QCOMPARE(spyRowsRemoved[0][2].toInt(), m_fileIndex.row());
 
     QModelIndex fileIndex = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "toplevelfile_1"));
     QVERIFY(!fileIndex.isValid());
 
     qDebug() << "Test done, recreating file";
 
     // Recreate the file, for consistency in the next tests
     // So the second part of this test is a "testCreateFile"
     createTestFile(file);
     fillModel(true, false); // see testDeleteFile
     fillModel(false);
 }
 
 void KDirModelTest::testOverwriteFileWithDir() // #151851 c4
 {
     fillModel(false);
     const QString path = m_tempDir->path() + '/';
     const QString dir = path + "subdir";
     const QString file = path + "toplevelfile_1";
     const int oldTopLevelRowCount = m_dirModel->rowCount();
 
     bool removalWithinTopLevel = false;
     bool dataChangedAtFirstLevel = false;
     auto rrc = connect(m_dirModel, &KDirModel::rowsRemoved, this, [&removalWithinTopLevel](const QModelIndex &index) {
         if (!index.isValid()) {
             // yes, that's what we have been waiting for
             removalWithinTopLevel = true;
         }
     });
     auto dcc = connect(m_dirModel, &KDirModel::dataChanged, this, [&dataChangedAtFirstLevel](const QModelIndex &index) {
         if (index.isValid() && !index.parent().isValid()) {
             // a change of a node whose parent is root, yay, that's it
             dataChangedAtFirstLevel = true;
         }
     });
 
     checkedConnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     KIO::Job *job = KIO::move(QUrl::fromLocalFile(dir), QUrl::fromLocalFile(file), KIO::HideProgressInfo);
     job->setUiDelegate(nullptr);
     PredefinedAnswerJobUiDelegate extension;
     extension.m_renameResult = KIO::R_OVERWRITE;
     job->setUiDelegateExtension(&extension);
     QVERIFY(job->exec());
 
     QCOMPARE(extension.m_askFileRenameCalled, 1);
 
     // Wait for a removal within the top level (that's for the old file going away), and also
     // for a dataChanged which notifies us that a file has become a directory
 
     int retries = 0;
     while ((!removalWithinTopLevel || !dataChangedAtFirstLevel) && retries < 100) {
         QTest::qWait(10);
         ++retries;
     }
     QVERIFY(removalWithinTopLevel);
     QVERIFY(dataChangedAtFirstLevel);
 
     m_dirModel->disconnect(rrc);
     m_dirModel->disconnect(dcc);
 
     // If we come here, then rowsRemoved() was emitted - all good.
     const int topLevelRowCount = m_dirModel->rowCount();
     QCOMPARE(topLevelRowCount, oldTopLevelRowCount - 1); // one less than before
 
     QVERIFY(!m_dirModel->indexForUrl(QUrl::fromLocalFile(dir)).isValid());
     QModelIndex newIndex = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "toplevelfile_1"));
     QVERIFY(newIndex.isValid());
     KFileItem newItem = m_dirModel->itemForIndex(newIndex);
     QVERIFY(newItem.isDir()); // yes, the file is a dir now ;-)
 
     qDebug() << "========= Test done, recreating test data =========";
 
     recreateTestData();
     fillModel(false);
 }
 
 void KDirModelTest::testDeleteFiles()
 {
     const int oldTopLevelRowCount = m_dirModel->rowCount();
     const QString file = m_tempDir->path() + "/toplevelfile_";
     QList<QUrl> urls;
     urls << QUrl::fromLocalFile(file + '1') << QUrl::fromLocalFile(file + '2') << QUrl::fromLocalFile(file + '3');
 
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
 
     KIO::DeleteJob *job = KIO::del(urls, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     int numRowsRemoved = 0;
     while (numRowsRemoved < 3) {
 
         QTest::qWait(20);
 
         numRowsRemoved = 0;
         for (int sigNum = 0; sigNum < spyRowsRemoved.count(); ++sigNum) {
             numRowsRemoved += spyRowsRemoved[sigNum][2].toInt() - spyRowsRemoved[sigNum][1].toInt() + 1;
         }
         qDebug() << "numRowsRemoved=" << numRowsRemoved;
     }
 
     const int topLevelRowCount = m_dirModel->rowCount();
     QCOMPARE(topLevelRowCount, oldTopLevelRowCount - 3); // three less than before
 
     qDebug() << "Recreating test data";
     recreateTestData();
     qDebug() << "Re-filling model";
     fillModel(false);
 }
 
 // A renaming that looks more like a deletion to the model
 void KDirModelTest::testRenameFileToHidden() // #174721
 {
     const QUrl url = QUrl::fromLocalFile(m_tempDir->path() + "/toplevelfile_2");
     const QUrl newUrl = QUrl::fromLocalFile(m_tempDir->path() + "/.toplevelfile_2");
 
     QSignalSpy spyDataChanged(m_dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
     QSignalSpy spyRowsInserted(m_dirModel, SIGNAL(rowsInserted(QModelIndex,int,int)));
     checkedConnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     KIO::SimpleJob *job = KIO::rename(url, newUrl, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers KDirLister
     enterLoop();
 
     // If we come here, then rowsRemoved() was emitted - all good.
     QCOMPARE(spyDataChanged.count(), 0);
     QCOMPARE(spyRowsRemoved.count(), 1);
     QCOMPARE(spyRowsInserted.count(), 0);
     COMPARE_INDEXES(spyRowsRemoved[0][0].value<QModelIndex>(), QModelIndex()); // parent is invalid
     const int row = spyRowsRemoved[0][1].toInt();
     QCOMPARE(row, m_secondFileIndex.row()); // only compare row
 
     disconnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                &m_eventLoop, SLOT(exitLoop()));
     spyRowsRemoved.clear();
 
     // Put things back to normal, should make the file reappear
     checkedConnect(m_dirModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
                    &m_eventLoop, SLOT(exitLoop()));
     job = KIO::rename(newUrl, url, KIO::HideProgressInfo);
     QVERIFY(job->exec());
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers KDirLister
     enterLoop();
     QCOMPARE(spyDataChanged.count(), 0);
     QCOMPARE(spyRowsRemoved.count(), 0);
     QCOMPARE(spyRowsInserted.count(), 1);
     int newRow = spyRowsInserted[0][1].toInt();
     m_secondFileIndex = m_dirModel->index(newRow, 0);
     QVERIFY(m_secondFileIndex.isValid());
     QCOMPARE(m_dirModel->itemForIndex(m_secondFileIndex).url().toString(), url.toString());
 }
 
 void KDirModelTest::testDeleteDirectory()
 {
     const QString path = m_tempDir->path() + '/';
     const QUrl url = QUrl::fromLocalFile(path + "subdir/subsubdir");
 
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
     checkedConnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     QSignalSpy spyDirWatchDeleted(KDirWatch::self(), SIGNAL(deleted(QString)));
 
     KIO::DeleteJob *job = KIO::del(url, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers rowsRemoved
     enterLoop();
 
     // If we come here, then rowsRemoved() was emitted - all good.
     QCOMPARE(spyRowsRemoved.count(), 1);
     disconnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                &m_eventLoop, SLOT(exitLoop()));
 
     QModelIndex deletedDirIndex = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir/subsubdir"));
     QVERIFY(!deletedDirIndex.isValid());
     QModelIndex dirIndex = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "subdir"));
     QVERIFY(dirIndex.isValid());
 
     // TODO!!! Bug in KDirWatch? ###
     // QCOMPARE(spyDirWatchDeleted.count(), 1);
 }
 
 void KDirModelTest::testDeleteCurrentDirectory()
 {
     const int oldTopLevelRowCount = m_dirModel->rowCount();
     const QString path = m_tempDir->path() + '/';
     const QUrl url = QUrl::fromLocalFile(path);
 
     QSignalSpy spyRowsRemoved(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)));
     checkedConnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                    &m_eventLoop, SLOT(exitLoop()));
 
     KDirWatch::self()->statistics();
 
     KIO::DeleteJob *job = KIO::del(url, KIO::HideProgressInfo);
     QVERIFY(job->exec());
 
     // Wait for the DBUS signal from KDirNotify, it's the one the triggers rowsRemoved
     enterLoop();
 
     // If we come here, then rowsRemoved() was emitted - all good.
     const int topLevelRowCount = m_dirModel->rowCount();
     QCOMPARE(topLevelRowCount, 0); // empty
 
     // We can get rowsRemoved for subdirs first, since kdirwatch notices that.
     QVERIFY(spyRowsRemoved.count() >= 1);
 
     // Look for the signal(s) that had QModelIndex() as parent.
     int i;
     int numDeleted = 0;
     for (i = 0; i < spyRowsRemoved.count(); ++i) {
         const int from = spyRowsRemoved[i][1].toInt();
         const int to = spyRowsRemoved[i][2].toInt();
         qDebug() << spyRowsRemoved[i][0].value<QModelIndex>() << from << to;
         if (!spyRowsRemoved[i][0].value<QModelIndex>().isValid()) {
             numDeleted += (to - from) + 1;
         }
     }
 
     QCOMPARE(numDeleted, oldTopLevelRowCount);
     disconnect(m_dirModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                &m_eventLoop, SLOT(exitLoop()));
 
     QModelIndex fileIndex = m_dirModel->indexForUrl(QUrl::fromLocalFile(path + "toplevelfile_1"));
     QVERIFY(!fileIndex.isValid());
 }
 
 void KDirModelTest::testQUrlHash()
 {
     const int count = 3000;
     // Prepare an array of QUrls so that url constructing isn't part of the timing
     QVector<QUrl> urls;
     urls.resize(count);
     for (int i = 0; i < count; ++i) {
         urls[i] = QUrl("http://www.kde.org/path/" + QString::number(i));
     }
     QHash<QUrl, int> qurlHash;
     QHash<QUrl, int> kurlHash;
     QTime dt; dt.start();
     for (int i = 0; i < count; ++i) {
         qurlHash.insert(urls[i], i);
     }
     //qDebug() << "inserting" << count << "urls into QHash using old qHash:" << dt.elapsed() << "msecs";
     dt.start();
     for (int i = 0; i < count; ++i) {
         kurlHash.insert(urls[i], i);
     }
     //qDebug() << "inserting" << count << "urls into QHash using new qHash:" << dt.elapsed() << "msecs";
     // Nice results: for count=30000 I got 4515 (before) and 103 (after)
 
     dt.start();
     for (int i = 0; i < count; ++i) {
         QCOMPARE(qurlHash.value(urls[i]), i);
     }
     //qDebug() << "looking up" << count << "urls into QHash using old qHash:" << dt.elapsed() << "msecs";
     dt.start();
     for (int i = 0; i < count; ++i) {
         QCOMPARE(kurlHash.value(urls[i]), i);
     }
     //qDebug() << "looking up" << count << "urls into QHash using new qHash:" << dt.elapsed() << "msecs";
     // Nice results: for count=30000 I got 4296 (before) and 63 (after)
 }
diff --git a/src/filewidgets/kfilepreviewgenerator.cpp b/src/filewidgets/kfilepreviewgenerator.cpp
index ffeda3dc..a36bf296 100644
--- a/src/filewidgets/kfilepreviewgenerator.cpp
+++ b/src/filewidgets/kfilepreviewgenerator.cpp
@@ -1,1283 +1,1283 @@
 /*******************************************************************************
  *   Copyright (C) 2008-2009 by Peter Penz <peter.penz@gmx.at>                 *
  *                                                                             *
  *   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 "kfilepreviewgenerator.h"
 
 #include "defaultviewadapter_p.h"
 #include <imagefilter_p.h> // from kiowidgets
 #include <config-kiofilewidgets.h> // for HAVE_XRENDER
 #include <kconfiggroup.h>
 #include <kfileitem.h>
 #include <kiconeffect.h>
 #include <kio/previewjob.h>
 #include <kio/paste.h>
 #include <kdirlister.h>
 #include <kdirmodel.h>
 #include <kiconloader.h>
 #include <ksharedconfig.h>
 #include <kurlmimedata.h>
 
 #include <QApplication>
 #include <QAbstractItemView>
 #include <QAbstractProxyModel>
 #include <QClipboard>
 #include <QColor>
 #include <QHash>
 #include <QList>
 #include <QListView>
 #include <QMimeData>
 #include <QPainter>
 #include <QPixmap>
 #include <QPointer>
 #include <QTimer>
 #include <QScrollBar>
 #include <QIcon>
 
 #if HAVE_X11 && HAVE_XRENDER
 #  include <QX11Info>
 #  include <X11/Xlib.h>
 #  include <X11/extensions/Xrender.h>
 #endif
 
 /**
  * If the passed item view is an instance of QListView, expensive
  * layout operations are blocked in the constructor and are unblocked
  * again in the destructor.
  *
  * This helper class is a workaround for the following huge performance
  * problem when having directories with several 1000 items:
  * - each change of an icon emits a dataChanged() signal from the model
  * - QListView iterates through all items on each dataChanged() signal
  *   and invokes QItemDelegate::sizeHint()
  * - the sizeHint() implementation of KFileItemDelegate is quite complex,
  *   invoking it 1000 times for each icon change might block the UI
  *
  * QListView does not invoke QItemDelegate::sizeHint() when the
  * uniformItemSize property has been set to true, so this property is
  * set before exchanging a block of icons.
  */
 class KFilePreviewGenerator::LayoutBlocker
 {
 public:
     LayoutBlocker(QAbstractItemView *view) :
         m_uniformSizes(false),
         m_view(qobject_cast<QListView *>(view))
     {
         if (m_view != nullptr) {
             m_uniformSizes = m_view->uniformItemSizes();
             m_view->setUniformItemSizes(true);
         }
     }
 
     ~LayoutBlocker()
     {
         if (m_view != nullptr) {
             m_view->setUniformItemSizes(m_uniformSizes);
             /* The QListView did the layout with uniform item
              * sizes, so trigger a relayout with the expected sizes. */
             if (!m_uniformSizes) {
                 m_view->setGridSize(m_view->gridSize());
             }
         }
     }
 
 private:
     bool m_uniformSizes;
     QListView *m_view;
 };
 
 /** Helper class for drawing frames for image previews. */
 class KFilePreviewGenerator::TileSet
 {
 public:
     enum { LeftMargin = 3, TopMargin = 2, RightMargin = 3, BottomMargin = 4 };
 
     enum Tile { TopLeftCorner = 0, TopSide, TopRightCorner, LeftSide,
                 RightSide, BottomLeftCorner, BottomSide, BottomRightCorner,
                 NumTiles
               };
 
     TileSet()
     {
         QImage image(8 * 3, 8 * 3, QImage::Format_ARGB32_Premultiplied);
 
         QPainter p(&image);
         p.setCompositionMode(QPainter::CompositionMode_Source);
         p.fillRect(image.rect(), Qt::transparent);
         p.fillRect(image.rect().adjusted(3, 3, -3, -3), Qt::black);
         p.end();
 
         KIO::ImageFilter::shadowBlur(image, 3, Qt::black);
 
         QPixmap pixmap = QPixmap::fromImage(image);
         m_tiles[TopLeftCorner]     = pixmap.copy(0, 0, 8, 8);
         m_tiles[TopSide]           = pixmap.copy(8, 0, 8, 8);
         m_tiles[TopRightCorner]    = pixmap.copy(16, 0, 8, 8);
         m_tiles[LeftSide]          = pixmap.copy(0, 8, 8, 8);
         m_tiles[RightSide]         = pixmap.copy(16, 8, 8, 8);
         m_tiles[BottomLeftCorner]  = pixmap.copy(0, 16, 8, 8);
         m_tiles[BottomSide]        = pixmap.copy(8, 16, 8, 8);
         m_tiles[BottomRightCorner] = pixmap.copy(16, 16, 8, 8);
     }
 
     void paint(QPainter *p, const QRect &r)
     {
         p->drawPixmap(r.topLeft(), m_tiles[TopLeftCorner]);
         if (r.width() - 16 > 0) {
             p->drawTiledPixmap(r.x() + 8, r.y(), r.width() - 16, 8, m_tiles[TopSide]);
         }
         p->drawPixmap(r.right() - 8 + 1, r.y(), m_tiles[TopRightCorner]);
         if (r.height() - 16 > 0) {
             p->drawTiledPixmap(r.x(), r.y() + 8, 8, r.height() - 16,  m_tiles[LeftSide]);
             p->drawTiledPixmap(r.right() - 8 + 1, r.y() + 8, 8, r.height() - 16, m_tiles[RightSide]);
         }
         p->drawPixmap(r.x(), r.bottom() - 8 + 1, m_tiles[BottomLeftCorner]);
         if (r.width() - 16 > 0) {
             p->drawTiledPixmap(r.x() + 8, r.bottom() - 8 + 1, r.width() - 16, 8, m_tiles[BottomSide]);
         }
         p->drawPixmap(r.right() - 8 + 1, r.bottom() - 8 + 1, m_tiles[BottomRightCorner]);
 
         const QRect contentRect = r.adjusted(LeftMargin + 1, TopMargin + 1,
                                              -(RightMargin + 1), -(BottomMargin + 1));
         p->fillRect(contentRect, Qt::transparent);
     }
 
 private:
     QPixmap m_tiles[NumTiles];
 };
 
 class Q_DECL_HIDDEN KFilePreviewGenerator::Private
 {
 public:
     Private(KFilePreviewGenerator *parent,
             KAbstractViewAdapter *viewAdapter,
             QAbstractItemModel *model);
     ~Private();
 
     /**
      * Requests a new icon for the item \a index.
      * @param sequenceIndex If this is zero, the standard icon is requested, else another one.
      */
     void requestSequenceIcon(const QModelIndex &index, int sequenceIndex);
 
     /**
      * Generates previews for the items \a items asynchronously.
      */
     void updateIcons(const KFileItemList &items);
 
     /**
      * Generates previews for the indices within \a topLeft
      * and \a bottomRight asynchronously.
      */
     void updateIcons(const QModelIndex &topLeft, const QModelIndex &bottomRight);
 
     /**
      * Adds the preview \a pixmap for the item \a item to the preview
      * queue and starts a timer which will dispatch the preview queue
      * later.
      */
     void addToPreviewQueue(const KFileItem &item, const QPixmap &pixmap);
 
     /**
      * Is invoked when the preview job has been finished and
      * removes the job from the m_previewJobs list.
      */
     void slotPreviewJobFinished(KJob *job);
 
     /** Synchronizes the icon of all items with the clipboard of cut items. */
     void updateCutItems();
 
     /**
      * Reset all icons of the items from m_cutItemsCache and clear
      * the cache.
      */
     void clearCutItemsCache();
 
     /**
      * Dispatches the preview queue  block by block within
      * time slices.
      */
     void dispatchIconUpdateQueue();
 
     /**
      * Pauses all icon updates and invokes KFilePreviewGenerator::resumeIconUpdates()
      * after a short delay. Is invoked as soon as the user has moved
      * a scrollbar.
      */
     void pauseIconUpdates();
 
     /**
      * Resumes the icons updates that have been paused after moving the
      * scrollbar. The previews for the current visible area are
      * generated first.
      */
     void resumeIconUpdates();
 
     /**
      * Starts the resolving of the MIME types from
      * the m_pendingItems queue.
      */
     void startMimeTypeResolving();
 
     /**
      * Resolves the MIME type for exactly one item of the
      * m_pendingItems queue.
      */
     void resolveMimeType();
 
     /**
      * Returns true, if the item \a item has been cut into
      * the clipboard.
      */
     bool isCutItem(const KFileItem &item) const;
 
     /**
      * Applies a cut-item effect to all given \a items, if they
      * are marked as cut in the clipboard.
      */
     void applyCutItemEffect(const KFileItemList &items);
 
     /**
      * Applies a frame around the icon. False is returned if
      * no frame has been added because the icon is too small.
      */
     bool applyImageFrame(QPixmap &icon);
 
     /**
      * Resizes the icon to \a maxSize if the icon size does not
      * fit into the maximum size. The aspect ratio of the icon
      * is kept.
      */
     void limitToSize(QPixmap &icon, const QSize &maxSize);
 
     /**
      * Creates previews by starting new preview jobs for the items
      * and triggers the preview timer.
      */
     void createPreviews(const KFileItemList &items);
 
     /**
      * Helper method for createPreviews(): Starts a preview job for the given
      * items. For each returned preview addToPreviewQueue() will get invoked.
      */
     void startPreviewJob(const KFileItemList &items, int width, int height);
 
     /** Kills all ongoing preview jobs. */
     void killPreviewJobs();
 
     /**
      * Orders the items \a items in a way that the visible items
      * are moved to the front of the list. When passing this
      * list to a preview job, the visible items will get generated
      * first.
      */
     void orderItems(KFileItemList &items);
 
     /**
      * Helper method for KFilePreviewGenerator::updateIcons(). Adds
      * recursively all items from the model to the list \a list.
      */
     void addItemsToList(const QModelIndex &index, KFileItemList &list);
 
     /**
      * Updates the icons of files that are constantly changed due to a copy
      * operation. See m_changedItems and m_changedItemsTimer for details.
      */
     void delayedIconUpdate();
 
     /**
      * Any items that are removed from the model are also removed from m_changedItems.
      */
     void rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end);
 
     /** Remembers the pixmap for an item specified by an URL. */
     struct ItemInfo {
         QUrl url;
         QPixmap pixmap;
     };
 
     /**
      * During the lifetime of a DataChangeObtainer instance changing
      * the data of the model won't trigger generating a preview.
      */
     class DataChangeObtainer
     {
     public:
         DataChangeObtainer(KFilePreviewGenerator::Private *generator) :
             m_gen(generator)
         {
             ++m_gen->m_internalDataChange;
         }
         ~DataChangeObtainer()
         {
             --m_gen->m_internalDataChange;
         }
     private:
         KFilePreviewGenerator::Private *m_gen;
     };
 
     bool m_previewShown;
 
     /**
      * True, if m_pendingItems and m_dispatchedItems should be
      * cleared when the preview jobs have been finished.
      */
     bool m_clearItemQueues;
 
     /**
      * True if a selection has been done which should cut items.
      */
     bool m_hasCutSelection;
 
     /**
      * True if the updates of icons has been paused by pauseIconUpdates().
      * The value is reset by resumeIconUpdates().
      */
     bool m_iconUpdatesPaused;
 
     /**
      * If the value is 0, the slot
      * updateIcons(const QModelIndex&, const QModelIndex&) has
      * been triggered by an external data change.
      */
     int m_internalDataChange;
 
     int m_pendingVisibleIconUpdates;
 
     KAbstractViewAdapter *m_viewAdapter;
     QAbstractItemView *m_itemView;
     QTimer *m_iconUpdateTimer;
     QTimer *m_scrollAreaTimer;
     QList<KJob *> m_previewJobs;
     QPointer<KDirModel> m_dirModel;
     QAbstractProxyModel *m_proxyModel;
 
     /**
       * Set of all items that already have the 'cut' effect applied, together with the pixmap it was applied to
       * This is used to make sure that the 'cut' effect is applied max. once for each pixmap
       *
       * Referencing the pixmaps here imposes no overhead, as they were also given to KDirModel::setData(),
       * and thus are held anyway.
       */
     QHash<QUrl, QPixmap> m_cutItemsCache;
     QList<ItemInfo> m_previews;
     QMap<QUrl, int> m_sequenceIndices;
 
     /**
      * When huge items are copied, it must be prevented that a preview gets generated
      * for each item size change. m_changedItems keeps track of the changed items and it
      * is assured that a final preview is only done if an item does not change within
      * at least 5 seconds.
      */
     QHash<QUrl, bool> m_changedItems;
     QTimer *m_changedItemsTimer;
 
     /**
      * Contains all items where a preview must be generated, but
      * where the preview job has not dispatched the items yet.
      */
     KFileItemList m_pendingItems;
 
     /**
      * Contains all items, where a preview has already been
      * generated by the preview jobs.
      */
     KFileItemList m_dispatchedItems;
 
     KFileItemList m_resolvedMimeTypes;
 
     QStringList m_enabledPlugins;
 
     TileSet *m_tileSet;
 
 private:
     KFilePreviewGenerator *const q;
 
 };
 
 KFilePreviewGenerator::Private::Private(KFilePreviewGenerator *parent,
                                         KAbstractViewAdapter *viewAdapter,
                                         QAbstractItemModel *model) :
     m_previewShown(true),
     m_clearItemQueues(true),
     m_hasCutSelection(false),
     m_iconUpdatesPaused(false),
     m_internalDataChange(0),
     m_pendingVisibleIconUpdates(0),
     m_viewAdapter(viewAdapter),
     m_itemView(nullptr),
     m_iconUpdateTimer(nullptr),
     m_scrollAreaTimer(nullptr),
     m_previewJobs(),
     m_proxyModel(nullptr),
     m_cutItemsCache(),
     m_previews(),
     m_sequenceIndices(),
     m_changedItems(),
     m_changedItemsTimer(nullptr),
     m_pendingItems(),
     m_dispatchedItems(),
     m_resolvedMimeTypes(),
     m_enabledPlugins(),
     m_tileSet(nullptr),
     q(parent)
 {
     if (!m_viewAdapter->iconSize().isValid()) {
         m_previewShown = false;
     }
 
     m_proxyModel = qobject_cast<QAbstractProxyModel *>(model);
     m_dirModel = (m_proxyModel == nullptr) ?
                  qobject_cast<KDirModel *>(model) :
                  qobject_cast<KDirModel *>(m_proxyModel->sourceModel());
     if (!m_dirModel) {
         // previews can only get generated for directory models
         m_previewShown = false;
     } else {
         KDirModel *dirModel = m_dirModel.data();
         connect(dirModel->dirLister(), SIGNAL(newItems(KFileItemList)),
                 q, SLOT(updateIcons(KFileItemList)));
         connect(dirModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                 q, SLOT(updateIcons(QModelIndex,QModelIndex)));
         connect(dirModel, SIGNAL(needSequenceIcon(QModelIndex,int)),
                 q, SLOT(requestSequenceIcon(QModelIndex,int)));
         connect(dirModel, SIGNAL(rowsAboutToBeRemoved(QModelIndex,int,int)),
                 q, SLOT(rowsAboutToBeRemoved(QModelIndex,int,int)));
     }
 
     QClipboard *clipboard = QApplication::clipboard();
     connect(clipboard, SIGNAL(dataChanged()),
             q, SLOT(updateCutItems()));
 
     m_iconUpdateTimer = new QTimer(q);
     m_iconUpdateTimer->setSingleShot(true);
     m_iconUpdateTimer->setInterval(200);
     connect(m_iconUpdateTimer, SIGNAL(timeout()), q, SLOT(dispatchIconUpdateQueue()));
 
     // Whenever the scrollbar values have been changed, the pending previews should
     // be reordered in a way that the previews for the visible items are generated
     // first. The reordering is done with a small delay, so that during moving the
     // scrollbars the CPU load is kept low.
     m_scrollAreaTimer = new QTimer(q);
     m_scrollAreaTimer->setSingleShot(true);
     m_scrollAreaTimer->setInterval(200);
     connect(m_scrollAreaTimer, SIGNAL(timeout()),
             q, SLOT(resumeIconUpdates()));
     m_viewAdapter->connect(KAbstractViewAdapter::IconSizeChanged,
                            q, SLOT(updateIcons()));
     m_viewAdapter->connect(KAbstractViewAdapter::ScrollBarValueChanged,
                            q, SLOT(pauseIconUpdates()));
 
     m_changedItemsTimer = new QTimer(q);
     m_changedItemsTimer->setSingleShot(true);
     m_changedItemsTimer->setInterval(5000);
     connect(m_changedItemsTimer, SIGNAL(timeout()),
             q, SLOT(delayedIconUpdate()));
 
     KConfigGroup globalConfig(KSharedConfig::openConfig(QStringLiteral("dolphinrc")), "PreviewSettings");
     m_enabledPlugins = globalConfig.readEntry("Plugins", QStringList{
                                                               QStringLiteral("directorythumbnail"),
                                                               QStringLiteral("imagethumbnail"),
                                                               QStringLiteral("jpegthumbnail")});
 
     // Compatibility update: in 4.7, jpegrotatedthumbnail was merged into (or
     // replaced with?) jpegthumbnail
     if (m_enabledPlugins.contains(QStringLiteral("jpegrotatedthumbnail"))) {
         m_enabledPlugins.removeAll(QStringLiteral("jpegrotatedthumbnail"));
         m_enabledPlugins.append(QStringLiteral("jpegthumbnail"));
         globalConfig.writeEntry("Plugins", m_enabledPlugins);
         globalConfig.sync();
     }
 }
 
 KFilePreviewGenerator::Private::~Private()
 {
     killPreviewJobs();
     m_pendingItems.clear();
     m_dispatchedItems.clear();
     delete m_tileSet;
 }
 
 void KFilePreviewGenerator::Private::requestSequenceIcon(const QModelIndex &index,
         int sequenceIndex)
 {
     if (m_pendingItems.isEmpty() || (sequenceIndex == 0)) {
         KDirModel *dirModel = m_dirModel.data();
         if (!dirModel) {
             return;
         }
 
         KFileItem item = dirModel->itemForIndex(index);
         if (sequenceIndex == 0) {
             m_sequenceIndices.remove(item.url());
         } else {
             m_sequenceIndices.insert(item.url(), sequenceIndex);
         }
 
         ///@todo Update directly, without using m_sequenceIndices
         updateIcons(KFileItemList() << item);
     }
 }
 
 void KFilePreviewGenerator::Private::updateIcons(const KFileItemList &items)
 {
     if (items.isEmpty()) {
         return;
     }
 
     applyCutItemEffect(items);
 
     KFileItemList orderedItems = items;
     orderItems(orderedItems);
 
     m_pendingItems.reserve(m_pendingItems.size() + orderedItems.size());
     foreach (const KFileItem &item, orderedItems) {
         m_pendingItems.append(item);
     }
 
     if (m_previewShown) {
         createPreviews(orderedItems);
     } else {
         startMimeTypeResolving();
     }
 }
 
 void KFilePreviewGenerator::Private::updateIcons(const QModelIndex &topLeft,
         const QModelIndex &bottomRight)
 {
     if (m_internalDataChange > 0) {
         // QAbstractItemModel::setData() has been invoked internally by the KFilePreviewGenerator.
         // The signal dataChanged() is connected with this method, but previews only need
         // to be generated when an external data change has occurred.
         return;
     }
 
     // dataChanged emitted for the root dir (e.g. permission changes)
     if (!topLeft.isValid() || !bottomRight.isValid()) {
         return;
     }
 
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     KFileItemList itemList;
     for (int row = topLeft.row(); row <= bottomRight.row(); ++row) {
         const QModelIndex index = dirModel->index(row, 0);
         if (!index.isValid()) {
             continue;
         }
         const KFileItem item = dirModel->itemForIndex(index);
         Q_ASSERT(!item.isNull());
 
         if (m_previewShown) {
             const QUrl url = item.url();
             const bool hasChanged = m_changedItems.contains(url); // O(1)
             m_changedItems.insert(url, hasChanged);
             if (!hasChanged) {
                 // only update the icon if it has not been already updated within
                 // the last 5 seconds (the other icons will be updated later with
                 // the help of m_changedItemsTimer)
                 itemList.append(item);
             }
         } else {
             itemList.append(item);
         }
     }
 
     updateIcons(itemList);
     m_changedItemsTimer->start();
 }
 
 void KFilePreviewGenerator::Private::addToPreviewQueue(const KFileItem &item, const QPixmap &pixmap)
 {
     KIO::PreviewJob *senderJob = qobject_cast<KIO::PreviewJob *>(q->sender());
     Q_ASSERT(senderJob != nullptr);
     if (senderJob != nullptr) {
         QMap<QUrl, int>::iterator it = m_sequenceIndices.find(item.url());
         if (senderJob->sequenceIndex() && (it == m_sequenceIndices.end() || *it != senderJob->sequenceIndex())) {
             return; // the sequence index does not match the one we want
         }
         if (!senderJob->sequenceIndex() && it != m_sequenceIndices.end()) {
             return; // the sequence index does not match the one we want
         }
 
         m_sequenceIndices.erase(it);
     }
 
     if (!m_previewShown) {
         // the preview has been canceled in the meantime
         return;
     }
 
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     // check whether the item is part of the directory lister (it is possible
     // that a preview from an old directory lister is received)
     bool isOldPreview = true;
 
     const QUrl itemParentDir = item.url().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
 
     foreach (const QUrl &dir, dirModel->dirLister()->directories()) {
         if (dir == itemParentDir || dir.path().isEmpty()) {
             isOldPreview = false;
             break;
         }
     }
     if (isOldPreview) {
         return;
     }
 
     QPixmap icon = pixmap;
 
     const QString mimeType = item.mimetype();
     const int slashIndex = mimeType.indexOf(QLatin1Char('/'));
     const QStringRef mimeTypeGroup = mimeType.leftRef(slashIndex);
     if ((mimeTypeGroup != QLatin1String("image")) || !applyImageFrame(icon)) {
         limitToSize(icon, m_viewAdapter->iconSize());
     }
 
     if (m_hasCutSelection && isCutItem(item)) {
         // apply the disabled effect to the icon for marking it as "cut item"
         // and apply the icon to the item
         KIconEffect *iconEffect = KIconLoader::global()->iconEffect();
         icon = iconEffect->apply(icon, KIconLoader::Desktop, KIconLoader::DisabledState);
     }
 
     KIconLoader::global()->drawOverlays(item.overlays(), icon, KIconLoader::Desktop);
 
     // remember the preview and URL, so that it can be applied to the model
     // in KFilePreviewGenerator::dispatchIconUpdateQueue()
     ItemInfo preview;
     preview.url = item.url();
     preview.pixmap = icon;
     m_previews.append(preview);
 
     m_pendingItems.removeOne(item);
 
     m_dispatchedItems.append(item);
 }
 
 void KFilePreviewGenerator::Private::slotPreviewJobFinished(KJob *job)
 {
     const int index = m_previewJobs.indexOf(job);
     m_previewJobs.removeAt(index);
 
     if (m_previewJobs.isEmpty()) {
         foreach (const KFileItem &item, m_pendingItems) {
             if (item.isMimeTypeKnown()) {
                 m_resolvedMimeTypes.append(item);
             }
         }
 
         if (m_clearItemQueues) {
             m_pendingItems.clear();
             m_dispatchedItems.clear();
             m_pendingVisibleIconUpdates = 0;
             QMetaObject::invokeMethod(q, "dispatchIconUpdateQueue", Qt::QueuedConnection);
         }
         m_sequenceIndices.clear(); // just to be sure that we don't leak anything
     }
 }
 
 void KFilePreviewGenerator::Private::updateCutItems()
 {
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     DataChangeObtainer obt(this);
     clearCutItemsCache();
 
     KFileItemList items;
     KDirLister *dirLister = dirModel->dirLister();
     const QList<QUrl> dirs = dirLister->directories();
     items.reserve(dirs.size());
     foreach (const QUrl &url, dirs) {
         items << dirLister->itemsForDir(url);
     }
     applyCutItemEffect(items);
 }
 
 void KFilePreviewGenerator::Private::clearCutItemsCache()
 {
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     DataChangeObtainer obt(this);
     KFileItemList previews;
     // Reset the icons of all items that are stored in the cache
     // to use their default MIME type icon.
     foreach (const QUrl &url, m_cutItemsCache.keys()) {
         const QModelIndex index = dirModel->indexForUrl(url);
         if (index.isValid()) {
             dirModel->setData(index, QIcon(), Qt::DecorationRole);
             if (m_previewShown) {
                 previews.append(dirModel->itemForIndex(index));
             }
         }
     }
     m_cutItemsCache.clear();
 
-    if (previews.size() > 0) {
+    if (!previews.isEmpty()) {
         // assure that the previews gets restored
         Q_ASSERT(m_previewShown);
         orderItems(previews);
         updateIcons(previews);
     }
 }
 
 void KFilePreviewGenerator::Private::dispatchIconUpdateQueue()
 {
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     const int count = m_previews.count() + m_resolvedMimeTypes.count();
     if (count > 0) {
         LayoutBlocker blocker(m_itemView);
         DataChangeObtainer obt(this);
 
         if (m_previewShown) {
             // dispatch preview queue
             foreach (const ItemInfo &preview, m_previews) {
                 const QModelIndex idx = dirModel->indexForUrl(preview.url);
                 if (idx.isValid() && (idx.column() == 0)) {
                     dirModel->setData(idx, QIcon(preview.pixmap), Qt::DecorationRole);
                 }
             }
             m_previews.clear();
         }
 
         // dispatch mime type queue
         foreach (const KFileItem &item, m_resolvedMimeTypes) {
             const QModelIndex idx = dirModel->indexForItem(item);
             dirModel->itemChanged(idx);
         }
         m_resolvedMimeTypes.clear();
 
         m_pendingVisibleIconUpdates -= count;
         if (m_pendingVisibleIconUpdates < 0) {
             m_pendingVisibleIconUpdates = 0;
         }
     }
 
     if (m_pendingVisibleIconUpdates > 0) {
         // As long as there are pending previews for visible items, poll
         // the preview queue periodically. If there are no pending previews,
         // the queue is dispatched in slotPreviewJobFinished().
         m_iconUpdateTimer->start();
     }
 }
 
 void KFilePreviewGenerator::Private::pauseIconUpdates()
 {
     m_iconUpdatesPaused = true;
     foreach (KJob *job, m_previewJobs) {
         Q_ASSERT(job != nullptr);
         job->suspend();
     }
     m_scrollAreaTimer->start();
 }
 
 void KFilePreviewGenerator::Private::resumeIconUpdates()
 {
     m_iconUpdatesPaused = false;
 
     // Before creating new preview jobs the m_pendingItems queue must be
     // cleaned up by removing the already dispatched items. Implementation
     // note: The order of the m_dispatchedItems queue and the m_pendingItems
     // queue is usually equal. So even when having a lot of elements the
     // nested loop is no performance bottle neck, as the inner loop is only
     // entered once in most cases.
     foreach (const KFileItem &item, m_dispatchedItems) {
         KFileItemList::iterator begin = m_pendingItems.begin();
         KFileItemList::iterator end   = m_pendingItems.end();
         for (KFileItemList::iterator it = begin; it != end; ++it) {
             if ((*it).url() == item.url()) {
                 m_pendingItems.erase(it);
                 break;
             }
         }
     }
     m_dispatchedItems.clear();
 
     m_pendingVisibleIconUpdates = 0;
     dispatchIconUpdateQueue();
 
     if (m_previewShown) {
         KFileItemList orderedItems = m_pendingItems;
         orderItems(orderedItems);
 
         // Kill all suspended preview jobs. Usually when a preview job
         // has been finished, slotPreviewJobFinished() clears all item queues.
         // This is not wanted in this case, as a new job is created afterwards
         // for m_pendingItems.
         m_clearItemQueues = false;
         killPreviewJobs();
         m_clearItemQueues = true;
 
         createPreviews(orderedItems);
     } else {
         orderItems(m_pendingItems);
         startMimeTypeResolving();
     }
 }
 
 void KFilePreviewGenerator::Private::startMimeTypeResolving()
 {
     resolveMimeType();
     m_iconUpdateTimer->start();
 }
 
 void KFilePreviewGenerator::Private::resolveMimeType()
 {
     if (m_pendingItems.isEmpty()) {
         return;
     }
 
     // resolve at least one MIME type
     bool resolved = false;
     do {
         KFileItem item = m_pendingItems.takeFirst();
         if (item.isMimeTypeKnown()) {
             if (m_pendingVisibleIconUpdates > 0) {
                 // The item is visible and the MIME type already known.
                 // Decrease the update counter for dispatchIconUpdateQueue():
                 --m_pendingVisibleIconUpdates;
             }
         } else {
             // The MIME type is unknown and must get resolved. The
             // directory model is not informed yet, as a single update
             // would be very expensive. Instead the item is remembered in
             // m_resolvedMimeTypes and will be dispatched later
             // by dispatchIconUpdateQueue().
             item.determineMimeType();
             m_resolvedMimeTypes.append(item);
             resolved = true;
         }
     } while (!resolved && !m_pendingItems.isEmpty());
 
     if (m_pendingItems.isEmpty()) {
         // All MIME types have been resolved now. Assure
         // that the directory model gets informed about
         // this, so that an update of the icons is done.
         dispatchIconUpdateQueue();
     } else if (!m_iconUpdatesPaused) {
         // assure that the MIME type of the next
         // item will be resolved asynchronously
         QMetaObject::invokeMethod(q, "resolveMimeType", Qt::QueuedConnection);
     }
 }
 
 bool KFilePreviewGenerator::Private::isCutItem(const KFileItem &item) const
 {
     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
     const QList<QUrl> cutUrls = KUrlMimeData::urlsFromMimeData(mimeData);
     return cutUrls.contains(item.url());
 }
 
 void KFilePreviewGenerator::Private::applyCutItemEffect(const KFileItemList &items)
 {
     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
     m_hasCutSelection = mimeData && KIO::isClipboardDataCut(mimeData);
     if (!m_hasCutSelection) {
         return;
     }
 
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     const QSet<QUrl> cutUrls = KUrlMimeData::urlsFromMimeData(mimeData).toSet();
 
     DataChangeObtainer obt(this);
     KIconEffect *iconEffect = KIconLoader::global()->iconEffect();
     foreach (const KFileItem &item, items) {
         if (cutUrls.contains(item.url())) {
             const QModelIndex index = dirModel->indexForItem(item);
             const QVariant value = dirModel->data(index, Qt::DecorationRole);
             if (value.type() == QVariant::Icon) {
                 const QIcon icon(qvariant_cast<QIcon>(value));
                 const QSize actualSize = icon.actualSize(m_viewAdapter->iconSize());
                 QPixmap pixmap = icon.pixmap(actualSize);
 
                 const QHash<QUrl, QPixmap>::const_iterator cacheIt = m_cutItemsCache.constFind(item.url());
                 if ((cacheIt == m_cutItemsCache.constEnd()) || (cacheIt->cacheKey() != pixmap.cacheKey())) {
                     pixmap = iconEffect->apply(pixmap, KIconLoader::Desktop, KIconLoader::DisabledState);
                     dirModel->setData(index, QIcon(pixmap), Qt::DecorationRole);
 
                     m_cutItemsCache.insert(item.url(), pixmap);
                 }
             }
         }
     }
 }
 
 bool KFilePreviewGenerator::Private::applyImageFrame(QPixmap &icon)
 {
     const QSize maxSize = m_viewAdapter->iconSize();
     const bool applyFrame = (maxSize.width()  > KIconLoader::SizeSmallMedium) &&
                             (maxSize.height() > KIconLoader::SizeSmallMedium) &&
                             !icon.hasAlpha();
     if (!applyFrame) {
         // the maximum size or the image itself is too small for a frame
         return false;
     }
 
     // resize the icon to the maximum size minus the space required for the frame
     const QSize size(maxSize.width() - TileSet::LeftMargin - TileSet::RightMargin,
                      maxSize.height() - TileSet::TopMargin - TileSet::BottomMargin);
     limitToSize(icon, size);
 
     if (m_tileSet == nullptr) {
         m_tileSet = new TileSet();
     }
 
     QPixmap framedIcon(icon.size().width() + TileSet::LeftMargin + TileSet::RightMargin,
                        icon.size().height() + TileSet::TopMargin + TileSet::BottomMargin);
     framedIcon.fill(Qt::transparent);
 
     QPainter painter;
     painter.begin(&framedIcon);
     painter.setCompositionMode(QPainter::CompositionMode_Source);
     m_tileSet->paint(&painter, framedIcon.rect());
     painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
     painter.drawPixmap(TileSet::LeftMargin, TileSet::TopMargin, icon);
     painter.end();
 
     icon = framedIcon;
     return true;
 }
 
 void KFilePreviewGenerator::Private::limitToSize(QPixmap &icon, const QSize &maxSize)
 {
     if ((icon.width() > maxSize.width()) || (icon.height() > maxSize.height())) {
 #pragma message("Cannot use XRender with QPixmap anymore. Find equivalent with Qt API.")
 #if 0 // HAVE_X11 && HAVE_XRENDER
         // Assume that the texture size limit is 2048x2048
         if ((icon.width() <= 2048) && (icon.height() <= 2048) && icon.x11PictureHandle()) {
             QSize size = icon.size();
             size.scale(maxSize, Qt::KeepAspectRatio);
 
             const qreal factor = size.width() / qreal(icon.width());
 
             XTransform xform = {{
                     { XDoubleToFixed(1 / factor), 0, 0 },
                     { 0, XDoubleToFixed(1 / factor), 0 },
                     { 0, 0, XDoubleToFixed(1) }
                 }
             };
 
             QPixmap pixmap(size);
             pixmap.fill(Qt::transparent);
 
             Display *dpy = QX11Info::display();
 
             XRenderPictureAttributes attr;
             attr.repeat = RepeatPad;
             XRenderChangePicture(dpy, icon.x11PictureHandle(), CPRepeat, &attr);
 
             XRenderSetPictureFilter(dpy, icon.x11PictureHandle(), FilterBilinear, 0, 0);
             XRenderSetPictureTransform(dpy, icon.x11PictureHandle(), &xform);
             XRenderComposite(dpy, PictOpOver, icon.x11PictureHandle(), None, pixmap.x11PictureHandle(),
                              0, 0, 0, 0, 0, 0, pixmap.width(), pixmap.height());
             icon = pixmap;
         } else {
             icon = icon.scaled(maxSize, Qt::KeepAspectRatio, Qt::FastTransformation);
         }
 #else
         icon = icon.scaled(maxSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
 #endif
     }
 }
 
 void KFilePreviewGenerator::Private::createPreviews(const KFileItemList &items)
 {
     if (items.count() == 0) {
         return;
     }
 
     const QMimeData *mimeData = QApplication::clipboard()->mimeData();
     m_hasCutSelection = mimeData && KIO::isClipboardDataCut(mimeData);
 
     // PreviewJob internally caches items always with the size of
     // 128 x 128 pixels or 256 x 256 pixels. A downscaling is done
     // by PreviewJob if a smaller size is requested. For images KFilePreviewGenerator must
     // do a downscaling anyhow because of the frame, so in this case only the provided
     // cache sizes are requested.
     KFileItemList imageItems;
     KFileItemList otherItems;
     QString mimeType;
     foreach (const KFileItem &item, items) {
         mimeType = item.mimetype();
         const int slashIndex = mimeType.indexOf(QLatin1Char('/'));
         const QStringRef mimeTypeGroup = mimeType.leftRef(slashIndex);
         if (mimeTypeGroup == QLatin1String("image")) {
             imageItems.append(item);
         } else {
             otherItems.append(item);
         }
     }
     const QSize size = m_viewAdapter->iconSize();
     startPreviewJob(otherItems, size.width(), size.height());
 
     const int cacheSize = (size.width() > 128) || (size.height() > 128) ? 256 : 128;
     startPreviewJob(imageItems, cacheSize, cacheSize);
 
     m_iconUpdateTimer->start();
 }
 
 void KFilePreviewGenerator::Private::startPreviewJob(const KFileItemList &items, int width, int height)
 {
-    if (items.count() > 0) {
+    if (!items.isEmpty()) {
         KIO::PreviewJob *job = KIO::filePreview(items, QSize(width, height), &m_enabledPlugins);
 
         // Set the sequence index to the target. We only need to check if items.count() == 1,
         // because requestSequenceIcon(..) creates exactly such a request.
         if (!m_sequenceIndices.isEmpty() && (items.count() == 1)) {
             QMap<QUrl, int>::iterator it = m_sequenceIndices.find(items[0].url());
             if (it != m_sequenceIndices.end()) {
                 job->setSequenceIndex(*it);
             }
         }
 
         connect(job, SIGNAL(gotPreview(KFileItem,QPixmap)),
                 q, SLOT(addToPreviewQueue(KFileItem,QPixmap)));
         connect(job, SIGNAL(finished(KJob*)),
                 q, SLOT(slotPreviewJobFinished(KJob*)));
         m_previewJobs.append(job);
     }
 }
 
 void KFilePreviewGenerator::Private::killPreviewJobs()
 {
     foreach (KJob *job, m_previewJobs) {
         Q_ASSERT(job != nullptr);
         job->kill();
     }
     m_previewJobs.clear();
     m_sequenceIndices.clear();
 
     m_iconUpdateTimer->stop();
     m_scrollAreaTimer->stop();
     m_changedItemsTimer->stop();
 }
 
 void KFilePreviewGenerator::Private::orderItems(KFileItemList &items)
 {
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     // Order the items in a way that the preview for the visible items
     // is generated first, as this improves the feeled performance a lot.
     const bool hasProxy = (m_proxyModel != nullptr);
     const int itemCount = items.count();
     const QRect visibleArea = m_viewAdapter->visibleArea();
 
     QModelIndex dirIndex;
     QRect itemRect;
     int insertPos = 0;
     for (int i = 0; i < itemCount; ++i) {
         dirIndex = dirModel->indexForItem(items.at(i)); // O(n) (n = number of rows)
         if (hasProxy) {
             const QModelIndex proxyIndex = m_proxyModel->mapFromSource(dirIndex);
             itemRect = m_viewAdapter->visualRect(proxyIndex);
         } else {
             itemRect = m_viewAdapter->visualRect(dirIndex);
         }
 
         if (itemRect.intersects(visibleArea)) {
             // The current item is (at least partly) visible. Move it
             // to the front of the list, so that the preview is
             // generated earlier.
             items.insert(insertPos, items.at(i));
             items.removeAt(i + 1);
             ++insertPos;
             ++m_pendingVisibleIconUpdates;
         }
     }
 }
 
 void KFilePreviewGenerator::Private::addItemsToList(const QModelIndex &index, KFileItemList &list)
 {
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     const int rowCount = dirModel->rowCount(index);
     for (int row = 0; row < rowCount; ++row) {
         const QModelIndex subIndex = dirModel->index(row, 0, index);
         KFileItem item = dirModel->itemForIndex(subIndex);
         list.append(item);
 
         if (dirModel->rowCount(subIndex) > 0) {
             // the model is hierarchical (treeview)
             addItemsToList(subIndex, list);
         }
     }
 }
 
 void KFilePreviewGenerator::Private::delayedIconUpdate()
 {
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     // Precondition: No items have been changed within the last
     // 5 seconds. This means that items that have been changed constantly
     // due to a copy operation should be updated now.
 
     KFileItemList itemList;
 
     QHash<QUrl, bool>::const_iterator it = m_changedItems.constBegin();
     while (it != m_changedItems.constEnd()) {
         const bool hasChanged = it.value();
         if (hasChanged) {
             const QModelIndex index = dirModel->indexForUrl(it.key());
             const KFileItem item = dirModel->itemForIndex(index);
             itemList.append(item);
         }
         ++it;
     }
     m_changedItems.clear();
 
     updateIcons(itemList);
 }
 
 void KFilePreviewGenerator::Private::rowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
 {
     if (m_changedItems.isEmpty()) {
         return;
     }
 
     KDirModel *dirModel = m_dirModel.data();
     if (!dirModel) {
         return;
     }
 
     for (int row = start; row <= end; row++) {
         const QModelIndex index = dirModel->index(row, 0, parent);
 
         const KFileItem item = dirModel->itemForIndex(index);
         if (!item.isNull()) {
             m_changedItems.remove(item.url());
         }
 
         if (dirModel->hasChildren(index)) {
             rowsAboutToBeRemoved(index, 0, dirModel->rowCount(index) - 1);
         }
     }
 }
 
 KFilePreviewGenerator::KFilePreviewGenerator(QAbstractItemView *parent) :
     QObject(parent),
     d(new Private(this, new KIO::DefaultViewAdapter(parent, this), parent->model()))
 {
     d->m_itemView = parent;
 }
 
 KFilePreviewGenerator::KFilePreviewGenerator(KAbstractViewAdapter *parent, QAbstractProxyModel *model) :
     QObject(parent),
     d(new Private(this, parent, model))
 {
 }
 
 KFilePreviewGenerator::~KFilePreviewGenerator()
 {
     delete d;
 }
 
 void KFilePreviewGenerator::setPreviewShown(bool show)
 {
     if (d->m_previewShown == show) {
         return;
     }
 
     KDirModel *dirModel = d->m_dirModel.data();
     if (show && (!d->m_viewAdapter->iconSize().isValid() || !dirModel)) {
         // The view must provide an icon size and a directory model,
         // otherwise the showing the previews will get ignored
         return;
     }
 
     d->m_previewShown = show;
     if (!show) {
         dirModel->clearAllPreviews();
     }
     updateIcons();
 }
 
 bool KFilePreviewGenerator::isPreviewShown() const
 {
     return d->m_previewShown;
 }
 
 // deprecated (use updateIcons() instead)
 void KFilePreviewGenerator::updatePreviews()
 {
     updateIcons();
 }
 
 void KFilePreviewGenerator::updateIcons()
 {
     d->killPreviewJobs();
 
     d->clearCutItemsCache();
     d->m_pendingItems.clear();
     d->m_dispatchedItems.clear();
 
     KFileItemList itemList;
     d->addItemsToList(QModelIndex(), itemList);
 
     d->updateIcons(itemList);
 }
 
 void KFilePreviewGenerator::cancelPreviews()
 {
     d->killPreviewJobs();
     d->m_pendingItems.clear();
     d->m_dispatchedItems.clear();
     updateIcons();
 }
 
 void KFilePreviewGenerator::setEnabledPlugins(const QStringList &plugins)
 {
     d->m_enabledPlugins = plugins;
 }
 
 QStringList KFilePreviewGenerator::enabledPlugins() const
 {
     return d->m_enabledPlugins;
 }
 
 #include "moc_kfilepreviewgenerator.cpp"
diff --git a/src/filewidgets/kfilewidget.cpp b/src/filewidgets/kfilewidget.cpp
index 2d0972e6..1ab0ed40 100644
--- a/src/filewidgets/kfilewidget.cpp
+++ b/src/filewidgets/kfilewidget.cpp
@@ -1,2886 +1,2886 @@
 // -*- c++ -*-
 /* This file is part of the KDE libraries
     Copyright (C) 1997, 1998 Richard Moore <rich@kde.org>
                   1998 Stephan Kulow <coolo@kde.org>
                   1998 Daniel Grana <grana@ie.iwi.unibe.ch>
                   1999,2000,2001,2002,2003 Carsten Pfeiffer <pfeiffer@kde.org>
                   2003 Clarence Dang <dang@kde.org>
                   2007 David Faure <faure@kde.org>
                   2008 Rafael Fernández López <ereslibre@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #include "kfilewidget.h"
 #include "../pathhelpers_p.h"
 
 #include "kfileplacesview.h"
 #include "kfileplacesmodel.h"
 #include "kfilebookmarkhandler_p.h"
 #include "kurlcombobox.h"
 #include "kurlnavigator.h"
 #include "kfilepreviewgenerator.h"
 #include "kfilewidgetdocktitlebar_p.h"
 #include <config-kiofilewidgets.h>
 #include <defaults-kfile.h>
 
 #include <kactioncollection.h>
 #include <kactionmenu.h>
 #include <kconfiggroup.h>
 #include <kdiroperator.h>
 #include <kfilefiltercombo.h>
 #include <kimagefilepreview.h>
 #include <krecentdocument.h>
 #include <ktoolbar.h>
 #include <kurlcompletion.h>
 #include <kprotocolmanager.h>
 #include <kio/pixmaploader.h>
 #include <kio/job.h>
 #include <kio/jobuidelegate.h>
 #include <kio/scheduler.h>
 #include <krecentdirs.h>
 #include <QDebug>
 #include <klocalizedstring.h>
 #include <kfileitemdelegate.h>
 #include <ksharedconfig.h>
 
 #include <QCheckBox>
 #include <QDesktopWidget>
 #include <QDockWidget>
 #include <QLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QMenu>
 #include <QSplitter>
 #include <QAbstractProxyModel>
 #include <QHelpEvent>
 #include <QApplication>
 #include <QPushButton>
 #include <QStandardPaths>
 #include <qmimedatabase.h>
 
 #include <kshell.h>
 #include <kmessagebox.h>
 #include <kurlauthorized.h>
 #include <kjobwidgets.h>
 
 class KFileWidgetPrivate
 {
 public:
     explicit KFileWidgetPrivate(KFileWidget *widget)
         : q(widget),
           boxLayout(nullptr),
           placesDock(nullptr),
           placesView(nullptr),
           placesViewSplitter(nullptr),
           placesViewWidth(-1),
           labeledCustomWidget(nullptr),
           bottomCustomWidget(nullptr),
           autoSelectExtCheckBox(nullptr),
           operationMode(KFileWidget::Opening),
           bookmarkHandler(nullptr),
           toolbar(nullptr),
           locationEdit(nullptr),
           ops(nullptr),
           filterWidget(nullptr),
           autoSelectExtChecked(false),
           keepLocation(false),
           hasView(false),
           hasDefaultFilter(false),
           inAccept(false),
           dummyAdded(false),
           confirmOverwrite(false),
           differentHierarchyLevelItemsEntered(false),
           iconSizeSlider(nullptr),
           zoomOutAction(nullptr),
           zoomInAction(nullptr)
     {
     }
 
     ~KFileWidgetPrivate()
     {
         delete bookmarkHandler; // Should be deleted before ops!
         delete ops;
     }
 
     void updateLocationWhatsThis();
     void updateAutoSelectExtension();
     void initSpeedbar();
     void setPlacesViewSplitterSizes();
     void setLafBoxColumnWidth();
     void initGUI();
     void readViewConfig();
     void writeViewConfig();
     void setNonExtSelection();
     void setLocationText(const QUrl &);
     void setLocationText(const QList<QUrl> &);
     void appendExtension(QUrl &url);
     void updateLocationEditExtension(const QString &);
     void updateFilter();
     QList<QUrl> &parseSelectedUrls();
     /**
      * Parses the string "line" for files. If line doesn't contain any ", the
      * whole line will be interpreted as one file. If the number of " is odd,
      * an empty list will be returned. Otherwise, all items enclosed in " "
      * will be returned as correct urls.
      */
     QList<QUrl> tokenize(const QString &line) const;
     /**
      * Reads the recent used files and inserts them into the location combobox
      */
     void readRecentFiles();
     /**
      * Saves the entries from the location combobox.
      */
     void saveRecentFiles();
     /**
      * called when an item is highlighted/selected in multiselection mode.
      * handles setting the locationEdit.
      */
     void multiSelectionChanged();
 
     /**
      * Returns the absolute version of the URL specified in locationEdit.
      */
     QUrl getCompleteUrl(const QString &) const;
 
     /**
      * Sets the dummy entry on the history combo box. If the dummy entry
      * already exists, it is overwritten with this information.
      */
     void setDummyHistoryEntry(const QString &text, const QPixmap &icon = QPixmap(),
                               bool usePreviousPixmapIfNull = true);
 
     /**
      * Removes the dummy entry of the history combo box.
      */
     void removeDummyHistoryEntry();
 
     /**
      * Asks for overwrite confirmation using a KMessageBox and returns
      * true if the user accepts.
      *
      * @since 4.2
      */
     bool toOverwrite(const QUrl &);
 
     // private slots
     void _k_slotLocationChanged(const QString &);
     void _k_urlEntered(const QUrl &);
     void _k_enterUrl(const QUrl &);
     void _k_enterUrl(const QString &);
     void _k_locationAccepted(const QString &);
     void _k_slotFilterChanged();
     void _k_fileHighlighted(const KFileItem &);
     void _k_fileSelected(const KFileItem &);
     void _k_slotLoadingFinished();
     void _k_fileCompletion(const QString &);
     void _k_toggleSpeedbar(bool);
     void _k_toggleBookmarks(bool);
     void _k_slotAutoSelectExtClicked();
     void _k_placesViewSplitterMoved(int, int);
     void _k_activateUrlNavigator();
     void _k_zoomOutIconsSize();
     void _k_zoomInIconsSize();
     void _k_slotIconSizeSliderMoved(int);
     void _k_slotIconSizeChanged(int);
     void _k_slotViewDoubleClicked(const QModelIndex&);
 
     void addToRecentDocuments();
 
     QString locationEditCurrentText() const;
 
     /**
      * KIO::NetAccess::mostLocalUrl local replacement.
      * This method won't show any progress dialogs for stating, since
      * they are very annoying when stating.
      */
     QUrl mostLocalUrl(const QUrl &url);
 
     void setInlinePreviewShown(bool show);
 
     KFileWidget * const q;
 
     // the last selected url
     QUrl url;
 
     // the selected filenames in multiselection mode -- FIXME
     QString filenames;
 
     // now following all kind of widgets, that I need to rebuild
     // the geometry management
     QBoxLayout *boxLayout;
     QGridLayout *lafBox;
     QVBoxLayout *vbox;
 
     QLabel *locationLabel;
     QWidget *opsWidget;
     QWidget *pathSpacer;
 
     QLabel *filterLabel;
     KUrlNavigator *urlNavigator;
     QPushButton *okButton, *cancelButton;
     QDockWidget *placesDock;
     KFilePlacesView *placesView;
     QSplitter *placesViewSplitter;
     // caches the places view width. This value will be updated when the splitter
     // is moved. This allows us to properly set a value when the dialog itself
     // is resized
     int placesViewWidth;
 
     QWidget *labeledCustomWidget;
     QWidget *bottomCustomWidget;
 
     // Automatically Select Extension stuff
     QCheckBox *autoSelectExtCheckBox;
     QString extension; // current extension for this filter
 
     QList<KIO::StatJob *> statJobs;
 
     QList<QUrl> urlList; //the list of selected urls
 
     KFileWidget::OperationMode operationMode;
 
     // The file class used for KRecentDirs
     QString fileClass;
 
     KFileBookmarkHandler *bookmarkHandler;
 
     KActionMenu *bookmarkButton;
 
     KToolBar *toolbar;
     KUrlComboBox *locationEdit;
     KDirOperator *ops;
     KFileFilterCombo *filterWidget;
     QTimer filterDelayTimer;
 
     KFilePlacesModel *model;
 
     // whether or not the _user_ has checked the above box
     bool autoSelectExtChecked : 1;
 
     // indicates if the location edit should be kept or cleared when changing
     // directories
     bool keepLocation : 1;
 
     // the KDirOperators view is set in KFileWidget::show(), so to avoid
     // setting it again and again, we have this nice little boolean :)
     bool hasView : 1;
 
     bool hasDefaultFilter : 1; // necessary for the operationMode
     bool autoDirectoryFollowing : 1;
     bool inAccept : 1; // true between beginning and end of accept()
     bool dummyAdded : 1; // if the dummy item has been added. This prevents the combo from having a
     // blank item added when loaded
     bool confirmOverwrite : 1;
     bool differentHierarchyLevelItemsEntered;
 
     QSlider *iconSizeSlider;
     QAction *zoomOutAction;
     QAction *zoomInAction;
 
     // The group which stores app-specific settings. These settings are recent
     // files and urls. Visual settings (view mode, sorting criteria...) are not
     // app-specific and are stored in kdeglobals
     KConfigGroup configGroup;
 };
 
 Q_GLOBAL_STATIC(QUrl, lastDirectory) // to set the start path
 
 static const char autocompletionWhatsThisText[] = I18N_NOOP("<qt>While typing in the text area, you may be presented "
         "with possible matches. "
         "This feature can be controlled by clicking with the right mouse button "
         "and selecting a preferred mode from the <b>Text Completion</b> menu.</qt>");
 
 // returns true if the string contains "<a>:/" sequence, where <a> is at least 2 alpha chars
 static bool containsProtocolSection(const QString &string)
 {
     int len = string.length();
     static const char prot[] = ":/";
     for (int i = 0; i < len;) {
         i = string.indexOf(QLatin1String(prot), i);
         if (i == -1) {
             return false;
         }
         int j = i - 1;
         for (; j >= 0; j--) {
             const QChar &ch(string[j]);
             if (ch.toLatin1() == 0 || !ch.isLetter()) {
                 break;
             }
             if (ch.isSpace() && (i - j - 1) >= 2) {
                 return true;
             }
         }
         if (j < 0 && i >= 2) {
             return true;    // at least two letters before ":/"
         }
         i += 3; // skip : and / and one char
     }
     return false;
 }
 
 // this string-to-url conversion function handles relative paths, full paths and URLs
 // without the http-prepending that QUrl::fromUserInput does.
 static QUrl urlFromString(const QString& str)
 {
     if (QDir::isAbsolutePath(str)) {
         return QUrl::fromLocalFile(str);
     }
     QUrl url(str);
     if (url.isRelative()) {
         url.clear();
         url.setPath(str);
     }
     return url;
 }
 
 
 KFileWidget::KFileWidget(const QUrl &_startDir, QWidget *parent)
     : QWidget(parent), d(new KFileWidgetPrivate(this))
 {
     QUrl startDir(_startDir);
     // qDebug() << "startDir" << startDir;
     QString filename;
 
     d->okButton = new QPushButton(this);
     KGuiItem::assign(d->okButton, KStandardGuiItem::ok());
     d->okButton->setDefault(true);
     d->cancelButton = new QPushButton(this);
     KGuiItem::assign(d->cancelButton, KStandardGuiItem::cancel());
     // The dialog shows them
     d->okButton->hide();
     d->cancelButton->hide();
 
     d->opsWidget = new QWidget(this);
     QVBoxLayout *opsWidgetLayout = new QVBoxLayout(d->opsWidget);
     opsWidgetLayout->setMargin(0);
     opsWidgetLayout->setSpacing(0);
     //d->toolbar = new KToolBar(this, true);
     d->toolbar = new KToolBar(d->opsWidget, true);
     d->toolbar->setObjectName(QStringLiteral("KFileWidget::toolbar"));
     d->toolbar->setMovable(false);
     opsWidgetLayout->addWidget(d->toolbar);
 
     d->model = new KFilePlacesModel(this);
 
     // Resolve this now so that a 'kfiledialog:' URL, if specified,
     // does not get inserted into the urlNavigator history.
     d->url = getStartUrl(startDir, d->fileClass, filename);
     startDir = d->url;
 
     // Don't pass startDir to the KUrlNavigator at this stage: as well as
     // the above, it may also contain a file name which should not get
     // inserted in that form into the old-style navigation bar history.
     // Wait until the KIO::stat has been done later.
     //
     // The stat cannot be done before this point, bug 172678.
     d->urlNavigator = new KUrlNavigator(d->model, QUrl(), d->opsWidget); //d->toolbar);
     d->urlNavigator->setPlacesSelectorVisible(false);
     opsWidgetLayout->addWidget(d->urlNavigator);
 
     QUrl u;
     KUrlComboBox *pathCombo = d->urlNavigator->editor();
 #ifdef Q_OS_WIN
 #if 0
     foreach (const QFileInfo &drive, QFSFileEngine::drives()) {
         u = QUrl::fromLocalFile(drive.filePath());
         pathCombo->addDefaultUrl(u,
                                  KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                                  i18n("Drive: %1",  u.toLocalFile()));
     }
 #else
 #pragma message("QT5 PORT")
 #endif
 #else
     u = QUrl::fromLocalFile(QDir::rootPath());
     pathCombo->addDefaultUrl(u,
                              KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 #endif
 
     u = QUrl::fromLocalFile(QDir::homePath());
     pathCombo->addDefaultUrl(u, KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 
     QUrl docPath = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
     if (u.adjusted(QUrl::StripTrailingSlash) != docPath.adjusted(QUrl::StripTrailingSlash) &&
             QDir(docPath.toLocalFile()).exists()) {
         pathCombo->addDefaultUrl(docPath,
                                  KIO::pixmapForUrl(docPath, 0, KIconLoader::Small),
                                  docPath.toLocalFile());
     }
 
     u = QUrl::fromLocalFile(QStandardPaths::writableLocation(QStandardPaths::DesktopLocation));
     pathCombo->addDefaultUrl(u,
                              KIO::pixmapForUrl(u, 0, KIconLoader::Small),
                              u.toLocalFile());
 
     d->ops = new KDirOperator(QUrl(), d->opsWidget);
     d->ops->setObjectName(QStringLiteral("KFileWidget::ops"));
     d->ops->setIsSaving(d->operationMode == Saving);
     opsWidgetLayout->addWidget(d->ops);
     connect(d->ops, SIGNAL(urlEntered(QUrl)),
             SLOT(_k_urlEntered(QUrl)));
     connect(d->ops, SIGNAL(fileHighlighted(KFileItem)),
             SLOT(_k_fileHighlighted(KFileItem)));
     connect(d->ops, SIGNAL(fileSelected(KFileItem)),
             SLOT(_k_fileSelected(KFileItem)));
     connect(d->ops, SIGNAL(finishedLoading()),
             SLOT(_k_slotLoadingFinished()));
 
     d->ops->setupMenu(KDirOperator::SortActions |
                       KDirOperator::FileActions |
                       KDirOperator::ViewActions);
     KActionCollection *coll = d->ops->actionCollection();
     coll->addAssociatedWidget(this);
 
     // add nav items to the toolbar
     //
     // NOTE:  The order of the button icons here differs from that
     // found in the file manager and web browser, but has been discussed
     // and agreed upon on the kde-core-devel mailing list:
     //
     // http://lists.kde.org/?l=kde-core-devel&m=116888382514090&w=2
 
     coll->action(QStringLiteral("up"))->setWhatsThis(i18n("<qt>Click this button to enter the parent folder.<br /><br />"
                                           "For instance, if the current location is file:/home/konqi clicking this "
                                           "button will take you to file:/home.</qt>"));
 
     coll->action(QStringLiteral("back"))->setWhatsThis(i18n("Click this button to move backwards one step in the browsing history."));
     coll->action(QStringLiteral("forward"))->setWhatsThis(i18n("Click this button to move forward one step in the browsing history."));
 
     coll->action(QStringLiteral("reload"))->setWhatsThis(i18n("Click this button to reload the contents of the current location."));
     coll->action(QStringLiteral("mkdir"))->setShortcut(QKeySequence(Qt::Key_F10));
     coll->action(QStringLiteral("mkdir"))->setWhatsThis(i18n("Click this button to create a new folder."));
 
     QAction *goToNavigatorAction = coll->addAction(QStringLiteral("gotonavigator"), this, SLOT(_k_activateUrlNavigator()));
     goToNavigatorAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_L));
 
     KToggleAction *showSidebarAction =
         new KToggleAction(i18n("Show Places Navigation Panel"), this);
     coll->addAction(QStringLiteral("toggleSpeedbar"), showSidebarAction);
     showSidebarAction->setShortcut(QKeySequence(Qt::Key_F9));
     connect(showSidebarAction, SIGNAL(toggled(bool)),
             SLOT(_k_toggleSpeedbar(bool)));
 
     KToggleAction *showBookmarksAction =
         new KToggleAction(i18n("Show Bookmarks"), this);
     coll->addAction(QStringLiteral("toggleBookmarks"), showBookmarksAction);
     connect(showBookmarksAction, SIGNAL(toggled(bool)),
             SLOT(_k_toggleBookmarks(bool)));
 
     KActionMenu *menu = new KActionMenu(QIcon::fromTheme(QStringLiteral("configure")), i18n("Options"), this);
     coll->addAction(QStringLiteral("extra menu"), menu);
     menu->setWhatsThis(i18n("<qt>This is the preferences menu for the file dialog. "
                             "Various options can be accessed from this menu including: <ul>"
                             "<li>how files are sorted in the list</li>"
                             "<li>types of view, including icon and list</li>"
                             "<li>showing of hidden files</li>"
                             "<li>the Places navigation panel</li>"
                             "<li>file previews</li>"
                             "<li>separating folders from files</li></ul></qt>"));
     menu->addAction(coll->action(QStringLiteral("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.count()) {
+    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.count()) {
+    } 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
 
     placesViewSplitter = new QSplitter(q);
     placesViewSplitter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
     placesViewSplitter->setChildrenCollapsible(false);
     boxLayout->addWidget(placesViewSplitter);
 
     QObject::connect(placesViewSplitter, SIGNAL(splitterMoved(int,int)),
                      q, SLOT(_k_placesViewSplitterMoved(int,int)));
     placesViewSplitter->insertWidget(0, opsWidget);
 
     vbox = new QVBoxLayout();
     vbox->setMargin(0);
     boxLayout->addLayout(vbox);
 
     lafBox = new QGridLayout();
 
     lafBox->addWidget(locationLabel, 0, 0, Qt::AlignVCenter | Qt::AlignRight);
     lafBox->addWidget(locationEdit, 0, 1, Qt::AlignVCenter);
     lafBox->addWidget(okButton, 0, 2, Qt::AlignVCenter);
 
     lafBox->addWidget(filterLabel, 1, 0, Qt::AlignVCenter | Qt::AlignRight);
     lafBox->addWidget(filterWidget, 1, 1, Qt::AlignVCenter);
     lafBox->addWidget(cancelButton, 1, 2, Qt::AlignVCenter);
 
     lafBox->setColumnStretch(1, 4);
 
     vbox->addLayout(lafBox);
 
     // add the Automatically Select Extension checkbox
     vbox->addWidget(autoSelectExtCheckBox);
 
     q->setTabOrder(ops, autoSelectExtCheckBox);
     q->setTabOrder(autoSelectExtCheckBox, locationEdit);
     q->setTabOrder(locationEdit, filterWidget);
     q->setTabOrder(filterWidget, okButton);
     q->setTabOrder(okButton, cancelButton);
     q->setTabOrder(cancelButton, urlNavigator);
     q->setTabOrder(urlNavigator, ops);
 }
 
 void KFileWidgetPrivate::_k_slotFilterChanged()
 {
 //     qDebug();
 
     filterDelayTimer.stop();
 
     QString filter = filterWidget->currentFilter();
     ops->clearFilter();
 
     if (filter.contains(QLatin1Char('/'))) {
         QStringList types = filter.split(QLatin1Char(' '), QString::SkipEmptyParts);
         types.prepend(QStringLiteral("inode/directory"));
         ops->setMimeFilter(types);
     } else if (filter.contains(QLatin1Char('*')) || filter.contains(QLatin1Char('?')) || filter.contains(QLatin1Char('['))) {
         ops->setNameFilter(filter);
     } else {
         ops->setNameFilter(QLatin1Char('*') + filter.replace(QLatin1Char(' '), QLatin1Char('*')) + QLatin1Char('*'));
     }
 
     updateAutoSelectExtension();
 
     ops->updateDir();
 
     emit q->filterChanged(filter);
 }
 
 void KFileWidget::setUrl(const QUrl &url, bool clearforward)
 {
 //     qDebug();
 
     d->ops->setUrl(url, clearforward);
 }
 
 // Protected
 void KFileWidgetPrivate::_k_urlEntered(const QUrl &url)
 {
 //     qDebug();
 
     QString filename = locationEditCurrentText();
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     if (pathCombo->count() != 0) { // little hack
         pathCombo->setUrl(url);
     }
 
     bool blocked = locationEdit->blockSignals(true);
     if (keepLocation) {
         QUrl currentUrl = urlFromString(filename);
         locationEdit->changeUrl(0, QIcon::fromTheme(KIO::iconNameForUrl(currentUrl)), currentUrl);
         locationEdit->lineEdit()->setModified(true);
     }
 
     locationEdit->blockSignals(blocked);
 
     urlNavigator->setLocationUrl(url);
 
     // is trigged in ctor before completion object is set
     KUrlCompletion *completion = dynamic_cast<KUrlCompletion *>(locationEdit->completionObject());
     if (completion) {
         completion->setDir(url);
     }
 
     if (placesView) {
         placesView->setUrl(url);
     }
 }
 
 void KFileWidgetPrivate::_k_locationAccepted(const QString &url)
 {
     Q_UNUSED(url);
 //     qDebug();
     q->slotOk();
 }
 
 void KFileWidgetPrivate::_k_enterUrl(const QUrl &url)
 {
 //     qDebug();
 
     // append '/' if needed: url combo does not add it
     // tokenize() expects it because it uses QUrl::adjusted(QUrl::RemoveFilename)
     QUrl u(url);
     if (!u.path().isEmpty() && !u.path().endsWith(QLatin1Char('/'))) {
         u.setPath(u.path() + QLatin1Char('/'));
     }
     q->setUrl(u);
 
     // We need to check window()->focusWidget() instead of locationEdit->hasFocus
     // because when the window is showing up locationEdit
     // may still not have focus but it'll be the one that will have focus when the window
     // gets it and we don't want to steal its focus either
     if (q->window()->focusWidget() != locationEdit) {
         ops->setFocus();
     }
 }
 
 void KFileWidgetPrivate::_k_enterUrl(const QString &url)
 {
 //     qDebug();
 
     _k_enterUrl(urlFromString(KUrlCompletion::replacedPath(url, true, true)));
 }
 
 bool KFileWidgetPrivate::toOverwrite(const QUrl &url)
 {
 //     qDebug();
 
     KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
     KJobWidgets::setWindow(statJob, q);
     bool res = statJob->exec();
 
     if (res) {
         int ret = KMessageBox::warningContinueCancel(q,
                   i18n("The file \"%1\" already exists. Do you wish to overwrite it?",
                        url.fileName()), i18n("Overwrite File?"), KStandardGuiItem::overwrite(),
                   KStandardGuiItem::cancel(), QString(), KMessageBox::Notify | KMessageBox::Dangerous);
 
         if (ret != KMessageBox::Continue) {
             return false;
         }
         return true;
     }
 
     return true;
 }
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KFileWidget::setSelection(const QString &url)
 {
 //     qDebug() << "setSelection " << url;
 
     if (url.isEmpty()) {
         return;
     }
 
     QUrl u = d->getCompleteUrl(url);
     if (!u.isValid()) { // if it still is
         qWarning() << url << " is not a correct argument for setSelection!";
         return;
     }
 
     setSelectedUrl(urlFromString(url));
 }
 #endif
 
 void KFileWidget::setSelectedUrl(const QUrl &url)
 {
     // Honor protocols that do not support directory listing
     if (!url.isRelative() && !KProtocolManager::supportsListing(url)) {
         return;
     }
     d->setLocationText(url);
 }
 
 void KFileWidgetPrivate::_k_slotLoadingFinished()
 {
     const QString currentText = locationEdit->currentText();
     if (currentText.isEmpty()) {
         return;
     }
 
     ops->blockSignals(true);
     QUrl u(ops->url());
     if (currentText.startsWith(QLatin1Char('/')))
         u.setPath(currentText);
     else
         u.setPath(concatPaths(ops->url().path(), currentText));
     ops->setCurrentItem(u);
     ops->blockSignals(false);
 }
 
 void KFileWidgetPrivate::_k_fileCompletion(const QString &match)
 {
 //     qDebug();
 
     if (match.isEmpty() || locationEdit->currentText().contains(QLatin1Char('"'))) {
         return;
     }
 
     const QUrl url = urlFromString(match);
     const QPixmap pix = KIconLoader::global()->loadMimeTypeIcon(KIO::iconNameForUrl(url), KIconLoader::Small);
     setDummyHistoryEntry(locationEdit->currentText(), pix, !locationEdit->currentText().isEmpty());
 }
 
 void KFileWidgetPrivate::_k_slotLocationChanged(const QString &text)
 {
 //     qDebug();
 
     locationEdit->lineEdit()->setModified(true);
 
     if (text.isEmpty() && ops->view()) {
         ops->view()->clearSelection();
     }
 
     if (text.isEmpty()) {
         removeDummyHistoryEntry();
     } else {
         setDummyHistoryEntry(text);
     }
 
     if (!locationEdit->lineEdit()->text().isEmpty()) {
         const QList<QUrl> urlList(tokenize(text));
         ops->setCurrentItems(urlList);
     }
 
     updateFilter();
 }
 
 QUrl KFileWidget::selectedUrl() const
 {
 //     qDebug();
 
     if (d->inAccept) {
         return d->url;
     } else {
         return QUrl();
     }
 }
 
 QList<QUrl> KFileWidget::selectedUrls() const
 {
 //     qDebug();
 
     QList<QUrl> list;
     if (d->inAccept) {
         if (d->ops->mode() & KFile::Files) {
             list = d->parseSelectedUrls();
         } else {
             list.append(d->url);
         }
     }
     return list;
 }
 
 QList<QUrl> &KFileWidgetPrivate::parseSelectedUrls()
 {
 //     qDebug();
 
     if (filenames.isEmpty()) {
         return urlList;
     }
 
     urlList.clear();
     if (filenames.contains(QLatin1Char('/'))) {    // assume _one_ absolute filename
         QUrl u;
         if (containsProtocolSection(filenames)) {
             u = QUrl(filenames);
         } else {
             u.setPath(filenames);
         }
 
         if (u.isValid()) {
             urlList.append(u);
         } else
             KMessageBox::error(q,
                                i18n("The chosen filenames do not\n"
                                     "appear to be valid."),
                                i18n("Invalid Filenames"));
     }
 
     else {
         urlList = tokenize(filenames);
     }
 
     filenames.clear(); // indicate that we parsed that one
 
     return urlList;
 }
 
 // FIXME: current implementation drawback: a filename can't contain quotes
 QList<QUrl> KFileWidgetPrivate::tokenize(const QString &line) const
 {
 //     qDebug();
 
     QList<QUrl> urls;
     QUrl u(ops->url());
     if (!u.path().endsWith(QLatin1Char('/'))) {
         u.setPath(u.path() + QLatin1Char('/'));
     }
     QString name;
 
     const int count = line.count(QLatin1Char('"'));
     if (count == 0) {   // no " " -> assume one single file
         if (!QDir::isAbsolutePath(line)) {
             u = u.adjusted(QUrl::RemoveFilename);
             u.setPath(u.path() + line);
             if (u.isValid()) {
                 urls.append(u);
             }
         } else {
             urls << QUrl::fromLocalFile(line);
         }
 
         return urls;
     }
 
     int start = 0;
     int index1 = -1, index2 = -1;
     while (true) {
         index1 = line.indexOf(QLatin1Char('"'), start);
         index2 = line.indexOf(QLatin1Char('"'), index1 + 1);
 
         if (index1 < 0 || index2 < 0) {
             break;
         }
 
         // get everything between the " "
         name = line.mid(index1 + 1, index2 - index1 - 1);
 
         // since we use setPath we need to do this under a temporary url
         QUrl _u(u);
         QUrl currUrl(name);
 
         if (!QDir::isAbsolutePath(currUrl.url())) {
             _u = _u.adjusted(QUrl::RemoveFilename);
             _u.setPath(_u.path() + name);
         } else {
             // we allow to insert various absolute paths like:
             // "/home/foo/bar.txt" "/boot/grub/menu.lst"
             _u = currUrl;
         }
 
         if (_u.isValid()) {
             urls.append(_u);
         }
 
         start = index2 + 1;
     }
 
     return urls;
 }
 
 QString KFileWidget::selectedFile() const
 {
 //     qDebug();
 
     if (d->inAccept) {
         const QUrl url = d->mostLocalUrl(d->url);
         if (url.isLocalFile()) {
             return url.toLocalFile();
         } else {
             KMessageBox::sorry(const_cast<KFileWidget *>(this),
                                i18n("You can only select local files."),
                                i18n("Remote Files Not Accepted"));
         }
     }
     return QString();
 }
 
 QStringList KFileWidget::selectedFiles() const
 {
 //     qDebug();
 
     QStringList list;
 
     if (d->inAccept) {
         if (d->ops->mode() & KFile::Files) {
             const QList<QUrl> urls = d->parseSelectedUrls();
             QList<QUrl>::const_iterator it = urls.begin();
             while (it != urls.end()) {
                 QUrl url = d->mostLocalUrl(*it);
                 if (url.isLocalFile()) {
                     list.append(url.toLocalFile());
                 }
                 ++it;
             }
         }
 
         else { // single-selection mode
             if (d->url.isLocalFile()) {
                 list.append(d->url.toLocalFile());
             }
         }
     }
 
     return list;
 }
 
 QUrl KFileWidget::baseUrl() const
 {
     return d->ops->url();
 }
 
 void KFileWidget::resizeEvent(QResizeEvent *event)
 {
     QWidget::resizeEvent(event);
 
     if (d->placesDock) {
         // we don't want our places dock actually changing size when we resize
         // and qt doesn't make it easy to enforce such a thing with QSplitter
         d->setPlacesViewSplitterSizes();
     }
 }
 
 void KFileWidget::showEvent(QShowEvent *event)
 {
     if (!d->hasView) {   // delayed view-creation
         Q_ASSERT(d);
         Q_ASSERT(d->ops);
         d->ops->setView(KFile::Default);
         d->ops->view()->setSizePolicy(QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
         d->hasView = true;
 
         connect(d->ops->view(), SIGNAL(doubleClicked(QModelIndex)), this, SLOT(_k_slotViewDoubleClicked(QModelIndex)));
     }
     d->ops->clearHistory();
 
     QWidget::showEvent(event);
 }
 
 bool KFileWidget::eventFilter(QObject *watched, QEvent *event)
 {
     const bool res = QWidget::eventFilter(watched, event);
 
     QKeyEvent *keyEvent = dynamic_cast<QKeyEvent *>(event);
     if (watched == d->iconSizeSlider && keyEvent) {
         if (keyEvent->key() == Qt::Key_Left || keyEvent->key() == Qt::Key_Up ||
                 keyEvent->key() == Qt::Key_Right || keyEvent->key() == Qt::Key_Down) {
             d->_k_slotIconSizeSliderMoved(d->iconSizeSlider->value());
         }
     } else if (watched == d->locationEdit && event->type() == QEvent::KeyPress) {
         if (keyEvent->modifiers() & Qt::AltModifier) {
             switch (keyEvent->key()) {
             case Qt::Key_Up:
                 d->ops->actionCollection()->action(QStringLiteral("up"))->trigger();
                 break;
             case Qt::Key_Left:
                 d->ops->actionCollection()->action(QStringLiteral("back"))->trigger();
                 break;
             case Qt::Key_Right:
                 d->ops->actionCollection()->action(QStringLiteral("forward"))->trigger();
                 break;
             default:
                 break;
             }
         }
     }
 
     return res;
 }
 
 void KFileWidget::setMode(KFile::Modes m)
 {
 //     qDebug();
 
     d->ops->setMode(m);
     if (d->ops->dirOnlyMode()) {
         d->filterWidget->setDefaultFilter(i18n("*|All Folders"));
     } else {
         d->filterWidget->setDefaultFilter(i18n("*|All Files"));
     }
 
     d->updateAutoSelectExtension();
 }
 
 KFile::Modes KFileWidget::mode() const
 {
     return d->ops->mode();
 }
 
 void KFileWidgetPrivate::readViewConfig()
 {
     ops->setViewConfig(configGroup);
     ops->readConfig(configGroup);
     KUrlComboBox *combo = urlNavigator->editor();
 
     autoDirectoryFollowing = configGroup.readEntry(AutoDirectoryFollowing,
                              DefaultDirectoryFollowing);
 
     KCompletion::CompletionMode cm = (KCompletion::CompletionMode)
                                      configGroup.readEntry(PathComboCompletionMode,
                                              static_cast<int>(KCompletion::CompletionPopup));
     if (cm != KCompletion::CompletionPopup) {
         combo->setCompletionMode(cm);
     }
 
     cm = (KCompletion::CompletionMode)
          configGroup.readEntry(LocationComboCompletionMode,
                                static_cast<int>(KCompletion::CompletionPopup));
     if (cm != KCompletion::CompletionPopup) {
         locationEdit->setCompletionMode(cm);
     }
 
     // show or don't show the speedbar
     _k_toggleSpeedbar(configGroup.readEntry(ShowSpeedbar, true));
 
     // show or don't show the bookmarks
     _k_toggleBookmarks(configGroup.readEntry(ShowBookmarks, false));
 
     // does the user want Automatically Select Extension?
     autoSelectExtChecked = configGroup.readEntry(AutoSelectExtChecked, DefaultAutoSelectExtChecked);
     updateAutoSelectExtension();
 
     // should the URL navigator use the breadcrumb navigation?
     urlNavigator->setUrlEditable(!configGroup.readEntry(BreadcrumbNavigation, true));
 
     // should the URL navigator show the full path?
     urlNavigator->setShowFullPath(configGroup.readEntry(ShowFullPath, false));
 
     int w1 = q->minimumSize().width();
     int w2 = toolbar->sizeHint().width();
     if (w1 < w2) {
         q->setMinimumWidth(w2);
     }
 }
 
 void KFileWidgetPrivate::writeViewConfig()
 {
     // these settings are global settings; ALL instances of the file dialog
     // should reflect them.
     // There is no way to tell KFileOperator::writeConfig() to write to
     // kdeglobals so we write settings to a temporary config group then copy
     // them all to kdeglobals
     KConfig tmp(QString(), KConfig::SimpleConfig);
     KConfigGroup tmpGroup(&tmp, ConfigGroup);
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     //saveDialogSize( tmpGroup, KConfigGroup::Persistent | KConfigGroup::Global );
     tmpGroup.writeEntry(PathComboCompletionMode, static_cast<int>(pathCombo->completionMode()));
     tmpGroup.writeEntry(LocationComboCompletionMode, static_cast<int>(locationEdit->completionMode()));
 
     const bool showSpeedbar = placesDock && !placesDock->isHidden();
     tmpGroup.writeEntry(ShowSpeedbar, showSpeedbar);
     if (placesViewWidth > 0) {
         tmpGroup.writeEntry(SpeedbarWidth, placesViewWidth);
     }
 
     tmpGroup.writeEntry(ShowBookmarks, bookmarkHandler != nullptr);
     tmpGroup.writeEntry(AutoSelectExtChecked, autoSelectExtChecked);
     tmpGroup.writeEntry(BreadcrumbNavigation, !urlNavigator->isUrlEditable());
     tmpGroup.writeEntry(ShowFullPath, urlNavigator->showFullPath());
 
     ops->writeConfig(tmpGroup);
 
     // Copy saved settings to kdeglobals
     tmpGroup.copyTo(&configGroup, KConfigGroup::Persistent | KConfigGroup::Global);
 }
 
 void KFileWidgetPrivate::readRecentFiles()
 {
 //     qDebug();
 
     QObject::disconnect(locationEdit, SIGNAL(editTextChanged(QString)),
                         q, SLOT(_k_slotLocationChanged(QString)));
 
     locationEdit->setMaxItems(configGroup.readEntry(RecentFilesNumber, DefaultRecentURLsNumber));
     locationEdit->setUrls(configGroup.readPathEntry(RecentFiles, QStringList()),
                           KUrlComboBox::RemoveBottom);
     locationEdit->setCurrentIndex(-1);
 
     QObject::connect(locationEdit, SIGNAL(editTextChanged(QString)),
                      q, SLOT(_k_slotLocationChanged(QString)));
 
     KUrlComboBox *combo = urlNavigator->editor();
     combo->setUrls(configGroup.readPathEntry(RecentURLs, QStringList()), KUrlComboBox::RemoveTop);
     combo->setMaxItems(configGroup.readEntry(RecentURLsNumber, DefaultRecentURLsNumber));
     combo->setUrl(ops->url());
     // since we delayed this moment, initialize the directory of the completion object to
     // our current directory (that was very probably set on the constructor)
     KUrlCompletion *completion = dynamic_cast<KUrlCompletion *>(locationEdit->completionObject());
     if (completion) {
         completion->setDir(ops->url());
     }
 
 }
 
 void KFileWidgetPrivate::saveRecentFiles()
 {
 //     qDebug();
     configGroup.writePathEntry(RecentFiles, locationEdit->urls());
 
     KUrlComboBox *pathCombo = urlNavigator->editor();
     configGroup.writePathEntry(RecentURLs, pathCombo->urls());
 }
 
 QPushButton *KFileWidget::okButton() const
 {
     return d->okButton;
 }
 
 QPushButton *KFileWidget::cancelButton() const
 {
     return d->cancelButton;
 }
 
 // Called by KFileDialog
 void KFileWidget::slotCancel()
 {
     d->writeViewConfig();
     d->ops->close();
 }
 
 void KFileWidget::setKeepLocation(bool keep)
 {
     d->keepLocation = keep;
 }
 
 bool KFileWidget::keepsLocation() const
 {
     return d->keepLocation;
 }
 
 void KFileWidget::setOperationMode(OperationMode mode)
 {
 //     qDebug();
 
     d->operationMode = mode;
     d->keepLocation = (mode == Saving);
     d->filterWidget->setEditable(!d->hasDefaultFilter || mode != Saving);
     if (mode == Opening) {
         // don't use KStandardGuiItem::open() here which has trailing ellipsis!
         d->okButton->setText(i18n("&Open"));
         d->okButton->setIcon(QIcon::fromTheme(QStringLiteral("document-open")));
         // hide the new folder actions...usability team says they shouldn't be in open file dialog
         actionCollection()->removeAction(actionCollection()->action(QStringLiteral("mkdir")));
     } else if (mode == Saving) {
         KGuiItem::assign(d->okButton, KStandardGuiItem::save());
         d->setNonExtSelection();
     } else {
         KGuiItem::assign(d->okButton, KStandardGuiItem::ok());
     }
     d->updateLocationWhatsThis();
     d->updateAutoSelectExtension();
 
     if (d->ops) {
         d->ops->setIsSaving(mode == Saving);
     }
 }
 
 KFileWidget::OperationMode KFileWidget::operationMode() const
 {
     return d->operationMode;
 }
 
 void KFileWidgetPrivate::_k_slotAutoSelectExtClicked()
 {
 //     qDebug() << "slotAutoSelectExtClicked(): "
 //                          << autoSelectExtCheckBox->isChecked() << endl;
 
     // whether the _user_ wants it on/off
     autoSelectExtChecked = autoSelectExtCheckBox->isChecked();
 
     // update the current filename's extension
     updateLocationEditExtension(extension /* extension hasn't changed */);
 }
 
 void KFileWidgetPrivate::_k_placesViewSplitterMoved(int pos, int index)
 {
 //     qDebug();
 
     // we need to record the size of the splitter when the splitter changes size
     // so we can keep the places box the right size!
     if (placesDock && index == 1) {
         placesViewWidth = pos;
 //         qDebug() << "setting lafBox minwidth to" << placesViewWidth;
         setLafBoxColumnWidth();
     }
 }
 
 void KFileWidgetPrivate::_k_activateUrlNavigator()
 {
 //     qDebug();
 
     urlNavigator->setUrlEditable(!urlNavigator->isUrlEditable());
     if (urlNavigator->isUrlEditable()) {
         urlNavigator->setFocus();
         urlNavigator->editor()->lineEdit()->selectAll();
     }
 }
 
 void KFileWidgetPrivate::_k_zoomOutIconsSize()
 {
     const int currValue = ops->iconsZoom();
     const int futValue = qMax(0, currValue - 10);
     iconSizeSlider->setValue(futValue);
     _k_slotIconSizeSliderMoved(futValue);
 }
 
 void KFileWidgetPrivate::_k_zoomInIconsSize()
 {
     const int currValue = ops->iconsZoom();
     const int futValue = qMin(100, currValue + 10);
     iconSizeSlider->setValue(futValue);
     _k_slotIconSizeSliderMoved(futValue);
 }
 
 void KFileWidgetPrivate::_k_slotIconSizeChanged(int _value)
 {
     int maxSize = KIconLoader::SizeEnormous - KIconLoader::SizeSmall;
     int value = (maxSize * _value / 100) + KIconLoader::SizeSmall;
     switch (value) {
     case KIconLoader::SizeSmall:
     case KIconLoader::SizeSmallMedium:
     case KIconLoader::SizeMedium:
     case KIconLoader::SizeLarge:
     case KIconLoader::SizeHuge:
     case KIconLoader::SizeEnormous:
         iconSizeSlider->setToolTip(i18n("Icon size: %1 pixels (standard size)", value));
         break;
     default:
         iconSizeSlider->setToolTip(i18n("Icon size: %1 pixels", value));
         break;
     }
 }
 
 void KFileWidgetPrivate::_k_slotIconSizeSliderMoved(int _value)
 {
     // Force this to be called in case this slot is called first on the
     // slider move.
     _k_slotIconSizeChanged(_value);
 
     QPoint global(iconSizeSlider->rect().topLeft());
     global.ry() += iconSizeSlider->height() / 2;
     QHelpEvent toolTipEvent(QEvent::ToolTip, QPoint(0, 0), iconSizeSlider->mapToGlobal(global));
     QApplication::sendEvent(iconSizeSlider, &toolTipEvent);
 }
 
 void KFileWidgetPrivate::_k_slotViewDoubleClicked(const QModelIndex &index)
 {
     // double clicking to save should only work on files
     if (operationMode == KFileWidget::Saving && index.isValid() && ops->selectedItems().constFirst().isFile()) {
         q->slotOk();
     }
 }
 
 static QString getExtensionFromPatternList(const QStringList &patternList)
 {
 //     qDebug();
 
     QString ret;
 //     qDebug() << "\tgetExtension " << patternList;
 
     QStringList::ConstIterator patternListEnd = patternList.end();
     for (QStringList::ConstIterator it = patternList.begin();
             it != patternListEnd;
             ++it) {
 //         qDebug() << "\t\ttry: \'" << (*it) << "\'";
 
         // is this pattern like "*.BMP" rather than useless things like:
         //
         // README
         // *.
         // *.*
         // *.JP*G
         // *.JP?
         if ((*it).startsWith(QLatin1String("*.")) &&
                 (*it).length() > 2 &&
                 (*it).indexOf(QLatin1Char('*'), 2) < 0 && (*it).indexOf(QLatin1Char('?'), 2) < 0) {
             ret = (*it).mid(1);
             break;
         }
     }
 
     return ret;
 }
 
 static QString stripUndisplayable(const QString &string)
 {
     QString ret = string;
 
     ret.remove(QLatin1Char(':'));
     ret = KLocalizedString::removeAcceleratorMarker(ret);
 
     return ret;
 }
 
 //QString KFileWidget::currentFilterExtension()
 //{
 //    return d->extension;
 //}
 
 void KFileWidgetPrivate::updateAutoSelectExtension()
 {
     if (!autoSelectExtCheckBox) {
         return;
     }
 
     QMimeDatabase db;
     //
     // Figure out an extension for the Automatically Select Extension thing
     // (some Windows users apparently don't know what to do when confronted
     // with a text file called "COPYING" but do know what to do with
     // COPYING.txt ...)
     //
 
 //     qDebug() << "Figure out an extension: ";
     QString lastExtension = extension;
     extension.clear();
 
     // Automatically Select Extension is only valid if the user is _saving_ a _file_
     if ((operationMode == KFileWidget::Saving) && (ops->mode() & KFile::File)) {
         //
         // Get an extension from the filter
         //
 
         QString filter = filterWidget->currentFilter();
         if (!filter.isEmpty()) {
             // if the currently selected filename already has an extension which
             // is also included in the currently allowed extensions, keep it
             // otherwise use the default extension
             QString currentExtension = db.suffixForFileName(locationEditCurrentText());
             if (currentExtension.isEmpty()) {
                 currentExtension = locationEditCurrentText().section(QLatin1Char('.'), -1, -1);
             }
             // qDebug() << "filter:" << filter << "locationEdit:" << locationEditCurrentText() << "currentExtension:" << currentExtension;
 
             QString defaultExtension;
             QStringList extensionList;
 
             // e.g. "*.cpp"
             if (filter.indexOf(QLatin1Char('/')) < 0) {
                 extensionList = filter.split(QLatin1Char(' '), QString::SkipEmptyParts);
                 defaultExtension = getExtensionFromPatternList(extensionList);
             }
             // e.g. "text/html"
             else {
                 QMimeType mime = db.mimeTypeForName(filter);
                 if (mime.isValid()) {
                     extensionList = mime.globPatterns();
                     defaultExtension = mime.preferredSuffix();
                     if (!defaultExtension.isEmpty()) {
                         defaultExtension.prepend(QLatin1Char('.'));
                     }
                 }
             }
 
             if ((!currentExtension.isEmpty() && extensionList.contains(QLatin1String("*.") + currentExtension))
                     || filter == QStringLiteral("application/octet-stream")) {
                 extension = QLatin1Char('.') + currentExtension;
             } else {
                 extension = defaultExtension;
             }
 
             // qDebug() << "List:" << extensionList << "auto-selected extension:" << extension;
         }
 
         //
         // GUI: checkbox
         //
 
         QString whatsThisExtension;
         if (!extension.isEmpty()) {
             // remember: sync any changes to the string with below
             autoSelectExtCheckBox->setText(i18n("Automatically select filename e&xtension (%1)",  extension));
             whatsThisExtension = i18n("the extension <b>%1</b>",  extension);
 
             autoSelectExtCheckBox->setEnabled(true);
             autoSelectExtCheckBox->setChecked(autoSelectExtChecked);
         } else {
             // remember: sync any changes to the string with above
             autoSelectExtCheckBox->setText(i18n("Automatically select filename e&xtension"));
             whatsThisExtension = i18n("a suitable extension");
 
             autoSelectExtCheckBox->setChecked(false);
             autoSelectExtCheckBox->setEnabled(false);
         }
 
         const QString locationLabelText = stripUndisplayable(locationLabel->text());
         autoSelectExtCheckBox->setWhatsThis(QLatin1String("<qt>") +
                                             i18n(
                                                 "This option enables some convenient features for "
                                                 "saving files with extensions:<br />"
                                                 "<ol>"
                                                 "<li>Any extension specified in the <b>%1</b> text "
                                                 "area will be updated if you change the file type "
                                                 "to save in.<br />"
                                                 "<br /></li>"
                                                 "<li>If no extension is specified in the <b>%2</b> "
                                                 "text area when you click "
                                                 "<b>Save</b>, %3 will be added to the end of the "
                                                 "filename (if the filename does not already exist). "
                                                 "This extension is based on the file type that you "
                                                 "have chosen to save in.<br />"
                                                 "<br />"
                                                 "If you do not want KDE to supply an extension for the "
                                                 "filename, you can either turn this option off or you "
                                                 "can suppress it by adding a period (.) to the end of "
                                                 "the filename (the period will be automatically "
                                                 "removed)."
                                                 "</li>"
                                                 "</ol>"
                                                 "If unsure, keep this option enabled as it makes your "
                                                 "files more manageable."
                                                 ,
                                                 locationLabelText,
                                                 locationLabelText,
                                                 whatsThisExtension)
                                             + QLatin1String("</qt>")
                                            );
 
         autoSelectExtCheckBox->show();
 
         // update the current filename's extension
         updateLocationEditExtension(lastExtension);
     }
     // Automatically Select Extension not valid
     else {
         autoSelectExtCheckBox->setChecked(false);
         autoSelectExtCheckBox->hide();
     }
 }
 
 // Updates the extension of the filename specified in d->locationEdit if the
 // Automatically Select Extension feature is enabled.
 // (this prevents you from accidently saving "file.kwd" as RTF, for example)
 void KFileWidgetPrivate::updateLocationEditExtension(const QString &lastExtension)
 {
     if (!autoSelectExtCheckBox->isChecked() || extension.isEmpty()) {
         return;
     }
 
     QString urlStr = locationEditCurrentText();
     if (urlStr.isEmpty()) {
         return;
     }
 
     QUrl url = getCompleteUrl(urlStr);
 //     qDebug() << "updateLocationEditExtension (" << url << ")";
 
     const int fileNameOffset = urlStr.lastIndexOf(QLatin1Char('/')) + 1;
     QString fileName = urlStr.mid(fileNameOffset);
 
     const int dot = fileName.lastIndexOf(QLatin1Char('.'));
     const int len = fileName.length();
     if (dot > 0 && // has an extension already and it's not a hidden file
             // like ".hidden" (but we do accept ".hidden.ext")
             dot != len - 1 // and not deliberately suppressing extension
        ) {
         // exists?
         KIO::StatJob *statJob = KIO::stat(url, KIO::HideProgressInfo);
         KJobWidgets::setWindow(statJob, q);
         bool result = statJob->exec();
         if (result) {
 //             qDebug() << "\tfile exists";
 
             if (statJob->statResult().isDir()) {
 //                 qDebug() << "\tisDir - won't alter extension";
                 return;
             }
 
             // --- fall through ---
         }
 
         //
         // try to get rid of the current extension
         //
 
         // catch "double extensions" like ".tar.gz"
         if (lastExtension.length() && fileName.endsWith(lastExtension)) {
             fileName.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/kurlnavigatorprotocolcombo.cpp b/src/filewidgets/kurlnavigatorprotocolcombo.cpp
index 086c9a5d..e50bf943 100644
--- a/src/filewidgets/kurlnavigatorprotocolcombo.cpp
+++ b/src/filewidgets/kurlnavigatorprotocolcombo.cpp
@@ -1,234 +1,234 @@
 /***************************************************************************
  *   Copyright (C) 2006 by Aaron J. Seigo (<aseigo@kde.org>)               *
  *   Copyright (C) 2009 by Peter Penz (<peter.penz@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) 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     *
  *   Lesser General Public License for more details.                       *
  *                                                                         *
  *   You should have received a copy of the GNU Lesser General Public      *
  *   License along with this library; if not, write to the                 *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA          *
  ***************************************************************************/
 
 #include "kurlnavigatorprotocolcombo_p.h"
 
 #include <QAction>
 #include <QMenu>
 #include <QPainter>
 #include <QPaintEvent>
 #include <QStyleOption>
 
 #include <klocalizedstring.h>
 #include <kprotocolinfo.h>
 #include <kprotocolmanager.h>
 #include <kurlnavigator.h>
 
 namespace
 {
 const int ArrowSize = 10;
 }
 
 namespace KDEPrivate
 {
 
 KUrlNavigatorProtocolCombo::KUrlNavigatorProtocolCombo(const QString &protocol, QWidget *parent) :
     KUrlNavigatorButtonBase(parent),
     m_menu(nullptr),
     m_protocols(),
     m_categories()
 {
     m_menu = new QMenu(this);
     connect(m_menu, &QMenu::triggered, this, QOverload<QAction*>::of(&KUrlNavigatorProtocolCombo::setProtocol));
     setText(protocol);
     setMenu(m_menu);
 }
 
 void KUrlNavigatorProtocolCombo::setCustomProtocols(const QStringList &protocols)
 {
     m_protocols = protocols;
     m_menu->clear();
 
     foreach (const QString &protocol, protocols) {
         QAction *action = m_menu->addAction(protocol);
         action->setData(protocol);
     }
 }
 
 QSize KUrlNavigatorProtocolCombo::sizeHint() const
 {
     const QSize size = KUrlNavigatorButtonBase::sizeHint();
 
     QFontMetrics fontMetrics(font());
     int width = fontMetrics.width(KLocalizedString::removeAcceleratorMarker(text()));
     width += (3 * BorderWidth) + ArrowSize;
 
     return QSize(width, size.height());
 }
 
 void KUrlNavigatorProtocolCombo::setProtocol(const QString &protocol)
 {
     setText(protocol);
 }
 
 QString KUrlNavigatorProtocolCombo::currentProtocol() const
 {
     return text();
 }
 
 void KUrlNavigatorProtocolCombo::showEvent(QShowEvent *event)
 {
     KUrlNavigatorButtonBase::showEvent(event);
     if (!event->spontaneous() && m_protocols.isEmpty()) {
         m_protocols = KProtocolInfo::protocols();
         qSort(m_protocols);
 
         QStringList::iterator it = m_protocols.begin();
         while (it != m_protocols.end()) {
             QUrl url;
             url.setScheme(*it);
             if (!KProtocolManager::supportsListing(url)) {
                 it = m_protocols.erase(it);
             } else {
                 ++it;
             }
         }
 
         updateMenu();
     }
 }
 
 void KUrlNavigatorProtocolCombo::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event);
 
     QPainter painter(this);
     const int buttonWidth  = width();
     const int buttonHeight = height();
 
     drawHoverBackground(&painter);
 
     const QColor fgColor = foregroundColor();
     painter.setPen(fgColor);
 
     // draw arrow
     const int arrowX = buttonWidth - ArrowSize - BorderWidth;
     const int arrowY = (buttonHeight - ArrowSize) / 2;
 
     QStyleOption option;
     option.rect = QRect(arrowX, arrowY, ArrowSize, ArrowSize);
     option.palette = palette();
     option.palette.setColor(QPalette::Text, fgColor);
     option.palette.setColor(QPalette::WindowText, fgColor);
     option.palette.setColor(QPalette::ButtonText, fgColor);
     style()->drawPrimitive(QStyle::PE_IndicatorArrowDown, &option, &painter, this);
 
     // draw text
     const int textWidth = arrowX - (2 * BorderWidth);
     int alignment = Qt::AlignCenter | Qt::TextShowMnemonic;
     if (!style()->styleHint(QStyle::SH_UnderlineShortcut, &option, this)) {
         alignment |= Qt::TextHideMnemonic;
     }
     style()->drawItemText(&painter, QRect(BorderWidth, 0, textWidth, buttonHeight),
                           alignment, option.palette, isEnabled(), text());
 }
 
 void KUrlNavigatorProtocolCombo::setProtocol(QAction *action)
 {
     const QString protocol = action->data().toString();
     setText(protocol);
     emit activated(protocol);
 }
 
 void KUrlNavigatorProtocolCombo::updateMenu()
 {
     initializeCategories();
     qSort(m_protocols);
 
     // move all protocols into the corresponding category of 'items'
     QList<QString> items[CategoryCount];
     foreach (const QString &protocol, m_protocols) {
         if (m_categories.contains(protocol)) {
             const ProtocolCategory category = m_categories.value(protocol);
             items[category].append(protocol);
         } else {
             items[OtherCategory].append(protocol);
         }
     }
 
     // Create the menu that includes all entries from 'items'. The categories
     // CoreCategory and PlacesCategory are placed at the top level, the remaining
     // categories are placed in sub menus.
     QMenu *menu = m_menu;
     for (int category = 0; category < CategoryCount; ++category) {
-        if (items[category].count() > 0) {
+        if (!items[category].isEmpty()) {
             switch (category) {
             case DevicesCategory:
                 menu = m_menu->addMenu(i18nc("@item:inmenu", "Devices"));
                 break;
 
             case SubversionCategory:
                 menu = m_menu->addMenu(i18nc("@item:inmenu", "Subversion"));
                 break;
 
             case OtherCategory:
                 menu = m_menu->addMenu(i18nc("@item:inmenu", "Other"));
                 break;
 
             case CoreCategory:
             case PlacesCategory:
             default:
                 break;
             }
 
             foreach (const QString &protocol, items[category]) {
                 QAction *action = menu->addAction(protocol);
                 action->setData(protocol);
             }
 
             if (menu == m_menu) {
                 menu->addSeparator();
             }
         }
     }
 }
 
 void KUrlNavigatorProtocolCombo::initializeCategories()
 {
     if (m_categories.isEmpty()) {
         m_categories.insert(QStringLiteral("file"), CoreCategory);
         m_categories.insert(QStringLiteral("ftp"), CoreCategory);
         m_categories.insert(QStringLiteral("fish"), CoreCategory);
         m_categories.insert(QStringLiteral("nfs"), CoreCategory);
         m_categories.insert(QStringLiteral("sftp"), CoreCategory);
         m_categories.insert(QStringLiteral("smb"), CoreCategory);
         m_categories.insert(QStringLiteral("webdav"), CoreCategory);
 
         m_categories.insert(QStringLiteral("desktop"), PlacesCategory);
         m_categories.insert(QStringLiteral("fonts"), PlacesCategory);
         m_categories.insert(QStringLiteral("programs"), PlacesCategory);
         m_categories.insert(QStringLiteral("settings"), PlacesCategory);
         m_categories.insert(QStringLiteral("trash"), PlacesCategory);
 
         m_categories.insert(QStringLiteral("floppy"), DevicesCategory);
         m_categories.insert(QStringLiteral("camera"), DevicesCategory);
         m_categories.insert(QStringLiteral("remote"), DevicesCategory);
 
         m_categories.insert(QStringLiteral("svn"), SubversionCategory);
         m_categories.insert(QStringLiteral("svn+file"), SubversionCategory);
         m_categories.insert(QStringLiteral("svn+http"), SubversionCategory);
         m_categories.insert(QStringLiteral("svn+https"), SubversionCategory);
         m_categories.insert(QStringLiteral("svn+ssh"), SubversionCategory);
     }
 }
 
 } // namespace KDEPrivate
 
 #include "moc_kurlnavigatorprotocolcombo_p.cpp"
diff --git a/src/ioslaves/http/http.cpp b/src/ioslaves/http/http.cpp
index 2c556047..3016bee1 100644
--- a/src/ioslaves/http/http.cpp
+++ b/src/ioslaves/http/http.cpp
@@ -1,5626 +1,5626 @@
 /*
    Copyright (C) 2000-2003 Waldo Bastian <bastian@kde.org>
    Copyright (C) 2000-2002 George Staikos <staikos@kde.org>
    Copyright (C) 2000-2002 Dawit Alemayehu <adawit@kde.org>
    Copyright (C) 2001,2002 Hamish Rodda <rodda@kde.org>
    Copyright (C) 2007      Nick Shaforostoff <shafff@ukr.net>
    Copyright (C) 2007-2018 Daniel Nicoletti <dantti12@gmail.com>
    Copyright (C) 2008,2009 Andreas Hartmetz <ahartmetz@gmail.com>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License (LGPL) 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.
 */
 
 // TODO delete / do not save very big files; "very big" to be defined
 
 #include "http.h"
 
 #include <config-kioslave-http.h>
 
 #include <qplatformdefs.h> // must be explicitly included for MacOSX
 
 #include <qdom.h>
 #include <QFile>
 #include <QLibraryInfo>
 #include <QRegExp>
 #include <QDateTime>
 #include <QBuffer>
 #include <QIODevice>
 #include <QTemporaryFile>
 #include <QStandardPaths>
 #include <QDBusConnection>
 #include <QMimeDatabase>
 #include <QAuthenticator>
 #include <QNetworkProxy>
 #include <QTcpSocket>
 #include <QNetworkConfigurationManager>
 #include <QUrl>
 #include <QCoreApplication>
 #include <QDataStream>
 #include <QThread>
 
 #include <QDebug>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <klocalizedstring.h>
 
 #include <QDBusInterface>
 #include <kremoteencoding.h>
 #include <ktcpsocket.h>
 
 #include <ioslave_defaults.h>
 #include <http_slave_defaults.h>
 
 #include <QDBusReply>
 #include <QProcess>
 #include <httpfilter.h>
 
 #include <sys/stat.h>
 
 #include "httpauthentication.h"
 #include "kioglobal_p.h"
 
 #include <QLoggingCategory>
 Q_DECLARE_LOGGING_CATEGORY(KIO_HTTP)
 Q_LOGGING_CATEGORY(KIO_HTTP, "kf5.kio.kio_http", QtWarningMsg) // disable debug by default
 
 // HeaderTokenizer declarations
 #include "parsinghelpers.h"
 //string parsing helpers and HeaderTokenizer implementation
 #include "parsinghelpers.cpp"
 
 // Pseudo plugin class to embed meta data
 class KIOPluginForMetaData : public QObject
 {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "org.kde.kio.slave.http" FILE "http.json")
 };
 
 static bool supportedProxyScheme(const QString &scheme)
 {
     // scheme is supposed to be lowercase
     return (scheme.startsWith(QLatin1String("http"))
             || scheme == QLatin1String("socks"));
 }
 
 // see filenameFromUrl(): a sha1 hash is 160 bits
 static const int s_hashedUrlBits = 160;   // this number should always be divisible by eight
 static const int s_hashedUrlNibbles = s_hashedUrlBits / 4;
 static const int s_MaxInMemPostBufSize = 256 * 1024;   // Write anything over 256 KB to file...
 
 using namespace KIO;
 
 extern "C" Q_DECL_EXPORT int kdemain(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);   // needed for QSocketNotifier
     app.setApplicationName(QStringLiteral("kio_http"));
 
     if (argc != 4) {
         fprintf(stderr, "Usage: kio_http protocol domain-socket1 domain-socket2\n");
         exit(-1);
     }
 
     HTTPProtocol slave(argv[1], argv[2], argv[3]);
     slave.dispatchLoop();
     return 0;
 }
 
 /***********************************  Generic utility functions ********************/
 
 static QString toQString(const QByteArray &value)
 {
     return QString::fromLatin1(value.constData(), value.size());
 }
 
 static bool isCrossDomainRequest(const QString &fqdn, const QString &originURL)
 {
     //TODO read the RFC
     if (originURL == QLatin1String("true")) { // Backwards compatibility
         return true;
     }
 
     QUrl url(originURL);
 
     // Document Origin domain
     QString a = url.host();
     // Current request domain
     QString b = fqdn;
 
     if (a == b) {
         return false;
     }
 
     QStringList la = a.split(QLatin1Char('.'), QString::SkipEmptyParts);
     QStringList lb = b.split(QLatin1Char('.'), QString::SkipEmptyParts);
 
     if (qMin(la.count(), lb.count()) < 2) {
         return true;  // better safe than sorry...
     }
 
     while (la.count() > 2) {
         la.pop_front();
     }
     while (lb.count() > 2) {
         lb.pop_front();
     }
 
     return la != lb;
 }
 
 /*
   Eliminates any custom header that could potentially alter the request
 */
 static QString sanitizeCustomHTTPHeader(const QString &_header)
 {
     QString sanitizedHeaders;
     const QStringList headers = _header.split(QRegExp(QStringLiteral("[\r\n]")));
 
     for (QStringList::ConstIterator it = headers.begin(); it != headers.end(); ++it) {
         // Do not allow Request line to be specified and ignore
         // the other HTTP headers.
         if (!(*it).contains(QLatin1Char(':')) ||
                 (*it).startsWith(QLatin1String("host"), Qt::CaseInsensitive) ||
                 (*it).startsWith(QLatin1String("proxy-authorization"), Qt::CaseInsensitive) ||
                 (*it).startsWith(QLatin1String("via"), Qt::CaseInsensitive)) {
             continue;
         }
 
         sanitizedHeaders += (*it) + QLatin1String("\r\n");
     }
     sanitizedHeaders.chop(2);
 
     return sanitizedHeaders;
 }
 
 static bool isPotentialSpoofingAttack(const HTTPProtocol::HTTPRequest &request, const KConfigGroup *config)
 {
     qCDebug(KIO_HTTP) << request.url << "response code: " << request.responseCode << "previous response code:" << request.prevResponseCode;
     if (config->readEntry("no-spoof-check", false)) {
         return false;
     }
 
     if (request.url.userName().isEmpty()) {
         return false;
     }
 
     // We already have cached authentication.
     if (config->readEntry(QStringLiteral("cached-www-auth"), false)) {
         return false;
     }
 
     const QString userName = config->readEntry(QStringLiteral("LastSpoofedUserName"), QString());
     return ((userName.isEmpty() || userName != request.url.userName()) && request.responseCode != 401 && request.prevResponseCode != 401);
 }
 
 // for a given response code, conclude if the response is going to/likely to have a response body
 static bool canHaveResponseBody(int responseCode, KIO::HTTP_METHOD method)
 {
     /* RFC 2616 says...
         1xx: false
         200: method HEAD: false, otherwise:true
         201: true
         202: true
         203: see 200
         204: false
         205: false
         206: true
         300: see 200
         301: see 200
         302: see 200
         303: see 200
         304: false
         305: probably like 300, RFC seems to expect disconnection afterwards...
         306: (reserved), for simplicity do it just like 200
         307: see 200
         4xx: see 200
         5xx :see 200
     */
     if (responseCode >= 100 && responseCode < 200) {
         return false;
     }
     switch (responseCode) {
     case 201:
     case 202:
     case 206:
         // RFC 2616 does not mention HEAD in the description of the above. if the assert turns out
         // to be a problem the response code should probably be treated just like 200 and friends.
         Q_ASSERT(method != HTTP_HEAD);
         return true;
     case 204:
     case 205:
     case 304:
         return false;
     default:
         break;
     }
     // safe (and for most remaining response codes exactly correct) default
     return method != HTTP_HEAD;
 }
 
 static bool isEncryptedHttpVariety(const QByteArray &p)
 {
     return p == "https" || p == "webdavs";
 }
 
 static bool isValidProxy(const QUrl &u)
 {
     return u.isValid() && !u.host().isEmpty();
 }
 
 static bool isHttpProxy(const QUrl &u)
 {
     return isValidProxy(u) && u.scheme() == QLatin1String("http");
 }
 
 static QIODevice *createPostBufferDeviceFor(KIO::filesize_t size)
 {
     QIODevice *device;
     if (size > static_cast<KIO::filesize_t>(s_MaxInMemPostBufSize)) {
         device = new QTemporaryFile;
     } else {
         device = new QBuffer;
     }
 
     if (!device->open(QIODevice::ReadWrite)) {
         return nullptr;
     }
 
     return device;
 }
 
 QByteArray HTTPProtocol::HTTPRequest::methodString() const
 {
     if (!methodStringOverride.isEmpty()) {
         return (methodStringOverride).toLatin1();
     }
 
     switch (method) {
     case HTTP_GET:
         return "GET";
     case HTTP_PUT:
         return "PUT";
     case HTTP_POST:
         return "POST";
     case HTTP_HEAD:
         return "HEAD";
     case HTTP_DELETE:
         return "DELETE";
     case HTTP_OPTIONS:
         return "OPTIONS";
     case DAV_PROPFIND:
         return "PROPFIND";
     case DAV_PROPPATCH:
         return "PROPPATCH";
     case DAV_MKCOL:
         return "MKCOL";
     case DAV_COPY:
         return "COPY";
     case DAV_MOVE:
         return "MOVE";
     case DAV_LOCK:
         return "LOCK";
     case DAV_UNLOCK:
         return "UNLOCK";
     case DAV_SEARCH:
         return "SEARCH";
     case DAV_SUBSCRIBE:
         return "SUBSCRIBE";
     case DAV_UNSUBSCRIBE:
         return "UNSUBSCRIBE";
     case DAV_POLL:
         return "POLL";
     case DAV_NOTIFY:
         return "NOTIFY";
     case DAV_REPORT:
         return "REPORT";
     default:
         Q_ASSERT(false);
         return QByteArray();
     }
 }
 
 static QString formatHttpDate(const QDateTime &date)
 {
     return QLocale::c().toString(date, QStringLiteral("ddd, dd MMM yyyy hh:mm:ss 'GMT'"));
 }
 
 static bool isAuthenticationRequired(int responseCode)
 {
     return (responseCode == 401) || (responseCode == 407);
 }
 
 static void changeProtocolToHttp(QUrl* url)
 {
     const QString protocol(url->scheme());
     if (protocol == QLatin1String("webdavs")) {
         url->setScheme(QStringLiteral("https"));
     } else if (protocol == QLatin1String("webdav")) {
         url->setScheme(QStringLiteral("http"));
     }
 }
 
 #define NO_SIZE ((KIO::filesize_t) -1)
 
 #if HAVE_STRTOLL
 #define STRTOLL strtoll
 #else
 #define STRTOLL strtol
 #endif
 
 /************************************** HTTPProtocol **********************************************/
 
 HTTPProtocol::HTTPProtocol(const QByteArray &protocol, const QByteArray &pool,
                            const QByteArray &app)
     : TCPSlaveBase(protocol, pool, app, isEncryptedHttpVariety(protocol))
     , m_iSize(NO_SIZE)
     , m_iPostDataSize(NO_SIZE)
     , m_isBusy(false)
     , m_POSTbuf(nullptr)
     , m_maxCacheAge(DEFAULT_MAX_CACHE_AGE)
     , m_maxCacheSize(DEFAULT_MAX_CACHE_SIZE)
     , m_protocol(protocol)
     , m_wwwAuth(nullptr)
     , m_triedWwwCredentials(NoCredentials)
     , m_proxyAuth(nullptr)
     , m_triedProxyCredentials(NoCredentials)
     , m_socketProxyAuth(nullptr)
     , m_networkConfig(nullptr)
     , m_kioError(0)
     , m_isLoadingErrorPage(false)
     , m_remoteRespTimeout(DEFAULT_RESPONSE_TIMEOUT)
     , m_iEOFRetryCount(0)
 {
     reparseConfiguration();
     setBlocking(true);
     connect(socket(), SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
             this, SLOT(proxyAuthenticationForSocket(QNetworkProxy,QAuthenticator*)));
 }
 
 HTTPProtocol::~HTTPProtocol()
 {
     httpClose(false);
 }
 
 void HTTPProtocol::reparseConfiguration()
 {
     qCDebug(KIO_HTTP);
 
     delete m_proxyAuth;
     delete m_wwwAuth;
     m_proxyAuth = nullptr;
     m_wwwAuth = nullptr;
     m_request.proxyUrl.clear(); //TODO revisit
     m_request.proxyUrls.clear();
 
     TCPSlaveBase::reparseConfiguration();
 }
 
 void HTTPProtocol::resetConnectionSettings()
 {
     m_isEOF = false;
     m_kioError = 0;
     m_isLoadingErrorPage = false;
 }
 
 quint16 HTTPProtocol::defaultPort() const
 {
     return isEncryptedHttpVariety(m_protocol) ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT;
 }
 
 void HTTPProtocol::resetResponseParsing()
 {
     m_isRedirection = false;
     m_isChunked = false;
     m_iSize = NO_SIZE;
     clearUnreadBuffer();
 
     m_responseHeaders.clear();
     m_contentEncodings.clear();
     m_transferEncodings.clear();
     m_contentMD5.clear();
     m_mimeType.clear();
 
     setMetaData(QStringLiteral("request-id"), m_request.id);
 }
 
 void HTTPProtocol::resetSessionSettings()
 {
     // Follow HTTP/1.1 spec and enable keep-alive by default
     // unless the remote side tells us otherwise or we determine
     // the persistent link has been terminated by the remote end.
     m_request.isKeepAlive = true;
     m_request.keepAliveTimeout = 0;
 
     m_request.redirectUrl = QUrl();
     m_request.useCookieJar = config()->readEntry("Cookies", false);
     m_request.cacheTag.useCache = config()->readEntry("UseCache", true);
     m_request.preferErrorPage = config()->readEntry("errorPage", true);
     const bool noAuth = config()->readEntry("no-auth", false);
     m_request.doNotWWWAuthenticate = config()->readEntry("no-www-auth", noAuth);
     m_request.doNotProxyAuthenticate = config()->readEntry("no-proxy-auth", noAuth);
     m_strCacheDir = config()->readPathEntry("CacheDir", QString());
     m_maxCacheAge = config()->readEntry("MaxCacheAge", DEFAULT_MAX_CACHE_AGE);
     m_request.windowId = config()->readEntry("window-id");
 
     m_request.methodStringOverride = metaData(QStringLiteral("CustomHTTPMethod"));
     m_request.sentMethodString.clear();
 
     qCDebug(KIO_HTTP) << "Window Id =" << m_request.windowId;
     qCDebug(KIO_HTTP) << "ssl_was_in_use =" << metaData(QStringLiteral("ssl_was_in_use"));
 
     m_request.referrer.clear();
     // RFC 2616: do not send the referrer if the referrer page was served using SSL and
     //           the current page does not use SSL.
     if (config()->readEntry("SendReferrer", true) &&
             (isEncryptedHttpVariety(m_protocol) || metaData(QStringLiteral("ssl_was_in_use")) != QLatin1String("TRUE"))) {
         QUrl refUrl(metaData(QStringLiteral("referrer")));
         if (refUrl.isValid()) {
             // Sanitize
             QString protocol = refUrl.scheme();
             if (protocol.startsWith(QLatin1String("webdav"))) {
                 protocol.replace(0, 6, QStringLiteral("http"));
                 refUrl.setScheme(protocol);
             }
 
             if (protocol.startsWith(QLatin1String("http"))) {
                 m_request.referrer = toQString(refUrl.toEncoded(QUrl::RemoveUserInfo | QUrl::RemoveFragment));
             }
         }
     }
 
     if (config()->readEntry("SendLanguageSettings", true)) {
         m_request.charsets = config()->readEntry("Charsets", DEFAULT_PARTIAL_CHARSET_HEADER);
         if (!m_request.charsets.contains(QLatin1String("*;"), Qt::CaseInsensitive)) {
             m_request.charsets += QLatin1String(",*;q=0.5");
         }
         m_request.languages = config()->readEntry("Languages", DEFAULT_LANGUAGE_HEADER);
     } else {
         m_request.charsets.clear();
         m_request.languages.clear();
     }
 
     // Adjust the offset value based on the "range-start" meta-data.
     QString resumeOffset = metaData(QStringLiteral("range-start"));
     if (resumeOffset.isEmpty()) {
         resumeOffset = metaData(QStringLiteral("resume")); // old name
     }
     if (!resumeOffset.isEmpty()) {
         m_request.offset = resumeOffset.toULongLong();
     } else {
         m_request.offset = 0;
     }
     // Same procedure for endoffset.
     QString resumeEndOffset = metaData(QStringLiteral("range-end"));
     if (resumeEndOffset.isEmpty()) {
         resumeEndOffset = metaData(QStringLiteral("resume_until")); // old name
     }
     if (!resumeEndOffset.isEmpty()) {
         m_request.endoffset = resumeEndOffset.toULongLong();
     } else {
         m_request.endoffset = 0;
     }
 
     m_request.disablePassDialog = config()->readEntry("DisablePassDlg", false);
     m_request.allowTransferCompression = config()->readEntry("AllowCompressedPage", true);
     m_request.id = metaData(QStringLiteral("request-id"));
 
     // Store user agent for this host.
     if (config()->readEntry("SendUserAgent", true)) {
         m_request.userAgent = metaData(QStringLiteral("UserAgent"));
     } else {
         m_request.userAgent.clear();
     }
 
     m_request.cacheTag.etag.clear();
     m_request.cacheTag.servedDate = QDateTime();
     m_request.cacheTag.lastModifiedDate = QDateTime();
     m_request.cacheTag.expireDate = QDateTime();
     m_request.responseCode = 0;
     m_request.prevResponseCode = 0;
 
     delete m_wwwAuth;
     m_wwwAuth = nullptr;
     delete m_socketProxyAuth;
     m_socketProxyAuth = nullptr;
     m_blacklistedWwwAuthMethods.clear();
     m_triedWwwCredentials = NoCredentials;
     m_blacklistedProxyAuthMethods.clear();
     m_triedProxyCredentials = NoCredentials;
 
     // Obtain timeout values
     m_remoteRespTimeout = responseTimeout();
 
     // Bounce back the actual referrer sent
     setMetaData(QStringLiteral("referrer"), m_request.referrer);
 
     // Reset the post data size
     m_iPostDataSize = NO_SIZE;
 
     // Reset the EOF retry counter
     m_iEOFRetryCount = 0;
 }
 
 void HTTPProtocol::setHost(const QString &host, quint16 port,
                            const QString &user, const QString &pass)
 {
     // Reset the webdav-capable flags for this host
     if (m_request.url.host() != host) {
         m_davHostOk = m_davHostUnsupported = false;
     }
 
     m_request.url.setHost(host);
 
     // is it an IPv6 address?
     if (host.indexOf(QLatin1Char(':')) == -1) {
         m_request.encoded_hostname = toQString(QUrl::toAce(host));
     } else  {
         int pos = host.indexOf(QLatin1Char('%'));
         if (pos == -1) {
             m_request.encoded_hostname = QLatin1Char('[') + host + QLatin1Char(']');
         } else
             // don't send the scope-id in IPv6 addresses to the server
         {
             m_request.encoded_hostname = QLatin1Char('[') + host.leftRef(pos) + QLatin1Char(']');
         }
     }
     m_request.url.setPort((port > 0 && port != defaultPort()) ? port : -1);
     m_request.url.setUserName(user);
     m_request.url.setPassword(pass);
 
     // On new connection always clear previous proxy information...
     m_request.proxyUrl.clear();
     m_request.proxyUrls.clear();
 
     qCDebug(KIO_HTTP) << "Hostname is now:" << m_request.url.host() << "(" << m_request.encoded_hostname << ")";
 }
 
 bool HTTPProtocol::maybeSetRequestUrl(const QUrl &u)
 {
     qCDebug(KIO_HTTP) << u;
 
     m_request.url = u;
     m_request.url.setPort(u.port(defaultPort()) != defaultPort() ? u.port() : -1);
 
     if (u.host().isEmpty()) {
         error(KIO::ERR_UNKNOWN_HOST, i18n("No host specified."));
         return false;
     }
 
     if (u.path().isEmpty()) {
         QUrl newUrl(u);
         newUrl.setPath(QStringLiteral("/"));
         redirection(newUrl);
         finished();
         return false;
     }
 
     return true;
 }
 
 void HTTPProtocol::proceedUntilResponseContent(bool dataInternal /* = false */)
 {
     qCDebug(KIO_HTTP);
 
     const bool status = proceedUntilResponseHeader() &&
                         readBody(dataInternal || m_kioError);
 
     // If not an error condition or internal request, close
     // the connection based on the keep alive settings...
     if (!m_kioError && !dataInternal) {
         httpClose(m_request.isKeepAlive);
     }
 
     // if data is required internally or we got error, don't finish,
     // it is processed before we finish()
     if (dataInternal || !status) {
         return;
     }
 
     if (!sendHttpError()) {
         finished();
     }
 }
 
 bool HTTPProtocol::proceedUntilResponseHeader()
 {
     qCDebug(KIO_HTTP);
 
     // Retry the request until it succeeds or an unrecoverable error occurs.
     // Recoverable errors are, for example:
     // - Proxy or server authentication required: Ask for credentials and try again,
     //   this time with an authorization header in the request.
     // - Server-initiated timeout on keep-alive connection: Reconnect and try again
 
     while (true) {
         if (!sendQuery()) {
             return false;
         }
         if (readResponseHeader()) {
             // Success, finish the request.
             break;
         }
 
         // If not loading error page and the response code requires us to resend the query,
         // then throw away any error message that might have been sent by the server.
         if (!m_isLoadingErrorPage && isAuthenticationRequired(m_request.responseCode)) {
             // This gets rid of any error page sent with 401 or 407 authentication required response...
             readBody(true);
         }
 
         // no success, close the cache file so the cache state is reset - that way most other code
         // doesn't have to deal with the cache being in various states.
         cacheFileClose();
         if (m_kioError || m_isLoadingErrorPage) {
             // Unrecoverable error, abort everything.
             // Also, if we've just loaded an error page there is nothing more to do.
             // In that case we abort to avoid loops; some webservers manage to send 401 and
             // no authentication request. Or an auth request we don't understand.
             setMetaData(QStringLiteral("responsecode"), QString::number(m_request.responseCode));
             return false;
         }
 
         if (!m_request.isKeepAlive) {
             httpCloseConnection();
             m_request.isKeepAlive = true;
             m_request.keepAliveTimeout = 0;
         }
     }
 
     // Do not save authorization if the current response code is
     // 4xx (client error) or 5xx (server error).
     qCDebug(KIO_HTTP) << "Previous Response:" << m_request.prevResponseCode;
     qCDebug(KIO_HTTP) << "Current Response:" << m_request.responseCode;
 
     setMetaData(QStringLiteral("responsecode"), QString::number(m_request.responseCode));
     setMetaData(QStringLiteral("content-type"), m_mimeType);
 
     // At this point sendBody() should have delivered any POST data.
     clearPostDataBuffer();
 
     return true;
 }
 
 void HTTPProtocol::stat(const QUrl &url)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     if (m_protocol != "webdav" && m_protocol != "webdavs") {
         QString statSide = metaData(QStringLiteral("statSide"));
         if (statSide != QLatin1String("source")) {
             // When uploading we assume the file doesn't exit
             error(ERR_DOES_NOT_EXIST, url.toDisplayString());
             return;
         }
 
         // When downloading we assume it exists
         UDSEntry entry;
         entry.fastInsert(KIO::UDSEntry::UDS_NAME, url.fileName());
         entry.fastInsert(KIO::UDSEntry::UDS_FILE_TYPE, S_IFREG);   // a file
         entry.fastInsert(KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IRGRP | S_IROTH);   // readable by everybody
 
         statEntry(entry);
         finished();
         return;
     }
 
     davStatList(url);
 }
 
 void HTTPProtocol::listDir(const QUrl &url)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     davStatList(url, false);
 }
 
 void HTTPProtocol::davSetRequest(const QByteArray &requestXML)
 {
     // insert the document into the POST buffer, kill trailing zero byte
     cachePostData(requestXML);
 }
 
 void HTTPProtocol::davStatList(const QUrl &url, bool stat)
 {
     UDSEntry entry;
 
     // check to make sure this host supports WebDAV
     if (!davHostOk()) {
         return;
     }
 
     QMimeDatabase db;
 
     // Maybe it's a disguised SEARCH...
     QString query = metaData(QStringLiteral("davSearchQuery"));
     if (!query.isEmpty()) {
         const QByteArray request =
             "<?xml version=\"1.0\"?>\r\n"
             "<D:searchrequest xmlns:D=\"DAV:\">\r\n" + query.toUtf8() + "</D:searchrequest>\r\n";
 
         davSetRequest(request);
     } else {
         // We are only after certain features...
         QByteArray request = QByteArrayLiteral("<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
                   "<D:propfind xmlns:D=\"DAV:\">");
 
         // insert additional XML request from the davRequestResponse metadata
         if (hasMetaData(QStringLiteral("davRequestResponse"))) {
             request += metaData(QStringLiteral("davRequestResponse")).toUtf8();
         } else {
             // No special request, ask for default properties
             request += "<D:prop>"
                        "<D:creationdate/>"
                        "<D:getcontentlength/>"
                        "<D:displayname/>"
                        "<D:source/>"
                        "<D:getcontentlanguage/>"
                        "<D:getcontenttype/>"
                        "<D:getlastmodified/>"
                        "<D:getetag/>"
                        "<D:supportedlock/>"
                        "<D:lockdiscovery/>"
                        "<D:resourcetype/>"
                        "<D:quota-available-bytes/>"
                        "<D:quota-used-bytes/>"
                        "</D:prop>";
         }
         request += "</D:propfind>";
 
         davSetRequest(request);
     }
 
     // WebDAV Stat or List...
     m_request.method = query.isEmpty() ? DAV_PROPFIND : DAV_SEARCH;
     m_request.url.setQuery(QString());
     m_request.cacheTag.policy = CC_Reload;
     m_request.davData.depth = stat ? 0 : 1;
     if (!stat) {
         if (!m_request.url.path().endsWith(QLatin1Char('/'))) {
             m_request.url.setPath(m_request.url.path() + QLatin1Char('/'));
         }
     }
 
     proceedUntilResponseContent(true);
     infoMessage(QLatin1String(""));
 
     // Has a redirection already been called? If so, we're done.
     if (m_isRedirection || m_kioError) {
         if (m_isRedirection) {
             davFinished();
         }
         return;
     }
 
     QDomDocument multiResponse;
     multiResponse.setContent(m_webDavDataBuf, true);
 
     bool hasResponse = false;
 
     qCDebug(KIO_HTTP) << endl << multiResponse.toString(2);
 
     for (QDomNode n = multiResponse.documentElement().firstChild();
             !n.isNull(); n = n.nextSibling()) {
         QDomElement thisResponse = n.toElement();
         if (thisResponse.isNull()) {
             continue;
         }
 
         hasResponse = true;
 
         QDomElement href = thisResponse.namedItem(QStringLiteral("href")).toElement();
         if (!href.isNull()) {
             entry.clear();
 
             const QUrl thisURL(href.text()); // href.text() is a percent-encoded url.
             if (thisURL.isValid()) {
                 const QUrl adjustedThisURL = thisURL.adjusted(QUrl::StripTrailingSlash);
                 const QUrl adjustedUrl = url.adjusted(QUrl::StripTrailingSlash);
 
                 // base dir of a listDir(): name should be "."
                 QString name;
                 if (!stat && adjustedThisURL.path() == adjustedUrl.path()) {
                     name = QLatin1Char('.');
                 } else {
                     name = adjustedThisURL.fileName();
                 }
 
                 entry.fastInsert(KIO::UDSEntry::UDS_NAME, name.isEmpty() ? href.text() : name);
             }
 
             QDomNodeList propstats = thisResponse.elementsByTagName(QStringLiteral("propstat"));
 
             davParsePropstats(propstats, entry);
 
             // Since a lot of webdav servers seem not to send the content-type information
             // for the requested directory listings, we attempt to guess the mime-type from
             // the resource name so long as the resource is not a directory.
             if (entry.stringValue(KIO::UDSEntry::UDS_MIME_TYPE).isEmpty() &&
                     entry.numberValue(KIO::UDSEntry::UDS_FILE_TYPE) != S_IFDIR) {
                 QMimeType mime = db.mimeTypeForFile(thisURL.path(), QMimeDatabase::MatchExtension);
                 if (mime.isValid() && !mime.isDefault()) {
                     qCDebug(KIO_HTTP) << "Setting" << mime.name() << "as guessed mime type for" << thisURL.path();
                     entry.fastInsert(KIO::UDSEntry::UDS_GUESSED_MIME_TYPE, mime.name());
                 }
             }
 
             if (stat) {
                 // return an item
                 statEntry(entry);
                 davFinished();
                 return;
             }
 
             listEntry(entry);
         } else   {
             qCDebug(KIO_HTTP) << "Error: no URL contained in response to PROPFIND on" << url;
         }
     }
 
     if (stat || !hasResponse) {
         error(ERR_DOES_NOT_EXIST, url.toDisplayString());
         return;
     }
 
     davFinished();
 }
 
 void HTTPProtocol::davGeneric(const QUrl &url, KIO::HTTP_METHOD method, qint64 size)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     // check to make sure this host supports WebDAV
     if (!davHostOk()) {
         return;
     }
 
     // WebDAV method
     m_request.method = method;
     m_request.url.setQuery(QString());
     m_request.cacheTag.policy = CC_Reload;
 
     m_iPostDataSize = (size > -1 ? static_cast<KIO::filesize_t>(size) : NO_SIZE);
     proceedUntilResponseContent();
 }
 
 int HTTPProtocol::codeFromResponse(const QString &response)
 {
     const int firstSpace = response.indexOf(QLatin1Char(' '));
     const int secondSpace = response.indexOf(QLatin1Char(' '), firstSpace + 1);
     return response.midRef(firstSpace + 1, secondSpace - firstSpace - 1).toInt();
 }
 
 void HTTPProtocol::davParsePropstats(const QDomNodeList &propstats, UDSEntry &entry)
 {
     QString mimeType;
     bool foundExecutable = false;
     bool isDirectory = false;
     uint lockCount = 0;
     uint supportedLockCount = 0;
     qlonglong quotaUsed = -1;
     qlonglong quotaAvailable = -1;
 
     for (int i = 0; i < propstats.count(); i++) {
         QDomElement propstat = propstats.item(i).toElement();
 
         QDomElement status = propstat.namedItem(QStringLiteral("status")).toElement();
         if (status.isNull()) {
             // error, no status code in this propstat
             qCDebug(KIO_HTTP) << "Error, no status code in this propstat";
             return;
         }
 
         int code = codeFromResponse(status.text());
 
         if (code != 200) {
             qCDebug(KIO_HTTP) << "Got status code" << code << "(this may mean that some properties are unavailable)";
             continue;
         }
 
         QDomElement prop = propstat.namedItem(QStringLiteral("prop")).toElement();
         if (prop.isNull()) {
             qCDebug(KIO_HTTP) << "Error: no prop segment in this propstat.";
             return;
         }
 
         if (hasMetaData(QStringLiteral("davRequestResponse"))) {
             QDomDocument doc;
             doc.appendChild(prop);
             entry.replace(KIO::UDSEntry::UDS_XML_PROPERTIES, doc.toString());
         }
 
         for (QDomNode n = prop.firstChild(); !n.isNull(); n = n.nextSibling()) {
             QDomElement property = n.toElement();
             if (property.isNull()) {
                 continue;
             }
 
             if (property.namespaceURI() != QLatin1String("DAV:")) {
                 // break out - we're only interested in properties from the DAV namespace
                 continue;
             }
 
             if (property.tagName() == QLatin1String("creationdate")) {
                 // Resource creation date. Should be is ISO 8601 format.
                 entry.replace(KIO::UDSEntry::UDS_CREATION_TIME,
                              parseDateTime(property.text(), property.attribute(QStringLiteral("dt"))).toTime_t());
             } else if (property.tagName() == QLatin1String("getcontentlength")) {
                 // Content length (file size)
                 entry.replace(KIO::UDSEntry::UDS_SIZE, property.text().toULong());
             } else if (property.tagName() == QLatin1String("displayname")) {
                 // Name suitable for presentation to the user
                 setMetaData(QStringLiteral("davDisplayName"), property.text());
             } else if (property.tagName() == QLatin1String("source")) {
                 // Source template location
                 QDomElement source = property.namedItem(QStringLiteral("link")).toElement()
                                      .namedItem(QStringLiteral("dst")).toElement();
                 if (!source.isNull()) {
                     setMetaData(QStringLiteral("davSource"), source.text());
                 }
             } else if (property.tagName() == QLatin1String("getcontentlanguage")) {
                 // equiv. to Content-Language header on a GET
                 setMetaData(QStringLiteral("davContentLanguage"), property.text());
             } else if (property.tagName() == QLatin1String("getcontenttype")) {
                 // Content type (mime type)
                 // This may require adjustments for other server-side webdav implementations
                 // (tested with Apache + mod_dav 1.0.3)
                 if (property.text() == QLatin1String("httpd/unix-directory")) {
                     isDirectory = true;
                 } else {
                     mimeType = property.text();
                 }
             } else if (property.tagName() == QLatin1String("executable")) {
                 // File executable status
                 if (property.text() == QLatin1String("T")) {
                     foundExecutable = true;
                 }
 
             } else if (property.tagName() == QLatin1String("getlastmodified")) {
                 // Last modification date
                 entry.replace(KIO::UDSEntry::UDS_MODIFICATION_TIME,
                              parseDateTime(property.text(), property.attribute(QStringLiteral("dt"))).toTime_t());
             } else if (property.tagName() == QLatin1String("getetag")) {
                 // Entity tag
                 setMetaData(QStringLiteral("davEntityTag"), property.text());
             } else if (property.tagName() == QLatin1String("supportedlock")) {
                 // Supported locking specifications
                 for (QDomNode n2 = property.firstChild(); !n2.isNull(); n2 = n2.nextSibling()) {
                     QDomElement lockEntry = n2.toElement();
                     if (lockEntry.tagName() == QLatin1String("lockentry")) {
                         QDomElement lockScope = lockEntry.namedItem(QStringLiteral("lockscope")).toElement();
                         QDomElement lockType = lockEntry.namedItem(QStringLiteral("locktype")).toElement();
                         if (!lockScope.isNull() && !lockType.isNull()) {
                             // Lock type was properly specified
                             supportedLockCount++;
                             const QString lockCountStr = QString::number(supportedLockCount);
                             const QString scope = lockScope.firstChild().toElement().tagName();
                             const QString type = lockType.firstChild().toElement().tagName();
 
                             setMetaData(QLatin1String("davSupportedLockScope") + lockCountStr, scope);
                             setMetaData(QLatin1String("davSupportedLockType") + lockCountStr, type);
                         }
                     }
                 }
             } else if (property.tagName() == QLatin1String("lockdiscovery")) {
                 // Lists the available locks
                 davParseActiveLocks(property.elementsByTagName(QStringLiteral("activelock")), lockCount);
             } else if (property.tagName() == QLatin1String("resourcetype")) {
                 // Resource type. "Specifies the nature of the resource."
                 if (!property.namedItem(QStringLiteral("collection")).toElement().isNull()) {
                     // This is a collection (directory)
                     isDirectory = true;
                 }
             } else if (property.tagName() == QLatin1String("quota-used-bytes")) {
                 // Quota-used-bytes. "Contains the amount of storage already in use."
                 quotaUsed = property.text().toLongLong();
             } else if (property.tagName() == QLatin1String("quota-available-bytes")) {
                 // Quota-available-bytes. "Indicates the maximum amount of additional storage available."
                 quotaAvailable = property.text().toLongLong();
             } else {
                 qCDebug(KIO_HTTP) << "Found unknown webdav property:" << property.tagName();
             }
         }
     }
 
     setMetaData(QStringLiteral("davLockCount"), QString::number(lockCount));
     setMetaData(QStringLiteral("davSupportedLockCount"), QString::number(supportedLockCount));
 
     entry.replace(KIO::UDSEntry::UDS_FILE_TYPE, isDirectory ? S_IFDIR : S_IFREG);
 
     if (foundExecutable || isDirectory) {
         // File was executable, or is a directory.
         entry.replace(KIO::UDSEntry::UDS_ACCESS, 0700);
     } else {
         entry.replace(KIO::UDSEntry::UDS_ACCESS, 0600);
     }
 
     if (!isDirectory && !mimeType.isEmpty()) {
         entry.replace(KIO::UDSEntry::UDS_MIME_TYPE, mimeType);
     }
 
     if (quotaUsed >= 0 && quotaAvailable >= 0) {
         // Only used and available storage properties exist, the total storage size has to be calculated.
         setMetaData(QStringLiteral("total"), QString::number(quotaUsed + quotaAvailable));
         setMetaData(QStringLiteral("available"), QString::number(quotaAvailable));
     }
 }
 
 void HTTPProtocol::davParseActiveLocks(const QDomNodeList &activeLocks,
                                        uint &lockCount)
 {
     for (int i = 0; i < activeLocks.count(); i++) {
         const QDomElement activeLock = activeLocks.item(i).toElement();
 
         lockCount++;
         // required
         const QDomElement lockScope = activeLock.namedItem(QStringLiteral("lockscope")).toElement();
         const QDomElement lockType = activeLock.namedItem(QStringLiteral("locktype")).toElement();
         const QDomElement lockDepth = activeLock.namedItem(QStringLiteral("depth")).toElement();
         // optional
         const QDomElement lockOwner = activeLock.namedItem(QStringLiteral("owner")).toElement();
         const QDomElement lockTimeout = activeLock.namedItem(QStringLiteral("timeout")).toElement();
         const QDomElement lockToken = activeLock.namedItem(QStringLiteral("locktoken")).toElement();
 
         if (!lockScope.isNull() && !lockType.isNull() && !lockDepth.isNull()) {
             // lock was properly specified
             lockCount++;
             const QString lockCountStr = QString::number(lockCount);
             const QString scope = lockScope.firstChild().toElement().tagName();
             const QString type = lockType.firstChild().toElement().tagName();
             const QString depth = lockDepth.text();
 
             setMetaData(QLatin1String("davLockScope") + lockCountStr, scope);
             setMetaData(QLatin1String("davLockType") + lockCountStr, type);
             setMetaData(QLatin1String("davLockDepth") + lockCountStr, depth);
 
             if (!lockOwner.isNull()) {
                 setMetaData(QLatin1String("davLockOwner") + lockCountStr, lockOwner.text());
             }
 
             if (!lockTimeout.isNull()) {
                 setMetaData(QLatin1String("davLockTimeout") + lockCountStr, lockTimeout.text());
             }
 
             if (!lockToken.isNull()) {
                 QDomElement tokenVal = lockScope.namedItem(QStringLiteral("href")).toElement();
                 if (!tokenVal.isNull()) {
                     setMetaData(QLatin1String("davLockToken") + lockCountStr, tokenVal.text());
                 }
             }
         }
     }
 }
 
 QDateTime HTTPProtocol::parseDateTime(const QString &input, const QString &type)
 {
     if (type == QLatin1String("dateTime.tz")) {
         return QDateTime::fromString(input, Qt::ISODate);
     } else if (type == QLatin1String("dateTime.rfc1123")) {
         return QDateTime::fromString(input, Qt::RFC2822Date);
     }
 
     // format not advertised... try to parse anyway
     QDateTime time = QDateTime::fromString(input, Qt::RFC2822Date);
     if (time.isValid()) {
         return time;
     }
 
     return QDateTime::fromString(input, Qt::ISODate);
 }
 
 QString HTTPProtocol::davProcessLocks()
 {
     if (hasMetaData(QStringLiteral("davLockCount"))) {
         QString response = QStringLiteral("If:");
         int numLocks = metaData(QStringLiteral("davLockCount")).toInt();
         bool bracketsOpen = false;
         for (int i = 0; i < numLocks; i++) {
             const QString countStr = QString::number(i);
             if (hasMetaData(QLatin1String("davLockToken") + countStr)) {
                 if (hasMetaData(QLatin1String("davLockURL") + countStr)) {
                     if (bracketsOpen) {
                         response += QLatin1Char(')');
                         bracketsOpen = false;
                     }
                     response += QLatin1String(" <") + metaData(QLatin1String("davLockURL") + countStr) + QLatin1Char('>');
                 }
 
                 if (!bracketsOpen) {
                     response += QLatin1String(" (");
                     bracketsOpen = true;
                 } else {
                     response += QLatin1Char(' ');
                 }
 
                 if (hasMetaData(QLatin1String("davLockNot") + countStr)) {
                     response += QLatin1String("Not ");
                 }
 
                 response += QLatin1Char('<') + metaData(QLatin1String("davLockToken") + countStr) + QLatin1Char('>');
             }
         }
 
         if (bracketsOpen) {
             response += QLatin1Char(')');
         }
 
         response += QLatin1String("\r\n");
         return response;
     }
 
     return QString();
 }
 
 bool HTTPProtocol::davHostOk()
 {
     // FIXME needs to be reworked. Switched off for now.
     return true;
 
     // cached?
     if (m_davHostOk) {
         qCDebug(KIO_HTTP) << "true";
         return true;
     } else if (m_davHostUnsupported) {
         qCDebug(KIO_HTTP) << " false";
         davError(-2);
         return false;
     }
 
     m_request.method = HTTP_OPTIONS;
 
     // query the server's capabilities generally, not for a specific URL
     m_request.url.setPath(QStringLiteral("*"));
     m_request.url.setQuery(QString());
     m_request.cacheTag.policy = CC_Reload;
 
     // clear davVersions variable, which holds the response to the DAV: header
     m_davCapabilities.clear();
 
     proceedUntilResponseHeader();
 
-    if (m_davCapabilities.count()) {
+    if (!m_davCapabilities.isEmpty()) {
         for (int i = 0; i < m_davCapabilities.count(); i++) {
             bool ok;
             uint verNo = m_davCapabilities[i].toUInt(&ok);
             if (ok && verNo > 0 && verNo < 3) {
                 m_davHostOk = true;
                 qCDebug(KIO_HTTP) << "Server supports DAV version" << verNo;
             }
         }
 
         if (m_davHostOk) {
             return true;
         }
     }
 
     m_davHostUnsupported = true;
     davError(-2);
     return false;
 }
 
 // This function is for closing proceedUntilResponseHeader(); requests
 // Required because there may or may not be further info expected
 void HTTPProtocol::davFinished()
 {
     // TODO: Check with the DAV extension developers
     httpClose(m_request.isKeepAlive);
     finished();
 }
 
 void HTTPProtocol::mkdir(const QUrl &url, int)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     m_request.method = DAV_MKCOL;
     m_request.url.setQuery(QString());
     m_request.cacheTag.policy = CC_Reload;
 
     proceedUntilResponseContent(true);
 
     if (m_request.responseCode == 201) {
         davFinished();
     } else {
         davError();
     }
 }
 
 void HTTPProtocol::get(const QUrl &url)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     m_request.method = HTTP_GET;
 
     QString tmp(metaData(QStringLiteral("cache")));
     if (!tmp.isEmpty()) {
         m_request.cacheTag.policy = parseCacheControl(tmp);
     } else {
         m_request.cacheTag.policy = DEFAULT_CACHE_CONTROL;
     }
 
     proceedUntilResponseContent();
 }
 
 void HTTPProtocol::put(const QUrl &url, int, KIO::JobFlags flags)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
 
     resetSessionSettings();
 
     // Webdav hosts are capable of observing overwrite == false
     if (m_protocol.startsWith("webdav")) { // krazy:exclude=strings
         if (!(flags & KIO::Overwrite)) {
             // check to make sure this host supports WebDAV
             if (!davHostOk()) {
                 return;
             }
 
             // Checks if the destination exists and return an error if it does.
             if (!davStatDestination()) {
                 error(ERR_FILE_ALREADY_EXIST, QString());
                 return;
             }
 
             // force re-authentication...
             delete m_wwwAuth;
             m_wwwAuth = nullptr;
         }
     }
 
     m_request.method = HTTP_PUT;
     m_request.cacheTag.policy = CC_Reload;
 
     proceedUntilResponseContent();
 }
 
 void HTTPProtocol::copy(const QUrl &src, const QUrl &dest, int, KIO::JobFlags flags)
 {
     qCDebug(KIO_HTTP) << src << "->" << dest;
     const bool isSourceLocal = src.isLocalFile();
     const bool isDestinationLocal = dest.isLocalFile();
 
     if (isSourceLocal && !isDestinationLocal) {
         copyPut(src, dest, flags);
     } else {
         if (!maybeSetRequestUrl(dest) || !maybeSetRequestUrl(src)) {
             return;
         }
 
         resetSessionSettings();
 
         // destination has to be "http(s)://..."
         QUrl newDest (dest);
         changeProtocolToHttp(&newDest);
 
         m_request.method = DAV_COPY;
         m_request.davData.desturl = newDest.toString(QUrl::FullyEncoded);
         m_request.davData.overwrite = (flags & KIO::Overwrite);
         m_request.url.setQuery(QString());
         m_request.cacheTag.policy = CC_Reload;
 
         proceedUntilResponseHeader();
 
         // The server returns a HTTP/1.1 201 Created or 204 No Content on successful completion
         if (m_request.responseCode == 201 || m_request.responseCode == 204) {
             davFinished();
         } else {
             davError();
         }
     }
 }
 
 void HTTPProtocol::rename(const QUrl &src, const QUrl &dest, KIO::JobFlags flags)
 {
     qCDebug(KIO_HTTP) << src << "->" << dest;
 
     if (!maybeSetRequestUrl(dest) || !maybeSetRequestUrl(src)) {
         return;
     }
     resetSessionSettings();
 
     // destination has to be "http://..."
     QUrl newDest(dest);
     changeProtocolToHttp(&newDest);
 
     m_request.method = DAV_MOVE;
     m_request.davData.desturl = newDest.toString(QUrl::FullyEncoded);
     m_request.davData.overwrite = (flags & KIO::Overwrite);
     m_request.url.setQuery(QString());
     m_request.cacheTag.policy = CC_Reload;
 
     proceedUntilResponseHeader();
 
     // Work around strict Apache-2 WebDAV implementation which refuses to cooperate
     // with webdav://host/directory, instead requiring webdav://host/directory/
     // (strangely enough it accepts Destination: without a trailing slash)
     // See BR# 209508 and BR#187970
     if (m_request.responseCode == 301) {
         m_request.url = m_request.redirectUrl;
         m_request.method = DAV_MOVE;
         m_request.davData.desturl = newDest.toString();
         m_request.davData.overwrite = (flags & KIO::Overwrite);
         m_request.url.setQuery(QString());
         m_request.cacheTag.policy = CC_Reload;
         // force re-authentication...
         delete m_wwwAuth;
         m_wwwAuth = nullptr;
         proceedUntilResponseHeader();
     }
 
     if (m_request.responseCode == 201) {
         davFinished();
     } else {
         davError();
     }
 }
 
 void HTTPProtocol::del(const QUrl &url, bool)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
 
     resetSessionSettings();
 
     m_request.method = HTTP_DELETE;
     m_request.cacheTag.policy = CC_Reload;
 
     if (m_protocol.startsWith("webdav")) { //krazy:exclude=strings due to QByteArray
         m_request.url.setQuery(QString());
         if (!proceedUntilResponseHeader()) {
             return;
         }
 
         // The server returns a HTTP/1.1 200 Ok or HTTP/1.1 204 No Content
         // on successful completion.
         if (m_request.responseCode == 200 || m_request.responseCode == 204 || m_isRedirection) {
             davFinished();
         } else {
             davError();
         }
 
         return;
     }
 
     proceedUntilResponseContent();
 }
 
 void HTTPProtocol::post(const QUrl &url, qint64 size)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     m_request.method = HTTP_POST;
     m_request.cacheTag.policy = CC_Reload;
 
     m_iPostDataSize = (size > -1 ? static_cast<KIO::filesize_t>(size) : NO_SIZE);
     proceedUntilResponseContent();
 }
 
 void HTTPProtocol::davLock(const QUrl &url, const QString &scope,
                            const QString &type, const QString &owner)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     m_request.method = DAV_LOCK;
     m_request.url.setQuery(QString());
     m_request.cacheTag.policy = CC_Reload;
 
     /* Create appropriate lock XML request. */
     QDomDocument lockReq;
 
     QDomElement lockInfo = lockReq.createElementNS(QStringLiteral("DAV:"), QStringLiteral("lockinfo"));
     lockReq.appendChild(lockInfo);
 
     QDomElement lockScope = lockReq.createElement(QStringLiteral("lockscope"));
     lockInfo.appendChild(lockScope);
 
     lockScope.appendChild(lockReq.createElement(scope));
 
     QDomElement lockType = lockReq.createElement(QStringLiteral("locktype"));
     lockInfo.appendChild(lockType);
 
     lockType.appendChild(lockReq.createElement(type));
 
     if (!owner.isNull()) {
         QDomElement ownerElement = lockReq.createElement(QStringLiteral("owner"));
         lockReq.appendChild(ownerElement);
 
         QDomElement ownerHref = lockReq.createElement(QStringLiteral("href"));
         ownerElement.appendChild(ownerHref);
 
         ownerHref.appendChild(lockReq.createTextNode(owner));
     }
 
     // insert the document into the POST buffer
     cachePostData(lockReq.toByteArray());
 
     proceedUntilResponseContent(true);
 
     if (m_request.responseCode == 200) {
         // success
         QDomDocument multiResponse;
         multiResponse.setContent(m_webDavDataBuf, true);
 
         QDomElement prop = multiResponse.documentElement().namedItem(QStringLiteral("prop")).toElement();
 
         QDomElement lockdiscovery = prop.namedItem(QStringLiteral("lockdiscovery")).toElement();
 
         uint lockCount = 0;
         davParseActiveLocks(lockdiscovery.elementsByTagName(QStringLiteral("activelock")), lockCount);
 
         setMetaData(QStringLiteral("davLockCount"), QString::number(lockCount));
 
         finished();
 
     } else {
         davError();
     }
 }
 
 void HTTPProtocol::davUnlock(const QUrl &url)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     m_request.method = DAV_UNLOCK;
     m_request.url.setQuery(QString());
     m_request.cacheTag.policy = CC_Reload;
 
     proceedUntilResponseContent(true);
 
     if (m_request.responseCode == 200) {
         finished();
     } else {
         davError();
     }
 }
 
 QString HTTPProtocol::davError(int code /* = -1 */, const QString &_url)
 {
     bool callError = false;
     if (code == -1) {
         code = m_request.responseCode;
         callError = true;
     }
     if (code == -2) {
         callError = true;
     }
 
     QString url = _url;
     if (!url.isNull()) {
         url = m_request.url.toDisplayString();
     }
 
     QString action, errorString;
     int errorCode = ERR_SLAVE_DEFINED;
 
     // for 412 Precondition Failed
     QString ow = i18n("Otherwise, the request would have succeeded.");
 
     switch (m_request.method) {
     case DAV_PROPFIND:
         action = i18nc("request type", "retrieve property values");
         break;
     case DAV_PROPPATCH:
         action = i18nc("request type", "set property values");
         break;
     case DAV_MKCOL:
         action = i18nc("request type", "create the requested folder");
         break;
     case DAV_COPY:
         action = i18nc("request type", "copy the specified file or folder");
         break;
     case DAV_MOVE:
         action = i18nc("request type", "move the specified file or folder");
         break;
     case DAV_SEARCH:
         action = i18nc("request type", "search in the specified folder");
         break;
     case DAV_LOCK:
         action = i18nc("request type", "lock the specified file or folder");
         break;
     case DAV_UNLOCK:
         action = i18nc("request type", "unlock the specified file or folder");
         break;
     case HTTP_DELETE:
         action = i18nc("request type", "delete the specified file or folder");
         break;
     case HTTP_OPTIONS:
         action = i18nc("request type", "query the server's capabilities");
         break;
     case HTTP_GET:
         action = i18nc("request type", "retrieve the contents of the specified file or folder");
         break;
     case DAV_REPORT:
         action = i18nc("request type", "run a report in the specified folder");
         break;
     case HTTP_PUT:
     case HTTP_POST:
     case HTTP_HEAD:
     default:
         // this should not happen, this function is for webdav errors only
         Q_ASSERT(0);
     }
 
     // default error message if the following code fails
     errorString = i18nc("%1: code, %2: request type", "An unexpected error (%1) occurred "
                         "while attempting to %2.", code, action);
 
     switch (code) {
     case -2:
         // internal error: OPTIONS request did not specify DAV compliance
         // ERR_UNSUPPORTED_PROTOCOL
         errorString = i18n("The server does not support the WebDAV protocol.");
         break;
     case 207:
         // 207 Multi-status
     {
         // our error info is in the returned XML document.
         // retrieve the XML document
 
         // there was an error retrieving the XML document.
         if (!readBody(true) && m_kioError) {
             return QString();
         }
 
         QStringList errors;
         QDomDocument multiResponse;
 
         multiResponse.setContent(m_webDavDataBuf, true);
 
         QDomElement multistatus = multiResponse.documentElement().namedItem(QStringLiteral("multistatus")).toElement();
 
         QDomNodeList responses = multistatus.elementsByTagName(QStringLiteral("response"));
 
         for (int i = 0; i < responses.count(); i++) {
             int errCode;
             QString errUrl;
 
             QDomElement response = responses.item(i).toElement();
             QDomElement code = response.namedItem(QStringLiteral("status")).toElement();
 
             if (!code.isNull()) {
                 errCode = codeFromResponse(code.text());
                 QDomElement href = response.namedItem(QStringLiteral("href")).toElement();
                 if (!href.isNull()) {
                     errUrl = href.text();
                 }
                 errors << davError(errCode, errUrl);
             }
         }
 
         //kError = ERR_SLAVE_DEFINED;
         errorString = i18nc("%1: request type, %2: url",
                             "An error occurred while attempting to %1, %2. A "
                             "summary of the reasons is below.", action, url);
 
         errorString += QLatin1String("<ul>");
 
         Q_FOREACH (const QString &error, errors) {
             errorString += QLatin1String("<li>") + error + QLatin1String("</li>");
         }
 
         errorString += QLatin1String("</ul>");
     }
         break;
     case 403:
     case 500: // hack: Apache mod_dav returns this instead of 403 (!)
         // 403 Forbidden
         // ERR_ACCESS_DENIED
         errorString = i18nc("%1: request type", "Access was denied while attempting to %1.",  action);
         break;
     case 405:
         // 405 Method Not Allowed
         if (m_request.method == DAV_MKCOL) {
             // ERR_DIR_ALREADY_EXIST
             errorString = url;
             errorCode = ERR_DIR_ALREADY_EXIST;
         }
         break;
     case 409:
         // 409 Conflict
         // ERR_ACCESS_DENIED
         errorString = i18n("A resource cannot be created at the destination "
                            "until one or more intermediate collections (folders) "
                            "have been created.");
         break;
     case 412:
         // 412 Precondition failed
         if (m_request.method == DAV_COPY || m_request.method == DAV_MOVE) {
             // ERR_ACCESS_DENIED
             errorString = i18n("The server was unable to maintain the liveness of "
                                "the properties listed in the propertybehavior XML "
                                "element\n or you attempted to overwrite a file while "
                                "requesting that files are not overwritten.\n %1",
                                ow);
 
         } else if (m_request.method == DAV_LOCK) {
             // ERR_ACCESS_DENIED
             errorString = i18n("The requested lock could not be granted. %1",  ow);
         }
         break;
     case 415:
         // 415 Unsupported Media Type
         // ERR_ACCESS_DENIED
         errorString = i18n("The server does not support the request type of the body.");
         break;
     case 423:
         // 423 Locked
         // ERR_ACCESS_DENIED
         errorString = i18nc("%1: request type", "Unable to %1 because the resource is locked.",  action);
         break;
     case 425:
         // 424 Failed Dependency
         errorString = i18n("This action was prevented by another error.");
         break;
     case 502:
         // 502 Bad Gateway
         if (m_request.method == DAV_COPY || m_request.method == DAV_MOVE) {
             // ERR_WRITE_ACCESS_DENIED
             errorString = i18nc("%1: request type", "Unable to %1 because the destination server refuses "
                                 "to accept the file or folder.",  action);
         }
         break;
     case 507:
         // 507 Insufficient Storage
         // ERR_DISK_FULL
         errorString = i18n("The destination resource does not have sufficient space "
                            "to record the state of the resource after the execution "
                            "of this method.");
         break;
     default:
         break;
     }
 
     // if ( kError != ERR_SLAVE_DEFINED )
     //errorString += " (" + url + ')';
 
     if (callError) {
         error(errorCode, errorString);
     }
 
     return errorString;
 }
 
 // HTTP generic error
 static int httpGenericError(const HTTPProtocol::HTTPRequest &request, QString *errorString)
 {
     Q_ASSERT(errorString);
 
     int errorCode = 0;
     errorString->clear();
 
     if (request.responseCode == 204) {
         errorCode = ERR_NO_CONTENT;
     }
 
     return errorCode;
 }
 
 // HTTP DELETE specific errors
 static int httpDelError(const HTTPProtocol::HTTPRequest &request, QString *errorString)
 {
     Q_ASSERT(errorString);
 
     int errorCode = 0;
     const int responseCode = request.responseCode;
     errorString->clear();
 
     switch (responseCode) {
     case 204:
         errorCode = ERR_NO_CONTENT;
         break;
     default:
         break;
     }
 
     if (!errorCode
             && (responseCode < 200 || responseCode > 400)
             && responseCode != 404) {
         errorCode = ERR_SLAVE_DEFINED;
         *errorString = i18n("The resource cannot be deleted.");
     }
 
     return errorCode;
 }
 
 // HTTP PUT specific errors
 static int httpPutError(const HTTPProtocol::HTTPRequest &request, QString *errorString)
 {
     Q_ASSERT(errorString);
 
     int errorCode = 0;
     const int responseCode = request.responseCode;
     const QString action(i18nc("request type", "upload %1", request.url.toDisplayString()));
 
     switch (responseCode) {
     case 403:
     case 405:
     case 500: // hack: Apache mod_dav returns this instead of 403 (!)
         // 403 Forbidden
         // 405 Method Not Allowed
         // ERR_ACCESS_DENIED
         *errorString = i18nc("%1: request type", "Access was denied while attempting to %1.",  action);
         errorCode = ERR_SLAVE_DEFINED;
         break;
     case 409:
         // 409 Conflict
         // ERR_ACCESS_DENIED
         *errorString = i18n("A resource cannot be created at the destination "
                             "until one or more intermediate collections (folders) "
                             "have been created.");
         errorCode = ERR_SLAVE_DEFINED;
         break;
     case 423:
         // 423 Locked
         // ERR_ACCESS_DENIED
         *errorString = i18nc("%1: request type", "Unable to %1 because the resource is locked.",  action);
         errorCode = ERR_SLAVE_DEFINED;
         break;
     case 502:
         // 502 Bad Gateway
         // ERR_WRITE_ACCESS_DENIED;
         *errorString = i18nc("%1: request type", "Unable to %1 because the destination server refuses "
                              "to accept the file or folder.",  action);
         errorCode = ERR_SLAVE_DEFINED;
         break;
     case 507:
         // 507 Insufficient Storage
         // ERR_DISK_FULL
         *errorString = i18n("The destination resource does not have sufficient space "
                             "to record the state of the resource after the execution "
                             "of this method.");
         errorCode = ERR_SLAVE_DEFINED;
         break;
     default:
         break;
     }
 
     if (!errorCode
             && (responseCode < 200 || responseCode > 400)
             && responseCode != 404) {
         errorCode = ERR_SLAVE_DEFINED;
         *errorString = i18nc("%1: response code, %2: request type",
                              "An unexpected error (%1) occurred while attempting to %2.",
                              responseCode, action);
     }
 
     return errorCode;
 }
 
 bool HTTPProtocol::sendHttpError()
 {
     QString errorString;
     int errorCode = 0;
 
     switch (m_request.method) {
     case HTTP_GET:
     case HTTP_POST:
         errorCode = httpGenericError(m_request, &errorString);
         break;
     case HTTP_PUT:
         errorCode = httpPutError(m_request, &errorString);
         break;
     case HTTP_DELETE:
         errorCode = httpDelError(m_request, &errorString);
         break;
     default:
         break;
     }
 
     // Force any message previously shown by the client to be cleared.
     infoMessage(QLatin1String(""));
 
     if (errorCode) {
         error(errorCode, errorString);
         return true;
     }
 
     return false;
 }
 
 bool HTTPProtocol::sendErrorPageNotification()
 {
     if (!m_request.preferErrorPage) {
         return false;
     }
 
     if (m_isLoadingErrorPage) {
         qCWarning(KIO_HTTP) << "called twice during one request, something is probably wrong.";
     }
 
     m_isLoadingErrorPage = true;
     SlaveBase::errorPage();
     return true;
 }
 
 bool HTTPProtocol::isOffline()
 {
     if (!m_networkConfig) {
         m_networkConfig = new QNetworkConfigurationManager(this);
     }
 
     return !m_networkConfig->isOnline();
 }
 
 void HTTPProtocol::multiGet(const QByteArray &data)
 {
     QDataStream stream(data);
     quint32 n;
     stream >> n;
 
     qCDebug(KIO_HTTP) << n;
 
     HTTPRequest saveRequest;
     if (m_isBusy) {
         saveRequest = m_request;
     }
 
     resetSessionSettings();
 
     for (unsigned i = 0; i < n; ++i) {
         QUrl url;
         stream >> url >> mIncomingMetaData;
 
         if (!maybeSetRequestUrl(url)) {
             continue;
         }
 
         //### should maybe call resetSessionSettings() if the server/domain is
         //    different from the last request!
 
         qCDebug(KIO_HTTP) << url;
 
         m_request.method = HTTP_GET;
         m_request.isKeepAlive = true;   //readResponseHeader clears it if necessary
 
         QString tmp = metaData(QStringLiteral("cache"));
         if (!tmp.isEmpty()) {
             m_request.cacheTag.policy = parseCacheControl(tmp);
         } else {
             m_request.cacheTag.policy = DEFAULT_CACHE_CONTROL;
         }
 
         m_requestQueue.append(m_request);
     }
 
     if (m_isBusy) {
         m_request = saveRequest;
     }
 #if 0
     if (!m_isBusy) {
         m_isBusy = true;
         QMutableListIterator<HTTPRequest> it(m_requestQueue);
         while (it.hasNext()) {
             m_request = it.next();
             it.remove();
             proceedUntilResponseContent();
         }
         m_isBusy = false;
     }
 #endif
     if (!m_isBusy) {
         m_isBusy = true;
         QMutableListIterator<HTTPRequest> it(m_requestQueue);
         // send the requests
         while (it.hasNext()) {
             m_request = it.next();
             sendQuery();
             // save the request state so we can pick it up again in the collection phase
             it.setValue(m_request);
             qCDebug(KIO_HTTP) << "check one: isKeepAlive =" << m_request.isKeepAlive;
             if (m_request.cacheTag.ioMode != ReadFromCache) {
                 m_server.initFrom(m_request);
             }
         }
         // collect the responses
         //### for the moment we use a hack: instead of saving and restoring request-id
         //    we just count up like ParallelGetJobs does.
         int requestId = 0;
         Q_FOREACH (const HTTPRequest &r, m_requestQueue) {
             m_request = r;
             qCDebug(KIO_HTTP) << "check two: isKeepAlive =" << m_request.isKeepAlive;
             setMetaData(QStringLiteral("request-id"), QString::number(requestId++));
             sendAndKeepMetaData();
             if (!(readResponseHeader() && readBody())) {
                 return;
             }
             // the "next job" signal for ParallelGetJob is data of size zero which
             // readBody() sends without our intervention.
             qCDebug(KIO_HTTP) << "check three: isKeepAlive =" << m_request.isKeepAlive;
             httpClose(m_request.isKeepAlive);  //actually keep-alive is mandatory for pipelining
         }
 
         finished();
         m_requestQueue.clear();
         m_isBusy = false;
     }
 }
 
 ssize_t HTTPProtocol::write(const void *_buf, size_t nbytes)
 {
     size_t sent = 0;
     const char *buf = static_cast<const char *>(_buf);
     while (sent < nbytes) {
         int n = TCPSlaveBase::write(buf + sent, nbytes - sent);
 
         if (n < 0) {
             // some error occurred
             return -1;
         }
 
         sent += n;
     }
 
     return sent;
 }
 
 void HTTPProtocol::clearUnreadBuffer()
 {
     m_unreadBuf.clear();
 }
 
 // Note: the implementation of unread/readBuffered assumes that unread will only
 // be used when there is extra data we don't want to handle, and not to wait for more data.
 void HTTPProtocol::unread(char *buf, size_t size)
 {
     // implement LIFO (stack) semantics
     const int newSize = m_unreadBuf.size() + size;
     m_unreadBuf.resize(newSize);
     for (size_t i = 0; i < size; i++) {
         m_unreadBuf.data()[newSize - i - 1] = buf[i];
     }
     if (size) {
         //hey, we still have data, closed connection or not!
         m_isEOF = false;
     }
 }
 
 size_t HTTPProtocol::readBuffered(char *buf, size_t size, bool unlimited)
 {
     size_t bytesRead = 0;
     if (!m_unreadBuf.isEmpty()) {
         const int bufSize = m_unreadBuf.size();
         bytesRead = qMin((int)size, bufSize);
 
         for (size_t i = 0; i < bytesRead; i++) {
             buf[i] = m_unreadBuf.constData()[bufSize - i - 1];
         }
         m_unreadBuf.chop(bytesRead);
 
         // If we have an unread buffer and the size of the content returned by the
         // server is unknown, e.g. chuncked transfer, return the bytes read here since
         // we may already have enough data to complete the response and don't want to
         // wait for more. See BR# 180631.
         if (unlimited) {
             return bytesRead;
         }
     }
     if (bytesRead < size) {
         int rawRead = TCPSlaveBase::read(buf + bytesRead, size - bytesRead);
         if (rawRead < 1) {
             m_isEOF = true;
             return bytesRead;
         }
         bytesRead += rawRead;
     }
     return bytesRead;
 }
 
 //### this method will detect an n*(\r\n) sequence if it crosses invocations.
 //    it will look (n*2 - 1) bytes before start at most and never before buf, naturally.
 //    supported number of newlines are one and two, in line with HTTP syntax.
 // return true if numNewlines newlines were found.
 bool HTTPProtocol::readDelimitedText(char *buf, int *idx, int end, int numNewlines)
 {
     Q_ASSERT(numNewlines >= 1 && numNewlines <= 2);
     char mybuf[64]; //somewhere close to the usual line length to avoid unread()ing too much
     int pos = *idx;
     while (pos < end && !m_isEOF) {
         int step = qMin((int)sizeof(mybuf), end - pos);
         if (m_isChunked) {
             //we might be reading the end of the very last chunk after which there is no data.
             //don't try to read any more bytes than there are because it causes stalls
             //(yes, it shouldn't stall but it does)
             step = 1;
         }
         size_t bufferFill = readBuffered(mybuf, step);
 
         for (size_t i = 0; i < bufferFill; ++i, ++pos) {
             // we copy the data from mybuf to buf immediately and look for the newlines in buf.
             // that way we don't miss newlines split over several invocations of this method.
             buf[pos] = mybuf[i];
 
             // did we just copy one or two times the (usually) \r\n delimiter?
             // until we find even more broken webservers in the wild let's assume that they either
             // send \r\n (RFC compliant) or \n (broken) as delimiter...
             if (buf[pos] == '\n') {
                 bool found = numNewlines == 1;
                 if (!found) {   // looking for two newlines
                     // Detect \n\n and \n\r\n. The other cases (\r\n\n, \r\n\r\n) are covered by the first two.
                     found = ((pos >= 1 && buf[pos - 1] == '\n') ||
                              (pos >= 2 && buf[pos - 2] == '\n' && buf[pos - 1] == '\r'));
                 }
                 if (found) {
                     i++;    // unread bytes *after* CRLF
                     unread(&mybuf[i], bufferFill - i);
                     *idx = pos + 1;
                     return true;
                 }
             }
         }
     }
     *idx = pos;
     return false;
 }
 
 static bool isCompatibleNextUrl(const QUrl &previous, const QUrl &now)
 {
     if (previous.host() != now.host() || previous.port() != now.port()) {
         return false;
     }
     if (previous.userName().isEmpty() && previous.password().isEmpty()) {
         return true;
     }
     return previous.userName() == now.userName() && previous.password() == now.password();
 }
 
 bool HTTPProtocol::httpShouldCloseConnection()
 {
     qCDebug(KIO_HTTP);
 
     if (!isConnected()) {
         return false;
     }
 
     if (!m_request.proxyUrls.isEmpty() && !isAutoSsl()) {
         Q_FOREACH (const QString &url, m_request.proxyUrls) {
             if (url != QLatin1String("DIRECT")) {
                 if (isCompatibleNextUrl(m_server.proxyUrl, QUrl(url))) {
                     return false;
                 }
             }
         }
         return true;
     }
 
     return !isCompatibleNextUrl(m_server.url, m_request.url);
 }
 
 bool HTTPProtocol::httpOpenConnection()
 {
     qCDebug(KIO_HTTP);
     m_server.clear();
 
     // Only save proxy auth information after proxy authentication has
     // actually taken place, which will set up exactly this connection.
     disconnect(socket(), SIGNAL(connected()),
                this, SLOT(saveProxyAuthenticationForSocket()));
 
     clearUnreadBuffer();
 
     int connectError = 0;
     QString errorString;
 
     // Get proxy information...
     if (m_request.proxyUrls.isEmpty()) {
         m_request.proxyUrls = config()->readEntry("ProxyUrls", QStringList());
         qCDebug(KIO_HTTP) << "Proxy URLs:" << m_request.proxyUrls;
     }
 
     if (m_request.proxyUrls.isEmpty()) {
         QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);
         connectError = connectToHost(m_request.url.host(), m_request.url.port(defaultPort()), &errorString);
     } else {
         QList<QUrl> badProxyUrls;
         Q_FOREACH (const QString &proxyUrl, m_request.proxyUrls) {
             if (proxyUrl == QLatin1String("DIRECT")) {
                 QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);
                 connectError = connectToHost(m_request.url.host(), m_request.url.port(defaultPort()), &errorString);
                 if (connectError == 0) {
                     //qDebug() << "Connected DIRECT: host=" << m_request.url.host() << "port=" << m_request.url.port(defaultPort());
                     break;
                 } else {
                     continue;
                 }
             }
 
             const QUrl url(proxyUrl);
             const QString proxyScheme(url.scheme());
             if (!supportedProxyScheme(proxyScheme)) {
                 connectError = ERR_CANNOT_CONNECT;
                 errorString = url.toDisplayString();
                 badProxyUrls << url;
                 continue;
             }
 
             QNetworkProxy::ProxyType proxyType = QNetworkProxy::NoProxy;
             if (proxyScheme == QLatin1String("socks")) {
                 proxyType = QNetworkProxy::Socks5Proxy;
             } else if (isAutoSsl()) {
                 proxyType = QNetworkProxy::HttpProxy;
             }
 
             qCDebug(KIO_HTTP) << "Connecting to proxy: address=" << proxyUrl << "type=" << proxyType;
 
             if (proxyType == QNetworkProxy::NoProxy) {
                 QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);
                 connectError = connectToHost(url.host(), url.port(), &errorString);
                 if (connectError == 0) {
                     m_request.proxyUrl = url;
                     //qDebug() << "Connected to proxy: host=" << url.host() << "port=" << url.port();
                     break;
                 } else {
                     if (connectError == ERR_UNKNOWN_HOST) {
                         connectError = ERR_UNKNOWN_PROXY_HOST;
                     }
                     //qDebug() << "Failed to connect to proxy:" << proxyUrl;
                     badProxyUrls << url;
                 }
             } else {
                 QNetworkProxy proxy(proxyType, url.host(), url.port(), url.userName(), url.password());
                 QNetworkProxy::setApplicationProxy(proxy);
                 connectError = connectToHost(m_request.url.host(), m_request.url.port(defaultPort()), &errorString);
                 if (connectError == 0) {
                     qCDebug(KIO_HTTP) << "Tunneling thru proxy: host=" << url.host() << "port=" << url.port();
                     break;
                 } else {
                     if (connectError == ERR_UNKNOWN_HOST) {
                         connectError = ERR_UNKNOWN_PROXY_HOST;
                     }
                     qCDebug(KIO_HTTP) << "Failed to connect to proxy:" << proxyUrl;
                     badProxyUrls << url;
                     QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);
                 }
             }
         }
 
         if (!badProxyUrls.isEmpty()) {
             //TODO: Notify the client of BAD proxy addresses (needed for PAC setups).
         }
     }
 
     if (connectError != 0) {
         error(connectError, errorString);
         return false;
     }
 
     // Disable Nagle's algorithm, i.e turn on TCP_NODELAY.
     KTcpSocket *sock = qobject_cast<KTcpSocket *>(socket());
     if (sock) {
         qCDebug(KIO_HTTP) << "TCP_NODELAY:" << sock->socketOption(QAbstractSocket::LowDelayOption);
         sock->setSocketOption(QAbstractSocket::LowDelayOption, 1);
     }
 
     m_server.initFrom(m_request);
     connected();
     return true;
 }
 
 bool HTTPProtocol::satisfyRequestFromCache(bool *cacheHasPage)
 {
     qCDebug(KIO_HTTP);
 
     if (m_request.cacheTag.useCache) {
         const bool offline = isOffline();
 
         if (offline && m_request.cacheTag.policy != KIO::CC_Reload) {
             m_request.cacheTag.policy = KIO::CC_CacheOnly;
         }
 
         const bool isCacheOnly = m_request.cacheTag.policy == KIO::CC_CacheOnly;
         const CacheTag::CachePlan plan = m_request.cacheTag.plan(m_maxCacheAge);
 
         bool openForReading = false;
         if (plan == CacheTag::UseCached || plan == CacheTag::ValidateCached) {
             openForReading = cacheFileOpenRead();
 
             if (!openForReading && (isCacheOnly || offline)) {
                 // cache-only or offline -> we give a definite answer and it is "no"
                 *cacheHasPage = false;
                 if (isCacheOnly) {
                     error(ERR_DOES_NOT_EXIST, m_request.url.toDisplayString());
                 } else if (offline) {
                     error(ERR_CANNOT_CONNECT, m_request.url.toDisplayString());
                 }
                 return true;
             }
         }
 
         if (openForReading) {
             m_request.cacheTag.ioMode = ReadFromCache;
             *cacheHasPage = true;
             // return false if validation is required, so a network request will be sent
             return m_request.cacheTag.plan(m_maxCacheAge) == CacheTag::UseCached;
         }
     }
     *cacheHasPage = false;
     return false;
 }
 
 QString HTTPProtocol::formatRequestUri() const
 {
     // Only specify protocol, host and port when they are not already clear, i.e. when
     // we handle HTTP proxying ourself and the proxy server needs to know them.
     // Sending protocol/host/port in other cases confuses some servers, and it's not their fault.
     if (isHttpProxy(m_request.proxyUrl) && !isAutoSsl()) {
         QUrl u;
 
         QString protocol = m_request.url.scheme();
         if (protocol.startsWith(QLatin1String("webdav"))) {
             protocol.replace(0, qstrlen("webdav"), QStringLiteral("http"));
         }
         u.setScheme(protocol);
 
         u.setHost(m_request.url.host());
         // if the URL contained the default port it should have been stripped earlier
         Q_ASSERT(m_request.url.port() != defaultPort());
         u.setPort(m_request.url.port());
         u.setPath(m_request.url.path(QUrl::FullyEncoded));
         u.setQuery(m_request.url.query(QUrl::FullyEncoded));
         return u.toString(QUrl::FullyEncoded);
     } else {
         QString result = m_request.url.path(QUrl::FullyEncoded);
         if (m_request.url.hasQuery()) {
             result += QLatin1Char('?') + m_request.url.query(QUrl::FullyEncoded);
         }
         return result;
     }
 }
 
 /**
  * This function is responsible for opening up the connection to the remote
  * HTTP server and sending the header.  If this requires special
  * authentication or other such fun stuff, then it will handle it.  This
  * function will NOT receive anything from the server, however.  This is in
  * contrast to previous incarnations of 'httpOpen' as this method used to be
  * called.
  *
  * The basic process now is this:
  *
  * 1) Open up the socket and port
  * 2) Format our request/header
  * 3) Send the header to the remote server
  * 4) Call sendBody() if the HTTP method requires sending body data
  */
 bool HTTPProtocol::sendQuery()
 {
     qCDebug(KIO_HTTP);
 
     // Cannot have an https request without autoSsl!  This can
     // only happen if  the current installation does not support SSL...
     if (isEncryptedHttpVariety(m_protocol) && !isAutoSsl()) {
         error(ERR_UNSUPPORTED_PROTOCOL, toQString(m_protocol));
         return false;
     }
 
     // Check the reusability of the current connection.
     if (httpShouldCloseConnection()) {
         httpCloseConnection();
     }
 
     // Create a new connection to the remote machine if we do
     // not already have one...
     // NB: the !m_socketProxyAuth condition is a workaround for a proxied Qt socket sometimes
     // looking disconnected after receiving the initial 407 response.
     // I guess the Qt socket fails to hide the effect of  proxy-connection: close after receiving
     // the 407 header.
     if ((!isConnected() && !m_socketProxyAuth)) {
         if (!httpOpenConnection()) {
             qCDebug(KIO_HTTP) << "Couldn't connect, oopsie!";
             return false;
         }
     }
 
     m_request.cacheTag.ioMode = NoCache;
     m_request.cacheTag.servedDate = QDateTime();
     m_request.cacheTag.lastModifiedDate = QDateTime();
     m_request.cacheTag.expireDate = QDateTime();
     QString header;
     bool hasBodyData = false;
     bool hasDavData = false;
 
     {
         m_request.sentMethodString = m_request.methodString();
         header = toQString(m_request.sentMethodString) + QLatin1Char(' ');
 
         QString davHeader;
 
         // Fill in some values depending on the HTTP method to guide further processing
         switch (m_request.method) {
         case HTTP_GET: {
             bool cacheHasPage = false;
             if (satisfyRequestFromCache(&cacheHasPage)) {
                 qCDebug(KIO_HTTP) << "cacheHasPage =" << cacheHasPage;
                 return cacheHasPage;
             }
             if (!cacheHasPage) {
                 // start a new cache file later if appropriate
                 m_request.cacheTag.ioMode = WriteToCache;
             }
             break;
         }
         case HTTP_HEAD:
             break;
         case HTTP_PUT:
         case HTTP_POST:
             hasBodyData = true;
             break;
         case HTTP_DELETE:
         case HTTP_OPTIONS:
             break;
         case DAV_PROPFIND:
             hasDavData = true;
             davHeader = QStringLiteral("Depth: ");
             if (hasMetaData(QStringLiteral("davDepth"))) {
                 qCDebug(KIO_HTTP) << "Reading DAV depth from metadata:" << metaData( QStringLiteral("davDepth") );
                 davHeader += metaData(QStringLiteral("davDepth"));
             } else {
                 if (m_request.davData.depth == 2) {
                     davHeader += QLatin1String("infinity");
                 } else {
                     davHeader += QString::number(m_request.davData.depth);
                 }
             }
             davHeader += QLatin1String("\r\n");
             break;
         case DAV_PROPPATCH:
             hasDavData = true;
             break;
         case DAV_MKCOL:
             break;
         case DAV_COPY:
         case DAV_MOVE:
             davHeader =
                 QLatin1String("Destination: ") + m_request.davData.desturl +
             // infinity depth means copy recursively
             // (optional for copy -> but is the desired action)
                 QLatin1String("\r\nDepth: infinity\r\nOverwrite: ") +
                 QLatin1Char(m_request.davData.overwrite ? 'T' : 'F') +
                 QLatin1String("\r\n");
             break;
         case DAV_LOCK:
             davHeader = QStringLiteral("Timeout: ");
             {
                 uint timeout = 0;
                 if (hasMetaData(QStringLiteral("davTimeout"))) {
                     timeout = metaData(QStringLiteral("davTimeout")).toUInt();
                 }
                 if (timeout == 0) {
                     davHeader += QLatin1String("Infinite");
                 } else {
                     davHeader += QLatin1String("Seconds-") + QString::number(timeout);
                 }
             }
             davHeader += QLatin1String("\r\n");
             hasDavData = true;
             break;
         case DAV_UNLOCK:
             davHeader = QLatin1String("Lock-token: ") + metaData(QStringLiteral("davLockToken")) + QLatin1String("\r\n");
             break;
         case DAV_SEARCH:
         case DAV_REPORT:
             hasDavData = true;
         /* fall through */
         case DAV_SUBSCRIBE:
         case DAV_UNSUBSCRIBE:
         case DAV_POLL:
             break;
         default:
             error(ERR_UNSUPPORTED_ACTION, QString());
             return false;
         }
         // DAV_POLL; DAV_NOTIFY
 
         header += formatRequestUri() + QLatin1String(" HTTP/1.1\r\n"); /* start header */
 
         /* support for virtual hosts and required by HTTP 1.1 */
         header += QLatin1String("Host: ") + m_request.encoded_hostname;
         if (m_request.url.port(defaultPort()) != defaultPort()) {
             header += QLatin1Char(':') + QString::number(m_request.url.port());
         }
         header += QLatin1String("\r\n");
 
         // Support old HTTP/1.0 style keep-alive header for compatibility
         // purposes as well as performance improvements while giving end
         // users the ability to disable this feature for proxy servers that
         // don't support it, e.g. junkbuster proxy server.
         if (isHttpProxy(m_request.proxyUrl) && !isAutoSsl()) {
             header += QLatin1String("Proxy-Connection: ");
         } else {
             header += QLatin1String("Connection: ");
         }
         if (m_request.isKeepAlive) {
             header += QLatin1String("keep-alive\r\n");
         } else {
             header += QLatin1String("close\r\n");
         }
 
         if (!m_request.userAgent.isEmpty()) {
             header += QLatin1String("User-Agent: ") + m_request.userAgent + QLatin1String("\r\n");
         }
 
         if (!m_request.referrer.isEmpty()) {
             // Don't try to correct spelling!
             header += QLatin1String("Referer: ") + m_request.referrer + QLatin1String("\r\n");
         }
 
         if (m_request.endoffset > m_request.offset) {
             header += QLatin1String("Range: bytes=") + KIO::number(m_request.offset) + QLatin1Char('-') +
                 KIO::number(m_request.endoffset) + QLatin1String("\r\n");
             qCDebug(KIO_HTTP) << "kio_http : Range =" << KIO::number(m_request.offset) << "-"  << KIO::number(m_request.endoffset);
         } else if (m_request.offset > 0 && m_request.endoffset == 0) {
             header += QLatin1String("Range: bytes=") + KIO::number(m_request.offset) + QLatin1String("-\r\n");
             qCDebug(KIO_HTTP) << "kio_http: Range =" << KIO::number(m_request.offset);
         }
 
         if (!m_request.cacheTag.useCache || m_request.cacheTag.policy == CC_Reload) {
             /* No caching for reload */
             header += QLatin1String("Pragma: no-cache\r\n"); /* for HTTP/1.0 caches */
             header += QLatin1String("Cache-control: no-cache\r\n"); /* for HTTP >=1.1 caches */
         } else if (m_request.cacheTag.plan(m_maxCacheAge) == CacheTag::ValidateCached) {
             qCDebug(KIO_HTTP) << "needs validation, performing conditional get.";
             /* conditional get */
             if (!m_request.cacheTag.etag.isEmpty()) {
                 header += QLatin1String("If-None-Match: ") + m_request.cacheTag.etag + QLatin1String("\r\n");
             }
 
             if (m_request.cacheTag.lastModifiedDate.isValid()) {
                 const QString httpDate = formatHttpDate(m_request.cacheTag.lastModifiedDate);
                 header += QLatin1String("If-Modified-Since: ") + httpDate + QLatin1String("\r\n");
                 setMetaData(QStringLiteral("modified"), httpDate);
             }
         }
 
         header += QLatin1String("Accept: ");
         const QString acceptHeader = metaData(QStringLiteral("accept"));
         if (!acceptHeader.isEmpty()) {
             header += acceptHeader;
         } else {
             header += QLatin1String(DEFAULT_ACCEPT_HEADER);
         }
         header += QLatin1String("\r\n");
 
         if (m_request.allowTransferCompression) {
             header += QLatin1String("Accept-Encoding: gzip, deflate, x-gzip, x-deflate\r\n");
         }
 
         if (!m_request.charsets.isEmpty()) {
             header += QLatin1String("Accept-Charset: ") + m_request.charsets + QLatin1String("\r\n");
         }
 
         if (!m_request.languages.isEmpty()) {
             header += QLatin1String("Accept-Language: ") + m_request.languages + QLatin1String("\r\n");
         }
 
         QString cookieStr;
         const QString cookieMode = metaData(QStringLiteral("cookies")).toLower();
 
         if (cookieMode == QLatin1String("none")) {
             m_request.cookieMode = HTTPRequest::CookiesNone;
         } else if (cookieMode == QLatin1String("manual")) {
             m_request.cookieMode = HTTPRequest::CookiesManual;
             cookieStr = metaData(QStringLiteral("setcookies"));
         } else {
             m_request.cookieMode = HTTPRequest::CookiesAuto;
             if (m_request.useCookieJar) {
                 cookieStr = findCookies(m_request.url.toString());
             }
         }
 
         if (!cookieStr.isEmpty()) {
             header += cookieStr + QLatin1String("\r\n");
         }
 
         const QString customHeader = metaData(QStringLiteral("customHTTPHeader"));
         if (!customHeader.isEmpty()) {
             header += sanitizeCustomHTTPHeader(customHeader) + QLatin1String("\r\n");
         }
 
         const QString contentType = metaData(QStringLiteral("content-type"));
         if (!contentType.isEmpty()) {
             if (!contentType.startsWith(QLatin1String("content-type"), Qt::CaseInsensitive)) {
                 header += QLatin1String("Content-Type: ");
             }
             header += contentType + QLatin1String("\r\n");
         }
 
         // DoNotTrack feature...
         if (config()->readEntry("DoNotTrack", false)) {
             header += QLatin1String("DNT: 1\r\n");
         }
 
         // Remember that at least one failed (with 401 or 407) request/response
         // roundtrip is necessary for the server to tell us that it requires
         // authentication. However, we proactively add authentication headers if when
         // we have cached credentials to avoid the extra roundtrip where possible.
         header += authenticationHeader();
 
         if (m_protocol == "webdav" || m_protocol == "webdavs") {
             header += davProcessLocks();
 
             // add extra webdav headers, if supplied
             davHeader += metaData(QStringLiteral("davHeader"));
 
             // Set content type of webdav data
             if (hasDavData) {
                 davHeader += QStringLiteral("Content-Type: text/xml; charset=utf-8\r\n");
             }
 
             // add extra header elements for WebDAV
             header += davHeader;
         }
     }
 
     qCDebug(KIO_HTTP) << "============ Sending Header:";
     Q_FOREACH (const QString &s, header.split(QStringLiteral("\r\n"), QString::SkipEmptyParts)) {
         qCDebug(KIO_HTTP) << s;
     }
 
     // End the header iff there is no payload data. If we do have payload data
     // sendBody() will add another field to the header, Content-Length.
     if (!hasBodyData && !hasDavData) {
         header += QStringLiteral("\r\n");
     }
 
     // Now that we have our formatted header, let's send it!
 
     // Clear out per-connection settings...
     resetConnectionSettings();
 
     // Send the data to the remote machine...
     const QByteArray headerBytes = header.toLatin1();
     ssize_t written = write(headerBytes.constData(), headerBytes.length());
     bool sendOk = (written == (ssize_t) headerBytes.length());
     if (!sendOk) {
         qCDebug(KIO_HTTP) << "Connection broken! (" << m_request.url.host() << ")"
                           << "  -- intended to write" << headerBytes.length()
                           << "bytes but wrote" << (int)written << ".";
 
         // The server might have closed the connection due to a timeout, or maybe
         // some transport problem arose while the connection was idle.
         if (m_request.isKeepAlive) {
             httpCloseConnection();
             return true; // Try again
         }
 
         qCDebug(KIO_HTTP) << "sendOk == false. Connection broken !"
                           << "  -- intended to write" << headerBytes.length()
                           << "bytes but wrote" << (int)written << ".";
         error(ERR_CONNECTION_BROKEN, m_request.url.host());
         return false;
     } else {
         qCDebug(KIO_HTTP) << "sent it!";
     }
 
     bool res = true;
     if (hasBodyData || hasDavData) {
         res = sendBody();
     }
 
     infoMessage(i18n("%1 contacted. Waiting for reply...", m_request.url.host()));
 
     return res;
 }
 
 void HTTPProtocol::forwardHttpResponseHeader(bool forwardImmediately)
 {
     // Send the response header if it was requested...
     if (!config()->readEntry("PropagateHttpHeader", false)) {
         return;
     }
 
     setMetaData(QStringLiteral("HTTP-Headers"), m_responseHeaders.join(QLatin1Char('\n')));
 
     if (forwardImmediately) {
         sendMetaData();
     }
 }
 
 bool HTTPProtocol::parseHeaderFromCache()
 {
     qCDebug(KIO_HTTP);
     if (!cacheFileReadTextHeader2()) {
         return false;
     }
 
     Q_FOREACH (const QString &str, m_responseHeaders) {
         const QString header = str.trimmed();
         if (header.startsWith(QLatin1String("content-type:"), Qt::CaseInsensitive)) {
             int pos = header.indexOf(QLatin1String("charset="), Qt::CaseInsensitive);
             if (pos != -1) {
                 const QString charset = header.mid(pos + 8).toLower();
                 m_request.cacheTag.charset = charset;
                 setMetaData(QStringLiteral("charset"), charset);
             }
         } else if (header.startsWith(QLatin1String("content-language:"), Qt::CaseInsensitive)) {
             const QString language = header.mid(17).trimmed().toLower();
             setMetaData(QStringLiteral("content-language"), language);
         } else if (header.startsWith(QLatin1String("content-disposition:"), Qt::CaseInsensitive)) {
             parseContentDisposition(header.mid(20).toLower());
         }
     }
 
     if (m_request.cacheTag.lastModifiedDate.isValid()) {
         setMetaData(QStringLiteral("modified"), formatHttpDate(m_request.cacheTag.lastModifiedDate));
     }
 
     // this header comes from the cache, so the response must have been cacheable :)
     setCacheabilityMetadata(true);
     qCDebug(KIO_HTTP) << "Emitting mimeType" << m_mimeType;
     forwardHttpResponseHeader(false);
     mimeType(m_mimeType);
     // IMPORTANT: Do not remove the call below or the http response headers will
     // not be available to the application if this slave is put on hold.
     forwardHttpResponseHeader();
     return true;
 }
 
 void HTTPProtocol::fixupResponseMimetype()
 {
     if (m_mimeType.isEmpty()) {
         return;
     }
 
     qCDebug(KIO_HTTP) << "before fixup" << m_mimeType;
     // Convert some common mimetypes to standard mimetypes
     if (m_mimeType == QLatin1String("application/x-targz")) {
         m_mimeType = QStringLiteral("application/x-compressed-tar");
     } else if (m_mimeType == QLatin1String("image/x-png")) {
         m_mimeType = QStringLiteral("image/png");
     } else if (m_mimeType == QLatin1String("audio/x-mp3") || m_mimeType == QLatin1String("audio/x-mpeg") || m_mimeType == QLatin1String("audio/mp3")) {
         m_mimeType = QStringLiteral("audio/mpeg");
     } else if (m_mimeType == QLatin1String("audio/microsoft-wave")) {
         m_mimeType = QStringLiteral("audio/x-wav");
     } else if (m_mimeType == QLatin1String("image/x-ms-bmp")) {
         m_mimeType = QStringLiteral("image/bmp");
     }
 
     // Crypto ones....
     else if (m_mimeType == QLatin1String("application/pkix-cert") ||
              m_mimeType == QLatin1String("application/binary-certificate")) {
         m_mimeType = QStringLiteral("application/x-x509-ca-cert");
     }
 
     // Prefer application/x-compressed-tar or x-gzpostscript over application/x-gzip.
     else if (m_mimeType == QLatin1String("application/x-gzip")) {
         if ((m_request.url.path().endsWith(QLatin1String(".tar.gz"))) ||
                 (m_request.url.path().endsWith(QLatin1String(".tar")))) {
             m_mimeType = QStringLiteral("application/x-compressed-tar");
         }
         if ((m_request.url.path().endsWith(QLatin1String(".ps.gz")))) {
             m_mimeType = QStringLiteral("application/x-gzpostscript");
         }
     }
 
     // Prefer application/x-xz-compressed-tar over application/x-xz for LMZA compressed
     // tar files. Arch Linux AUR servers notoriously send the wrong mimetype for this.
     else if (m_mimeType == QLatin1String("application/x-xz")) {
         if (m_request.url.path().endsWith(QLatin1String(".tar.xz")) ||
                 m_request.url.path().endsWith(QLatin1String(".txz"))) {
             m_mimeType = QStringLiteral("application/x-xz-compressed-tar");
         }
     }
 
     // Some webservers say "text/plain" when they mean "application/x-bzip"
     else if ((m_mimeType == QLatin1String("text/plain")) || (m_mimeType == QLatin1String("application/octet-stream"))) {
         const QString ext = QFileInfo(m_request.url.path()).suffix().toUpper();
         if (ext == QLatin1String("BZ2")) {
             m_mimeType = QStringLiteral("application/x-bzip");
         } else if (ext == QLatin1String("PEM")) {
             m_mimeType = QStringLiteral("application/x-x509-ca-cert");
         } else if (ext == QLatin1String("SWF")) {
             m_mimeType = QStringLiteral("application/x-shockwave-flash");
         } else if (ext == QLatin1String("PLS")) {
             m_mimeType = QStringLiteral("audio/x-scpls");
         } else if (ext == QLatin1String("WMV")) {
             m_mimeType = QStringLiteral("video/x-ms-wmv");
         } else if (ext == QLatin1String("WEBM")) {
             m_mimeType = QStringLiteral("video/webm");
         } else if (ext == QLatin1String("DEB")) {
             m_mimeType = QStringLiteral("application/x-deb");
         }
     }
     qCDebug(KIO_HTTP) << "after fixup" << m_mimeType;
 }
 
 void HTTPProtocol::fixupResponseContentEncoding()
 {
     // WABA: Correct for tgz files with a gzip-encoding.
     // They really shouldn't put gzip in the Content-Encoding field!
     // Web-servers really shouldn't do this: They let Content-Size refer
     // to the size of the tgz file, not to the size of the tar file,
     // while the Content-Type refers to "tar" instead of "tgz".
     if (!m_contentEncodings.isEmpty() && m_contentEncodings.last() == QLatin1String("gzip")) {
         if (m_mimeType == QLatin1String("application/x-tar")) {
             m_contentEncodings.removeLast();
             m_mimeType = QStringLiteral("application/x-compressed-tar");
         } else if (m_mimeType == QLatin1String("application/postscript")) {
             // LEONB: Adding another exception for psgz files.
             // Could we use the mimelnk files instead of hardcoding all this?
             m_contentEncodings.removeLast();
             m_mimeType = QStringLiteral("application/x-gzpostscript");
         } else if ((m_request.allowTransferCompression &&
                     m_mimeType == QLatin1String("text/html"))
                    ||
                    (m_request.allowTransferCompression &&
                     m_mimeType != QLatin1String("application/x-compressed-tar") &&
                     m_mimeType != QLatin1String("application/x-tgz") && // deprecated name
                     m_mimeType != QLatin1String("application/x-targz") && // deprecated name
                     m_mimeType != QLatin1String("application/x-gzip"))) {
             // Unzip!
         } else {
             m_contentEncodings.removeLast();
             m_mimeType = QStringLiteral("application/x-gzip");
         }
     }
 
     // We can't handle "bzip2" encoding (yet). So if we get something with
     // bzip2 encoding, we change the mimetype to "application/x-bzip".
     // Note for future changes: some web-servers send both "bzip2" as
     //   encoding and "application/x-bzip[2]" as mimetype. That is wrong.
     //   currently that doesn't bother us, because we remove the encoding
     //   and set the mimetype to x-bzip anyway.
     if (!m_contentEncodings.isEmpty() && m_contentEncodings.last() == QLatin1String("bzip2")) {
         m_contentEncodings.removeLast();
         m_mimeType = QStringLiteral("application/x-bzip");
     }
 }
 
 #ifdef Q_CC_MSVC
 // strncasecmp does not exist on windows, have to use _strnicmp
 static inline int strncasecmp(const char *c1, const char* c2, size_t max) { return _strnicmp(c1, c2, max);  }
 #endif
 
 //Return true if the term was found, false otherwise. Advance *pos.
 //If (*pos + strlen(term) >= end) just advance *pos to end and return false.
 //This means that users should always search for the shortest terms first.
 static bool consume(const char input[], int *pos, int end, const char *term)
 {
     // note: gcc/g++ is quite good at optimizing away redundant strlen()s
     int idx = *pos;
     if (idx + (int)strlen(term) >= end) {
         *pos = end;
         return false;
     }
     if (strncasecmp(&input[idx], term, strlen(term)) == 0) {
         *pos = idx + strlen(term);
         return true;
     }
     return false;
 }
 
 /**
  * This function will read in the return header from the server.  It will
  * not read in the body of the return message.  It will also not transmit
  * the header to our client as the client doesn't need to know the gory
  * details of HTTP headers.
  */
 bool HTTPProtocol::readResponseHeader()
 {
     resetResponseParsing();
     if (m_request.cacheTag.ioMode == ReadFromCache &&
             m_request.cacheTag.plan(m_maxCacheAge) == CacheTag::UseCached) {
         // parseHeaderFromCache replaces this method in case of cached content
         return parseHeaderFromCache();
     }
 
 try_again:
     qCDebug(KIO_HTTP);
 
     bool upgradeRequired = false;   // Server demands that we upgrade to something
     // This is also true if we ask to upgrade and
     // the server accepts, since we are now
     // committed to doing so
     bool noHeadersFound = false;
 
     m_request.cacheTag.charset.clear();
     m_responseHeaders.clear();
 
     static const int maxHeaderSize = 128 * 1024;
 
     char buffer[maxHeaderSize];
     bool cont = false;
     bool bCanResume = false;
 
     if (!isConnected()) {
         qCDebug(KIO_HTTP) << "No connection.";
         return false; // Reestablish connection and try again
     }
 
 #if 0
     // NOTE: This is unnecessary since TCPSlaveBase::read does the same exact
     // thing. Plus, if we are unable to read from the socket we need to resend
     // the request as done below, not error out! Do not assume remote server
     // will honor persistent connections!!
     if (!waitForResponse(m_remoteRespTimeout)) {
         qCDebug(KIO_HTTP) << "Got socket error:" << socket()->errorString();
         // No response error
         error(ERR_SERVER_TIMEOUT, m_request.url.host());
         return false;
     }
 #endif
 
     int bufPos = 0;
     bool foundDelimiter = readDelimitedText(buffer, &bufPos, maxHeaderSize, 1);
     if (!foundDelimiter && bufPos < maxHeaderSize) {
         qCDebug(KIO_HTTP) << "EOF while waiting for header start.";
         if (m_request.isKeepAlive && m_iEOFRetryCount < 2) {
             m_iEOFRetryCount++;
             httpCloseConnection(); // Try to reestablish connection.
             return false; // Reestablish connection and try again.
         }
 
         if (m_request.method == HTTP_HEAD) {
             // HACK
             // Some web-servers fail to respond properly to a HEAD request.
             // We compensate for their failure to properly implement the HTTP standard
             // by assuming that they will be sending html.
             qCDebug(KIO_HTTP) << "HEAD -> returned mimetype:" << DEFAULT_MIME_TYPE;
             mimeType(QStringLiteral(DEFAULT_MIME_TYPE));
             return true;
         }
 
         qCDebug(KIO_HTTP) << "Connection broken !";
         error(ERR_CONNECTION_BROKEN, m_request.url.host());
         return false;
     }
     if (!foundDelimiter) {
         //### buffer too small for first line of header(!)
         Q_ASSERT(0);
     }
 
     qCDebug(KIO_HTTP) << "============ Received Status Response:";
     qCDebug(KIO_HTTP) << QByteArray(buffer, bufPos).trimmed();
 
     HTTP_REV httpRev = HTTP_None;
     int idx = 0;
 
     if (idx != bufPos && buffer[idx] == '<') {
         qCDebug(KIO_HTTP) << "No valid HTTP header found! Document starts with XML/HTML tag";
         // document starts with a tag, assume HTML instead of text/plain
         m_mimeType = QStringLiteral("text/html");
         m_request.responseCode = 200; // Fake it
         httpRev = HTTP_Unknown;
         m_request.isKeepAlive = false;
         noHeadersFound = true;
         // put string back
         unread(buffer, bufPos);
         goto endParsing;
     }
 
     // "HTTP/1.1" or similar
     if (consume(buffer, &idx, bufPos, "ICY ")) {
         httpRev = SHOUTCAST;
         m_request.isKeepAlive = false;
     } else if (consume(buffer, &idx, bufPos, "HTTP/")) {
         if (consume(buffer, &idx, bufPos, "1.0")) {
             httpRev = HTTP_10;
             m_request.isKeepAlive = false;
         } else if (consume(buffer, &idx, bufPos, "1.1")) {
             httpRev = HTTP_11;
         }
     }
 
     if (httpRev == HTTP_None && bufPos != 0) {
         // Remote server does not seem to speak HTTP at all
         // Put the crap back into the buffer and hope for the best
         qCDebug(KIO_HTTP) << "DO NOT WANT." << bufPos;
         unread(buffer, bufPos);
         if (m_request.responseCode) {
             m_request.prevResponseCode = m_request.responseCode;
         }
         m_request.responseCode = 200; // Fake it
         httpRev = HTTP_Unknown;
         m_request.isKeepAlive = false;
         noHeadersFound = true;
         goto endParsing;
     }
 
     // response code //### maybe wrong if we need several iterations for this response...
     //### also, do multiple iterations (cf. try_again) to parse one header work w/ pipelining?
     if (m_request.responseCode) {
         m_request.prevResponseCode = m_request.responseCode;
     }
     skipSpace(buffer, &idx, bufPos);
     //TODO saner handling of invalid response code strings
     if (idx != bufPos) {
         m_request.responseCode = atoi(&buffer[idx]);
     } else {
         m_request.responseCode = 200;
     }
     // move idx to start of (yet to be fetched) next line, skipping the "OK"
     idx = bufPos;
     // (don't bother parsing the "OK", what do we do if it isn't there anyway?)
 
     // immediately act on most response codes...
 
     // Protect users against bogus username intended to fool them into visiting
     // sites they had no intention of visiting.
     if (isPotentialSpoofingAttack(m_request, config())) {
         qCDebug(KIO_HTTP) << "**** POTENTIAL ADDRESS SPOOFING:" << m_request.url;
         const int result =
             messageBox(WarningYesNo,
                        i18nc("@info Security check on url being accessed",
                              "<p>You are about to log in to the site \"%1\" "
                              "with the username \"%2\", but the website "
                              "does not require authentication. "
                              "This may be an attempt to trick you.</p>"
                              "<p>Is \"%1\" the site you want to visit?</p>",
                              m_request.url.host(), m_request.url.userName()),
                        i18nc("@title:window", "Confirm Website Access"));
         if (result == SlaveBase::No) {
             error(ERR_USER_CANCELED, m_request.url.toDisplayString());
             return false;
         }
         setMetaData(QStringLiteral("{internal~currenthost}LastSpoofedUserName"), m_request.url.userName());
     }
 
     if (m_request.responseCode != 200 && m_request.responseCode != 304) {
         m_request.cacheTag.ioMode = NoCache;
 
         if (m_request.responseCode >= 500 && m_request.responseCode <= 599) {
             // Server side errors
             if (m_request.method == HTTP_HEAD) {
                 ; // Ignore error
             } else {
                 if (!sendErrorPageNotification()) {
                     error(ERR_INTERNAL_SERVER, m_request.url.toDisplayString());
                     return false;
                 }
             }
         } else if (m_request.responseCode == 416) {
             // Range not supported
             m_request.offset = 0;
             return false; // Try again.
         } else if (m_request.responseCode == 426) {
             // Upgrade Required
             upgradeRequired = true;
         } else if (m_request.responseCode >= 400 && m_request.responseCode <= 499 && !isAuthenticationRequired(m_request.responseCode)) {
             // Any other client errors
             // Tell that we will only get an error page here.
             if (!sendErrorPageNotification()) {
                 if (m_request.responseCode == 403) {
                     error(ERR_ACCESS_DENIED, m_request.url.toDisplayString());
                 } else {
                     error(ERR_DOES_NOT_EXIST, m_request.url.toDisplayString());
                 }
             }
         } else if (m_request.responseCode >= 301 && m_request.responseCode <= 308) {
             // NOTE: According to RFC 2616 (section 10.3.[2-4,8]), 301 and 302
             // redirects for a POST operation should not be converted to a GET
             // request. That should only be done for a 303 response. However,
             // because almost all other client implementations do exactly that
             // in violation of the spec, many servers have simply adapted to
             // this way of doing things! Thus, we are forced to do the same
             // thing here. Otherwise, we loose compatibility and might not be
             // able to correctly retrieve sites that redirect.
             switch (m_request.responseCode) {
               case 301: // Moved Permanently
                 setMetaData(QStringLiteral("permanent-redirect"), QStringLiteral("true"));
                 // fall through
               case 302: // Found
                 if (m_request.sentMethodString == "POST") {
                     m_request.method = HTTP_GET; // FORCE a GET
                     setMetaData(QStringLiteral("redirect-to-get"), QStringLiteral("true"));
                 }
                 break;
               case 303: // See Other
                 if (m_request.method != HTTP_HEAD) {
                     m_request.method = HTTP_GET; // FORCE a GET
                     setMetaData(QStringLiteral("redirect-to-get"), QStringLiteral("true"));
                 }
                 break;
               case 308: // Permanent Redirect
                 setMetaData(QStringLiteral("permanent-redirect"), QStringLiteral("true"));
                 break;
               default:
                 break;
             }
         } else if (m_request.responseCode == 204) {
             // No content
 
             // error(ERR_NO_CONTENT, i18n("Data have been successfully sent."));
             // Short circuit and do nothing!
 
             // The original handling here was wrong, this is not an error: eg. in the
             // example of a 204 No Content response to a PUT completing.
             // return false;
         } else if (m_request.responseCode == 206) {
             if (m_request.offset) {
                 bCanResume = true;
             }
         } else if (m_request.responseCode == 102) {
             // Processing (for WebDAV)
             /***
              * This status code is given when the server expects the
              * command to take significant time to complete. So, inform
              * the user.
              */
             infoMessage(i18n("Server processing request, please wait..."));
             cont = true;
         } else if (m_request.responseCode == 100) {
             // We got 'Continue' - ignore it
             cont = true;
         }
     } // (m_request.responseCode != 200 && m_request.responseCode != 304)
 
 endParsing:
     bool authRequiresAnotherRoundtrip = false;
 
     // Skip the whole header parsing if we got no HTTP headers at all
     if (!noHeadersFound) {
         // Auth handling
         const bool wasAuthError = isAuthenticationRequired(m_request.prevResponseCode);
         const bool isAuthError = isAuthenticationRequired(m_request.responseCode);
         const bool sameAuthError = (m_request.responseCode == m_request.prevResponseCode);
         qCDebug(KIO_HTTP) << "wasAuthError=" << wasAuthError << "isAuthError=" << isAuthError
                           << "sameAuthError=" << sameAuthError;
         // Not the same authorization error as before and no generic error?
         // -> save the successful credentials.
         if (wasAuthError && (m_request.responseCode < 400 || (isAuthError && !sameAuthError))) {
             saveAuthenticationData();
         }
 
         // done with the first line; now tokenize the other lines
 
         // TODO review use of STRTOLL vs. QByteArray::toInt()
 
         foundDelimiter = readDelimitedText(buffer, &bufPos, maxHeaderSize, 2);
         qCDebug(KIO_HTTP) << " -- full response:" << endl << QByteArray(buffer, bufPos).trimmed();
         // Use this to see newlines:
         //qCDebug(KIO_HTTP) << " -- full response:" << endl << QByteArray(buffer, bufPos).replace("\r", "\\r").replace("\n", "\\n\n");
         Q_ASSERT(foundDelimiter);
 
         //NOTE because tokenizer will overwrite newlines in case of line continuations in the header
         //     unread(buffer, bufSize) will not generally work anymore. we don't need it either.
         //     either we have a http response line -> try to parse the header, fail if it doesn't work
         //     or we have garbage -> fail.
         HeaderTokenizer tokenizer(buffer);
         tokenizer.tokenize(idx, sizeof(buffer));
 
         // Note that not receiving "accept-ranges" means that all bets are off
         // wrt the server supporting ranges.
         TokenIterator tIt = tokenizer.iterator("accept-ranges");
         if (tIt.hasNext() && tIt.next().toLower().startsWith("none")) { // krazy:exclude=strings
             bCanResume = false;
         }
 
         tIt = tokenizer.iterator("keep-alive");
         while (tIt.hasNext()) {
             QByteArray ka = tIt.next().trimmed().toLower();
             if (ka.startsWith("timeout=")) { // krazy:exclude=strings
                 int ka_timeout = ka.mid(qstrlen("timeout=")).trimmed().toInt();
                 if (ka_timeout > 0) {
                     m_request.keepAliveTimeout = ka_timeout;
                 }
                 if (httpRev == HTTP_10) {
                     m_request.isKeepAlive = true;
                 }
 
                 break; // we want to fetch ka timeout only
             }
         }
 
         // get the size of our data
         tIt = tokenizer.iterator("content-length");
         if (tIt.hasNext()) {
             m_iSize = STRTOLL(tIt.next().constData(), nullptr, 10);
         }
 
         tIt = tokenizer.iterator("content-location");
         if (tIt.hasNext()) {
             setMetaData(QStringLiteral("content-location"), toQString(tIt.next().trimmed()));
         }
 
         // which type of data do we have?
         QString mediaValue;
         QString mediaAttribute;
         tIt = tokenizer.iterator("content-type");
         if (tIt.hasNext()) {
             QList<QByteArray> l = tIt.next().split(';');
             if (!l.isEmpty()) {
                 // Assign the mime-type.
                 m_mimeType = toQString(l.first().trimmed().toLower());
                 if (m_mimeType.startsWith(QLatin1Char('"'))) {
                     m_mimeType.remove(0, 1);
                 }
                 if (m_mimeType.endsWith(QLatin1Char('"'))) {
                     m_mimeType.chop(1);
                 }
                 qCDebug(KIO_HTTP) << "Content-type:" << m_mimeType;
                 l.removeFirst();
             }
 
             // If we still have text, then it means we have a mime-type with a
             // parameter (eg: charset=iso-8851) ; so let's get that...
             Q_FOREACH (const QByteArray &statement, l) {
                 const int index = statement.indexOf('=');
                 if (index <= 0) {
                     mediaAttribute = toQString(statement.mid(0, index));
                 } else {
                     mediaAttribute = toQString(statement.mid(0, index));
                     mediaValue = toQString(statement.mid(index + 1));
                 }
                 mediaAttribute = mediaAttribute.trimmed();
                 mediaValue     = mediaValue.trimmed();
 
                 bool quoted = false;
                 if (mediaValue.startsWith(QLatin1Char('"'))) {
                     quoted = true;
                     mediaValue.remove(0, 1);
                 }
 
                 if (mediaValue.endsWith(QLatin1Char('"'))) {
                     mediaValue.chop(1);
                 }
 
                 qCDebug(KIO_HTTP) << "Encoding-type:" << mediaAttribute << "=" << mediaValue;
 
                 if (mediaAttribute == QLatin1String("charset")) {
                     mediaValue = mediaValue.toLower();
                     m_request.cacheTag.charset = mediaValue;
                     setMetaData(QStringLiteral("charset"), mediaValue);
                 } else {
                     setMetaData(QLatin1String("media-") + mediaAttribute, mediaValue);
                     if (quoted) {
                         setMetaData(QLatin1String("media-") + mediaAttribute + QLatin1String("-kio-quoted"),
                                     QStringLiteral("true"));
                     }
                 }
             }
         }
 
         // content?
         tIt = tokenizer.iterator("content-encoding");
         while (tIt.hasNext()) {
             // This is so wrong !!  No wonder kio_http is stripping the
             // gzip encoding from downloaded files.  This solves multiple
             // bug reports and caitoo's problem with downloads when such a
             // header is encountered...
 
             // A quote from RFC 2616:
             // " When present, its (Content-Encoding) value indicates what additional
             // content have been applied to the entity body, and thus what decoding
             // mechanism must be applied to obtain the media-type referenced by the
             // Content-Type header field.  Content-Encoding is primarily used to allow
             // a document to be compressed without loosing the identity of its underlying
             // media type.  Simply put if it is specified, this is the actual mime-type
             // we should use when we pull the resource !!!
             addEncoding(toQString(tIt.next()), m_contentEncodings);
         }
         // Refer to RFC 2616 sec 15.5/19.5.1 and RFC 2183
         tIt = tokenizer.iterator("content-disposition");
         if (tIt.hasNext()) {
             parseContentDisposition(toQString(tIt.next()));
         }
         tIt = tokenizer.iterator("content-language");
         if (tIt.hasNext()) {
             QString language = toQString(tIt.next().trimmed());
             if (!language.isEmpty()) {
                 setMetaData(QStringLiteral("content-language"), language);
             }
         }
 
         tIt = tokenizer.iterator("proxy-connection");
         if (tIt.hasNext() && isHttpProxy(m_request.proxyUrl) && !isAutoSsl()) {
             QByteArray pc = tIt.next().toLower();
             if (pc.startsWith("close")) { // krazy:exclude=strings
                 m_request.isKeepAlive = false;
             } else if (pc.startsWith("keep-alive")) { // krazy:exclude=strings
                 m_request.isKeepAlive = true;
             }
         }
 
         tIt = tokenizer.iterator("link");
         if (tIt.hasNext()) {
             // We only support Link: <url>; rel="type"   so far
             QStringList link = toQString(tIt.next()).split(QLatin1Char(';'), QString::SkipEmptyParts);
             if (link.count() == 2) {
                 QString rel = link[1].trimmed();
                 if (rel.startsWith(QLatin1String("rel=\""))) {
                     rel = rel.mid(5, rel.length() - 6);
                     if (rel.toLower() == QLatin1String("pageservices")) {
                         //### the remove() part looks fishy!
                         QString url = link[0].remove(QRegExp(QStringLiteral("[<>]"))).trimmed();
                         setMetaData(QStringLiteral("PageServices"), url);
                     }
                 }
             }
         }
 
         tIt = tokenizer.iterator("p3p");
         if (tIt.hasNext()) {
             // P3P privacy policy information
             QStringList policyrefs, compact;
             while (tIt.hasNext()) {
                 QStringList policy = toQString(tIt.next().simplified())
                                      .split(QLatin1Char('='), QString::SkipEmptyParts);
                 if (policy.count() == 2) {
                     if (policy[0].toLower() == QLatin1String("policyref")) {
                         policyrefs << policy[1].remove(QRegExp(QStringLiteral("[\")\']"))).trimmed();
                     } else if (policy[0].toLower() == QLatin1String("cp")) {
                         // We convert to cp\ncp\ncp\n[...]\ncp to be consistent with
                         // other metadata sent in strings.  This could be a bit more
                         // efficient but I'm going for correctness right now.
                         const QString s = policy[1].remove(QRegExp(QStringLiteral("[\")\']")));
                         const QStringList cps = s.split(QLatin1Char(' '), QString::SkipEmptyParts);
                         compact << cps;
                     }
                 }
             }
             if (!policyrefs.isEmpty()) {
                 setMetaData(QStringLiteral("PrivacyPolicy"), policyrefs.join(QLatin1Char('\n')));
             }
             if (!compact.isEmpty()) {
                 setMetaData(QStringLiteral("PrivacyCompactPolicy"), compact.join(QLatin1Char('\n')));
             }
         }
 
         // continue only if we know that we're at least HTTP/1.0
         if (httpRev == HTTP_11 || httpRev == HTTP_10) {
             // let them tell us if we should stay alive or not
             tIt = tokenizer.iterator("connection");
             while (tIt.hasNext()) {
                 QByteArray connection = tIt.next().toLower();
                 if (!(isHttpProxy(m_request.proxyUrl) && !isAutoSsl())) {
                     if (connection.startsWith("close")) { // krazy:exclude=strings
                         m_request.isKeepAlive = false;
                     } else if (connection.startsWith("keep-alive")) { // krazy:exclude=strings
                         m_request.isKeepAlive = true;
                     }
                 }
                 if (connection.startsWith("upgrade")) { // krazy:exclude=strings
                     if (m_request.responseCode == 101) {
                         // Ok, an upgrade was accepted, now we must do it
                         upgradeRequired = true;
                     } else if (upgradeRequired) {  // 426
                         // Nothing to do since we did it above already
                     }
                 }
             }
             // what kind of encoding do we have?  transfer?
             tIt = tokenizer.iterator("transfer-encoding");
             while (tIt.hasNext()) {
                 // If multiple encodings have been applied to an entity, the
                 // transfer-codings MUST be listed in the order in which they
                 // were applied.
                 addEncoding(toQString(tIt.next().trimmed()), m_transferEncodings);
             }
 
             // md5 signature
             tIt = tokenizer.iterator("content-md5");
             if (tIt.hasNext()) {
                 m_contentMD5 = toQString(tIt.next().trimmed());
             }
 
             // *** Responses to the HTTP OPTIONS method follow
             // WebDAV capabilities
             tIt = tokenizer.iterator("dav");
             while (tIt.hasNext()) {
                 m_davCapabilities << toQString(tIt.next());
             }
             // *** Responses to the HTTP OPTIONS method finished
         }
 
         // Now process the HTTP/1.1 upgrade
         QStringList upgradeOffers;
         tIt = tokenizer.iterator("upgrade");
         if (tIt.hasNext()) {
             // Now we have to check to see what is offered for the upgrade
             QString offered = toQString(tIt.next());
             upgradeOffers = offered.split(QRegExp(QStringLiteral("[ \n,\r\t]")), QString::SkipEmptyParts);
         }
         Q_FOREACH (const QString &opt, upgradeOffers) {
             if (opt == QLatin1String("TLS/1.0")) {
                 if (!startSsl() && upgradeRequired) {
                     error(ERR_UPGRADE_REQUIRED, opt);
                     return false;
                 }
             } else if (opt == QLatin1String("HTTP/1.1")) {
                 httpRev = HTTP_11;
             } else if (upgradeRequired) {
                 // we are told to do an upgrade we don't understand
                 error(ERR_UPGRADE_REQUIRED, opt);
                 return false;
             }
         }
 
         // Harvest cookies (mmm, cookie fields!)
         QByteArray cookieStr; // In case we get a cookie.
         tIt = tokenizer.iterator("set-cookie");
         while (tIt.hasNext()) {
             cookieStr += "Set-Cookie: " + tIt.next() + '\n';
         }
         if (!cookieStr.isEmpty()) {
             if ((m_request.cookieMode == HTTPRequest::CookiesAuto) && m_request.useCookieJar) {
                 // Give cookies to the cookiejar.
                 const QString domain = config()->readEntry("cross-domain");
                 if (!domain.isEmpty() && isCrossDomainRequest(m_request.url.host(), domain)) {
                     cookieStr = "Cross-Domain\n" + cookieStr;
                 }
                 addCookies(m_request.url.toString(), cookieStr);
             } else if (m_request.cookieMode == HTTPRequest::CookiesManual) {
                 // Pass cookie to application
                 setMetaData(QStringLiteral("setcookies"), QString::fromUtf8(cookieStr)); // ## is encoding ok?
             }
         }
 
         // We need to reread the header if we got a '100 Continue' or '102 Processing'
         // This may be a non keepalive connection so we handle this kind of loop internally
         if (cont) {
             qCDebug(KIO_HTTP) << "cont; returning to mark try_again";
             goto try_again;
         }
 
         if (!m_isChunked && (m_iSize == NO_SIZE) && m_request.isKeepAlive &&
                 canHaveResponseBody(m_request.responseCode, m_request.method)) {
             qCDebug(KIO_HTTP) << "Ignoring keep-alive: otherwise unable to determine response body length.";
             m_request.isKeepAlive = false;
         }
 
         // TODO cache the proxy auth data (not doing this means a small performance regression for now)
 
         // we may need to send (Proxy or WWW) authorization data
         if ((!m_request.doNotWWWAuthenticate && m_request.responseCode == 401) ||
                 (!m_request.doNotProxyAuthenticate && m_request.responseCode == 407)) {
             authRequiresAnotherRoundtrip = handleAuthenticationHeader(&tokenizer);
             if (m_kioError) {
                 // If error is set, then handleAuthenticationHeader failed.
                 return false;
             }
         } else {
             authRequiresAnotherRoundtrip = false;
         }
 
         QString locationStr;
         // In fact we should do redirection only if we have a redirection response code (300 range)
         tIt = tokenizer.iterator("location");
         if (tIt.hasNext() && m_request.responseCode > 299 && m_request.responseCode < 400) {
             locationStr = QString::fromUtf8(tIt.next().trimmed());
         }
         // We need to do a redirect
         if (!locationStr.isEmpty()) {
             QUrl u = m_request.url.resolved(QUrl(locationStr));
             if (!u.isValid()) {
                 error(ERR_MALFORMED_URL, u.toDisplayString());
                 return false;
             }
 
             // preserve #ref: (bug 124654)
             // if we were at http://host/resource1#ref, we sent a GET for "/resource1"
             // if we got redirected to http://host/resource2, then we have to re-add
             // the fragment:
             // http to https redirection included
             if (m_request.url.hasFragment() && !u.hasFragment() &&
                     (m_request.url.host() == u.host()) &&
                     (m_request.url.scheme() == u.scheme() ||
                     (m_request.url.scheme() ==  QLatin1String("http") && u.scheme() == QLatin1String("https")))) {
                 u.setFragment(m_request.url.fragment());
             }
 
             m_isRedirection = true;
 
             if (!m_request.id.isEmpty()) {
                 sendMetaData();
             }
 
             // If we're redirected to a http:// url, remember that we're doing webdav...
             if (m_protocol == "webdav" || m_protocol == "webdavs") {
                 if (u.scheme() == QLatin1String("http")) {
                     u.setScheme(QStringLiteral("webdav"));
                 } else if (u.scheme() == QLatin1String("https")) {
                     u.setScheme(QStringLiteral("webdavs"));
                 }
 
                 m_request.redirectUrl = u;
             }
 
             qCDebug(KIO_HTTP) << "Re-directing from" << m_request.url << "to" << u;
 
             redirection(u);
 
             // It would be hard to cache the redirection response correctly. The possible benefit
             // is small (if at all, assuming fast disk and slow network), so don't do it.
             cacheFileClose();
             setCacheabilityMetadata(false);
         }
 
         // Inform the job that we can indeed resume...
         if (bCanResume && m_request.offset) {
             //TODO turn off caching???
             canResume();
         } else {
             m_request.offset = 0;
         }
 
         // Correct a few common wrong content encodings
         fixupResponseContentEncoding();
 
         // Correct some common incorrect pseudo-mimetypes
         fixupResponseMimetype();
 
         // parse everything related to expire and other dates, and cache directives; also switch
         // between cache reading and writing depending on cache validation result.
         cacheParseResponseHeader(tokenizer);
     }
 
     if (m_request.cacheTag.ioMode == ReadFromCache) {
         if (m_request.cacheTag.policy == CC_Verify &&
                 m_request.cacheTag.plan(m_maxCacheAge) != CacheTag::UseCached) {
             qCDebug(KIO_HTTP) << "Reading resource from cache even though the cache plan is not "
                                  "UseCached; the server is probably sending wrong expiry information.";
         }
         // parseHeaderFromCache replaces this method in case of cached content
         return parseHeaderFromCache();
     }
 
     if (config()->readEntry("PropagateHttpHeader", false) ||
             m_request.cacheTag.ioMode == WriteToCache) {
         // store header lines if they will be used; note that the tokenizer removing
         // line continuation special cases is probably more good than bad.
         int nextLinePos = 0;
         int prevLinePos = 0;
         bool haveMore = true;
         while (haveMore) {
             haveMore = nextLine(buffer, &nextLinePos, bufPos);
             int prevLineEnd = nextLinePos;
             while (buffer[prevLineEnd - 1] == '\r' || buffer[prevLineEnd - 1] == '\n') {
                 prevLineEnd--;
             }
 
             m_responseHeaders.append(QString::fromLatin1(&buffer[prevLinePos],
                                      prevLineEnd - prevLinePos));
             prevLinePos = nextLinePos;
         }
 
         // IMPORTANT: Do not remove this line because forwardHttpResponseHeader
         // is called below. This line is here to ensure the response headers are
         // available to the client before it receives mimetype information.
         // The support for putting ioslaves on hold in the KIO-QNAM integration
         // will break if this line is removed.
         setMetaData(QStringLiteral("HTTP-Headers"), m_responseHeaders.join(QLatin1Char('\n')));
     }
 
     // Let the app know about the mime-type iff this is not a redirection and
     // the mime-type string is not empty.
     if (!m_isRedirection && m_request.responseCode != 204 &&
             (!m_mimeType.isEmpty() || m_request.method == HTTP_HEAD) &&
             !m_kioError &&
             (m_isLoadingErrorPage || !authRequiresAnotherRoundtrip)) {
         qCDebug(KIO_HTTP) << "Emitting mimetype " << m_mimeType;
         mimeType(m_mimeType);
     }
 
     // IMPORTANT: Do not move the function call below before doing any
     // redirection. Otherwise it might mess up some sites, see BR# 150904.
     forwardHttpResponseHeader();
 
     if (m_request.method == HTTP_HEAD) {
         return true;
     }
 
     return !authRequiresAnotherRoundtrip; // return true if no more credentials need to be sent
 }
 
 void HTTPProtocol::parseContentDisposition(const QString &disposition)
 {
     const QMap<QString, QString> parameters = contentDispositionParser(disposition);
 
     QMap<QString, QString>::const_iterator i = parameters.constBegin();
     while (i != parameters.constEnd()) {
         setMetaData(QLatin1String("content-disposition-") + i.key(), i.value());
         qCDebug(KIO_HTTP) << "Content-Disposition:" << i.key() << "=" << i.value();
         ++i;
     }
 }
 
 void HTTPProtocol::addEncoding(const QString &_encoding, QStringList &encs)
 {
     QString encoding = _encoding.trimmed().toLower();
     // Identity is the same as no encoding
     if (encoding == QLatin1String("identity")) {
         return;
     } else if (encoding == QLatin1String("8bit")) {
         // Strange encoding returned by http://linac.ikp.physik.tu-darmstadt.de
         return;
     } else if (encoding == QLatin1String("chunked")) {
         m_isChunked = true;
         // Anyone know of a better way to handle unknown sizes possibly/ideally with unsigned ints?
         //if ( m_cmd != CMD_COPY )
         m_iSize = NO_SIZE;
     } else if ((encoding == QLatin1String("x-gzip")) || (encoding == QLatin1String("gzip"))) {
         encs.append(QStringLiteral("gzip"));
     } else if ((encoding == QLatin1String("x-bzip2")) || (encoding == QLatin1String("bzip2"))) {
         encs.append(QStringLiteral("bzip2")); // Not yet supported!
     } else if ((encoding == QLatin1String("x-deflate")) || (encoding == QLatin1String("deflate"))) {
         encs.append(QStringLiteral("deflate"));
     } else {
         qCDebug(KIO_HTTP) << "Unknown encoding encountered.  " << "Please write code. Encoding =" << encoding;
     }
 }
 
 void HTTPProtocol::cacheParseResponseHeader(const HeaderTokenizer &tokenizer)
 {
     if (!m_request.cacheTag.useCache) {
         return;
     }
 
     // might have to add more response codes
     if (m_request.responseCode != 200 && m_request.responseCode != 304) {
         return;
     }
 
     m_request.cacheTag.servedDate = QDateTime();
     m_request.cacheTag.lastModifiedDate = QDateTime();
     m_request.cacheTag.expireDate = QDateTime();
 
     const QDateTime currentDate = QDateTime::currentDateTime();
     bool mayCache = m_request.cacheTag.ioMode != NoCache;
 
     TokenIterator tIt = tokenizer.iterator("last-modified");
     if (tIt.hasNext()) {
         m_request.cacheTag.lastModifiedDate =
             QDateTime::fromString(toQString(tIt.next()), Qt::RFC2822Date);
 
         //### might be good to canonicalize the date by using QDateTime::toString()
         if (m_request.cacheTag.lastModifiedDate.isValid()) {
             setMetaData(QStringLiteral("modified"), toQString(tIt.current()));
         }
     }
 
     // determine from available information when the response was served by the origin server
     {
         QDateTime dateHeader;
         tIt = tokenizer.iterator("date");
         if (tIt.hasNext()) {
             dateHeader = QDateTime::fromString(toQString(tIt.next()), Qt::RFC2822Date);
             // -1 on error
         }
 
         qint64 ageHeader = 0;
         tIt = tokenizer.iterator("age");
         if (tIt.hasNext()) {
             ageHeader = tIt.next().toLongLong();
             // 0 on error
         }
 
         if (dateHeader.isValid()) {
             m_request.cacheTag.servedDate = dateHeader;
         } else if (ageHeader) {
             m_request.cacheTag.servedDate = currentDate.addSecs(-ageHeader);
         } else {
             m_request.cacheTag.servedDate = currentDate;
         }
     }
 
     bool hasCacheDirective = false;
     // determine when the response "expires", i.e. becomes stale and needs revalidation
     {
         // (we also parse other cache directives here)
         qint64 maxAgeHeader = 0;
         tIt = tokenizer.iterator("cache-control");
         while (tIt.hasNext()) {
             QByteArray cacheStr = tIt.next().toLower();
             if (cacheStr.startsWith("no-cache") || cacheStr.startsWith("no-store")) { // krazy:exclude=strings
                 // Don't put in cache
                 mayCache = false;
                 hasCacheDirective = true;
             } else if (cacheStr.startsWith("max-age=")) { // krazy:exclude=strings
                 QByteArray ba = cacheStr.mid(qstrlen("max-age=")).trimmed();
                 bool ok = false;
                 maxAgeHeader = ba.toLongLong(&ok);
                 if (ok) {
                     hasCacheDirective = true;
                 }
             }
         }
 
         QDateTime expiresHeader;
         tIt = tokenizer.iterator("expires");
         if (tIt.hasNext()) {
             expiresHeader = QDateTime::fromString(toQString(tIt.next()), Qt::RFC2822Date);
             qCDebug(KIO_HTTP) << "parsed expire date from 'expires' header:" << tIt.current();
         }
 
         if (maxAgeHeader) {
             m_request.cacheTag.expireDate = m_request.cacheTag.servedDate.addSecs(maxAgeHeader);
         } else if (expiresHeader.isValid()) {
             m_request.cacheTag.expireDate = expiresHeader;
         } else {
             // heuristic expiration date
             if (m_request.cacheTag.lastModifiedDate.isValid()) {
                 // expAge is following the RFC 2616 suggestion for heuristic expiration
                 qint64 expAge =
                     (m_request.cacheTag.lastModifiedDate.secsTo(m_request.cacheTag.servedDate)) / 10;
                 // not in the RFC: make sure not to have a huge heuristic cache lifetime
                 expAge = qMin(expAge, qint64(3600 * 24));
                 m_request.cacheTag.expireDate = m_request.cacheTag.servedDate.addSecs(expAge);
             } else {
                 m_request.cacheTag.expireDate = m_request.cacheTag.servedDate.addSecs(DEFAULT_CACHE_EXPIRE);
             }
         }
         // make sure that no future clock monkey business causes the cache entry to un-expire
         if (m_request.cacheTag.expireDate < currentDate) {
             m_request.cacheTag.expireDate.setMSecsSinceEpoch(0);  // January 1, 1970 :)
         }
     }
 
     tIt = tokenizer.iterator("etag");
     if (tIt.hasNext()) {
         QString prevEtag = m_request.cacheTag.etag;
         m_request.cacheTag.etag = toQString(tIt.next());
         if (m_request.cacheTag.etag != prevEtag && m_request.responseCode == 304) {
             qCDebug(KIO_HTTP) << "304 Not Modified but new entity tag - I don't think this is legal HTTP.";
         }
     }
 
     // whoops.. we received a warning
     tIt = tokenizer.iterator("warning");
     if (tIt.hasNext()) {
         //Don't use warning() here, no need to bother the user.
         //Those warnings are mostly about caches.
         infoMessage(toQString(tIt.next()));
     }
 
     // Cache management (HTTP 1.0)
     tIt = tokenizer.iterator("pragma");
     while (tIt.hasNext()) {
         if (tIt.next().toLower().startsWith("no-cache")) { // krazy:exclude=strings
             mayCache = false;
             hasCacheDirective = true;
         }
     }
 
     // The deprecated Refresh Response
     tIt = tokenizer.iterator("refresh");
     if (tIt.hasNext()) {
         mayCache = false;
         setMetaData(QStringLiteral("http-refresh"), toQString(tIt.next().trimmed()));
     }
 
     // We don't cache certain text objects
     if (m_mimeType.startsWith(QLatin1String("text/")) && (m_mimeType != QLatin1String("text/css")) &&
             (m_mimeType != QLatin1String("text/x-javascript")) && !hasCacheDirective) {
         // Do not cache secure pages or pages
         // originating from password protected sites
         // unless the webserver explicitly allows it.
         if (isUsingSsl() || m_wwwAuth) {
             mayCache = false;
         }
     }
 
     // note that we've updated cacheTag, so the plan() is with current data
     if (m_request.cacheTag.plan(m_maxCacheAge) == CacheTag::ValidateCached) {
         qCDebug(KIO_HTTP) << "Cache needs validation";
         if (m_request.responseCode == 304) {
             qCDebug(KIO_HTTP) << "...was revalidated by response code but not by updated expire times. "
                                  "We're going to set the expire date to 60 seconds in the future...";
             m_request.cacheTag.expireDate = currentDate.addSecs(60);
             if (m_request.cacheTag.policy == CC_Verify &&
                     m_request.cacheTag.plan(m_maxCacheAge) != CacheTag::UseCached) {
                 // "apparently" because we /could/ have made an error ourselves, but the errors I
                 // witnessed were all the server's fault.
                 qCDebug(KIO_HTTP) << "this proxy or server apparently sends bogus expiry information.";
             }
         }
     }
 
     // validation handling
     if (mayCache && m_request.responseCode == 200 && !m_mimeType.isEmpty()) {
         qCDebug(KIO_HTTP) << "Cache, adding" << m_request.url;
         // ioMode can still be ReadFromCache here if we're performing a conditional get
         // aka validation
         m_request.cacheTag.ioMode = WriteToCache;
         if (!cacheFileOpenWrite()) {
             qCDebug(KIO_HTTP) << "Error creating cache entry for" << m_request.url << "!";
         }
         m_maxCacheSize = config()->readEntry("MaxCacheSize", DEFAULT_MAX_CACHE_SIZE);
     } else if (m_request.responseCode == 304 && m_request.cacheTag.file) {
         if (!mayCache) {
             qCDebug(KIO_HTTP) << "This webserver is confused about the cacheability of the data it sends.";
         }
         // the cache file should still be open for reading, see satisfyRequestFromCache().
         Q_ASSERT(m_request.cacheTag.file->openMode() == QIODevice::ReadOnly);
         Q_ASSERT(m_request.cacheTag.ioMode == ReadFromCache);
     } else {
         cacheFileClose();
     }
 
     setCacheabilityMetadata(mayCache);
 }
 
 void HTTPProtocol::setCacheabilityMetadata(bool cachingAllowed)
 {
     if (!cachingAllowed) {
         setMetaData(QStringLiteral("no-cache"), QStringLiteral("true"));
         setMetaData(QStringLiteral("expire-date"), QStringLiteral("1")); // Expired
     } else {
         QString tmp;
         tmp.setNum(m_request.cacheTag.expireDate.toTime_t());
         setMetaData(QStringLiteral("expire-date"), tmp);
         // slightly changed semantics from old creationDate, probably more correct now
         tmp.setNum(m_request.cacheTag.servedDate.toTime_t());
         setMetaData(QStringLiteral("cache-creation-date"), tmp);
     }
 }
 
 bool HTTPProtocol::sendCachedBody()
 {
     infoMessage(i18n("Sending data to %1",  m_request.url.host()));
 
     const qint64 size = m_POSTbuf->size();
     const QByteArray cLength = "Content-Length: " + QByteArray::number(size) + "\r\n\r\n";
 
     //qDebug() << "sending cached data (size=" << size << ")";
 
     // Send the content length...
     bool sendOk = (write(cLength.data(), cLength.size()) == (ssize_t) cLength.size());
     if (!sendOk) {
         qCDebug(KIO_HTTP) << "Connection broken when sending " << "content length: (" << m_request.url.host() << ")";
         error(ERR_CONNECTION_BROKEN, m_request.url.host());
         return false;
     }
 
     totalSize(size);
     // Make sure the read head is at the beginning...
     m_POSTbuf->reset();
     KIO::filesize_t totalBytesSent = 0;
 
     // Send the data...
     while (!m_POSTbuf->atEnd()) {
         const QByteArray buffer = m_POSTbuf->read(65536);
         const ssize_t bytesSent = write(buffer.data(), buffer.size());
         if (bytesSent != static_cast<ssize_t>(buffer.size()))  {
             qCDebug(KIO_HTTP) << "Connection broken when sending message body: (" << m_request.url.host() << ")";
             error(ERR_CONNECTION_BROKEN, m_request.url.host());
             return false;
         }
 
         totalBytesSent += bytesSent;
         processedSize(totalBytesSent);
     }
 
     return true;
 }
 
 bool HTTPProtocol::sendBody()
 {
     // If we have cached data, the it is either a repost or a DAV request so send
     // the cached data...
     if (m_POSTbuf) {
         return sendCachedBody();
     }
 
     if (m_iPostDataSize == NO_SIZE) {
         // Try the old approach of retrieving content data from the job
         // before giving up.
         if (retrieveAllData()) {
             return sendCachedBody();
         }
 
         error(ERR_POST_NO_SIZE, m_request.url.host());
         return false;
     }
 
     qCDebug(KIO_HTTP) << "sending data (size=" << m_iPostDataSize << ")";
 
     infoMessage(i18n("Sending data to %1",  m_request.url.host()));
 
     const QByteArray cLength = "Content-Length: " + QByteArray::number(m_iPostDataSize) + "\r\n\r\n";
 
     qCDebug(KIO_HTTP) << cLength.trimmed();
 
     // Send the content length...
     bool sendOk = (write(cLength.data(), cLength.size()) == (ssize_t) cLength.size());
     if (!sendOk) {
         // The server might have closed the connection due to a timeout, or maybe
         // some transport problem arose while the connection was idle.
         if (m_request.isKeepAlive) {
             httpCloseConnection();
             return true; // Try again
         }
 
         qCDebug(KIO_HTTP) << "Connection broken while sending POST content size to" << m_request.url.host();
         error(ERR_CONNECTION_BROKEN, m_request.url.host());
         return false;
     }
 
     // Send the amount
     totalSize(m_iPostDataSize);
 
     // If content-length is 0, then do nothing but simply return true.
     if (m_iPostDataSize == 0) {
         return true;
     }
 
     sendOk = true;
     KIO::filesize_t bytesSent = 0;
 
     while (true) {
         dataReq();
 
         QByteArray buffer;
         const int bytesRead = readData(buffer);
 
         // On done...
         if (bytesRead == 0) {
             sendOk = (bytesSent == m_iPostDataSize);
             break;
         }
 
         // On error return false...
         if (bytesRead < 0) {
             error(ERR_ABORTED, m_request.url.host());
             sendOk = false;
             break;
         }
 
         // Cache the POST data in case of a repost request.
         cachePostData(buffer);
 
         // This will only happen if transmitting the data fails, so we will simply
         // cache the content locally for the potential re-transmit...
         if (!sendOk) {
             continue;
         }
 
         if (write(buffer.data(), bytesRead) == static_cast<ssize_t>(bytesRead)) {
             bytesSent += bytesRead;
             processedSize(bytesSent);  // Send update status...
             continue;
         }
 
         qCDebug(KIO_HTTP) << "Connection broken while sending POST content to" << m_request.url.host();
         error(ERR_CONNECTION_BROKEN, m_request.url.host());
         sendOk = false;
     }
 
     return sendOk;
 }
 
 void HTTPProtocol::httpClose(bool keepAlive)
 {
     qCDebug(KIO_HTTP) << "keepAlive =" << keepAlive;
 
     cacheFileClose();
 
     // Only allow persistent connections for GET requests.
     // NOTE: we might even want to narrow this down to non-form
     // based submit requests which will require a meta-data from
     // khtml.
     if (keepAlive) {
         if (!m_request.keepAliveTimeout) {
             m_request.keepAliveTimeout = DEFAULT_KEEP_ALIVE_TIMEOUT;
         } else if (m_request.keepAliveTimeout > 2 * DEFAULT_KEEP_ALIVE_TIMEOUT) {
             m_request.keepAliveTimeout = 2 * DEFAULT_KEEP_ALIVE_TIMEOUT;
         }
 
         qCDebug(KIO_HTTP) << "keep alive (" << m_request.keepAliveTimeout << ")";
         QByteArray data;
         QDataStream stream(&data, QIODevice::WriteOnly);
         stream << int(99); // special: Close connection
         setTimeoutSpecialCommand(m_request.keepAliveTimeout, data);
 
         return;
     }
 
     httpCloseConnection();
 }
 
 void HTTPProtocol::closeConnection()
 {
     qCDebug(KIO_HTTP);
     httpCloseConnection();
 }
 
 void HTTPProtocol::httpCloseConnection()
 {
     qCDebug(KIO_HTTP);
     m_server.clear();
     disconnectFromHost();
     clearUnreadBuffer();
     setTimeoutSpecialCommand(-1); // Cancel any connection timeout
 }
 
 void HTTPProtocol::slave_status()
 {
     qCDebug(KIO_HTTP);
 
     if (!isConnected()) {
         httpCloseConnection();
     }
 
     slaveStatus(m_server.url.host(), isConnected());
 }
 
 void HTTPProtocol::mimetype(const QUrl &url)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     m_request.method = HTTP_HEAD;
     m_request.cacheTag.policy = CC_Cache;
 
     if (proceedUntilResponseHeader()) {
         httpClose(m_request.isKeepAlive);
         finished();
     }
 
     qCDebug(KIO_HTTP) << m_mimeType;
 }
 
 void HTTPProtocol::special(const QByteArray &data)
 {
     qCDebug(KIO_HTTP);
 
     int tmp;
     QDataStream stream(data);
 
     stream >> tmp;
     switch (tmp) {
     case 1: { // HTTP POST
         QUrl url;
         qint64 size;
         stream >> url >> size;
         post(url, size);
         break;
     }
     case 2: { // cache_update
         QUrl url;
         bool no_cache;
         qint64 expireDate;
         stream >> url >> no_cache >> expireDate;
         if (no_cache) {
             QString filename = cacheFilePathFromUrl(url);
             // there is a tiny risk of deleting the wrong file due to hash collisions here.
             // this is an unimportant performance issue.
             // FIXME on Windows we may be unable to delete the file if open
             QFile::remove(filename);
             finished();
             break;
         }
         // let's be paranoid and inefficient here...
         HTTPRequest savedRequest = m_request;
 
         m_request.url = url;
         if (cacheFileOpenRead()) {
             m_request.cacheTag.expireDate.setTime_t(expireDate);
             cacheFileClose(); // this sends an update command to the cache cleaner process
         }
 
         m_request = savedRequest;
         finished();
         break;
     }
     case 5: { // WebDAV lock
         QUrl url;
         QString scope, type, owner;
         stream >> url >> scope >> type >> owner;
         davLock(url, scope, type, owner);
         break;
     }
     case 6: { // WebDAV unlock
         QUrl url;
         stream >> url;
         davUnlock(url);
         break;
     }
     case 7: { // Generic WebDAV
         QUrl url;
         int method;
         qint64 size;
         stream >> url >> method >> size;
         davGeneric(url, (KIO::HTTP_METHOD) method, size);
         break;
     }
     case 99: { // Close Connection
         httpCloseConnection();
         break;
     }
     default:
         // Some command we don't understand.
         // Just ignore it, it may come from some future version of KDE.
         break;
     }
 }
 
 /**
  * Read a chunk from the data stream.
  */
 int HTTPProtocol::readChunked()
 {
     if ((m_iBytesLeft == 0) || (m_iBytesLeft == NO_SIZE)) {
         // discard CRLF from previous chunk, if any, and read size of next chunk
 
         int bufPos = 0;
         m_receiveBuf.resize(4096);
 
         bool foundCrLf = readDelimitedText(m_receiveBuf.data(), &bufPos, m_receiveBuf.size(), 1);
 
         if (foundCrLf && bufPos == 2) {
             // The previous read gave us the CRLF from the previous chunk. As bufPos includes
             // the trailing CRLF it has to be > 2 to possibly include the next chunksize.
             bufPos = 0;
             foundCrLf = readDelimitedText(m_receiveBuf.data(), &bufPos, m_receiveBuf.size(), 1);
         }
         if (!foundCrLf) {
             qCDebug(KIO_HTTP) << "Failed to read chunk header.";
             return -1;
         }
         Q_ASSERT(bufPos > 2);
 
         long long nextChunkSize = STRTOLL(m_receiveBuf.data(), nullptr, 16);
         if (nextChunkSize < 0) {
             qCDebug(KIO_HTTP) << "Negative chunk size";
             return -1;
         }
         m_iBytesLeft = nextChunkSize;
 
         qCDebug(KIO_HTTP) << "Chunk size =" << m_iBytesLeft << "bytes";
 
         if (m_iBytesLeft == 0) {
             // Last chunk; read and discard chunk trailer.
             // The last trailer line ends with CRLF and is followed by another CRLF
             // so we have CRLFCRLF like at the end of a standard HTTP header.
             // Do not miss a CRLFCRLF spread over two of our 4K blocks: keep three previous bytes.
             //NOTE the CRLF after the chunksize also counts if there is no trailer. Copy it over.
             char trash[4096];
             trash[0] = m_receiveBuf.constData()[bufPos - 2];
             trash[1] = m_receiveBuf.constData()[bufPos - 1];
             int trashBufPos = 2;
             bool done = false;
             while (!done && !m_isEOF) {
                 if (trashBufPos > 3) {
                     // shift everything but the last three bytes out of the buffer
                     for (int i = 0; i < 3; i++) {
                         trash[i] = trash[trashBufPos - 3 + i];
                     }
                     trashBufPos = 3;
                 }
                 done = readDelimitedText(trash, &trashBufPos, 4096, 2);
             }
             if (m_isEOF && !done) {
                 qCDebug(KIO_HTTP) << "Failed to read chunk trailer.";
                 return -1;
             }
 
             return 0;
         }
     }
 
     int bytesReceived = readLimited();
     if (!m_iBytesLeft) {
         m_iBytesLeft = NO_SIZE; // Don't stop, continue with next chunk
     }
     return bytesReceived;
 }
 
 int HTTPProtocol::readLimited()
 {
     if (!m_iBytesLeft) {
         return 0;
     }
 
     m_receiveBuf.resize(4096);
 
     int bytesToReceive;
     if (m_iBytesLeft > KIO::filesize_t(m_receiveBuf.size())) {
         bytesToReceive = m_receiveBuf.size();
     } else {
         bytesToReceive = m_iBytesLeft;
     }
 
     const int bytesReceived = readBuffered(m_receiveBuf.data(), bytesToReceive, false);
 
     if (bytesReceived <= 0) {
         return -1;    // Error: connection lost
     }
 
     m_iBytesLeft -= bytesReceived;
     return bytesReceived;
 }
 
 int HTTPProtocol::readUnlimited()
 {
     if (m_request.isKeepAlive) {
         qCDebug(KIO_HTTP) << "Unbounded datastream on a Keep-alive connection!";
         m_request.isKeepAlive = false;
     }
 
     m_receiveBuf.resize(4096);
 
     int result = readBuffered(m_receiveBuf.data(), m_receiveBuf.size());
     if (result > 0) {
         return result;
     }
 
     m_isEOF = true;
     m_iBytesLeft = 0;
     return 0;
 }
 
 void HTTPProtocol::slotData(const QByteArray &_d)
 {
     if (!_d.size()) {
         m_isEOD = true;
         return;
     }
 
     if (m_iContentLeft != NO_SIZE) {
         if (m_iContentLeft >= KIO::filesize_t(_d.size())) {
             m_iContentLeft -= _d.size();
         } else {
             m_iContentLeft = NO_SIZE;
         }
     }
 
     QByteArray d = _d;
     if (!m_dataInternal) {
         // If a broken server does not send the mime-type,
         // we try to id it from the content before dealing
         // with the content itself.
         if (m_mimeType.isEmpty() && !m_isRedirection &&
                 !(m_request.responseCode >= 300 && m_request.responseCode <= 399)) {
             qCDebug(KIO_HTTP) << "Determining mime-type from content...";
             int old_size = m_mimeTypeBuffer.size();
             m_mimeTypeBuffer.resize(old_size + d.size());
             memcpy(m_mimeTypeBuffer.data() + old_size, d.data(), d.size());
             if ((m_iBytesLeft != NO_SIZE) && (m_iBytesLeft > 0)
                     && (m_mimeTypeBuffer.size() < 1024)) {
                 m_cpMimeBuffer = true;
                 return;   // Do not send up the data since we do not yet know its mimetype!
             }
 
             qCDebug(KIO_HTTP) << "Mimetype buffer size:" << m_mimeTypeBuffer.size();
 
             QMimeDatabase db;
             QMimeType mime = db.mimeTypeForFileNameAndData(m_request.url.adjusted(QUrl::StripTrailingSlash).path(), m_mimeTypeBuffer);
             if (mime.isValid() && !mime.isDefault()) {
                 m_mimeType = mime.name();
                 qCDebug(KIO_HTTP) << "Mimetype from content:" << m_mimeType;
             }
 
             if (m_mimeType.isEmpty()) {
                 m_mimeType = QStringLiteral(DEFAULT_MIME_TYPE);
                 qCDebug(KIO_HTTP) << "Using default mimetype:" <<  m_mimeType;
             }
 
             //### we could also open the cache file here
 
             if (m_cpMimeBuffer) {
                 d.resize(0);
                 d.resize(m_mimeTypeBuffer.size());
                 memcpy(d.data(), m_mimeTypeBuffer.data(), d.size());
             }
             mimeType(m_mimeType);
             m_mimeTypeBuffer.resize(0);
         }
 
         //qDebug() << "Sending data of size" << d.size();
         data(d);
         if (m_request.cacheTag.ioMode == WriteToCache) {
             cacheFileWritePayload(d);
         }
     } else {
         uint old_size = m_webDavDataBuf.size();
         m_webDavDataBuf.resize(old_size + d.size());
         memcpy(m_webDavDataBuf.data() + old_size, d.data(), d.size());
     }
 }
 
 /**
  * This function is our "receive" function.  It is responsible for
  * downloading the message (not the header) from the HTTP server.  It
  * is called either as a response to a client's KIOJob::dataEnd()
  * (meaning that the client is done sending data) or by 'sendQuery()'
  * (if we are in the process of a PUT/POST request). It can also be
  * called by a webDAV function, to receive stat/list/property/etc.
  * data; in this case the data is stored in m_webDavDataBuf.
  */
 bool HTTPProtocol::readBody(bool dataInternal /* = false */)
 {
     // special case for reading cached body since we also do it in this function. oh well.
     if (!canHaveResponseBody(m_request.responseCode, m_request.method) &&
             !(m_request.cacheTag.ioMode == ReadFromCache && m_request.responseCode == 304 &&
               m_request.method != HTTP_HEAD)) {
         return true;
     }
 
     m_isEOD = false;
     // Note that when dataInternal is true, we are going to:
     // 1) save the body data to a member variable, m_webDavDataBuf
     // 2) _not_ advertise the data, speed, size, etc., through the
     //    corresponding functions.
     // This is used for returning data to WebDAV.
     m_dataInternal = dataInternal;
     if (dataInternal) {
         m_webDavDataBuf.clear();
     }
 
     // Check if we need to decode the data.
     // If we are in copy mode, then use only transfer decoding.
     bool useMD5 = !m_contentMD5.isEmpty();
 
     // Deal with the size of the file.
     KIO::filesize_t sz = m_request.offset;
     if (sz) {
         m_iSize += sz;
     }
 
     if (!m_isRedirection) {
         // Update the application with total size except when
         // it is compressed, or when the data is to be handled
         // internally (webDAV).  If compressed we have to wait
         // until we uncompress to find out the actual data size
         if (!dataInternal) {
             if ((m_iSize > 0) && (m_iSize != NO_SIZE)) {
                 totalSize(m_iSize);
                 infoMessage(i18n("Retrieving %1 from %2...", KIO::convertSize(m_iSize),
                                  m_request.url.host()));
             } else {
                 totalSize(0);
             }
         }
 
         if (m_request.cacheTag.ioMode == ReadFromCache) {
             qCDebug(KIO_HTTP) << "reading data from cache...";
 
             m_iContentLeft = NO_SIZE;
 
             QByteArray d;
             while (true) {
                 d = cacheFileReadPayload(MAX_IPC_SIZE);
                 if (d.isEmpty()) {
                     break;
                 }
                 slotData(d);
                 sz += d.size();
                 if (!dataInternal) {
                     processedSize(sz);
                 }
             }
 
             m_receiveBuf.resize(0);
 
             if (!dataInternal) {
                 data(QByteArray());
             }
 
             return true;
         }
     }
 
     if (m_iSize != NO_SIZE) {
         m_iBytesLeft = m_iSize - sz;
     } else {
         m_iBytesLeft = NO_SIZE;
     }
 
     m_iContentLeft = m_iBytesLeft;
 
     if (m_isChunked) {
         m_iBytesLeft = NO_SIZE;
     }
 
     qCDebug(KIO_HTTP) << KIO::number(m_iBytesLeft) << "bytes left.";
 
     // Main incoming loop...  Gather everything while we can...
     m_cpMimeBuffer = false;
     m_mimeTypeBuffer.resize(0);
 
     HTTPFilterChain chain;
 
     // redirection ignores the body
     if (!m_isRedirection) {
         QObject::connect(&chain, &HTTPFilterBase::output,
                          this, &HTTPProtocol::slotData);
     }
     QObject::connect(&chain, &HTTPFilterBase::error,
                      this, &HTTPProtocol::slotFilterError);
 
     // decode all of the transfer encodings
     while (!m_transferEncodings.isEmpty()) {
         QString enc = m_transferEncodings.takeLast();
         if (enc == QLatin1String("gzip")) {
             chain.addFilter(new HTTPFilterGZip);
         } else if (enc == QLatin1String("deflate")) {
             chain.addFilter(new HTTPFilterDeflate);
         }
     }
 
     // From HTTP 1.1 Draft 6:
     // The MD5 digest is computed based on the content of the entity-body,
     // including any content-coding that has been applied, but not including
     // any transfer-encoding applied to the message-body. If the message is
     // received with a transfer-encoding, that encoding MUST be removed
     // prior to checking the Content-MD5 value against the received entity.
     HTTPFilterMD5 *md5Filter = nullptr;
     if (useMD5) {
         md5Filter = new HTTPFilterMD5;
         chain.addFilter(md5Filter);
     }
 
     // now decode all of the content encodings
     // -- Why ?? We are not
     // -- a proxy server, be a client side implementation!!  The applications
     // -- are capable of determining how to extract the encoded implementation.
     // WB: That's a misunderstanding. We are free to remove the encoding.
     // WB: Some braindead www-servers however, give .tgz files an encoding
     // WB: of "gzip" (or even "x-gzip") and a content-type of "applications/tar"
     // WB: They shouldn't do that. We can work around that though...
     while (!m_contentEncodings.isEmpty()) {
         QString enc = m_contentEncodings.takeLast();
         if (enc == QLatin1String("gzip")) {
             chain.addFilter(new HTTPFilterGZip);
         } else if (enc == QLatin1String("deflate")) {
             chain.addFilter(new HTTPFilterDeflate);
         }
     }
 
     while (!m_isEOF) {
         int bytesReceived;
 
         if (m_isChunked) {
             bytesReceived = readChunked();
         } else if (m_iSize != NO_SIZE) {
             bytesReceived = readLimited();
         } else {
             bytesReceived = readUnlimited();
         }
 
         // make sure that this wasn't an error, first
         qCDebug(KIO_HTTP) << "bytesReceived:"
                           << bytesReceived << " m_iSize:" << (int)m_iSize << " Chunked:"
                           << m_isChunked << " BytesLeft:"<< (int)m_iBytesLeft;
         if (bytesReceived == -1) {
             if (m_iContentLeft == 0) {
                 // gzip'ed data sometimes reports a too long content-length.
                 // (The length of the unzipped data)
                 m_iBytesLeft = 0;
                 break;
             }
             // Oh well... log an error and bug out
             qCDebug(KIO_HTTP) << "bytesReceived==-1 sz=" << (int)sz << " Connection broken !";
             error(ERR_CONNECTION_BROKEN, m_request.url.host());
             return false;
         }
 
         // I guess that nbytes == 0 isn't an error.. but we certainly
         // won't work with it!
         if (bytesReceived > 0) {
             // Important: truncate the buffer to the actual size received!
             // Otherwise garbage will be passed to the app
             m_receiveBuf.truncate(bytesReceived);
 
             chain.slotInput(m_receiveBuf);
 
             if (m_kioError) {
                 return false;
             }
 
             sz += bytesReceived;
             if (!dataInternal) {
                 processedSize(sz);
             }
         }
         m_receiveBuf.resize(0); // res
 
         if (m_iBytesLeft && m_isEOD && !m_isChunked) {
             // gzip'ed data sometimes reports a too long content-length.
             // (The length of the unzipped data)
             m_iBytesLeft = 0;
         }
 
         if (m_iBytesLeft == 0) {
             qCDebug(KIO_HTTP) << "EOD received! Left ="<< KIO::number(m_iBytesLeft);
             break;
         }
     }
     chain.slotInput(QByteArray()); // Flush chain.
 
     if (useMD5) {
         QString calculatedMD5 = md5Filter->md5();
 
         if (m_contentMD5 != calculatedMD5)
             qCWarning(KIO_HTTP) << "MD5 checksum MISMATCH! Expected:"
                        << calculatedMD5 << ", Got:" << m_contentMD5;
     }
 
     // Close cache entry
     if (m_iBytesLeft == 0) {
         cacheFileClose(); // no-op if not necessary
     }
 
     if (!dataInternal && sz <= 1) {
         if (m_request.responseCode >= 500 && m_request.responseCode <= 599) {
             error(ERR_INTERNAL_SERVER, m_request.url.host());
             return false;
         } else if (m_request.responseCode >= 400 && m_request.responseCode <= 499 &&
                    !isAuthenticationRequired(m_request.responseCode)) {
             error(ERR_DOES_NOT_EXIST, m_request.url.host());
             return false;
         }
     }
 
     if (!dataInternal && !m_isRedirection) {
         data(QByteArray());
     }
 
     return true;
 }
 
 void HTTPProtocol::slotFilterError(const QString &text)
 {
     error(KIO::ERR_SLAVE_DEFINED, text);
 }
 
 void HTTPProtocol::error(int _err, const QString &_text)
 {
     // Close the connection only on connection errors. Otherwise, honor the
     // keep alive flag.
     if (_err == ERR_CONNECTION_BROKEN || _err == ERR_CANNOT_CONNECT) {
         httpClose(false);
     } else {
         httpClose(m_request.isKeepAlive);
     }
 
     if (!m_request.id.isEmpty()) {
         forwardHttpResponseHeader();
         sendMetaData();
     }
 
     // It's over, we don't need it anymore
     clearPostDataBuffer();
 
     SlaveBase::error(_err, _text);
     m_kioError = _err;
 }
 
 void HTTPProtocol::addCookies(const QString &url, const QByteArray &cookieHeader)
 {
     qlonglong windowId = m_request.windowId.toLongLong();
     QDBusInterface kcookiejar(QStringLiteral("org.kde.kcookiejar5"), QStringLiteral("/modules/kcookiejar"), QStringLiteral("org.kde.KCookieServer"));
     (void)kcookiejar.call(QDBus::NoBlock, QStringLiteral("addCookies"), url,
                           cookieHeader, windowId);
 }
 
 QString HTTPProtocol::findCookies(const QString &url)
 {
     qlonglong windowId = m_request.windowId.toLongLong();
     QDBusInterface kcookiejar(QStringLiteral("org.kde.kcookiejar5"), QStringLiteral("/modules/kcookiejar"), QStringLiteral("org.kde.KCookieServer"));
     QDBusReply<QString> reply = kcookiejar.call(QStringLiteral("findCookies"), url, windowId);
 
     if (!reply.isValid()) {
         qCWarning(KIO_HTTP) << "Can't communicate with kded_kcookiejar!";
         return QString();
     }
     return reply;
 }
 
 /******************************* CACHING CODE ****************************/
 
 HTTPProtocol::CacheTag::CachePlan HTTPProtocol::CacheTag::plan(int maxCacheAge) const
 {
     //notable omission: we're not checking cache file presence or integrity
     switch (policy) {
     case KIO::CC_Refresh:
         // Conditional GET requires the presence of either an ETag or
         // last modified date.
         if (lastModifiedDate.isValid() || !etag.isEmpty()) {
             return ValidateCached;
         }
         break;
     case KIO::CC_Reload:
         return IgnoreCached;
     case KIO::CC_CacheOnly:
     case KIO::CC_Cache:
         return UseCached;
     default:
         break;
     }
 
     Q_ASSERT((policy == CC_Verify || policy == CC_Refresh));
     QDateTime currentDate = QDateTime::currentDateTime();
     if ((servedDate.isValid() && (currentDate > servedDate.addSecs(maxCacheAge))) ||
             (expireDate.isValid() && (currentDate > expireDate))) {
         return ValidateCached;
     }
     return UseCached;
 }
 
 // !START SYNC!
 // The following code should be kept in sync
 // with the code in http_cache_cleaner.cpp
 
 // we use QDataStream; this is just an illustration
 struct BinaryCacheFileHeader {
     quint8 version[2];
     quint8 compression; // for now fixed to 0
     quint8 reserved;    // for now; also alignment
     qint32 useCount;
     qint64 servedDate;
     qint64 lastModifiedDate;
     qint64 expireDate;
     qint32 bytesCached;
     // packed size should be 36 bytes; we explicitly set it here to make sure that no compiler
     // padding ruins it. We write the fields to disk without any padding.
     static const int size = 36;
 };
 
 enum CacheCleanerCommandCode {
     InvalidCommand = 0,
     CreateFileNotificationCommand,
     UpdateFileCommand
 };
 
 // illustration for cache cleaner update "commands"
 struct CacheCleanerCommand {
     BinaryCacheFileHeader header;
     quint32 commandCode;
     // filename in ASCII, binary isn't worth the coding and decoding
     quint8 filename[s_hashedUrlNibbles];
 };
 
 QByteArray HTTPProtocol::CacheTag::serialize() const
 {
     QByteArray ret;
     QDataStream stream(&ret, QIODevice::WriteOnly);
     stream << quint8('A');
     stream << quint8('\n');
     stream << quint8(0);
     stream << quint8(0);
 
     stream << fileUseCount;
 
     stream << servedDate.toMSecsSinceEpoch() / 1000;
     stream << lastModifiedDate.toMSecsSinceEpoch() / 1000;
     stream << expireDate.toMSecsSinceEpoch() / 1000;
 
     stream << bytesCached;
     Q_ASSERT(ret.size() == BinaryCacheFileHeader::size);
     return ret;
 }
 
 static bool compareByte(QDataStream *stream, quint8 value)
 {
     quint8 byte;
     *stream >> byte;
     return byte == value;
 }
 
 // If starting a new file cacheFileWriteVariableSizeHeader() must have been called *before*
 // calling this! This is to fill in the headerEnd field.
 // If the file is not new headerEnd has already been read from the file and in fact the variable
 // size header *may* not be rewritten because a size change would mess up the file layout.
 bool HTTPProtocol::CacheTag::deserialize(const QByteArray &d)
 {
     if (d.size() != BinaryCacheFileHeader::size) {
         return false;
     }
     QDataStream stream(d);
     stream.setVersion(QDataStream::Qt_4_5);
 
     bool ok = true;
     ok = ok && compareByte(&stream, 'A');
     ok = ok && compareByte(&stream, '\n');
     ok = ok && compareByte(&stream, 0);
     ok = ok && compareByte(&stream, 0);
     if (!ok) {
         return false;
     }
 
     stream >> fileUseCount;
 
     qint64 servedDateMs;
     stream >> servedDateMs;
     servedDate = QDateTime::fromMSecsSinceEpoch(servedDateMs * 1000);
 
     qint64 lastModifiedDateMs;
     stream >> lastModifiedDateMs;
     lastModifiedDate = QDateTime::fromMSecsSinceEpoch(lastModifiedDateMs * 1000);
 
     qint64 expireDateMs;
     stream >> expireDateMs;
     expireDate = QDateTime::fromMSecsSinceEpoch(expireDateMs * 1000);
 
     stream >> bytesCached;
 
     return true;
 }
 
 /* Text part of the header, directly following the binary first part:
 URL\n
 etag\n
 mimetype\n
 header line\n
 header line\n
 ...
 \n
 */
 
 static QUrl storableUrl(const QUrl &url)
 {
     QUrl ret(url);
     ret.setPassword(QString());
     ret.setFragment(QString());
     return ret;
 }
 
 static void writeLine(QIODevice *dev, const QByteArray &line)
 {
     static const char linefeed = '\n';
     dev->write(line);
     dev->write(&linefeed, 1);
 }
 
 void HTTPProtocol::cacheFileWriteTextHeader()
 {
     QFile *&file = m_request.cacheTag.file;
     Q_ASSERT(file);
     Q_ASSERT(file->openMode() & QIODevice::WriteOnly);
 
     file->seek(BinaryCacheFileHeader::size);
     writeLine(file, storableUrl(m_request.url).toEncoded());
     writeLine(file, m_request.cacheTag.etag.toLatin1());
     writeLine(file, m_mimeType.toLatin1());
     writeLine(file, m_responseHeaders.join(QLatin1Char('\n')).toLatin1());
     // join("\n") adds no \n to the end, but writeLine() does.
     // Add another newline to mark the end of text.
     writeLine(file, QByteArray());
 }
 
 static bool readLineChecked(QIODevice *dev, QByteArray *line)
 {
     *line = dev->readLine(MAX_IPC_SIZE);
     // if nothing read or the line didn't fit into 8192 bytes(!)
     if (line->isEmpty() || !line->endsWith('\n')) {
         return false;
     }
     // we don't actually want the newline!
     line->chop(1);
     return true;
 }
 
 bool HTTPProtocol::cacheFileReadTextHeader1(const QUrl &desiredUrl)
 {
     QFile *&file = m_request.cacheTag.file;
     Q_ASSERT(file);
     Q_ASSERT(file->openMode() == QIODevice::ReadOnly);
 
     QByteArray readBuf;
     bool ok = readLineChecked(file, &readBuf);
     if (storableUrl(desiredUrl).toEncoded() != readBuf) {
         qCDebug(KIO_HTTP) << "You have witnessed a very improbable hash collision!";
         return false;
     }
 
     ok = ok && readLineChecked(file, &readBuf);
     m_request.cacheTag.etag = toQString(readBuf);
 
     return ok;
 }
 
 bool HTTPProtocol::cacheFileReadTextHeader2()
 {
     QFile *&file = m_request.cacheTag.file;
     Q_ASSERT(file);
     Q_ASSERT(file->openMode() == QIODevice::ReadOnly);
 
     bool ok = true;
     QByteArray readBuf;
 #ifndef NDEBUG
     // we assume that the URL and etag have already been read
     qint64 oldPos = file->pos();
     file->seek(BinaryCacheFileHeader::size);
     ok = ok && readLineChecked(file, &readBuf);
     ok = ok && readLineChecked(file, &readBuf);
     Q_ASSERT(file->pos() == oldPos);
 #endif
     ok = ok && readLineChecked(file, &readBuf);
     m_mimeType = toQString(readBuf);
 
     m_responseHeaders.clear();
     // read as long as no error and no empty line found
     while (true) {
         ok = ok && readLineChecked(file, &readBuf);
         if (ok && !readBuf.isEmpty()) {
             m_responseHeaders.append(toQString(readBuf));
         } else {
             break;
         }
     }
     return ok; // it may still be false ;)
 }
 
 static QString filenameFromUrl(const QUrl &url)
 {
     QCryptographicHash hash(QCryptographicHash::Sha1);
     hash.addData(storableUrl(url).toEncoded());
     return toQString(hash.result().toHex());
 }
 
 QString HTTPProtocol::cacheFilePathFromUrl(const QUrl &url) const
 {
     QString filePath = m_strCacheDir;
     if (!filePath.endsWith(QLatin1Char('/'))) {
         filePath.append(QLatin1Char('/'));
     }
     filePath.append(filenameFromUrl(url));
     return filePath;
 }
 
 bool HTTPProtocol::cacheFileOpenRead()
 {
     qCDebug(KIO_HTTP);
     QString filename = cacheFilePathFromUrl(m_request.url);
 
     QFile *&file = m_request.cacheTag.file;
     if (file) {
         qCDebug(KIO_HTTP) << "File unexpectedly open; old file is" << file->fileName() << "new name is" << filename;
         Q_ASSERT(file->fileName() == filename);
     }
     Q_ASSERT(!file);
     file = new QFile(filename);
     if (file->open(QIODevice::ReadOnly)) {
         QByteArray header = file->read(BinaryCacheFileHeader::size);
         if (!m_request.cacheTag.deserialize(header)) {
             qCDebug(KIO_HTTP) << "Cache file header is invalid.";
 
             file->close();
         }
     }
 
     if (file->isOpen() && !cacheFileReadTextHeader1(m_request.url)) {
         file->close();
     }
 
     if (!file->isOpen()) {
         cacheFileClose();
         return false;
     }
     return true;
 }
 
 bool HTTPProtocol::cacheFileOpenWrite()
 {
     qCDebug(KIO_HTTP);
     QString filename = cacheFilePathFromUrl(m_request.url);
 
     // if we open a cache file for writing while we have a file open for reading we must have
     // found out that the old cached content is obsolete, so delete the file.
     QFile *&file = m_request.cacheTag.file;
     if (file) {
         // ensure that the file is in a known state - either open for reading or null
         Q_ASSERT(!qobject_cast<QTemporaryFile *>(file));
         Q_ASSERT((file->openMode() & QIODevice::WriteOnly) == 0);
         Q_ASSERT(file->fileName() == filename);
         qCDebug(KIO_HTTP) << "deleting expired cache entry and recreating.";
         file->remove();
         delete file;
         file = nullptr;
     }
 
     // note that QTemporaryFile will automatically append random chars to filename
     file = new QTemporaryFile(filename);
     file->open(QIODevice::WriteOnly);
 
     // if we have started a new file we have not initialized some variables from disk data.
     m_request.cacheTag.fileUseCount = 0;  // the file has not been *read* yet
     m_request.cacheTag.bytesCached = 0;
 
     if ((file->openMode() & QIODevice::WriteOnly) == 0) {
         qCDebug(KIO_HTTP) << "Could not open file for writing: QTemporaryFile(" << filename << ")"
                           << "due to error" << file->error();
         cacheFileClose();
         return false;
     }
     return true;
 }
 
 static QByteArray makeCacheCleanerCommand(const HTTPProtocol::CacheTag &cacheTag,
         CacheCleanerCommandCode cmd)
 {
     QByteArray ret = cacheTag.serialize();
     QDataStream stream(&ret, QIODevice::ReadWrite);
     stream.setVersion(QDataStream::Qt_4_5);
 
     stream.skipRawData(BinaryCacheFileHeader::size);
     // append the command code
     stream << quint32(cmd);
     // append the filename
     QString fileName = cacheTag.file->fileName();
     int basenameStart = fileName.lastIndexOf(QLatin1Char('/')) + 1;
     const QByteArray baseName = fileName.midRef(basenameStart, s_hashedUrlNibbles).toLatin1();
     stream.writeRawData(baseName.constData(), baseName.size());
 
     Q_ASSERT(ret.size() == BinaryCacheFileHeader::size + sizeof(quint32) + s_hashedUrlNibbles);
     return ret;
 }
 
 //### not yet 100% sure when and when not to call this
 void HTTPProtocol::cacheFileClose()
 {
     qCDebug(KIO_HTTP);
 
     QFile *&file = m_request.cacheTag.file;
     if (!file) {
         return;
     }
 
     m_request.cacheTag.ioMode = NoCache;
 
     QByteArray ccCommand;
     QTemporaryFile *tempFile = qobject_cast<QTemporaryFile *>(file);
 
     if (file->openMode() & QIODevice::WriteOnly) {
         Q_ASSERT(tempFile);
 
         if (m_request.cacheTag.bytesCached && !m_kioError) {
             QByteArray header = m_request.cacheTag.serialize();
             tempFile->seek(0);
             tempFile->write(header);
 
             ccCommand = makeCacheCleanerCommand(m_request.cacheTag, CreateFileNotificationCommand);
 
             QString oldName = tempFile->fileName();
             QString newName = oldName;
             int basenameStart = newName.lastIndexOf(QLatin1Char('/')) + 1;
             // remove the randomized name part added by QTemporaryFile
             newName.chop(newName.length() - basenameStart - s_hashedUrlNibbles);
             qCDebug(KIO_HTTP) << "Renaming temporary file" << oldName << "to" << newName;
 
             // on windows open files can't be renamed
             tempFile->setAutoRemove(false);
             delete tempFile;
             file = nullptr;
 
             if (!QFile::rename(oldName, newName)) {
                 // ### currently this hides a minor bug when force-reloading a resource. We
                 //     should not even open a new file for writing in that case.
                 qCDebug(KIO_HTTP) << "Renaming temporary file failed, deleting it instead.";
                 QFile::remove(oldName);
                 ccCommand.clear();  // we have nothing of value to tell the cache cleaner
             }
         } else {
             // oh, we've never written payload data to the cache file.
             // the temporary file is closed and removed and no proper cache entry is created.
         }
     } else if (file->openMode() == QIODevice::ReadOnly) {
         Q_ASSERT(!tempFile);
         ccCommand = makeCacheCleanerCommand(m_request.cacheTag, UpdateFileCommand);
     }
     delete file;
     file = nullptr;
 
     if (!ccCommand.isEmpty()) {
         sendCacheCleanerCommand(ccCommand);
     }
 }
 
 void HTTPProtocol::sendCacheCleanerCommand(const QByteArray &command)
 {
     qCDebug(KIO_HTTP);
     if (!qEnvironmentVariableIsEmpty("KIO_DISABLE_CACHE_CLEANER")) // for autotests
         return;
     Q_ASSERT(command.size() == BinaryCacheFileHeader::size + s_hashedUrlNibbles + sizeof(quint32));
     if (m_cacheCleanerConnection.state() != QLocalSocket::ConnectedState) {
         QString socketFileName = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation) + QLatin1Char('/') + QLatin1String("kio_http_cache_cleaner");
         m_cacheCleanerConnection.connectToServer(socketFileName, QIODevice::WriteOnly);
 
         if (m_cacheCleanerConnection.state() == QLocalSocket::UnconnectedState) {
             // An error happened.
             // Most likely the cache cleaner is not running, let's start it.
 
             // search paths
             const QStringList searchPaths = QStringList()
                 << QCoreApplication::applicationDirPath() // then look where our application binary is located
                 << QLibraryInfo::location(QLibraryInfo::LibraryExecutablesPath) // look where libexec path is (can be set in qt.conf)
                 << QFile::decodeName(CMAKE_INSTALL_FULL_LIBEXECDIR_KF5); // look at our installation location
             const QString exe = QStandardPaths::findExecutable(QStringLiteral("kio_http_cache_cleaner"), searchPaths);
             if (exe.isEmpty()) {
                 qCWarning(KIO_HTTP) << "kio_http_cache_cleaner not found in" << searchPaths;
                 return;
             }
             qCDebug(KIO_HTTP) << "starting" << exe;
             QProcess::startDetached(exe, QStringList());
 
             for (int i = 0 ; i < 30 && m_cacheCleanerConnection.state() == QLocalSocket::UnconnectedState; ++i) {
                 // Server is not listening yet; let's hope it does so under 3 seconds
                 QThread::msleep(100);
                 m_cacheCleanerConnection.connectToServer(socketFileName, QIODevice::WriteOnly);
                 if (m_cacheCleanerConnection.state() != QLocalSocket::UnconnectedState) {
                     break; // connecting or connected, sounds good
                 }
             }
         }
 
         if (!m_cacheCleanerConnection.waitForConnected(1500)) {
             // updating the stats is not vital, so we just give up.
             qCDebug(KIO_HTTP) << "Could not connect to cache cleaner, not updating stats of this cache file.";
             return;
         }
         qCDebug(KIO_HTTP) << "Successfully connected to cache cleaner.";
     }
 
     Q_ASSERT(m_cacheCleanerConnection.state() == QLocalSocket::ConnectedState);
     m_cacheCleanerConnection.write(command);
     m_cacheCleanerConnection.flush();
 }
 
 QByteArray HTTPProtocol::cacheFileReadPayload(int maxLength)
 {
     Q_ASSERT(m_request.cacheTag.file);
     Q_ASSERT(m_request.cacheTag.ioMode == ReadFromCache);
     Q_ASSERT(m_request.cacheTag.file->openMode() == QIODevice::ReadOnly);
     QByteArray ret = m_request.cacheTag.file->read(maxLength);
     if (ret.isEmpty()) {
         cacheFileClose();
     }
     return ret;
 }
 
 void HTTPProtocol::cacheFileWritePayload(const QByteArray &d)
 {
     if (!m_request.cacheTag.file) {
         return;
     }
 
     // If the file being downloaded is so big that it exceeds the max cache size,
     // do not cache it! See BR# 244215. NOTE: this can be improved upon in the
     // future...
     if (m_iSize >= KIO::filesize_t(m_maxCacheSize * 1024)) {
         qCDebug(KIO_HTTP) << "Caching disabled because content size is too big.";
         cacheFileClose();
         return;
     }
 
     Q_ASSERT(m_request.cacheTag.ioMode == WriteToCache);
     Q_ASSERT(m_request.cacheTag.file->openMode() & QIODevice::WriteOnly);
 
     if (d.isEmpty()) {
         cacheFileClose();
     }
 
     //TODO: abort if file grows too big!
 
     // write the variable length text header as soon as we start writing to the file
     if (!m_request.cacheTag.bytesCached) {
         cacheFileWriteTextHeader();
     }
     m_request.cacheTag.bytesCached += d.size();
     m_request.cacheTag.file->write(d);
 }
 
 void HTTPProtocol::cachePostData(const QByteArray &data)
 {
     if (!m_POSTbuf) {
         m_POSTbuf = createPostBufferDeviceFor(qMax(m_iPostDataSize, static_cast<KIO::filesize_t>(data.size())));
         if (!m_POSTbuf) {
             return;
         }
     }
 
     m_POSTbuf->write(data.constData(), data.size());
 }
 
 void HTTPProtocol::clearPostDataBuffer()
 {
     if (!m_POSTbuf) {
         return;
     }
 
     delete m_POSTbuf;
     m_POSTbuf = nullptr;
 }
 
 bool HTTPProtocol::retrieveAllData()
 {
     if (!m_POSTbuf) {
         m_POSTbuf = createPostBufferDeviceFor(s_MaxInMemPostBufSize + 1);
     }
 
     if (!m_POSTbuf) {
         error(ERR_OUT_OF_MEMORY, m_request.url.host());
         return false;
     }
 
     while (true) {
         dataReq();
         QByteArray buffer;
         const int bytesRead = readData(buffer);
 
         if (bytesRead < 0) {
             error(ERR_ABORTED, m_request.url.host());
             return false;
         }
 
         if (bytesRead == 0) {
             break;
         }
 
         m_POSTbuf->write(buffer.constData(), buffer.size());
     }
 
     return true;
 }
 
 // The above code should be kept in sync
 // with the code in http_cache_cleaner.cpp
 // !END SYNC!
 
 //**************************  AUTHENTICATION CODE ********************/
 
 QString HTTPProtocol::authenticationHeader()
 {
     QByteArray ret;
 
     // If the internal meta-data "cached-www-auth" is set, then check for cached
     // authentication data and preemptively send the authentication header if a
     // matching one is found.
     if (!m_wwwAuth && config()->readEntry("cached-www-auth", false)) {
         KIO::AuthInfo authinfo;
         authinfo.url = m_request.url;
         authinfo.realmValue = config()->readEntry("www-auth-realm", QString());
         // If no realm metadata, then make sure path matching is turned on.
         authinfo.verifyPath = (authinfo.realmValue.isEmpty());
 
         const bool useCachedAuth = (m_request.responseCode == 401 || !config()->readEntry("no-preemptive-auth-reuse", false));
 
         if (useCachedAuth && checkCachedAuthentication(authinfo)) {
             const QByteArray cachedChallenge = config()->readEntry("www-auth-challenge", QByteArray());
             if (!cachedChallenge.isEmpty()) {
                 m_wwwAuth = KAbstractHttpAuthentication::newAuth(cachedChallenge, config());
                 if (m_wwwAuth) {
                     qCDebug(KIO_HTTP) << "creating www authentication header from cached info";
                     m_wwwAuth->setChallenge(cachedChallenge, m_request.url, m_request.sentMethodString);
                     m_wwwAuth->generateResponse(authinfo.username, authinfo.password);
                 }
             }
         }
     }
 
     // If the internal meta-data "cached-proxy-auth" is set, then check for cached
     // authentication data and preemptively send the authentication header if a
     // matching one is found.
     if (!m_proxyAuth && config()->readEntry("cached-proxy-auth", false)) {
         KIO::AuthInfo authinfo;
         authinfo.url = m_request.proxyUrl;
         authinfo.realmValue = config()->readEntry("proxy-auth-realm", QString());
         // If no realm metadata, then make sure path matching is turned on.
         authinfo.verifyPath = (authinfo.realmValue.isEmpty());
 
         if (checkCachedAuthentication(authinfo)) {
             const QByteArray cachedChallenge = config()->readEntry("proxy-auth-challenge", QByteArray());
             if (!cachedChallenge.isEmpty()) {
                 m_proxyAuth = KAbstractHttpAuthentication::newAuth(cachedChallenge, config());
                 if (m_proxyAuth) {
                     qCDebug(KIO_HTTP) << "creating proxy authentication header from cached info";
                     m_proxyAuth->setChallenge(cachedChallenge, m_request.proxyUrl, m_request.sentMethodString);
                     m_proxyAuth->generateResponse(authinfo.username, authinfo.password);
                 }
             }
         }
     }
 
     // the authentication classes don't know if they are for proxy or webserver authentication...
     if (m_wwwAuth && !m_wwwAuth->isError()) {
         ret += "Authorization: " + m_wwwAuth->headerFragment();
     }
 
     if (m_proxyAuth && !m_proxyAuth->isError()) {
         ret += "Proxy-Authorization: " + m_proxyAuth->headerFragment();
     }
 
     return toQString(ret); // ## encoding ok?
 }
 
 static QString protocolForProxyType(QNetworkProxy::ProxyType type)
 {
     switch (type) {
     case QNetworkProxy::DefaultProxy:
         break;
     case QNetworkProxy::Socks5Proxy:
         return QStringLiteral("socks");
     case QNetworkProxy::NoProxy:
         break;
     case QNetworkProxy::HttpProxy:
     case QNetworkProxy::HttpCachingProxy:
     case QNetworkProxy::FtpCachingProxy:
         break;
     }
 
     return QStringLiteral("http");
 }
 
 void HTTPProtocol::proxyAuthenticationForSocket(const QNetworkProxy &proxy, QAuthenticator *authenticator)
 {
     qCDebug(KIO_HTTP) << "realm:" << authenticator->realm() << "user:" << authenticator->user();
 
     // Set the proxy URL...
     m_request.proxyUrl.setScheme(protocolForProxyType(proxy.type()));
     m_request.proxyUrl.setUserName(proxy.user());
     m_request.proxyUrl.setHost(proxy.hostName());
     m_request.proxyUrl.setPort(proxy.port());
 
     AuthInfo info;
     info.url = m_request.proxyUrl;
     info.realmValue = authenticator->realm();
     info.username = authenticator->user();
     info.verifyPath = info.realmValue.isEmpty();
 
     const bool haveCachedCredentials = checkCachedAuthentication(info);
     const bool retryAuth = (m_socketProxyAuth != nullptr);
 
     // if m_socketProxyAuth is a valid pointer then authentication has been attempted before,
     // and it was not successful. see below and saveProxyAuthenticationForSocket().
     if (!haveCachedCredentials || retryAuth) {
         // Save authentication info if the connection succeeds. We need to disconnect
         // this after saving the auth data (or an error) so we won't save garbage afterwards!
         connect(socket(), SIGNAL(connected()),
                 this, SLOT(saveProxyAuthenticationForSocket()));
         //### fillPromptInfo(&info);
         info.prompt = i18n("You need to supply a username and a password for "
                            "the proxy server listed below before you are allowed "
                            "to access any sites.");
         info.keepPassword = true;
         info.commentLabel = i18n("Proxy:");
         info.comment = i18n("<b>%1</b> at <b>%2</b>", info.realmValue.toHtmlEscaped(), m_request.proxyUrl.host());
 
         const QString errMsg((retryAuth ? i18n("Proxy Authentication Failed.") : QString()));
 
         const int errorCode = openPasswordDialogV2(info, errMsg);
         if (errorCode) {
             qCDebug(KIO_HTTP) << "proxy auth cancelled by user, or communication error";
             error(errorCode, QString());
             delete m_proxyAuth;
             m_proxyAuth = nullptr;
             return;
         }
     }
     authenticator->setUser(info.username);
     authenticator->setPassword(info.password);
     authenticator->setOption(QStringLiteral("keepalive"), info.keepPassword);
 
     if (m_socketProxyAuth) {
         *m_socketProxyAuth = *authenticator;
     } else {
         m_socketProxyAuth = new QAuthenticator(*authenticator);
     }
 
     if (!m_request.proxyUrl.userName().isEmpty()) {
         m_request.proxyUrl.setUserName(info.username);
     }
 }
 
 void HTTPProtocol::saveProxyAuthenticationForSocket()
 {
     qCDebug(KIO_HTTP) << "Saving authenticator";
     disconnect(socket(), SIGNAL(connected()),
                this, SLOT(saveProxyAuthenticationForSocket()));
     Q_ASSERT(m_socketProxyAuth);
     if (m_socketProxyAuth) {
         qCDebug(KIO_HTTP) << "realm:" << m_socketProxyAuth->realm() << "user:" << m_socketProxyAuth->user();
         KIO::AuthInfo a;
         a.verifyPath = true;
         a.url = m_request.proxyUrl;
         a.realmValue = m_socketProxyAuth->realm();
         a.username = m_socketProxyAuth->user();
         a.password = m_socketProxyAuth->password();
         a.keepPassword = m_socketProxyAuth->option(QStringLiteral("keepalive")).toBool();
         cacheAuthentication(a);
     }
     delete m_socketProxyAuth;
     m_socketProxyAuth = nullptr;
 }
 
 void HTTPProtocol::saveAuthenticationData()
 {
     KIO::AuthInfo authinfo;
     bool alreadyCached = false;
     KAbstractHttpAuthentication *auth = nullptr;
     switch (m_request.prevResponseCode) {
     case 401:
         auth = m_wwwAuth;
         alreadyCached = config()->readEntry("cached-www-auth", false);
         break;
     case 407:
         auth = m_proxyAuth;
         alreadyCached = config()->readEntry("cached-proxy-auth", false);
         break;
     default:
         Q_ASSERT(false); // should never happen!
     }
 
     // Prevent recaching of the same credentials over and over again.
     if (auth && (!auth->realm().isEmpty() || !alreadyCached)) {
         auth->fillKioAuthInfo(&authinfo);
         if (auth == m_wwwAuth) {
             setMetaData(QStringLiteral("{internal~currenthost}cached-www-auth"), QStringLiteral("true"));
             if (!authinfo.realmValue.isEmpty()) {
                 setMetaData(QStringLiteral("{internal~currenthost}www-auth-realm"), authinfo.realmValue);
             }
             if (!authinfo.digestInfo.isEmpty()) {
                 setMetaData(QStringLiteral("{internal~currenthost}www-auth-challenge"), authinfo.digestInfo);
             }
         } else {
             setMetaData(QStringLiteral("{internal~allhosts}cached-proxy-auth"), QStringLiteral("true"));
             if (!authinfo.realmValue.isEmpty()) {
                 setMetaData(QStringLiteral("{internal~allhosts}proxy-auth-realm"), authinfo.realmValue);
             }
             if (!authinfo.digestInfo.isEmpty()) {
                 setMetaData(QStringLiteral("{internal~allhosts}proxy-auth-challenge"), authinfo.digestInfo);
             }
         }
 
         qCDebug(KIO_HTTP) << "Cache authentication info ?" << authinfo.keepPassword;
 
         if (authinfo.keepPassword) {
             cacheAuthentication(authinfo);
             qCDebug(KIO_HTTP) << "Cached authentication for" << m_request.url;
         }
     }
     // Update our server connection state which includes www and proxy username and password.
     m_server.updateCredentials(m_request);
 }
 
 bool HTTPProtocol::handleAuthenticationHeader(const HeaderTokenizer *tokenizer)
 {
     KIO::AuthInfo authinfo;
     QList<QByteArray> authTokens;
     KAbstractHttpAuthentication **auth;
     QList<QByteArray> *blacklistedAuthTokens;
     TriedCredentials *triedCredentials;
 
     if (m_request.responseCode == 401) {
         auth = &m_wwwAuth;
         blacklistedAuthTokens = &m_blacklistedWwwAuthMethods;
         triedCredentials = &m_triedWwwCredentials;
         authTokens = tokenizer->iterator("www-authenticate").all();
         authinfo.url = m_request.url;
         authinfo.username = m_server.url.userName();
         authinfo.prompt = i18n("You need to supply a username and a "
                                "password to access this site.");
         authinfo.commentLabel = i18n("Site:");
     } else {
         // make sure that the 407 header hasn't escaped a lower layer when it shouldn't.
         // this may break proxy chains which were never tested anyway, and AFAIK they are
         // rare to nonexistent in the wild.
         Q_ASSERT(QNetworkProxy::applicationProxy().type() == QNetworkProxy::NoProxy);
         auth = &m_proxyAuth;
         blacklistedAuthTokens = &m_blacklistedProxyAuthMethods;
         triedCredentials = &m_triedProxyCredentials;
         authTokens = tokenizer->iterator("proxy-authenticate").all();
         authinfo.url = m_request.proxyUrl;
         authinfo.username = m_request.proxyUrl.userName();
         authinfo.prompt = i18n("You need to supply a username and a password for "
                                "the proxy server listed below before you are allowed "
                                "to access any sites.");
         authinfo.commentLabel = i18n("Proxy:");
     }
 
     bool authRequiresAnotherRoundtrip = false;
 
     // Workaround brain dead server responses that violate the spec and
     // incorrectly return a 401/407 without the required WWW/Proxy-Authenticate
     // header fields. See bug 215736...
     if (!authTokens.isEmpty()) {
         QString errorMsg;
         authRequiresAnotherRoundtrip = true;
 
         if (m_request.responseCode == m_request.prevResponseCode && *auth) {
             // Authentication attempt failed. Retry...
             if ((*auth)->wasFinalStage()) {
                 errorMsg = (m_request.responseCode == 401 ?
                             i18n("Authentication Failed.") :
                             i18n("Proxy Authentication Failed."));
                 // The authentication failed in its final stage. If the chosen method didn't use a password or
                 // if it failed with both the supplied and prompted password then blacklist this method and try
                 // again with another one if possible.
                 if (!(*auth)->needCredentials() || *triedCredentials > JobCredentials) {
                     QByteArray scheme((*auth)->scheme().trimmed());
                     qCDebug(KIO_HTTP) << "Blacklisting auth" << scheme;
                     blacklistedAuthTokens->append(scheme);
                 }
                 delete *auth;
                 *auth = nullptr;
             } else {     // Create authentication header
                 //  WORKAROUND: The following piece of code prevents brain dead IIS
                 // servers that send back multiple "WWW-Authenticate" headers from
                 // screwing up our authentication logic during the challenge
                 // phase (Type 2) of NTLM authentication.
                 QMutableListIterator<QByteArray> it(authTokens);
                 const QByteArray authScheme((*auth)->scheme().trimmed());
                 while (it.hasNext()) {
                     if (qstrnicmp(authScheme.constData(), it.next().constData(), authScheme.length()) != 0) {
                         it.remove();
                     }
                 }
             }
         }
 
         QList<QByteArray>::iterator it = authTokens.begin();
         while (it != authTokens.end()) {
             QByteArray scheme = *it;
             // Separate the method name from any additional parameters (for ex. nonce or realm).
             int index = it->indexOf(' ');
             if (index > 0) {
                 scheme.truncate(index);
             }
 
             if (blacklistedAuthTokens->contains(scheme)) {
                 it = authTokens.erase(it);
             } else {
                 it++;
             }
         }
 
     try_next_auth_scheme:
         QByteArray bestOffer = KAbstractHttpAuthentication::bestOffer(authTokens);
         if (*auth) {
             const QByteArray authScheme((*auth)->scheme().trimmed());
             if (qstrnicmp(authScheme.constData(), bestOffer.constData(), authScheme.length()) != 0) {
                 // huh, the strongest authentication scheme offered has changed.
                 delete *auth;
                 *auth = nullptr;
             }
         }
 
         if (!(*auth)) {
             *auth = KAbstractHttpAuthentication::newAuth(bestOffer, config());
         }
 
         if (*auth) {
             qCDebug(KIO_HTTP) << "Trying authentication scheme:" << (*auth)->scheme();
 
             // remove trailing space from the method string, or digest auth will fail
             (*auth)->setChallenge(bestOffer, authinfo.url, m_request.sentMethodString);
 
             QString username, password;
             bool generateAuthHeader = true;
             if ((*auth)->needCredentials()) {
                 // use credentials supplied by the application if available
                 if (!m_request.url.userName().isEmpty() && !m_request.url.password().isEmpty() &&
                     *triedCredentials == NoCredentials) {
                     username = m_request.url.userName();
                     password = m_request.url.password();
                     // don't try this password any more
                     *triedCredentials = JobCredentials;
                 } else {
                     // try to get credentials from kpasswdserver's cache, then try asking the user.
                     authinfo.verifyPath = false; // we have realm, no path based checking please!
                     authinfo.realmValue = (*auth)->realm();
                     if (authinfo.realmValue.isEmpty() && !(*auth)->supportsPathMatching()) {
                         authinfo.realmValue = QLatin1String((*auth)->scheme());
                     }
 
                     // Save the current authinfo url because it can be modified by the call to
                     // checkCachedAuthentication. That way we can restore it if the call
                     // modified it.
                     const QUrl reqUrl = authinfo.url;
                     if (!errorMsg.isEmpty() || !checkCachedAuthentication(authinfo)) {
                         // Reset url to the saved url...
                         authinfo.url = reqUrl;
                         authinfo.keepPassword = true;
                         authinfo.comment = i18n("<b>%1</b> at <b>%2</b>",
                                                 authinfo.realmValue.toHtmlEscaped(), authinfo.url.host());
 
                         const int errorCode = openPasswordDialogV2(authinfo, errorMsg);
                         if (errorCode) {
                             generateAuthHeader = false;
                             authRequiresAnotherRoundtrip = false;
                             if (!sendErrorPageNotification()) {
                                 error(ERR_ACCESS_DENIED, reqUrl.host());
                             }
                             qCDebug(KIO_HTTP) << "looks like the user canceled the authentication dialog";
                             delete *auth;
                             *auth = nullptr;
                         }
                         *triedCredentials = UserInputCredentials;
                     } else {
                         *triedCredentials = CachedCredentials;
                     }
                     username = authinfo.username;
                     password = authinfo.password;
                 }
             }
 
             if (generateAuthHeader) {
                 (*auth)->generateResponse(username, password);
                 (*auth)->setCachePasswordEnabled(authinfo.keepPassword);
 
                 qCDebug(KIO_HTTP) << "isError=" << (*auth)->isError()
                                   << "needCredentials=" << (*auth)->needCredentials()
                                   << "forceKeepAlive=" << (*auth)->forceKeepAlive()
                                   << "forceDisconnect=" << (*auth)->forceDisconnect();
 
                 if ((*auth)->isError()) {
                     QByteArray scheme((*auth)->scheme().trimmed());
                     qCDebug(KIO_HTTP) << "Blacklisting auth" << scheme;
                     authTokens.removeOne(scheme);
                     blacklistedAuthTokens->append(scheme);
                     if (!authTokens.isEmpty()) {
                         goto try_next_auth_scheme;
                     } else {
                         if (!sendErrorPageNotification()) {
                             error(ERR_UNSUPPORTED_ACTION, i18n("Authorization failed."));
                         }
                         authRequiresAnotherRoundtrip = false;
                     }
                     //### return false; ?
                 } else if ((*auth)->forceKeepAlive()) {
                     //### think this through for proxied / not proxied
                     m_request.isKeepAlive = true;
                 } else if ((*auth)->forceDisconnect()) {
                     //### think this through for proxied / not proxied
                     m_request.isKeepAlive = false;
                     httpCloseConnection();
                 }
             }
         } else {
             authRequiresAnotherRoundtrip = false;
             if (!sendErrorPageNotification()) {
                 error(ERR_UNSUPPORTED_ACTION, i18n("Unknown Authorization method."));
             }
         }
     }
 
     return authRequiresAnotherRoundtrip;
 }
 
 void HTTPProtocol::copyPut(const QUrl& src, const QUrl& dest, JobFlags flags)
 {
     qCDebug(KIO_HTTP) << src << "->" << dest;
 
     if (!maybeSetRequestUrl(dest)) {
         return;
     }
 
     resetSessionSettings();
 
     if (!(flags & KIO::Overwrite)) {
         // check to make sure this host supports WebDAV
         if (!davHostOk()) {
             return;
         }
 
         // Checks if the destination exists and return an error if it does.
         if (!davStatDestination()) {
             return;
         }
     }
 
     m_POSTbuf = new QFile (src.toLocalFile());
     if (!m_POSTbuf->open(QFile::ReadOnly)) {
         error(KIO::ERR_CANNOT_OPEN_FOR_READING, QString());
         return;
     }
 
     m_request.method = HTTP_PUT;
     m_request.cacheTag.policy = CC_Reload;
 
     proceedUntilResponseContent();
 }
 
 bool HTTPProtocol::davStatDestination()
 {
     const QByteArray request ("<?xml version=\"1.0\" encoding=\"utf-8\" ?>"
                               "<D:propfind xmlns:D=\"DAV:\"><D:prop>"
                               "<D:creationdate/>"
                               "<D:getcontentlength/>"
                               "<D:displayname/>"
                               "<D:resourcetype/>"
                               "</D:prop></D:propfind>");
     davSetRequest(request);
 
     // WebDAV Stat or List...
     m_request.method = DAV_PROPFIND;
     m_request.url.setQuery(QString());
     m_request.cacheTag.policy = CC_Reload;
     m_request.davData.depth = 0;
 
     proceedUntilResponseContent(true);
 
     if (!m_request.isKeepAlive) {
         httpCloseConnection(); // close connection if server requested it.
         m_request.isKeepAlive = true; // reset the keep alive flag.
     }
 
     if (m_request.responseCode == 207) {
         error(ERR_FILE_ALREADY_EXIST, QString());
         return false;
     }
 
     // force re-authentication...
     delete m_wwwAuth;
     m_wwwAuth = nullptr;
 
     return true;
 }
 
 void HTTPProtocol::fileSystemFreeSpace(const QUrl &url)
 {
     qCDebug(KIO_HTTP) << url;
 
     if (!maybeSetRequestUrl(url)) {
         return;
     }
     resetSessionSettings();
 
     davStatList(url);
 }
 
 void HTTPProtocol::virtual_hook(int id, void *data)
 {
     switch(id) {
     case SlaveBase::GetFileSystemFreeSpace: {
         QUrl *url = static_cast<QUrl *>(data);
         fileSystemFreeSpace(*url);
     }   break;
     default:
         SlaveBase::virtual_hook(id, data);
     }
 }
 
 // needed for JSON file embedding
 #include "http.moc"
diff --git a/src/ioslaves/http/kcookiejar/kcookiejar.cpp b/src/ioslaves/http/kcookiejar/kcookiejar.cpp
index 8b65c667..40e69f78 100644
--- a/src/ioslaves/http/kcookiejar/kcookiejar.cpp
+++ b/src/ioslaves/http/kcookiejar/kcookiejar.cpp
@@ -1,1612 +1,1612 @@
 /* This file is part of the KDE File Manager
 
    Copyright (C) 1998-2000 Waldo Bastian (bastian@kde.org)
    Copyright (C) 2000,2001 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 Cookies
 
 //
 // The cookie protocol is a mess. RFC2109 is a joke since nobody seems to
 // use it. Apart from that it is badly written.
 // We try to implement Netscape Cookies and try to behave us according to
 // RFC2109 as much as we can.
 //
 // We assume cookies do not contain any spaces (Netscape spec.)
 // According to RFC2109 this is allowed though.
 //
 
 #include "kcookiejar.h"
 
 #include <kconfig.h>
 #include <kconfiggroup.h>
 #include <qsavefile.h>
 #include <QDebug>
 
 #include <QString>
 #include <QFile>
 #include <QDir>
 #include <QRegExp>
 #include <QTextStream>
 #include <QLocale>
 #include <QUrl>
 
 Q_LOGGING_CATEGORY(KIO_COOKIEJAR, "kf5.kio.cookiejar")
 
 // BR87227
 // Waba: Should the number of cookies be limited?
 // I am not convinced of the need of such limit
 // Mozilla seems to limit to 20 cookies / domain
 // but it is unclear which policy it uses to expire
 // cookies when it exceeds that amount
 #undef MAX_COOKIE_LIMIT
 
 #define MAX_COOKIES_PER_HOST 25
 #define READ_BUFFER_SIZE 8192
 #define IP_ADDRESS_EXPRESSION "(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
 
 // Note with respect to QLatin1String( )....
 // Cookies are stored as 8 bit data and passed to kio_http as Latin1
 // regardless of their actual encoding.
 #define QL1S(x)   QLatin1String(x)
 #define QL1C(x)   QLatin1Char(x)
 
 static QString removeWeekday(const QString &value)
 {
     const int index = value.indexOf(QL1C(' '));
     if (index > -1) {
         int pos = 0;
         const QStringRef weekday = value.leftRef(index);
         const QLocale cLocale = QLocale::c();
         for (int i = 1; i < 8; ++i) {
             // No need to check for long names since the short names are
             // prefixes of the long names
             if (weekday.startsWith(cLocale.dayName(i, QLocale::ShortFormat), Qt::CaseInsensitive)) {
                 pos = index + 1;
                 break;
             }
         }
         if (pos > 0) {
             return value.mid(pos);
         }
     }
     return value;
 }
 
 static QDateTime parseDate(const QString &_value)
 {
     // Handle sites sending invalid weekday as part of the date. #298660
     const QString value(removeWeekday(_value));
 
     // Check if expiration date matches RFC dates as specified under
     // RFC 2616 sec 3.3.1 & RFC 6265 sec 4.1.1
     QDateTime dt = QDateTime::fromString(value, Qt::RFC2822Date);
 
     if (!dt.isValid()) {
         static const char *const date_formats[] = {
             // Other formats documented in RFC 2616 sec 3.3.1
             // Note: the RFC says timezone information MUST be "GMT", hence the hardcoded timezone string
             "MMM dd HH:mm:ss yyyy",       /* ANSI C's asctime() format (#145244): Jan 01 00:00:00 1970 GMT */
             "dd-MMM-yy HH:mm:ss 'GMT'",   /* RFC 850 date: 06-Dec-39 00:30:42 GMT */
             // Non-standard formats
             "MMM dd yyyy HH:mm:ss",       /* A variation on ANSI C format seen @ amazon.com: Jan 01 1970 00:00:00 GMT */
             "dd-MMM-yyyy HH:mm:ss 'GMT'", /* cookies.test: Y2K38 problem: 06-Dec-2039 00:30:42 GMT */
             "MMM dd HH:mm:ss yyyy 'GMT'", /* cookies.test: Non-standard expiration dates: Sep 12 07:00:00 2020 GMT */
             "MMM dd yyyy HH:mm:ss 'GMT'", /* cookies.test: Non-standard expiration dates: Sep 12 2020 07:00:00 GMT */
             nullptr
         };
 
         // Only English month names are allowed, thus use the C locale.
         const QLocale cLocale = QLocale::c();
         for (int i = 0; date_formats[i]; ++i) {
             dt = cLocale.toDateTime(value, QL1S(date_formats[i]));
             if (dt.isValid()) {
                 dt.setTimeSpec(Qt::UTC);
                 break;
             }
         }
     }
 
     return dt.toUTC();  // Per RFC 2616 sec 3.3.1 always convert to UTC.
 }
 
 static qint64 toEpochSecs(const QDateTime &dt)
 {
     return (dt.toMSecsSinceEpoch() / 1000); // convert to seconds...
 }
 
 static qint64 epoch()
 {
     return toEpochSecs(QDateTime::currentDateTimeUtc());
 }
 
 QString KCookieJar::adviceToStr(KCookieAdvice _advice)
 {
     switch (_advice) {
     case KCookieAccept: return QStringLiteral("Accept");
     case KCookieAcceptForSession: return QStringLiteral("AcceptForSession");
     case KCookieReject: return QStringLiteral("Reject");
     case KCookieAsk: return QStringLiteral("Ask");
     default: return QStringLiteral("Dunno");
     }
 }
 
 KCookieAdvice KCookieJar::strToAdvice(const QString &_str)
 {
     if (_str.isEmpty()) {
         return KCookieDunno;
     }
 
     QString advice = _str.toLower();
 
     if (advice == QL1S("accept")) {
         return KCookieAccept;
     } else if (advice == QL1S("acceptforsession")) {
         return KCookieAcceptForSession;
     } else if (advice == QL1S("reject")) {
         return KCookieReject;
     } else if (advice == QL1S("ask")) {
         return KCookieAsk;
     }
 
     return KCookieDunno;
 }
 
 // KHttpCookie
 ///////////////////////////////////////////////////////////////////////////
 
 //
 // Cookie constructor
 //
 KHttpCookie::KHttpCookie(const QString &_host,
                          const QString &_domain,
                          const QString &_path,
                          const QString &_name,
                          const QString &_value,
                          qint64 _expireDate,
                          int _protocolVersion,
                          bool _secure,
                          bool _httpOnly,
                          bool _explicitPath) :
     mHost(_host),
     mDomain(_domain),
     mPath(_path.isEmpty() ? QString() : _path),
     mName(_name),
     mValue(_value),
     mExpireDate(_expireDate),
     mProtocolVersion(_protocolVersion),
     mSecure(_secure),
     mCrossDomain(false),
     mHttpOnly(_httpOnly),
     mExplicitPath(_explicitPath),
     mUserSelectedAdvice(KCookieDunno)
 {
 }
 
 //
 // Checks if a cookie has been expired
 //
 bool KHttpCookie::isExpired(qint64 currentDate) const
 {
     if (currentDate == -1) {
         currentDate = epoch();
     }
 
     return (mExpireDate != 0) && (mExpireDate < currentDate);
 }
 
 //
 // Returns a string for a HTTP-header
 //
 QString KHttpCookie::cookieStr(bool useDOMFormat) const
 {
     QString result;
 
     if (useDOMFormat || (mProtocolVersion == 0)) {
         if (mName.isEmpty()) {
             result = mValue;
         } else {
             result = mName + QL1C('=') + mValue;
         }
     } else {
         result = mName + QL1C('=') + mValue;
         if (mExplicitPath) {
             result += QL1S("; $Path=\"") + mPath + QL1C('"');
         }
         if (!mDomain.isEmpty()) {
             result += QL1S("; $Domain=\"") + mDomain + QL1C('"');
         }
         if (!mPorts.isEmpty()) {
             if (mPorts.length() == 2 && mPorts.at(0) == -1) {
                 result += QL1S("; $Port");
             } else {
                 QString portNums;
                 Q_FOREACH (int port, mPorts) {
                     portNums += QString::number(port) + QL1C(' ');
                 }
                 result += QL1S("; $Port=\"") + portNums.trimmed() + QL1C('"');
             }
         }
     }
     return result;
 }
 
 //
 // Returns whether this cookie should be send to this location.
 bool KHttpCookie::match(const QString &fqdn, const QStringList &domains,
                         const QString &path, int port) const
 {
     // Cookie domain match check
     if (mDomain.isEmpty()) {
         if (fqdn != mHost) {
             return false;
         }
     } else if (!domains.contains(mDomain)) {
         if (mDomain[0] == QL1C('.')) {
             return false;
         }
 
         // Maybe the domain needs an extra dot.
         const QString domain = QL1C('.') + mDomain;
         if (!domains.contains(domain))
             if (fqdn != mDomain) {
                 return false;
             }
     } else if (mProtocolVersion != 0 && port != -1 &&
                !mPorts.isEmpty() && !mPorts.contains(port)) {
         return false;
     }
 
     // Cookie path match check
     if (mPath.isEmpty()) {
         return true;
     }
 
     // According to the netscape spec http://www.acme.com/foobar,
     // http://www.acme.com/foo.bar and http://www.acme.com/foo/bar
     // should all match http://www.acme.com/foo...
     // We only match http://www.acme.com/foo/bar
     if (path.startsWith(mPath) &&
             (
                 (path.length() == mPath.length()) ||   // Paths are exact match
                 mPath.endsWith(QL1C('/')) ||          // mPath ended with a slash
                 (path[mPath.length()] == QL1C('/'))        // A slash follows
             )) {
         return true;    // Path of URL starts with cookie-path
     }
 
     return false;
 }
 
 // KCookieJar
 ///////////////////////////////////////////////////////////////////////////
 
 //
 // Constructs a new cookie jar
 //
 // One jar should be enough for all cookies.
 //
 KCookieJar::KCookieJar()
 {
     m_globalAdvice = KCookieDunno;
     m_configChanged = false;
     m_cookiesChanged = false;
 
     KConfig cfg(QStringLiteral("kf5/kcookiejar/domain_info"), KConfig::NoGlobals, QStandardPaths::GenericDataLocation);
     KConfigGroup group(&cfg, QString());
     m_gTLDs = QSet<QString>::fromList(group.readEntry("gTLDs", QStringList()));
     m_twoLevelTLD = QSet<QString>::fromList(group.readEntry("twoLevelTLD", QStringList()));
 }
 
 //
 // Destructs the cookie jar
 //
 // Poor little cookies, they will all be eaten by the cookie monster!
 //
 KCookieJar::~KCookieJar()
 {
     qDeleteAll(m_cookieDomains);
     // Not much to do here
 }
 
 // cookiePtr is modified: the window ids of the existing cookie in the list are added to it
 static void removeDuplicateFromList(KHttpCookieList *list, KHttpCookie &cookiePtr, bool nameMatchOnly = false, bool updateWindowId = false)
 {
     QString domain1 = cookiePtr.domain();
     if (domain1.isEmpty()) {
         domain1 = cookiePtr.host();
     }
 
     QMutableListIterator<KHttpCookie> cookieIterator(*list);
     while (cookieIterator.hasNext()) {
         const KHttpCookie &cookie = cookieIterator.next();
         QString domain2 = cookie.domain();
         if (domain2.isEmpty()) {
             domain2 = cookie.host();
         }
 
         if (cookiePtr.name() == cookie.name() &&
                 (nameMatchOnly || (domain1 == domain2 && cookiePtr.path() == cookie.path()))) {
             if (updateWindowId) {
                 Q_FOREACH (WId windowId, cookie.windowIds()) {
                     if (windowId && (!cookiePtr.windowIds().contains(windowId))) {
                         cookiePtr.windowIds().append(windowId);
                     }
                 }
             }
             cookieIterator.remove();
             break;
         }
     }
 }
 
 //
 // Looks for cookies in the cookie jar which are appropriate for _url.
 // Returned is a string containing all appropriate cookies in a format
 // which can be added to a HTTP-header without any additional processing.
 //
 QString KCookieJar::findCookies(const QString &_url, bool useDOMFormat, WId windowId, KHttpCookieList *pendingCookies)
 {
     QString cookieStr, fqdn, path;
     QStringList domains;
     int port = -1;
 
     if (!parseUrl(_url, fqdn, path, &port)) {
         return cookieStr;
     }
 
     const bool secureRequest = (_url.startsWith(QL1S("https://"), Qt::CaseInsensitive) ||
                                 _url.startsWith(QL1S("webdavs://"), Qt::CaseInsensitive));
     if (port == -1) {
         port = (secureRequest ? 443 : 80);
     }
 
     extractDomains(fqdn, domains);
 
     KHttpCookieList allCookies;
     for (QStringList::ConstIterator it = domains.constBegin(), itEnd = domains.constEnd();; ++it) {
         KHttpCookieList *cookieList = nullptr;
         if (it == itEnd) {
             cookieList = pendingCookies; // Add pending cookies
             pendingCookies = nullptr;
             if (!cookieList) {
                 break;
             }
         } else {
             if ((*it).isNull()) {
                 cookieList = m_cookieDomains.value(QL1S(""));
             } else {
                 cookieList = m_cookieDomains.value(*it);
             }
 
             if (!cookieList) {
                 continue;    // No cookies for this domain
             }
         }
 
         QMutableListIterator<KHttpCookie> cookieIt(*cookieList);
         while (cookieIt.hasNext()) {
             KHttpCookie &cookie = cookieIt.next();
             if (cookieAdvice(cookie) == KCookieReject) {
                 continue;
             }
 
             if (!cookie.match(fqdn, domains, path, port)) {
                 continue;
             }
 
             if (cookie.isSecure() && !secureRequest) {
                 continue;
             }
 
             if (cookie.isHttpOnly() && useDOMFormat) {
                 continue;
             }
 
             // Do not send expired cookies.
             if (cookie.isExpired()) {
                 // NOTE: there is no need to delete the cookie here because the
                 // cookieserver will invoke its saveCookieJar function as a result
                 // of the state change below. This will then result in the cookie
                 // being deleting at that point.
                 m_cookiesChanged = true;
                 continue;
             }
 
             if (windowId && (cookie.windowIds().indexOf(windowId) == -1)) {
                 cookie.windowIds().append(windowId);
             }
 
             if (it == itEnd) { // Only needed when processing pending cookies
                 removeDuplicateFromList(&allCookies, cookie);
             }
 
             allCookies.append(cookie);
         }
 
         if (it == itEnd) {
             break;    // Finished.
         }
     }
 
     int protVersion = 0;
     Q_FOREACH (const KHttpCookie &cookie, allCookies) {
         if (cookie.protocolVersion() > protVersion) {
             protVersion = cookie.protocolVersion();
         }
     }
 
     if (!allCookies.isEmpty()) {
         if (!useDOMFormat) {
             cookieStr = QStringLiteral("Cookie: ");
         }
 
         if (protVersion > 0) {
             cookieStr = cookieStr + QStringLiteral("$Version=") + QString::number(protVersion) + QStringLiteral("; ");
         }
 
         Q_FOREACH (const KHttpCookie &cookie, allCookies) {
             cookieStr = cookieStr + cookie.cookieStr(useDOMFormat) + QStringLiteral("; ");
         }
 
         cookieStr.chop(2); // Remove the trailing '; '
     }
 
     return cookieStr;
 }
 
 //
 // This function parses a string like 'my_name="my_value";' and returns
 // 'my_name' in Name and 'my_value' in Value.
 //
 // A pointer to the end of the parsed part is returned.
 // This pointer points either to:
 // '\0' - The end of the string has reached.
 // ';'  - Another my_name="my_value" pair follows
 // ','  - Another cookie follows
 // '\n' - Another header follows
 static const char *parseNameValue(const char *header,
                                   QString &Name,
                                   QString &Value,
                                   bool keepQuotes = false,
                                   bool rfcQuotes = false)
 {
     const char *s = header;
     // Parse 'my_name' part
     for (; (*s != '='); s++) {
         if ((*s == '\0') || (*s == ';') || (*s == '\n')) {
             // No '=' sign -> use string as the value, name is empty
             // (behavior found in Mozilla and IE)
             Name = QL1S("");
             Value = QL1S(header);
             Value.truncate(s - header);
             Value = Value.trimmed();
             return s;
         }
     }
 
     Name = QL1S(header);
     Name.truncate(s - header);
     Name = Name.trimmed();
 
     // *s == '='
     s++;
 
     // Skip any whitespace
     for (; (*s == ' ') || (*s == '\t'); s++) {
         if ((*s == '\0') || (*s == ';') || (*s == '\n')) {
             // End of Name
             Value = QLatin1String("");
             return s;
         }
     }
 
     if ((rfcQuotes || !keepQuotes) && (*s == '\"')) {
         // Parse '"my_value"' part (quoted value)
         if (keepQuotes) {
             header = s++;
         } else {
             header = ++s;    // skip "
         }
         for (; (*s != '\"'); s++) {
             if ((*s == '\0') || (*s == '\n')) {
                 // End of Name
                 Value = QL1S(header);
                 Value.truncate(s - header);
                 return s;
             }
         }
         Value = QL1S(header);
         // *s == '\"';
         if (keepQuotes) {
             Value.truncate(++s - header);
         } else {
             Value.truncate(s++ - header);
         }
 
         // Skip any remaining garbage
         for (;; s++) {
             if ((*s == '\0') || (*s == ';') || (*s == '\n')) {
                 break;
             }
         }
     } else {
         // Parse 'my_value' part (unquoted value)
         header = s;
         while ((*s != '\0') && (*s != ';') && (*s != '\n')) {
             s++;
         }
         // End of Name
         Value = QL1S(header);
         Value.truncate(s - header);
         Value = Value.trimmed();
     }
     return s;
 
 }
 
 void KCookieJar::stripDomain(const QString &_fqdn, QString &_domain) const
 {
     QStringList domains;
     extractDomains(_fqdn, domains);
     if (domains.count() > 3) {
         _domain = domains[3];
-    } else if (domains.count() > 0) {
+    } else if (!domains.isEmpty()) {
         _domain = domains[0];
     } else {
         _domain = QL1S("");
     }
 }
 
 QString KCookieJar::stripDomain(const KHttpCookie &cookie) const
 {
     QString domain; // We file the cookie under this domain.
     if (cookie.domain().isEmpty()) {
         stripDomain(cookie.host(), domain);
     } else {
         domain = cookie.domain();
     }
     return domain;
 }
 
 bool KCookieJar::parseUrl(const QString &_url, QString &_fqdn, QString &_path, int *port)
 {
     QUrl kurl(_url);
     if (!kurl.isValid() || kurl.scheme().isEmpty()) {
         return false;
     }
 
     _fqdn = kurl.host().toLower();
     // Cookie spoofing protection.  Since there is no way a path separator,
     // a space or the escape encoding character is allowed in the hostname
     // according to RFC 2396, reject attempts to include such things there!
     if (_fqdn.contains(QL1C('/')) || _fqdn.contains(QL1C('%'))) {
         return false;    // deny everything!!
     }
 
     // Set the port number from the protocol when one is found...
     if (port) {
         *port = kurl.port();
     }
 
     _path = kurl.path();
     if (_path.isEmpty()) {
         _path = QStringLiteral("/");
     }
 
     return true;
 }
 
 // not static because it uses m_twoLevelTLD
 void KCookieJar::extractDomains(const QString &_fqdn,
                                 QStringList &_domains) const
 {
     if (_fqdn.isEmpty()) {
         _domains.append(QStringLiteral("localhost"));
         return;
     }
 
     // Return numeric IPv6 addresses as is...
     if (_fqdn[0] == QL1C('[')) {
         _domains.append(_fqdn);
         return;
     }
     // Return numeric IPv4 addresses as is...
     if (_fqdn[0] >= QL1C('0') && _fqdn[0] <= QL1C('9') && _fqdn.indexOf(QRegExp(QStringLiteral(IP_ADDRESS_EXPRESSION))) > -1) {
         _domains.append(_fqdn);
         return;
     }
 
     // Always add the FQDN at the start of the list for
     // hostname == cookie-domainname checks!
     _domains.append(_fqdn);
     _domains.append(QL1C('.') + _fqdn);
 
     QStringList partList = _fqdn.split(QL1C('.'), QString::SkipEmptyParts);
 
-    if (partList.count()) {
+    if (!partList.isEmpty()) {
         partList.erase(partList.begin());    // Remove hostname
     }
 
     while (partList.count()) {
 
         if (partList.count() == 1) {
             break;    // We only have a TLD left.
         }
 
         if ((partList.count() == 2) && m_twoLevelTLD.contains(partList[1].toLower())) {
             // This domain uses two-level TLDs in the form xxxx.yy
             break;
         }
 
         if ((partList.count() == 2) && (partList[1].length() == 2)) {
             // If this is a TLD, we should stop. (e.g. co.uk)
             // We assume this is a TLD if it ends with .xx.yy or .x.yy
             if (partList[0].length() <= 2) {
                 break;    // This is a TLD.
             }
 
             // Catch some TLDs that we miss with the previous check
             // e.g. com.au, org.uk, mil.co
             if (m_gTLDs.contains(partList[0].toLower())) {
                 break;
             }
         }
 
         QString domain = partList.join(QLatin1Char('.'));
         _domains.append(domain);
         _domains.append(QL1C('.') + domain);
         partList.erase(partList.begin()); // Remove part
     }
 }
 
 //
 // This function parses cookie_headers and returns a linked list of
 // KHttpCookie objects for all cookies found in cookie_headers.
 // If no cookies could be found 0 is returned.
 //
 // cookie_headers should be a concatenation of all lines of a HTTP-header
 // which start with "Set-Cookie". The lines should be separated by '\n's.
 //
 KHttpCookieList KCookieJar::makeCookies(const QString &_url,
                                         const QByteArray &cookie_headers,
                                         WId windowId)
 {
     QString fqdn, path;
 
     if (!parseUrl(_url, fqdn, path)) {
         return KHttpCookieList();    // Error parsing _url
     }
 
     QString Name, Value;
     KHttpCookieList cookieList, cookieList2;
 
     bool isRFC2965 = false;
     bool crossDomain = false;
     const char *cookieStr = cookie_headers.constData();
 
     QString defaultPath;
     const int index = path.lastIndexOf(QL1C('/'));
     if (index > 0) {
         defaultPath = path.left(index);
     }
 
     // Check for cross-domain flag from kio_http
     if (qstrncmp(cookieStr, "Cross-Domain\n", 13) == 0) {
         cookieStr += 13;
         crossDomain = true;
     }
 
     //  The hard stuff :)
     for (;;) {
         // check for "Set-Cookie"
         if (qstrnicmp(cookieStr, "Set-Cookie:", 11) == 0) {
             cookieStr = parseNameValue(cookieStr + 11, Name, Value, true);
 
             // Host = FQDN
             // Default domain = ""
             // Default path according to rfc2109
 
             KHttpCookie cookie(fqdn, QL1S(""), defaultPath, Name, Value);
             if (windowId) {
                 cookie.mWindowIds.append(windowId);
             }
             cookie.mCrossDomain = crossDomain;
 
             // Insert cookie in chain
             cookieList.append(cookie);
         } else if (qstrnicmp(cookieStr, "Set-Cookie2:", 12) == 0) {
             // Attempt to follow rfc2965
             isRFC2965 = true;
             cookieStr = parseNameValue(cookieStr + 12, Name, Value, true, true);
 
             // Host = FQDN
             // Default domain = ""
             // Default path according to rfc2965
 
             KHttpCookie cookie(fqdn, QL1S(""), defaultPath, Name, Value);
             if (windowId) {
                 cookie.mWindowIds.append(windowId);
             }
             cookie.mCrossDomain = crossDomain;
 
             // Insert cookie in chain
             cookieList2.append(cookie);
         } else {
             // This is not the start of a cookie header, skip till next line.
             while (*cookieStr && *cookieStr != '\n') {
                 cookieStr++;
             }
 
             if (*cookieStr == '\n') {
                 cookieStr++;
             }
 
             if (!*cookieStr) {
                 break;    // End of cookie_headers
             } else {
                 continue;    // end of this header, continue with next.
             }
         }
 
         while ((*cookieStr == ';') || (*cookieStr == ' ')) {
             cookieStr++;
 
             // Name-Value pair follows
             cookieStr = parseNameValue(cookieStr, Name, Value);
             KHttpCookie &lastCookie = (isRFC2965 ? cookieList2.last() : cookieList.last());
 
             if (Name.compare(QL1S("domain"), Qt::CaseInsensitive) == 0) {
                 QString dom = Value.toLower();
                 // RFC2965 3.2.2: If an explicitly specified value does not
                 // start with a dot, the user agent supplies a leading dot
                 if (dom.length() > 0 && dom[0] != QL1C('.')) {
                     dom.prepend(QL1C('.'));
                 }
                 // remove a trailing dot
                 if (dom.length() > 2 && dom[dom.length() - 1] == QL1C('.')) {
                     dom.chop(1);
                 }
 
                 if (dom.count(QL1C('.')) > 1 || dom == QLatin1String(".local")) {
                     lastCookie.mDomain = dom;
                 }
             } else if (Name.compare(QL1S("max-age"), Qt::CaseInsensitive) == 0) {
                 int max_age = Value.toInt();
                 if (max_age == 0) {
                     lastCookie.mExpireDate = 1;
                 } else {
                     lastCookie.mExpireDate = toEpochSecs(QDateTime::currentDateTimeUtc().addSecs(max_age));
                 }
             } else if (Name.compare(QL1S("expires"), Qt::CaseInsensitive) == 0) {
                 const QDateTime dt = parseDate(Value);
 
                 if (dt.isValid()) {
                     lastCookie.mExpireDate = toEpochSecs(dt);
                     if (lastCookie.mExpireDate == 0) {
                         lastCookie.mExpireDate = 1;
                     }
                 }
             } else if (Name.compare(QL1S("path"), Qt::CaseInsensitive) == 0) {
                 if (Value.isEmpty()) {
                     lastCookie.mPath.clear();    // Catch "" <> QString()
                 } else {
                     lastCookie.mPath = QUrl::fromPercentEncoding(Value.toLatin1());
                 }
                 lastCookie.mExplicitPath = true;
             } else if (Name.compare(QL1S("version"), Qt::CaseInsensitive) == 0) {
                 lastCookie.mProtocolVersion = Value.toInt();
             } else if (Name.compare(QL1S("secure"), Qt::CaseInsensitive) == 0 ||
                        (Name.isEmpty() && Value.compare(QL1S("secure"), Qt::CaseInsensitive) == 0)) {
                 lastCookie.mSecure = true;
             } else if (Name.compare(QL1S("httponly"), Qt::CaseInsensitive) == 0 ||
                        (Name.isEmpty() && Value.compare(QL1S("httponly"), Qt::CaseInsensitive) == 0)) {
                 lastCookie.mHttpOnly = true;
             } else if (isRFC2965 && (Name.compare(QL1S("port"), Qt::CaseInsensitive) == 0 ||
                                      (Name.isEmpty() && Value.compare(QL1S("port"), Qt::CaseInsensitive) == 0))) {
                 // Based on the port selection rule of RFC 2965 section 3.3.4...
                 if (Name.isEmpty()) {
                     // We intentionally append a -1 first in order to distinguish
                     // between only a 'Port' vs a 'Port="80 443"' in the sent cookie.
                     lastCookie.mPorts.append(-1);
                     const bool secureRequest = (_url.startsWith(QL1S("https://"), Qt::CaseInsensitive) ||
                                                 _url.startsWith(QL1S("webdavs://"), Qt::CaseInsensitive));
                     if (secureRequest) {
                         lastCookie.mPorts.append(443);
                     } else {
                         lastCookie.mPorts.append(80);
                     }
                 } else {
                     bool ok;
                     const QStringList portNums = Value.split(QL1C(' '), QString::SkipEmptyParts);
                     Q_FOREACH (const QString &portNum, portNums) {
                         const int port = portNum.toInt(&ok);
                         if (ok) {
                             lastCookie.mPorts.append(port);
                         }
                     }
                 }
             }
         }
 
         if (*cookieStr == '\0') {
             break;    // End of header
         }
 
         // Skip ';' or '\n'
         cookieStr++;
     }
 
     // RFC2965 cookies come last so that they override netscape cookies.
     while (!cookieList2.isEmpty()) {
         KHttpCookie &lastCookie = cookieList2.first();
         removeDuplicateFromList(&cookieList, lastCookie, true);
         cookieList.append(lastCookie);
         cookieList2.removeFirst();
     }
 
     return cookieList;
 }
 
 /**
 * Parses cookie_domstr and returns a linked list of KHttpCookie objects.
 * cookie_domstr should be a semicolon-delimited list of "name=value"
 * pairs. Any whitespace before "name" or around '=' is discarded.
 * If no cookies are found, 0 is returned.
 */
 KHttpCookieList KCookieJar::makeDOMCookies(const QString &_url,
         const QByteArray &cookie_domstring,
         WId windowId)
 {
     // A lot copied from above
     KHttpCookieList cookieList;
 
     const char *cookieStr = cookie_domstring.data();
     QString fqdn;
     QString path;
 
     if (!parseUrl(_url, fqdn, path)) {
         // Error parsing _url
         return KHttpCookieList();
     }
 
     QString Name;
     QString Value;
     //  This time it's easy
     while (*cookieStr) {
         cookieStr = parseNameValue(cookieStr, Name, Value);
 
         // Host = FQDN
         // Default domain = ""
         // Default path = ""
         KHttpCookie cookie(fqdn, QString(), QString(),
                            Name, Value);
         if (windowId) {
             cookie.mWindowIds.append(windowId);
         }
 
         cookieList.append(cookie);
 
         if (*cookieStr != '\0') {
             cookieStr++;    // Skip ';' or '\n'
         }
     }
 
     return cookieList;
 }
 
 // KHttpCookieList sorting
 ///////////////////////////////////////////////////////////////////////////
 
 // We want the longest path first
 static bool compareCookies(const KHttpCookie &item1, const KHttpCookie &item2)
 {
     return item1.path().length() > item2.path().length();
 }
 
 #ifdef MAX_COOKIE_LIMIT
 static void makeRoom(KHttpCookieList *cookieList, KHttpCookiePtr &cookiePtr)
 {
     // Too many cookies: throw one away, try to be somewhat clever
     KHttpCookiePtr lastCookie = 0;
     for (KHttpCookiePtr cookie = cookieList->first(); cookie; cookie = cookieList->next()) {
         if (compareCookies(cookie, cookiePtr)) {
             break;
         }
         lastCookie = cookie;
     }
     if (!lastCookie) {
         lastCookie = cookieList->first();
     }
     cookieList->removeRef(lastCookie);
 }
 #endif
 
 //
 // This function hands a KHttpCookie object over to the cookie jar.
 //
 void KCookieJar::addCookie(KHttpCookie &cookie)
 {
     QStringList domains;
     // We always need to do this to make sure that the
     // that cookies of type hostname == cookie-domainname
     // are properly removed and/or updated as necessary!
     extractDomains(cookie.host(), domains);
 
     // If the cookie specifies a domain, check whether it is valid. Otherwise,
     // accept the cookie anyways but removes the domain="" value to prevent
     // cross-site cookie injection.
     if (!cookie.domain().isEmpty()) {
         if (!domains.contains(cookie.domain()) &&
                 !cookie.domain().endsWith(QL1C('.') + cookie.host())) {
             cookie.fixDomain(QString());
         }
     }
 
     QStringListIterator it(domains);
     while (it.hasNext()) {
         const QString &key = it.next();
         KHttpCookieList *list;
 
         if (key.isNull()) {
             list = m_cookieDomains.value(QL1S(""));
         } else {
             list = m_cookieDomains.value(key);
         }
 
         if (list) {
             removeDuplicateFromList(list, cookie, false, true);
         }
     }
 
     const QString domain = stripDomain(cookie);
     KHttpCookieList *cookieList;
     if (domain.isNull()) {
         cookieList = m_cookieDomains.value(QL1S(""));
     } else {
         cookieList = m_cookieDomains.value(domain);
     }
 
     if (!cookieList) {
         // Make a new cookie list
         cookieList = new KHttpCookieList();
 
         // All cookies whose domain is not already
         // known to us should be added with KCookieDunno.
         // KCookieDunno means that we use the global policy.
         cookieList->setAdvice(KCookieDunno);
 
         m_cookieDomains.insert(domain, cookieList);
 
         // Update the list of domains
         m_domainList.append(domain);
     }
 
     // Add the cookie to the cookie list
     // The cookie list is sorted 'longest path first'
     if (!cookie.isExpired()) {
 #ifdef MAX_COOKIE_LIMIT
         if (cookieList->count() >= MAX_COOKIES_PER_HOST) {
             makeRoom(cookieList, cookie);    // Delete a cookie
         }
 #endif
         cookieList->push_back(cookie);
         // Use a stable sort so that unit tests are reliable.
         // In practice it doesn't matter though.
         qStableSort(cookieList->begin(), cookieList->end(), compareCookies);
 
         m_cookiesChanged = true;
     }
 }
 
 //
 // This function advises whether a single KHttpCookie object should
 // be added to the cookie jar.
 //
 KCookieAdvice KCookieJar::cookieAdvice(const KHttpCookie &cookie) const
 {
     if (m_rejectCrossDomainCookies && cookie.isCrossDomain()) {
         return KCookieReject;
     }
 
     if (cookie.getUserSelectedAdvice() != KCookieDunno) {
         return cookie.getUserSelectedAdvice();
     }
 
     if (m_autoAcceptSessionCookies && cookie.expireDate() == 0) {
         return KCookieAccept;
     }
 
     QStringList domains;
     extractDomains(cookie.host(), domains);
 
     KCookieAdvice advice = KCookieDunno;
     QStringListIterator it(domains);
     while (advice == KCookieDunno && it.hasNext()) {
         const QString &domain = it.next();
         if (domain.startsWith(QL1C('.')) || cookie.host() == domain) {
             KHttpCookieList *cookieList = m_cookieDomains.value(domain);
             if (cookieList) {
                 advice = cookieList->getAdvice();
             }
         }
     }
 
     if (advice == KCookieDunno) {
         advice = m_globalAdvice;
     }
 
     return advice;
 }
 
 //
 // This function tells whether a single KHttpCookie object should
 // be considered persistent. Persistent cookies do not get deleted
 // at the end of the session and are saved on disk.
 //
 bool KCookieJar::cookieIsPersistent(const KHttpCookie &cookie) const
 {
     if (cookie.expireDate() == 0) {
         return false;
     }
 
     KCookieAdvice advice = cookieAdvice(cookie);
 
     if (advice == KCookieReject || advice == KCookieAcceptForSession) {
         return false;
     }
 
     return true;
 }
 
 //
 // This function gets the advice for all cookies originating from
 // _domain.
 //
 KCookieAdvice KCookieJar::getDomainAdvice(const QString &_domain) const
 {
     KHttpCookieList *cookieList = m_cookieDomains.value(_domain);
     KCookieAdvice advice;
 
     if (cookieList) {
         advice = cookieList->getAdvice();
     } else {
         advice = KCookieDunno;
     }
 
     return advice;
 }
 
 //
 // This function sets the advice for all cookies originating from
 // _domain.
 //
 void KCookieJar::setDomainAdvice(const QString &_domain, KCookieAdvice _advice)
 {
     QString domain(_domain);
     KHttpCookieList *cookieList = m_cookieDomains.value(domain);
 
     if (cookieList) {
         if (cookieList->getAdvice() != _advice) {
             m_configChanged = true;
             // domain is already known
             cookieList->setAdvice(_advice);
         }
 
         if ((cookieList->isEmpty()) && (_advice == KCookieDunno)) {
             // This deletes cookieList!
             delete m_cookieDomains.take(domain);
             m_domainList.removeAll(domain);
         }
     } else {
         // domain is not yet known
         if (_advice != KCookieDunno) {
             // We should create a domain entry
             m_configChanged = true;
             // Make a new cookie list
             cookieList = new KHttpCookieList();
             cookieList->setAdvice(_advice);
             m_cookieDomains.insert(domain, cookieList);
             // Update the list of domains
             m_domainList.append(domain);
         }
     }
 }
 
 //
 // This function sets the advice for all cookies originating from
 // the same domain as _cookie
 //
 void KCookieJar::setDomainAdvice(const KHttpCookie &cookie, KCookieAdvice _advice)
 {
     QString domain;
     stripDomain(cookie.host(), domain); // We file the cookie under this domain.
     setDomainAdvice(domain, _advice);
 }
 
 //
 // This function sets the global advice for cookies
 //
 void KCookieJar::setGlobalAdvice(KCookieAdvice _advice)
 {
     if (m_globalAdvice != _advice) {
         m_configChanged = true;
     }
     m_globalAdvice = _advice;
 }
 
 //
 // Get a list of all domains known to the cookie jar.
 //
 const QStringList &KCookieJar::getDomainList()
 {
     return m_domainList;
 }
 
 //
 // Get a list of all cookies in the cookie jar originating from _domain.
 //
 KHttpCookieList *KCookieJar::getCookieList(const QString &_domain,
         const QString &_fqdn)
 {
     QString domain;
 
     if (_domain.isEmpty()) {
         stripDomain(_fqdn, domain);
     } else {
         domain = _domain;
     }
 
     return m_cookieDomains.value(domain);
 }
 
 //
 // Eat a cookie out of the jar.
 // cookieIterator should be one of the cookies returned by getCookieList()
 //
 void KCookieJar::eatCookie(const KHttpCookieList::iterator &cookieIterator)
 {
     const KHttpCookie &cookie = *cookieIterator;
     const QString domain = stripDomain(cookie); // We file the cookie under this domain.
     KHttpCookieList *cookieList = m_cookieDomains.value(domain);
 
     if (cookieList) {
         // This deletes cookie!
         cookieList->erase(cookieIterator);
 
         if ((cookieList->isEmpty()) &&
                 (cookieList->getAdvice() == KCookieDunno)) {
             // This deletes cookieList!
             delete m_cookieDomains.take(domain);
             m_domainList.removeAll(domain);
         }
     }
 }
 
 void KCookieJar::eatCookiesForDomain(const QString &domain)
 {
     KHttpCookieList *cookieList = m_cookieDomains.value(domain);
     if (!cookieList || cookieList->isEmpty()) {
         return;
     }
 
     cookieList->clear();
     if (cookieList->getAdvice() == KCookieDunno) {
         // This deletes cookieList!
         delete m_cookieDomains.take(domain);
         m_domainList.removeAll(domain);
     }
     m_cookiesChanged = true;
 }
 
 void KCookieJar::eatSessionCookies(long windowId)
 {
     if (!windowId) {
         return;
     }
 
     Q_FOREACH (const QString &domain, m_domainList) {
         eatSessionCookies(domain, windowId, false);
     }
 }
 
 void KCookieJar::eatAllCookies()
 {
     Q_FOREACH (const QString &domain, m_domainList) {
         eatCookiesForDomain(domain);    // This might remove domain from m_domainList!
     }
 }
 
 void KCookieJar::eatSessionCookies(const QString &fqdn, WId windowId,
                                    bool isFQDN)
 {
     KHttpCookieList *cookieList;
     if (!isFQDN) {
         cookieList = m_cookieDomains.value(fqdn);
     } else {
         QString domain;
         stripDomain(fqdn, domain);
         cookieList = m_cookieDomains.value(domain);
     }
 
     if (cookieList) {
         QMutableListIterator<KHttpCookie> cookieIterator(*cookieList);
         while (cookieIterator.hasNext()) {
             KHttpCookie &cookie = cookieIterator.next();
 
             if (cookieIsPersistent(cookie)) {
                 continue;
             }
 
             QList<WId> &ids = cookie.windowIds();
 
 #ifndef NDEBUG
             if (ids.contains(windowId)) {
                 if (ids.count() > 1) {
                     qCDebug(KIO_COOKIEJAR) << "removing window id" << windowId << "from session cookie";
                 } else {
                     qCDebug(KIO_COOKIEJAR) << "deleting session cookie";
                 }
             }
 #endif
             if (!ids.removeAll(windowId) || !ids.isEmpty()) {
                 continue;
             }
             cookieIterator.remove();
         }
     }
 }
 
 static QString hostWithPort(const KHttpCookie *cookie)
 {
     const QList<int> &ports = cookie->ports();
 
     if (ports.isEmpty()) {
         return cookie->host();
     }
 
     QStringList portList;
     Q_FOREACH (int port, ports) {
         portList << QString::number(port);
     }
 
     return (cookie->host() + QL1C(':') + portList.join(QLatin1Char(',')));
 }
 
 //
 // Saves all cookies to the file '_filename'.
 // On success 'true' is returned.
 // On failure 'false' is returned.
 bool KCookieJar::saveCookies(const QString &_filename)
 {
     QSaveFile cookieFile(_filename);
 
     if (!cookieFile.open(QIODevice::WriteOnly)) {
         return false;
     }
 
     QTextStream ts(&cookieFile);
 
     ts << "# KDE Cookie File v2\n#\n";
 
     QString s;
     s.sprintf("%-20s %-20s %-12s %-10s %-4s %-20s %-4s %s\n",
               "# Host", "Domain", "Path", "Exp.date", "Prot",
               "Name", "Sec", "Value");
     ts << s.toLatin1().constData();
 
     QStringListIterator it(m_domainList);
     while (it.hasNext()) {
         const QString &domain = it.next();
         bool domainPrinted = false;
 
         KHttpCookieList *cookieList = m_cookieDomains.value(domain);
         if (!cookieList) {
             continue;
         }
 
         QMutableListIterator<KHttpCookie> cookieIterator(*cookieList);
         while (cookieIterator.hasNext()) {
             const KHttpCookie &cookie = cookieIterator.next();
 
             if (cookie.isExpired()) {
                 // Delete expired cookies
                 cookieIterator.remove();
                 continue;
             }
             if (cookieIsPersistent(cookie)) {
                 // Only save cookies that are not "session-only cookies"
                 if (!domainPrinted) {
                     domainPrinted = true;
                     ts << '[' << domain.toLocal8Bit().data() << "]\n";
                 }
                 // Store persistent cookies
                 const QString path = QL1C('"') + cookie.path() + QL1C('"');
                 const QString domain = QL1C('"') + cookie.domain() + QL1C('"');
                 const QString host = hostWithPort(&cookie);
 
                 // TODO: replace with direct QTextStream output ?
                 s.sprintf("%-20s %-20s %-12s %10lld  %3d %-20s %-4i %s\n",
                           host.toLatin1().constData(), domain.toLatin1().constData(),
                           path.toLatin1().constData(), cookie.expireDate(),
                           cookie.protocolVersion(),
                           cookie.name().isEmpty() ? cookie.value().toLatin1().constData() : cookie.name().toLatin1().constData(),
                           (cookie.isSecure() ? 1 : 0) + (cookie.isHttpOnly() ? 2 : 0) +
                           (cookie.hasExplicitPath() ? 4 : 0) + (cookie.name().isEmpty() ? 8 : 0),
                           cookie.value().toLatin1().constData());
                 ts << s.toLatin1().constData();
             }
         }
     }
 
     if (cookieFile.commit()) {
         QFile::setPermissions(_filename, QFile::ReadUser | QFile::WriteUser);
         return true;
     }
     return false;
 }
 
 static const char *parseField(char *&buffer, bool keepQuotes = false)
 {
     char *result;
     if (!keepQuotes && (*buffer == '\"')) {
         // Find terminating "
         buffer++;
         result = buffer;
         while ((*buffer != '\"') && (*buffer)) {
             buffer++;
         }
     } else {
         // Find first white space
         result = buffer;
         while ((*buffer != ' ') && (*buffer != '\t') && (*buffer != '\n') && (*buffer)) {
             buffer++;
         }
     }
 
     if (!*buffer) {
         return result;    //
     }
     *buffer++ = '\0';
 
     // Skip white-space
     while ((*buffer == ' ') || (*buffer == '\t') || (*buffer == '\n')) {
         buffer++;
     }
 
     return result;
 }
 
 static QString extractHostAndPorts(const QString &str, QList<int> *ports = nullptr)
 {
     if (str.isEmpty()) {
         return str;
     }
 
     const int index = str.indexOf(QL1C(':'));
     if (index == -1) {
         return str;
     }
 
     const QString host = str.left(index);
     if (ports) {
         bool ok;
         QStringList portList = str.mid(index + 1).split(QL1C(','));
         Q_FOREACH (const QString &portStr, portList) {
             const int portNum = portStr.toInt(&ok);
             if (ok) {
                 ports->append(portNum);
             }
         }
     }
 
     return host;
 }
 
 //
 // Reloads all cookies from the file '_filename'.
 // On success 'true' is returned.
 // On failure 'false' is returned.
 bool KCookieJar::loadCookies(const QString &_filename)
 {
     QFile cookieFile(_filename);
 
     if (!cookieFile.open(QIODevice::ReadOnly)) {
         return false;
     }
 
     int version = 1;
     bool success = false;
     char *buffer = new char[READ_BUFFER_SIZE];
     qint64 len = cookieFile.readLine(buffer, READ_BUFFER_SIZE - 1);
 
     if (len != -1) {
         if (qstrcmp(buffer, "# KDE Cookie File\n") == 0) {
             success = true;
         } else if (qstrcmp(buffer, "# KDE Cookie File v") > 0) {
             bool ok = false;
             const int verNum = QByteArray(buffer + 19, len - 19).trimmed().toInt(&ok);
             if (ok) {
                 version = verNum;
                 success = true;
             }
         }
     }
 
     if (success) {
         const qint64 currentTime = epoch();
         QList<int> ports;
 
         while (cookieFile.readLine(buffer, READ_BUFFER_SIZE - 1) != -1) {
             char *line = buffer;
             // Skip lines which begin with '#' or '['
             if ((line[0] == '#') || (line[0] == '[')) {
                 continue;
             }
 
             const QString host = extractHostAndPorts(QL1S(parseField(line)), &ports);
             const QString domain = QL1S(parseField(line));
             if (host.isEmpty() && domain.isEmpty()) {
                 continue;
             }
             const QString path = QL1S(parseField(line));
             const QString expStr = QL1S(parseField(line));
             if (expStr.isEmpty()) {
                 continue;
             }
             const qint64 expDate = expStr.toLongLong();
             const QString verStr = QL1S(parseField(line));
             if (verStr.isEmpty()) {
                 continue;
             }
             int protVer  = verStr.toInt();
             QString name = QL1S(parseField(line));
             bool keepQuotes = false;
             bool secure = false;
             bool httpOnly = false;
             bool explicitPath = false;
             const char *value = nullptr;
             if ((version == 2) || (protVer >= 200)) {
                 if (protVer >= 200) {
                     protVer -= 200;
                 }
                 int i = atoi(parseField(line));
                 secure = i & 1;
                 httpOnly = i & 2;
                 explicitPath = i & 4;
                 if (i & 8) {
                     name = QLatin1String("");
                 }
                 line[strlen(line) - 1] = '\0'; // Strip LF.
                 value = line;
             } else {
                 if (protVer >= 100) {
                     protVer -= 100;
                     keepQuotes = true;
                 }
                 value = parseField(line, keepQuotes);
                 secure = QByteArray(parseField(line)).toShort();
             }
 
             // Expired or parse error
             if (!value || expDate == 0 || expDate < currentTime) {
                 continue;
             }
 
             KHttpCookie cookie(host, domain, path, name, QString::fromUtf8(value), expDate,
                                protVer, secure, httpOnly, explicitPath);
-            if (ports.count()) {
+            if (!ports.isEmpty()) {
                 cookie.mPorts = ports;
             }
             addCookie(cookie);
         }
     }
 
     delete [] buffer;
     m_cookiesChanged = false;
     return success;
 }
 
 //
 // Save the cookie configuration
 //
 
 void KCookieJar::saveConfig(KConfig *_config)
 {
     if (!m_configChanged) {
         return;
     }
 
     KConfigGroup dlgGroup(_config, "Cookie Dialog");
     dlgGroup.writeEntry("PreferredPolicy", static_cast<int>(m_preferredPolicy));
     dlgGroup.writeEntry("ShowCookieDetails", m_showCookieDetails);
     KConfigGroup policyGroup(_config, "Cookie Policy");
     policyGroup.writeEntry("CookieGlobalAdvice", adviceToStr(m_globalAdvice));
 
     QStringList domainSettings;
     QStringListIterator it(m_domainList);
     while (it.hasNext()) {
         const QString &domain = it.next();
         KCookieAdvice advice = getDomainAdvice(domain);
         if (advice != KCookieDunno) {
             const QString value = domain + QL1C(':') + adviceToStr(advice);
             domainSettings.append(value);
         }
     }
     policyGroup.writeEntry("CookieDomainAdvice", domainSettings);
     _config->sync();
     m_configChanged = false;
 }
 
 //
 // Load the cookie configuration
 //
 
 void KCookieJar::loadConfig(KConfig *_config, bool reparse)
 {
     if (reparse) {
         _config->reparseConfiguration();
     }
 
     KConfigGroup dlgGroup(_config, "Cookie Dialog");
     m_showCookieDetails = dlgGroup.readEntry("ShowCookieDetails", false);
     m_preferredPolicy = static_cast<KCookieDefaultPolicy>(dlgGroup.readEntry("PreferredPolicy", 0));
 
     KConfigGroup policyGroup(_config, "Cookie Policy");
     const QStringList domainSettings = policyGroup.readEntry("CookieDomainAdvice", QStringList());
     // Warning: those default values are duplicated in the kcm (kio/kcookiespolicies.cpp)
     m_rejectCrossDomainCookies = policyGroup.readEntry("RejectCrossDomainCookies", true);
     m_autoAcceptSessionCookies = policyGroup.readEntry("AcceptSessionCookies", true);
     m_globalAdvice = strToAdvice(policyGroup.readEntry("CookieGlobalAdvice", QStringLiteral("Accept")));
 
     // Reset current domain settings first.
     Q_FOREACH (const QString &domain, m_domainList) {
         setDomainAdvice(domain, KCookieDunno);
     }
 
     // Now apply the domain settings read from config file...
     for (QStringList::ConstIterator it = domainSettings.constBegin(), itEnd = domainSettings.constEnd();
             it != itEnd; ++it) {
         const QString &value = *it;
         const int sepPos = value.lastIndexOf(QL1C(':'));
         if (sepPos <= 0) {
             continue;
         }
 
         const QString domain(value.left(sepPos));
         KCookieAdvice advice = strToAdvice(value.mid(sepPos + 1));
         setDomainAdvice(domain, advice);
     }
 }
 
 QDebug operator<<(QDebug dbg, const KHttpCookie &cookie)
 {
     dbg.nospace() << cookie.cookieStr(false);
     return dbg.space();
 }
 
 QDebug operator<<(QDebug dbg, const KHttpCookieList &list)
 {
     Q_FOREACH (const KHttpCookie &cookie, list) {
         dbg << cookie;
     }
     return dbg;
 }
diff --git a/src/ioslaves/http/kcookiejar/kcookiewin.cpp b/src/ioslaves/http/kcookiejar/kcookiewin.cpp
index 10123456..bf4918ba 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().count() > 0) {
+    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);
 
     // 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);
     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);
     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/useragentinfo.cpp b/src/kcms/kio/useragentinfo.cpp
index 28246619..3f190638 100644
--- a/src/kcms/kio/useragentinfo.cpp
+++ b/src/kcms/kio/useragentinfo.cpp
@@ -1,190 +1,190 @@
 /*
  * Copyright (c) 2001 Dawit Alemayehu <adawit@kde.org>
  *
  *  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 "useragentinfo.h"
 
 // std
 #include <time.h>
 
 #ifndef Q_OS_WIN
 #include <sys/utsname.h>
 #else
 #include <QSysInfo>
 #endif
 
 // Qt
 #include <QLocale>
 
 // KDE
 #include <kservicetypetrader.h>
 
 #define UA_PTOS(x) (*it)->property(x).toString()
 #define QFL(x) QLatin1String(x)
 
 UserAgentInfo::UserAgentInfo()
 {
    m_bIsDirty = true;
 }
 
 UserAgentInfo::StatusCode UserAgentInfo::createNewUAProvider( const QString& uaStr )
 {
   QStringList split;
   int pos = (uaStr).indexOf(QStringLiteral("::"));
 
   if ( pos == -1 )
   {
     pos = (uaStr).indexOf(QLatin1Char(':'));
     if ( pos != -1 )
     {
       split.append(uaStr.left(pos));
       split.append(uaStr.mid(pos+1));
     }
   }
   else
   {
     split = uaStr.split( QStringLiteral("::"));
   }
 
   if ( m_lstIdentity.contains(split[1]) )
     return DUPLICATE_ENTRY;
   else
   {
     int count = split.count();
     m_lstIdentity.append( split[1] );
     if ( count > 2 )
       m_lstAlias.append(split[2]);
     else
       m_lstAlias.append( split[1]);
   }
 
   return SUCCEEDED;
 }
 
 void UserAgentInfo::loadFromDesktopFiles()
 {
   m_providers.clear();
   m_providers = KServiceTypeTrader::self()->query(QStringLiteral("UserAgentStrings"));
 }
 
 void UserAgentInfo::parseDescription()
 {
   QString tmp;
 
   KService::List::ConstIterator it = m_providers.constBegin();
   KService::List::ConstIterator lastItem = m_providers.constEnd();
 
   for ( ; it != lastItem; ++it )
   {
     tmp = UA_PTOS(QStringLiteral("X-KDE-UA-FULL"));
 
     if ( (*it)->property(QStringLiteral("X-KDE-UA-DYNAMIC-ENTRY")).toBool() )
     {
 #ifndef Q_OS_WIN
       struct utsname utsn;
       uname( &utsn );
 
       tmp.replace( QFL("appSysName"), QString::fromUtf8(utsn.sysname) );
       tmp.replace( QFL("appSysRelease"), QString::fromUtf8(utsn.release) );
       tmp.replace( QFL("appMachineType"), QString::fromUtf8(utsn.machine) );
 #else
       tmp.replace( QFL("appSysName"),  QLatin1String("Windows") );
       // TODO: maybe we can use QSysInfo also on linux?
       tmp.replace( QFL("appSysRelease"), QSysInfo::kernelVersion() );
       tmp.replace( QFL("appMachineType"), QSysInfo::currentCpuArchitecture() );
 #endif
       QStringList languageList = QLocale().uiLanguages();
-      if ( languageList.count() )
+      if ( !languageList.isEmpty() )
       {
         int ind = languageList.indexOf( QStringLiteral("C") );
         if( ind >= 0 )
         {
           if( languageList.contains( QStringLiteral("en") ) )
             languageList.removeAt( ind );
           else
             languageList.value(ind) = QStringLiteral("en");
         }
       }
 
       tmp.replace( QFL("appLanguage"), QStringLiteral("%1").arg(languageList.join(QStringLiteral(", "))) );
       tmp.replace( QFL("appPlatform"), QFL("X11") );
     }
 
     // Ignore dups...
     if ( m_lstIdentity.contains(tmp) )
       continue;
 
     m_lstIdentity << tmp;
 
     tmp = QStringLiteral("%1 %2").arg(UA_PTOS(QStringLiteral("X-KDE-UA-SYSNAME")), UA_PTOS(QStringLiteral("X-KDE-UA-SYSRELEASE")));
     if ( tmp.trimmed().isEmpty() )
       tmp = QStringLiteral("%1 %2").arg(UA_PTOS(QStringLiteral("X-KDE-UA-"
                     "NAME")), UA_PTOS(QStringLiteral("X-KDE-UA-VERSION")));
     else
       tmp = QStringLiteral("%1 %2 on %3").arg(UA_PTOS(QStringLiteral("X-KDE-UA-"
                     "NAME")), (QStringLiteral("X-KDE-UA-VERSION")), tmp);
 
     m_lstAlias << tmp;
   }
 
   m_bIsDirty = false;
 }
 
 QString UserAgentInfo::aliasStr( const QString& name )
 {
   int id = userAgentStringList().indexOf(name);
   if ( id == -1 )
     return QString();
   else
     return m_lstAlias[id];
 }
 
 QString UserAgentInfo::agentStr( const QString& name )
 {
   int id = userAgentAliasList().indexOf(name);
   if ( id == -1 )
     return QString();
   else
     return m_lstIdentity[id];
 }
 
 
 QStringList UserAgentInfo::userAgentStringList()
 {
   if ( m_bIsDirty )
   {
     loadFromDesktopFiles();
-    if ( !m_providers.count() )
+    if ( m_providers.isEmpty() )
       return QStringList();
     parseDescription();
   }
   return m_lstIdentity;
 }
 
 QStringList UserAgentInfo::userAgentAliasList ()
 {
   if ( m_bIsDirty )
   {
     loadFromDesktopFiles();
-    if ( !m_providers.count() )
+    if ( m_providers.isEmpty() )
       return QStringList();
     parseDescription();
   }
   return m_lstAlias;
 }
 
diff --git a/src/kpasswdserver/kpasswdserver.cpp b/src/kpasswdserver/kpasswdserver.cpp
index ae99bdcd..ad0960f6 100644
--- a/src/kpasswdserver/kpasswdserver.cpp
+++ b/src/kpasswdserver/kpasswdserver.cpp
@@ -1,1116 +1,1116 @@
 /*
     This file is part of the KDE Password Server
 
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2005 David Faure (faure@kde.org)
     Copyright (C) 2012 Dawit Alemayehu (adawit@kde.org)
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU General Public License
     version 2 as published by the Free Software Foundation.
 
     This software 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 library; see the file COPYING. If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 //----------------------------------------------------------------------------
 //
 // KDE Password Server
 
 #include "kpasswdserver.h"
 
 #include "kpasswdserveradaptor.h"
 
 #include <kmessagebox.h>
 #include <kpassworddialog.h>
 #include <kwindowsystem.h>
 #include <kusertimestamp.h>
 #include <klocalizedstring.h>
 
 #ifdef HAVE_KF5WALLET
 #include <kwallet.h>
 #endif
 
 #include <QPushButton>
 #include <QTimer>
 #include <ctime>
 
 static QLoggingCategory category("org.kde.kio.kpasswdserver");
 
 #define AUTHINFO_EXTRAFIELD_DOMAIN QStringLiteral("domain")
 #define AUTHINFO_EXTRAFIELD_ANONYMOUS QStringLiteral("anonymous")
 #define AUTHINFO_EXTRAFIELD_BYPASS_CACHE_AND_KWALLET QStringLiteral("bypass-cache-and-kwallet")
 #define AUTHINFO_EXTRAFIELD_SKIP_CACHING_ON_QUERY QStringLiteral("skip-caching-on-query")
 #define AUTHINFO_EXTRAFIELD_HIDE_USERNAME_INPUT QStringLiteral("hide-username-line")
 
 static qlonglong getRequestId()
 {
     static qlonglong nextRequestId = 0;
     return nextRequestId++;
 }
 
 bool
 KPasswdServer::AuthInfoContainer::Sorter::operator ()(AuthInfoContainer* n1, AuthInfoContainer* n2) const
 {
    if (!n1 || !n2)
       return 0;
 
    const int l1 = n1->directory.length();
    const int l2 = n2->directory.length();
    return l1 < l2;
 }
 
 
 KPasswdServer::KPasswdServer(QObject* parent, const QList<QVariant>&)
  : KDEDModule(parent)
 {
     KIO::AuthInfo::registerMetaTypes();
 
     m_seqNr = 0;
     m_wallet = nullptr;
     m_walletDisabled = false;
 
     KPasswdServerAdaptor *adaptor = new KPasswdServerAdaptor(this);
     // connect signals to the adaptor
     connect(this, &KPasswdServer::checkAuthInfoAsyncResult,
             adaptor, &KPasswdServerAdaptor::checkAuthInfoAsyncResult);
     connect(this, &KPasswdServer::queryAuthInfoAsyncResult,
             adaptor, &KPasswdServerAdaptor::queryAuthInfoAsyncResult);
 
     connect(this, &KDEDModule::windowUnregistered,
             this, &KPasswdServer::removeAuthForWindowId);
 
     connect(KWindowSystem::self(), &KWindowSystem::windowRemoved,
             this, &KPasswdServer::windowRemoved);
 }
 
 KPasswdServer::~KPasswdServer()
 {
     // TODO: what about clients waiting for requests? will they just
     //       notice kpasswdserver is gone from the dbus?
     qDeleteAll(m_authPending);
     qDeleteAll(m_authWait);
     qDeleteAll(m_authDict);
     qDeleteAll(m_authInProgress);
     qDeleteAll(m_authRetryInProgress);
 
 #ifdef HAVE_KF5WALLET
     delete m_wallet;
 #endif
 }
 
 #ifdef HAVE_KF5WALLET
 
 // Helper - returns the wallet key to use for read/store/checking for existence.
 static QString makeWalletKey( const QString& key, const QString& realm )
 {
     return realm.isEmpty() ? key : key + QLatin1Char('-') + realm;
 }
 
 // Helper for storeInWallet/readFromWallet
 static QString makeMapKey( const char* key, int entryNumber )
 {
     QString str = QLatin1String( key );
     if ( entryNumber > 1 )
         str += QLatin1Char('-') + QString::number( entryNumber );
     return str;
 }
 
 static bool storeInWallet( KWallet::Wallet* wallet, const QString& key, const KIO::AuthInfo &info )
 {
     if ( !wallet->hasFolder( KWallet::Wallet::PasswordFolder() ) )
         if ( !wallet->createFolder( KWallet::Wallet::PasswordFolder() ) )
             return false;
     wallet->setFolder( KWallet::Wallet::PasswordFolder() );
     // Before saving, check if there's already an entry with this login.
     // If so, replace it (with the new password). Otherwise, add a new entry.
     typedef QMap<QString,QString> Map;
     int entryNumber = 1;
     Map map;
     QString walletKey = makeWalletKey( key, info.realmValue );
     qCDebug(category) << "walletKey =" << walletKey << "  reading existing map";
     if ( wallet->readMap( walletKey, map ) == 0 ) {
         Map::ConstIterator end = map.constEnd();
         Map::ConstIterator it = map.constFind( QStringLiteral("login") );
         while ( it != end ) {
             if ( it.value() == info.username ) {
                 break; // OK, overwrite this entry
             }
             it = map.constFind( QStringLiteral( "login-" ) + QString::number( ++entryNumber ) );
         }
         // If no entry was found, create a new entry - entryNumber is set already.
     }
     const QString loginKey = makeMapKey( "login", entryNumber );
     const QString passwordKey = makeMapKey( "password", entryNumber );
     qCDebug(category) << "writing to " << loginKey << "," << passwordKey;
     // note the overwrite=true by default
     map.insert( loginKey, info.username );
     map.insert( passwordKey, info.password );
     wallet->writeMap( walletKey, map );
     return true;
 }
 
 static bool readFromWallet( KWallet::Wallet* wallet, const QString& key, const QString& realm, QString& username, QString& password, bool userReadOnly, QMap<QString,QString>& knownLogins )
 {
     //qCDebug(category) << "key =" << key << " username =" << username << " password =" /*<< password*/ << " userReadOnly =" << userReadOnly << " realm =" << realm;
     if ( wallet->hasFolder( KWallet::Wallet::PasswordFolder() ) )
     {
         wallet->setFolder( KWallet::Wallet::PasswordFolder() );
 
         QMap<QString,QString> map;
         if ( wallet->readMap( makeWalletKey( key, realm ), map ) == 0 )
         {
             typedef QMap<QString,QString> Map;
             int entryNumber = 1;
             Map::ConstIterator end = map.constEnd();
             Map::ConstIterator it = map.constFind( QStringLiteral("login") );
             while ( it != end ) {
                 //qCDebug(category) << "found " << it.key() << "=" << it.value();
                 Map::ConstIterator pwdIter = map.constFind( makeMapKey( "password", entryNumber ) );
                 if ( pwdIter != end ) {
                     if ( it.value() == username )
                         password = pwdIter.value();
                     knownLogins.insert( it.value(), pwdIter.value() );
                 }
 
                 it = map.constFind( QStringLiteral( "login-" ) + QString::number( ++entryNumber ) );
             }
             //qCDebug(category) << knownLogins.count() << " known logins";
 
             if ( !userReadOnly && !knownLogins.isEmpty() && username.isEmpty() ) {
                 // Pick one, any one...
                 username = knownLogins.begin().key();
                 password = knownLogins.begin().value();
                 //qCDebug(category) << "picked the first one:" << username;
             }
 
             return true;
         }
     }
     return false;
 }
 
 #endif
 
 bool KPasswdServer::hasPendingQuery(const QString &key, const KIO::AuthInfo &info)
 {
     const QString path2 (info.url.path().left(info.url.path().indexOf(QLatin1Char('/'))+1));
     Q_FOREACH(const Request *request, m_authPending) {
         if (request->key != key) {
             continue;
         }
 
         if (info.verifyPath) {
             const QString path1 (request->info.url.path().left(info.url.path().indexOf(QLatin1Char('/'))+1));
             if (!path2.startsWith(path1)) {
                 continue;
             }
         }
 
         return true;
     }
 
     return false;
 }
 
 // deprecated method, not used anymore. TODO KF6: REMOVE
 QByteArray KPasswdServer::checkAuthInfo(const QByteArray &data, qlonglong windowId, qlonglong usertime)
 {
     KIO::AuthInfo info;
     QDataStream stream(data);
     stream >> info;
     if (usertime != 0) {
         KUserTimestamp::updateUserTimestamp(usertime);
     }
 
     // if the check depends on a pending query, delay it
     // until that query is finished.
     const QString key (createCacheKey(info));
     if (hasPendingQuery(key, info)) {
         setDelayedReply(true);
         Request *pendingCheck = new Request;
         pendingCheck->isAsync = false;
         if (calledFromDBus()) {
             pendingCheck->transaction = message();
         }
         pendingCheck->key = key;
         pendingCheck->info = info;
         m_authWait.append(pendingCheck);
         return data;             // return value will be ignored
     }
 
     // qCDebug(category) << "key =" << key << "user =" << info.username << "windowId =" << windowId;
     const AuthInfoContainer *result = findAuthInfoItem(key, info);
     if (!result || result->isCanceled)
     {
 #ifdef HAVE_KF5WALLET
         if (!result &&
             !m_walletDisabled &&
             (info.username.isEmpty() || info.password.isEmpty()) &&
             !KWallet::Wallet::keyDoesNotExist(KWallet::Wallet::NetworkWallet(),
                                               KWallet::Wallet::PasswordFolder(),
                                               makeWalletKey(key, info.realmValue)))
         {
             QMap<QString, QString> knownLogins;
             if (openWallet(windowId)) {
                 if (readFromWallet(m_wallet, key, info.realmValue, info.username,
                                    info.password, info.readOnly, knownLogins))
                 {
                     info.setModified(true);
                             // fall through
                 }
             }
         } else {
             info.setModified(false);
         }
 #else
         info.setModified(false);
 #endif
     } else {
         qCDebug(category) << "Found cached authentication for" << key;
         updateAuthExpire(key, result, windowId, false);
         copyAuthInfo(result, info);
     }
 
     QByteArray data2;
     QDataStream stream2(&data2, QIODevice::WriteOnly);
     stream2 << info;
     return data2;
 }
 
 qlonglong KPasswdServer::checkAuthInfoAsync(KIO::AuthInfo info, qlonglong windowId,
                                             qlonglong usertime)
 {
     if (usertime != 0) {
         KUserTimestamp::updateUserTimestamp(usertime);
     }
 
     // send the request id back to the client
     qlonglong requestId = getRequestId();
     qCDebug(category) << "User =" << info.username << ", WindowId =" << windowId;
     if (calledFromDBus()) {
         QDBusMessage reply(message().createReply(requestId));
         QDBusConnection::sessionBus().send(reply);
     }
 
     // if the check depends on a pending query, delay it
     // until that query is finished.
     const QString key (createCacheKey(info));
     if (hasPendingQuery(key, info)) {
         Request *pendingCheck = new Request;
         pendingCheck->isAsync = true;
         pendingCheck->requestId = requestId;
         pendingCheck->key = key;
         pendingCheck->info = info;
         m_authWait.append(pendingCheck);
         return 0; // ignored as we already sent a reply
     }
 
     const AuthInfoContainer *result = findAuthInfoItem(key, info);
     if (!result || result->isCanceled)
     {
 #ifdef HAVE_KF5WALLET
         if (!result &&
             !m_walletDisabled &&
             (info.username.isEmpty() || info.password.isEmpty()) &&
             !KWallet::Wallet::keyDoesNotExist(KWallet::Wallet::NetworkWallet(),
                                               KWallet::Wallet::PasswordFolder(),
                                               makeWalletKey(key, info.realmValue)))
         {
             QMap<QString, QString> knownLogins;
             if (openWallet(windowId)) {
                 if (readFromWallet(m_wallet, key, info.realmValue, info.username,
                                    info.password, info.readOnly, knownLogins))
                 {
                     info.setModified(true);
                             // fall through
                 }
             }
         } else {
             info.setModified(false);
         }
 #else
         info.setModified(false);
 #endif
     } else {
         // qCDebug(category) << "Found cached authentication for" << key;
         updateAuthExpire(key, result, windowId, false);
         copyAuthInfo(result, info);
     }
 
     emit checkAuthInfoAsyncResult(requestId, m_seqNr, info);
     return 0; // ignored
 }
 
 // deprecated method, not used anymore. TODO KF6: REMOVE
 QByteArray KPasswdServer::queryAuthInfo(const QByteArray &data, const QString &errorMsg,
                                         qlonglong windowId, qlonglong seqNr, qlonglong usertime)
 {
     KIO::AuthInfo info;
     QDataStream stream(data);
     stream >> info;
 
     qCDebug(category) << "User =" << info.username << ", WindowId =" << windowId
                         << "seqNr =" << seqNr << ", errorMsg =" << errorMsg;
 
     if ( !info.password.isEmpty() ) { // should we really allow the caller to pre-fill the password?
         qCDebug(category) << "password was set by caller";
     }
     if (usertime != 0) {
         KUserTimestamp::updateUserTimestamp(usertime);
     }
 
     const QString key (createCacheKey(info));
     Request *request = new Request;
     setDelayedReply(true);
     request->isAsync = false;
     request->transaction = message();
     request->key = key;
     request->info = info;
     request->windowId = windowId;
     request->seqNr = seqNr;
     if (errorMsg == QLatin1String("<NoAuthPrompt>"))
     {
        request->errorMsg.clear();
        request->prompt = false;
     }
     else
     {
        request->errorMsg = errorMsg;
        request->prompt = true;
     }
     m_authPending.append(request);
 
     if (m_authPending.count() == 1)
        QTimer::singleShot(0, this, &KPasswdServer::processRequest);
 
     return QByteArray();        // return value is going to be ignored
 }
 
 qlonglong
 KPasswdServer::queryAuthInfoAsync(const KIO::AuthInfo &info, const QString &errorMsg,
                                   qlonglong windowId, qlonglong seqNr, qlonglong usertime)
 {
     qCDebug(category) << "User =" << info.username << ", WindowId =" << windowId
                         << "seqNr =" << seqNr << ", errorMsg =" << errorMsg;
 
     if (!info.password.isEmpty()) {
         qCDebug(category) << "password was set by caller";
     }
     if (usertime != 0) {
         KUserTimestamp::updateUserTimestamp(usertime);
     }
 
     const QString key (createCacheKey(info));
     Request *request = new Request;
     request->isAsync = true;
     request->requestId = getRequestId();
     request->key = key;
     request->info = info;
     request->windowId = windowId;
     request->seqNr = seqNr;
     if (errorMsg == QLatin1String("<NoAuthPrompt>")) {
         request->errorMsg.clear();
         request->prompt = false;
     } else {
         request->errorMsg = errorMsg;
         request->prompt = true;
     }
     m_authPending.append(request);
 
     if (m_authPending.count() == 1) {
         QTimer::singleShot(0, this, &KPasswdServer::processRequest);
     }
 
     return request->requestId;
 }
 
 void
 KPasswdServer::addAuthInfo(const KIO::AuthInfo &info, qlonglong windowId)
 {
     qCDebug(category) << "User =" << info.username << ", Realm =" << info.realmValue << ", WindowId =" << windowId;
     const QString key (createCacheKey(info));
 
     m_seqNr++;
 
 #ifdef HAVE_KF5WALLET
     if (!m_walletDisabled && openWallet(windowId) && storeInWallet(m_wallet, key, info)) {
         // Since storing the password in the wallet succeeded, make sure the
         // password information is stored in memory only for the duration the
         // windows associated with it are still around.
         KIO::AuthInfo authToken (info);
         authToken.keepPassword = false;
         addAuthInfoItem(key, authToken, windowId, m_seqNr, false);
         return;
     }
 #endif
 
     addAuthInfoItem(key, info, windowId, m_seqNr, false);
 }
 
 // deprecated method, not used anymore. TODO KF6: REMOVE
 void KPasswdServer::addAuthInfo(const QByteArray &data, qlonglong windowId)
 {
     KIO::AuthInfo info;
     QDataStream stream(data);
     stream >> info;
     addAuthInfo(info, windowId);
 }
 
 void
 KPasswdServer::removeAuthInfo(const QString& host, const QString& protocol, const QString& user)
 {
     qCDebug(category) << protocol << host << user;
 
     QHashIterator< QString, AuthInfoContainerList* > dictIterator(m_authDict);
     while (dictIterator.hasNext())
     {
         dictIterator.next();
 
         AuthInfoContainerList *authList = dictIterator.value();
         if (!authList)
             continue;
 
         Q_FOREACH(AuthInfoContainer *current, *authList)
         {
             qCDebug(category) << "Evaluating: " << current->info.url.scheme()
                      << current->info.url.host()
                      << current->info.username;
             if (current->info.url.scheme() == protocol &&
                current->info.url.host() == host &&
                (current->info.username == user || user.isEmpty()))
             {
                 qCDebug(category) << "Removing this entry";
                 removeAuthInfoItem(dictIterator.key(), current->info);
             }
         }
     }
 }
 
 #ifdef HAVE_KF5WALLET
 bool
 KPasswdServer::openWallet( qlonglong windowId )
 {
     if ( m_wallet && !m_wallet->isOpen() ) { // forced closed
         delete m_wallet;
         m_wallet = nullptr;
     }
     if ( !m_wallet )
         m_wallet = KWallet::Wallet::openWallet(
             KWallet::Wallet::NetworkWallet(), (WId)(windowId));
     return m_wallet != nullptr;
 }
 #endif
 
 void
 KPasswdServer::processRequest()
 {
     if (m_authPending.isEmpty()) {
         return;
     }
 
     QScopedPointer<Request> request (m_authPending.takeFirst());
 
     // Prevent multiple prompts originating from the same window or the same
     // key (server address).
     const QString windowIdStr = QString::number(request->windowId);
     if (m_authPrompted.contains(windowIdStr) || m_authPrompted.contains(request->key)) {
         m_authPending.prepend(request.take());  // put it back.
         return;
     }
 
     m_authPrompted.append(windowIdStr);
     m_authPrompted.append(request->key);
 
     KIO::AuthInfo &info = request->info;
 
     // NOTE: If info.username is empty and info.url.userName() is not, set
     // info.username to info.url.userName() to ensure proper caching. See
     // note passwordDialogDone.
     if (info.username.isEmpty() && !info.url.userName().isEmpty()) {
         info.username = info.url.userName();
     }
     const bool bypassCacheAndKWallet = info.getExtraField(AUTHINFO_EXTRAFIELD_BYPASS_CACHE_AND_KWALLET).toBool();
 
     const AuthInfoContainer *result = findAuthInfoItem(request->key, request->info);
     qCDebug(category) << "key=" << request->key << ", user=" << info.username << "seqNr: request=" << request->seqNr << ", result=" << (result ? result->seqNr : -1);
 
     if (!bypassCacheAndKWallet && result && (request->seqNr < result->seqNr))
     {
         qCDebug(category) << "auto retry!";
         if (result->isCanceled)
         {
            info.setModified(false);
         }
         else
         {
            updateAuthExpire(request->key, result, request->windowId, false);
            copyAuthInfo(result, info);
         }
     }
     else
     {
         m_seqNr++;
         if (result && !request->errorMsg.isEmpty())
         {
             const QString prompt = request->errorMsg.trimmed() + QLatin1Char('\n') +
                 i18n("Do you want to retry?");
 
             QDialog* dlg = new QDialog;
             connect(dlg, &QDialog::finished, this, &KPasswdServer::retryDialogDone);
             connect(this, &QObject::destroyed, dlg, &QObject::deleteLater);
             dlg->setWindowTitle(i18n("Retry Authentication"));
             dlg->setWindowIcon(QIcon::fromTheme(QStringLiteral("dialog-password")));
             dlg->setObjectName(QStringLiteral("warningOKCancel"));
             QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Yes|QDialogButtonBox::Cancel);
             buttonBox->button(QDialogButtonBox::Yes)->setText(i18nc("@action:button filter-continue", "Retry"));
 
             KMessageBox::createKMessageBox(dlg, buttonBox, QMessageBox::Warning, prompt,
                                            QStringList(), QString(), nullptr,
                                            (KMessageBox::Notify | KMessageBox::NoExec));
 
         #ifndef Q_WS_WIN
             KWindowSystem::setMainWindow(dlg, request->windowId);
         #else
             KWindowSystem::setMainWindow(dlg, (HWND)(long)request->windowId);
         #endif
 
             qCDebug(category) << "Calling open on retry dialog" << dlg;
             m_authRetryInProgress.insert(dlg, request.take());
             dlg->open();
             return;
         }
 
         if (request->prompt)
         {
             showPasswordDialog(request.take());
             return;
         }
         else
         {
             if (!bypassCacheAndKWallet && request->prompt)
             {
                 addAuthInfoItem(request->key, info, 0, m_seqNr, true);
             }
             info.setModified( false );
         }
     }
 
     sendResponse(request.data());
 }
 
 QString KPasswdServer::createCacheKey( const KIO::AuthInfo &info )
 {
     if( !info.url.isValid() ) {
         // Note that a null key will break findAuthInfoItem later on...
         qCWarning(category) << "createCacheKey: invalid URL " << info.url ;
         return QString();
     }
 
     // Generate the basic key sequence.
     QString key = info.url.scheme();
     key += QLatin1Char('-');
     if (!info.url.userName().isEmpty())
     {
        key += info.url.userName() + QLatin1Char('@');
     }
     key += info.url.host();
     int port = info.url.port();
     if( port )
     {
       key += QLatin1Char(':') + QString::number(port);
     }
 
     return key;
 }
 
 void KPasswdServer::copyAuthInfo(const AuthInfoContainer *i, KIO::AuthInfo& info)
 {
     info = i->info;
     info.setModified(true);
 }
 
 const KPasswdServer::AuthInfoContainer *
 KPasswdServer::findAuthInfoItem(const QString &key, const KIO::AuthInfo &info)
 {
    // qCDebug(category) << "key=" << key << ", user=" << info.username;
 
    AuthInfoContainerList *authList = m_authDict.value(key);
    if (authList)
    {
       QString path2 = info.url.path().left(info.url.path().indexOf(QLatin1Char('/'))+1);
       Q_FOREACH(AuthInfoContainer *current, *authList)
       {
           if (current->expire == AuthInfoContainer::expTime &&
               static_cast<qulonglong>(time(nullptr)) > current->expireTime)
           {
               authList->removeOne(current);
               delete current;
               continue;
           }
 
           if (info.verifyPath)
           {
               QString path1 = current->directory;
               if (path2.startsWith(path1) &&
                   (info.username.isEmpty() || info.username == current->info.username))
                 return current;
           }
           else
           {
               if (current->info.realmValue == info.realmValue &&
                   (info.username.isEmpty() || info.username == current->info.username))
                 return current; // TODO: Update directory info,
           }
       }
    }
    return nullptr;
 }
 
 void
 KPasswdServer::removeAuthInfoItem(const QString &key, const KIO::AuthInfo &info)
 {
    AuthInfoContainerList *authList = m_authDict.value(key);
    if (!authList)
       return;
 
    Q_FOREACH(AuthInfoContainer *current, *authList)
    {
        if (current->info.realmValue == info.realmValue)
        {
           authList->removeOne(current);
           delete current;
        }
    }
    if (authList->isEmpty())
    {
        delete m_authDict.take(key);
    }
 }
 
 
 void
 KPasswdServer::addAuthInfoItem(const QString &key, const KIO::AuthInfo &info, qlonglong windowId, qlonglong seqNr, bool canceled)
 {
    qCDebug(category) << "key=" << key
                        << "window-id=" << windowId
                        << "username=" << info.username
                        << "realm=" << info.realmValue
                        << "seqNr=" << seqNr
                        << "keepPassword?" << info.keepPassword
                        << "canceled?" << canceled;
    AuthInfoContainerList *authList = m_authDict.value(key);
    if (!authList)
    {
       authList = new AuthInfoContainerList;
       m_authDict.insert(key, authList);
    }
    AuthInfoContainer *authItem = nullptr;
    Q_FOREACH(AuthInfoContainer* current, *authList)
    {
        if (current->info.realmValue == info.realmValue)
        {
           authList->removeAll(current);
           authItem = current;
           break;
        }
    }
 
    if (!authItem)
    {
       qCDebug(category) << "Creating AuthInfoContainer";
       authItem = new AuthInfoContainer;
       authItem->expire = AuthInfoContainer::expTime;
    }
 
    authItem->info = info;
    authItem->directory = info.url.path().left(info.url.path().indexOf(QLatin1Char('/'))+1);
    authItem->seqNr = seqNr;
    authItem->isCanceled = canceled;
 
    updateAuthExpire(key, authItem, windowId, (info.keepPassword && !canceled));
 
    // Insert into list, keep the list sorted "longest path" first.
    authList->append(authItem);
    std::sort(authList->begin(), authList->end(), AuthInfoContainer::Sorter());
 }
 
 void
 KPasswdServer::updateAuthExpire(const QString &key, const AuthInfoContainer *auth, qlonglong windowId, bool keep)
 {
    AuthInfoContainer *current = const_cast<AuthInfoContainer *>(auth);
    Q_ASSERT(current);
 
    qCDebug(category) << "key=" << key << "expire=" << current->expire << "window-id=" << windowId << "keep=" << keep;
 
    if (keep && !windowId)
    {
       current->expire = AuthInfoContainer::expNever;
    }
    else if (windowId && (current->expire != AuthInfoContainer::expNever))
    {
       current->expire = AuthInfoContainer::expWindowClose;
       if (!current->windowList.contains(windowId))
          current->windowList.append(windowId);
    }
    else if (current->expire == AuthInfoContainer::expTime)
    {
       current->expireTime = time(nullptr) + 10;
    }
 
    // Update mWindowIdList
    if (windowId)
    {
       QStringList& keysChanged = mWindowIdList[windowId]; // find or insert
       if (!keysChanged.contains(key))
          keysChanged.append(key);
    }
 }
 
 void
 KPasswdServer::removeAuthForWindowId(qlonglong windowId)
 {
    const QStringList keysChanged = mWindowIdList.value(windowId);
    foreach (const QString &key, keysChanged)
    {
       AuthInfoContainerList *authList = m_authDict.value(key);
       if (!authList)
          continue;
 
       QMutableListIterator<AuthInfoContainer*> it (*authList);
       while (it.hasNext())
       {
         AuthInfoContainer* current = it.next();
         if (current->expire == AuthInfoContainer::expWindowClose)
         {
            if (current->windowList.removeAll(windowId) && current->windowList.isEmpty())
            {
               delete current;
               it.remove();
            }
         }
       }
    }
 }
 
 void KPasswdServer::showPasswordDialog (KPasswdServer::Request* request)
 {
     KIO::AuthInfo &info = request->info;
     QString username = info.username;
     QString password = info.password;
     bool hasWalletData = false;
     QMap<QString, QString> knownLogins;
 
 #ifdef HAVE_KF5WALLET
     const bool bypassCacheAndKWallet = info.getExtraField(AUTHINFO_EXTRAFIELD_BYPASS_CACHE_AND_KWALLET).toBool();
     if ( !bypassCacheAndKWallet
         && ( username.isEmpty() || password.isEmpty() )
         && !m_walletDisabled
         && !KWallet::Wallet::keyDoesNotExist(KWallet::Wallet::NetworkWallet(), KWallet::Wallet::PasswordFolder(), makeWalletKey( request->key, info.realmValue )) )
     {
         // no login+pass provided, check if kwallet has one
         if ( openWallet( request->windowId ) )
             hasWalletData = readFromWallet( m_wallet, request->key, info.realmValue, username, password, info.readOnly, knownLogins );
     }
 #endif
 
     // assemble dialog-flags
     KPasswordDialog::KPasswordDialogFlags dialogFlags;
 
     if (info.getExtraField(AUTHINFO_EXTRAFIELD_DOMAIN).isValid())
     {
         dialogFlags |= KPasswordDialog::ShowDomainLine;
         if (info.getExtraFieldFlags(AUTHINFO_EXTRAFIELD_DOMAIN) & KIO::AuthInfo::ExtraFieldReadOnly)
         {
             dialogFlags |= KPasswordDialog::DomainReadOnly;
         }
     }
 
     if (info.getExtraField(AUTHINFO_EXTRAFIELD_ANONYMOUS).isValid())
     {
         dialogFlags |= KPasswordDialog::ShowAnonymousLoginCheckBox;
     }
 
     if (!info.getExtraField(AUTHINFO_EXTRAFIELD_HIDE_USERNAME_INPUT).toBool())
     {
         dialogFlags |= KPasswordDialog::ShowUsernameLine;
     }
 
 #ifdef HAVE_KF5WALLET
     // If wallet is not enabled and the caller explicitly requested for it,
     // do not show the keep password checkbox.
     if (info.keepPassword && KWallet::Wallet::isEnabled())
         dialogFlags |= KPasswordDialog::ShowKeepPassword;
 #endif
 
     // instantiate dialog
 #ifndef Q_WS_WIN
     qCDebug(category) << "Widget for" << request->windowId << QWidget::find(request->windowId);
 #else
     qCDebug(category) << "Widget for" << request->windowId << QWidget::find((HWND)request->windowId);
 #endif
 
     KPasswordDialog* dlg = new KPasswordDialog(nullptr, dialogFlags);
     connect(dlg, &QDialog::finished, this, &KPasswdServer::passwordDialogDone);
     connect(this, &QObject::destroyed, dlg, &QObject::deleteLater);
 
     dlg->setPrompt(info.prompt);
     dlg->setUsername(username);
     if (info.caption.isEmpty())
         dlg->setWindowTitle( i18n("Authentication Dialog") );
     else
         dlg->setWindowTitle( info.caption );
 
     if ( !info.comment.isEmpty() )
         dlg->addCommentLine( info.commentLabel, info.comment );
 
     if ( !password.isEmpty() )
         dlg->setPassword( password );
 
     if (info.readOnly)
         dlg->setUsernameReadOnly( true );
     else
         dlg->setKnownLogins( knownLogins );
 
     if (hasWalletData)
         dlg->setKeepPassword( true );
 
     if (info.getExtraField(AUTHINFO_EXTRAFIELD_DOMAIN).isValid ())
         dlg->setDomain(info.getExtraField(AUTHINFO_EXTRAFIELD_DOMAIN).toString());
 
     if (info.getExtraField(AUTHINFO_EXTRAFIELD_ANONYMOUS).isValid () && password.isEmpty() && username.isEmpty())
         dlg->setAnonymousMode(info.getExtraField(AUTHINFO_EXTRAFIELD_ANONYMOUS).toBool());
 
 #ifndef Q_OS_MACOS
 #ifndef Q_WS_WIN
     KWindowSystem::setMainWindow(dlg, request->windowId);
 #else
     KWindowSystem::setMainWindow(dlg, (HWND)request->windowId);
 #endif
 #else
     KWindowSystem::forceActiveWindow(dlg->winId(), 0);
 #endif
 
     qCDebug(category) << "Showing password dialog" << dlg << ", window-id=" << request->windowId;
     m_authInProgress.insert(dlg, request);
     dlg->open();
 }
 
 
 void KPasswdServer::sendResponse (KPasswdServer::Request* request)
 {
     Q_ASSERT(request);
     if (!request) {
         return;
     }
 
     qCDebug(category) << "key=" << request->key;
     if (request->isAsync) {
         emit queryAuthInfoAsyncResult(request->requestId, m_seqNr, request->info);
     } else {
         QByteArray replyData;
         QDataStream stream2(&replyData, QIODevice::WriteOnly);
         stream2 << request->info;
         QDBusConnection::sessionBus().send(request->transaction.createReply(QVariantList() << replyData << m_seqNr));
     }
 
     // Check all requests in the wait queue.
     Request *waitRequest;
     QMutableListIterator<Request*> it(m_authWait);
     while (it.hasNext()) {
         waitRequest = it.next();
 
         if (!hasPendingQuery(waitRequest->key, waitRequest->info))
         {
             const AuthInfoContainer *result = findAuthInfoItem(waitRequest->key,
                                                                waitRequest->info);
             QByteArray replyData;
 
             QDataStream stream2(&replyData, QIODevice::WriteOnly);
 
             KIO::AuthInfo rcinfo;
             if (!result || result->isCanceled)
             {
                 waitRequest->info.setModified(false);
                 stream2 << waitRequest->info;
             }
             else
             {
                 updateAuthExpire(waitRequest->key, result, waitRequest->windowId, false);
                 copyAuthInfo(result, rcinfo);
                 stream2 << rcinfo;
             }
 
             if (waitRequest->isAsync) {
                 emit checkAuthInfoAsyncResult(waitRequest->requestId, m_seqNr, rcinfo);
             } else {
                 QDBusConnection::sessionBus().send(waitRequest->transaction.createReply(QVariantList() << replyData << m_seqNr));
             }
 
             delete waitRequest;
             it.remove();
         }
     }
 
     // Re-enable password request processing for the current window id again.
     m_authPrompted.removeAll(QString::number(request->windowId));
     m_authPrompted.removeAll(request->key);
 
-    if (m_authPending.count())
+    if (!m_authPending.isEmpty())
        QTimer::singleShot(0, this, &KPasswdServer::processRequest);
 }
 
 void KPasswdServer::passwordDialogDone(int result)
 {
     KPasswordDialog* dlg = qobject_cast<KPasswordDialog*>(sender());
     Q_ASSERT(dlg);
 
     QScopedPointer<Request> request (m_authInProgress.take(dlg));
     Q_ASSERT(request);  // request should never be nullptr.
 
     if (request) {
         KIO::AuthInfo& info = request->info;
         const bool bypassCacheAndKWallet = info.getExtraField(AUTHINFO_EXTRAFIELD_BYPASS_CACHE_AND_KWALLET).toBool();
 
         qCDebug(category) << "dialog result=" << result << ", bypassCacheAndKWallet?" << bypassCacheAndKWallet;
         if (dlg && result == QDialog::Accepted) {
             Q_ASSERT(dlg);
             info.username = dlg->username();
             info.password = dlg->password();
             info.keepPassword = dlg->keepPassword();
 
             if (info.getExtraField(AUTHINFO_EXTRAFIELD_DOMAIN).isValid ())
                 info.setExtraField(AUTHINFO_EXTRAFIELD_DOMAIN, dlg->domain());
             if (info.getExtraField(AUTHINFO_EXTRAFIELD_ANONYMOUS).isValid ())
                 info.setExtraField(AUTHINFO_EXTRAFIELD_ANONYMOUS, dlg->anonymousMode());
 
             // When the user checks "keep password", that means:
             // * if the wallet is enabled, store it there for long-term, and in kpasswdserver
             // only for the duration of the window (#92928)
             // * otherwise store in kpasswdserver for the duration of the KDE session.
             if (!bypassCacheAndKWallet) {
                 /*
                   NOTE: The following code changes the key under which the auth
                   info is stored in memory if the request url contains a username.
                   e.g. "ftp://user@localhost", but the user changes that username
                   in the password dialog.
 
                   Since the key generated to store the credential contains the
                   username from the request URL, the key must be updated on such
                   changes. Otherwise, the key will not be found on subsequent
                   requests and the user will be end up being prompted over and
                   over to re-enter the password unnecessarily.
                 */
                 if (!info.url.userName().isEmpty() && info.username != info.url.userName()) {
                     const QString oldKey(request->key);
                     removeAuthInfoItem(oldKey, info);
                     info.url.setUserName(info.username);
                     request->key = createCacheKey(info);
                     updateCachedRequestKey(m_authPending, oldKey, request->key);
                     updateCachedRequestKey(m_authWait, oldKey, request->key);
                 }
 
 #ifdef HAVE_KF5WALLET
                 const bool skipAutoCaching = info.getExtraField(AUTHINFO_EXTRAFIELD_SKIP_CACHING_ON_QUERY).toBool();
                 if (!skipAutoCaching && info.keepPassword && openWallet(request->windowId)) {
                     if ( storeInWallet( m_wallet, request->key, info ) )
                         // password is in wallet, don't keep it in memory after window is closed
                         info.keepPassword = false;
                 }
 #endif
                 addAuthInfoItem(request->key, info, request->windowId, m_seqNr, false);
             }
             info.setModified( true );
         } else {
             if (!bypassCacheAndKWallet && request->prompt) {
                 addAuthInfoItem(request->key, info, 0, m_seqNr, true);
             }
             info.setModified( false );
         }
 
         sendResponse(request.data());
     }
 
     dlg->deleteLater();
 }
 
 void KPasswdServer::retryDialogDone(int result)
 {
     QDialog* dlg = qobject_cast<QDialog*>(sender());
     Q_ASSERT(dlg);
 
     QScopedPointer<Request> request (m_authRetryInProgress.take(dlg));
     Q_ASSERT(request);
 
     if (request) {
         if (result == QDialogButtonBox::Yes) {
             showPasswordDialog(request.take());
         } else {
             // NOTE: If the user simply cancels the retry dialog, we remove the
             // credential stored under this key because the original attempt to
             // use it has failed. Otherwise, the failed credential would be cached
             // and used subsequently.
             //
             // TODO: decide whether it should be removed from the wallet too.
             KIO::AuthInfo& info = request->info;
             removeAuthInfoItem(request->key, request->info);
             info.setModified(false);
             sendResponse(request.data());
         }
     }
 }
 
 void KPasswdServer::windowRemoved (WId id)
 {
     bool foundMatch = false;
     if (!m_authInProgress.isEmpty()) {
         const qlonglong windowId = (qlonglong)(id);
         QMutableHashIterator<QObject*, Request*> it (m_authInProgress);
         while (it.hasNext()) {
             it.next();
             if (it.value()->windowId == windowId) {
                 Request* request = it.value();
                 QObject* obj = it.key();
                 it.remove();
                 m_authPrompted.removeAll(QString::number(request->windowId));
                 m_authPrompted.removeAll(request->key);
                 delete obj;
                 delete request;
                 foundMatch = true;
             }
         }
     }
 
     if (!foundMatch && !m_authRetryInProgress.isEmpty()) {
         const qlonglong windowId = (qlonglong)(id);
         QMutableHashIterator<QObject*, Request*> it (m_authRetryInProgress);
         while (it.hasNext()) {
             it.next();
             if (it.value()->windowId == windowId) {
                 Request* request = it.value();
                 QObject* obj = it.key();
                 it.remove();
                 delete obj;
                 delete request;
             }
         }
     }
 }
 
 void KPasswdServer::updateCachedRequestKey (QList<KPasswdServer::Request*>& list, const QString& oldKey, const QString& newKey)
 {
     QListIterator<Request*> it (list);
     while (it.hasNext()) {
         Request* r = it.next();
         if (r->key == oldKey) {
             r->key = newKey;
         }
     }
 }
 
diff --git a/src/urifilters/ikws/ikwsopts.cpp b/src/urifilters/ikws/ikwsopts.cpp
index c4ab97dc..c9dbd7c8 100644
--- a/src/urifilters/ikws/ikwsopts.cpp
+++ b/src/urifilters/ikws/ikwsopts.cpp
@@ -1,453 +1,453 @@
 /*
  * Copyright (c) 2000 Yves Arrouye <yves@realnames.com>
  * Copyright (c) 2001, 2002 Dawit Alemayehu <adawit@kde.org>
  * Copyright (c) 2009 Nick Shaforostoff <shaforostoff@kde.ru>
  *
  *  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.
  */
 
 #include "ikwsopts.h"
 #include "ikwsopts_p.h"
 
 #include "kuriikwsfiltereng.h"
 #include "searchprovider.h"
 #include "searchproviderdlg.h"
 
 #include <KBuildSycocaProgressDialog>
 #include <klocalizedstring.h>
 #include <kconfiggroup.h>
 #include <ksharedconfig.h>
 
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QFile>
 #include <QSortFilterProxyModel>
 
 
 
 //BEGIN ProvidersModel
 
 ProvidersModel::~ProvidersModel()
 {
 
 }
 
 QVariant ProvidersModel::headerData(int section, Qt::Orientation orientation, int role ) const
 {
   Q_UNUSED(orientation);
   if (role == Qt::DisplayRole)
   {
     switch (section) {
     case Name:
       return i18nc("@title:column Name label from web shortcuts column", "Name");
     case Shortcuts:
       return i18nc("@title:column", "Shortcuts");
     case Preferred:
       return i18nc("@title:column", "Preferred");
     default:
       break;
     }
   }
   return QVariant();
 }
 
 Qt::ItemFlags ProvidersModel::flags(const QModelIndex& index) const
 {
   if (!index.isValid())
     return Qt::ItemIsEnabled;
   if (index.column()==Preferred)
     return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsUserCheckable;
   return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 }
 
 bool ProvidersModel::setData (const QModelIndex& index, const QVariant& value, int role)
 {
   if (role==Qt::CheckStateRole)
   {
     if (value.toInt() == Qt::Checked)
         m_favoriteEngines.insert(m_providers.at(index.row())->desktopEntryName());
     else
         m_favoriteEngines.remove(m_providers.at(index.row())->desktopEntryName());
     emit dataModified();
     return true;
   }
   return false;
 }
 
 QVariant ProvidersModel::data(const QModelIndex& index, int role) const
 {
   if (index.isValid())
   {
     if (role == Qt::CheckStateRole && index.column()==Preferred)
       return (m_favoriteEngines.contains(m_providers.at(index.row())->desktopEntryName()) ? Qt::Checked : Qt::Unchecked);
 
     if (role == Qt::DisplayRole)
     {
       if (index.column()==Name)
         return m_providers.at(index.row())->name();
       if (index.column()==Shortcuts)
         return m_providers.at(index.row())->keys().join(QLatin1Char(','));
     }
 
     if (role == Qt::ToolTipRole || role == Qt::WhatsThisRole)
     {
       if (index.column() == Preferred)
         return xi18nc("@info:tooltip", "Check this box to select the highlighted web shortcut "
                     "as preferred.<nl/>Preferred web shortcuts are used in "
                     "places where only a few select shortcuts can be shown "
                     "at one time.");
     }
 
     if (role == Qt::UserRole)
       return index.row();//a nice way to bypass proxymodel
   }
 
   return QVariant();
 }
 
 void ProvidersModel::setProviders(const QList<SearchProvider*>& providers, const QStringList& favoriteEngines)
 {
   m_providers = providers;
   setFavoriteProviders(favoriteEngines);
 }
 
 void ProvidersModel::setFavoriteProviders(const QStringList& favoriteEngines)
 {
   beginResetModel();
   m_favoriteEngines = QSet<QString>::fromList(favoriteEngines);
   endResetModel();
 }
 
 int ProvidersModel::rowCount(const QModelIndex & parent) const
 {
   if (parent.isValid())
     return 0;
   return m_providers.size();
 }
 
 QAbstractListModel* ProvidersModel::createListModel()
 {
   ProvidersListModel* pListModel = new ProvidersListModel(m_providers, this);
   connect(this, &QAbstractItemModel::modelAboutToBeReset,   pListModel, &QAbstractItemModel::modelAboutToBeReset);
   connect(this, &QAbstractItemModel::modelReset,            pListModel, &QAbstractItemModel::modelReset);
   // TODO: next two are private signals, does this still work? and is this needed?
   connect(this, SIGNAL(layoutAboutToBeChanged()),     pListModel, SIGNAL(modelReset()));
   connect(this, SIGNAL(layoutChanged()),              pListModel, SIGNAL(modelReset()));
   connect(this, &QAbstractItemModel::dataChanged,           pListModel, &ProvidersListModel::emitDataChanged);
   connect(this, &QAbstractItemModel::rowsAboutToBeInserted, pListModel, &ProvidersListModel::emitRowsAboutToBeInserted);
   connect(this, &QAbstractItemModel::rowsAboutToBeRemoved,  pListModel, &ProvidersListModel::emitRowsAboutToBeRemoved);
   connect(this, &QAbstractItemModel::rowsInserted,          pListModel, &ProvidersListModel::emitRowsInserted);
   connect(this, &QAbstractItemModel::rowsRemoved,           pListModel, &ProvidersListModel::emitRowsRemoved);
 
   return pListModel;
 }
 
 void ProvidersModel::deleteProvider(SearchProvider* p)
 {
   const int row = m_providers.indexOf(p);
   beginRemoveRows(QModelIndex(), row, row);
   m_favoriteEngines.remove(m_providers.takeAt(row)->desktopEntryName());
   endRemoveRows();
   delete p;
   emit dataModified();
 }
 
 void ProvidersModel::addProvider(SearchProvider* p)
 {
   beginInsertRows(QModelIndex(), m_providers.size(), m_providers.size());
   m_providers.append(p);
   endInsertRows();
   emit dataModified();
 }
 
 void ProvidersModel::changeProvider(SearchProvider* p)
 {
   const int row = m_providers.indexOf(p);
   emit dataChanged(index(row,0),index(row,ColumnCount-1));
   emit dataModified();
 }
 
 QStringList ProvidersModel::favoriteEngines() const
 {
   return m_favoriteEngines.toList();
 }
 //END ProvidersModel
 
 //BEGIN ProvidersListModel
 ProvidersListModel::ProvidersListModel(QList<SearchProvider*>& providers,  QObject* parent)
     : QAbstractListModel(parent)
     , m_providers(providers)
 {}
 
 QVariant ProvidersListModel::data(const QModelIndex& index, int role) const
 {
   if (index.isValid())
   {
     if (role==Qt::DisplayRole)
     {
       if (index.row() == m_providers.size())
         return i18nc("@item:inlistbox No default web shortcut", "None");
       return m_providers.at(index.row())->name();
     }
 
     if (role==ShortNameRole)
     {
       if (index.row() == m_providers.size())
         return QString();
       return m_providers.at(index.row())->desktopEntryName();
     }
   }
   return QVariant();
 }
 
 int ProvidersListModel::rowCount (const QModelIndex& parent) const
 {
   if (parent.isValid())
     return 0;
   return m_providers.size() + 1;
 }
 //END ProvidersListModel
 
 static QSortFilterProxyModel* wrapInProxyModel(QAbstractItemModel* model)
 {
   QSortFilterProxyModel* proxyModel = new QSortFilterProxyModel(model);
   proxyModel->setSourceModel(model);
   proxyModel->setDynamicSortFilter(true);
   proxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
   proxyModel->setFilterCaseSensitivity(Qt::CaseInsensitive);
   proxyModel->setFilterKeyColumn(-1);
   return proxyModel;
 }
 
 FilterOptions::FilterOptions(const KAboutData* about, QWidget *parent)
               : KCModule(about, parent),
                 m_providersModel(new ProvidersModel(this))
 {
   m_dlg.setupUi(this);
 
   QSortFilterProxyModel* searchProviderModel = wrapInProxyModel(m_providersModel);
   m_dlg.lvSearchProviders->setModel(searchProviderModel);
   m_dlg.cmbDefaultEngine->setModel(wrapInProxyModel(m_providersModel->createListModel()));
 
   // Connect all the signals/slots...
   connect(m_dlg.cbEnableShortcuts,  &QAbstractButton::toggled, this, QOverload<>::of(&FilterOptions::changed));
   connect(m_dlg.cbEnableShortcuts, &QAbstractButton::toggled, this, &FilterOptions::updateSearchProviderEditingButons);
   connect(m_dlg.cbUseSelectedShortcutsOnly,  &QAbstractButton::toggled, this, QOverload<>::of(&FilterOptions::changed));
 
   connect(m_providersModel, &ProvidersModel::dataModified, this, QOverload<>::of(&FilterOptions::changed));
   connect(m_dlg.cmbDefaultEngine, QOverload<int>::of(&QComboBox::currentIndexChanged), this, QOverload<>::of(&FilterOptions::changed));
   connect(m_dlg.cmbDelimiter,     QOverload<int>::of(&QComboBox::currentIndexChanged), this, QOverload<>::of(&FilterOptions::changed));
 
   connect(m_dlg.pbNew,    &QAbstractButton::clicked, this, &FilterOptions::addSearchProvider);
   connect(m_dlg.pbDelete, &QAbstractButton::clicked, this, &FilterOptions::deleteSearchProvider);
   connect(m_dlg.pbChange, &QAbstractButton::clicked, this, &FilterOptions::changeSearchProvider);
   connect(m_dlg.lvSearchProviders->selectionModel(), &QItemSelectionModel::currentChanged,
            this, &FilterOptions::updateSearchProviderEditingButons);
   connect(m_dlg.lvSearchProviders, &QAbstractItemView::doubleClicked,this, &FilterOptions::changeSearchProvider);
   connect(m_dlg.searchLineEdit, &QLineEdit::textEdited, searchProviderModel, &QSortFilterProxyModel::setFilterFixedString);
 }
 
 QString FilterOptions::quickHelp() const
 {
   return xi18nc("@info:whatsthis", "<para>In this module you can configure the web shortcuts feature. "
               "Web shortcuts allow you to quickly search or lookup words on "
               "the Internet. For example, to search for information about the "
               "KDE project using the Google engine, you simply type <emphasis>gg:KDE</emphasis> "
               "or <emphasis>google:KDE</emphasis>.</para>"
               "<para>If you select a default search engine, then you can search for "
               "normal words or phrases by simply typing them into the input widget "
               "of applications that have built-in support for such a feature, e.g "
               "Konqueror.</para>");
 }
 
 void FilterOptions::setDefaultEngine(int index)
 {
   QSortFilterProxyModel* proxy = qobject_cast<QSortFilterProxyModel*>(m_dlg.cmbDefaultEngine->model());
   if (index == -1)
     index = proxy->rowCount()-1;//"None" is the last
 
   const QModelIndex modelIndex = proxy->mapFromSource(proxy->sourceModel()->index(index,0));
   m_dlg.cmbDefaultEngine->setCurrentIndex(modelIndex.row());
   m_dlg.cmbDefaultEngine->view()->setCurrentIndex(modelIndex);  //TODO: remove this when Qt bug is fixed
 }
 
 void FilterOptions::load()
 {
   KConfig config(QString::fromUtf8(KURISearchFilterEngine::self()->name()) + QLatin1String("rc"), KConfig::NoGlobals);
   KConfigGroup group = config.group("General");
 
   const QString defaultSearchEngine = group.readEntry("DefaultWebShortcut");
   const QStringList favoriteEngines = group.readEntry("PreferredWebShortcuts", DEFAULT_PREFERRED_SEARCH_PROVIDERS);
 
   const QList<SearchProvider*> providers = m_registry.findAll();
   int defaultProviderIndex = providers.size(); //default is "None", it is last in the list
 
   for (SearchProvider *provider : providers)
   {
     if (defaultSearchEngine == provider->desktopEntryName())
       defaultProviderIndex = providers.size();
   }
 
   m_providersModel->setProviders(providers, favoriteEngines);
   m_dlg.lvSearchProviders->setColumnWidth(0,200);
   m_dlg.lvSearchProviders->resizeColumnToContents(1);
   m_dlg.lvSearchProviders->sortByColumn(0,Qt::AscendingOrder);
   m_dlg.cmbDefaultEngine->model()->sort(0,Qt::AscendingOrder);
   setDefaultEngine(defaultProviderIndex);
 
   m_dlg.cbEnableShortcuts->setChecked(group.readEntry("EnableWebShortcuts", true));
   m_dlg.cbUseSelectedShortcutsOnly->setChecked(group.readEntry("UsePreferredWebShortcutsOnly", false));
 
   const QString delimiter = group.readEntry ("KeywordDelimiter", ":");
   setDelimiter(delimiter.at(0).toLatin1());
 }
 
 char FilterOptions::delimiter()
 {
   const char delimiters[]={':',' '};
   return delimiters[m_dlg.cmbDelimiter->currentIndex()];
 }
 
 void FilterOptions::setDelimiter (char sep)
 {
   m_dlg.cmbDelimiter->setCurrentIndex(sep==' ');
 }
 
 void FilterOptions::save()
 {
   KConfig config(QString::fromUtf8(KURISearchFilterEngine::self()->name()) + QLatin1String("rc"), KConfig::NoGlobals );
 
   KConfigGroup group = config.group("General");
   group.writeEntry("EnableWebShortcuts", m_dlg.cbEnableShortcuts->isChecked());
   group.writeEntry("KeywordDelimiter", QString(QLatin1Char(delimiter())));
   group.writeEntry("DefaultWebShortcut", m_dlg.cmbDefaultEngine->view()->currentIndex().data(ProvidersListModel::ShortNameRole));
   group.writeEntry("PreferredWebShortcuts", m_providersModel->favoriteEngines());
   group.writeEntry("UsePreferredWebShortcutsOnly", m_dlg.cbUseSelectedShortcutsOnly->isChecked());
 
   int changedProviderCount = 0;
   QList<SearchProvider*> providers = m_providersModel->providers();
   const QString path = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation) + QLatin1String("/kservices5/searchproviders/");
 
   Q_FOREACH(SearchProvider* provider, providers)
   {
     if (!provider->isDirty())
       continue;
 
     changedProviderCount++;
 
     KConfig _service(path + provider->desktopEntryName() + QLatin1String(".desktop"), KConfig::SimpleConfig);
     KConfigGroup service(&_service, "Desktop Entry");
     service.writeEntry("Type", "Service");
     service.writeEntry("X-KDE-ServiceTypes", "SearchProvider");
     service.writeEntry("Name", provider->name());
     service.writeEntry("Query", provider->query());
     service.writeEntry("Keys", provider->keys());
     service.writeEntry("Charset", provider->charset());
     service.writeEntry("Hidden", false); // we might be overwriting a hidden entry
   }
  
  const QStringList servicesDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("kservices5/searchproviders/"), QStandardPaths::LocateDirectory);
   Q_FOREACH(const QString& providerName, m_deletedProviders)
   {
     QStringList matches;
     foreach(const QString& dir, servicesDirs) {
       QString current = dir + QLatin1Char('/') + providerName + QLatin1String(".desktop");
       if(QFile::exists(current))
         matches += current;
     }
 
     // Shouldn't happen
-    if (!matches.size())
+    if (matches.isEmpty())
       continue;
 
     changedProviderCount++;
 
     if (matches.size() == 1 && matches.first().startsWith(path))
     {
       // If only the local copy existed, unlink it
       // TODO: error handling
       QFile::remove(matches.first());
       continue;
     }
 
     KConfig _service(path + providerName + QLatin1String(".desktop"), KConfig::SimpleConfig);
     KConfigGroup service(&_service,     "Desktop Entry");
     service.writeEntry("Type",          "Service");
     service.writeEntry("X-KDE-ServiceTypes",  "SearchProvider");
     service.writeEntry("Hidden",        true);
   }
 
   config.sync();
 
   emit changed(false);
 
   // Update filters in running applications...
   QDBusMessage msg = QDBusMessage::createSignal(QStringLiteral("/"), QStringLiteral("org.kde.KUriFilterPlugin"), QStringLiteral("configure"));
   QDBusConnection::sessionBus().send(msg);
 
   // If the providers changed, tell sycoca to rebuild its database...
   if (changedProviderCount)
     KBuildSycocaProgressDialog::rebuildKSycoca(this);
 }
 
 void FilterOptions::defaults()
 {
   m_dlg.cbEnableShortcuts->setChecked(true);
   m_dlg.cbUseSelectedShortcutsOnly->setChecked(false);
   m_providersModel->setFavoriteProviders(DEFAULT_PREFERRED_SEARCH_PROVIDERS);
   setDelimiter(':');
   setDefaultEngine(-1);
 }
 
 void FilterOptions::addSearchProvider()
 {
   QList<SearchProvider*> providers = m_providersModel->providers();
   QPointer<SearchProviderDialog> dlg = new SearchProviderDialog(nullptr, providers, this);
 
   if (dlg->exec()) {
     m_providersModel->addProvider(dlg->provider());
     m_providersModel->changeProvider(dlg->provider());
   }
   delete dlg;
 }
 
 void FilterOptions::changeSearchProvider()
 {
   QList<SearchProvider*> providers = m_providersModel->providers();
   SearchProvider* provider = providers.at(m_dlg.lvSearchProviders->currentIndex().data(Qt::UserRole).toInt());
   QPointer<SearchProviderDialog> dlg = new SearchProviderDialog(provider, providers, this);
 
   if (dlg->exec())
     m_providersModel->changeProvider(dlg->provider());
 
   delete dlg;
 }
 
 void FilterOptions::deleteSearchProvider()
 {
   SearchProvider* provider = m_providersModel->providers().at(m_dlg.lvSearchProviders->currentIndex().data(Qt::UserRole).toInt());
   m_deletedProviders.append(provider->desktopEntryName());
   m_providersModel->deleteProvider(provider);
 }
 
 void FilterOptions::updateSearchProviderEditingButons()
 {
   const bool enable = (m_dlg.cbEnableShortcuts->isChecked() &&
                        m_dlg.lvSearchProviders->currentIndex().isValid());
   m_dlg.pbChange->setEnabled(enable);
   m_dlg.pbDelete->setEnabled(enable);
 }
 
 // kate: replace-tabs 1; indent-width 2;
diff --git a/src/widgets/kdirmodel.cpp b/src/widgets/kdirmodel.cpp
index 81202854..c2323d22 100644
--- a/src/widgets/kdirmodel.cpp
+++ b/src/widgets/kdirmodel.cpp
@@ -1,1296 +1,1296 @@
 /* This file is part of the KDE project
    Copyright (C) 2006 David Faure <faure@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "kdirmodel.h"
 #include "kdirlister.h"
 #include "kfileitem.h"
 #include "kio_widgets_debug.h"
 #include <klocalizedstring.h>
 #include <kjobuidelegate.h>
 #include <kio/simplejob.h>
 #include <kio/fileundomanager.h>
 #include "joburlcache_p.h"
 #include <kurlmimedata.h>
 #include <kiconloader.h>
 #include <QMimeData>
 #include <QBitArray>
 #include <QDebug>
 #include <QFile>
 #include <QFileInfo>
 #include <QDir>
 #include <QIcon>
 #include <QLocale>
 #include <qplatformdefs.h>
 
 #include <algorithm>
 
 #ifdef Q_OS_WIN
 #include <qt_windows.h>
 #endif
 
 class KDirModelNode;
 class KDirModelDirNode;
 
 static QUrl cleanupUrl(const QUrl &url)
 {
     QUrl u = url;
     u.setPath(QDir::cleanPath(u.path())); // remove double slashes in the path, simplify "foo/." to "foo/", etc.
     u = u.adjusted(QUrl::StripTrailingSlash); // KDirLister does this too, so we remove the slash before comparing with the root node url.
     u.setQuery(QString());
     u.setFragment(QString());
     return u;
 }
 
 // We create our own tree behind the scenes to have fast lookup from an item to its parent,
 // and also to get the children of an item fast.
 class KDirModelNode
 {
 public:
     KDirModelNode(KDirModelDirNode *parent, const KFileItem &item) :
         m_item(item),
         m_parent(parent),
         m_preview()
     {
     }
     virtual ~KDirModelNode()
     {
         // Required, code will delete ptrs to this or a subclass.
     }
     // m_item is KFileItem() for the root item
     const KFileItem &item() const
     {
         return m_item;
     }
     void setItem(const KFileItem &item)
     {
         m_item = item;
     }
     KDirModelDirNode *parent() const
     {
         return m_parent;
     }
     // linear search
     int rowNumber() const; // O(n)
     QIcon preview() const
     {
         return m_preview;
     }
     void setPreview(const QPixmap &pix)
     {
         m_preview = QIcon();
         m_preview.addPixmap(pix);
     }
     void setPreview(const QIcon &icn)
     {
         m_preview = icn;
     }
 
 private:
     KFileItem m_item;
     KDirModelDirNode *const m_parent;
     QIcon m_preview;
 };
 
 // Specialization for directory nodes
 class KDirModelDirNode : public KDirModelNode
 {
 public:
     KDirModelDirNode(KDirModelDirNode *parent, const KFileItem &item)
         : KDirModelNode(parent, item),
           m_childNodes(),
           m_childCount(KDirModel::ChildCountUnknown),
           m_populated(false)
     {}
     ~KDirModelDirNode() override
     {
         qDeleteAll(m_childNodes);
     }
     QList<KDirModelNode *> m_childNodes; // owns the nodes
 
     // If we listed the directory, the child count is known. Otherwise it can be set via setChildCount.
     int childCount() const
     {
         return m_childNodes.isEmpty() ? m_childCount : m_childNodes.count();
     }
     void setChildCount(int count)
     {
         m_childCount = count;
     }
     bool isPopulated() const
     {
         return m_populated;
     }
     void setPopulated(bool populated)
     {
         m_populated = populated;
     }
     bool isSlow() const
     {
         return item().isSlow();
     }
 
     // For removing all child urls from the global hash.
     void collectAllChildUrls(QList<QUrl> &urls) const
     {
         urls.reserve(urls.size() + m_childNodes.size());
         Q_FOREACH (KDirModelNode *node, m_childNodes) {
             const KFileItem &item = node->item();
             urls.append(cleanupUrl(item.url()));
             if (item.isDir()) {
                 static_cast<KDirModelDirNode *>(node)->collectAllChildUrls(urls);
             }
         }
     }
 
 private:
     int m_childCount: 31;
     bool m_populated: 1;
 };
 
 int KDirModelNode::rowNumber() const
 {
     if (!m_parent) {
         return 0;
     }
     return m_parent->m_childNodes.indexOf(const_cast<KDirModelNode *>(this));
 }
 
 ////
 
 class KDirModelPrivate
 {
 public:
     explicit KDirModelPrivate(KDirModel *model)
         : q(model), m_dirLister(nullptr),
           m_rootNode(new KDirModelDirNode(nullptr, KFileItem())),
           m_dropsAllowed(KDirModel::NoDrops), m_jobTransfersVisible(false)
     {
     }
     ~KDirModelPrivate()
     {
         delete m_rootNode;
     }
 
     void _k_slotNewItems(const QUrl &directoryUrl, const KFileItemList &);
     void _k_slotDeleteItems(const KFileItemList &);
     void _k_slotRefreshItems(const QList<QPair<KFileItem, KFileItem> > &);
     void _k_slotClear();
     void _k_slotRedirection(const QUrl &oldUrl, const QUrl &newUrl);
     void _k_slotJobUrlsChanged(const QStringList &urlList);
 
     void clear()
     {
         delete m_rootNode;
         m_rootNode = new KDirModelDirNode(nullptr, KFileItem());
     }
     // Emit expand for each parent and then return the
     // last known parent if there is no node for this url
     KDirModelNode *expandAllParentsUntil(const QUrl &url) const;
 
     // Return the node for a given url, using the hash.
     KDirModelNode *nodeForUrl(const QUrl &url) const;
     KDirModelNode *nodeForIndex(const QModelIndex &index) const;
     QModelIndex indexForNode(KDirModelNode *node, int rowNumber = -1 /*unknown*/) const;
     bool isDir(KDirModelNode *node) const
     {
         return (node == m_rootNode) || node->item().isDir();
     }
     QUrl urlForNode(KDirModelNode *node) const
     {
         /**
          * Queries and fragments are removed from the URL, so that the URL of
          * child items really starts with the URL of the parent.
          *
          * For instance ksvn+http://url?rev=100 is the parent for ksvn+http://url/file?rev=100
          * so we have to remove the query in both to be able to compare the URLs
          */
         QUrl url(node == m_rootNode ? m_dirLister->url() : node->item().url());
         if (url.hasQuery() || url.hasFragment()) { // avoid detach if not necessary.
             url.setQuery(QString());
             url.setFragment(QString()); // kill ref (#171117)
         }
         return url;
     }
     void removeFromNodeHash(KDirModelNode *node, const QUrl &url);
     void clearAllPreviews(KDirModelDirNode *node);
 #ifndef NDEBUG
     void dump();
 #endif
 
     KDirModel * const q;
     KDirLister *m_dirLister;
     KDirModelDirNode *m_rootNode;
     KDirModel::DropsAllowed m_dropsAllowed;
     bool m_jobTransfersVisible;
     // key = current known parent node (always a KDirModelDirNode but KDirModelNode is more convenient),
     // value = final url[s] being fetched
     QMap<KDirModelNode *, QList<QUrl> > m_urlsBeingFetched;
     QHash<QUrl, KDirModelNode *> m_nodeHash; // global node hash: url -> node
     QStringList m_allCurrentDestUrls; //list of all dest urls that have jobs on them (e.g. copy, download)
 };
 
 KDirModelNode *KDirModelPrivate::nodeForUrl(const QUrl &_url) const // O(1), well, O(length of url as a string)
 {
     QUrl url = cleanupUrl(_url);
     if (url == urlForNode(m_rootNode)) {
         return m_rootNode;
     }
     return m_nodeHash.value(url);
 }
 
 void KDirModelPrivate::removeFromNodeHash(KDirModelNode *node, const QUrl &url)
 {
     if (node->item().isDir()) {
         QList<QUrl> urls;
         static_cast<KDirModelDirNode *>(node)->collectAllChildUrls(urls);
         Q_FOREACH (const QUrl &u, urls) {
             m_nodeHash.remove(u);
         }
     }
     m_nodeHash.remove(cleanupUrl(url));
 }
 
 KDirModelNode *KDirModelPrivate::expandAllParentsUntil(const QUrl &_url) const // O(depth)
 {
     QUrl url = cleanupUrl(_url);
 
     //qDebug() << url;
     QUrl nodeUrl = urlForNode(m_rootNode);
     if (url == nodeUrl) {
         return m_rootNode;
     }
 
     // Protocol mismatch? Don't even start comparing paths then. #171721
     if (url.scheme() != nodeUrl.scheme()) {
         return nullptr;
     }
 
     const QString pathStr = url.path(); // no trailing slash
     KDirModelDirNode *dirNode = m_rootNode;
 
     if (!pathStr.startsWith(nodeUrl.path())) {
         return nullptr;
     }
 
     for (;;) {
         QString nodePath = nodeUrl.path();
         if (!nodePath.endsWith(QLatin1Char('/'))) {
             nodePath += QLatin1Char('/');
         }
         if (!pathStr.startsWith(nodePath)) {
             qCWarning(KIO_WIDGETS) << "The kioslave for" << url.scheme() << "violates the hierarchy structure:"
                        << "I arrived at node" << nodePath << ", but" << pathStr << "does not start with that path.";
             return nullptr;
         }
 
         // E.g. pathStr is /a/b/c and nodePath is /a/. We want to find the node with url /a/b
         const int nextSlash = pathStr.indexOf(QLatin1Char('/'), nodePath.length());
         const QString newPath = pathStr.left(nextSlash); // works even if nextSlash==-1
         nodeUrl.setPath(newPath);
         nodeUrl = nodeUrl.adjusted(QUrl::StripTrailingSlash); // #172508
         KDirModelNode *node = nodeForUrl(nodeUrl);
         if (!node) {
             //qDebug() << "child equal or starting with" << url << "not found";
             // return last parent found:
             return dirNode;
         }
 
         emit q->expand(indexForNode(node));
 
         //qDebug() << " nodeUrl=" << nodeUrl;
         if (nodeUrl == url) {
             //qDebug() << "Found node" << node << "for" << url;
             return node;
         }
         //qDebug() << "going into" << node->item().url();
         Q_ASSERT(isDir(node));
         dirNode = static_cast<KDirModelDirNode *>(node);
     }
     // NOTREACHED
     //return 0;
 }
 
 #ifndef NDEBUG
 void KDirModelPrivate::dump()
 {
     qCDebug(KIO_WIDGETS) << "Dumping contents of KDirModel" << q << "dirLister url:" << m_dirLister->url();
     QHashIterator<QUrl, KDirModelNode *> it(m_nodeHash);
     while (it.hasNext()) {
         it.next();
         qDebug(KIO_WIDGETS) << it.key() << it.value();
     }
 }
 #endif
 
 // node -> index. If rowNumber is set (or node is root): O(1). Otherwise: O(n).
 QModelIndex KDirModelPrivate::indexForNode(KDirModelNode *node, int rowNumber) const
 {
     if (node == m_rootNode) {
         return QModelIndex();
     }
 
     Q_ASSERT(node->parent());
     return q->createIndex(rowNumber == -1 ? node->rowNumber() : rowNumber, 0, node);
 }
 
 // index -> node. O(1)
 KDirModelNode *KDirModelPrivate::nodeForIndex(const QModelIndex &index) const
 {
     return index.isValid()
            ? static_cast<KDirModelNode *>(index.internalPointer())
            : m_rootNode;
 }
 
 /*
  * This model wraps the data held by KDirLister.
  *
  * The internal pointer of the QModelIndex for a given file is the node for that file in our own tree.
  * E.g. index(2,0) returns a QModelIndex with row=2 internalPointer=<KDirModelNode for the 3rd child of the root>
  *
  * Invalid parent index means root of the tree, m_rootNode
  */
 
 #ifndef NDEBUG
 static QString debugIndex(const QModelIndex &index)
 {
     QString str;
     if (!index.isValid()) {
         str = QStringLiteral("[invalid index, i.e. root]");
     } else {
         KDirModelNode *node = static_cast<KDirModelNode *>(index.internalPointer());
         str = QLatin1String("[index for ") + node->item().url().toString();
         if (index.column() > 0) {
             str += QLatin1String(", column ") + QString::number(index.column());
         }
         str += QLatin1Char(']');
     }
     return str;
 }
 #endif
 
 KDirModel::KDirModel(QObject *parent)
     : QAbstractItemModel(parent),
       d(new KDirModelPrivate(this))
 {
     setDirLister(new KDirLister(this));
 }
 
 KDirModel::~KDirModel()
 {
     delete d;
 }
 
 void KDirModel::setDirLister(KDirLister *dirLister)
 {
     if (d->m_dirLister) {
         d->clear();
         delete d->m_dirLister;
     }
     d->m_dirLister = dirLister;
     d->m_dirLister->setParent(this);
     connect(d->m_dirLister, &KCoreDirLister::itemsAdded, this,
         [this](const QUrl &dirUrl, const KFileItemList &items){d->_k_slotNewItems(dirUrl, items);} );
     connect(d->m_dirLister, &KCoreDirLister::itemsDeleted, this,
         [this](const KFileItemList &items){d->_k_slotDeleteItems(items);} );
     connect(d->m_dirLister, &KCoreDirLister::refreshItems, this,
         [this](const QList<QPair<KFileItem,KFileItem> > &items){d->_k_slotRefreshItems(items);} );
     connect(d->m_dirLister, QOverload<>::of(&KCoreDirLister::clear), this,
         [this](){d->_k_slotClear();} );
     connect(d->m_dirLister, QOverload<const QUrl&, const QUrl&>::of(&KCoreDirLister::redirection), this,
         [this](const QUrl &oldUrl, const QUrl &newUrl){d->_k_slotRedirection(oldUrl, newUrl);} );
 }
 
 KDirLister *KDirModel::dirLister() const
 {
     return d->m_dirLister;
 }
 
 void KDirModelPrivate::_k_slotNewItems(const QUrl &directoryUrl, const KFileItemList &items)
 {
     //qDebug() << "directoryUrl=" << directoryUrl;
 
     KDirModelNode *result = nodeForUrl(directoryUrl); // O(depth)
     // If the directory containing the items wasn't found, then we have a big problem.
     // Are you calling KDirLister::openUrl(url,true,false)? Please use expandToUrl() instead.
     if (!result) {
         qCWarning(KIO_WIDGETS) << "Items emitted in directory" << directoryUrl
                    << "but that directory isn't in KDirModel!"
                    << "Root directory:" << urlForNode(m_rootNode);
         Q_FOREACH (const KFileItem &item, items) {
             qDebug() << "Item:" << item.url();
         }
 #ifndef NDEBUG
         dump();
 #endif
         Q_ASSERT(result);
     }
     Q_ASSERT(isDir(result));
     KDirModelDirNode *dirNode = static_cast<KDirModelDirNode *>(result);
 
     const QModelIndex index = indexForNode(dirNode); // O(n)
     const int newItemsCount = items.count();
     const int newRowCount = dirNode->m_childNodes.count() + newItemsCount;
 #if 0
 #ifndef NDEBUG // debugIndex only defined in debug mode
     //qDebug() << items.count() << "in" << directoryUrl
             << "index=" << debugIndex(index) << "newRowCount=" << newRowCount;
 #endif
 #endif
 
     q->beginInsertRows(index, newRowCount - newItemsCount, newRowCount - 1);   // parent, first, last
 
     const QList<QUrl> urlsBeingFetched = m_urlsBeingFetched.value(dirNode);
     //qDebug() << "urlsBeingFetched for dir" << dirNode << directoryUrl << ":" << urlsBeingFetched;
 
     QList<QModelIndex> emitExpandFor;
 
     dirNode->m_childNodes.reserve(newRowCount);
     KFileItemList::const_iterator it = items.begin();
     KFileItemList::const_iterator end = items.end();
     for (; it != end; ++it) {
         const bool isDir = it->isDir();
         KDirModelNode *node = isDir
                               ? new KDirModelDirNode(dirNode, *it)
                               : new KDirModelNode(dirNode, *it);
 #ifndef NDEBUG
         // Test code for possible duplication of items in the childnodes list,
         // not sure if/how it ever happened.
         //if (dirNode->m_childNodes.count() &&
         //    dirNode->m_childNodes.last()->item().name() == (*it).name()) {
         //    qCWarning(KIO_WIDGETS) << "Already having" << (*it).name() << "in" << directoryUrl
         //             << "url=" << dirNode->m_childNodes.last()->item().url();
         //    abort();
         //}
 #endif
         dirNode->m_childNodes.append(node);
         const QUrl url = it->url();
         m_nodeHash.insert(cleanupUrl(url), node);
         //qDebug() << url;
 
         if (!urlsBeingFetched.isEmpty()) {
             const QUrl dirUrl(url);
             foreach (const QUrl &urlFetched, urlsBeingFetched) {
                 if (dirUrl.matches(urlFetched, QUrl::StripTrailingSlash) || dirUrl.isParentOf(urlFetched)) {
                     //qDebug() << "Listing found" << dirUrl.url() << "which is a parent of fetched url" << urlFetched;
                     const QModelIndex parentIndex = indexForNode(node, dirNode->m_childNodes.count() - 1);
                     Q_ASSERT(parentIndex.isValid());
                     emitExpandFor.append(parentIndex);
                     if (isDir && dirUrl != urlFetched) {
                         q->fetchMore(parentIndex);
                         m_urlsBeingFetched[node].append(urlFetched);
                     }
                 }
             }
         }
     }
 
     m_urlsBeingFetched.remove(dirNode);
 
     q->endInsertRows();
 
     // Emit expand signal after rowsInserted signal has been emitted,
     // so that any proxy model will have updated its mapping already
     Q_FOREACH (const QModelIndex &idx, emitExpandFor) {
         emit q->expand(idx);
     }
 }
 
 void KDirModelPrivate::_k_slotDeleteItems(const KFileItemList &items)
 {
     //qDebug() << items.count();
 
     // I assume all items are from the same directory.
     // From KDirLister's code, this should be the case, except maybe emitChanges?
     const KFileItem item = items.first();
     Q_ASSERT(!item.isNull());
     QUrl url = item.url();
     KDirModelNode *node = nodeForUrl(url); // O(depth)
     if (!node) {
         qCWarning(KIO_WIDGETS) << "No node found for item that was just removed:" << url;
         return;
     }
 
     KDirModelDirNode *dirNode = node->parent();
     if (!dirNode) {
         return;
     }
 
     QModelIndex parentIndex = indexForNode(dirNode); // O(n)
 
     // Short path for deleting a single item
     if (items.count() == 1) {
         const int r = node->rowNumber();
         q->beginRemoveRows(parentIndex, r, r);
         removeFromNodeHash(node, url);
         delete dirNode->m_childNodes.takeAt(r);
         q->endRemoveRows();
         return;
     }
 
     // We need to make lists of consecutive row numbers, for the beginRemoveRows call.
     // Let's use a bit array where each bit represents a given child node.
     const int childCount = dirNode->m_childNodes.count();
     QBitArray rowNumbers(childCount, false);
     Q_FOREACH (const KFileItem &item, items) {
         if (!node) { // don't lookup the first item twice
             url = item.url();
             node = nodeForUrl(url);
             if (!node) {
                 qCWarning(KIO_WIDGETS) << "No node found for item that was just removed:" << url;
                 continue;
             }
             if (!node->parent()) {
                 // The root node has been deleted, but it was not first in the list 'items'.
                 // see https://bugs.kde.org/show_bug.cgi?id=196695
                 return;
             }
         }
         rowNumbers.setBit(node->rowNumber(), 1); // O(n)
         removeFromNodeHash(node, url);
         node = nullptr;
     }
 
     int start = -1;
     int end = -1;
     bool lastVal = false;
     // Start from the end, otherwise all the row numbers are offset while we go
     for (int i = childCount - 1; i >= 0; --i) {
         const bool val = rowNumbers.testBit(i);
         if (!lastVal && val) {
             end = i;
             //qDebug() << "end=" << end;
         }
         if ((lastVal && !val) || (i == 0 && val)) {
             start = val ? i : i + 1;
             //qDebug() << "beginRemoveRows" << start << end;
             q->beginRemoveRows(parentIndex, start, end);
             for (int r = end; r >= start; --r) { // reverse because takeAt changes indexes ;)
                 //qDebug() << "Removing from m_childNodes at" << r;
                 delete dirNode->m_childNodes.takeAt(r);
             }
             q->endRemoveRows();
         }
         lastVal = val;
     }
 }
 
 void KDirModelPrivate::_k_slotRefreshItems(const QList<QPair<KFileItem, KFileItem> > &items)
 {
     QModelIndex topLeft, bottomRight;
 
     // Solution 1: we could emit dataChanged for one row (if items.size()==1) or all rows
     // Solution 2: more fine-grained, actually figure out the beginning and end rows.
     for (QList<QPair<KFileItem, KFileItem> >::const_iterator fit = items.begin(), fend = items.end(); fit != fend; ++fit) {
         Q_ASSERT(!fit->first.isNull());
         Q_ASSERT(!fit->second.isNull());
         const QUrl oldUrl = fit->first.url();
         const QUrl newUrl = fit->second.url();
         KDirModelNode *node = nodeForUrl(oldUrl); // O(n); maybe we could look up to the parent only once
         //qDebug() << "in model for" << m_dirLister->url() << ":" << oldUrl << "->" << newUrl << "node=" << node;
         if (!node) { // not found [can happen when renaming a dir, redirection was emitted already]
             continue;
         }
         if (node != m_rootNode) { // we never set an item in the rootnode, we use m_dirLister->rootItem instead.
             bool hasNewNode = false;
             // A file became directory (well, it was overwritten)
             if (fit->first.isDir() != fit->second.isDir()) {
                 //qDebug() << "DIR/FILE STATUS CHANGE";
                 const int r = node->rowNumber();
                 removeFromNodeHash(node, oldUrl);
                 KDirModelDirNode *dirNode = node->parent();
                 delete dirNode->m_childNodes.takeAt(r); // i.e. "delete node"
                 node = fit->second.isDir() ? new KDirModelDirNode(dirNode, fit->second)
                        : new KDirModelNode(dirNode, fit->second);
                 dirNode->m_childNodes.insert(r, node); // same position!
                 hasNewNode = true;
             } else {
                 node->setItem(fit->second);
             }
 
             if (oldUrl != newUrl || hasNewNode) {
                 // What if a renamed dir had children? -> kdirlister takes care of emitting for each item
                 //qDebug() << "Renaming" << oldUrl << "to" << newUrl << "in node hash";
                 m_nodeHash.remove(cleanupUrl(oldUrl));
                 m_nodeHash.insert(cleanupUrl(newUrl), node);
             }
             // Mimetype changed -> forget cached icon (e.g. from "cut", #164185 comment #13)
             if (fit->first.determineMimeType().name() != fit->second.determineMimeType().name()) {
                 node->setPreview(QIcon());
             }
 
             const QModelIndex index = indexForNode(node);
             if (!topLeft.isValid() || index.row() < topLeft.row()) {
                 topLeft = index;
             }
             if (!bottomRight.isValid() || index.row() > bottomRight.row()) {
                 bottomRight = index;
             }
         }
     }
 #ifndef NDEBUG // debugIndex only defined in debug mode
     //qDebug() << "dataChanged(" << debugIndex(topLeft) << " - " << debugIndex(bottomRight);
     Q_UNUSED(debugIndex(QModelIndex())); // fix compiler warning
 #endif
     bottomRight = bottomRight.sibling(bottomRight.row(), q->columnCount(QModelIndex()) - 1);
     emit q->dataChanged(topLeft, bottomRight);
 }
 
 // Called when a kioslave redirects (e.g. smb:/Workgroup -> smb://workgroup)
 // and when renaming a directory.
 void KDirModelPrivate::_k_slotRedirection(const QUrl &oldUrl, const QUrl &newUrl)
 {
     KDirModelNode *node = nodeForUrl(oldUrl);
     if (!node) {
         return;
     }
     m_nodeHash.remove(cleanupUrl(oldUrl));
     m_nodeHash.insert(cleanupUrl(newUrl), node);
 
     // Ensure the node's URL is updated. In case of a listjob redirection
     // we won't get a refreshItem, and in case of renaming a directory
     // we'll get it too late (so the hash won't find the old url anymore).
     KFileItem item = node->item();
     if (!item.isNull()) { // null if root item, #180156
         item.setUrl(newUrl);
         node->setItem(item);
     }
 
     // The items inside the renamed directory have been handled before,
     // KDirLister took care of emitting refreshItem for each of them.
 }
 
 void KDirModelPrivate::_k_slotClear()
 {
     const int numRows = m_rootNode->m_childNodes.count();
     if (numRows > 0) {
         q->beginRemoveRows(QModelIndex(), 0, numRows - 1);
         q->endRemoveRows();
     }
 
     m_nodeHash.clear();
     //emit layoutAboutToBeChanged();
     clear();
     //emit layoutChanged();
 }
 
 void KDirModelPrivate::_k_slotJobUrlsChanged(const QStringList &urlList)
 {
     QStringList dirtyUrls;
 
     std::set_symmetric_difference(urlList.begin(), urlList.end(),
                                   m_allCurrentDestUrls.constBegin(), m_allCurrentDestUrls.constEnd(),
                                   std::back_inserter(dirtyUrls));
 
     m_allCurrentDestUrls = urlList;
 
     for (const QString &dirtyUrl : qAsConst(dirtyUrls)) {
         if (KDirModelNode *node = nodeForUrl(QUrl(dirtyUrl))) {
             const QModelIndex idx = indexForNode(node);
             emit q->dataChanged(idx, idx, {KDirModel::HasJobRole});
         }
     }
 }
 
 void KDirModelPrivate::clearAllPreviews(KDirModelDirNode *dirNode)
 {
     const int numRows = dirNode->m_childNodes.count();
     if (numRows > 0) {
         KDirModelNode *lastNode = nullptr;
         for (KDirModelNode *node : qAsConst(dirNode->m_childNodes)) {
             node->setPreview(QIcon());
             //node->setPreview(QIcon::fromTheme(node->item().iconName()));
             if (isDir(node)) {
                 // recurse into child dirs
                 clearAllPreviews(static_cast<KDirModelDirNode *>(node));
             }
             lastNode = node;
         }
         emit q->dataChanged(indexForNode(dirNode->m_childNodes.at(0), 0),  // O(1)
                             indexForNode(lastNode, numRows - 1));          // O(1)
     }
 
 }
 
 void KDirModel::clearAllPreviews()
 {
     d->clearAllPreviews(d->m_rootNode);
 }
 
 void KDirModel::itemChanged(const QModelIndex &index)
 {
     // This method is really a itemMimeTypeChanged(), it's mostly called by KFilePreviewGenerator.
     // When the mimetype is determined, clear the old "preview" (could be
     // mimetype dependent like when cutting files, #164185)
     KDirModelNode *node = d->nodeForIndex(index);
     if (node) {
         node->setPreview(QIcon());
     }
 
 #ifndef NDEBUG // debugIndex only defined in debug mode
     //qDebug() << "dataChanged(" << debugIndex(index);
 #endif
     emit dataChanged(index, index);
 }
 
 int KDirModel::columnCount(const QModelIndex &) const
 {
     return ColumnCount;
 }
 
 QVariant KDirModel::data(const QModelIndex &index, int role) const
 {
     if (index.isValid()) {
         KDirModelNode *node = static_cast<KDirModelNode *>(index.internalPointer());
         const KFileItem &item(node->item());
         switch (role) {
         case Qt::DisplayRole:
             switch (index.column()) {
             case Name:
                 return item.text();
             case Size:
                 return KIO::convertSize(item.size()); // size formatted as QString
             case ModifiedTime: {
                 QDateTime dt = item.time(KFileItem::ModificationTime);
                 return dt.toString(Qt::SystemLocaleShortDate);
             }
             case Permissions:
                 return item.permissionsString();
             case Owner:
                 return item.user();
             case Group:
                 return item.group();
             case Type:
                 return item.mimeComment();
             }
             break;
         case Qt::EditRole:
             switch (index.column()) {
             case Name:
                 return item.text();
             }
             break;
         case Qt::DecorationRole:
             if (index.column() == Name) {
                 if (!node->preview().isNull()) {
                     //qDebug() << item->url() << " preview found";
                     return node->preview();
                 }
                 Q_ASSERT(!item.isNull());
                 //qDebug() << item->url() << " overlays=" << item->overlays();
                 return KDE::icon(item.iconName(), item.overlays());
             }
             break;
         case Qt::TextAlignmentRole:
             if (index.column() == Size) {
                 // use a right alignment for L2R and R2L languages
                 const Qt::Alignment alignment = Qt::AlignRight | Qt::AlignVCenter;
                 return int(alignment);
             }
             break;
         case Qt::ToolTipRole:
             return item.text();
         case FileItemRole:
             return QVariant::fromValue(item);
         case ChildCountRole:
             if (!item.isDir()) {
                 return ChildCountUnknown;
             } else {
                 KDirModelDirNode *dirNode = static_cast<KDirModelDirNode *>(node);
                 int count = dirNode->childCount();
                 if (count == ChildCountUnknown && item.isReadable() && !dirNode->isSlow()) {
                     const QString path = item.localPath();
                     if (!path.isEmpty()) {
 //                        slow
 //                        QDir dir(path);
 //                        count = dir.entryList(QDir::AllEntries|QDir::NoDotAndDotDot|QDir::System).count();
 #ifdef Q_OS_WIN
                         QString s = path + QLatin1String("\\*.*");
                         s.replace(QLatin1Char('/'), QLatin1Char('\\'));
                         count = 0;
                         WIN32_FIND_DATA findData;
                         HANDLE hFile = FindFirstFile((LPWSTR)s.utf16(), &findData);
                         if (hFile != INVALID_HANDLE_VALUE) {
                             do {
                                 if (!(findData.cFileName[0] == '.' &&
                                         findData.cFileName[1] == '\0') &&
                                         !(findData.cFileName[0] == '.' &&
                                           findData.cFileName[1] == '.' &&
                                           findData.cFileName[2] == '\0')) {
                                     ++count;
                                 }
                             } while (FindNextFile(hFile, &findData) != 0);
                             FindClose(hFile);
                         }
 #else
                         DIR *dir = QT_OPENDIR(QFile::encodeName(path).constData());
                         if (dir) {
                             count = 0;
                             QT_DIRENT *dirEntry = nullptr;
                             while ((dirEntry = QT_READDIR(dir))) {
                                 if (dirEntry->d_name[0] == '.') {
                                     if (dirEntry->d_name[1] == '\0') { // skip "."
                                         continue;
                                     }
                                     if (dirEntry->d_name[1] == '.' && dirEntry->d_name[2] == '\0') { // skip ".."
                                         continue;
                                     }
                                 }
                                 ++count;
                             }
                             QT_CLOSEDIR(dir);
                         }
 #endif
                         //qDebug() << "child count for " << path << ":" << count;
                         dirNode->setChildCount(count);
                     }
                 }
                 return count;
             }
         case HasJobRole:
             if (d->m_jobTransfersVisible && d->m_allCurrentDestUrls.isEmpty() == false) {
                 KDirModelNode *node = d->nodeForIndex(index);
                 const QString url = node->item().url().toString();
                 //return whether or not there are job dest urls visible in the view, so the delegate knows which ones to paint.
                 return QVariant(d->m_allCurrentDestUrls.contains(url));
             }
         }
     }
     return QVariant();
 }
 
 void KDirModel::sort(int column, Qt::SortOrder order)
 {
     // Not implemented - we should probably use QSortFilterProxyModel instead.
     QAbstractItemModel::sort(column, order);
 }
 
 bool KDirModel::setData(const QModelIndex &index, const QVariant &value, int role)
 {
     switch (role) {
     case Qt::EditRole:
         if (index.column() == Name && value.type() == QVariant::String) {
             Q_ASSERT(index.isValid());
             KDirModelNode *node = static_cast<KDirModelNode *>(index.internalPointer());
             const KFileItem &item = node->item();
             const QString newName = value.toString();
             if (newName.isEmpty() || newName == item.text() || (newName == QLatin1String(".")) || (newName == QLatin1String(".."))) {
                 return true;
             }
             QUrl newUrl = item.url().adjusted(QUrl::RemoveFilename);
             newUrl.setPath(newUrl.path() + KIO::encodeFileName(newName));
             KIO::Job *job = KIO::rename(item.url(), newUrl, item.url().isLocalFile() ? KIO::HideProgressInfo : KIO::DefaultFlags);
             job->uiDelegate()->setAutoErrorHandlingEnabled(true);
             // undo handling
             KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Rename, QList<QUrl>() << item.url(), newUrl, job);
             return true;
         }
         break;
     case Qt::DecorationRole:
         if (index.column() == Name) {
             Q_ASSERT(index.isValid());
             // Set new pixmap - e.g. preview
             KDirModelNode *node = static_cast<KDirModelNode *>(index.internalPointer());
             //qDebug() << "setting icon for " << node->item()->url();
             Q_ASSERT(node);
             if (value.type() == QVariant::Icon) {
                 const QIcon icon(qvariant_cast<QIcon>(value));
                 node->setPreview(icon);
             } else if (value.type() == QVariant::Pixmap) {
                 node->setPreview(qvariant_cast<QPixmap>(value));
             }
             emit dataChanged(index, index);
             return true;
         }
         break;
     default:
         break;
     }
     return false;
 }
 
 int KDirModel::rowCount(const QModelIndex &parent) const
 {
     KDirModelNode *node = d->nodeForIndex(parent);
     if (!node || !d->isDir(node)) { // #176555
         return 0;
     }
 
     KDirModelDirNode *parentNode = static_cast<KDirModelDirNode *>(node);
     Q_ASSERT(parentNode);
     const int count = parentNode->m_childNodes.count();
 #if 0
     QStringList filenames;
     for (int i = 0; i < count; ++i) {
         filenames << d->urlForNode(parentNode->m_childNodes.at(i)).fileName();
     }
     //qDebug() << "rowCount for " << d->urlForNode(parentNode) << ": " << count << filenames;
 #endif
     return count;
 }
 
 QModelIndex KDirModel::parent(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return QModelIndex();
     }
     KDirModelNode *childNode = static_cast<KDirModelNode *>(index.internalPointer());
     Q_ASSERT(childNode);
     KDirModelNode *parentNode = childNode->parent();
     Q_ASSERT(parentNode);
     return d->indexForNode(parentNode); // O(n)
 }
 
 // Reimplemented to avoid the default implementation which calls parent
 // (O(n) for finding the parent's row number for nothing). This implementation is O(1).
 QModelIndex KDirModel::sibling(int row, int column, const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return QModelIndex();
     }
     KDirModelNode *oldChildNode = static_cast<KDirModelNode *>(index.internalPointer());
     Q_ASSERT(oldChildNode);
     KDirModelNode *parentNode = oldChildNode->parent();
     Q_ASSERT(parentNode);
     Q_ASSERT(d->isDir(parentNode));
     KDirModelNode *childNode = static_cast<KDirModelDirNode *>(parentNode)->m_childNodes.value(row); // O(1)
     if (childNode) {
         return createIndex(row, column, childNode);
     }
     return QModelIndex();
 }
 
 void KDirModel::requestSequenceIcon(const QModelIndex &index, int sequenceIndex)
 {
     emit needSequenceIcon(index, sequenceIndex);
 }
 
 void KDirModel::setJobTransfersVisible(bool value)
 {
     if (value) {
         d->m_jobTransfersVisible = true;
         connect(&JobUrlCache::instance(), SIGNAL(jobUrlsChanged(QStringList)), this, SLOT(_k_slotJobUrlsChanged(QStringList)), Qt::UniqueConnection);
 
         JobUrlCache::instance().requestJobUrlsChanged();
     } else {
         disconnect(this, SLOT(_k_slotJobUrlsChanged(QStringList)));
     }
 
 }
 
 bool KDirModel::jobTransfersVisible() const
 {
     return d->m_jobTransfersVisible;
 }
 
 QList<QUrl> KDirModel::simplifiedUrlList(const QList<QUrl> &urls)
 {
-    if (!urls.count()) {
+    if (urls.isEmpty()) {
         return urls;
     }
 
     QList<QUrl> ret(urls);
     std::sort(ret.begin(), ret.end());
 
     QList<QUrl>::iterator it = ret.begin();
     QUrl url = *it;
     ++it;
     while (it != ret.end()) {
         if (url.isParentOf(*it) || url == *it) {
             it = ret.erase(it);
         } else {
             url = *it;
             ++it;
         }
     }
 
     return ret;
 }
 
 QStringList KDirModel::mimeTypes() const
 {
     return KUrlMimeData::mimeDataTypes();
 }
 
 QMimeData *KDirModel::mimeData(const QModelIndexList &indexes) const
 {
     QList<QUrl> urls, mostLocalUrls;
     urls.reserve(indexes.size());
     mostLocalUrls.reserve(indexes.size());
     bool canUseMostLocalUrls = true;
     foreach (const QModelIndex &index, indexes) {
         const KFileItem &item = d->nodeForIndex(index)->item();
         urls << item.url();
         bool isLocal;
         mostLocalUrls << item.mostLocalUrl(isLocal);
         if (!isLocal) {
             canUseMostLocalUrls = false;
         }
     }
     QMimeData *data = new QMimeData();
     const bool different = canUseMostLocalUrls && (mostLocalUrls != urls);
     urls = simplifiedUrlList(urls);
     if (different) {
         mostLocalUrls = simplifiedUrlList(mostLocalUrls);
         KUrlMimeData::setUrls(urls, mostLocalUrls, data);
     } else {
         data->setUrls(urls);
     }
 
     return data;
 }
 
 // Public API; not much point in calling it internally
 KFileItem KDirModel::itemForIndex(const QModelIndex &index) const
 {
     if (!index.isValid()) {
         return d->m_dirLister->rootItem();
     } else {
         return static_cast<KDirModelNode *>(index.internalPointer())->item();
     }
 }
 
 #ifndef KIOWIDGETS_NO_DEPRECATED
 QModelIndex KDirModel::indexForItem(const KFileItem *item) const
 {
     // Note that we can only use the URL here, not the pointer.
     // KFileItems can be copied.
     return indexForUrl(item->url()); // O(n)
 }
 #endif
 
 QModelIndex KDirModel::indexForItem(const KFileItem &item) const
 {
     // Note that we can only use the URL here, not the pointer.
     // KFileItems can be copied.
     return indexForUrl(item.url()); // O(n)
 }
 
 // url -> index. O(n)
 QModelIndex KDirModel::indexForUrl(const QUrl &url) const
 {
     KDirModelNode *node = d->nodeForUrl(url); // O(depth)
     if (!node) {
         //qDebug() << url << "not found";
         return QModelIndex();
     }
     return d->indexForNode(node); // O(n)
 }
 
 QModelIndex KDirModel::index(int row, int column, const QModelIndex &parent) const
 {
     KDirModelNode *parentNode = d->nodeForIndex(parent); // O(1)
     Q_ASSERT(parentNode);
     if (d->isDir(parentNode)) {
         KDirModelNode *childNode = static_cast<KDirModelDirNode *>(parentNode)->m_childNodes.value(row); // O(1)
         if (childNode) {
             return createIndex(row, column, childNode);
         }
     }
     return QModelIndex();
 }
 
 QVariant KDirModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     if (orientation == Qt::Horizontal) {
         switch (role) {
         case Qt::DisplayRole:
             switch (section) {
             case Name:
                 return i18nc("@title:column", "Name");
             case Size:
                 return i18nc("@title:column", "Size");
             case ModifiedTime:
                 return i18nc("@title:column", "Date");
             case Permissions:
                 return i18nc("@title:column", "Permissions");
             case Owner:
                 return i18nc("@title:column", "Owner");
             case Group:
                 return i18nc("@title:column", "Group");
             case Type:
                 return i18nc("@title:column", "Type");
             }
         }
     }
     return QVariant();
 }
 
 bool KDirModel::hasChildren(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return true;
     }
 
     const KFileItem &parentItem = static_cast<KDirModelNode *>(parent.internalPointer())->item();
     Q_ASSERT(!parentItem.isNull());
     return parentItem.isDir();
 }
 
 Qt::ItemFlags KDirModel::flags(const QModelIndex &index) const
 {
     Qt::ItemFlags f = Qt::ItemIsEnabled;
     if (index.column() == Name) {
         f |= Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled;
     }
 
     // Allow dropping onto this item?
     if (d->m_dropsAllowed != NoDrops) {
         if (!index.isValid()) {
             if (d->m_dropsAllowed & DropOnDirectory) {
                 f |= Qt::ItemIsDropEnabled;
             }
         } else {
             KFileItem item = itemForIndex(index);
             if (item.isNull()) {
                 qCWarning(KIO_WIDGETS) << "Invalid item returned for index";
             } else if (item.isDir()) {
                 if (d->m_dropsAllowed & DropOnDirectory) {
                     f |= Qt::ItemIsDropEnabled;
                 }
             } else { // regular file item
                 if (d->m_dropsAllowed & DropOnAnyFile) {
                     f |= Qt::ItemIsDropEnabled;
                 } else if (d->m_dropsAllowed & DropOnLocalExecutable) {
                     if (!item.localPath().isEmpty()) {
                         // Desktop file?
                         if (item.determineMimeType().inherits(QStringLiteral("application/x-desktop"))) {
                             f |= Qt::ItemIsDropEnabled;
                         }
                         // Executable, shell script ... ?
                         else if (QFileInfo(item.localPath()).isExecutable()) {
                             f |= Qt::ItemIsDropEnabled;
                         }
                     }
                 }
             }
         }
     }
 
     return f;
 }
 
 bool KDirModel::canFetchMore(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return false;
     }
 
     // We now have a bool KDirModelNode::m_populated,
     // to avoid calling fetchMore more than once on empty dirs.
     // But this wastes memory, and how often does someone open and re-open an empty dir in a treeview?
     // Maybe we can ask KDirLister "have you listed <url> already"? (to discuss with M. Brade)
 
     KDirModelNode *node = static_cast<KDirModelNode *>(parent.internalPointer());
     const KFileItem &item = node->item();
     return item.isDir() && !static_cast<KDirModelDirNode *>(node)->isPopulated()
            && static_cast<KDirModelDirNode *>(node)->m_childNodes.isEmpty();
 }
 
 void KDirModel::fetchMore(const QModelIndex &parent)
 {
     if (!parent.isValid()) {
         return;
     }
 
     KDirModelNode *parentNode = static_cast<KDirModelNode *>(parent.internalPointer());
 
     KFileItem parentItem = parentNode->item();
     Q_ASSERT(!parentItem.isNull());
     if (!parentItem.isDir()) {
         return;
     }
     KDirModelDirNode *dirNode = static_cast<KDirModelDirNode *>(parentNode);
     if (dirNode->isPopulated()) {
         return;
     }
     dirNode->setPopulated(true);
 
     const QUrl parentUrl = parentItem.url();
     d->m_dirLister->openUrl(parentUrl, KDirLister::Keep);
 }
 
 bool KDirModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)
 {
     // Not sure we want to implement any drop handling at this level,
     // but for sure the default QAbstractItemModel implementation makes no sense for a dir model.
     Q_UNUSED(data);
     Q_UNUSED(action);
     Q_UNUSED(row);
     Q_UNUSED(column);
     Q_UNUSED(parent);
     return false;
 }
 
 void KDirModel::setDropsAllowed(DropsAllowed dropsAllowed)
 {
     d->m_dropsAllowed = dropsAllowed;
 }
 
 void KDirModel::expandToUrl(const QUrl &url)
 {
     // emit expand for each parent and return last parent
     KDirModelNode *result = d->expandAllParentsUntil(url); // O(depth)
     //qDebug() << url << result;
 
     if (!result) { // doesn't seem related to our base url?
         return;
     }
     if (!(result->item().isNull()) && result->item().url() == url) {
         // We have it already, nothing to do
         //qDebug() << "have it already item=" <<url /*result->item()*/;
         return;
     }
 
     d->m_urlsBeingFetched[result].append(url);
 
     if (result == d->m_rootNode) {
         //qDebug() << "Remembering to emit expand after listing the root url";
         // the root is fetched by default, so it must be currently being fetched
         return;
     }
 
     //qDebug() << "Remembering to emit expand after listing" << result->item().url();
 
     // start a new fetch to look for the next level down the URL
     const QModelIndex parentIndex = d->indexForNode(result); // O(n)
     Q_ASSERT(parentIndex.isValid());
     fetchMore(parentIndex);
 }
 
 bool KDirModel::insertRows(int, int, const QModelIndex &)
 {
     return false;
 }
 
 bool KDirModel::insertColumns(int, int, const QModelIndex &)
 {
     return false;
 }
 
 bool KDirModel::removeRows(int, int, const QModelIndex &)
 {
     return false;
 }
 
 bool KDirModel::removeColumns(int, int, const QModelIndex &)
 {
     return false;
 }
 
 #include "moc_kdirmodel.cpp"
diff --git a/src/widgets/kpropertiesdialog.cpp b/src/widgets/kpropertiesdialog.cpp
index 13b307b4..02e8731b 100644
--- a/src/widgets/kpropertiesdialog.cpp
+++ b/src/widgets/kpropertiesdialog.cpp
@@ -1,3930 +1,3930 @@
 /* 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->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);
 
         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(d->m_frame);
                 grid->addWidget(l, curRow++, 2);
                 l->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
                 l->setText(mp->mountedFrom());
             }
         }
 
         l = new QLabel(i18n("Device usage:"), d->m_frame);
         grid->addWidget(l, curRow, 0, Qt::AlignRight);
 
         d->m_capacityBar = new KCapacityBar(KCapacityBar::DrawTextOutline, d->m_frame);
         d->m_capacityBar->setText(i18nc("@info:status", "Unknown size"));
         grid->addWidget(d->m_capacityBar, curRow++, 2);
 
         KIO::FileSystemFreeSpaceJob *job = KIO::fileSystemFreeSpace(url);
         connect(job, &KIO::FileSystemFreeSpaceJob::result, this, &KFilePropsPlugin::slotFreeSpaceResult);
     }
 
     vbl->addStretch(1);
 }
 
 bool KFilePropsPlugin::enableIconButton() const
 {
     bool iconEnabled = false;
     const KFileItem item = properties->item();
     // If the current item is a directory, check if it's writable,
     // so we can create/update a .directory
     // Current item is a file, same thing: check if it is writable
     if (item.isWritable()) {
         iconEnabled = true;
     }
     return iconEnabled;
 }
 
 // QString KFilePropsPlugin::tabName () const
 // {
 //   return i18n ("&General");
 // }
 
 void KFilePropsPlugin::setFileNameReadOnly(bool ro)
 {
     Q_ASSERT(ro); // false isn't supported
     if (ro && !d->m_fileNameLabel) {
         Q_ASSERT(!d->m_bFromTemplate);
         delete d->m_lined;
         d->m_lined = nullptr;
         d->m_fileNameLabel = new QLabel(d->m_frame);
         d->m_fileNameLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::TextSelectableByKeyboard);
         d->m_fileNameLabel->setText(d->oldName); // will get overwritten if d->bMultiple
         d->m_grid->addWidget(d->m_fileNameLabel, 0, 2);
     }
 }
 
 void KFilePropsPlugin::slotEditFileType()
 {
     QString mime;
     if (d->mimeType == QLatin1String("application/octet-stream")) {
         const int pos = d->oldFileName.lastIndexOf(QLatin1Char('.'));
         if (pos != -1) {
             mime = QLatin1Char('*') + d->oldFileName.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);
 
     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 ***/
 
     QStringList groupList;
     KUser user(KUser::UseEffectiveUID);
     const bool isMyGroup = user.groupNames().contains(d->strGroup);
 
     /* add the group the file currently belongs to ..
     * .. if it is not there already
     */
     if (!isMyGroup) {
         groupList += d->strGroup;
     }
 
     l = new QLabel(i18n("Group:"), gb);
     gl->addWidget(l, 2, 0, Qt::AlignRight);
 
     /* Set group: if possible to change:
     * - Offer a KLineEdit for root, since he can change to any group.
     * - Offer a KComboBox for a normal user, since he can change to a fixed
     *   (small) set of groups only.
     * If not changeable: offer a QLabel.
     */
     if (IamRoot && isLocal) {
         d->grpEdit = new KLineEdit(gb);
         KCompletion *kcom = new KCompletion;
         kcom->setItems(groupList);
         d->grpEdit->setCompletionObject(kcom, true);
         d->grpEdit->setAutoDeleteCompletionObject(true);
         d->grpEdit->setCompletionMode(KCompletion::CompletionAuto);
         d->grpEdit->setText(d->strGroup);
         gl->addWidget(d->grpEdit, 2, 1);
         connect(d->grpEdit, &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.count() > 0) {
+    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.count() > 0) {
+    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);
 
     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->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"