diff --git a/src/cursorthemesmodel.cpp b/src/cursorthemesmodel.cpp
index c1ba1f2..926a666 100644
--- a/src/cursorthemesmodel.cpp
+++ b/src/cursorthemesmodel.cpp
@@ -1,89 +1,87 @@
 /* KDE GTK Configuration Module
  * 
  * Copyright 2016 Jason A. Donenfeld <Jason@zx2c4.com>
  * Copyright 2016 Andrey Bondrov <andrey.bondrov@rosalab.ru>
  * Copyright 2011 Aleix Pol Gonzalez <aleixpol@blue-systems.com>
  *
  * 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  * 
  * 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 "cursorthemesmodel.h"
 #include <QDir>
 #include <QDirIterator>
 #include <QSet>
 #include <QStandardPaths>
 #include <KIconTheme>
 #include <KShell>
 
 #include <X11/Xcursor/Xcursor.h>
 
 CursorThemesModel::CursorThemesModel(QObject* parent)
     : IconThemesModel(parent)
 {
     reload();
 }
 
 QList<QDir> CursorThemesModel::installedThemesPaths()
 {
     QList<QDir> availableIcons;
     QStringList dirs(QString(XcursorLibraryPath()).split(':', QString::SkipEmptyParts));
 
     std::transform(dirs.begin(), dirs.end(), dirs.begin(), KShell::tildeExpand);
     dirs.removeDuplicates();
 
     foreach(const QString& dir, dirs) {
         QDir userIconsDir(dir);
         QDirIterator it(userIconsDir.path(), QDir::NoDotAndDotDot|QDir::AllDirs|QDir::NoSymLinks);
         while(it.hasNext()) {
             QString currentPath = it.next();
             QDir dir(currentPath);
 
             if(dir.exists() && dir.exists("cursors"))
                 availableIcons << dir;
         }
     }
     return availableIcons;
 }
 
 void CursorThemesModel::fillItem(const QDir& dir, QStandardItem* item)
 {
     KIconTheme theme(dir.dirName());
     if(!theme.name().isEmpty())
         item->setText(theme.name());
     else
         item->setText(dir.dirName());
     item->setToolTip(theme.description());
     item->setData(theme.inherits(), CursorThemesModel::InheritsRole);
 }
 
 
 
 void CursorThemesModel::reload()
 {
     clear();
     
     QList<QDir> paths = installedThemesPaths();
     Q_FOREACH(const QDir& dir, paths) {
         QStandardItem* themeit = new QStandardItem(dir.dirName());
         themeit->setData(dir.path(), PathRole);
         themeit->setData(dir.dirName(), DirNameRole);
         fillItem(dir, themeit);
         appendRow(themeit);
     }
-
-    sort(0);
 }
diff --git a/src/gtkconfigkcmodule.cpp b/src/gtkconfigkcmodule.cpp
index d364a6a..7b82d50 100644
--- a/src/gtkconfigkcmodule.cpp
+++ b/src/gtkconfigkcmodule.cpp
@@ -1,525 +1,538 @@
 /* KDE GTK Configuration Module
  * 
  * Copyright 2011 José Antonio Sanchez Reynaga <joanzare@gmail.com>
  * Copyright 2011 Aleix Pol Gonzalez <aleixpol@blue-systems.com>
  *
  * 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  * 
  * 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 "gtkconfigkcmodule.h"
 #include <kaboutdata.h>
 #include <KPluginFactory>
 #include <KProcess>
 #include <KMessageBox>
 #include <KIconTheme>
 #include <KLocalizedString>
 #include <QStandardPaths>
 #include <QFile>
 #include <QMenu>
 #include <QDebug>
 #include <QDir>
 #include <config.h>
 #include "ui_gui.h"
 #include "abstractappearance.h"
 #include "iconthemesmodel.h"
 #include "fontshelpers.h"
+#include <QSortFilterProxyModel>
 #include <qstringlistmodel.h>
 
 K_PLUGIN_FACTORY_WITH_JSON(GTKConfigKCModuleFactory, "kde-gtk-config.json", registerPlugin<GTKConfigKCModule>();)
 
 QMap<QString, int> gtkToolbarInit()
 {
     QMap<QString, int> gtkToolbar;
     gtkToolbar["GTK_TOOLBAR_ICONS"] = 0;
     gtkToolbar["GTK_TOOLBAR_TEXT"] = 1;
     gtkToolbar["GTK_TOOLBAR_BOTH"] = 2;
     gtkToolbar["GTK_TOOLBAR_BOTH_HORIZ"] = 3;
     return gtkToolbar;
 }
 
 static QMap<QString, int> gtkToolbar = gtkToolbarInit();
 
 GTKConfigKCModule::GTKConfigKCModule(QWidget* parent, const QVariantList& args )
     : KCModule(parent)
     , ui(new Ui::GUI)
     , installer(0)
     , uninstaller(0)
     , m_saveEnabled(true)
 {
     Q_UNUSED(args);
     KAboutData *acercade = new KAboutData("cgc", i18n("KDE GTK Config"), PROJECT_VERSION,
                     i18n("Configure your GTK Applications"),
                     KAboutLicense::LGPL_V3,
                     i18n("Copyright 2011 José Antonio Sánchez Reynaga"));
     acercade->addAuthor(i18n("José Antonio Sánchez Reynaga (antonioJASR)"),i18n("Main Developer"), "joanzare@gmail.com");
     acercade->addAuthor(i18n("Aleix Pol i Gonzalez"), i18n("Feature development. Previews, code refactoring."), "aleixpol@blue-systems.com");
     acercade->addCredit(i18n("Manuel Tortosa (manutortosa)"), i18n("Ideas, tester, internationalization"));
     acercade->addCredit(i18n("Adrián Chaves Fernández (Gallaecio)"), i18n("Internationalization"));
     setAboutData(acercade);
     setButtons(KCModule::Default | KCModule::Apply);
     ui->setupUi(this);
     appareance = new AppearenceGTK;
+
     m_cursorsModel = new CursorThemesModel(this);
-    ui->cb_cursor->setModel(m_cursorsModel);
+    QSortFilterProxyModel *cursorsProxyModel = new QSortFilterProxyModel(this);
+    cursorsProxyModel->setSourceModel(m_cursorsModel);
+    cursorsProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
+    cursorsProxyModel->setSortRole(Qt::DisplayRole);
+    cursorsProxyModel->sort(0);
+    ui->cb_cursor->setModel(cursorsProxyModel);
+
     m_iconsModel = new IconThemesModel(false, this);
-    ui->cb_icon->setModel(m_iconsModel);
-    ui->cb_icon_fallback->setModel(m_iconsModel);
+    QSortFilterProxyModel *iconsProxyModel = new QSortFilterProxyModel(this);
+    iconsProxyModel->setSourceModel(m_iconsModel);
+    iconsProxyModel->setSortCaseSensitivity(Qt::CaseInsensitive);
+    iconsProxyModel->setSortRole(Qt::DisplayRole);
+    iconsProxyModel->sort(0);
+    ui->cb_icon->setModel(iconsProxyModel);
+    ui->cb_icon_fallback->setModel(iconsProxyModel);
     
     m_tempGtk2Preview = QStandardPaths::writableLocation(QStandardPaths::TempLocation)+ "/gtkrc-2.0";
     m_tempGtk3Preview = QStandardPaths::writableLocation(QStandardPaths::TempLocation)+ "/.config/gtk-3.0/settings.ini";
     
     const QIcon previewIcon = QIcon::fromTheme("document-preview");
     ui->gtk2Preview->setIcon(previewIcon);
     ui->gtk3Preview->setIcon(previewIcon);
     
     QString gtk2Preview = QStandardPaths::findExecutable("gtk_preview",  {CMAKE_INSTALL_FULL_LIBEXECDIR});
     QString gtk3Preview = QStandardPaths::findExecutable("gtk3_preview", {CMAKE_INSTALL_FULL_LIBEXECDIR});
     
     m_p2 = new KProcess(this);
     m_p2->setEnv("GTK2_RC_FILES", m_tempGtk2Preview, true);
     if(!gtk2Preview.isEmpty()) {
         *m_p2 << gtk2Preview;
         connect(m_p2, SIGNAL(finished(int)), this, SLOT(untogglePreview()));
     }
     
     m_p3 = new KProcess(this);
     m_p3->setEnv("XDG_CONFIG_HOME", QStandardPaths::writableLocation(QStandardPaths::TempLocation)+"/.config");
     if(!gtk3Preview.isEmpty()) {
         *m_p3 << gtk3Preview;
         connect(m_p3, SIGNAL(finished(int)), this, SLOT(untogglePreview()));
     }
     
     ui->gtk2Preview->setVisible(!gtk2Preview.isEmpty());
     ui->gtk3Preview->setVisible(!gtk3Preview.isEmpty());
     
     //UI changes
     connect(ui->cb_theme, SIGNAL(currentIndexChanged(int)), this, SLOT(appChanged()));
     connect(ui->cb_theme_gtk3, SIGNAL(currentIndexChanged(int)), this, SLOT(appChanged()));
     connect(ui->checkBox_theme_gtk3_prefer_dark, &QAbstractButton::clicked, this, &GTKConfigKCModule::appChanged);
     connect(ui->cb_cursor, SIGNAL(currentIndexChanged(int)), this, SLOT(appChanged()));
     connect(ui->cb_icon, SIGNAL(currentIndexChanged(int)), this, SLOT(appChanged()));
     connect(ui->cb_icon_fallback ,SIGNAL(currentIndexChanged(int)), this, SLOT(appChanged()));
     connect(ui->font, &KFontRequester::fontSelected, this, &GTKConfigKCModule::appChanged);
     connect(ui->cb_toolbar_icons, SIGNAL(currentIndexChanged(int)), this, SLOT(appChanged()));
     connect(ui->checkBox_icon_gtk_menus, &QAbstractButton::clicked, this, &GTKConfigKCModule::appChanged);
     connect(ui->checkBox_icon_gtk_buttons, &QAbstractButton::clicked, this, &GTKConfigKCModule::appChanged);
     connect(ui->buttonGroup_primary_button_warps_slider, SIGNAL(buttonToggled(QAbstractButton*, bool)), this, SLOT(appChanged()));
 
     //preview updates
     connect(ui->cb_icon_fallback, SIGNAL(activated(QString)), this, SLOT(makePreviewIconTheme()));
     connect(ui->cb_icon, SIGNAL(activated(QString)), this, SLOT(makePreviewIconTheme()));
     connect(ui->gtk2Preview, &QAbstractButton::clicked, this, &GTKConfigKCModule::runGtk2IfNecessary);
     connect(ui->gtk3Preview, &QAbstractButton::clicked, this, &GTKConfigKCModule::runGtk3IfNecessary);
     
     QMenu* m = new QMenu(this);
     m->addAction(QIcon::fromTheme("get-hot-new-stuff"), i18n("Download GTK2 themes..."), this, SLOT(showThemeGHNS()));
     m->addAction(QIcon::fromTheme("get-hot-new-stuff"), i18n("Download GTK3 themes..."), this, SLOT(installThemeGTK3GHNS()));
     m->addAction(QIcon::fromTheme("archive-insert"), i18n("Install a local theme..."), this, SLOT(showDialogForInstall()));
     m->addAction(QIcon::fromTheme("archive-remove"), i18n("Uninstall a local theme..."), this, SLOT(showDialogForUninstall()));
     ui->newThemes->setMenu(m);
     ui->newThemes->setIcon(QIcon::fromTheme("get-hot-new-stuff"));
 }
 
 GTKConfigKCModule::~GTKConfigKCModule()
 {
     m_p2->kill();
     m_p3->kill();
     
     QFile::remove(m_tempGtk2Preview);
     QFile::remove(m_tempGtk3Preview);
     delete appareance;
     
     m_p2->waitForFinished();
     m_p3->waitForFinished();
     delete ui;
 }
 
 void GTKConfigKCModule::syncUI()
 {
     appareance->setThemeGtk3(ui->cb_theme_gtk3->currentText());
     appareance->setTheme(ui->cb_theme->currentText());
     appareance->setApplicationPreferDarkTheme(ui->checkBox_theme_gtk3_prefer_dark->isChecked());
     appareance->setCursor(ui->cb_cursor->itemData(ui->cb_cursor->currentIndex(), CursorThemesModel::DirNameRole).toString());
     appareance->setIcon(ui->cb_icon->itemData(ui->cb_icon->currentIndex(), IconThemesModel::DirNameRole).toString());
     appareance->setIconFallback(ui->cb_icon_fallback->itemData(ui->cb_icon_fallback->currentIndex(), IconThemesModel::DirNameRole).toString());
     appareance->setFont(fontToString(ui->font->font()));
 
     appareance->setToolbarStyle(gtkToolbar.key(ui->cb_toolbar_icons->currentIndex()));
     appareance->setShowIconsInButtons(ui->checkBox_icon_gtk_buttons->isChecked());
     appareance->setShowIconsInMenus(ui->checkBox_icon_gtk_menus->isChecked());
     appareance->setPrimaryButtonWarpsSlider(ui->buttonGroup_primary_button_warps_slider->checkedButton() == ui->radioButton_warp);
 }
 
 void GTKConfigKCModule::showThemeGHNS()
 {
      KNS3::DownloadDialog d("cgctheme.knsrc", this);
      if(d.exec()) {
           refreshLists();
      }
 }
 
 void GTKConfigKCModule::installThemeGTK3GHNS()
 {
      KNS3::DownloadDialog d("cgcgtk3.knsrc", this);
      if(d.exec()) {
           refreshLists();
      }
 }
 
 void GTKConfigKCModule::refreshLists()
 {
     refreshThemesUi(true);
 
     const auto newFont = stringToFont(appareance->getFont());
     if (newFont != ui->font->font())
         ui->font->setFont(newFont);
     
     ui->cb_toolbar_icons->setCurrentIndex(gtkToolbar[appareance->getToolbarStyle()]);
     
     ui->checkBox_icon_gtk_buttons->setChecked(appareance->getShowIconsInButtons());
     ui->checkBox_icon_gtk_menus->setChecked(appareance->getShowIconsInMenus());
     const bool warps = appareance->getPrimaryButtonWarpsSlider();
     ui->radioButton_warp->setChecked(warps);
     ui->radioButton_dont_warp->setChecked(!warps);
 
     makePreviewIconTheme();
 }
 
 void tryIcon(QLabel* label, const QString& fallback, const QString& theme, const QString& iconName)
 {
     label->setToolTip(iconName);
     
     QString ret;
     if(!theme.isEmpty())
         ret = IconThemesModel::findIconRecursivelyByName(iconName, QDir(theme));
     
     if(!ret.isEmpty()) {
         QPixmap p(ret);
         Q_ASSERT(!p.isNull());
         label->setPixmap(p);
         return;
     }
     
     if(!fallback.isEmpty())
         ret = IconThemesModel::findIconRecursivelyByName(iconName, fallback);
     
     if(!ret.isEmpty()) {
         QPixmap p(ret);
         Q_ASSERT(!p.isNull());
         label->setPixmap(p);
         return;
     }
     
     QIcon notFoundIcon = QIcon::fromTheme("application-x-zerosize");
     QPixmap noIcon(notFoundIcon.pixmap(48,48));
     label->setPixmap(noIcon);
     
     qWarning() << "could not find icon" << iconName;
 }
 
 void GTKConfigKCModule::makePreviewIconTheme()
 {
     int icon_fallback = ui->cb_icon_fallback->currentIndex();
     QString path_fallback = ui->cb_icon->itemData(icon_fallback, IconThemesModel::PathRole).toString();
     
     int icon = ui->cb_icon->currentIndex();
     QString path_icon = ui->cb_icon->itemData(icon, IconThemesModel::PathRole).toString();
     
     tryIcon(ui->lb_prev_1, path_fallback, path_icon, "user-home");
     tryIcon(ui->lb_prev_2, path_fallback, path_icon, "folder");
     tryIcon(ui->lb_prev_3, path_fallback, path_icon, "user-trash");
     tryIcon(ui->lb_prev_4, path_fallback, path_icon, "document-print");
     tryIcon(ui->lb_prev_5, path_fallback, path_icon, "user-desktop");
     tryIcon(ui->lb_prev_6, path_fallback, path_icon, "network-server");
     tryIcon(ui->lb_prev_7, path_fallback, path_icon, "system-help");
     tryIcon(ui->lb_prev_8, path_fallback, path_icon, "start-here");
     tryIcon(ui->lb_prev_9, path_fallback, path_icon, "go-up");
 }
 
 void GTKConfigKCModule::appChanged()
 {
     if (m_loading)
         return;
 
     savePreviewConfig();
     emit changed(true);
 }
 
 
 void GTKConfigKCModule::savePreviewConfig()
 {
     if(!m_saveEnabled || !(ui->gtk2Preview->isChecked() || ui->gtk3Preview->isChecked()))
         return;
 //     qDebug() << "saving UI...";
     
     syncUI();
     
     if(ui->gtk3Preview->isChecked()) {
         //we don't want to recursively loop between savePreviewConfig and runIfNecessary
         m_saveEnabled = false;
         m_p3->kill();
         appareance->gtk3Appearance()->saveSettings(m_tempGtk3Preview);
         
         //need to make sure runIfNecessary() to know that it's not running
         m_p3->waitForFinished();
         
         m_p3->start();
         ui->gtk3Preview->setChecked(true);
         m_saveEnabled = true;
     } else if(ui->gtk2Preview->isChecked()) {
         appareance->gtk2Appearance()->saveSettings(m_tempGtk2Preview);
     }
 }
 
 void GTKConfigKCModule::runGtk2IfNecessary(bool checked)
 {
     KProcess* p = m_p2;
     KProcess* np = m_p3;
     
     if(checked) {
         np->kill();
         np->waitForFinished();
         savePreviewConfig();
         if(p->state() == QProcess::NotRunning)
             p->start();
     } else {
         p->kill();
         p->waitForFinished();
     }
 }
 
 void GTKConfigKCModule::runGtk3IfNecessary(bool checked)
 {
     KProcess* p = m_p3;
     KProcess* np = m_p2;
     
     if(checked) {
         np->kill();
         np->waitForFinished();
         savePreviewConfig();
         if(p->state() == QProcess::NotRunning)
             p->start();
     } else {
         p->kill();
         p->waitForFinished();
     }
 }
 
 void GTKConfigKCModule::save()
 {
 /*    qDebug() << "******************************************* INSTALLATION :\n"
             << "theme : " << appareance->getTheme() << "\n"
             << "themeGTK3 : " << appareance->getThemeGtk3() << "\n"
             << "icons : " << appareance->getIcon() << "\n"
             << "fallback icons : " << appareance->getIconFallback() << "\n"
             << "cursors : " << appareance->getCursor() << "\n"
             << "font family : " << appareance->getFont() << "\n"
             << "toolbar style : " << appareance->getToolbarStyle() << "\n"
             << "icons in buttons : " << appareance->getShowIconsInButtons() << "\n"
             << "icons in menus : " << appareance->getShowIconsInMenus() << "\n"
             << "********************************************************";
     */
     syncUI();
     if(!appareance->saveFileConfig())
         KMessageBox::error(this, i18n("Failed to save configuration."));
 }
 
 void setComboItem(QComboBox* combo, const QStringList& texts)
 {
     foreach(const QString& text, texts) {
         int pos = combo->findText(text);
         if(pos>=0) {
             combo->setCurrentIndex(pos);
             return;
         }
     }
 }
 
 void GTKConfigKCModule::defaults()
 {
     refreshThemesUi(false);
 
 //     qDebug() << "loading defaults...";
     m_saveEnabled = false;
     ui->font->setFont(font());
     bool showIcons = !QCoreApplication::testAttribute(Qt::AA_DontShowIconsInMenus);
     ui->checkBox_icon_gtk_buttons->setChecked(showIcons);
     ui->checkBox_icon_gtk_menus->setChecked(showIcons);
 
     // this makes it consistent with Qt apps and restores the old Gtk behavior
     ui->radioButton_dont_warp->setChecked(true);
     
     setComboItem(ui->cb_theme, QStringList("oxygen-gtk") << "Clearlooks");
     setComboItem(ui->cb_theme_gtk3, QStringList("oxygen-gtk") << "Adwaita");
     
     QStringList icons;
     icons << KIconLoader::global()->theme()->name() << "GNOME";
     setComboItem(ui->cb_icon, icons);
     
     int idx = ui->cb_icon->currentIndex();
     if(idx>=0) {
         setComboItem(ui->cb_icon_fallback, icons.mid(icons.indexOf(ui->cb_icon->currentText())+1));
     }
     m_saveEnabled = true;
     
     makePreviewIconTheme();
     appChanged();
 }
 
 void GTKConfigKCModule::load()
 {
     m_saveEnabled = false;
     bool someCorrect = appareance->loadFileConfig();
     m_loading = true;
     if(someCorrect) {
         refreshLists();
     } else {
         defaults();
     }
     m_loading = false;
     
     m_saveEnabled = true;
 }
 
 class MyStringListModel : public QAbstractListModel
 {
 public:
     MyStringListModel(const QStringList &texts, QObject* parent) : QAbstractListModel(parent), m_texts(texts)
     {
     }
 
     QVariant data(const QModelIndex & index, int role) const override
     {
         if (role != Qt::DisplayRole || !index.isValid() || index.row()>=m_texts.count())
             return {};
 
         return m_texts[index.row()];
     }
 
     int rowCount(const QModelIndex & parent) const override { return parent.isValid() ? 0 : m_texts.count(); }
 
     void setStrings(const QSet<QString> &list) {
         const auto current = m_texts.toSet();
 
         const auto oldRows = QSet<QString>(current).subtract(list);
         const auto newRows = QSet<QString>(list).subtract(current);
         if (!newRows.isEmpty()) {
             beginInsertRows({}, m_texts.count(), m_texts.count() + newRows.count());
             m_texts += newRows.toList();
             endInsertRows();
         }
 
         int from = -1;
         for(const auto &row: oldRows) {
             for(; from<m_texts.count();) {
                 const auto idx = m_texts.indexOf(row, from);
                 if (idx<0)
                     break;
                 beginRemoveRows({}, idx, idx);
                 m_texts.removeAt(idx);
                 endRemoveRows();
                 from = idx + 1;
             }
         }
     }
 
 private:
     QStringList m_texts;
 };
 
 void refreshComboSameCurrentValue(QComboBox* combo, const QString& temp, const QStringList& texts)
 {
     const auto model = dynamic_cast<MyStringListModel*>(combo->model());
     if (!model) {
         combo->setModel(new MyStringListModel(texts, combo));
     } else {
         model->setStrings(texts.toSet());
     }
 
     const int idx = combo->findText(temp);
     combo->setCurrentIndex(qMax(0, idx));
 }
 
 void GTKConfigKCModule::refreshThemesUi(bool useConfig)
 {
     //theme gtk2
     bool wasenabled = m_saveEnabled;
     m_saveEnabled = false;
     
     refreshComboSameCurrentValue(ui->cb_theme,
         useConfig ? appareance->getTheme() : ui->cb_theme->currentText(),
         appareance->gtk2Appearance()->installedThemesNames());
     
     //theme gtk3
     refreshComboSameCurrentValue(ui->cb_theme_gtk3,
         useConfig ? appareance->getThemeGtk3() : ui->cb_theme_gtk3->currentText(),
         appareance->gtk3Appearance()->installedThemesNames());
 
     // dark theme for gtk3
     ui->checkBox_theme_gtk3_prefer_dark->setChecked(appareance->getApplicationPreferDarkTheme());
 
     //cursors
     QString currentCursor = useConfig ? appareance->getCursor() : ui->cb_cursor->currentText();
     int currentCursorIdx = ui->cb_cursor->findData(currentCursor, CursorThemesModel::DirNameRole);
     ui->cb_cursor->setCurrentIndex(qMax(currentCursorIdx, 0));
     
     //icons
     QString currentIcon = useConfig ? appareance->getIcon() : ui->cb_icon->currentText(),
             currentFallback = useConfig ? appareance->getIconFallback() : ui->cb_icon_fallback->currentText();
     int currentIconIdx = ui->cb_icon->findData(currentIcon, IconThemesModel::DirNameRole);
     int currentFallbackIdx = ui->cb_icon_fallback->findData(currentFallback, IconThemesModel::DirNameRole);
     ui->cb_icon->setCurrentIndex(qMax(currentIconIdx, 0));
     ui->cb_icon_fallback->setCurrentIndex(qMax(currentFallbackIdx, 0));
     
     m_saveEnabled = wasenabled;
     if(currentCursorIdx<0 || currentIconIdx<0 || currentFallbackIdx<0)
         emit changed(true);
 }
 
 void GTKConfigKCModule::showDialogForInstall()
 {
     if(!installer) {
         installer =  new DialogInstaller(this);
         connect(installer, &DialogInstaller::themeInstalled, this, &GTKConfigKCModule::refreshLists);
     }
     
     installer->exec();
     refreshThemesUi();
 }
 
 void GTKConfigKCModule::showDialogForUninstall()
 {
     if(!uninstaller) {
         uninstaller = new DialogUninstaller(this, appareance);
         connect(uninstaller, &DialogUninstaller::themeUninstalled, this, &GTKConfigKCModule::refreshLists);
     }
     
     uninstaller->refreshListsForUninstall();
     uninstaller->exec();
     
     refreshThemesUi();
 }
 
 void GTKConfigKCModule::untogglePreview()
 {
     if(sender()==m_p2)
         ui->gtk2Preview->setChecked(false);
     else
         ui->gtk3Preview->setChecked(false);
 }
 
 #include "gtkconfigkcmodule.moc"
