diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8410fb57..ed9c1430 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,189 +1,189 @@
 # CMake version required. This must be the very first line, because it sets default policies affecting everything else
 cmake_minimum_required(VERSION 3.1)
 
 # Project name and version
 project(Falkon VERSION 3.0.99)
 
 # Find ECM, with nice error handling in case of failure
 include(FeatureSummary)
 find_package(ECM 5.27.0 CONFIG)
 set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/frameworks/extra-cmake-modules")
 feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
 # Many includes from ECM, to get all the nice cmake functions and settings
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(ECMInstallIcons)
 include(ECMSetupVersion)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 include(ECMPoQmTools)
 
 # Output dirs (like ECM 5.38 does)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib")
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin")
 
 if (UNIX AND NOT APPLE)
     set(FALKON_INSTALL_PLUGINDIR "${KDE_INSTALL_PLUGINDIR}/falkon")
 else()
     set(FALKON_INSTALL_PLUGINDIR "${KDE_INSTALL_PLUGINDIR}")
 endif()
 if (IS_ABSOLUTE ${FALKON_INSTALL_PLUGINDIR})
     set(PLUGIN_PATH "${FALKON_INSTALL_PLUGINDIR}")
 else()
     set(PLUGIN_PATH "${CMAKE_INSTALL_PREFIX}/${FALKON_INSTALL_PLUGINDIR}")
 endif()
 if (NOT WIN32)
     set(FALKON_PLUGIN_PATH "${PLUGIN_PATH}" CACHE PATH "Default plugin search path")
 endif()
 
 # Defines that are always set
 add_definitions(-DQT_NO_URL_CAST_FROM_STRING -DQT_USE_QSTRINGBUILDER -DQT_NO_CAST_TO_ASCII)
 
 # Mandatory: Qt5
