diff --git a/krusader/Dialogs/packguibase.cpp b/krusader/Dialogs/packguibase.cpp
index 91cc5f3d..bcee78cf 100644
--- a/krusader/Dialogs/packguibase.cpp
+++ b/krusader/Dialogs/packguibase.cpp
@@ -1,497 +1,497 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader 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.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "packguibase.h"
 
 // QtCore
 #include <QVariant>
 // QtGui
 #include <QGuiApplication>
 #include <QImage>
 #include <QPixmap>
 #include <QKeyEvent>
 // QtWidgets
 #include <QSlider>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QLabel>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QToolButton>
 #include <QLayout>
 #include <QSpinBox>
 #include <QHBoxLayout>
 #include <QGridLayout>
 #include <QFrame>
 #include <QVBoxLayout>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIconThemes/KIconLoader>
 #include <KCompletion/KComboBox>
 #include <KWidgetsAddons/KMessageBox>
 #include <KIO/Global>
 #include <KCompletion/KHistoryComboBox>
 #include <KWidgetsAddons/KStandardGuiItem>
 
 #include "../defaults.h"
 #include "../krglobal.h"
 #include "../icon.h"
 
 /*
  *  Constructs a PackGUIBase which is a child of 'parent', with the
  *  name 'name' and widget flags set to 'f'
  *
  *  The dialog will by default be modeless, unless you set 'modal' to
  *  TRUE to construct a modal dialog.
  */
 PackGUIBase::PackGUIBase(QWidget* parent)
         : QDialog(parent), expanded(false)
 {
     KConfigGroup group(krConfig, "Archives");
 
     setModal(true);
     resize(430, 140);
     setWindowTitle(i18n("Pack"));
     grid = new QGridLayout(this);
     grid->setSpacing(6);
     grid->setContentsMargins(11, 11, 11, 11);
 
     hbox = new QHBoxLayout;
     hbox->setSpacing(6);
     hbox->setContentsMargins(0, 0, 0, 0);
 
     TextLabel3 = new QLabel(this);
     TextLabel3->setText(i18n("To archive"));
     hbox->addWidget(TextLabel3);
 
     nameData = new QLineEdit(this);
     hbox->addWidget(nameData);
 
     typeData = new QComboBox(this);
     typeData->setSizePolicy(QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed));
     connect(typeData, SIGNAL(activated(QString)), this,  SLOT(checkConsistency()));
     connect(typeData, SIGNAL(highlighted(QString)), this,  SLOT(checkConsistency()));
     hbox->addWidget(typeData);
 
     grid->addLayout(hbox, 1, 0);
 
     hbox_2 = new QHBoxLayout;
     hbox_2->setSpacing(6);
     hbox_2->setContentsMargins(0, 0, 0, 0);
 
     TextLabel5 = new QLabel(this);
     TextLabel5->setText(i18n("In folder"));
     hbox_2->addWidget(TextLabel5);
 
     dirData = new QLineEdit(this);
     hbox_2->addWidget(dirData);
 
     browseButton = new QToolButton(this);
