diff --git a/src/lib/opensearch/searchenginesdialog.cpp b/src/lib/opensearch/searchenginesdialog.cpp
index 4613fee9..d4460ccd 100644
--- a/src/lib/opensearch/searchenginesdialog.cpp
+++ b/src/lib/opensearch/searchenginesdialog.cpp
@@ -1,284 +1,284 @@
 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2010-2017 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #include "searchenginesdialog.h"
 #include "ui_searchenginesdialog.h"
 #include "editsearchengine.h"
 #include "mainapplication.h"
 #include "removeitemfocusdelegate.h"
 
 #include <QMessageBox>
 
 SearchEnginesDialog::SearchEnginesDialog(QWidget* parent)
     : QDialog(parent)
     , ui(new Ui::SearchEnginesDialog)
     , m_manager(mApp->searchEnginesManager())
 {
     setAttribute(Qt::WA_DeleteOnClose);
 
     ui->setupUi(this);
 
     connect(ui->add, &QAbstractButton::clicked, this, &SearchEnginesDialog::addEngine);
     connect(ui->remove, &QAbstractButton::clicked, this, &SearchEnginesDialog::removeEngine);
     connect(ui->edit, &QAbstractButton::clicked, this, &SearchEnginesDialog::editEngine);
     connect(ui->setAsDefault, &QAbstractButton::clicked, this, &SearchEnginesDialog::setDefaultEngine);
     connect(ui->defaults, &QAbstractButton::clicked, this, &SearchEnginesDialog::defaults);
     connect(ui->moveUp, &QAbstractButton::clicked, this, &SearchEnginesDialog::moveUp);
     connect(ui->moveDown, &QAbstractButton::clicked, this, &SearchEnginesDialog::moveDown);
 
     connect(ui->treeWidget, &QTreeWidget::itemDoubleClicked, this, &SearchEnginesDialog::editEngine);
 
     ui->treeWidget->setItemDelegate(new RemoveItemFocusDelegate(ui->treeWidget));
-    ui->treeWidget->sortByColumn(-1);
+    ui->treeWidget->sortByColumn(-1, Qt::AscendingOrder);
     reloadEngines();
 }
 
 void SearchEnginesDialog::addEngine()
 {
     EditSearchEngine dialog(tr("Add Search Engine"), this);
     dialog.hideIconLabels();
 
     if (dialog.exec() != QDialog::Accepted) {
         return;
     }
 
     SearchEngine engine;
     engine.name = dialog.name();
     engine.url = dialog.url();
     engine.postData = dialog.postData().toUtf8();
     engine.shortcut = dialog.shortcut();
     engine.icon = SearchEnginesManager::iconForSearchEngine(QUrl::fromEncoded(dialog.url().toUtf8()));
 
     if (engine.name.isEmpty() || engine.url.isEmpty()) {
         return;
     }
 
     QTreeWidgetItem* item = new QTreeWidgetItem();
     setEngine(item, engine);
 
     changeItemToDefault(item, false);
     item->setIcon(0, engine.icon);
     item->setText(1, engine.shortcut);
 
     ui->treeWidget->addTopLevelItem(item);
 }
 
 void SearchEnginesDialog::removeEngine()
 {
     QTreeWidgetItem* item = ui->treeWidget->currentItem();
     if (!item || ui->treeWidget->topLevelItemCount() == 1) {
         return;
     }
 
     if (isDefaultEngine(item)) {
         SearchEngine en = getEngine(item);
         QMessageBox::warning(this, tr("Remove Engine"),
                              tr("You can't remove the default search engine.<br>"
                                 "Set a different engine as default before removing %1.").arg(en.name));
     }
     else {
         delete item;
     }
 }
 
 void SearchEnginesDialog::editEngine()
 {
     QTreeWidgetItem* item = ui->treeWidget->currentItem();
     if (!item) {
         return;
     }
 
     SearchEngine engine = getEngine(item);
 
     EditSearchEngine dialog(tr("Edit Search Engine"), this);
 
     dialog.setName(engine.name);
     dialog.setUrl(engine.url);
     dialog.setPostData(engine.postData);
     dialog.setShortcut(engine.shortcut);
     dialog.setIcon(engine.icon);
 
     if (dialog.exec() != QDialog::Accepted) {
         return;
     }
 
     engine.name = dialog.name();
     engine.url = dialog.url();
     engine.postData = dialog.postData().toUtf8();
     engine.shortcut = dialog.shortcut();
     engine.icon = dialog.icon();
 
     if (engine.name.isEmpty() || engine.url.isEmpty()) {
         return;
     }
 
     setEngine(item, engine);
 
     changeItemToDefault(item, isDefaultEngine(item));
     item->setIcon(0, engine.icon);
     item->setText(1, engine.shortcut);
 }
 
 void SearchEnginesDialog::setDefaultEngine()
 {
     QTreeWidgetItem* item = ui->treeWidget->currentItem();
     if (!item) {
         return;
     }
 
     for (int j = 0; j < ui->treeWidget->topLevelItemCount(); ++j) {
         QTreeWidgetItem* i = ui->treeWidget->topLevelItem(j);
         if (isDefaultEngine(i)) {
             if (i == item) {
                 return;
             }
             changeItemToDefault(i, false);
             break;
         }
     }
 
     changeItemToDefault(item, true);
 }
 
 void SearchEnginesDialog::defaults()
 {
     m_manager->restoreDefaults();
     reloadEngines();
 }
 
 bool SearchEnginesDialog::isDefaultEngine(QTreeWidgetItem* item)
 {
     return item->data(0, DefaultRole).toBool();
 }
 
 SearchEngine SearchEnginesDialog::getEngine(QTreeWidgetItem* item)
 {
     return item->data(0, EngineRole).value<SearchEngine>();
 }
 
 void SearchEnginesDialog::setEngine(QTreeWidgetItem* item, const SearchEngine &engine)
 {
     QVariant v;
     v.setValue<SearchEngine>(engine);
     item->setData(0, EngineRole, v);
     item->setText(0, engine.name);
 }
 
 void SearchEnginesDialog::changeItemToDefault(QTreeWidgetItem* item, bool isDefault)
 {
     QFont font = item->font(0);
     font.setBold(isDefault);
 
     item->setFont(0, font);
     item->setFont(1, font);
     item->setData(0, DefaultRole, isDefault);
 }
 
 void SearchEnginesDialog::moveUp()
 {
     QTreeWidgetItem* currentItem = ui->treeWidget->currentItem();
     int index = ui->treeWidget->indexOfTopLevelItem(currentItem);
 
     if (!currentItem || index == 0) {
         return;
     }
 
     ui->treeWidget->takeTopLevelItem(index);
     ui->treeWidget->insertTopLevelItem(index - 1, currentItem);
     ui->treeWidget->setCurrentItem(currentItem);
 }
 
 void SearchEnginesDialog::moveDown()
 {
     QTreeWidgetItem* currentItem = ui->treeWidget->currentItem();
     int index = ui->treeWidget->indexOfTopLevelItem(currentItem);
 
     if (!currentItem || !ui->treeWidget->itemBelow(currentItem)) {
         return;
     }
 
     ui->treeWidget->takeTopLevelItem(index);
     ui->treeWidget->insertTopLevelItem(index + 1, currentItem);
     ui->treeWidget->setCurrentItem(currentItem);
 }
 
 void SearchEnginesDialog::reloadEngines()
 {
     ui->treeWidget->clear();
     const SearchEngine defaultEngine = mApp->searchEnginesManager()->defaultEngine();
 
     const auto engines = m_manager->allEngines();
     for (const SearchEngine &en : engines) {
         QTreeWidgetItem* item = new QTreeWidgetItem();
         setEngine(item, en);
         changeItemToDefault(item, en == defaultEngine);
         item->setIcon(0, en.icon);
         item->setText(1, en.shortcut);
 
         ui->treeWidget->addTopLevelItem(item);
     }
 }
 
 void SearchEnginesDialog::showEvent(QShowEvent *e)
 {
     QDialog::showEvent(e);
     resizeViewHeader();
 }
 
 void SearchEnginesDialog::resizeEvent(QResizeEvent *e)
 {
     QDialog::resizeEvent(e);
     resizeViewHeader();
 }
 
 void SearchEnginesDialog::resizeViewHeader()
 {
     const int headerWidth = ui->treeWidget->header()->width();
     ui->treeWidget->header()->resizeSection(0, headerWidth - headerWidth / 4);
 }
 
 void SearchEnginesDialog::accept()
 {
     if (ui->treeWidget->topLevelItemCount() < 1) {
         return;
     }
 
     QVector<SearchEngine> allEngines;
 
     for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++) {
         QTreeWidgetItem* item = ui->treeWidget->topLevelItem(i);
         if (!item) {
             continue;
         }
 
         SearchEngine engine = getEngine(item);
         allEngines.append(engine);
 
         if (isDefaultEngine(item)) {
             m_manager->setDefaultEngine(engine);
         }
     }
 
     m_manager->setAllEngines(allEngines);
 
     QDialog::accept();
 }
 
 SearchEnginesDialog::~SearchEnginesDialog()
 {
     delete ui;
 }
