diff --git a/src/icon.cpp b/src/icon.cpp
index 1683b962..c8719cce 100644
--- a/src/icon.cpp
+++ b/src/icon.cpp
@@ -1,598 +1,598 @@
 /*
  *   Copyright 2011 Marco Martin <mart@kde.org>
  *   Copyright 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 Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "icon.h"
 #include "libkirigami/platformtheme.h"
 
 #include <QSGSimpleTextureNode>
 #include <qquickwindow.h>
 #include <QIcon>
 #include <QBitmap>
 #include <QSGTexture>
 #include <QDebug>
 #include <QSharedPointer>
 #include <QtQml>
 #include <QQuickImageProvider>
 #include <QGuiApplication>
 #include <QPointer>
 #include <QPainter>
 #include <QScreen>
 
 class ManagedTextureNode : public QSGSimpleTextureNode
 {
 Q_DISABLE_COPY(ManagedTextureNode)
 public:
     ManagedTextureNode();
 
     void setTexture(QSharedPointer<QSGTexture> texture);
 
 private:
     QSharedPointer<QSGTexture> m_texture;
 };
 
 ManagedTextureNode::ManagedTextureNode()
 {}
 
 void ManagedTextureNode::setTexture(QSharedPointer<QSGTexture> texture)
 {
     m_texture = texture;
     QSGSimpleTextureNode::setTexture(texture.data());
 }
 
 typedef QHash<qint64, QHash<QWindow*, QWeakPointer<QSGTexture> > > TexturesCache;
 
 struct ImageTexturesCachePrivate
 {
     TexturesCache cache;
 };
 
 class ImageTexturesCache
 {
 public:
     ImageTexturesCache();
     ~ImageTexturesCache();
 
     /**
      * @returns the texture for a given @p window and @p image.
      *
      * If an @p image id is the same as one already provided before, we won't create
      * a new texture and return a shared pointer to the existing texture.
      */
     QSharedPointer<QSGTexture> loadTexture(QQuickWindow *window, const QImage &image, QQuickWindow::CreateTextureOptions options);
 
     QSharedPointer<QSGTexture> loadTexture(QQuickWindow *window, const QImage &image);
 
 
 private:
     QScopedPointer<ImageTexturesCachePrivate> d;
 };
 
 
 ImageTexturesCache::ImageTexturesCache()
     : d(new ImageTexturesCachePrivate)
 {
 }
 
 ImageTexturesCache::~ImageTexturesCache()
 {
 }
 
 QSharedPointer<QSGTexture> ImageTexturesCache::loadTexture(QQuickWindow *window, const QImage &image, QQuickWindow::CreateTextureOptions options)
 {
     qint64 id = image.cacheKey();
     QSharedPointer<QSGTexture> texture = d->cache.value(id).value(window).toStrongRef();
 
     if (!texture) {
         auto cleanAndDelete = [this, window, id](QSGTexture* texture) {
             QHash<QWindow*, QWeakPointer<QSGTexture> >& textures = (d->cache)[id];
             textures.remove(window);
             if (textures.isEmpty())
                 d->cache.remove(id);
             delete texture;
         };
         texture = QSharedPointer<QSGTexture>(window->createTextureFromImage(image, options), cleanAndDelete);
         (d->cache)[id][window] = texture.toWeakRef();
     }
 
     //if we have a cache in an atlas but our request cannot use an atlassed texture
     //create a new texture and use that
     //don't use removedFromAtlas() as that requires keeping a reference to the non atlased version
     if (!(options & QQuickWindow::TextureCanUseAtlas) && texture->isAtlasTexture()) {
         texture = QSharedPointer<QSGTexture>(window->createTextureFromImage(image, options));
     }
 
     return texture;
 }
 
 QSharedPointer<QSGTexture> ImageTexturesCache::loadTexture(QQuickWindow *window, const QImage &image)
 {
     return loadTexture(window, image, nullptr);
 }
 
 Q_GLOBAL_STATIC(ImageTexturesCache, s_iconImageCache)
 
 Icon::Icon(QQuickItem *parent)
     : QQuickItem(parent),
       m_smooth(false),
       m_changed(false),
       m_active(false),
       m_selected(false),
       m_isMask(false)
 {
     setFlag(ItemHasContents, true);
     //FIXME: not necessary anymore
     connect(qApp, &QGuiApplication::paletteChanged, this, [this]() {
         m_changed = true;
         update();
     });
     connect(this, &QQuickItem::enabledChanged, this, [this]() {
         m_changed = true;
         update();
     });
 }
 
 
 Icon::~Icon()
 {
 }
 
 void Icon::setSource(const QVariant &icon)
 {
     if (m_source == icon) {
         return;
     }
     m_source = icon;
     m_changed = true;
     m_monochromeHeuristics.clear();
 
     if (!m_theme) {
         m_theme = static_cast<Kirigami::PlatformTheme *>(qmlAttachedPropertiesObject<Kirigami::PlatformTheme>(this, true));
         Q_ASSERT(m_theme);
 
         connect(m_theme, &Kirigami::PlatformTheme::colorsChanged, this, [this]() {
             m_changed = true;
             update();
         });
     }
 
     if (icon.type() == QVariant::String) {
         const QString iconSource = icon.toString();
-        m_isMaskHeuristic = (iconSource.endsWith(QStringLiteral("-symbolic"))
-                            || iconSource.endsWith(QStringLiteral("-symbolic-rtl"))
-                            || iconSource.endsWith(QStringLiteral("-symbolic-ltr")));
+        m_isMaskHeuristic = (iconSource.endsWith(QLatin1String("-symbolic"))
+                            || iconSource.endsWith(QLatin1String("-symbolic-rtl"))
+                            || iconSource.endsWith(QLatin1String("-symbolic-ltr")));
         emit isMaskChanged();
     }
 
     if (m_networkReply) {
         //if there was a network query going on, interrupt it
         m_networkReply->close();
     }
     m_loadedImage = QImage();
     update();
     emit sourceChanged();
 }
 
 QVariant Icon::source() const
 {
     return m_source;
 }
 
 void Icon::setActive(const bool active)
 {
     if (active == m_active) {
         return;
     }
     m_active = active;
     m_changed = true;
     update();
     emit activeChanged();
 }
 
 bool Icon::active() const
 {
     return m_active;
 }
 
 bool Icon::valid() const
 {
     return !m_source.isNull();
 }
 
 void Icon::setSelected(const bool selected)
 {
     if (selected == m_selected) {
         return;
     }
     m_selected = selected;
     m_changed = true;
     update();
     emit selectedChanged();
 }
 
 bool Icon::selected() const
 {
     return m_selected;
 }
 
 void Icon::setIsMask(bool mask)
 {
     if (m_isMask == mask) {
         return;
     }
 
     m_isMask = mask;
     m_isMaskHeuristic = mask;
     m_changed = true;
     update();
     emit isMaskChanged();
 }
 
 bool Icon::isMask() const
 {
     return m_isMask || m_isMaskHeuristic;
 }
 
 void Icon::setColor(const QColor &color)
 {
     if (m_color == color) {
         return;
     }
 
     m_color = color;
     m_changed = true;
     update();
     emit colorChanged();
 }
 
 QColor Icon::color() const
 {
     return m_color;
 }
 
 
 int Icon::implicitWidth() const
 {
     return 32;
 }
 
 int Icon::implicitHeight() const
 {
     return 32;
 }
 
 void Icon::setSmooth(const bool smooth)
 {
     if (smooth == m_smooth) {
         return;
     }
     m_smooth = smooth;
     m_changed = true;
     update();
     emit smoothChanged();
 }
 
 bool Icon::smooth() const
 {
     return m_smooth;
 }
 
 QSGNode* Icon::updatePaintNode(QSGNode* node, QQuickItem::UpdatePaintNodeData* /*data*/)
 {
     if (m_source.isNull()) {
         delete node;
         return Q_NULLPTR;
     }
 
     if (m_changed || node == nullptr) {
         QImage img;
         const QSize itemSize(width(), height());
         QRect nodeRect(QPoint(0,0), itemSize);
 
         if (itemSize.width() != 0 && itemSize.height() != 0) {
             const auto multiplier = QCoreApplication::instance()->testAttribute(Qt::AA_UseHighDpiPixmaps) ? 1 : (window() ? window()->devicePixelRatio() : qApp->devicePixelRatio());
             const QSize size = itemSize * multiplier;
 
             switch(m_source.type()){
             case QVariant::Pixmap:
                 img = m_source.value<QPixmap>().toImage();
                 break;
             case QVariant::Image:
                 img = m_source.value<QImage>();
                 break;
             case QVariant::Bitmap:
                 img = m_source.value<QBitmap>().toImage();
                 break;
             case QVariant::Icon:
                 img = m_source.value<QIcon>().pixmap(size, iconMode(), QIcon::On).toImage();
                 break;
             case QVariant::Url:
             case QVariant::String:
                 img = findIcon(size);
                 break;
             case QVariant::Brush:
                 //todo: fill here too?
             case QVariant::Color:
                 img = QImage(size, QImage::Format_Alpha8);
                 img.fill(m_source.value<QColor>());
                 break;
             default:
                 break;
             }
 
             if (img.isNull()){
                 img = QImage(size, QImage::Format_Alpha8);
                 img.fill(Qt::transparent);
             }
             if (img.size() != size) {
                 // At this point, the image will already be scaled, but we need to output it in
                 // the correct aspect ratio, painted centered in the viewport. So:
                 QRect destination(QPoint(0, 0), img.size().scaled(itemSize, Qt::KeepAspectRatio));
                 destination.moveCenter(nodeRect.center());
                 nodeRect = destination;
             }
             
             const QColor tintColor = !m_color.isValid() || m_color == Qt::transparent ? (m_selected ? m_theme->highlightedTextColor() : m_theme->textColor()) : m_color;
 
             //TODO: initialize m_isMask with icon.isMask()
             if (tintColor.alpha() > 0 && (isMask() || guessMonochrome(img))) {
                 QPainter p(&img);
                 p.setCompositionMode(QPainter::CompositionMode_SourceIn);
                 p.fillRect(img.rect(), tintColor);
                 p.end();
             }
         }
         m_changed = false;
 
         ManagedTextureNode* mNode = dynamic_cast<ManagedTextureNode*>(node);
         if (!mNode) {
             delete node;
             mNode = new ManagedTextureNode;
         }
         mNode->setTexture(s_iconImageCache->loadTexture(window(), img));
         mNode->setRect(nodeRect);
         node = mNode;
         if (m_smooth) {
             mNode->setFiltering(QSGTexture::Linear);
         }
     }
 
     return node;
 }
 
 void Icon::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
 {
     if (newGeometry.size() != oldGeometry.size()) {
         m_changed = true;
         update();
     }
     QQuickItem::geometryChanged(newGeometry, oldGeometry);
 }
 
 void Icon::handleRedirect(QNetworkReply* reply)
 {
     QNetworkAccessManager* qnam = reply->manager();
     if (reply->error() != QNetworkReply::NoError) {
         return;
     }
     const QUrl possibleRedirectUrl = reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl();
     if (!possibleRedirectUrl.isEmpty()) {
         const QUrl redirectUrl = reply->url().resolved(possibleRedirectUrl);
         if (redirectUrl == reply->url()) {
             // no infinite redirections thank you very much
             reply->deleteLater();
             return;
         }
         reply->deleteLater();
         QNetworkRequest request(possibleRedirectUrl);
         request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
         m_networkReply = qnam->get(request);
         connect(m_networkReply.data(), &QNetworkReply::finished, this, [this](){handleFinished(m_networkReply); });
     }
 }
 
 void Icon::handleFinished(QNetworkReply* reply)
 {
     reply->deleteLater();
     if (!reply->attribute(QNetworkRequest::RedirectionTargetAttribute).isNull()) {
         handleRedirect(reply);
         return;
     }
 
     m_loadedImage = QImage();
 
     const QString filename = reply->url().fileName();
     if (!m_loadedImage.load(reply, filename.mid(filename.indexOf(QLatin1Char('.'))).toLatin1().constData())) {
         qWarning() << "received broken image" << reply->url();
 
         // broken image from data, inform the user of this with some useful broken-image thing...
         const QSize size = QSize(width(), height()) * (window() ? window()->devicePixelRatio() : qApp->devicePixelRatio());
         m_loadedImage = QIcon::fromTheme(m_fallback).pixmap(size, iconMode(), QIcon::On).toImage();
     }
     m_changed = true;
     update();
 }
 
 QImage Icon::findIcon(const QSize &size)
 {
     QImage img;
     QString iconSource = m_source.toString();
 
     if (iconSource.startsWith(QLatin1String("image://"))) {
         QUrl iconUrl(iconSource);
         QString iconProviderId = iconUrl.host();
         QString iconId = iconUrl.path();
 
         // QRC paths are not correctly handled by .path()
         if (iconId.size() >=2 && iconId.startsWith(QLatin1String("/:"))) {
-            iconId = iconId.remove(0, 1);
+            iconId.remove(0, 1);
         }
 
         QSize actualSize;
         QQuickImageProvider* imageProvider = dynamic_cast<QQuickImageProvider*>(
                     qmlEngine(this)->imageProvider(iconProviderId));
         if (!imageProvider)
             return img;
         switch(imageProvider->imageType()){
         case QQmlImageProviderBase::Image:
             img = imageProvider->requestImage(iconId, &actualSize, size);
             break;
         case QQmlImageProviderBase::Pixmap:
             img = imageProvider->requestPixmap(iconId, &actualSize, size).toImage();
             break;
         case QQmlImageProviderBase::Texture:
         case QQmlImageProviderBase::Invalid:
         case QQmlImageProviderBase::ImageResponse:
             //will have to investigate this more
             break;
         }
     } else if(iconSource.startsWith(QLatin1String("http://")) || iconSource.startsWith(QLatin1String("https://"))) {
         if(!m_loadedImage.isNull()) {
             return m_loadedImage.scaled(size, Qt::KeepAspectRatio, m_smooth ? Qt::SmoothTransformation : Qt::FastTransformation );
         }
         const auto url = m_source.toUrl();
         QQmlEngine* engine = qmlEngine(this);
         QNetworkAccessManager* qnam;
         if (engine && (qnam = engine->networkAccessManager()) && (!m_networkReply || m_networkReply->url() != url)) {
             QNetworkRequest request(url);
             request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferCache);
             m_networkReply = qnam->get(request);
             connect(m_networkReply.data(), &QNetworkReply::finished, this, [this](){ handleFinished(m_networkReply); });
         }
         // Temporary icon while we wait for the real image to load...
         img = QIcon::fromTheme(QStringLiteral("image-x-icon")).pixmap(size, iconMode(), QIcon::On).toImage();
     } else {
         if (iconSource.startsWith(QLatin1String("qrc:/"))) {
             iconSource = iconSource.mid(3);
         } else if (iconSource.startsWith(QLatin1String("file:/"))) {
             iconSource = QUrl(iconSource).path();
         }
 
         QIcon icon;
         const bool isPath = iconSource.contains(QLatin1String("/"));
         if (isPath) {
             icon = QIcon(iconSource);
         } else {
             if (icon.isNull()) {
                 icon = m_theme->iconFromTheme(iconSource, m_color);
             }
         }
         if (!icon.isNull()) {
             img = icon.pixmap(size, iconMode(), QIcon::On).toImage();
 
             /*const QColor tintColor = !m_color.isValid() || m_color == Qt::transparent ? (m_selected ? m_theme->highlightedTextColor() : m_theme->textColor()) : m_color;
 
-            if (m_isMask || icon.isMask() || iconSource.endsWith(QStringLiteral("-symbolic")) || iconSource.endsWith(QStringLiteral("-symbolic-rtl")) || iconSource.endsWith(QStringLiteral("-symbolic-ltr")) || guessMonochrome(img)) {
+            if (m_isMask || icon.isMask() || iconSource.endsWith(QLatin1String("-symbolic")) || iconSource.endsWith(QLatin1String("-symbolic-rtl")) || iconSource.endsWith(QLatin1String("-symbolic-ltr")) || guessMonochrome(img)) {
                 QPainter p(&img);
                 p.setCompositionMode(QPainter::CompositionMode_SourceIn);
                 p.fillRect(img.rect(), tintColor);
                 p.end();
             }*/
         }
     }
     return img;
 }
 
 QIcon::Mode Icon::iconMode() const
 {
     if (!isEnabled()) {
         return QIcon::Disabled;
     } else if (m_selected) {
         return QIcon::Selected;
     } else if (m_active) {
         return QIcon::Active;
     }
     return QIcon::Normal;
 }
 
 bool Icon::guessMonochrome(const QImage &img)
 {
     //don't try for too big images
     if (img.width() >= 256 || m_theme->supportsIconColoring()) {
         return false;
     }
     // round size to a standard size. hardcode as we can't use KIconLoader
     int stdSize;
     if (img.width() <= 16) {
         stdSize = 16;
     } else if (img.width() <= 22) {
         stdSize = 22;
     } else if (img.width() <= 24) {
         stdSize = 24;
     } else if (img.width() <= 32) {
         stdSize = 32;
     } else if (img.width() <= 48) {
         stdSize = 48;
     } else if (img.width() <= 64) {
         stdSize = 64;
     } else {
         stdSize = 128;
     }
 
     auto findIt = m_monochromeHeuristics.constFind(stdSize);
     if (findIt != m_monochromeHeuristics.constEnd()) {
         return findIt.value();
     }
 
     QHash<int, int> dist;
     int transparentPixels = 0;
     int saturatedPixels = 0;
     for(int x=0; x < img.width(); x++) {
         for(int y=0; y < img.height(); y++) {
             QColor color = QColor::fromRgba(qUnpremultiply(img.pixel(x, y)));
             if (color.alpha() < 100) {
                 ++transparentPixels;
                 continue;
             } else if (color.saturation() > 84) {
                 ++saturatedPixels;
             }
             dist[qGray(color.rgb())]++;
         }
     }
 
     QMultiMap<int, int> reverseDist;
     auto it = dist.constBegin();
     std::vector<qreal> probabilities(dist.size());
     qreal entropy = 0;
     while (it != dist.constEnd()) {
         reverseDist.insertMulti(it.value(), it.key());
         qreal probability = qreal(it.value()) / qreal(img.size().width() * img.size().height() - transparentPixels);
         entropy -= probability * log(probability) / log(255);
         ++it;
     }
 
     // Arbitrarly low values of entropy and colored pixels
     m_monochromeHeuristics[stdSize] = saturatedPixels <= (img.size().width()*img.size().height() - transparentPixels) * 0.3 && entropy <= 0.3;
     return m_monochromeHeuristics[stdSize];
 }
 
 QString Icon::fallback() const
 {
     return m_fallback;
 }
 
 void Icon::setFallback(const QString& fallback)
 {
     if (m_fallback != fallback) {
         m_fallback = fallback;
         Q_EMIT fallbackChanged(fallback);
     }
 }
 
 #include "moc_icon.cpp"