-    browseButton->setIcon(SmallIcon("document-open"));
+    browseButton->setIcon(Icon("document-open"));
     hbox_2->addWidget(browseButton);
     QSpacerItem* spacer = new QSpacerItem(48, 20, QSizePolicy::Fixed, QSizePolicy::Fixed);
     hbox_2->addItem(spacer);
 
     grid->addLayout(hbox_2, 2, 0);
 
     hbox_3 = new QHBoxLayout;
     hbox_3->setSpacing(6);
     hbox_3->setContentsMargins(0, 0, 0, 0);
 
     PixmapLabel1 = new QLabel(this);
     PixmapLabel1->setPixmap(Icon("package-x-generic").pixmap(32));
     PixmapLabel1->setScaledContents(true);
     PixmapLabel1->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
     hbox_3->addWidget(PixmapLabel1);
 
     TextLabel1 = new QLabel(this);
     TextLabel1->setText(i18n("Pack"));
     hbox_3->addWidget(TextLabel1);
 
     grid->addLayout(hbox_3, 0, 0);
 
 
     hbox_4 = new QHBoxLayout;
     hbox_4->setSpacing(6);
     hbox_4->setContentsMargins(0, 0, 0, 0);
 
     QSpacerItem* spacer_3 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Expanding);
     hbox_4->addItem(spacer_3);
     grid->addLayout(hbox_4, 3, 0);
 
     advancedWidget = new QWidget(this);
 
     hbox_5 = new QGridLayout(advancedWidget);
     hbox_5->setSpacing(6);
     hbox_5->setContentsMargins(0, 0, 0, 0);
 
 
     QVBoxLayout *compressLayout = new QVBoxLayout;
     compressLayout->setSpacing(6);
     compressLayout->setContentsMargins(0, 0, 0, 0);
 
     multipleVolume = new QCheckBox(i18n("Multiple volume archive"), advancedWidget);
     connect(multipleVolume, SIGNAL(toggled(bool)), this, SLOT(checkConsistency()));
     compressLayout->addWidget(multipleVolume, 0, 0);
 
     QHBoxLayout * volumeHbox = new QHBoxLayout;
 
     QSpacerItem* spacer_5 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Fixed);
     volumeHbox->addItem(spacer_5);
 
     TextLabel7 = new QLabel(i18n("Size:"), advancedWidget);
     volumeHbox->addWidget(TextLabel7);
 
     volumeSpinBox = new QSpinBox(advancedWidget);
     volumeSpinBox->setMinimum(1);
     volumeSpinBox->setMaximum(9999);
     volumeSpinBox->setValue(1440);
     volumeHbox->addWidget(volumeSpinBox);
 
     volumeUnitCombo = new QComboBox(advancedWidget);
     volumeUnitCombo->addItem("B");
     volumeUnitCombo->addItem("KB");
     volumeUnitCombo->addItem("MB");
     volumeUnitCombo->setCurrentIndex(1);
     volumeHbox->addWidget(volumeUnitCombo);
 
     compressLayout->addLayout(volumeHbox);
 
     int level = group.readEntry("Compression level", _defaultCompressionLevel);
     setCompressionLevel = new QCheckBox(i18n("Set compression level"), advancedWidget);
     if (level != _defaultCompressionLevel)
         setCompressionLevel->setChecked(true);
     connect(setCompressionLevel, SIGNAL(toggled(bool)), this, SLOT(checkConsistency()));
     compressLayout->addWidget(setCompressionLevel, 0, 0);
 
     QHBoxLayout * sliderHbox = new QHBoxLayout;
 
     QSpacerItem* spacer_6 = new QSpacerItem(20, 26, QSizePolicy::Fixed, QSizePolicy::Fixed);
     sliderHbox->addItem(spacer_6);
 
     QWidget * sliderVBoxWidget = new QWidget(advancedWidget);
     QVBoxLayout *sliderVBox = new QVBoxLayout(sliderVBoxWidget);
 
     compressionSlider = new QSlider(Qt::Horizontal, sliderVBoxWidget);
     compressionSlider->setMinimum(1);
     compressionSlider->setMaximum(9);
     compressionSlider->setPageStep(1);
     compressionSlider->setValue(level);
     compressionSlider->setTickPosition(QSlider::TicksBelow);
     sliderVBox->addWidget(compressionSlider);
 
     QWidget * minmaxWidget = new QWidget(sliderVBoxWidget);
     sliderVBox->addWidget(minmaxWidget);
 
     QHBoxLayout * minmaxHbox = new QHBoxLayout(minmaxWidget);
 
     minLabel = new QLabel(i18n("MIN"), minmaxWidget);
     maxLabel = new QLabel(i18n("MAX"), minmaxWidget);
     maxLabel->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
     minmaxHbox->addWidget(minLabel);
     minmaxHbox->addWidget(maxLabel);
 
     sliderHbox->addWidget(sliderVBoxWidget);
 
     compressLayout->addLayout(sliderHbox);
 
     compressLayout->addStretch(0);
     hbox_5->addLayout(compressLayout, 0, 0);
 
     QFrame *vline = new QFrame(advancedWidget);
     vline->setFrameStyle(QFrame::VLine | QFrame::Sunken);
     vline->setMinimumWidth(20);
     hbox_5->addWidget(vline, 0, 1);
 
 
     QGridLayout * passwordGrid = new QGridLayout;
     passwordGrid->setSpacing(6);
     passwordGrid->setContentsMargins(0, 0, 0, 0);
 
     TextLabel4 = new QLabel(advancedWidget);
     TextLabel4->setText(i18n("Password"));
     passwordGrid->addWidget(TextLabel4, 0, 0);
 
     password = new QLineEdit(advancedWidget);
     password->setEchoMode(QLineEdit::Password);
     connect(password, SIGNAL(textChanged(QString)), this, SLOT(checkConsistency()));
 
     passwordGrid->addWidget(password, 0, 1);
 
     TextLabel6 = new QLabel(advancedWidget);
     TextLabel6->setText(i18n("Again"));
     passwordGrid->addWidget(TextLabel6, 1, 0);
 
     passwordAgain = new QLineEdit(advancedWidget);
     passwordAgain->setEchoMode(QLineEdit::Password);
     connect(passwordAgain, SIGNAL(textChanged(QString)), this, SLOT(checkConsistency()));
 
     passwordGrid->addWidget(passwordAgain, 1, 1);
 
     QHBoxLayout *consistencyHbox = new QHBoxLayout;
 
     QSpacerItem* spacer_cons = new QSpacerItem(48, 20, QSizePolicy::Expanding, QSizePolicy::Fixed);
     consistencyHbox->addItem(spacer_cons);
 
     passwordConsistencyLabel = new QLabel(advancedWidget);
     consistencyHbox->addWidget(passwordConsistencyLabel);
     passwordGrid->addLayout(consistencyHbox, 2, 0, 1, 2);
 
     encryptHeaders = new QCheckBox(i18n("Encrypt headers"), advancedWidget);
     passwordGrid->addWidget(encryptHeaders, 3, 0, 1, 2);
 
     QSpacerItem* spacer_psw = new QSpacerItem(20, 20, QSizePolicy::Fixed, QSizePolicy::Expanding);
     passwordGrid->addItem(spacer_psw, 4, 0);
 
     hbox_5->addLayout(passwordGrid, 0, 2);
 
     hbox_7 = new QHBoxLayout;
     hbox_7->setSpacing(6);
     hbox_7->setContentsMargins(0, 0, 0, 0);
 
     TextLabel8 = new QLabel(i18n("Command line switches:"), advancedWidget);
     TextLabel8->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
     hbox_7->addWidget(TextLabel8);
 
     commandLineSwitches = new KHistoryComboBox(advancedWidget);
     commandLineSwitches->setMaxCount(25);  // remember 25 items
     commandLineSwitches->setDuplicatesEnabled(false);
     commandLineSwitches->setMinimumContentsLength(10);
 
     QStringList list = group.readEntry("Command Line Switches", QStringList());
     commandLineSwitches->setHistoryItems(list);
 
     hbox_7->addWidget(commandLineSwitches);
 
     hbox_5->addLayout(hbox_7, 1, 0, 1, 3);
 
 
     advancedWidget->hide();
     checkConsistency();
 
     grid->addWidget(advancedWidget, 4, 0);
 
     hbox_6 = new QHBoxLayout;
     hbox_6->setSpacing(6);
     hbox_6->setContentsMargins(0, 0, 0, 0);
 
     advancedButton = new QPushButton(this);
     advancedButton->setText(i18n("&Advanced >>"));
     hbox_6->addWidget(advancedButton);
 
     QSpacerItem* spacer_2 = new QSpacerItem(140, 20, QSizePolicy::Expanding, QSizePolicy::Fixed);
     hbox_6->addItem(spacer_2);
 
     okButton = new QPushButton(this);
     KStandardGuiItem::assign(okButton, KStandardGuiItem::Ok);
     okButton->setDefault(true);
     hbox_6->addWidget(okButton);
 
     cancelButton = new QPushButton(this);
     KStandardGuiItem::assign(cancelButton, KStandardGuiItem::Cancel);
     hbox_6->addWidget(cancelButton);
 
     grid->addLayout(hbox_6, 6, 0);
 
     // signals and slots connections
     connect(okButton, SIGNAL(clicked()), this, SLOT(accept()));
     connect(advancedButton, SIGNAL(clicked()), this, SLOT(expand()));
     connect(cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
     connect(browseButton, SIGNAL(clicked()), this, SLOT(browse()));
 }
 
 /*
  *  Destroys the object and frees any allocated resources
  */
 PackGUIBase::~PackGUIBase()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 void PackGUIBase::browse()
 {
     qWarning("PackGUIBase::browse(): Not implemented yet!");
 }
 
 void PackGUIBase::expand()
 {
     expanded = !expanded;
 
     advancedButton->setText(expanded ? i18n("&Advanced <<") : i18n("&Advanced >>"));
 
     if (expanded)
         advancedWidget->show();
     else {
         advancedWidget->hide();
         layout()->activate();
         QSize minSize = minimumSize();
         resize(width(), minSize.height());
     }
     show();
 }
 
 void PackGUIBase::checkConsistency()
 {
     QPalette p = QGuiApplication::palette();
     QPalette pal = passwordConsistencyLabel->palette();
     if (password->text().isEmpty() && passwordAgain->text().isEmpty()) {
         pal.setColor(passwordConsistencyLabel->foregroundRole(), p.color(QPalette::Active, QPalette::Text));
         passwordConsistencyLabel->setText(i18n("No password specified"));
     } else if (password->text() == passwordAgain->text()) {
         pal.setColor(passwordConsistencyLabel->foregroundRole(), p.color(QPalette::Active, QPalette::Text));
         passwordConsistencyLabel->setText(i18n("The passwords are equal"));
     } else {
         pal.setColor(passwordConsistencyLabel->foregroundRole(), Qt::red);
         passwordConsistencyLabel->setText(i18n("The passwords are different"));
     }
     passwordConsistencyLabel->setPalette(pal);
 
     QString packer = typeData->currentText();
 
     bool passworded = false;
     if (packer == "7z" || packer == "rar" || packer == "zip" || packer == "arj")
         passworded = true;
 
     passwordConsistencyLabel->setEnabled(passworded);
     password->setEnabled(passworded);
     passwordAgain->setEnabled(passworded);
     TextLabel4->setEnabled(passworded);
     TextLabel6->setEnabled(passworded);
 
     encryptHeaders->setEnabled(packer == "rar");
 
     multipleVolume->setEnabled(packer == "rar" || packer == "arj");
     bool volumeEnabled = multipleVolume->isEnabled() && multipleVolume->isChecked();
     volumeSpinBox->setEnabled(volumeEnabled);
     volumeUnitCombo->setEnabled(volumeEnabled);
     TextLabel7->setEnabled(volumeEnabled);
 
     /* TODO */
     setCompressionLevel->setEnabled(packer == "rar" || packer == "arj" || packer == "zip" ||
                                     packer == "7z");
     bool sliderEnabled = setCompressionLevel->isEnabled() && setCompressionLevel->isChecked();
     compressionSlider->setEnabled(sliderEnabled);
     minLabel->setEnabled(sliderEnabled);
     maxLabel->setEnabled(sliderEnabled);
 }
 
 bool PackGUIBase::extraProperties(QMap<QString, QString> & inMap)
 {
     inMap.clear();
 
     KConfigGroup group(krConfig, "Archives");
 
     if (password->isEnabled() && passwordAgain->isEnabled()) {
         if (password->text() != passwordAgain->text()) {
             KMessageBox::error(this, i18n("Cannot pack, the passwords are different."));
             return false;
         }
 
         if (!password->text().isEmpty()) {
             inMap[ "Password" ] = password->text();
 
             if (encryptHeaders->isEnabled() && encryptHeaders->isChecked())
                 inMap[ "EncryptHeaders" ] = '1';
         }
     }
 
     if (multipleVolume->isEnabled() && multipleVolume->isChecked()) {
         KIO::filesize_t size = volumeSpinBox->value();
 
         switch (volumeUnitCombo->currentIndex()) {
         case 2:
             size *= 1000;
 #if __GNUC__ >= 7
             [[gnu::fallthrough]];
 #endif
         case 1:
             size *= 1000;
         default:
             break;
         }
 
         if (size < 10000) {
             KMessageBox::error(this, i18n("Invalid volume size."));
             return false;
         }
 
         QString sbuffer;
         sbuffer.sprintf("%llu", size);
 
         inMap[ "VolumeSize" ] = sbuffer;
     }
 
     if (setCompressionLevel->isEnabled() && setCompressionLevel->isChecked()) {
         inMap[ "CompressionLevel" ] = QString("%1").arg(compressionSlider->value());
         int level = compressionSlider->value();
         group.writeEntry("Compression level", level);
     }
 
     QString cmdArgs = commandLineSwitches->currentText().trimmed();
     if (!cmdArgs.isEmpty()) {
         bool firstChar = true;
         QChar quote = QChar::Null;
 
         for (int i = 0; i < cmdArgs.length(); i++) {
             QChar ch(cmdArgs[ i ]);
             if (ch.isSpace())
                 continue;
 
             if (ch == quote) {
                 quote = QChar::Null;
                 continue;
             }
 
             if (firstChar && ch != QLatin1Char('-')) {
                 KMessageBox::error(this, i18n("Invalid command line switch.\nA switch must start with '-'."));
                 return false;
             }
 
             firstChar = false;
 
             if (quote == QLatin1Char('"'))
                 continue;
             if (quote == QChar::Null && (ch == QLatin1Char('\'') || ch == QLatin1Char('"')))
                 quote = ch;
             if (ch == QLatin1Char('\\')) {
                 if (i == cmdArgs.length() - 1) {
                     KMessageBox::error(this, i18n("Invalid command line switch.\nBackslashes cannot be the last character."));
                     return false;
                 }
                 i++;
             }
         }
 
         if (quote != QChar::Null) {
             KMessageBox::error(this, i18n("Invalid command line switch.\nUnclosed quotation mark."));
             return false;
         }
 
         commandLineSwitches->addToHistory(cmdArgs);
         QStringList list = commandLineSwitches->historyItems();
         group.writeEntry("Command Line Switches", list);
 
         inMap[ "CommandLineSwitches" ] = cmdArgs;
     }
     return true;
 }
diff --git a/krusader/Dialogs/popularurls.cpp b/krusader/Dialogs/popularurls.cpp
index bcd40a1d..ff2627a8 100644
--- a/krusader/Dialogs/popularurls.cpp
+++ b/krusader/Dialogs/popularurls.cpp
@@ -1,375 +1,376 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader 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.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "popularurls.h"
 
 #include <stdio.h>
 
 // QtCore
 #include <QList>
 // QtWidgets
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QGridLayout>
 #include <QHeaderView>
 #include <QLayout>
 #include <QLabel>
 #include <QToolButton>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KWidgetsAddons/KMessageBox>
 #include <KIconThemes/KIconLoader>
 #include <KItemViews/KTreeWidgetSearchLine>
 
 #include "../krglobal.h"