diff --git a/src/lib/other/siteinfo.cpp b/src/lib/other/siteinfo.cpp
index 43265b74..bbe1f6d1 100644
--- a/src/lib/other/siteinfo.cpp
+++ b/src/lib/other/siteinfo.cpp
@@ -1,282 +1,282 @@
 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2010-2018 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #include "siteinfo.h"
 #include "ui_siteinfo.h"
 #include "listitemdelegate.h"
 #include "webview.h"
 #include "webpage.h"
 #include "mainapplication.h"
 #include "downloaditem.h"
 #include "certificateinfowidget.h"
 #include "qztools.h"
 #include "iconprovider.h"
 #include "scripts.h"
 #include "networkmanager.h"
 #include "locationbar.h"
 
 #include <QMenu>
 #include <QMessageBox>
 #include <QFileDialog>
 #include <QNetworkDiskCache>
 #include <QClipboard>
 #include <QTimer>
 #include <QGraphicsPixmapItem>
 
 SiteInfo::SiteInfo(WebView *view)
     : QDialog(view)
     , ui(new Ui::SiteInfo)
     , m_certWidget(0)
     , m_view(view)
     , m_imageReply(Q_NULLPTR)
     , m_baseUrl(view->url())
 {
     setAttribute(Qt::WA_DeleteOnClose);
     ui->setupUi(this);
     ui->treeTags->setLayoutDirection(Qt::LeftToRight);
     QzTools::centerWidgetOnScreen(this);
 
     ListItemDelegate* delegate = new ListItemDelegate(24, ui->listWidget);
     delegate->setUpdateParentHeight(true);
     delegate->setUniformItemSizes(true);
     ui->listWidget->setItemDelegate(delegate);
 
     ui->listWidget->item(0)->setIcon(QIcon::fromTheme("document-properties", QIcon(":/icons/preferences/document-properties.png")));
     ui->listWidget->item(1)->setIcon(QIcon::fromTheme("applications-graphics", QIcon(":/icons/preferences/applications-graphics.png")));
     ui->listWidget->item(0)->setSelected(true);
 
     // General
     ui->heading->setText(QString("<b>%1</b>:").arg(m_view->title()));
     ui->siteAddress->setText(m_view->url().toString());
 
     if (m_view->url().scheme() == QL1S("https"))
         ui->securityLabel->setText(tr("<b>Connection is Encrypted.</b>"));
     else
         ui->securityLabel->setText(tr("<b>Connection Not Encrypted.</b>"));
 
     m_view->page()->runJavaScript(QSL("document.charset"), WebPage::SafeJsWorld, [this](const QVariant &res) {
         ui->encodingLabel->setText(res.toString());
     });
 
     // Meta
     m_view->page()->runJavaScript(Scripts::getAllMetaAttributes(), WebPage::SafeJsWorld, [this](const QVariant &res) {
         const QVariantList &list = res.toList();
         for (const QVariant &val : list) {
             const QVariantMap &meta = val.toMap();
             QString content = meta.value(QSL("content")).toString();
             QString name = meta.value(QSL("name")).toString();
 
             if (name.isEmpty())
                 name = meta.value(QSL("httpequiv")).toString();
 
             if (content.isEmpty() || name.isEmpty())
                 continue;
 
             QTreeWidgetItem* item = new QTreeWidgetItem(ui->treeTags);
             item->setText(0, name);
             item->setText(1, content);
             ui->treeTags->addTopLevelItem(item);
         }
     });
 
     // Images
     m_view->page()->runJavaScript(Scripts::getAllImages(), WebPage::SafeJsWorld, [this](const QVariant &res) {
         const QVariantList &list = res.toList();
         for (const QVariant &val : list) {
             const QVariantMap &img = val.toMap();
             QString src = img.value(QSL("src")).toString();
             QString alt = img.value(QSL("alt")).toString();
             if (alt.isEmpty()) {
                 if (src.indexOf(QLatin1Char('/')) == -1) {
                     alt = src;
                 }
                 else {
                     int pos = src.lastIndexOf(QLatin1Char('/'));
                     alt = src.mid(pos);
                     alt.remove(QLatin1Char('/'));
                 }
             }
 
             if (src.isEmpty() || alt.isEmpty())
                 continue;
 
             QTreeWidgetItem* item = new QTreeWidgetItem(ui->treeImages);
             item->setText(0, alt);
             item->setText(1, src);
             ui->treeImages->addTopLevelItem(item);
         }
     });
 
     connect(ui->saveButton, SIGNAL(clicked(QAbstractButton*)), this, SLOT(saveImage()));
     connect(ui->listWidget, SIGNAL(currentRowChanged(int)), ui->stackedWidget, SLOT(setCurrentIndex(int)));
     connect(ui->treeImages, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)), this, SLOT(showImagePreview(QTreeWidgetItem*)));
     connect(ui->treeImages, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(imagesCustomContextMenuRequested(QPoint)));
 
     ui->treeImages->setContextMenuPolicy(Qt::CustomContextMenu);
