diff --git a/src/core/ktcpsocket.cpp b/src/core/ktcpsocket.cpp
index e654c06b..f186e89a 100644
--- a/src/core/ktcpsocket.cpp
+++ b/src/core/ktcpsocket.cpp
@@ -1,1091 +1,1091 @@
 /* This file is part of the KDE libraries
     Copyright (C) 2007, 2008 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 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 "ktcpsocket.h"
 #include "ktcpsocket_p.h"
 #include "kiocoredebug.h"
 
 #include <ksslcertificatemanager.h>
 #include <klocalizedstring.h>
 
 #include <QDebug>
 #include <QUrl>
 #include <QStringList>
 #include <QSslKey>
 #include <QSslCipher>
 #include <QHostAddress>
 #include <QNetworkProxy>
 
 static KTcpSocket::SslVersion kSslVersionFromQ(QSsl::SslProtocol protocol)
 {
     switch (protocol) {
     case QSsl::SslV2:
         return KTcpSocket::SslV2;
     case QSsl::SslV3:
         return KTcpSocket::SslV3;
     case QSsl::TlsV1_0:
         return KTcpSocket::TlsV1;
     case QSsl::TlsV1_1:
         return KTcpSocket::TlsV1_1;
     case QSsl::TlsV1_2:
         return KTcpSocket::TlsV1_2;
     case QSsl::AnyProtocol:
         return KTcpSocket::AnySslVersion;
     case QSsl::TlsV1SslV3:
         return KTcpSocket::TlsV1SslV3;
     case QSsl::SecureProtocols:
         return KTcpSocket::SecureProtocols;
     default:
         return KTcpSocket::UnknownSslVersion;
     }
 }
 
 static QSsl::SslProtocol qSslProtocolFromK(KTcpSocket::SslVersion sslVersion)
 {
     //### this lowlevel bit-banging is a little dangerous and a likely source of bugs
     if (sslVersion == KTcpSocket::AnySslVersion) {
         return QSsl::AnyProtocol;
     }
     //does it contain any valid protocol?
     KTcpSocket::SslVersions validVersions(KTcpSocket::SslV2 | KTcpSocket::SslV3 | KTcpSocket::TlsV1);
     validVersions |= KTcpSocket::TlsV1_1;
     validVersions |= KTcpSocket::TlsV1_2;
     validVersions |= KTcpSocket::TlsV1SslV3;
     validVersions |= KTcpSocket::SecureProtocols;
 
     if (!(sslVersion & validVersions)) {
         return QSsl::UnknownProtocol;
     }
 
     switch (sslVersion) {
     case KTcpSocket::SslV2:
         return QSsl::SslV2;
     case KTcpSocket::SslV3:
         return QSsl::SslV3;
     case KTcpSocket::TlsV1_0:
         return QSsl::TlsV1_0;
     case KTcpSocket::TlsV1_1:
         return QSsl::TlsV1_1;
     case KTcpSocket::TlsV1_2:
         return QSsl::TlsV1_2;
     case KTcpSocket::TlsV1SslV3:
         return QSsl::TlsV1SslV3;
     case KTcpSocket::SecureProtocols:
         return QSsl::SecureProtocols;
 
     default:
         //QSslSocket doesn't really take arbitrary combinations. It's one or all.
         return QSsl::AnyProtocol;
     }
 }
 
 static QString protocolString(QSsl::SslProtocol protocol)
 {
     switch (protocol) {
     case QSsl::SslV2:
         return QStringLiteral("SSLv2");
     case QSsl::SslV3:
         return QStringLiteral("SSLv3");
     case QSsl::TlsV1_0:
         return QStringLiteral("TLSv1.0");
     case QSsl::TlsV1_1:
         return QStringLiteral("TLSv1.1");
     case QSsl::TlsV1_2:
         return QStringLiteral("TLSv1.2");
     default:
         return QStringLiteral("Unknown");;
     }
 }
 
 //cipher class converter KSslCipher -> QSslCipher
 class CipherCc
 {
 public:
     CipherCc()
     {
         foreach (const QSslCipher &c, QSslSocket::supportedCiphers()) {
             allCiphers.insert(c.name(), c);
         }
     }
 
     QSslCipher converted(const KSslCipher &ksc)
     {
         return allCiphers.value(ksc.name());
     }
 
 private:
     QHash<QString, QSslCipher> allCiphers;
 };
 
 class KSslErrorPrivate
 {
 public:
     static KSslError::Error errorFromQSslError(QSslError::SslError e)
     {
         switch (e) {
         case QSslError::NoError:
             return KSslError::NoError;
         case QSslError::UnableToGetLocalIssuerCertificate:
         case QSslError::InvalidCaCertificate:
             return KSslError::InvalidCertificateAuthorityCertificate;
         case QSslError::InvalidNotBeforeField:
         case QSslError::InvalidNotAfterField:
         case QSslError::CertificateNotYetValid:
         case QSslError::CertificateExpired:
             return KSslError::ExpiredCertificate;
         case QSslError::UnableToDecodeIssuerPublicKey:
         case QSslError::SubjectIssuerMismatch:
         case QSslError::AuthorityIssuerSerialNumberMismatch:
             return KSslError::InvalidCertificate;
         case QSslError::SelfSignedCertificate:
         case QSslError::SelfSignedCertificateInChain:
             return KSslError::SelfSignedCertificate;
         case QSslError::CertificateRevoked:
             return KSslError::RevokedCertificate;
         case QSslError::InvalidPurpose:
             return KSslError::InvalidCertificatePurpose;
         case QSslError::CertificateUntrusted:
             return KSslError::UntrustedCertificate;
         case QSslError::CertificateRejected:
             return KSslError::RejectedCertificate;
         case QSslError::NoPeerCertificate:
             return KSslError::NoPeerCertificate;
         case QSslError::HostNameMismatch:
             return KSslError::HostNameMismatch;
         case QSslError::UnableToVerifyFirstCertificate:
         case QSslError::UnableToDecryptCertificateSignature:
         case QSslError::UnableToGetIssuerCertificate:
         case QSslError::CertificateSignatureFailed:
             return KSslError::CertificateSignatureFailed;
         case QSslError::PathLengthExceeded:
             return KSslError::PathLengthExceeded;
         case QSslError::UnspecifiedError:
         case QSslError::NoSslSupport:
         default:
             return KSslError::UnknownError;
         }
     }
 
     static QString errorString(KSslError::Error e)
     {
         switch (e) {
         case KSslError::NoError:
             return i18nc("SSL error", "No error");
         case KSslError::InvalidCertificateAuthorityCertificate:
             return i18nc("SSL error", "The certificate authority's certificate is invalid");
         case KSslError::ExpiredCertificate:
             return i18nc("SSL error", "The certificate has expired");
         case KSslError::InvalidCertificate:
             return i18nc("SSL error", "The certificate is invalid");
         case KSslError::SelfSignedCertificate:
             return i18nc("SSL error", "The certificate is not signed by any trusted certificate authority");
         case KSslError::RevokedCertificate:
             return i18nc("SSL error", "The certificate has been revoked");
         case KSslError::InvalidCertificatePurpose:
             return i18nc("SSL error", "The certificate is unsuitable for this purpose");
         case KSslError::UntrustedCertificate:
             return i18nc("SSL error", "The root certificate authority's certificate is not trusted for this purpose");
         case KSslError::RejectedCertificate:
             return i18nc("SSL error", "The certificate authority's certificate is marked to reject this certificate's purpose");
         case KSslError::NoPeerCertificate:
             return i18nc("SSL error", "The peer did not present any certificate");
         case KSslError::HostNameMismatch:
             return i18nc("SSL error", "The certificate does not apply to the given host");
         case KSslError::CertificateSignatureFailed:
             return i18nc("SSL error", "The certificate cannot be verified for internal reasons");
         case KSslError::PathLengthExceeded:
             return i18nc("SSL error", "The certificate chain is too long");
         case KSslError::UnknownError:
         default:
             return i18nc("SSL error", "Unknown error");
         }
     }
 
     KSslError::Error error;
     QSslCertificate certificate;
 };
 
 KSslError::KSslError(Error errorCode, const QSslCertificate &certificate)
     : d(new KSslErrorPrivate())
 {
     d->error = errorCode;
     d->certificate = certificate;
 }
 
 KSslError::KSslError(const QSslError &other)
     : d(new KSslErrorPrivate())
 {
     d->error = KSslErrorPrivate::errorFromQSslError(other.error());
     d->certificate = other.certificate();
 }
 
 KSslError::KSslError(const KSslError &other)
     : d(new KSslErrorPrivate())
 {
     *d = *other.d;
 }
 
 KSslError::~KSslError()
 {
     delete d;
 }
 
 KSslError &KSslError::operator=(const KSslError &other)
 {
     *d = *other.d;
     return *this;
 }
 
 KSslError::Error KSslError::error() const
 {
     return d->error;
 }
 
 QString KSslError::errorString() const
 {
     return KSslErrorPrivate::errorString(d->error);
 }
 
 QSslCertificate KSslError::certificate() const
 {
     return d->certificate;
 }
 
 class KTcpSocketPrivate
 {
 public:
     KTcpSocketPrivate(KTcpSocket *qq)
         : q(qq),
           certificatesLoaded(false),
           emittedReadyRead(false)
     {
         // create the instance, which sets Qt's static internal cert set to empty.
         KSslCertificateManager::self();
     }
 
     KTcpSocket::State state(QAbstractSocket::SocketState s)
     {
         switch (s) {
         case QAbstractSocket::UnconnectedState:
             return KTcpSocket::UnconnectedState;
         case QAbstractSocket::HostLookupState:
             return KTcpSocket::HostLookupState;
         case QAbstractSocket::ConnectingState:
             return KTcpSocket::ConnectingState;
         case QAbstractSocket::ConnectedState:
             return KTcpSocket::ConnectedState;
         case QAbstractSocket::ClosingState:
             return KTcpSocket::ClosingState;
         case QAbstractSocket::BoundState:
         case QAbstractSocket::ListeningState:
         //### these two are not relevant as long as this can't be a server socket
         default:
             return KTcpSocket::UnconnectedState; //the closest to "error"
         }
     }
 
     KTcpSocket::EncryptionMode encryptionMode(QSslSocket::SslMode mode)
     {
         switch (mode) {
         case QSslSocket::SslClientMode:
             return KTcpSocket::SslClientMode;
         case QSslSocket::SslServerMode:
             return KTcpSocket::SslServerMode;
         default:
             return KTcpSocket::UnencryptedMode;
         }
     }
 
     KTcpSocket::Error errorFromAbsSocket(QAbstractSocket::SocketError e)
     {
         switch (e) {
         case QAbstractSocket::ConnectionRefusedError:
             return KTcpSocket::ConnectionRefusedError;
         case QAbstractSocket::RemoteHostClosedError:
             return KTcpSocket::RemoteHostClosedError;
         case QAbstractSocket::HostNotFoundError:
             return KTcpSocket::HostNotFoundError;
         case QAbstractSocket::SocketAccessError:
             return KTcpSocket::SocketAccessError;
         case QAbstractSocket::SocketResourceError:
             return KTcpSocket::SocketResourceError;
         case QAbstractSocket::SocketTimeoutError:
             return KTcpSocket::SocketTimeoutError;
         case QAbstractSocket::NetworkError:
             return KTcpSocket::NetworkError;
         case QAbstractSocket::UnsupportedSocketOperationError:
             return KTcpSocket::UnsupportedSocketOperationError;
         case QAbstractSocket::SslHandshakeFailedError:
             return KTcpSocket::SslHandshakeFailedError;
         case QAbstractSocket::DatagramTooLargeError:
         //we don't do UDP
         case QAbstractSocket::AddressInUseError:
         case QAbstractSocket::SocketAddressNotAvailableError:
         //### own values if/when we ever get server socket support
         case QAbstractSocket::ProxyAuthenticationRequiredError:
         //### maybe we need an enum value for this
         case QAbstractSocket::UnknownSocketError:
         default:
             return KTcpSocket::UnknownError;
         }
     }
 
     //private slots
     void reemitSocketError(QAbstractSocket::SocketError e)
     {
         q->setErrorString(sock.errorString());
         emit q->error(errorFromAbsSocket(e));
     }
 
     void reemitSslErrors(const QList<QSslError> &errors)
     {
         q->setErrorString(sock.errorString());
         q->showSslErrors(); //H4X
         QList<KSslError> kErrors;
         foreach (const QSslError &e, errors) {
             kErrors.append(KSslError(e));
         }
         emit q->sslErrors(kErrors);
     }
 
     void reemitStateChanged(QAbstractSocket::SocketState s)
     {
         emit q->stateChanged(state(s));
     }
 
     void reemitModeChanged(QSslSocket::SslMode m)
     {
         emit q->encryptionModeChanged(encryptionMode(m));
     }
 
     // This method is needed because we might emit readyRead() due to this QIODevice
     // having some data buffered, so we need to care about blocking, too.
     //### useless ATM as readyRead() now just calls d->sock.readyRead().
     void reemitReadyRead()
     {
         if (!emittedReadyRead) {
             emittedReadyRead = true;
             emit q->readyRead();
             emittedReadyRead = false;
         }
     }
 
     void maybeLoadCertificates()
     {
         if (!certificatesLoaded) {
             sock.setCaCertificates(KSslCertificateManager::self()->caCertificates());
             certificatesLoaded = true;
         }
     }
 
     KTcpSocket *const q;
     bool certificatesLoaded;
     bool emittedReadyRead;
     QSslSocket sock;
     QList<KSslCipher> ciphers;
     KTcpSocket::SslVersion advertisedSslVersion;
     CipherCc ccc;
 };
 
 KTcpSocket::KTcpSocket(QObject *parent)
     : QIODevice(parent),
       d(new KTcpSocketPrivate(this))
 {
     d->advertisedSslVersion = SslV3;
 
     connect(&d->sock, SIGNAL(aboutToClose()), this, SIGNAL(aboutToClose()));
     connect(&d->sock, SIGNAL(bytesWritten(qint64)), this, SIGNAL(bytesWritten(qint64)));
     connect(&d->sock, SIGNAL(encryptedBytesWritten(qint64)), this, SIGNAL(encryptedBytesWritten(qint64)));
     connect(&d->sock, SIGNAL(readyRead()), this, SLOT(reemitReadyRead()));
     connect(&d->sock, SIGNAL(connected()), this, SIGNAL(connected()));
     connect(&d->sock, SIGNAL(encrypted()), this, SIGNAL(encrypted()));
     connect(&d->sock, SIGNAL(disconnected()), this, SIGNAL(disconnected()));
 #ifndef QT_NO_NETWORKPROXY
     connect(&d->sock, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
             this, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
 #endif
     connect(&d->sock, SIGNAL(error(QAbstractSocket::SocketError)),
             this, SLOT(reemitSocketError(QAbstractSocket::SocketError)));
     connect(&d->sock, SIGNAL(sslErrors(QList<QSslError>)),
             this, SLOT(reemitSslErrors(QList<QSslError>)));
     connect(&d->sock, SIGNAL(hostFound()), this, SIGNAL(hostFound()));
     connect(&d->sock, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
             this, SLOT(reemitStateChanged(QAbstractSocket::SocketState)));
     connect(&d->sock, SIGNAL(modeChanged(QSslSocket::SslMode)),
             this, SLOT(reemitModeChanged(QSslSocket::SslMode)));
 }
 
 KTcpSocket::~KTcpSocket()
 {
     delete d;
 }
 
 ////////////////////////////// (mostly) virtuals from QIODevice
 
 bool KTcpSocket::atEnd() const
 {
     return d->sock.atEnd() && QIODevice::atEnd();
 }
 
 qint64 KTcpSocket::bytesAvailable() const
 {
     return d->sock.bytesAvailable() + QIODevice::bytesAvailable();
 }
 
 qint64 KTcpSocket::bytesToWrite() const
 {
     return d->sock.bytesToWrite();
 }
 
 bool KTcpSocket::canReadLine() const
 {
     return d->sock.canReadLine() || QIODevice::canReadLine();
 }
 
 void KTcpSocket::close()
 {
     d->sock.close();
     QIODevice::close();
 }
 
 bool KTcpSocket::isSequential() const
 {
     return true;
 }
 
 bool KTcpSocket::open(QIODevice::OpenMode open)
 {
     bool ret = d->sock.open(open);
     setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
     return ret;
 }
 
 bool KTcpSocket::waitForBytesWritten(int msecs)
 {
     return d->sock.waitForBytesWritten(msecs);
 }
 
 bool KTcpSocket::waitForReadyRead(int msecs)
 {
     return d->sock.waitForReadyRead(msecs);
 }
 
 qint64 KTcpSocket::readData(char *data, qint64 maxSize)
 {
     return d->sock.read(data, maxSize);
 }
 
 qint64 KTcpSocket::writeData(const char *data, qint64 maxSize)
 {
     return d->sock.write(data, maxSize);
 }
 
 ////////////////////////////// public methods from QAbstractSocket
 
 void KTcpSocket::abort()
 {
     d->sock.abort();
 }
 
 void KTcpSocket::connectToHost(const QString &hostName, quint16 port, ProxyPolicy policy)
 {
     if (policy == AutoProxy) {
         //###
     }
     d->sock.connectToHost(hostName, port);
     // there are enough layers of buffers between us and the network, and there is a quirk
     // in QIODevice that can make it try to readData() twice per read() call if buffered and
     // reaData() does not deliver enough data the first time. like when the other side is
     // simply not sending any more data...
     // this can *apparently* lead to long delays sometimes which stalls applications.
     // do not want.
     setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
 }
 
 void KTcpSocket::connectToHost(const QHostAddress &hostAddress, quint16 port, ProxyPolicy policy)
 {
     if (policy == AutoProxy) {
         //###
     }
     d->sock.connectToHost(hostAddress, port);
     setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
 }
 
 void KTcpSocket::connectToHost(const QUrl &url, ProxyPolicy policy)
 {
     if (policy == AutoProxy) {
         //###
     }
     d->sock.connectToHost(url.host(), url.port());
     setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
 }
 
 void KTcpSocket::disconnectFromHost()
 {
     d->sock.disconnectFromHost();
     setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
 }
 
 KTcpSocket::Error KTcpSocket::error() const
 {
     return d->errorFromAbsSocket(d->sock.error());
 }
 
 QList<KSslError> KTcpSocket::sslErrors() const
 {
     //### pretty slow; also consider throwing out duplicate error codes. We may get
     //    duplicates even though there were none in the original list because KSslError
     //    has a smallest common denominator range of SSL error codes.
     QList<KSslError> ret;
     foreach (const QSslError &e, d->sock.sslErrors()) {
         ret.append(KSslError(e));
     }
     return ret;
 }
 
 bool KTcpSocket::flush()
 {
     return d->sock.flush();
 }
 
 bool KTcpSocket::isValid() const
 {
     return d->sock.isValid();
 }
 
 QHostAddress KTcpSocket::localAddress() const
 {
     return d->sock.localAddress();
 }
 
 QHostAddress KTcpSocket::peerAddress() const
 {
     return d->sock.peerAddress();
 }
 
 QString KTcpSocket::peerName() const
 {
     return d->sock.peerName();
 }
 
 quint16 KTcpSocket::peerPort() const
 {
     return d->sock.peerPort();
 }
 
 #ifndef QT_NO_NETWORKPROXY
 QNetworkProxy KTcpSocket::proxy() const
 {
     return d->sock.proxy();
 }
 #endif
 
 qint64 KTcpSocket::readBufferSize() const
 {
     return d->sock.readBufferSize();
 }
 
 #ifndef QT_NO_NETWORKPROXY
 void KTcpSocket::setProxy(const QNetworkProxy &proxy)
 {
     d->sock.setProxy(proxy);
 }
 #endif
 
 void KTcpSocket::setReadBufferSize(qint64 size)
 {
     d->sock.setReadBufferSize(size);
 }
 
 KTcpSocket::State KTcpSocket::state() const
 {
     return d->state(d->sock.state());
 }
 
 bool KTcpSocket::waitForConnected(int msecs)
 {
     bool ret = d->sock.waitForConnected(msecs);
     if (!ret) {
         setErrorString(d->sock.errorString());
     }
     setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
     return ret;
 }
 
 bool KTcpSocket::waitForDisconnected(int msecs)
 {
     bool ret = d->sock.waitForDisconnected(msecs);
     if (!ret) {
         setErrorString(d->sock.errorString());
     }
     setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
     return ret;
 }
 
 ////////////////////////////// public methods from QSslSocket
 
 void KTcpSocket::addCaCertificate(const QSslCertificate &certificate)
 {
     d->maybeLoadCertificates();
     d->sock.addCaCertificate(certificate);
 }
 
 /*
 bool KTcpSocket::addCaCertificates(const QString &path, QSsl::EncodingFormat format,
                                    QRegExp::PatternSyntax syntax)
 {
     d->maybeLoadCertificates();
     return d->sock.addCaCertificates(path, format, syntax);
 }
 */
 
 void KTcpSocket::addCaCertificates(const QList<QSslCertificate> &certificates)
 {
     d->maybeLoadCertificates();
     d->sock.addCaCertificates(certificates);
 }
 
 QList<QSslCertificate> KTcpSocket::caCertificates() const
 {
     d->maybeLoadCertificates();
     return d->sock.caCertificates();
 }
 
 QList<KSslCipher> KTcpSocket::ciphers() const
 {
     return d->ciphers;
 }
 
 void KTcpSocket::connectToHostEncrypted(const QString &hostName, quint16 port, OpenMode openMode)
 {
     d->maybeLoadCertificates();
     d->sock.setProtocol(qSslProtocolFromK(d->advertisedSslVersion));
     d->sock.connectToHostEncrypted(hostName, port, openMode);
     setOpenMode(d->sock.openMode() | QIODevice::Unbuffered);
 }
 
 QSslCertificate KTcpSocket::localCertificate() const
 {
     return d->sock.localCertificate();
 }
 
 QList<QSslCertificate> KTcpSocket::peerCertificateChain() const
 {
     return d->sock.peerCertificateChain();
 }
 
 KSslKey KTcpSocket::privateKey() const
 {
     return KSslKey(d->sock.privateKey());
 }
 
 KSslCipher KTcpSocket::sessionCipher() const
 {
     return KSslCipher(d->sock.sessionCipher());
 }
 
 void KTcpSocket::setCaCertificates(const QList<QSslCertificate> &certificates)
 {
     d->sock.setCaCertificates(certificates);
     d->certificatesLoaded = true;
 }
 
 void KTcpSocket::setCiphers(const QList<KSslCipher> &ciphers)
 {
     d->ciphers = ciphers;
     QList<QSslCipher> cl;
     foreach (const KSslCipher &c, d->ciphers) {
         cl.append(d->ccc.converted(c));
     }
     d->sock.setCiphers(cl);
 }
 
 void KTcpSocket::setLocalCertificate(const QSslCertificate &certificate)
 {
     d->sock.setLocalCertificate(certificate);
 }
 
 void KTcpSocket::setLocalCertificate(const QString &fileName, QSsl::EncodingFormat format)
 {
     d->sock.setLocalCertificate(fileName, format);
 }
 
 void KTcpSocket::setVerificationPeerName(const QString &hostName)
 {
     d->sock.setPeerVerifyName(hostName);
 }
 
 void KTcpSocket::setPrivateKey(const KSslKey &key)
 {
     // We cannot map KSslKey::Algorithm:Dh to anything in QSsl::KeyAlgorithm.
     if (key.algorithm() == KSslKey::Dh) {
         return;
     }
 
     QSslKey _key(key.toDer(),
                  (key.algorithm() == KSslKey::Rsa) ? QSsl::Rsa : QSsl::Dsa,
                  QSsl::Der,
                  (key.secrecy() == KSslKey::PrivateKey) ? QSsl::PrivateKey : QSsl::PublicKey);
 
     d->sock.setPrivateKey(_key);
 }
 
 void KTcpSocket::setPrivateKey(const QString &fileName, KSslKey::Algorithm algorithm,
                                QSsl::EncodingFormat format, const QByteArray &passPhrase)
 {
     // We cannot map KSslKey::Algorithm:Dh to anything in QSsl::KeyAlgorithm.
     if (algorithm == KSslKey::Dh) {
         return;
     }
 
     d->sock.setPrivateKey(fileName,
                           (algorithm == KSslKey::Rsa) ? QSsl::Rsa : QSsl::Dsa,
                           format,
                           passPhrase);
 }
 
 bool KTcpSocket::waitForEncrypted(int msecs)
 {
     return d->sock.waitForEncrypted(msecs);
 }
 
 KTcpSocket::EncryptionMode KTcpSocket::encryptionMode() const
 {
     return d->encryptionMode(d->sock.mode());
 }
 
 QVariant KTcpSocket::socketOption(QAbstractSocket::SocketOption options) const
 {
     return d->sock.socketOption(options);
 }
 
 void KTcpSocket::setSocketOption(QAbstractSocket::SocketOption options, const QVariant &value)
 {
     d->sock.setSocketOption(options, value);
 }
 
 QSslConfiguration KTcpSocket::sslConfiguration() const
 {
     return d->sock.sslConfiguration();
 }
 
 void KTcpSocket::setSslConfiguration(const QSslConfiguration &configuration)
 {
     d->sock.setSslConfiguration(configuration);
 }
 
 //slot
 void KTcpSocket::ignoreSslErrors()
 {
     d->sock.ignoreSslErrors();
 }
 
 //slot
 void KTcpSocket::startClientEncryption()
 {
     d->maybeLoadCertificates();
     d->sock.setProtocol(qSslProtocolFromK(d->advertisedSslVersion));
     d->sock.startClientEncryption();
 }
 
 //debugging H4X
 void KTcpSocket::showSslErrors()
 {
     foreach (const QSslError &e, d->sock.sslErrors()) {
         qCDebug(KIO_CORE) << e.errorString();
     }
 }
 
 void KTcpSocket::setAdvertisedSslVersion(KTcpSocket::SslVersion version)
 {
     d->advertisedSslVersion = version;
 }
 
 KTcpSocket::SslVersion KTcpSocket::advertisedSslVersion() const
 {
     return d->advertisedSslVersion;
 }
 
 KTcpSocket::SslVersion KTcpSocket::negotiatedSslVersion() const
 {
     if (!d->sock.isEncrypted()) {
         return UnknownSslVersion;
     }
 
     return kSslVersionFromQ(d->sock.sessionProtocol());
 }
 
 QString KTcpSocket::negotiatedSslVersionName() const
 {
     if (!d->sock.isEncrypted()) {
         return QString();
     }
 
     return protocolString(d->sock.sessionProtocol());
 }
 
 ////////////////////////////// KSslKey
 
 class KSslKeyPrivate
 {
 public:
     KSslKey::Algorithm convertAlgorithm(QSsl::KeyAlgorithm a)
     {
         switch (a) {
         case QSsl::Dsa:
             return KSslKey::Dsa;
         default:
             return KSslKey::Rsa;
         }
     }
 
     KSslKey::Algorithm algorithm;
     KSslKey::KeySecrecy secrecy;
     bool isExportable;
     QByteArray der;
 };
 
 KSslKey::KSslKey()
     : d(new KSslKeyPrivate)
 {
     d->algorithm = Rsa;
     d->secrecy = PublicKey;
     d->isExportable = true;
 }
 
 KSslKey::KSslKey(const KSslKey &other)
     : d(new KSslKeyPrivate)
 {
     *d = *other.d;
 }
 
 KSslKey::KSslKey(const QSslKey &qsk)
     : d(new KSslKeyPrivate)
 {
     d->algorithm = d->convertAlgorithm(qsk.algorithm());
     d->secrecy = (qsk.type() == QSsl::PrivateKey) ? PrivateKey : PublicKey;
     d->isExportable = true;
     d->der = qsk.toDer();
 }
 
 KSslKey::~KSslKey()
 {
     delete d;
 }
 
 KSslKey &KSslKey::operator=(const KSslKey &other)
 {
     *d = *other.d;
     return *this;
 }
 
 KSslKey::Algorithm KSslKey::algorithm() const
 {
     return d->algorithm;
 }
 
 bool KSslKey::isExportable() const
 {
     return d->isExportable;
 }
 
 KSslKey::KeySecrecy KSslKey::secrecy() const
 {
     return d->secrecy;
 }
 
 QByteArray KSslKey::toDer() const
 {
     return d->der;
 }
 
 ////////////////////////////// KSslCipher
 
 //nice-to-have: make implicitly shared
 class KSslCipherPrivate
 {
 public:
 
     QString authenticationMethod;
     QString encryptionMethod;
     QString keyExchangeMethod;
     QString name;
     bool isNull;
     int supportedBits;
     int usedBits;
 };
 
 KSslCipher::KSslCipher()
     : d(new KSslCipherPrivate)
 {
     d->isNull = true;
     d->supportedBits = 0;
     d->usedBits = 0;
 }
 
 KSslCipher::KSslCipher(const KSslCipher &other)
     : d(new KSslCipherPrivate)
 {
     *d = *other.d;
 }
 
 KSslCipher::KSslCipher(const QSslCipher &qsc)
     : d(new KSslCipherPrivate)
 {
     d->authenticationMethod = qsc.authenticationMethod();
     d->encryptionMethod = qsc.encryptionMethod();
     //Qt likes to append the number of bits (usedBits?) to the algorithm,
     //for example "AES(256)". We only want the pure algorithm name, though.
     int parenIdx = d->encryptionMethod.indexOf(QLatin1Char('('));
     if (parenIdx > 0) {
         d->encryptionMethod.truncate(parenIdx);
     }
     d->keyExchangeMethod = qsc.keyExchangeMethod();
     d->name = qsc.name();
     d->isNull = qsc.isNull();
     d->supportedBits = qsc.supportedBits();
     d->usedBits = qsc.usedBits();
 }
 
 KSslCipher::~KSslCipher()
 {
     delete d;
 }
 
 KSslCipher &KSslCipher::operator=(const KSslCipher &other)
 {
     *d = *other.d;
     return *this;
 }
 
 bool KSslCipher::isNull() const
 {
     return d->isNull;
 }
 
 QString KSslCipher::authenticationMethod() const
 {
     return d->authenticationMethod;
 }
 
 QString KSslCipher::encryptionMethod() const
 {
     return d->encryptionMethod;
 }
 
 QString KSslCipher::keyExchangeMethod() const
 {
     return d->keyExchangeMethod;
 }
 
 QString KSslCipher::digestMethod() const
 {
     //### This is not really backend neutral. It works for OpenSSL and
     //    for RFC compliant names, though.
     if (d->name.endsWith(QLatin1String("SHA"))) {
         return QStringLiteral("SHA-1");
     } else if (d->name.endsWith(QLatin1String("MD5"))) {
         return QStringLiteral("MD5");
     } else {
-        return QStringLiteral("");    // ## probably QString() is enough
+        return QString();
     }
 }
 
 QString KSslCipher::name() const
 {
     return d->name;
 }
 
 int KSslCipher::supportedBits() const
 {
     return d->supportedBits;
 }
 
 int KSslCipher::usedBits() const
 {
     return d->usedBits;
 }
 
 //static
 QList<KSslCipher> KSslCipher::supportedCiphers()
 {
     QList<KSslCipher> ret;
     QList<QSslCipher> candidates = QSslSocket::supportedCiphers();
     foreach (const QSslCipher &c, candidates) {
         ret.append(KSslCipher(c));
     }
     return ret;
 }
 
 KSslErrorUiData::KSslErrorUiData()
     : d(new Private())
 {
     d->usedBits = 0;
     d->bits = 0;
 }
 
 KSslErrorUiData::KSslErrorUiData(const KTcpSocket *socket)
     : d(new Private())
 {
     d->certificateChain = socket->peerCertificateChain();
     d->sslErrors = socket->sslErrors();
     d->ip = socket->peerAddress().toString();
     d->host = socket->peerName();
     d->sslProtocol = socket->negotiatedSslVersionName();
     d->cipher = socket->sessionCipher().name();
     d->usedBits = socket->sessionCipher().usedBits();
     d->bits = socket->sessionCipher().supportedBits();
 }
 
 KSslErrorUiData::KSslErrorUiData(const QSslSocket *socket)
     : d(new Private())
 {
     d->certificateChain = socket->peerCertificateChain();
 
     // See KTcpSocket::sslErrors()
     foreach (const QSslError &e, socket->sslErrors()) {
         d->sslErrors.append(KSslError(e));
     }
 
     d->ip = socket->peerAddress().toString();
     d->host = socket->peerName();
     if (socket->isEncrypted()) {
         d->sslProtocol = socket->sessionCipher().protocolString();
     }
     d->cipher = socket->sessionCipher().name();
     d->usedBits = socket->sessionCipher().usedBits();
     d->bits = socket->sessionCipher().supportedBits();
 }
 
 KSslErrorUiData::KSslErrorUiData(const KSslErrorUiData &other)
     : d(new Private(*other.d))
 {}
 
 KSslErrorUiData::~KSslErrorUiData()
 {
     delete d;
 }
 
 KSslErrorUiData &KSslErrorUiData::operator=(const KSslErrorUiData &other)
 {
     *d = *other.d;
     return *this;
 }
 
 #include "moc_ktcpsocket.cpp"