diff --git a/src/iconthemesmodel.cpp b/src/iconthemesmodel.cpp
index f642ecc..a880d40 100644
--- a/src/iconthemesmodel.cpp
+++ b/src/iconthemesmodel.cpp
@@ -1,133 +1,131 @@
 /* KDE GTK Configuration Module
  *
  * Copyright 2011 José Antonio Sanchez Reynaga <joanzare@gmail.com>
  * Copyright 2011 Aleix Pol Gonzalez <aleixpol@blue-systems.com>
  *
  * 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) version 3, or any
  * later version accepted by the membership of KDE e.V. (or its
  * successor approved by the membership of KDE e.V.), which shall
  * act as a proxy defined in Section 6 of version 3 of the license.
  *
  * 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 "iconthemesmodel.h"
 #include <QDir>
 #include <QDirIterator>
 #include <QDebug>
 #include <QSet>
 #include <KIconTheme>
 #include <QStandardPaths>
 
 IconThemesModel::IconThemesModel(bool onlyHome, QObject* parent)
     : QStandardItemModel(parent)
     , m_onlyHome(onlyHome)
 {
-    setSortRole(Qt::DisplayRole);
     reload();
 }
 
 QList<QDir> IconThemesModel::installedThemesPaths()
 {
     QList<QDir> availableIcons;
 
     QSet<QString> dirs;
     dirs += QDir::home().filePath(".icons");
     if(!m_onlyHome) {
         dirs += QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, "icons", QStandardPaths::LocateDirectory).toSet();
     }
 
     foreach(const QString& dir, dirs) {
         QDir userIconsDir(dir);
         QDirIterator it(userIconsDir.path(), QDir::NoDotAndDotDot|QDir::AllDirs|QDir::NoSymLinks);
         while(it.hasNext()) {
             QString currentPath = it.next();
             QDir dir(currentPath);
 
             if(dir.exists() && dir.exists("index.theme")) {
                 availableIcons << dir;
             }
         }
     }
 
     return availableIcons;
 }
 
 bool greatSizeIs48(const QString& a, const QString& b)
 {
     bool a48=a.contains("48"), b48=b.contains("48");
     if((a48 && b48) || (!a48 && !b48))
         return a<b;
     else
         return a48;
 }
 
 QString IconThemesModel::findIconRecursivelyByName(const QString& name, const QDir& directory)
 {
     return findFilesRecursively(QStringList() << (name+".png") << (name+".svg") << (name+".svgz"), directory);
 }
 
 QString IconThemesModel::findFilesRecursively(const QStringList& wildcard, const QDir& directory)
 {
     Q_ASSERT(directory.isAbsolute());
     QFileInfoList entries = directory.entryInfoList(wildcard, QDir::Files);
     foreach(const QFileInfo& f, entries) {
         return f.absoluteFilePath();
     }
 
     QStringList subdirs = directory.entryList(QDir::AllDirs|QDir::NoDotAndDotDot);
     qSort(subdirs.begin(), subdirs.end(), greatSizeIs48);
     foreach(const QString& subdir, subdirs) {
         QString ret = findFilesRecursively(wildcard, QDir(directory.filePath(subdir)));
         if(!ret.isEmpty())
             return ret;
     }
 
     return QString();
 }
 
 void IconThemesModel::reload()
 {
     clear();
 
     QSet<QString> done;
     QList<QDir> paths = installedThemesPaths();
     Q_FOREACH(const QDir& dir, paths) {
         KIconTheme theme(dir.dirName());
         if (!theme.isValid()) { //most likely a cursor theme
 //             qWarning() << "invalid theme" << dir.dirName();
             continue;
         }
 
         if (done.contains(dir.dirName()))
             continue;
 
         done << dir.dirName();
 
         QStandardItem* item = new QStandardItem(dir.dirName());
         item->setData(dir.path(), PathRole);
         item->setData(dir.dirName(), DirNameRole);
 
         item->setText(theme.name());
         item->setToolTip(theme.description());
         item->setData(theme.inherits(), IconThemesModel::InheritsRole);
         QString iconName = theme.example();
         if (iconName.isEmpty())
             iconName = QStringLiteral("folder");
 
         QString path = theme.iconPathByName(iconName, 16, KIconLoader::MatchBest);
         item->setIcon(QIcon(path));
 
         appendRow(item);
     }
-    sort(0);
 }