diff --git a/components/sessionsprivate/sessionsmodel.cpp b/components/sessionsprivate/sessionsmodel.cpp
index 64653ac0e..25d3f3d19 100644
--- a/components/sessionsprivate/sessionsmodel.cpp
+++ b/components/sessionsprivate/sessionsmodel.cpp
@@ -1,297 +1,297 @@
 /*
     Copyright 2015 Kai Uwe Broulik <kde@privat.broulik.de>
 
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"), to deal
     in the Software without restriction, including without limitation the rights
     to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     copies of the Software, and to permit persons to whom the Software is
     furnished to do so, subject to the following conditions:
 
     The above copyright notice and this permission notice shall be included in
     all copies or substantial portions of the Software.
 
     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     THE SOFTWARE.
 */
 
 #include "sessionsmodel.h"
 
 #include <KAuthorized>
 #include <KUser>
 #include <KLocalizedString>
 
 #include "kscreensaversettings.h"
 
 #include "screensaver_interface.h"
 
 SessionsModel::SessionsModel(QObject *parent)
     : QAbstractListModel(parent)
     , m_screensaverInterface(
         new org::freedesktop::ScreenSaver(QStringLiteral("org.freedesktop.ScreenSaver"),
                                           QStringLiteral("/ScreenSaver"),
                                           QDBusConnection::sessionBus(),
                                           this)
         )
 {
     reload();
 
     // wait for the screen locker to be ready before actually switching
     connect(m_screensaverInterface, &org::freedesktop::ScreenSaver::ActiveChanged, this, [this](bool active) {
         if (active) {
             if (m_pendingVt) {
                 m_displayManager.switchVT(m_pendingVt);
                 emit switchedUser(m_pendingVt);
             } else if (m_pendingReserve) {
                 m_displayManager.startReserve();
                 emit startedNewSession();
             }
 
             m_pendingVt = 0;
             m_pendingReserve = false;
         }
     });
 }
 
 bool SessionsModel::canSwitchUser() const
 {
     return const_cast<SessionsModel *>(this)->m_displayManager.isSwitchable() && KAuthorized::authorizeAction(QLatin1String("switch_user"));
 }
 
 bool SessionsModel::canStartNewSession() const
 {
     return const_cast<SessionsModel *>(this)->m_displayManager.numReserve() > 0 && KAuthorized::authorizeAction(QLatin1String("start_new_session"));
 }
 
 bool SessionsModel::shouldLock() const
 {
     return m_shouldLock;
 }
 
 bool SessionsModel::includeUnusedSessions() const
 {
     return m_includeUnusedSessions;
 }
 
 void SessionsModel::setIncludeUnusedSessions(bool includeUnusedSessions)
 {
     if (m_includeUnusedSessions != includeUnusedSessions) {
         m_includeUnusedSessions = includeUnusedSessions;
 
         reload();
 
         emit includeUnusedSessionsChanged();
     }
 }
 
 void SessionsModel::switchUser(int vt, bool shouldLock)
 {
     if (vt < 0) {
         startNewSession(shouldLock);
         return;
     }
 
     if (!canSwitchUser()) {
         return;
     }
 
     if (!shouldLock) {
         m_displayManager.switchVT(vt);
         emit switchedUser(vt);
         return;
     }
 
     checkScreenLocked([this, vt](bool locked) {
         if (locked) {
             // already locked, switch right away
             m_displayManager.switchVT(vt);
             emit switchedUser(vt);
         } else {
             m_pendingReserve = false;
             m_pendingVt = vt;
 
             emit aboutToLockScreen();
             m_screensaverInterface->Lock();
         }
     });
 }
 
 void SessionsModel::startNewSession(bool shouldLock)
 {
     if (!canStartNewSession()) {
         return;
     }
 
     if (!shouldLock) {
         m_displayManager.startReserve();
         emit startedNewSession();
         return;
     }
 
     checkScreenLocked([this](bool locked) {
         if (locked) {
             // already locked, switch right away
             m_displayManager.startReserve();
             emit startedNewSession();
         } else {
             m_pendingReserve = true;
             m_pendingVt = 0;
 
             emit aboutToLockScreen();
             m_screensaverInterface->Lock();
         }
     });
 }
 
 void SessionsModel::reload()
 {
     static QHash<QString, KUser> kusers;
 
     const bool oldShouldLock = m_shouldLock;
     m_shouldLock = KAuthorized::authorizeAction(QStringLiteral("lock_screen")) && KScreenSaverSettings::autolock();
     if (m_shouldLock != oldShouldLock) {
         emit shouldLockChanged();
     }
 
     SessList sessions;
     m_displayManager.localSessions(sessions);
 
     const int oldCount = m_data.count();
 
     beginResetModel();
 
     m_data.clear();
     m_data.reserve(sessions.count());
 
     foreach (const SessEnt &session, sessions) {
         if (!session.vt || session.self) {
             continue;
         }
 
         if (!m_includeUnusedSessions && session.session.isEmpty()) {
             continue;
         }
 
         SessionEntry entry;
         entry.name = session.user;
         entry.displayNumber = session.display;
         entry.vtNumber = session.vt;
         entry.session = session.session;
         entry.isTty = session.tty;
 
         auto it = kusers.constFind(session.user);
         if (it != kusers.constEnd()) {
             entry.realName = it->property(KUser::FullName).toString();
             entry.icon = it->faceIconPath();
         } else {
             KUser user(session.user);
             entry.realName = user.property(KUser::FullName).toString();
             entry.icon = user.faceIconPath();
             kusers.insert(session.user, user);
         }
 
         m_data.append(entry);
     }
 
     endResetModel();
 
     if (oldCount != m_data.count()) {
         emit countChanged();
     }
 }
 
 void SessionsModel::checkScreenLocked(const std::function<void (bool)> &cb)
 {
     auto reply = m_screensaverInterface->GetActive();
     QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(reply, this);
     QObject::connect(watcher, &QDBusPendingCallWatcher::finished, this, [this, cb](QDBusPendingCallWatcher *watcher) {
         QDBusPendingReply<bool> reply = *watcher;
         if (!reply.isError()) {
             cb(reply.value());
         }
         watcher->deleteLater();
     });
 }
 
 void SessionsModel::setShowNewSessionEntry(bool showNewSessionEntry)
 {
     if (!canStartNewSession()) {
         return;
     }
 
     if (showNewSessionEntry == m_showNewSessionEntry) {
         return;
     }
 
     int row = m_data.size();
     if (showNewSessionEntry) {
         beginInsertRows(QModelIndex(), row, row);
         m_showNewSessionEntry = showNewSessionEntry;
         endInsertRows();
     } else {
         beginRemoveRows(QModelIndex(), row, row);
         m_showNewSessionEntry = showNewSessionEntry;
         endRemoveRows();
     }
     emit countChanged();
 }
 
 
 QVariant SessionsModel::data(const QModelIndex &index, int role) const
 {
     if (index.row() < 0 || index.row() > rowCount(QModelIndex())) {
         return QVariant();
     }
 
     if (index.row() == m_data.count()) {
         switch (static_cast<Role>(role)) {
         case Role::RealName: return i18n("New Session");
-        case Role::IconName: return QStringLiteral("list-add");
+        case Role::IconName: return QStringLiteral("system-switch-user");
         case Role::Name: return i18n("New Session");
         case Role::DisplayNumber: return 0; //NA
         case Role::VtNumber: return -1; //an invalid VtNumber - which we'll use to indicate it's to start a new session
         case Role::Session: return 0; //NA
         case Role::IsTty: return false; //NA
         default: return QVariant();
         }
     }
 
     const SessionEntry &item = m_data.at(index.row());
 
     switch (static_cast<Role>(role)) {
     case Role::RealName: return item.realName;
     case Role::Icon: return item.icon;
     case Role::Name: return item.name;
     case Role::DisplayNumber: return item.displayNumber;
     case Role::VtNumber: return item.vtNumber;
     case Role::Session: return item.session;
     case Role::IsTty: return item.isTty;
     default: return QVariant();
     }
 
 }
 
 int SessionsModel::rowCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent);
     return m_data.count() + (m_showNewSessionEntry ? 1 : 0);
 }
 
 QHash<int, QByteArray> SessionsModel::roleNames() const
 {
     return {
         {static_cast<int>(Role::Name), QByteArrayLiteral("name")},
         {static_cast<int>(Role::RealName), QByteArrayLiteral("realName")},
         {static_cast<int>(Role::Icon), QByteArrayLiteral("icon")},
         {static_cast<int>(Role::IconName), QByteArrayLiteral("iconName")},
         {static_cast<int>(Role::DisplayNumber), QByteArrayLiteral("displayNumber")},
         {static_cast<int>(Role::VtNumber), QByteArrayLiteral("vtNumber")},
         {static_cast<int>(Role::Session), QByteArrayLiteral("session")},
         {static_cast<int>(Role::IsTty), QByteArrayLiteral("isTty")}
     };
 }