-set(QT_MIN_VERSION "5.9.0")
+set(QT_MIN_VERSION "5.10.0")
 find_package(Qt5 ${QT_MIN_VERSION} REQUIRED COMPONENTS Core Widgets Network Sql QuickWidgets PrintSupport WebEngine WebEngineWidgets WebChannel)
 if (BUILD_TESTING)
     find_package(Qt5 ${QT_MIN_VERSION} REQUIRED COMPONENTS Test)
 endif()
 if (NOT DISABLE_DBUS)
     find_package(Qt5 ${QT_MIN_VERSION} REQUIRED COMPONENTS DBus)
 endif()
 
 if (UNIX AND NOT APPLE AND NOT NO_X11)
     add_definitions(-DQZ_WS_X11)
     find_package(XCB REQUIRED COMPONENTS XCB UTIL)
     find_package(Qt5 ${QT_MIN_VERSION} REQUIRED COMPONENTS X11Extras)
 endif()
 if (WIN32)
     add_definitions(-DW7API)
     find_package(Qt5 ${QT_MIN_VERSION} REQUIRED COMPONENTS WinExtras)
 
     # taken from https://stackoverflow.com/a/40217291
     macro(get_WIN32_WINNT version)
         if (CMAKE_SYSTEM_VERSION)
             set(ver ${CMAKE_SYSTEM_VERSION})
             string(REGEX MATCH "^([0-9]+).([0-9])" ver ${ver})
             string(REGEX MATCH "^([0-9]+)" verMajor ${ver})
             # Check for Windows 10, b/c we'll need to convert to hex 'A'.
             if ("${verMajor}" MATCHES "10")
                 set(verMajor "A")
                 string(REGEX REPLACE "^([0-9]+)" ${verMajor} ver ${ver})
             endif ("${verMajor}" MATCHES "10")
             # Remove all remaining '.' characters.
             string(REPLACE "." "" ver ${ver})
             # Prepend each digit with a zero.
             string(REGEX REPLACE "([0-9A-Z])" "0\\1" ver ${ver})
             set(${version} "0x${ver}")
         endif(CMAKE_SYSTEM_VERSION)
     endmacro(get_WIN32_WINNT)
 
     get_WIN32_WINNT(ver)
     add_definitions(-D_WIN32_WINNT=${ver})
 endif()
 
 # Mandatory: OpenSSL
 find_package(OpenSSL REQUIRED)
 
 # KF5I18n: Mandatory with downloaded translations (only for ki18n_install)
 if (EXISTS "${CMAKE_SOURCE_DIR}/po")
     find_package(KF5I18n REQUIRED)
 endif()
 
 # Optional: GnomeKeyring
 find_package(PkgConfig)
 if (PKG_CONFIG_FOUND)
     option(BUILD_KEYRING "Gnome keyring password plugin" ON)
     if (BUILD_KEYRING)
         pkg_check_modules(GNOME_KEYRING IMPORTED_TARGET gnome-keyring-1 )
     endif()
 endif()
 
 # Optional: KWallet, KIO, KCrash, KCoreAddons
 set(KF5_MIN_VERSION "5.54.0")
 find_package(KF5Wallet ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Wallet PROPERTIES DESCRIPTION "KDE Frameworks Integration plugin" TYPE OPTIONAL)
 find_package(KF5KIO ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5KIO PROPERTIES DESCRIPTION "KDE Frameworks Integration plugin" TYPE OPTIONAL)
 find_package(KF5Crash ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Crash PROPERTIES DESCRIPTION "KDE Frameworks Integration plugin" TYPE OPTIONAL)
 find_package(KF5CoreAddons ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5CoreAddons PROPERTIES DESCRIPTION "KDE Frameworks Integration plugin" TYPE OPTIONAL)
 find_package(KF5Purpose ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Purpose PROPERTIES DESCRIPTION "KDE Frameworks Integration plugin" TYPE OPTIONAL)
 if (KF5Wallet_FOUND AND KF5KIO_FOUND AND KF5Crash_FOUND AND KF5CoreAddons_FOUND AND KF5Purpose_FOUND)
     set(ENABLE_KDE_FRAMEWORKS_INTEGRATION_PLUGIN TRUE)
 endif()
 
 # Optional: PySide2
 find_package(PySide2 "2.0.0")
 find_package(Shiboken2 "2.0.0")
 find_package(PythonLibs "3.0")
 set_package_properties(PySide2 PROPERTIES DESCRIPTION "Python plugins (experimental)" TYPE OPTIONAL)
 set_package_properties(Shiboken2 PROPERTIES DESCRIPTION "Python plugins (experimental)" TYPE OPTIONAL)
 set_package_properties(PythonLibs PROPERTIES DESCRIPTION "Python plugins (experimental)" TYPE OPTIONAL)
 if (PySide2_FOUND AND Shiboken2_FOUND AND PythonLibs_FOUND)
     set(ENABLE_PYTHON_PLUGINS TRUE)
 endif()
 
 find_package(LibIntl)
 
 # Git revision
 if (EXISTS "${CMAKE_SOURCE_DIR}/.git")
   find_package(Git QUIET)
   if(GIT_FOUND)
     execute_process(
       COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
       WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
       OUTPUT_VARIABLE GIT_REVISION
     )
     string(REGEX REPLACE "\n" "" GIT_REVISION "${GIT_REVISION}")
     set(FALKON_GIT_REVISION "${GIT_REVISION}")
   else()
     message(STATUS "Git revision could not be determined")
   endif()
 endif()
 
 configure_file(config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/src/config.h)
 
 # Include dirs used everywhere
 include_directories(
      ${CMAKE_SOURCE_DIR}/src/lib/3rdparty
      ${CMAKE_SOURCE_DIR}/src/lib/adblock
      ${CMAKE_SOURCE_DIR}/src/lib/app
      ${CMAKE_SOURCE_DIR}/src/lib/autofill
      ${CMAKE_SOURCE_DIR}/src/lib/bookmarks
      ${CMAKE_SOURCE_DIR}/src/lib/cookies
      ${CMAKE_SOURCE_DIR}/src/lib/downloads
      ${CMAKE_SOURCE_DIR}/src/lib/history
      ${CMAKE_SOURCE_DIR}/src/lib/navigation
      ${CMAKE_SOURCE_DIR}/src/lib/network
      ${CMAKE_SOURCE_DIR}/src/lib/notifications
      ${CMAKE_SOURCE_DIR}/src/lib/opensearch
      ${CMAKE_SOURCE_DIR}/src/lib/other
      ${CMAKE_SOURCE_DIR}/src/lib/plugins
      ${CMAKE_SOURCE_DIR}/src/lib/popupwindow
      ${CMAKE_SOURCE_DIR}/src/lib/preferences
      ${CMAKE_SOURCE_DIR}/src/lib/session
      ${CMAKE_SOURCE_DIR}/src/lib/sidebar
      ${CMAKE_SOURCE_DIR}/src/lib/tabwidget
      ${CMAKE_SOURCE_DIR}/src/lib/tools
      ${CMAKE_SOURCE_DIR}/src/lib/webengine
      ${CMAKE_SOURCE_DIR}/src/lib/webtab
 )
 
 # Finally, go into the subdirs
 add_subdirectory(src)
 
 if (BUILD_TESTING)
     add_subdirectory(autotests)
     add_subdirectory(tests/benchmarks)
 endif()
 
 # Tell releaseme that po is already taken care of
 # SKIP_PO_INSTALL
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/src/lib/app/mainapplication.cpp b/src/lib/app/mainapplication.cpp
index 34634f40..cb403f01 100644
--- a/src/lib/app/mainapplication.cpp
+++ b/src/lib/app/mainapplication.cpp
@@ -1,1238 +1,1235 @@
 /* ============================================================
 * 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 "mainapplication.h"
 #include "history.h"
 #include "qztools.h"
 #include "updater.h"
 #include "autofill.h"
 #include "settings.h"
 #include "autosaver.h"
 #include "datapaths.h"
 #include "tabwidget.h"
 #include "cookiejar.h"
 #include "bookmarks.h"
 #include "qzsettings.h"
 #include "proxystyle.h"
 #include "pluginproxy.h"
 #include "iconprovider.h"
 #include "browserwindow.h"
 #include "checkboxdialog.h"
 #include "networkmanager.h"
 #include "profilemanager.h"
 #include "restoremanager.h"
 #include "browsinglibrary.h"
 #include "downloadmanager.h"
 #include "clearprivatedata.h"
 #include "useragentmanager.h"
 #include "commandlineoptions.h"
 #include "searchenginesmanager.h"
 #include "desktopnotificationsfactory.h"
 #include "html5permissions/html5permissionsmanager.h"
 #include "scripts.h"
 #include "sessionmanager.h"
 #include "closedwindowsmanager.h"
 #include "../config.h"
 
 #include <QWebEngineSettings>
 #include <QDesktopServices>
 #include <QFontDatabase>
 #include <QSqlDatabase>
 #include <QLibraryInfo>
 #include <QMessageBox>
 #include <QTranslator>
 #include <QThreadPool>
 #include <QSettings>
 #include <QProcess>
 #include <QTimer>
 #include <QDir>
 #include <QStandardPaths>
 #include <QWebEngineProfile>
 #include <QWebEngineDownloadItem>
 #include <QWebEngineScriptCollection>
 #include <QRegularExpression>
 #include <QtWebEngineWidgetsVersion>
 
 #ifdef Q_OS_WIN
 #include <QtWin>
 #include <QWinJumpList>
 #include <QWinJumpListCategory>
 #endif
 
 #include <iostream>
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_OS2)
 #include "registerqappassociation.h"
 #endif
 
 static bool s_testMode = false;
 
 MainApplication::MainApplication(int &argc, char** argv)
     : QtSingleApplication(argc, argv)
     , m_isPrivate(false)
     , m_isPortable(false)
     , m_isClosing(false)
     , m_isStartingAfterCrash(false)
     , m_history(nullptr)
     , m_bookmarks(nullptr)
     , m_autoFill(nullptr)
     , m_cookieJar(nullptr)
     , m_plugins(nullptr)
     , m_browsingLibrary(nullptr)
     , m_networkManager(nullptr)
     , m_restoreManager(nullptr)
     , m_sessionManager(nullptr)
     , m_downloadManager(nullptr)
     , m_userAgentManager(nullptr)
     , m_searchEnginesManager(nullptr)
     , m_closedWindowsManager(nullptr)
     , m_html5PermissionsManager(nullptr)
     , m_desktopNotifications(nullptr)
     , m_webProfile(nullptr)
     , m_autoSaver(nullptr)
 #if defined(Q_OS_WIN) && !defined(Q_OS_OS2)
     , m_registerQAppAssociation(0)
 #endif
 {
     setAttribute(Qt::AA_UseHighDpiPixmaps);
     setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
 
     setApplicationName(QLatin1String("falkon"));
     setOrganizationDomain(QLatin1String("org.kde"));
     setWindowIcon(QIcon::fromTheme(QSL("falkon"), QIcon(QSL(":icons/falkon.svg"))));
     setDesktopFileName(QSL("org.kde.falkon"));
 
 #ifdef GIT_REVISION
     setApplicationVersion(QSL("%1 (%2)").arg(Qz::VERSION, GIT_REVISION));
 #else
     setApplicationVersion(QString::fromLatin1(Qz::VERSION));
 #endif
 
     // Set fallback icon theme (eg. on Windows/Mac)
     if (QIcon::fromTheme(QSL("view-refresh")).isNull()) {
         QIcon::setThemeName(QSL("breeze-fallback"));
     }
 
     // QSQLITE database plugin is required
     if (!QSqlDatabase::isDriverAvailable(QSL("QSQLITE"))) {
         QMessageBox::critical(nullptr, QSL("Error"), QSL("Qt SQLite database plugin is not available. Please install it and restart the application."));
         m_isClosing = true;
         return;
     }
 
 #ifdef Q_OS_WIN
     // Set default app font (needed for N'ko)
     int fontId = QFontDatabase::addApplicationFont(QSL("font.ttf"));
     if (fontId != -1) {
         const QStringList families = QFontDatabase::applicationFontFamilies(fontId);
         if (!families.empty())
             setFont(QFont(families.at(0)));
     }
 #endif
 
     QUrl startUrl;
     QString startProfile;
     QStringList messages;
 
     bool noAddons = false;
     bool newInstance = false;
 
     if (argc > 1) {
         CommandLineOptions cmd;
         foreach (const CommandLineOptions::ActionPair &pair, cmd.getActions()) {
             switch (pair.action) {
             case Qz::CL_StartWithoutAddons:
                 noAddons = true;
                 break;
             case Qz::CL_StartWithProfile:
                 startProfile = pair.text;
                 break;
             case Qz::CL_StartPortable:
                 m_isPortable = true;
                 break;
             case Qz::CL_NewTab:
                 messages.append(QLatin1String("ACTION:NewTab"));
                 m_postLaunchActions.append(OpenNewTab);
                 break;
             case Qz::CL_NewWindow:
                 messages.append(QLatin1String("ACTION:NewWindow"));
                 break;
             case Qz::CL_ToggleFullScreen:
                 messages.append(QLatin1String("ACTION:ToggleFullScreen"));
                 m_postLaunchActions.append(ToggleFullScreen);
                 break;
             case Qz::CL_ShowDownloadManager:
                 messages.append(QLatin1String("ACTION:ShowDownloadManager"));
                 m_postLaunchActions.append(OpenDownloadManager);
                 break;
             case Qz::CL_StartPrivateBrowsing:
                 m_isPrivate = true;
                 break;
             case Qz::CL_StartNewInstance:
                 newInstance = true;
                 break;
             case Qz::CL_OpenUrlInCurrentTab:
                 startUrl = QUrl::fromUserInput(pair.text);
                 messages.append("ACTION:OpenUrlInCurrentTab" + pair.text);
                 break;
             case Qz::CL_OpenUrlInNewWindow:
                 startUrl = QUrl::fromUserInput(pair.text);
                 messages.append("ACTION:OpenUrlInNewWindow" + pair.text);
                 break;
             case Qz::CL_OpenUrl:
                 startUrl = QUrl::fromUserInput(pair.text);
                 messages.append("URL:" + pair.text);
                 break;
             case Qz::CL_ExitAction:
                 m_isClosing = true;
                 return;
             case Qz::CL_WMClass:
                 m_wmClass = pair.text.toUtf8();
                 break;
             default:
                 break;
             }
         }
     }
 
     if (!isPortable()) {
         QSettings falkonConf(QSL("%1/falkon.conf").arg(applicationDirPath()), QSettings::IniFormat);
         m_isPortable = falkonConf.value(QSL("Config/Portable")).toBool();
     }
 
     if (isPortable()) {
         std::cout << "Falkon: Running in Portable Mode." << std::endl;
         DataPaths::setPortableVersion();
     }
 
     // Don't start single application in private browsing
     if (!isPrivate()) {
         QString appId = QLatin1String("FalkonWebBrowser");
 
         if (isPortable()) {
             appId.append(QLatin1String("Portable"));
         }
 
         if (isTestModeEnabled()) {
             appId.append(QSL("TestMode"));
         }
 
         if (newInstance) {
             if (startProfile.isEmpty() || startProfile == QLatin1String("default")) {
                 std::cout << "New instance cannot be started with default profile!" << std::endl;
             }
             else {
                 // Generate unique appId so it is possible to start more separate instances
                 // of the same profile. It is dangerous to run more instances of the same profile,
                 // but if the user wants it, we should allow it.
                 appId.append(startProfile + QString::number(QDateTime::currentMSecsSinceEpoch()));
             }
         }
 
         setAppId(appId);
     }
 
     // If there is nothing to tell other instance, we need to at least wake it
     if (messages.isEmpty()) {
         messages.append(QLatin1String(" "));
     }
 
     if (isRunning()) {
         m_isClosing = true;
         foreach (const QString &message, messages) {
             sendMessage(message);
         }
         return;
     }
 
 #ifdef Q_OS_MACOS
     setQuitOnLastWindowClosed(false);
     // disable tabbing issue#2261
     extern void disableWindowTabbing();
     disableWindowTabbing();
 #else
     setQuitOnLastWindowClosed(true);
 #endif
 
     QSettings::setDefaultFormat(QSettings::IniFormat);
     QDesktopServices::setUrlHandler(QSL("http"), this, "addNewTab");
     QDesktopServices::setUrlHandler(QSL("https"), this, "addNewTab");
     QDesktopServices::setUrlHandler(QSL("ftp"), this, "addNewTab");
 
     ProfileManager profileManager;
     profileManager.initConfigDir();
     profileManager.initCurrentProfile(startProfile);
 
     Settings::createSettings(DataPaths::currentProfilePath() + QLatin1String("/settings.ini"));
 
     m_webProfile = isPrivate() ? new QWebEngineProfile(this) : QWebEngineProfile::defaultProfile();
     connect(m_webProfile, &QWebEngineProfile::downloadRequested, this, &MainApplication::downloadRequested);
 
     m_networkManager = new NetworkManager(this);
 
     setupUserScripts();
 
     if (!isPrivate() && !isTestModeEnabled()) {
         m_sessionManager = new SessionManager(this);
         m_autoSaver = new AutoSaver(this);
         connect(m_autoSaver, SIGNAL(save()), m_sessionManager, SLOT(autoSaveLastSession()));
 
         Settings settings;
         settings.beginGroup(QSL("SessionRestore"));
         const bool wasRunning = settings.value(QSL("isRunning"), false).toBool();
         const bool wasRestoring = settings.value(QSL("isRestoring"), false).toBool();
         settings.setValue(QSL("isRunning"), true);
         settings.setValue(QSL("isRestoring"), wasRunning);
         settings.endGroup();
         settings.sync();
 
         m_isStartingAfterCrash = wasRunning && wasRestoring;
 
         if (wasRunning) {
             QTimer::singleShot(60 * 1000, this, [this]() {
                 Settings().setValue(QSL("SessionRestore/isRestoring"), false);
             });
         }
 
         // we have to ask about startup session before creating main window
         if (!m_isStartingAfterCrash && afterLaunch() == SelectSession)
             m_restoreManager = new RestoreManager(sessionManager()->askSessionFromUser());
     }
 
     loadSettings();
 
     m_plugins = new PluginProxy(this);
     m_autoFill = new AutoFill(this);
 
     if (!noAddons)
         m_plugins->loadPlugins();
 
     BrowserWindow* window = createWindow(Qz::BW_FirstAppWindow, startUrl);
     connect(window, SIGNAL(startingCompleted()), this, SLOT(restoreOverrideCursor()));
 
     connect(this, SIGNAL(focusChanged(QWidget*,QWidget*)), this, SLOT(onFocusChanged()));
 
     if (!isPrivate() && !isTestModeEnabled()) {
 #ifndef DISABLE_CHECK_UPDATES
         Settings settings;
         bool checkUpdates = settings.value("Web-Browser-Settings/CheckUpdates", true).toBool();
 
         if (checkUpdates) {
             new Updater(window);
         }
 #endif
 
         sessionManager()->backupSavedSessions();
 
         if (m_isStartingAfterCrash || afterLaunch() == RestoreSession) {
             m_restoreManager = new RestoreManager(sessionManager()->lastActiveSessionPath());
             if (!m_restoreManager->isValid()) {
                 destroyRestoreManager();
             }
         }
 
         if (!m_isStartingAfterCrash && m_restoreManager) {
             restoreSession(window, m_restoreManager->restoreData());
         }
     }
 
     QSettings::setPath(QSettings::IniFormat, QSettings::UserScope, DataPaths::currentProfilePath());
 
     connect(this, SIGNAL(messageReceived(QString)), this, SLOT(messageReceived(QString)));
     connect(this, SIGNAL(aboutToQuit()), this, SLOT(saveSettings()));
 
     QTimer::singleShot(0, this, SLOT(postLaunch()));
 }
 
 MainApplication::~MainApplication()
 {
     m_isClosing = true;
 
     IconProvider::instance()->saveIconsToDatabase();
 
     // Wait for all QtConcurrent jobs to finish
     QThreadPool::globalInstance()->waitForDone();
 
     // Delete all classes that are saving data in destructor
     delete m_bookmarks;
     m_bookmarks = nullptr;
     delete m_cookieJar;
     m_cookieJar = nullptr;
 
     Settings::syncSettings();
 }
 
 bool MainApplication::isClosing() const
 {
     return m_isClosing;
 }
 
 bool MainApplication::isPrivate() const
 {
     return m_isPrivate;
 }
 
 bool MainApplication::isPortable() const
 {
 #ifdef PORTABLE_BUILD
     return true;
 #else
     return m_isPortable;
 #endif
 }
 
 bool MainApplication::isStartingAfterCrash() const
 {
     return m_isStartingAfterCrash;
 }
 
 int MainApplication::windowCount() const
 {
     return m_windows.count();
 }
 
 QList<BrowserWindow*> MainApplication::windows() const
 {
     return m_windows;
 }
 
 BrowserWindow* MainApplication::getWindow() const
 {
     if (m_lastActiveWindow) {
         return m_lastActiveWindow.data();
     }
 
     return m_windows.isEmpty() ? 0 : m_windows.at(0);
 }
 
 BrowserWindow* MainApplication::createWindow(Qz::BrowserWindowType type, const QUrl &startUrl)
 {
     if (windowCount() == 0 && type != Qz::BW_MacFirstWindow) {
         type = Qz::BW_FirstAppWindow;
     }
 
     BrowserWindow* window = new BrowserWindow(type, startUrl);
     connect(window, SIGNAL(destroyed(QObject*)), this, SLOT(windowDestroyed(QObject*)));
 
     m_windows.prepend(window);
     return window;
 }
 
 MainApplication::AfterLaunch MainApplication::afterLaunch() const
 {
     return static_cast<AfterLaunch>(Settings().value(QSL("Web-URL-Settings/afterLaunch"), RestoreSession).toInt());
 }
 
 void MainApplication::openSession(BrowserWindow* window, RestoreData &restoreData)
 {
     setOverrideCursor(Qt::BusyCursor);
 
     if (!window)
         window = createWindow(Qz::BW_OtherRestoredWindow);
 
     if (window->tabCount() != 0) {
         // This can only happen when recovering crashed session!
         // Don't restore tabs in current window as user already opened some new tabs.
         createWindow(Qz::BW_OtherRestoredWindow)->restoreWindow(restoreData.windows.takeAt(0));
     } else {
         window->restoreWindow(restoreData.windows.takeAt(0));
     }
 
     foreach (const BrowserWindow::SavedWindow &data, restoreData.windows) {
         BrowserWindow* window = createWindow(Qz::BW_OtherRestoredWindow);
         window->restoreWindow(data);
     }
 
     m_closedWindowsManager->restoreState(restoreData.closedWindows);
 
     restoreOverrideCursor();
 }
 
 bool MainApplication::restoreSession(BrowserWindow* window, RestoreData restoreData)
 {
     if (m_isPrivate || !restoreData.isValid()) {
         return false;
     }
 
     openSession(window, restoreData);
 
     m_restoreManager->clearRestoreData();
     destroyRestoreManager();
 
     return true;
 }
 
 void MainApplication::destroyRestoreManager()
 {
     if (m_restoreManager && m_restoreManager->isValid()) {
         return;
     }
 
     delete m_restoreManager;
     m_restoreManager = 0;
 }
 
 void MainApplication::reloadSettings()
 {
     loadSettings();
     emit settingsReloaded();
 }
 
 QString MainApplication::styleName() const
 {
     return m_proxyStyle ? m_proxyStyle->name() : QString();
 }
 
 void MainApplication::setProxyStyle(ProxyStyle *style)
 {
     m_proxyStyle = style;
     setStyle(style);
 }
 
 QByteArray MainApplication::wmClass() const
 {
     return m_wmClass;
 }
 
 History* MainApplication::history()
 {
     if (!m_history) {
         m_history = new History(this);
     }
     return m_history;
 }
 
 Bookmarks* MainApplication::bookmarks()
 {
     if (!m_bookmarks) {
         m_bookmarks = new Bookmarks(this);
     }
     return m_bookmarks;
 }
 
 AutoFill* MainApplication::autoFill()
 {
     return m_autoFill;
 }
 
 CookieJar* MainApplication::cookieJar()
 {
     if (!m_cookieJar) {
         m_cookieJar = new CookieJar(this);
     }
     return m_cookieJar;
 }
 
 PluginProxy* MainApplication::plugins()
 {
     return m_plugins;
 }
 
 BrowsingLibrary* MainApplication::browsingLibrary()
 {
     if (!m_browsingLibrary) {
         m_browsingLibrary = new BrowsingLibrary(getWindow());
     }
     return m_browsingLibrary;
 }
 
 NetworkManager *MainApplication::networkManager()
 {
     return m_networkManager;
 }
 
 RestoreManager* MainApplication::restoreManager()
 {
     return m_restoreManager;
 }
 
 SessionManager* MainApplication::sessionManager()
 {
     return m_sessionManager;
 }
 
 DownloadManager* MainApplication::downloadManager()
 {
     if (!m_downloadManager) {
         m_downloadManager = new DownloadManager();
     }
     return m_downloadManager;
 }
 
 UserAgentManager* MainApplication::userAgentManager()
 {
     if (!m_userAgentManager) {
         m_userAgentManager = new UserAgentManager(this);
     }
     return m_userAgentManager;
 }
 
 SearchEnginesManager* MainApplication::searchEnginesManager()
 {
     if (!m_searchEnginesManager) {
         m_searchEnginesManager = new SearchEnginesManager(this);
     }
     return m_searchEnginesManager;
 }
 
 ClosedWindowsManager* MainApplication::closedWindowsManager()
 {
     if (!m_closedWindowsManager) {
         m_closedWindowsManager = new ClosedWindowsManager(this);
     }
     return m_closedWindowsManager;
 }
 
 HTML5PermissionsManager* MainApplication::html5PermissionsManager()
 {
     if (!m_html5PermissionsManager) {
         m_html5PermissionsManager = new HTML5PermissionsManager(this);
     }
     return m_html5PermissionsManager;
 }
 
 DesktopNotificationsFactory* MainApplication::desktopNotifications()
 {
     if (!m_desktopNotifications) {
         m_desktopNotifications = new DesktopNotificationsFactory(this);
     }
     return m_desktopNotifications;
 }
 
 QWebEngineProfile *MainApplication::webProfile() const
 {
     return m_webProfile;
 }
 
 QWebEngineSettings *MainApplication::webSettings() const
 {
     return m_webProfile->settings();
 }
 
 // static
 MainApplication* MainApplication::instance()
 {
     return static_cast<MainApplication*>(QCoreApplication::instance());
 }
 
 // static
 bool MainApplication::isTestModeEnabled()
 {
     return s_testMode;
 }
 
 // static
 void MainApplication::setTestModeEnabled(bool enabled)
 {
     s_testMode = enabled;
 }
 
 void MainApplication::addNewTab(const QUrl &url)
 {
     BrowserWindow* window = getWindow();
 
     if (window) {
         window->tabWidget()->addView(url, url.isEmpty() ? Qz::NT_SelectedNewEmptyTab : Qz::NT_SelectedTabAtTheEnd);
     }
 }
 
 void MainApplication::startPrivateBrowsing(const QUrl &startUrl)
 {
     QUrl url = startUrl;
     if (QAction* act = qobject_cast<QAction*>(sender())) {
         url = act->data().toUrl();
     }
 
     QStringList args;
     args.append(QSL("--private-browsing"));
     args.append(QSL("--profile=") + ProfileManager::currentProfile());
 
     if (!url.isEmpty()) {
         args << url.toEncoded();
     }
 
     if (!QProcess::startDetached(applicationFilePath(), args)) {
         qWarning() << "MainApplication: Cannot start new browser process for private browsing!" << applicationFilePath() << args;
     }
 }
 
 void MainApplication::reloadUserStyleSheet()
 {
     const QString userCssFile = Settings().value(QSL("Web-Browser-Settings/userStyleSheet"), QString()).toString();
     setUserStyleSheet(userCssFile);
 }
 
 void MainApplication::restoreOverrideCursor()
 {
     QApplication::restoreOverrideCursor();
 }
 
 void MainApplication::changeOccurred()
 {
     if (m_autoSaver)
         m_autoSaver->changeOccurred();
 }
 
 void MainApplication::quitApplication()
 {
     if (m_downloadManager && !m_downloadManager->canClose()) {
         m_downloadManager->show();
         return;
     }
 
     for (BrowserWindow *window : qAsConst(m_windows)) {
         emit window->aboutToClose();
     }
 
     if (m_sessionManager && m_windows.count() > 0) {
         m_sessionManager->autoSaveLastSession();
     }
 
     m_isClosing = true;
 
     for (BrowserWindow *window : qAsConst(m_windows)) {
         window->close();
     }
 
     // Saving settings in saveSettings() slot called from quit() so
     // everything gets saved also when quitting application in other
     // way than clicking Quit action in File menu or closing last window
     // eg. on Mac (#157)
 
     if (!isPrivate()) {
         removeLockFile();
     }
 
     quit();
 }
 
 void MainApplication::postLaunch()
 {
     if (m_postLaunchActions.contains(OpenDownloadManager)) {
         downloadManager()->show();
     }
 
     if (m_postLaunchActions.contains(OpenNewTab)) {
         getWindow()->tabWidget()->addView(QUrl(), Qz::NT_SelectedNewEmptyTab);
     }
 
     if (m_postLaunchActions.contains(ToggleFullScreen)) {
         getWindow()->toggleFullScreen();
     }
 
     createJumpList();
     initPulseSupport();
 
     QTimer::singleShot(5000, this, &MainApplication::runDeferredPostLaunchActions);
 }
 
 QByteArray MainApplication::saveState() const
 {
     RestoreData restoreData;
     restoreData.windows.reserve(m_windows.count());
     for (BrowserWindow *window : qAsConst(m_windows)) {
         restoreData.windows.append(BrowserWindow::SavedWindow(window));
     }
 
     if (m_restoreManager && m_restoreManager->isValid()) {
         QDataStream stream(&restoreData.crashedSession, QIODevice::WriteOnly);
         stream << m_restoreManager->restoreData();
     }
 
     restoreData.closedWindows = m_closedWindowsManager->saveState();
 
     QByteArray data;
     QDataStream stream(&data, QIODevice::WriteOnly);
 
     stream << Qz::sessionVersion;
     stream << restoreData;
 
     return data;
 }
 
 void MainApplication::saveSettings()
 {
     if (isPrivate()) {
         return;
     }
 
     m_isClosing = true;
 
     Settings settings;
     settings.beginGroup(QSL("SessionRestore"));
     settings.setValue(QSL("isRunning"), false);
     settings.setValue(QSL("isRestoring"), false);
     settings.endGroup();
 
     settings.beginGroup(QSL("Web-Browser-Settings"));
     bool deleteCache = settings.value(QSL("deleteCacheOnClose"), false).toBool();
     bool deleteHistory = settings.value(QSL("deleteHistoryOnClose"), false).toBool();
     bool deleteHtml5Storage = settings.value(QSL("deleteHTML5StorageOnClose"), false).toBool();
     settings.endGroup();
 
     settings.beginGroup(QSL("Cookie-Settings"));
     bool deleteCookies = settings.value(QSL("deleteCookiesOnClose"), false).toBool();
     settings.endGroup();
 
     if (deleteHistory) {
         m_history->clearHistory();
     }
     if (deleteHtml5Storage) {
         ClearPrivateData::clearLocalStorage();
     }
     if (deleteCookies) {
         m_cookieJar->deleteAllCookies(false);
     }
     if (deleteCache) {
         QzTools::removeRecursively(mApp->webProfile()->cachePath());
     }
 
     m_searchEnginesManager->saveSettings();
     m_plugins->shutdown();
     m_networkManager->shutdown();
 
     qzSettings->saveSettings();
     QFile::remove(DataPaths::currentProfilePath() + QLatin1String("/WebpageIcons.db"));
 
     sessionManager()->saveSettings();
 }
 
 void MainApplication::messageReceived(const QString &message)
 {
     QWidget* actWin = getWindow();
     QUrl actUrl;
 
     if (message.startsWith(QLatin1String("URL:"))) {
         const QUrl url = QUrl::fromUserInput(message.mid(4));
         addNewTab(url);
         actWin = getWindow();
     }
     else if (message.startsWith(QLatin1String("ACTION:"))) {
         const QString text = message.mid(7);
         if (text == QLatin1String("NewTab")) {
             addNewTab();
         }
         else if (text == QLatin1String("NewWindow")) {
             actWin = createWindow(Qz::BW_NewWindow);
         }
         else if (text == QLatin1String("ShowDownloadManager")) {
             downloadManager()->show();
             actWin = downloadManager();
         }
         else if (text == QLatin1String("ToggleFullScreen") && actWin) {
             BrowserWindow* qz = static_cast<BrowserWindow*>(actWin);
             qz->toggleFullScreen();
         }
         else if (text.startsWith(QLatin1String("OpenUrlInCurrentTab"))) {
             actUrl = QUrl::fromUserInput(text.mid(19));
         }
         else if (text.startsWith(QLatin1String("OpenUrlInNewWindow"))) {
             createWindow(Qz::BW_NewWindow, QUrl::fromUserInput(text.mid(18)));
             return;
         }
     }
     else {
         // User attempted to start another instance, let's open a new window
         actWin = createWindow(Qz::BW_NewWindow);
     }
 
     if (!actWin) {
         if (!isClosing()) {
             // It can only occur if download manager window was still opened
             createWindow(Qz::BW_NewWindow, actUrl);
         }
         return;
     }
 
     actWin->setWindowState(actWin->windowState() & ~Qt::WindowMinimized);
     actWin->raise();
     actWin->activateWindow();
     actWin->setFocus();
 
     BrowserWindow* win = qobject_cast<BrowserWindow*>(actWin);
 
     if (win && !actUrl.isEmpty()) {
         win->loadAddress(actUrl);
     }
 }
 
 void MainApplication::windowDestroyed(QObject* window)
 {
     // qobject_cast doesn't work because QObject::destroyed is emitted from destructor
     Q_ASSERT(static_cast<BrowserWindow*>(window));
     Q_ASSERT(m_windows.contains(static_cast<BrowserWindow*>(window)));
 
     m_windows.removeOne(static_cast<BrowserWindow*>(window));
 }
 
 void MainApplication::onFocusChanged()
 {
     BrowserWindow* activeBrowserWindow = qobject_cast<BrowserWindow*>(activeWindow());
 
     if (activeBrowserWindow) {
         m_lastActiveWindow = activeBrowserWindow;
 
         emit activeWindowChanged(m_lastActiveWindow);
     }
 }
 
 void MainApplication::runDeferredPostLaunchActions()
 {
     checkDefaultWebBrowser();
     checkOptimizeDatabase();
 }
 
 void MainApplication::downloadRequested(QWebEngineDownloadItem *download)
 {
     downloadManager()->download(download);
 }
 
 void MainApplication::loadSettings()
 {
     Settings settings;
     settings.beginGroup(QSL("Themes"));
     QString activeTheme = settings.value(QSL("activeTheme"), DEFAULT_THEME_NAME).toString();
     settings.endGroup();
 
     loadTheme(activeTheme);
 
     QWebEngineSettings* webSettings = m_webProfile->settings();
 
     // Web browsing settings
     settings.beginGroup(QSL("Web-Browser-Settings"));
 
     webSettings->setAttribute(QWebEngineSettings::LocalStorageEnabled, settings.value(QSL("HTML5StorageEnabled"), true).toBool());
     webSettings->setAttribute(QWebEngineSettings::PluginsEnabled, settings.value(QSL("allowPlugins"), true).toBool());
     webSettings->setAttribute(QWebEngineSettings::JavascriptEnabled, settings.value(QSL("allowJavaScript"), true).toBool());
     webSettings->setAttribute(QWebEngineSettings::JavascriptCanOpenWindows, settings.value(QSL("allowJavaScriptOpenWindow"), false).toBool());
     webSettings->setAttribute(QWebEngineSettings::JavascriptCanAccessClipboard, settings.value(QSL("allowJavaScriptAccessClipboard"), true).toBool());
     webSettings->setAttribute(QWebEngineSettings::LinksIncludedInFocusChain, settings.value(QSL("IncludeLinkInFocusChain"), false).toBool());
     webSettings->setAttribute(QWebEngineSettings::XSSAuditingEnabled, settings.value(QSL("XSSAuditing"), false).toBool());
     webSettings->setAttribute(QWebEngineSettings::PrintElementBackgrounds, settings.value(QSL("PrintElementBackground"), true).toBool());
     webSettings->setAttribute(QWebEngineSettings::SpatialNavigationEnabled, settings.value(QSL("SpatialNavigation"), false).toBool());
     webSettings->setAttribute(QWebEngineSettings::ScrollAnimatorEnabled, settings.value(QSL("AnimateScrolling"), true).toBool());
     webSettings->setAttribute(QWebEngineSettings::HyperlinkAuditingEnabled, false);
     webSettings->setAttribute(QWebEngineSettings::FullScreenSupportEnabled, true);
     webSettings->setAttribute(QWebEngineSettings::LocalContentCanAccessRemoteUrls, true);
     webSettings->setAttribute(QWebEngineSettings::FocusOnNavigationEnabled, false);
-
-#if QTWEBENGINEWIDGETS_VERSION >= QT_VERSION_CHECK(5, 10, 0)
     webSettings->setAttribute(QWebEngineSettings::AllowWindowActivationFromJavaScript, settings.value(QSL("allowJavaScriptActivateWindow"), false).toBool());
-#endif
 
 #if QTWEBENGINEWIDGETS_VERSION >= QT_VERSION_CHECK(5, 11, 0)
     webSettings->setAttribute(QWebEngineSettings::JavascriptCanPaste, settings.value(QSL("allowJavaScriptPaste"), true).toBool());
     webSettings->setAttribute(QWebEngineSettings::PlaybackRequiresUserGesture, settings.value(QSL("DisableVideoAutoPlay"), false).toBool());
     webSettings->setAttribute(QWebEngineSettings::WebRTCPublicInterfacesOnly, settings.value(QSL("WebRTCPublicIpOnly"), true).toBool());
     webSettings->setUnknownUrlSchemePolicy(QWebEngineSettings::AllowAllUnknownUrlSchemes);
 #endif
 
     webSettings->setDefaultTextEncoding(settings.value(QSL("DefaultEncoding"), webSettings->defaultTextEncoding()).toString());
 
     setWheelScrollLines(settings.value(QSL("wheelScrollLines"), wheelScrollLines()).toInt());
 
     const QString userCss = settings.value(QSL("userStyleSheet"), QString()).toString();
     settings.endGroup();
 
     setUserStyleSheet(userCss);
 
     settings.beginGroup(QSL("Browser-Fonts"));
     webSettings->setFontFamily(QWebEngineSettings::StandardFont, settings.value(QSL("StandardFont"), webSettings->fontFamily(QWebEngineSettings::StandardFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::CursiveFont, settings.value(QSL("CursiveFont"), webSettings->fontFamily(QWebEngineSettings::CursiveFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::FantasyFont, settings.value(QSL("FantasyFont"), webSettings->fontFamily(QWebEngineSettings::FantasyFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::FixedFont, settings.value(QSL("FixedFont"), webSettings->fontFamily(QWebEngineSettings::FixedFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::SansSerifFont, settings.value(QSL("SansSerifFont"), webSettings->fontFamily(QWebEngineSettings::SansSerifFont)).toString());
     webSettings->setFontFamily(QWebEngineSettings::SerifFont, settings.value(QSL("SerifFont"), webSettings->fontFamily(QWebEngineSettings::SerifFont)).toString());
     webSettings->setFontSize(QWebEngineSettings::DefaultFontSize, settings.value(QSL("DefaultFontSize"), 15).toInt());
     webSettings->setFontSize(QWebEngineSettings::DefaultFixedFontSize, settings.value(QSL("FixedFontSize"), 14).toInt());
     webSettings->setFontSize(QWebEngineSettings::MinimumFontSize, settings.value(QSL("MinimumFontSize"), 3).toInt());
     webSettings->setFontSize(QWebEngineSettings::MinimumLogicalFontSize, settings.value(QSL("MinimumLogicalFontSize"), 5).toInt());
     settings.endGroup();
 
     QWebEngineProfile* profile = QWebEngineProfile::defaultProfile();
     profile->setPersistentCookiesPolicy(QWebEngineProfile::AllowPersistentCookies);
     profile->setPersistentStoragePath(DataPaths::currentProfilePath());
 
     QString defaultPath = DataPaths::path(DataPaths::Cache);
     if (!defaultPath.startsWith(DataPaths::currentProfilePath()))
         defaultPath.append(QLatin1Char('/') + ProfileManager::currentProfile());
     const QString &cachePath = settings.value(QSL("Web-Browser-Settings/CachePath"), defaultPath).toString();
     profile->setCachePath(cachePath);
 
     const bool allowCache = settings.value(QSL("Web-Browser-Settings/AllowLocalCache"), true).toBool();
     profile->setHttpCacheType(allowCache ? QWebEngineProfile::DiskHttpCache : QWebEngineProfile::MemoryHttpCache);
 
     const int cacheSize = settings.value(QSL("Web-Browser-Settings/LocalCacheSize"), 50).toInt() * 1000 * 1000;
     profile->setHttpCacheMaximumSize(cacheSize);
 
     settings.beginGroup(QSL("SpellCheck"));
     profile->setSpellCheckEnabled(settings.value(QSL("Enabled"), false).toBool());
     profile->setSpellCheckLanguages(settings.value(QSL("Languages")).toStringList());
     settings.endGroup();
 
     if (isPrivate()) {
         webSettings->setAttribute(QWebEngineSettings::LocalStorageEnabled, false);
         history()->setSaving(false);
     }
 
     if (m_downloadManager) {
         m_downloadManager->loadSettings();
     }
 
     qzSettings->loadSettings();
     userAgentManager()->loadSettings();
     networkManager()->loadSettings();
 }
 
 void MainApplication::loadTheme(const QString &name)
 {
     QString activeThemePath = DataPaths::locate(DataPaths::Themes, name);
 
     if (activeThemePath.isEmpty()) {
         qWarning() << "Cannot load theme " << name;
         activeThemePath = QSL("%1/%2").arg(DataPaths::path(DataPaths::Themes), DEFAULT_THEME_NAME);
     }
 
     QString qss = QzTools::readAllFileContents(activeThemePath + QLatin1String("/main.css"));
 
 #if defined(Q_OS_MACOS)
     qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/mac.css")));
 #elif defined(Q_OS_UNIX)
     qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/linux.css")));
 #elif defined(Q_OS_WIN) || defined(Q_OS_OS2)
     qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/windows.css")));
 #endif
 
     if (isRightToLeft()) {
         qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/rtl.css")));
     }
 
     if (isPrivate()) {
         qss.append(QzTools::readAllFileContents(activeThemePath + QLatin1String("/private.css")));
     }
 
     qss.append(QzTools::readAllFileContents(DataPaths::currentProfilePath() + QL1S("/userChrome.css")));
 
     QString relativePath = QDir::current().relativeFilePath(activeThemePath);
     qss.replace(QRegularExpression(QSL("url\\s*\\(\\s*([^\\*:\\);]+)\\s*\\)")), QSL("url(%1/\\1)").arg(relativePath));
     setStyleSheet(qss);
 }
 
 void MainApplication::checkDefaultWebBrowser()
 {
     if (isPortable()) {
         return;
     }
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_OS2)
     Settings settings;
     bool checkNow = settings.value(QSL("Web-Browser-Settings/CheckDefaultBrowser"), DEFAULT_CHECK_DEFAULTBROWSER).toBool();
 
     if (!checkNow) {
         return;
     }
 
     bool checkAgain = true;
 
     if (!associationManager()->isDefaultForAllCapabilities()) {
         CheckBoxDialog dialog(QMessageBox::Yes | QMessageBox::No, getWindow());
         dialog.setDefaultButton(QMessageBox::Yes);
         dialog.setText(tr("Falkon is not currently your default browser. Would you like to make it your default browser?"));
         dialog.setCheckBoxText(tr("Always perform this check when starting Falkon."));
         dialog.setDefaultCheckState(Qt::Checked);
         dialog.setWindowTitle(tr("Default Browser"));
         dialog.setIcon(QMessageBox::Warning);
 
         if (dialog.exec() == QMessageBox::Yes) {
             if (!mApp->associationManager()->showNativeDefaultAppSettingsUi())
                 mApp->associationManager()->registerAllAssociation();
         }
 
         checkAgain = dialog.isChecked();
     }
 
     settings.setValue(QSL("Web-Browser-Settings/CheckDefaultBrowser"), checkAgain);
 #endif
 }
 
 void MainApplication::checkOptimizeDatabase()
 {
     Settings settings;
     settings.beginGroup(QSL("Browser"));
     const int numberOfRuns = settings.value(QSL("RunsWithoutOptimizeDb"), 0).toInt();
     settings.setValue(QSL("RunsWithoutOptimizeDb"), numberOfRuns + 1);
 
     if (numberOfRuns > 20) {
         std::cout << "Optimizing database..." << std::endl;
         IconProvider::instance()->clearOldIconsInDatabase();
         settings.setValue(QSL("RunsWithoutOptimizeDb"), 0);
     }
 
     settings.endGroup();
 }
 
 void MainApplication::setupUserScripts()
 {
     // WebChannel for SafeJsWorld
     QWebEngineScript script;
     script.setName(QSL("_falkon_webchannel"));
     script.setInjectionPoint(QWebEngineScript::DocumentCreation);
     script.setWorldId(WebPage::SafeJsWorld);
     script.setRunsOnSubFrames(true);
     script.setSourceCode(Scripts::setupWebChannel());
     m_webProfile->scripts()->insert(script);
 
     // falkon:restore
     QWebEngineScript falkonRestore;
     falkonRestore.setWorldId(WebPage::SafeJsWorld);
     falkonRestore.setSourceCode(QzTools::readAllFileContents(QSL(":html/restore.user.js")));
     m_webProfile->scripts()->insert(falkonRestore);
 
     // falkon:speeddial
     QWebEngineScript falkonSpeedDial;
     falkonSpeedDial.setWorldId(WebPage::SafeJsWorld);
     falkonSpeedDial.setSourceCode(Scripts::setupSpeedDial());
     m_webProfile->scripts()->insert(falkonSpeedDial);
 
     // document.window object addons
     QWebEngineScript documentWindowAddons;
     documentWindowAddons.setName(QSL("_falkon_window_object"));
     documentWindowAddons.setInjectionPoint(QWebEngineScript::DocumentCreation);
     documentWindowAddons.setWorldId(WebPage::UnsafeJsWorld);
     documentWindowAddons.setRunsOnSubFrames(true);
     documentWindowAddons.setSourceCode(Scripts::setupWindowObject());
     m_webProfile->scripts()->insert(documentWindowAddons);
 }
 
 void MainApplication::setUserStyleSheet(const QString &filePath)
 {
     QString userCss;
 
 #if !defined(Q_OS_UNIX) && !defined(Q_OS_MACOS)
     // Don't grey out selection on losing focus (to prevent graying out found text)
     QString highlightColor;
     QString highlightedTextColor;
 #ifdef Q_OS_MACOS
     highlightColor = QLatin1String("#b6d6fc");
     highlightedTextColor = QLatin1String("#000");
 #else
     QPalette pal = style()->standardPalette();
     highlightColor = pal.color(QPalette::Highlight).name();
     highlightedTextColor = pal.color(QPalette::HighlightedText).name();
 #endif
     userCss += QString("::selection {background: %1; color: %2;} ").arg(highlightColor, highlightedTextColor);
 #endif
 
     userCss += QzTools::readAllFileContents(filePath).remove(QLatin1Char('\n'));
 
     const QString name = QStringLiteral("_falkon_userstylesheet");
 
     QWebEngineScript oldScript = m_webProfile->scripts()->findScript(name);
     if (!oldScript.isNull()) {
         m_webProfile->scripts()->remove(oldScript);
     }
 
     if (userCss.isEmpty())
         return;
 
     QWebEngineScript script;
     script.setName(name);
     script.setInjectionPoint(QWebEngineScript::DocumentReady);
     script.setWorldId(WebPage::SafeJsWorld);
     script.setRunsOnSubFrames(true);
     script.setSourceCode(Scripts::setCss(userCss));
     m_webProfile->scripts()->insert(script);
 }
 
 void MainApplication::createJumpList()
 {
 #ifdef Q_OS_WIN
     QWinJumpList *jumpList = new QWinJumpList(this);
     jumpList->clear();
 
     // Frequent
     QWinJumpListCategory *frequent = jumpList->frequent();
     frequent->setVisible(true);
     const QVector<HistoryEntry> mostList = m_history->mostVisited(7);
     for (const HistoryEntry &entry : mostList) {
         frequent->addLink(IconProvider::iconForUrl(entry.url), entry.title, applicationFilePath(), QStringList{entry.url.toEncoded()});
     }
 
     // Tasks
     QWinJumpListCategory *tasks = jumpList->tasks();
     tasks->setVisible(true);
     tasks->addLink(IconProvider::newTabIcon(), tr("Open new tab"), applicationFilePath(), {QSL("--new-tab")});
     tasks->addLink(IconProvider::newWindowIcon(), tr("Open new window"), applicationFilePath(), {QSL("--new-window")});
     tasks->addLink(IconProvider::privateBrowsingIcon(), tr("Open new private window"), applicationFilePath(), {QSL("--private-browsing")});
 #endif
 }
 
 void MainApplication::initPulseSupport()
 {
     qputenv("PULSE_PROP_OVERRIDE_application.name", "Falkon");
     qputenv("PULSE_PROP_OVERRIDE_application.icon_name", "falkon");
     qputenv("PULSE_PROP_OVERRIDE_media.icon_name", "falkon");
 }
 
 #if defined(Q_OS_WIN) && !defined(Q_OS_OS2)
 RegisterQAppAssociation* MainApplication::associationManager()
 {
     if (!m_registerQAppAssociation) {
         QString desc = tr("Falkon is a new and very fast Qt web browser. Falkon is licensed under GPL version 3 or (at your option) any later version. It is based on QtWebEngine and Qt Framework.");
         QString fileIconPath = QApplication::applicationFilePath() + ",1";
         QString appIconPath = QApplication::applicationFilePath() + ",0";
         m_registerQAppAssociation = new RegisterQAppAssociation("Falkon", QApplication::applicationFilePath(), appIconPath, desc, this);
         m_registerQAppAssociation->addCapability(".html", "FalkonHTML", "Falkon HTML Document", fileIconPath, RegisterQAppAssociation::FileAssociation);
         m_registerQAppAssociation->addCapability(".htm", "FalkonHTML", "Falkon HTML Document", fileIconPath, RegisterQAppAssociation::FileAssociation);
         m_registerQAppAssociation->addCapability("http", "FalkonURL", "Falkon URL", appIconPath, RegisterQAppAssociation::UrlAssociation);
         m_registerQAppAssociation->addCapability("https", "FalkonURL", "Falkon URL", appIconPath, RegisterQAppAssociation::UrlAssociation);
         m_registerQAppAssociation->addCapability("ftp", "FalkonURL", "Falkon URL", appIconPath, RegisterQAppAssociation::UrlAssociation);
     }
     return m_registerQAppAssociation;
 }
 #endif
 
 #ifdef Q_OS_MACOS
 #include <QFileOpenEvent>
 
 bool MainApplication::event(QEvent* e)
 {
     switch (e->type()) {
     case QEvent::FileOpen: {
         QFileOpenEvent *ev = static_cast<QFileOpenEvent*>(e);
         if (!ev->url().isEmpty()) {
             addNewTab(ev->url());
         } else if (!ev->file().isEmpty()) {
             addNewTab(QUrl::fromLocalFile(ev->file()));
         } else {
             return false;
         }
         return true;
     }
 
     case QEvent::ApplicationActivate:
         if (!activeWindow() && m_windows.isEmpty())
             createWindow(Qz::BW_NewWindow);
         break;
 
     default:
         break;
     }
 
     return QtSingleApplication::event(e);
 }
 #endif
diff --git a/src/lib/preferences/jsoptions.cpp b/src/lib/preferences/jsoptions.cpp
index 8bd06d09..44604a08 100644
--- a/src/lib/preferences/jsoptions.cpp
+++ b/src/lib/preferences/jsoptions.cpp
@@ -1,66 +1,62 @@
 /* ============================================================
 * Falkon - Qt web browser
 * Copyright (C) 2013-2014  David Rosca <nowrep@gmail.com>
                 2013-2014  Mladen Pejaković <pejakm@autistici.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 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 "jsoptions.h"
 #include "ui_jsoptions.h"
 #include "mainapplication.h"
 #include "settings.h"
 #include <QtWebEngineWidgetsVersion>
 
 JsOptions::JsOptions(QWidget* parent)
     : QDialog(parent)
     , ui(new Ui::JsOptions)
 {
     setAttribute(Qt::WA_DeleteOnClose);
 
     ui->setupUi(this);
 
-#if QTWEBENGINEWIDGETS_VERSION < QT_VERSION_CHECK(5, 10, 0)
-    ui->jscanActivateWindow->setVisible(false);
-#endif
-
 #if QTWEBENGINEWIDGETS_VERSION < QT_VERSION_CHECK(5, 11, 0)
     ui->jscanPaste->setVisible(false);
 #endif
 
     Settings settings;
     settings.beginGroup("Web-Browser-Settings");
     ui->jscanOpenWindow->setChecked(settings.value("allowJavaScriptOpenWindow", false).toBool());
     ui->jscanActivateWindow->setChecked(settings.value("allowJavaScriptActivateWindow", false).toBool());
     ui->jscanAccessClipboard->setChecked(settings.value("allowJavaScriptAccessClipboard", true).toBool());
     ui->jscanPaste->setChecked(settings.value("allowJavaScriptPaste", true).toBool());
     settings.endGroup();
 }
 
 void JsOptions::accept()
 {
     Settings settings;
     settings.beginGroup("Web-Browser-Settings");
     settings.setValue("allowJavaScriptOpenWindow", ui->jscanOpenWindow->isChecked());
     settings.setValue("allowJavaScriptActivateWindow", ui->jscanActivateWindow->isChecked());
     settings.setValue("allowJavaScriptAccessClipboard", ui->jscanAccessClipboard->isChecked());
     settings.setValue("allowJavaScriptPaste", ui->jscanPaste->isChecked());
     settings.endGroup();
 
     QDialog::close();
 }
 
 JsOptions::~JsOptions()
 {
     delete ui;
 }
diff --git a/src/lib/webengine/webview.cpp b/src/lib/webengine/webview.cpp
index a2506c1c..f275b15f 100644
--- a/src/lib/webengine/webview.cpp
+++ b/src/lib/webengine/webview.cpp
@@ -1,1371 +1,1367 @@
 /* ============================================================
 * 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 "webview.h"
 #include "webpage.h"
 #include "mainapplication.h"
 #include "qztools.h"
 #include "iconprovider.h"
 #include "history.h"
 #include "pluginproxy.h"
 #include "downloadmanager.h"
 #include "siteinfo.h"
 #include "searchenginesmanager.h"
 #include "browsinglibrary.h"
 #include "bookmarkstools.h"
 #include "settings.h"
 #include "qzsettings.h"
 #include "enhancedmenu.h"
 #include "locationbar.h"
 #include "webinspector.h"
 #include "scripts.h"
 #include "webhittestresult.h"
 #include "webscrollbarmanager.h"
 
 #include <iostream>
 
 #include <QDir>
 #include <QTimer>
 #include <QDesktopServices>
 #include <QWebEngineHistory>
 #include <QClipboard>
 #include <QMimeData>
 #include <QWebEngineContextMenuData>
 #include <QStackedLayout>
 #include <QScrollBar>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QQuickWidget>
 #include <QtWebEngineWidgetsVersion>
 
 bool WebView::s_forceContextMenuOnMouseRelease = false;
 
 WebView::WebView(QWidget* parent)
     : QWebEngineView(parent)
     , m_progress(100)
     , m_backgroundActivity(false)
     , m_page(0)
     , m_firstLoad(false)
 {
     connect(this, &QWebEngineView::loadStarted, this, &WebView::slotLoadStarted);
     connect(this, &QWebEngineView::loadProgress, this, &WebView::slotLoadProgress);
     connect(this, &QWebEngineView::loadFinished, this, &WebView::slotLoadFinished);
     connect(this, &QWebEngineView::iconChanged, this, &WebView::slotIconChanged);
     connect(this, &QWebEngineView::urlChanged, this, &WebView::slotUrlChanged);
     connect(this, &QWebEngineView::titleChanged, this, &WebView::slotTitleChanged);
 
     m_currentZoomLevel = zoomLevels().indexOf(100);
 
     setAcceptDrops(true);
     installEventFilter(this);
     if (parentWidget()) {
         parentWidget()->installEventFilter(this);
     }
 
     WebInspector::registerView(this);
 }
 
 WebView::~WebView()
 {
     mApp->plugins()->emitWebPageDeleted(m_page);
 
     WebInspector::unregisterView(this);
     WebScrollBarManager::instance()->removeWebView(this);
 }
 
 QIcon WebView::icon(bool allowNull) const
 {
     if (!QWebEngineView::icon().isNull()) {
         return QWebEngineView::icon();
     }
 
     if (url().scheme() == QLatin1String("ftp")) {
         return IconProvider::standardIcon(QStyle::SP_ComputerIcon);
     }
 
     if (url().scheme() == QLatin1String("file")) {
         return IconProvider::standardIcon(QStyle::SP_DriveHDIcon);
     }
 
     return IconProvider::iconForUrl(url(), allowNull);
 }
 
 QString WebView::title(bool allowEmpty) const
 {
     QString title = QWebEngineView::title();
 
     if (allowEmpty) {
         return title;
     }
 
     const QUrl u = url().isEmpty() ? m_page->requestedUrl() : url();
 
     if (title.isEmpty()) {
         title = u.host();
     }
 
     if (title.isEmpty()) {
         title = u.toString(QUrl::RemoveFragment);
     }
 
     if (title.isEmpty() || title == QL1S("about:blank")) {
         return tr("Empty Page");
     }
 
     return title;
 }
 
 WebPage* WebView::page() const
 {
     return m_page;
 }
 
 void WebView::setPage(WebPage *page)
 {
     if (m_page == page) {
         return;
     }
 
     if (m_page) {
         if (m_page->isLoading()) {
             emit m_page->loadProgress(100);
             emit m_page->loadFinished(true);
         }
         mApp->plugins()->emitWebPageDeleted(m_page);
         m_page->setView(nullptr);
     }
 
     page->setParent(this);
     QWebEngineView::setPage(page);
     delete m_page;
     m_page = page;
 
     if (m_page->isLoading()) {
         emit loadStarted();
         emit loadProgress(m_page->m_loadProgress);
     }
 
     connect(m_page, &WebPage::privacyChanged, this, &WebView::privacyChanged);
     connect(m_page, &WebPage::printRequested, this, &WebView::printPage);
 
     // Set default zoom level
     zoomReset();
 
     // Actions needs to be initialized for every QWebEnginePage change
     initializeActions();
 
     // Scrollbars must be added only after QWebEnginePage is set
     WebScrollBarManager::instance()->addWebView(this);
 
     emit pageChanged(m_page);
     mApp->plugins()->emitWebPageCreated(m_page);
 }
 
 void WebView::load(const QUrl &url)
 {
     if (m_page && !m_page->acceptNavigationRequest(url, QWebEnginePage::NavigationTypeTyped, true)) {
         return;
     }
 
     QWebEngineView::load(url);
 
     if (!m_firstLoad) {
         m_firstLoad = true;
         WebInspector::pushView(this);
     }
 }
 
 void WebView::load(const LoadRequest &request)
 {
     const QUrl reqUrl = request.url();
 
     if (reqUrl.isEmpty())
         return;
 
     if (reqUrl.scheme() == QL1S("javascript")) {
         const QString scriptSource = reqUrl.toString().mid(11);
         // Is the javascript source percent encoded or not?
         // Looking for % character in source should work in most cases
         if (scriptSource.contains(QL1C('%')))
             page()->runJavaScript(QUrl::fromPercentEncoding(scriptSource.toUtf8()));
         else
             page()->runJavaScript(scriptSource);
         return;
     }
 
     if (isUrlValid(reqUrl)) {
         loadRequest(request);
     }
 }
 
 bool WebView::isLoading() const
 {
     return m_progress < 100;
 }
 
 int WebView::loadingProgress() const
 {
     return m_progress;
 }
 
 bool WebView::backgroundActivity() const
 {
     return m_backgroundActivity;
 }
 
 int WebView::zoomLevel() const
 {
     return m_currentZoomLevel;
 }
 
 void WebView::setZoomLevel(int level)
 {
     m_currentZoomLevel = level;
     applyZoom();
 }
 
 QPointF WebView::mapToViewport(const QPointF &pos) const
 {
     return page()->mapToViewport(pos);
 }
 
 QRect WebView::scrollBarGeometry(Qt::Orientation orientation) const
 {
     QScrollBar *s = WebScrollBarManager::instance()->scrollBar(orientation, const_cast<WebView*>(this));
     return s && s->isVisible() ? s->geometry() : QRect();
 }
 
 QWidget *WebView::inputWidget() const
 {
     return m_rwhvqt ? m_rwhvqt : const_cast<WebView*>(this);
 }
 
 // static
 bool WebView::isUrlValid(const QUrl &url)
 {
     // Valid url must have scheme and actually contains something (therefore scheme:// is invalid)
     return url.isValid() && !url.scheme().isEmpty() && (!url.host().isEmpty() || !url.path().isEmpty() || url.hasQuery());
 }
 
 // static
 QList<int> WebView::zoomLevels()
 {
     return QList<int>() << 30 << 40 << 50 << 67 << 80 << 90 << 100
            << 110 << 120 << 133 << 150 << 170 << 200
            << 220 << 233 << 250 << 270 << 285 << 300;
 }
 
 // static
 bool WebView::forceContextMenuOnMouseRelease()
 {
     return s_forceContextMenuOnMouseRelease;
 }
 
 // static
 void WebView::setForceContextMenuOnMouseRelease(bool force)
 {
     // Windows open context menu on mouse release by default
 #ifndef Q_OS_WIN
     s_forceContextMenuOnMouseRelease = force;
 #endif
 }
 
 void WebView::addNotification(QWidget* notif)
 {
     emit showNotification(notif);
 }
 
 void WebView::applyZoom()
 {
     setZoomFactor(qreal(zoomLevels().at(m_currentZoomLevel)) / 100.0);
 
     emit zoomLevelChanged(m_currentZoomLevel);
 }
 
 void WebView::zoomIn()
 {
     if (m_currentZoomLevel < zoomLevels().count() - 1) {
         m_currentZoomLevel++;
         applyZoom();
     }
 }
 
 void WebView::zoomOut()
 {
     if (m_currentZoomLevel > 0) {
         m_currentZoomLevel--;
         applyZoom();
     }
 }
 
 void WebView::zoomReset()
 {
     if (m_currentZoomLevel != qzSettings->defaultZoomLevel) {
         m_currentZoomLevel = qzSettings->defaultZoomLevel;
         applyZoom();
     }
 }
 
 void WebView::editUndo()
 {
     triggerPageAction(QWebEnginePage::Undo);
 }
 
 void WebView::editRedo()
 {
     triggerPageAction(QWebEnginePage::Redo);
 }
 
 void WebView::editCut()
 {
     triggerPageAction(QWebEnginePage::Cut);
 }
 
 void WebView::editCopy()
 {
     triggerPageAction(QWebEnginePage::Copy);
 }
 
 void WebView::editPaste()
 {
     triggerPageAction(QWebEnginePage::Paste);
 }
 
 void WebView::editSelectAll()
 {
     triggerPageAction(QWebEnginePage::SelectAll);
 }
 
 void WebView::editDelete()
 {
     QKeyEvent ev(QEvent::KeyPress, Qt::Key_Delete, Qt::NoModifier);
     QApplication::sendEvent(this, &ev);
 }
 
 void WebView::reloadBypassCache()
 {
     triggerPageAction(QWebEnginePage::ReloadAndBypassCache);
 }
 
 void WebView::back()
 {
     QWebEngineHistory* history = page()->history();
 
     if (history->canGoBack()) {
         history->back();
 
         emit urlChanged(url());
     }
 }
 
 void WebView::forward()
 {
     QWebEngineHistory* history = page()->history();
 
     if (history->canGoForward()) {
         history->forward();
 
         emit urlChanged(url());
     }
 }
 
 void WebView::printPage()
 {
     Q_ASSERT(m_page);
 
     QPrinter *printer = new QPrinter();
     printer->setCreator(tr("Falkon %1 (%2)").arg(Qz::VERSION, Qz::WWWADDRESS));
     printer->setDocName(QzTools::filterCharsFromFilename(title()));
 
     QPrintDialog *dialog = new QPrintDialog(printer, this);
     dialog->setOptions(QAbstractPrintDialog::PrintToFile | QAbstractPrintDialog::PrintShowPageSize);
 #ifndef Q_OS_WIN
     dialog->setOption(QAbstractPrintDialog::PrintPageRange);
     dialog->setOption(QAbstractPrintDialog::PrintCollateCopies);
 #endif
 
     if (dialog->exec() == QDialog::Accepted) {
         if (dialog->printer()->outputFormat() == QPrinter::PdfFormat) {
             m_page->printToPdf(dialog->printer()->outputFileName(), dialog->printer()->pageLayout());
             delete dialog;
         } else {
             m_page->print(dialog->printer(), [=](bool success) {
                 Q_UNUSED(success);
                 delete dialog;
             });
         }
     }
 }
 
 void WebView::slotLoadStarted()
 {
     m_progress = 0;
 
     if (title(/*allowEmpty*/true).isEmpty()) {
         emit titleChanged(title());
     }
 }
 
 void WebView::slotLoadProgress(int progress)
 {
     if (m_progress < 100) {
         m_progress = progress;
     }
 
     // QtWebEngine sometimes forgets applied zoom factor
     if (!qFuzzyCompare(zoomFactor(), zoomLevels().at(m_currentZoomLevel) / 100.0)) {
         applyZoom();
     }
 }
 
 void WebView::slotLoadFinished(bool ok)
 {
     m_progress = 100;
 
     if (ok)
         mApp->history()->addHistoryEntry(this);
 }
 
 void WebView::slotIconChanged()
 {
     IconProvider::instance()->saveIcon(this);
 }
 
 void WebView::slotUrlChanged(const QUrl &url)
 {
     if (!url.isEmpty() && title(/*allowEmpty*/true).isEmpty()) {
         // Don't treat this as background activity change
         const bool oldActivity = m_backgroundActivity;
         m_backgroundActivity = true;
         emit titleChanged(title());
         m_backgroundActivity = oldActivity;
     }
 }
 
 void WebView::slotTitleChanged(const QString &title)
 {
     Q_UNUSED(title)
 
     if (!isVisible() && !isLoading() && !m_backgroundActivity) {
         m_backgroundActivity = true;
         emit backgroundActivityChanged(m_backgroundActivity);
     }
 }
 
 void WebView::openUrlInNewWindow()
 {
     if (QAction* action = qobject_cast<QAction*>(sender())) {
         mApp->createWindow(Qz::BW_NewWindow, action->data().toUrl());
     }
 }
 
 void WebView::sendTextByMail()
 {
     if (QAction* action = qobject_cast<QAction*>(sender())) {
         const QUrl mailUrl = QUrl::fromEncoded("mailto:%20?body=" + QUrl::toPercentEncoding(action->data().toString()));
         QDesktopServices::openUrl(mailUrl);
     }
 }
 
 void WebView::sendPageByMail()
 {
     const QUrl mailUrl = QUrl::fromEncoded("mailto:%20?body=" + QUrl::toPercentEncoding(url().toEncoded()) + "&subject=" + QUrl::toPercentEncoding(title()));
     QDesktopServices::openUrl(mailUrl);
 }
 
 void WebView::copyLinkToClipboard()
 {
     if (QAction* action = qobject_cast<QAction*>(sender())) {
         QApplication::clipboard()->setText(action->data().toUrl().toEncoded());
     }
 }
 
 void WebView::savePageAs()
 {
-#if QTWEBENGINEWIDGETS_VERSION >= QT_VERSION_CHECK(5, 10, 0)
     page()->runJavaScript(QSL("document.contentType"), WebPage::SafeJsWorld, [this](const QVariant &res) {
         const QSet<QString> webPageTypes = {
             QSL("text/html"),
             QSL("application/xhtml+xml")
         };
         if (res.isNull() || webPageTypes.contains(res.toString())) {
             triggerPageAction(QWebEnginePage::SavePage);
         } else {
             page()->download(url());
         }
     });
-#else
-    triggerPageAction(QWebEnginePage::SavePage);
-#endif
 }
 
 void WebView::copyImageToClipboard()
 {
     triggerPageAction(QWebEnginePage::CopyImageToClipboard);
 }
 
 void WebView::downloadLinkToDisk()
 {
     triggerPageAction(QWebEnginePage::DownloadLinkToDisk);
 }
 
 void WebView::downloadImageToDisk()
 {
     triggerPageAction(QWebEnginePage::DownloadImageToDisk);
 }
 
 void WebView::downloadMediaToDisk()
 {
     triggerPageAction(QWebEnginePage::DownloadMediaToDisk);
 }
 
 void WebView::openUrlInNewTab(const QUrl &url, Qz::NewTabPositionFlags position)
 {
     loadInNewTab(url, position);
 }
 
 void WebView::openActionUrl()
 {
     if (QAction* action = qobject_cast<QAction*>(sender())) {
         load(action->data().toUrl());
     }
 }
 
 void WebView::showSource()
 {
     // view-source: doesn't work on itself and custom schemes
     if (url().scheme() == QL1S("view-source") || url().scheme() == QL1S("falkon") || url().scheme() == QL1S("qrc")) {
         page()->toHtml([](const QString &html) {
             std::cout << html.toLocal8Bit().constData() << std::endl;
         });
         return;
     }
 
     triggerPageAction(QWebEnginePage::ViewSource);
 }
 
 void WebView::showSiteInfo()
 {
     SiteInfo* s = new SiteInfo(this);
     s->show();
 }
 
 void WebView::searchSelectedText()
 {
     SearchEngine engine = mApp->searchEnginesManager()->defaultEngine();
     if (QAction* act = qobject_cast<QAction*>(sender())) {
         if (act->data().isValid()) {
             engine = act->data().value<SearchEngine>();
         }
     }
 
     const LoadRequest req = mApp->searchEnginesManager()->searchResult(engine, selectedText());
     loadInNewTab(req, Qz::NT_SelectedTab);
 }
 
 void WebView::searchSelectedTextInBackgroundTab()
 {
     SearchEngine engine = mApp->searchEnginesManager()->defaultEngine();
     if (QAction* act = qobject_cast<QAction*>(sender())) {
         if (act->data().isValid()) {
             engine = act->data().value<SearchEngine>();
         }
     }
 
     const LoadRequest req = mApp->searchEnginesManager()->searchResult(engine, selectedText());
     loadInNewTab(req, Qz::NT_NotSelectedTab);
 }
 
 void WebView::bookmarkLink()
 {
     if (QAction* action = qobject_cast<QAction*>(sender())) {
         if (action->data().isNull()) {
             BookmarksTools::addBookmarkDialog(this, url(), title());
         }
         else {
             const QVariantList bData = action->data().value<QVariantList>();
             const QString bookmarkTitle = bData.at(1).toString().isEmpty() ? title() : bData.at(1).toString();
 
             BookmarksTools::addBookmarkDialog(this, bData.at(0).toUrl(), bookmarkTitle);
         }
     }
 }
 
 void WebView::openUrlInSelectedTab()
 {
     if (QAction* action = qobject_cast<QAction*>(sender())) {
         openUrlInNewTab(action->data().toUrl(), Qz::NT_CleanSelectedTab);
     }
 }
 
 void WebView::openUrlInBackgroundTab()
 {
     if (QAction* action = qobject_cast<QAction*>(sender())) {
         openUrlInNewTab(action->data().toUrl(), Qz::NT_CleanNotSelectedTab);
     }
 }
 
 void WebView::userDefinedOpenUrlInNewTab(const QUrl &url, bool invert)
 {
     Qz::NewTabPositionFlags position = qzSettings->newTabPosition;
     if (invert) {
         if (position & Qz::NT_SelectedTab) {
             position &= ~Qz::NT_SelectedTab;
             position |= Qz::NT_NotSelectedTab;
         }
         else {
             position &= ~Qz::NT_NotSelectedTab;
             position |= Qz::NT_SelectedTab;
         }
     }
 
     QUrl actionUrl;
 
     if (!url.isEmpty()) {
         actionUrl = url;
     }
     else if (QAction* action = qobject_cast<QAction*>(sender())) {
         actionUrl = action->data().toUrl();
     }
 
     openUrlInNewTab(actionUrl, position);
 }
 
 void WebView::userDefinedOpenUrlInBgTab(const QUrl &url)
 {
     QUrl actionUrl;
 
     if (!url.isEmpty()) {
         actionUrl = url;
     }
     else if (QAction* action = qobject_cast<QAction*>(sender())) {
         actionUrl = action->data().toUrl();
     }
 
     userDefinedOpenUrlInNewTab(actionUrl, true);
 }
 
 void WebView::showEvent(QShowEvent *event)
 {
     QWebEngineView::showEvent(event);
 
     if (m_backgroundActivity) {
         m_backgroundActivity = false;
         emit backgroundActivityChanged(m_backgroundActivity);
     }
 }
 
 void WebView::createContextMenu(QMenu *menu, WebHitTestResult &hitTest)
 {
     // cppcheck-suppress variableScope
     int spellCheckActionCount = 0;
 
     const QWebEngineContextMenuData &contextMenuData = page()->contextMenuData();
     hitTest.updateWithContextMenuData(contextMenuData);
 
     if (!contextMenuData.misspelledWord().isEmpty()) {
         QFont boldFont = menu->font();
         boldFont.setBold(true);
 
         for (const QString &suggestion : contextMenuData.spellCheckerSuggestions()) {
             QAction *action = menu->addAction(suggestion);
             action->setFont(boldFont);
 
             connect(action, &QAction::triggered, this, [=]() {
                 page()->replaceMisspelledWord(suggestion);
             });
         }
 
         if (menu->actions().isEmpty()) {
             menu->addAction(tr("No suggestions"))->setEnabled(false);
         }
 
         menu->addSeparator();
         spellCheckActionCount = menu->actions().count();
     }
 
     if (!hitTest.linkUrl().isEmpty() && hitTest.linkUrl().scheme() != QL1S("javascript")) {
         createLinkContextMenu(menu, hitTest);
     }
 
     if (!hitTest.imageUrl().isEmpty()) {
         createImageContextMenu(menu, hitTest);
     }
 
     if (!hitTest.mediaUrl().isEmpty()) {
         createMediaContextMenu(menu, hitTest);
     }
 
     if (hitTest.isContentEditable()) {
         // This only checks if the menu is empty (only spellchecker actions added)
         if (menu->actions().count() == spellCheckActionCount) {
             menu->addAction(pageAction(QWebEnginePage::Undo));
             menu->addAction(pageAction(QWebEnginePage::Redo));
             menu->addSeparator();
             menu->addAction(pageAction(QWebEnginePage::Cut));
             menu->addAction(pageAction(QWebEnginePage::Copy));
             menu->addAction(pageAction(QWebEnginePage::Paste));
         }
 
         if (hitTest.tagName() == QL1S("input")) {
             QAction *act = menu->addAction(QString());
             act->setVisible(false);
             checkForForm(act, hitTest.pos());
         }
     }
 
     if (!selectedText().isEmpty()) {
         createSelectedTextContextMenu(menu, hitTest);
     }
 
     if (menu->isEmpty()) {
         createPageContextMenu(menu);
     }
 
     menu->addSeparator();
     mApp->plugins()->populateWebViewMenu(menu, this, hitTest);
 }
 
 void WebView::createPageContextMenu(QMenu* menu)
 {
     QAction* action = menu->addAction(tr("&Back"), this, SLOT(back()));
     action->setIcon(IconProvider::standardIcon(QStyle::SP_ArrowBack));
     action->setEnabled(history()->canGoBack());
 
     action = menu->addAction(tr("&Forward"), this, SLOT(forward()));
     action->setIcon(IconProvider::standardIcon(QStyle::SP_ArrowForward));
     action->setEnabled(history()->canGoForward());
 
     // Special menu for Speed Dial page
     if (url().toString() == QL1S("falkon:speeddial")) {
         menu->addSeparator();
         menu->addAction(QIcon::fromTheme("list-add"), tr("&Add New Page"), this, SLOT(addSpeedDial()));
         menu->addAction(IconProvider::settingsIcon(), tr("&Configure Speed Dial"), this, SLOT(configureSpeedDial()));
         menu->addSeparator();
         menu->addAction(QIcon::fromTheme(QSL("view-refresh")), tr("Reload All Dials"), this, SLOT(reloadAllSpeedDials()));
         return;
     }
 
     QAction *reloadAction = pageAction(QWebEnginePage::Reload);
     action = menu->addAction(reloadAction->icon(), reloadAction->text(), reloadAction, &QAction::trigger);
     action->setVisible(reloadAction->isEnabled());
     connect(reloadAction, &QAction::changed, action, [=]() {
         action->setVisible(reloadAction->isEnabled());
     });
 
     QAction *stopAction = pageAction(QWebEnginePage::Stop);
     action = menu->addAction(stopAction->icon(), stopAction->text(), stopAction, &QAction::trigger);
     action->setVisible(stopAction->isEnabled());
     connect(stopAction, &QAction::changed, action, [=]() {
         action->setVisible(stopAction->isEnabled());
     });
 
     menu->addSeparator();
     menu->addAction(QIcon::fromTheme("bookmark-new"), tr("Book&mark page"), this, SLOT(bookmarkLink()));
     menu->addAction(QIcon::fromTheme("document-save"), tr("&Save page as..."), this, SLOT(savePageAs()));
     menu->addAction(QIcon::fromTheme("edit-copy"), tr("&Copy page link"), this, SLOT(copyLinkToClipboard()))->setData(url());
     menu->addAction(QIcon::fromTheme("mail-message-new"), tr("Send page link..."), this, SLOT(sendPageByMail()));
     menu->addSeparator();
     menu->addAction(QIcon::fromTheme("edit-select-all"), tr("Select &all"), this, SLOT(editSelectAll()));
     menu->addSeparator();
 
     const QString scheme = url().scheme();
 
     if (scheme != QL1S("view-source") && WebPage::internalSchemes().contains(scheme)) {
         menu->addAction(QIcon::fromTheme("text-html"), tr("Show so&urce code"), this, SLOT(showSource()));
     }
 
     if (SiteInfo::canShowSiteInfo(url()))
         menu->addAction(QIcon::fromTheme("dialog-information"), tr("Show info ab&out site"), this, SLOT(showSiteInfo()));
 }
 
 void WebView::createLinkContextMenu(QMenu* menu, const WebHitTestResult &hitTest)
 {
     menu->addSeparator();
     Action* act = new Action(IconProvider::newTabIcon(), tr("Open link in new &tab"));
     act->setData(hitTest.linkUrl());
     connect(act, SIGNAL(triggered()), this, SLOT(userDefinedOpenUrlInNewTab()));
     connect(act, SIGNAL(ctrlTriggered()), this, SLOT(userDefinedOpenUrlInBgTab()));
     menu->addAction(act);
     menu->addAction(IconProvider::newWindowIcon(), tr("Open link in new &window"), this, SLOT(openUrlInNewWindow()))->setData(hitTest.linkUrl());
     menu->addAction(IconProvider::privateBrowsingIcon(), tr("Open link in &private window"), mApp, SLOT(startPrivateBrowsing()))->setData(hitTest.linkUrl());
     menu->addSeparator();
 
     QVariantList bData;
     bData << hitTest.linkUrl() << hitTest.linkTitle();
     menu->addAction(QIcon::fromTheme("bookmark-new"), tr("B&ookmark link"), this, SLOT(bookmarkLink()))->setData(bData);
 
     menu->addAction(QIcon::fromTheme("document-save"), tr("&Save link as..."), this, SLOT(downloadLinkToDisk()));
     menu->addAction(QIcon::fromTheme("mail-message-new"), tr("Send link..."), this, SLOT(sendTextByMail()))->setData(hitTest.linkUrl().toEncoded());
     menu->addAction(QIcon::fromTheme("edit-copy"), tr("&Copy link address"), this, SLOT(copyLinkToClipboard()))->setData(hitTest.linkUrl());
     menu->addSeparator();
 
     if (!selectedText().isEmpty()) {
         pageAction(QWebEnginePage::Copy)->setIcon(QIcon::fromTheme("edit-copy"));
         menu->addAction(pageAction(QWebEnginePage::Copy));
     }
 }
 
 void WebView::createImageContextMenu(QMenu* menu, const WebHitTestResult &hitTest)
 {
     menu->addSeparator();
     if (hitTest.imageUrl() != url()) {
         Action *act = new Action(tr("Show i&mage"));
         act->setData(hitTest.imageUrl());
         connect(act, SIGNAL(triggered()), this, SLOT(openActionUrl()));
         connect(act, SIGNAL(ctrlTriggered()), this, SLOT(userDefinedOpenUrlInNewTab()));
         menu->addAction(act);
     }
     menu->addAction(tr("Copy image"), this, SLOT(copyImageToClipboard()));
     menu->addAction(QIcon::fromTheme("edit-copy"), tr("Copy image ad&dress"), this, SLOT(copyLinkToClipboard()))->setData(hitTest.imageUrl());
     menu->addSeparator();
     menu->addAction(QIcon::fromTheme("document-save"), tr("&Save image as..."), this, SLOT(downloadImageToDisk()));
     menu->addAction(QIcon::fromTheme("mail-message-new"), tr("Send image..."), this, SLOT(sendTextByMail()))->setData(hitTest.imageUrl().toEncoded());
     menu->addSeparator();
 
     if (!selectedText().isEmpty()) {
         pageAction(QWebEnginePage::Copy)->setIcon(QIcon::fromTheme("edit-copy"));
         menu->addAction(pageAction(QWebEnginePage::Copy));
     }
 }
 
 void WebView::createSelectedTextContextMenu(QMenu* menu, const WebHitTestResult &hitTest)
 {
     Q_UNUSED(hitTest)
 
     QString selectedText = page()->selectedText();
 
     menu->addSeparator();
     if (!menu->actions().contains(pageAction(QWebEnginePage::Copy))) {
         menu->addAction(pageAction(QWebEnginePage::Copy));
     }
     menu->addAction(QIcon::fromTheme("mail-message-new"), tr("Send text..."), this, SLOT(sendTextByMail()))->setData(selectedText);
     menu->addSeparator();
 
     // #379: Remove newlines
     QString selectedString = selectedText.trimmed().remove(QLatin1Char('\n'));
     if (!selectedString.contains(QLatin1Char('.'))) {
         // Try to add .com
         selectedString.append(QLatin1String(".com"));
     }
     QUrl guessedUrl = QUrl::fromUserInput(selectedString);
 
     if (isUrlValid(guessedUrl)) {
         Action* act = new Action(QIcon::fromTheme("document-open-remote"), tr("Go to &web address"));
         act->setData(guessedUrl);
 
         connect(act, SIGNAL(triggered()), this, SLOT(openActionUrl()));
         connect(act, SIGNAL(ctrlTriggered()), this, SLOT(userDefinedOpenUrlInNewTab()));
         menu->addAction(act);
     }
 
     menu->addSeparator();
     selectedText.truncate(20);
     // KDE is displaying newlines in menu actions ... weird -,-
     selectedText.replace(QLatin1Char('\n'), QLatin1Char(' ')).replace(QLatin1Char('\t'), QLatin1Char(' '));
 
     SearchEngine engine = mApp->searchEnginesManager()->defaultEngine();
     Action* act = new Action(engine.icon, tr("Search \"%1 ..\" with %2").arg(selectedText, engine.name));
     connect(act, SIGNAL(triggered()), this, SLOT(searchSelectedText()));
     connect(act, SIGNAL(ctrlTriggered()), this, SLOT(searchSelectedTextInBackgroundTab()));
     menu->addAction(act);
 
     // Search with ...
     Menu* swMenu = new Menu(tr("Search with..."), menu);
     swMenu->setCloseOnMiddleClick(true);
     SearchEnginesManager* searchManager = mApp->searchEnginesManager();
     foreach (const SearchEngine &en, searchManager->allEngines()) {
         Action* act = new Action(en.icon, en.name);
         act->setData(QVariant::fromValue(en));
 
         connect(act, SIGNAL(triggered()), this, SLOT(searchSelectedText()));
         connect(act, SIGNAL(ctrlTriggered()), this, SLOT(searchSelectedTextInBackgroundTab()));
         swMenu->addAction(act);
     }
 
     menu->addMenu(swMenu);
 }
 
 void WebView::createMediaContextMenu(QMenu *menu, const WebHitTestResult &hitTest)
 {
     bool paused = hitTest.mediaPaused();
     bool muted = hitTest.mediaMuted();
 
     menu->addSeparator();
     menu->addAction(paused ? tr("&Play") : tr("&Pause"), this, SLOT(toggleMediaPause()))->setIcon(QIcon::fromTheme(paused ? "media-playback-start" : "media-playback-pause"));
     menu->addAction(muted ? tr("Un&mute") : tr("&Mute"), this, SLOT(toggleMediaMute()))->setIcon(QIcon::fromTheme(muted ? "audio-volume-muted" : "audio-volume-high"));
     menu->addSeparator();
     menu->addAction(QIcon::fromTheme("edit-copy"), tr("&Copy Media Address"), this, SLOT(copyLinkToClipboard()))->setData(hitTest.mediaUrl());
     menu->addAction(QIcon::fromTheme("mail-message-new"), tr("&Send Media Address"), this, SLOT(sendTextByMail()))->setData(hitTest.mediaUrl().toEncoded());
     menu->addAction(QIcon::fromTheme("document-save"), tr("Save Media To &Disk"), this, SLOT(downloadMediaToDisk()));
 }
 
 void WebView::checkForForm(QAction *action, const QPoint &pos)
 {
     m_clickedPos = mapToViewport(pos);
     QPointer<QAction> act = action;
 
     page()->runJavaScript(Scripts::getFormData(m_clickedPos), WebPage::SafeJsWorld, [this, act](const QVariant &res) {
         const QVariantMap &map = res.toMap();
         if (!act || map.isEmpty())
             return;
 
         const QUrl url = map.value(QSL("action")).toUrl();
         const QString method = map.value(QSL("method")).toString();
 
         if (!url.isEmpty() && (method == QL1S("get") || method == QL1S("post"))) {
             act->setVisible(true);
             act->setIcon(QIcon::fromTheme(QSL("edit-find"), QIcon(QSL(":icons/menu/search-icon.svg"))));
             act->setText(tr("Create Search Engine"));
             connect(act.data(), &QAction::triggered, this, &WebView::createSearchEngine);
         }
     });
 }
 
 void WebView::createSearchEngine()
 {
     page()->runJavaScript(Scripts::getFormData(m_clickedPos), WebPage::SafeJsWorld, [this](const QVariant &res) {
         mApp->searchEnginesManager()->addEngineFromForm(res.toMap(), this);
     });
 }
 
 void WebView::addSpeedDial()
 {
     page()->runJavaScript("addSpeedDial()");
 }
 
 void WebView::configureSpeedDial()
 {
     page()->runJavaScript("configureSpeedDial()");
 }
 
 void WebView::reloadAllSpeedDials()
 {
     page()->runJavaScript("reloadAll()");
 }
 
 void WebView::toggleMediaPause()
 {
     triggerPageAction(QWebEnginePage::ToggleMediaPlayPause);
 }
 
 void WebView::toggleMediaMute()
 {
     triggerPageAction(QWebEnginePage::ToggleMediaMute);
 }
 
 void WebView::initializeActions()
 {
     QAction* undoAction = pageAction(QWebEnginePage::Undo);
     undoAction->setText(tr("&Undo"));
     undoAction->setShortcut(QKeySequence("Ctrl+Z"));
     undoAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     undoAction->setIcon(QIcon::fromTheme(QSL("edit-undo")));
 
     QAction* redoAction = pageAction(QWebEnginePage::Redo);
     redoAction->setText(tr("&Redo"));
     redoAction->setShortcut(QKeySequence("Ctrl+Shift+Z"));
     redoAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     redoAction->setIcon(QIcon::fromTheme(QSL("edit-redo")));
 
     QAction* cutAction = pageAction(QWebEnginePage::Cut);
     cutAction->setText(tr("&Cut"));
     cutAction->setShortcut(QKeySequence("Ctrl+X"));
     cutAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     cutAction->setIcon(QIcon::fromTheme(QSL("edit-cut")));
 
     QAction* copyAction = pageAction(QWebEnginePage::Copy);
     copyAction->setText(tr("&Copy"));
     copyAction->setShortcut(QKeySequence("Ctrl+C"));
     copyAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     copyAction->setIcon(QIcon::fromTheme(QSL("edit-copy")));
 
     QAction* pasteAction = pageAction(QWebEnginePage::Paste);
     pasteAction->setText(tr("&Paste"));
     pasteAction->setShortcut(QKeySequence("Ctrl+V"));
     pasteAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     pasteAction->setIcon(QIcon::fromTheme(QSL("edit-paste")));
 
     QAction* selectAllAction = pageAction(QWebEnginePage::SelectAll);
     selectAllAction->setText(tr("Select All"));
     selectAllAction->setShortcut(QKeySequence("Ctrl+A"));
     selectAllAction->setShortcutContext(Qt::WidgetWithChildrenShortcut);
     selectAllAction->setIcon(QIcon::fromTheme(QSL("edit-select-all")));
 
     QAction* reloadAction = pageAction(QWebEnginePage::Reload);
     reloadAction->setText(tr("&Reload"));
     reloadAction->setIcon(QIcon::fromTheme(QSL("view-refresh")));
 
     QAction* stopAction = pageAction(QWebEnginePage::Stop);
     stopAction->setText(tr("S&top"));
     stopAction->setIcon(QIcon::fromTheme(QSL("process-stop")));
 
     // Make action shortcuts available for webview
     addAction(undoAction);
     addAction(redoAction);
     addAction(cutAction);
     addAction(copyAction);
     addAction(pasteAction);
     addAction(selectAllAction);
 }
 
 void WebView::_wheelEvent(QWheelEvent *event)
 {
     if (mApp->plugins()->processWheelEvent(Qz::ON_WebView, this, event)) {
         event->accept();
         return;
     }
 
     if (event->modifiers() & Qt::ControlModifier) {
         m_wheelHelper.processEvent(event);
         while (WheelHelper::Direction direction = m_wheelHelper.takeDirection()) {
             switch (direction) {
             case WheelHelper::WheelUp:
             case WheelHelper::WheelLeft:
                 zoomIn();
                 break;
 
             case WheelHelper::WheelDown:
             case WheelHelper::WheelRight:
                 zoomOut();
                 break;
 
             default:
                 break;
             }
         }
         event->accept();
         return;
     }
 
     m_wheelHelper.reset();
 
     // QtWebEngine ignores QApplication::wheelScrollLines() and instead always scrolls 3 lines
     if (event->spontaneous()) {
         const qreal multiplier = QApplication::wheelScrollLines() / 3.0;
         if (multiplier != 1.0) {
             QWheelEvent e(event->pos(), event->globalPos(), event->pixelDelta(),
                           event->angleDelta() * multiplier, 0, Qt::Horizontal, event->buttons(),
                           event->modifiers(), event->phase(), event->source(), event->inverted());
             QApplication::sendEvent(m_rwhvqt, &e);
             event->accept();
         }
     }
 }
 
 void WebView::_mousePressEvent(QMouseEvent *event)
 {
     m_clickedUrl = QUrl();
     m_clickedPos = QPointF();
 
     if (mApp->plugins()->processMousePress(Qz::ON_WebView, this, event)) {
         event->accept();
         return;
     }
 
     switch (event->button()) {
     case Qt::XButton1:
         back();
         event->accept();
         break;
 
     case Qt::XButton2:
         forward();
         event->accept();
         break;
 
     case Qt::MiddleButton:
         m_clickedUrl = page()->hitTestContent(event->pos()).linkUrl();
         if (!m_clickedUrl.isEmpty())
             event->accept();
         break;
 
     case Qt::LeftButton:
         m_clickedUrl = page()->hitTestContent(event->pos()).linkUrl();
         break;
 
     default:
         break;
     }
 }
 
 void WebView::_mouseReleaseEvent(QMouseEvent *event)
 {
     if (mApp->plugins()->processMouseRelease(Qz::ON_WebView, this, event)) {
         event->accept();
         return;
     }
 
     switch (event->button()) {
     case Qt::MiddleButton:
         if (!m_clickedUrl.isEmpty()) {
             const QUrl link = page()->hitTestContent(event->pos()).linkUrl();
             if (m_clickedUrl == link && isUrlValid(link)) {
                 userDefinedOpenUrlInNewTab(link, event->modifiers() & Qt::ShiftModifier);
                 event->accept();
             }
         }
         break;
 
     case Qt::LeftButton:
         if (!m_clickedUrl.isEmpty()) {
             const QUrl link = page()->hitTestContent(event->pos()).linkUrl();
             if (m_clickedUrl == link && isUrlValid(link)) {
                 if (event->modifiers() & Qt::ControlModifier) {
                     userDefinedOpenUrlInNewTab(link, event->modifiers() & Qt::ShiftModifier);
                     event->accept();
                 }
             }
         }
         break;
 
     case Qt::RightButton:
         if (s_forceContextMenuOnMouseRelease) {
             QContextMenuEvent ev(QContextMenuEvent::Mouse, event->pos(), event->globalPos(), event->modifiers());
             _contextMenuEvent(&ev);
             event->accept();
         }
         break;
 
     default:
         break;
     }
 }
 
 void WebView::_mouseMoveEvent(QMouseEvent *event)
 {
     if (mApp->plugins()->processMouseMove(Qz::ON_WebView, this, event)) {
         event->accept();
     }
 }
 
 void WebView::_keyPressEvent(QKeyEvent *event)
 {
     if (mApp->plugins()->processKeyPress(Qz::ON_WebView, this, event)) {
         event->accept();
         return;
     }
 
     switch (event->key()) {
     case Qt::Key_ZoomIn:
         zoomIn();
         event->accept();
         break;
 
     case Qt::Key_ZoomOut:
         zoomOut();
         event->accept();
         break;
 
     case Qt::Key_Plus:
         if (event->modifiers() & Qt::ControlModifier) {
             zoomIn();
             event->accept();
         }
         break;
 
     case Qt::Key_Minus:
         if (event->modifiers() & Qt::ControlModifier) {
             zoomOut();
             event->accept();
         }
         break;
 
     case Qt::Key_0:
         if (event->modifiers() & Qt::ControlModifier) {
             zoomReset();
             event->accept();
         }
         break;
 
     case Qt::Key_M:
         if (event->modifiers() & Qt::ControlModifier) {
             page()->setAudioMuted(!page()->isAudioMuted());
             event->accept();
         }
         break;
 
     default:
         break;
     }
 }
 
 void WebView::_keyReleaseEvent(QKeyEvent *event)
 {
     if (mApp->plugins()->processKeyRelease(Qz::ON_WebView, this, event)) {
         event->accept();
     }
 
     switch (event->key()) {
     case Qt::Key_Escape:
         if (isFullScreen()) {
             triggerPageAction(QWebEnginePage::ExitFullScreen);
             event->accept();
         }
         break;
 
     default:
         break;
     }
 }
 
 void WebView::_contextMenuEvent(QContextMenuEvent *event)
 {
     Q_UNUSED(event)
 }
 
 void WebView::resizeEvent(QResizeEvent *event)
 {
     QWebEngineView::resizeEvent(event);
     emit viewportResized(size());
 }
 
 void WebView::contextMenuEvent(QContextMenuEvent *event)
 {
     // Context menu is created in mouseReleaseEvent
     if (s_forceContextMenuOnMouseRelease)
         return;
 
     const QPoint pos = event->pos();
     const QContextMenuEvent::Reason reason = event->reason();
 
     QTimer::singleShot(0, this, [this, pos, reason]() {
         QContextMenuEvent ev(reason, pos);
         _contextMenuEvent(&ev);
     });
 }
 
 bool WebView::focusNextPrevChild(bool next)
 {
 #if QTWEBENGINEWIDGETS_VERSION < QT_VERSION_CHECK(5, 11, 0)
     // QTBUG-67043
     // Workaround QtWebEngine issue where QWebEngineView loses focus on second load() call.
     if (next) {
         setFocus();
         return false;
     }
 #endif
     return QWebEngineView::focusNextPrevChild(next);
 }
 
 void WebView::loadRequest(const LoadRequest &req)
 {
     QWebEngineView::load(req.webRequest());
 }
 
 bool WebView::eventFilter(QObject *obj, QEvent *event)
 {
     // Keyboard events are sent to parent widget
     if (obj == this && event->type() == QEvent::ParentChange && parentWidget()) {
         parentWidget()->installEventFilter(this);
     }
 
     // Hack to find widget that receives input events
     if (obj == this && event->type() == QEvent::ChildAdded) {
         QTimer::singleShot(0, this, [this]() {
             if (focusProxy() && m_rwhvqt != focusProxy()) {
                 m_rwhvqt = focusProxy();
                 m_rwhvqt->installEventFilter(this);
                 if (QQuickWidget *w = qobject_cast<QQuickWidget*>(m_rwhvqt)) {
                     w->setClearColor(palette().color(QPalette::Window));
                 }
             }
         });
     }
 
     // Forward events to WebView
 #define HANDLE_EVENT(f, t) \
     { \
     bool wasAccepted = event->isAccepted(); \
     event->setAccepted(false); \
     f(static_cast<t*>(event)); \
     bool ret = event->isAccepted(); \
     event->setAccepted(wasAccepted); \
     return ret; \
     }
 
     if (obj == m_rwhvqt) {
         switch (event->type()) {
         case QEvent::MouseButtonPress:
             HANDLE_EVENT(_mousePressEvent, QMouseEvent);
 
         case QEvent::MouseButtonRelease:
             HANDLE_EVENT(_mouseReleaseEvent, QMouseEvent);
 
         case QEvent::MouseMove:
             HANDLE_EVENT(_mouseMoveEvent, QMouseEvent);
 
         case QEvent::Wheel:
             HANDLE_EVENT(_wheelEvent, QWheelEvent);
 
         default:
             break;
         }
     }
 
     if (obj == parentWidget()) {
         switch (event->type()) {
         case QEvent::KeyPress:
             HANDLE_EVENT(_keyPressEvent, QKeyEvent);
 
         case QEvent::KeyRelease:
             HANDLE_EVENT(_keyReleaseEvent, QKeyEvent);
 
         default:
             break;
         }
     }
 #undef HANDLE_EVENT
 
     // Block already handled events
     if (obj == this) {
         switch (event->type()) {
         case QEvent::KeyPress:
         case QEvent::KeyRelease:
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease:
         case QEvent::MouseMove:
         case QEvent::Wheel:
             return true;
 
         case QEvent::Hide:
             if (isFullScreen()) {
                 triggerPageAction(QWebEnginePage::ExitFullScreen);
             }
             break;
 
         default:
             break;
         }
     }
 
     const bool res = QWebEngineView::eventFilter(obj, event);
 
     if (obj == m_rwhvqt) {
         switch (event->type()) {
         case QEvent::FocusIn:
         case QEvent::FocusOut:
             emit focusChanged(hasFocus());
             break;
 
         default:
             break;
         }
     }
 
     return res;
 }