-    ui->treeImages->sortByColumn(-1);
+    ui->treeImages->sortByColumn(-1, Qt::AscendingOrder);
 
-    ui->treeTags->sortByColumn(-1);
+    ui->treeTags->sortByColumn(-1, Qt::AscendingOrder);
 
     QzTools::setWmClass("Site Info", this);
 }
 
 bool SiteInfo::canShowSiteInfo(const QUrl &url)
 {
     if (LocationBar::convertUrlToText(url).isEmpty())
         return false;
 
     if (url.scheme() == QL1S("falkon") || url.scheme() == QL1S("view-source") || url.scheme() == QL1S("extension"))
         return false;
 
     return true;
 }
 
 void SiteInfo::imagesCustomContextMenuRequested(const QPoint &p)
 {
     QTreeWidgetItem* item = ui->treeImages->itemAt(p);
     if (!item) {
         return;
     }
 
     QMenu menu;
     menu.addAction(QIcon::fromTheme("edit-copy"), tr("Copy Image Location"), this, SLOT(copyActionData()))->setData(item->text(1));
     menu.addAction(tr("Copy Image Name"), this, SLOT(copyActionData()))->setData(item->text(0));
     menu.addSeparator();
     menu.addAction(QIcon::fromTheme("document-save"), tr("Save Image to Disk"), this, SLOT(saveImage()));
     menu.exec(ui->treeImages->viewport()->mapToGlobal(p));
 }
 
 void SiteInfo::copyActionData()
 {
     if (QAction* action = qobject_cast<QAction*>(sender())) {
         qApp->clipboard()->setText(action->data().toString());
     }
 }
 
 void SiteInfo::saveImage()
 {
     QTreeWidgetItem* item = ui->treeImages->currentItem();
     if (!item) {
         return;
     }
 
     if (!ui->mediaPreview->scene() || ui->mediaPreview->scene()->items().isEmpty())
         return;
 
     QGraphicsItem *graphicsItem = ui->mediaPreview->scene()->items().at(0);
     QGraphicsPixmapItem *pixmapItem = static_cast<QGraphicsPixmapItem*>(graphicsItem);
     if (graphicsItem->type() != QGraphicsPixmapItem::Type || !pixmapItem)
         return;
 
     if (!pixmapItem || pixmapItem->pixmap().isNull()) {
         QMessageBox::warning(this, tr("Error!"), tr("This preview is not available!"));
         return;
     }
 
     QString imageFileName = QzTools::getFileNameFromUrl(QUrl(item->text(1)));
     int index = imageFileName.lastIndexOf(QLatin1Char('.'));
     if (index != -1) {
         imageFileName.truncate(index);
         imageFileName.append(QL1S(".png"));
     }
 
     QString filePath = QzTools::getSaveFileName("SiteInfo-DownloadImage", this, tr("Save image..."),
                                                 QDir::homePath() + QDir::separator() + imageFileName,
                                                 QSL("*.png"));
     if (filePath.isEmpty()) {
         return;
     }
 
     if (!pixmapItem->pixmap().save(filePath, "PNG")) {
         QMessageBox::critical(this, tr("Error!"), tr("Cannot write to file!"));
         return;
     }
 }
 
 void SiteInfo::showLoadingText()
 {
     delete ui->mediaPreview->scene();
     QGraphicsScene* scene = new QGraphicsScene(ui->mediaPreview);
 
     scene->addText(tr("Loading..."));
 
     ui->mediaPreview->setScene(scene);
 }
 
 void SiteInfo::showPixmap(QPixmap pixmap)
 {
     pixmap.setDevicePixelRatio(devicePixelRatioF());
 
     delete ui->mediaPreview->scene();
     QGraphicsScene* scene = new QGraphicsScene(ui->mediaPreview);
 
     if (pixmap.isNull())
         scene->addText(tr("Preview not available"));
     else
         scene->addPixmap(pixmap);
 
     ui->mediaPreview->setScene(scene);
 }
 
 void SiteInfo::showImagePreview(QTreeWidgetItem *item)
 {
     if (!item) {
         return;
     }
     QUrl imageUrl = QUrl::fromEncoded(item->text(1).toUtf8());
     if (imageUrl.isRelative()) {
         imageUrl = m_baseUrl.resolved(imageUrl);
     }
 
     QPixmap pixmap;
     bool loading = false;
 
     if (imageUrl.scheme() == QLatin1String("data")) {
         QByteArray encodedUrl = item->text(1).toUtf8();
         QByteArray imageData = encodedUrl.mid(encodedUrl.indexOf(',') + 1);
         pixmap = QzTools::pixmapFromByteArray(imageData);
     }
     else if (imageUrl.scheme() == QLatin1String("file")) {
         pixmap = QPixmap(imageUrl.toLocalFile());
     }
     else if (imageUrl.scheme() == QLatin1String("qrc")) {
         pixmap = QPixmap(imageUrl.toString().mid(3)); // Remove qrc from url
     }
     else {
         delete m_imageReply;
         m_imageReply = mApp->networkManager()->get(QNetworkRequest(imageUrl));
         connect(m_imageReply, &QNetworkReply::finished, this, [this]() {
             if (m_imageReply->error() != QNetworkReply::NoError)
                 return;
 
             const QByteArray &data = m_imageReply->readAll();
             showPixmap(QPixmap::fromImage(QImage::fromData(data)));
         });
 
         loading = true;
         showLoadingText();
     }
 
     if (!loading)
         showPixmap(pixmap);
 }
 
 SiteInfo::~SiteInfo()
 {
     delete ui;
     delete m_certWidget;
 }