+#include "../icon.h"
 #include "../krslots.h"
 #include "../GUI/krtreewidget.h"
 
 #define STARTING_RANK 20
 #define INCREASE   2
 #define DECREASE   1
 
 PopularUrls::PopularUrls(QObject *parent) : QObject(parent),
         head(0), tail(0), count(0)
 {
     dlg = new PopularUrlsDlg();
 }
 
 PopularUrls::~PopularUrls()
 {
     clearList();
     delete dlg;
 }
 
 void PopularUrls::clearList()
 {
     if (head) {
         UrlNodeP p = head, tmp;
         while (p) {
             tmp = p;
             p = p->next;
             delete tmp;
         }
     }
     ranks.clear();
     head = tail = 0;
 }
 
 void PopularUrls::save()
 {
     KConfigGroup svr(krConfig, "Private");
     // prepare the string list containing urls and int list with ranks
     QStringList urlList;
     QList<int> rankList;
     UrlNodeP p = head;
     while (p) {
         urlList << p->url.toDisplayString();
         rankList << p->rank;
         p = p->next;
     }
     svr.writeEntry("PopularUrls", urlList);
     svr.writeEntry("PopularUrlsRank", rankList);
 }
 
 void PopularUrls::load()
 {
     KConfigGroup svr(krConfig, "Private");
     QStringList urlList = svr.readEntry("PopularUrls", QStringList());
     QList<int> rankList = svr.readEntry("PopularUrlsRank", QList<int>());
     if (urlList.count() != rankList.count()) {
         KMessageBox::error(krMainWindow, i18n("The saved 'Popular URLs' are invalid. The list will be cleared."));
         return;
     }
     clearList();
     count = 0;
     // iterate through both lists and
     QStringList::Iterator uit;
     QList<int>::Iterator rit;
     for (uit = urlList.begin(), rit = rankList.begin(); uit != urlList.end() && rit != rankList.end(); ++uit, ++rit) {
         UrlNodeP node = new UrlNode;
         node->url = QUrl(*uit);
         node->rank = *rit;
         appendNode(node);
         ranks.insert(*uit, node);
     }
 }
 
 
 // returns a url list with the 'max' top popular urls
 QList<QUrl> PopularUrls::getMostPopularUrls(int max)
 {
     // get at most 'max' urls
     QList<QUrl> list;
     UrlNodeP p = head;
     int tmp = 0;
     if (maxUrls < max) max = maxUrls; // don't give more than maxUrls
     while (p && tmp < max) {
         list << p->url;
         p = p->next;
         ++tmp;
     }
 
     return list;
 }
 
 // adds a url to the list, or increase rank of an existing url, making
 // sure to bump it up the list if needed
 void PopularUrls::addUrl(const QUrl& url)
 {
     QUrl tmpurl = url;
     tmpurl.setPassword(QString()); // make sure no passwords are permanently stored
     if (!tmpurl.path().endsWith('/')) // make a uniform trailing slash policy
         tmpurl.setPath(tmpurl.path() + '/');
     UrlNodeP pnode;
 
     decreaseRanks();
     if (!head) { // if the list is empty ... (assumes dict to be empty as well)
         pnode = new UrlNode;
         pnode->rank = STARTING_RANK;
         pnode->url = tmpurl;
         appendNode(pnode);
         ranks.insert(tmpurl.url(), head);
     } else {
         if (ranks.find(tmpurl.url()) == ranks.end()) {  // is the added url new? if so, append it
             pnode = new UrlNode;
             pnode->rank = STARTING_RANK;
             pnode->url = tmpurl;
             appendNode(pnode);
             ranks.insert(tmpurl.url(), pnode);
         } else {
             pnode = ranks[ tmpurl.url()];
             pnode->rank += INCREASE;
         }
     }
 
     // do we need to change location for this one?
     relocateIfNeeded(pnode);
 
     // too many urls?
     if (count > maxUrls) removeNode(tail);
 
     //dumpList();
 }
 
 // checks if 'node' needs to be bumped-up the ranking list and does it if needed
 void PopularUrls::relocateIfNeeded(UrlNodeP node)
 {
     if (node->prev && (node->prev->rank < node->rank)) {
         // iterate until we find the correct place to put it
         UrlNodeP tmp = node->prev->prev;
         while (tmp) {
             if (tmp->rank >= node->rank)
                 break; // found it!
             else tmp = tmp->prev;
         }
         // now, if tmp isn't null, we need to move node to tmp->next
         // else move it to become head
         removeNode(node);
         insertNode(node, tmp);
     }
 }
 
 
 // iterate over the list, decreasing each url's rank
 // this is very naive, but a 1..30 for loop is acceptable (i hope)
 void PopularUrls::decreaseRanks()
 {
     if (head) {
         UrlNodeP p = head;
         while (p) {
             if (p->rank - DECREASE >= 0)
                 p->rank -= DECREASE;
             else p->rank = 0;
             p = p->next;
         }
     }
 }
 
 // removes a node from the list, but doesn't free memory!
 // note: this will be buggy in case the list becomes empty (which should never happen)
 void PopularUrls::removeNode(UrlNodeP node)
 {
     if (node->prev) {
         if (tail == node) tail = node->prev;
         node->prev->next = node->next;
     }
     if (node->next) {
         if (head == node) head = node->next;
         node->next->prev = node->prev;
     }
     --count;
 }
 
 void PopularUrls::insertNode(UrlNodeP node, UrlNodeP after)
 {
     if (!after) { // make node head
         node->next = head;
         node->prev = 0;
         head->prev = node;
         head = node;
     } else {
         if (tail == after) tail = node;
         node->prev = after;
         node->next = after->next;
         if (node->next) {
             after->next->prev = node;
             after->next = node;
         }
     }
     ++count;
 }
 
 // appends 'node' to the end of the list, collecting garbage if needed
 void PopularUrls::appendNode(UrlNodeP node)
 {
     if (!tail) { // creating the first element
         head = tail = node;
         node->prev = node->next = 0;
     } else {
         node->next = 0;
         node->prev = tail;
         tail->next = node;
         tail = node;
     }
     ++count;
 }
 
 void PopularUrls::dumpList()
 {
     UrlNodeP p = head;
     printf("====start %d====\n", count);
     while (p) {
         printf("%d : %s\n", p->rank, p->url.url().toLatin1().data());
         p = p->next;
     }
     fflush(stdout);
 }
 
 void PopularUrls::showDialog()
 {
     QList<QUrl> list = getMostPopularUrls(maxUrls);
     dlg->run(list);
     if (dlg->result() == -1) return;
     SLOTS->refresh(list[dlg->result()]);
     //printf("running %s\n", list[dlg->result()].url().toLatin1());fflush(stdout);
 }
 
 // ===================================== PopularUrlsDlg ======================================
 PopularUrlsDlg::PopularUrlsDlg():
         QDialog(krMainWindow)
 {
     setWindowTitle(i18n("Popular URLs"));
     setWindowModality(Qt::WindowModal);
 
     QVBoxLayout *mainLayout = new QVBoxLayout;
     setLayout(mainLayout);
 
     QGridLayout *layout = new QGridLayout;
     layout->setContentsMargins(0, 0, 0, 0);
 
     // listview to contain the urls
     urls = new KrTreeWidget(this);
     urls->header()->hide();
     urls->setSortingEnabled(false);
     urls->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOn);
 
     // quick search
     search = new KTreeWidgetSearchLine(this, urls);
     QLabel *lbl = new QLabel(i18n("&Search:"), this);
     lbl->setBuddy(search);
 
     layout->addWidget(lbl, 0, 0);
     layout->addWidget(search, 0, 1);
     layout->addWidget(urls, 1, 0, 1, 2);
 
     mainLayout->addLayout(layout);
 
     QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
     mainLayout->addWidget(buttonBox);
 
     setTabOrder(search, urls);
     setTabOrder((QWidget *)urls, buttonBox->button(QDialogButtonBox::Close));
 
     connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
     connect(urls, SIGNAL(activated(QModelIndex)),
             this, SLOT(slotItemSelected(QModelIndex)));
     connect(search, SIGNAL(hiddenChanged(QTreeWidgetItem*,bool)),
             this, SLOT(slotVisibilityChanged()));
 }
 
 void PopularUrlsDlg::slotItemSelected(const QModelIndex & ndx)
 {
     selection = ndx.row();
     accept();
 }
 
 void PopularUrlsDlg::slotVisibilityChanged()
 {
     // select the first visible item
     QList<QTreeWidgetItem *> list = urls->selectedItems();
     if (list.count() > 0 && !list[0]->isHidden())
         return;
 
     urls->clearSelection();
     urls->setCurrentItem(0);
 
     QTreeWidgetItemIterator it(urls);
     while (*it) {
         if (!(*it)->isHidden()) {
             (*it)->setSelected(true);
             urls->setCurrentItem(*it);
             break;
         }
         it++;
     }
 }
 
 PopularUrlsDlg::~PopularUrlsDlg()
 {
     delete search;
     delete urls;
 }
 
 void PopularUrlsDlg::run(QList<QUrl> list)
 {
     // populate the listview
     urls->clear();
     QList<QUrl>::Iterator it;
 
     QTreeWidgetItem * lastItem = 0;
 
     for (it = list.begin(); it != list.end(); ++it) {
         QTreeWidgetItem *item = new QTreeWidgetItem(urls, lastItem);
         lastItem = item;
         item->setText(0, (*it).isLocalFile() ? (*it).path() : (*it).toDisplayString());
-        item->setIcon(0, (*it).isLocalFile() ? SmallIcon("folder") : SmallIcon("folder-html"));
+        item->setIcon(0, (*it).isLocalFile() ? Icon("folder") : Icon("folder-html"));
     }
 
     setMinimumSize(urls->sizeHint().width() + 45, 400);
 
     search->clear();
     search->setFocus();
     selection = -1;
     slotVisibilityChanged();
     exec();
 }
 
