diff --git a/src/controls/swipenavigator/PrivateSwipeHighlight.qml b/src/controls/swipenavigator/PrivateSwipeHighlight.qml
index 8abdb185..087ae4d0 100644
--- a/src/controls/swipenavigator/PrivateSwipeHighlight.qml
+++ b/src/controls/swipenavigator/PrivateSwipeHighlight.qml
@@ -1,32 +1,33 @@
 /*
  *  SPDX-FileCopyrightText: 2020 Carson Black <uhhadd@gmail.com>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 import QtQuick 2.12
 import QtQuick.Layouts 1.12
 import QtQuick.Controls 2.12
 import org.kde.kirigami 2.12 as Kirigami
 
 Rectangle {
     Accessible.ignored: true
 
     anchors {
-        bottom: parent.bottom
+        bottom: Kirigami.Settings.isMobile ? undefined : parent.bottom
+        top: Kirigami.Settings.isMobile ? parent.top : undefined
         left: parent.left
         right: parent.right
     }
 
     color: {
         if (state == "highlighted") {
             return Kirigami.Theme.activeTextColor
         } else if (state == "requestingAttention") {
             return Kirigami.Theme.negativeTextColor
         }
         return "transparent"
     }
 
     // Unlike most things, we don't want to scale with the em grid, so we don't use a Unit.
     height: 2
 }
\ No newline at end of file
diff --git a/src/controls/swipenavigator/PrivateSwipeProgress.qml b/src/controls/swipenavigator/PrivateSwipeProgress.qml
index 950d37f2..d3aaf050 100644
--- a/src/controls/swipenavigator/PrivateSwipeProgress.qml
+++ b/src/controls/swipenavigator/PrivateSwipeProgress.qml
@@ -1,66 +1,68 @@
 /*
  *  SPDX-FileCopyrightText: 2020 Carson Black <uhhadd@gmail.com>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 import QtQuick 2.12
 import QtQuick.Layouts 1.12
 import QtQuick.Controls 2.12
 import org.kde.kirigami 2.12 as Kirigami
 
 Item {
     id: __progressRoot
     property var progress
 
     Rectangle {
         Accessible.ignored: true
 
         anchors {
             top: parent.top
             bottom: parent.bottom
             left: parent.left
         }
         width: parent.width * __progressRoot.progress
         color: Kirigami.ColorUtils.adjustColor(Kirigami.Theme.positiveTextColor, {"alpha": 0.2*255})
 
         Rectangle {
             anchors {
-                bottom: parent.bottom
+                bottom: Kirigami.Settings.isMobile ? undefined : parent.bottom
+                top: Kirigami.Settings.isMobile ? parent.top : undefined
                 left: parent.left
                 right: parent.right
             }
 
             color: Kirigami.Theme.positiveTextColor
 
             // Unlike most things, we don't want to scale with the em grid, so we don't use a Unit.
             height: 2
         }
     }
 
 
     Rectangle {
         Accessible.ignored: true
 
         anchors {
             top: parent.top
             bottom: parent.bottom
             right: parent.right
         }
         width: parent.width - (parent.width * __progressRoot.progress)
         color: Kirigami.ColorUtils.adjustColor(Kirigami.Theme.textColor, {"alpha": 0.1*255})
 
         Rectangle {
             anchors {
-                bottom: parent.bottom
+                bottom: Kirigami.Settings.isMobile ? undefined : parent.bottom
+                top: Kirigami.Settings.isMobile ? parent.top : undefined
                 left: parent.left
                 right: parent.right
             }
 
             color: Kirigami.ColorUtils.adjustColor(Kirigami.Theme.textColor, {"alpha": 0.1*255})
 
             // Unlike most things, we don't want to scale with the em grid, so we don't use a Unit.
             height: 2
         }
     }
 }
\ No newline at end of file
diff --git a/src/controls/swipenavigator/PrivateSwipeTab.qml b/src/controls/swipenavigator/PrivateSwipeTab.qml
index 275bb7d7..d26b6013 100644
--- a/src/controls/swipenavigator/PrivateSwipeTab.qml
+++ b/src/controls/swipenavigator/PrivateSwipeTab.qml
@@ -1,153 +1,153 @@
 /*
  *  SPDX-FileCopyrightText: 2020 Carson Black <uhhadd@gmail.com>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 import QtQuick 2.12
 import QtQuick.Layouts 1.12
 import QtQuick.Controls 2.12
 import org.kde.kirigami 2.12 as Kirigami
 
 Rectangle {
     id: tabRoot
     property bool small: false
     signal indexChanged(real xPos)
 
     Keys.onPressed: {
         if (event.key == Qt.Key_Enter || event.key == Qt.Key_Return) {
             columnView.currentIndex = index
         }
     }
     activeFocusOnTab: true
     implicitHeight: small ? Kirigami.Units.gridUnit*3 : Kirigami.Units.gridUnit*2
 
     Connections {
         target: columnView
         function onCurrentIndexChanged() {
             if (index == columnView.currentIndex) {
                 tabRoot.indexChanged(tabRoot.x)
             }
         }
     }
 
     Accessible.name: modelData.title
     Accessible.description: {
         if (!!modelData.progress) {
             if (index == columnView.currentIndex) {
                 return i18nc("Accessibility text for a page tab. Keep the text as concise as possible and don't use a percent sign.", "Current page. Progress: %1 percent.", Math.round(modelData.progress*100))
             } else {
                 return i18nc("Accessibility text for a page tab. Keep the text as concise as possible.", "Navigate to %1. Progress: %1 percent.", modelData.title, Math.round(modelData.progress*100))
             }
         } else {
             if (index == columnView.currentIndex) {
                 return i18nc("Accessibility text for a page tab. Keep the text as concise as possible.", "Current page.")
             } else if (modelData.needsAttention) {
                 return i18nc("Accessibility text for a page tab that's requesting the user's attention. Keep the text as concise as possible.", "Navigate to %1. Demanding attention.", modelData.title)
             } else {
                 return i18nc("Accessibility text for a page tab that's requesting the user's attention. Keep the text as concise as possible.", "Navigate to %1.", modelData.title)
             }
         }
     }
     Accessible.role: Accessible.PageTab
     Accessible.focusable: true
     Accessible.onPressAction: columnView.currentIndex = index
 
     implicitWidth: small ? smallTitleRow.implicitWidth : largeTitleRow.implicitWidth
     border {
         width: activeFocus ? 2 : 0
         color: Kirigami.Theme.textColor
     }
     color: {
         if (index == columnView.currentIndex) {
             return Kirigami.ColorUtils.adjustColor(Kirigami.Theme.activeTextColor, {"alpha": 0.2*255})
         } else if (modelData.needsAttention) {
             return Kirigami.ColorUtils.adjustColor(Kirigami.Theme.negativeTextColor, {"alpha": 0.2*255})
         } else {
             return "transparent"
         }
     }
 
     PrivateSwipeHighlight {
         states: [
             State { name: "highlighted"; when: index == columnView.currentIndex },
             State { name: "requestingAttention"; when: modelData.needsAttention }
         ]
     }
 
     PrivateSwipeProgress {
         anchors.fill: parent
         visible: modelData.progress != undefined
         progress: modelData.progress
     }
 
     RowLayout {
         id: smallTitleRow
         anchors.fill: parent
         Accessible.ignored: true
         visible: small
 
         ColumnLayout {
-            Layout.margins: Kirigami.Units.largeSpacing
+            Layout.margins: Kirigami.Settings.isMobile ? Kirigami.Units.smallSpacing : Kirigami.Units.largeSpacing
             Layout.alignment: Qt.AlignVCenter
 
             Kirigami.Icon {
                 visible: !!modelData.icon.name
                 source: modelData.icon.name
 
                 Layout.preferredHeight: Kirigami.Units.iconSizes.small
                 Layout.preferredWidth: Layout.preferredHeight
 
                 Layout.alignment: (Qt.AlignHCenter | Qt.AlignBottom)
             }
             Kirigami.Heading {
                 level: 5
                 text: modelData.title
 
                 Layout.fillWidth: true
                 Layout.alignment: (Qt.AlignLeft | Qt.AlignVCenter)
             }
         }
     }
 
     RowLayout {
         id: largeTitleRow
         anchors.fill: parent
         Accessible.ignored: true
         visible: !small
 
         RowLayout {
             Layout.margins: Kirigami.Units.largeSpacing
             Layout.alignment: Qt.AlignVCenter
 
             Kirigami.Icon {
                 visible: !!modelData.icon.name
                 source: modelData.icon.name
 
                 Layout.preferredHeight: Kirigami.Units.iconSizes.small
                 Layout.preferredWidth: Layout.preferredHeight
 
                 Layout.alignment: (Qt.AlignLeft | Qt.AlignVCenter)
             }
             Kirigami.Heading {
                 level: 2
                 text: modelData.title
 
                 Layout.fillWidth: true
                 Layout.alignment: (Qt.AlignLeft | Qt.AlignVCenter)
             }
         }
     }
 
     MouseArea {
         id: mouse
         anchors.fill: parent
         Accessible.ignored: true
         onClicked: {
             columnView.currentIndex = index
         }
     }
 
     Layout.fillHeight: true
     Layout.alignment: Qt.AlignHCenter
 }
\ No newline at end of file
diff --git a/src/controls/swipenavigator/SwipeNavigator.qml b/src/controls/swipenavigator/SwipeNavigator.qml
index 80c83ec0..9dfdc886 100644
--- a/src/controls/swipenavigator/SwipeNavigator.qml
+++ b/src/controls/swipenavigator/SwipeNavigator.qml
@@ -1,135 +1,163 @@
 /*
  *  SPDX-FileCopyrightText: 2020 Carson Black <uhhadd@gmail.com>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 import QtQuick 2.12
 import QtQuick.Layouts 1.12
 import QtQuick.Controls 2.12
 import org.kde.kirigami 2.13 as Kirigami
 
 /**
  * SwipeNavigator is a control providing for lateral navigation.
  * 
  * @include swipenavigator/main.qml
  */
 GridLayout {
     id: swipeNavigatorRoot
     rowSpacing: 0
     columns: 1
 
     /**
      * pages: list<Kirigami.Page>
      *
      * A list of pages to swipe between.
      */
     default property list<Kirigami.Page> pages
 
     /**
      * layers: StackView
      *
      * The StackView holding the core item, allowing users of a SwipeNavigator
      * in order to push pages on top of the SwipeNavigator.
      */
     property alias layers: stackView
 
     /**
      * header: Item
      *
      * The item that will be displayed before the tabs.
      */
     property Item header: Item {visible: false}
     onHeaderChanged: {
         header.parent = _grid
         header.Layout.alignment = Qt.AlignLeft | Qt.AlignVcenter
     }
 
     /**
      * footer: Item
      *
      * The item that will be displayed after the tabs.
      */
     property Item footer: Item {visible: false}
     onFooterChanged: {
         footer.parent = _grid
         footer.Layout.alignment = Qt.AlignLeft | Qt.AlignVcenter
     }
 
-    Item {
+    Loader {
         visible: false
         id: layouter
         property bool tall: (swipeNavigatorRoot.header.width + __main.item.width + swipeNavigatorRoot.footer.width) > swipeNavigatorRoot.width
-        states: [
-            State {
-                name: "small"
-                when: !layouter.tall
-                PropertyChanges { target: swipeNavigatorRoot.header; Layout.row: 0; Layout.column: 0}
-                PropertyChanges { target: __main; Layout.row: 0; Layout.column: 1}
-                PropertyChanges { target: swipeNavigatorRoot.footer; Layout.row: 0; Layout.column: 2}
-            },
-            State {
-                name: "tall"
-                when: layouter.tall
-                PropertyChanges { target: swipeNavigatorRoot.header; Layout.row: 0; Layout.column: 0}
-                PropertyChanges { target: __main; Layout.row: 1; Layout.column: 0; Layout.columnSpan: 3}
-                PropertyChanges { target: swipeNavigatorRoot.footer; Layout.row: 0; Layout.column: 2}
-                PropertyChanges { target: _spacer; Layout.row: 0; Layout.column: 1; Layout.fillWidth: true; visible: true }
+        sourceComponent: Kirigami.Settings.isMobile ? mobile : desktop
+        Component {
+            id: mobile
+            Item {
+                states: [
+                    State {
+                        name: "small"
+                        when: !layouter.tall
+                        PropertyChanges { target: swipeNavigatorRoot.header; Layout.row: 0; Layout.column: 0}
+                        PropertyChanges { target: __main; Layout.row: 0; Layout.column: 1}
+                        PropertyChanges { target: swipeNavigatorRoot.footer; Layout.row: 0; Layout.column: 2}
+                    },
+                    State {
+                        name: "tall"
+                        when: layouter.tall
+                        PropertyChanges { target: swipeNavigatorRoot.header; Layout.row: 1; Layout.column: 0}
+                        PropertyChanges { target: __main; Layout.row: 0; Layout.column: 0; Layout.columnSpan: 3}
+                        PropertyChanges { target: swipeNavigatorRoot.footer; Layout.row: 1; Layout.column: 2}
+                        PropertyChanges { target: _spacer; Layout.row: 1; Layout.column: 1; Layout.fillWidth: true; visible: true }
+                    }
+                ]
             }
-        ]
+        }
+        Component {
+            id: desktop
+            Item {
+                states: [
+                    State {
+                        name: "small"
+                        when: !layouter.tall
+                        PropertyChanges { target: swipeNavigatorRoot.header; Layout.row: 0; Layout.column: 0}
+                        PropertyChanges { target: __main; Layout.row: 0; Layout.column: 1}
+                        PropertyChanges { target: swipeNavigatorRoot.footer; Layout.row: 0; Layout.column: 2}
+                    },
+                    State {
+                        name: "tall"
+                        when: layouter.tall
+                        PropertyChanges { target: swipeNavigatorRoot.header; Layout.row: 0; Layout.column: 0}
+                        PropertyChanges { target: __main; Layout.row: 1; Layout.column: 0; Layout.columnSpan: 3}
+                        PropertyChanges { target: swipeNavigatorRoot.footer; Layout.row: 0; Layout.column: 2}
+                        PropertyChanges { target: _spacer; Layout.row: 0; Layout.column: 1; Layout.fillWidth: true; visible: true }
+                    }
+                ]
+            }
+        }
     }
 
     ToolBar {
         id: topToolBar
 
         padding: 0
         bottomPadding: 1
         position: Kirigami.Settings.isMobile ? ToolBar.Footer : ToolBar.Header
 
         Layout.row: Kirigami.Settings.isMobile ? 1 : 0
 
         GridLayout {
             id: _grid
 
             rowSpacing: 0
             columnSpacing: 0
             anchors.fill: parent
             rows: 2
             columns: 3
 
             Item { id: _spacer; visible: false }
             PrivateSwipeTabBarLoader {
                 id: __main
                 visible: false
                 Layout.fillWidth: true
                 Layout.fillHeight: true
                 Layout.alignment: Qt.AlignHCenter
             }
         }
 
         Layout.fillWidth: true
 
         Accessible.role: Accessible.PageTabList
     }
 
     StackView {
         id: stackView
 
         Layout.fillWidth: true
         Layout.fillHeight: true
 
         Layout.row: Kirigami.Settings.isMobile ? 0 : 1
 
         Kirigami.ColumnView {
             id: columnView
             columnResizeMode: Kirigami.ColumnView.SingleColumn
 
             contentChildren: swipeNavigatorRoot.pages
             anchors.fill: parent
 
             Component.onCompleted: {
                 columnView.currentIndex = 0
             }
         }
     }
 }
diff --git a/src/kirigamiplugin.cpp b/src/kirigamiplugin.cpp
index 26fc8668..60c1b027 100644
--- a/src/kirigamiplugin.cpp
+++ b/src/kirigamiplugin.cpp
@@ -1,273 +1,272 @@
 /*
  *  SPDX-FileCopyrightText: 2009 Alan Alpert <alan.alpert@nokia.com>
  *  SPDX-FileCopyrightText: 2010 Ménard Alexis <menard@kde.org>
  *  SPDX-FileCopyrightText: 2010 Marco Martin <mart@kde.org>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #include "kirigamiplugin.h"
 #include "columnview.h"
 #include "enums.h"
 #include "icon.h"
 #include "settings.h"
 #include "formlayoutattached.h"
 #include "mnemonicattached.h"
 #include "delegaterecycler.h"
 #include "pagepool.h"
 #include "scenepositionattached.h"
 #include "wheelhandler.h"
 #include "shadowedrectangle.h"
 #include "shadowedtexture.h"
 #include "colorutils.h"
 #include "pagerouter.h"
 #include "imagecolors.h"
 
 #include <QQmlEngine>
 #include <QQmlContext>
 #include <QQuickItem>
 #include <QQuickStyle>
 #include <QGuiApplication>
 #include <QClipboard>
 
 #include "libkirigami/platformtheme.h"
 
 static QString s_selectedStyle;
 
 //Q_INIT_RESOURCE(kirigami);
 #ifdef KIRIGAMI_BUILD_TYPE_STATIC
 #include <qrc_kirigami.cpp>
 #endif
 
 class CopyHelperPrivate : public QObject
 {
     Q_OBJECT
     public:
         Q_INVOKABLE static void copyTextToClipboard(const QString& text)
         {
             qGuiApp->clipboard()->setText(text);
         }
 };
 
 // we can't do this in the plugin object directly, as that can live in a different thread
 // and event filters are only allowed in the same thread as the filtered object
 class LanguageChangeEventFilter : public QObject
 {
     Q_OBJECT
 public:
     bool eventFilter(QObject *receiver, QEvent *event) override
     {
         if (event->type() == QEvent::LanguageChange && receiver == QCoreApplication::instance()) {
             emit languageChangeEvent();
         }
         return QObject::eventFilter(receiver, event);
     }
 
 Q_SIGNALS:
     void languageChangeEvent();
 };
 
 KirigamiPlugin::KirigamiPlugin(QObject *parent)
     : QQmlExtensionPlugin(parent)
 {
     auto filter = new LanguageChangeEventFilter;
     filter->moveToThread(QCoreApplication::instance()->thread());
     QCoreApplication::instance()->installEventFilter(filter);
     connect(filter, &LanguageChangeEventFilter::languageChangeEvent, this, &KirigamiPlugin::languageChangeEvent);
 }
 
 QUrl KirigamiPlugin::componentUrl(const QString &fileName) const
 {
     for (const QString &style : qAsConst(m_stylesFallbackChain)) {
         const QString candidate = QStringLiteral("styles/") + style + QLatin1Char('/') + fileName;
         if (QFile::exists(resolveFilePath(candidate))) {
 #ifdef KIRIGAMI_BUILD_TYPE_STATIC
             return QUrl(QStringLiteral("qrc:/org/kde/kirigami/styles/") + style + QLatin1Char('/') + fileName);
 #else
             return QUrl(resolveFileUrl(candidate));
 #endif
         }
     }
 
 #ifdef KIRIGAMI_BUILD_TYPE_STATIC
             return QUrl(QStringLiteral("qrc:/org/kde/kirigami/") + fileName);
 #else
     return QUrl(resolveFileUrl(fileName));
 #endif
 }
 
 void KirigamiPlugin::registerTypes(const char *uri)
 {
 #if defined(Q_OS_ANDROID) && QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
     QResource::registerResource(QStringLiteral("assets:/android_rcc_bundle.rcc"));
 #endif
 
     Q_ASSERT(QLatin1String(uri) == QLatin1String("org.kde.kirigami"));
     const QString style = QQuickStyle::name();
 
     if (QIcon::themeName().isEmpty() && !qEnvironmentVariableIsSet("XDG_CURRENT_DESKTOP")) {
         QIcon::setThemeSearchPaths({resolveFilePath(QStringLiteral(".")), QStringLiteral(":/icons")});
         QIcon::setThemeName(QStringLiteral("breeze-internal"));
     }
 
 #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
     //org.kde.desktop.plasma is a couple of files that fall back to desktop by purpose
     if ((style.isEmpty() || style == QStringLiteral("org.kde.desktop.plasma")) && QFile::exists(resolveFilePath(QStringLiteral("/styles/org.kde.desktop")))) {
         m_stylesFallbackChain.prepend(QStringLiteral("org.kde.desktop"));
     }
 #elif defined(Q_OS_ANDROID)
     if (!m_stylesFallbackChain.contains(QLatin1String("Material"))) {
         m_stylesFallbackChain.prepend(QStringLiteral("Material"));
     }
 #else // do we have an iOS specific style?
     if (!m_stylesFallbackChain.contains(QLatin1String("Material"))) {
         m_stylesFallbackChain.prepend(QStringLiteral("Material"));
     }
 #endif
 
     if (!style.isEmpty() && QFile::exists(resolveFilePath(QStringLiteral("/styles/") + style)) && !m_stylesFallbackChain.contains(style)) {
         m_stylesFallbackChain.prepend(style);
         //if we have plasma deps installed, use them for extra integration
         if (style == QStringLiteral("org.kde.desktop") && QFile::exists(resolveFilePath(QStringLiteral("/styles/org.kde.desktop.plasma")))) {
             m_stylesFallbackChain.prepend(QStringLiteral("org.kde.desktop.plasma"));
         }
     } else {
 #if !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS)
         m_stylesFallbackChain.prepend(QStringLiteral("org.kde.desktop"));
 #endif
     }
     //At this point the fallback chain will be selected->org.kde.desktop->Fallback
     s_selectedStyle = m_stylesFallbackChain.first();
 
     qmlRegisterSingletonType<Settings>(uri, 2, 0, "Settings",
          [](QQmlEngine *e, QJSEngine*) -> QObject* {
              Settings *settings = Settings::self();
              //singleton managed internally, qml should never delete it
              e->setObjectOwnership(settings, QQmlEngine::CppOwnership);
              settings->setStyle(s_selectedStyle);
              return settings;
          }
      );
 
     qmlRegisterUncreatableType<ApplicationHeaderStyle>(uri, 2, 0, "ApplicationHeaderStyle", QStringLiteral("Cannot create objects of type ApplicationHeaderStyle"));
 
     //old legacy retrocompatible Theme
     qmlRegisterSingletonType(componentUrl(QStringLiteral("Theme.qml")), uri, 2, 0, "Theme");
 
     qmlRegisterSingletonType(componentUrl(QStringLiteral("Units.qml")), uri, 2, 0, "Units");
 
     qmlRegisterType(componentUrl(QStringLiteral("Action.qml")), uri, 2, 0, "Action");
     qmlRegisterType(componentUrl(QStringLiteral("AbstractApplicationHeader.qml")), uri, 2, 0, "AbstractApplicationHeader");
     qmlRegisterType(componentUrl(QStringLiteral("AbstractApplicationWindow.qml")), uri, 2, 0, "AbstractApplicationWindow");
     qmlRegisterType(componentUrl(QStringLiteral("AbstractListItem.qml")), uri, 2, 0, "AbstractListItem");
     qmlRegisterType(componentUrl(QStringLiteral("ApplicationHeader.qml")), uri, 2, 0, "ApplicationHeader");
     qmlRegisterType(componentUrl(QStringLiteral("ToolBarApplicationHeader.qml")), uri, 2, 0, "ToolBarApplicationHeader");
     qmlRegisterType(componentUrl(QStringLiteral("ApplicationWindow.qml")), uri, 2, 0, "ApplicationWindow");
     qmlRegisterType(componentUrl(QStringLiteral("BasicListItem.qml")), uri, 2, 0, "BasicListItem");
     qmlRegisterType(componentUrl(QStringLiteral("OverlayDrawer.qml")), uri, 2, 0, "OverlayDrawer");
     qmlRegisterType(componentUrl(QStringLiteral("ContextDrawer.qml")), uri, 2, 0, "ContextDrawer");
     qmlRegisterType(componentUrl(QStringLiteral("GlobalDrawer.qml")), uri, 2, 0, "GlobalDrawer");
     qmlRegisterType(componentUrl(QStringLiteral("Heading.qml")), uri, 2, 0, "Heading");
     qmlRegisterType(componentUrl(QStringLiteral("Separator.qml")), uri, 2, 0, "Separator");
     qmlRegisterType(componentUrl(QStringLiteral("PageRow.qml")), uri, 2, 0, "PageRow");
 
     qmlRegisterType<Icon>(uri, 2, 0, "Icon");
 
     qmlRegisterType(componentUrl(QStringLiteral("Label.qml")), uri, 2, 0, "Label");
     //TODO: uncomment for 2.3 release
     //qmlRegisterTypeNotAvailable(uri, 2, 3, "Label", "Label type not supported anymore, use QtQuick.Controls.Label 2.0 instead");
     qmlRegisterType(componentUrl(QStringLiteral("OverlaySheet.qml")), uri, 2, 0, "OverlaySheet");
     qmlRegisterType(componentUrl(QStringLiteral("Page.qml")), uri, 2, 0, "Page");
     qmlRegisterType(componentUrl(QStringLiteral("ScrollablePage.qml")), uri, 2, 0, "ScrollablePage");
     qmlRegisterType(componentUrl(QStringLiteral("SplitDrawer.qml")), uri, 2, 0, "SplitDrawer");
     qmlRegisterType(componentUrl(QStringLiteral("SwipeListItem.qml")), uri, 2, 0, "SwipeListItem");
 
     //2.1
     qmlRegisterType(componentUrl(QStringLiteral("AbstractItemViewHeader.qml")), uri, 2, 1, "AbstractItemViewHeader");
     qmlRegisterType(componentUrl(QStringLiteral("ItemViewHeader.qml")), uri, 2, 1, "ItemViewHeader");
     qmlRegisterType(componentUrl(QStringLiteral("AbstractApplicationItem.qml")), uri, 2, 1, "AbstractApplicationItem");
     qmlRegisterType(componentUrl(QStringLiteral("ApplicationItem.qml")), uri, 2, 1, "ApplicationItem");
 
     //2.2
     //Theme changed from a singleton to an attached property
     qmlRegisterUncreatableType<Kirigami::PlatformTheme>(uri, 2, 2, "Theme", QStringLiteral("Cannot create objects of type Theme, use it as an attached property"));
 
     //2.3
     qmlRegisterType(componentUrl(QStringLiteral("FormLayout.qml")), uri, 2, 3, "FormLayout");
     qmlRegisterUncreatableType<FormLayoutAttached>(uri, 2, 3, "FormData", QStringLiteral("Cannot create objects of type FormData, use it as an attached property"));
     qmlRegisterUncreatableType<MnemonicAttached>(uri, 2, 3, "MnemonicData", QStringLiteral("Cannot create objects of type MnemonicData, use it as an attached property"));
 
     //2.4
     qmlRegisterType(componentUrl(QStringLiteral("AbstractCard.qml")), uri, 2, 4, "AbstractCard");
     qmlRegisterType(componentUrl(QStringLiteral("Card.qml")), uri, 2, 4, "Card");
     qmlRegisterType(componentUrl(QStringLiteral("CardsListView.qml")), uri, 2, 4, "CardsListView");
     qmlRegisterType(componentUrl(QStringLiteral("CardsGridView.qml")), uri, 2, 4, "CardsGridView");
     qmlRegisterType(componentUrl(QStringLiteral("CardsLayout.qml")), uri, 2, 4, "CardsLayout");
     qmlRegisterType(componentUrl(QStringLiteral("InlineMessage.qml")), uri, 2, 4, "InlineMessage");
     qmlRegisterUncreatableType<MessageType>(uri, 2, 4, "MessageType", QStringLiteral("Cannot create objects of type MessageType"));
     qmlRegisterType<DelegateRecycler>(uri, 2, 4, "DelegateRecycler");
 
     //2.5
     qmlRegisterType(componentUrl(QStringLiteral("ListItemDragHandle.qml")), uri, 2, 5, "ListItemDragHandle");
     qmlRegisterType(componentUrl(QStringLiteral("ActionToolBar.qml")), uri, 2, 5, "ActionToolBar");
     qmlRegisterUncreatableType<ScenePositionAttached>(uri, 2, 5, "ScenePosition", QStringLiteral("Cannot create objects of type ScenePosition, use it as an attached property"));
 
     //2.6
     qmlRegisterType(componentUrl(QStringLiteral("AboutPage.qml")), uri, 2, 6, "AboutPage");
     qmlRegisterType(componentUrl(QStringLiteral("LinkButton.qml")), uri, 2, 6, "LinkButton");
     qmlRegisterType(componentUrl(QStringLiteral("UrlButton.qml")), uri, 2, 6, "UrlButton");
     qmlRegisterSingletonType<CopyHelperPrivate>("org.kde.kirigami.private", 2, 6, "CopyHelperPrivate", [] (QQmlEngine*, QJSEngine*) -> QObject* { return new CopyHelperPrivate; });
 
     //2.7
     qmlRegisterType<ColumnView>(uri, 2, 7, "ColumnView");
     qmlRegisterType(componentUrl(QStringLiteral("ActionTextField.qml")), uri, 2, 7, "ActionTextField");
 
     //2.8
     qmlRegisterType(componentUrl(QStringLiteral("SearchField.qml")), uri, 2, 8, "SearchField");
     qmlRegisterType(componentUrl(QStringLiteral("PasswordField.qml")), uri, 2, 8, "PasswordField");
 
     //2.9
     qmlRegisterType<WheelHandler>(uri, 2, 9, "WheelHandler");
     qmlRegisterUncreatableType<KirigamiWheelEvent>(uri, 2, 9, "WheelEvent", QStringLiteral("Cannot create objects of type WheelEvent."));
 
     //2.10
     qmlRegisterType(componentUrl(QStringLiteral("ListSectionHeader.qml")), uri, 2, 10, "ListSectionHeader");
 
     // 2.11
     qmlRegisterType<PagePool>(uri, 2, 11, "PagePool");
     qmlRegisterType(componentUrl(QStringLiteral("PagePoolAction.qml")), uri, 2, 11, "PagePoolAction");
 
     //TODO: remove
     qmlRegisterType(componentUrl(QStringLiteral("SwipeListItem2.qml")), uri, 2, 11, "SwipeListItem2");
 
     // 2.12
     qmlRegisterType<ShadowedRectangle>(uri, 2, 12, "ShadowedRectangle");
     qmlRegisterType<ShadowedTexture>(uri, 2, 12, "ShadowedTexture");
     qmlRegisterType(componentUrl(QStringLiteral("ShadowedImage.qml")), uri, 2, 12, "ShadowedImage");
     qmlRegisterType(componentUrl(QStringLiteral("PlaceholderMessage.qml")), uri, 2, 12, "PlaceholderMessage");
 
     qmlRegisterUncreatableType<BorderGroup>(uri, 2, 12, "BorderGroup", QStringLiteral("Used as grouped property"));
     qmlRegisterUncreatableType<ShadowGroup>(uri, 2, 12, "ShadowGroup", QStringLiteral("Used as grouped property"));
     qmlRegisterSingletonType<ColorUtils>(uri, 2, 12, "ColorUtils", [] (QQmlEngine*, QJSEngine*) -> QObject* { return new ColorUtils; });
 
     qmlRegisterUncreatableType<CornersGroup>(uri, 2, 12, "CornersGroup", QStringLiteral("Used as grouped property"));
     qmlRegisterType<PageRouter>(uri, 2, 12, "PageRouter");
     qmlRegisterType<PageRoute>(uri, 2, 12, "PageRoute");
     qmlRegisterUncreatableType<PageRouterAttached>(uri, 2, 12, "PageRouterAttached", QStringLiteral("PageRouterAttached cannot be created"));
     qmlRegisterType(componentUrl(QStringLiteral("RouterWindow.qml")), uri, 2, 12, "RouterWindow");
 
     // 2.13
     qmlRegisterType<ImageColors>(uri, 2, 13, "ImageColors");
     qmlRegisterType(componentUrl(QStringLiteral("swipenavigator/SwipeNavigator.qml")), uri, 2, 13, "SwipeNavigator");
-    qmlRegisterUncreatableType<SwipeNavigatorType>(uri, 2, 13, "SwipeNavigatorType", QStringLiteral("Cannot create objects of type SwipeNavigatorType"));
 
     qmlProtectModule(uri, 2);
 }
 
 void KirigamiPlugin::initializeEngine(QQmlEngine *engine, const char *uri)
 {
     Q_UNUSED(uri);
     connect(this, &KirigamiPlugin::languageChangeEvent, engine, &QQmlEngine::retranslate);
 }
 
 #include "kirigamiplugin.moc"