diff --git a/src/filewidgets/kurlnavigator.cpp b/src/filewidgets/kurlnavigator.cpp
index 845ddbb1..e63f7f45 100644
--- a/src/filewidgets/kurlnavigator.cpp
+++ b/src/filewidgets/kurlnavigator.cpp
@@ -1,1309 +1,1309 @@
 /*****************************************************************************
  * Copyright (C) 2006-2010 by Peter Penz <peter.penz@gmx.at>                 *
  * Copyright (C) 2006 by Aaron J. Seigo <aseigo@kde.org>                     *
  * Copyright (C) 2007 by Kevin Ottens <ervin@kde.org>                        *
  * Copyright (C) 2007 by Urs Wolfer <uwolfer @ kde.org>                      *
  *                                                                           *
  * This library is free software; you can redistribute it and/or             *
  * modify it under the terms of the GNU Library General Public               *
  * License as published by the Free Software Foundation; either              *
  * version 2 of the License, or (at your option) any later version.          *
  *                                                                           *
  * This library is distributed in the hope that it will be useful,           *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  * Library General Public License for more details.                          *
  *                                                                           *
  * You should have received a copy of the GNU Library General Public License *
  * along with this library; see the file COPYING.LIB.  If not, write to      *
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,      *
  * Boston, MA 02110-1301, USA.                                               *
  *****************************************************************************/
 
 #include "kurlnavigator.h"
 
 #include "kurlnavigatorplacesselector_p.h"
 #include "kurlnavigatorprotocolcombo_p.h"
 #include "kurlnavigatordropdownbutton_p.h"
 #include "kurlnavigatorbutton_p.h"
 #include "kurlnavigatortogglebutton_p.h"
 #include "kurlnavigatorpathselectoreventfilter_p.h"
 #include "urlutil_p.h"
 
 #include <kfileitem.h>
 #include <kfileplacesmodel.h>
 #include <klocalizedstring.h>
 #include <kprotocolinfo.h>
 #include <kurlcombobox.h>
 #include <kurlcompletion.h>
 #include <kurifilter.h>
 
 #include <QDir>
 #include <QLinkedList>
 #include <QTimer>
 #include <QApplication>
 #include <QBoxLayout>
 #include <QClipboard>
 #include <QDropEvent>
 #include <QKeyEvent>
 #include <QLabel>
 #include <QMenu>
 #include <QPainter>
 #include <QStyleOption>
 #include <qmimedatabase.h>
 #include <QMimeData>
 
 using namespace KDEPrivate;
 
 struct LocationData {
     QUrl url;
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
     QUrl rootUrl;      // KDE5: remove after the deprecated methods have been removed
     QPoint pos;        // KDE5: remove after the deprecated methods have been removed
 #endif
     QByteArray state;
 };
 
 class Q_DECL_HIDDEN KUrlNavigator::Private
 {
 public:
     Private(KUrlNavigator *q, KFilePlacesModel *placesModel);
 
     void initialize(const QUrl &url);
 
     /** Applies the edited URL in m_pathBox to the URL navigator */
     void applyUncommittedUrl();
 
     void slotReturnPressed();
     void slotProtocolChanged(const QString &);
     void openPathSelectorMenu();
 
     /**
      * Appends the widget at the end of the URL navigator. It is assured
      * that the filler widget remains as last widget to fill the remaining
      * width.
      */
     void appendWidget(QWidget *widget, int stretch = 0);
 
     /**
      * This slot is connected to the clicked signal of the navigation bar button. It calls switchView().
      * Moreover, if switching from "editable" mode to the breadcrumb view, it calls applyUncommittedUrl().
      */
     void slotToggleEditableButtonPressed();
 
     /**
      * Switches the navigation bar between the breadcrumb view and the
      * traditional view (see setUrlEditable()).
      */
     void switchView();
 
     /** Emits the signal urlsDropped(). */
     void dropUrls(const QUrl &destination, QDropEvent *event);
 
     /**
      * Is invoked when a navigator button has been clicked. Changes the URL
      * of the navigator if the left mouse button has been used. If the middle
      * mouse button has been used, the signal tabRequested() will be emitted.
      */
     void slotNavigatorButtonClicked(const QUrl &url, Qt::MouseButton button);
 
     void openContextMenu();
 
     void slotPathBoxChanged(const QString &text);
 
     void updateContent();
 
     /**
      * Updates all buttons to have one button for each part of the
      * current URL. Existing buttons, which are available by m_navButtons,
      * are reused if possible. If the URL is longer, new buttons will be
      * created, if the URL is shorter, the remaining buttons will be deleted.
      * @param startIndex    Start index of URL part (/), where the buttons
      *                      should be created for each following part.
      */
     void updateButtons(int startIndex);
 
     /**
      * Updates the visibility state of all buttons describing the URL. If the
      * width of the URL navigator is too small, the buttons representing the upper
      * paths of the URL will be hidden and moved to a drop down menu.
      */
     void updateButtonVisibility();
 
     /**
      * @return Text for the first button of the URL navigator.
      */
     QString firstButtonText() const;
 
     /**
      * Returns the URL that should be applied for the button with the index \a index.
      */
     QUrl buttonUrl(int index) const;
 
     void switchToBreadcrumbMode();
 
     /**
      * Deletes all URL navigator buttons. m_navButtons is
      * empty after this operation.
      */
     void deleteButtons();
 
     /**
      * Retrieves the place url for the current url.
      * E. g. for the path "fish://root@192.168.0.2/var/lib" the string
      * "fish://root@192.168.0.2" will be returned, which leads to the
      * navigation indication 'Custom Path > var > lib". For e. g.
      * "settings:///System/" the path "settings://" will be returned.
      */
     QUrl retrievePlaceUrl() const;
 
     /**
      * Returns true, if the MIME type of the path represents a
      * compressed file like TAR or ZIP.
      */
     bool isCompressedPath(const QUrl &path) const;
 
     void removeTrailingSlash(QString &url) const;
 
     /**
      * Returns the current history index, if \a historyIndex is
      * smaller than 0. If \a historyIndex is greater or equal than
      * the number of available history items, the largest possible
      * history index is returned. For the other cases just \a historyIndex
      * is returned.
      */
     int adjustedHistoryIndex(int historyIndex) const;
 
     bool m_editable : 1;
     bool m_active : 1;
     bool m_showPlacesSelector : 1;
     bool m_showFullPath : 1;
     int m_historyIndex;
 
     QHBoxLayout *m_layout;
 
     QList<LocationData> m_history;
     KUrlNavigatorPlacesSelector *m_placesSelector;
     KUrlComboBox *m_pathBox;
     KUrlNavigatorProtocolCombo *m_protocols;
     KUrlNavigatorDropDownButton *m_dropDownButton;
     QList<KUrlNavigatorButton *> m_navButtons;
     KUrlNavigatorButtonBase *m_toggleEditableMode;
     QUrl m_homeUrl;
     QStringList m_customProtocols;
     QWidget *m_dropWidget;
     KUrlNavigator *q;
 };
 
 KUrlNavigator::Private::Private(KUrlNavigator *q, KFilePlacesModel *placesModel) :
     m_editable(false),
     m_active(true),
     m_showPlacesSelector(placesModel != nullptr),
     m_showFullPath(false),
     m_historyIndex(0),
     m_layout(new QHBoxLayout),
     m_placesSelector(nullptr),
     m_pathBox(nullptr),
     m_protocols(nullptr),
     m_dropDownButton(nullptr),
     m_navButtons(),
     m_toggleEditableMode(nullptr),
     m_homeUrl(),
     m_customProtocols(QStringList()),
     m_dropWidget(nullptr),
     q(q)
 {
     m_layout->setSpacing(0);
     m_layout->setMargin(0);
 
     // initialize the places selector
     q->setAutoFillBackground(false);
 
     if (placesModel != nullptr) {
         m_placesSelector = new KUrlNavigatorPlacesSelector(q, placesModel);
         connect(m_placesSelector, SIGNAL(placeActivated(QUrl)),
                 q, SLOT(setLocationUrl(QUrl)));
         connect(m_placesSelector, &KUrlNavigatorPlacesSelector::tabRequested,
                 q, &KUrlNavigator::tabRequested);
 
         connect(placesModel, SIGNAL(rowsInserted(QModelIndex,int,int)),
                 q, SLOT(updateContent()));
         connect(placesModel, SIGNAL(rowsRemoved(QModelIndex,int,int)),
                 q, SLOT(updateContent()));
         connect(placesModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                 q, SLOT(updateContent()));
     }
 
     // create protocol combo
     m_protocols = new KUrlNavigatorProtocolCombo(QString(), q);
     connect(m_protocols, SIGNAL(activated(QString)),
             q, SLOT(slotProtocolChanged(QString)));
 
     // create drop down button for accessing all paths of the URL
     m_dropDownButton = new KUrlNavigatorDropDownButton(q);
     m_dropDownButton->setForegroundRole(QPalette::WindowText);
     m_dropDownButton->installEventFilter(q);
     connect(m_dropDownButton, SIGNAL(clicked()),
             q, SLOT(openPathSelectorMenu()));
 
     // initialize the path box of the traditional view
     m_pathBox = new KUrlComboBox(KUrlComboBox::Directories, true, q);
     m_pathBox->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
     m_pathBox->installEventFilter(q);
 
     KUrlCompletion *kurlCompletion = new KUrlCompletion(KUrlCompletion::DirCompletion);
     m_pathBox->setCompletionObject(kurlCompletion);
     m_pathBox->setAutoDeleteCompletionObject(true);
 
     connect(m_pathBox, SIGNAL(returnPressed()),
             q, SLOT(slotReturnPressed()));
     connect(m_pathBox, SIGNAL(urlActivated(QUrl)),
             q, SLOT(setLocationUrl(QUrl)));
     connect(m_pathBox, SIGNAL(editTextChanged(QString)),
             q, SLOT(slotPathBoxChanged(QString)));
 
     // create toggle button which allows to switch between
     // the breadcrumb and traditional view
     m_toggleEditableMode = new KUrlNavigatorToggleButton(q);
     m_toggleEditableMode->installEventFilter(q);
     m_toggleEditableMode->setMinimumWidth(20);
     connect(m_toggleEditableMode, SIGNAL(clicked()),
             q, SLOT(slotToggleEditableButtonPressed()));
 
     if (m_placesSelector != nullptr) {
         m_layout->addWidget(m_placesSelector);
     }
     m_layout->addWidget(m_protocols);
     m_layout->addWidget(m_dropDownButton);
     m_layout->addWidget(m_pathBox, 1);
     m_layout->addWidget(m_toggleEditableMode);
 
     q->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(q, SIGNAL(customContextMenuRequested(QPoint)),
             q, SLOT(openContextMenu()));
 }
 
 void KUrlNavigator::Private::initialize(const QUrl &url)
 {
     LocationData data;
     data.url = url.adjusted(QUrl::NormalizePathSegments);
     m_history.prepend(data);
 
     q->setLayoutDirection(Qt::LeftToRight);
 
     const int minHeight = m_pathBox->sizeHint().height();
     q->setMinimumHeight(minHeight);
 
     q->setLayout(m_layout);
     q->setMinimumWidth(100);
 
     updateContent();
 }
 
 void KUrlNavigator::Private::appendWidget(QWidget *widget, int stretch)
 {
     m_layout->insertWidget(m_layout->count() - 1, widget, stretch);
 }
 
 void KUrlNavigator::Private::applyUncommittedUrl()
 {
     // Parts of the following code have been taken
     // from the class KateFileSelector located in
     // kate/app/katefileselector.hpp of Kate.
     // Copyright (C) 2001 Christoph Cullmann <cullmann@kde.org>
     // Copyright (C) 2001 Joseph Wenninger <jowenn@kde.org>
     // Copyright (C) 2001 Anders Lund <anders.lund@lund.tdcadsl.dk>
 
     const QUrl typedUrl = q->uncommittedUrl();
     QStringList urls = m_pathBox->urls();
     urls.removeAll(typedUrl.toString());
     urls.prepend(typedUrl.toString());
     m_pathBox->setUrls(urls, KUrlComboBox::RemoveBottom);
 
     q->setLocationUrl(typedUrl);
     // The URL might have been adjusted by KUrlNavigator::setUrl(), hence
     // synchronize the result in the path box.
     const QUrl currentUrl = q->locationUrl();
     m_pathBox->setUrl(currentUrl);
 }
 
 void KUrlNavigator::Private::slotReturnPressed()
 {
     applyUncommittedUrl();
 
     emit q->returnPressed();
 
     if (QApplication::keyboardModifiers() & Qt::ControlModifier) {
         // Pressing Ctrl+Return automatically switches back to the breadcrumb mode.
         // The switch must be done asynchronously, as we are in the context of the
         // editor.
         QMetaObject::invokeMethod(q, "switchToBreadcrumbMode", Qt::QueuedConnection);
     }
 }
 
 void KUrlNavigator::Private::slotProtocolChanged(const QString &protocol)
 {
     Q_ASSERT(m_editable);
 
     QUrl url;
     url.setScheme(protocol);
     if (protocol == QLatin1String("file")) {
         url.setPath(QStringLiteral("/"));
     } else {
         // With no authority set we'll get e.g. "ftp:" instead of "ftp://".
         // We want the latter, so let's set an empty authority.
-        url.setAuthority(QStringLiteral(""));
+        url.setAuthority(QString());
     }
 
     m_pathBox->setEditUrl(url);
 }
 
 void KUrlNavigator::Private::openPathSelectorMenu()
 {
     if (m_navButtons.count() <= 0) {
         return;
     }
 
     const QUrl firstVisibleUrl = m_navButtons.first()->url();
 
     QString spacer;
     QPointer<QMenu> popup = new QMenu(q);
 
     auto *popupFilter = new KUrlNavigatorPathSelectorEventFilter(popup.data());
     connect(popupFilter, &KUrlNavigatorPathSelectorEventFilter::tabRequested, q, &KUrlNavigator::tabRequested);
     popup->installEventFilter(popupFilter);
 
     popup->setLayoutDirection(Qt::LeftToRight);
 
     const QUrl placeUrl = retrievePlaceUrl();
     int idx = placeUrl.path().count(QLatin1Char('/')); // idx points to the first directory
     // after the place path
 
     const QString path = m_history[m_historyIndex].url.path();
     QString dirName = path.section(QLatin1Char('/'), idx, idx);
     if (dirName.isEmpty()) {
         if (placeUrl.isLocalFile()) {
             dirName = QStringLiteral("/");
         } else {
             dirName = placeUrl.toDisplayString();
         }
     }
     do {
         const QString text = spacer + dirName;
 
         QAction *action = new QAction(text, popup);
         const QUrl currentUrl = buttonUrl(idx);
         if (currentUrl == firstVisibleUrl) {
             popup->addSeparator();
         }
         action->setData(QVariant(currentUrl.toString()));
         popup->addAction(action);
 
         ++idx;
         spacer.append("  ");
         dirName = path.section('/', idx, idx);
     } while (!dirName.isEmpty());
 
     const QPoint pos = q->mapToGlobal(m_dropDownButton->geometry().bottomRight());
     const QAction *activatedAction = popup->exec(pos);
     if (activatedAction != nullptr) {
         const QUrl url(activatedAction->data().toString());
         q->setLocationUrl(url);
     }
 
     // Delete the menu, unless it has been deleted in its own nested event loop already.
     if (popup) {
         popup->deleteLater();
     }
 }
 
 void KUrlNavigator::Private::slotToggleEditableButtonPressed()
 {
     if (m_editable) {
         applyUncommittedUrl();
     }
 
     switchView();
 }
 
 void KUrlNavigator::Private::switchView()
 {
     m_toggleEditableMode->setFocus();
     m_editable = !m_editable;
     m_toggleEditableMode->setChecked(m_editable);
     updateContent();
     if (q->isUrlEditable()) {
         m_pathBox->setFocus();
     }
 
     q->requestActivation();
     emit q->editableStateChanged(m_editable);
 }
 
 void KUrlNavigator::Private::dropUrls(const QUrl &destination, QDropEvent *event)
 {
     if (event->mimeData()->hasUrls()) {
         m_dropWidget = qobject_cast<QWidget*>(q->sender());
         emit q->urlsDropped(destination, event);
     }
 }
 
 void KUrlNavigator::Private::slotNavigatorButtonClicked(const QUrl &url, Qt::MouseButton button)
 {
     if (button & Qt::LeftButton) {
         q->setLocationUrl(url);
     } else if (button & Qt::MidButton) {
         emit q->tabRequested(url);
     }
 }
 
 void KUrlNavigator::Private::openContextMenu()
 {
     q->setActive(true);
 
     QPointer<QMenu> popup = new QMenu(q);
 
     // provide 'Copy' action, which copies the current URL of
     // the URL navigator into the clipboard
     QAction *copyAction = popup->addAction(QIcon::fromTheme(QStringLiteral("edit-copy")), i18n("Copy"));
 
     // provide 'Paste' action, which copies the current clipboard text
     // into the URL navigator
     QAction *pasteAction = popup->addAction(QIcon::fromTheme(QStringLiteral("edit-paste")), i18n("Paste"));
     QClipboard *clipboard = QApplication::clipboard();
     pasteAction->setEnabled(!clipboard->text().isEmpty());
 
     popup->addSeparator();
 
     // provide radiobuttons for toggling between the edit and the navigation mode
     QAction *editAction = popup->addAction(i18n("Edit"));
     editAction->setCheckable(true);
 
     QAction *navigateAction = popup->addAction(i18n("Navigate"));
     navigateAction->setCheckable(true);
 
     QActionGroup *modeGroup = new QActionGroup(popup);
     modeGroup->addAction(editAction);
     modeGroup->addAction(navigateAction);
     if (q->isUrlEditable()) {
         editAction->setChecked(true);
     } else {
         navigateAction->setChecked(true);
     }
 
     popup->addSeparator();
 
     // allow showing of the full path
     QAction *showFullPathAction = popup->addAction(i18n("Show Full Path"));
     showFullPathAction->setCheckable(true);
     showFullPathAction->setChecked(q->showFullPath());
 
     QAction *activatedAction = popup->exec(QCursor::pos());
     if (activatedAction == copyAction) {
         QMimeData *mimeData = new QMimeData();
         mimeData->setText(q->locationUrl().toDisplayString(QUrl::PreferLocalFile));
         clipboard->setMimeData(mimeData);
     } else if (activatedAction == pasteAction) {
         q->setLocationUrl(QUrl::fromUserInput(clipboard->text()));
     } else if (activatedAction == editAction) {
         q->setUrlEditable(true);
     } else if (activatedAction == navigateAction) {
         q->setUrlEditable(false);
     } else if (activatedAction == showFullPathAction) {
         q->setShowFullPath(showFullPathAction->isChecked());
     }
 
     // Delete the menu, unless it has been deleted in its own nested event loop already.
     if (popup) {
         popup->deleteLater();
     }
 }
 
 void KUrlNavigator::Private::slotPathBoxChanged(const QString &text)
 {
     if (text.isEmpty()) {
         const QString protocol = q->locationUrl().scheme();
         m_protocols->setProtocol(protocol);
         if (m_customProtocols.count() != 1) {
             m_protocols->show();
         }
     } else {
         m_protocols->hide();
     }
 }
 
 void KUrlNavigator::Private::updateContent()
 {
     const QUrl currentUrl = q->locationUrl();
     if (m_placesSelector != nullptr) {
         m_placesSelector->updateSelection(currentUrl);
     }
 
     if (m_editable) {
         m_protocols->hide();
         m_dropDownButton->hide();
 
         deleteButtons();
         m_toggleEditableMode->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
         q->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
 
         m_pathBox->show();
         m_pathBox->setUrl(currentUrl);
     } else {
         m_pathBox->hide();
 
         m_protocols->hide();
 
         m_toggleEditableMode->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
         q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
         // Calculate the start index for the directories that should be shown as buttons
         // and create the buttons
         QUrl placeUrl;
         if ((m_placesSelector != nullptr) && !m_showFullPath) {
             placeUrl = m_placesSelector->selectedPlaceUrl();
         }
 
         if (!placeUrl.isValid()) {
             placeUrl = retrievePlaceUrl();
         }
         QString placePath = placeUrl.path();
         removeTrailingSlash(placePath);
 
         const int startIndex = placePath.count('/');
         updateButtons(startIndex);
     }
 }
 
 void KUrlNavigator::Private::updateButtons(int startIndex)
 {
     QUrl currentUrl = q->locationUrl();
     if (!currentUrl.isValid()) { // QFileDialog::setDirectory not called yet
         return;
     }
 
     const QString path = currentUrl.path();
 
     bool createButton = false;
     const int oldButtonCount = m_navButtons.count();
 
     int idx = startIndex;
     bool hasNext = true;
     do {
         createButton = (idx - startIndex >= oldButtonCount);
         const bool isFirstButton = (idx == startIndex);
         const QString dirName = path.section(QLatin1Char('/'), idx, idx);
         hasNext = isFirstButton || !dirName.isEmpty();
         if (hasNext) {
             KUrlNavigatorButton *button = nullptr;
             if (createButton) {
                 button = new KUrlNavigatorButton(buttonUrl(idx), q);
                 button->installEventFilter(q);
                 button->setForegroundRole(QPalette::WindowText);
                 connect(button, SIGNAL(urlsDropped(QUrl,QDropEvent*)),
                         q, SLOT(dropUrls(QUrl,QDropEvent*)));
                 connect(button, SIGNAL(clicked(QUrl,Qt::MouseButton)),
                         q, SLOT(slotNavigatorButtonClicked(QUrl,Qt::MouseButton)));
                 connect(button, SIGNAL(finishedTextResolving()),
                         q, SLOT(updateButtonVisibility()));
                 appendWidget(button);
             } else {
                 button = m_navButtons[idx - startIndex];
                 button->setUrl(buttonUrl(idx));
             }
 
             if (isFirstButton) {
                 button->setText(firstButtonText());
             }
             button->setActive(q->isActive());
 
             if (createButton) {
                 if (!isFirstButton) {
                     setTabOrder(m_navButtons.last(), button);
                 }
                 m_navButtons.append(button);
             }
 
             ++idx;
             button->setActiveSubDirectory(path.section(QLatin1Char('/'), idx, idx));
         }
     } while (hasNext);
 
     // delete buttons which are not used anymore
     const int newButtonCount = idx - startIndex;
     if (newButtonCount < oldButtonCount) {
         const QList<KUrlNavigatorButton *>::iterator itBegin = m_navButtons.begin() + newButtonCount;
         const QList<KUrlNavigatorButton *>::iterator itEnd = m_navButtons.end();
         QList<KUrlNavigatorButton *>::iterator it = itBegin;
         while (it != itEnd) {
             (*it)->hide();
             (*it)->deleteLater();
             ++it;
         }
         m_navButtons.erase(itBegin, itEnd);
     }
 
     setTabOrder(m_dropDownButton, m_navButtons.first());
     setTabOrder(m_navButtons.last(), m_toggleEditableMode);
 
     updateButtonVisibility();
 }
 
 void KUrlNavigator::Private::updateButtonVisibility()
 {
     if (m_editable) {
         return;
     }
 
     const int buttonsCount = m_navButtons.count();
     if (buttonsCount == 0) {
         m_dropDownButton->hide();
         return;
     }
 
     // Subtract all widgets from the available width, that must be shown anyway
     int availableWidth = q->width() - m_toggleEditableMode->minimumWidth();
 
     if ((m_placesSelector != nullptr) && m_placesSelector->isVisible()) {
         availableWidth -= m_placesSelector->width();
     }
 
     if ((m_protocols != nullptr) && m_protocols->isVisible()) {
         availableWidth -= m_protocols->width();
     }
 
     // Check whether buttons must be hidden at all...
     int requiredButtonWidth = 0;
     foreach (const KUrlNavigatorButton *button, m_navButtons) {
         requiredButtonWidth += button->minimumWidth();
     }
 
     if (requiredButtonWidth > availableWidth) {
         // At least one button must be hidden. This implies that the
         // drop-down button must get visible, which again decreases the
         // available width.
         availableWidth -= m_dropDownButton->width();
     }
 
     // Hide buttons...
     QList<KUrlNavigatorButton *>::const_iterator it = m_navButtons.constEnd();
     const QList<KUrlNavigatorButton *>::const_iterator itBegin = m_navButtons.constBegin();
     bool isLastButton = true;
     bool hasHiddenButtons = false;
 
     QLinkedList<KUrlNavigatorButton *> buttonsToShow;
     while (it != itBegin) {
         --it;
         KUrlNavigatorButton *button = (*it);
         availableWidth -= button->minimumWidth();
         if ((availableWidth <= 0) && !isLastButton) {
             button->hide();
             hasHiddenButtons = true;
         } else {
             // Don't show the button immediately, as setActive()
             // might change the size and a relayout gets triggered
             // after showing the button. So the showing of all buttons
             // is postponed until all buttons have the correct
             // activation state.
             buttonsToShow.append(button);
         }
         isLastButton = false;
     }
 
     // All buttons have the correct activation state and
     // can be shown now
     foreach (KUrlNavigatorButton *button, buttonsToShow) {
         button->show();
     }
 
     if (hasHiddenButtons) {
         m_dropDownButton->show();
     } else {
         // Check whether going upwards is possible. If this is the case, show the drop-down button.
         QUrl url(m_navButtons.front()->url());
         const bool visible = !url.matches(KIO::upUrl(url), QUrl::StripTrailingSlash) && (url.scheme() != QLatin1String("nepomuksearch"));
         m_dropDownButton->setVisible(visible);
     }
 }
 
 QString KUrlNavigator::Private::firstButtonText() const
 {
     QString text;
 
     // The first URL navigator button should get the name of the
     // place instead of the directory name
     if ((m_placesSelector != nullptr) && !m_showFullPath) {
         text = m_placesSelector->selectedPlaceText();
     }
 
     if (text.isEmpty()) {
         const QUrl currentUrl = q->locationUrl();
         if (currentUrl.isLocalFile()) {
 #ifdef Q_OS_WIN
             text = currentUrl.path().length() > 1 ? currentUrl.path().left(2) : QDir::rootPath();
 #else
             text = m_showFullPath ? QStringLiteral("/") : i18n("Custom Path");
 #endif
         } else {
             text = currentUrl.scheme() + QLatin1Char(':');
             if (!currentUrl.host().isEmpty()) {
                 text += QLatin1Char(' ') + currentUrl.host();
             }
         }
     }
 
     return text;
 }
 
 QUrl KUrlNavigator::Private::buttonUrl(int index) const
 {
     if (index < 0) {
         index = 0;
     }
 
     // Keep scheme, hostname etc. as this is needed for e. g. browsing
     // FTP directories
     QUrl url = q->locationUrl();
     QString path = url.path();
 
     if (!path.isEmpty()) {
         if (index == 0) {
             // prevent the last "/" from being stripped
             // or we end up with an empty path
 #ifdef Q_OS_WIN
             path = path.length() > 1 ? path.left(2) : QDir::rootPath();
 #else
             path = QStringLiteral("/");
 #endif
         } else {
             path = path.section('/', 0, index);
         }
     }
 
     url.setPath(path);
     return url;
 }
 
 void KUrlNavigator::Private::switchToBreadcrumbMode()
 {
     q->setUrlEditable(false);
 }
 
 void KUrlNavigator::Private::deleteButtons()
 {
     foreach (KUrlNavigatorButton *button, m_navButtons) {
         button->hide();
         button->deleteLater();
     }
     m_navButtons.clear();
 }
 
 QUrl KUrlNavigator::Private::retrievePlaceUrl() const
 {
     QUrl currentUrl = q->locationUrl();
     currentUrl.setPath(QString());
     return currentUrl;
 }
 
 bool KUrlNavigator::Private::isCompressedPath(const QUrl &url) const
 {
     QMimeDatabase db;
     const QMimeType mime = db.mimeTypeForUrl(QUrl(url.toString(QUrl::StripTrailingSlash)));
     // Note: this list of MIME types depends on the protocols implemented by kio_archive
     return  mime.inherits(QStringLiteral("application/x-compressed-tar")) ||
             mime.inherits(QStringLiteral("application/x-bzip-compressed-tar")) ||
             mime.inherits(QStringLiteral("application/x-lzma-compressed-tar")) ||
             mime.inherits(QStringLiteral("application/x-xz-compressed-tar")) ||
             mime.inherits(QStringLiteral("application/x-tar")) ||
             mime.inherits(QStringLiteral("application/x-tarz")) ||
             mime.inherits(QStringLiteral("application/x-tzo")) || // (not sure KTar supports those?)
             mime.inherits(QStringLiteral("application/zip")) ||
             mime.inherits(QStringLiteral("application/x-archive"));
 }
 
 void KUrlNavigator::Private::removeTrailingSlash(QString &url) const
 {
     const int length = url.length();
     if ((length > 0) && (url.at(length - 1) == QChar('/'))) {
         url.remove(length - 1, 1);
     }
 }
 
 int KUrlNavigator::Private::adjustedHistoryIndex(int historyIndex) const
 {
     if (historyIndex < 0) {
         historyIndex = m_historyIndex;
     } else if (historyIndex >= m_history.size()) {
         historyIndex = m_history.size() - 1;
         Q_ASSERT(historyIndex >= 0); // m_history.size() must always be > 0
     }
     return historyIndex;
 }
 
 // ------------------------------------------------------------------------------------------------
 
 KUrlNavigator::KUrlNavigator(QWidget *parent) :
     QWidget(parent),
     d(new Private(this, nullptr))
 {
     d->initialize(QUrl());
 }
 
 KUrlNavigator::KUrlNavigator(KFilePlacesModel *placesModel,
                              const QUrl &url,
                              QWidget *parent) :
     QWidget(parent),
     d(new Private(this, placesModel))
 {
     d->initialize(url);
 }
 
 KUrlNavigator::~KUrlNavigator()
 {
     delete d;
 }
 
 QUrl KUrlNavigator::locationUrl(int historyIndex) const
 {
     historyIndex = d->adjustedHistoryIndex(historyIndex);
     return d->m_history[historyIndex].url;
 }
 
 void KUrlNavigator::saveLocationState(const QByteArray &state)
 {
     d->m_history[d->m_historyIndex].state = state;
 }
 
 QByteArray KUrlNavigator::locationState(int historyIndex) const
 {
     historyIndex = d->adjustedHistoryIndex(historyIndex);
     return d->m_history[historyIndex].state;
 }
 
 bool KUrlNavigator::goBack()
 {
     const int count = d->m_history.count();
     if (d->m_historyIndex < count - 1) {
         const QUrl newUrl = locationUrl(d->m_historyIndex + 1);
         emit urlAboutToBeChanged(newUrl);
 
         ++d->m_historyIndex;
         d->updateContent();
 
         emit historyChanged();
         emit urlChanged(locationUrl());
         return true;
     }
 
     return false;
 }
 
 bool KUrlNavigator::goForward()
 {
     if (d->m_historyIndex > 0) {
         const QUrl newUrl = locationUrl(d->m_historyIndex - 1);
         emit urlAboutToBeChanged(newUrl);
 
         --d->m_historyIndex;
         d->updateContent();
 
         emit historyChanged();
         emit urlChanged(locationUrl());
         return true;
     }
 
     return false;
 }
 
 bool KUrlNavigator::goUp()
 {
     const QUrl currentUrl = locationUrl();
     const QUrl upUrl = KIO::upUrl(currentUrl);
     if (upUrl != currentUrl) { // TODO use url.matches(KIO::upUrl(url), QUrl::StripTrailingSlash)
         setLocationUrl(upUrl);
         return true;
     }
 
     return false;
 }
 
 void KUrlNavigator::goHome()
 {
     if (d->m_homeUrl.isEmpty() || !d->m_homeUrl.isValid()) {
         setLocationUrl(QUrl::fromLocalFile(QDir::homePath()));
     } else {
         setLocationUrl(d->m_homeUrl);
     }
 }
 
 void KUrlNavigator::setHomeUrl(const QUrl &url)
 {
     d->m_homeUrl = url;
 }
 
 QUrl KUrlNavigator::homeUrl() const
 {
     return d->m_homeUrl;
 }
 
 void KUrlNavigator::setUrlEditable(bool editable)
 {
     if (d->m_editable != editable) {
         d->switchView();
     }
 }
 
 bool KUrlNavigator::isUrlEditable() const
 {
     return d->m_editable;
 }
 
 void KUrlNavigator::setShowFullPath(bool show)
 {
     if (d->m_showFullPath != show) {
         d->m_showFullPath = show;
         d->updateContent();
     }
 }
 
 bool KUrlNavigator::showFullPath() const
 {
     return d->m_showFullPath;
 }
 
 void KUrlNavigator::setActive(bool active)
 {
     if (active != d->m_active) {
         d->m_active = active;
 
         d->m_dropDownButton->setActive(active);
         foreach (KUrlNavigatorButton *button, d->m_navButtons) {
             button->setActive(active);
         }
 
         update();
         if (active) {
             emit activated();
         }
     }
 }
 
 bool KUrlNavigator::isActive() const
 {
     return d->m_active;
 }
 
 void KUrlNavigator::setPlacesSelectorVisible(bool visible)
 {
     if (visible == d->m_showPlacesSelector) {
         return;
     }
 
     if (visible  && (d->m_placesSelector == nullptr)) {
         // the places selector cannot get visible as no
         // places model is available
         return;
     }
 
     d->m_showPlacesSelector = visible;
     d->m_placesSelector->setVisible(visible);
 }
 
 bool KUrlNavigator::isPlacesSelectorVisible() const
 {
     return d->m_showPlacesSelector;
 }
 
 QUrl KUrlNavigator::uncommittedUrl() const
 {
     KUriFilterData filteredData(d->m_pathBox->currentText().trimmed());
     filteredData.setCheckForExecutables(false);
     if (KUriFilter::self()->filterUri(filteredData, QStringList() << QStringLiteral("kshorturifilter") << QStringLiteral("kurisearchfilter"))) {
         return filteredData.uri();
     } else {
         return QUrl::fromUserInput(filteredData.typedString());
     }
 }
 
 void KUrlNavigator::setLocationUrl(const QUrl &newUrl)
 {
     if (newUrl == locationUrl()) {
         return;
     }
 
     QUrl url = newUrl.adjusted(QUrl::NormalizePathSegments);
 
     // This will be used below; we define it here because in the lower part of the
     // code locationUrl() and url become the same URLs
     const QUrl firstChildUrl = KIO::UrlUtil::firstChildUrl(locationUrl(), url);
 
     if ((url.scheme() == QLatin1String("tar")) || (url.scheme() == QLatin1String("zip"))) {
         // The URL represents a tar- or zip-file. Check whether
         // the URL is really part of the tar- or zip-file, otherwise
         // replace it by the local path again.
         bool insideCompressedPath = d->isCompressedPath(url);
         if (!insideCompressedPath) {
             QUrl prevUrl = url;
             QUrl parentUrl = KIO::upUrl(url);
             while (parentUrl != prevUrl) {
                 if (d->isCompressedPath(parentUrl)) {
                     insideCompressedPath = true;
                     break;
                 }
                 prevUrl = parentUrl;
                 parentUrl = KIO::upUrl(parentUrl);
             }
         }
         if (!insideCompressedPath) {
             // drop the tar: or zip: protocol since we are not
             // inside the compressed path
             url.setScheme(QStringLiteral("file"));
         }
     }
 
     // Check whether current history element has the same URL.
     // If this is the case, just ignore setting the URL.
     const LocationData &data = d->m_history[d->m_historyIndex];
     const bool isUrlEqual = url.matches(locationUrl(), QUrl::StripTrailingSlash) ||
                             (!url.isValid() && url.matches(data.url, QUrl::StripTrailingSlash));
     if (isUrlEqual) {
         return;
     }
 
     emit urlAboutToBeChanged(url);
 
     if (d->m_historyIndex > 0) {
         // If an URL is set when the history index is not at the end (= 0),
         // then clear all previous history elements so that a new history
         // tree is started from the current position.
         QList<LocationData>::iterator begin = d->m_history.begin();
         QList<LocationData>::iterator end = begin + d->m_historyIndex;
         d->m_history.erase(begin, end);
         d->m_historyIndex = 0;
     }
 
     Q_ASSERT(d->m_historyIndex == 0);
     LocationData newData;
     newData.url = url;
     d->m_history.insert(0, newData);
 
     // Prevent an endless growing of the history: remembering
     // the last 100 Urls should be enough...
     const int historyMax = 100;
     if (d->m_history.size() > historyMax) {
         QList<LocationData>::iterator begin = d->m_history.begin() + historyMax;
         QList<LocationData>::iterator end = d->m_history.end();
         d->m_history.erase(begin, end);
     }
 
     emit historyChanged();
     emit urlChanged(url);
 
     if (firstChildUrl.isValid()) {
         emit urlSelectionRequested(firstChildUrl);
     }
 
     d->updateContent();
 
     requestActivation();
 }
 
 void KUrlNavigator::requestActivation()
 {
     setActive(true);
 }
 
 void KUrlNavigator::setFocus()
 {
     if (isUrlEditable()) {
         d->m_pathBox->setFocus();
     } else {
         QWidget::setFocus();
     }
 }
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KUrlNavigator::setUrl(const QUrl &url)
 {
     // deprecated
     setLocationUrl(url);
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KUrlNavigator::saveRootUrl(const QUrl &url)
 {
     // deprecated
     d->m_history[d->m_historyIndex].rootUrl = url;
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KUrlNavigator::savePosition(int x, int y)
 {
     // deprecated
     d->m_history[d->m_historyIndex].pos = QPoint(x, y);
 }
 #endif
 
 void KUrlNavigator::keyPressEvent(QKeyEvent *event)
 {
     if (isUrlEditable() && (event->key() == Qt::Key_Escape)) {
         setUrlEditable(false);
     } else {
         QWidget::keyPressEvent(event);
     }
 }
 
 void KUrlNavigator::keyReleaseEvent(QKeyEvent *event)
 {
     QWidget::keyReleaseEvent(event);
 }
 
 void KUrlNavigator::mouseReleaseEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::MidButton) {
         const QRect bounds = d->m_toggleEditableMode->geometry();
         if (bounds.contains(event->pos())) {
             // The middle mouse button has been clicked above the
             // toggle-editable-mode-button. Paste the clipboard content
             // as location URL.
             QClipboard *clipboard = QApplication::clipboard();
             const QMimeData *mimeData = clipboard->mimeData();
             if (mimeData->hasText()) {
                 const QString text = mimeData->text();
                 setLocationUrl(QUrl::fromUserInput(text));
             }
         }
     }
     QWidget::mouseReleaseEvent(event);
 }
 
 void KUrlNavigator::resizeEvent(QResizeEvent *event)
 {
     QTimer::singleShot(0, this, SLOT(updateButtonVisibility()));
     QWidget::resizeEvent(event);
 }
 
 void KUrlNavigator::wheelEvent(QWheelEvent *event)
 {
     setActive(true);
     QWidget::wheelEvent(event);
 }
 
 bool KUrlNavigator::eventFilter(QObject *watched, QEvent *event)
 {
     switch (event->type()) {
     case QEvent::FocusIn:
         if (watched == d->m_pathBox) {
             requestActivation();
             setFocus();
         }
         foreach (KUrlNavigatorButton *button, d->m_navButtons) {
             button->setShowMnemonic(true);
         }
         break;
 
     case QEvent::FocusOut:
         foreach (KUrlNavigatorButton *button, d->m_navButtons) {
             button->setShowMnemonic(false);
         }
         break;
 
     default:
         break;
     }
 
     return QWidget::eventFilter(watched, event);
 }
 
 int KUrlNavigator::historySize() const
 {
     return d->m_history.count();
 }
 
 int KUrlNavigator::historyIndex() const
 {
     return d->m_historyIndex;
 }
 
 KUrlComboBox *KUrlNavigator::editor() const
 {
     return d->m_pathBox;
 }
 
 void KUrlNavigator::setCustomProtocols(const QStringList &protocols)
 {
     d->m_customProtocols = protocols;
     d->m_protocols->setCustomProtocols(d->m_customProtocols);
 }
 
 QStringList KUrlNavigator::customProtocols() const
 {
     return d->m_customProtocols;
 }
 
 QWidget *KUrlNavigator::dropWidget() const
 {
     return d->m_dropWidget;
 }
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 const QUrl &KUrlNavigator::url() const
 {
     // deprecated
 
     // Workaround required because of flawed interface ('const QUrl&' is returned
     // instead of 'QUrl'): remember the URL to prevent a dangling pointer
     static QUrl url;
     url = locationUrl();
     return url;
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 QUrl KUrlNavigator::url(int index) const
 {
     // deprecated
     return d->buttonUrl(index);
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 QUrl KUrlNavigator::historyUrl(int historyIndex) const
 {
     // deprecated
     return locationUrl(historyIndex);
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 const QUrl &KUrlNavigator::savedRootUrl() const
 {
     // deprecated
 
     // Workaround required because of flawed interface ('const QUrl&' is returned
     // instead of 'QUrl'): remember the root URL to prevent a dangling pointer
     static QUrl rootUrl;
     rootUrl = d->m_history[d->m_historyIndex].rootUrl;
     return rootUrl;
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 QPoint KUrlNavigator::savedPosition() const
 {
     // deprecated
     return d->m_history[d->m_historyIndex].pos;
 }
 #endif
 
 #ifndef KIOFILEWIDGETS_NO_DEPRECATED
 void KUrlNavigator::setHomeUrl(const QString &homeUrl)
 {
     // deprecated
     setLocationUrl(QUrl::fromUserInput(homeUrl));
 }
 #endif
 
 #include "moc_kurlnavigator.cpp"