diff --git a/krusader/GUI/kcmdline.cpp b/krusader/GUI/kcmdline.cpp
index af726ec4..9bcc0fa6 100644
--- a/krusader/GUI/kcmdline.cpp
+++ b/krusader/GUI/kcmdline.cpp
@@ -1,315 +1,316 @@
 /*****************************************************************************
  * Copyright (C) 2000 Shie Erlich <krusader@users.sourceforge.net>           *
  * Copyright (C) 2000 Rafi Yanai <krusader@users.sourceforge.net>            *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader 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.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kcmdline.h"
 
 // QtCore
 #include <QDir>
 #include <QStringList>
 #include <QUrl>
 // QtGui
 #include <QKeyEvent>
 #include <QIcon>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QImage>
 // QtWidgets
 #include <QSizePolicy>
 #include <QGridLayout>
 #include <QFrame>
 #include <QLabel>
 
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIconThemes/KIconLoader>
 
 #include "../krglobal.h"
+#include "../icon.h"
 #include "../krslots.h"
 #include "../defaults.h"
 #include "../krusaderview.h"
 #include "../krservices.h"
 #include "../ActionMan/addplaceholderpopup.h"
 #include "kcmdmodebutton.h"
 
 
 CmdLineCombo::CmdLineCombo(QWidget *parent) : KHistoryComboBox(parent), _handlingLineEditResize(false)
 {
     lineEdit()->installEventFilter(this);
     _pathLabel = new QLabel(this);
     _pathLabel->setWhatsThis(i18n("Name of folder where command will be processed."));
     _pathLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
 }
 
 bool CmdLineCombo::eventFilter(QObject *watched, QEvent *e)
 {
     if(watched == lineEdit() && (e->type() == QEvent::Move || e->type() == QEvent::Resize)) {
         if(!_handlingLineEditResize) { // avoid infinite recursion
             _handlingLineEditResize = true;
             updateLineEditGeometry();
             _handlingLineEditResize = false;
         }
     }
     return false;
 }
 
 void CmdLineCombo::setPath(QString path)
 {
     _path = path;
     doLayout();
 }
 
 void CmdLineCombo::updateLineEditGeometry()
 {
     QRect r = lineEdit()->geometry();
     r.setLeft(_pathLabel->geometry().right());
     lineEdit()->setGeometry(r);
 }
 
 void CmdLineCombo::doLayout()
 {
     QString pathNameLabel = _path;
     QFontMetrics fm(_pathLabel->fontMetrics());
     int textWidth = fm.width(_path);
     int maxWidth = (width() + _pathLabel->width()) * 2 / 5;
     int letters = _path.length() / 2;
 
     while (letters && textWidth > maxWidth) {
         pathNameLabel = _path.left(letters) + "..." + _path.right(letters);
         letters--;
         textWidth = fm.width(pathNameLabel);
     }
 
     _pathLabel->setText(pathNameLabel + "> ");
     _pathLabel->adjustSize();
 
     QStyleOptionComboBox opt;
     initStyleOption(&opt);
     QRect labelRect = style()->subControlRect(QStyle::CC_ComboBox, &opt,
                                             QStyle::SC_ComboBoxEditField, this);
     labelRect.adjust(2, 0, 0, 0);
     labelRect.setWidth(_pathLabel->width());
     _pathLabel->setGeometry(labelRect);
 
     updateLineEditGeometry();
 }
 
 void CmdLineCombo::resizeEvent(QResizeEvent *e)
 {
     KHistoryComboBox::resizeEvent(e);
     doLayout();
 }
 
 void CmdLineCombo::keyPressEvent(QKeyEvent *e)
 {
     switch (e->key()) {
     case Qt::Key_Enter:
     case Qt::Key_Return:
         if (e->modifiers() & Qt::ControlModifier) {
             SLOTS->insertFileName((e->modifiers()&Qt::ShiftModifier)!=0);
             break;
         }
         KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Down:
         if (e->modifiers()  == (Qt::ControlModifier | Qt::ShiftModifier)) {
             MAIN_VIEW->focusTerminalEmulator();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Up:
         if (e->modifiers() == Qt::ControlModifier || e->modifiers() == (Qt::ControlModifier | Qt::ShiftModifier)) {
             emit returnToPanel();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     case Qt::Key_Escape:
         if (e->modifiers() == 0) {
             emit returnToPanel();
             return;
         } else
             KHistoryComboBox::keyPressEvent(e);
         break;
     default:
         KHistoryComboBox::keyPressEvent(e);
     }
 }
 
 
 KCMDLine::KCMDLine(QWidget *parent) : QWidget(parent)
 {
     QGridLayout * layout = new QGridLayout(this);
     layout->setSpacing(0);
     layout->setContentsMargins(0, 0, 0, 0);
 
     int height = QFontMetrics(QFontDatabase::systemFont(QFontDatabase::GeneralFont)).height();
     height =  height + 5 * (height > 14) + 6;
 
     // and editable command line
     completion.setMode(KUrlCompletion::FileCompletion);
     cmdLine = new CmdLineCombo(this);
     cmdLine->setMaxCount(100);  // remember 100 commands
     cmdLine->setMinimumContentsLength(10);
     cmdLine->setDuplicatesEnabled(false);
     cmdLine->setMaximumHeight(height);
     cmdLine->setCompletionObject(&completion);
     cmdLine->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
     // load the history
     KConfigGroup grpSvr(krConfig, "Private");
     QStringList list = grpSvr.readEntry("cmdline history", QStringList());
     cmdLine->setHistoryItems(list);
 
     connect(cmdLine, SIGNAL(returnPressed(QString)), this, SLOT(slotRun()));
     connect(cmdLine, SIGNAL(returnPressed(QString)), cmdLine->lineEdit(), SLOT(clear()));
     connect(cmdLine, SIGNAL(returnToPanel()), this, SLOT(slotReturnFocus()));
 
     cmdLine->setWhatsThis(i18n("<qt><p>Well, it is actually quite simple: you type your command here and Krusader obeys.</p><p><b>Tip</b>: move within command line history with &lt;Up&gt; and &lt;Down&gt; arrows.</p></qt>"));
     layout->addWidget(cmdLine, 0, 1);
 
     buttonAddPlaceholder = new QToolButton(this);
     buttonAddPlaceholder->setAutoRaise(true);
-    buttonAddPlaceholder->setIcon(SmallIcon("list-add"));
+    buttonAddPlaceholder->setIcon(Icon("list-add"));
     connect(buttonAddPlaceholder, SIGNAL(clicked()), this, SLOT(addPlaceholder()));
     buttonAddPlaceholder->setWhatsThis(i18n("Add <b>Placeholders</b> for the selected files in the panel."));
 
     layout->addWidget(buttonAddPlaceholder, 0, 2);
 
     // a run in terminal button
     terminal = new KCMDModeButton(this);
     terminal->setAutoRaise(true);
     layout->addWidget(terminal, 0, 3);
 
     layout->activate();
 }
 
 KCMDLine::~KCMDLine()
 {
     KConfigGroup grpSvr(krConfig, "Private");
     QStringList list = cmdLine->historyItems();
     //qWarning() << list[0];
     grpSvr.writeEntry("cmdline history", list);
     krConfig->sync();
 }
 
 void KCMDLine::addPlaceholder()
 {
     AddPlaceholderPopup popup(this);
     QString exp = popup.getPlaceholder(
                       buttonAddPlaceholder->mapToGlobal(QPoint(0, 0))
                   );
     this->addText(exp);
 }
 
 void KCMDLine::setCurrent(const QString &path)
 {
     cmdLine->setPath(path);
 
     completion.setDir(QUrl::fromLocalFile(path));
     // make sure our command is executed in the right directory
     // This line is important for Krusader overall functions -> do not remove !
     QDir::setCurrent(path);
 }
 
 void KCMDLine::slotRun()
 {
     const QString command1(cmdLine->currentText());
     if (command1.isEmpty())
         return;
 
     cmdLine->addToHistory(command1);
     // bugfix by aardvark: current editline is destroyed by addToHistory() in some cases
     cmdLine->setEditText(command1);
 
     if (command1.simplified().left(3) == "cd ") {     // cd command effect the active panel
         QString dir = command1.right(command1.length() - command1.indexOf(" ")).trimmed();
         if (dir == "~")
             dir = QDir::homePath();
         else if (dir.left(1) != "/" && !dir.contains(":/"))
             dir = cmdLine->path() + (cmdLine->path() == "/" ? "" : "/") + dir;
         SLOTS->refresh(QUrl::fromUserInput(dir,QDir::currentPath(),QUrl::AssumeLocalFile));
     } else {
         exec();
         cmdLine->clearEditText();
     }
 }
 
 
 void KCMDLine::slotReturnFocus()
 {
     MAIN_VIEW->cmdLineUnFocus();
 }
 
 static const KrActionBase::ExecType execModesMenu[] = {
     KrActionBase::Normal,
     KrActionBase::CollectOutputSeparateStderr,
     KrActionBase::CollectOutput,
     KrActionBase::Terminal,
     KrActionBase::RunInTE,
 };
 
 QString KCMDLine::command() const
 {
     return cmdLine->currentText();
 }
 
 KrActionBase::ExecType KCMDLine::execType() const
 {
     KConfigGroup grp(krConfig, "Private");
     int i = grp.readEntry("Command Execution Mode", (int)0);
     return execModesMenu[i];
 }
 
 QString KCMDLine::startpath() const
 {
     return cmdLine->path();
 //     return path->text().left(path->text().length() - 1);
 }
 
 QString KCMDLine::user() const
 {
     return QString();
 }
 
 QString KCMDLine::text() const
 {
     return cmdLine->currentText();
 }
 
 bool KCMDLine::acceptURLs() const
 {
     return false;
 }
 
 bool KCMDLine::confirmExecution() const
 {
     return false;
 }
 
 bool KCMDLine::doSubstitution() const
 {
     return true;
 }
 
 void KCMDLine::setText(QString text)
 {
     cmdLine->lineEdit()->setText(text);
 }
diff --git a/krusader/GUI/kcmdmodebutton.cpp b/krusader/GUI/kcmdmodebutton.cpp
index 25a45c27..a7e859ff 100644
--- a/krusader/GUI/kcmdmodebutton.cpp
+++ b/krusader/GUI/kcmdmodebutton.cpp
@@ -1,74 +1,75 @@
 /*****************************************************************************
  * Copyright (C) 2006 Václav Juza <vaclavjuza@gmail.com>                     *
  * Copyright (C) 2006-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader 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.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "kcmdmodebutton.h"
 
 #include "../kractions.h"
+#include "../icon.h"
 
 // QtWidgets
 #include <QMenu>
 
 #include <KI18n/KLocalizedString>
 #include <KIconThemes/KIconLoader>
 #include <KWidgetsAddons/KActionMenu>
 
 /**
  * KCMDModeButton class, which represents a button with popup menu to switch
  * the mode of the krusader built-in command-line
  */
 KCMDModeButton::KCMDModeButton(QWidget *parent) : QToolButton(parent)
 {
     /* // from the old terminal-button:
       setText( i18n( "If pressed, Krusader executes command line in a terminal." ) );
       setToolTip( i18n( "If pressed, Krusader executes command line in a terminal." ) );
       QWhatsThis::add( terminal, i18n(
                             "The 'run in terminal' button allows Krusader "
                             "to run console (or otherwise non-graphical) "
                             "programs in a terminal of your choice. If it's "
                             "pressed, terminal mode is active." ) );
     */
-    setIcon(SmallIcon("utilities-terminal"));
+    setIcon(Icon("utilities-terminal"));
     adjustSize();
     action = new KActionMenu(i18n("Execution mode"), this);
     Q_CHECK_PTR(action);
     for (int i = 0; KrActions::execTypeArray[i] != 0; i++) {
         action->addAction(*KrActions::execTypeArray[i]);
     }
     QMenu *pP = action->menu();
     Q_CHECK_PTR(pP);
     setMenu(pP);
     setPopupMode(QToolButton::InstantPopup);
     setAcceptDrops(false);
 }
 
 KCMDModeButton::~KCMDModeButton()
 {
     delete action;
 }
 
 /** called when clicked to the button */
 void KCMDModeButton::showMenu()
 {
     QMenu * pP = menu();
     if (pP) {
         menu() ->exec(mapToGlobal(QPoint(0, 0)));
     }
 }
 