diff --git a/src/lib/preferences/autofillmanager.cpp b/src/lib/preferences/autofillmanager.cpp
index 6f50b8a9..f27f5a07 100644
--- a/src/lib/preferences/autofillmanager.cpp
+++ b/src/lib/preferences/autofillmanager.cpp
@@ -1,382 +1,382 @@
 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2010-2017 David Rosca <nowrep@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * ============================================================ */
 #include "autofillmanager.h"
 #include "ui_autofillmanager.h"
 #include "autofill.h"
 #include "passwordmanager.h"
 #include "passwordbackends/passwordbackend.h"
 #include "mainapplication.h"
 #include "settings.h"
 #include "qztools.h"
 #include "sqldatabase.h"
 
 #include <QUrl>
 #include <QMenu>
 #include <QTimer>
 #include <QMessageBox>
 #include <QInputDialog>
 #include <QFileDialog>
 #include <QClipboard>
 
 AutoFillManager::AutoFillManager(QWidget* parent)
     : QWidget(parent)
     , ui(new Ui::AutoFillManager)
     , m_passwordManager(mApp->autoFill()->passwordManager())
     , m_passwordsShown(false)
 {
     ui->setupUi(this);
     if (isRightToLeft()) {
         ui->treePass->headerItem()->setTextAlignment(0, Qt::AlignRight | Qt::AlignVCenter);
         ui->treePass->headerItem()->setTextAlignment(1, Qt::AlignRight | Qt::AlignVCenter);
         ui->treePass->headerItem()->setTextAlignment(2, Qt::AlignRight | Qt::AlignVCenter);
         ui->treePass->setLayoutDirection(Qt::LeftToRight);
         ui->treeExcept->setLayoutDirection(Qt::LeftToRight);
     }
 
     connect(ui->removePass, &QAbstractButton::clicked, this, &AutoFillManager::removePass);
     connect(ui->removeAllPass, &QAbstractButton::clicked, this, &AutoFillManager::removeAllPass);
     connect(ui->editPass, &QAbstractButton::clicked, this, &AutoFillManager::editPass);
     connect(ui->showPasswords, &QAbstractButton::clicked, this, &AutoFillManager::showPasswords);
     connect(ui->search, &QLineEdit::textChanged, ui->treePass, &TreeWidget::filterString);
     connect(ui->changeBackend, &QAbstractButton::clicked, this, &AutoFillManager::changePasswordBackend);
     connect(ui->backendOptions, &QAbstractButton::clicked, this, &AutoFillManager::showBackendOptions);
     connect(m_passwordManager, &PasswordManager::passwordBackendChanged, this, &AutoFillManager::currentPasswordBackendChanged);
 
     connect(ui->removeExcept, &QAbstractButton::clicked, this, &AutoFillManager::removeExcept);
     connect(ui->removeAllExcept, &QAbstractButton::clicked, this, &AutoFillManager::removeAllExcept);
 
     ui->treePass->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(ui->treePass, &TreeWidget::customContextMenuRequested, this, &AutoFillManager::passwordContextMenu);
 
     QMenu* menu = new QMenu(this);
     menu->addAction(tr("Import Passwords from File..."), this, &AutoFillManager::importPasswords);
     menu->addAction(tr("Export Passwords to File..."), this, &AutoFillManager::exportPasswords);
     ui->importExport->setMenu(menu);
     ui->search->setPlaceholderText(tr("Search"));
 
     // Password backends
     ui->currentBackend->setText(QString("<b>%1</b>").arg(m_passwordManager->activeBackend()->name()));
     ui->backendOptions->setVisible(m_passwordManager->activeBackend()->hasSettings());
 
     // Load passwords
     QTimer::singleShot(0, this, &AutoFillManager::loadPasswords);
 }
 
 void AutoFillManager::loadPasswords()
 {
     ui->showPasswords->setText(tr("Show Passwords"));
     m_passwordsShown = false;
 
     const QVector<PasswordEntry> allEntries = mApp->autoFill()->getAllFormData();
 
     ui->treePass->clear();
     for (const PasswordEntry &entry : allEntries) {
         QTreeWidgetItem* item = new QTreeWidgetItem(ui->treePass);
         item->setText(0, entry.host);
         item->setText(1, entry.username);
         item->setText(2, "*****");
 
         QVariant v;
         v.setValue<PasswordEntry>(entry);
         item->setData(0, Qt::UserRole + 10, v);
         ui->treePass->addTopLevelItem(item);
     }
 
     QSqlQuery query(SqlDatabase::instance()->database());
     query.exec("SELECT server, id FROM autofill_exceptions");
     ui->treeExcept->clear();
     while (query.next()) {
         QTreeWidgetItem* item = new QTreeWidgetItem(ui->treeExcept);
         item->setText(0, query.value(0).toString());
         item->setData(0, Qt::UserRole + 10, query.value(1).toString());
         ui->treeExcept->addTopLevelItem(item);
     }
 
-    ui->treePass->sortByColumn(-1);
-    ui->treeExcept->sortByColumn(-1);
+    ui->treePass->sortByColumn(-1, Qt::AscendingOrder);
+    ui->treeExcept->sortByColumn(-1, Qt::AscendingOrder);
 }
 
 void AutoFillManager::changePasswordBackend()
 {
     QHash<QString, PasswordBackend*> backends = m_passwordManager->availableBackends();
     QStringList items;
 
     int current = 0;
 
     QHashIterator<QString, PasswordBackend*> i(backends);
     while (i.hasNext()) {
         i.next();
         if (i.value() == m_passwordManager->activeBackend()) {
             current = items.size();
         }
         items << i.value()->name();
     }
 
     QString item = QInputDialog::getItem(this, tr("Change backend..."), tr("Change backend:"), items, current, false);
 
     // Switch backends
     if (!item.isEmpty()) {
         PasswordBackend* backend = 0;
 
         QHashIterator<QString, PasswordBackend*> i(backends);
         while (i.hasNext()) {
             i.next();
             if (i.value()->name() == item) {
                 backend = i.value();
                 break;
             }
         }
 
         if (backend) {
             m_passwordManager->switchBackend(backends.key(backend));
         }
     }
 }
 
 void AutoFillManager::showBackendOptions()
 {
     PasswordBackend* backend = m_passwordManager->activeBackend();
 
     if (backend->hasSettings()) {
         backend->showSettings(this);
     }
 }
 
 void AutoFillManager::showPasswords()
 {
     if (m_passwordsShown) {
         for (int i = 0; i < ui->treePass->topLevelItemCount(); i++) {
             QTreeWidgetItem* item = ui->treePass->topLevelItem(i);
             if (!item) {
                 continue;
             }
             item->setText(2, "*****");
         }
 
         ui->showPasswords->setText(tr("Show Passwords"));
         m_passwordsShown = false;
 
         return;
     }
 
     m_passwordsShown = true;
 
     int result = QMessageBox::question(this, tr("Show Passwords"), tr("Are you sure that you want to show all passwords?"),
                                        QMessageBox::Yes | QMessageBox::No, QMessageBox::No);
     if (result != QMessageBox::Yes) {
         return;
     }
 
     for (int i = 0; i < ui->treePass->topLevelItemCount(); i++) {
         QTreeWidgetItem* item = ui->treePass->topLevelItem(i);
         if (!item) {
             continue;
         }
 
         item->setText(2, item->data(0, Qt::UserRole + 10).value<PasswordEntry>().password);
     }
 
     ui->showPasswords->setText(tr("Hide Passwords"));
 }
 
 void AutoFillManager::copyPassword()
 {
     QTreeWidgetItem* curItem = ui->treePass->currentItem();
     if (!curItem)
         return;
 
     PasswordEntry entry = curItem->data(0, Qt::UserRole + 10).value<PasswordEntry>();
     QApplication::clipboard()->setText(entry.password);
 }
 
 void AutoFillManager::copyUsername()
 {
     QTreeWidgetItem* curItem = ui->treePass->currentItem();
     if (!curItem)
         return;
 
     PasswordEntry entry = curItem->data(0, Qt::UserRole + 10).value<PasswordEntry>();
     QApplication::clipboard()->setText(entry.username);
 }
 
 void AutoFillManager::removePass()
 {
     QTreeWidgetItem* curItem = ui->treePass->currentItem();
     if (!curItem) {
         return;
     }
 
     PasswordEntry entry = curItem->data(0, Qt::UserRole + 10).value<PasswordEntry>();
     mApp->autoFill()->removeEntry(entry);
 
     delete curItem;
 }
 
 void AutoFillManager::removeAllPass()
 {
     QMessageBox::StandardButton button = QMessageBox::warning(this, tr("Confirmation"),
                                          tr("Are you sure you want to delete all passwords on your computer?"), QMessageBox::Yes | QMessageBox::No);
     if (button != QMessageBox::Yes) {
         return;
     }
 
     mApp->autoFill()->removeAllEntries();
     ui->treePass->clear();
 }
 
 void AutoFillManager::editPass()
 {
     QTreeWidgetItem* curItem = ui->treePass->currentItem();
     if (!curItem) {
         return;
     }
 
     PasswordEntry entry = curItem->data(0, Qt::UserRole + 10).value<PasswordEntry>();
 
     bool ok;
     QString text = QInputDialog::getText(this, tr("Edit password"), tr("Change password:"), QLineEdit::Normal, entry.password, &ok);
 
     if (ok && !text.isEmpty() && text != entry.password) {
         QByteArray oldPass = "=" + PasswordManager::urlEncodePassword(entry.password);
         entry.data.replace(oldPass, "=" + PasswordManager::urlEncodePassword(text));
         entry.password = text;
 
         if (mApp->autoFill()->updateEntry(entry)) {
             QVariant v;
             v.setValue<PasswordEntry>(entry);
             curItem->setData(0, Qt::UserRole + 10, v);
 
             if (m_passwordsShown) {
                 curItem->setText(2, text);
             }
         }
     }
 }
 
 void AutoFillManager::removeExcept()
 {
     QTreeWidgetItem* curItem = ui->treeExcept->currentItem();
     if (!curItem) {
         return;
     }
     QString id = curItem->data(0, Qt::UserRole + 10).toString();
     QSqlQuery query(SqlDatabase::instance()->database());
     query.prepare("DELETE FROM autofill_exceptions WHERE id=?");
     query.addBindValue(id);
     query.exec();
 
     delete curItem;
 }
 
 void AutoFillManager::removeAllExcept()
 {
     QSqlQuery query(SqlDatabase::instance()->database());
     query.exec("DELETE FROM autofill_exceptions");
 
     ui->treeExcept->clear();
 }
 
 void AutoFillManager::showExceptions()
 {
     ui->tabWidget->setCurrentIndex(1);
 }
 
 void AutoFillManager::importPasswords()
 {
     m_fileName = QzTools::getOpenFileName("AutoFill-ImportPasswords", this, tr("Choose file..."), QDir::homePath() + "/passwords.xml", "*.xml");
 
     if (m_fileName.isEmpty()) {
         return;
     }
 
     QTimer::singleShot(0, this, &AutoFillManager::slotImportPasswords);
 }
 
 void AutoFillManager::exportPasswords()
 {
     m_fileName = QzTools::getSaveFileName("AutoFill-ExportPasswords", this, tr("Choose file..."), QDir::homePath() + "/passwords.xml", "*.xml");
 
     if (m_fileName.isEmpty()) {
         return;
     }
 
     QTimer::singleShot(0, this, &AutoFillManager::slotExportPasswords);
 }
 
 void AutoFillManager::slotImportPasswords()
 {
     QFile file(m_fileName);
 
     if (!file.open(QFile::ReadOnly)) {
         ui->importExportLabel->setText(tr("Cannot read file!"));
         return;
     }
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
 
     bool status = mApp->autoFill()->importPasswords(file.readAll());
     file.close();
 
     ui->importExportLabel->setText(status ? tr("Successfully imported") : tr("Error while importing!"));
     loadPasswords();
 
     QApplication::restoreOverrideCursor();
 }
 
 void AutoFillManager::slotExportPasswords()
 {
     QFile file(m_fileName);
 
     if (!file.open(QFile::WriteOnly)) {
         ui->importExportLabel->setText(tr("Cannot write to file!"));
         return;
     }
 
     QApplication::setOverrideCursor(Qt::WaitCursor);
 
     file.write(mApp->autoFill()->exportPasswords());
     file.close();
 
     ui->importExportLabel->setText(tr("Successfully exported"));
 
     QApplication::restoreOverrideCursor();
 }
 
 void AutoFillManager::currentPasswordBackendChanged()
 {
     ui->currentBackend->setText(QString("<b>%1</b>").arg(m_passwordManager->activeBackend()->name()));
     ui->backendOptions->setVisible(m_passwordManager->activeBackend()->hasSettings());
 
     QTimer::singleShot(0, this, &AutoFillManager::loadPasswords);
 }
 
 void AutoFillManager::passwordContextMenu(const QPoint &pos)
 {
     QMenu *menu = new QMenu;
     menu->setAttribute(Qt::WA_DeleteOnClose);
     menu->addAction(tr("Copy Username"), this, &AutoFillManager::copyUsername);
     menu->addAction(tr("Copy Password"), this, &AutoFillManager::copyPassword);
     menu->addSeparator();
     menu->addAction(tr("Edit Password"), this, &AutoFillManager::editPass);
     menu->popup(ui->treePass->viewport()->mapToGlobal(pos));
 }
 
 AutoFillManager::~AutoFillManager()
 {
     delete ui;
 }