diff --git a/src/kirigamiplugin.cpp b/src/kirigamiplugin.cpp
index f2700c02..018fcd79 100644
--- a/src/kirigamiplugin.cpp
+++ b/src/kirigamiplugin.cpp
@@ -1,200 +1,200 @@
 /*
  *   Copyright 2009 by Alan Alpert <alan.alpert@nokia.com>
  *   Copyright 2010 by Ménard Alexis <menard@kde.org>
  *   Copyright 2010 by Marco Martin <mart@kde.org>
 
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public License for more details
  *
  *   You should have received a copy of the GNU Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #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 "scenepositionattached.h"
 #include "wheelhandler.h"
 
 #include <QQmlEngine>
 #include <QQmlContext>
 #include <QQuickItem>
 #include <QQuickStyle>
 
 #include "libkirigami/platformtheme.h"
 
 static QString s_selectedStyle;
 
 //Q_INIT_RESOURCE(kirigami);
 #ifdef KIRIGAMI_BUILD_TYPE_STATIC
 #include <qrc_kirigami.cpp>
 #endif
 
 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)
 {
     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(QStringLiteral("Material"))) {
+    if (!m_stylesFallbackChain.contains(QLatin1String("Material"))) {
         m_stylesFallbackChain.prepend(QStringLiteral("Material"));
     }
 #else // do we have an iOS specific style?
-    if (!m_stylesFallbackChain.contains(QStringLiteral("Material"))) {
+    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");
 
     //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."));
 
     qmlProtectModule(uri, 2);
 }
 
 #include "moc_kirigamiplugin.cpp"