diff --git a/krusader/Konfigurator/konfiguratoritems.cpp b/krusader/Konfigurator/konfiguratoritems.cpp
index a14917e7..ee7c5a93 100644
--- a/krusader/Konfigurator/konfiguratoritems.cpp
+++ b/krusader/Konfigurator/konfiguratoritems.cpp
@@ -1,836 +1,838 @@
 /*****************************************************************************
  * Copyright (C) 2003 Csaba Karai <krusader@users.sourceforge.net>           *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader 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.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "konfiguratoritems.h"
+
 #include "../krglobal.h"
+#include "../icon.h"
 
 // QtCore
 #include <QMetaMethod>
 // QtGui
 #include <QPainter>
 #include <QPen>
 #include <QPixmap>
 // QtWidgets
 #include <QColorDialog>
 #include <QFontDialog>
 #include <QLabel>
 
 #include <KCompletion/KLineEdit>
 #include <KConfigCore/KSharedConfig>
 #include <KI18n/KLocalizedString>
 #include <KIconThemes/KIconLoader>
 
 KonfiguratorExtension::KonfiguratorExtension(QObject *obj, QString cfgGroup, QString cfgName,
                                              bool restartNeeded, int page)
     : QObject(), objectPtr(obj), applyConnected(false), setDefaultsConnected(false), changed(false),
       restartNeeded(restartNeeded), subpage(page), configGroup(cfgGroup), configName(cfgName)
 {
 }
 
 void KonfiguratorExtension::connectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&KonfiguratorExtension::applyManually))
         applyConnected = true;
     else if (signal == QMetaMethod::fromSignal(&KonfiguratorExtension::setDefaultsManually))
         setDefaultsConnected = true;
 
     QObject::connectNotify(signal);
 }
 
 bool KonfiguratorExtension::apply()
 {
     if (!changed)
         return false;
 
     if (applyConnected)
         emit applyManually(objectPtr, configGroup, configName);
     else
         emit applyAuto(objectPtr, configGroup, configName);
 
     setChanged(false);
     return restartNeeded;
 }
 
 void KonfiguratorExtension::setDefaults()
 {
     if (setDefaultsConnected)
         emit setDefaultsManually(objectPtr);
     else
         emit setDefaultsAuto(objectPtr);
 }
 
 void KonfiguratorExtension::loadInitialValue()
 {
     emit setInitialValue(objectPtr);
 }
 
 bool KonfiguratorExtension::isChanged()
 {
     return changed;
 }
 
 // KonfiguratorCheckBox class
 ///////////////////////////////
 
 KonfiguratorCheckBox::KonfiguratorCheckBox(QString configGroup, QString name, bool defaultValue, QString text,
         QWidget *parent, bool restart, int page) : QCheckBox(text, parent),
         defaultValue(defaultValue)
 {
     ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
     connect(ext, SIGNAL(applyAuto(QObject*,QString,QString)), this, SLOT(slotApply(QObject*,QString,QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 
     connect(this, SIGNAL(stateChanged(int)), ext, SLOT(setChanged()));
     loadInitialValue();
 }
 
 KonfiguratorCheckBox::~KonfiguratorCheckBox()
 {
     delete ext;
 }
 
 void KonfiguratorCheckBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     setChecked(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
 void KonfiguratorCheckBox::checkStateSet()
 {
     QCheckBox::checkStateSet();
     updateDeps();
 }
 
 void KonfiguratorCheckBox::nextCheckState()
 {
     QCheckBox::nextCheckState();
     updateDeps();
 }
 
 void KonfiguratorCheckBox::addDep(KonfiguratorCheckBox *dep)
 {
     deps << dep;
     dep->setEnabled(isChecked());
 }
 
 void KonfiguratorCheckBox::updateDeps()
 {
     foreach(KonfiguratorCheckBox *dep, deps)
         dep->setEnabled(isChecked());
 }
 
 void KonfiguratorCheckBox::slotApply(QObject *, QString configGroup, QString name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, isChecked());
 }
 
 void KonfiguratorCheckBox::slotSetDefaults(QObject *)
 {
     if (isChecked() != defaultValue)
         setChecked(defaultValue);
 }
 
 
 // KonfiguratorSpinBox class
 ///////////////////////////////
 
 KonfiguratorSpinBox::KonfiguratorSpinBox(QString configGroup, QString configName, int defaultValue,
                                          int min, int max, QWidget *parent, bool restartNeeded,
                                          int page)
     : QSpinBox(parent), defaultValue(defaultValue)
 {
     ext = new KonfiguratorExtension(this, configGroup, configName, restartNeeded, page);
     connect(ext, SIGNAL(applyAuto(QObject*,QString,QString)), this, SLOT(slotApply(QObject*,QString,QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 
     connect(this, SIGNAL(valueChanged(int)), ext, SLOT(setChanged()));
 
     setMinimum(min);
     setMaximum(max);
 
     loadInitialValue();
 }
 
 KonfiguratorSpinBox::~KonfiguratorSpinBox()
 {
     delete ext;
 }
 
 void KonfiguratorSpinBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     setValue(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
 void KonfiguratorSpinBox::slotApply(QObject *, QString configGroup, QString name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, value());
 }
 
 void KonfiguratorSpinBox::slotSetDefaults(QObject *)
 {
     if (value() != defaultValue)
         setValue(defaultValue);
 }
 
 // KonfiguratorCheckBoxGroup class
 ///////////////////////////////
 
 void KonfiguratorCheckBoxGroup::add(KonfiguratorCheckBox *checkBox)
 {
     checkBoxList.append(checkBox);
 }
 
 KonfiguratorCheckBox * KonfiguratorCheckBoxGroup::find(int index)
 {
     if (index < 0 || index >= checkBoxList.count())
         return 0;
     return checkBoxList.at(index);
 }
 
 KonfiguratorCheckBox * KonfiguratorCheckBoxGroup::find(QString name)
 {
     QListIterator<KonfiguratorCheckBox *> it(checkBoxList);
     while (it.hasNext()) {
         KonfiguratorCheckBox * checkBox = it.next();
 
         if (checkBox->extension()->getConfigName() == name)
             return checkBox;
     }
 
     return 0;
 }
 
 
 // KonfiguratorRadioButtons class
 ///////////////////////////////
 
 KonfiguratorRadioButtons::KonfiguratorRadioButtons(QString configGroup, QString name,
         QString defaultValue, QWidget *parent, bool restart, int page) :
         QWidget(parent), defaultValue(defaultValue)
 {
     ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
     connect(ext, SIGNAL(applyAuto(QObject*,QString,QString)), this, SLOT(slotApply(QObject*,QString,QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 }
 
 KonfiguratorRadioButtons::~KonfiguratorRadioButtons()
 {
     delete ext;
 }
 
 void KonfiguratorRadioButtons::addRadioButton(QRadioButton *radioWidget, QString name, QString value)
 {
     radioButtons.append(radioWidget);
     radioNames.push_back(name);
     radioValues.push_back(value);
 
     connect(radioWidget, SIGNAL(toggled(bool)), ext, SLOT(setChanged()));
 }
 
 QRadioButton * KonfiguratorRadioButtons::find(int index)
 {
     if (index < 0 || index >= radioButtons.count())
         return 0;
 
     return radioButtons.at(index);
 }
 
 QRadioButton * KonfiguratorRadioButtons::find(QString name)
 {
     int index = radioNames.indexOf(name);
     if (index == -1)
         return 0;
 
     return radioButtons.at(index);
 }
 
 void KonfiguratorRadioButtons::selectButton(QString value)
 {
     int cnt = 0;
 
     QListIterator<QRadioButton *> it(radioButtons);
     while (it.hasNext()) {
         QRadioButton * btn = it.next();
 
         if (value == radioValues[ cnt ]) {
             btn->setChecked(true);
             return;
         }
 
         cnt++;
     }
 
     if (!radioButtons.isEmpty())
         radioButtons.first()->setChecked(true);
 }
 
 void KonfiguratorRadioButtons::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     QString initValue = group.readEntry(ext->getConfigName(), defaultValue);
 
     selectButton(initValue);
     ext->setChanged(false);
 }
 
 QString KonfiguratorRadioButtons::selectedValue()
 {
     int cnt = 0;
 
     QListIterator<QRadioButton *> it(radioButtons);
     while (it.hasNext()) {
         QRadioButton * btn = it.next();
 
         if (btn->isChecked()) {
             return radioValues[ cnt ];
         }
 
         cnt++;
     }
     return QString();
 }
 
 void KonfiguratorRadioButtons::slotApply(QObject *, QString configGroup, QString name)
 {
     QString value = selectedValue();
 
     if (!value.isEmpty())
         KConfigGroup(krConfig, configGroup).writeEntry(name, value);
 }
 
 void KonfiguratorRadioButtons::slotSetDefaults(QObject *)
 {
     selectButton(defaultValue);
 }
 
 // KonfiguratorEditBox class
 ///////////////////////////////
 
 KonfiguratorEditBox::KonfiguratorEditBox(QString configGroup, QString name, QString defaultValue,
         QWidget *parent, bool restart, int page) : QLineEdit(parent),
         defaultValue(defaultValue)
 {
     ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
     connect(ext, SIGNAL(applyAuto(QObject *, QString, QString)), this,
             SLOT(slotApply(QObject *, QString, QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 
     connect(this, SIGNAL(textChanged(QString)), ext, SLOT(setChanged()));
 
     loadInitialValue();
 }
 
 KonfiguratorEditBox::~KonfiguratorEditBox()
 {
     delete ext;
 }
 
 void KonfiguratorEditBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     setText(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
 void KonfiguratorEditBox::slotApply(QObject *, QString configGroup, QString name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, text());
 }
 
 void KonfiguratorEditBox::slotSetDefaults(QObject *)
 {
     if (text() != defaultValue)
         setText(defaultValue);
 }
 
 
 // KonfiguratorURLRequester class
 ///////////////////////////////
 
 KonfiguratorURLRequester::KonfiguratorURLRequester(QString configGroup, QString name,
                                                    QString defaultValue, QWidget *parent,
                                                    bool restart, int page, bool expansion)
     : KUrlRequester(parent), defaultValue(defaultValue), expansion(expansion)
 {
     ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
     connect(ext, SIGNAL(applyAuto(QObject *, QString, QString)), this,
             SLOT(slotApply(QObject *, QString, QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 
     connect(this, SIGNAL(textChanged(QString)), ext, SLOT(setChanged()));
 
     loadInitialValue();
 }
 
 KonfiguratorURLRequester::~KonfiguratorURLRequester()
 {
     delete ext;
 }
 
 void KonfiguratorURLRequester::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     lineEdit()->setText(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
 void KonfiguratorURLRequester::slotApply(QObject *, QString configGroup, QString name)
 {
     KConfigGroup(krConfig, configGroup)
         .writeEntry(name, expansion ? url().toDisplayString(QUrl::PreferLocalFile) : text());
 }
 
 void KonfiguratorURLRequester::slotSetDefaults(QObject *)
 {
     if (url().toDisplayString(QUrl::PreferLocalFile) != defaultValue)
         lineEdit()->setText(defaultValue);
 }
 
 // KonfiguratorFontChooser class
 ///////////////////////////////
 
 KonfiguratorFontChooser::KonfiguratorFontChooser(QString configGroup, QString name, QFont defaultValue,
         QWidget *parent, bool restart, int page) : QWidget(parent),
         defaultValue(defaultValue)
 {
     QHBoxLayout *layout = new QHBoxLayout(this);
 
     ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
     connect(ext, SIGNAL(applyAuto(QObject*,QString,QString)), this, SLOT(slotApply(QObject*,QString,QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 
     pLabel = new QLabel(this);
     pLabel->setMinimumWidth(150);
     layout->addWidget(pLabel);
 
     pToolButton = new QToolButton(this);
 
     connect(pToolButton, SIGNAL(clicked()), this, SLOT(slotBrowseFont()));
 
-    pToolButton->setIcon(SmallIcon("document-open"));
+    pToolButton->setIcon(Icon("document-open"));
     layout->addWidget(pToolButton);
 
     loadInitialValue();
 }
 
 KonfiguratorFontChooser::~KonfiguratorFontChooser()
 {
     delete ext;
 }
 
 void KonfiguratorFontChooser::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     font = group.readEntry(ext->getConfigName(), defaultValue);
     ext->setChanged(false);
     setFont();
 }
 
 void KonfiguratorFontChooser::setFont()
 {
     pLabel->setFont(font);
     pLabel->setText(font.family() + QString(", %1").arg(font.pointSize()));
 }
 
 void KonfiguratorFontChooser::slotApply(QObject *, QString configGroup, QString name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, font);
 }
 
 void KonfiguratorFontChooser::slotSetDefaults(QObject *)
 {
     font = defaultValue;
     ext->setChanged();
     setFont();
 }
 
 void KonfiguratorFontChooser::slotBrowseFont()
 {
     bool ok;
     font = QFontDialog::getFont(&ok, font, this);
     if (!ok) return;  // cancelled by the user, and font is actually not changed (getFont returns the font we gave it)
     ext->setChanged();
     setFont();
 }
 
 // KonfiguratorComboBox class
 ///////////////////////////////
 
 KonfiguratorComboBox::KonfiguratorComboBox(QString configGroup, QString name, QString defaultValue,
         KONFIGURATOR_NAME_VALUE_PAIR *listIn, int listInLen, QWidget *parent,
         bool restart, bool editable, int page) : QComboBox(parent),
         defaultValue(defaultValue), listLen(listInLen)
 {
     list = new KONFIGURATOR_NAME_VALUE_PAIR[ listInLen ];
 
     for (int i = 0; i != listLen; i++) {
         list[i] = listIn[i];
         addItem(list[i].text);
     }
 
     ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
     connect(ext, SIGNAL(applyAuto(QObject*,QString,QString)), this, SLOT(slotApply(QObject*,QString,QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 
 //  connect( this, SIGNAL(highlighted(int)), ext, SLOT(setChanged()) ); /* Removed because of startup combo failure */
     connect(this, SIGNAL(activated(int)), ext, SLOT(setChanged()));
     connect(this, SIGNAL(currentTextChanged(QString)), ext, SLOT(setChanged()));
 
     setEditable(editable);
     loadInitialValue();
 }
 
 KonfiguratorComboBox::~KonfiguratorComboBox()
 {
     delete []list;
     delete ext;
 }
 
 void KonfiguratorComboBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     QString select = group.readEntry(ext->getConfigName(), defaultValue);
     selectEntry(select);
     ext->setChanged(false);
 }
 
 void KonfiguratorComboBox::slotApply(QObject *, QString configGroup, QString name)
 {
     QString text = isEditable() ? lineEdit()->text() : currentText();
     QString value = text;
 
     for (int i = 0; i != listLen; i++)
         if (list[i].text == text) {
             value = list[i].value;
             break;
         }
 
     KConfigGroup(krConfig, configGroup).writeEntry(name, value);
 }
 
 void KonfiguratorComboBox::selectEntry(QString entry)
 {
     for (int i = 0; i != listLen; i++)
         if (list[i].value == entry) {
             setCurrentIndex(i);
             return;
         }
 
     if (isEditable())
         lineEdit()->setText(entry);
     else
         setCurrentIndex(0);
 }
 
 void KonfiguratorComboBox::slotSetDefaults(QObject *)
 {
     selectEntry(defaultValue);
 }
 
 
 // KonfiguratorColorChooser class
 ///////////////////////////////
 
 KonfiguratorColorChooser::KonfiguratorColorChooser(QString configGroup, QString name,
                                                    QColor defaultValue, QWidget *parent,
                                                    bool restart, ADDITIONAL_COLOR *addColPtr,
                                                    int addColNum, int page)
     : QComboBox(parent), defaultValue(defaultValue), disableColorChooser(true)
 {
     ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
 
     connect(ext, SIGNAL(applyAuto(QObject*,QString,QString)), this, SLOT(slotApply(QObject*,QString,QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 
     addColor(i18n("Custom color"),  QColor(255, 255, 255));
     addColor(i18nc("Default color", "Default"), defaultValue);
 
     for (int i = 0; i != addColNum; i++) {
         additionalColors.push_back(addColPtr[i]);
         addColor(addColPtr[i].name, addColPtr[i].color);
     }
 
     addColor(i18n("Red"),           Qt::red);
     addColor(i18n("Green"),         Qt::green);
     addColor(i18n("Blue"),          Qt::blue);
     addColor(i18n("Cyan"),          Qt::cyan);
     addColor(i18n("Magenta"),       Qt::magenta);
     addColor(i18n("Yellow"),        Qt::yellow);
     addColor(i18n("Dark Red"),      Qt::darkRed);
     addColor(i18n("Dark Green"),    Qt::darkGreen);
     addColor(i18n("Dark Blue"),     Qt::darkBlue);
     addColor(i18n("Dark Cyan"),     Qt::darkCyan);
     addColor(i18n("Dark Magenta"),  Qt::darkMagenta);
     addColor(i18n("Dark Yellow"),   Qt::darkYellow);
     addColor(i18n("White"),         Qt::white);
     addColor(i18n("Light Gray"),    Qt::lightGray);
     addColor(i18n("Gray"),          Qt::gray);
     addColor(i18n("Dark Gray"),     Qt::darkGray);
     addColor(i18n("Black"),         Qt::black);
 
     connect(this, SIGNAL(activated(int)),   this, SLOT(slotCurrentChanged(int)));
 
     loadInitialValue();
 }
 
 KonfiguratorColorChooser::~KonfiguratorColorChooser()
 {
     delete ext;
 }
 
 QPixmap KonfiguratorColorChooser::createPixmap(QColor color)
 {
     QPainter painter;
     QPen pen;
     int size = QFontMetrics(font()).height() * 3 / 4;
     QRect rect(0, 0, size, size);
     QPixmap pixmap(rect.width(), rect.height());
 
     pen.setColor(Qt::black);
 
     painter.begin(&pixmap);
     QBrush brush(color);
     painter.fillRect(rect, brush);
     painter.setPen(pen);
     painter.drawRect(rect);
     painter.end();
 
     pixmap.detach();
     return pixmap;
 }
 
 void KonfiguratorColorChooser::addColor(QString text, QColor color)
 {
     addItem(createPixmap(color), text);
     palette.push_back(color);
 }
 
 void KonfiguratorColorChooser::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     QString selected = group.readEntry(ext->getConfigName(), QString(""));
     setValue(selected);
     ext->setChanged(false);
 }
 
 void KonfiguratorColorChooser::setDefaultColor(QColor dflt)
 {
     defaultValue = dflt;
     palette[1] = defaultValue;
     setItemIcon(1, createPixmap(defaultValue));
 
     if (currentIndex() == 1)
         emit colorChanged();
 }
 
 void KonfiguratorColorChooser::changeAdditionalColor(int num, QColor color)
 {
     if (num < additionalColors.size()) {
         palette[2+num] = color;
         additionalColors[num].color = color;
         setItemIcon(2 + num, createPixmap(color));
 
         if (currentIndex() == 2 + num)
             emit colorChanged();
     }
 }
 
 void KonfiguratorColorChooser::setDefaultText(QString text)
 {
     setItemIcon(1, createPixmap(defaultValue));
     setItemText(1, text);
 }
 
 void KonfiguratorColorChooser::slotApply(QObject *, QString configGroup, QString name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, getValue());
 }
 
 void KonfiguratorColorChooser::setValue(QString value)
 {
     disableColorChooser = true;
 
     if (value.isEmpty()) {
         setCurrentIndex(1);
         customValue = defaultValue;
     } else {
         bool found = false;
 
         for (int j = 0; j != additionalColors.size(); j++)
             if (additionalColors[j].value == value) {
                 setCurrentIndex(2 + j);
                 found = true;
                 break;
             }
 
         if (! found) {
             KConfigGroup colGroup(krConfig, ext->getConfigGroup());
             colGroup.writeEntry("TmpColor", value);
             QColor color = colGroup.readEntry("TmpColor", defaultValue);
             customValue = color;
             colGroup.deleteEntry("TmpColor");
 
             setCurrentIndex(0);
             for (int i = 2 + additionalColors.size(); i != palette.size(); i++)
                 if (palette[i] == color) {
                     setCurrentIndex(i);
                     break;
                 }
         }
     }
 
     palette[0] = customValue;
     setItemIcon(0, createPixmap(customValue));
 
     ext->setChanged();
     emit colorChanged();
     disableColorChooser = false;
 }
 
 QString KonfiguratorColorChooser::getValue()
 {
     QColor color = palette[ currentIndex()];
     if (currentIndex() == 1)     /* it's the default value? */
         return "";
     else if (currentIndex() >= 2 && currentIndex() < 2 + additionalColors.size())
         return additionalColors[ currentIndex() - 2 ].value;
     else
         return QString("%1,%2,%3").arg(color.red()).arg(color.green()).arg(color.blue());
 }
 
 bool KonfiguratorColorChooser::isValueRGB()
 {
     return !(currentIndex() >= 1 && currentIndex() < 2 + additionalColors.size());
 }
 
 void KonfiguratorColorChooser::slotSetDefaults(QObject *)
 {
     ext->setChanged();
     setCurrentIndex(1);
     emit colorChanged();
 }
 
 void KonfiguratorColorChooser::slotCurrentChanged(int number)
 {
     ext->setChanged();
     if (number == 0 && !disableColorChooser) {
         QColor color = QColorDialog::getColor(customValue, this);
         if (color.isValid()) {
             disableColorChooser = true;
             customValue = color;
             palette[0] = customValue;
             setItemIcon(0, createPixmap(customValue));
             disableColorChooser = false;
         }
     }
 
     emit colorChanged();
 }
 
 QColor KonfiguratorColorChooser::getColor()
 {
     return palette[ currentIndex()];
 }
 
 // KonfiguratorListBox class
 ///////////////////////////////
 
 KonfiguratorListBox::KonfiguratorListBox(QString configGroup, QString name, QStringList defaultValue,
         QWidget *parent, bool restart, int page) : KrListWidget(parent),
         defaultValue(defaultValue)
 {
     ext = new KonfiguratorExtension(this, configGroup, name, restart, page);
     connect(ext, SIGNAL(applyAuto(QObject*,QString,QString)), this, SLOT(slotApply(QObject*,QString,QString)));
     connect(ext, SIGNAL(setDefaultsAuto(QObject*)), this, SLOT(slotSetDefaults(QObject*)));
     connect(ext, SIGNAL(setInitialValue(QObject*)), this, SLOT(loadInitialValue()));
 
     loadInitialValue();
 }
 
 KonfiguratorListBox::~KonfiguratorListBox()
 {
     delete ext;
 }
 
 void KonfiguratorListBox::loadInitialValue()
 {
     KConfigGroup group(krConfig, ext->getConfigGroup());
     setList(group.readEntry(ext->getConfigName(), defaultValue));
     ext->setChanged(false);
 }
 
 void KonfiguratorListBox::slotApply(QObject *, QString configGroup, QString name)
 {
     KConfigGroup(krConfig, configGroup).writeEntry(name, list());
 }
 
 void KonfiguratorListBox::slotSetDefaults(QObject *)
 {
     if (list() != defaultValue) {
         ext->setChanged();
         setList(defaultValue);
     }
 }
 
 void KonfiguratorListBox::setList(QStringList list)
 {
     clear();
     addItems(list);
 }
 
 QStringList KonfiguratorListBox::list()
 {
     QStringList lst;
 
     for (int i = 0; i != count(); i++)
         lst += item(i)->text();
 
     return lst;
 }
 
 void KonfiguratorListBox::addItem(const QString & item)
 {
     if (!list().contains(item)) {
         KrListWidget::addItem(item);
         ext->setChanged();
     }
 }
 
 void KonfiguratorListBox::removeItem(const QString & item)
 {
     QList<QListWidgetItem *> list = findItems(item, Qt::MatchExactly);
     for (int i = 0; i != list.count(); i++)
         delete list[ i ];
 
     if (list.count())
         ext->setChanged();
 }
 
diff --git a/krusader/panelmanager.cpp b/krusader/panelmanager.cpp
index 9961c9ef..c60f0c99 100644
--- a/krusader/panelmanager.cpp
+++ b/krusader/panelmanager.cpp
@@ -1,462 +1,463 @@
 /*****************************************************************************
  * Copyright (C) 2002 Shie Erlich <erlich@users.sourceforge.net>             *
  * Copyright (C) 2002 Rafi Yanai <yanai@users.sourceforge.net>               *
  * Copyright (C) 2004-2018 Krusader Krew [https://krusader.org]              *
  *                                                                           *
  * This file is part of Krusader [https://krusader.org].                     *
  *                                                                           *
  * Krusader 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.                                       *
  *                                                                           *
  * Krusader 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 Krusader.  If not, see [http://www.gnu.org/licenses/].         *
  *****************************************************************************/
 
 #include "panelmanager.h"
 
 #include "defaults.h"
+#include "icon.h"
 #include "tabactions.h"
 #include "krusaderview.h"
 #include "krmainwindow.h"
 #include "Panel/listpanel.h"
 #include "Panel/panelfunc.h"
 #include "Panel/PanelView/krviewfactory.h"
 
 #include <assert.h>
 
 // QtGui
 #include <QImage>
 // QtWidgets
 #include <QStackedWidget>
 #include <QToolButton>
 #include <QGridLayout>
 
 #include <KConfigCore/KConfig>
 #include <KI18n/KLocalizedString>
 #include <KIconThemes/KIconLoader>
 
 
 PanelManager::PanelManager(QWidget *parent, KrMainWindow* mainWindow, bool left) :
         QWidget(parent),
         _otherManager(0),
         _actions(mainWindow->tabActions()),
         _layout(0),
         _left(left),
         _currentPanel(0)
 {
     _layout = new QGridLayout(this);
     _layout->setContentsMargins(0, 0, 0, 0);
     _layout->setSpacing(0);
     _stack = new QStackedWidget(this);
 
     // new tab button
     _newTab = new QToolButton(this);
     _newTab->setAutoRaise(true);
     _newTab->setText(i18n("Open a new tab in home"));
     _newTab->setToolTip(i18n("Open a new tab in home"));
-    _newTab->setIcon(SmallIcon("tab-new"));
+    _newTab->setIcon(Icon("tab-new"));
     _newTab->adjustSize();
     connect(_newTab, SIGNAL(clicked()), this, SLOT(slotNewTab()));
 
     // tab-bar
     _tabbar = new PanelTabBar(this, _actions);
     connect(_tabbar, SIGNAL(currentChanged(int)), this, SLOT(slotCurrentTabChanged(int)));
     connect(_tabbar, SIGNAL(tabCloseRequested(int)), this, SLOT(slotCloseTab(int)));
     connect(_tabbar, SIGNAL(closeCurrentTab()), this, SLOT(slotCloseTab()));
     connect(_tabbar, SIGNAL(newTab(QUrl)), this, SLOT(slotNewTab(QUrl)));
     connect(_tabbar, SIGNAL(draggingTab(QMouseEvent*)), this, SLOT(slotDraggingTab(QMouseEvent*)));
     connect(_tabbar, SIGNAL(draggingTabFinished(QMouseEvent*)), this, SLOT(slotDraggingTabFinished(QMouseEvent*)));
 
     QHBoxLayout *tabbarLayout = new QHBoxLayout;
     tabbarLayout->setSpacing(0);
     tabbarLayout->setContentsMargins(0, 0, 0, 0);
 
     tabbarLayout->addWidget(_tabbar);
     tabbarLayout->addWidget(_newTab);
 
     _layout->addWidget(_stack, 0, 0);
     _layout->addLayout(tabbarLayout, 1, 0);
 
     updateTabbarPos();
 
     setLayout(_layout);
 
     addPanel(true);
 
     tabsCountChanged();
 }
 
 void PanelManager::tabsCountChanged()
 {
     const KConfigGroup cfg(krConfig, "Look&Feel");
     const bool showTabbar = _tabbar->count() > 1 || cfg.readEntry("Show Tab Bar On Single Tab", true);
     const bool showButtons = showTabbar && cfg.readEntry("Show Tab Buttons", true);
 
     _tabbar->setVisible(showTabbar);
     _newTab->setVisible(showButtons);
 
     // disable close button if only 1 tab is left
     _tabbar->setTabsClosable(showButtons && _tabbar->count() > 1);
 
     _actions->refreshActions();
 }
 
 void PanelManager::activate()
 {
     assert(sender() == (currentPanel()->gui));
     emit setActiveManager(this);
     _actions->refreshActions();
 }
 
 void PanelManager::slotCurrentTabChanged(int index)
 {
     ListPanel *panel = _tabbar->getPanel(index);
 
     if (!panel || panel == _currentPanel)
         return;
 
     ListPanel *previousPanel = _currentPanel;
     _currentPanel = panel;
 
     _stack->setCurrentWidget(_currentPanel);
 
     if (previousPanel) {
         previousPanel->slotFocusOnMe(false); // FIXME - necessary ?
     }
     _currentPanel->slotFocusOnMe(this == ACTIVE_MNG);
 
     emit pathChanged(panel);
 
     if (otherManager()) {
         otherManager()->currentPanel()->otherPanelChanged();
     }
 
     // go back to pinned url if tab is pinned and switched back to active
     if (panel->isPinned()) {
         panel->func->openUrl(panel->pinnedUrl());
     }
 }
 
 ListPanel* PanelManager::createPanel(KConfigGroup cfg)
 {
     ListPanel * p = new ListPanel(_stack, this, cfg);
     connectPanel(p);
     return p;
 }
 
 void PanelManager::connectPanel(ListPanel *p)
 {
     connect(p, &ListPanel::activate, this, &PanelManager::activate);
     connect(p, &ListPanel::pathChanged, this, [=]() { pathChanged(p); });
     connect(p, &ListPanel::pathChanged, this, [=]() { _tabbar->updateTab(p); });
 }
 
 void PanelManager::disconnectPanel(ListPanel *p)
 {
     disconnect(p, &ListPanel::activate, this, nullptr);
     disconnect(p, &ListPanel::pathChanged, this, nullptr);
 }
 
 ListPanel* PanelManager::addPanel(bool setCurrent, KConfigGroup cfg, KrPanel *nextTo)
 {
     // create the panel and add it into the widgetstack
     ListPanel * p = createPanel(cfg);
     _stack->addWidget(p);
 
     // now, create the corresponding tab
     int index = _tabbar->addPanel(p, setCurrent, nextTo);
     tabsCountChanged();
 
     if (setCurrent)
         slotCurrentTabChanged(index);
 
     return p;
 }
 
 void PanelManager::saveSettings(KConfigGroup config, bool saveHistory)
 {
     config.writeEntry("ActiveTab", activeTab());
 
     KConfigGroup grpTabs(&config, "Tabs");
     foreach(const QString &grpTab, grpTabs.groupList())
         grpTabs.deleteGroup(grpTab);
 
     for(int i = 0; i < _tabbar->count(); i++) {
         ListPanel *panel = _tabbar->getPanel(i);
         KConfigGroup grpTab(&grpTabs, "Tab" + QString::number(i));
         panel->saveSettings(grpTab, saveHistory);
     }
 }
 
 void PanelManager::loadSettings(KConfigGroup config)
 {
     KConfigGroup grpTabs(&config, "Tabs");
     int numTabsOld = _tabbar->count();
     int numTabsNew = grpTabs.groupList().count();
 
     for(int i = 0;  i < numTabsNew; i++) {
         KConfigGroup grpTab(&grpTabs, "Tab" + QString::number(i));
         // TODO workaround for bug 371453. Remove this when bug is fixed
         if (grpTab.keyList().isEmpty())
             continue;
 
         ListPanel *panel = i < numTabsOld ? _tabbar->getPanel(i) : addPanel(false, grpTab);
         panel->restoreSettings(grpTab);
         _tabbar->updateTab(panel);
     }
 
     for(int i = numTabsOld - 1; i >= numTabsNew && i > 0; i--)
         slotCloseTab(i);
 
     setActiveTab(config.readEntry("ActiveTab", 0));
 
     // this is needed so that all tab labels get updated
     layoutTabs();
 }
 
 void PanelManager::layoutTabs()
 {
     // delayed url refreshes may be pending -
     // delay the layout too so it happens after them
     QTimer::singleShot(0, _tabbar, SLOT(layoutTabs()));
 }
 
 KrPanel *PanelManager::currentPanel() const {
     return _currentPanel;
 }
 
 void PanelManager::moveTabToOtherSide()
 {
     if (tabCount() < 2)
         return;
 
     ListPanel *p;
     _tabbar->removeCurrentPanel(p);
     _stack->removeWidget(p);
     disconnectPanel(p);
 
     p->reparent(_otherManager->_stack, _otherManager);
     _otherManager->connectPanel(p);
     _otherManager->_stack->addWidget(p);
     _otherManager->_tabbar->addPanel(p, true);
 
     _otherManager->tabsCountChanged();
     tabsCountChanged();
 
     p->slotFocusOnMe();
 }
 
 void PanelManager::slotNewTab(const QUrl &url, bool setCurrent, KrPanel *nextTo)
 {
     ListPanel *p = addPanel(setCurrent, KConfigGroup(), nextTo);
     if(nextTo && nextTo->gui) {
         // We duplicate tab settings by writing original settings to a temporary
         // group and making the new tab read settings from it. Duplicating
         // settings directly would add too much complexity.
         QString grpName = "PanelManager_" + QString::number(qApp->applicationPid());
         krConfig->deleteGroup(grpName); // make sure the group is empty
         KConfigGroup cfg(krConfig, grpName);
 
         nextTo->gui->saveSettings(cfg, true);
         // reset undesired duplicated settings
         cfg.writeEntry("Properties", 0);
         p->restoreSettings(cfg);
         krConfig->deleteGroup(grpName);
     }
     p->start(url);
 }
 
 void PanelManager::slotNewTab()
 {
     slotNewTab(QUrl::fromLocalFile(QDir::home().absolutePath()));
     _currentPanel->slotFocusOnMe();
 }
 
 void PanelManager::slotCloseTab()
 {
     slotCloseTab(_tabbar->currentIndex());
 }
 
 void PanelManager::slotCloseTab(int index)
 {
     if (_tabbar->count() <= 1)    /* if this is the last tab don't close it */
         return;
 
     ListPanel *oldp;
 
     _tabbar->removePanel(index, oldp); //this automatically changes the current panel
 
     _stack->removeWidget(oldp);
     deletePanel(oldp);
     tabsCountChanged();
 }
 
 void PanelManager::updateTabbarPos()
 {
     KConfigGroup group(krConfig, "Look&Feel");
     if(group.readEntry("Tab Bar Position", "bottom") == "top") {
         _layout->addWidget(_stack, 2, 0);
         _tabbar->setShape(QTabBar::RoundedNorth);
     } else {
         _layout->addWidget(_stack, 0, 0);
         _tabbar->setShape(QTabBar::RoundedSouth);
     }
 }
 
 int PanelManager::activeTab()
 {
     return _tabbar->currentIndex();
 }
 
 void PanelManager::setActiveTab(int index)
 {
     _tabbar->setCurrentIndex(index);
 }
 
 void PanelManager::slotRecreatePanels()
 {
     updateTabbarPos();
 
     for (int i = 0; i != _tabbar->count(); i++) {
         QString grpName = "PanelManager_" + QString::number(qApp->applicationPid());
         krConfig->deleteGroup(grpName); // make sure the group is empty
         KConfigGroup cfg(krConfig, grpName);
 
         ListPanel *oldPanel = _tabbar->getPanel(i);
         oldPanel->saveSettings(cfg, true);
         disconnect(oldPanel);
 
         ListPanel *newPanel = createPanel(cfg);
         _stack->insertWidget(i, newPanel);
         _tabbar->changePanel(i, newPanel);
 
         if (_currentPanel == oldPanel) {
             _currentPanel = newPanel;
             _stack->setCurrentWidget(_currentPanel);
         }
 
         _stack->removeWidget(oldPanel);
         deletePanel(oldPanel);
 
         newPanel->restoreSettings(cfg);
 
         _tabbar->updateTab(newPanel);
 
         krConfig->deleteGroup(grpName);
     }
     tabsCountChanged();
     _currentPanel->slotFocusOnMe(this == ACTIVE_MNG);
     emit pathChanged(_currentPanel);
 }
 
 void PanelManager::slotNextTab()
 {
     int currTab = _tabbar->currentIndex();
     int nextInd = (currTab == _tabbar->count() - 1 ? 0 : currTab + 1);
     _tabbar->setCurrentIndex(nextInd);
 }
 
 
 void PanelManager::slotPreviousTab()
 {
     int currTab = _tabbar->currentIndex();
     int nextInd = (currTab == 0 ? _tabbar->count() - 1 : currTab - 1);
     _tabbar->setCurrentIndex(nextInd);
 }
 
 void PanelManager::reloadConfig()
 {
     for (int i = 0; i < _tabbar->count(); i++) {
         ListPanel *panel = _tabbar->getPanel(i);
         if (panel) {
             panel->func->refresh();
         }
     }
 }
 
 void PanelManager::deletePanel(ListPanel * p)
 {
     disconnect(p);
     delete p;
 }
 
 void PanelManager::slotCloseInactiveTabs()
 {
     int i = 0;
     while (i < _tabbar->count()) {
         if (i == activeTab())
             i++;
         else
             slotCloseTab(i);
     }
 }
 
 void PanelManager::slotCloseDuplicatedTabs()
 {
     int i = 0;
     while (i < _tabbar->count() - 1) {
         ListPanel * panel1 = _tabbar->getPanel(i);
         if (panel1 != 0) {
             for (int j = i + 1; j < _tabbar->count(); j++) {
                 ListPanel * panel2 = _tabbar->getPanel(j);
                 if (panel2 != 0 && panel1->virtualPath().matches(panel2->virtualPath(), QUrl::StripTrailingSlash)) {
                     if (j == activeTab()) {
                         slotCloseTab(i);
                         i--;
                         break;
                     } else {
                         slotCloseTab(j);
                         j--;
                     }
                 }
             }
         }
         i++;
     }
 }
 
 int PanelManager::findTab(QUrl url)
 {
     url.setPath(QDir::cleanPath(url.path()));
     for(int i = 0; i < _tabbar->count(); i++) {
         if(_tabbar->getPanel(i)) {
             QUrl panelUrl = _tabbar->getPanel(i)->virtualPath();
             panelUrl.setPath(QDir::cleanPath(panelUrl.path()));
             if(panelUrl.matches(url, QUrl::StripTrailingSlash))
                 return i;
         }
     }
     return -1;
 }
 
 void PanelManager::slotLockTab()
 {
     ListPanel *panel = _currentPanel;
     panel->gui->setTabState(panel->gui->isLocked() ? ListPanel::TabState::DEFAULT : ListPanel::TabState::LOCKED);
     _actions->refreshActions();
     _tabbar->updateTab(panel);
 }
 
 void PanelManager::slotPinTab()
 {
     ListPanel *panel = _currentPanel;
     panel->gui->setTabState(panel->gui->isPinned() ? ListPanel::TabState::DEFAULT : ListPanel::TabState::PINNED);
     if (panel->gui->isPinned()) {
         QUrl virtualPath = panel->virtualPath();
         panel->setPinnedUrl(virtualPath);
     }
     _actions->refreshActions();
     _tabbar->updateTab(panel);
 }
 
 void PanelManager::newTabs(const QStringList& urls) {
     for(int i = 0; i < urls.count(); i++)
         slotNewTab(QUrl::fromUserInput(urls[i], QString(), QUrl::AssumeLocalFile));
 }