diff --git a/plugins/adblock/CMakeLists.txt b/plugins/adblock/CMakeLists.txt
index e0dc37dfd..7540168ed 100644
--- a/plugins/adblock/CMakeLists.txt
+++ b/plugins/adblock/CMakeLists.txt
@@ -1,18 +1,18 @@
 
 
 ########### next target ###############
 add_definitions(-DTRANSLATION_DOMAIN=\"adblock\")
 set(adblock_PART_SRCS adblock.cpp  adblockdialog.cpp )
 
 add_library(adblock MODULE ${adblock_PART_SRCS})
 
 
 
-target_link_libraries(adblock  KF5::Parts KF5::KHtml KF5::KCMUtils)
+target_link_libraries(adblock  KF5::Parts KF5::KHtml KF5::KCMUtils KF5::KDELibs4Support)
 
 install(TARGETS adblock  DESTINATION ${KDE_INSTALL_PLUGINDIR} )
 
 
 ########### install files ###############
 
 install( FILES plugin_adblock.desktop  plugin_adblock.rc  DESTINATION  ${KDE_INSTALL_DATADIR}/khtml/kpartplugins )
diff --git a/plugins/adblock/adblock.cpp b/plugins/adblock/adblock.cpp
index c98c4a6e2..2fc50980c 100644
--- a/plugins/adblock/adblock.cpp
+++ b/plugins/adblock/adblock.cpp
@@ -1,354 +1,355 @@
 /*
   Copyright (c) 2008 Laurent Montel <montel@kde.org>
   Copyright (C) 2006 Daniele Galdi <daniele.galdi@gmail.com>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
   02110-1301, USA.
 */
 
 /* Project related */
 #include "adblock.h"
 #include "adblockdialog.h"
 
 /* Kde related */
 #include <kpluginfactory.h>
 #include <kdebug.h>
 #include <kiconloader.h>
 #include <klibloader.h>
 #include <kparts/statusbarextension.h>
 #include <khtml_part.h>
 #include <khtml_settings.h>
 #include <kstatusbar.h>
 #include <kurllabel.h>
 #include <kurl.h>
 #include <kconfig.h>
 #include <kmessagebox.h>
 #include <kcmultidialog.h>
 #include <klocale.h>
 #include <KActionCollection>
 #include <KActionMenu>
 #include <KMenu>
+#include <KIcon>
 #include <dom/html_document.h>
 #include <dom/html_image.h>
 #include <dom/html_inline.h>
 #include <dom/html_misc.h>
 #include <dom/html_element.h>
 #include <dom/dom_doc.h>
 
 using namespace DOM;
 
 #include <qpixmap.h>
 #include <qcursor.h>
 #include <qregexp.h>
 
 K_PLUGIN_FACTORY(AdBlockFactory, registerPlugin< AdBlock >();)
 K_EXPORT_PLUGIN(AdBlockFactory("adblock"))
 
 AdBlock::AdBlock(QObject *parent, const QVariantList & /*args*/) :
     Plugin(parent),
     m_menu(0), m_elements(0)
 {
     m_part = dynamic_cast<KHTMLPart *>(parent);
     if (!m_part) {
         kDebug() << "couldn't get KHTMLPart";
         return;
     }
     m_menu = new KActionMenu(KIcon("preferences-web-browser-adblock"), i18n("Adblock"),
                              actionCollection());
     actionCollection()->addAction("action adblock", m_menu);
     m_menu->setDelayed(false);
 
     QAction *a = actionCollection()->addAction("show_elements");
     a->setText(i18n("Show Blockable Elements..."));
     connect(a, SIGNAL(triggered()), this, SLOT(slotConfigure()));
     m_menu->addAction(a);
 
     a = actionCollection()->addAction("configure");
     a->setText(i18n("Configure Filters..."));
     connect(a, SIGNAL(triggered()), this, SLOT(showKCModule()));
     m_menu->addAction(a);
 
     a = actionCollection()->addAction("separator");
     a->setSeparator(true);
     m_menu->addAction(a);
 
     a = actionCollection()->addAction("disable_for_this_page");
     a->setText(i18n("No blocking for this page"));
     connect(a, SIGNAL(triggered()), this, SLOT(slotDisableForThisPage()));
     m_menu->addAction(a);
 
     a = actionCollection()->addAction("disable_for_this_site");
     a->setText(i18n("No blocking for this site"));
     connect(a, SIGNAL(triggered()), this, SLOT(slotDisableForThisSite()));
     m_menu->addAction(a);
 
     connect(m_part, SIGNAL(completed()), this, SLOT(initLabel()));
 }
 
 AdBlock::~AdBlock()
 {
     KParts::StatusBarExtension *statusBarEx = KParts::StatusBarExtension::childObject(m_part);
 
     if (statusBarEx && m_label) {
         statusBarEx->removeStatusBarItem(m_label.data());
     }
     delete m_label.data();
     m_label.clear();
     delete m_menu;
     m_menu = 0;
     delete m_elements;
     m_elements = 0;
 }
 
 void AdBlock::initLabel()
 {
     if (m_label) {
         return;
     }
 
     KParts::StatusBarExtension *statusBarEx = KParts::StatusBarExtension::childObject(m_part);
 
     if (!statusBarEx) {
         kDebug() << "couldn't get KParts::StatusBarExtension";
         return;
     }
 
     KUrlLabel *label = new KUrlLabel(statusBarEx->statusBar());
 
     KIconLoader *loader = KIconLoader::global();
 
     label->setFixedHeight(loader->currentSize(KIconLoader::Small));
     label->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     label->setUseCursor(false);
     label->setPixmap(loader->loadIcon("preferences-web-browser-adblock", KIconLoader::Small));
 
     statusBarEx->addStatusBarItem(label, 0, false);
     connect(label, SIGNAL(leftClickedUrl()), this, SLOT(slotConfigure()));
     connect(label, SIGNAL(rightClickedUrl()), this, SLOT(contextMenu()));
 
     m_label = label;
 }
 
 void AdBlock::disableForUrl(KUrl url)
 {
     url.setQuery(QString());
     url.setRef(QString());
 
     KHTMLSettings *settings = const_cast<KHTMLSettings *>(m_part->settings());
     settings->addAdFilter("@@" + url.url());
 }
 
 void AdBlock::slotDisableForThisPage()
 {
     disableForUrl(m_part->toplevelURL().url());
 }
 
 void AdBlock::slotDisableForThisSite()
 {
     KUrl u(m_part->toplevelURL().url());
     u.setPath("/*");
     disableForUrl(u);
 }
 
 void AdBlock::slotConfigure()
 {
     if (!m_part->settings()->isAdFilterEnabled()) {
         KMessageBox::error(0,
                            i18n("Please enable Konqueror's Adblock"),
                            i18nc("@title:window", "Adblock disabled"));
 
         return;
     }
 
     m_elements = new AdElementList;
     fillBlockableElements();
 
     AdBlockDlg *dlg = new AdBlockDlg(m_part->widget(), m_elements, m_part);
     connect(dlg, SIGNAL(notEmptyFilter(QString)), this, SLOT(addAdFilter(QString)));
     connect(dlg, SIGNAL(configureFilters()), this, SLOT(showKCModule()));
     dlg->exec();
     delete dlg;
 }
 
 void AdBlock::showKCModule()
 {
     KCMultiDialog *dialogue = new KCMultiDialog(m_part->widget());
     dialogue->addModule("khtml_filter");
     connect(dialogue, SIGNAL(cancelClicked()), dialogue, SLOT(delayedDestruct()));
     connect(dialogue, SIGNAL(closeClicked()), dialogue, SLOT(delayedDestruct()));
     dialogue->show();
 }
 
 void AdBlock::contextMenu()
 {
     m_menu->menu()->exec(QCursor::pos());
 }
 
 void AdBlock::fillBlockableElements()
 {
     fillWithHtmlTag("script", "src", i18n("script"));
     fillWithHtmlTag("embed", "src", i18n("object"));
     fillWithHtmlTag("object", "src", i18n("object"));
     // TODO: iframe's are not blocked by KHTML yet
     fillWithHtmlTag("iframe", "src", i18n("frame"));
     fillWithImages();
 
     updateFilters();
 }
 
 void AdBlock::fillWithImages()
 {
     HTMLDocument htmlDoc = m_part->htmlDocument();
 
     HTMLCollection images = htmlDoc.images();
 
     for (unsigned int i = 0; i < images.length(); i++) {
         HTMLImageElement image = static_cast<HTMLImageElement>(images.item(i));
 
         DOMString src = image.src();
 
         QString url = htmlDoc.completeURL(src).string();
         if (!url.isEmpty() && url != m_part->baseURL().url()) {
             AdElement element(url, i18n("image"), "IMG", false, image);
             if (!m_elements->contains(element)) {
                 m_elements->append(element);
             }
         }
     }
 }
 
 void AdBlock::fillWithHtmlTag(const DOMString &tagName,
                               const DOMString &attrName,
                               const QString &category)
 {
     Document doc = m_part->document();
 
     NodeList nodes = doc.getElementsByTagName(tagName);
 
     for (unsigned int i = 0; i < nodes.length(); i++) {
         Node node = nodes.item(i);
         Node attr = node.attributes().getNamedItem(attrName);
 
         DOMString src = attr.nodeValue();
         if (src.isNull()) {
             continue;
         }
 
         QString url = doc.completeURL(src).string();
         if (!url.isEmpty() && url != m_part->baseURL().url()) {
             AdElement element(url, category, tagName.string().toUpper(), false, attr);
             if (!m_elements->contains(element)) {
                 m_elements->append(element);
             }
         }
     }
 }
 
 void AdBlock::addAdFilter(const QString &url)
 {
     //FIXME hackish
     KHTMLSettings *settings = const_cast<KHTMLSettings *>(m_part->settings());
     settings->addAdFilter(url);
     updateFilters();
 }
 
 void AdBlock::updateFilters()
 {
     const KHTMLSettings *settings = m_part->settings();
 
     AdElementList::iterator it;
     for (it = m_elements->begin(); it != m_elements->end(); ++it) {
         AdElement &element = (*it);
 
         bool isWhitelist;
         QString filter = settings->adFilteredBy(element.url(), &isWhitelist);
         if (!filter.isEmpty()) {
             if (!isWhitelist) {
                 element.setBlocked(true);
                 element.setBlockedBy(i18n("Blocked by %1", filter));
             } else {
                 element.setBlockedBy(i18n("Allowed by %1", filter));
             }
         }
     }
 }
 
 // ----------------------------------------------------------------------------
 
 AdElement::AdElement() :
     m_blocked(false) {}
 
 AdElement::AdElement(const QString &url, const QString &category,
                      const QString &type, bool blocked, const DOM::Node &node) :
     m_url(url), m_category(category), m_type(type), m_blocked(blocked), m_node(node) {}
 
 AdElement &AdElement::operator=(const AdElement &obj)
 {
     m_blocked = obj.m_blocked;
     m_blockedBy = obj.m_blockedBy;
     m_url = obj.m_url;
     m_category = obj.m_category;
     m_type = obj.m_type;
     m_node = obj.m_node;
 
     return *this;
 }
 
 bool AdElement::operator==(const AdElement &obj)
 {
     return m_url == obj.m_url;
 }
 
 bool AdElement::isBlocked() const
 {
     return m_blocked;
 }
 
 QString AdElement::blockedBy() const
 {
     return m_blockedBy;
 }
 
 void AdElement::setBlockedBy(const QString &by)
 {
     m_blockedBy = by;
 }
 
 void AdElement::setBlocked(bool blocked)
 {
     m_blocked = blocked;
 }
 
 QString AdElement::url() const
 {
     return m_url;
 }
 
 QString AdElement::category() const
 {
     return m_category;
 }
 
 QString AdElement::type() const
 {
     return m_type;
 }
 
 DOM::Node AdElement::node() const
 {
     return m_node;
 }
 
 #include "adblock.moc"
diff --git a/plugins/adblock/adblockdialog.cpp b/plugins/adblock/adblockdialog.cpp
index 2b23c4f29..74e771137 100644
--- a/plugins/adblock/adblockdialog.cpp
+++ b/plugins/adblock/adblockdialog.cpp
@@ -1,328 +1,329 @@
 /*
   Copyright (c) 2008 Laurent Montel <montel@kde.org>
   Copyright (C) 2006 Daniele Galdi <daniele.galdi@gmail.com>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the Free
   Software Foundation; either version 2 of the License, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
   more details.
 
   You should have received a copy of the GNU General Public License along with
   this program; if not, write to the Free Software Foundation, Inc., 51
   Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
 
-#include "adblock.h"
 #include "adblockdialog.h"
+#include "adblock.h"
 
-#include <kdebug.h>
-#include <kmenu.h>
-#include <klocale.h>
+#include <KDebug>
+#include <KMenu>
+#include <KLocalizedString>
+#include <KIcon>
 #include <KTreeWidgetSearchLine>
 #include <KRun>
 #include <KStandardGuiItem>
 
-#include <qcursor.h>
-#include <qlabel.h>
-#include <qlineedit.h>
-#include <qcolor.h>
-#include <qfont.h>
-#include <qpainter.h>
+#include <QCursor>
+#include <QLabel>
+#include <QLineEdit>
+#include <QColor>
+#include <QFont>
+#include <QPainter>
 #include <QTreeWidget>
 #include <QApplication>
 #include <QClipboard>
 #include <QVBoxLayout>
 
 // ----------------------------------------------------------------------------
 
 class ListViewItem : public QTreeWidgetItem
 {
 public:
     ListViewItem(QTreeWidget *listView, const QStringList &lst, const AdElement *element)
         : QTreeWidgetItem(listView, lst),
           m_element(element),
           m_blocked(false) {};
 
     bool isBlocked() const
     {
         return (m_blocked);
     };
     void setBlocked(bool blocked);
     void setBlockedBy(const QString &reason);
     void setNode(const DOM::Node &node);
     DOM::Node node()const
     {
         return (m_node);
     }
     const AdElement *element() const
     {
         return (m_element);
     }
 
 private:
     const AdElement *m_element;
     bool m_blocked;
     DOM::Node m_node;
 };
 
 void ListViewItem::setBlocked(bool blocked)
 {
     m_blocked = blocked;
     setData(0, Qt::TextColorRole, (blocked ? Qt::red : Qt::black));
     QFont itemFont =  font(0);
     itemFont.setItalic(blocked);
     itemFont.setBold(blocked);
     setData(0, Qt::FontRole, itemFont);
 }
 
 void ListViewItem::setBlockedBy(const QString &reason)
 {
     setToolTip(0, reason);
 }
 
 void ListViewItem::setNode(const DOM::Node &node)
 {
     m_node = node;
 }
 
 // ----------------------------------------------------------------------------
 
 AdBlockDlg::AdBlockDlg(QWidget *parent, const AdElementList *elements, KHTMLPart *part) :
     KDialog(parent), m_part(part)
 {
     setModal(true);
     setCaption(i18nc("@title:window", "Blockable items on this page"));
     setButtons(KDialog::User1 | KDialog::User2 | KDialog::Close);
     setDefaultButton(KDialog::User2);
     setButtonText(KDialog::User1, i18n("Configure Filters..."));
     setButtonIcon(KDialog::User1, KIcon("preferences-web-browser-adblock"));
     setButtonText(KDialog::User2, i18n("Add filter"));
     setButtonIcon(KDialog::User2, KStandardGuiItem::add().icon());
 
     QWidget *page = new QWidget(this);
     setMainWidget(page);
 
     QVBoxLayout *layout = new QVBoxLayout(page);
     layout->setMargin(0);
 
     QLabel *l = new QLabel(i18n("Search:"), page);
     layout->addWidget(l);
 
     KTreeWidgetSearchLine *searchLine = new KTreeWidgetSearchLine(page);
     layout->addWidget(searchLine);
     l->setBuddy(searchLine);
 
     l = new QLabel(i18n("Blockable items:"), page);
     layout->addWidget(l);
 
     m_list = new QTreeWidget(page);
     m_list->setAllColumnsShowFocus(true);
     layout->addWidget(m_list);
     l->setBuddy(m_list);
 
     QStringList lstHeader;
     lstHeader << i18n("Source") << i18n("Category") << i18n("Tag");
     m_list->setHeaderLabels(lstHeader);
 
     m_list->setColumnWidth(0, 600);
     m_list->setColumnWidth(1, 90);
     m_list->setColumnWidth(2, 65);
 
     m_list->setRootIsDecorated(false);
 
     AdElementList::const_iterator it;
     for (it = elements->constBegin(); it != elements->constEnd(); ++it) {
         const AdElement &element = (*it);
 
         QStringList lst;
         lst << element.url() <<  element.category() << element.type();
 
         ListViewItem *item = new ListViewItem(m_list, lst, &element);
         item->setBlocked(element.isBlocked());
         item->setBlockedBy(element.blockedBy());
         item->setNode(element.node());
     }
 
     searchLine->setTreeWidget(m_list);
 
     layout->addSpacing(KDialog::spacingHint());
 
     l = new QLabel(i18n("New filter (can use *?[] wildcards, /RE/ for regular expression, prefix with @@ for white list):"), page);
     layout->addWidget(l);
 
     m_filter = new QLineEdit(page);
     layout->addWidget(m_filter);
     connect(m_filter, SIGNAL(textChanged(QString)), SLOT(filterTextChanged(QString)));
     l->setBuddy(m_filter);
     filterTextChanged(QString::null);
 
     connect(this, SIGNAL(user1Clicked()), this, SLOT(slotConfigureFilters()));
     connect(this, SIGNAL(user2Clicked()), this, SLOT(slotAddFilter()));
 
     // Use itemActivated() signal instead of itemDoubleClicked() to honour
     // the KDE single/double click setting, and allow keyboard navigation.
     // Activating a item just copies its URL to the "new filter" box and
     // sets focus to there, it doesn't add the filter immediately.
     //connect(m_list, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)), this, SLOT(updateFilter(QTreeWidgetItem*)) );
     connect(m_list, SIGNAL(itemActivated(QTreeWidgetItem*,int)), this, SLOT(updateFilter(QTreeWidgetItem*)));
 
     m_menu = new KMenu(this);
     m_menu->addAction(i18n("Filter this item"), this, SLOT(filterItem()));
     m_menu->addAction(i18n("Filter all items at same path"), this, SLOT(filterPath()));
     m_menu->addAction(i18n("Filter all items from same host"), this, SLOT(filterHost()));
     m_menu->addAction(i18n("Filter all items from same domain"), this, SLOT(filterDomain()));
     m_menu->addSeparator();
     m_menu->addAction(i18n("Add this item to white list"), this, SLOT(addWhiteList()));
     m_menu->addSeparator();
     m_menu->addAction(i18n("Copy Link Address"),  this,  SLOT(copyLinkAddress()));
     //comment for the moment
     //m_menu->addAction( i18n( "Highlight Element" ), this, SLOT(highLightElement()) );
     m_menu->addAction(i18n("View item"), this, SLOT(showElement()));
     m_list->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(m_list, SIGNAL(customContextMenuRequested(QPoint)),
             this, SLOT(showContextMenu(QPoint)));
 
     resize(800, 400);
 }
 
 AdBlockDlg::~AdBlockDlg()
 {
 }
 
 void AdBlockDlg::filterTextChanged(const QString &text)
 {
     enableButton(KDialog::User2, !text.isEmpty());
 }
 
 void AdBlockDlg::setFilterText(const QString &text)
 {
     m_filter->setText(text);
     m_filter->setFocus(Qt::OtherFocusReason);
 }
 
 void AdBlockDlg::updateFilter(QTreeWidgetItem *selected)
 {
     ListViewItem *item = static_cast<ListViewItem *>(selected);
 
     if (item->isBlocked()) {
         m_filter->clear();
         return;
     }
 
     setFilterText(item->text(0));
 }
 
 void AdBlockDlg::slotAddFilter()
 {
     const QString text = m_filter->text().trimmed();
     if (text.isEmpty()) {
         return;
     }
 
     kDebug() << "adding filter" << text;
     emit notEmptyFilter(text);
 
     for (QTreeWidgetItemIterator it(m_list); (*it) != 0; ++it) {
         ListViewItem *item = static_cast<ListViewItem *>(*it);
         item->setBlocked(item->element()->isBlocked());
         item->setBlockedBy(item->element()->blockedBy());
     }
 
     enableButton(KDialog::User2, false);        // now that filter has been added
 }                           // until it is changed again
 
 void AdBlockDlg::slotConfigureFilters()
 {
     emit configureFilters();
     delayedDestruct();
 }
 
 void AdBlockDlg::showContextMenu(const QPoint &pos)
 {
     QPoint newPos = m_list->viewport()->mapToGlobal(pos);
     int column = m_list->columnAt(pos.x());
     if (column == -1) {
         return;
     }
     m_menu->popup(newPos);
 }
 
 void AdBlockDlg::filterItem()
 {
     QTreeWidgetItem *item = m_list->currentItem();
     setFilterText(item->text(0));
 }
 
 KUrl AdBlockDlg::getItem()
 {
     QTreeWidgetItem *item = m_list->currentItem();
     KUrl u(item->text(0));
     u.setQuery(QString());
     u.setRef(QString());
     return (u);
 }
 
 void AdBlockDlg::filterPath()
 {
     KUrl u(getItem());
     u.setFileName("*");
     setFilterText(u.url());
 }
 
 void AdBlockDlg::filterHost()
 {
     KUrl u(getItem());
     u.setPath("/*");
     setFilterText(u.url());
 }
 
 void AdBlockDlg::filterDomain()
 {
     KUrl u(getItem());
 
     QString host = u.host();
     if (host.isEmpty()) {
         return;
     }
     int idx = host.indexOf('.');
     if (idx < 0) {
         return;
     }
 
     QString t = u.protocol() + "://*" + host.mid(idx) + "/*";
     setFilterText(t);
 }
 
 void AdBlockDlg::addWhiteList()
 {
     QTreeWidgetItem *item = m_list->currentItem();
     setFilterText("@@" + item->text(0));
 }
 
 void AdBlockDlg::copyLinkAddress()
 {
     QApplication::clipboard()->setText(m_list->currentItem()->text(0));
 }
 
 void AdBlockDlg::highLightElement()
 {
     ListViewItem *item = static_cast<ListViewItem *>(m_list->currentItem());
     if (item) {
         DOM::Node handle = item->node();
         kDebug() << " m_part :" << m_part;
         if (!handle.isNull()) {
             m_part->setActiveNode(handle);
         }
     }
 }
 
 void AdBlockDlg::showElement()
 {
     new KRun(m_list->currentItem()->text(0), 0);
 }
 
diff --git a/plugins/adblock/adblockdialog.h b/plugins/adblock/adblockdialog.h
index e8d0c1bf4..464eb6c45 100644
--- a/plugins/adblock/adblockdialog.h
+++ b/plugins/adblock/adblockdialog.h
@@ -1,67 +1,68 @@
 /*
   Copyright (c) 2008 Laurent Montel <montel@kde.org>
   Copyright (C) 2006 Daniele Galdi <daniele.galdi@gmail.com>
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
 
-#ifndef KONQ_ADBLOCKDLG_H
-#define KONQ_ADBLOCKDLG_H
+#ifndef KONQ_ADBLOCKDIALOG_H
+#define KONQ_ADBLOCKDIALOG_H
 
+#include "adblock.h"
 #include <kdialog.h>
 #include <QTreeWidgetItem>
 #include <khtml_part.h>
 class QLineEdit;
 class KMenu;
 class QTreeWidget;
 
 class AdBlockDlg : public KDialog
 {
     Q_OBJECT
 public:
     AdBlockDlg(QWidget *parent, const AdElementList *elements, KHTMLPart *part);
     ~AdBlockDlg();
 
 private slots:
     void slotAddFilter();
     void slotConfigureFilters();
 
     void updateFilter(QTreeWidgetItem *item);
     void showContextMenu(const QPoint &);
     void filterItem();
     void filterPath();
     void filterHost();
     void filterDomain();
     void addWhiteList();
     void copyLinkAddress();
     void highLightElement();
     void showElement();
     void filterTextChanged(const QString &text);
 
 signals:
     void notEmptyFilter(const QString &url);
     void configureFilters();
 
 private:
     KUrl getItem();
     void setFilterText(const QString &text);
 
     QLineEdit *m_filter;
     QTreeWidget *m_list;
     KMenu *m_menu;
     KHTMLPart *m_part;
 };
 
 #endif
diff --git a/plugins/akregator/CMakeLists.txt b/plugins/akregator/CMakeLists.txt
index 0734e5fa0..a80ca89c2 100644
--- a/plugins/akregator/CMakeLists.txt
+++ b/plugins/akregator/CMakeLists.txt
@@ -1,34 +1,34 @@
 
 ecm_qt_declare_logging_category(akregatorplugin_DEBUG_SRCS HEADER akregatorplugindebug.h IDENTIFIER AKREGATORPLUGIN_LOG CATEGORY_NAME org.kde.konqueror.akregatorplugin)
 
 ########### next target ###############
 
 set(akregatorplugin_PART_SRCS akregatorplugin.cpp pluginutil.cpp )
 
 kcoreaddons_add_plugin(akregatorplugin SOURCES ${akregatorplugin_PART_SRCS} ${akregatorplugin_DEBUG_SRCS} INSTALL_NAMESPACE "kf5/kfileitemaction")
 kcoreaddons_desktop_to_json(akregatorplugin akregator_konqplugin.desktop)
 
 target_compile_definitions(akregatorplugin PRIVATE TRANSLATION_DOMAIN="akregator_konqplugin")
-target_link_libraries(akregatorplugin KF5::I18n KF5::KIOWidgets)
+target_link_libraries(akregatorplugin KF5::I18n KF5::KIOWidgets Qt5::DBus)
 
 ########### next target ###############
 
 set(akregatorkonqfeedicon_PART_SRCS konqfeedicon.cpp feeddetector.cpp pluginutil.cpp )
 
 add_library(akregatorkonqfeedicon MODULE ${akregatorkonqfeedicon_PART_SRCS} ${akregatorplugin_DEBUG_SRCS})
 
 target_compile_definitions(akregatorkonqfeedicon PRIVATE TRANSLATION_DOMAIN="akregator_konqplugin")
 target_link_libraries(akregatorkonqfeedicon KF5::Parts KF5::IconThemes)
 
 install(TARGETS akregatorkonqfeedicon DESTINATION ${KDE_INSTALL_PLUGINDIR} )
 
 ########### install files ###############
 
 install( FILES akregator_konqplugin.desktop  DESTINATION  ${KDE_INSTALL_KSERVICES5DIR} )
 install( FILES akregator_konqfeedicon.desktop akregator_konqfeedicon.rc  DESTINATION  ${KDE_INSTALL_DATADIR}/khtml/kpartplugins )
 install( FILES akregator_konqfeedicon.desktop akregator_konqfeedicon.rc  DESTINATION  ${KDE_INSTALL_DATADIR}/kwebkitpart/kpartplugins )
 
 install( FILES feed.png DESTINATION ${KDE_INSTALL_DATADIR}/akregator/pics )
 
 # contains list of debug categories, for kdebugsettings
 install(FILES akregatorplugin.categories DESTINATION ${KDE_INSTALL_CONFDIR})
diff --git a/plugins/akregator/feeddetector.cpp b/plugins/akregator/feeddetector.cpp
index 1e9742fff..b4f1bceea 100644
--- a/plugins/akregator/feeddetector.cpp
+++ b/plugins/akregator/feeddetector.cpp
@@ -1,148 +1,148 @@
 /*
     This file is part of Akregator.
 
     Copyright (C) 2004 Teemu Rytilahti <tpr@d5k.net>
 
     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.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
 
-#include <qregexp.h>
-#include <qstring.h>
-#include <qstringlist.h>
+#include "feeddetector.h"
+#include <QRegExp>
+#include <QString>
+#include <QStringList>
 
-#include <kcharsets.h>
+#include <KCharsets>
 
-#include "feeddetector.h"
 #include "akregatorplugindebug.h"
 
 using namespace Akregator;
 
 FeedDetectorEntryList FeedDetector::extractFromLinkTags(const QString &s)
 {
     //reduce all sequences of spaces, newlines etc. to one space:
     QString str = s.simplified();
 
     // extracts <link> tags
     QRegExp reLinkTag("<[\\s]?LINK[^>]*REL[\\s]?=[\\s]?\\\"[^\\\"]*(ALTERNATE|FEED|SERVICE\\.FEED)[^\\\"]*\\\"[^>]*>", Qt::CaseInsensitive);
 
     // extracts the URL (href="url")
     QRegExp reHref("HREF[\\s]?=[\\s]?\\\"([^\\\"]*)\\\"", Qt::CaseInsensitive);
     // extracts type attribute
     QRegExp reType("TYPE[\\s]?=[\\s]?\\\"([^\\\"]*)\\\"", Qt::CaseInsensitive);
     // extracts the title (title="title")
     QRegExp reTitle("TITLE[\\s]?=[\\s]?\\\"([^\\\"]*)\\\"", Qt::CaseInsensitive);
 
     int pos = 0;
     int matchpos = 0;
 
     // get all <link> tags
     QStringList linkTags;
     //int strlength = str.length();
     while (matchpos != -1) {
         matchpos = reLinkTag.indexIn(str, pos);
         if (matchpos != -1) {
             linkTags.append(str.mid(matchpos, reLinkTag.matchedLength()));
             pos = matchpos + reLinkTag.matchedLength();
         }
     }
 
     FeedDetectorEntryList list;
 
     for (QStringList::Iterator it = linkTags.begin(); it != linkTags.end(); ++it) {
         QString type;
         int pos = reType.indexIn(*it, 0);
         if (pos != -1) {
             type = reType.cap(1).toLower();
         }
 
         // we accept only type attributes indicating a feed
         if (type != QLatin1String("application/rss+xml") && type != QLatin1String("application/rdf+xml")
                 && type != QLatin1String("application/atom+xml") && type != QLatin1String("application/xml")) {
             continue;
         }
 
         QString title;
         pos = reTitle.indexIn(*it, 0);
         if (pos != -1) {
             title = reTitle.cap(1);
         }
 
         title = KCharsets::resolveEntities(title);
 
         QString url;
         pos = reHref.indexIn(*it, 0);
         if (pos != -1) {
             url = reHref.cap(1);
         }
 
         url = KCharsets::resolveEntities(url);
 
         // if feed has no title, use the url as preliminary title (until feed is parsed)
         if (title.isEmpty()) {
             title = url;
         }
 
         if (!url.isEmpty()) {
             qCDebug(AKREGATORPLUGIN_LOG) << "found feed:" << url << title;
             list.append(FeedDetectorEntry(url, title));
         }
     }
 
     return list;
 }
 
 QStringList FeedDetector::extractBruteForce(const QString &s)
 {
     QString str = s.simplified();
 
     QRegExp reAhrefTag("<[\\s]?A[^>]?HREF=[\\s]?\\\"[^\\\"]*\\\"[^>]*>", Qt::CaseInsensitive);
 
     // extracts the URL (href="url")
     QRegExp reHref("HREF[\\s]?=[\\s]?\\\"([^\\\"]*)\\\"", Qt::CaseInsensitive);
 
     QRegExp rssrdfxml(".*(RSS|RDF|XML)", Qt::CaseInsensitive);
 
     int pos = 0;
     int matchpos = 0;
 
     // get all <a href> tags and capture url
     QStringList list;
     //int strlength = str.length();
     while (matchpos != -1) {
         matchpos = reAhrefTag.indexIn(str, pos);
         if (matchpos != -1) {
             QString ahref = str.mid(matchpos, reAhrefTag.matchedLength());
             int hrefpos = reHref.indexIn(ahref, 0);
             if (hrefpos != -1) {
                 QString url = reHref.cap(1);
 
                 url = KCharsets::resolveEntities(url);
 
                 if (rssrdfxml.exactMatch(url)) {
                     list.append(url);
                 }
             }
 
             pos = matchpos + reAhrefTag.matchedLength();
         }
     }
 
     return list;
 
 }
diff --git a/plugins/autorefresh/autorefresh.cpp b/plugins/autorefresh/autorefresh.cpp
index dd96ca542..96a162af6 100644
--- a/plugins/autorefresh/autorefresh.cpp
+++ b/plugins/autorefresh/autorefresh.cpp
@@ -1,128 +1,128 @@
 // -*- c++ -*-
 
 /*
   Copyright 2003 by Richard J. Moore, rich@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.
  */
 
-#include <kparts/part.h>
 #include "autorefresh.h"
+#include <kparts/part.h>
 
 #include <kcomponentdata.h>
 #include <kiconloader.h>
 #include <kmessagebox.h>
 #include <KLocalizedString>
 #include <qtimer.h>
 #include <kselectaction.h>
 #include <kactioncollection.h>
 #include <kpluginfactory.h>
 #include <KParts/ReadOnlyPart>
 
 AutoRefresh::AutoRefresh(QObject *parent, const QVariantList & /*args*/)
     : Plugin(parent)
 {
     timer = new QTimer(this);
     connect(timer, &QTimer::timeout, this, &AutoRefresh::slotRefresh);
 
     refresher = actionCollection()->add<KSelectAction>(QStringLiteral("autorefresh"));
     refresher->setText(i18n("&Auto Refresh"));
     refresher->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));
     connect(refresher, SIGNAL(triggered(QAction*)), this, SLOT(slotIntervalChanged()));
     QStringList sl;
     sl << i18n("None");
     sl << i18n("Every 15 Seconds");
     sl << i18n("Every 30 Seconds");
     sl << i18n("Every Minute");
     sl << i18n("Every 5 Minutes");
     sl << i18n("Every 10 Minutes");
     sl << i18n("Every 15 Minutes");
     sl << i18n("Every 30 Minutes");
     sl << i18n("Every 60 Minutes");
     sl << i18n("Every 2 Hours");
     sl << i18n("Every 6 Hours");
 
     refresher->setItems(sl);
     refresher->setCurrentItem(0);
 }
 
 AutoRefresh::~AutoRefresh()
 {
 }
 
 void AutoRefresh::slotIntervalChanged()
 {
     int idx = refresher->currentItem();
     int timeout = 0;
     switch (idx) {
     case 1:
         timeout = (15 * 1000);
         break;
     case 2:
         timeout = (30 * 1000);
         break;
     case 3:
         timeout = (60 * 1000);
         break;
     case 4:
         timeout = (5 * 60 * 1000);
         break;
     case 5:
         timeout = (10 * 60 * 1000);
         break;
     case 6:
         timeout = (15 * 60 * 1000);
         break;
     case 7:
         timeout = (30 * 60 * 1000);
         break;
     case 8:
         timeout = (60 * 60 * 1000);
         break;
     case 9:
         timeout = (2 * 60 * 60 * 1000);
         break;
     case 10:
         timeout = (6 * 60 * 60 * 1000);
         break;
     default:
         break;
     }
     timer->stop();
     if (timeout) {
         timer->start(timeout);
     }
 }
 
 void AutoRefresh::slotRefresh()
 {
     KParts::ReadOnlyPart *part = qobject_cast< KParts::ReadOnlyPart * >(parent());
     if (!part) {
         QString title = i18nc("@title:window", "Cannot Refresh Source");
         QString text = i18n("<qt>This plugin cannot auto-refresh the current part.</qt>");
 
         KMessageBox::error(0, text, title);
     } else {
         // Get URL
         QUrl url = part->url();
         part->openUrl(url);
     }
 }
 
 K_PLUGIN_FACTORY(AutoRefreshFactory, registerPlugin< AutoRefresh >();)
 
 #include "autorefresh.moc"
 
diff --git a/plugins/fsview/fsview.cpp b/plugins/fsview/fsview.cpp
index e2552064e..3e38c1975 100644
--- a/plugins/fsview/fsview.cpp
+++ b/plugins/fsview/fsview.cpp
@@ -1,592 +1,592 @@
 /* This file is part of FSView.
    Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
 
    KCachegrind 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, version 2.
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 /*
- * FSView specialisaton of TreeMap classes.
+ * FSView specialization of TreeMap classes.
  */
 
-#include <qdir.h>
-#include <qtimer.h>
+#include "fsview.h"
+
+#include <QDir>
+#include <QTimer>
 #include <QApplication>
 
 #include <KLocalizedString>
 #include <kconfig.h>
 #include <kdebug.h>
 #include <kmessagebox.h>
 
 #include <kio/job.h>
 #include <kauthorized.h>
 #include <kconfiggroup.h>
 #include <kurlauthorized.h>
 
-#include "fsview.h"
-
 // FSView
 
 QMap<QString, MetricEntry> FSView::_dirMetric;
 
 FSView::FSView(Inode *base, QWidget *parent)
     : TreeMapWidget(base, parent)
 {
     setFieldType(0, i18n("Name"));
     setFieldType(1, i18n("Size"));
     setFieldType(2, i18n("File Count"));
     setFieldType(3, i18n("Directory Count"));
     setFieldType(4, i18n("Last Modified"));
     setFieldType(5, i18n("Owner"));
     setFieldType(6, i18n("Group"));
     setFieldType(7, i18n("Mime Type"));
 
     // defaults
     setVisibleWidth(4, true);
     setSplitMode(TreeMapItem::Rows);
     setFieldForced(0, true); // show directory names
     setFieldForced(1, true); // show directory sizes
     setSelectionMode(TreeMapWidget::Extended);
 
     _colorMode = Depth;
     _pathDepth = 0;
     _allowRefresh = true;
 
     _progressPhase = 0;
     _chunkData1 = 0;
     _chunkData2 = 0;
     _chunkData3 = 0;
     _chunkSize1 = 0;
     _chunkSize2 = 0;
     _chunkSize3 = 0;
     _progressSize = 0;
     _progress = 0;
     _dirsFinished = 0;
     _lastDir = 0;
 
     _config = new KConfig(QStringLiteral("fsviewrc"));
 
     // restore TreeMap visualization options of last execution
     KConfigGroup tmconfig(_config, "TreeMap");
     restoreOptions(&tmconfig);
     QString str = tmconfig.readEntry("ColorMode");
     if (!str.isEmpty()) {
         setColorMode(str);
     }
 
     if (_dirMetric.count() == 0) {
         // restore metric cache
         KConfigGroup cconfig(_config, "MetricCache");
         int ccount = cconfig.readEntry("Count", 0);
         int i, f, d;
         double s;
         QString str;
         for (i = 1; i <= ccount; i++) {
             str = QStringLiteral("Dir%1").arg(i);
             if (!cconfig.hasKey(str)) {
                 continue;
             }
             str = cconfig.readPathEntry(str, QString());
             s = cconfig.readEntry(QStringLiteral("Size%1").arg(i), 0.0);
             f = cconfig.readEntry(QStringLiteral("Files%1").arg(i), 0);
             d = cconfig.readEntry(QStringLiteral("Dirs%1").arg(i), 0);
             if (s == 0.0 || f == 0 || d == 0) {
                 continue;
             }
             setDirMetric(str, s, f, d);
         }
     }
 
     _sm.setListener(this);
 }
 
 FSView::~FSView()
 {
     delete _config;
 }
 
 void FSView::stop()
 {
     _sm.stopScan();
 }
 
 void FSView::setPath(const QString &p)
 {
     Inode *b = (Inode *)base();
     if (!b) {
         return;
     }
 
     //kDebug(90100) << "FSView::setPath " << p;
 
     // stop any previous updating
     stop();
 
     QFileInfo fi(p);
     _path = fi.absoluteFilePath();
     if (!fi.isDir()) {
         _path = fi.absolutePath();
     }
     _path = QDir::cleanPath(_path);
     _pathDepth = _path.count('/');
 
     QUrl u;
     u.setPath(_path);
     if (!KUrlAuthorized::authorizeUrlAction(QStringLiteral("list"), QUrl(), u)) {
         QString msg = KIO::buildErrorString(KIO::ERR_ACCESS_DENIED, u.toDisplayString());
         KMessageBox::sorry(this, msg);
     }
 
     ScanDir *d = _sm.setTop(_path);
 
     b->setPeer(d);
 
     setWindowTitle(QStringLiteral("%1 - FSView").arg(_path));
     requestUpdate(b);
 }
 
 QList<QUrl> FSView::selectedUrls()
 {
     QList<QUrl> urls;
 
     foreach (TreeMapItem *i, selection()) {
         QUrl u = QUrl::fromLocalFile(((Inode *)i)->path());
         urls.append(u);
     }
     return urls;
 }
 
 bool FSView::getDirMetric(const QString &k,
                           double &s, unsigned int &f, unsigned int &d)
 {
     QMap<QString, MetricEntry>::iterator it;
 
     it = _dirMetric.find(k);
     if (it == _dirMetric.end()) {
         return false;
     }
 
     s = (*it).size;
     f = (*it).fileCount;
     d = (*it).dirCount;
 
     if (0) {
         kDebug(90100) << "getDirMetric " << k;
     }
     if (0) {
         kDebug(90100) << " - got size " << s << ", files " << f;
     }
 
     return true;
 }
 
 void FSView::setDirMetric(const QString &k,
                           double s, unsigned int f, unsigned int d)
 {
     if (0) kDebug(90100) << "setDirMetric '" << k << "': size "
                              << s << ", files " << f << ", dirs " << d << endl;
     _dirMetric.insert(k, MetricEntry(s, f, d));
 }
 
 void FSView::requestUpdate(Inode *i)
 {
     if (0) kDebug(90100) << "FSView::requestUpdate(" << i->path()
                              << ")" << endl;
 
     ScanDir *peer = i->dirPeer();
     if (!peer) {
         return;
     }
 
     peer->clear();
     i->clear();
 
     if (!_sm.scanRunning()) {
         QTimer::singleShot(0, this, SLOT(doUpdate()));
         QTimer::singleShot(100, this, SLOT(doRedraw()));
 
         /* start new progress chunk */
         _progressPhase = 1;
         _chunkData1 += 3;
         _chunkData2 = _chunkData1 + 1;
         _chunkData3 = _chunkData1 + 2;
         _chunkSize1 = 0;
         _chunkSize2 = 0;
         _chunkSize3 = 0;
         peer->setData(_chunkData1);
 
         _progressSize = 0;
         _progress = 0;
         _dirsFinished = 0;
         _lastDir = 0;
         emit started();
     }
 
     _sm.startScan(peer);
 }
 
 void FSView::scanFinished(ScanDir *d)
 {
     /* if finished directory was from last progress chunk, increment */
     int data = d->data();
     switch (_progressPhase) {
     case 1:
         if (data == _chunkData1) {
             _chunkSize1--;
         }
         break;
     case 2:
         if (data == _chunkData1) {
             _progress++;
         }
         if (data == _chunkData2) {
             _chunkSize2--;
         }
         break;
     case 3:
         if ((data == _chunkData1) ||
                 (data == _chunkData2)) {
             _progress++;
         }
         if (data == _chunkData3) {
             _chunkSize3--;
         }
         break;
     case 4:
         if ((data == _chunkData1) ||
                 (data == _chunkData2) ||
                 (data == _chunkData3)) {
             _progress++;
         }
         break;
     default:
         break;
     }
 
     _lastDir = d;
     _dirsFinished++;
 
     if (0) kDebug(90100) << "FSFiew::scanFinished: " << d->path()
                              << ", Data " << data
                              << ", Progress " << _progress << "/"
                              << _progressSize << endl;
 }
 
 void FSView::selected(TreeMapItem *i)
 {
     setPath(((Inode *)i)->path());
 }
 
 void FSView::contextMenu(TreeMapItem *i, const QPoint &p)
 {
     QMenu popup;
 
     QMenu *spopup = new QMenu(i18n("Go To"));
     QMenu *dpopup = new QMenu(i18n("Stop at Depth"));
     QMenu *apopup = new QMenu(i18n("Stop at Area"));
     QMenu *fpopup = new QMenu(i18n("Stop at Name"));
 
     // choosing from the selection menu will give a selectionChanged() signal
     addSelectionItems(spopup, 901, i);
     popup.addMenu(spopup);
 
     QAction *actionGoUp = popup.addAction(i18n("Go Up"));
     popup.addSeparator();
     QAction *actionStopRefresh = popup.addAction(i18n("Stop Refresh"));
     actionStopRefresh->setEnabled(_sm.scanRunning());
     QAction *actionRefresh = popup.addAction(i18n("Refresh"));
     actionRefresh->setEnabled(!_sm.scanRunning());
 
     QAction *actionRefreshSelected = 0;
     if (i) {
         actionRefreshSelected = popup.addAction(i18n("Refresh '%1'", i->text(0)));
     }
     popup.addSeparator();
     addDepthStopItems(dpopup, 1001, i);
     popup.addMenu(dpopup);
     addAreaStopItems(apopup, 1101, i);
     popup.addMenu(apopup);
     addFieldStopItems(fpopup, 1201, i);
     popup.addMenu(fpopup);
 
     popup.addSeparator();
 
     QMenu *cpopup = new QMenu(i18n("Color Mode"));
     addColorItems(cpopup, 1401);
     popup.addMenu(cpopup);
     QMenu *vpopup = new QMenu(i18n("Visualization"));
     addVisualizationItems(vpopup, 1301);
     popup.addMenu(vpopup);
 
     _allowRefresh = false;
     QAction *action = popup.exec(mapToGlobal(p));
     _allowRefresh = true;
     if (!action) {
         return;
     }
 
     if (action == actionGoUp) {
         Inode *i = (Inode *) base();
         if (i) {
             setPath(i->path() + QLatin1String("/.."));
         }
     } else if (action == actionStopRefresh) {
         stop();
     } else if (action == actionRefreshSelected) {
         //((Inode*)i)->refresh();
         requestUpdate((Inode *)i);
     } else if (action == actionRefresh) {
         Inode *i = (Inode *) base();
         if (i) {
             requestUpdate(i);
         }
     }
 }
 
 void FSView::saveMetric(KConfigGroup *g)
 {
     QMap<QString, MetricEntry>::iterator it;
     int c = 1;
     for (it = _dirMetric.begin(); it != _dirMetric.end(); ++it) {
         g->writePathEntry(QStringLiteral("Dir%1").arg(c), it.key());
         g->writeEntry(QStringLiteral("Size%1").arg(c), (*it).size);
         g->writeEntry(QStringLiteral("Files%1").arg(c), (*it).fileCount);
         g->writeEntry(QStringLiteral("Dirs%1").arg(c), (*it).dirCount);
         c++;
     }
     g->writeEntry("Count", c - 1);
 }
 
 void FSView::setColorMode(FSView::ColorMode cm)
 {
     if (_colorMode == cm) {
         return;
     }
 
     _colorMode = cm;
     redraw();
 }
 
 bool FSView::setColorMode(const QString &mode)
 {
     if (mode == QLatin1String("None")) {
         setColorMode(None);
     } else if (mode == QLatin1String("Depth")) {
         setColorMode(Depth);
     } else if (mode == QLatin1String("Name")) {
         setColorMode(Name);
     } else if (mode == QLatin1String("Owner")) {
         setColorMode(Owner);
     } else if (mode == QLatin1String("Group")) {
         setColorMode(Group);
     } else if (mode == QLatin1String("Mime")) {
         setColorMode(Mime);
     } else {
         return false;
     }
 
     return true;
 }
 
 QString FSView::colorModeString() const
 {
     QString mode;
     switch (_colorMode) {
     case None:  mode = QStringLiteral("None"); break;
     case Depth: mode = QStringLiteral("Depth"); break;
     case Name:  mode = QStringLiteral("Name"); break;
     case Owner: mode = QStringLiteral("Owner"); break;
     case Group: mode = QStringLiteral("Group"); break;
     case Mime:  mode = QStringLiteral("Mime"); break;
     default:    mode = QStringLiteral("Unknown"); break;
     }
     return mode;
 }
 
 void FSView::addColorItems(QMenu *popup, int id)
 {
     _colorID = id;
 
     connect(popup, SIGNAL(triggered(QAction*)),
             this, SLOT(colorActivated(QAction*)));
 
     addPopupItem(popup, i18n("None"),      colorMode() == None,  id++);
     addPopupItem(popup, i18n("Depth"),     colorMode() == Depth, id++);
     addPopupItem(popup, i18n("Name"),      colorMode() == Name,  id++);
     addPopupItem(popup, i18n("Owner"),     colorMode() == Owner, id++);
     addPopupItem(popup, i18n("Group"),     colorMode() == Group, id++);
     addPopupItem(popup, i18n("Mime Type"), colorMode() == Mime,  id++);
 }
 
 void FSView::colorActivated(QAction *a)
 {
     const int id = a->data().toInt();
     if (id == _colorID) {
         setColorMode(None);
     } else if (id == _colorID + 1) {
         setColorMode(Depth);
     } else if (id == _colorID + 2) {
         setColorMode(Name);
     } else if (id == _colorID + 3) {
         setColorMode(Owner);
     } else if (id == _colorID + 4) {
         setColorMode(Group);
     } else if (id == _colorID + 5) {
         setColorMode(Mime);
     }
 }
 
 void FSView::keyPressEvent(QKeyEvent *e)
 {
     if (e->key() == Qt::Key_Escape && !_pressed && (selection().size() > 0)) {
         // For consistency with Dolphin, deselect all on Escape if we're not dragging.
         TreeMapItem *changed = selection().commonParent();
         if (changed) {
             clearSelection(changed);
         }
     } else {
         TreeMapWidget::keyPressEvent(e);
     }
 }
 
 void FSView::saveFSOptions()
 {
     KConfigGroup tmconfig(_config, "TreeMap");
     saveOptions(&tmconfig);
     tmconfig.writeEntry("ColorMode", colorModeString());
 
     KConfigGroup gconfig(_config, "General");
     gconfig.writeEntry("Path", _path);
 
     KConfigGroup cconfig(_config, "MetricCache");
     saveMetric(&cconfig);
 }
 
 void FSView::quit()
 {
     saveFSOptions();
     qApp->quit();
 }
 
 void FSView::doRedraw()
 {
     // we update progress every 1/4 second, and redraw every second
     static int redrawCounter = 0;
 
     bool redo = _sm.scanRunning();
     if (!redo) {
         redrawCounter = 0;
     }
 
     if ((_progress > 0) && (_progressSize > 0) && _lastDir) {
         int percent = _progress * 100 / _progressSize;
         if (0) kDebug(90100) << "FSView::progress "
                                  << _progress << "/" << _progressSize
                                  << "= " << percent << "%, "
                                  << _dirsFinished << " dirs read, in "
                                  << _lastDir->path() << endl;
         emit progress(percent, _dirsFinished, _lastDir->path());
     }
 
     if (_allowRefresh && ((redrawCounter % 4) == 0)) {
         if (0) {
             kDebug(90100) << "doRedraw " << _sm.scanLength();
         }
         redraw();
     } else {
         redo = true;
     }
 
     if (redo) {
         QTimer::singleShot(500, this, SLOT(doRedraw()));
         redrawCounter++;
     }
 }
 
 void FSView::doUpdate()
 {
     for (int i = 0; i < 5; i++) {
         switch (_progressPhase) {
         case 1:
             _chunkSize1 += _sm.scan(_chunkData1);
             if (_chunkSize1 > 100) {
                 _progressPhase = 2;
 
                 /* Go to maximally 33% by scaling with 3 */
                 _progressSize = 3 * _chunkSize1;
 
                 if (1) {
                     kDebug(90100) << "Phase 2: CSize " << _chunkSize1;
                 }
             }
             break;
 
         case 2:
             /* progress phase 2 */
             _chunkSize2 += _sm.scan(_chunkData2);
             /* switch to Phase 3 if we reach 80 % of Phase 2 */
             if (_progress * 3 > _progressSize * 8 / 10) {
                 _progressPhase = 3;
 
                 /* Goal: Keep percentage equal from phase 2 to 3 */
                 double percent = (double)_progress / _progressSize;
                 /* We scale by factor 2/3 aferwards */
                 percent = percent * 3 / 2;
 
                 int todo = _chunkSize2 + (_progressSize / 3 - _progress);
                 _progressSize = (int)((double)todo / (1.0 - percent));
                 _progress = _progressSize - todo;
 
                 /* Go to maximally 66% by scaling with 1.5 */
                 _progressSize = _progressSize * 3 / 2;
 
                 if (1) kDebug(90100) << "Phase 3: CSize " << _chunkSize2
                                          << ", Todo " << todo
                                          << ", Progress " << _progress
                                          << "/" << _progressSize << endl;
             }
             break;
 
         case 3:
             /* progress phase 3 */
             _chunkSize3 += _sm.scan(_chunkData3);
             /* switch to Phase 4 if we reach 80 % of Phase 3 */
             if (_progress * 3 / 2 > _progressSize * 8 / 10) {
                 _progressPhase = 4;
 
                 /* Goal: Keep percentage equal from phase 2 to 3 */
                 double percent = (double)_progress / _progressSize;
                 int todo = _chunkSize3 + (_progressSize * 2 / 3 - _progress);
                 _progressSize = (int)((double)todo / (1.0 - percent) + .5);
                 _progress = _progressSize - todo;
 
                 if (1) kDebug(90100) << "Phase 4: CSize " << _chunkSize3
                                          << ", Todo " << todo
                                          << ", Progress " << _progress
                                          << "/" << _progressSize << endl;
             }
 
         default:
             _sm.scan(-1);
             break;
         }
     }
 
     if (_sm.scanRunning()) {
         QTimer::singleShot(0, this, SLOT(doUpdate()));
     } else {
         emit completed(_dirsFinished);
     }
 }
 
diff --git a/plugins/fsview/fsview_part.cpp b/plugins/fsview/fsview_part.cpp
index ff584fd32..2b017aca7 100644
--- a/plugins/fsview/fsview_part.cpp
+++ b/plugins/fsview/fsview_part.cpp
@@ -1,556 +1,557 @@
 /* This file is part of FSView.
    Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
    Some file management code taken from the Dolphin file manager (C) 2006-2009,
    by Peter Penz <peter.penz19@mail.com>
 
    KCachegrind 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, version 2.
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 /*
  * The KPart embedding the FSView widget
  */
 
-#include <qclipboard.h>
-#include <qtimer.h>
+#include "fsview_part.h"
+
+#include <QClipboard>
+#include <QTimer>
+#include <QStyle>
 
 #include <kfileitem.h>
 #include <kpluginfactory.h>
 #include <kaboutdata.h>
 
 #include <kglobalsettings.h>
 #include <kprotocolmanager.h>
 #include <kio/copyjob.h>
 #include <kio/deletejob.h>
 #include <kio/paste.h>
 #include <kmessagebox.h>
 #include <kactionmenu.h>
 #include <kactioncollection.h>
 #include <kpropertiesdialog.h>
 #include <KMimeTypeEditor>
 #include <kio/jobuidelegate.h>
 #include <KIO/FileUndoManager>
 #include <KJobWidgets>
 #include <ktoolinvocation.h>
 #include <kconfiggroup.h>
 #include <KDebug>
 
 #include <KLocalizedString>
 
 #include <QApplication>
 #include <QMimeData>
 
-#include "fsview_part.h"
-
 K_PLUGIN_FACTORY(FSViewPartFactory, registerPlugin<FSViewPart>();)
 K_EXPORT_PLUGIN(FSViewPartFactory(KAboutData(
                                       "fsview",
                                       0,
                                       ki18n("FSView"),
                                       "0.1.1",
                                       ki18n("Filesystem Utilization Viewer"),
                                       KAboutData::License_GPL,
                                       ki18n("(c) 2003-2005, Josef Weidendorfer"))))
 
 // FSJob, for progress
 
 FSJob::FSJob(FSView *v)
     : KIO::Job()
 {
     _view = v;
     QObject::connect(v, SIGNAL(progress(int,int,QString)),
                      this, SLOT(progressSlot(int,int,QString)));
 }
 
 void FSJob::kill(bool /*quietly*/)
 {
     _view->stop();
 
     Job::kill();
 }
 
 void FSJob::progressSlot(int percent, int dirs, const QString &cDir)
 {
     if (percent < 100) {
         emitPercent(percent, 100);
         slotInfoMessage(this, i18np("Read 1 folder, in %2",
                                     "Read %1 folders, in %2",
                                     dirs, cDir), QString());
     } else {
         slotInfoMessage(this, i18np("1 folder", "%1 folders", dirs), QString());
     }
 }
 
 // FSViewPart
 
 FSViewPart::FSViewPart(QWidget *parentWidget,
                        QObject *parent,
                        const QList<QVariant> & /* args */)
     : KParts::ReadOnlyPart(parent)
 {
     KAboutData aboutData(QStringLiteral("fsview"), i18n("FSView"), QStringLiteral("0.1"),
                          i18n("Filesystem Viewer"),
                          KAboutLicense::GPL,
                          i18n("(c) 2002, Josef Weidendorfer"));
     setComponentData(aboutData);
 
     _view = new FSView(new Inode(), parentWidget);
     _view->setWhatsThis(i18n("<p>This is the FSView plugin, a graphical "
                              "browsing mode showing filesystem utilization "
                              "by using a tree map visualization.</p>"
                              "<p>Note that in this mode, automatic updating "
                              "when filesystem changes are made "
                              "is intentionally <b>not</b> done.</p>"
                              "<p>For details on usage and options available, "
                              "see the online help under "
                              "menu 'Help/FSView Manual'.</p>"));
 
     _view->show();
     setWidget(_view);
 
     _ext = new FSViewBrowserExtension(this);
     _job = 0;
 
     _areaMenu = new KActionMenu(i18n("Stop at Area"),
                                 actionCollection());
     actionCollection()->addAction(QStringLiteral("treemap_areadir"), _areaMenu);
     _depthMenu = new KActionMenu(i18n("Stop at Depth"),
                                  actionCollection());
     actionCollection()->addAction(QStringLiteral("treemap_depthdir"), _depthMenu);
     _visMenu = new KActionMenu(i18n("Visualization"),
                                actionCollection());
     actionCollection()->addAction(QStringLiteral("treemap_visdir"), _visMenu);
 
     _colorMenu = new KActionMenu(i18n("Color Mode"),
                                  actionCollection());
     actionCollection()->addAction(QStringLiteral("treemap_colordir"), _colorMenu);
 
     QAction *action;
     action = actionCollection()->addAction(QStringLiteral("help_fsview"));
     action->setText(i18n("&FSView Manual"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("fsview")));
     action->setToolTip(i18n("Show FSView manual"));
     action->setWhatsThis(i18n("Opens the help browser with the "
                               "FSView documentation"));
     connect(action, SIGNAL(triggered()), this, SLOT(showHelp()));
 
     QObject::connect(_visMenu->menu(), SIGNAL(aboutToShow()),
                      SLOT(slotShowVisMenu()));
     QObject::connect(_areaMenu->menu(), SIGNAL(aboutToShow()),
                      SLOT(slotShowAreaMenu()));
     QObject::connect(_depthMenu->menu(), SIGNAL(aboutToShow()),
                      SLOT(slotShowDepthMenu()));
     QObject::connect(_colorMenu->menu(), SIGNAL(aboutToShow()),
                      SLOT(slotShowColorMenu()));
 
     slotSettingsChanged(KGlobalSettings::SETTINGS_MOUSE);
     connect(KGlobalSettings::self(), SIGNAL(settingsChanged(int)),
             SLOT(slotSettingsChanged(int)));
 
     QObject::connect(_view, SIGNAL(returnPressed(TreeMapItem*)),
                      _ext, SLOT(selected(TreeMapItem*)));
     QObject::connect(_view, SIGNAL(selectionChanged()),
                      this, SLOT(updateActions()));
     QObject::connect(_view,
                      SIGNAL(contextMenuRequested(TreeMapItem*,QPoint)),
                      this,
                      SLOT(contextMenu(TreeMapItem*,QPoint)));
 
     QObject::connect(_view, SIGNAL(started()), this, SLOT(startedSlot()));
     QObject::connect(_view, SIGNAL(completed(int)),
                      this, SLOT(completedSlot(int)));
 
     // Create common file management actions - this is necessary in KDE4
     // as these common actions are no longer automatically part of KParts.
     // Much of this is taken from Dolphin.
     // FIXME: Renaming didn't even seem to work in KDE3! Implement (non-inline) renaming
     // functionality.
     //QAction* renameAction = m_actionCollection->addAction("rename");
     //rename->setText(i18nc("@action:inmenu Edit", "Rename..."));
     //rename->setShortcut(Qt::Key_F2);
 
     QAction *moveToTrashAction = actionCollection()->addAction(QStringLiteral("move_to_trash"));
     moveToTrashAction->setText(i18nc("@action:inmenu File", "Move to Trash"));
     moveToTrashAction->setIcon(QIcon::fromTheme(QStringLiteral("user-trash")));
     actionCollection()->setDefaultShortcut(moveToTrashAction, QKeySequence(QKeySequence::Delete));
     connect(moveToTrashAction, SIGNAL(triggered(Qt::MouseButtons,Qt::KeyboardModifiers)),
             _ext, SLOT(trash(Qt::MouseButtons,Qt::KeyboardModifiers)));
 
     QAction *deleteAction = actionCollection()->addAction(QStringLiteral("delete"));
     deleteAction->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
     deleteAction->setText(i18nc("@action:inmenu File", "Delete"));
     actionCollection()->setDefaultShortcut(deleteAction, QKeySequence(Qt::SHIFT | Qt::Key_Delete));
     connect(deleteAction, SIGNAL(triggered()), _ext, SLOT(del()));
 
     QAction *editMimeTypeAction = actionCollection()->addAction(QStringLiteral("editMimeType"));
     editMimeTypeAction->setText(i18nc("@action:inmenu Edit", "&Edit File Type..."));
     connect(editMimeTypeAction, SIGNAL(triggered()), _ext, SLOT(editMimeType()));
 
     QAction *propertiesAction = actionCollection()->addAction(QStringLiteral("properties"));
     propertiesAction->setText(i18nc("@action:inmenu File", "Properties"));
     propertiesAction->setIcon(QIcon::fromTheme(QStringLiteral("document-properties")));
     propertiesAction->setShortcut(Qt::ALT | Qt::Key_Return);
     connect(propertiesAction, SIGNAL(triggered()), SLOT(slotProperties()));
 
     QTimer::singleShot(1, this, SLOT(showInfo()));
 
     updateActions();
 
     setXMLFile(QStringLiteral("fsview_part.rc"));
 }
 
 FSViewPart::~FSViewPart()
 {
     kDebug(90100) << "FSViewPart Destructor";
 
     delete _job;
     _view->saveFSOptions();
 }
 
 void FSViewPart::slotSettingsChanged(int category)
 {
     if (category != KGlobalSettings::SETTINGS_MOUSE) {
         return;
     }
 
     QObject::disconnect(_view, SIGNAL(clicked(TreeMapItem*)),
                         _ext, SLOT(selected(TreeMapItem*)));
     QObject::disconnect(_view, SIGNAL(doubleClicked(TreeMapItem*)),
                         _ext, SLOT(selected(TreeMapItem*)));
 
-    if (KGlobalSettings::singleClick())
+    if (_view->style()->styleHint(QStyle::SH_ItemView_ActivateItemOnSingleClick))
         QObject::connect(_view, SIGNAL(clicked(TreeMapItem*)),
                          _ext, SLOT(selected(TreeMapItem*)));
     else
         QObject::connect(_view, SIGNAL(doubleClicked(TreeMapItem*)),
                          _ext, SLOT(selected(TreeMapItem*)));
 }
 
 void FSViewPart::showInfo()
 {
     QString info;
     info = i18n("FSView intentionally does not support automatic updates "
                 "when changes are made to files or directories, "
                 "currently visible in FSView, from the outside.\n"
                 "For details, see the 'Help/FSView Manual'.");
 
     KMessageBox::information(_view, info, QString(), QStringLiteral("ShowFSViewInfo"));
 }
 
 void FSViewPart::showHelp()
 {
     KToolInvocation::startServiceByDesktopName(QStringLiteral("khelpcenter"),
             QStringLiteral("help:/konqueror/index.html#fsview"));
 }
 
 void FSViewPart::startedSlot()
 {
     _job = new FSJob(_view);
     _job->setUiDelegate(new KIO::JobUiDelegate());
     emit started(_job);
 }
 
 void FSViewPart::completedSlot(int dirs)
 {
     if (_job) {
         _job->progressSlot(100, dirs, QString());
         delete _job;
         _job = 0;
     }
 
     KConfigGroup cconfig(_view->config(), "MetricCache");
     _view->saveMetric(&cconfig);
 
     emit completed();
 }
 
 void FSViewPart::slotShowVisMenu()
 {
     _visMenu->menu()->clear();
     _view->addVisualizationItems(_visMenu->menu(), 1301);
 }
 
 void FSViewPart::slotShowAreaMenu()
 {
     _areaMenu->menu()->clear();
     _view->addAreaStopItems(_areaMenu->menu(), 1001, 0);
 }
 
 void FSViewPart::slotShowDepthMenu()
 {
     _depthMenu->menu()->clear();
     _view->addDepthStopItems(_depthMenu->menu(), 1501, 0);
 }
 
 void FSViewPart::slotShowColorMenu()
 {
     _colorMenu->menu()->clear();
     _view->addColorItems(_colorMenu->menu(), 1401);
 }
 
 bool FSViewPart::openFile() // never called since openUrl is reimplemented
 {
     kDebug(90100) << "FSViewPart::openFile " << localFilePath();
     _view->setPath(localFilePath());
 
     return true;
 }
 
 bool FSViewPart::openUrl(const QUrl &url)
 {
     kDebug(90100) << "FSViewPart::openUrl " << url.path();
 
     if (!url.isValid()) {
         return false;
     }
     if (!url.isLocalFile()) {
         return false;
     }
 
     setUrl(url);
     emit setWindowCaption(this->url().toDisplayString(QUrl::PreferLocalFile));
 
     _view->setPath(this->url().path());
 
     return true;
 }
 
 bool FSViewPart::closeUrl()
 {
     kDebug(90100) << "FSViewPart::closeUrl ";
 
     _view->stop();
 
     return true;
 }
 
 void FSViewPart::setNonStandardActionEnabled(const char *actionName, bool enabled)
 {
     QAction *action = actionCollection()->action(actionName);
     action->setEnabled(enabled);
 }
 
 void FSViewPart::updateActions()
 {
     int canDel = 0, canCopy = 0, canMove = 0;
     QList<QUrl> urls;
 
     foreach (TreeMapItem *i, _view->selection()) {
         QUrl u = QUrl::fromLocalFile(((Inode *)i)->path());
         urls.append(u);
         canCopy++;
         if (KProtocolManager::supportsDeleting(u)) {
             canDel++;
         }
         if (KProtocolManager::supportsMoving(u)) {
             canMove++;
         }
     }
 
     // Standard KBrowserExtension actions.
     emit _ext->enableAction("copy", canCopy > 0);
     emit _ext->enableAction("cut", canMove > 0);
     // Custom actions.
     //setNonStandardActionEnabled("rename", canMove > 0 ); // FIXME
     setNonStandardActionEnabled("move_to_trash", (canDel > 0 && canMove > 0));
     setNonStandardActionEnabled("delete", canDel > 0);
     setNonStandardActionEnabled("editMimeType", _view->selection().count() == 1);
     setNonStandardActionEnabled("properties", _view->selection().count() == 1);
 
     emit _ext->selectionInfo(urls);
 
     if (canCopy > 0) {
         stateChanged(QStringLiteral("has_selection"));
     } else {
         stateChanged(QStringLiteral("has_no_selection"));
     }
 
     kDebug(90100) << "FSViewPart::updateActions, deletable " << canDel;
 }
 
 void FSViewPart::contextMenu(TreeMapItem * /*item*/, const QPoint &p)
 {
     int canDel = 0, canCopy = 0, canMove = 0;
     KFileItemList items;
 
     foreach (TreeMapItem *i, _view->selection()) {
         QUrl u = QUrl::fromLocalFile(((Inode *)i)->path());
         QString mimetype = ((Inode *)i)->mimeType().name();
         const QFileInfo &info = ((Inode *)i)->fileInfo();
         mode_t mode =
             info.isFile() ? S_IFREG :
             info.isDir() ? S_IFDIR :
             info.isSymLink() ? S_IFLNK : (mode_t) - 1;
         items.append(KFileItem(u, mimetype, mode));
 
         canCopy++;
         if (KProtocolManager::supportsDeleting(u)) {
             canDel++;
         }
         if (KProtocolManager::supportsMoving(u)) {
             canMove++;
         }
     }
 
     QList<QAction *> editActions;
     KParts::BrowserExtension::ActionGroupMap actionGroups;
     KParts::BrowserExtension::PopupFlags flags = KParts::BrowserExtension::ShowUrlOperations |
             KParts::BrowserExtension::ShowProperties;
 
     bool addTrash = (canMove > 0);
     bool addDel = false;
     if (canDel == 0) {
         flags |= KParts::BrowserExtension::NoDeletion;
     } else {
         if (!url().isLocalFile()) {
             addDel = true;
         } else if (QApplication::keyboardModifiers() & Qt::ShiftModifier) {
             addTrash = false;
             addDel = true;
         } else {
             KSharedConfig::Ptr globalConfig = KSharedConfig::openConfig(QStringLiteral("kdeglobals"), KConfig::IncludeGlobals);
             KConfigGroup configGroup(globalConfig, "KDE");
             addDel = configGroup.readEntry("ShowDeleteCommand", false);
         }
     }
 
     if (addTrash) {
         editActions.append(actionCollection()->action(QStringLiteral("move_to_trash")));
     }
     if (addDel) {
         editActions.append(actionCollection()->action(QStringLiteral("delete")));
     }
 
 // FIXME: rename is currently unavailable. Requires popup renaming.
 //     if (canMove)
 //       editActions.append(actionCollection()->action("rename"));
     actionGroups.insert(QStringLiteral("editactions"), editActions);
 
     if (items.count() > 0)
         emit _ext->popupMenu(_view->mapToGlobal(p), items,
                              KParts::OpenUrlArguments(),
                              KParts::BrowserArguments(),
                              flags,
                              actionGroups);
 }
 
 void FSViewPart::slotProperties()
 {
     QList<QUrl> urlList;
     if (view()) {
         urlList = view()->selectedUrls();
     }
 
     if (!urlList.isEmpty()) {
         KPropertiesDialog::showDialog(urlList.first(), view());
     }
 }
 
 // FSViewBrowserExtension
 
 FSViewBrowserExtension::FSViewBrowserExtension(FSViewPart *viewPart)
     : KParts::BrowserExtension(viewPart)
 {
     _view = viewPart->view();
 }
 
 FSViewBrowserExtension::~FSViewBrowserExtension()
 {}
 
 void FSViewBrowserExtension::del()
 {
     const QList<QUrl> urls = _view->selectedUrls();
     KIO::JobUiDelegate uiDelegate;
     uiDelegate.setWindow(_view);
     if (uiDelegate.askDeleteConfirmation(urls,
                                          KIO::JobUiDelegate::Delete, KIO::JobUiDelegate::DefaultConfirmation)) {
         KIO::Job *job = KIO::del(urls);
         KJobWidgets::setWindow(job, _view);
         job->ui()->setAutoErrorHandlingEnabled(true);
         connect(job, SIGNAL(result(KJob*)),
                 this, SLOT(refresh()));
     }
 }
 
 void FSViewBrowserExtension::trash(Qt::MouseButtons, Qt::KeyboardModifiers modifiers)
 {
     bool deleteNotTrash = ((modifiers & Qt::ShiftModifier) != 0);
     if (deleteNotTrash) {
         del();
     } else {
         KIO::JobUiDelegate uiDelegate;
         uiDelegate.setWindow(_view);
         const QList<QUrl> urls = _view->selectedUrls();
         if (uiDelegate.askDeleteConfirmation(urls,
                                              KIO::JobUiDelegate::Trash, KIO::JobUiDelegate::DefaultConfirmation)) {
             KIO::Job *job = KIO::trash(urls);
             KIO::FileUndoManager::self()->recordJob(KIO::FileUndoManager::Trash, urls, QUrl("trash:/"), job);
             KJobWidgets::setWindow(job, _view);
             job->ui()->setAutoErrorHandlingEnabled(true);
             connect(job, SIGNAL(result(KJob*)),
                     this, SLOT(refresh()));
         }
     }
 }
 
 void FSViewBrowserExtension::copySelection(bool move)
 {
     QMimeData *data = new QMimeData;
     data->setUrls(_view->selectedUrls());
     KIO::setClipboardDataCut(data, move);
     QApplication::clipboard()->setMimeData(data);
 }
 
 void FSViewBrowserExtension::editMimeType()
 {
     Inode *i = (Inode *) _view->selection().first();
     if (i) {
         KMimeTypeEditor::editMimeType(i->mimeType().name(), _view);
     }
 }
 
 // refresh treemap at end of KIO jobs
 void FSViewBrowserExtension::refresh()
 {
     // only need to refresh common ancestor for all selected items
     TreeMapItem *commonParent = _view->selection().commonParent();
     if (!commonParent) {
         return;
     }
 
     /* if commonParent is a file, update parent directory */
     if (!((Inode *)commonParent)->isDir()) {
         commonParent = commonParent->parent();
         if (!commonParent) {
             return;
         }
     }
 
     kDebug(90100) << "FSViewPart::refreshing "
                   << ((Inode *)commonParent)->path() << endl;
 
     _view->requestUpdate((Inode *)commonParent);
 }
 
 void FSViewBrowserExtension::selected(TreeMapItem *i)
 {
     if (!i) {
         return;
     }
 
     QUrl url = QUrl::fromLocalFile(((Inode *)i)->path());
     emit openUrlRequest(url);
 }
 
 #include "fsview_part.moc"
diff --git a/plugins/fsview/inode.cpp b/plugins/fsview/inode.cpp
index 5fa39cc8f..ab2efe4dd 100644
--- a/plugins/fsview/inode.cpp
+++ b/plugins/fsview/inode.cpp
@@ -1,429 +1,429 @@
 /* This file is part of FSView.
    Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
 
    KCachegrind 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, version 2.
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 /*
  * FSView specialisaton of TreeMapItem class.
  */
 
+#include "inode.h"
 #include <kdebug.h>
 #include <kglobal.h>
 #include <kiconloader.h>
 #include <KLocalizedString>
 #include <QMimeDatabase>
 #include <QMimeType>
-#include "inode.h"
 #include "scan.h"
 #include "fsview.h"
 
 // Inode
 
 Inode::Inode()
 {
     _dirPeer = 0;
     _filePeer = 0;
     init(QString());
 }
 
 Inode::Inode(ScanDir *d, Inode *parent)
     : TreeMapItem(parent)
 {
     QString absPath;
     if (parent) {
         absPath = parent->path();
         if (!absPath.endsWith(QLatin1Char('/'))) {
             absPath += QLatin1Char('/');
         }
     }
     absPath += d->name();
 
     _dirPeer = d;
     _filePeer = 0;
 
     init(absPath);
 }
 
 Inode::Inode(ScanFile *f, Inode *parent)
     : TreeMapItem(parent)
 {
     QString absPath;
     if (parent) {
         absPath = parent->path() + QLatin1Char('/');
     }
     absPath += f->name();
 
     _dirPeer = 0;
     _filePeer = f;
 
     init(absPath);
 }
 
 Inode::~Inode()
 {
     if (0) kDebug(90100) << "~Inode [" << path()
                              << "]" << endl;
 
     /* reset Listener of old Peer */
     if (_dirPeer) {
         _dirPeer->setListener(0);
     }
     if (_filePeer) {
         _filePeer->setListener(0);
     }
 }
 
 void Inode::setPeer(ScanDir *d)
 {
     /* reset Listener of old Peer */
     if (_dirPeer) {
         _dirPeer->setListener(0);
     }
     if (_filePeer) {
         _filePeer->setListener(0);
     }
 
     _dirPeer = d;
     _filePeer = 0;
     init(d->name());
 }
 
 QString Inode::path() const
 {
     return _info.absoluteFilePath();
 }
 
 void Inode::init(const QString &path)
 {
     if (0) kDebug(90100) << "Inode::init [" << path
                              << "]" << endl;
 
     _info = QFileInfo(path);
 
     if (!FSView::getDirMetric(path, _sizeEstimation,
                               _fileCountEstimation,
                               _dirCountEstimation)) {
         _sizeEstimation = 0.0;
         _fileCountEstimation = 0;
         _dirCountEstimation = 0;
     }
 
     _mimeSet = false;
     _mimePixmapSet = false;
     _resortNeeded = false;
 
     clear();
 
     /* we want to get notifications about dir changes */
     if (_dirPeer) {
         _dirPeer->setListener(this);
     }
     if (_filePeer) {
         _filePeer->setListener(this);
     }
 
     if (_dirPeer && _dirPeer->scanFinished()) {
         scanFinished(_dirPeer);
     }
 }
 
 /* ScanListener interface */
 void Inode::sizeChanged(ScanDir *d)
 {
     if (0) kDebug(90100) << "Inode::sizeChanged [" << path() << "] in "
                              << d->name() << ": size " << d->size() << endl;
 
     _resortNeeded = true;
 }
 
 void Inode::scanFinished(ScanDir *d)
 {
     if (0) kDebug(90100) << "Inode::scanFinished [" << path() << "] in "
                              << d->name() << ": size " << d->size() << endl;
 
     _resortNeeded = true;
 
     /* no estimation any longer */
     _sizeEstimation = 0.0;
     _fileCountEstimation = 0;
     _dirCountEstimation = 0;
 
     // cache metrics if "important" (for "/usr" is dd==3)
     int dd = ((FSView *)widget())->pathDepth() + depth();
     int files = d->fileCount();
     int dirs = d->dirCount();
 
     if ((files < 500) && (dirs < 50)) {
         if (dd > 4 && (files < 50) && (dirs < 5)) {
             return;
         }
     }
 
     FSView::setDirMetric(path(), d->size(), files, dirs);
 }
 
 void Inode::destroyed(ScanDir *d)
 {
     if (_dirPeer == d) {
         _dirPeer = 0;
     }
 
     // remove children
     clear();
 }
 
 void Inode::destroyed(ScanFile *f)
 {
     if (_filePeer == f) {
         _filePeer = 0;
     }
 }
 
 TreeMapItemList *Inode::children()
 {
     if (!_dirPeer) {
         return 0;
     }
 
     if (!_children) {
         if (!_dirPeer->scanStarted()) {
             return 0;
         }
 
         _children = new TreeMapItemList;
 
         setSorting(-1);
 
         ScanFileVector &files = _dirPeer->files();
         if (files.count() > 0) {
             ScanFileVector::iterator it;
             for (it = files.begin(); it != files.end(); ++it) {
                 new Inode(&(*it), this);
             }
         }
 
         ScanDirVector &dirs = _dirPeer->dirs();
         if (dirs.count() > 0) {
             ScanDirVector::iterator it;
             for (it = dirs.begin(); it != dirs.end(); ++it) {
                 new Inode(&(*it), this);
             }
         }
 
         setSorting(-2);
         _resortNeeded = false;
     }
 
     if (_resortNeeded) {
         resort();
         _resortNeeded = false;
     }
 
     return _children;
 }
 
 double Inode::size() const
 {
     // sizes of files are always correct
     if (_filePeer) {
         return _filePeer->size();
     }
     if (!_dirPeer) {
         return 0;
     }
 
     double size = _dirPeer->size();
     return (_sizeEstimation > size) ? _sizeEstimation : size;
 }
 
 double Inode::value() const
 {
     return size();
 }
 
 unsigned int Inode::fileCount() const
 {
     unsigned int fileCount = 1;
 
     if (_dirPeer) {
         fileCount = _dirPeer->fileCount();
     }
 
     if (_fileCountEstimation > fileCount) {
         fileCount = _fileCountEstimation;
     }
 
     return fileCount;
 }
 
 unsigned int Inode::dirCount() const
 {
     unsigned int dirCount = 0;
 
     if (_dirPeer) {
         dirCount = _dirPeer->dirCount();
     }
 
     if (_dirCountEstimation > dirCount) {
         dirCount = _dirCountEstimation;
     }
 
     return dirCount;
 }
 
 QColor Inode::backColor() const
 {
     QString n;
     int id = 0;
 
     switch (((FSView *)widget())->colorMode()) {
     case FSView::Depth: {
         int d = ((FSView *)widget())->pathDepth() + depth();
         return QColor::fromHsv((100 * d) % 360, 192, 128);
     }
 
     case FSView::Name:   n = text(0); break;
     case FSView::Owner:  id = _info.ownerId(); break;
     case FSView::Group:  id = _info.groupId(); break;
     case FSView::Mime:   n = text(7); break;
 
     default:
         break;
     }
 
     if (id > 0) {
         n = QString::number(id);
     }
 
     if (n.isEmpty()) {
         return widget()->palette().button().color();
     }
 
     QByteArray tmpBuf = n.toLocal8Bit();
     const char *str = tmpBuf.data();
     int h = 0, s = 100;
     while (*str) {
         h = (h * 37 + s * (unsigned) * str) % 256;
         s = (s * 17 + h * (unsigned) * str) % 192;
         str++;
     }
     return QColor::fromHsv(h, 64 + s, 192);
 }
 
 QMimeType Inode::mimeType() const
 {
     if (!_mimeSet) {
         QMimeDatabase db;
         _mimeType = db.mimeTypeForUrl(QUrl::fromLocalFile(path()));
 
         _mimeSet = true;
     }
     return _mimeType;
 }
 
 QString Inode::text(int i) const
 {
     if (i == 0) {
         QString name;
         if (_dirPeer) {
             name = _dirPeer->name();
             if (!name.endsWith(QLatin1Char('/'))) {
                 name += QLatin1Char('/');
             }
         } else if (_filePeer) {
             name = _filePeer->name();
         }
 
         return name;
     }
     if (i == 1) {
         QString text;
         double s = size();
 
         if (s < 1000) {
             text = QStringLiteral("%1 B").arg((int)(s + .5));
         } else if (s < 10 * 1024) {
             text = QStringLiteral("%1 kB").arg(KGlobal::locale()->formatNumber(s / 1024 + .005, 2));
         } else if (s < 100 * 1024) {
             text = QStringLiteral("%1 kB").arg(KGlobal::locale()->formatNumber(s / 1024 + .05, 1));
         } else if (s < 1000 * 1024) {
             text = QStringLiteral("%1 kB").arg((int)(s / 1024 + .5));
         } else if (s < 10 * 1024 * 1024) {
             text = QStringLiteral("%1 MB").arg(KGlobal::locale()->formatNumber(s / 1024 / 1024 + .005, 2));
         } else if (s < 100 * 1024 * 1024) {
             text = QStringLiteral("%1 MB").arg(KGlobal::locale()->formatNumber(s / 1024 / 1024 + .05, 1));
         } else if (s < 1000 * 1024 * 1024) {
             text = QStringLiteral("%1 MB").arg((int)(s / 1024 / 1024 + .5));
         } else {
             text =  QStringLiteral("%1 GB").arg(KGlobal::locale()->formatNumber(s / 1024 / 1024 / 1024 + .005, 2));
         }
 
         if (_sizeEstimation > 0) {
             text += '+';
         }
         return text;
     }
 
     if ((i == 2) || (i == 3)) {
         /* file/dir count makes no sense for files */
         if (_filePeer) {
             return QString();
         }
 
         QString text;
         unsigned int f = (i == 2) ? fileCount() : dirCount();
 
         if (f > 0) {
             while (f > 1000) {
                 text = QStringLiteral("%1 %2").arg(QString::number(f).right(3)).arg(text);
                 f /= 1000;
             }
             text = QStringLiteral("%1 %2").arg(QString::number(f)).arg(text);
             if (_fileCountEstimation > 0) {
                 text += '+';
             }
         }
         return text;
     }
 
     if (i == 4) {
         return _info.lastModified().toString();
     }
     if (i == 5) {
         return _info.owner();
     }
     if (i == 6) {
         return _info.group();
     }
     if (i == 7) {
         return mimeType().comment();
     }
     return QString();
 }
 
 QPixmap Inode::pixmap(int i) const
 {
     if (i != 0) {
         return QPixmap();
     }
 
     if (!_mimePixmapSet) {
         QUrl u = QUrl::fromLocalFile(path());
         _mimePixmap = KIconLoader::global()->loadMimeTypeIcon(KIO::iconNameForUrl(u), KIconLoader::Small);
         _mimePixmapSet = true;
     }
     return _mimePixmap;
 }
diff --git a/plugins/fsview/scan.cpp b/plugins/fsview/scan.cpp
index 700cfe882..f654ae5a9 100644
--- a/plugins/fsview/scan.cpp
+++ b/plugins/fsview/scan.cpp
@@ -1,436 +1,437 @@
 /* This file is part of FSView.
    Copyright (C) 2002, 2003 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>
 
    KCachegrind 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, version 2.
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
-#include <qdir.h>
-#include <qstringlist.h>
-#include <qset.h>
+#include "scan.h"
+
+#include <QDir>
+#include <QStringList>
+#include <QSet>
 #include <qplatformdefs.h>
 
 #include <kdebug.h>
 #include <kauthorized.h>
 #include <kurlauthorized.h>
 
-#include "scan.h"
 #include "inode.h"
 
 // ScanManager
 
 ScanManager::ScanManager()
 {
     _topDir = 0;
     _listener = 0;
 }
 
 ScanManager::ScanManager(const QString &path)
 {
     _topDir = 0;
     _listener = 0;
     setTop(path);
 }
 
 ScanManager::~ScanManager()
 {
     stopScan();
     delete _topDir;
 }
 
 void ScanManager::setListener(ScanListener *l)
 {
     _listener = l;
 }
 
 ScanDir *ScanManager::setTop(const QString &path, int data)
 {
     stopScan();
     if (_topDir) {
         delete _topDir;
         _topDir = 0;
     }
     if (!path.isEmpty()) {
         _topDir = new ScanDir(path, this, 0, data);
     }
     return _topDir;
 }
 
 bool ScanManager::scanRunning()
 {
     if (!_topDir) {
         return false;
     }
 
     return _topDir->scanRunning();
 }
 
 void ScanManager::startScan(ScanDir *from)
 {
     if (!_topDir) {
         return;
     }
     if (!from) {
         from = _topDir;
     }
 
     if (scanRunning()) {
         stopScan();
     }
 
     from->clear();
     if (from->parent()) {
         from->parent()->setupChildRescan();
     }
 
     _list.append(new ScanItem(from->path(), from));
 }
 
 void ScanManager::stopScan()
 {
     if (!_topDir) {
         return;
     }
 
     if (0) kDebug(90100) << "ScanManager::stopScan, scanLength "
                              << _list.count() << endl;
 
     while (!_list.isEmpty()) {
         ScanItem *si = _list.takeFirst();
         si->dir->finish();
         delete si;
     }
 }
 
 int ScanManager::scan(int data)
 {
     if (_list.isEmpty()) {
         return false;
     }
     ScanItem *si = _list.takeFirst();
 
     int newCount = si->dir->scan(si, _list, data);
     delete si;
 
     return newCount;
 }
 
 // ScanFile
 
 ScanFile::ScanFile()
 {
     _size = 0;
     _listener = 0;
 }
 
 ScanFile::ScanFile(const QString &n, KIO::fileoffset_t s)
 {
     _name = n;
     _size = s;
     _listener = 0;
 }
 
 ScanFile::~ScanFile()
 {
     if (_listener) {
         _listener->destroyed(this);
     }
 }
 
 // ScanDir
 
 ScanDir::ScanDir()
 {
     _dirty = true;
     _dirsFinished = -1; /* scan not started */
 
     _parent = Q_NULLPTR;
     _manager = 0;
     _listener = 0;
     _data = 0;
 }
 
 ScanDir::ScanDir(const QString &n, ScanManager *m,
                  ScanDir *p, int data)
     : _name(n)
 {
     _dirty = true;
     _dirsFinished = -1; /* scan not started */
 
     _parent = p;
     _manager = m;
     _listener = 0;
     _data = data;
 }
 
 ScanDir::~ScanDir()
 {
     if (_listener) {
         _listener->destroyed(this);
     }
 }
 
 void ScanDir::setListener(ScanListener *l)
 {
     _listener = l;
 }
 
 QString ScanDir::path()
 {
     if (_parent) {
         QString p = _parent->path();
         if (!p.endsWith(QLatin1Char('/'))) {
             p += QLatin1Char('/');
         }
         return p + _name;
     }
 
     return _name;
 }
 
 void ScanDir::clear()
 {
     _dirty = true;
     _dirsFinished = -1; /* scan not started */
 
     _files.clear();
     _dirs.clear();
 }
 
 void ScanDir::update()
 {
     if (!_dirty) {
         return;
     }
     _dirty = false;
 
     _fileCount = 0;
     _dirCount = 0;
     _size = 0;
 
     if (_dirsFinished == -1) {
         return;
     }
 
     if (_files.count() > 0) {
         _fileCount += _files.count();
         _size = _fileSize;
     }
     if (_dirs.count() > 0) {
         _dirCount += _dirs.count();
         ScanDirVector::iterator it;
         for (it = _dirs.begin(); it != _dirs.end(); ++it) {
             (*it).update();
             _fileCount += (*it)._fileCount;
             _dirCount  += (*it)._dirCount;
             _size      += (*it)._size;
         }
     }
 }
 
 bool ScanDir::isForbiddenDir(QString &d)
 {
     static QSet<QString> *s = 0;
 
     if (!s) {
         s = new QSet<QString>;
         // directories without real files on Linux
         // TODO: should be OS specific
         s->insert(QStringLiteral("/proc"));
         s->insert(QStringLiteral("/dev"));
         s->insert(QStringLiteral("/sys"));
     }
     return (s->contains(d));
 }
 
 int ScanDir::scan(ScanItem *si, ScanItemList &list, int data)
 {
     clear();
     _dirsFinished = 0;
     _fileSize = 0;
     _dirty = true;
 
     if (isForbiddenDir(si->absPath)) {
         if (_parent) {
             _parent->subScanFinished();
         }
         return 0;
     }
 
     QUrl u = QUrl::fromLocalFile(si->absPath);
     if (!KUrlAuthorized::authorizeUrlAction(QStringLiteral("list"), QUrl(), u)) {
         if (_parent) {
             _parent->subScanFinished();
         }
 
         return 0;
     }
 
     QDir d(si->absPath);
     const QStringList fileList = d.entryList(QDir::Files |
                                  QDir::Hidden | QDir::NoSymLinks);
 
     if (fileList.count() > 0) {
         QT_STATBUF buff;
 
         _files.reserve(fileList.count());
 
         QStringList::ConstIterator it;
         for (it = fileList.constBegin(); it != fileList.constEnd(); ++it) {
             QString tmp(si->absPath + QLatin1Char('/') + (*it));
             if (QT_LSTAT(tmp.toStdString().c_str(), &buff) != 0) {
                 continue;
             }
             _files.append(ScanFile(*it, buff.st_size));
             _fileSize += buff.st_size;
         }
     }
 
     const QStringList dirList = d.entryList(QDir::Dirs |
                                             QDir::Hidden | QDir::NoSymLinks | QDir::NoDotAndDotDot);
 
     if (dirList.count() > 0) {
         _dirs.reserve(dirList.count());
 
         QStringList::ConstIterator it;
         for (it = dirList.constBegin(); it != dirList.constEnd(); ++it) {
             _dirs.append(ScanDir(*it, _manager, this, data));
             QString newpath = si->absPath;
             if (!newpath.endsWith(QChar('/'))) {
                 newpath.append("/");
             }
             newpath.append(*it);
             list.append(new ScanItem(newpath, &(_dirs.last())));
         }
         _dirCount += _dirs.count();
     }
 
     callScanStarted();
     callSizeChanged();
 
     if (_dirs.count() == 0) {
         callScanFinished();
 
         if (_parent) {
             _parent->subScanFinished();
         }
     }
 
     return _dirs.count();
 }
 
 void ScanDir::subScanFinished()
 {
     _dirsFinished++;
     callSizeChanged();
 
     if (0) kDebug(90100) << "ScanDir::subScanFinished [" << path()
                              << "]: " << _dirsFinished << "/" << _dirs.count() << endl;
 
     if (_dirsFinished < _dirs.count()) {
         return;
     }
 
     /* all subdirs read */
     callScanFinished();
 
     if (_parent) {
         _parent->subScanFinished();
     }
 }
 
 void ScanDir::finish()
 {
     if (scanRunning()) {
         _dirsFinished = _dirs.count();
         callScanFinished();
     }
 
     if (_parent) {
         _parent->finish();
     }
 }
 
 void ScanDir::setupChildRescan()
 {
     if (_dirs.count() == 0) {
         return;
     }
 
     _dirsFinished = 0;
     ScanDirVector::iterator it;
     for (it = _dirs.begin(); it != _dirs.end(); ++it)
         if ((*it).scanFinished()) {
             _dirsFinished++;
         }
 
     if (_parent &&
             (_dirsFinished < _dirs.count())) {
         _parent->setupChildRescan();
     }
 
     callScanStarted();
 }
 
 void ScanDir::callScanStarted()
 {
     if (0) kDebug(90100) << "ScanDir:Started [" << path()
                              << "]: size " << size() << ", files " << fileCount() << endl;
 
     ScanListener *mListener = _manager ? _manager->listener() : 0;
 
     if (_listener) {
         _listener->scanStarted(this);
     }
     if (mListener) {
         mListener->scanStarted(this);
     }
 }
 
 void ScanDir::callSizeChanged()
 {
     if (0) kDebug(90100) << ". [" << path()
                              << "]: size " << size() << ", files " << fileCount() << endl;
 
     _dirty = true;
 
     if (_parent) {
         _parent->callSizeChanged();
     }
 
     ScanListener *mListener = _manager ? _manager->listener() : 0;
 
     if (_listener) {
         _listener->sizeChanged(this);
     }
     if (mListener) {
         mListener->sizeChanged(this);
     }
 }
 
 void ScanDir::callScanFinished()
 {
     if (0) kDebug(90100) << "ScanDir:Finished [" << path()
                              << "]: size " << size() << ", files " << fileCount() << endl;
 
     ScanListener *mListener = _manager ? _manager->listener() : 0;
 
     if (_listener) {
         _listener->scanFinished(this);
     }
     if (mListener) {
         mListener->scanFinished(this);
     }
 }
 
diff --git a/plugins/kimgalleryplugin/imgallerydialog.cpp b/plugins/kimgalleryplugin/imgallerydialog.cpp
index 872a4b65b..16a49476a 100644
--- a/plugins/kimgalleryplugin/imgallerydialog.cpp
+++ b/plugins/kimgalleryplugin/imgallerydialog.cpp
@@ -1,484 +1,482 @@
 /* This file is part of the KDE project
 
 Copyright (C) 2001, 2003 Lukas Tinkl <lukas@kde.org>
 Andreas Schlapbach <schlpbch@iam.unibe.ch>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qcombobox.h>
-
-#include <qcheckbox.h>
-#include <qlineedit.h>
-#include <qspinbox.h>
-//Added by qt3to4:
+#include "imgallerydialog.h"
+
+#include <QLabel>
+#include <QLayout>
+#include <QComboBox>
+#include <QCheckBox>
+#include <QLineEdit>
+#include <QSpinBox>
 #include <QVBoxLayout>
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QGridLayout>
+#include <QFontDatabase>
 
 #include <KLocalizedString>
 #include <kfontdialog.h>
 #include <kiconloader.h>
 #include <klineedit.h>
 #include <knuminput.h>
 #include <kcolorbutton.h>
 #include <kurlrequester.h>
 #include <kconfig.h>
 
-#include <QFontDatabase>
-#include "imgallerydialog.h"
-
 KIGPDialog::KIGPDialog(QWidget *parent, const QString &path)
     : KPageDialog(parent)
 {
     setStandardButtons(QDialogButtonBox::RestoreDefaults | QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
     buttonBox()->button(QDialogButtonBox::Ok)->setDefault(true);
     setModal(true);
     setFaceType(List);
 
     m_path = path;
     setWindowTitle(i18nc("@title:window", "Create Image Gallery"));
     KGuiItem::assign(buttonBox()->button(QDialogButtonBox::Ok), KGuiItem(i18n("Create"), QStringLiteral("imagegallery")));
     m_config = new KConfig(QStringLiteral("kimgallerypluginrc"), KConfig::NoGlobals);
     setupLookPage(path);
     setupDirectoryPage(path);
     setupThumbnailPage(path);
     connect(buttonBox()->button(QDialogButtonBox::RestoreDefaults), SIGNAL(clicked()), this, SLOT(slotDefault()));
 }
 
 void KIGPDialog::slotDefault()
 {
     m_title->setText(i18n("Image Gallery for %1", m_path));
     m_imagesPerRow->setValue(4);
     m_imageName->setChecked(true);
     m_imageSize->setChecked(false);
     m_imageProperty->setChecked(false);
     m_fontName->setItemText(m_fontName->currentIndex(), QFontDatabase::systemFont(QFontDatabase::GeneralFont).family());
     m_fontSize->setValue(14);
     m_foregroundColor->setColor(QColor(QStringLiteral("#d0ffd0")));
     m_backgroundColor->setColor(QColor(QStringLiteral("#333333")));
 
     m_imageNameReq->setUrl(QUrl::fromLocalFile(m_path + "images.html"));
     m_recurseSubDir->setChecked(false);
     m_recursionLevel->setEnabled(false);
     m_recursionLevel->setValue(0);
     m_copyOriginalFiles->setChecked(false);
     m_useCommentFile->setChecked(false);
     m_commentFileReq->setUrl(QUrl::fromLocalFile(m_path + "comments"));
     m_commentFileReq->setEnabled(false);
 
     m_imageFormat->setItemText(m_imageFormat->currentIndex(), QStringLiteral("JPEG"));
     m_thumbnailSize->setValue(140);
     m_colorDepthSet->setChecked(false);
     m_colorDepth->setItemText(m_colorDepth->currentIndex(), QStringLiteral("8"));
 }
 
 void KIGPDialog::setupLookPage(const QString &path)
 {
     QFrame *page = new QFrame();
     KPageWidgetItem *pageItem = new KPageWidgetItem(page, i18n("Look"));
     pageItem->setHeader(i18n("Page Look"));
     pageItem->setIcon(QIcon::fromTheme("fill-color"));
     addPage(pageItem);
 
     KConfigGroup look = m_config->group("Look");
     QVBoxLayout *vlay = new QVBoxLayout(page);
     vlay->setMargin(0);
 
     QLabel *label = new QLabel(i18n("&Page title:"), page);
     vlay->addWidget(label);
 
     m_title = new QLineEdit(i18n("Image Gallery for %1", path), page);
     vlay->addWidget(m_title);
     label->setBuddy(m_title);
 
     m_imagesPerRow = new KIntNumInput(look.readEntry("ImagesPerRow", 4), page);
     m_imagesPerRow->setRange(1, 8, 1);
     m_imagesPerRow->setSliderEnabled(true);
     m_imagesPerRow->setLabel(i18n("I&mages per row:"));
     vlay->addWidget(m_imagesPerRow);
 
     QGridLayout *grid = new QGridLayout();
     grid->setMargin(2);
     grid->setSpacing(2);
     vlay->addLayout(grid);
 
     m_imageName = new QCheckBox(i18n("Show image file &name"), page);
     m_imageName->setChecked(look.readEntry("ImageName", true));
     grid->addWidget(m_imageName, 0, 0);
 
     m_imageSize = new QCheckBox(i18n("Show image file &size"), page);
     m_imageSize->setChecked(look.readEntry("ImageSize", false));
     grid->addWidget(m_imageSize, 0, 1);
 
     m_imageProperty = new QCheckBox(i18n("Show image &dimensions"), page);
     m_imageProperty->setChecked(look.readEntry("ImageProperty", false));
     grid->addWidget(m_imageProperty, 1, 0);
 
     QHBoxLayout *hlay11  = new QHBoxLayout();
     vlay->addLayout(hlay11);
 
     m_fontName = new QComboBox(page);
     QStringList standardFonts;
     KFontChooser::getFontList(standardFonts, 0);
     m_fontName->addItems(standardFonts);
     m_fontName->setItemText(m_fontName->currentIndex(), look.readEntry("FontName", QFontDatabase::systemFont(QFontDatabase::GeneralFont).family()));
 
     label = new QLabel(i18n("Fon&t name:"), page);
     label->setBuddy(m_fontName);
     hlay11->addWidget(label);
     hlay11->addStretch(1);
     hlay11->addWidget(m_fontName);
 
     QHBoxLayout *hlay12  = new QHBoxLayout();
     vlay->addLayout(hlay12);
 
     m_fontSize = new QSpinBox(page);
     m_fontSize->setMinimum(6);
     m_fontSize->setMaximum(15);
     m_fontSize->setSingleStep(1);
     m_fontSize->setValue(look.readEntry("FontSize", 14));
 
     label = new QLabel(i18n("Font si&ze:"), page);
     label->setBuddy(m_fontSize);
     hlay12->addWidget(label);
     hlay12->addStretch(1);
     hlay12->addWidget(m_fontSize);
 
     QHBoxLayout *hlay1  = new QHBoxLayout();
     vlay->addLayout(hlay1);
 
     m_foregroundColor = new KColorButton(page);
     m_foregroundColor->setColor(QColor(look.readEntry("ForegroundColor", "#d0ffd0")));
 
     label = new QLabel(i18n("&Foreground color:"), page);
     label->setBuddy(m_foregroundColor);
     hlay1->addWidget(label);
     hlay1->addStretch(1);
     hlay1->addWidget(m_foregroundColor);
 
     QHBoxLayout *hlay2 = new QHBoxLayout();
     vlay->addLayout(hlay2);
 
     m_backgroundColor = new KColorButton(page);
     m_backgroundColor->setColor(QColor(look.readEntry("BackgroundColor", "#333333")));
 
     label = new QLabel(i18n("&Background color:"), page);
     hlay2->addWidget(label);
     label->setBuddy(m_backgroundColor);
     hlay2->addStretch(1);
     hlay2->addWidget(m_backgroundColor);
 
     vlay->addStretch(1);
 }
 
 void KIGPDialog::setupDirectoryPage(const QString &path)
 {
     QFrame *page = new QFrame();
     KPageWidgetItem *pageItem = new KPageWidgetItem(page, i18n("Folders"));
     pageItem->setHeader(i18n("Folders"));
     pageItem->setIcon(QIcon("folder"));
     addPage(pageItem);
 
     KConfigGroup group =  m_config->group("Directory");
     QVBoxLayout *dvlay = new QVBoxLayout(page);
     dvlay->setMargin(0);
 
     QLabel *label;
     label = new QLabel(i18n("&Save to HTML file:"), page);
     dvlay->addWidget(label);
     QString whatsThis;
     whatsThis = i18n("<p>The name of the HTML file this gallery will be saved to.</p>");
     label->setWhatsThis(whatsThis);
 
     m_imageNameReq = new KUrlRequester(QUrl::fromLocalFile(QString(path + "images.html")), page);
     label->setBuddy(m_imageNameReq);
     dvlay->addWidget(m_imageNameReq);
     connect(m_imageNameReq, SIGNAL(textChanged(QString)),
             this, SLOT(imageUrlChanged(QString)));
     m_imageNameReq->setWhatsThis(whatsThis);
 
     const bool recurseSubDir = group.readEntry("RecurseSubDirectories", false);
     m_recurseSubDir = new QCheckBox(i18n("&Recurse subfolders"), page);
     m_recurseSubDir->setChecked(recurseSubDir);
     whatsThis = i18n("<p>Whether subfolders should be included for the "
                      "image gallery creation or not.</p>");
     m_recurseSubDir->setWhatsThis(whatsThis);
 
     const int recursionLevel = group.readEntry("RecursionLevel", 0);
     m_recursionLevel = new KIntNumInput(recursionLevel, page);
     m_recursionLevel->setRange(0, 99, 1);
     m_recursionLevel->setSliderEnabled(true);
     m_recursionLevel->setLabel(i18n("Rec&ursion depth:"));
     if (recursionLevel == 0) {
         m_recursionLevel->setSpecialValueText(i18n("Endless"));
     }
     m_recursionLevel->setEnabled(recurseSubDir);
     whatsThis = i18n("<p>You can limit the number of folders the "
                      "image gallery creator will traverse to by setting an "
                      "upper bound for the recursion depth.</p>");
     m_recursionLevel->setWhatsThis(whatsThis);
 
     connect(m_recurseSubDir, SIGNAL(toggled(bool)),
             m_recursionLevel, SLOT(setEnabled(bool)));
 
     dvlay->addWidget(m_recurseSubDir);
     dvlay->addWidget(m_recursionLevel);
 
     m_copyOriginalFiles = new QCheckBox(i18n("Copy or&iginal files"), page);
     m_copyOriginalFiles->setChecked(group.readEntry("CopyOriginalFiles", false));
     dvlay->addWidget(m_copyOriginalFiles);
     whatsThis = i18n("<p>This makes a copy of all images and the gallery will refer "
                      "to these copies instead of the original images.</p>");
     m_copyOriginalFiles->setWhatsThis(whatsThis);
 
     const bool useCommentFile = group.readEntry("UseCommentFile", false);
     m_useCommentFile = new QCheckBox(i18n("Use &comment file"), page);
     m_useCommentFile->setChecked(useCommentFile);
     dvlay->addWidget(m_useCommentFile);
 
     whatsThis = i18n("<p>If you enable this option you can specify "
                      "a comment file which will be used for generating "
                      "subtitles for the images.</p>"
                      "<p>For details about the file format please see "
                      "the \"What's This?\" help below.</p>");
     m_useCommentFile->setWhatsThis(whatsThis);
 
     label = new QLabel(i18n("Comments &file:"), page);
     label->setEnabled(useCommentFile);
     dvlay->addWidget(label);
     whatsThis = i18n("<p>You can specify the name of the comment file here. "
                      "The comment file contains the subtitles for the images. "
                      "The format of this file is:</p>"
                      "<p>FILENAME1:"
                      "<br />Description"
                      "<br />"
                      "<br />FILENAME2:"
                      "<br />Description"
                      "<br />"
                      "<br />and so on</p>");
     label->setWhatsThis(whatsThis);
 
     m_commentFileReq = new KUrlRequester(QUrl::fromLocalFile(QString(path + "comments")), page);
     m_commentFileReq->setEnabled(useCommentFile);
     label->setBuddy(m_commentFileReq);
     dvlay->addWidget(m_commentFileReq);
     m_commentFileReq->setWhatsThis(whatsThis);
 
     connect(m_useCommentFile, SIGNAL(toggled(bool)),
             label, SLOT(setEnabled(bool)));
     connect(m_useCommentFile, SIGNAL(toggled(bool)),
             m_commentFileReq, SLOT(setEnabled(bool)));
 
     dvlay->addStretch(1);
 }
 
 void KIGPDialog::setupThumbnailPage(const QString &path)
 {
     Q_UNUSED(path);
 
     QFrame *page = new QFrame();
     KPageWidgetItem *pageItem = new KPageWidgetItem(page, i18n("Thumbnails"));
     pageItem->setHeader(i18n("Thumbnails"));
     pageItem->setIcon(QIcon::fromTheme("view-preview"));
     addPage(pageItem);
 
     KConfigGroup group =  m_config->group("Thumbnails");
     QLabel *label;
 
     QVBoxLayout *vlay = new QVBoxLayout(page);
     vlay->setMargin(0);
 
     QHBoxLayout *hlay3 = new QHBoxLayout();
     vlay->addLayout(hlay3);
 
     m_imageFormat = new QComboBox(page);
     QStringList lstImgageFormat;
     lstImgageFormat << QStringLiteral("JPEG") << QStringLiteral("PNG");
     m_imageFormat->addItems(lstImgageFormat);
     m_imageFormat->setItemText(m_imageFormat->currentIndex(), group.readEntry("ImageFormat", "JPEG"));
 
     label = new QLabel(i18n("Image format f&or the thumbnails:"), page);
     hlay3->addWidget(label);
     label->setBuddy(m_imageFormat);
     hlay3->addStretch(1);
     hlay3->addWidget(m_imageFormat);
 
     m_thumbnailSize = new KIntNumInput(group.readEntry("ThumbnailSize", 140), page);
     m_thumbnailSize->setRange(10, 1000, 1);
     m_thumbnailSize->setLabel(i18n("Thumbnail size:"));
     m_thumbnailSize->setSliderEnabled(true);
     vlay->addWidget(m_thumbnailSize);
 
     QGridLayout *grid = new QGridLayout();
     grid->setMargin(2);
     grid->setSpacing(2);
     vlay->addLayout(grid);
 
     QHBoxLayout *hlay4 = new QHBoxLayout();
     vlay->addLayout(hlay4);
     const bool colorDepthSet = group.readEntry("ColorDepthSet", false);
     m_colorDepthSet = new QCheckBox(i18n("&Set different color depth:"), page);
     m_colorDepthSet->setChecked(colorDepthSet);
     hlay4->addWidget(m_colorDepthSet);
 
     m_colorDepth = new QComboBox(page);
     QStringList lst;
     lst << QStringLiteral("1") << QStringLiteral("8") << QStringLiteral("16") << QStringLiteral("32");
     m_colorDepth->addItems(lst);
     m_colorDepth->setItemText(m_colorDepth->currentIndex(), group.readEntry("ColorDepth", "8"));
     m_colorDepth->setEnabled(colorDepthSet);
     hlay4->addWidget(m_colorDepth);
 
     connect(m_colorDepthSet, SIGNAL(toggled(bool)),
             m_colorDepth, SLOT(setEnabled(bool)));
 
     vlay->addStretch(1);
 
 }
 
 void KIGPDialog::writeConfig()
 {
     KConfigGroup group = m_config->group("Look");
     group.writeEntry("ImagesPerRow", getImagesPerRow());
     group.writeEntry("ImageName", printImageName());
     group.writeEntry("ImageSize", printImageSize());
     group.writeEntry("ImageProperty", printImageProperty());
     group.writeEntry("FontName", getFontName());
     group.writeEntry("FontSize", getFontSize());
     group.writeEntry("ForegroundColor", getForegroundColor().name());
     group.writeEntry("BackgroundColor", getBackgroundColor().name());
 
     group = m_config->group("Directory");
     group.writeEntry("RecurseSubDirectories", recurseSubDirectories());
     group.writeEntry("RecursionLevel", recursionLevel());
     group.writeEntry("CopyOriginalFiles", copyOriginalFiles());
     group.writeEntry("UseCommentFile", useCommentFile());
 
     group = m_config->group("Thumbnails");
     group.writeEntry("ThumbnailSize", getThumbnailSize());
     group.writeEntry("ColorDepth", getColorDepth());
     group.writeEntry("ColorDepthSet", colorDepthSet());
     group.writeEntry("ImageFormat", getImageFormat());
     group.sync();
 }
 
 KIGPDialog::~KIGPDialog()
 {
     delete m_config;
 }
 
 void KIGPDialog::imageUrlChanged(const QString &url)
 {
     buttonBox()->button(QDialogButtonBox::Ok)->setEnabled(!url.isEmpty());
 }
 
 bool  KIGPDialog::printImageName()  const
 {
     return m_imageName->isChecked();
 }
 
 bool  KIGPDialog::printImageSize() const
 {
     return m_imageSize->isChecked();
 }
 
 bool  KIGPDialog::printImageProperty() const
 {
     return m_imageProperty->isChecked();
 }
 
 bool KIGPDialog::recurseSubDirectories() const
 {
     return m_recurseSubDir->isChecked();
 }
 
 int KIGPDialog::recursionLevel() const
 {
     return m_recursionLevel->value();
 }
 
 bool KIGPDialog::copyOriginalFiles() const
 {
     return m_copyOriginalFiles->isChecked();
 }
 
 bool KIGPDialog::useCommentFile() const
 {
     return m_useCommentFile->isChecked();
 }
 
 int KIGPDialog::getImagesPerRow() const
 {
     return m_imagesPerRow->value();
 }
 
 int KIGPDialog::getThumbnailSize() const
 {
     return m_thumbnailSize->value();
 }
 
 int KIGPDialog::getColorDepth() const
 {
     return m_colorDepth->currentText().toInt();
 }
 
 bool KIGPDialog::colorDepthSet() const
 {
     return m_colorDepthSet->isChecked();
 }
 
 const QString KIGPDialog::getTitle() const
 {
     return m_title->text();
 }
 
 const QUrl KIGPDialog::getImageUrl() const
 {
     return m_imageNameReq->url();
 }
 
 const QString KIGPDialog::getCommentFile() const
 {
     return m_commentFileReq->url().toLocalFile();
 }
 
 const QString KIGPDialog::getFontName() const
 {
     return m_fontName->currentText();
 }
 
 const QString KIGPDialog::getFontSize() const
 {
     return m_fontSize->text();
 }
 
 const QColor KIGPDialog::getBackgroundColor() const
 {
     return m_backgroundColor->color();
 }
 
 const QColor KIGPDialog::getForegroundColor() const
 {
     return m_foregroundColor->color();
 }
 
 const QString KIGPDialog::getImageFormat() const
 {
     return m_imageFormat->currentText();
 }
diff --git a/plugins/kimgalleryplugin/imgalleryplugin.cpp b/plugins/kimgalleryplugin/imgalleryplugin.cpp
index 0d3244535..e9e311e10 100644
--- a/plugins/kimgalleryplugin/imgalleryplugin.cpp
+++ b/plugins/kimgalleryplugin/imgalleryplugin.cpp
@@ -1,540 +1,541 @@
 /* This file is part of the KDE project
 
 Copyright (C) 2001, 2003 Lukas Tinkl <lukas@kde.org>
 Andreas Schlapbach <schlpbch@iam.unibe.ch>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
 */
 
-#include <qdir.h>
-#include <qtextstream.h>
-#include <qfile.h>
-#include <qdatetime.h>
-#include <qpixmap.h>
-#include <qimage.h>
-#include <qtextcodec.h>
+#include "imgalleryplugin.h"
+
+#include <QDir>
+#include <QTextStream>
+#include <QFile>
+#include <QDateTime>
+#include <QPixmap>
+#include <QImage>
+#include <QTextCodec>
 #include <QApplication>
 
 
 #include <kglobal.h>
 #include <KLocalizedString>
 #include <kcharsets.h>
 #include <kmessagebox.h>
 #include <kimageio.h>
 
 #include <kdebug.h>
 #include <kpluginfactory.h>
 #include <kio/netaccess.h>
 #include <QPushButton>
 #include <ktoolinvocation.h>
 #include <QProgressDialog>
 #include <qtextdocument.h>
 #include <kactioncollection.h>
 #include <kparts/part.h>
 
 #include "imgallerydialog.h"
-#include "imgalleryplugin.h"
 
 //KDELibs4Support
 #include <kdeversion.h>
 
 K_PLUGIN_FACTORY(KImGalleryPluginFactory, registerPlugin<KImGalleryPlugin>();)
 
 static QString directory(const QUrl &url) {
     return url.adjusted(QUrl::StripTrailingSlash).adjusted(QUrl::RemoveFilename).toLocalFile();
 }
 
 KImGalleryPlugin::KImGalleryPlugin(QObject *parent, const QVariantList &)
     : KParts::Plugin(parent), m_commentMap(0)
 {
     QAction *a = actionCollection()->addAction(QStringLiteral("create_img_gallery"));
     a->setText(i18n("&Create Image Gallery..."));
     a->setIcon(QIcon::fromTheme(QStringLiteral("imagegallery")));
     actionCollection()->setDefaultShortcut(a, QKeySequence(Qt::CTRL + Qt::Key_I));
     connect(a, SIGNAL(triggered()), this, SLOT(slotExecute()));
 }
 
 void KImGalleryPlugin::slotExecute()
 {
     m_progressDlg = 0L;
     if (!parent()) {
         KMessageBox::sorry(0L, i18n("Could not create the plugin, please report a bug."));
         return;
     }
     m_part = qobject_cast<KParts::ReadOnlyPart *>(parent());
 
     if (!m_part || !m_part->url().isLocalFile()) {  //TODO support remote URLs too?
         KMessageBox::sorry(m_part->widget(), i18n("Creating an image gallery works only on local folders."));
         return;
     }
 
     QString path = m_part->url().adjusted(QUrl::StripTrailingSlash).toLocalFile() + '/';
     m_configDlg = new KIGPDialog(m_part->widget(), path);
 
     if (m_configDlg->exec() == QDialog::Accepted) {
         kDebug(90170) << "dialog is ok";
         m_configDlg->writeConfig();
         m_copyFiles = m_configDlg->copyOriginalFiles();
         m_recurseSubDirectories = m_configDlg->recurseSubDirectories();
         m_useCommentFile = m_configDlg->useCommentFile();
         m_imagesPerRow = m_configDlg->getImagesPerRow();
 
         QUrl url(m_configDlg->getImageUrl());
         if (!url.isEmpty() && url.isValid()) {
             m_progressDlg = new QProgressDialog(m_part->widget());
             QObject::connect(m_progressDlg, SIGNAL(canceled()), this, SLOT(slotCancelled()));
 
             m_progressDlg->setLabelText(i18n("Creating thumbnails"));
             QPushButton *button = new QPushButton(m_progressDlg);
             KGuiItem::assign(button, KStandardGuiItem::cancel());
             m_progressDlg->setCancelButton(button);
             m_cancelled = false;
             m_progressDlg->show();
             if (createHtml(url, m_part->url().path(), m_configDlg->recursionLevel() > 0 ? m_configDlg->recursionLevel() + 1 : 0, m_configDlg->getImageFormat())) {
                 KToolInvocation::invokeBrowser(url.url());  // Open a browser to show the result
             } else {
                 deleteCancelledGallery(url, m_part->url().path(), m_configDlg->recursionLevel() > 0 ? m_configDlg->recursionLevel() + 1 : 0, m_configDlg->getImageFormat());
             }
         }
     }
     delete m_progressDlg;
 }
 
 bool KImGalleryPlugin::createDirectory(const QDir &dir, const QString &imgGalleryDir, const QString &dirName)
 {
     QDir thumb_dir(dir);
 
     if (!thumb_dir.exists()) {
         thumb_dir.setPath(imgGalleryDir);
         if (!(thumb_dir.mkdir(dirName/*, false*/))) {
             KMessageBox::sorry(m_part->widget(), i18n("Could not create folder: %1", thumb_dir.path()));
             return false;
         } else {
             thumb_dir.setPath(imgGalleryDir + '/' + dirName + '/');
             return true;
         }
     } else {
         return true;
     }
 }
 
 void KImGalleryPlugin::createHead(QTextStream &stream)
 {
     const QString chsetName = QTextCodec::codecForLocale()->name();
 
     stream << "<?xml version=\"1.0\" encoding=\"" +  chsetName + "\" ?>" << endl;
     stream << "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd\">" << endl;
     stream << "<html xmlns=\"http://www.w3.org/1999/xhtml\">" << endl;
     stream << "<head>" << endl;
     stream << "<title>" << m_configDlg->getTitle().toHtmlEscaped() << "</title>" << endl;
     stream << "<meta http-equiv=\"content-type\" content=\"text/html; charset=" << chsetName << "\"/>" << endl;
     stream << "<meta name=\"GENERATOR\" content=\"KDE Konqueror KImgallery plugin version " KDE_VERSION_STRING "\"/>" << endl;
     createCSSSection(stream);
     stream << "</head>" << endl;
 }
 
 void KImGalleryPlugin::createCSSSection(QTextStream &stream)
 {
     const QString backgroundColor = m_configDlg->getBackgroundColor().name();
     const QString foregroundColor = m_configDlg->getForegroundColor().name();
     //adding a touch of style
     stream << "<style type='text/css'>\n";
     stream << "BODY {color: " << foregroundColor << "; background: " << backgroundColor << ";" << endl;
     stream << "          font-family: " << m_configDlg->getFontName() << ", sans-serif;" << endl;
     stream << "          font-size: " << m_configDlg->getFontSize() << "pt; margin: 8%; }" << endl;
     stream << "H1       {color: " << foregroundColor << ";}" << endl;
     stream << "TABLE    {text-align: center; margin-left: auto; margin-right: auto;}" << endl;
     stream << "TD       { color: " << foregroundColor << "; padding: 1em}" << endl;
     stream << "IMG      { border: 1px solid " << foregroundColor << "; }" << endl;
     stream << "</style>" << endl;
 }
 
 QString KImGalleryPlugin::extension(const QString &imageFormat)
 {
     if (imageFormat == QLatin1String("PNG")) {
         return QStringLiteral(".png");
     }
     if (imageFormat == QLatin1String("JPEG")) {
         return QStringLiteral(".jpg");
     }
     Q_ASSERT(false);
     return QString();
 }
 
 void KImGalleryPlugin::createBody(QTextStream &stream, const QString &sourceDirName, const QStringList &subDirList,
                                   const QDir &imageDir, const QUrl &url, const QString &imageFormat)
 {
     int numOfImages = imageDir.count();
     const QString imgGalleryDir = directory(url);
     const QString today(KLocale::global()->formatDate(QDate::currentDate()));
 
     stream << "<body>\n<h1>" << m_configDlg->getTitle().toHtmlEscaped() << "</h1><p>" << endl;
     stream << i18n("<i>Number of images</i>: %1", numOfImages) << "<br/>" << endl;
     stream << i18n("<i>Created on</i>: %1", today) << "</p>" << endl;
 
     stream << "<hr/>" << endl;
 
     if (m_recurseSubDirectories && subDirList.count() > 2) { //subDirList.count() is always >= 2 because of the "." and ".." directories
         stream << i18n("<i>Subfolders</i>:") << "<br>" << endl;
         for (QStringList::ConstIterator it = subDirList.constBegin(); it != subDirList.constEnd(); it++) {
             if (*it == QLatin1String(".") || *it == QLatin1String("..")) {
                 continue;    //disregard the "." and ".." directories
             }
             stream << "<a href=\"" << *it << "/" << url.fileName()
                    << "\">" << *it << "</a><br>" << endl;
         }
         stream << "<hr/>" << endl;
     }
 
     stream << "<table>" << endl;
 
     //table with images
     int imgIndex;
     QFileInfo imginfo;
     QPixmap  imgProp;
     for (imgIndex = 0; !m_cancelled && (imgIndex < numOfImages);) {
         stream << "<tr>" << endl;
 
         for (int col = 0; !m_cancelled && (col < m_imagesPerRow) && (imgIndex < numOfImages); col++) {
             const QString imgName = imageDir[imgIndex];
 
             if (m_copyFiles) {
                 stream << "<td align='center'>\n<a href=\"images/" << imgName << "\">";
             } else {
                 stream << "<td align='center'>\n<a href=\"" << imgName << "\">";
             }
 
             if (createThumb(imgName, sourceDirName, imgGalleryDir, imageFormat)) {
                 const QString imgPath("thumbs/" + imgName + extension(imageFormat));
                 stream << "<img src=\"" << imgPath << "\" width=\"" << m_imgWidth << "\" ";
                 stream << "height=\"" << m_imgHeight << "\" alt=\"" << imgPath << "\"/>";
                 m_progressDlg->setLabelText(i18n("Created thumbnail for: \n%1", imgName));
             } else {
                 kDebug(90170) << "Creating thumbnail for " << imgName << " failed";
                 m_progressDlg->setLabelText(i18n("Creating thumbnail for: \n%1\n failed", imgName));
             }
             stream << "</a>" << endl;
 
             if (m_configDlg->printImageName()) {
                 stream << "<div>" << imgName << "</div>" << endl;
             }
 
             if (m_configDlg->printImageProperty()) {
 #ifdef __GNUC__
 #warning "kde4: verify it : imageDir.absoluteFilePath(imgName,true)";
 #endif
                 imgProp.load(imageDir.absoluteFilePath(imgName));
                 stream << "<div>" << imgProp.width() << " x " << imgProp.height() << "</div>" << endl;
             }
 
             if (m_configDlg->printImageSize()) {
                 imginfo.setFile(imageDir, imgName);
                 stream << "<div>(" << (imginfo.size() / 1024) << " " <<  i18n("KiB") << ")" << "</div>" << endl;
             }
 
             if (m_useCommentFile) {
                 QString imgComment = (*m_commentMap)[imgName];
                 stream << "<div>" << imgComment.toHtmlEscaped() << "</div>" << endl;
             }
             stream << "</td>" << endl;
 
             m_progressDlg->setMaximum(numOfImages);
             m_progressDlg->setValue(imgIndex);
             qApp->processEvents();
             imgIndex++;
         }
         stream << "</tr>" << endl;
     }
     //close the HTML
     stream << "</table>\n</body>\n</html>" << endl;
 }
 
 bool KImGalleryPlugin::createHtml(const QUrl &url, const QString &sourceDirName, int recursionLevel, const QString &imageFormat)
 {
     if (m_cancelled) {
         return false;
     }
 
     if (!parent() || !parent()->inherits("DolphinPart")) {
         return false;
     }
 
     QStringList subDirList;
     if (m_recurseSubDirectories && (recursionLevel >= 0)) { //recursionLevel == 0 means endless
         QDir toplevel_dir = QDir(sourceDirName);
         toplevel_dir.setFilter(QDir::Dirs | QDir::Readable | QDir::Writable);
         subDirList = toplevel_dir.entryList();
 
         for (QStringList::ConstIterator it = subDirList.constBegin(); it != subDirList.constEnd() && !m_cancelled; it++) {
             const QString currentDir = *it;
             if (currentDir == QLatin1String(".") || currentDir == QLatin1String("..")) {
                 continue;   //disregard the "." and ".." directories
             }
             QDir subDir = QDir(directory(url) + '/' + currentDir);
             if (!subDir.exists()) {
                 subDir.setPath(directory(url));
                 if (!(subDir.mkdir(currentDir/*, false*/))) {
                     KMessageBox::sorry(m_part->widget(), i18n("Could not create folder: %1", subDir.path()));
                     continue;
                 } else {
                     subDir.setPath(directory(url) + '/' + currentDir);
                 }
             }
             if (!createHtml(QUrl::fromLocalFile(subDir.path() + '/' + url.fileName()), sourceDirName + '/' + currentDir,
                             recursionLevel > 1 ? recursionLevel - 1 : 0, imageFormat)) {
                 return false;
             }
         }
     }
 
     if (m_useCommentFile) {
         loadCommentFile();
     }
 
     kDebug(90170) << "sourceDirName: " << sourceDirName;
     //We're interested in only the patterns, so look for the first |
     //#### perhaps an accessor should be added to KImageIO instead?
     QString filter = KImageIO::pattern(KImageIO::Reading).section('|', 0, 0);
 
     QDir imageDir(sourceDirName, filter.toLatin1(),
                   QDir::Name | QDir::IgnoreCase, QDir::Files | QDir::Readable);
 
     const QString imgGalleryDir = directory(url);
     kDebug(90170) << "imgGalleryDir: " << imgGalleryDir;
 
     // Create the "thumbs" subdirectory if necessary
     QDir thumb_dir(imgGalleryDir + QLatin1String("/thumbs/"));
     if (createDirectory(thumb_dir, imgGalleryDir, QStringLiteral("thumbs")) == false) {
         return false;
     }
 
     // Create the "images" subdirectory if necessary
     QDir images_dir(imgGalleryDir + QLatin1String("/images/"));
     if (m_copyFiles) {
         if (createDirectory(images_dir, imgGalleryDir, QStringLiteral("images")) == false) {
             return false;
         }
     }
 
     QFile file(url.path());
     kDebug(90170) << "url.path(): " << url.path() << ", thumb_dir: " << thumb_dir.path()
                   << ", imageDir: " << imageDir.path() << endl;
 
     if (imageDir.exists() && file.open(QIODevice::WriteOnly)) {
         QTextStream stream(&file);
         stream.setCodec(QTextCodec::codecForLocale());
 
         createHead(stream);
         createBody(stream, sourceDirName, subDirList, imageDir, url, imageFormat); //ugly
 
         file.close();
 
         return !m_cancelled;
 
     } else {
         QString path = url.toLocalFile();
         if (!path.endsWith("/")) {
             path += '/';
         }
         KMessageBox::sorry(m_part->widget(), i18n("Could not open file: %1", path));
         return false;
     }
 }
 
 void KImGalleryPlugin::deleteCancelledGallery(const QUrl &url, const QString &sourceDirName, int recursionLevel, const QString &imageFormat)
 {
     if (m_recurseSubDirectories && (recursionLevel >= 0)) {
         QStringList subDirList;
         QDir toplevel_dir = QDir(sourceDirName);
         toplevel_dir.setFilter(QDir::Dirs);
         subDirList = toplevel_dir.entryList();
 
         for (QStringList::ConstIterator it = subDirList.constBegin(); it != subDirList.constEnd(); it++) {
             if (*it == QLatin1String(".") || *it == QLatin1String("..") || *it == QLatin1String("thumbs") || (m_copyFiles && *it == QLatin1String("images"))) {
                 continue; //disregard the "." and ".." directories
             }
             deleteCancelledGallery(QUrl::fromLocalFile(directory(url) + '/' + *it + '/' + url.fileName()),
                                    sourceDirName + '/' + *it,
                                    recursionLevel > 1 ? recursionLevel - 1 : 0, imageFormat);
         }
     }
 
     const QString imgGalleryDir = directory(url);
     QDir thumb_dir(imgGalleryDir + QLatin1String("/thumbs/"));
     QDir images_dir(imgGalleryDir + QLatin1String("/images/"));
     QDir imageDir(sourceDirName, QStringLiteral("*.png *.PNG *.gif *.GIF *.jpg *.JPG *.jpeg *.JPEG *.bmp *.BMP"),
                   QDir::Name | QDir::IgnoreCase, QDir::Files | QDir::Readable);
     QFile file(url.path());
 
     // Remove the image file ..
     file.remove();
     // ..all the thumbnails ..
     for (uint i = 0; i < imageDir.count(); i++) {
         const QString imgName = imageDir[i];
         const QString imgNameFormat = imgName + extension(imageFormat);
         bool isRemoved = thumb_dir.remove(imgNameFormat);
         kDebug(90170) << "removing: " << thumb_dir.path() << "/" << imgNameFormat << "; " << isRemoved;
     }
     // ..and the thumb directory
     thumb_dir.rmdir(thumb_dir.path());
 
     // ..and the images directory if images were to be copied
     if (m_copyFiles) {
         for (uint i = 0; i < imageDir.count(); i++) {
             const QString imgName = imageDir[i];
             bool isRemoved = images_dir.remove(imgName);
             kDebug(90170) << "removing: " << images_dir.path() << "/" << imgName << "; " << isRemoved;
         }
         images_dir.rmdir(images_dir.path());
     }
 }
 
 void KImGalleryPlugin::loadCommentFile()
 {
     QFile file(m_configDlg->getCommentFile());
     if (file.open(QIODevice::ReadOnly)) {
         kDebug(90170) << "File opened.";
 
         QTextStream *m_textStream = new QTextStream(&file);
         m_textStream->setCodec(QTextCodec::codecForLocale());
 
         delete m_commentMap;
         m_commentMap = new CommentMap;
 
         QString picName, picComment, curLine, curLineStripped;
         while (!m_textStream->atEnd()) {
             curLine = m_textStream->readLine();
             curLineStripped = curLine.trimmed();
             // Lines starting with '#' are comment
             if (!(curLineStripped.isEmpty()) && !curLineStripped.startsWith(QLatin1String("#"))) {
                 if (curLineStripped.endsWith(QLatin1String(":"))) {
                     picComment.clear();
                     picName = curLineStripped.left(curLineStripped.length() - 1);
                     kDebug(90170) << "picName: " << picName;
                 } else {
                     do {
                         //kDebug(90170) << "picComment";
                         picComment += curLine + '\n';
                         curLine = m_textStream->readLine();
                     } while (!m_textStream->atEnd() && !(curLine.trimmed().isEmpty()) &&
                              !curLine.trimmed().startsWith(QLatin1String("#")));
                     //kDebug(90170) << "Pic comment: " << picComment;
                     m_commentMap->insert(picName, picComment);
                 }
             }
         }
         CommentMap::ConstIterator it;
         for (it = m_commentMap->constBegin(); it != m_commentMap->constEnd(); ++it) {
             kDebug(90170) << "picName: " << it.key() << ", picComment: " << it.value();
         }
         file.close();
         kDebug(90170) << "File closed.";
         delete m_textStream;
     } else {
         KMessageBox::sorry(m_part->widget(), i18n("Could not open file: %1", m_configDlg->getCommentFile()));
         m_useCommentFile = false;
     }
 }
 
 bool KImGalleryPlugin::createThumb(const QString &imgName, const QString &sourceDirName,
                                    const QString &imgGalleryDir, const QString &imageFormat)
 {
     QImage img;
     const QString pixPath = sourceDirName + QLatin1String("/") + imgName;
 
     if (m_copyFiles) {
         QUrl srcURL = QUrl::fromLocalFile(pixPath);
         //kDebug(90170) << "srcURL: " << srcURL;
         QUrl destURL = QUrl::fromLocalFile(imgGalleryDir + QLatin1String("/images/") + imgName);
         //kDebug(90170) << "destURL: " << destURL;
         KIO::NetAccess::file_copy(srcURL, destURL, static_cast<KParts::Part *>(parent())->widget());
     }
 
     const QString imgNameFormat = imgName + extension(imageFormat);
     const QString thumbDir = imgGalleryDir + QLatin1String("/thumbs/");
     int extent = m_configDlg->getThumbnailSize();
 
     // this code is stolen from kdebase/kioslave/thumbnail/imagecreator.cpp
     // (c) 2000 gis and malte
 
     m_imgWidth = 120; // Setting the size of the images is
     m_imgHeight = 90; // required to generate faster 'loading' pages
     if (img.load(pixPath)) {
         int w = img.width(), h = img.height();
         // scale to pixie size
         // kDebug(90170) << "w: " << w << " h: " << h;
         // Resizing if to big
         if (w > extent || h > extent) {
             if (w > h) {
                 h = (int)((double)(h * extent) / w);
                 if (h == 0) {
                     h = 1;
                 }
                 w = extent;
                 Q_ASSERT(h <= extent);
             } else {
                 w = (int)((double)(w * extent) / h);
                 if (w == 0) {
                     w = 1;
                 }
                 h = extent;
                 Q_ASSERT(w <= extent);
             }
             const QImage scaleImg(img.scaled(w, h, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
             if (scaleImg.width() != w || scaleImg.height() != h) {
                 kDebug(90170) << "Resizing failed. Aborting.";
                 return false;
             }
             img = scaleImg;
             if (m_configDlg->colorDepthSet() == true) {
                 QImage::Format format;
                 switch (m_configDlg->getColorDepth()) {
                 case 1:
                     format = QImage::Format_Mono;
                     break;
                 case 8:
                     format = QImage::Format_Indexed8;
                     break;
                 case 16:
                     format = QImage::Format_RGB16;
                     break;
                 case 32:
                 default:
                     format = QImage::Format_RGB32;
                     break;
                 }
 
                 const QImage depthImg(img.convertToFormat(format));
                 img = depthImg;
             }
         }
         kDebug(90170) << "Saving thumbnail to: " << thumbDir + imgNameFormat;
         if (!img.save(thumbDir + imgNameFormat, imageFormat.toLatin1())) {
             kDebug(90170) << "Saving failed. Aborting.";
             return false;
         }
         m_imgWidth = w;
         m_imgHeight = h;
         return true;
     }
     return false;
 }
 
 void KImGalleryPlugin::slotCancelled()
 {
     m_cancelled = true;
 }
 
 #include "imgalleryplugin.moc"
diff --git a/plugins/microformat/pluginbase.cpp b/plugins/microformat/pluginbase.cpp
index b5bbda0ff..d71c6ba45 100644
--- a/plugins/microformat/pluginbase.cpp
+++ b/plugins/microformat/pluginbase.cpp
@@ -1,43 +1,43 @@
 /*
     Copyright (C) 2004 Teemu Rytilahti <tpr@d5k.net>
     Copyright (C) 2005 George Staikos <staikos@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.
 
     As a special exception, permission is given to link this program
     with any edition of Qt, and distribute the resulting executable,
     without including the source code for Qt in the source distribution.
 */
+#include "pluginbase.h"
+
 #include <QDBusInterface>
 #include <klocale.h>
 
-#include "pluginbase.h"
-
 #include <kdebug.h>
 
 PluginBase::PluginBase()
 {
 }
 
 PluginBase::~PluginBase()
 {
 }
 
 void PluginBase::addVCardViaDCOP(const QString &card)
 {
     QDBusInterface kaddressbook("org.kde.kaddressbook", "/AddressBookService", "org.kde.adressbook.service");
     kaddressbook.call("importVCardFromData", card);
 }
 
diff --git a/plugins/minitools/minitoolsplugin.cpp b/plugins/minitools/minitoolsplugin.cpp
index 2f15575e1..de864dc1e 100644
--- a/plugins/minitools/minitoolsplugin.cpp
+++ b/plugins/minitools/minitoolsplugin.cpp
@@ -1,170 +1,169 @@
 /*
     Copyright (c) 2003 Alexander Kellett <lypanov@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 (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.
 */
 
-#include <qfile.h>
-
+#include "minitoolsplugin.h"
 #include "minitoolsplugindebug.h"
 
+#include <QFile>
+
 #include <kglobal.h>
 #include <kconfig.h>
 #include <kcomponentdata.h>
 #include <khtml_part.h>
 #include <kpluginfactory.h>
 
 #include <kstandarddirs.h>
 
-#include <krun.h>
 #include <kservice.h>
 #include <kactionmenu.h>
 #include <QMenu>
 #include <kbookmarkimporter.h>
 #include <kbookmarkmanager.h>
 #include <kactioncollection.h>
-#include "minitoolsplugin.h"
 
 K_PLUGIN_FACTORY(MinitoolsPluginFactory, registerPlugin<MinitoolsPlugin>();)
 
 MinitoolsPlugin::MinitoolsPlugin(QObject *parent, const QVariantList &)
     : KParts::Plugin(parent)
 {
     m_part = (parent && parent->inherits("KHTMLPart")) ? static_cast<KHTMLPart *>(parent) : 0L;
 
     m_pMinitoolsMenu = new KActionMenu(QIcon::fromTheme(QStringLiteral("minitools")), i18n("&Minitools"), actionCollection());
     actionCollection()->addAction(QStringLiteral("minitools"), m_pMinitoolsMenu);
 
     m_pMinitoolsMenu->setDelayed(false);
     m_pMinitoolsMenu->setEnabled(true);
 
     connect(m_pMinitoolsMenu->menu(), SIGNAL(aboutToShow()),
             this, SLOT(slotAboutToShow()));
 }
 
 MinitoolsPlugin::~MinitoolsPlugin()
 {
     ;
 }
 
 void MinitoolsPlugin::slotAboutToShow()
 {
 
     m_minitoolsList.clear();
     KXBELBookmarkImporterImpl importer;
     connect(&importer, SIGNAL(newBookmark(QString,QString,QString)),
             SLOT(newBookmarkCallback(QString,QString,QString)));
     connect(&importer, SIGNAL(endFolder()),
             SLOT(endFolderCallback()));
     QString filename = minitoolsFilename(true);
     if (!filename.isEmpty() && QFile::exists(filename)) {
         importer.setFilename(filename);
         importer.parse();
     }
     filename = minitoolsFilename(false);
     if (!filename.isEmpty() && QFile::exists(filename)) {
         importer.setFilename(filename);
         importer.parse();
     }
 
     m_pMinitoolsMenu->menu()->clear();
 
     int count = m_pMinitoolsMenu->menu()->actions().count(); // why not 0???
     bool gotSep = true; // don't start with a sep
 
     if (m_minitoolsList.count() > 0) {
         MinitoolsList::ConstIterator e = m_minitoolsList.constBegin();
         for (; e != m_minitoolsList.constEnd(); ++e) {
             if (((*e).first  == QLatin1String("-"))
                     && ((*e).second == QLatin1String("-"))
                ) {
                 if (!gotSep) {
                     m_pMinitoolsMenu->menu()->addSeparator();
                 }
                 gotSep = true;
                 count++;
             } else {
                 QString str = (*e).first;
                 // emsquieezzy thingy?
                 if (str.length() > 48) {
                     str.truncate(48);
                     str.append("...");
                 }
                 QAction *action = m_pMinitoolsMenu->menu()->addAction(
                                       str, this,
                                       SLOT(slotItemSelected()));
                 action->setData(qVariantFromValue(++count));
                 gotSep = false;
             }
         }
     }
 
     if (!gotSep) {
         // don't have an extra sep
         m_pMinitoolsMenu->menu()->addSeparator();
     }
 
     m_pMinitoolsMenu->menu()
     ->addAction(i18n("&Edit Minitools"),
                 this, SLOT(slotEditBookmarks()));
 }
 
 void MinitoolsPlugin::newBookmarkCallback(
     const QString &text, const QString &url, const QString &
 )
 {
     qCDebug(MINITOOLSPLUGIN_LOG) << "MinitoolsPlugin::newBookmarkCallback" << text << url;
     m_minitoolsList.prepend(qMakePair(text, url));
 }
 
 void MinitoolsPlugin::endFolderCallback()
 {
     qCDebug(MINITOOLSPLUGIN_LOG) << "MinitoolsPlugin::endFolderCallback";
     m_minitoolsList.prepend(qMakePair(QStringLiteral("-"), QStringLiteral("-")));
 }
 
 QString MinitoolsPlugin::minitoolsFilename(bool local)
 {
     return local ? KStandardDirs::locateLocal("data", QStringLiteral("konqueror/minitools.xml"))
            : KStandardDirs::locateLocal("data", QStringLiteral("konqueror/minitools-global.xml"));
 }
 
 void MinitoolsPlugin::slotEditBookmarks()
 {
     KBookmarkManager *manager = KBookmarkManager::managerForFile(minitoolsFilename(true), QStringLiteral("minitools"));
     manager->slotEditBookmarks();
 }
 
 void MinitoolsPlugin::slotItemSelected()
 {
     bool ok = false;
     int id = sender() ? qobject_cast<QAction *>(sender())->data().toInt(&ok) : 0;
     if (!ok) {
         return;
     }
     if (m_minitoolsList.count() == 0) {
         return;
     }
     QString tmp = m_minitoolsList[id - 1].second;
     QString script = QUrl::fromPercentEncoding(tmp.right(tmp.length() - 11).toLatin1()); // sizeof("javascript:")
     connect(this, SIGNAL(executeScript(QString)),
             m_part, SLOT(executeScript(QString)));
     emit executeScript(script);
     disconnect(this, SIGNAL(executeScript(QString)), 0, 0);
 }
 
 #include "minitoolsplugin.moc"
diff --git a/plugins/rellinks/plugin_rellinks.cpp b/plugins/rellinks/plugin_rellinks.cpp
index 639492b02..e9e1456e4 100644
--- a/plugins/rellinks/plugin_rellinks.cpp
+++ b/plugins/rellinks/plugin_rellinks.cpp
@@ -1,642 +1,642 @@
 /***************************************************************************
  *   Copyright (C) 2002, Anders Lund <anders@alweb.dk>                     *
  *   Copyright (C) 2003, 2004, Franck Quélain <shift@free.fr>              *
  *   Copyright (C) 2004, Kevin Krammer <kevin.krammer@gmx.at>              *
  *   Copyright (C) 2004, 2006, Olivier Goffart <ogoffart @ 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.             *
  ***************************************************************************/
 
+// local includes
+#include "plugin_rellinks.h"
+
 // Qt includes
-#include <qapplication.h>
-#include <qtimer.h>
+#include <QApplication>
+#include <QTimer>
 #include <QKeySequence>
 #include <QActionGroup>
 
 // KDE include
 #include <dom/dom_doc.h>
 #include <dom/dom_element.h>
 #include <dom/dom_string.h>
 #include <dom/html_document.h>
 
 #include <kdebug.h>
 #include <kpluginfactory.h>
 #include <khtml_part.h>
 #include <khtmlview.h>
 #include <kiconloader.h>
 #include <kcomponentdata.h>
 #include <KLocalizedString>
 #include <QMenu>
 #include <ktoolbar.h>
 #include <kactionmenu.h>
 #include <kactioncollection.h>
-// local includes
-#include "plugin_rellinks.h"
-
 
 /** Rellinks factory */
 K_PLUGIN_FACTORY(RelLinksFactory, registerPlugin<RelLinksPlugin>();)
 #include <kaboutdata.h>
 
 static QUrl resolvedUrl(const QUrl &base, const QString& rel) {
     return QUrl(base).resolved(QUrl(rel));
 }
 
 Q_DECLARE_METATYPE(DOM::Element);
 
 /** Constructor of the plugin. */
 RelLinksPlugin::RelLinksPlugin(QObject *parent, const QVariantList &)
     : KParts::Plugin(parent),
       m_part(0),
       m_viewVisible(false),
       m_linksFound(false)
 {
     setComponentData(KAboutData(QStringLiteral("rellinks"), i18n("Rellinks"), QStringLiteral("1.0")));
 
     QActionGroup *grp = new QActionGroup(this);
     connect(grp, SIGNAL(triggered(QAction*)), this, SLOT(actionTriggered(QAction*)));
 
     QAction *a;
     // ------------- Navigation links --------------
     a =  actionCollection()->addAction(QStringLiteral("rellinks_home"));
     a->setText(i18n("&Top"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-top")));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+T")));
     a->setWhatsThis(i18n("<p>This link references a home page or the top of some hierarchy.</p>"));
     grp->addAction(a);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_up"));
     a->setText(i18n("&Up"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+U")));
     a->setWhatsThis(i18n("<p>This link references the immediate parent of the current document.</p>"));
     grp->addAction(a);
 
     bool isRTL = QApplication::isRightToLeft();
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_begin"));
     a->setText(i18n("&First"));
     a->setIcon(QIcon::fromTheme(isRTL ? "go-last" : "go-first"));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+F")));
     a->setWhatsThis(i18n("<p>This link type tells search engines which document is considered by the author to be the starting point of the collection.</p>"));
     grp->addAction(a);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_prev"));
     a->setText(i18n("&Previous"));
     a->setIcon(QIcon::fromTheme(isRTL ? "go-next" : "go-previous"));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+P")));
     a->setWhatsThis(i18n("<p>This link references the previous document in an ordered series of documents.</p>"));
     grp->addAction(a);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_next"));
     a->setText(i18n("&Next"));
     a->setIcon(QIcon::fromTheme(isRTL ? "go-previous" : "go-next"));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+N")));
     a->setWhatsThis(i18n("<p>This link references the next document in an ordered series of documents.</p>"));
     grp->addAction(a);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_last"));
     a->setText(i18n("&Last"));
     a->setIcon(QIcon::fromTheme(isRTL ? "go-first" : "go-last"));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+L")));
     a->setWhatsThis(i18n("<p>This link references the end of a sequence of documents.</p>"));
     grp->addAction(a);
 
     // ------------ special items --------------------------
     a = actionCollection()->addAction(QStringLiteral("rellinks_search"));
     a->setText(i18n("&Search"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("edit-find")));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+S")));
     a->setWhatsThis(i18n("<p>This link references the search.</p>"));
     grp->addAction(a);
 
     // ------------ Document structure links ---------------
     m_document = new KActionMenu(QIcon::fromTheme(QStringLiteral("go-jump")), i18n("Document"), actionCollection());
     actionCollection()->addAction(QStringLiteral("rellinks_document"), m_document);
     m_document->setWhatsThis(i18n("<p>This menu contains the links referring the document information.</p>"));
     m_document->setDelayed(false);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_contents"));
     a->setText(i18n("Table of &Contents"));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+C")));
     a->setWhatsThis(i18n("<p>This link references the table of contents.</p>"));
     m_document->addAction(a);
     grp->addAction(a);
 
     kactionmenu_map[QStringLiteral("chapter")] = new KActionMenu(i18n("Chapters"), actionCollection());
     actionCollection()->addAction(QStringLiteral("rellinks_chapters"), kactionmenu_map[QStringLiteral("chapter") ]);
 
     m_document->addAction(kactionmenu_map[QStringLiteral("chapter")]);
     connect(kactionmenu_map[QStringLiteral("chapter")]->menu(), &QMenu::triggered, this, &RelLinksPlugin::actionTriggered);
     kactionmenu_map[QStringLiteral("chapter")]->setWhatsThis(i18n("<p>This menu references the chapters of the document.</p>"));
     kactionmenu_map[QStringLiteral("chapter")]->setDelayed(false);
 
     kactionmenu_map[QStringLiteral("section")] = new KActionMenu(i18n("Sections"), actionCollection());
     actionCollection()->addAction(QStringLiteral("rellinks_sections"), kactionmenu_map[QStringLiteral("section")]);
 
     m_document->addAction(kactionmenu_map[QStringLiteral("section")]);
 
     connect(kactionmenu_map[QStringLiteral("section")]->menu(), &QMenu::triggered, this, &RelLinksPlugin::actionTriggered);
     kactionmenu_map[QStringLiteral("section")]->setWhatsThis(i18n("<p>This menu references the sections of the document.</p>"));
     kactionmenu_map[QStringLiteral("section")]->setDelayed(false);
 
     kactionmenu_map[QStringLiteral("subsection")] = new KActionMenu(i18n("Subsections"), actionCollection());
     m_document->addAction(kactionmenu_map[QStringLiteral("subsection")]);
     actionCollection()->addAction(QStringLiteral("rellinks_subsections"), kactionmenu_map[QStringLiteral("subsection")]);
 
     connect(kactionmenu_map[QStringLiteral("subsection")]->menu(), &QMenu::triggered, this, &RelLinksPlugin::actionTriggered);
     kactionmenu_map[QStringLiteral("subsection")]->setWhatsThis(i18n("<p>This menu references the subsections of the document.</p>"));
     kactionmenu_map[QStringLiteral("subsection")]->setDelayed(false);
 
     kactionmenu_map[QStringLiteral("appendix")] = new KActionMenu(i18n("Appendix"), actionCollection());
     actionCollection()->addAction(QStringLiteral("rellinks_appendix"), kactionmenu_map[QStringLiteral("appendix")]);
 
     m_document->addAction(kactionmenu_map[QStringLiteral("appendix")]);
     connect(kactionmenu_map[QStringLiteral("appendix")]->menu(), &QMenu::triggered, this, &RelLinksPlugin::actionTriggered);
     kactionmenu_map[QStringLiteral("appendix")]->setWhatsThis(i18n("<p>This link references the appendix.</p>"));
     kactionmenu_map[QStringLiteral("appendix")]->setDelayed(false);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_glossary"));
     a->setText(i18n("&Glossary"));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+G")));
     a->setWhatsThis(i18n("<p>This link references the glossary.</p>"));
     m_document->addAction(a);
     grp->addAction(a);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_index"));
     a->setText(i18n("&Index"));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+I")));
     a->setWhatsThis(i18n("<p>This link references the index.</p>"));
     m_document->addAction(a);
     grp->addAction(a);
 
     // Other links
     m_more  = new KActionMenu(i18n("More"), actionCollection());
     actionCollection()->addAction(QStringLiteral("rellinks_more"), m_more);
     m_more->setWhatsThis(i18n("<p>This menu contains other important links.</p>"));
     m_more->setDelayed(false);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_help"));
     a->setText(i18n("&Help"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("help-contents")));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+H")));
     a->setWhatsThis(i18n("<p>This link references the help.</p>"));
     m_more->addAction(a);
     grp->addAction(a);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_author"));
     a->setText(i18n("&Authors"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("x-office-contact")));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+A")));
     a->setWhatsThis(i18n("<p>This link references the author.</p>"));
     m_more->addAction(a);
     grp->addAction(a);
 
     a = actionCollection()->addAction(QStringLiteral("rellinks_copyright"));
     a->setText(i18n("Copy&right"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("help-about")));
     actionCollection()->setDefaultShortcut(a, QKeySequence(QStringLiteral("Ctrl+Alt+R")));
     a->setWhatsThis(i18n("<p>This link references the copyright.</p>"));
     m_more->addAction(a);
     grp->addAction(a);
 
     kactionmenu_map[QStringLiteral("bookmark")] = new KActionMenu(QIcon::fromTheme(QStringLiteral("bookmarks")), i18n("Bookmarks"), actionCollection());
     actionCollection()->addAction(QStringLiteral("rellinks_bookmarks"), kactionmenu_map[QStringLiteral("bookmark")]);
     m_more->addAction(kactionmenu_map[QStringLiteral("bookmark")]);
     kactionmenu_map[QStringLiteral("bookmark")]->setWhatsThis(i18n("<p>This menu references the bookmarks.</p>"));
     connect(kactionmenu_map[QStringLiteral("bookmark")]->menu(), &QMenu::triggered, this, &RelLinksPlugin::actionTriggered);
     kactionmenu_map[QStringLiteral("bookmark")]->setDelayed(false);
 
     kactionmenu_map[QStringLiteral("alternate")] = new KActionMenu(i18n("Other Versions"), actionCollection());
     actionCollection()->addAction(QStringLiteral("rellinks_other_versions"), kactionmenu_map[QStringLiteral("alternate")]);
     m_more->addAction(kactionmenu_map[QStringLiteral("alternate")]);
     kactionmenu_map[QStringLiteral("alternate")]->setWhatsThis(i18n("<p>This link references the alternate versions of this document.</p>"));
     connect(kactionmenu_map[QStringLiteral("alternate")]->menu(), &QMenu::triggered, this, &RelLinksPlugin::actionTriggered);
     kactionmenu_map[QStringLiteral("alternate")]->setDelayed(false);
 
     // Unclassified menu
     m_links = new KActionMenu(QIcon::fromTheme(QStringLiteral("rellinks")), i18n("Miscellaneous"), actionCollection());
     actionCollection()->addAction(QStringLiteral("rellinks_links"), m_links);
     kactionmenu_map[QStringLiteral("unclassified")] = m_links;
     kactionmenu_map[QStringLiteral("unclassified")]->setWhatsThis(i18n("<p>Miscellaneous links.</p>"));
     connect(kactionmenu_map[QStringLiteral("unclassified")]->menu(), &QMenu::triggered, this, &RelLinksPlugin::actionTriggered);
     kactionmenu_map[QStringLiteral("unclassified")]->setDelayed(false);
 
     // We unactivate all the possible actions
     disableAll();
 
     // When the rendering of the HTML is done, we update the site navigation bar
     m_part = qobject_cast<KHTMLPart *>(parent);
     if (!m_part) {
         return;
     }
 
     connect(m_part, SIGNAL(docCreated()), this, SLOT(newDocument()));
     connect(m_part, SIGNAL(completed()), this, SLOT(loadingFinished()));
 
     // create polling timer and connect it
     m_pollTimer = new QTimer(this);
     m_pollTimer->setObjectName(QStringLiteral("polling timer"));
     connect(m_pollTimer, &QTimer::timeout, this, &RelLinksPlugin::updateToolbar);
 
     // delay access to our part's members until it has finished its initialisation
     QTimer::singleShot(0, this, SLOT(delayedSetup()));
 
 }
 
 /** Destructor */
 RelLinksPlugin::~RelLinksPlugin()
 {
 }
 
 bool RelLinksPlugin::eventFilter(QObject *watched, QEvent *event)
 {
     if (m_part == 0) {
         return false;
     }
 
     if (watched == 0 || event == 0) {
         return false;
     }
 
     if (watched == m_view) {
         switch (event->type()) {
         case QEvent::Show:
             m_viewVisible = true;
             updateToolbar();
             break;
 
         case QEvent::Hide:
             m_viewVisible = false;
             updateToolbar();
             break;
 
         case QEvent::Close:
             m_pollTimer->stop();
             m_view->removeEventFilter(this);
             break;
 
         default:
             break;
         }
     }
 
     // we never filter an event, we just want to know about it
     return false;
 }
 
 void RelLinksPlugin::delayedSetup()
 {
     if (m_part == 0) {
         return;
     }
 
     m_view = m_part->view();
     m_view->installEventFilter(this);
     m_viewVisible = m_view->isVisible();
 }
 
 void RelLinksPlugin::newDocument()
 {
     // start calling upateToolbar periodically to get the new links as soon as possible
 
     m_pollTimer->start(500);
     //kDebug(90210) << "newDocument()";
 
     updateToolbar();
 }
 
 void RelLinksPlugin::loadingFinished()
 {
     m_pollTimer->stop();
     //kDebug(90210) << "loadingFinished()";
     updateToolbar();
     guessRelations();
 }
 
 /* Update the site navigation bar */
 void RelLinksPlugin::updateToolbar()
 {
 
     // If we have a part
     if (!m_part) {
         return;
     }
 
     // We disable all
     disableAll();
 
     // get a list of LINK nodes in document
     DOM::NodeList linkNodes = m_part->document().getElementsByTagName("link");
 
     //kDebug(90210) << "Rellinks: Link nodes =" << linkNodes.length();
 
     bool showBar = false;
     unsigned long nodeLength = linkNodes.length();
     m_linksFound = nodeLength > 0;
 
     for (unsigned int i = 0; i < nodeLength; i++) {
         // create a entry for each one
         DOM::Element e(linkNodes.item(i));
 
         // --- Retrieve of the relation type --
 
         QString rel = e.getAttribute("rel").string();
         rel = rel.simplified();
         if (rel.isEmpty()) {
             // If the "rel" attribut is null then use the "rev" attribute...
             QString rev = e.getAttribute("rev").string();
             rev = rev.simplified();
             if (rev.isEmpty()) {
                 // if "rev" attribut is also empty => ignore
                 continue;
             }
             // Determine the "rel" equivalent of "rev" type
             rel =  transformRevToRel(rev);
         }
         // Determin the name used internally
         QString lrel = getLinkType(rel.toLower());
         // relation to ignore
         if (lrel.isEmpty()) {
             continue;
         }
 //  kDebug() << "lrel=" << lrel;
 
         // -- Retrieve of other useful information --
 
         QString href = e.getAttribute("href").string();
         // if nowhere to go, ignore the link
         if (href.isEmpty()) {
             continue;
         }
         QString title = e.getAttribute("title").string();
         QString hreflang = e.getAttribute("hreflang").string();
 
         QUrl ref(resolvedUrl(m_part->url(), href));
         if (title.isEmpty()) {
             title = ref.toDisplayString();
         }
 
         // escape ampersand before settings as action title, otherwise the menu entry will interpret it as an
         // accelerator
         title.replace('&', QLatin1String("&&"));
 
         // -- Menus activation --
 
         // Activation of "Document" menu ?
         if (lrel == QLatin1String("contents") || lrel == QLatin1String("glossary") || lrel == QLatin1String("index") || lrel == QLatin1String("appendix")) {
             m_document->setEnabled(true);
         }
         // Activation of "More" menu ?
         if (lrel == QLatin1String("help") || lrel == QLatin1String("author") || lrel == QLatin1String("copyright")) {
             m_more->setEnabled(true);
         }
 
         // -- Buttons or menu items activation / creation --
         if (lrel == QLatin1String("bookmark") || lrel == QLatin1String("alternate")) {
             QAction *a = kactionmenu_map[lrel]->menu()->addAction(title);
             a->setData(QVariant::fromValue(e));
             m_more->setEnabled(true);
             kactionmenu_map[lrel]->setEnabled(true);
 
         } else if (lrel == QLatin1String("appendix") || lrel == QLatin1String("chapter") || lrel == QLatin1String("section") || lrel == QLatin1String("subsection")) {
             QAction *a = kactionmenu_map[lrel]->menu()->addAction(title);
             m_document->setEnabled(true);
             kactionmenu_map[lrel]->setEnabled(true);
             a->setData(QVariant::fromValue<DOM::Element>(e));
 
         } else {
             // It is a unique action
             QAction *a = actionCollection()->action("rellinks_" + lrel);
             if (a) {
                 a->setData(QVariant::fromValue<DOM::Element>(e));
                 a->setEnabled(true);
                 // Tooltip
                 if (hreflang.isEmpty()) {
                     a->setToolTip(title);
                 } else {
                     a->setToolTip(title + " [" + hreflang + ']');
                 }
             } else {
                 // For the moment all the elements are reference in a separated menu
                 // TODO : reference the unknown ?
                 QAction *a = kactionmenu_map[QStringLiteral("unclassified")]->menu()->addAction(lrel + " : " + title);
                 kactionmenu_map[QStringLiteral("unclassified")]->setEnabled(true);
                 a->setData(QVariant::fromValue<DOM::Element>(e));
             }
 
         }
 
         showBar = true;
     }
 }
 
 void RelLinksPlugin::guessRelations()
 {
     m_part = qobject_cast<KHTMLPart *>(parent());
     if (!m_part || m_part->document().isNull()) {
         return;
     }
 
     //If the page already contains some link, that mean the webmaster is aware
     //of the meaning of <link> so we can consider that if prev/next was possible
     //they are already there.
     if (m_linksFound) {
         return;
     }
 
     // - The number of didgit may not be more of 3, or this is certenly an id.
     // - We make sure that the number is followed by a dot, a &, or the end, we
     //   don't want to match stuff like that:   page.html?id=A14E12FD
     // - We make also sure the number is not preceded dirrectly by others number
     QRegExp rx("^(.*[=/?&][^=/?&.\\-0-9]*)([\\d]{1,3})([.&][^/0-9]{0,15})?$");
 
     const QString zeros(QStringLiteral("0000"));
     QString url = m_part->url().url();
     if (rx.indexIn(url) != -1) {
         uint val = rx.cap(2).toUInt();
         int lenval = rx.cap(2).length();
         QString nval_str = QString::number(val + 1);
         //prepend by zeros if the original also contains zeros.
         if (nval_str.length() < lenval && rx.cap(2)[0] == '0') {
             nval_str.prepend(zeros.left(lenval - nval_str.length()));
         }
 
         QString href = rx.cap(1) + nval_str + rx.cap(3);
         QUrl ref(resolvedUrl(m_part->url(), href));
         QString title = i18n("[Autodetected] %1", ref.toDisplayString());
         DOM::Element e = m_part->document().createElement("link");
         e.setAttribute("href", href);
         QAction *a = actionCollection()->action(QStringLiteral("rellinks_next"));
         a->setEnabled(true);
         a->setToolTip(title);
         a->setData(QVariant::fromValue(e));
 
         if (val > 1) {
             nval_str = QString::number(val - 1);
             if (nval_str.length() < lenval && rx.cap(2)[0] == '0') {
                 nval_str.prepend(zeros.left(lenval - nval_str.length()));
             }
             QString href = rx.cap(1) + nval_str + rx.cap(3);
             QUrl ref(resolvedUrl(m_part->url(), href));
             QString title = i18n("[Autodetected] %1", ref.toDisplayString());
             e = m_part->document().createElement("link");
             e.setAttribute("href", href);
             QAction *a = actionCollection()->action(QStringLiteral("rellinks_prev"));
             a->setEnabled(true);
             a->setToolTip(title);
             a->setData(QVariant::fromValue(e));
         }
     }
 }
 
 void RelLinksPlugin::goToLink(DOM::Element e)
 {
     // have the KHTML part open it
     KHTMLPart *part = qobject_cast<KHTMLPart *>(parent());
     if (!part) {
         return;
     }
     QString href = e.getAttribute("href").string();
     QUrl url(resolvedUrl(part->url(), href));
     QString target = e.getAttribute("target").string();
 
     // URL arguments
     KParts::OpenUrlArguments arguments;
     KParts::BrowserArguments browserArguments;
     browserArguments.frameName = target;
 
     // Add base url if not valid
     if (url.isValid()) {
         part->browserExtension()->openUrlRequest(url, arguments, browserArguments);
     } else {
         QUrl baseURL = part->baseURL();
         QString endURL = url.toDisplayString();
         QUrl realURL = resolvedUrl(baseURL, endURL);
         part->browserExtension()->openUrlRequest(realURL, arguments, browserArguments);
     }
 
 }
 
 void RelLinksPlugin::disableAll()
 {
     m_linksFound = false;
 
     foreach (QAction *a, actionCollection()->actionGroups()[0]->actions()) {
         a->setEnabled(false);
         a->setToolTip(a->text().remove('&'));
     }
 
     // Clear actions
     KActionMenuMap::Iterator itmenu;
     for (itmenu = kactionmenu_map.begin(); itmenu != kactionmenu_map.end(); ++itmenu) {
         // If I don't test it crash :(
         if (itmenu.value()) {
             itmenu.value()->menu()->clear();
             itmenu.value()->setEnabled(false);
             itmenu.value()->setToolTip(itmenu.value()->text().remove('&'));
         }
     }
 
     // Unactivate menus
     m_more->setEnabled(false);
     m_document->setEnabled(false);
 
 }
 
 QString RelLinksPlugin::getLinkType(const QString &lrel)
 {
     // Relations to ignore...
     if (lrel.contains(QLatin1String("stylesheet"))
             || lrel == QLatin1String("script")
             || lrel == QLatin1String("icon")
             || lrel == QLatin1String("shortcut icon")
             || lrel == QLatin1String("prefetch")) {
         return QString();
     }
 
     // ...known relations...
     if (lrel == QLatin1String("top") || lrel == QLatin1String("origin") || lrel == QLatin1String("start")) {
         return QStringLiteral("home");
     }
     if (lrel == QLatin1String("parent")) {
         return QStringLiteral("up");
     }
     if (lrel == QLatin1String("first")) {
         return QStringLiteral("begin");
     }
     if (lrel == QLatin1String("previous")) {
         return QStringLiteral("prev");
     }
     if (lrel == QLatin1String("child")) {
         return QStringLiteral("next");
     }
     if (lrel == QLatin1String("end")) {
         return QStringLiteral("last");
     }
     if (lrel == QLatin1String("toc")) {
         return QStringLiteral("contents");
     }
     if (lrel == QLatin1String("find")) {
         return QStringLiteral("search");
     }
     if (lrel == QLatin1String("alternative stylesheet")) {
         return QStringLiteral("alternate stylesheet");
     }
     if (lrel == QLatin1String("authors")) {
         return QStringLiteral("author");
     }
     if (lrel == QLatin1String("toc")) {
         return QStringLiteral("contents");
     }
 
     //...unknown relations or name that don't need to change
     return lrel;
 }
 
 QString RelLinksPlugin::transformRevToRel(const QString &rev)
 {
     QString altRev = getLinkType(rev);
 
     // Known relations
     if (altRev == QLatin1String("prev")) {
         return getLinkType(QStringLiteral("next"));
     }
     if (altRev == QLatin1String("next")) {
         return getLinkType(QStringLiteral("prev"));
     }
     if (altRev == QLatin1String("made")) {
         return getLinkType(QStringLiteral("author"));
     }
     if (altRev == QLatin1String("up")) {
         return getLinkType(QStringLiteral("child"));
     }
     if (altRev == QLatin1String("sibling")) {
         return getLinkType(QStringLiteral("sibling"));
     }
 
     //...unknown inverse relation => ignore for the moment
     return QString();
 }
 
 void RelLinksPlugin::actionTriggered(QAction *action)
 {
     if (action->data().isValid()) {
         goToLink(action->data().value<DOM::Element>());
     }
 }
 
 #include "plugin_rellinks.moc"
diff --git a/plugins/uachanger/uachangerplugin.cpp b/plugins/uachanger/uachangerplugin.cpp
index 7aa7cdf14..705e8cd55 100644
--- a/plugins/uachanger/uachangerplugin.cpp
+++ b/plugins/uachanger/uachangerplugin.cpp
@@ -1,462 +1,463 @@
 /*
     Copyright (c) 2001 Dawit Alemayehu <adawit@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License (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.
 */
 
+#include "uachangerplugin.h"
+
 #include <sys/utsname.h>
 
-#include <qregexp.h>
+#include <QRegExp>
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <kicon.h>
 #include <kactionmenu.h>
 #include <kservicetypetrader.h>
 #include <krun.h>
 #include <kdebug.h>
 #include <kaction.h>
 #include <klocale.h>
 #include <kglobal.h>
 #include <kconfig.h>
 #include <kio/job.h>
 #include <kio/scheduler.h>
 #include <kservice.h>
 #include <kcomponentdata.h>
 #include <kmenu.h>
 #include <KConfigGroup>
 #include <kparts/part.h>
 #include <kpluginfactory.h>
 #include <kprotocolmanager.h>
 #include <kaboutdata.h>
 #include <kactioncollection.h>
-#include "uachangerplugin.h"
 
 static const KAboutData aboutdata("uachangerplugin", 0, ki18n("Change Browser Identification"), "1.0");
 K_PLUGIN_FACTORY(UAChangerPluginFactory, registerPlugin<UAChangerPlugin>();)
 K_EXPORT_PLUGIN(UAChangerPluginFactory(aboutdata))
 
 #define UA_PTOS(x) (*it)->property(x).toString()
 #define QFL1(x) QLatin1String(x)
 
 UAChangerPlugin::UAChangerPlugin(QObject *parent,
                                  const QVariantList &)
     : KParts::Plugin(parent),
       m_bSettingsLoaded(false), m_part(0L), m_config(0L)
 {
     setComponentData(UAChangerPlugin::componentData());
 
     m_pUAMenu = new KActionMenu(KIcon("preferences-web-browser-identification"), i18n("Change Browser &Identification"),
                                 actionCollection());
     actionCollection()->addAction("changeuseragent", m_pUAMenu);
     m_pUAMenu->setDelayed(false);
     connect(m_pUAMenu->menu(), SIGNAL(aboutToShow()),
             this, SLOT(slotAboutToShow()));
 
     if (parent) {
         m_part = qobject_cast<KParts::ReadOnlyPart *>(parent);
         connect(m_part, SIGNAL(started(KIO::Job*)), this,
                 SLOT(slotEnableMenu()));
         connect(m_part, SIGNAL(completed()), this,
                 SLOT(slotEnableMenu()));
         connect(m_part, SIGNAL(completed(bool)), this,
                 SLOT(slotEnableMenu()));
     }
 }
 
 UAChangerPlugin::~UAChangerPlugin()
 {
     saveSettings();
     slotReloadDescriptions();
 }
 
 void UAChangerPlugin::slotReloadDescriptions()
 {
     delete m_config;
     m_config = 0L;
 }
 
 void UAChangerPlugin::parseDescFiles()
 {
     const KService::List list = KServiceTypeTrader::self()->query("UserAgentStrings");
     if (list.isEmpty()) {
         return;
     }
 
     m_mapAlias.clear();
     m_lstAlias.clear();
     m_lstIdentity.clear();
 
     struct utsname utsn;
     uname(&utsn);
 
     QStringList languageList = KLocale::global()->languageList();
     if (!languageList.isEmpty()) {
         const int index = languageList.indexOf(QFL1("C"));
         if (index > -1) {
             if (languageList.contains(QFL1("en"))) {
                 languageList.removeAt(index);
             } else {
                 languageList[index] = QFL1("en");
             }
         }
     }
 
     KService::List::ConstIterator it = list.constBegin();
     KService::List::ConstIterator lastItem = list.constEnd();
 
     for (; it != lastItem; ++it) {
         QString ua  = UA_PTOS("X-KDE-UA-FULL");
         QString tag = UA_PTOS("X-KDE-UA-TAG");
 
         // The menu groups thing by tag, with the menu name being the X-KDE-UA-NAME by default. We make groups for
         // IE, NS, Firefox, Safari, and Opera, and put everything else into "Other"
         QString menuName;
         MenuGroupSortKey menuKey; // key for the group..
         if (tag != "IE" && tag != "NN" && tag != "FF" && tag != "SAF" && tag != "OPR") {
             tag = "OTHER";
             menuName = i18n("Other");
             menuKey = MenuGroupSortKey(tag, true);
         } else {
             menuName = UA_PTOS("X-KDE-UA-NAME");
             menuKey  = MenuGroupSortKey(tag, false);
         }
 
         if ((*it)->property("X-KDE-UA-DYNAMIC-ENTRY").toBool()) {
             ua.replace(QFL1("appSysName"), QFL1(utsn.sysname));
             ua.replace(QFL1("appSysRelease"), QFL1(utsn.release));
             ua.replace(QFL1("appMachineType"), QFL1(utsn.machine));
             ua.replace(QFL1("appLanguage"), languageList.join(QFL1(", ")));
             ua.replace(QFL1("appPlatform"), QFL1("X11"));
         }
 
         if (m_lstIdentity.contains(ua)) {
             continue;    // Ignore dups!
         }
 
         m_lstIdentity << ua;
 
         // Compute what to display for our menu entry --- including platform name if it's available,
         // and avoiding repeating the browser name in categories other than 'other'.
         QString platform = QString("%1 %2").arg(UA_PTOS("X-KDE-UA-SYSNAME")).arg(UA_PTOS("X-KDE-UA-SYSRELEASE"));
 
         QString alias;
         if (platform.trimmed().isEmpty()) {
             if (!menuKey.isOther) {
                 alias = i18nc("%1 = browser version (e.g. 2.0)", "Version %1", UA_PTOS("X-KDE-UA-VERSION"));
             } else
                 alias = i18nc("%1 = browser name, %2 = browser version (e.g. Firefox, 2.0)",
                               "%1 %2", UA_PTOS("X-KDE-UA-NAME"), UA_PTOS("X-KDE-UA-VERSION"));
         } else {
             if (!menuKey.isOther)
                 alias = i18nc("%1 = browser version, %2 = platform (e.g. 2.0, Windows XP)",
                               "Version %1 on %2", UA_PTOS("X-KDE-UA-VERSION"), platform);
             else
                 alias = i18nc("%1 = browser name, %2 = browser version, %3 = platform (e.g. Firefox, 2.0, Windows XP)",
                               "%1 %2 on %3", UA_PTOS("X-KDE-UA-NAME"), UA_PTOS("X-KDE-UA-VERSION"), platform);
         }
 
         m_lstAlias << alias;
 
         /* sort in this UA Alias alphabetically */
         BrowserGroup ualist = m_mapAlias[menuKey];
         BrowserGroup::Iterator e = ualist.begin();
         while (!alias.isEmpty() && e != ualist.end()) {
             if (m_lstAlias[(*e)] > alias) {
                 ualist.insert(e, m_lstAlias.count() - 1);
                 alias.clear();
             }
             ++e;
         }
 
         if (!alias.isEmpty()) {
             ualist.append(m_lstAlias.count() - 1);
         }
 
         m_mapAlias[menuKey]   = ualist;
         m_mapBrowser[menuKey] = menuName;
     }
 }
 
 void UAChangerPlugin::slotEnableMenu()
 {
     m_currentURL = m_part->url();
 
     // This plugin works on local files, http[s], and webdav[s].
     QString proto = m_currentURL.protocol();
     if (m_currentURL.isLocalFile() ||
             proto.startsWith("http") || proto.startsWith("webdav")) {
         if (!m_pUAMenu->isEnabled()) {
             m_pUAMenu->setEnabled(true);
         }
     } else {
         m_pUAMenu->setEnabled(false);
     }
 }
 
 void UAChangerPlugin::slotAboutToShow()
 {
     if (!m_config) {
         m_config = new KConfig("kio_httprc");
         parseDescFiles();
     }
 
     if (!m_bSettingsLoaded) {
         loadSettings();
     }
 
     if (m_pUAMenu->menu()->actions().isEmpty()) { // need to create the actions
         m_pUAMenu->menu()->addTitle(i18n("Identify As")); // imho title doesn't need colon..
 
         m_defaultAction = new QAction(i18n("Default Identification"), this);
         m_defaultAction->setCheckable(true);
         connect(m_defaultAction, SIGNAL(triggered()), this, SLOT(slotDefault()));
         m_pUAMenu->menu()->addAction(m_defaultAction);
 
         m_pUAMenu->menu()->addSeparator();
 
         m_actionGroup = new QActionGroup(m_pUAMenu->menu());
         AliasConstIterator map = m_mapAlias.constBegin();
         for (; map != m_mapAlias.constEnd(); ++map) {
             QMenu *browserMenu = m_pUAMenu->menu()->addMenu(m_mapBrowser.value(map.key()));
             BrowserGroup::ConstIterator e = map.value().begin();
             for (; e != map.value().end(); ++e) {
                 QAction *action = new QAction(m_lstAlias[*e], m_actionGroup);
                 action->setCheckable(true);
                 action->setData(*e);
                 browserMenu->addAction(action);
             }
         }
         connect(m_actionGroup, SIGNAL(triggered(QAction*)), this, SLOT(slotItemSelected(QAction*)));
 
         m_pUAMenu->menu()->addSeparator();
 
         /* useless here, imho..
            m_pUAMenu->menu()->insertItem( i18n("Reload Identifications"), this,
            SLOT(slotReloadDescriptions()),
            0, ++count );*/
 
         m_applyEntireSiteAction = new QAction(i18n("Apply to Entire Site"), this);
         m_applyEntireSiteAction->setCheckable(true);
         connect(m_applyEntireSiteAction, SIGNAL(triggered()), this, SLOT(slotApplyToDomain()));
         m_pUAMenu->menu()->addAction(i18n("Apply to Entire Site"));
 
         m_pUAMenu->menu()->addAction(i18n("Configure..."), this,
                                      SLOT(slotConfigure()));
     }
 
     // Reflect current settings in the actions
 
     QString host = m_currentURL.isLocalFile() ? QFL1("localhost") : m_currentURL.host();
     m_currentUserAgent = KProtocolManager::userAgentForHost(host);
     //kDebug(90130) << "User Agent: " << m_currentUserAgent;
     m_defaultAction->setChecked(m_currentUserAgent == KProtocolManager::defaultUserAgent());
 
     m_applyEntireSiteAction->setChecked(m_bApplyToDomain);
     Q_FOREACH (QAction *action, m_actionGroup->actions()) {
         const int id = action->data().toInt();
         action->setChecked(m_lstIdentity[id] == m_currentUserAgent);
     }
 
 }
 
 void UAChangerPlugin::slotConfigure()
 {
     KService::Ptr service = KService::serviceByDesktopName("useragent");
     if (service) {
         KRun::runCommand(service->exec(), m_part->widget());
     }
 }
 
 void UAChangerPlugin::slotItemSelected(QAction *action)
 {
     const int id = action->data().toInt();
     if (m_lstIdentity[id] == m_currentUserAgent) {
         return;
     }
 
     m_currentUserAgent = m_lstIdentity[id];
     QString host = m_currentURL.isLocalFile() ? QFL1("localhost") : filterHost(m_currentURL.host());
 
     KConfigGroup grp = m_config->group(host.toLower());
     grp.writeEntry("UserAgent", m_currentUserAgent);
     //kDebug(90130) << "Writing out UserAgent=" << m_currentUserAgent << "for host=" << host;
     grp.sync();
 
     // Reload the page with the new user-agent string
     reloadPage();
 }
 
 void UAChangerPlugin::slotDefault()
 {
     if (m_currentUserAgent == KProtocolManager::defaultUserAgent()) {
         return;    // don't flicker!
     }
     // We have no choice but delete all higher domain level settings here since it
     // affects what will be matched.
     QStringList partList = m_currentURL.host().split(' ', QString::SkipEmptyParts);
     if (!partList.isEmpty()) {
         partList.removeFirst();
 
         QStringList domains;
         // Remove the exact name match...
         domains << m_currentURL.host();
 
         while (partList.count()) {
             if (partList.count() == 2)
                 if (partList[0].length() <= 2 && partList[1].length() == 2) {
                     break;
                 }
 
             if (partList.count() == 1) {
                 break;
             }
 
             domains << partList.join(QFL1("."));
             partList.removeFirst();
         }
 
         KConfigGroup grp(m_config, QString());
         for (QStringList::Iterator it = domains.begin(); it != domains.end(); it++) {
             //kDebug () << "Domain to remove: " << *it;
             if (grp.hasGroup(*it)) {
                 grp.deleteGroup(*it);
             } else if (grp.hasKey(*it)) {
                 grp.deleteEntry(*it);
             }
         }
     } else if (m_currentURL.isLocalFile() && m_config->hasGroup("localhost")) {
         m_config->deleteGroup("localhost");
     }
 
     m_config->sync();
 
     // Reset some internal variables and inform the http io-slaves of the changes.
     m_currentUserAgent = KProtocolManager::defaultUserAgent();
 
     // Reload the page with the default user-agent
     reloadPage();
 }
 
 void UAChangerPlugin::reloadPage()
 {
     // Inform running http(s) io-slaves about the change...
     KIO::Scheduler::emitReparseSlaveConfiguration();
 
     KParts::OpenUrlArguments args = m_part->arguments();
     args.setReload(true);
     m_part->setArguments(args);
     m_part->openUrl(m_currentURL);
 }
 
 QString UAChangerPlugin::filterHost(const QString &hostname)
 {
     QRegExp rx;
 
     // Check for IPv4 address
     rx.setPattern("[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}");
     if (rx.exactMatch(hostname)) {
         return hostname;
     }
 
     // Check for IPv6 address here...
     rx.setPattern("^\\[.*\\]$");
     if (rx.exactMatch(hostname)) {
         return hostname;
     }
 
     // Return the TLD if apply to domain or
     return (m_bApplyToDomain ? findTLD(hostname) : hostname);
 }
 
 QString UAChangerPlugin::findTLD(const QString &hostname)
 {
     QStringList domains;
     QStringList partList =  hostname.split(' ', QString::SkipEmptyParts);
 
     if (partList.count()) {
         partList.removeFirst();    // Remove hostname
     }
 
     while (partList.count()) {
         // We only have a TLD left.
         if (partList.count() == 1) {
             break;
         }
 
         if (partList.count() == 2) {
             // The .name domain uses <name>.<surname>.name
             // Although the TLD is striclty speaking .name, for our purpose
             // it should be <surname>.name since people should not be able
             // to set cookies for everyone with the same surname.
             // Matches <surname>.name
             if (partList[1].toLower() == QFL1("name")) {
                 break;
             } else if (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
                 QByteArray t = partList[0].toLower().toUtf8();
                 if ((t == "com") || (t == "net") || (t == "org") || (t == "gov") ||
                         (t == "edu") || (t == "mil") || (t == "int")) {
                     break;
                 }
             }
         }
 
         domains.append(partList.join(QFL1(".")));
         partList.removeFirst(); // Remove part
     }
 
     if (domains.isEmpty()) {
         return hostname;
     }
 
     return domains[0];
 }
 
 void UAChangerPlugin::saveSettings()
 {
     if (!m_bSettingsLoaded) {
         return;
     }
 
     KConfig cfg("uachangerrc", KConfig::NoGlobals);
     KConfigGroup grp = cfg.group("General");
 
     grp.writeEntry("applyToDomain", m_bApplyToDomain);
 }
 
 void UAChangerPlugin::loadSettings()
 {
     KConfig cfg("uachangerrc", KConfig::NoGlobals);
     KConfigGroup grp = cfg.group("General");
 
     m_bApplyToDomain = grp.readEntry("applyToDomain", true);
     m_bSettingsLoaded = true;
 }
 
 void UAChangerPlugin::slotApplyToDomain()
 {
     m_bApplyToDomain = !m_bApplyToDomain;
 }
 
 #include "uachangerplugin.moc"
diff --git a/plugins/webarchiver/archivedialog.cpp b/plugins/webarchiver/archivedialog.cpp
index 4a734445b..ee05dfcc8 100644
--- a/plugins/webarchiver/archivedialog.cpp
+++ b/plugins/webarchiver/archivedialog.cpp
@@ -1,1374 +1,1375 @@
 /*
    Copyright (C) 2001 Andreas Schlapbach <schlpbch@iam.unibe.ch>
    Copyright (C) 2003 Antonio Larrosa <larrosa@kde.org>
    Copyright (C) 2008 Matthias Grimrath <maps4711@gmx.de>
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
 */
 
 // The DOM-tree is recursed twice. The first run gathers all URLs while the second
 // run writes out all HTML frames and CSS stylesheets. These two distinct runs are
 // necessary, because some frames and/or stylesheets may be dropped (for example
 // a frame currently not displayed or deemed insecure). In that case an URL that
 // points to such a frame/stylesheet has to be removed. Since the URL may be mentioned
 // earlier before recursing to the to-be-removed frame, two runs are necessary to get
 // a complete list of URLs that should be archived.
 
 // Changelog
 // * replace dynamic_cast<> and ->inherits() with qobject_cast<>
 // * use QHash instead of QMap; get rid of Ordered<> class
 // * fixed crash / assertion on Konqueror exit after a webpage was archived
 //   See comment about KHTMLView parent widget in plugin_webarchiver.cpp
 // * Using KDE4/Qt4 QUrl::equals() and QUrl::fragment() to compare Urls
 // * KHTML stores comment with a trailing '-'. Looks like some off-by-one bug.
 // * Add mimetype indicating suffix to downloaded files.
 
 // DONE CSS mentioned in <link> elements that are not parsed by Konqueror did not get their
 //      href='' resolved/removed
 
 // TODO if href= etc links in a frameset refer to frames currently displayed, make links relative
 //      to archived page instead of absolute
 // TODO KDE4 webarchiver: look at m_bPreserveWS
 // TODO KDE4 webarchiver: look at closing tags
 // TODO check if PartFrameData::framesWithName get a 'KHTMLPart *' if any
 // TODO KHTMLPart::frames(): Is it possible to have NULL pointers in returned list?
 // TODO If downloaded object need no data conversion, use KIO::file_copy or signal data()
 // TODO KDE4 check what KHTMLPart is doing on job->addMetaData()
 // TODO KDE4 use HTMLScriptElementImpl::charset() to get charset="" attribute of <link> elements
 
+#include "archivedialog.h"
+
 #include <cassert>
 
-#include <qtextcodec.h>
-#include <qtextdocument.h>
+#include <QTextCodec>
+#include <QTextDocument>
 
 #include <ktar.h>
 #include <kauthorized.h>
 #include <kcharsets.h>
 #include <kmimetype.h>
 #include <kmessagebox.h>
 #include <kstringhandler.h>
 #include <kstandardguiitem.h>
 #include <KUrlAuthorized>
 
 #include <khtml_part.h>
 
 #include <kio/job.h>
 
 #include <dom/css_rule.h>
 #include <dom/css_stylesheet.h>
 #include <dom/css_value.h>
 
-#include "archivedialog.h"
 #include "webarchiverdebug.h"
 
 //KDELibs4Support
 #include <kglobal.h>
 
 // Set to true if you have a patched http-io-slave that has
 // improved offline-browsing functionality.
 static const bool patchedHttpSlave = false;
 
 #define CONTENT_TYPE "<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\" />"
 
 //
 // Qt 4.x offers a @c foreach pseudo keyword. This is however slightly slower than FOR_ITER
 // because @c foreach makes a shared copy of the container.
 //
 #define FOR_ITER(type,var,it) for (type::iterator it(var.begin()), it##end(var.end()); it != it##end; ++it)
 #define FOR_CONST_ITER(type,var,it) for (type::const_iterator it(var.begin()), it##end(var.end()); it != it##end; ++it)
 #define FOR_ITER_TEMPLATE(type,var,it) for (typename type::iterator it(var.begin()), it##end(var.end()); it != it##end; ++it)
 
 static const mode_t archivePerms = S_IFREG | 0644;
 
 typedef QList<KParts::ReadOnlyPart *> ROPartList;
 
 //
 // functions needed for storing certain DOM elements in a QHash<>
 //
 namespace DOM
 {
 
 inline uint qHash(const CSSStyleSheet &a)
 {
     return ::qHash(static_cast<void *>(a.handle()));
 }
 
 inline bool operator==(const DOM::CSSStyleSheet &a, const DOM::CSSStyleSheet &b)
 {
     return a.handle() == b.handle();
 }
 
 inline uint qHash(const Node &a)
 {
     return ::qHash(static_cast<void *>(a.handle()));
 }
 
 }// namespace DOM
 
 //
 // elems with 'type' attr: object, param, link, script, style
 //
 
 // TODO convert to bsearch? probably more time and memory efficient
 ArchiveDialog::NonCDataAttr::NonCDataAttr()
 {
     static const char *const non_cdata[] = {
         "id", "dir", "shape", "tabindex", "align", "nohref", "clear"
         // Unfinished...
     };
     for (int i = 0; i != (sizeof(non_cdata) / sizeof(non_cdata[0])); ++i) {
         insert(non_cdata[i]);
     }
 }
 
 // TODO lazy init?
 ArchiveDialog::NonCDataAttr ArchiveDialog::non_cdata_attr;
 
 ArchiveDialog::RecurseData::RecurseData(KHTMLPart *_part, QTextStream *_textStream, PartFrameData *pfd)
     : part(_part), textStream(_textStream), partFrameData(pfd), document(_part->htmlDocument()),
       baseSeen(false)
 {
     Q_ASSERT(!document.isNull());
 }
 
 static KHTMLPart *isArchivablePart(KParts::ReadOnlyPart *part)
 {
     KHTMLPart *cp = qobject_cast<KHTMLPart *>(part);
     if (! cp) {
         return NULL;
     }
     DOM::HTMLDocument domdoc(cp->htmlDocument());
     if (domdoc.isNull()) {
         return NULL;
     }
     return cp;
 }
 
 ArchiveDialog::ArchiveDialog(QWidget *parent, const QString &filename, KHTMLPart *part)
     : KDialog(parent), m_top(part), m_job(NULL), m_uniqId(2), m_tarBall(NULL), m_filename(filename), m_widget(NULL)
 {
     setCaption(i18nc("@title:window", "Web Archiver"));
     setButtons(KDialog::Ok | KDialog::Cancel);
     setButtonGuiItem(KDialog::Ok, KStandardGuiItem::close());
     setModal(false);
     enableButtonOk(false);
     setDefaultButton(KDialog::NoDefault);
 
     m_widget = new ArchiveViewBase(this);
     {
         QTreeWidgetItem *twi = m_widget->progressView->headerItem();
         twi->setText(0, i18n("Status"));
         twi->setText(1, i18n("Url"));
     }
     setMainWidget(m_widget);
 
     QUrl srcURL = part->url();
     m_widget->urlLabel->setText(QStringLiteral("<a href=\"") + srcURL.url() + "\">" +
                                 KStringHandler::csqueeze(srcURL.toDisplayString(), 80) + "</a>");
     m_widget->targetLabel->setText(QStringLiteral("<a href=\"") + filename + "\">" +
                                    KStringHandler::csqueeze(filename, 80) + "</a>");
 
     //if(part->document().ownerDocument().isNull())
     //   m_document = part->document();
     //else
     //   m_document = part->document().ownerDocument();
 
     m_tarBall = new KTar(filename, QStringLiteral("application/x-gzip"));
     m_archiveTime = QDateTime::currentDateTime();
 }
 
 ArchiveDialog::~ArchiveDialog()
 {
     // TODO cancel outstanding download jobs?
     qCDebug(WEBARCHIVERPLUGIN_LOG) << "destroying";
     if (m_job) {
         m_job->kill();
         m_job = NULL;
     }
     delete m_tarBall; m_tarBall = NULL;
 }
 
 void ArchiveDialog::archive()
 {
     if (m_tarBall->open(QIODevice::WriteOnly)) {
 
         obtainURLs();
 
         // Assign unique tarname to URLs
         // Split m_url2tar into Stylesheets / non stylesheets
         m_objects.clear();
         assert(static_cast<ssize_t>(m_url2tar.size()) - static_cast<ssize_t>(m_cssURLs.size()) >= 0);
 //         m_objects.reserve(m_url2tar.size() - m_cssURLs.size());
 
         FOR_ITER(UrlTarMap, m_url2tar, u2t_it) {
             const QUrl &url = u2t_it.key();
             DownloadInfo &info = u2t_it.value();
 
             assert(info.tarName.isNull());
 //             info.tarName = uniqTarName( url.fileName(), 0 );
 
             // To able to append mimetype hinting suffixes to tarnames, for instance adding '.gif' to a
             // webbug '87626734' adding the name to the url-to-tarname map is deferred.
             // This cannot be done with CSS because CSS may reference each other so when URLS
             // of the first CSS are changed all tarnames need to be there.
             //
             if (m_cssURLs.find(url) == m_cssURLs.end()) {
                 m_objects.append(u2t_it);
             } else {
                 info.tarName = uniqTarName(url.fileName(), 0);
             }
         }
 
         QProgressBar *pb = m_widget->progressBar;
         pb->setMaximum(m_url2tar.count() + 1);
         pb->setValue(0);
 
         m_objects_it = m_objects.begin();
         downloadObjects();
 
     } else {
         const QString title = i18nc("@title:window", "Unable to Open Web-Archive");
         const QString text = i18n("Unable to open \n %1 \n for writing.", m_tarBall->fileName());
         KMessageBox::sorry(NULL, text, title);
     }
 }
 
 void ArchiveDialog::downloadObjects()
 {
 
     if (m_objects_it == m_objects.end()) {
 
         m_styleSheets_it = m_cssURLs.begin();
         downloadStyleSheets();
 
     } else {
 
         m_dlurl2tar_it = (*m_objects_it);
         const QUrl &url    = m_dlurl2tar_it.key();
         DownloadInfo &info = m_dlurl2tar_it.value();
         assert(m_dlurl2tar_it != m_url2tar.end());
 
         Q_ASSERT(m_job == NULL);
         m_job = startDownload(url, info.part);
         connect(m_job, SIGNAL(result(KJob*)), SLOT(slotObjectFinished(KJob*)));
     }
 }
 
 void ArchiveDialog::slotObjectFinished(KJob *_job)
 {
     KIO::StoredTransferJob *job = qobject_cast<KIO::StoredTransferJob *>(_job);
     Q_ASSERT(job == m_job);
     m_job = NULL;
     const QUrl &url    = m_dlurl2tar_it.key();
     DownloadInfo &info = m_dlurl2tar_it.value();
 
     assert(info.tarName.isNull());
     bool error = job->error();
     if (!error) {
         const QString &mimetype(job->mimetype());
         info.tarName = uniqTarName(appendMimeTypeSuffix(url.fileName(), mimetype), 0);
 
         QByteArray data(job->data());
         const QString &tarName = info.tarName;
 
 //         qCDebug(WEBARCHIVERPLUGIN_LOG) << "downloaded " << url.toDisplayString() << "size=" << data.size() << "mimetype" << mimetype;
         error = ! m_tarBall->writeFile(tarName, data, archivePerms, QString::null, QString::null,
                                        m_archiveTime, m_archiveTime, m_archiveTime);
         if (error) {
             qCDebug(WEBARCHIVERPLUGIN_LOG) << "Error writing to archive file";
             finishedArchiving(true);
             return;
         }
     } else {
         info.tarName.clear();
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "download error for url='" << url;
     }
 
     endProgressInfo(error);
     ++m_objects_it;
     downloadObjects();
 }
 
 void ArchiveDialog::downloadStyleSheets()
 {
     if (m_styleSheets_it == m_cssURLs.end()) {
 
         saveWebpages();
 
     } else {
 
 //         QTimer::singleShot(3000, this, SLOT(slotDownloadStyleSheetsDelay()));
         const QUrl &url = m_styleSheets_it.key();
         m_dlurl2tar_it = m_url2tar.find(url);
         assert(m_dlurl2tar_it != m_url2tar.end());
         DownloadInfo &info = m_dlurl2tar_it.value();
 
         Q_ASSERT(m_job == NULL);
         m_job = startDownload(url, info.part);
         connect(m_job, SIGNAL(result(KJob*)), SLOT(slotStyleSheetFinished(KJob*)));
     }
 }
 
 void ArchiveDialog::slotStyleSheetFinished(KJob *_job)
 {
     KIO::StoredTransferJob *job = qobject_cast<KIO::StoredTransferJob *>(_job);
     Q_ASSERT(job == m_job);
     m_job = NULL;
     const QUrl &url    = m_dlurl2tar_it.key();
     DownloadInfo &info = m_dlurl2tar_it.value();
 
     bool error = job->error();
     if (! error) {
         QByteArray data(job->data());
         const QString &tarName = info.tarName;
 
         URLsInStyleSheet::Iterator uss_it = m_URLsInStyleSheet.find(m_styleSheets_it.value());
         assert(uss_it != m_URLsInStyleSheet.end());
 
         DOM::DOMString ds(uss_it.key().charset());
         QString cssCharSet(ds.string());
         bool ok;
         QTextCodec *codec = KCharsets::charsets()->codecForName(cssCharSet, ok);
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "translating URLs in CSS" << url << "charset=" << cssCharSet << " found=" << ok;
         assert(codec);
         QString css_text = codec->toUnicode(data);
         data.clear();
         // Do *NOT* delete 'codec'!  These are allocated by Qt
 
         changeCSSURLs(css_text, uss_it.value());
         data = codec->fromUnicode(css_text);
         css_text.clear();
 
         error = ! m_tarBall->writeFile(tarName, data, archivePerms, QString::null, QString::null,
                                        m_archiveTime, m_archiveTime, m_archiveTime);
         if (error) {
             qCDebug(WEBARCHIVERPLUGIN_LOG) << "Error writing to archive file";
             finishedArchiving(true);
             return;
         }
     } else {
         info.tarName.clear();
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "download error for css url='" << url;
     }
 
     endProgressInfo(error);
     ++m_styleSheets_it;
     downloadStyleSheets();
 }
 
 KIO::Job *ArchiveDialog::startDownload(const QUrl &url, KHTMLPart *part)
 {
     QTreeWidgetItem *twi = new QTreeWidgetItem;
     twi->setText(0, i18n("Downloading"));
     twi->setText(1, url.toDisplayString());
     QTreeWidget *tw = m_widget->progressView;
     tw->insertTopLevelItem(0, twi);
 
     KIO::Job *job = KIO::storedGet(url, KIO::NoReload, KIO::HideProgressInfo);
 
     // Use entry from cache only. Avoids re-downloading. Requires modified kio_http slave.
     job->addMetaData(QStringLiteral("cache"), patchedHttpSlave ? "cacheonly" : "cache");
 
     // This is a duplication of the code in loader.cpp: Loader::servePendingRequests()
 
     //job->addMetaData("accept", req->object->accept());
     job->addMetaData(QStringLiteral("referrer"), part->url().url());
     job->addMetaData(QStringLiteral("cross-domain"), part->toplevelURL().url());
 
     return job;
 }
 
 void ArchiveDialog::endProgressInfo(bool error)
 {
     QTreeWidget *tw = m_widget->progressView;
     tw->topLevelItem(0)->setText(0, error ? i18n("Error") : i18n("OK"));
     QProgressBar *pb = m_widget->progressBar;
     pb->setValue(pb->value() + 1);
 }
 
 void ArchiveDialog::saveWebpages()
 {
     bool error = saveTopFrame();
     if (error) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "Error writing to archive file";
         finishedArchiving(true);
         return;
     }
     QProgressBar *pb = m_widget->progressBar;
     pb->setValue(pb->value() + 1);
 
 //     KMessageBox::information(0, i18n( "Archiving webpage completed." ), QString::null, QString::null, false);
     finishedArchiving(false);
 }
 
 void ArchiveDialog::finishedArchiving(bool tarerror)
 {
     if (tarerror) {
         KMessageBox::error(this, i18n("I/O error occurred while writing to web archive file %1.", m_tarBall->fileName()));
     }
     m_tarBall->close();
 
     m_widget->progressView->sortItems(0, Qt::AscendingOrder);
     setDefaultButton(KDialog::Ok);
     setEscapeButton(KDialog::Ok);
     enableButtonOk(true);
     enableButtonCancel(false);
 }
 
 void ArchiveDialog::slotButtonClicked(int)
 {
     deleteLater();  // Keep memory consumption low
 }
 
 // This is the mess you get because C++ lacks a lambda generator
 //
 // The whole purpose of the Get* classes is to parametrize what
 // attribute of a KHTMLPart object should be fetched.
 //
 // GetName and GetURL are used for the 'class FuncObj' parameter
 // class in the template function filterFrameMappings below
 struct GetFromPart {
     const KHTMLPart *child;
 
     GetFromPart(const KHTMLPart *_child) : child(_child) { }
 };
 
 struct GetName : public GetFromPart {
     GetName(const KHTMLPart *child) : GetFromPart(child) { }
 
     operator QString()
     {
         return child->objectName();
     }
 };
 struct GetURL : public GetFromPart {
     GetURL(const KHTMLPart *child) : GetFromPart(child) { }
 
     operator QUrl()
     {
         return child->url();
     }
 };
 
 template< class Id2Part, class FuncObj >
 static void filterFrameMappings(KHTMLPart *part, Id2Part &result)
 {
     Id2Part existing_frames;
 
     // TODO this can probably be optimized: no temp of existing, directly store to be removed parts.
     ROPartList childParts(part->frames());
     FOR_ITER(ROPartList, childParts, child_it) {
         // TODO It is not clear from browsing the source code of KHTML if *child_it may be NULL
         Q_ASSERT(*child_it);
         KHTMLPart *cp = isArchivablePart(*child_it);
         if (cp) {
             existing_frames.insert(FuncObj(cp), cp);
         }
     }
 
     typedef QList< typename Id2Part::Iterator > IdRemoveList;
     IdRemoveList beRemoved;
 
     FOR_ITER_TEMPLATE(Id2Part, result, it) {
         typename Id2Part::Iterator exists_it = existing_frames.find(it.key());
         if (exists_it == existing_frames.end()) {
             beRemoved.append(it);
         } else {
             it.value() = exists_it.value();
         }
     }
     FOR_ITER_TEMPLATE(IdRemoveList, beRemoved, rem_it) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "removing insecure(?) frame='" << (*rem_it).key();
         result.erase((*rem_it));
     }
 }
 
 template void filterFrameMappings< ArchiveDialog::Name2Part, GetName >(KHTMLPart *, ArchiveDialog::Name2Part &);
 template void filterFrameMappings< ArchiveDialog::URL2Part, GetURL >(KHTMLPart *, ArchiveDialog::URL2Part &);
 
 /**
  * Recursively traverses the DOM-Tree extracting all URLs that need to be downloaded
  */
 void ArchiveDialog::obtainURLs()
 {
     m_url2tar.clear();
     m_tarName2part.clear();
     m_framesInPart.clear();
     m_cssURLs.clear();
     m_URLsInStyleSheet.clear();
     m_URLsInStyleElement.clear();
     m_topStyleSheets.clear();
 
     obtainURLsLower(m_top, 0);
 
     FOR_ITER(FramesInPart, m_framesInPart, fip_it) {
         KHTMLPart     *part = fip_it.key();
         PartFrameData &pfd  = fip_it.value();
 
         // Remove all frames obtained from the DOM tree parse
         // that do not have a corresponding KHTMLPart as a direct child.
 
         // Do NOT use KHTMLPart::findFrame()! This one searches recursively all subframes as well!
         filterFrameMappings< Name2Part, GetName >(part, pfd.framesWithName);
         filterFrameMappings< URL2Part, GetURL >(part, pfd.framesWithURLOnly);
     }
     assert(! m_framesInPart.empty());
 #if 0
     FOR_ITER(CSSURLSet, m_cssURLs, it) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "to be downloaded stylesheet='" << it.key();
     }
     FOR_ITER(URLsInStyleSheet, m_URLsInStyleSheet, ss2u_it) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "raw URLs in sheet='" << ss2u_it.key().href();
         FOR_ITER(RawHRef2FullURL, ss2u_it.data(), c2f_it) {
             qCDebug(WEBARCHIVERPLUGIN_LOG) << "   url='" << c2f_it.key() << "' -> '" << c2f_it.data().toDisplayString();
         }
     }
     FOR_ITER(URLsInStyleElement, m_URLsInStyleElement, e2u_it) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "raw URLs in style-element:";
         FOR_ITER(RawHRef2FullURL, e2u_it.data(), c2f_it) {
             qCDebug(WEBARCHIVERPLUGIN_LOG) << "   url='" << c2f_it.key() << "' -> '" << c2f_it.data().toDisplayString();
         }
     }
 #endif
 }
 
 void ArchiveDialog::obtainStyleSheetURLsLower(DOM::CSSStyleSheet css, RecurseData &data)
 {
 
     //qCDebug(WEBARCHIVERPLUGIN_LOG) << "stylesheet title='" << styleSheet.title().string() << "' "
     //                "type='" << styleSheet.type().string();
 
     RawHRef2FullURL &raw2full = m_URLsInStyleSheet.insert(css, RawHRef2FullURL()).value();
 
     DOM::CSSRuleList crl = css.cssRules();
     for (int j = 0; j != static_cast<int>(crl.length()); ++j) {
 
         DOM::CSSRule cr = crl.item(j);
         switch (cr.type()) {
 
         case DOM::CSSRule::STYLE_RULE: {
             const DOM::CSSStyleRule &csr = static_cast<DOM::CSSStyleRule &>(cr);
 
             //qCDebug(WEBARCHIVERPLUGIN_LOG) << "found selector '" << csr.selectorText();
             parseStyleDeclaration(css.baseUrl(), csr.style(), raw2full, data);
         } break;
 
         case DOM::CSSRule::IMPORT_RULE: {
             const DOM::CSSImportRule &cir = static_cast<DOM::CSSImportRule &>(cr);
 
             DOM::CSSStyleSheet importSheet = cir.styleSheet();
             if (importSheet.isNull()) {
 
                 // Given stylesheet was not downloaded / parsed by KHTML
                 // Remove that URL from the stylesheet
                 qCDebug(WEBARCHIVERPLUGIN_LOG) << "stylesheet: invalid @import url('" << cir.href() << "')";
 
                 raw2full.insert(cir.href().string(), QUrl());
 
             } else {
 
                 qCDebug(WEBARCHIVERPLUGIN_LOG) << "stylesheet: @import url('" << cir.href() << "') found";
 
                 QString href = cir.href().string();
                 Q_ASSERT(!href.isNull());
 
                 QUrl fullURL  = importSheet.baseUrl();
                 bool inserted = insertHRefFromStyleSheet(href, raw2full, fullURL, data);
                 if (inserted) {
                     m_cssURLs.insert(fullURL, importSheet);
                     obtainStyleSheetURLsLower(importSheet, data);
                 }
             }
         } break;
 
         default:
             qCDebug(WEBARCHIVERPLUGIN_LOG) << " unknown/unsupported rule=" << cr.type();
         }
     }
 }
 
 void ArchiveDialog::obtainURLsLower(KHTMLPart *part, int level)
 {
     //QString indent;
     //indent.fill(' ', level*2);
 
     QString htmlFileName = (level == 0) ? QStringLiteral("index.html") : part->url().fileName();
 
     // Add .html extension if not found already.  This works around problems with frames,
     // where the frame is for example "framead.php".  The http-io-slave gets the mimetype
     // from the webserver, but files in a tar archive do not have such metadata.  The result
     // is that Konqueror asks "save 'adframe.php' to file?" without this measure.
     htmlFileName = appendMimeTypeSuffix(htmlFileName, QStringLiteral("text/html"));
 
     // If level == 0, the m_tarName2part map is empty and so uniqTarName will return "index.html" unchanged.
     uniqTarName(htmlFileName, part);
 
     assert(m_framesInPart.find(part) == m_framesInPart.end());
     FramesInPart::Iterator fip_it = m_framesInPart.insert(part, PartFrameData());
 
     RecurseData data(part, 0, &(fip_it.value()));
     data.document.documentElement();
     obtainPartURLsLower(data.document.documentElement(), 1, data);
     {
         // Limit lifetime of @c childParts
         ROPartList childParts(part->frames());
         FOR_ITER(ROPartList, childParts, child_it) {
             KHTMLPart *cp = isArchivablePart(*child_it);
             if (cp) {
                 obtainURLsLower(cp, level + 1);
             }
         }
     }
 
     DOM::StyleSheetList styleSheetList = data.document.styleSheets();
     //qCDebug(WEBARCHIVERPLUGIN_LOG) << "# of stylesheets=" << styleSheetList.length();
     for (int i = 0; i != static_cast<int>(styleSheetList.length()); ++i) {
         DOM::StyleSheet ss = styleSheetList.item(i);
         if (ss.isCSSStyleSheet()) {
             DOM::CSSStyleSheet &css = static_cast<DOM::CSSStyleSheet &>(ss);
 
             QString href = css.href().string();
             if (! href.isNull()) {
                 QString href  = css.href().string();
                 QUrl fullUrl  = css.baseUrl();
                 qCDebug(WEBARCHIVERPLUGIN_LOG) << "top-level stylesheet='" << href;
                 bool inserted = insertTranslateURL(fullUrl, data);
                 if (inserted) {
                     m_cssURLs.insert(fullUrl, css);
                 }
             } else {
                 DOM::Node node = css.ownerNode();
                 if (! node.isNull()) {
                     assert(! m_topStyleSheets.contains(node));
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "top-level inline stylesheet '" << node.nodeName();
                     // TODO I think there can be more than one <style> area...
                     assert(href.isNull());
                     m_topStyleSheets.insert(node, css);
 
                 } else {
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "found loose style sheet '" << node.nodeName();
                     assert(0); // FIXME for testing only
                 }
             }
             obtainStyleSheetURLsLower(css, data);
         }
     }
 }
 
 void ArchiveDialog::obtainPartURLsLower(const DOM::Node &pNode, int level, RecurseData &data)
 {
     const QString nodeName = pNode.nodeName().string().toUpper();
 
     QString indent;
     indent.fill(' ', level * 2);
 
     if (!pNode.isNull() && (pNode.nodeType() == DOM::Node::ELEMENT_NODE)) {
         const DOM::Element &element = static_cast<const DOM::Element &>(pNode);
 
         if (const_cast<DOM::Element &>(element).hasAttribute("STYLE")) {
             RawHRef2FullURL &raw2full = m_URLsInStyleElement.insert(element, RawHRef2FullURL()).value();
             parseStyleDeclaration(data.part->url(), const_cast<DOM::Element &>(element).style(),
                                   raw2full, data);
         }
 
         if (nodeName == QLatin1String("BASE")) {
             data.baseSeen = true;
         }
 
         ExtractURLs eurls(nodeName, element);
         const AttrList::iterator invalid = eurls.attrList.end();
 
         if (eurls.frameName != invalid) {
 
             // If a frame tag has a name tag, the src attribute will be overwritten
             // This ensures the current selected frame is saved and not the default
             // frame given by the original 'src' attribute
             data.partFrameData->framesWithName.insert((*eurls.frameName).value, 0);
 
         } else if (eurls.frameURL != invalid) {
 
             // URL has no 'name' attribute.  This frame cannot(?) change, so 'src' should
             // identify it unambigously
             QUrl _frameURL = absoluteURL((*eurls.frameURL).value, data);
             if (!urlCheckFailed(data.part, _frameURL)) {
                 data.partFrameData->framesWithURLOnly.insert(QUrl(_frameURL.url()), 0);
             }
 
         } else {
             // Ignore empty frame tags
         }
 
         if (eurls.transURL != invalid) {
             // Kills insecure/invalid links. Frames are treated separately.
             insertTranslateURL(absoluteURL(parseURL((*eurls.transURL).value), data), data);
         }
 
         // StyleSheet-URLs are compared against the internal stylesheets data structures
         // Treatment is similar to frames
     }
 
     if (! pNode.isNull()) {
         DOM::Node child = pNode.firstChild();
         while (! child.isNull()) {
             obtainPartURLsLower(child, level + 1, data);
             child = child.nextSibling();
         }
     }
 }
 
 // Kill insecure/invalid links. Frames are treated separately.
 
 bool ArchiveDialog::insertTranslateURL(const QUrl &fullURL, RecurseData &data)
 {
     if (!urlCheckFailed(data.part, fullURL)) {
 //         qCDebug(WEBARCHIVERPLUGIN_LOG) << "adding '" << fullURL << "' to to-be-downloaded URLs";
         m_url2tar.insert(fullURL, DownloadInfo(QString::null, data.part));
         return true;
     } else {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "URL check failed on '" << fullURL << "' -- skipping";
         return false;
     }
 }
 
 bool ArchiveDialog::insertHRefFromStyleSheet(const QString &hrefRaw, RawHRef2FullURL &raw2full,
         const QUrl &fullURL, RecurseData &data)
 {
     bool inserted = insertTranslateURL(fullURL, data);
 
 #if 0
     if (inserted) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "stylesheet: found url='"
                       << fullURL.toDisplayString() << "' hrefRaw='" << hrefRaw;
     } else {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "stylesheet: killing insecure/invalid url='"
                       << fullURL.toDisplayString() << "' hrefRaw='" << hrefRaw;
     }
 #endif
 
     raw2full.insert(hrefRaw, inserted ? fullURL : QUrl());
     return inserted;
 }
 
 void ArchiveDialog::parseStyleDeclaration(const QUrl &baseURL, DOM::CSSStyleDeclaration decl,
         RawHRef2FullURL &raw2full, RecurseData &data /*, bool verbose*/)
 {
     for (int k = 0; k != static_cast<int>(decl.length()); ++k) {
         DOM::DOMString item  = decl.item(k);
         DOM::DOMString val   = decl.getPropertyValue(item);
         //DOM::CSSValue  csval = decl.getPropertyCSSValue(item);
 
 //         qCDebug(WEBARCHIVERPLUGIN_LOG) << "style declaration " << item << ":" << val << ";";
 
         QString href = extractCSSURL(val.string());
         if (href != QString::null) {
 
 //             qCDebug(WEBARCHIVERPLUGIN_LOG) << "URL in CSS " << item << ":" << val << ";";
 
             // TODO Would like to use khtml::parseURL to remove \r, \n and similar
             QString parsedURL = parseURL(href);
 
 //             qCDebug(WEBARCHIVERPLUGIN_LOG) << "found URL='" << val << "' extracted='" << parsedURL << "'";
             insertHRefFromStyleSheet(href, raw2full, QUrl(baseURL).resolved(QUrl(parsedURL)), data);
         }
     }
 }
 
 /* Saves all frames, starting from top */
 
 bool ArchiveDialog::saveTopFrame()
 {
     m_part2tarName.clear();
 
     FOR_ITER(TarName2Part, m_tarName2part, t2p_it) {
         if (t2p_it.value() != 0) {
             m_part2tarName.insert(t2p_it.value(), t2p_it.key());
         }
     }
 
     return saveFrame(m_top, 0);
 }
 
 bool ArchiveDialog::saveFrame(KHTMLPart *part, int level)
 {
 
     // Rebuild HTML file from 'part' and write to tar archive
 
     QByteArray rawtext;
     {
         FramesInPart::Iterator fip_it = m_framesInPart.find(part);
         assert(fip_it != m_framesInPart.end());
         PartFrameData *pfd = &(fip_it.value());
 
         //
         // Overloading madness: Note the @c &rawtext : If you accidently write @c rawtext
         // it still compiles but it uses a different ctor that does not write to @c rawtext
         // but initializes @c textStream with @c rawtext
         //
         QTextStream textStream(&rawtext, QIODevice::WriteOnly);
         textStream.setCodec(QTextCodec::codecForMib(106));       // 106 == UTF-8
         RecurseData data(part, &textStream, pfd);
         saveHTMLPart(data);
     } // @c textStream destroyed and flushed
 
     Part2TarName::Iterator p2tn_it = m_part2tarName.find(part);
     assert(p2tn_it != m_part2tarName.end());
     const QString &tarName = p2tn_it.value();
 
     qCDebug(WEBARCHIVERPLUGIN_LOG) << "writing part='" << part->url() << "' to tarfile='" << tarName
                   << "' size=" << rawtext.size();
     bool error = ! m_tarBall->writeFile(tarName, rawtext, archivePerms, QString::null, QString::null,
                                         m_archiveTime, m_archiveTime, m_archiveTime);
     if (error) {
         return true;
     }
 
     // Recursively handle all frames / subparts
     {
         // Limit lifetime of @c childParts
         ROPartList childParts(part->frames());
         FOR_ITER(ROPartList, childParts, child_it) {
             KHTMLPart *cp = isArchivablePart(*child_it);
             if (cp) {
                 error = saveFrame(cp, level + 1);
                 if (error) {
                     return true;
                 }
             }
         }
     }
 
     return false;
 }
 
 // Saves the frame given in @c data.part
 
 void ArchiveDialog::saveHTMLPart(RecurseData &data)
 {
     QTextStream &textStream(*data.textStream);
     // Add a doctype
     DOM::DocumentType t(data.document.doctype());
     if (! t.isNull()) {
         DOM::DOMString name(t.name());
         DOM::DOMString publicId(t.publicId());
 
         if (!name.isEmpty() && !publicId.isEmpty()) {
             textStream << "<!DOCTYPE " << name.string() << " PUBLIC \"" << publicId.string() << "\"";
             DOM::DOMString systemId(t.systemId());
             if (!systemId.isEmpty()) {
                 textStream << " \"" << systemId.string() << "\"";
             }
             textStream << ">\n";
         }
     }
 
     textStream << "<!-- saved from: " << data.part->url().toDisplayString() << " -->\n";
 
     try {
         saveHTMLPartLower(data.document.documentElement(), 1, data);
     } catch (...) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "exception";
         Q_ASSERT(0);
     }
 }
 
 void ArchiveDialog::saveHTMLPartLower(const DOM::Node &pNode, int level, RecurseData &data)
 {
     const QString nodeName(pNode.nodeName().string().toUpper());
 
     //QString indent;
     //indent.fill(' ', level*2);
 
     bool skipElement   = false;
     bool fullEmptyTags = false;
     bool hasChildren   = const_cast<DOM::Node &>(pNode).hasChildNodes();
     QString text = QLatin1String("");
 
     bool isElement = !pNode.isNull() && (pNode.nodeType() == DOM::Node::ELEMENT_NODE);
 
     //qCDebug(WEBARCHIVERPLUGIN_LOG) << indent << "nodeName=" << nodeName << " toString()='" << pNode.toString() << "'";
     if (isElement) {
         const DOM::Element &element = static_cast<const DOM::Element &>(pNode);
         URLsInStyleElement::Iterator style_it = m_URLsInStyleElement.find(element);
         bool hasStyle = (style_it != m_URLsInStyleElement.end());
 
         if ((nodeName == QLatin1String("META")) && hasAttrWithValue(element, QStringLiteral("HTTP-EQUIV"), QStringLiteral("CONTENT-TYPE"))) {
             // Skip content-type meta tag, we provide our own.
             skipElement = true;
         } else if ((nodeName == QLatin1String("NOFRAMES")) && !hasChildren) {
             skipElement = true;
         } else {
 
             // translate URLs of stylesheets, jscript, images ...
 
             ExtractURLs eurls(nodeName, element);
 
             AttrList::Iterator filterOut1 = eurls.attrList.end();
             AttrList::Iterator filterOut2 = eurls.attrList.end();
             const AttrList::Iterator invalid = eurls.attrList.end();
 
             // make URLs in hyperref links absolute
             if (eurls.absURL != invalid) {
                 QUrl baseurl = absoluteURL(QLatin1String(""), data);
                 QUrl newurl = QUrl(baseurl).resolved(QUrl(parseURL((*eurls.absURL).value)));
                 if (urlCheckFailed(data.part, newurl)) {
                     (*eurls.absURL).value = QLatin1String("");
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "removing invalid/insecure href='" << newurl << "'";
                 } else {
                     //
                     // KUrl::htmlRef() calls internally fragment()->toPercent()->toLatin1()->fromLatin1()->fromPercent()
                     // This is slow of course and there would be only a difference if there is some suburl.
                     // Since we discard any urls with suburls for security reasons QUrl::fragment() is sufficient.
                     //
                     if (newurl.hasFragment() && baseurl.matches(newurl, QUrl::RemoveFragment)) {
                         (*eurls.absURL).value = QStringLiteral("#") + newurl.fragment();
                     } else {
                         (*eurls.absURL).value = newurl.url();
                     }
                 }
             }
 
             // make URLs of embedded objects local to tarfile
             if (eurls.transURL != invalid) {
                 // NOTE This is a bit inefficient, because the URL is computed twice, here and when obtaining all
                 // URLs first. However it is necessary, because two URLs that look different in the HTML frames (for
                 // example absolute and relative) may resolve to the same absolute URL
                 QUrl fullURL = absoluteURL(parseURL((*eurls.transURL).value), data);
                 UrlTarMap::Iterator it = m_url2tar.find(fullURL);
                 if (it == m_url2tar.end()) {
 
                     (*eurls.transURL).value = QLatin1String("");
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "removing invalid/insecure link='" << fullURL << "'";
 
                 } else {
 //                     assert( !it.value().tarName.isNull() );
                     (*eurls.transURL).value = it.value().tarName;
                 }
             }
 
             // Check stylesheet <link>s
             if (eurls.cssURL != invalid) {
 
                 QUrl fullURL = absoluteURL((*eurls.cssURL).value, data);
                 UrlTarMap::Iterator it = m_url2tar.find(fullURL);
 
                 if (it == m_url2tar.end()) {
 
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "removing invalid/insecure CSS link='" << fullURL << "'";
                     (*eurls.cssURL).value = QLatin1String("");
 
                 } else {
 //                     assert( !it.value().tarName.isNull() );
                     (*eurls.cssURL).value = it.value().tarName;
                 }
             }
 
             // Check for a frame with a name
             if (eurls.frameName != invalid) {
                 Name2Part &n2f = data.partFrameData->framesWithName;
                 Name2Part::Iterator n2f_part = n2f.find((*eurls.frameName).value);
 
                 if (n2f_part == n2f.end()) {
 
                     // KHTML ignores this frame tag, so remove it here
                     filterOut1 = eurls.frameName;
                     filterOut2 = eurls.frameURL;
 
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "emptying frame=" << (*eurls.frameName).value;
 
                 } else {
 
                     // Always add a 'src' attribute.  If it's not there, add one
                     if (eurls.frameURL == invalid) {
                         eurls.attrList.prepend(AttrElem(QStringLiteral("src"), QString::null));
                         eurls.frameURL = eurls.attrList.begin();
 
                         // NOTE Now that we changed the list, pray the older iterators of 'attrList' still work...
                     }
                     Part2TarName::Iterator p2tn_it = m_part2tarName.find(n2f_part.value());
                     Q_ASSERT(p2tn_it != m_part2tarName.end());
                     (*eurls.frameURL).value = p2tn_it.value();
 
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "setting frame='" << (*eurls.frameName).value << "' to src='"
                                   << (*eurls.frameURL).value;
                 }
 
             } else if (eurls.frameURL != invalid) {
 
                 URL2Part &u2f = data.partFrameData->framesWithURLOnly;
                 QUrl fullURL = absoluteURL((*eurls.frameURL).value, data);
                 URL2Part::Iterator u2f_part = u2f.find(fullURL);
 
                 if (u2f_part == u2f.end()) {
 
                     // KHTML ignores this frame tag, so remove it here
                     filterOut1 = eurls.frameURL;
 
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "emptying frame='" << (*eurls.frameURL).value << "'";
 
                 } else {
 
                     Part2TarName::Iterator p2tn_it = m_part2tarName.find(u2f_part.value());
                     Q_ASSERT(p2tn_it != m_part2tarName.end());
                     (*eurls.frameURL).value = p2tn_it.value();
 
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "setting frame='" << fullURL << "' to src='"
                                   << (*eurls.frameURL).value;
                 }
             }
 
             // Remove <base href=... > attribute
             if (nodeName == QLatin1String("BASE")) {
                 filterOut1 = getAttribute(eurls.attrList, QStringLiteral("href"));
                 data.baseSeen = true;
             }
 
             // Insert <head> tag if not found
             if (nodeName == QLatin1String("HTML")) {
                 if (!hasChildNode(pNode, QStringLiteral("HEAD"))) {
                     text += "<head>" CONTENT_TYPE "</head>\n";
                 }
                 fullEmptyTags = true;
                 // Always write out full closing tags for some tags
             } else if (nodeName == QLatin1String("HEAD") || nodeName == QLatin1String("FRAME") || nodeName == QLatin1String("IFRAME") || nodeName == QLatin1String("A") ||
                        nodeName == QLatin1String("DIV") || nodeName == QLatin1String("SPAN")) {
                 fullEmptyTags = true;
             }
 
             text += "<" + nodeName.toLower();
 
             // Write attributes
             for (AttrList::ConstIterator i = eurls.attrList.begin(); i != eurls.attrList.end(); ++i) {
                 QString attr  = (*i).name.toLower();
                 QString value = (*i).value;
                 if ((i != filterOut1) && (i != filterOut2)) {
                     if (hasStyle && (attr == QLatin1String("style"))) {
 //                         qCDebug(WEBARCHIVERPLUGIN_LOG) << "translating URLs in element:";
 //                         qCDebug(WEBARCHIVERPLUGIN_LOG) << "value=" << value;
                         changeCSSURLs(value, style_it.value());
 //                         qCDebug(WEBARCHIVERPLUGIN_LOG) << "value=" << value;
                     }
                     if (non_cdata_attr.find(attr) == non_cdata_attr.end()) {
                         value = escapeHTML(value);
                     }
                     text += " " + attr + "=\"" + value + "\"";
                 }
             }
 
             // Take care for self-contained tags like <hr />.  This code is needed to close such
             // tags later with '/>'. 'fullEmptyTags == true' means to always write an explicit
             // closing tag, e.g. <script></script>
             if (fullEmptyTags || hasChildren) {
                 text += QLatin1String(">");
             }
 
             if (nodeName == QLatin1String("HEAD")) {
                 text += CONTENT_TYPE "\n";
             }
         }
     } else {
         const QString &nodeValue(pNode.nodeValue().string());
         if (!(nodeValue.isEmpty())) {
             // Don't escape < > in JS or CSS
             DOM::Node parentNode = pNode.parentNode();
             QString parentNodeName = parentNode.nodeName().string().toUpper();
             if (parentNodeName == QLatin1String("STYLE")) {
                 text = pNode.nodeValue().string(); //analyzeInternalCSS(baseURL, pNode.nodeValue().string());
 
                 Node2StyleSheet::Iterator topcss_it = m_topStyleSheets.find(parentNode);
                 if (topcss_it != m_topStyleSheets.end()) {
                     URLsInStyleSheet::ConstIterator uss_it = m_URLsInStyleSheet.constFind(*topcss_it);
                     m_topStyleSheets.erase(topcss_it);  // for safety
                     assert(uss_it != m_URLsInStyleSheet.constEnd());
 
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "translating URLs in <style> area.";
                     changeCSSURLs(text, uss_it.value());
 
                 } else {
                     qCDebug(WEBARCHIVERPLUGIN_LOG) << "found style area '" << nodeName << "', but KHMTL didn't feel like parsing it";
                 }
 
             } else if (parentNodeName == QLatin1String("SCRIPT")) {
                 text = pNode.nodeValue().string();
             } else {
                 if (pNode.nodeType() == DOM::Node::COMMENT_NODE) {
                     text = QStringLiteral("<!--");
                     text += nodeValue.toHtmlEscaped();  // No need to escape " as well
                     text += QLatin1String("-->");
                 } else {
                     text = escapeHTML(nodeValue);
                 }
             }
         }
     }
 
     (*data.textStream) << text;
 
     if (! pNode.isNull()) {
         DOM::Node child = pNode.firstChild();
         while (! child.isNull()) {
             saveHTMLPartLower(child, level + 1, data);
             child = child.nextSibling();
         }
     }
 
     if (isElement && !skipElement) {
         if (fullEmptyTags || hasChildren) {
             text = "</" + nodeName.toLower() + ">";
         } else {
             text = QStringLiteral(" />"); // close self-contained tags
         }
         (*data.textStream) << text;
     }
 }
 
 QString ArchiveDialog::extractCSSURL(const QString &text)
 {
     if (text.startsWith(QLatin1String("url(")) && text.endsWith(QLatin1String(")"))) {
         return text.mid(4, text.length() - 5);
     } else {
         return QString::null;
     }
 }
 
 QString &ArchiveDialog::changeCSSURLs(QString &text, const RawHRef2FullURL &raw2full)
 {
     FOR_CONST_ITER(RawHRef2FullURL, raw2full, r2f_it) {
         const QString &raw  = r2f_it.key();
         const QUrl &fullURL = r2f_it.value();
         if (fullURL.isValid()) {
             UrlTarMap::Iterator utm_it = m_url2tar.find(fullURL);
             if (utm_it != m_url2tar.end()) {
                 const QString &tarName = utm_it.value().tarName;
 //                 assert(! tarName.isNull());
 
                 qCDebug(WEBARCHIVERPLUGIN_LOG) << "changeCSSURLs: url=" << raw << " -> " << tarName;
                 text.replace(raw, tarName);
             } else {
                 qCDebug(WEBARCHIVERPLUGIN_LOG) << "changeCSSURLs: raw URL not found in tar map";
                 text.replace(raw, QLatin1String(""));
             }
         } else {
             qCDebug(WEBARCHIVERPLUGIN_LOG) << "changeCSSURLs: emptying invalid raw URL";
             text.replace(raw, QLatin1String(""));
         }
     }
     return text;
 }
 
 ArchiveDialog::ExtractURLs::ExtractURLs(const QString &nodeName, const DOM::Element &element)
 {
 
     DOM::NamedNodeMap attrs = element.attributes();
     int lmap = static_cast<int>(attrs.length());    // More than 2^31 attributes? hardly...
     for (int j = 0; j != lmap; ++j) {
         DOM::Attr attr = static_cast<DOM::Attr>(attrs.item(j));
         attrList.append(AttrElem(attr.name().string(), attr.value().string()));
     }
 
     AttrList::Iterator rel        = attrList.end();
     AttrList::Iterator href       = attrList.end();
     AttrList::Iterator src        = attrList.end();
     AttrList::Iterator name       = attrList.end();
     AttrList::Iterator background = attrList.end();
     AttrList::Iterator invalid    = attrList.end();
     for (AttrList::Iterator i = attrList.begin(); i != attrList.end(); ++i) {
         QString attrName  = (*i).name.toUpper();
         if (attrName == QLatin1String("REL")) {
             rel = i;
         } else if (attrName == QLatin1String("HREF")) {
             href = i;
         } else if (attrName == QLatin1String("BACKGROUND")) {
             background = i;
         } else if (attrName == QLatin1String("SRC")) {
             src = i;
         } else if (attrName == QLatin1String("NAME")) {
             name = i;
         }
     }
 
     //
     // Check attributes
     //
     transURL  =
         absURL    =
             frameURL  =
                 frameName =
                     cssURL    = attrList.end();
     if ((nodeName == QLatin1String("A")) && (href != invalid)) {
         absURL = href;
     } else if ((nodeName == QLatin1String("LINK")) && (rel != invalid) && (href != invalid)) {
         QString relUp = (*rel).value.toUpper();
         if (relUp == QLatin1String("STYLESHEET")) {
             cssURL = href;
         } else if (relUp == QLatin1String("SHORTCUT ICON")) {
             transURL = href;
         } else {
             absURL = href;
         }
     } else if (nodeName == QLatin1String("FRAME") || nodeName == QLatin1String("IFRAME")) {
         if (src != invalid) {
             frameURL = src;
         }
         if (name != invalid) {
             frameName = name;
         }
     } else if ((nodeName == QLatin1String("IMG") || nodeName == QLatin1String("INPUT") || nodeName == QLatin1String("SCRIPT")) && (src != invalid)) {
         transURL = src;
     } else if ((nodeName == QLatin1String("BODY") || nodeName == QLatin1String("TABLE") || nodeName == QLatin1String("TH") || nodeName == QLatin1String("TD")) &&
                (background != invalid)) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "found background URL " << (*background).value;
         transURL = background;
     }
 }
 
 bool ArchiveDialog::hasAttrWithValue(const DOM::Element &elem, const QString &attrName, const QString &attrValue)
 {
     DOM::Attr attr = const_cast<DOM::Element &>(elem).getAttributeNode(attrName);
 
     if (!attr.isNull()) {
         return attr.value().string().toUpper() == attrValue;
     } else {
         return false;
     }
 }
 
 bool ArchiveDialog::hasChildNode(const DOM::Node &pNode, const QString &nodeName)
 {
     DOM::Node child;
     try {
         // We might throw a DOM exception
         child = pNode.firstChild();
     } catch (...) {
         // No children, stop recursion here
         child = DOM::Node();
     }
 
     while (!child.isNull()) {
         if (child.nodeName().string().toUpper() == nodeName) {
             return true;
         }
         child = child.nextSibling();
     }
     return false;
 }
 
 ArchiveDialog::AttrList::Iterator ArchiveDialog::getAttribute(AttrList &attrList, const QString &attr)
 {
     FOR_ITER(AttrList, attrList, it) {
         if ((*it).name == attr) {
             return it;
         }
     }
     return attrList.end();
 }
 
 QUrl ArchiveDialog::absoluteURL(const QString &partURL, RecurseData &data)
 {
     if (data.baseSeen) {
         return QUrl(data.document.completeURL(partURL).string());
     } else {
         return QUrl(data.part->url()).resolved(QUrl(partURL));
     }
 }
 
 // TODO Should be khtml::parseURL
 QString ArchiveDialog::parseURL(const QString &rawurl)
 {
     QString result = rawurl;
     return result.replace(QRegExp("[\\x0000-\\x000D]"), QLatin1String(""));
 }
 
 QString ArchiveDialog::uniqTarName(const QString &suggestion, KHTMLPart *part)
 {
 
     QString result = suggestion;
 
     // Name clash -> add unique id
     while (result.isEmpty() || m_tarName2part.contains(result)) {
         result = QString::number(m_uniqId++) + suggestion;
     }
     m_tarName2part.insert(result, part);
 
     return result;
 }
 
 bool ArchiveDialog::urlCheckFailed(KHTMLPart *part, const QUrl &fullURL)
 {
     if (!fullURL.isValid()) {
         return true;
     }
 
     QString prot = fullURL.scheme();
     bool protFile = (prot == QLatin1String("file"));
     if (part->onlyLocalReferences() && !protFile) {
         return true;
     }
 
     bool protHttp = (prot == QLatin1String("http")) || (prot == QLatin1String("https"));
     if (!protFile && !protHttp) {
         return true;
     }
 
     if (! KUrlAuthorized::authorizeUrlAction(QStringLiteral("redirect"), part->url(), fullURL) ||
             ! KUrlAuthorized::authorizeUrlAction(QStringLiteral("open"), part->url(), fullURL)) {
         return true;
     }
 
     return false;
 }
 
 QString ArchiveDialog::escapeHTML(const QString &in)
 {
     return in.toHtmlEscaped().replace('"', QLatin1String("&quot;"));
 }
 
 QString ArchiveDialog::appendMimeTypeSuffix(QString filename, const QString &mimetype)
 {
     KMimeType::Ptr mimeType = KMimeType::mimeType(mimetype, KMimeType::ResolveAliases);
     if (mimeType.isNull() || (mimeType == KMimeType::defaultMimeTypePtr())) {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "mimetype" << mimetype << "unknown here, returning unchanged";
         return filename;
     }
     const QStringList &patterns = mimeType->patterns();
     FOR_CONST_ITER(QStringList, patterns, pat_it) {
         // Lets hope all patterns are '*.xxx'
         QString suffix(*pat_it);
         int pos = suffix.lastIndexOf('*');
         if (pos < 0) {
             qCDebug(WEBARCHIVERPLUGIN_LOG) << "Illegal mime pattern '" << suffix << "for" << mimeType;
             Q_ASSERT(0);
             continue;
         }
         suffix = suffix.mid(pos + 1);
         if (filename.endsWith(suffix, Qt::CaseInsensitive)) {
 //             qCDebug(WEBARCHIVERPLUGIN_LOG) << filename << "has already good suffix" << suffix;
             return filename;    // already has good suffix
         }
     }
     //
     // @c filename has no known suffix, append one
     //
     if (! patterns.isEmpty()) {
         QString suffix(*patterns.constBegin());
         suffix.replace('*', QString::null);
         filename += suffix;
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "appended missing mimetype suffix, returning" << filename;
     } else {
         qCDebug(WEBARCHIVERPLUGIN_LOG) << "mimetype" << mimetype << " has no pattern list, this is bad";
         Q_ASSERT(0);
     }
     return filename;
 }
diff --git a/plugins/webarchiver/plugin_webarchiver.cpp b/plugins/webarchiver/plugin_webarchiver.cpp
index 3446fb75c..78901d03e 100644
--- a/plugins/webarchiver/plugin_webarchiver.cpp
+++ b/plugins/webarchiver/plugin_webarchiver.cpp
@@ -1,144 +1,145 @@
 /* This file is part of Webarchiver
  *  Copyright (C) 2001 by Andreas Schlapbach <schlpbch@iam.unibe.ch>
  *
  *  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.
  **/
 
 /* $Id$ */
 
 /*
  * There are two recursions within this code:
  * - Recursively create DOM-Tree for referenced links which get recursively
  *   converted to HTML
  *
  * => This code has the potential to download whole sites to a TarGz-Archive
  */
 
 //#define DEBUG_WAR
 
+#include "plugin_webarchiver.h"
+
 #include <QDir>
 #include <QFile>
 #include <QIcon>
 #include <QUrl>
 
 
 #include <kcomponentdata.h>
 
 #include <kfiledialog.h>
 #include <kmessagebox.h>
 #include <KLocalizedString>
 #include <khtmlview.h>
 #include <khtml_part.h>
 #include <kpluginfactory.h>
 #include <kactioncollection.h>
 #include <kstandardguiitem.h>
 #include <QStandardPaths>
-#include "plugin_webarchiver.h"
 #include "archivedialog.h"
 
 K_PLUGIN_FACTORY(PluginWebArchiverFactory, registerPlugin<PluginWebArchiver>();)
 K_EXPORT_PLUGIN(PluginWebArchiverFactory("webarchiver"))
 
 PluginWebArchiver::PluginWebArchiver(QObject *parent,
                                      const QVariantList &)
     : Plugin(parent)
 {
     QAction *a = actionCollection()->addAction(QStringLiteral("archivepage"));
     a->setText(i18n("Archive &Web Page..."));
     a->setIcon(QIcon::fromTheme(QStringLiteral("webarchiver")));
     connect(a, SIGNAL(triggered()), this, SLOT(slotSaveToArchive()));
 }
 
 PluginWebArchiver::~PluginWebArchiver()
 {
 }
 
 void PluginWebArchiver::slotSaveToArchive()
 {
     // ## Unicode ok?
     if (!parent() || !parent()->inherits("KHTMLPart")) {
         return;
     }
     KHTMLPart *part = qobject_cast<KHTMLPart *>(parent());
 
     QString archiveName = QString::fromUtf8(part->htmlDocument().title().string().toUtf8());
 
     if (archiveName.isEmpty()) {
         archiveName = i18n("Untitled");
     }
 
     KConfig config(QStringLiteral("webarchiverrc"), KConfig::SimpleConfig);
     KConfigGroup configGroup = config.group("Recent");
 
     archiveName = archiveName.simplified();
     archiveName.replace(QLatin1String("\\s:"), QLatin1String(" "));      // what is this intended to do?
     archiveName.replace(QLatin1String("?"), QLatin1String(""));
     archiveName.replace(QLatin1String(":"), QLatin1String(""));
     archiveName.replace(QLatin1String("/"), QLatin1String(""));
     // Replace space with underscore, proposed Frank Pieczynski <pieczy@knuut.de>
     archiveName = archiveName.replace(QRegExp("\\s+"), QStringLiteral("_"));
 
     QString lastCWD = configGroup.readPathEntry("savedialogcwd",
                       QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
     archiveName = lastCWD + "/" + archiveName + ".war";
 
     QUrl url = KFileDialog::getSaveUrl(QUrl::fromLocalFile(archiveName), i18n("*.war *.tgz|Web Archives"), part->widget(),
                                        i18n("Save Page as Web-Archive"));
 
     if (url.isEmpty()) {
         return;
     }
 
     if (!url.isValid()) {
         const QString title = i18nc("@title:window", "Invalid URL");
         const QString text = i18n("The URL\n%1\nis not valid.", url.toString());
         KMessageBox::sorry(part->widget(), text, title);
         return;
     }
 
     lastCWD = url.adjusted(QUrl::RemoveFilename).toLocalFile();
     if (! lastCWD.isNull()) {
         configGroup.writePathEntry("savedialogcwd", lastCWD);
         config.sync();
     }
 
     const QFile file(url.path());
     if (file.exists()) {
         const QString title = i18nc("@title:window", "File Exists");
         const QString text = i18n("Do you really want to overwrite:\n%1?", url.toDisplayString());
         if (KMessageBox::Continue != KMessageBox::warningContinueCancel(part->widget(), text, title, KStandardGuiItem::overwrite())) {
             return;
         }
     }
 
     //
     // It is very important to make the archive dialog a child of the KHTMLPart!
     // If not crashes due to dangling refs will happen. For example if Konqueror quits
     // while archiving runs @c part becomes invalid. Furthermore the various @ref QHash<>
     // members of @ref ArchiveDialog contain DOM elements that use ref counting. Upon
     // exit of Konqueror @c part gets destroyed *before* our @ref ArchiveDialog . Since
     // our running ArchiveDialog keeps the DOM ref counts up KHTML triggers an assertion
     // in KHTMLGlobal
     //
     // In contrast if @ref ArchiveDialog is a child of the part view Qt ensures that all
     // child dialogs are destroyed _before_ @c part is destroyed.
     //
     ArchiveDialog *dialog = new ArchiveDialog(part->view(), url.path(), part);
     dialog->show();
     dialog->archive();
 }
 
 #include "plugin_webarchiver.moc"
diff --git a/settings/konqhtml/appearance.cpp b/settings/konqhtml/appearance.cpp
index 2a8349fbb..e7eee2311 100644
--- a/settings/konqhtml/appearance.cpp
+++ b/settings/konqhtml/appearance.cpp
@@ -1,439 +1,439 @@
+#include "appearance.h"
+
 #include "kcmcss.h"
 
 #include <QFormLayout>
 #include <QDBusMessage>
 #include <QDBusConnection>
 #include <QGroupBox>
 
 #include <kcharsets.h>
 #include <ksharedconfig.h>
 #include <kdebug.h>
 #include <kdialog.h>
 #include <kglobal.h>
 #include <khtmldefaults.h>
 #include <KLocalizedString>
 #include <knuminput.h>
 #include <KPluginFactory>
 #include <KPluginLoader>
 #include <QFontComboBox>
 #include <KTabWidget>
 #include <QFontDatabase>
 #include <QSpinBox>
 
-#include "appearance.h"
-
 static const char *const animationValues[] = {"Enabled", "Disabled", "LoopOnce"};
 enum AnimationsType { AnimationsAlways = 0, AnimationsNever = 1, AnimationsLoopOnce = 2 };
 
 static const char *const smoothScrollingValues[] = {"Enabled", "Disabled", "WhenEfficient"};
 enum SmoothScrollingType { SmoothScrollingAlways = 0, SmoothScrollingNever = 1, SmoothScrollingWhenEfficient = 2 };
 
 enum UnderlineLinkType { UnderlineAlways = 0, UnderlineNever = 1, UnderlineHover = 2 };
 
 KAppearanceOptions::KAppearanceOptions(QWidget *parent, const QVariantList &)
     : KCModule(parent), m_groupname(QStringLiteral("HTML Settings")),
       fSize(10), fMinSize(HTML_DEFAULT_MIN_FONT_SIZE)
 
 {
     QVBoxLayout *l = new QVBoxLayout(this);
     KTabWidget *tab = new KTabWidget(this);
     l->addWidget(tab);
     QWidget *mainTab = new QWidget(this);
     QWidget *fontsTab = new QWidget(this);
     cssConfig = new CSSConfig(this);
     tab->addTab(mainTab, i18nc("@title:tab", "General"));
     tab->addTab(fontsTab, i18nc("@title:tab", "Fonts"));
     tab->addTab(cssConfig, i18nc("@title:tab", "Stylesheets"));
 
     connect(cssConfig, SIGNAL(changed()), this, SLOT(changed()));
     connect(cssConfig, SIGNAL(changed(bool)), this, SIGNAL(changed(bool)));
 
     l = new QVBoxLayout(mainTab);
 
     //Images
     QGroupBox *box = new QGroupBox(i18n("Images"), mainTab);
     l->addWidget(box);
     QFormLayout *fl = new QFormLayout(box);
 
     m_pAutoLoadImagesCheckBox = new QCheckBox(i18n("A&utomatically load images"), this);
     m_pAutoLoadImagesCheckBox->setWhatsThis(i18n("<html>If this box is checked, Konqueror will"
                                             " automatically load any images that are embedded in a web page."
                                             " Otherwise, it will display placeholders for the images, and"
                                             " you can then manually load the images by clicking on the image"
                                             " button.<br />Unless you have a very slow network connection, you"
                                             " will probably want to check this box to enhance your browsing"
                                             " experience.</html>"));
     connect(m_pAutoLoadImagesCheckBox, SIGNAL(toggled(bool)), SLOT(changed()));
     fl->addRow(m_pAutoLoadImagesCheckBox);
 
     m_pUnfinishedImageFrameCheckBox = new QCheckBox(i18n("Dra&w frame around not completely loaded images"), this);
     m_pUnfinishedImageFrameCheckBox->setWhatsThis(i18n("<html>If this box is checked, Konqueror will draw"
             " a frame as a placeholder around images embedded in a web page that are"
             " not yet fully loaded.<br />You will probably want to check this box to"
             " enhance your browsing experience, especially if have a slow network"
             " connection.</html>"));
     connect(m_pUnfinishedImageFrameCheckBox, SIGNAL(toggled(bool)), SLOT(changed()));
     fl->addRow(m_pUnfinishedImageFrameCheckBox);
 
     m_pAnimationsCombo = new QComboBox(this);
     m_pAnimationsCombo->setEditable(false);
     m_pAnimationsCombo->insertItem(AnimationsAlways, i18nc("animations", "Enabled"));
     m_pAnimationsCombo->insertItem(AnimationsNever, i18nc("animations", "Disabled"));
     m_pAnimationsCombo->insertItem(AnimationsLoopOnce, i18n("Show Only Once"));
     m_pAnimationsCombo->setWhatsThis(i18n("<html>Controls how Konqueror shows animated images:<br />"
                                           "<ul><li><b>Enabled</b>: Show all animations completely.</li>"
                                           "<li><b>Disabled</b>: Never show animations, show the starting image only.</li>"
                                           "<li><b>Show only once</b>: Show all animations completely but do not repeat them.</li></ul></html>"));
     connect(m_pAnimationsCombo, SIGNAL(currentIndexChanged(int)), SLOT(changed()));
     fl->addRow(i18n("A&nimations:"), m_pAnimationsCombo);
 
     //Other
     box = new QGroupBox(i18nc("@title:group", "Miscellaneous"), mainTab);
     l->addWidget(box);
     fl = new QFormLayout(box);
     m_pUnderlineCombo = new QComboBox(this);
     m_pUnderlineCombo->setEditable(false);
     m_pUnderlineCombo->insertItem(UnderlineAlways, i18nc("underline", "Enabled"));
     m_pUnderlineCombo->insertItem(UnderlineNever, i18nc("underline", "Disabled"));
     m_pUnderlineCombo->insertItem(UnderlineHover, i18n("Only on Hover"));
     fl->addRow(i18n("Und&erline links:"), m_pUnderlineCombo);
 
     m_pUnderlineCombo->setWhatsThis(i18n(
                                         "<html>Controls how Konqueror handles underlining hyperlinks:<br />"
                                         "<ul><li><b>Enabled</b>: Always underline links</li>"
                                         "<li><b>Disabled</b>: Never underline links</li>"
                                         "<li><b>Only on Hover</b>: Underline when the mouse is moved over the link</li>"
                                         "</ul><br /><i>Note: The site's CSS definitions can override this value.</i></html>"));
     connect(m_pUnderlineCombo, SIGNAL(currentIndexChanged(int)), SLOT(changed()));
 
     m_pSmoothScrollingCombo = new QComboBox(this);
     m_pSmoothScrollingCombo->setEditable(false);
     m_pSmoothScrollingCombo->insertItem(SmoothScrollingWhenEfficient, i18n("When Efficient"));
     m_pSmoothScrollingCombo->insertItem(SmoothScrollingAlways, i18nc("smooth scrolling", "Always"));
     m_pSmoothScrollingCombo->insertItem(SmoothScrollingNever, i18nc("soft scrolling", "Never"));
     fl->addRow(i18n("S&mooth scrolling:"), m_pSmoothScrollingCombo);
     m_pSmoothScrollingCombo->setWhatsThis(i18n(
             "<html>Determines whether Konqueror should use smooth steps to scroll HTML pages, or whole steps:<br />"
             "<ul><li><b>Always</b>: Always use smooth steps when scrolling.</li>"
             "<li><b>Never</b>: Never use smooth scrolling, scroll with whole steps instead.</li>"
             "<li><b>When Efficient</b>: Only use smooth scrolling on pages where it can be achieved with moderate usage of system resources.</li></ul></html>"));
     connect(m_pSmoothScrollingCombo, SIGNAL(currentIndexChanged(int)), SLOT(changed()));
 
     l->addStretch(5);
 
     m_pConfig = KSharedConfig::openConfig(QStringLiteral("konquerorrc"), KConfig::NoGlobals);
     setQuickHelp(i18n("<h1>Konqueror Fonts</h1>On this page, you can configure "
                       "which fonts Konqueror should use to display the web "
                       "pages you view.") + "<br /><br />" + cssConfig->whatsThis());
 
     QString empty;
     //initialise fonts list otherwise it crashs
     while (fonts.count() < 7) {
         fonts.append(empty);
     }
 
     QVBoxLayout *lay = new QVBoxLayout(fontsTab);
 
     QGroupBox *gb = new QGroupBox(i18n("Font Si&ze"));
     lay->addWidget(gb);
     fl = new QFormLayout(gb);
     gb->setWhatsThis(i18n("This is the relative font size Konqueror uses to display web sites."));
 
     m_minSize = new QSpinBox;
     m_minSize->setValue(fMinSize);
     fl->addRow(i18n("M&inimum font size:"), m_minSize);
     m_minSize->setRange(2, 30);
     connect(m_minSize, SIGNAL(valueChanged(int)), this, SLOT(slotMinimumFontSize(int)));
     connect(m_minSize, SIGNAL(valueChanged(int)), this, SLOT(changed()));
     m_minSize->setWhatsThis("<qt>" + i18n("Konqueror will never display text smaller than "
                                           "this size,<br />overriding any other settings.") + "</qt>");
 
     m_MedSize = new QSpinBox(m_minSize);
     m_MedSize->setValue(fSize);
     fl->addRow(i18n("&Medium font size:"), m_MedSize);
     m_MedSize->setRange(2, 30);
     connect(m_MedSize, SIGNAL(valueChanged(int)), this, SLOT(slotFontSize(int)));
     connect(m_MedSize, SIGNAL(valueChanged(int)), this, SLOT(changed()));
     m_MedSize->setWhatsThis(
         i18n("This is the relative font size Konqueror uses "
              "to display web sites."));
 
     box = new QGroupBox(/*i18n("Font Families")*/);
     lay->addWidget(box);
     fl = new QFormLayout(box);
 
     m_pFonts[0] = new QFontComboBox(fontsTab);
     fl->addRow(i18n("S&tandard font:"), m_pFonts[0]);
     m_pFonts[0]->setWhatsThis(i18n("This is the font used to display normal text in a web page."));
     connect(m_pFonts[0], SIGNAL(currentFontChanged(QFont)),
             SLOT(slotStandardFont(QFont)));
 
     m_pFonts[1] = new QFontComboBox(fontsTab);
     fl->addRow(i18n("&Fixed font:"), m_pFonts[1]);
     m_pFonts[1]->setWhatsThis(i18n("This is the font used to display fixed-width (i.e. non-proportional) text."));
     connect(m_pFonts[1], SIGNAL(currentFontChanged(QFont)),
             SLOT(slotFixedFont(QFont)));
 
     m_pFonts[2] = new QFontComboBox(this);
     fl->addRow(i18n("S&erif font:"),  m_pFonts[2]);
     m_pFonts[2]->setWhatsThis(i18n("This is the font used to display text that is marked up as serif."));
 
     connect(m_pFonts[2], SIGNAL(currentFontChanged(QFont)),
             SLOT(slotSerifFont(QFont)));
 
     m_pFonts[3] = new QFontComboBox(this);
     fl->addRow(i18n("Sa&ns serif font:"),  m_pFonts[3]);
     m_pFonts[3]->setWhatsThis(i18n("This is the font used to display text that is marked up as sans-serif."));
     connect(m_pFonts[3], SIGNAL(currentFontChanged(QFont)),
             SLOT(slotSansSerifFont(QFont)));
 
     m_pFonts[4] = new QFontComboBox(this);
     fl->addRow(i18n("C&ursive font:"),  m_pFonts[4]);
     m_pFonts[4]->setWhatsThis(i18n("This is the font used to display text that is marked up as italic."));
     connect(m_pFonts[4], SIGNAL(currentFontChanged(QFont)),
             SLOT(slotCursiveFont(QFont)));
 
     m_pFonts[5] = new QFontComboBox(this);
     fl->addRow(i18n("Fantas&y font:"), m_pFonts[5]);
     m_pFonts[5]->setWhatsThis(i18n("This is the font used to display text that is marked up as a fantasy font."));
     connect(m_pFonts[5], SIGNAL(currentFontChanged(QFont)),
             SLOT(slotFantasyFont(QFont)));
 
     for (int i = 0; i < 6; ++i)
         connect(m_pFonts[i], SIGNAL(currentFontChanged(QFont)),
                 SLOT(changed()));
 
     m_pFontSizeAdjust = new QSpinBox(this);
     m_pFontSizeAdjust->setRange(-5, 5);
     m_pFontSizeAdjust->setSingleStep(1);
     fl->addRow(i18n("Font &size adjustment for this encoding:"), m_pFontSizeAdjust);
 
     connect(m_pFontSizeAdjust, SIGNAL(valueChanged(int)),
             SLOT(slotFontSizeAdjust(int)));
     connect(m_pFontSizeAdjust, SIGNAL(valueChanged(int)),
             SLOT(changed()));
 
     m_pEncoding = new QComboBox(this);
     m_pEncoding->setEditable(false);
     encodings = KCharsets::charsets()->availableEncodingNames();
     encodings.prepend(i18n("Use Language Encoding"));
     m_pEncoding->addItems(encodings);
     fl->addRow(i18n("Default encoding:"), m_pEncoding);
 
     m_pEncoding->setWhatsThis(i18n("Select the default encoding to be used; normally, you will be fine with 'Use language encoding' "
                                    "and should not have to change this."));
 
     connect(m_pEncoding, SIGNAL(activated(QString)),
             SLOT(slotEncoding(QString)));
     connect(m_pEncoding, SIGNAL(activated(QString)),
             SLOT(changed()));
 
     lay->addStretch(5);
 }
 
 KAppearanceOptions::~KAppearanceOptions()
 {
 }
 
 void KAppearanceOptions::slotFontSize(int i)
 {
     fSize = i;
     if (fSize < fMinSize) {
         m_minSize->setValue(fSize);
         fMinSize = fSize;
     }
 }
 
 void KAppearanceOptions::slotMinimumFontSize(int i)
 {
     fMinSize = i;
     if (fMinSize > fSize) {
         m_MedSize->setValue(fMinSize);
         fSize = fMinSize;
     }
 }
 
 void KAppearanceOptions::slotStandardFont(const QFont &n)
 {
     fonts[0] = n.family();
 }
 
 void KAppearanceOptions::slotFixedFont(const QFont &n)
 {
     fonts[1] = n.family();
 }
 
 void KAppearanceOptions::slotSerifFont(const QFont &n)
 {
     fonts[2] = n.family();
 }
 
 void KAppearanceOptions::slotSansSerifFont(const QFont &n)
 {
     fonts[3] = n.family();
 }
 
 void KAppearanceOptions::slotCursiveFont(const QFont &n)
 {
     fonts[4] = n.family();
 }
 
 void KAppearanceOptions::slotFantasyFont(const QFont &n)
 {
     fonts[5] = n.family();
 }
 
 void KAppearanceOptions::slotFontSizeAdjust(int value)
 {
     fonts[6] = QString::number(value);
 }
 
 void KAppearanceOptions::slotEncoding(const QString &n)
 {
     encodingName = n;
 }
 
 static int stringToIndex(const char *const *possibleValues, int possibleValuesCount, int defaultValue, const QString &value)
 {
     int i = possibleValuesCount;
     while (--i >= 0)
         if (possibleValues[i] == value) {
             break;
         }
     if (i == -1) {
         i = defaultValue;
     }
     return i;
 }
 
 void KAppearanceOptions::load()
 {
     KConfigGroup khtmlrc(KSharedConfig::openConfig(QStringLiteral("khtmlrc"), KConfig::NoGlobals), "");
     KConfigGroup cg(m_pConfig, "");
 #define SET_GROUP(x) cg = KConfigGroup(m_pConfig,x); khtmlrc = KConfigGroup(KSharedConfig::openConfig("khtmlrc", KConfig::NoGlobals),x)
 #define READ_NUM(x,y) cg.readEntry(x, khtmlrc.readEntry(x, y))
 #define READ_LIST(x) cg.readEntry(x, khtmlrc.readEntry(x, QStringList() ))
 #define READ_BOOL(x,y) cg.readEntry(x, khtmlrc.readEntry(x, y))
 #define READ_ENTRYNODEFAULT(x) cg.readEntry(x, khtmlrc.readEntry(x))
 
     SET_GROUP(m_groupname);
     fSize = READ_NUM("MediumFontSize", 12);
     fMinSize = READ_NUM("MinimumFontSize", HTML_DEFAULT_MIN_FONT_SIZE);
     if (fSize < fMinSize) {
         fSize = fMinSize;
     }
 
     defaultFonts = QStringList();
     defaultFonts.append(QFontDatabase::systemFont(QFontDatabase::GeneralFont).family());
     defaultFonts.append(QFontDatabase::systemFont(QFontDatabase::FixedFont).family());
     defaultFonts.append(HTML_DEFAULT_VIEW_SERIF_FONT);
     defaultFonts.append(HTML_DEFAULT_VIEW_SANSSERIF_FONT);
     defaultFonts.append(HTML_DEFAULT_VIEW_CURSIVE_FONT);
     defaultFonts.append(HTML_DEFAULT_VIEW_FANTASY_FONT);
     defaultFonts.append(QStringLiteral("0"));   // default font size adjustment
 
     if (cg.hasKey("Fonts")) {
         fonts = cg.readEntry("Fonts", QStringList());
     } else {
         fonts = khtmlrc.readEntry("Fonts", QStringList());
     }
     while (fonts.count() < 7) {
         fonts.append(QString());
     }
 
     encodingName = READ_ENTRYNODEFAULT("DefaultEncoding"); //TODO move
     //kDebug(0) << "encoding = " << encodingName;
 
     m_pAutoLoadImagesCheckBox->setChecked(READ_BOOL("AutoLoadImages", true));
     m_pUnfinishedImageFrameCheckBox->setChecked(READ_BOOL("UnfinishedImageFrame", true));
 
     m_pAnimationsCombo->setCurrentIndex(stringToIndex(animationValues,      sizeof(animationValues) / sizeof(char *),      /*default*/2, READ_ENTRYNODEFAULT("ShowAnimations")));
     m_pSmoothScrollingCombo->setCurrentIndex(stringToIndex(smoothScrollingValues, sizeof(smoothScrollingValues) / sizeof(char *),/*default*/2, READ_ENTRYNODEFAULT("SmoothScrolling")));
     // we use two keys for link underlining so that this config file
     // is backwards compatible with KDE 2.0.  the HoverLink setting
     // has precedence over the UnderlineLinks setting
     if (READ_BOOL("HoverLinks", true)) {
         m_pUnderlineCombo->setCurrentIndex(UnderlineHover);
     } else {
         m_pUnderlineCombo->setCurrentIndex(READ_BOOL("UnderlineLinks", true) ? UnderlineAlways : UnderlineNever);
     }
 
     cssConfig->load();
 
     updateGUI();
     emit changed(false);
 }
 
 void KAppearanceOptions::defaults()
 {
     bool old = m_pConfig->readDefaults();
     m_pConfig->setReadDefaults(true);
     load();
     m_pConfig->setReadDefaults(old);
 
     cssConfig->defaults();
     emit changed(true);
 }
 
 void KAppearanceOptions::updateGUI()
 {
     //kDebug() << "KAppearanceOptions::updateGUI " << charset;
     for (int f = 0; f < 6; f++) {
         QString ff = fonts[f];
         if (ff.isEmpty()) {
             ff = defaultFonts[f];
         }
         m_pFonts[f]->setCurrentFont(ff);
     }
 
     int i = 0;
     QStringList::const_iterator end = encodings.constEnd();
     for (QStringList::const_iterator it = encodings.constBegin(); it != end; ++it, ++i)
         if (encodingName == *it) {
             m_pEncoding->setCurrentIndex(i);
         }
     if (encodingName.isEmpty()) {
         m_pEncoding->setCurrentIndex(0);
     }
     m_pFontSizeAdjust->setValue(fonts[6].toInt());
     m_MedSize->blockSignals(true);
     m_MedSize->setValue(fSize);
     m_MedSize->blockSignals(false);
     m_minSize->blockSignals(true);
     m_minSize->setValue(fMinSize);
     m_minSize->blockSignals(false);
 }
 
 void KAppearanceOptions::save()
 {
     KConfigGroup cg(m_pConfig, m_groupname);
     cg.writeEntry("MediumFontSize", fSize);
     cg.writeEntry("MinimumFontSize", fMinSize);
     cg.writeEntry("Fonts", fonts);
 
     //TODO move to behaviour
     // If the user chose "Use language encoding", write an empty string
     if (encodingName == i18n("Use Language Encoding")) {
         encodingName = QLatin1String("");
     }
     cg.writeEntry("DefaultEncoding", encodingName);
 
     //Images
     cg.writeEntry("AutoLoadImages", m_pAutoLoadImagesCheckBox->isChecked());
     cg.writeEntry("UnfinishedImageFrame", m_pUnfinishedImageFrameCheckBox->isChecked());
     cg.writeEntry("ShowAnimations", animationValues[m_pAnimationsCombo->currentIndex()]);
     cg.writeEntry("UnderlineLinks", m_pUnderlineCombo->currentIndex() == UnderlineAlways);
     cg.writeEntry("HoverLinks", m_pUnderlineCombo->currentIndex() == UnderlineHover);
     cg.writeEntry("SmoothScrolling", smoothScrollingValues[m_pSmoothScrollingCombo->currentIndex()]);
 
     cssConfig->save();
 
     cg.sync();
     // Send signal to all konqueror instances
     QDBusMessage message =
         QDBusMessage::createSignal(QStringLiteral("/KonqMain"), QStringLiteral("org.kde.Konqueror.Main"), QStringLiteral("reparseConfiguration"));
     QDBusConnection::sessionBus().send(message);
 
     emit changed(false);
 }
 
diff --git a/sidebar/test/konqsidebartest.cpp b/sidebar/test/konqsidebartest.cpp
index ff176dddf..eaa9c2d96 100644
--- a/sidebar/test/konqsidebartest.cpp
+++ b/sidebar/test/konqsidebartest.cpp
@@ -1,26 +1,26 @@
 /***************************************************************************
                              konqsidebartest.cpp
                              -------------------
     begin                : Sat June 2 16:25:27 CEST 2001
     copyright            : (C) 2001 Joseph Wenninger
     email                : jowenn@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.                                   *
  *                                                                         *
  ***************************************************************************/
-#include <kcomponentdata.h>
 #include "konqsidebartest.h"
+#include <kcomponentdata.h>
 
 extern "C"
 {
     Q_DECL_EXPORT void *create_konq_sidebartest(QWidget *parent, const QString &desktopname, const KConfigGroup &configGroup)
     {
         return new SidebarTest(parent, desktopname, configGroup);
     }
 }
diff --git a/src/KonqMainWindowAdaptor.h b/src/KonqMainWindowAdaptor.h
index 206a6bddb..e06788ad1 100644
--- a/src/KonqMainWindowAdaptor.h
+++ b/src/KonqMainWindowAdaptor.h
@@ -1,91 +1,93 @@
 /* This file is part of the KDE project
    Copyright 2000 Simon Hausmann <hausmann@kde.org>
    Copyright 2000, 2006 David Faure <faure@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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef __KonqMainWindowAdaptor_h__
 #define __KonqMainWindowAdaptor_h__
 
 // !!! Don't regenerate this file, I don't want to lose the method documentation
 // Use qdbuscpp2xml KonqMainWindowAdaptor.h > org.kde.Konqueror.MainWindow.xml
 // if you change the API.
 
-#include <QtDBus>
+#include <QDBusAbstractAdaptor>
+#include <QDBusObjectPath>
+#include <QDBusConnection>
 
 class KonqMainWindow;
 
 /**
  * DBUS interface for a konqueror main window
  */
 class KonqMainWindowAdaptor : public QDBusAbstractAdaptor
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.Konqueror.MainWindow")
 
 public:
 
     explicit KonqMainWindowAdaptor(KonqMainWindow *mainWindow);
     ~KonqMainWindowAdaptor();
 
 public slots:
 
     /**
      * Open a url in this window
      * @param url the url to open
      * @param tempFile whether to delete the file after use, usually this is false
      */
     void openUrl(const QString &url, bool tempFile);
     /**
      * Open a url in a new tab in this window
      * @param url the url to open
      * @param tempFile whether to delete the file after use, usually this is false
      */
     void newTab(const QString &url, bool tempFile);
 
     void newTabASN(const QString &url, const QByteArray &startup_id, bool tempFile);
 
     void newTabASNWithMimeType(const QString &url, const QString &mimetype, const QByteArray &startup_id, bool tempFile);
 
     void splitViewHorizontally();
     void splitViewVertically();
 
     /**
      * Reloads the current view.
      */
     void reload();
 
     /**
      * @return reference to the current KonqView
      */
     QDBusObjectPath currentView();
     /**
      * @return reference to the current part
      */
     QDBusObjectPath currentPart();
 
     QDBusObjectPath view(int viewNumber);
 
     QDBusObjectPath part(int partNumber);
 
 private:
 
     KonqMainWindow *m_pMainWindow;
 };
 
 #endif
 
diff --git a/src/KonqViewAdaptor.h b/src/KonqViewAdaptor.h
index e07f6e773..4c8b6649d 100644
--- a/src/KonqViewAdaptor.h
+++ b/src/KonqViewAdaptor.h
@@ -1,134 +1,134 @@
 /* This file is part of the KDE project
    Copyright 2000       Simon Hausmann <hausmann@kde.org>
    Copyright 2000, 2006 David Faure <faure@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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef __KonqViewAdaptor_h__
 #define __KonqViewAdaptor_h__
 
 #include <QStringList>
-#include <QtDBus>
+#include <QDBusObjectPath>
 
 class KonqView;
 
 /**
  * DBus interface for a konqueror view
  */
 class KonqViewAdaptor : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.Konqueror.View")
 
 public:
 
     explicit KonqViewAdaptor(KonqView *view);
     ~KonqViewAdaptor();
 
 public slots:
 
     /**
      * Displays another URL, but without changing the view mode
      * (Make sure the part can display this URL)
      */
     void openUrl(const QString &url,
                  const QString &locationBarURL,
                  const QString &nameFilter);
 
     /**
      * Reload
      */
     void reload();
 
     /**
      * Change the type of view (i.e. loads a new konqueror view)
      * @param mimeType the mime type we want to show
      * @param serviceName allows to enforce a particular service to be chosen,
      *        @see KonqFactory.
      */
     bool changeViewMode(const QString &mimeType,
                         const QString &serviceName);
 
     /**
      * Call this to prevent next openUrl() call from changing history lists
      * Used when the same URL is reloaded (for instance with another view mode)
      */
     void lockHistory();
 
     /**
      * Stop loading
      */
     void stop();
 
     /**
      * Retrieve view's URL
      */
     QString url();
 
     /**
      * Get view's location bar URL, i.e. the one that the view signals
      * It can be different from url(), for instance if we display a index.html
      */
     QString locationBarURL();
 
     /**
      * @return the servicetype this view is currently displaying
      */
     QString serviceType();
 
     /**
      * @return the servicetypes this view is capable to display
      */
     QStringList serviceTypes();
 
     /**
      * @return the part embedded into this view
      */
     QDBusObjectPath part();
 
     /**
      * Enable/Disable the context popup menu for this view.
      */
     void enablePopupMenu(bool b);
 
     bool isPopupMenuEnabled() const;
 
     /*
      * Return length of history
      */
     uint historyLength()const;
 
     /*
      * Move forward in history "-1"
      */
     void goForward();
     /*
      * Move back in history "+1"
      */
     void goBack();
 
     bool canGoBack()const;
     bool canGoForward()const;
 
 private:
 
     KonqView *m_pView;
 
 };
 
 #endif
 
diff --git a/src/KonquerorAdaptor.h b/src/KonquerorAdaptor.h
index 2b6dee49b..eec1cd232 100644
--- a/src/KonquerorAdaptor.h
+++ b/src/KonquerorAdaptor.h
@@ -1,105 +1,106 @@
 /* This file is part of the KDE project
    Copyright 2000 Simon Hausmann <hausmann@kde.org>
    Copyright 2000-2006 David Faure <faure@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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KONQUERORADAPTOR_H
 #define KONQUERORADAPTOR_H
 
 #include <QStringList>
-#include <QtDBus>
+#include <QDBusObjectPath>
+#include <QDBusMessage>
 
 #define KONQ_MAIN_PATH "/KonqMain"
 
 /**
  * DBus interface of a konqueror process
  */
 class KonquerorAdaptor : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.Konqueror.Main")
 
 public:
 
     KonquerorAdaptor();
     ~KonquerorAdaptor();
 
 public slots:
 
     /**
      * Opens a new window for the given @p url (using createSimpleWindow, i.e. a single view)
      * @param url the url to open
      * @param startup_id sets the application startup notification (ASN) property on the window, if not empty.
      * @return the DBUS object path of the window
      */
     QDBusObjectPath openBrowserWindow(const QString &url, const QByteArray &startup_id);
 
     /**
      * Opens a new window for the given @p url (using createNewWindow)
      * @param url the url to open
      * @param mimetype pass the mimetype of the url, if known, to speed up the process.
      * @param startup_id sets the application startup notification (ASN) property on the window, if not empty.
      * @param tempFile whether to delete the file after use, usually this is false
      * @return the DBUS object path of the window
      */
     QDBusObjectPath createNewWindow(const QString &url, const QString &mimetype, const QByteArray &startup_id, bool tempFile);
 
     /**
      * Opens a new window like @ref createNewWindow, then selects the given @p filesToSelect
      * @param filesToSelect the files to select in the newly opened file-manager window
      * @param startup_id sets the application startup notification (ASN) property on the window, if not empty.
      * @return the DBUS object path of the window
      */
     QDBusObjectPath createNewWindowWithSelection(const QString &url, const QStringList &filesToSelect, const QByteArray &startup_id);
 
     /**
      * @return a list of references to all the windows
      */
     QList<QDBusObjectPath> getWindows();
 
     /**
      * @return a list of all URLs currently opened in this process
      * Convenience function to avoid iterating over windows by hand.
      */
     QStringList urls() const;
 
     /**
      * Find a window which can be used for a new tab. Called by kfmclient.
      */
     QDBusObjectPath windowForTab();
 
 Q_SIGNALS:
     /**
      * Emitted by kcontrol when the global configuration changes
      */
     void reparseConfiguration();
     /**
      * Used internally by Konqueror to notify all instances when a URL should be added to the combobox.
      */
     void addToCombo(const QString &url, const QDBusMessage &msg);
     /**
      * Used internally by Konqueror to notify all instances when a URL should be removed from the combobox.
      */
     void removeFromCombo(const QString &url, const QDBusMessage &msg);
     /**
      * Used internally by Konqueror to notify all instances when the combobox should be cleared.
      */
     void comboCleared(const QDBusMessage &msg);
 };
 
 #endif
diff --git a/src/konqcloseditem.h b/src/konqcloseditem.h
index 47da48a99..196073987 100644
--- a/src/konqcloseditem.h
+++ b/src/konqcloseditem.h
@@ -1,137 +1,136 @@
 /* This file is part of the KDE project
    Copyright 2007 David Faure <faure@kde.org>
    Copyright 2007 Eduardo Robles Elvira <edulix@gmail.com>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KONQCLOSEDITEM_H
 #define KONQCLOSEDITEM_H
 
 #include "konqprivate_export.h"
 #include <kconfiggroup.h>
-#include <QtDBus>
 #include <QString>
 
 class KConfig;
 
 class KONQ_TESTS_EXPORT KonqClosedItem : public QObject
 {
 public:
     virtual ~KonqClosedItem();
     virtual KConfigGroup &configGroup()
     {
         return m_configGroup;
     }
     virtual const KConfigGroup &configGroup() const
     {
         return m_configGroup;
     }
     quint64 serialNumber() const
     {
         return m_serialNumber;
     }
     QString title() const
     {
         return m_title;
     }
     virtual QPixmap icon() const = 0;
 
 protected:
     KonqClosedItem(const QString &title, const QString &group, quint64 serialNumber);
     QString m_title;
     KConfigGroup m_configGroup;
     quint64 m_serialNumber;
 };
 
 /**
  * This class stores all the needed information about a closed tab
  * in order to be able to reopen it if requested
  */
 class KONQ_TESTS_EXPORT KonqClosedTabItem : public KonqClosedItem
 {
 public:
     KonqClosedTabItem(const QString &url, const QString &title, int index, quint64 serialNumber);
     virtual ~KonqClosedTabItem();
     QPixmap icon() const Q_DECL_OVERRIDE;
     QString url() const
     {
         return m_url;
     }
     /// The position inside the tabbar that the tab had when it was  closed
     int pos() const
     {
         return m_pos;
     }
 
 protected:
     QString m_url;
     int m_pos;
 };
 
 /**
  * This class stores all the needed information about a closed tab
  * in order to be able to reopen it if requested
  */
 class KONQ_TESTS_EXPORT KonqClosedWindowItem : public KonqClosedItem
 {
 public:
     KonqClosedWindowItem(const QString &title, quint64 serialNumber, int numTabs);
     virtual ~KonqClosedWindowItem();
     QPixmap icon() const Q_DECL_OVERRIDE;
     int numTabs() const;
 
 protected:
     int m_numTabs;
 };
 
 class KONQ_TESTS_EXPORT KonqClosedRemoteWindowItem : public KonqClosedWindowItem
 {
 public:
     KonqClosedRemoteWindowItem(const QString &title, const QString &groupName, const QString &configFileName, quint64 serialNumber, int numTabs, const QString &dbusService);
     virtual ~KonqClosedRemoteWindowItem();
     KConfigGroup &configGroup() Q_DECL_OVERRIDE;
     const KConfigGroup &configGroup() const Q_DECL_OVERRIDE;
     bool equalsTo(const QString &groupName, const QString &configFileName) const;
     QString dbusService() const
     {
         return m_dbusService;
     }
     const QString &remoteGroupName() const
     {
         return m_remoteGroupName;
     }
     const QString &remoteConfigFileName() const
     {
         return m_remoteConfigFileName;
     }
 protected:
     /**
      * Actually reads the config file. Call to this function before calling to
      * configGroup(). This function is const so that it can be called by
      * configGroup() const. It's used to get delayed initialization so that
      * we don't load the config file unless it's needed.
      */
     void readConfig() const;
     QString m_remoteGroupName;
     QString m_remoteConfigFileName;
     QString m_dbusService;
     mutable KConfigGroup *m_remoteConfigGroup;
     mutable KConfig *m_remoteConfig;
 };
 
 #endif /* KONQCLOSEDITEM_H */
 
diff --git a/src/konqhistoryproxymodel.cpp b/src/konqhistoryproxymodel.cpp
index 951e68f53..acc10cb87 100644
--- a/src/konqhistoryproxymodel.cpp
+++ b/src/konqhistoryproxymodel.cpp
@@ -1,118 +1,119 @@
 /* This file is part of the KDE project
    Copyright 2009 Pino Toscano <pino@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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "konqhistoryproxymodel.h"
 
 #include "konqhistory.h"
 #include "konqhistorysettings.h"
+#include <QDateTime>
 
 KonqHistoryProxyModel::KonqHistoryProxyModel(KonqHistorySettings *settings, QObject *parent)
     : KSortFilterProxyModel(parent)
     , m_settings(settings)
 {
     setDynamicSortFilter(true);
     setFilterCaseSensitivity(Qt::CaseInsensitive);
 
     connect(m_settings, &KonqHistorySettings::settingsChanged, this, &KonqHistoryProxyModel::slotSettingsChanged);
 }
 
 KonqHistoryProxyModel::~KonqHistoryProxyModel()
 {
 }
 
 QVariant KonqHistoryProxyModel::data(const QModelIndex &index, int role) const
 {
     if (!sourceModel()) {
         return QVariant();
     }
 
     const QModelIndex source_index = mapToSource(index);
     QVariant res;
     switch (source_index.data(KonqHistory::TypeRole).toInt()) {
     case KonqHistory::HistoryType:
         switch (role) {
         case Qt::ToolTipRole:
             if (m_settings->m_detailedTips) {
                 res = sourceModel()->data(source_index, KonqHistory::DetailedToolTipRole);
             } else {
                 res = sourceModel()->data(source_index, Qt::ToolTipRole);
             }
             break;
         case Qt::FontRole: {
             const QDateTime current = QDateTime::currentDateTime();
             const QDateTime entryDate = source_index.data(KonqHistory::LastVisitedRole).toDateTime();
 
             QDateTime dt;
             if (m_settings->m_metricYoungerThan == KonqHistorySettings::DAYS) {
                 dt = current.addDays(-int(m_settings->m_valueYoungerThan));
             } else {
                 dt = current.addSecs(-(int(m_settings->m_valueYoungerThan) * 60));
             }
 
             if (entryDate > dt) {
                 res = qVariantFromValue(m_settings->m_fontYoungerThan);
             } else {
                 if (m_settings->m_metricOlderThan == KonqHistorySettings::DAYS) {
                     dt = current.addDays(-int(m_settings->m_valueOlderThan));
                 } else {
                     dt = current.addSecs(-(int(m_settings->m_valueOlderThan) * 60));
                 }
                 if (entryDate < dt) {
                     res = qVariantFromValue(m_settings->m_fontOlderThan);
                 }
             }
             break;
         }
         }
         break;
     case KonqHistory::GroupType:
         break;
     }
     if (res.isNull()) {
         res = QSortFilterProxyModel::data(index, role);
     }
     return res;
 }
 
 bool KonqHistoryProxyModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
 {
     switch (left.data(KonqHistory::TypeRole).toInt()) {
     case KonqHistory::HistoryType:
         Q_ASSERT(right.data(KonqHistory::TypeRole).toInt() == KonqHistory::HistoryType);
         if (m_settings->m_sortsByName) {
             return left.data().toString() < right.data().toString();
         } else {
             return left.data(KonqHistory::LastVisitedRole).toDateTime() > right.data(KonqHistory::LastVisitedRole).toDateTime();
         }
     case KonqHistory::GroupType:
         Q_ASSERT(right.data(KonqHistory::TypeRole).toInt() == KonqHistory::GroupType);
         if (m_settings->m_sortsByName) {
             return left.data().toString() < right.data().toString();
         } else {
             return left.data(KonqHistory::LastVisitedRole).toDateTime() > right.data(KonqHistory::LastVisitedRole).toDateTime();
         }
     }
     return QSortFilterProxyModel::lessThan(left, right);
 }
 
 void KonqHistoryProxyModel::slotSettingsChanged()
 {
     reset();
 }
 
diff --git a/src/konqhistorysettings.h b/src/konqhistorysettings.h
index e856fda5b..d0e7ff0a6 100644
--- a/src/konqhistorysettings.h
+++ b/src/konqhistorysettings.h
@@ -1,93 +1,94 @@
 /* This file is part of the KDE project
    Copyright (C) 2000 Carsten Pfeiffer <pfeiffer@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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef KONQ_HISTORYSETTINGS_H
 #define KONQ_HISTORYSETTINGS_H
 
 #include <QFont>
 #include <QObject>
-#include <QtDBus>
+#include <QDBusAbstractAdaptor>
+#include <QDBusConnection>
 
 /**
  * Object containing the settings used by the history views
  * (both the sidebar module and the history dialog)
  *
  * The instances of KonqHistorySettings in all konqueror processes
  * synchronize themselves using DBus.
  */
 class KonqHistorySettings : public QObject
 {
     Q_OBJECT
 
 public:
     enum { MINUTES, DAYS };
 
     static KonqHistorySettings *self();
     virtual ~KonqHistorySettings();
 
     void applySettings();
 
     uint m_valueYoungerThan;
     uint m_valueOlderThan;
 
     int m_metricYoungerThan;
     int m_metricOlderThan;
 
     QFont m_fontYoungerThan;
     QFont m_fontOlderThan;
 
     bool m_detailedTips;
     bool m_sortsByName;
 
 Q_SIGNALS:
     void settingsChanged();
 
 private Q_SLOTS:
     void slotSettingsChanged();
 
 protected:
     Q_DISABLE_COPY(KonqHistorySettings)
 
 Q_SIGNALS:
     // DBus signals
     void notifySettingsChanged();
 
 private:
     void readSettings(bool reparse);
 
     friend class KonqHistorySettingsSingleton;
     KonqHistorySettings();
 };
 
 class KonqHistorySettingsAdaptor : public QDBusAbstractAdaptor
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.Konqueror.SidebarHistorySettings")
 public:
     KonqHistorySettingsAdaptor(KonqHistorySettings *parent)
         : QDBusAbstractAdaptor(parent)
     {
         setAutoRelaySignals(true);
     }
 
 Q_SIGNALS:
     void notifySettingsChanged();
 };
 
 #endif // KONQ_HISTORYSETTINGS_H
diff --git a/src/konqhistoryview.cpp b/src/konqhistoryview.cpp
index f9f30cfd2..088595e31 100644
--- a/src/konqhistoryview.cpp
+++ b/src/konqhistoryview.cpp
@@ -1,257 +1,259 @@
 /* This file is part of the KDE project
    Copyright 2009 Pino Toscano <pino@kde.org>
    Copyright 2009 Daivd Faure <faure@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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "konqhistoryview.h"
 #include "konqhistory.h"
 #include "konq_historyprovider.h"
 #include "konqhistorymodel.h"
 #include "konqhistoryproxymodel.h"
 #include "konqhistorysettings.h"
 
 #include <QClipboard>
 #include <QApplication>
 #include <QMenu>
+#include <QMimeData>
+#include <QTimer>
 #include <QTreeView>
 #include <QVBoxLayout>
 
 #include <kactioncollection.h>
 #include <QAction>
 #include "konqdebug.h"
 #include <QIcon>
 #include <klineedit.h>
 #include <KLocalizedString>
 #include <kmessagebox.h>
 #include <krun.h>
 
 KonqHistoryView::KonqHistoryView(QWidget *parent)
     : QWidget(parent)
     , m_searchTimer(0)
 {
     m_treeView = new QTreeView(this);
     m_treeView->setContextMenuPolicy(Qt::CustomContextMenu);
     m_treeView->setHeaderHidden(true);
 
     m_historyProxyModel = new KonqHistoryProxyModel(KonqHistorySettings::self(), m_treeView);
     connect(m_treeView, &QTreeView::customContextMenuRequested, this, &KonqHistoryView::slotContextMenu);
     m_historyModel = new KonqHistoryModel(m_historyProxyModel);
     m_treeView->setModel(m_historyProxyModel);
     m_historyProxyModel->setSourceModel(m_historyModel);
     m_historyProxyModel->sort(0);
 
     m_collection = new KActionCollection(this);
     m_collection->addAssociatedWidget(m_treeView); // make shortcuts work
     QAction *action = m_collection->addAction(QStringLiteral("open_new"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("window-new")));
     action->setText(i18n("Open in New &Window"));
     connect(action, &QAction::triggered, this, &KonqHistoryView::slotNewWindow);
 
     action = m_collection->addAction(QStringLiteral("open_tab"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("tab-new")));
     action->setText(i18n("Open in New Tab"));
     connect(action, &QAction::triggered, this, &KonqHistoryView::slotNewTab);
 
     action = m_collection->addAction(QStringLiteral("copylinklocation"));
     action->setText(i18n("&Copy Link Address"));
     connect(action, &QAction::triggered, this, &KonqHistoryView::slotCopyLinkLocation);
 
     action = m_collection->addAction(QStringLiteral("remove"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-delete")));
     action->setText(i18n("&Remove Entry"));
     m_collection->setDefaultShortcut(action, QKeySequence(Qt::Key_Delete)); // #135966
     action->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     connect(action, &QAction::triggered, this, &KonqHistoryView::slotRemoveEntry);
 
     action = m_collection->addAction(QStringLiteral("clear"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("edit-clear-history")));
     action->setText(i18n("C&lear History"));
     connect(action, &QAction::triggered, this, &KonqHistoryView::slotClearHistory);
 
     action = m_collection->addAction(QStringLiteral("preferences"));
     action->setIcon(QIcon::fromTheme(QStringLiteral("configure")));
     action->setText(i18n("&Preferences..."));
     connect(action, &QAction::triggered, this, &KonqHistoryView::slotPreferences);
 
     QActionGroup *sortGroup = new QActionGroup(this);
     sortGroup->setExclusive(true);
 
     action = m_collection->addAction(QStringLiteral("byName"));
     action->setText(i18n("By &Name"));
     action->setCheckable(true);
     action->setData(qVariantFromValue(0));
     sortGroup->addAction(action);
 
     action = m_collection->addAction(QStringLiteral("byDate"));
     action->setText(i18n("By &Date"));
     action->setCheckable(true);
     action->setData(qVariantFromValue(1));
     sortGroup->addAction(action);
 
     KonqHistorySettings *settings = KonqHistorySettings::self();
     sortGroup->actions().at(settings->m_sortsByName ? 0 : 1)->setChecked(true);
     connect(sortGroup, &QActionGroup::triggered, this, &KonqHistoryView::slotSortChange);
 
     m_searchLineEdit = new KLineEdit(this);
     m_searchLineEdit->setPlaceholderText(i18n("Search in history"));
     m_searchLineEdit->setClearButtonShown(true);
 
     connect(m_searchLineEdit, &KLineEdit::textChanged, this, &KonqHistoryView::slotFilterTextChanged);
 
     QVBoxLayout *mainLayout = new QVBoxLayout(this);
     mainLayout->setMargin(0);
     mainLayout->addWidget(m_searchLineEdit);
     mainLayout->addWidget(m_treeView);
 }
 
 void KonqHistoryView::slotContextMenu(const QPoint &pos)
 {
     const QModelIndex index = m_treeView->indexAt(pos);
     if (!index.isValid()) {
         return;
     }
 
     const int nodeType = index.data(KonqHistory::TypeRole).toInt();
 
     QMenu *menu = new QMenu(this);
 
     if (nodeType == KonqHistory::HistoryType) {
         menu->addAction(m_collection->action(QStringLiteral("open_new")));
         menu->addAction(m_collection->action(QStringLiteral("open_tab")));
         menu->addAction(m_collection->action(QStringLiteral("copylinklocation")));
         menu->addSeparator();
     }
 
     menu->addAction(m_collection->action(QStringLiteral("remove")));
     menu->addAction(m_collection->action(QStringLiteral("clear")));
     menu->addSeparator();
     QMenu *sortMenu = menu->addMenu(i18nc("@action:inmenu Parent of 'By Name' and 'By Date'", "Sort"));
     sortMenu->addAction(m_collection->action(QStringLiteral("byName")));
     sortMenu->addAction(m_collection->action(QStringLiteral("byDate")));
     menu->addSeparator();
     menu->addAction(m_collection->action(QStringLiteral("preferences")));
 
     menu->exec(m_treeView->viewport()->mapToGlobal(pos));
 
     delete menu;
 }
 
 void KonqHistoryView::slotRemoveEntry()
 {
     const QModelIndex index = m_treeView->currentIndex();
     if (!index.isValid()) {
         return;
     }
 
     // TODO undo/redo support
     m_historyModel->deleteItem(m_historyProxyModel->mapToSource(index));
 }
 
 void KonqHistoryView::slotClearHistory()
 {
     KGuiItem guiitem = KStandardGuiItem::clear();
     guiitem.setIcon(QIcon::fromTheme(QStringLiteral("edit-clear-history")));
 
     if (KMessageBox::warningContinueCancel(this,
                                            i18n("Do you really want to clear the entire history?"),
                                            i18nc("@title:window", "Clear History?"), guiitem)
             == KMessageBox::Continue) {
         KonqHistoryProvider::self()->emitClear();
     }
 }
 
 void KonqHistoryView::slotPreferences()
 {
     // Run the history sidebar settings.
     KRun::run(QStringLiteral("kcmshell5 kcmhistory"), QList<QUrl>(), this);
 }
 
 void KonqHistoryView::slotSortChange(QAction *action)
 {
     if (!action) {
         return;
     }
 
     const int which = action->data().toInt();
     KonqHistorySettings *settings = KonqHistorySettings::self();
     settings->m_sortsByName = (which == 0);
     settings->applySettings();
 }
 
 void KonqHistoryView::slotFilterTextChanged(const QString &text)
 {
     Q_UNUSED(text);
     if (!m_searchTimer) {
         m_searchTimer = new QTimer(this);
         m_searchTimer->setSingleShot(true);
         connect(m_searchTimer, &QTimer::timeout, this, &KonqHistoryView::slotTimerTimeout);
     }
     m_searchTimer->start(600);
 }
 
 void KonqHistoryView::slotTimerTimeout()
 {
     m_historyProxyModel->setFilterFixedString(m_searchLineEdit->text());
 }
 
 QTreeView *KonqHistoryView::treeView() const
 {
     return m_treeView;
 }
 
 KLineEdit *KonqHistoryView::lineEdit() const
 {
     return m_searchLineEdit;
 }
 
 void KonqHistoryView::slotNewWindow()
 {
     const QUrl url = urlForIndex(m_treeView->currentIndex());
     if (url.isValid()) {
         emit openUrlInNewWindow(url);
     }
 }
 
 void KonqHistoryView::slotNewTab()
 {
     const QUrl url = urlForIndex(m_treeView->currentIndex());
     if (url.isValid()) {
         emit openUrlInNewTab(url);
     }
 }
 
 QUrl KonqHistoryView::urlForIndex(const QModelIndex &index) const
 {
     if (!index.isValid() || (index.data(KonqHistory::TypeRole).toInt() != KonqHistory::HistoryType)) {
         return QUrl();
     }
 
     return index.data(KonqHistory::UrlRole).toUrl();
 }
 
 // Code taken from KHTMLPopupGUIClient::slotCopyLinkLocation
 void KonqHistoryView::slotCopyLinkLocation()
 {
     QUrl safeURL = urlForIndex(m_treeView->currentIndex()).adjusted(QUrl::RemovePassword);
 
     // Set it in both the mouse selection and in the clipboard
     QMimeData *mimeData = new QMimeData;
     mimeData->setUrls(QList<QUrl>() << safeURL);
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Selection);
 }
diff --git a/src/konqview.cpp b/src/konqview.cpp
index 316664bb8..8e5e569c9 100644
--- a/src/konqview.cpp
+++ b/src/konqview.cpp
@@ -1,1461 +1,1463 @@
 /*
    This file is part of the KDE project
    Copyright (C) 1998-2005 David Faure <faure@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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "konqview.h"
 
 #include "KonqViewAdaptor.h"
 #include "konqsettingsxt.h"
 #include "konqframestatusbar.h"
 #include "konqrun.h"
 #include <konq_events.h>
 #include "konqviewmanager.h"
 #include "konqtabs.h"
 #include "konqbrowseriface.h"
 #include "konqhistorymanager.h"
 #include "konqpixmapprovider.h"
 
 #include <kio/job.h>
 #include <kio/jobuidelegate.h>
 #include "konqdebug.h"
 #include <kcursor.h>
 #include <kmessagebox.h>
 #include <KLocalizedString>
 #include <krandom.h>
 #include <ktoggleaction.h>
 #include <kjobuidelegate.h>
 #include <KUrlMimeData>
 #include <KComponentData>
 
 #include <QApplication>
 #include <QArgument>
 #include <QObject>
 #include <QByteRef>
 #include <QEvent>
 #include <QFile>
 #include <QDropEvent>
+#include <QDBusConnection>
+#include <QMimeData>
 #ifdef KActivities_FOUND
 #endif
 
 #include <KJobWidgets/KJobWidgets>
 #include <KParts/Part>
 #include <KParts/StatusBarExtension>
 #include <KParts/ReadOnlyPart>
 #include <KParts/BrowserArguments>
 #include <KParts/OpenUrlEvent>
 #include <KParts/BrowserHostExtension>
 #include <KParts/OpenUrlArguments>
 #include <KParts/BrowserExtension>
 #include <KParts/WindowArgs>
 
 //#define DEBUG_HISTORY
 
 KonqView::KonqView(KonqViewFactory &viewFactory,
                    KonqFrame *viewFrame,
                    KonqMainWindow *mainWindow,
                    const KService::Ptr &service,
                    const KService::List &partServiceOffers,
                    const KService::List &appServiceOffers,
                    const QString &serviceType,
                    bool passiveMode
                   )
 {
     m_pKonqFrame = viewFrame;
     m_pKonqFrame->setView(this);
 
     m_sLocationBarURL = QLatin1String("");
     m_pageSecurity = KonqMainWindow::NotCrypted;
     m_bLockHistory = false;
     m_doPost = false;
     m_pMainWindow = mainWindow;
     m_pRun = NULL;
     m_pPart = NULL;
 
     m_randID = KRandom::random();
 
     m_service = service;
     m_partServiceOffers = partServiceOffers;
     m_appServiceOffers = appServiceOffers;
     m_serviceType = serviceType;
 
     m_lstHistoryIndex = -1;
     m_bLoading = false;
     m_bPendingRedirection = false;
     m_bPassiveMode = passiveMode;
     m_bLockedLocation = false;
     m_bLinkedView = false;
     m_bAborted = false;
     m_bToggleView = false;
     m_bDisableScrolling = false;
     m_bGotIconURL = false;
     m_bPopupMenuEnabled = true;
     m_browserIface = new KonqBrowserInterface(this);
     m_bFollowActive = false;
     m_bBuiltinView = false;
     m_bURLDropHandling = false;
     m_bErrorURL = false;
 
 #ifdef KActivities_FOUND
     m_activityResourceInstance = new KActivities::ResourceInstance(mainWindow->winId(), this);
 #endif
 
     switchView(viewFactory);
 }
 
 KonqView::~KonqView()
 {
     //qCDebug(KONQUEROR_LOG) << "part=" << m_pPart;
 
     // We did so ourselves for passive views
     if (m_pPart != 0L) {
         finishedWithCurrentURL();
         if (isPassiveMode()) {
             disconnect(m_pPart, SIGNAL(destroyed()), m_pMainWindow->viewManager(), SLOT(slotObjectDestroyed()));
         }
 
         if (m_pPart->manager()) {
             m_pPart->manager()->removePart(m_pPart);    // ~Part does this, but we have to do it before (#213876, #207173)
         }
 
         delete m_pPart;
     }
 
     qDeleteAll(m_lstHistory);
     m_lstHistory.clear();
 
     setRun(0L);
     //qCDebug(KONQUEROR_LOG) << this << "done";
 }
 
 void KonqView::openUrl(const QUrl &url, const QString &locationBarURL,
                        const QString &nameFilter, bool tempFile)
 {
     qCDebug(KONQUEROR_LOG) << "url=" << url << "locationBarURL=" << locationBarURL;
 
     setPartMimeType();
 
     KParts::OpenUrlArguments args;
     if (m_pPart) {
         args = m_pPart->arguments();
     }
 
     KParts::BrowserExtension *ext = browserExtension();
     KParts::BrowserArguments browserArgs;
     if (ext) {
         browserArgs = ext->browserArguments();
     }
 
     // Typing "Enter" again after the URL of an aborted view, triggers a reload.
     if (m_bAborted && m_pPart && m_pPart->url() == url && !browserArgs.doPost()) {
         if (!prepareReload(args, browserArgs, false /* not softReload */)) {
             return;
         }
         m_pPart->setArguments(args);
     }
 
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "m_bLockedLocation=" << m_bLockedLocation << "browserArgs.lockHistory()=" << browserArgs.lockHistory();
 #endif
     if (browserArgs.lockHistory()) {
         lockHistory();
     }
 
     if (!m_bLockHistory) {
         // Store this new URL in the history, removing any existing forward history.
         // We do this first so that everything is ready if a part calls completed().
         createHistoryEntry();
     } else {
         m_bLockHistory = false;
     }
 
     if (m_pPart) {
         m_pPart->setProperty("nameFilter", nameFilter);
     }
 
     if (m_bDisableScrolling) {
         callExtensionMethod("disableScrolling");
     }
 
     // Set location-bar URL, except for error urls, where we know the browser component
     // will set back the url with the error anyway.
     if (url.scheme() != QLatin1String("error")) {
         setLocationBarURL(locationBarURL);
     }
 
     setPageSecurity(KonqMainWindow::NotCrypted);
 
     if (!args.reload()) {
         // Save the POST data that is necessary to open this URL
         // (so that reload can re-post it)
         m_doPost = browserArgs.doPost();
         m_postContentType = browserArgs.contentType();
         m_postData = browserArgs.postData;
         // Save the referrer
         m_pageReferrer = args.metaData()[QStringLiteral("referrer")];
     }
 
     if (tempFile) {
         // Store the path to the tempfile. Yes, we could store a bool only,
         // but this would be more dangerous. If anything goes wrong in the code,
         // we might end up deleting a real file.
         if (url.isLocalFile()) {
             m_tempFile = url.toLocalFile();
         } else {
             qCWarning(KONQUEROR_LOG) << "Tempfile option is set, but URL is remote:" << url;
         }
     }
 
     aboutToOpenURL(url, args);
 
     m_pPart->openUrl(url);
 
     updateHistoryEntry(false /* don't save location bar URL yet */);
     // add pending history entry
     KonqHistoryManager::kself()->addPending(url, locationBarURL, QString());
 
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "Current position:" << historyIndex();
 #endif
 
 #ifdef KActivities_FOUND
     m_activityResourceInstance->setUri(url);
 
     if (m_pPart->widget()->hasFocus()) {
         m_activityResourceInstance->notifyFocusedIn();
     }
 #endif
 }
 
 void KonqView::switchView(KonqViewFactory &viewFactory)
 {
     //qCDebug(KONQUEROR_LOG);
     KParts::ReadOnlyPart *oldPart = m_pPart;
     KParts::ReadOnlyPart *part = m_pKonqFrame->attach(viewFactory);   // creates the part
     if (!part) {
         return;
     }
     m_pPart = part;
 
     // Set the statusbar in the BE asap to avoid a KMainWindow statusbar being created.
     KParts::StatusBarExtension *sbext = statusBarExtension();
     if (sbext) {
         sbext->setStatusBar(frame()->statusbar());
     }
 
     // Activate the new part
     if (oldPart) {
         m_pPart->setObjectName(oldPart->objectName());
         emit sigPartChanged(this, oldPart, m_pPart);
         delete oldPart;
     }
 
     connectPart();
 
     QVariant prop;
 
     prop = m_service->property(QStringLiteral("X-KDE-BrowserView-FollowActive"));
     if (prop.isValid() && prop.toBool()) {
         //qCDebug(KONQUEROR_LOG) << "X-KDE-BrowserView-FollowActive -> setFollowActive";
         setFollowActive(true);
     }
 
     prop = m_service->property(QStringLiteral("X-KDE-BrowserView-Built-Into"));
     m_bBuiltinView = (prop.isValid() && prop.toString() == QLatin1String("konqueror"));
 
     if (!m_pMainWindow->viewManager()->isLoadingProfile()) {
         // Honor "non-removable passive mode" (like the dirtree)
         prop = m_service->property(QStringLiteral("X-KDE-BrowserView-PassiveMode"));
         if (prop.isValid() && prop.toBool()) {
             qCDebug(KONQUEROR_LOG) << "X-KDE-BrowserView-PassiveMode -> setPassiveMode";
             setPassiveMode(true);   // set as passive
         }
 
         // Honor "linked view"
         prop = m_service->property(QStringLiteral("X-KDE-BrowserView-LinkedView"));
         if (prop.isValid() && prop.toBool()) {
             setLinkedView(true);   // set as linked
             // Two views : link both
             if (m_pMainWindow->viewCount() <= 2) { // '1' can happen if this view is not yet in the map
                 KonqView *otherView = m_pMainWindow->otherView(this);
                 if (otherView) {
                     otherView->setLinkedView(true);
                 }
             }
         }
     }
 }
 
 bool KonqView::ensureViewSupports(const QString &mimeType,
                                   bool forceAutoEmbed)
 {
     if (supportsMimeType(mimeType)) {
         // could be more specific, let's store it so that OpenUrlArguments::mimeType is correct
         // testcase: http://acid3.acidtests.org/svg.xml should be opened as image/svg+xml
         m_serviceType = mimeType;
         return true;
     }
     return changePart(mimeType, QString(), forceAutoEmbed);
 }
 
 bool KonqView::changePart(const QString &mimeType,
                           const QString &serviceName,
                           bool forceAutoEmbed)
 {
     // Caller should call stop first.
     Q_ASSERT(!m_bLoading);
 
     //qCDebug(KONQUEROR_LOG) << "mimeType=" << mimeType
     //             << "requested serviceName=" << serviceName
     //             << "current service name=" << m_service->desktopEntryName();
 
     if (serviceName == m_service->desktopEntryName()) {
         m_serviceType = mimeType;
         return true;
     }
 
     if (isLockedViewMode()) {
         //qCDebug(KONQUEROR_LOG) << "This view's mode is locked - can't change";
         return false; // we can't do that if our view mode is locked
     }
 
     KService::List partServiceOffers, appServiceOffers;
     KService::Ptr service;
     KonqFactory konqFactory;
     KonqViewFactory viewFactory = konqFactory.createView(mimeType, serviceName, &service, &partServiceOffers, &appServiceOffers, forceAutoEmbed);
 
     if (viewFactory.isNull()) {
         return false;
     }
 
     m_serviceType = mimeType;
     m_partServiceOffers = partServiceOffers;
     m_appServiceOffers = appServiceOffers;
 
     // Check if that's already the kind of part we have -> no need to recreate it
     // Note: we should have an operator== for KService...
     if (m_service && m_service->entryPath() == service->entryPath()) {
         qCDebug(KONQUEROR_LOG) << "Reusing service. Service type set to" << m_serviceType;
         if (m_pMainWindow->currentView() == this) {
             m_pMainWindow->updateViewModeActions();
         }
     } else {
         m_service = service;
 
         switchView(viewFactory);
     }
 
     return true;
 }
 
 void KonqView::connectPart()
 {
     //qCDebug(KONQUEROR_LOG);
     connect(m_pPart, SIGNAL(started(KIO::Job*)),
             this, SLOT(slotStarted(KIO::Job*)));
     connect(m_pPart, SIGNAL(completed()),
             this, SLOT(slotCompleted()));
     connect(m_pPart, SIGNAL(completed(bool)),
             this, SLOT(slotCompleted(bool)));
     connect(m_pPart, SIGNAL(canceled(QString)),
             this, SLOT(slotCanceled(QString)));
     connect(m_pPart, SIGNAL(setWindowCaption(QString)),
             this, SLOT(setCaption(QString)));
     if (!internalViewMode().isEmpty()) {
         // Update checked action in "View Mode" menu when switching view mode in dolphin
         connect(m_pPart, SIGNAL(viewModeChanged()),
                 m_pMainWindow, SLOT(slotInternalViewModeChanged()));
     }
 
     KParts::BrowserExtension *ext = browserExtension();
 
     if (ext) {
         ext->setBrowserInterface(m_browserIface);
 
         connect(ext, SIGNAL(openUrlRequestDelayed(QUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)),
                 m_pMainWindow, SLOT(slotOpenURLRequest(QUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)));
 
         if (m_bPopupMenuEnabled) {
             m_bPopupMenuEnabled = false; // force
             enablePopupMenu(true);
         }
 
         connect(ext, SIGNAL(setLocationBarUrl(QString)),
                 this, SLOT(setLocationBarURL(QString)));
 
         connect(ext, SIGNAL(setIconUrl(QUrl)),
                 this, SLOT(setIconURL(QUrl)));
 
         connect(ext, SIGNAL(setPageSecurity(int)),
                 this, SLOT(setPageSecurity(int)));
 
         connect(ext, SIGNAL(createNewWindow(QUrl,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::WindowArgs,KParts::ReadOnlyPart**)),
                 m_pMainWindow, SLOT(slotCreateNewWindow(QUrl,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::WindowArgs,KParts::ReadOnlyPart**)));
 
         connect(ext, SIGNAL(loadingProgress(int)),
                 m_pKonqFrame->statusbar(), SLOT(slotLoadingProgress(int)));
 
         connect(ext, SIGNAL(speedProgress(int)),
                 m_pKonqFrame->statusbar(), SLOT(slotSpeedProgress(int)));
 
         connect(ext, SIGNAL(selectionInfo(KFileItemList)),
                 this, SLOT(slotSelectionInfo(KFileItemList)));
 
         connect(ext, SIGNAL(mouseOverInfo(KFileItem)),
                 this, SLOT(slotMouseOverInfo(KFileItem)));
 
         connect(ext, SIGNAL(openUrlNotify()),
                 this, SLOT(slotOpenURLNotify()));
 
         connect(ext, SIGNAL(enableAction(const char*,bool)),
                 this, SLOT(slotEnableAction(const char*,bool)));
 
         connect(ext, SIGNAL(setActionText(const char*,QString)),
                 this, SLOT(slotSetActionText(const char*,QString)));
 
         connect(ext, SIGNAL(moveTopLevelWidget(int,int)),
                 this, SLOT(slotMoveTopLevelWidget(int,int)));
 
         connect(ext, SIGNAL(resizeTopLevelWidget(int,int)),
                 this, SLOT(slotResizeTopLevelWidget(int,int)));
 
         connect(ext, SIGNAL(requestFocus(KParts::ReadOnlyPart*)),
                 this, SLOT(slotRequestFocus(KParts::ReadOnlyPart*)));
 
         if (service()->desktopEntryName() != QLatin1String("konq_sidebartng")) {
             connect(ext, SIGNAL(infoMessage(QString)),
                     m_pKonqFrame->statusbar(), SLOT(message(QString)));
 
             connect(ext,
                     SIGNAL(addWebSideBar(QUrl,QString)),
                     m_pMainWindow,
                     SLOT(slotAddWebSideBar(QUrl,QString)));
         }
     }
 
     QVariant urlDropHandling;
 
     if (ext) {
         urlDropHandling = ext->property("urlDropHandling");
     } else {
         urlDropHandling = QVariant(true);
     }
 
     // Handle url drops if
     //  a) either the property says "ok"
     //  or
     //  b) the part is a plain krop (no BE)
     m_bURLDropHandling = (urlDropHandling.type() == QVariant::Bool &&
                           urlDropHandling.toBool());
     if (m_bURLDropHandling) {
         m_pPart->widget()->setAcceptDrops(true);
     }
 
     m_pPart->widget()->installEventFilter(this);
 }
 
 void KonqView::slotEnableAction(const char *name, bool enabled)
 {
     if (m_pMainWindow->currentView() == this) {
         m_pMainWindow->enableAction(name, enabled);
     }
     // Otherwise, we don't have to do anything, the state of the action is
     // stored inside the browser-extension.
 }
 
 void KonqView::slotSetActionText(const char *name, const QString &text)
 {
     if (m_pMainWindow->currentView() == this) {
         m_pMainWindow->setActionText(name, text);
     }
     // Otherwise, we don't have to do anything, the state of the action is
     // stored inside the browser-extension.
 }
 
 void KonqView::slotMoveTopLevelWidget(int x, int y)
 {
     KonqFrameContainerBase *container = frame()->parentContainer();
     // If tabs are shown, only accept to move the whole window if there's only one tab.
     if (container->frameType() != KonqFrameBase::Tabs || static_cast<KonqFrameTabs *>(container)->count() == 1) {
         m_pMainWindow->move(x, y);
     }
 }
 
 void KonqView::slotResizeTopLevelWidget(int w, int h)
 {
     KonqFrameContainerBase *container = frame()->parentContainer();
     // If tabs are shown, only accept to resize the whole window if there's only one tab.
     // ### Maybe we could store the size requested by each tab and resize the window to the biggest one.
     if (container->frameType() != KonqFrameBase::Tabs || static_cast<KonqFrameTabs *>(container)->count() == 1) {
         m_pMainWindow->resize(w, h);
     }
 }
 
 void KonqView::slotStarted(KIO::Job *job)
 {
     //qCDebug(KONQUEROR_LOG) << job;
     setLoading(true);
 
     if (job) {
         // Manage passwords properly...
         //qCDebug(KONQUEROR_LOG) << "Window ID =" << m_pMainWindow->window()->winId();
         KJobWidgets::setWindow(job, m_pMainWindow->window());
 
         connect(job, SIGNAL(percent(KJob*,ulong)), this, SLOT(slotPercent(KJob*,ulong)));
         connect(job, SIGNAL(speed(KJob*,ulong)), this, SLOT(slotSpeed(KJob*,ulong)));
         connect(job, SIGNAL(infoMessage(KJob*,QString,QString)), this, SLOT(slotInfoMessage(KJob*,QString)));
     }
 }
 
 void KonqView::slotRequestFocus(KParts::ReadOnlyPart *)
 {
     m_pMainWindow->viewManager()->showTab(this);
 }
 
 void KonqView::setLoading(bool loading, bool hasPending /*= false*/)
 {
     //qCDebug(KONQUEROR_LOG) << "loading=" << loading << "hasPending=" << hasPending;
     m_bLoading = loading;
     m_bPendingRedirection = hasPending;
     if (m_pMainWindow->currentView() == this) {
         m_pMainWindow->updateToolBarActions(hasPending);
         // Make sure the focus is restored on the part's widget and not the combo
         // box if it starts loading a request. See #304933.
         if (loading) {
             QWidget *partWidget = (m_pPart ? m_pPart->widget() : 0);
             if (partWidget && !partWidget->hasFocus()) {
                 //qCDebug(KONQUEROR_LOG) << "SET FOCUS on the widget";
                 partWidget->setFocus();
             }
         }
     }
 
     m_pMainWindow->viewManager()->setLoading(this, loading || hasPending);
 }
 
 void KonqView::slotPercent(KJob *, unsigned long percent)
 {
     m_pKonqFrame->statusbar()->slotLoadingProgress(percent);
 }
 
 void KonqView::slotSpeed(KJob *, unsigned long bytesPerSecond)
 {
     m_pKonqFrame->statusbar()->slotSpeedProgress(bytesPerSecond);
 }
 
 void KonqView::slotInfoMessage(KJob *, const QString &msg)
 {
     m_pKonqFrame->statusbar()->message(msg);
 }
 
 void KonqView::slotCompleted()
 {
     slotCompleted(false);
 }
 
 void KonqView::slotCompleted(bool hasPending)
 {
     //qCDebug(KONQUEROR_LOG) << "hasPending=" << hasPending;
     m_pKonqFrame->statusbar()->slotLoadingProgress(-1);
 
     if (! m_bLockHistory) {
         // Success... update history entry, including location bar URL
         updateHistoryEntry(true);
 
         if (m_bAborted) { // remove the pending entry on error
             KonqHistoryManager::kself()->removePending(url());
         } else if (currentHistoryEntry()) // register as proper history entry
             KonqHistoryManager::kself()->confirmPending(url(), typedUrl(),
                     currentHistoryEntry()->title);
 
         emit viewCompleted(this);
     }
     setLoading(false, hasPending);
 
     if (!m_bGotIconURL && !m_bAborted) {
         if (KonqSettings::enableFavicon() == true) {
             // Try to get /favicon.ico
             if (supportsMimeType(QStringLiteral("text/html")) && url().scheme().startsWith(QLatin1String("http"))) {
                 KonqPixmapProvider::self()->downloadHostIcon(url());
             }
         }
     }
 }
 
 void KonqView::slotCanceled(const QString &errorMsg)
 {
     //qCDebug(KONQUEROR_LOG);
     // The errorMsg comes from the ReadOnlyPart (usually from its kio job, but not necessarily).
     // It should probably be used in a KMessageBox
     // Let's use the statusbar for now
     m_pKonqFrame->statusbar()->setMessage(errorMsg, KonqStatusBarMessageLabel::Error);
     m_bAborted = true;
     slotCompleted();
 }
 
 void KonqView::slotSelectionInfo(const KFileItemList &items)
 {
     m_selectedItems = items;
     KonqFileSelectionEvent ev(items, m_pPart);
     QApplication::sendEvent(m_pMainWindow, &ev);
 }
 
 void KonqView::slotMouseOverInfo(const KFileItem &item)
 {
     KonqFileMouseOverEvent ev(item, m_pPart);
     QApplication::sendEvent(m_pMainWindow, &ev);
 }
 
 void KonqView::setLocationBarURL(const QUrl &locationBarURL)
 {
     setLocationBarURL(locationBarURL.url(QUrl::PreferLocalFile));
 }
 
 void KonqView::setLocationBarURL(const QString &locationBarURL)
 {
     //qCDebug(KONQUEROR_LOG) << locationBarURL << "this=" << this;
     m_sLocationBarURL = locationBarURL;
     if (m_pMainWindow->currentView() == this) {
         //qCDebug(KONQUEROR_LOG) << "is current view" << this;
         m_pMainWindow->setLocationBarURL(m_sLocationBarURL);
         m_pMainWindow->setPageSecurity(m_pageSecurity);
     }
     if (!m_bPassiveMode) {
         setTabIcon(QUrl::fromUserInput(m_sLocationBarURL));
     }
 }
 
 void KonqView::setIconURL(const QUrl &iconURL)
 // This function sets the favIcon in konqui's window if enabled,
 // thus it is responsible for the icon in the taskbar.
 // It does not set the tab's favIcon.
 {
     if (KonqSettings::enableFavicon()) {
         KonqPixmapProvider::self()->setIconForUrl(QUrl(m_sLocationBarURL), iconURL);
         m_bGotIconURL = true;
     }
 }
 
 void KonqView::setPageSecurity(int pageSecurity)
 {
     m_pageSecurity = static_cast<KonqMainWindow::PageSecurity>(pageSecurity);
 
     if (m_pMainWindow->currentView() == this) {
         m_pMainWindow->setPageSecurity(m_pageSecurity);
     }
 }
 
 void KonqView::setTabIcon(const QUrl &url)
 {
     if (!m_bPassiveMode && url.isValid()) {
         frame()->setTabIcon(url, 0L);
     }
 }
 
 void KonqView::setCaption(const QString &caption)
 {
     if (caption.isEmpty()) {
         return;
     }
 
     QString adjustedCaption = caption;
     // For local URLs we prefer to use only the directory name
     if (url().isLocalFile()) {
         // Is the caption a URL?  If so, is it local?  If so, only display the filename!
         const QUrl captionUrl(QUrl::fromUserInput(caption));
         if (captionUrl.isValid() && captionUrl.isLocalFile() && captionUrl.path() == url().path()) {
             adjustedCaption = captionUrl.adjusted(QUrl::StripTrailingSlash).fileName();
             if (adjustedCaption.isEmpty()) {
                 adjustedCaption = QLatin1Char('/');
             }
         }
     }
 
     m_caption = adjustedCaption;
     if (!m_bPassiveMode) {
         frame()->setTitle(adjustedCaption, 0L);
     }
 }
 
 void KonqView::slotOpenURLNotify()
 {
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG);
 #endif
     updateHistoryEntry(true);
     createHistoryEntry();
     if (m_pMainWindow->currentView() == this) {
         m_pMainWindow->updateToolBarActions();
     }
 }
 
 void KonqView::createHistoryEntry()
 {
     // First, remove any forward history
     HistoryEntry *current = currentHistoryEntry();
     if (current) {
 #ifdef DEBUG_HISTORY
         qCDebug(KONQUEROR_LOG) << "Truncating history";
 #endif
         while (current != m_lstHistory.last()) {
             delete m_lstHistory.takeLast();
         }
     }
     // Append a new entry
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "Append a new entry";
 #endif
     appendHistoryEntry(new HistoryEntry);
     setHistoryIndex(m_lstHistory.count() - 1); // made current
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "at=" << historyIndex() << "count=" << m_lstHistory.count();
 #endif
 }
 
 void KonqView::appendHistoryEntry(HistoryEntry *historyEntry)
 {
     // If there are too many HistoryEntries remove old ones
     while (m_lstHistory.count() > 0 && m_lstHistory.count() >= KonqSettings::maximumHistoryEntriesPerView()) {
         delete m_lstHistory.takeFirst();
     }
 
     m_lstHistory.append(historyEntry);
 }
 
 void KonqView::updateHistoryEntry(bool saveLocationBarURL)
 {
     Q_ASSERT(!m_bLockHistory);   // should never happen
 
     HistoryEntry *current = currentHistoryEntry();
     if (!current) {
         return;
     }
 
     current->reload = false; // We have a state for it now.
     if (browserExtension()) {
         current->buffer = QByteArray(); // Start with empty buffer.
         QDataStream stream(&current->buffer, QIODevice::WriteOnly);
 
         browserExtension()->saveState(stream);
     }
 
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "Saving part URL:" << m_pPart->url() << "in history position" << historyIndex();
 #endif
     current->url = m_pPart->url();
 
     if (saveLocationBarURL) {
 #ifdef DEBUG_HISTORY
         qCDebug(KONQUEROR_LOG) << "Saving location bar URL:" << m_sLocationBarURL << "in history position" << historyIndex();
 #endif
         current->locationBarURL = m_sLocationBarURL;
         current->pageSecurity = m_pageSecurity;
     }
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "Saving title:" << m_caption << "in history position" << historyIndex();
 #endif
     current->title = m_caption;
     current->strServiceType = m_serviceType;
     current->strServiceName = m_service->desktopEntryName();
 
     current->doPost = m_doPost;
     current->postData = m_doPost ? m_postData : QByteArray();
     current->postContentType = m_doPost ? m_postContentType : QString();
     current->pageReferrer = m_pageReferrer;
 }
 
 void KonqView::goHistory(int steps)
 {
     // This is called by KonqBrowserInterface
     if (m_pMainWindow->currentView() == this) {
         m_pMainWindow->viewManager()->setActivePart(part());
     }
 
     // Delay the go() call (we need to return to the caller first)
     m_pMainWindow->slotGoHistoryActivated(steps);
 }
 
 void KonqView::go(int steps)
 {
     if (!steps) { // [WildFox] i bet there are sites on the net with stupid devs who do that :)
 #ifdef DEBUG_HISTORY
         qCDebug(KONQUEROR_LOG) << "go(0) -> reload";
 #endif
         // [David] and you're right. And they expect that it reloads, apparently.
         // [George] I'm going to make nspluginviewer rely on this too. :-)
         m_pMainWindow->slotReload();
         return;
     }
 
     int newPos = historyIndex() + steps;
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "steps=" << steps
              << "newPos=" << newPos
              << "m_lstHistory.count()=" << m_lstHistory.count();
 #endif
     if (newPos < 0 || newPos >= m_lstHistory.count()) {
         return;
     }
 
     stop();
 
     setHistoryIndex(newPos);   // sets current item
 
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "New position" << historyIndex();
 #endif
 
     restoreHistory();
 }
 
 void KonqView::restoreHistory()
 {
     HistoryEntry h(*currentHistoryEntry());   // make a copy of the current history entry, as the data
     // the pointer points to will change with the following calls
 
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "Restoring servicetype/name, and location bar URL from history:" << h.locationBarURL;
 #endif
     setLocationBarURL(h.locationBarURL);
     setPageSecurity(h.pageSecurity);
     m_sTypedURL.clear();
 
     if (!changePart(h.strServiceType, h.strServiceName)) {
         qCWarning(KONQUEROR_LOG) << "Couldn't change view mode to" << h.strServiceType << h.strServiceName;
         return /*false*/;
     }
 
     setPartMimeType();
 
     aboutToOpenURL(h.url);
 
     if (h.reload == false && browserExtension()) {
         //qCDebug(KONQUEROR_LOG) << "Restoring view from stream";
         QDataStream stream(h.buffer);
 
         browserExtension()->restoreState(stream);
 
         m_doPost = h.doPost;
         m_postContentType = h.postContentType;
         m_postData = h.postData;
         m_pageReferrer = h.pageReferrer;
     } else {
         m_pPart->openUrl(h.url);
     }
 
     if (m_pMainWindow->currentView() == this) {
         m_pMainWindow->updateToolBarActions();
     }
 
 #ifdef DEBUG_HISTORY
     qCDebug(KONQUEROR_LOG) << "New position (2)" << historyIndex();
 #endif
 }
 
 const HistoryEntry *KonqView::historyAt(int pos)
 {
     return m_lstHistory.value(pos);
 }
 
 void KonqView::copyHistory(KonqView *other)
 {
     if (!other) {
         return;
     }
 
     qDeleteAll(m_lstHistory);
     m_lstHistory.clear();
 
     foreach (HistoryEntry *he, other->m_lstHistory) {
         appendHistoryEntry(new HistoryEntry(*he));
     }
     setHistoryIndex(other->historyIndex());
 }
 
 QUrl KonqView::url() const
 {
     Q_ASSERT(m_pPart);
     return m_pPart->url();
 }
 
 QUrl KonqView::upUrl() const
 {
     QUrl currentURL;
     if (m_pRun) {
         currentURL = m_pRun->url();
     } else {
         currentURL = QUrl::fromUserInput(m_sLocationBarURL);
     }
     return KIO::upUrl(currentURL);
 }
 
 void KonqView::setRun(KonqRun *run)
 {
     if (m_pRun) {
         // Tell the KonqRun to abort, but don't delete it ourselves.
         // It could be showing a message box right now. It will delete itself anyway.
         m_pRun->abort();
         // finish() will be emitted later (when back to event loop)
         // and we don't want it to call slotRunFinished (which stops the animation and stop button).
         m_pRun->disconnect(m_pMainWindow);
         if (!run) {
             frame()->unsetCursor();
         }
     } else if (run) {
         frame()->setCursor(Qt::BusyCursor);
     }
     m_pRun = run;
 }
 
 void KonqView::stop()
 {
     //qCDebug(KONQUEROR_LOG);
     m_bAborted = false;
     finishedWithCurrentURL();
     if (m_bLoading || m_bPendingRedirection) {
         // aborted -> confirm the pending url. We might as well remove it, but
         // we decided to keep it :)
         KonqHistoryManager::kself()->confirmPending(url(), m_sTypedURL);
 
         //qCDebug(KONQUEROR_LOG) << "m_pPart->closeUrl()";
         m_pPart->closeUrl();
         m_bAborted = true;
         m_pKonqFrame->statusbar()->slotLoadingProgress(-1);
         setLoading(false, false);
     }
     if (m_pRun) {
         // Revert to working URL - unless the URL was typed manually
         // This is duplicated with KonqMainWindow::slotRunFinished, but we can't call it
         //   since it relies on sender()...
         if (currentHistoryEntry() && m_pRun->typedUrl().isEmpty()) {   // not typed
             setLocationBarURL(currentHistoryEntry()->locationBarURL);
             setPageSecurity(currentHistoryEntry()->pageSecurity);
         }
 
         setRun(0L);
         m_pKonqFrame->statusbar()->slotLoadingProgress(-1);
     }
     if (!m_bLockHistory && m_lstHistory.count() > 0) {
         updateHistoryEntry(true);
     }
 }
 
 void KonqView::finishedWithCurrentURL()
 {
     if (!m_tempFile.isEmpty()) {
         qCDebug(KONQUEROR_LOG) << "######### Deleting tempfile after use:" << m_tempFile;
         QFile::remove(m_tempFile);
         m_tempFile.clear();
     }
 }
 
 void KonqView::setPassiveMode(bool mode)
 {
     // In theory, if m_bPassiveMode is true and mode is false,
     // the part should be removed from the part manager,
     // and if the other way round, it should be readded to the part manager...
     m_bPassiveMode = mode;
 
     if (mode && m_pMainWindow->viewCount() > 1 && m_pMainWindow->currentView() == this) {
         KParts::Part *part = m_pMainWindow->viewManager()->chooseNextView(this)->part();    // switch active part
         m_pMainWindow->viewManager()->setActivePart(part);
     }
 
     // Update statusbar stuff
     m_pMainWindow->viewManager()->viewCountChanged();
 }
 
 void KonqView::setLinkedView(bool mode)
 {
     m_bLinkedView = mode;
     if (m_pMainWindow->currentView() == this) {
         m_pMainWindow->linkViewAction()->setChecked(mode);
     }
     frame()->statusbar()->setLinkedView(mode);
 }
 
 void KonqView::setLockedLocation(bool b)
 {
     m_bLockedLocation = b;
 }
 
 void KonqView::aboutToOpenURL(const QUrl &url, const KParts::OpenUrlArguments &args)
 {
     m_bErrorURL = url.scheme() == QLatin1String("error");
 
     KParts::OpenUrlEvent ev(m_pPart, url, args);
     QApplication::sendEvent(m_pMainWindow, &ev);
 
     m_bGotIconURL = false;
     m_bAborted = false;
 }
 
 void KonqView::setPartMimeType()
 {
     KParts::OpenUrlArguments args(m_pPart->arguments());
     args.setMimeType(m_serviceType);
     m_pPart->setArguments(args);
 }
 
 QStringList KonqView::frameNames() const
 {
     return childFrameNames(m_pPart);
 }
 
 QStringList KonqView::childFrameNames(KParts::ReadOnlyPart *part)
 {
     QStringList res;
 
     KParts::BrowserHostExtension *hostExtension = KParts::BrowserHostExtension::childObject(part);
 
     if (!hostExtension) {
         return res;
     }
 
     res += hostExtension->frameNames();
 
     const QList<KParts::ReadOnlyPart *> children = hostExtension->frames();
     QListIterator<KParts::ReadOnlyPart *> i(children);
     while (i.hasNext()) {
         res += childFrameNames(i.next());
     }
 
     return res;
 }
 
 KParts::BrowserHostExtension *KonqView::hostExtension(KParts::ReadOnlyPart *part, const QString &name)
 {
     KParts::BrowserHostExtension *ext = KParts::BrowserHostExtension::childObject(part);
 
     if (!ext) {
         return 0;
     }
 
     if (ext->frameNames().contains(name)) {
         return ext;
     }
 
     const QList<KParts::ReadOnlyPart *> children = ext->frames();
     QListIterator<KParts::ReadOnlyPart *> i(children);
     while (i.hasNext()) {
         KParts::BrowserHostExtension *childHost = hostExtension(i.next(), name);
         if (childHost) {
             return childHost;
         }
     }
 
     return 0;
 }
 
 bool KonqView::callExtensionMethod(const char *methodName)
 {
     QObject *obj = KParts::BrowserExtension::childObject(m_pPart);
     if (!obj) { // not all views have a browser extension !
         return false;
     }
 
     return QMetaObject::invokeMethod(obj, methodName,  Qt::DirectConnection);
 }
 
 bool KonqView::callExtensionBoolMethod(const char *methodName, bool value)
 {
     QObject *obj = KParts::BrowserExtension::childObject(m_pPart);
     if (!obj) { // not all views have a browser extension !
         return false;
     }
 
     return QMetaObject::invokeMethod(obj, methodName,  Qt::DirectConnection, Q_ARG(bool, value));
 }
 
 bool KonqView::callExtensionURLMethod(const char *methodName, const QUrl &value)
 {
     QObject *obj = KParts::BrowserExtension::childObject(m_pPart);
     if (!obj) { // not all views have a browser extension !
         return false;
     }
 
     return QMetaObject::invokeMethod(obj, methodName,  Qt::DirectConnection, Q_ARG(QUrl, value));
 }
 
 void KonqView::setViewName(const QString &name)
 {
     //qCDebug(KONQUEROR_LOG) << this << "name=" << name;
     if (m_pPart) {
         m_pPart->setObjectName(name);
     }
 }
 
 QString KonqView::viewName() const
 {
     return m_pPart ? m_pPart->objectName() : QString();
 }
 
 void KonqView::enablePopupMenu(bool b)
 {
     Q_ASSERT(m_pMainWindow);
 
     KParts::BrowserExtension *ext = browserExtension();
 
     if (!ext) {
         return;
     }
 
     if (m_bPopupMenuEnabled == b) {
         return;
     }
 
     // enable context popup
     if (b) {
         m_bPopupMenuEnabled = true;
 
         connect(ext, SIGNAL(popupMenu(QPoint,KFileItemList,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)),
                 m_pMainWindow, SLOT(slotPopupMenu(QPoint,KFileItemList,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)));
 
         connect(ext, SIGNAL(popupMenu(QPoint,QUrl,mode_t,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)),
                 m_pMainWindow, SLOT(slotPopupMenu(QPoint,QUrl,mode_t,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)));
     } else { // disable context popup
         m_bPopupMenuEnabled = false;
 
         disconnect(ext, SIGNAL(popupMenu(QPoint,KFileItemList,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)),
                    m_pMainWindow, SLOT(slotPopupMenu(QPoint,KFileItemList,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)));
 
         disconnect(ext, SIGNAL(popupMenu(QPoint,QUrl,mode_t,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)),
                    m_pMainWindow, SLOT(slotPopupMenu(QPoint,QUrl,mode_t,KParts::OpenUrlArguments,KParts::BrowserArguments,KParts::BrowserExtension::PopupFlags,KParts::BrowserExtension::ActionGroupMap)));
     }
 }
 
 void KonqView::reparseConfiguration()
 {
     callExtensionMethod("reparseConfiguration");
 }
 
 void KonqView::disableScrolling()
 {
     m_bDisableScrolling = true;
     callExtensionMethod("disableScrolling");
 }
 
 QString KonqView::dbusObjectPath()
 {
     // TODO maybe this can be improved?
     // E.g. using the part's name, but we'd have to update the name in setViewName maybe?
     // And to make sure it's a valid dbus object path like in kmainwindow...
     static int s_viewNumber = 0;
     if (m_dbusObjectPath.isEmpty()) {
         m_dbusObjectPath = m_pMainWindow->dbusName() + '/' + QString::number(++s_viewNumber);
         new KonqViewAdaptor(this);
         QDBusConnection::sessionBus().registerObject(m_dbusObjectPath, this);
     }
     return m_dbusObjectPath;
 }
 
 QString KonqView::partObjectPath()
 {
     if (!m_pPart) {
         return QString();
     }
 
     const QVariant dcopProperty = m_pPart->property("dbusObjectPath");
     return dcopProperty.toString();
 }
 
 bool KonqView::eventFilter(QObject *obj, QEvent *e)
 {
     if (!m_pPart) {
         return false;
     }
 //  qCDebug(KONQUEROR_LOG) << "--" << obj->className() << "--" << e->type() << "--" ;
     if (e->type() == QEvent::DragEnter && m_bURLDropHandling && obj == m_pPart->widget()) {
         QDragEnterEvent *ev = static_cast<QDragEnterEvent *>(e);
         const QMimeData *mimeData = ev->mimeData();
         if (mimeData->hasUrls()) {
             QList<QUrl> lstDragURLs = KUrlMimeData::urlsFromMimeData(mimeData);
 
             QList<QObject *> children = qFindChildren<QObject *>(m_pPart->widget());   // ### slow, better write a isChildOf with a loop...
 
             if (!lstDragURLs.isEmpty()
                     && !lstDragURLs.first().url().startsWith(QLatin1String("javascript:"), Qt::CaseInsensitive) &&   // ### this looks like a hack to me
                     ev->source() != m_pPart->widget() &&
                     !children.contains(ev->source())) {
                 ev->acceptProposedAction();
             }
         }
     } else if (e->type() == QEvent::Drop && m_bURLDropHandling && obj == m_pPart->widget()) {
         QDropEvent *ev = static_cast<QDropEvent *>(e);
         const QMimeData *mimeData = ev->mimeData();
 
         QList<QUrl> lstDragURLs = KUrlMimeData::urlsFromMimeData(mimeData);
         KParts::BrowserExtension *ext = browserExtension();
         if (!lstDragURLs.isEmpty() && ext && lstDragURLs.first().isValid()) {
             emit ext->openUrlRequest(lstDragURLs.first());    // this will call m_pMainWindow::slotOpenURLRequest delayed
         }
     }
 
     if (e->type() == QEvent::FocusIn) {
         setActiveComponent();
     }
 
 #ifdef KActivities_FOUND
     if (e->type() == QEvent::FocusOut) {
         m_activityResourceInstance->notifyFocusedOut();
     }
 #endif
 
     return false;
 }
 
 void KonqView::setActiveComponent()
 {
 #if 0 // Removed with the port to KF5. The concept no longer exists, the about dialog and bug report
     // dialog just use the application information rather than the one of the current part.
     if (m_bBuiltinView) {
         KComponentData::setActiveComponent(KGlobal::mainComponent());
     } else {
         KComponentData::setActiveComponent(KComponentData(m_pPart->componentData()));
     }
 #endif
 
 #ifdef KActivities_FOUND
     m_activityResourceInstance->notifyFocusedIn();
 #endif
 }
 
 bool KonqView::prepareReload(KParts::OpenUrlArguments &args, KParts::BrowserArguments &browserArgs, bool softReload)
 {
     args.setReload(true);
     if (softReload) {
         browserArgs.softReload = true;
     }
 
     // Repost form data if this URL is the result of a POST HTML form.
     if (m_doPost && !browserArgs.redirectedRequest()) {
         if (KMessageBox::warningContinueCancel(0, i18n(
                 "The page you are trying to view is the result of posted form data. "
                 "If you resend the data, any action the form carried out (such as search or online purchase) will be repeated. "),
                                                i18nc("@title:window", "Warning"), KGuiItem(i18n("Resend"))) == KMessageBox::Continue) {
             browserArgs.setDoPost(true);
             browserArgs.setContentType(m_postContentType);
             browserArgs.postData = m_postData;
         } else {
             return false;
         }
     }
     // Re-set referrer
     args.metaData()[QStringLiteral("referrer")] = m_pageReferrer;
 
     return true;
 }
 
 KParts::BrowserExtension *KonqView::browserExtension() const
 {
     return KParts::BrowserExtension::childObject(m_pPart);
 }
 
 KParts::StatusBarExtension *KonqView::statusBarExtension() const
 {
     return KParts::StatusBarExtension::childObject(m_pPart);
 }
 
 KMimeType::Ptr KonqView::mimeType() const
 {
     return KMimeType::mimeType(serviceType()); // can be null
 }
 
 bool KonqView::supportsMimeType(const QString &mimeType) const
 {
     KMimeType::Ptr mime = KMimeType::mimeType(mimeType, KMimeType::ResolveAliases);
     if (!mime) {
         return false;
     }
     const QStringList lst = serviceTypes();
     for (QStringList::ConstIterator it = lst.begin(); it != lst.end(); ++it) {
         if (mime->is(*it)) { // same as mime == *it, but also respect inheritance, mimeType can be a subclass
             return true;
         }
     }
     return false;
 }
 
 void HistoryEntry::saveConfig(KConfigGroup &config, const QString &prefix, const KonqFrameBase::Options &options)
 {
     if (options & KonqFrameBase::saveURLs) {
         config.writeEntry(QStringLiteral("Url").prepend(prefix), url.url());
         config.writeEntry(QStringLiteral("LocationBarURL").prepend(prefix), locationBarURL);
         config.writeEntry(QStringLiteral("Title").prepend(prefix), title);
         config.writeEntry(QStringLiteral("StrServiceType").prepend(prefix), strServiceType);
         config.writeEntry(QStringLiteral("StrServiceName").prepend(prefix), strServiceName);
     } else if (options & KonqFrameBase::saveHistoryItems) {
         config.writeEntry(QStringLiteral("Url").prepend(prefix), url.url());
         config.writeEntry(QStringLiteral("LocationBarURL").prepend(prefix), locationBarURL);
         config.writeEntry(QStringLiteral("Title").prepend(prefix), title);
         config.writeEntry(QStringLiteral("Buffer").prepend(prefix), buffer);
         config.writeEntry(QStringLiteral("StrServiceType").prepend(prefix), strServiceType);
         config.writeEntry(QStringLiteral("StrServiceName").prepend(prefix), strServiceName);
         config.writeEntry(QStringLiteral("PostData").prepend(prefix), postData);
         config.writeEntry(QStringLiteral("PostContentType").prepend(prefix), postContentType);
         config.writeEntry(QStringLiteral("DoPost").prepend(prefix), doPost);
         config.writeEntry(QStringLiteral("PageReferrer").prepend(prefix), pageReferrer);
         config.writeEntry(QStringLiteral("PageSecurity").prepend(prefix), static_cast<int>(pageSecurity));
     }
 }
 
 void HistoryEntry::loadItem(const KConfigGroup &config, const QString &prefix, const KonqFrameBase::Options &options)
 {
     if (options & KonqFrameBase::saveURLs) {
         url = QUrl(config.readEntry(QStringLiteral("Url").prepend(prefix), ""));
         locationBarURL = config.readEntry(QStringLiteral("LocationBarURL").prepend(prefix), "");
         title = config.readEntry(QStringLiteral("Title").prepend(prefix), "");
         strServiceType = config.readEntry(QStringLiteral("StrServiceType").prepend(prefix), "");
         strServiceName = config.readEntry(QStringLiteral("StrServiceName").prepend(prefix), "");
         reload = true;
     } else if (options & KonqFrameBase::saveHistoryItems) {
         url = QUrl(config.readEntry(QStringLiteral("Url").prepend(prefix), ""));
         locationBarURL = config.readEntry(QStringLiteral("LocationBarURL").prepend(prefix), "");
         title = config.readEntry(QStringLiteral("Title").prepend(prefix), "");
         buffer = config.readEntry(QStringLiteral("Buffer").prepend(prefix), QByteArray());
         strServiceType = config.readEntry(QStringLiteral("StrServiceType").prepend(prefix), "");
         strServiceName = config.readEntry(QStringLiteral("StrServiceName").prepend(prefix), "");
         postData = config.readEntry(QStringLiteral("PostData").prepend(prefix), QByteArray());
         postContentType = config.readEntry(QStringLiteral("PostContentType").prepend(prefix), "");
         doPost = config.readEntry(QStringLiteral("DoPost").prepend(prefix), false);
         pageReferrer = config.readEntry(QStringLiteral("PageReferrer").prepend(prefix), "");
         pageSecurity = static_cast<KonqMainWindow::PageSecurity>(config.readEntry(
                            QStringLiteral("PageSecurity").prepend(prefix), 0));
         reload = false;
     }
 }
 
 void KonqView::saveConfig(KConfigGroup &config, const QString &prefix, const KonqFrameBase::Options &options)
 {
     config.writeEntry(QStringLiteral("ServiceType").prepend(prefix), serviceType());
     config.writeEntry(QStringLiteral("ServiceName").prepend(prefix), service()->desktopEntryName());
     config.writeEntry(QStringLiteral("PassiveMode").prepend(prefix), isPassiveMode());
     config.writeEntry(QStringLiteral("LinkedView").prepend(prefix), isLinkedView());
     config.writeEntry(QStringLiteral("ToggleView").prepend(prefix), isToggleView());
     config.writeEntry(QStringLiteral("LockedLocation").prepend(prefix), isLockedLocation());
 
     if (options & KonqFrameBase::saveURLs) {
         config.writePathEntry(QStringLiteral("URL").prepend(prefix), url().url());
     } else if (options & KonqFrameBase::saveHistoryItems) {
         if (m_pPart && !m_bLockHistory) {
             updateHistoryEntry(true);
         }
         QList<HistoryEntry *>::Iterator it = m_lstHistory.begin();
         for (int i = 0; it != m_lstHistory.end(); ++it, ++i) {
             // In order to not end up with a huge config file, we only save full
             // history for current history item
             KonqFrameBase::Options options;
             if (i == m_lstHistoryIndex) {
                 options = KonqFrameBase::saveHistoryItems;
             } else {
                 options = KonqFrameBase::saveURLs;
             }
 
             (*it)->saveConfig(config, QLatin1String("HistoryItem")
                               + QString::number(i).prepend(prefix), options);
         }
         config.writeEntry(QStringLiteral("CurrentHistoryItem").prepend(prefix), m_lstHistoryIndex);
         config.writeEntry(QStringLiteral("NumberOfHistoryItems").prepend(prefix), historyLength());
     }
 }
 
 void KonqView::loadHistoryConfig(const KConfigGroup &config, const QString &prefix)
 {
     // First, remove any history
     qDeleteAll(m_lstHistory);
     m_lstHistory.clear();
 
     int historySize = config.readEntry(QStringLiteral("NumberOfHistoryItems").prepend(prefix), 0);
     int currentIndex = config.readEntry(QStringLiteral("CurrentHistoryItem").prepend(prefix), historySize - 1);
 
     // No history to restore..
     if (historySize == 0) {
         createHistoryEntry();
         return;
     }
 
     // restore history list
     for (int i = 0; i < historySize; ++i) {
         HistoryEntry *historyEntry = new HistoryEntry;
 
         // Only current history item saves completely its HistoryEntry
         KonqFrameBase::Options options;
         if (i == currentIndex) {
             options = KonqFrameBase::saveHistoryItems;
         } else {
             options = KonqFrameBase::saveURLs;
         }
 
         historyEntry->loadItem(config, QLatin1String("HistoryItem") + QString::number(i).prepend(prefix), options);
 
         appendHistoryEntry(historyEntry);
     }
 
     // Shouldn't happen, but just in case..
     if (currentIndex >= historyLength()) {
         currentIndex = historyLength() - 1;
     }
 
     // set and load the correct history index
     setHistoryIndex(currentIndex);
     restoreHistory();
 }
 
 QString KonqView::internalViewMode() const
 {
     const QVariant viewModeProperty = m_pPart->property("currentViewMode");
     return viewModeProperty.toString();
 }
 
 void KonqView::setInternalViewMode(const QString &viewMode)
 {
     m_pPart->setProperty("currentViewMode", viewMode);
 }
 
 QString KonqView::nameFilter() const
 {
     const QVariant nameFilterProperty = m_pPart->property("nameFilter");
     return nameFilterProperty.toString();
 }
 
 bool KonqView::showsDirectory() const
 {
     return supportsMimeType(QStringLiteral("inode/directory"));
 }
 
 bool KonqView::isModified() const
 {
     if (m_pPart && (m_pPart->metaObject()->indexOfProperty("modified") != -1)) {
         const QVariant prop = m_pPart->property("modified");
         return prop.isValid() && prop.toBool();
     }
     return false;
 }
 
 void KonqView::setFocus()
 {
     if (m_pPart && m_pPart->widget() && !isErrorUrl()) {
         m_pPart->widget()->setFocus();
     }
 }
 
 bool KonqView::isErrorUrl() const
 {
     return m_bErrorURL;
 }
 
diff --git a/webenginepart/autotests/webengine_testutils.h b/webenginepart/autotests/webengine_testutils.h
index 37489847b..6eecb9077 100644
--- a/webenginepart/autotests/webengine_testutils.h
+++ b/webenginepart/autotests/webengine_testutils.h
@@ -1,108 +1,110 @@
 /****************************************************************************
   **
   ** Copyright (C) 2016 The Qt Company Ltd.
   ** Contact: https://www.qt.io/licensing/
   **
   ** This file is part of the QtWebEngine module of the Qt Toolkit.
   **
   ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
   ** Commercial License Usage
   ** Licensees holding valid commercial Qt licenses may use this file in
   ** accordance with the commercial license agreement provided with the
   ** Software or, alternatively, in accordance with the terms contained in
   ** a written agreement between you and The Qt Company. For licensing terms
   ** and conditions see https://www.qt.io/terms-conditions. For further
   ** information use the contact form at https://www.qt.io/contact-us.
   **
   ** GNU General Public License Usage
   ** Alternatively, this file may be used under the terms of the GNU
   ** General Public License version 3 as published by the Free Software
   ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
   ** included in the packaging of this file. Please review the following
   ** information to ensure the GNU General Public License requirements will
   ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
   **
   ** $QT_END_LICENSE$
   **
   ****************************************************************************/
+#ifndef WEBENGINE_TESTUTILS_H
+#define WEBENGINE_TESTUTILS_H
 
 #include <QEventLoop>
 #include <QTimer>
 #include <QWebEnginePage>
 
 template<typename T, typename R>
 struct RefWrapper {
     R &ref;
     void operator()(const T& result) {
         ref(result);
     }
 };
 
 template<typename T>
 class CallbackSpy {
 public:
     CallbackSpy() : called(false) {
         timeoutTimer.setSingleShot(true);
         QObject::connect(&timeoutTimer, SIGNAL(timeout()), &eventLoop, SLOT(quit()));
     }
 
     T waitForResult() {
         if (!called) {
             timeoutTimer.start(10000);
             eventLoop.exec();
         }
         return result;
     }
 
     bool wasCalled() const {
         return called;
     }
 
     void operator()(const T &result) {
         this->result = result;
         called = true;
         eventLoop.quit();
     }
 
     // Cheap rip-off of boost/std::ref
     RefWrapper<T, CallbackSpy<T> > ref()
     {
         RefWrapper<T, CallbackSpy<T> > wrapper = {*this};
         return wrapper;
     }
 
 private:
     Q_DISABLE_COPY(CallbackSpy)
     bool called;
     QTimer timeoutTimer;
     QEventLoop eventLoop;
     T result;
 };
 
 // taken from the qwebengine unittests
 static inline QVariant evaluateJavaScriptSync(QWebEnginePage *page, const QString &script)
 {
     CallbackSpy<QVariant> spy;
     page->runJavaScript(script, spy.ref());
     return spy.waitForResult();
 }
 
 // Taken from QtWebEngine's tst_qwebenginepage.cpp
 static QPoint elementCenter(QWebEnginePage *page, const QString &id)
 {
     QVariantList rectList = evaluateJavaScriptSync(page,
             "(function(){"
             "var elem = document.getElementById('" + id + "');"
             "var rect = elem.getBoundingClientRect();"
             "return [rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top];"
             "})()").toList();
 
     if (rectList.count() != 4) {
         qWarning("elementCenter failed.");
         return QPoint();
     }
     const QRect rect(rectList.at(0).toInt(), rectList.at(1).toInt(),
                      rectList.at(2).toInt(), rectList.at(3).toInt());
     return rect.center();
 }
-
+#endif
diff --git a/webenginepart/src/settings/webengine_filter.h b/webenginepart/src/settings/webengine_filter.h
index 2c908a478..38e6d9843 100644
--- a/webenginepart/src/settings/webengine_filter.h
+++ b/webenginepart/src/settings/webengine_filter.h
@@ -1,60 +1,60 @@
 /* This file is part of the KDE project
 
    Copyright (C) 2005 Ivor Hewitt     <ivor@kde.org>
    Copyright (C) 2008 Maksim Orlovich <maksim@kde.org>
    Copyright (C) 2008 Vyacheslav Tokarev <tsjoker@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.
 */
 
-#ifndef WEBENGNINE_FILTER_P_H
-#define WEBENGNINE_FILTER_P_H
+#ifndef WEBENGNINE_FILTER_H
+#define WEBENGNINE_FILTER_H
 
 #include <QString>
 #include <QRegExp>
 #include <QVector>
 #include <webenginepart.h>
 
 class StringsMatcher;
 
 namespace KDEPrivate
 {
 // This represents a set of filters that may match URLs.
 // Currently it supports a subset of AddBlock Plus functionality.
 class FilterSet {
 public:
     FilterSet();
     ~FilterSet();
 
     // Parses and registers a filter. This will also strip @@ for exclusion rules, skip comments, etc.
     // The user does have to split black and white lists into separate sets, however
     void addFilter(const QString& filter);
 
     bool isUrlMatched(const QString& url);
     QString urlMatchedBy(const QString& url);
 
     void clear();
 
 private:
     QVector<QRegExp> reFilters;
     StringsMatcher* stringFiltersMatcher;
 };
 
 }
 
-#endif // WEBENGINE_FILTER_P_H
+#endif // WEBENGINE_FILTER_H
 
 // kate: indent-width 4; replace-tabs on; tab-width 4; space-indent on;
diff --git a/webenginepart/src/settings/webenginesettings.cpp b/webenginepart/src/settings/webenginesettings.cpp
index a0e34158e..fe07785e9 100644
--- a/webenginepart/src/settings/webenginesettings.cpp
+++ b/webenginepart/src/settings/webenginesettings.cpp
@@ -1,1284 +1,1284 @@
 /* This file is part of the KDE project
    Copyright (C) 1999 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 "webenginesettings.h"
 
 #include "webengine_filter.h"
 
 #include <KConfig>
 #include <KSharedConfig>
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KJob>
 #include <KIO/Job>
 #include <KMessageBox>
 
-#include <QtWebEngineWidgets/QWebEngineSettings>
+#include <QWebEngineSettings>
 #include <QFontDatabase>
 #include <QFileInfo>
 
 // browser window color defaults -- Bernd
 #define HTML_DEFAULT_LNK_COLOR Qt::blue
 #define HTML_DEFAULT_TXT_COLOR Qt::black
 #define HTML_DEFAULT_VLNK_COLOR Qt::magenta
 #define HTML_DEFAULT_BASE_COLOR Qt::white
 
 #define HTML_DEFAULT_VIEW_FONT "Sans Serif"
 #define HTML_DEFAULT_VIEW_FIXED_FONT "Monospace"
 #define HTML_DEFAULT_VIEW_SERIF_FONT "Serif"
 #define HTML_DEFAULT_VIEW_SANSSERIF_FONT "Sans Serif"
 #define HTML_DEFAULT_VIEW_CURSIVE_FONT "Sans Serif"
 #define HTML_DEFAULT_VIEW_FANTASY_FONT "Sans Serif"
 #define HTML_DEFAULT_MIN_FONT_SIZE 7 // everything smaller is usually unreadable.
 
 /**
  * @internal
  * Contains all settings which are both available globally and per-domain
  */
 struct KPerDomainSettings {
     bool m_bEnableJava : 1;
     bool m_bEnableJavaScript : 1;
     bool m_bEnablePlugins : 1;
     // don't forget to maintain the bitfields as the enums grow
     KParts::HtmlSettingsInterface::JSWindowOpenPolicy m_windowOpenPolicy : 2;
     KParts::HtmlSettingsInterface::JSWindowStatusPolicy m_windowStatusPolicy : 1;
     KParts::HtmlSettingsInterface::JSWindowFocusPolicy m_windowFocusPolicy : 1;
     KParts::HtmlSettingsInterface::JSWindowMovePolicy m_windowMovePolicy : 1;
     KParts::HtmlSettingsInterface::JSWindowResizePolicy m_windowResizePolicy : 1;
 
 #ifdef DEBUG_SETTINGS
     void dump(const QString &infix = QString()) const {
       kDebug() << "KPerDomainSettings " << infix << " @" << this << ":";
       kDebug() << "  m_bEnableJava: " << m_bEnableJava;
       kDebug() << "  m_bEnableJavaScript: " << m_bEnableJavaScript;
       kDebug() << "  m_bEnablePlugins: " << m_bEnablePlugins;
       kDebug() << "  m_windowOpenPolicy: " << m_windowOpenPolicy;
       kDebug() << "  m_windowStatusPolicy: " << m_windowStatusPolicy;
       kDebug() << "  m_windowFocusPolicy: " << m_windowFocusPolicy;
       kDebug() << "  m_windowMovePolicy: " << m_windowMovePolicy;
       kDebug() << "  m_windowResizePolicy: " << m_windowResizePolicy;
     }
 #endif
 };
 
 typedef QMap<QString,KPerDomainSettings> PolicyMap;
 
 class WebEngineSettingsData
 {
 public:  
     bool m_bChangeCursor : 1;
     bool m_bOpenMiddleClick : 1;
     bool m_underlineLink : 1;
     bool m_hoverLink : 1;
     bool m_bEnableJavaScriptDebug : 1;
     bool m_bEnableJavaScriptErrorReporting : 1;
     bool enforceCharset : 1;
     bool m_bAutoLoadImages : 1;
     bool m_bUnfinishedImageFrame : 1;
     bool m_formCompletionEnabled : 1;
     bool m_autoDelayedActionsEnabled : 1;
     bool m_jsErrorsEnabled : 1;
     bool m_follow_system_colors : 1;
     bool m_allowTabulation : 1;
     bool m_autoSpellCheck : 1;
     bool m_adFilterEnabled : 1;
     bool m_hideAdsEnabled : 1;
     bool m_jsPopupBlockerPassivePopup : 1;
     bool m_accessKeysEnabled : 1;
     bool m_zoomTextOnly : 1;
     bool m_useCookieJar : 1;
     bool m_acceptCrossDomainCookies : 1;
     bool m_bAutoRefreshPage: 1;
     bool m_bEnableFavicon:1;
     bool m_disableInternalPluginHandling:1;
     bool m_offerToSaveWebSitePassword:1;
     bool m_loadPluginsOnDemand:1;
     bool m_enableLocalStorage:1;
     bool m_enableOfflineStorageDb:1;
     bool m_enableOfflineWebAppCache:1;
     bool m_enableWebGL:1;
     bool m_zoomToDPI:1;
     bool m_allowActiveMixedContent:1;
     bool m_allowMixedContentDisplay:1;
 
     // the virtual global "domain"
     KPerDomainSettings global;
 
     int m_fontSize;
     int m_minFontSize;
     int m_maxFormCompletionItems;
     WebEngineSettings::KAnimationAdvice m_showAnimations;
     WebEngineSettings::KSmoothScrollingMode m_smoothScrolling;
 
     QString m_encoding;
     QString m_userSheet;
 
     QColor m_textColor;
     QColor m_baseColor;
     QColor m_linkColor;
     QColor m_vLinkColor;
 
     PolicyMap domainPolicy;
     QStringList fonts;
     QStringList defaultFonts;
 
     KDEPrivate::FilterSet adBlackList;
     KDEPrivate::FilterSet adWhiteList;
     QList< QPair< QString, QChar > > m_fallbackAccessKeysAssignments;
 
     KSharedConfig::Ptr nonPasswordStorableSites;
 };
 
 class WebEngineSettingsPrivate : public QObject, public WebEngineSettingsData
 {
     Q_OBJECT
 public:
     void adblockFilterLoadList(const QString& filename)
     {
         /** load list file and process each line */
         QFile file(filename);
         if (file.open(QIODevice::ReadOnly)) {
             QTextStream ts(&file);
             QString line = ts.readLine();
             while (!line.isEmpty()) {
                 //kDebug() << "Adding filter:" << line;
                 /** white list lines start with "@@" */
                 if (line.startsWith(QLatin1String("@@")))
                     adWhiteList.addFilter(line);
                 else
                     adBlackList.addFilter(line);
                 line = ts.readLine();
             }
             file.close();
         }
     }
 
 public Q_SLOTS:
     void adblockFilterResult(KJob *job)
     {
         KIO::StoredTransferJob *tJob = qobject_cast<KIO::StoredTransferJob*>(job);
         Q_ASSERT(tJob);
 
         if ( job->error() == KJob::NoError )
         {
             const QByteArray byteArray = tJob->data();
             const QString localFileName = tJob->property( "webenginesettings_adBlock_filename" ).toString();
 
             QFile file(localFileName);
             if ( file.open(QFile::WriteOnly) )
             {
                 const bool success = (file.write(byteArray) == byteArray.size());
                 if ( success )
                     adblockFilterLoadList(localFileName);
                 else
                     qWarning() << "Could not write" << byteArray.size() << "to file" << localFileName;
                 file.close();
             }
             else
                 qDebug() << "Cannot open file" << localFileName << "for filter list";
         }
         else
             qDebug() << "Downloading" << tJob->url() << "failed with message:" << job->errorText();
     }
 };
 
 
 /** Returns a writeable per-domains settings instance for the given domain
   * or a deep copy of the global settings if not existent.
   */
 static KPerDomainSettings &setup_per_domain_policy(WebEngineSettingsPrivate* const d, const QString &domain)
 {
   if (domain.isEmpty())
     qWarning() << "setup_per_domain_policy: domain is empty";
 
   const QString ldomain = domain.toLower();
   PolicyMap::iterator it = d->domainPolicy.find(ldomain);
   if (it == d->domainPolicy.end()) {
     // simply copy global domain settings (they should have been initialized
     // by this time)
     it = d->domainPolicy.insert(ldomain,d->global);
   }
   return *it;
 }
 
 template<typename T>
 static T readEntry(const KConfigGroup& config, const QString& key, int defaultValue)
 {
     return static_cast<T>(config.readEntry(key, defaultValue));
 }
 
 void WebEngineSettings::readDomainSettings(const KConfigGroup &config, bool reset,
                                         bool global, KPerDomainSettings &pd_settings)
 {
   const QString javaPrefix ((global ? QString() : QStringLiteral("java.")));
   const QString jsPrefix ((global ? QString() : QStringLiteral("javascript.")));
   const QString pluginsPrefix (global ? QString() : QStringLiteral("plugins."));
 
   // The setting for Java
   QString key = javaPrefix + QLatin1String("EnableJava");
   if ( (global && reset) || config.hasKey( key ) )
     pd_settings.m_bEnableJava = config.readEntry( key, false );
   else if ( !global )
     pd_settings.m_bEnableJava = d->global.m_bEnableJava;
 
   // The setting for Plugins
   key = pluginsPrefix + QLatin1String("EnablePlugins");
   if ( (global && reset) || config.hasKey( key ) )
     pd_settings.m_bEnablePlugins = config.readEntry( key, true );
   else if ( !global )
     pd_settings.m_bEnablePlugins = d->global.m_bEnablePlugins;
 
   // The setting for JavaScript
   key = jsPrefix + QLatin1String("EnableJavaScript");
   if ( (global && reset) || config.hasKey( key ) )
     pd_settings.m_bEnableJavaScript = config.readEntry( key, true );
   else if ( !global )
     pd_settings.m_bEnableJavaScript = d->global.m_bEnableJavaScript;
 
   // window property policies
   key = jsPrefix + QLatin1String("WindowOpenPolicy");
   if ( (global && reset) || config.hasKey( key ) )
     pd_settings.m_windowOpenPolicy = readEntry<KParts::HtmlSettingsInterface::JSWindowOpenPolicy>(config, key, KParts::HtmlSettingsInterface::JSWindowOpenSmart);
   else if ( !global )
     pd_settings.m_windowOpenPolicy = d->global.m_windowOpenPolicy;
 
   key = jsPrefix + QLatin1String("WindowMovePolicy");
   if ( (global && reset) || config.hasKey( key ) )
     pd_settings.m_windowMovePolicy = readEntry<KParts::HtmlSettingsInterface::JSWindowMovePolicy>(config, key, KParts::HtmlSettingsInterface::JSWindowMoveAllow);
   else if ( !global )
     pd_settings.m_windowMovePolicy = d->global.m_windowMovePolicy;
 
   key = jsPrefix + QLatin1String("WindowResizePolicy");
   if ( (global && reset) || config.hasKey( key ) )
     pd_settings.m_windowResizePolicy = readEntry<KParts::HtmlSettingsInterface::JSWindowResizePolicy>(config, key, KParts::HtmlSettingsInterface::JSWindowResizeAllow);
   else if ( !global )
     pd_settings.m_windowResizePolicy = d->global.m_windowResizePolicy;
 
   key = jsPrefix + QLatin1String("WindowStatusPolicy");
   if ( (global && reset) || config.hasKey( key ) )
     pd_settings.m_windowStatusPolicy = readEntry<KParts::HtmlSettingsInterface::JSWindowStatusPolicy>(config, key, KParts::HtmlSettingsInterface::JSWindowStatusAllow);
   else if ( !global )
     pd_settings.m_windowStatusPolicy = d->global.m_windowStatusPolicy;
 
   key = jsPrefix + QLatin1String("WindowFocusPolicy");
   if ( (global && reset) || config.hasKey( key ) )
     pd_settings.m_windowFocusPolicy = readEntry<KParts::HtmlSettingsInterface::JSWindowFocusPolicy>(config, key, KParts::HtmlSettingsInterface::JSWindowFocusAllow);
   else if ( !global )
     pd_settings.m_windowFocusPolicy = d->global.m_windowFocusPolicy;
 }
 
 
 WebEngineSettings::WebEngineSettings()
   :d (new WebEngineSettingsPrivate)
 {
   init();
 }
 
 WebEngineSettings::~WebEngineSettings()
 {
   delete d;
 }
 
 bool WebEngineSettings::changeCursor() const
 {
   return d->m_bChangeCursor;
 }
 
 bool WebEngineSettings::underlineLink() const
 {
   return d->m_underlineLink;
 }
 
 bool WebEngineSettings::hoverLink() const
 {
   return d->m_hoverLink;
 }
 
 void WebEngineSettings::init()
 {
   initWebEngineSettings();
 
   KConfig global( QStringLiteral("khtmlrc"), KConfig::NoGlobals );
   init( &global, true );
 
   KSharedConfig::Ptr local = KSharedConfig::openConfig();
   if ( local ) {
       init( local.data(), false );
   }
 
   initNSPluginSettings();
   initCookieJarSettings();
 }
 
 void WebEngineSettings::init( KConfig * config, bool reset )
 {
   KConfigGroup cg( config, "MainView Settings" );
   if (reset || cg.exists() )
   {
     if ( reset || cg.hasKey( "OpenMiddleClick" ) )
         d->m_bOpenMiddleClick = cg.readEntry( "OpenMiddleClick", true );
   }
 
   KConfigGroup cgAccess(config,"Access Keys" );
   if (reset || cgAccess.exists() ) {
       d->m_accessKeysEnabled = cgAccess.readEntry( "Enabled", true );
   }
 
   KConfigGroup cgFilter( config, "Filter Settings" );
 
   if ((reset || cgFilter.exists()) && (d->m_adFilterEnabled = cgFilter.readEntry("Enabled", false)))
   {
       d->m_hideAdsEnabled = cgFilter.readEntry("Shrink", false);
 
       d->adBlackList.clear();
       d->adWhiteList.clear();
 
       /** read maximum age for filter list files, minimum is one day */
       int htmlFilterListMaxAgeDays = cgFilter.readEntry(QStringLiteral("HTMLFilterListMaxAgeDays")).toInt();
       if (htmlFilterListMaxAgeDays < 1)
           htmlFilterListMaxAgeDays = 1;
 
       QMapIterator<QString,QString> it (cgFilter.entryMap());
       while (it.hasNext())
       {
           it.next();
           int id = -1;
           const QString name = it.key();
           const QString url = it.value();
 
           if (name.startsWith(QLatin1String("Filter")))
           {
               if (url.startsWith(QLatin1String("@@")))
                   d->adWhiteList.addFilter(url);
               else
                   d->adBlackList.addFilter(url);
           }
           else if (name.startsWith(QLatin1String("HTMLFilterListName-")) && (id = name.midRef(19).toInt()) > 0)
           {
               /** check if entry is enabled */
               bool filterEnabled = cgFilter.readEntry(QStringLiteral("HTMLFilterListEnabled-").append(QString::number(id))) != QLatin1String("false");
 
               /** get url for HTMLFilterList */
               QUrl url(cgFilter.readEntry(QStringLiteral("HTMLFilterListURL-").append(QString::number(id))));
 
               if (filterEnabled && url.isValid()) {
                   /** determine where to cache HTMLFilterList file */
                   QString localFile = cgFilter.readEntry(QStringLiteral("HTMLFilterListLocalFilename-").append(QString::number(id)));
                   localFile = QStandardPaths::locate(QStandardPaths::ConfigLocation, "khtml/" + localFile);
 
                   /** determine existence and age of cache file */
                   QFileInfo fileInfo(localFile);
 
                   /** load cached file if it exists, irrespective of age */
                   if (fileInfo.exists())
                       d->adblockFilterLoadList( localFile );
 
                   /** if no cache list file exists or if it is too old ... */
                   if (!fileInfo.exists() || fileInfo.lastModified().daysTo(QDateTime::currentDateTime()) > htmlFilterListMaxAgeDays)
                   {
                       /** ... in this case, refetch list asynchronously */
                       // kDebug() << "Fetching filter list from" << url << "to" << localFile;
                       KIO::StoredTransferJob *job = KIO::storedGet( url, KIO::Reload, KIO::HideProgressInfo );
                       QObject::connect( job, SIGNAL(result(KJob*)), d, SLOT(adblockFilterResult(KJob*)) );
                       /** for later reference, store name of cache file */
                       job->setProperty("webenginesettings_adBlock_filename", localFile);
                   }
               }
           }
       }
   }
 
   KConfigGroup cgHtml( config, "HTML Settings" );
   if (reset || cgHtml.exists() )
   {
     // Fonts and colors
     if( reset ) {
         d->defaultFonts = QStringList();
         d->defaultFonts.append( cgHtml.readEntry( "StandardFont", QFontDatabase::systemFont(QFontDatabase::GeneralFont).family() ) );
         d->defaultFonts.append( cgHtml.readEntry( "FixedFont", QFontDatabase::systemFont(QFontDatabase::FixedFont).family() ));
         d->defaultFonts.append( cgHtml.readEntry( "SerifFont", HTML_DEFAULT_VIEW_SERIF_FONT ) );
         d->defaultFonts.append( cgHtml.readEntry( "SansSerifFont", HTML_DEFAULT_VIEW_SANSSERIF_FONT ) );
         d->defaultFonts.append( cgHtml.readEntry( "CursiveFont", HTML_DEFAULT_VIEW_CURSIVE_FONT ) );
         d->defaultFonts.append( cgHtml.readEntry( "FantasyFont", HTML_DEFAULT_VIEW_FANTASY_FONT ) );
         d->defaultFonts.append( QStringLiteral( "0" ) ); // font size adjustment
     }
 
     if ( reset || cgHtml.hasKey( "MinimumFontSize" ) )
         d->m_minFontSize = cgHtml.readEntry( "MinimumFontSize", HTML_DEFAULT_MIN_FONT_SIZE );
 
     if ( reset || cgHtml.hasKey( "MediumFontSize" ) )
         d->m_fontSize = cgHtml.readEntry( "MediumFontSize", 12 );
 
     d->fonts = cgHtml.readEntry( "Fonts", QStringList() );
 
     if ( reset || cgHtml.hasKey( "DefaultEncoding" ) )
         d->m_encoding = cgHtml.readEntry( "DefaultEncoding", "" );
 
     if ( reset || cgHtml.hasKey( "EnforceDefaultCharset" ) )
         d->enforceCharset = cgHtml.readEntry( "EnforceDefaultCharset", false );
 
     // Behavior
 
     if ( reset || cgHtml.hasKey("UnderlineLinks") )
         d->m_underlineLink = cgHtml.readEntry( "UnderlineLinks", true );
 
     if ( reset || cgHtml.hasKey( "HoverLinks" ) )
     {
         if ( (d->m_hoverLink = cgHtml.readEntry( "HoverLinks", false )))
             d->m_underlineLink = false;
     }
 
     if ( reset || cgHtml.hasKey( "AllowTabulation" ) )
         d->m_allowTabulation = cgHtml.readEntry( "AllowTabulation", false );
 
     if ( reset || cgHtml.hasKey( "AutoSpellCheck" ) )
         d->m_autoSpellCheck = cgHtml.readEntry( "AutoSpellCheck", true );
 
     // Other
     if ( reset || cgHtml.hasKey( "AutoLoadImages" ) )
       d->m_bAutoLoadImages = cgHtml.readEntry( "AutoLoadImages", true );
 
     if ( reset || cgHtml.hasKey( "AutoDelayedActions" ) )
         d->m_bAutoRefreshPage = cgHtml.readEntry( "AutoDelayedActions", true );
 
     if ( reset || cgHtml.hasKey( "UnfinishedImageFrame" ) )
       d->m_bUnfinishedImageFrame = cgHtml.readEntry( "UnfinishedImageFrame", true );
 
     if ( reset || cgHtml.hasKey( "ShowAnimations" ) )
     {
       QString value = cgHtml.readEntry( "ShowAnimations").toLower();
       if (value == QLatin1String("disabled"))
          d->m_showAnimations = KAnimationDisabled;
       else if (value == QLatin1String("looponce"))
          d->m_showAnimations = KAnimationLoopOnce;
       else
          d->m_showAnimations = KAnimationEnabled;
     }
 
     if ( reset || cgHtml.hasKey( "SmoothScrolling" ) )
     {
       QString value = cgHtml.readEntry( "SmoothScrolling", "whenefficient" ).toLower();
       if (value == QLatin1String("disabled"))
          d->m_smoothScrolling = KSmoothScrollingDisabled;
       else if (value == QLatin1String("whenefficient"))
          d->m_smoothScrolling = KSmoothScrollingWhenEfficient;
       else
          d->m_smoothScrolling = KSmoothScrollingEnabled;
     } 
 
     if ( reset || cgHtml.hasKey( "ZoomTextOnly" ) ) {
         d->m_zoomTextOnly = cgHtml.readEntry( "ZoomTextOnly", false );
     }
 
     if ( reset || cgHtml.hasKey( "ZoomToDPI" ) ) {
         d->m_zoomToDPI = cgHtml.readEntry( "ZoomToDPI", false );
     }
 
     if (cgHtml.readEntry("UserStyleSheetEnabled", false)) {
         if (reset || cgHtml.hasKey("UserStyleSheet"))
             d->m_userSheet = cgHtml.readEntry("UserStyleSheet", QString());
     } else {
         d->m_userSheet.clear();
     }
 
     d->m_formCompletionEnabled = cgHtml.readEntry("FormCompletion", true);
     d->m_maxFormCompletionItems = cgHtml.readEntry("MaxFormCompletionItems", 10);
     d->m_autoDelayedActionsEnabled = cgHtml.readEntry ("AutoDelayedActions", true);
     d->m_jsErrorsEnabled = cgHtml.readEntry("ReportJSErrors", true);
     const QStringList accesskeys = cgHtml.readEntry("FallbackAccessKeysAssignments", QStringList());
     d->m_fallbackAccessKeysAssignments.clear();
     for( QStringList::ConstIterator it = accesskeys.begin(); it != accesskeys.end(); ++it )
         if( (*it).length() > 2 && (*it)[ 1 ] == ':' )
             d->m_fallbackAccessKeysAssignments.append( qMakePair( (*it).mid( 2 ), (*it)[ 0 ] ));
 
     d->m_bEnableFavicon = cgHtml.readEntry("EnableFavicon", true);
     d->m_offerToSaveWebSitePassword = cgHtml.readEntry("OfferToSaveWebsitePassword", true);
   }
 
   // Colors
   //In which group ?????
   if ( reset || cg.hasKey( "FollowSystemColors" ) )
       d->m_follow_system_colors = cg.readEntry( "FollowSystemColors", false );
 
   KConfigGroup cgGeneral( config, "General" );
   if ( reset || cgGeneral.exists( ) )
   {
     if ( reset || cgGeneral.hasKey( "foreground" ) ) {
       QColor def(HTML_DEFAULT_TXT_COLOR);
       d->m_textColor = cgGeneral.readEntry( "foreground", def );
     }
 
     if ( reset || cgGeneral.hasKey( "linkColor" ) ) {
       QColor def(HTML_DEFAULT_LNK_COLOR);
       d->m_linkColor = cgGeneral.readEntry( "linkColor", def );
     }
 
     if ( reset || cgGeneral.hasKey( "visitedLinkColor" ) ) {
       QColor def(HTML_DEFAULT_VLNK_COLOR);
       d->m_vLinkColor = cgGeneral.readEntry( "visitedLinkColor", def);
     }
 
     if ( reset || cgGeneral.hasKey( "background" ) ) {
       QColor def(HTML_DEFAULT_BASE_COLOR);
       d->m_baseColor = cgGeneral.readEntry( "background", def);
     }
   }
 
   KConfigGroup cgJava( config, "Java/JavaScript Settings" );
   if( reset || cgJava.exists() )
   {
     // The global setting for JavaScript debugging
     // This is currently always enabled by default
     if ( reset || cgJava.hasKey( "EnableJavaScriptDebug" ) )
       d->m_bEnableJavaScriptDebug = cgJava.readEntry( "EnableJavaScriptDebug", false );
 
     // The global setting for JavaScript error reporting
     if ( reset || cgJava.hasKey( "ReportJavaScriptErrors" ) )
       d->m_bEnableJavaScriptErrorReporting = cgJava.readEntry( "ReportJavaScriptErrors", false );
 
     // The global setting for popup block passive popup
     if ( reset || cgJava.hasKey( "PopupBlockerPassivePopup" ) )
       d->m_jsPopupBlockerPassivePopup = cgJava.readEntry("PopupBlockerPassivePopup", true );
 
     // Read options from the global "domain"
     readDomainSettings(cgJava,reset,true,d->global);
 #ifdef DEBUG_SETTINGS
     d->global.dump("init global");
 #endif
 
     // The domain-specific settings.
 
     static const char *const domain_keys[] = {	// always keep order of keys
     	"ECMADomains", "JavaDomains", "PluginDomains"
     };
     bool check_old_ecma_settings = true;
     bool check_old_java_settings = true;
     // merge all domains into one list
     QSet<QString> domainList;
     for (unsigned i = 0; i < sizeof domain_keys/sizeof domain_keys[0]; ++i) {
         if (reset || cgJava.hasKey(domain_keys[i])) {
             if (i == 0) check_old_ecma_settings = false;
             else if (i == 1) check_old_java_settings = false;
             const QStringList dl = cgJava.readEntry( domain_keys[i], QStringList() );
             const QSet<QString>::Iterator notfound = domainList.end();
             QStringList::ConstIterator it = dl.begin();
             const QStringList::ConstIterator itEnd = dl.end();
             for (; it != itEnd; ++it) {
                 const QString domain = (*it).toLower();
                 QSet<QString>::Iterator pos = domainList.find(domain);
                 if (pos == notfound) domainList.insert(domain);
             }/*next it*/
         }
     }/*next i*/
 
     if (reset)
       d->domainPolicy.clear();
 
     {
       QSet<QString>::ConstIterator it = domainList.constBegin();
       const QSet<QString>::ConstIterator itEnd = domainList.constEnd();
       for ( ; it != itEnd; ++it)
       {
         const QString domain = *it;
         KConfigGroup cg( config, domain );
         readDomainSettings(cg,reset,false,d->domainPolicy[domain]);
 #ifdef DEBUG_SETTINGS
         d->domainPolicy[domain].dump("init "+domain);
 #endif
       }
     }
 
     bool check_old_java = true;
     if( (reset || cgJava.hasKey("JavaDomainSettings")) && check_old_java_settings)
     {
       check_old_java = false;
       const QStringList domainList = cgJava.readEntry( "JavaDomainSettings", QStringList() );
       QStringList::ConstIterator it = domainList.constBegin();
       const QStringList::ConstIterator itEnd = domainList.constEnd();
       for ( ; it != itEnd; ++it)
       {
         QString domain;
         KParts::HtmlSettingsInterface::JavaScriptAdvice javaAdvice;
         KParts::HtmlSettingsInterface::JavaScriptAdvice javaScriptAdvice;
         KParts::HtmlSettingsInterface::splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
         setup_per_domain_policy(d,domain).m_bEnableJava = javaAdvice == KParts::HtmlSettingsInterface::JavaScriptAccept;
 #ifdef DEBUG_SETTINGS
         setup_per_domain_policy(d,domain).dump("JavaDomainSettings 4 "+domain);
 #endif
       }
     }
 
     bool check_old_ecma = true;
     if( ( reset || cgJava.hasKey( "ECMADomainSettings" ) ) && check_old_ecma_settings )
     {
       check_old_ecma = false;
       const QStringList domainList = cgJava.readEntry( "ECMADomainSettings", QStringList() );
       QStringList::ConstIterator it = domainList.constBegin();
       const QStringList::ConstIterator itEnd = domainList.constEnd();
       for ( ; it != itEnd; ++it)
       {
         QString domain;
         KParts::HtmlSettingsInterface::JavaScriptAdvice javaAdvice;
         KParts::HtmlSettingsInterface::JavaScriptAdvice javaScriptAdvice;
         KParts::HtmlSettingsInterface::splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
         setup_per_domain_policy(d,domain).m_bEnableJavaScript = javaScriptAdvice == KParts::HtmlSettingsInterface::JavaScriptAccept;
 #ifdef DEBUG_SETTINGS
 	setup_per_domain_policy(d,domain).dump("ECMADomainSettings 4 "+domain);
 #endif
       }
     }
 
     if( ( reset || cgJava.hasKey( "JavaScriptDomainAdvice" ) )
              && ( check_old_java || check_old_ecma )
 	     && ( check_old_ecma_settings || check_old_java_settings ) )
     {
       const QStringList domainList = cgJava.readEntry( "JavaScriptDomainAdvice", QStringList() );
       QStringList::ConstIterator it = domainList.constBegin();
       const QStringList::ConstIterator itEnd = domainList.constEnd();
       for ( ; it != itEnd; ++it)
       {
         QString domain;
         KParts::HtmlSettingsInterface::JavaScriptAdvice javaAdvice;
         KParts::HtmlSettingsInterface::JavaScriptAdvice javaScriptAdvice;
         KParts::HtmlSettingsInterface::splitDomainAdvice(*it, domain, javaAdvice, javaScriptAdvice);
         if( check_old_java )
           setup_per_domain_policy(d,domain).m_bEnableJava = javaAdvice == KParts::HtmlSettingsInterface::JavaScriptAccept;
         if( check_old_ecma )
           setup_per_domain_policy(d,domain).m_bEnableJavaScript = javaScriptAdvice == KParts::HtmlSettingsInterface::JavaScriptAccept;
 #ifdef DEBUG_SETTINGS
         setup_per_domain_policy(d,domain).dump("JavaScriptDomainAdvice 4 "+domain);
 #endif
       }
     }
   }
 
 #if 0
   // DNS Prefect support...
   if ( reset || cgHtml.hasKey( "DNSPrefetch" ) )
   {
     // Enabled, Disabled, OnlyWWWAndSLD
     QString value = cgHtml.readEntry( "DNSPrefetch", "Enabled" ).toLower();
 
     if (value == "enabled")
         QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::DnsPrefetchEnabled, true);
     else
         QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::DnsPrefetchEnabled, false);
   }
 
   // Sync with QWebEngineSettings.
   if (!d->m_encoding.isEmpty())
       QWebEngineSettings::globalSettings()->setDefaultTextEncoding(d->m_encoding);
   QWebEngineSettings::globalSettings()->setUserStyleSheetUrl(QUrl::fromUserInput(userStyleSheet()));
 #endif
 
   QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::AutoLoadImages, autoLoadImages());
   QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::JavascriptEnabled, isJavaScriptEnabled());
  // QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::JavaEnabled, isJavaEnabled());
   QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::PluginsEnabled, isPluginsEnabled());
 
   // By default disable JS window.open when policy is deny or smart.
   const KParts::HtmlSettingsInterface::JSWindowOpenPolicy policy = windowOpenPolicy();
   if (policy == KParts::HtmlSettingsInterface::JSWindowOpenDeny || policy == KParts::HtmlSettingsInterface::JSWindowOpenSmart)
       QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::JavascriptCanOpenWindows, false);
   else
       QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::JavascriptCanOpenWindows, true);
 
 //  QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::ZoomTextOnly, zoomTextOnly());
 //  QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::DeveloperExtrasEnabled, isJavaScriptDebugEnabled());
   QWebEngineSettings::globalSettings()->setFontFamily(QWebEngineSettings::StandardFont, stdFontName());
   QWebEngineSettings::globalSettings()->setFontFamily(QWebEngineSettings::FixedFont, fixedFontName());
   QWebEngineSettings::globalSettings()->setFontFamily(QWebEngineSettings::SerifFont, serifFontName());
   QWebEngineSettings::globalSettings()->setFontFamily(QWebEngineSettings::SansSerifFont, sansSerifFontName());
   QWebEngineSettings::globalSettings()->setFontFamily(QWebEngineSettings::CursiveFont, cursiveFontName());
   QWebEngineSettings::globalSettings()->setFontFamily(QWebEngineSettings::FantasyFont, fantasyFontName());
 
   // TODO: Create a webengine config module that gets embedded into Konqueror's kcm.
   // Turn on WebGL support
 //  QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::WebGLEnabled, d->m_enableWebGL);
   // Turn on HTML 5 local and offline storage capabilities...
 //  QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::OfflineStorageDatabaseEnabled, d->m_enableOfflineStorageDb);
 //  QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::OfflineWebApplicationCacheEnabled, d->m_enableOfflineWebAppCache);
   QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::LocalStorageEnabled, d->m_enableLocalStorage);
 
   QWebEngineSettings::globalSettings()->setAttribute(QWebEngineSettings::ScrollAnimatorEnabled, smoothScrolling() != KSmoothScrollingDisabled);
 
   // These numbers should be calculated from real "logical" DPI/72, using a default dpi of 96 for now
   computeFontSizes(96);
 }
 
 
 void WebEngineSettings::computeFontSizes( int logicalDpi )
 {
   if (zoomToDPI())
       logicalDpi = 96;
 
   float toPix = logicalDpi/72.0;
 
   if (toPix < 96.0/72.0)
       toPix = 96.0/72.0;
 
   QWebEngineSettings::globalSettings()->setFontSize(QWebEngineSettings::MinimumFontSize, qRound(minFontSize() * toPix));
   QWebEngineSettings::globalSettings()->setFontSize(QWebEngineSettings::DefaultFontSize, qRound(mediumFontSize() * toPix));
 }
 
 bool WebEngineSettings::zoomToDPI() const
 {
     return d->m_zoomToDPI;
 }
 
 void WebEngineSettings::setZoomToDPI(bool enabled)
 {
   d->m_zoomToDPI = enabled;
   // save it
   KConfigGroup cg( KSharedConfig::openConfig(), "HTML Settings");
   cg.writeEntry("ZoomToDPI", enabled);
   cg.sync();
 }
 
 /** Local helper for retrieving per-domain settings.
   *
   * In case of doubt, the global domain is returned.
   */
 static const KPerDomainSettings& lookup_hostname_policy(const WebEngineSettingsPrivate* const d,
                                                         const QString& hostname)
 {
 #ifdef DEBUG_SETTINGS
   kDebug() << "lookup_hostname_policy(" << hostname << ")";
 #endif
   if (hostname.isEmpty()) {
 #ifdef DEBUG_SETTINGS
     d->global.dump("global");
 #endif
     return d->global;
   }
 
   const PolicyMap::const_iterator notfound = d->domainPolicy.constEnd();
 
   // First check whether there is a perfect match.
   PolicyMap::const_iterator it = d->domainPolicy.find(hostname);
   if( it != notfound ) {
 #ifdef DEBUG_SETTINGS
     kDebug() << "perfect match";
     (*it).dump(hostname);
 #endif
     // yes, use it (unless dunno)
     return *it;
   }
 
   // Now, check for partial match.  Chop host from the left until
   // there's no dots left.
   QString host_part = hostname;
   int dot_idx = -1;
   while( (dot_idx = host_part.indexOf(QChar('.'))) >= 0 ) {
     host_part.remove(0,dot_idx);
     it = d->domainPolicy.find(host_part);
     Q_ASSERT(notfound == d->domainPolicy.end());
     if( it != notfound ) {
 #ifdef DEBUG_SETTINGS
       kDebug() << "partial match";
       (*it).dump(host_part);
 #endif
       return *it;
     }
     // assert(host_part[0] == QChar('.'));
     host_part.remove(0,1); // Chop off the dot.
   }
 
   // No domain-specific entry: use global domain
 #ifdef DEBUG_SETTINGS
   kDebug() << "no match";
   d->global.dump("global");
 #endif
   return d->global;
 }
 
 bool WebEngineSettings::isOpenMiddleClickEnabled()
 {
   return d->m_bOpenMiddleClick;
 }
 
 bool WebEngineSettings::accessKeysEnabled() const
 {
     return d->m_accessKeysEnabled;
 }
 
 bool WebEngineSettings::favIconsEnabled() const
 {
     return d->m_bEnableFavicon;
 }
 
 bool WebEngineSettings::isAdFilterEnabled() const
 {
     return d->m_adFilterEnabled;
 }
 
 bool WebEngineSettings::isHideAdsEnabled() const
 {
     return d->m_hideAdsEnabled;
 }
 
 bool WebEngineSettings::isAdFiltered( const QString &url ) const
 {
     if (!d->m_adFilterEnabled)
         return false;
 
     if (url.startsWith(QLatin1String("data:")))
         return false;
 
     return d->adBlackList.isUrlMatched(url) && !d->adWhiteList.isUrlMatched(url);
 }
 
 QString WebEngineSettings::adFilteredBy( const QString &url, bool *isWhiteListed ) const
 {
     QString m = d->adWhiteList.urlMatchedBy(url);
 
     if (!m.isEmpty()) {
         if (isWhiteListed != 0)
             *isWhiteListed = true;
         return m;
     }
 
     m = d->adBlackList.urlMatchedBy(url);
     if (m.isEmpty())
         return QString();
 
     if (isWhiteListed != 0)
         *isWhiteListed = false;
     return m;
 }
 
 void WebEngineSettings::addAdFilter( const QString &url )
 {
     KConfigGroup config = KSharedConfig::openConfig( QStringLiteral("khtmlrc"), KConfig::NoGlobals )->group( "Filter Settings" );
 
     QRegExp rx;
 
     // Try compiling to avoid invalid stuff. Only support the basic syntax here...
     // ### refactor somewhat
     if (url.length()>2 && url[0]=='/' && url[url.length()-1] == '/')
     {
         const QString inside = url.mid(1, url.length()-2);
         rx.setPattern(inside);
     }
     else
     {
         rx.setPatternSyntax(QRegExp::Wildcard);
         rx.setPattern(url);
     }
 
     if (rx.isValid())
     {
         int last=config.readEntry("Count", 0);
         const QString key = "Filter-" + QString::number(last);
         config.writeEntry(key, url);
         config.writeEntry("Count",last+1);
         config.sync();
 
         if (url.startsWith(QLatin1String("@@")))
             d->adWhiteList.addFilter(url);
         else
             d->adBlackList.addFilter(url);
     }
     else
     {
         KMessageBox::error(0,
                            rx.errorString(),
                            i18n("Filter error"));
     }
 }
 
 bool WebEngineSettings::isJavaEnabled( const QString& hostname ) const
 {
   return lookup_hostname_policy(d,hostname.toLower()).m_bEnableJava;
 }
 
 bool WebEngineSettings::isJavaScriptEnabled( const QString& hostname ) const
 {
   return lookup_hostname_policy(d,hostname.toLower()).m_bEnableJavaScript;
 }
 
 bool WebEngineSettings::isJavaScriptDebugEnabled( const QString& /*hostname*/ ) const
 {
   // debug setting is global for now, but could change in the future
   return d->m_bEnableJavaScriptDebug;
 }
 
 bool WebEngineSettings::isJavaScriptErrorReportingEnabled( const QString& /*hostname*/ ) const
 {
   // error reporting setting is global for now, but could change in the future
   return d->m_bEnableJavaScriptErrorReporting;
 }
 
 bool WebEngineSettings::isPluginsEnabled( const QString& hostname ) const
 {
   return lookup_hostname_policy(d,hostname.toLower()).m_bEnablePlugins;
 }
 
 KParts::HtmlSettingsInterface::JSWindowOpenPolicy WebEngineSettings::windowOpenPolicy(const QString& hostname) const {
   return lookup_hostname_policy(d,hostname.toLower()).m_windowOpenPolicy;
 }
 
 KParts::HtmlSettingsInterface::JSWindowMovePolicy WebEngineSettings::windowMovePolicy(const QString& hostname) const {
   return lookup_hostname_policy(d,hostname.toLower()).m_windowMovePolicy;
 }
 
 KParts::HtmlSettingsInterface::JSWindowResizePolicy WebEngineSettings::windowResizePolicy(const QString& hostname) const {
   return lookup_hostname_policy(d,hostname.toLower()).m_windowResizePolicy;
 }
 
 KParts::HtmlSettingsInterface::JSWindowStatusPolicy WebEngineSettings::windowStatusPolicy(const QString& hostname) const {
   return lookup_hostname_policy(d,hostname.toLower()).m_windowStatusPolicy;
 }
 
 KParts::HtmlSettingsInterface::JSWindowFocusPolicy WebEngineSettings::windowFocusPolicy(const QString& hostname) const {
   return lookup_hostname_policy(d,hostname.toLower()).m_windowFocusPolicy;
 }
 
 int WebEngineSettings::mediumFontSize() const
 {
     return d->m_fontSize;
 }
 
 int WebEngineSettings::minFontSize() const
 {
   return d->m_minFontSize;
 }
 
 QString WebEngineSettings::settingsToCSS() const
 {
     // lets start with the link properties
     QString str = QStringLiteral("a:link {\ncolor: ");
     str += d->m_linkColor.name();
     str += ';';
     if(d->m_underlineLink)
         str += QLatin1String("\ntext-decoration: underline;");
 
     if( d->m_bChangeCursor )
     {
         str += QLatin1String("\ncursor: pointer;");
         str += QLatin1String("\n}\ninput[type=image] { cursor: pointer;");
     }
     str += QLatin1String("\n}\n");
     str += QLatin1String("a:visited {\ncolor: ");
     str += d->m_vLinkColor.name();
     str += ';';
     if(d->m_underlineLink)
         str += QLatin1String("\ntext-decoration: underline;");
 
     if( d->m_bChangeCursor )
         str += QLatin1String("\ncursor: pointer;");
     str += QLatin1String("\n}\n");
 
     if(d->m_hoverLink)
         str += QLatin1String("a:link:hover, a:visited:hover { text-decoration: underline; }\n");
 
     return str;
 }
 
 QString WebEngineSettings::lookupFont(int i) const
 {
     if (d->fonts.count() > i) {
         return d->fonts.at(i);
     }
 
     if (d->defaultFonts.count() > i) {
         return d->defaultFonts.at(i);
     }
 
     return QString();
 }
 
 QString WebEngineSettings::stdFontName() const
 {
     return lookupFont(0);
 }
 
 QString WebEngineSettings::fixedFontName() const
 {
     return lookupFont(1);
 }
 
 QString WebEngineSettings::serifFontName() const
 {
     return lookupFont(2);
 }
 
 QString WebEngineSettings::sansSerifFontName() const
 {
     return lookupFont(3);
 }
 
 QString WebEngineSettings::cursiveFontName() const
 {
     return lookupFont(4);
 }
 
 QString WebEngineSettings::fantasyFontName() const
 {
     return lookupFont(5);
 }
 
 void WebEngineSettings::setStdFontName(const QString &n)
 {
     while(d->fonts.count() <= 0)
         d->fonts.append(QString());
     d->fonts[0] = n;
 }
 
 void WebEngineSettings::setFixedFontName(const QString &n)
 {
     while(d->fonts.count() <= 1)
         d->fonts.append(QString());
     d->fonts[1] = n;
 }
 
 QString WebEngineSettings::userStyleSheet() const
 {
     return d->m_userSheet;
 }
 
 bool WebEngineSettings::isFormCompletionEnabled() const
 {
   return d->m_formCompletionEnabled;
 }
 
 int WebEngineSettings::maxFormCompletionItems() const
 {
   return d->m_maxFormCompletionItems;
 }
 
 const QString &WebEngineSettings::encoding() const
 {
   return d->m_encoding;
 }
 
 bool WebEngineSettings::followSystemColors() const
 {
     return d->m_follow_system_colors;
 }
 
 const QColor& WebEngineSettings::textColor() const
 {
   return d->m_textColor;
 }
 
 const QColor& WebEngineSettings::baseColor() const
 {
   return d->m_baseColor;
 }
 
 const QColor& WebEngineSettings::linkColor() const
 {
   return d->m_linkColor;
 }
 
 const QColor& WebEngineSettings::vLinkColor() const
 {
   return d->m_vLinkColor;
 }
 
 bool WebEngineSettings::autoPageRefresh() const
 {
   return d->m_bAutoRefreshPage;
 }
 
 bool WebEngineSettings::autoLoadImages() const
 {
   return d->m_bAutoLoadImages;
 }
 
 bool WebEngineSettings::unfinishedImageFrame() const
 {
   return d->m_bUnfinishedImageFrame;
 }
 
 WebEngineSettings::KAnimationAdvice WebEngineSettings::showAnimations() const
 {
   return d->m_showAnimations;
 }
 
 WebEngineSettings::KSmoothScrollingMode WebEngineSettings::smoothScrolling() const
 {
   return d->m_smoothScrolling;
 }
 
 bool WebEngineSettings::zoomTextOnly() const
 {
   return d->m_zoomTextOnly;
 }
 
 bool WebEngineSettings::isAutoDelayedActionsEnabled() const
 {
   return d->m_autoDelayedActionsEnabled;
 }
 
 bool WebEngineSettings::jsErrorsEnabled() const
 {
   return d->m_jsErrorsEnabled;
 }
 
 void WebEngineSettings::setJSErrorsEnabled(bool enabled)
 {
   d->m_jsErrorsEnabled = enabled;
   // save it
   KConfigGroup cg( KSharedConfig::openConfig(), "HTML Settings");
   cg.writeEntry("ReportJSErrors", enabled);
   cg.sync();
 }
 
 bool WebEngineSettings::allowTabulation() const
 {
     return d->m_allowTabulation;
 }
 
 bool WebEngineSettings::autoSpellCheck() const
 {
     return d->m_autoSpellCheck;
 }
 
 QList< QPair< QString, QChar > > WebEngineSettings::fallbackAccessKeysAssignments() const
 {
     return d->m_fallbackAccessKeysAssignments;
 }
 
 void WebEngineSettings::setJSPopupBlockerPassivePopup(bool enabled)
 {
     d->m_jsPopupBlockerPassivePopup = enabled;
     // save it
     KConfigGroup cg( KSharedConfig::openConfig(), "Java/JavaScript Settings");
     cg.writeEntry("PopupBlockerPassivePopup", enabled);
     cg.sync();
 }
 
 bool WebEngineSettings::jsPopupBlockerPassivePopup() const
 {
     return d->m_jsPopupBlockerPassivePopup;
 }
 
 bool WebEngineSettings::isCookieJarEnabled() const
 {
     return d->m_useCookieJar;
 }
 
 bool WebEngineSettings::acceptCrossDomainCookies() const
 {
     return d->m_acceptCrossDomainCookies;
 }
 
 
 // Password storage...
 static KConfigGroup nonPasswordStorableSitesCg(KSharedConfig::Ptr& configPtr)
 {
     if (!configPtr) {
         configPtr = KSharedConfig::openConfig(QStandardPaths::locate(QStandardPaths::DataLocation, QStringLiteral("khtml/formcompletions")), KConfig::NoGlobals);
     }
 
     return KConfigGroup(configPtr, "NonPasswordStorableSites");
 }
 
 bool WebEngineSettings::isNonPasswordStorableSite(const QString &host) const
 {
     KConfigGroup cg = nonPasswordStorableSitesCg(d->nonPasswordStorableSites);
     const QStringList sites = cg.readEntry("Sites", QStringList());
     return sites.contains(host);
 }
 
 void WebEngineSettings::addNonPasswordStorableSite(const QString &host)
 {
     KConfigGroup cg = nonPasswordStorableSitesCg(d->nonPasswordStorableSites);
     QStringList sites = cg.readEntry("Sites", QStringList());
     sites.append(host);
     cg.writeEntry("Sites", sites);
     cg.sync();
 }
 
 void WebEngineSettings::removeNonPasswordStorableSite(const QString &host)
 {
     KConfigGroup cg = nonPasswordStorableSitesCg(d->nonPasswordStorableSites);
     QStringList sites = cg.readEntry("Sites", QStringList());
     sites.removeOne(host);
     cg.writeEntry("Sites", sites);
     cg.sync();
 }
 
 bool WebEngineSettings::askToSaveSitePassword() const
 {
     return d->m_offerToSaveWebSitePassword;
 }
 
 bool WebEngineSettings::isInternalPluginHandlingDisabled() const
 {
     return d->m_disableInternalPluginHandling;
 }
 
 bool WebEngineSettings::isLoadPluginsOnDemandEnabled() const
 {
     return d->m_loadPluginsOnDemand;
 }
 
 bool WebEngineSettings::allowMixedContentDisplay() const
 {
     return d->m_allowMixedContentDisplay;
 }
 
 bool WebEngineSettings::alowActiveMixedContent() const
 {
     return d->m_allowActiveMixedContent;
 }
 
 
 void WebEngineSettings::initWebEngineSettings()
 {
     KConfig cfg (QStringLiteral("webenginepartrc"), KConfig::NoGlobals);
     KConfigGroup generalCfg (&cfg, "General");
     d->m_disableInternalPluginHandling = generalCfg.readEntry("DisableInternalPluginHandling", false);
     d->m_enableLocalStorage = generalCfg.readEntry("EnableLocalStorage", true);
     d->m_enableOfflineStorageDb = generalCfg.readEntry("EnableOfflineStorageDatabase", true);
     d->m_enableOfflineWebAppCache = generalCfg.readEntry("EnableOfflineWebApplicationCache", true);
     d->m_enableWebGL = generalCfg.readEntry("EnableWebGL", true);
     d->m_allowActiveMixedContent = generalCfg.readEntry("AllowActiveMixedContent", false);
     d->m_allowMixedContentDisplay = generalCfg.readEntry("AllowMixedContentDisplay", true);
 
     // Force the reloading of the non password storable sites settings.
     d->nonPasswordStorableSites.reset();
 }
 
 void WebEngineSettings::initCookieJarSettings()
 {
     KSharedConfig::Ptr cookieCfgPtr = KSharedConfig::openConfig(QStringLiteral("kcookiejarrc"), KConfig::NoGlobals);
     KConfigGroup cookieCfg ( cookieCfgPtr, "Cookie Policy");
     d->m_useCookieJar = cookieCfg.readEntry("Cookies", false);
     d->m_acceptCrossDomainCookies = !cookieCfg.readEntry("RejectCrossDomainCookies", true);
 }
 
 void WebEngineSettings::initNSPluginSettings()
 {
     KSharedConfig::Ptr cookieCfgPtr = KSharedConfig::openConfig(QStringLiteral("kcmnspluginrc"), KConfig::NoGlobals);
     KConfigGroup cookieCfg ( cookieCfgPtr, "Misc");
     d->m_loadPluginsOnDemand = cookieCfg.readEntry("demandLoad", false);
 }
 
 
 WebEngineSettings* WebEngineSettings::self()
 {
     static WebEngineSettings s_webEngineSettings;
     return &s_webEngineSettings;
 }
 
 #include "webenginesettings.moc"
diff --git a/webenginepart/src/ui/featurepermissionbar.h b/webenginepart/src/ui/featurepermissionbar.h
index d988ad36f..c348f5d10 100644
--- a/webenginepart/src/ui/featurepermissionbar.h
+++ b/webenginepart/src/ui/featurepermissionbar.h
@@ -1,54 +1,54 @@
 /*
  * This file is part of the KDE project.
  *
  * Copyright (C) 2013 Allan Sandfeld Jensen <sandfeld @ 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.1 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.
  */
 
 #ifndef FEATUREPERMISSIONBAR_H
 #define FEATUREPERMISSIONBAR_H
 
 #include <KMessageWidget>
 
-#include <QtWebEngineWidgets/QWebEnginePage>
+#include <QWebEnginePage>
 
 
 class FeaturePermissionBar : public KMessageWidget
 {
     Q_OBJECT
 public:
     explicit FeaturePermissionBar(QWidget *parent = Q_NULLPTR);
     ~FeaturePermissionBar();
 
     QWebEnginePage::Feature feature() const;
 
     void setFeature(QWebEnginePage::Feature);
 
 Q_SIGNALS:
     void permissionGranted(QWebEnginePage::Feature);
     void permissionDenied(QWebEnginePage::Feature);
     void done();
 
 private Q_SLOTS:
     void onDeniedButtonClicked();
     void onGrantedButtonClicked();
 
 private:
     QWebEnginePage::Feature m_feature;
 };
 
 #endif // FEATUREPERMISSIONBAR_H
diff --git a/webenginepart/src/webenginepage.h b/webenginepart/src/webenginepage.h
index cb3d5ed71..98741f6a2 100644
--- a/webenginepart/src/webenginepage.h
+++ b/webenginepart/src/webenginepage.h
@@ -1,168 +1,168 @@
 /*
  * This file is part of the KDE project.
  *
  * Copyright (C) 2008 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2008 Urs Wolfer <uwolfer @ kde.org>
  * Copyright (C) 2009 Dawit Alemayehu <adawit@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.1 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #ifndef WEBENGINEPAGE_H
 #define WEBENGINEPAGE_H
 
 #include "websslinfo.h"
 
 #include <KParts/BrowserExtension>
-#include <QtWebEngineWidgets/QWebEnginePage>
+#include <QWebEnginePage>
 
 #include <QUrl>
 #include <QDebug>
 #include <QMultiHash>
 #include <QPointer>
 #include <QScopedPointer>
 
 class QAuthenticator;
 class QUrl;
 class WebSslInfo;
 class WebEnginePart;
 class QWebEngineDownloadItem;
 class KPasswdServerClient;
 class WebEngineWallet;
 
 class WebEnginePage : public QWebEnginePage
 {
     Q_OBJECT
 public:
     explicit WebEnginePage(WebEnginePart *wpart, QWidget *parent = Q_NULLPTR);
     ~WebEnginePage();
 
     /**
      * Returns the SSL information for the current page.
      *
      * @see WebSslInfo.
      */
     const WebSslInfo& sslInfo() const;
 
     /**
      * Sets the page's SSL information to @p other.
      *
      * @see WebSslInfo
      */
     void setSslInfo (const WebSslInfo &other);
 
     void download(const QUrl &url, bool newWindow = false);
 
     WebEngineWallet* wallet() const {return m_wallet;}
 
 Q_SIGNALS:
     /**
      * This signal is emitted whenever a user cancels/aborts a load resource
      * request.
      */
     void loadAborted(const QUrl &url);
 
     void navigationRequested(WebEnginePage* page, const QUrl& url);
 
 protected:
     /**
      * Returns the webengine part in use by this object.
      * @internal
      */
     WebEnginePart* part() const;
 
     /**
      * Sets the webengine part to be used by this object.
      * @internal
      */
     void setPart(WebEnginePart*);
 
     /**
      * Reimplemented for internal reasons, the API is not affected.
      * @internal
      */
     QWebEnginePage* createWindow(WebWindowType type) Q_DECL_OVERRIDE;
 
     /**
      * Reimplemented for internal reasons, the API is not affected.
      * @internal
      */
     bool acceptNavigationRequest(const QUrl& request, NavigationType type, bool isMainFrame)  Q_DECL_OVERRIDE;
 
 protected Q_SLOTS:
     void slotLoadFinished(bool ok);
     void slotUnsupportedContent(QNetworkReply* reply);
     virtual void slotGeometryChangeRequested(const QRect& rect);
     void slotFeaturePermissionRequested(const QUrl& url, QWebEnginePage::Feature feature);
     void slotAuthenticationRequired(const QUrl &requestUrl, QAuthenticator *auth);
 
 private:
     bool checkLinkSecurity(const QNetworkRequest& req, NavigationType type) const;
     bool checkFormData(const QUrl& url) const;
     bool handleMailToUrl (const QUrl& , NavigationType type) const;
     void setPageJScriptPolicy(const QUrl& url);
 
 private:
     enum WebEnginePageSecurity { PageUnencrypted, PageEncrypted, PageMixed };
 
     int m_kioErrorCode;
     bool m_ignoreError;
 
     WebSslInfo m_sslInfo;
     QPointer<WebEnginePart> m_part;
 
     QScopedPointer<KPasswdServerClient> m_passwdServerClient;
     WebEngineWallet *m_wallet;
 };
 
 
 /**
  * This is a fake implementation of WebEnginePage to workaround the ugly API used
  * to request for the creation of a new window from javascript in QtWebEngine. PORTING_TODO
  *
  * The KPart API for creating new windows requires all the information about the
  * new window up front. Unfortunately QWebEnginePage::createWindow function does not
  * provide any of these necessary information except for the window type. All
  * the other necessary information is emitted as signals instead! Hence, the
  * need for this class to collect all of the necessary information, such as
  * window name, size and position, before calling KPart's createNewWindow
  * function.
  */
 class NewWindowPage : public WebEnginePage
 {
     Q_OBJECT
 public:
     NewWindowPage(WebWindowType windowType, WebEnginePart* part,
                   QWidget* parent = Q_NULLPTR);
     virtual ~NewWindowPage();
 
 protected:
     bool acceptNavigationRequest(const QUrl& request, NavigationType type, bool isMainFrame)  Q_DECL_OVERRIDE;
 
 private Q_SLOTS:
     void slotGeometryChangeRequested(const QRect& rect) override;
     void slotMenuBarVisibilityChangeRequested(bool visible);
     void slotStatusBarVisibilityChangeRequested(bool visible);
     void slotToolBarVisibilityChangeRequested(bool visible);
     void slotLoadFinished(bool);
 
 private:
     KParts::WindowArgs m_windowArgs;
     WebWindowType m_type;
     bool m_createNewWindow;
     WebEngineWallet* m_wallet; 
 };
 
 #endif // WEBENGINEPAGE_H
diff --git a/webenginepart/src/webenginepart.h b/webenginepart/src/webenginepart.h
index aa750dcd5..024312925 100644
--- a/webenginepart/src/webenginepart.h
+++ b/webenginepart/src/webenginepart.h
@@ -1,174 +1,174 @@
 /*
  * This file is part of the KDE project.
  *
  * Copyright (C) 2007 Trolltech ASA
  * Copyright (C) 2008 Urs Wolfer <uwolfer @ kde.org>
  * Copyright (C) 2009 Dawit Alemayehu <adawit@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.1 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, see <http://www.gnu.org/licenses/>.
  *
  */
 #ifndef WEBENGINEPART_H
 #define WEBENGINEPART_H
 
 #include "kwebenginepartlib_export.h"
 
-#include <QtWebEngineWidgets/QWebEnginePage>
+#include <QWebEnginePage>
 
 #include <KParts/ReadOnlyPart>
 #include <QUrl>
 
 namespace KParts {
   class BrowserExtension;
   class StatusBarExtension;
 }
 
 class QWebEngineView;
 class WebEngineView;
 class WebEnginePage;
 class SearchBar;
 class PasswordBar;
 class FeaturePermissionBar;
 class KUrlLabel;
 class WebEngineBrowserExtension;
 class WebEngineWallet;
 class WebEngineErrorSchemeHandler;
 
 /**
  * A KPart wrapper for the QtWebEngine's browser rendering engine.
  *
  * This class attempts to provide the same type of integration into KPart
  * plugin applications, such as Konqueror, in much the same way as KHTML.
  *
  * Unlink the KHTML part however, access into the internals of the rendering
  * engine are provided through existing QtWebEngine class ; @see QWebEngineView.
  *
  */
 class KWEBENGINEPARTLIB_EXPORT WebEnginePart : public KParts::ReadOnlyPart
 {
     Q_OBJECT
     Q_PROPERTY( bool modified READ isModified )
 public:
     explicit WebEnginePart(QWidget* parentWidget = 0, QObject* parent = Q_NULLPTR,
                          const QByteArray& cachedHistory = QByteArray(),
                          const QStringList& = QStringList());
     ~WebEnginePart();
 
     /**
      * Re-implemented for internal reasons. API remains unaffected.
      *
      * @see KParts::ReadOnlyPart::openUrl
      */
     bool openUrl(const QUrl &) Q_DECL_OVERRIDE;
 
     /**
      * Re-implemented for internal reasons. API remains unaffected.
      *
      * @see KParts::ReadOnlyPart::closeUrl
      */
     bool closeUrl() Q_DECL_OVERRIDE;
 
     /**
      * Returns a pointer to the render widget used to display a web page.
      *
      * @see QWebEngineView.
      */
     virtual QWebEngineView *view();
 
     /**
      * Checks whether the page contains unsubmitted form changes.
      *
      * @return @p true if form changes exist.
      */
     bool isModified() const;
 
     /**
      * Connects the appropriate signals from the given page to the slots
      * in this class.
      */
     void connectWebEnginePageSignals(WebEnginePage* page);
 
     void slotShowFeaturePermissionBar(QWebEnginePage::Feature);
 
     void setWallet(WebEngineWallet* wallet);
 
 protected:
     /**
      * Re-implemented for internal reasons. API remains unaffected.
      *
      * @see KParts::ReadOnlyPart::guiActivateEvent
      */
     void guiActivateEvent(KParts::GUIActivateEvent *) Q_DECL_OVERRIDE;
 
     /**
      * Re-implemented for internal reasons. API remains unaffected.
      *
      * @see KParts::ReadOnlyPart::openFile
      */
     bool openFile() Q_DECL_OVERRIDE;
 
 private Q_SLOTS:
     void slotShowSecurity();
     void slotShowSearchBar();
     void slotLoadStarted();
     void slotLoadAborted(const QUrl &);
     void slotLoadFinished(bool);
 
     void slotSearchForText(const QString &text, bool backward);
     void slotLinkHovered(const QString &);
     //void slotSaveFrameState(QWebFrame *frame, QWebHistoryItem *item);
     //void slotRestoreFrameState(QWebFrame *frame);
     void slotLinkMiddleOrCtrlClicked(const QUrl&);
     void slotSelectionClipboardUrlPasted(const QUrl&, const QString&);
 
     void slotUrlChanged(const QUrl &);
     void slotWalletClosed();
     void slotShowWalletMenu();
     void slotLaunchWalletManager();
     void slotDeleteNonPasswordStorableSite();
     void slotRemoveCachedPasswords();
     void slotSetTextEncoding(QTextCodec*);
     void slotSetStatusBarText(const QString& text);
     void slotWindowCloseRequested();
     void slotSaveFormDataRequested(const QString &, const QUrl &);
     void slotSaveFormDataDone();
     void slotFillFormRequestCompleted(bool);
 
     void slotFeaturePermissionGranted(QWebEnginePage::Feature);
     void slotFeaturePermissionDenied(QWebEnginePage::Feature);
 
 private:
     WebEnginePage* page();
     const WebEnginePage* page() const;
     
     void attemptInstallKIOSchemeHandler(const QUrl &url);
     
     void initActions();
     void updateActions();
     void addWalletStatusBarIcon();
 
     bool m_emitOpenUrlNotify;
     bool m_hasCachedFormData;
     bool m_doLoadFinishedActions;
     KUrlLabel* m_statusBarWalletLabel;
     SearchBar* m_searchBar;
     PasswordBar* m_passwordBar;
     FeaturePermissionBar* m_featurePermissionBar;
     WebEngineBrowserExtension* m_browserExtension;
     KParts::StatusBarExtension* m_statusBarExtension;
     WebEngineView* m_webView;
     WebEngineWallet* m_wallet;
 };
 
 #endif // WEBENGINEPART_H
diff --git a/webenginepart/src/webenginepart_ext.cpp b/webenginepart/src/webenginepart_ext.cpp
index 44bd3f9ea..b3c63b10a 100644
--- a/webenginepart/src/webenginepart_ext.cpp
+++ b/webenginepart/src/webenginepart_ext.cpp
@@ -1,1226 +1,1226 @@
 /*
  * This file is part of the KDE project.
  *
  * Copyright (C) 2009 Dawit Alemayehu <adawit@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.1 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, see <http://www.gnu.org/licenses/>.
  *
  */
 
-#include <QtWebEngine/QtWebEngineVersion>
 #include "webenginepart_ext.h"
+#include <QtWebEngine/QtWebEngineVersion>
 
 #include "webenginepart.h"
 #include "webengineview.h"
 #include "webenginepage.h"
 #include "settings/webenginesettings.h"
-#include <QtWebEngineWidgets/QWebEngineSettings>
+#include <QWebEngineSettings>
 
 #include <KDesktopFile>
 #include <KConfigGroup>
 #include <KToolInvocation>
 #include <KSharedConfig>
 #include <KRun>
 #include <KProtocolInfo>
 #include <QInputDialog>
 #include <KLocalizedString>
 #include <QTemporaryFile>
 #include <KUriFilter>
 #include <Sonnet/Dialog>
 #include <sonnet/backgroundchecker.h>
 
 #include <QBuffer>
 #include <QVariant>
 #include <QClipboard>
 #include <QApplication>
 #include <QAction>
 #include <QPrinter>
 #include <QPrintDialog>
 #include <QPrintPreviewDialog>
 #include <QWebEngineHistory>
 #include <QMimeData>
 #define QL1S(x)     QLatin1String(x)
 #define QL1C(x)     QLatin1Char(x)
 
 // A functor that calls a member function
 template<typename Arg, typename R, typename C>
 struct InvokeWrapper {
     R *receiver;
     void (C::*memberFun)(Arg);
     void operator()(Arg result)
     {
         (receiver->*memberFun)(result);
     }
 };
 
 template<typename Arg, typename R, typename C>
 InvokeWrapper<Arg, R, C> invoke(R *receiver, void (C::*memberFun)(Arg))
 {
     return InvokeWrapper<Arg, R, C>{receiver, memberFun};
 }
 
 WebEngineBrowserExtension::WebEngineBrowserExtension(WebEnginePart *parent, const QByteArray& cachedHistoryData)
                        :KParts::BrowserExtension(parent),
                         m_part(parent),
                         mCurrentPrinter(Q_NULLPTR)
 {
     enableAction("cut", false);
     enableAction("copy", false);
     enableAction("paste", false);
     enableAction("print", true);
 
     if (cachedHistoryData.isEmpty()) {
         return;
     }
 
     QBuffer buffer;
     buffer.setData(cachedHistoryData);
     if (!buffer.open(QIODevice::ReadOnly)) {
         return;
     }
 
     // NOTE: When restoring history, webengine PORTING_TODO automatically navigates to
     // the previous "currentItem". Since we do not want that to happen,
     // we set a property on the WebEnginePage object that is used to allow or
     // disallow history navigation in WebEnginePage::acceptNavigationRequest.
     view()->page()->setProperty("HistoryNavigationLocked", true);
     QDataStream s (&buffer);
     s >> *(view()->history());
 }
 
 WebEngineBrowserExtension::~WebEngineBrowserExtension()
 {
 }
 
 WebEngineView* WebEngineBrowserExtension::view()
 {
     if (!m_view && m_part) {
         m_view = qobject_cast<WebEngineView*>(m_part->view());
     }
 
     return m_view;
 }
 
 int WebEngineBrowserExtension::xOffset()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (view())
         return view()->page()->scrollPosition().x();
 #endif
 
     return KParts::BrowserExtension::xOffset();
 }
 
 int WebEngineBrowserExtension::yOffset()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
    if (view())
         return view()->page()->scrollPosition().y();
 #endif
 
     return KParts::BrowserExtension::yOffset();
 }
 
 void WebEngineBrowserExtension::saveState(QDataStream &stream)
 {
     // TODO: Save information such as form data from the current page.
     QWebEngineHistory* history = (view() ? view()->history() : 0);
     const int historyIndex = (history ? history->currentItemIndex() : -1);
     const QUrl historyUrl = (history && historyIndex > -1) ? QUrl(history->currentItem().url()) : m_part->url();
 
     stream << historyUrl
            << static_cast<qint32>(xOffset())
            << static_cast<qint32>(yOffset())
            << historyIndex
            << m_historyData;
 }
 
 void WebEngineBrowserExtension::restoreState(QDataStream &stream)
 {
     QUrl u;
     QByteArray historyData;
     qint32 xOfs = -1, yOfs = -1, historyItemIndex = -1;
     stream >> u >> xOfs >> yOfs >> historyItemIndex >> historyData;
 
     QWebEngineHistory* history = (view() ? view()->page()->history() : 0);
     if (history) {
         bool success = false;
         if (history->count() == 0) {   // Handle restoration: crash recovery, tab close undo, session restore
             if (!historyData.isEmpty()) {
                 historyData = qUncompress(historyData); // uncompress the history data...
                 QBuffer buffer (&historyData);
                 if (buffer.open(QIODevice::ReadOnly)) {
                     QDataStream stream (&buffer);
                     view()->page()->setProperty("HistoryNavigationLocked", true);
                     stream >> *history;
                     QWebEngineHistoryItem currentItem(history->currentItem());
                     if (currentItem.isValid()) {
                         if (currentItem.isValid() && (xOfs != -1 || yOfs != -1)) {
                             const QPoint scrollPos (xOfs, yOfs);
 //                            currentItem.setUserData(scrollPos);
                         }
                         // NOTE 1: The following Konqueror specific workaround is necessary
                         // because Konqueror only preserves information for the last visited
                         // page. However, we save the entire history content in saveState and
                         // and hence need to eliminate all but the current item here.
                         // NOTE 2: This condition only applies when Konqueror is restored from
                         // abnormal termination ; a crash and/or a session restoration.
                         if (QCoreApplication::applicationName() == QLatin1String("konqueror")) {
                             history->clear();
                         }
                         //kDebug() << "Restoring URL:" << currentItem.url();
                         m_part->setProperty("NoEmitOpenUrlNotification", true);
                         history->goToItem(currentItem);
                     }
                 }
             }
             success = (history->count() > 0);
         } else {        // Handle navigation: back and forward button navigation.
             //kDebug() << "history count:" << history->count() << "request index:" << historyItemIndex;
             if (history->count() > historyItemIndex && historyItemIndex > -1) {
                 QWebEngineHistoryItem item (history->itemAt(historyItemIndex));
                 //kDebug() << "URL:" << u << "Item URL:" << item.url();
                 if (u == item.url()) {
                     if (item.isValid() && (xOfs != -1 || yOfs != -1)) {
                         const QPoint scrollPos (xOfs, yOfs);
 //                        item.setUserData(scrollPos);
                     }
                     m_part->setProperty("NoEmitOpenUrlNotification", true);
                     history->goToItem(item);
                     success = true;
                 }
             }
         }
 
         if (success) {
             return;
         }
     }
 
     // As a last resort, in case the history restoration logic above fails,
     // attempt to open the requested URL directly.
     qDebug() << "Normal history navigation logic failed! Falling back to opening url directly.";
     m_part->openUrl(u);
 }
 
 
 void WebEngineBrowserExtension::cut()
 {
     if (view())
         view()->triggerPageAction(QWebEnginePage::Cut);
 }
 
 void WebEngineBrowserExtension::copy()
 {
     if (view())
         view()->triggerPageAction(QWebEnginePage::Copy);
 }
 
 void WebEngineBrowserExtension::paste()
 {
     if (view())
         view()->triggerPageAction(QWebEnginePage::Paste);
 }
 
 void WebEngineBrowserExtension::slotSaveDocument()
 {
     if (view())
         emit saveUrl(view()->url());
 }
 
 void WebEngineBrowserExtension::slotSaveFrame()
 {
     if (view())
         emit saveUrl(view()->page()->url()); // TODO lol
 }
 
 void WebEngineBrowserExtension::print()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 8, 0)
     if (view()) {
         mCurrentPrinter = new QPrinter();
         QPointer<QPrintDialog> dialog = new QPrintDialog(mCurrentPrinter, Q_NULLPTR);
         dialog->setWindowTitle(i18n("Print Document"));
         if (dialog->exec() != QDialog::Accepted) {
             slotHandlePagePrinted(false);
             delete dialog;
             return;
         }
         delete dialog;
         view()->page()->print(mCurrentPrinter, invoke(this, &WebEngineBrowserExtension::slotHandlePagePrinted));
     }
 #endif
 }
 
 void WebEngineBrowserExtension::slotHandlePagePrinted(bool result)
 {
     Q_UNUSED(result);
     delete mCurrentPrinter;
     mCurrentPrinter = Q_NULLPTR;
 }
 
 
 void WebEngineBrowserExtension::updateEditActions()
 {
     if (!view())
         return;
 
     enableAction("cut", view()->pageAction(QWebEnginePage::Cut)->isEnabled());
     enableAction("copy", view()->pageAction(QWebEnginePage::Copy)->isEnabled());
     enableAction("paste", view()->pageAction(QWebEnginePage::Paste)->isEnabled());
 }
 
 void WebEngineBrowserExtension::updateActions()
 {
     const QString protocol (m_part->url().scheme());
     const bool isValidDocument = (protocol != QL1S("about") && protocol != QL1S("error"));
     enableAction("print", isValidDocument);
 }
 
 void WebEngineBrowserExtension::searchProvider()
 {
     if (!view())
         return;
 
     QAction *action = qobject_cast<QAction*>(sender());
     if (!action)
         return;
 
     QUrl url = action->data().toUrl();
 
     if (url.host().isEmpty()) {
         KUriFilterData data;
         data.setData(action->data().toString());
         if (KUriFilter::self()->filterSearchUri(data, KUriFilter::WebShortcutFilter))
             url = data.uri();
     }
 
     if (!url.isValid())
       return;
 
     KParts::BrowserArguments bargs;
     bargs.frameName = QL1S("_blank");
     emit openUrlRequest(url, KParts::OpenUrlArguments(), bargs);
 }
 
 void WebEngineBrowserExtension::reparseConfiguration()
 {
     // Force the configuration stuff to reparse...
     WebEngineSettings::self()->init();
 }
 
 void WebEngineBrowserExtension::disableScrolling()
 {
     QWebEngineView* currentView = view();
     QWebEnginePage* page = currentView ? currentView->page() : 0;
 
     if (!page)
         return;
 
     page->runJavaScript(QStringLiteral("document.documentElement.style.overflow = 'hidden';"));
 }
 
 void WebEngineBrowserExtension::zoomIn()
 {
     if (view())
         view()->setZoomFactor(view()->zoomFactor() + 0.1);
 }
 
 void WebEngineBrowserExtension::zoomOut()
 {
     if (view())
         view()->setZoomFactor(view()->zoomFactor() - 0.1);
 }
 
 void WebEngineBrowserExtension::zoomNormal()
 {
     if (view()) {
         if (WebEngineSettings::self()->zoomToDPI())
             view()->setZoomFactor(view()->logicalDpiY() / 96.0f);
         else
             view()->setZoomFactor(1);
     }
 }
 
 void WebEngineBrowserExtension::toogleZoomTextOnly()
 {
     if (!view())
         return;
 
     KConfigGroup cgHtml(KSharedConfig::openConfig(), "HTML Settings");
     bool zoomTextOnly = cgHtml.readEntry( "ZoomTextOnly", false );
     cgHtml.writeEntry("ZoomTextOnly", !zoomTextOnly);
     cgHtml.sync();
 
     // view()->settings()->setAttribute(QWebEngineSettings::ZoomTextOnly, !zoomTextOnly);
 }
 
 void WebEngineBrowserExtension::toogleZoomToDPI()
 {
     if (!view())
         return;
 
     bool zoomToDPI = !WebEngineSettings::self()->zoomToDPI();
     WebEngineSettings::self()->setZoomToDPI(zoomToDPI);
     
     if (zoomToDPI)
         view()->setZoomFactor(view()->zoomFactor() * view()->logicalDpiY() / 96.0f);
     else 
         view()->setZoomFactor(view()->zoomFactor() * 96.0f / view()->logicalDpiY());
     
     // Recompute default font-sizes since they are only DPI dependent when zoomToDPI is false.
     WebEngineSettings::self()->computeFontSizes(view()->logicalDpiY());
 }
 
 void WebEngineBrowserExtension::slotSelectAll()
 {
     if (view())
         view()->triggerPageAction(QWebEnginePage::SelectAll);
 }
 
 void WebEngineBrowserExtension::slotSaveImageAs()
 {
     if (view())
         view()->triggerPageAction(QWebEnginePage::DownloadImageToDisk);
 }
 
 void WebEngineBrowserExtension::slotSendImage()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     QStringList urls;
     urls.append(view()->contextMenuResult().mediaUrl().path());
     const QString subject = view()->contextMenuResult().mediaUrl().path();
     KToolInvocation::invokeMailer(QString(), QString(), QString(), subject,
                                   QString(), //body
                                   QString(),
                                   urls); // attachments
 #endif
 }
 
 void WebEngineBrowserExtension::slotCopyImageURL()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     QUrl safeURL = view()->contextMenuResult().mediaUrl();
     safeURL.setPassword(QString());
     // Set it in both the mouse selection and in the clipboard
     QMimeData* mimeData = new QMimeData;
 //TODO: Porting: test
     QList<QUrl> safeURLList;
     safeURLList.append(safeURL);
     mimeData->setUrls(safeURLList);
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
 
     mimeData = new QMimeData;
     mimeData->setUrls(safeURLList);
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Selection);
 #endif
 }
 
 
 void WebEngineBrowserExtension::slotCopyImage()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     QUrl safeURL; //(view()->contextMenuResult().imageUrl());
     safeURL.setPassword(QString());
 
     // Set it in both the mouse selection and in the clipboard
     QMimeData* mimeData = new QMimeData;
 //    mimeData->setImageData(view()->contextMenuResult().pixmap());
 //TODO: Porting: test
     QList<QUrl> safeURLList;
     safeURLList.append(safeURL);
     mimeData->setUrls(safeURLList);
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
 
     mimeData = new QMimeData;
 //    mimeData->setImageData(view()->contextMenuResult().pixmap());
     mimeData->setUrls(safeURLList);
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Selection);
 #endif
 }
 
 void WebEngineBrowserExtension::slotViewImage()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (view())
         emit createNewWindow(view()->contextMenuResult().mediaUrl());
 #endif
 }
 
 void WebEngineBrowserExtension::slotBlockImage()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     bool ok = false;
     const QString url = QInputDialog::getText(view(), i18n("Add URL to Filter"),
                                               i18n("Enter the URL:"), QLineEdit::Normal,
                                               view()->contextMenuResult().mediaUrl().toString(),
                                               &ok);
     if (ok) {
         WebEngineSettings::self()->addAdFilter(url);
         reparseConfiguration();
     }
 #endif
 }
 
 void WebEngineBrowserExtension::slotBlockHost()
 {
     if (!view())
         return;
 
     QUrl url; // (view()->contextMenuResult().imageUrl());
     url.setPath(QL1S("/*"));
     WebEngineSettings::self()->addAdFilter(url.toString(QUrl::RemoveUserInfo | QUrl::RemovePort));
     reparseConfiguration();
 }
 
 void WebEngineBrowserExtension::slotCopyLinkURL()
 {
     if (view())
         view()->triggerPageAction(QWebEnginePage::CopyLinkToClipboard);
 }
 
 void WebEngineBrowserExtension::slotCopyLinkText()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (view()) {
         QMimeData* data = new QMimeData;
         data->setText(view()->contextMenuResult().linkText());
         QApplication::clipboard()->setMimeData(data, QClipboard::Clipboard);
     }
 #endif
 }
 
 void WebEngineBrowserExtension::slotCopyEmailAddress()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (view()) {
         QMimeData* data = new QMimeData;
         const QUrl url(view()->contextMenuResult().linkUrl());
         data->setText(url.path());
         QApplication::clipboard()->setMimeData(data, QClipboard::Clipboard);
     }
 #endif
 }
 
 void WebEngineBrowserExtension::slotSaveLinkAs()
 {
     if (view())
         view()->triggerPageAction(QWebEnginePage::DownloadLinkToDisk);
 }
 
 void WebEngineBrowserExtension::slotViewDocumentSource()
 {
     if (!view())
         return;
 
     const QUrl pageUrl (view()->url());
     if (pageUrl.isLocalFile()) {
         KRun::runUrl(pageUrl, QL1S("text/plain"), view(), false);
     } else {
         view()->page()->toHtml([this](const QString& html) {
             QTemporaryFile tempFile;
             tempFile.setFileTemplate(tempFile.fileTemplate() + QL1S(".html"));
             tempFile.setAutoRemove(false);
             if (tempFile.open()) {
                 tempFile.write(html.toUtf8());
                 KRun::runUrl(QUrl::fromLocalFile(tempFile.fileName()), QL1S("text/plain"), view(), true, false);
             }
         });
     }
 }
 
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
 static bool isMultimediaElement(QWebEngineContextMenuData::MediaType mediaType)
 {
     switch(mediaType)
     {
         case QWebEngineContextMenuData::MediaTypeVideo:
         case QWebEngineContextMenuData::MediaTypeAudio:
             return true;
         default:
             return false;
     }
 }
 #endif
 
 void WebEngineBrowserExtension::slotLoopMedia()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     QWebEngineContextMenuData data =  view()->contextMenuResult();
     if (!isMultimediaElement( data.mediaType()))
         return;
     view()->page()->triggerAction(QWebEnginePage::ToggleMediaLoop);
 #endif
 }
 
 void WebEngineBrowserExtension::slotMuteMedia()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     QWebEngineContextMenuData data =  view()->contextMenuResult();
     if (!isMultimediaElement( data.mediaType()))
         return;
     view()->page()->triggerAction(QWebEnginePage::ToggleMediaMute);
 #endif
 }
 
 void WebEngineBrowserExtension::slotPlayMedia()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     QWebEngineContextMenuData data =  view()->contextMenuResult();
     if (!isMultimediaElement( data.mediaType()))
         return;
     view()->page()->triggerAction(QWebEnginePage::ToggleMediaPlayPause);
 #endif
 }
 
 void WebEngineBrowserExtension::slotShowMediaControls()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     QWebEngineContextMenuData data =  view()->contextMenuResult();
     if (!isMultimediaElement( data.mediaType()))
         return;
     view()->page()->triggerAction(QWebEnginePage::ToggleMediaControls);
 #endif
 }
 
 #if 0
 static QUrl mediaUrlFrom(QWebElement& element)
 {
     QWebFrame* frame = element.webFrame();
     QString src = frame ? element.attribute(QL1S("src")) : QString();
     if (src.isEmpty())
         src = frame ? element.evaluateJavaScript(QL1S("this.src")).toString() : QString();
 
     if (src.isEmpty())
         return QUrl();
 
     return QUrl(frame->baseUrl().resolved(QUrl::fromEncoded(QUrl::toPercentEncoding(src), QUrl::StrictMode)));
 }
 #endif
 
 void WebEngineBrowserExtension::slotSaveMedia()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     QWebEngineContextMenuData data =  view()->contextMenuResult();
     if (!isMultimediaElement( data.mediaType()))
         return;
     emit saveUrl(data.mediaUrl());
 #endif
 }
 
 void WebEngineBrowserExtension::slotCopyMedia()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
     QWebEngineContextMenuData data =  view()->contextMenuResult();
     if (!isMultimediaElement( data.mediaType()))
         return;
 
     QUrl safeURL(data.mediaUrl());
     if (!safeURL.isValid())
         return;
 
     safeURL.setPassword(QString());
     // Set it in both the mouse selection and in the clipboard
     QMimeData* mimeData = new QMimeData;
 //TODO: Porting: test
     QList<QUrl> safeURLList;
     safeURLList.append(safeURL);
     mimeData->setUrls(safeURLList);
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Clipboard);
 
     mimeData = new QMimeData;
     mimeData->setUrls(safeURLList);
     QApplication::clipboard()->setMimeData(mimeData, QClipboard::Selection);
 #endif
 }
 
 void WebEngineBrowserExtension::slotTextDirectionChanged()
 {
     QAction* action = qobject_cast<QAction*>(sender());
     if (action) {
         bool ok = false;
         const int value = action->data().toInt(&ok);
         if (ok) {
             view()->triggerPageAction(static_cast<QWebEnginePage::WebAction>(value));
         }
     }
 }
 
 void WebEngineBrowserExtension::slotCheckSpelling()
 {
     view()->page()->runJavaScript(QL1S("this.value"), [this](const QVariant &value) {
         const QString text = value.toString();
         if (!text.isEmpty()) {
             m_spellTextSelectionStart = 0;
             m_spellTextSelectionEnd = 0;
 
             Sonnet::BackgroundChecker *backgroundSpellCheck = new Sonnet::BackgroundChecker;
             Sonnet::Dialog* spellDialog = new Sonnet::Dialog(backgroundSpellCheck, view());
             backgroundSpellCheck->setParent(spellDialog);
             spellDialog->setAttribute(Qt::WA_DeleteOnClose, true);
             spellDialog->showSpellCheckCompletionMessage(true);
             connect(spellDialog, SIGNAL(replace(QString,int,QString)), this, SLOT(spellCheckerCorrected(QString,int,QString)));
             connect(spellDialog, SIGNAL(misspelling(QString,int)), this, SLOT(spellCheckerMisspelling(QString,int)));
             spellDialog->setBuffer(text);
             spellDialog->show();
         }
     });
 }
 
 void WebEngineBrowserExtension::slotSpellCheckSelection()
 {
     view()->page()->runJavaScript(QL1S("this.value"), [this](const QVariant &value) {
         const QString text = value.toString();
         if (!text.isEmpty()) {
             view()->page()->runJavaScript(QL1S("this.selectionStart + ' ' + this.selectionEnd"), [this, text](const QVariant &value) {
                 const QString values = value.toString();
                 const int pos = values.indexOf(' ');
                 m_spellTextSelectionStart = qMax(0, values.leftRef(pos).toInt());
                 m_spellTextSelectionEnd = qMax(0, values.midRef(pos + 1).toInt());
                 // kDebug() << "selection start:" << m_spellTextSelectionStart << "end:" << m_spellTextSelectionEnd;
 
                 Sonnet::BackgroundChecker *backgroundSpellCheck = new Sonnet::BackgroundChecker;
                 Sonnet::Dialog* spellDialog = new Sonnet::Dialog(backgroundSpellCheck, view());
                 backgroundSpellCheck->setParent(spellDialog);
                 spellDialog->setAttribute(Qt::WA_DeleteOnClose, true);
                 spellDialog->showSpellCheckCompletionMessage(true);
                 connect(spellDialog, SIGNAL(replace(QString,int,QString)), this, SLOT(spellCheckerCorrected(QString,int,QString)));
                 connect(spellDialog, SIGNAL(misspelling(QString,int)), this, SLOT(spellCheckerMisspelling(QString,int)));
                 connect(spellDialog, SIGNAL(done(QString)), this, SLOT(slotSpellCheckDone(QString)));
                 spellDialog->setBuffer(text.mid(m_spellTextSelectionStart, (m_spellTextSelectionEnd - m_spellTextSelectionStart)));
                 spellDialog->show();
             });
         }
     });
 }
 
 void WebEngineBrowserExtension::spellCheckerCorrected(const QString& original, int pos, const QString& replacement)
 {
     // Adjust the selection end...
     if (m_spellTextSelectionEnd > 0) {
         m_spellTextSelectionEnd += qMax (0, (replacement.length() - original.length()));
     }
 
     const int index = pos + m_spellTextSelectionStart;
     QString script(QL1S("this.value=this.value.substring(0,"));
     script += QString::number(index);
     script += QL1S(") + \"");
     script +=  replacement;
     script += QL1S("\" + this.value.substring(");
     script += QString::number(index + original.length());
     script += QL1S(")");
 
     //kDebug() << "**** script:" << script;
     view()->page()->runJavaScript(script);
 }
 
 void WebEngineBrowserExtension::spellCheckerMisspelling(const QString& text, int pos)
 {
     // kDebug() << text << pos;
     QString selectionScript (QL1S("this.setSelectionRange("));
     selectionScript += QString::number(pos + m_spellTextSelectionStart);
     selectionScript += QL1C(',');
     selectionScript += QString::number(pos + text.length() + m_spellTextSelectionStart);
     selectionScript += QL1C(')');
     view()->page()->runJavaScript(selectionScript);
 }
 
 void WebEngineBrowserExtension::slotSpellCheckDone(const QString&)
 {
     // Restore the text selection if one was present before we started the
     // spell check.
     if (m_spellTextSelectionStart > 0 || m_spellTextSelectionEnd > 0) {
         QString script (QL1S("; this.setSelectionRange("));
         script += QString::number(m_spellTextSelectionStart);
         script += QL1C(',');
         script += QString::number(m_spellTextSelectionEnd);
         script += QL1C(')');
         view()->page()->runJavaScript(script);
     }
 }
 
 void WebEngineBrowserExtension::saveHistory()
 {
     QWebEngineHistory* history = (view() ? view()->history() : 0);
 
     if (history && history->count() > 0) {
         //kDebug() << "Current history: index=" << history->currentItemIndex() << "url=" << history->currentItem().url();
         QByteArray histData;
         QBuffer buff (&histData);
         m_historyData.clear();
         if (buff.open(QIODevice::WriteOnly)) {
             QDataStream stream (&buff);
             stream << *history;
             m_historyData = qCompress(histData, 9);
         }
         QWidget* mainWidget = m_part ? m_part->widget() : 0;
         QWidget* frameWidget = mainWidget ? mainWidget->parentWidget() : 0;
         if (frameWidget) {
             emit saveHistory(frameWidget, m_historyData);
             // kDebug() << "# of items:" << history->count() << "current item:" << history->currentItemIndex() << "url:" << history->currentItem().url();
         }
     } else {
         Q_ASSERT(false); // should never happen!!!
     }
 }
 
 void WebEngineBrowserExtension::slotPrintPreview()
 {
 #if 0
     // Make it non-modal, in case a redirection deletes the part
     QPointer<QPrintPreviewDialog> dlg (new QPrintPreviewDialog(view()));
     connect(dlg.data(), SIGNAL(paintRequested(QPrinter*)),
             view()->page()->currentFrame(), SLOT(print(QPrinter*)));
     dlg->exec();
     delete dlg;
 #endif
 }
 
 void WebEngineBrowserExtension::slotOpenSelection()
 {
     QAction *action = qobject_cast<QAction*>(sender());
     if (action) {
         KParts::BrowserArguments browserArgs;
         browserArgs.frameName = QStringLiteral("_blank");
         emit openUrlRequest(QUrl(action->data().toUrl()), KParts::OpenUrlArguments(), browserArgs);
     }
 }
 
 void WebEngineBrowserExtension::slotLinkInTop()
 {
 #if QTWEBENGINE_VERSION >= QT_VERSION_CHECK(5, 7, 0)
     if (!view())
         return;
 
     KParts::OpenUrlArguments uargs;
     uargs.setActionRequestedByUser(true);
 
     KParts::BrowserArguments bargs;
     bargs.frameName = QL1S("_top");
 
     const QUrl url(view()->contextMenuResult().linkUrl());
 
     emit openUrlRequest(url, uargs, bargs);
 #endif
 }
 
 ////
 
 WebEngineTextExtension::WebEngineTextExtension(WebEnginePart* part)
     : KParts::TextExtension(part)
 {
     connect(part->view(), SIGNAL(selectionChanged()), this, SIGNAL(selectionChanged()));
 }
 
 WebEnginePart* WebEngineTextExtension::part() const
 {
     return static_cast<WebEnginePart*>(parent());
 }
 
 bool WebEngineTextExtension::hasSelection() const
 {
     return part()->view()->hasSelection();
 }
 
 QString WebEngineTextExtension::selectedText(Format format) const
 {
     switch(format) {
     case PlainText:
         return part()->view()->selectedText();
     case HTML:
         // PORTING_TODO selectedText might not be html
         return part()->view()->selectedText();
     }
     return QString();
 }
 
 QString WebEngineTextExtension::completeText(Format format) const
 {
     // TODO David will hunt me down with a rusty spork if he sees this
     QEventLoop ev;
     QString str;
     switch(format) {
     case PlainText:
         part()->view()->page()->toPlainText([&ev,&str](const QString& data) {
             str = data;
             ev.quit();
         });
     case HTML:
         part()->view()->page()->toHtml([&ev,&str](const QString& data) {
             str = data;
             ev.quit();
         });
     }
     ev.exec();
     return QString();
 }
 
 ////
 
 WebEngineHtmlExtension::WebEngineHtmlExtension(WebEnginePart* part)
     : KParts::HtmlExtension(part)
 {
 }
 
 
 QUrl WebEngineHtmlExtension::baseUrl() const
 {
     return part()->view()->page()->url();
 }
 
 bool WebEngineHtmlExtension::hasSelection() const
 {
     return part()->view()->hasSelection();
 }
 
 KParts::SelectorInterface::QueryMethods WebEngineHtmlExtension::supportedQueryMethods() const
 {
     return (KParts::SelectorInterface::EntireContent
             | KParts::SelectorInterface::SelectedContent);
 }
 
 #if 0
 static KParts::SelectorInterface::Element convertWebElement(const QWebElement& webElem)
 {
     KParts::SelectorInterface::Element element;
     element.setTagName(webElem.tagName());
     Q_FOREACH(const QString &attr, webElem.attributeNames()) {
         element.setAttribute(attr, webElem.attribute(attr));
     }
     return element;
 }
 #endif
 
 static QString queryOne(const QString& query)
 {
    QString jsQuery = QL1S("(function(query) { var element; var selectedElement = window.getSelection().getRangeAt(0).cloneContents().querySelector(\"");
    jsQuery += query;
    jsQuery += QL1S("\"); if (selectedElement && selectedElement.length > 0) { element = new Object; "
                    "element.tagName = String(selectedElements[0].tagName); element.href = String(selectedElements[0].href); } "
                    "return element; }())");
    return jsQuery;
 }
 
 static QString queryAll(const QString& query)
 {
    QString jsQuery = QL1S("(function(query) { var elements = []; var selectedElements = window.getSelection().getRangeAt(0).cloneContents().querySelectorAll(\"");
    jsQuery += query;
    jsQuery += QL1S("\"); var numSelectedElements = (selectedElements ? selectedElements.length : 0);"
                    "for (var i = 0; i < numSelectedElements; ++i) { var element = new Object; "
                    "element.tagName = String(selectedElements[i].tagName); element.href = String(selectedElements[i].href);"
                    "elements.push(element); } return elements; } ())");
    return jsQuery;
 }
 
 static KParts::SelectorInterface::Element convertSelectionElement(const QVariant& variant)
 {
     KParts::SelectorInterface::Element element;
     if (!variant.isNull() && variant.type() == QVariant::Map) {
         const QVariantMap elementMap (variant.toMap());
         element.setTagName(elementMap.value(QL1S("tagName")).toString());
         element.setAttribute(QL1S("href"), elementMap.value(QL1S("href")).toString());
     }
     return element;
 }
 
 static QList<KParts::SelectorInterface::Element> convertSelectionElements(const QVariant& variant)
 {
     QList<KParts::SelectorInterface::Element> elements;
     const QVariantList resultList (variant.toList());
     Q_FOREACH(const QVariant& result, resultList) {
         const QVariantMap elementMap = result.toMap();
         KParts::SelectorInterface::Element element;
         element.setTagName(elementMap.value(QL1S("tagName")).toString());
         element.setAttribute(QL1S("href"), elementMap.value(QL1S("href")).toString());
         elements.append(element);
     }
     return elements;
 }
 
 KParts::SelectorInterface::Element WebEngineHtmlExtension::querySelector(const QString& query, KParts::SelectorInterface::QueryMethod method) const
 {
     KParts::SelectorInterface::Element element;
 
     // If the specified method is None, return an empty list...
     if (method == KParts::SelectorInterface::None)
         return element;
 
     // If the specified method is not supported, return an empty list...
     if (!(supportedQueryMethods() & method))
         return element;
 
 #if 0
     switch (method) {
     case KParts::SelectorInterface::EntireContent: {
         const QWebFrame* webFrame = part()->view()->page()->mainFrame();
         element = convertWebElement(webFrame->findFirstElement(query));
         break;
     }
     case KParts::SelectorInterface::SelectedContent: {
         QWebFrame* webFrame = part()->view()->page()->mainFrame();
         element = convertSelectionElement(webFrame->evaluateJavaScript(queryOne(query)));
         break;
     }
     default:
         break;
     }
 #endif
 
     return element;
 }
 
 QList<KParts::SelectorInterface::Element> WebEngineHtmlExtension::querySelectorAll(const QString& query, KParts::SelectorInterface::QueryMethod method) const
 {
     QList<KParts::SelectorInterface::Element> elements;
 
     // If the specified method is None, return an empty list...
     if (method == KParts::SelectorInterface::None)
         return elements;
 
     // If the specified method is not supported, return an empty list...
     if (!(supportedQueryMethods() & method))
         return elements;
 #if 0
     switch (method) {
     case KParts::SelectorInterface::EntireContent: {
         const QWebFrame* webFrame = part()->view()->page()->mainFrame();
         const QWebElementCollection collection = webFrame->findAllElements(query);
         elements.reserve(collection.count());
         Q_FOREACH(const QWebElement& element, collection)
             elements.append(convertWebElement(element));
         break;
     }
     case KParts::SelectorInterface::SelectedContent: {
         QWebFrame* webFrame = part()->view()->page()->mainFrame();
         elements = convertSelectionElements(webFrame->evaluateJavaScript(queryAll(query)));
         break;
     }
     default:
         break;
     }
 #endif
     return elements;
 }
 
 QVariant WebEngineHtmlExtension::htmlSettingsProperty(KParts::HtmlSettingsInterface::HtmlSettingsType type) const
 {
     QWebEngineView* view = part() ? part()->view() : 0;
     QWebEnginePage* page = view ? view->page() : 0;
     QWebEngineSettings* settings = page ? page->settings() : 0;
 
     if (settings) {
         switch (type) {
         case KParts::HtmlSettingsInterface::AutoLoadImages:
             return settings->testAttribute(QWebEngineSettings::AutoLoadImages);
         case KParts::HtmlSettingsInterface::JavaEnabled:
             return false; // settings->testAttribute(QWebEngineSettings::JavaEnabled);
         case KParts::HtmlSettingsInterface::JavascriptEnabled:
             return settings->testAttribute(QWebEngineSettings::JavascriptEnabled);
         case KParts::HtmlSettingsInterface::PluginsEnabled:
             return settings->testAttribute(QWebEngineSettings::PluginsEnabled);
         case KParts::HtmlSettingsInterface::DnsPrefetchEnabled:
             return false; //settings->testAttribute(QWebEngineSettings::DnsPrefetchEnabled);
         case KParts::HtmlSettingsInterface::MetaRefreshEnabled:
             return view->pageAction(QWebEnginePage::Stop)->isEnabled();
         case KParts::HtmlSettingsInterface::LocalStorageEnabled:
             return settings->testAttribute(QWebEngineSettings::LocalStorageEnabled);
         case KParts::HtmlSettingsInterface::OfflineStorageDatabaseEnabled:
             return false; //settings->testAttribute(QWebEngineSettings::OfflineStorageDatabaseEnabled);
         case KParts::HtmlSettingsInterface::OfflineWebApplicationCacheEnabled:
             return false ;//settings->testAttribute(QWebEngineSettings::OfflineWebApplicationCacheEnabled);
         case KParts::HtmlSettingsInterface::PrivateBrowsingEnabled:
             return false; //settings->testAttribute(QWebEngineSettings::PrivateBrowsingEnabled);
         case KParts::HtmlSettingsInterface::UserDefinedStyleSheetURL:
             return false; //settings->userStyleSheetUrl();
         default:
             break;
         }
     }
 
     return QVariant();
 }
 
 bool WebEngineHtmlExtension::setHtmlSettingsProperty(KParts::HtmlSettingsInterface::HtmlSettingsType type, const QVariant& value)
 {
     QWebEngineView* view = part() ? part()->view() : 0;
     QWebEnginePage* page = view ? view->page() : 0;
     QWebEngineSettings* settings = page ? page->settings() : 0;
 
     if (settings) {
         switch (type) {
         case KParts::HtmlSettingsInterface::AutoLoadImages:
             settings->setAttribute(QWebEngineSettings::AutoLoadImages, value.toBool());
             return true;
         case KParts::HtmlSettingsInterface::JavaEnabled:
             //settings->setAttribute(QWebESettings::JavaEnabled, value.toBool());
             return false;
         case KParts::HtmlSettingsInterface::JavascriptEnabled:
             settings->setAttribute(QWebEngineSettings::JavascriptEnabled, value.toBool());
             return true;
         case KParts::HtmlSettingsInterface::PluginsEnabled:
             settings->setAttribute(QWebEngineSettings::PluginsEnabled, value.toBool());
             return true;
         case KParts::HtmlSettingsInterface::DnsPrefetchEnabled:
 //            settings->setAttribute(QWebEngineSettings::DnsPrefetchEnabled, value.toBool());
             return false;
         case KParts::HtmlSettingsInterface::MetaRefreshEnabled:
             view->triggerPageAction(QWebEnginePage::Stop);
             return true;
         case KParts::HtmlSettingsInterface::LocalStorageEnabled:
             settings->setAttribute(QWebEngineSettings::LocalStorageEnabled, value.toBool());
             return false;
         case KParts::HtmlSettingsInterface::OfflineStorageDatabaseEnabled:
             //settings->setAttribute(QWebEngineSettings::OfflineStorageDatabaseEnabled, value.toBool());
             return false;
         case KParts::HtmlSettingsInterface::OfflineWebApplicationCacheEnabled:
             //settings->setAttribute(QWebEngineSettings::OfflineWebApplicationCacheEnabled, value.toBool());
             return false;
         case KParts::HtmlSettingsInterface::PrivateBrowsingEnabled:
             //settings->setAttribute(QWebEnngineSettings::PrivateBrowsingEnabled, value.toBool());
             return false;
         case KParts::HtmlSettingsInterface::UserDefinedStyleSheetURL:
             //kDebug() << "Setting user style sheet for" << page << "to" << value.toUrl();
           //  settings->setUserStyleSheetUrl(value.toUrl());
             return false;
         default:
             break;
         }
     }
 
     return false;
 }
 
 WebEnginePart* WebEngineHtmlExtension::part() const
 {
     return static_cast<WebEnginePart*>(parent());
 }
 
 WebEngineScriptableExtension::WebEngineScriptableExtension(WebEnginePart* part)
     : ScriptableExtension(part)
 {
 }
 
 QVariant WebEngineScriptableExtension::rootObject()
 {
     return QVariant::fromValue(KParts::ScriptableExtension::Object(this, reinterpret_cast<quint64>(this)));
 }
 
 bool WebEngineScriptableExtension::setException (KParts::ScriptableExtension* callerPrincipal, const QString& message)
 {
     return KParts::ScriptableExtension::setException (callerPrincipal, message);
 }
 
 QVariant WebEngineScriptableExtension::get (KParts::ScriptableExtension* callerPrincipal, quint64 objId, const QString& propName)
 {
     //kDebug() << "caller:" << callerPrincipal << "id:" << objId << "propName:" << propName;
     return callerPrincipal->get (0, objId, propName);
 }
 
 bool WebEngineScriptableExtension::put (KParts::ScriptableExtension* callerPrincipal, quint64 objId, const QString& propName, const QVariant& value)
 {
     return KParts::ScriptableExtension::put (callerPrincipal, objId, propName, value);
 }
 
 static QVariant exception(const char* msg)
 {
     qWarning() << msg;
     return QVariant::fromValue(KParts::ScriptableExtension::Exception(QString::fromLatin1(msg)));
 }
 
 QVariant WebEngineScriptableExtension::evaluateScript (KParts::ScriptableExtension* callerPrincipal,
                                                      quint64 contextObjectId,
                                                      const QString& code,
                                                      KParts::ScriptableExtension::ScriptLanguage lang)
 {
     Q_UNUSED(contextObjectId);
     Q_UNUSED(code)
     //kDebug() << "principal:" << callerPrincipal << "id:" << contextObjectId << "language:" << lang << "code:" << code;
 
     if (lang != ECMAScript)
         return exception("unsupported language");
 
 
     KParts::ReadOnlyPart* part = callerPrincipal ? qobject_cast<KParts::ReadOnlyPart*>(callerPrincipal->parent()) : 0;
    // QWebFrame* frame = part ? qobject_cast<QWebFrame*>(part->parent()) : 0;
    // if (!frame)
         return exception("failed to resolve principal");
 #if 0
     QVariant result (frame->evaluateJavaScript(code));
 
     if (result.type() == QVariant::Map) {
         const QVariantMap map (result.toMap());
         for (QVariantMap::const_iterator it = map.constBegin(), itEnd = map.constEnd(); it != itEnd; ++it) {
             callerPrincipal->put(callerPrincipal, 0, it.key(), it.value());
         }
     } else {
         const QString propName(code.contains(QLatin1String("__nsplugin")) ? QLatin1String("__nsplugin") : QString());
         callerPrincipal->put(callerPrincipal, 0, propName, result.toString());
     }
 
     return QVariant::fromValue(ScriptableExtension::Null());
 #endif
 }
 
 bool WebEngineScriptableExtension::isScriptLanguageSupported (KParts::ScriptableExtension::ScriptLanguage lang) const
 {
     return (lang == KParts::ScriptableExtension::ECMAScript);
 }
 
 QVariant WebEngineScriptableExtension::encloserForKid (KParts::ScriptableExtension* kid)
 {
 #if 0
     KParts::ReadOnlyPart* part = kid ? qobject_cast<KParts::ReadOnlyPart*>(kid->parent()) : 0;
     QWebFrame* frame = part ? qobject_cast<QWebFrame*>(part->parent()) : 0;
     if (frame) {
         return QVariant::fromValue(KParts::ScriptableExtension::Object(kid, reinterpret_cast<quint64>(kid)));
     }
 #endif
 
     return QVariant::fromValue(ScriptableExtension::Null());
 }
 
 WebEnginePart* WebEngineScriptableExtension::part()
 {
     return qobject_cast<WebEnginePart*>(parent());
 }