diff --git a/keyboard_layout.cpp b/keyboard_layout.cpp
index 810dd5d9e..d3697a45a 100644
--- a/keyboard_layout.cpp
+++ b/keyboard_layout.cpp
@@ -1,342 +1,342 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016, 2017 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "keyboard_layout.h"
 #include "keyboard_layout_switching.h"
 #include "keyboard_input.h"
 #include "input_event.h"
 #include "main.h"
 #include "platform.h"
 #include "utils.h"
 
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KNotifications/KStatusNotifierItem>
 #include <QAction>
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingCall>
 #include <QMenu>
 
 namespace KWin
 {
 
 KeyboardLayout::KeyboardLayout(Xkb *xkb)
     : QObject()
     , m_xkb(xkb)
     , m_notifierItem(nullptr)
 {
 }
 
 KeyboardLayout::~KeyboardLayout() = default;
 
 static QString translatedLayout(const QString &layout)
 {
     return i18nd("xkeyboard-config", layout.toUtf8().constData());
 }
 
 void KeyboardLayout::init()
 {
     QAction *switchKeyboardAction = new QAction(this);
     switchKeyboardAction->setObjectName(QStringLiteral("Switch to Next Keyboard Layout"));
     switchKeyboardAction->setProperty("componentName", QStringLiteral("KDE Keyboard Layout Switcher"));
     const QKeySequence sequence = QKeySequence(Qt::ALT+Qt::CTRL+Qt::Key_K);
     KGlobalAccel::self()->setDefaultShortcut(switchKeyboardAction, QList<QKeySequence>({sequence}));
     KGlobalAccel::self()->setShortcut(switchKeyboardAction, QList<QKeySequence>({sequence}));
     kwinApp()->platform()->setupActionForGlobalAccel(switchKeyboardAction);
     connect(switchKeyboardAction, &QAction::triggered, this, &KeyboardLayout::switchToNextLayout);
 
     QDBusConnection::sessionBus().connect(QString(),
                                           QStringLiteral("/Layouts"),
                                           QStringLiteral("org.kde.keyboard"),
                                           QStringLiteral("reloadConfig"),
                                           this,
                                           SLOT(reconfigure()));
 
     reconfigure();
 }
 
 void KeyboardLayout::initDBusInterface()
 {
     if (m_xkb->numberOfLayouts() <= 1) {
         delete m_dbusInterface;
         m_dbusInterface = nullptr;
         return;
     }
     if (m_dbusInterface) {
         return;
     }
     m_dbusInterface = new KeyboardLayoutDBusInterface(m_xkb, this);
     connect(this, &KeyboardLayout::layoutChanged, m_dbusInterface,
         [this] {
             emit m_dbusInterface->currentLayoutChanged(m_xkb->layoutName());
         }
     );
     // TODO: the signal might be emitted even if the list didn't change
     connect(this, &KeyboardLayout::layoutsReconfigured, m_dbusInterface, &KeyboardLayoutDBusInterface::layoutListChanged);
 }
 
 void KeyboardLayout::initNotifierItem()
 {
     bool showNotifier = true;
     bool showSingle = false;
     if (m_config) {
         const auto config = m_config->group(QStringLiteral("Layout"));
         showNotifier = config.readEntry("ShowLayoutIndicator", true);
         showSingle = config.readEntry("ShowSingle", false);
     }
     const bool shouldShow = showNotifier && (showSingle || m_xkb->numberOfLayouts() > 1);
     if (shouldShow) {
         if (m_notifierItem) {
             return;
         }
     } else {
         delete m_notifierItem;
         m_notifierItem = nullptr;
         return;
     }
 
     m_notifierItem = new KStatusNotifierItem(this);
     m_notifierItem->setCategory(KStatusNotifierItem::Hardware);
     m_notifierItem->setStatus(KStatusNotifierItem::Active);
     m_notifierItem->setToolTipTitle(i18nc("tooltip title", "Keyboard Layout"));
     m_notifierItem->setTitle(i18nc("tooltip title", "Keyboard Layout"));
     m_notifierItem->setToolTipIconByName(QStringLiteral("preferences-desktop-keyboard"));
     m_notifierItem->setStandardActionsEnabled(false);
 
     // TODO: proper icon
     m_notifierItem->setIconByName(QStringLiteral("preferences-desktop-keyboard"));
 
     connect(m_notifierItem, &KStatusNotifierItem::activateRequested, this, &KeyboardLayout::switchToNextLayout);
     connect(m_notifierItem, &KStatusNotifierItem::scrollRequested, this,
         [this] (int delta, Qt::Orientation orientation) {
             if (orientation == Qt::Horizontal) {
                 return;
             }
             if (delta > 0) {
                 switchToNextLayout();
             } else {
                 switchToPreviousLayout();
             }
         }
     );
 
     m_notifierItem->setStatus(KStatusNotifierItem::Active);
 }
 
 void KeyboardLayout::switchToNextLayout()
 {
     m_xkb->switchToNextLayout();
     checkLayoutChange();
 }
 
 void KeyboardLayout::switchToPreviousLayout()
 {
     m_xkb->switchToPreviousLayout();
     checkLayoutChange();
 }
 
 void KeyboardLayout::switchToLayout(xkb_layout_index_t index)
 {
     m_xkb->switchToLayout(index);
     checkLayoutChange();
 }
 
 void KeyboardLayout::reconfigure()
 {
     if (m_config) {
         m_config->reparseConfiguration();
         const QString policyKey = m_config->group(QStringLiteral("Layout")).readEntry("SwitchMode", QStringLiteral("Global"));
         if (!m_policy || m_policy->name() != policyKey) {
             delete m_policy;
             m_policy = KeyboardLayoutSwitching::Policy::create(m_xkb, this, policyKey);
         }
     }
     m_xkb->reconfigure();
     resetLayout();
 }
 
 void KeyboardLayout::resetLayout()
 {
     m_layout = m_xkb->currentLayout();
     initNotifierItem();
     updateNotifier();
     reinitNotifierMenu();
     loadShortcuts();
     emit layoutsReconfigured();
 
     initDBusInterface();
 }
 
 void KeyboardLayout::loadShortcuts()
 {
     qDeleteAll(m_layoutShortcuts);
     m_layoutShortcuts.clear();
     const auto layouts = m_xkb->layoutNames();
     const QString componentName = QStringLiteral("KDE Keyboard Layout Switcher");
     for (auto it = layouts.begin(); it != layouts.end(); it++) {
         // layout name is translated in the action name in keyboard kcm!
         const QString action = QStringLiteral("Switch keyboard layout to %1").arg(translatedLayout(it.value()));
         const auto shortcuts = KGlobalAccel::self()->globalShortcut(componentName, action);
         if (shortcuts.isEmpty()) {
             continue;
         }
         QAction *a = new QAction(this);
         a->setObjectName(action);
         a->setProperty("componentName", componentName);
         connect(a, &QAction::triggered, this,
                 std::bind(&KeyboardLayout::switchToLayout, this, it.key()));
         KGlobalAccel::self()->setShortcut(a, shortcuts, KGlobalAccel::Autoloading);
         m_layoutShortcuts << a;
     }
 }
 
 void KeyboardLayout::keyEvent(KeyEvent *event)
 {
     if (!event->isAutoRepeat()) {
         checkLayoutChange();
     }
 }
 
 void KeyboardLayout::checkLayoutChange()
 {
     const auto layout = m_xkb->currentLayout();
     if (m_layout == layout) {
         return;
     }
     m_layout = layout;
     notifyLayoutChange();
     updateNotifier();
     emit layoutChanged();
 }
 
 void KeyboardLayout::notifyLayoutChange()
 {
     // notify OSD service about the new layout
     QDBusMessage msg = QDBusMessage::createMethodCall(
         QStringLiteral("org.kde.plasmashell"),
         QStringLiteral("/org/kde/osdService"),
         QStringLiteral("org.kde.osdService"),
         QStringLiteral("kbdLayoutChanged"));
 
     msg << translatedLayout(m_xkb->layoutName());
 
     QDBusConnection::sessionBus().asyncCall(msg);
 }
 
 void KeyboardLayout::updateNotifier()
 {
     if (!m_notifierItem) {
         return;
     }
     m_notifierItem->setToolTipSubTitle(translatedLayout(m_xkb->layoutName()));
     // TODO: update icon
 }
 
 void KeyboardLayout::reinitNotifierMenu()
 {
     if (!m_notifierItem) {
         return;
     }
     const auto layouts = m_xkb->layoutNames();
 
     QMenu *menu = new QMenu;
     for (auto it = layouts.begin(); it != layouts.end(); it++) {
         menu->addAction(translatedLayout(it.value()), std::bind(&KeyboardLayout::switchToLayout, this, it.key()));
     }
 
     menu->addSeparator();
     menu->addAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure Layouts..."), this,
         [this] {
             // TODO: introduce helper function to start kcmshell5
             QProcess *p = new Process(this);
             p->setArguments(QStringList{QStringLiteral("--args=--tab=layouts"), QStringLiteral("kcm_keyboard")});
             p->setProcessEnvironment(kwinApp()->processStartupEnvironment());
             p->setProgram(QStringLiteral("kcmshell5"));
             connect(p, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), p, &QProcess::deleteLater);
             connect(p, static_cast<void (QProcess::*)(QProcess::ProcessError)>(&QProcess::error), this,
-                [p] (QProcess::ProcessError e) {
+                [] (QProcess::ProcessError e) {
                     if (e == QProcess::FailedToStart) {
                         qCDebug(KWIN_CORE) << "Failed to start kcmshell5";
                     }
                 }
             );
             p->start();
         }
     );
 
     m_notifierItem->setContextMenu(menu);
 }
 
 static const QString s_keyboardService = QStringLiteral("org.kde.keyboard");
 static const QString s_keyboardObject = QStringLiteral("/Layouts");
 
 KeyboardLayoutDBusInterface::KeyboardLayoutDBusInterface(Xkb *xkb, KeyboardLayout *parent)
     : QObject(parent)
     , m_xkb(xkb)
     , m_keyboardLayout(parent)
 {
     QDBusConnection::sessionBus().registerService(s_keyboardService);
     QDBusConnection::sessionBus().registerObject(s_keyboardObject, this, QDBusConnection::ExportAllSlots | QDBusConnection::ExportAllSignals);
 }
 
 KeyboardLayoutDBusInterface::~KeyboardLayoutDBusInterface()
 {
     QDBusConnection::sessionBus().unregisterService(s_keyboardService);
 }
 
 bool KeyboardLayoutDBusInterface::setLayout(const QString &layout)
 {
     const auto layouts = m_xkb->layoutNames();
     auto it = layouts.begin();
     for (; it !=layouts.end(); it++) {
         if (it.value() == layout) {
             break;
         }
     }
     if (it == layouts.end()) {
         return false;
     }
     m_xkb->switchToLayout(it.key());
     m_keyboardLayout->checkLayoutChange();
     return true;
 }
 
 QString KeyboardLayoutDBusInterface::getCurrentLayout()
 {
     return m_xkb->layoutName();
 }
 
 QStringList KeyboardLayoutDBusInterface::getLayoutsList()
 {
     const auto layouts = m_xkb->layoutNames();
     QStringList ret;
     for (auto it = layouts.begin(); it != layouts.end(); it++) {
         ret << it.value();
     }
     return ret;
 }
 
 QString KeyboardLayoutDBusInterface::getLayoutDisplayName(const QString &layout)
 {
     return translatedLayout(layout);
 }
 
 }