diff --git a/lookandfeel/contents/lockscreen/LockScreenUi.qml b/lookandfeel/contents/lockscreen/LockScreenUi.qml
index e1ccb7348..32e234a31 100644
--- a/lookandfeel/contents/lockscreen/LockScreenUi.qml
+++ b/lookandfeel/contents/lockscreen/LockScreenUi.qml
@@ -1,480 +1,516 @@
 /********************************************************************
  This file is part of the KDE project.
 
 Copyright (C) 2014 Aleix Pol Gonzalez <aleixpol@blue-systems.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 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/>.
 *********************************************************************/
 
 import QtQuick 2.8
 import QtQuick.Controls 1.1
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 
 import org.kde.plasma.private.sessions 2.0
 import "../components"
 
 PlasmaCore.ColorScope {
 
     // If we're using software rendering, draw outlines instead of shadows
     // See https://bugs.kde.org/show_bug.cgi?id=398317
     readonly property bool softwareRendering: GraphicsInfo.api === GraphicsInfo.Software
 
     colorGroup: PlasmaCore.Theme.ComplementaryColorGroup
 
     Connections {
         target: authenticator
         onFailed: {
             root.notification = i18nd("plasma_lookandfeel_org.kde.lookandfeel","Unlocking failed");
         }
         onGraceLockedChanged: {
             if (!authenticator.graceLocked) {
                 root.notification = "";
                 root.clearPassword();
             }
         }
         onMessage: {
             root.notification = msg;
         }
         onError: {
             root.notification = err;
         }
     }
 
     SessionsModel {
         id: sessionsModel
-        showNewSessionEntry: true
+        showNewSessionEntry: false
     }
 
     PlasmaCore.DataSource {
         id: keystateSource
         engine: "keystate"
         connectedSources: "Caps Lock"
     }
 
     Loader {
         id: changeSessionComponent
         active: false
         source: "ChangeSession.qml"
         visible: false
     }
 
     MouseArea {
         id: lockScreenRoot
 
         property bool uiVisible: false
         property bool blockUI: mainStack.depth > 1 || mainBlock.mainPasswordBox.text.length > 0 || inputPanel.keyboardActive
 
         x: parent.x
         y: parent.y
         width: parent.width
         height: parent.height
         hoverEnabled: true
         drag.filterChildren: true
         onPressed: uiVisible = true;
         onPositionChanged: uiVisible = true;
         onUiVisibleChanged: {
             if (blockUI) {
                 fadeoutTimer.running = false;
             } else if (uiVisible) {
                 fadeoutTimer.restart();
             }
         }
         onBlockUIChanged: {
             if (blockUI) {
                 fadeoutTimer.running = false;
                 uiVisible = true;
             } else {
                 fadeoutTimer.restart();
             }
         }
         Keys.onEscapePressed: {
             uiVisible = !uiVisible;
             if (inputPanel.keyboardActive) {
                 inputPanel.showHide();
             }
             if (!uiVisible) {
                 mainBlock.mainPasswordBox.text = "";
             }
         }
         Keys.onPressed: {
             uiVisible = true;
             event.accepted = false;
         }
         Timer {
             id: fadeoutTimer
             interval: 10000
             onTriggered: {
                 if (!lockScreenRoot.blockUI) {
                     lockScreenRoot.uiVisible = false;
                 }
             }
         }
 
         Component.onCompleted: PropertyAnimation { id: launchAnimation; target: lockScreenRoot; property: "opacity"; from: 0; to: 1; duration: 1000 }
 
         states: [
             State {
                 name: "onOtherSession"
                 // for slide out animation
                 PropertyChanges { target: lockScreenRoot; y: lockScreenRoot.height }
                 // we also change the opacity just to be sure it's not visible even on unexpected screen dimension changes with possible race conditions
                 PropertyChanges { target: lockScreenRoot; opacity: 0 }
             }
         ]
 
         transitions:
             Transition {
             // we only animate switchting to another session, because kscreenlocker doesn't get notified when
             // coming from another session back and so we wouldn't know when to trigger the animation exactly
             from: ""
             to: "onOtherSession"
 
             PropertyAnimation { id: stateChangeAnimation; properties: "y"; duration: 300; easing.type: Easing.InQuad}
             PropertyAnimation { properties: "opacity"; duration: 300}
 
             onRunningChanged: {
                 // after the animation has finished switch session: since we only animate the transition TO state "onOtherSession"
                 // and not the other way around, we don't have to check the state we transitioned into
                 if (/* lockScreenRoot.state == "onOtherSession" && */ !running) {
                     mainStack.currentItem.switchSession()
                 }
             }
         }
 
         WallpaperFader {
             anchors.fill: parent
             state: lockScreenRoot.uiVisible ? "on" : "off"
             source: wallpaper
             mainStack: mainStack
             footer: footer
             clock: clock
         }
 
         DropShadow {
             id: clockShadow
             anchors.fill: clock
             source: clock
             visible: !softwareRendering
             horizontalOffset: 1
             verticalOffset: 1
             radius: 6
             samples: 14
             spread: 0.3
             color: "black" // matches Breeze window decoration and desktopcontainment
             Behavior on opacity {
                 OpacityAnimator {
                     duration: 1000
                     easing.type: Easing.InOutQuad
                 }
             }
         }
 
         Clock {
             id: clock
             property Item shadow: clockShadow
             anchors.horizontalCenter: parent.horizontalCenter
             y: (mainBlock.userList.y + mainStack.y)/2 - height/2
             visible: y > 0
             Layout.alignment: Qt.AlignBaseline
         }
 
         ListModel {
             id: users
 
             Component.onCompleted: {
                 users.append({name: kscreenlocker_userName,
                                 realName: kscreenlocker_userName,
                                 icon: kscreenlocker_userImage,
 
                 })
             }
         }
 
         StackView {
             id: mainStack
             anchors {
                 left: parent.left
                 right: parent.right
             }
             height: lockScreenRoot.height + units.gridUnit * 3
             focus: true //StackView is an implicit focus scope, so we need to give this focus so the item inside will have it
 
             initialItem: MainBlock {
                 id: mainBlock
                 lockScreenUiVisible: lockScreenRoot.uiVisible
 
                 showUserList: userList.y + mainStack.y > 0
 
                 Stack.onStatusChanged: {
                     // prepare for presenting again to the user
                     if (Stack.status == Stack.Activating) {
                         mainPasswordBox.remove(0, mainPasswordBox.length)
                         mainPasswordBox.focus = true
                     }
                 }
                 userListModel: users
                 notificationMessage: {
                     var text = ""
                     if (keystateSource.data["Caps Lock"]["Locked"]) {
                         text += i18nd("plasma_lookandfeel_org.kde.lookandfeel","Caps Lock is on")
                         if (root.notification) {
                             text += " • "
                         }
                     }
                     text += root.notification
                     return text
                 }
 
                 onLoginRequest: {
                     root.notification = ""
                     authenticator.tryUnlock(password)
                 }
 
                 actionItems: [
                     ActionButton {
                         text: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Switch User")
                         iconSource: "system-switch-user"
-                        onClicked: mainStack.push(switchSessionPage)
+                        onClicked: {
+                            // If there are no existing sessions to switch to, create a new one instead
+                            if (((sessionsModel.showNewSessionEntry && sessionsModel.count === 1) ||
+                               (!sessionsModel.showNewSessionEntry && sessionsModel.count === 0)) &&
+                               sessionsModel.canSwitchUser) {
+                                mainStack.pop({immediate:true})
+                                sessionsModel.startNewSession(true /* lock the screen too */)
+                                lockScreenRoot.state = ''
+                            } else {
+                                mainStack.push(switchSessionPage)
+                            }
+                        }
                         visible: sessionsModel.canStartNewSession && sessionsModel.canSwitchUser
                     }
                 ]
 
                 Loader {
                     Layout.fillWidth: true
                     Layout.preferredHeight: item ? item.implicitHeight : 0
                     active: config.showMediaControls
                     source: "MediaControls.qml"
                 }
             }
 
             Component.onCompleted: {
                 if (defaultToSwitchUser) { //context property
-                    mainStack.push({
-                        item: switchSessionPage,
-                        immediate: true});
+                    // If we are in the only session, then going to the session switcher is
+                    // a pointless extra step; instead create a new session immediately
+                    if (((sessionsModel.showNewSessionEntry && sessionsModel.count === 1)  ||
+                       (!sessionsModel.showNewSessionEntry && sessionsModel.count === 0)) &&
+                       sessionsModel.canStartNewSession) {
+                        sessionsModel.startNewSession(true /* lock the screen too */)
+                    } else {
+                        mainStack.push({
+                            item: switchSessionPage,
+                            immediate: true});
+                    }
                 }
             }
         }
 
         Loader {
             id: inputPanel
             state: "hidden"
             readonly property bool keyboardActive: item ? item.active : false
             anchors {
                 left: parent.left
                 right: parent.right
             }
             function showHide() {
                 state = state == "hidden" ? "visible" : "hidden";
             }
             Component.onCompleted: inputPanel.source = "../components/VirtualKeyboard.qml"
 
             onKeyboardActiveChanged: {
                 if (keyboardActive) {
                     state = "visible";
                 } else {
                     state = "hidden";
                 }
             }
 
             states: [
                 State {
                     name: "visible"
                     PropertyChanges {
                         target: mainStack
                         y: Math.min(0, lockScreenRoot.height - inputPanel.height - mainBlock.visibleBoundary)
                     }
                     PropertyChanges {
                         target: inputPanel
                         y: lockScreenRoot.height - inputPanel.height
                         opacity: 1
                     }
                 },
                 State {
                     name: "hidden"
                     PropertyChanges {
                         target: mainStack
                         y: 0
                     }
                     PropertyChanges {
                         target: inputPanel
                         y: lockScreenRoot.height - lockScreenRoot.height/4
                         opacity: 0
                     }
                 }
             ]
             transitions: [
                 Transition {
                     from: "hidden"
                     to: "visible"
                     SequentialAnimation {
                         ScriptAction {
                             script: {
                                 inputPanel.item.activated = true;
                                 Qt.inputMethod.show();
                             }
                         }
                         ParallelAnimation {
                             NumberAnimation {
                                 target: mainStack
                                 property: "y"
                                 duration: units.longDuration
                                 easing.type: Easing.InOutQuad
                             }
                             NumberAnimation {
                                 target: inputPanel
                                 property: "y"
                                 duration: units.longDuration
                                 easing.type: Easing.OutQuad
                             }
                             OpacityAnimator {
                                 target: inputPanel
                                 duration: units.longDuration
                                 easing.type: Easing.OutQuad
                             }
                         }
                     }
                 },
                 Transition {
                     from: "visible"
                     to: "hidden"
                     SequentialAnimation {
                         ParallelAnimation {
                             NumberAnimation {
                                 target: mainStack
                                 property: "y"
                                 duration: units.longDuration
                                 easing.type: Easing.InOutQuad
                             }
                             NumberAnimation {
                                 target: inputPanel
                                 property: "y"
                                 duration: units.longDuration
                                 easing.type: Easing.InQuad
                             }
                             OpacityAnimator {
                                 target: inputPanel
                                 duration: units.longDuration
                                 easing.type: Easing.InQuad
                             }
                         }
                         ScriptAction {
                             script: {
                                 Qt.inputMethod.hide();
                             }
                         }
                     }
                 }
             ]
         }
 
         Component {
             id: switchSessionPage
             SessionManagementScreen {
                 property var switchSession: finalSwitchSession
 
                 Stack.onStatusChanged: {
                     if (Stack.status == Stack.Activating) {
                         focus = true
                     }
                 }
 
                 userListModel: sessionsModel
 
                 // initiating animation of lockscreen for session switch
                 function initSwitchSession() {
                     lockScreenRoot.state = 'onOtherSession'
                 }
 
                 // initiating session switch and preparing lockscreen for possible return of user
                 function finalSwitchSession() {
                     mainStack.pop({immediate:true})
                     sessionsModel.switchUser(userListCurrentModelData.vtNumber)
                     lockScreenRoot.state = ''
                 }
 
                 Keys.onLeftPressed: userList.decrementCurrentIndex()
                 Keys.onRightPressed: userList.incrementCurrentIndex()
                 Keys.onEnterPressed: initSwitchSession()
                 Keys.onReturnPressed: initSwitchSession()
                 Keys.onEscapePressed: mainStack.pop()
 
-                PlasmaComponents.Button {
+                ColumnLayout {
                     Layout.fillWidth: true
-                    font.pointSize: theme.defaultFont.pointSize + 1
-                    // the magic "-1" vtNumber indicates the "New Session" entry
-                    text: userListCurrentModelData.vtNumber === -1 ? i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Start New Session") : i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Switch Session")
-                    onClicked: initSwitchSession()
+                    spacing: units.largeSpacing
+
+                    PlasmaComponents.Button {
+                        Layout.fillWidth: true
+                        font.pointSize: theme.defaultFont.pointSize + 1
+                        text: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Switch to This Session")
+                        onClicked: initSwitchSession()
+                        visible: sessionsModel.count > 0
+                    }
+
+                    PlasmaComponents.Button {
+                        Layout.fillWidth: true
+                        font.pointSize: theme.defaultFont.pointSize + 1
+                        text: i18nd("plasma_lookandfeel_org.kde.lookandfeel", "Start New Session")
+                        onClicked: {
+                            mainStack.pop({immediate:true})
+                            sessionsModel.startNewSession(true /* lock the screen too */)
+                            lockScreenRoot.state = ''
+                        }
+                    }
                 }
 
+
                 actionItems: [
                     ActionButton {
                         iconSource: "go-previous"
                         text: i18nd("plasma_lookandfeel_org.kde.lookandfeel","Back")
                         onClicked: mainStack.pop()
                     }
                 ]
             }
         }
 
         Loader {
             active: root.viewVisible
             source: "LockOsd.qml"
             anchors {
                 horizontalCenter: parent.horizontalCenter
                 bottom: parent.bottom
                 bottomMargin: units.largeSpacing
             }
         }
 
         RowLayout {
             id: footer
             anchors {
                 bottom: parent.bottom
                 left: parent.left
                 right: parent.right
                 margins: units.smallSpacing
             }
 
             PlasmaComponents.ToolButton {
                 text: i18ndc("plasma_lookandfeel_org.kde.lookandfeel", "Button to show/hide virtual keyboard", "Virtual Keyboard")
                 iconName: inputPanel.keyboardActive ? "input-keyboard-virtual-on" : "input-keyboard-virtual-off"
                 onClicked: inputPanel.showHide()
 
                 visible: inputPanel.status == Loader.Ready
             }
 
             KeyboardLayoutButton {
             }
 
             Item {
                 Layout.fillWidth: true
             }
 
             Battery {}
         }
     }
 
     Component.onCompleted: {
         // version support checks
         if (root.interfaceVersion < 1) {
             // ksmserver of 5.4, with greeter of 5.5
             root.viewVisible = true;
         }
     }
 }