diff --git a/src/declarativeimports/core/windowthumbnail.cpp b/src/declarativeimports/core/windowthumbnail.cpp
index 7d26c9bec..1dc490931 100644
--- a/src/declarativeimports/core/windowthumbnail.cpp
+++ b/src/declarativeimports/core/windowthumbnail.cpp
@@ -1,899 +1,899 @@
 /*
  *   Copyright 2013 by 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 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 "windowthumbnail.h"
 // KF5
 #include <kwindowsystem.h>
 // Qt
 #include <QGuiApplication>
 #include <QIcon>
 #include <QOpenGLContext>
 #include <QQuickWindow>
 #include <QRunnable>
 
 // X11
 #if HAVE_XCB_COMPOSITE
 #include <QX11Info>
 #include <xcb/composite.h>
 #if HAVE_GLX
 #include <GL/glx.h>
 typedef void (*glXBindTexImageEXT_func)(Display *dpy, GLXDrawable drawable,
                                         int buffer, const int *attrib_list);
 typedef void (*glXReleaseTexImageEXT_func)(Display *dpy, GLXDrawable drawable, int buffer);
 #endif
 #if HAVE_EGL
 typedef EGLImageKHR(*eglCreateImageKHR_func)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint *);
 typedef EGLBoolean(*eglDestroyImageKHR_func)(EGLDisplay, EGLImageKHR);
 typedef GLvoid(*glEGLImageTargetTexture2DOES_func)(GLenum, GLeglImageOES);
 #endif // HAVE_EGL
 #endif
 
 #include <cstdlib>
 
 namespace Plasma
 {
 
 #if HAVE_XCB_COMPOSITE
 #if HAVE_GLX
 class DiscardGlxPixmapRunnable : public QRunnable {
 public:
     DiscardGlxPixmapRunnable(
         uint,
         QFunctionPointer,
         xcb_pixmap_t
     );
     void run() override;
 private:
     uint m_texture;
     QFunctionPointer m_releaseTexImage;
     xcb_pixmap_t m_glxPixmap;
 };
 
 DiscardGlxPixmapRunnable::DiscardGlxPixmapRunnable(uint texture, QFunctionPointer deleteFunction, xcb_pixmap_t pixmap)
     : QRunnable(),
     m_texture(texture),
     m_releaseTexImage(deleteFunction),
     m_glxPixmap(pixmap)
 {}
 
 void DiscardGlxPixmapRunnable::run()
 {
     if (m_glxPixmap != XCB_PIXMAP_NONE) {
         Display *d = QX11Info::display();
         ((glXReleaseTexImageEXT_func)(m_releaseTexImage))(d, m_glxPixmap, GLX_FRONT_LEFT_EXT);
         glXDestroyPixmap(d, m_glxPixmap);
         glDeleteTextures(1, &m_texture);
     }
 }
 #endif //HAVE_GLX
 
 #if HAVE_EGL
 class DiscardEglPixmapRunnable : public QRunnable {
 public:
     DiscardEglPixmapRunnable(
         uint,
         QFunctionPointer,
         EGLImageKHR
     );
     void run() override;
 private:
     uint m_texture;
     QFunctionPointer m_eglDestroyImageKHR;
     EGLImageKHR m_image;
 };
 
 DiscardEglPixmapRunnable::DiscardEglPixmapRunnable(uint texture, QFunctionPointer deleteFunction, EGLImageKHR image)
     : QRunnable(),
     m_texture(texture),
     m_eglDestroyImageKHR(deleteFunction),
     m_image(image)
 {}
 
 void DiscardEglPixmapRunnable::run()
 {
     if (m_image != EGL_NO_IMAGE_KHR) {
         ((eglDestroyImageKHR_func)(m_eglDestroyImageKHR))(eglGetCurrentDisplay(), m_image);
         glDeleteTextures(1, &m_texture);
     }
 }
 #endif//HAVE_EGL
 #endif //HAVE_XCB_COMPOSITE
 
 WindowTextureNode::WindowTextureNode()
     : QSGSimpleTextureNode()
 {
 }
 
 WindowTextureNode::~WindowTextureNode()
 {
 }
 
 void WindowTextureNode::reset(QSGTexture *texture)
 {
     setTexture(texture);
     m_texture.reset(texture);
 }
 
 WindowThumbnail::WindowThumbnail(QQuickItem *parent)
     : QQuickItem(parent)
     , QAbstractNativeEventFilter()
     , m_xcb(false)
     , m_composite(false)
     , m_winId(0)
     , m_paintedSize(QSizeF())
     , m_thumbnailAvailable(false)
     , m_damaged(false)
     , m_depth(0)
 #if HAVE_XCB_COMPOSITE
     , m_openGLFunctionsResolved(false)
     , m_damageEventBase(0)
     , m_damage(XCB_NONE)
     , m_pixmap(XCB_PIXMAP_NONE)
     , m_texture(0)
 #if HAVE_GLX
     , m_glxPixmap(XCB_PIXMAP_NONE)
     , m_bindTexImage(nullptr)
     , m_releaseTexImage(nullptr)
 #endif // HAVE_GLX
 #if HAVE_EGL
     , m_eglFunctionsResolved(false)
     , m_image(EGL_NO_IMAGE_KHR)
     , m_eglCreateImageKHR(nullptr)
     , m_eglDestroyImageKHR(nullptr)
     , m_glEGLImageTargetTexture2DOES(nullptr)
 #endif // HAVE_EGL
 #endif
 {
     setFlag(ItemHasContents);
     connect(this, &QQuickItem::windowChanged, [this](QQuickWindow * window) {
         if (!window) {
             return;
         }
         // restart the redirection, it might not have been active yet
         stopRedirecting();
         startRedirecting();
         update();
     });
     connect(this, &QQuickItem::enabledChanged, [this]() {
         if (!isEnabled()) {
             stopRedirecting();
             releaseResources();
         } else if (isVisible()) {
             startRedirecting();
             update();
         }
     });
     connect(this, &QQuickItem::visibleChanged, [this]() {
         if (!isVisible()) {
             stopRedirecting();
             releaseResources();
         } else if (isEnabled()) {
             startRedirecting();
             update();
         }
     });
     if (QGuiApplication *gui = dynamic_cast<QGuiApplication *>(QCoreApplication::instance())) {
         m_xcb = (gui->platformName() == QStringLiteral("xcb"));
         if (m_xcb) {
             gui->installNativeEventFilter(this);
 #if HAVE_XCB_COMPOSITE
             xcb_connection_t *c = QX11Info::connection();
             xcb_prefetch_extension_data(c, &xcb_composite_id);
             const auto *compositeReply = xcb_get_extension_data(c, &xcb_composite_id);
             m_composite = (compositeReply && compositeReply->present);
 
             xcb_prefetch_extension_data(c, &xcb_damage_id);
             const auto *reply = xcb_get_extension_data(c, &xcb_damage_id);
             m_damageEventBase = reply->first_event;
             if (reply->present) {
                 xcb_damage_query_version_unchecked(c, XCB_DAMAGE_MAJOR_VERSION, XCB_DAMAGE_MINOR_VERSION);
             }
 #endif
         }
     }
 }
 
 WindowThumbnail::~WindowThumbnail()
 {
     if (m_xcb) {
         QCoreApplication::instance()->removeNativeEventFilter(this);
         stopRedirecting();
     }
 }
 
 void WindowThumbnail::releaseResources()
 {
 #if HAVE_XCB_COMPOSITE
 
 #if HAVE_GLX && HAVE_EGL
     //only one (or none) should be set, but never both
     Q_ASSERT(m_glxPixmap == XCB_PIXMAP_NONE || m_image == EGL_NO_IMAGE_KHR);
 #endif
 #if HAVE_GLX || HAVE_EGL
     QQuickWindow::RenderStage m_renderStage = QQuickWindow::NoStage;
 #endif
 
     //data is deleted in the render thread (with relevant GLX calls)
     //note runnable may be called *after* this is deleted
     //but the pointer is held by the WindowThumbnail which is in the main thread
 #if HAVE_GLX
     if (m_glxPixmap != XCB_PIXMAP_NONE) {
         window()->scheduleRenderJob(new DiscardGlxPixmapRunnable(m_texture,
                                                         m_releaseTexImage,
                                                         m_glxPixmap),
                                                         m_renderStage);
 
         m_glxPixmap = XCB_PIXMAP_NONE;
         m_texture = 0;
     }
 #endif
 #if HAVE_EGL
     if (m_image != EGL_NO_IMAGE_KHR) {
         window()->scheduleRenderJob(new DiscardEglPixmapRunnable(m_texture,
                                                         m_eglDestroyImageKHR,
                                                         m_image),
                                                         m_renderStage);
 
         m_image = EGL_NO_IMAGE_KHR;
         m_texture = 0;
     }
 #endif
 #endif
 }
 
 
 
 uint32_t WindowThumbnail::winId() const
 {
     return m_winId;
 }
 
 void WindowThumbnail::setWinId(uint32_t winId)
 {
     if (m_winId == winId) {
         return;
     }
     if (!KWindowSystem::self()->hasWId(winId)) {
         // invalid Id, don't updated
         return;
     }
     if (window() && winId == window()->winId()) {
         // don't redirect to yourself
         return;
     }
     stopRedirecting();
     m_winId = winId;
 
     if (isEnabled() && isVisible()) {
         startRedirecting();
     }
 
     emit winIdChanged();
 }
 
 qreal WindowThumbnail::paintedWidth() const
 {
     return m_paintedSize.width();
 }
 
 qreal WindowThumbnail::paintedHeight() const
 {
     return m_paintedSize.height();
 }
 
 bool WindowThumbnail::thumbnailAvailable() const
 {
     return m_thumbnailAvailable;
 }
 
 QSGNode *WindowThumbnail::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData)
 {
     Q_UNUSED(updatePaintNodeData)
     auto *node = static_cast<WindowTextureNode *>(oldNode);
     if (!node) {
         node = new WindowTextureNode();
         node->setFiltering(QSGTexture::Linear);
     }
     if (!m_xcb || m_winId == 0 || (window() && window()->winId() == m_winId)) {
         iconToTexture(node);
     } else {
         windowToTexture(node);
     }
     node->setRect(boundingRect());
     const QSizeF size(node->texture()->textureSize().scaled(boundingRect().size().toSize(), Qt::KeepAspectRatio));
     if (size != m_paintedSize) {
         m_paintedSize = size;
         emit paintedSizeChanged();
     }
     const qreal x = boundingRect().x() + (boundingRect().width() - size.width()) / 2;
     const qreal y = boundingRect().y() + (boundingRect().height() - size.height()) / 2;
     node->setRect(QRectF(QPointF(x, y), size));
     return node;
 }
 
 bool WindowThumbnail::nativeEventFilter(const QByteArray &eventType, void *message, long int *result)
 {
     Q_UNUSED(result)
     if (!m_xcb || !m_composite || eventType != QByteArrayLiteral("xcb_generic_event_t")) {
         // currently we are only interested in XCB events
         return false;
     }
 #if HAVE_XCB_COMPOSITE
     xcb_generic_event_t *event = static_cast<xcb_generic_event_t *>(message);
     const uint8_t responseType = event->response_type & ~0x80;
     if (responseType == m_damageEventBase + XCB_DAMAGE_NOTIFY) {
         if (reinterpret_cast<xcb_damage_notify_event_t *>(event)->drawable == m_winId) {
             m_damaged = true;
             update();
         }
     } else if (responseType == XCB_CONFIGURE_NOTIFY) {
         if (reinterpret_cast<xcb_configure_notify_event_t *>(event)->window == m_winId) {
             releaseResources();
             m_damaged = true;
             update();
         }
     } else if (responseType == XCB_MAP_NOTIFY) {
         if (reinterpret_cast<xcb_configure_notify_event_t *>(event)->window == m_winId) {
             releaseResources();
             m_damaged = true;
             update();
         }
     }
 #else
     Q_UNUSED(message)
 #endif
     // do not filter out any events, there might be further WindowThumbnails for the same window
     return false;
 }
 
 void WindowThumbnail::iconToTexture(WindowTextureNode *textureNode)
 {
     QIcon icon;
     if (KWindowSystem::self()->hasWId(m_winId)) {
         icon = KWindowSystem::self()->icon(m_winId, boundingRect().width(), boundingRect().height());
     } else {
         // fallback to plasma icon
         icon = QIcon::fromTheme(QStringLiteral("plasma"));
     }
     QImage image = icon.pixmap(boundingRect().size().toSize()).toImage();
     textureNode->reset(window()->createTextureFromImage(image, QQuickWindow::TextureCanUseAtlas));
 }
 
 #if HAVE_XCB_COMPOSITE
 #if HAVE_GLX
 bool WindowThumbnail::windowToTextureGLX(WindowTextureNode *textureNode)
 {
     if (glXGetCurrentContext()) {
         if (!m_openGLFunctionsResolved) {
             resolveGLXFunctions();
         }
         if (!m_bindTexImage || !m_releaseTexImage) {
             return false;
         }
         if (m_glxPixmap == XCB_PIXMAP_NONE) {
             xcb_connection_t *c = QX11Info::connection();
             auto attrCookie = xcb_get_window_attributes_unchecked(c, m_winId);
             auto geometryCookie = xcb_get_geometry_unchecked(c, m_pixmap);
             QScopedPointer<xcb_get_window_attributes_reply_t, QScopedPointerPodDeleter> attr(xcb_get_window_attributes_reply(c, attrCookie, nullptr));
             QScopedPointer<xcb_get_geometry_reply_t, QScopedPointerPodDeleter> geo(xcb_get_geometry_reply(c, geometryCookie, nullptr));
 
             if (attr.isNull()) {
                 return false;
             }
 
             if (geo.isNull()) {
                 return false;
             }
 
             m_depth = geo->depth;
             m_visualid = attr->visual;
 
             if (!loadGLXTexture()) {
                 return false;
             }
 
             textureNode->reset(window()->createTextureFromId(m_texture, QSize(geo->width, geo->height), QQuickWindow::TextureCanUseAtlas));
         }
         textureNode->texture()->bind();
         bindGLXTexture();
         return true;
     }
     return false;
 }
 #endif // HAVE_GLX
 
 #if HAVE_EGL
 bool WindowThumbnail::xcbWindowToTextureEGL(WindowTextureNode *textureNode)
 {
     EGLContext context = eglGetCurrentContext();
 
     if (context != EGL_NO_CONTEXT) {
         if (!m_eglFunctionsResolved) {
             resolveEGLFunctions();
         }
         if (QByteArray((char *)glGetString(GL_RENDERER)).contains("llvmpipe")) {
             return false;
         }
         if (!m_eglCreateImageKHR || !m_eglDestroyImageKHR || !m_glEGLImageTargetTexture2DOES) {
             return false;
         }
         if (m_image == EGL_NO_IMAGE_KHR) {
             xcb_connection_t *c = QX11Info::connection();
             auto geometryCookie = xcb_get_geometry_unchecked(c, m_pixmap);
 
             const EGLint attribs[] = {
                 EGL_IMAGE_PRESERVED_KHR, EGL_TRUE,
                 EGL_NONE
             };
             m_image = ((eglCreateImageKHR_func)(m_eglCreateImageKHR))(eglGetCurrentDisplay(), EGL_NO_CONTEXT,
                       EGL_NATIVE_PIXMAP_KHR,
                       (EGLClientBuffer)m_pixmap, attribs);
 
             if (m_image == EGL_NO_IMAGE_KHR) {
                 qDebug() << "failed to create egl image";
                 return false;
             }
 
             glGenTextures(1, &m_texture);
             QScopedPointer<xcb_get_geometry_reply_t, QScopedPointerPodDeleter> geo(xcb_get_geometry_reply(c, geometryCookie, nullptr));
             QSize size;
             if (!geo.isNull()) {
                 size.setWidth(geo->width);
                 size.setHeight(geo->height);
             }
             textureNode->reset(window()->createTextureFromId(m_texture, size, QQuickWindow::TextureCanUseAtlas));
         }
         textureNode->texture()->bind();
         bindEGLTexture();
         return true;
     }
     return false;
 }
 
 void WindowThumbnail::resolveEGLFunctions()
 {
     EGLDisplay display = eglGetCurrentDisplay();
     if (display == EGL_NO_DISPLAY) {
         return;
     }
     auto *context = window()->openglContext();
     QList<QByteArray> extensions = QByteArray(eglQueryString(display, EGL_EXTENSIONS)).split(' ');
     if (extensions.contains(QByteArrayLiteral("EGL_KHR_image")) ||
             (extensions.contains(QByteArrayLiteral("EGL_KHR_image_base")) &&
              extensions.contains(QByteArrayLiteral("EGL_KHR_image_pixmap")))) {
         if (context->hasExtension(QByteArrayLiteral("GL_OES_EGL_image"))) {
             qDebug() << "Have EGL texture from pixmap";
             m_eglCreateImageKHR = context->getProcAddress(QByteArrayLiteral("eglCreateImageKHR"));
             m_eglDestroyImageKHR = context->getProcAddress(QByteArrayLiteral("eglDestroyImageKHR"));
             m_glEGLImageTargetTexture2DOES = context->getProcAddress(QByteArrayLiteral("glEGLImageTargetTexture2DOES"));
         }
     }
     m_eglFunctionsResolved = true;
 }
 
 void WindowThumbnail::bindEGLTexture()
 {
     ((glEGLImageTargetTexture2DOES_func)(m_glEGLImageTargetTexture2DOES))(GL_TEXTURE_2D, (GLeglImageOES)m_image);
     resetDamaged();
 }
 #endif // HAVE_EGL
 
 #endif // HAVE_XCB_COMPOSITE
 
 void WindowThumbnail::windowToTexture(WindowTextureNode *textureNode)
 {
     if (!m_damaged && textureNode->texture()) {
         return;
     }
 #if HAVE_XCB_COMPOSITE
     if (!textureNode->texture()) {
         // the texture got discarded by the scene graph, but our mapping is still valid
         // let's discard the pixmap to have a clean state again
         releaseResources();
     }
     if (m_pixmap == XCB_PIXMAP_NONE) {
         m_pixmap = pixmapForWindow();
     }
     if (m_pixmap == XCB_PIXMAP_NONE) {
         // create above failed
         iconToTexture(textureNode);
         setThumbnailAvailable(false);
         return;
     }
     bool fallbackToIcon = true;
 #if HAVE_GLX
     fallbackToIcon = !windowToTextureGLX(textureNode);
 #endif // HAVE_GLX
 #if HAVE_EGL
     if (fallbackToIcon) {
         // if glx succeeded fallbackToIcon is false, thus we shouldn't try egl
         fallbackToIcon = !xcbWindowToTextureEGL(textureNode);
     }
 #endif // HAVE_EGL
     if (fallbackToIcon) {
         // just for safety to not crash
         iconToTexture(textureNode);
     }
     setThumbnailAvailable(!fallbackToIcon);
     textureNode->markDirty(QSGNode::DirtyForceUpdate);
 #else
     iconToTexture(textureNode);
 #endif
 }
 
 #if HAVE_XCB_COMPOSITE
 xcb_pixmap_t WindowThumbnail::pixmapForWindow()
 {
     if (!m_composite) {
         return XCB_PIXMAP_NONE;
     }
 
     xcb_connection_t *c = QX11Info::connection();
     xcb_pixmap_t pix = xcb_generate_id(c);
     auto cookie = xcb_composite_name_window_pixmap_checked(c, m_winId, pix);
     QScopedPointer<xcb_generic_error_t, QScopedPointerPodDeleter> error(xcb_request_check(c, cookie));
     if (error) {
         return XCB_PIXMAP_NONE;
     }
     return pix;
 }
 
 #if HAVE_GLX
 void WindowThumbnail::resolveGLXFunctions()
 {
     auto *context = window()->openglContext();
     QList<QByteArray> extensions = QByteArray(glXQueryExtensionsString(QX11Info::display(), QX11Info::appScreen())).split(' ');
     if (extensions.contains(QByteArrayLiteral("GLX_EXT_texture_from_pixmap"))) {
         m_bindTexImage = context->getProcAddress(QByteArrayLiteral("glXBindTexImageEXT"));
         m_releaseTexImage = context->getProcAddress(QByteArrayLiteral("glXReleaseTexImageEXT"));
     } else
         qWarning() << "couldn't resolve GLX_EXT_texture_from_pixmap functions";
     m_openGLFunctionsResolved = true;
 }
 
 void WindowThumbnail::bindGLXTexture()
 {
     Display *d = QX11Info::display();
     ((glXReleaseTexImageEXT_func)(m_releaseTexImage))(d, m_glxPixmap, GLX_FRONT_LEFT_EXT);
     ((glXBindTexImageEXT_func)(m_bindTexImage))(d, m_glxPixmap, GLX_FRONT_LEFT_EXT, nullptr);
     resetDamaged();
 }
 
 struct FbConfigInfo
 {
     GLXFBConfig fbConfig;
     int textureFormat;
 };
 
 struct GlxGlobalData
 {
     GlxGlobalData() {
 	xcb_connection_t * const conn = QX11Info::connection();
 
         // Fetch the render pict formats
         reply = xcb_render_query_pict_formats_reply(conn,
                         xcb_render_query_pict_formats_unchecked(conn), nullptr);
 
         // Init the visual ID -> format ID hash table
         for (auto screens = xcb_render_query_pict_formats_screens_iterator(reply); screens.rem; xcb_render_pictscreen_next(&screens)) {
             for (auto depths = xcb_render_pictscreen_depths_iterator(screens.data); depths.rem; xcb_render_pictdepth_next(&depths)) {
                 const xcb_render_pictvisual_t *visuals = xcb_render_pictdepth_visuals(depths.data);
                 const int len = xcb_render_pictdepth_visuals_length(depths.data);
 
                 for (int i = 0; i < len; i++)
                     visualPictFormatHash.insert(visuals[i].visual, visuals[i].format);
             }
         }
 
         // Init the format ID -> xcb_render_directformat_t* hash table
         const xcb_render_pictforminfo_t *formats = xcb_render_query_pict_formats_formats(reply);
         const int len = xcb_render_query_pict_formats_formats_length(reply);
 
         for (int i = 0; i < len; i++) {
             if (formats[i].type == XCB_RENDER_PICT_TYPE_DIRECT)
                 formatInfoHash.insert(formats[i].id, &formats[i].direct);
         }
 
         // Init the visual ID -> depth hash table
         const xcb_setup_t *setup = xcb_get_setup(conn);
 
         for (auto screen = xcb_setup_roots_iterator(setup); screen.rem; xcb_screen_next(&screen)) {
             for (auto depth = xcb_screen_allowed_depths_iterator(screen.data); depth.rem; xcb_depth_next(&depth)) {
                 const int len = xcb_depth_visuals_length(depth.data);
                 const xcb_visualtype_t *visuals = xcb_depth_visuals(depth.data);
 
                 for (int i = 0; i < len; i++)
                     visualDepthHash.insert(visuals[i].visual_id, depth.data->depth);
             }
         }
     }
 
     ~GlxGlobalData() {
         qDeleteAll(visualFbConfigHash);
         std::free(reply);
     }
 
     xcb_render_query_pict_formats_reply_t *reply;
     QHash<xcb_visualid_t, xcb_render_pictformat_t> visualPictFormatHash;
     QHash<xcb_visualid_t, uint32_t> visualDepthHash;
     QHash<xcb_visualid_t, FbConfigInfo *> visualFbConfigHash;
     QHash<xcb_render_pictformat_t, const xcb_render_directformat_t *> formatInfoHash;
 };
 
 Q_GLOBAL_STATIC(GlxGlobalData, g_glxGlobalData)
 
 static xcb_render_pictformat_t findPictFormat(xcb_visualid_t visual)
 {
     GlxGlobalData *d = g_glxGlobalData;
     return d->visualPictFormatHash.value(visual);
 }
 
 static const xcb_render_directformat_t *findPictFormatInfo(xcb_render_pictformat_t format)
 {
     GlxGlobalData *d = g_glxGlobalData;
     return d->formatInfoHash.value(format);
 }
 
 static int visualDepth(xcb_visualid_t visual)
 {
     GlxGlobalData *d = g_glxGlobalData;
     return d->visualDepthHash.value(visual);
 }
 
 FbConfigInfo *getConfig(xcb_visualid_t visual)
 {
     Display *dpy = QX11Info::display();
     const xcb_render_pictformat_t format = findPictFormat(visual);
     const xcb_render_directformat_t *direct = findPictFormatInfo(format);
 
     if (!direct) {
         return nullptr;
     }
 
     const int red_bits   = qPopulationCount(direct->red_mask);
     const int green_bits = qPopulationCount(direct->green_mask);
     const int blue_bits  = qPopulationCount(direct->blue_mask);
     const int alpha_bits = qPopulationCount(direct->alpha_mask);
 
     const int depth = visualDepth(visual);
 
     const auto rgb_sizes = std::tie(red_bits, green_bits, blue_bits);
 
     const int attribs[] = {
         GLX_RENDER_TYPE,                  GLX_RGBA_BIT,
         GLX_DRAWABLE_TYPE,                GLX_WINDOW_BIT | GLX_PIXMAP_BIT,
         GLX_X_VISUAL_TYPE,                GLX_TRUE_COLOR,
         GLX_X_RENDERABLE,                 True,
         GLX_CONFIG_CAVEAT,                int(GLX_DONT_CARE), // The ARGB32 visual is marked non-conformant in Catalyst
         GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, int(GLX_DONT_CARE),
         GLX_BUFFER_SIZE,                  red_bits + green_bits + blue_bits + alpha_bits,
         GLX_RED_SIZE,                     red_bits,
         GLX_GREEN_SIZE,                   green_bits,
         GLX_BLUE_SIZE,                    blue_bits,
         GLX_ALPHA_SIZE,                   alpha_bits,
         GLX_STENCIL_SIZE,                 0,
         GLX_DEPTH_SIZE,                   0,
         0
     };
 
     if (QByteArray((char *)glGetString(GL_RENDERER)).contains("llvmpipe")) {
         return nullptr;
     }
 
     int count = 0;
     GLXFBConfig *configs = glXChooseFBConfig(dpy, QX11Info::appScreen(), attribs, &count);
     if (count < 1) {
         return nullptr;
     }
 
     struct FBConfig {
         GLXFBConfig config;
         int depth;
         int stencil;
         int format;
     };
 
     QList<FBConfig> candidates;
 
     for (int i = 0; i < count; i++) {
         int red, green, blue;
         glXGetFBConfigAttrib(dpy, configs[i], GLX_RED_SIZE,   &red);
         glXGetFBConfigAttrib(dpy, configs[i], GLX_GREEN_SIZE, &green);
         glXGetFBConfigAttrib(dpy, configs[i], GLX_BLUE_SIZE,  &blue);
 
         if (std::tie(red, green, blue) != rgb_sizes)
             continue;
 
         xcb_visualid_t visual;
         glXGetFBConfigAttrib(dpy, configs[i], GLX_VISUAL_ID, (int *) &visual);
 
         if (visualDepth(visual) != depth)
             continue;
 
         int bind_rgb, bind_rgba;
         glXGetFBConfigAttrib(dpy, configs[i], GLX_BIND_TO_TEXTURE_RGBA_EXT, &bind_rgba);
         glXGetFBConfigAttrib(dpy, configs[i], GLX_BIND_TO_TEXTURE_RGB_EXT,  &bind_rgb);
 
         if (!bind_rgb && !bind_rgba)
             continue;
 
         int texture_targets;
         glXGetFBConfigAttrib(dpy, configs[i], GLX_BIND_TO_TEXTURE_TARGETS_EXT, &texture_targets);
 
         if ((texture_targets & GLX_TEXTURE_2D_BIT_EXT) == 0)
             continue;
 
         int depth, stencil;
         glXGetFBConfigAttrib(dpy, configs[i], GLX_DEPTH_SIZE,   &depth);
         glXGetFBConfigAttrib(dpy, configs[i], GLX_STENCIL_SIZE, &stencil);
 
         int texture_format;
         if (alpha_bits)
             texture_format = bind_rgba ? GLX_TEXTURE_FORMAT_RGBA_EXT : GLX_TEXTURE_FORMAT_RGB_EXT;
         else
             texture_format = bind_rgb ? GLX_TEXTURE_FORMAT_RGB_EXT : GLX_TEXTURE_FORMAT_RGBA_EXT;
 
         candidates.append(FBConfig{configs[i], depth, stencil, texture_format});
     }
 
     if (count > 0)
         XFree(configs);
 
     std::stable_sort(candidates.begin(), candidates.end(), [](const FBConfig &left, const FBConfig &right) {
         if (left.depth < right.depth)
             return true;
 
         if (left.stencil < right.stencil)
             return true;
 
         return false;
     });
 
     FbConfigInfo *info = nullptr;
 
-    if (candidates.size() > 0) {
+    if (!candidates.isEmpty()) {
         const FBConfig &candidate = candidates.front();
 
         info = new FbConfigInfo;
         info->fbConfig      = candidate.config;
         info->textureFormat = candidate.format;
     }
 
 
     return info;
 }
 
 bool WindowThumbnail::loadGLXTexture()
 {
     GLXContext glxContext = glXGetCurrentContext();
     if (!glxContext) {
         return false;
     }
 
     FbConfigInfo *info = nullptr;
 
     auto &hashTable = g_glxGlobalData->visualFbConfigHash;
     auto it = hashTable.constFind(m_visualid);
 
     if (it != hashTable.constEnd()) {
         info = *it;
     } else {
         info = getConfig(m_visualid);
         hashTable.insert(m_visualid, info);
     }
 
     if (!info) {
         return false;
     }
 
     glGenTextures(1, &m_texture);
 
     const int attrs[] = {
         GLX_TEXTURE_FORMAT_EXT, info->textureFormat,
         GLX_MIPMAP_TEXTURE_EXT, false,
         GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
         XCB_NONE
     };
 
     m_glxPixmap = glXCreatePixmap(QX11Info::display(), info->fbConfig, m_pixmap, attrs);
 
     return true;
 }
 #endif
 
 #endif
 
 void WindowThumbnail::resetDamaged()
 {
     m_damaged = false;
 #if HAVE_XCB_COMPOSITE
     if (m_damage == XCB_NONE) {
         return;
     }
     xcb_damage_subtract(QX11Info::connection(), m_damage, XCB_NONE, XCB_NONE);
 #endif
 }
 
 void WindowThumbnail::stopRedirecting()
 {
     if (!m_xcb || !m_composite) {
         return;
     }
 #if HAVE_XCB_COMPOSITE
     xcb_connection_t *c = QX11Info::connection();
     if (m_pixmap != XCB_PIXMAP_NONE) {
         xcb_free_pixmap(c, m_pixmap);
         m_pixmap = XCB_PIXMAP_NONE;
     }
     if (m_winId == XCB_WINDOW_NONE) {
         return;
     }
     xcb_composite_unredirect_window(c, m_winId, XCB_COMPOSITE_REDIRECT_AUTOMATIC);
     if (m_damage == XCB_NONE) {
         return;
     }
     xcb_damage_destroy(c, m_damage);
     m_damage = XCB_NONE;
 #endif
 }
 
 void WindowThumbnail::startRedirecting()
 {
     if (!m_xcb || !m_composite || !window() || window()->winId() == m_winId) {
         return;
     }
 #if HAVE_XCB_COMPOSITE
     if (m_winId == XCB_WINDOW_NONE) {
         return;
     }
     xcb_connection_t *c = QX11Info::connection();
 
     // need to get the window attributes for the existing event mask
     const auto attribsCookie = xcb_get_window_attributes_unchecked(c, m_winId);
 
     // redirect the window
     xcb_composite_redirect_window(c, m_winId, XCB_COMPOSITE_REDIRECT_AUTOMATIC);
 
     // generate the damage handle
     m_damage = xcb_generate_id(c);
     xcb_damage_create(c, m_damage, m_winId, XCB_DAMAGE_REPORT_LEVEL_NON_EMPTY);
 
     QScopedPointer<xcb_get_window_attributes_reply_t, QScopedPointerPodDeleter> attr(xcb_get_window_attributes_reply(c, attribsCookie, nullptr));
     uint32_t events = XCB_EVENT_MASK_STRUCTURE_NOTIFY;
     if (!attr.isNull()) {
         events = events | attr->your_event_mask;
     }
     // the event mask will not be removed again. We cannot track whether another component also needs STRUCTURE_NOTIFY (e.g. KWindowSystem).
     // if we would remove the event mask again, other areas will break.
     xcb_change_window_attributes(c, m_winId, XCB_CW_EVENT_MASK, &events);
     // force to update the texture
     m_damaged = true;
 #endif
 }
 
 
 
 void WindowThumbnail::setThumbnailAvailable(bool thumbnailAvailable)
 {
     if (m_thumbnailAvailable != thumbnailAvailable) {
         m_thumbnailAvailable = thumbnailAvailable;
         emit thumbnailAvailableChanged();
     }
 }
 
 } // namespace
diff --git a/src/scriptengines/qml/plasmoid/appletinterface.cpp b/src/scriptengines/qml/plasmoid/appletinterface.cpp
index 543aaffe4..6f8f002c4 100644
--- a/src/scriptengines/qml/plasmoid/appletinterface.cpp
+++ b/src/scriptengines/qml/plasmoid/appletinterface.cpp
@@ -1,843 +1,843 @@
 /*
  *   Copyright 2008-2013 Aaron Seigo <aseigo@kde.org>
  *   Copyright 2010-2013 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 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 "appletinterface.h"
 
 #include <QAction>
 #include <QDir>
 #include <QFile>
 #include <QIcon>
 #include <QTimer>
 
 #include <kactioncollection.h>
 #include <QDebug>
 #include <kservice.h>
 #include <klocalizedstring.h>
 #include <KConfigLoader>
 
 #include <Plasma/Plasma>
 #include <Plasma/Applet>
 #include <Plasma/Corona>
 #include <Plasma/Package>
 #include <Plasma/PluginLoader>
 #include <Plasma/ContainmentActions>
 
 #include "containmentinterface.h"
 #include "wallpaperinterface.h"
 #include <kdeclarative/configpropertymap.h>
 #include <kdeclarative/qmlobject.h>
 
 Q_DECLARE_METATYPE(AppletInterface *)
 
 AppletInterface::AppletInterface(DeclarativeAppletScript *script, const QVariantList &args, QQuickItem *parent)
     : AppletQuickItem(script->applet(), parent),
       m_configuration(nullptr),
       m_appletScriptEngine(script),
       m_toolTipTextFormat(0),
       m_toolTipItem(nullptr),
       m_args(args),
       m_backgroundHints(Plasma::Types::StandardBackground),
       m_hideOnDeactivate(true),
       m_oldKeyboardShortcut(0),
       m_dummyNativeInterface(nullptr),
       m_positionBeforeRemoval(QPointF(-1, -1))
 {
     qmlRegisterType<QAction>();
 
     connect(this, &AppletInterface::configNeedsSaving,
             applet(), &Plasma::Applet::configNeedsSaving);
     connect(applet(), &Plasma::Applet::immutabilityChanged,
             this, &AppletInterface::immutabilityChanged);
     connect(applet(), &Plasma::Applet::userConfiguringChanged,
             this, &AppletInterface::userConfiguringChanged);
 
     connect(applet(), &Plasma::Applet::contextualActionsAboutToShow,
             this, &AppletInterface::contextualActionsAboutToShow);
 
     connect(applet(), &Plasma::Applet::statusChanged,
             this, &AppletInterface::statusChanged);
 
     connect(applet(), &Plasma::Applet::destroyedChanged,
             this, &AppletInterface::destroyedChanged);
 
     connect(applet(), &Plasma::Applet::titleChanged,
             this, &AppletInterface::titleChanged);
 
     connect(applet(), &Plasma::Applet::titleChanged,
             this, [this]() {
                 if (m_toolTipMainText.isNull()) {
                     emit toolTipMainTextChanged();
                 }
             });
 
     connect(applet(), &Plasma::Applet::iconChanged,
             this, &AppletInterface::iconChanged);
 
     connect(applet(), &Plasma::Applet::busyChanged,
             this, &AppletInterface::busyChanged);
 
     connect(applet(), &Plasma::Applet::configurationRequiredChanged, this,
             [this](bool configurationRequired, const QString &reason) {
         Q_UNUSED(configurationRequired);
         Q_UNUSED(reason);
         emit configurationRequiredChanged();
         emit configurationRequiredReasonChanged();
     });
 
     connect(applet(), &Plasma::Applet::activated,
             this, &AppletInterface::activated);
 
     connect(appletScript(), &DeclarativeAppletScript::formFactorChanged,
             this, &AppletInterface::formFactorChanged);
     connect(appletScript(), &DeclarativeAppletScript::locationChanged,
             this, &AppletInterface::locationChanged);
     connect(appletScript(), &DeclarativeAppletScript::contextChanged,
             this, &AppletInterface::contextChanged);
 
     if (applet()->containment()) {
         connect(applet()->containment(), &Plasma::Containment::screenChanged,
                 this, &AppletInterface::screenChanged);
 
         // Screen change implies geo change for good measure.
         connect(applet()->containment(), &Plasma::Containment::screenChanged,
                 this, &AppletInterface::screenGeometryChanged);
 
         connect(applet()->containment()->corona(), &Plasma::Corona::screenGeometryChanged, this, [this](int id) {
             if (id == applet()->containment()->screen()) {
                 emit screenGeometryChanged();
             }
         });
 
     }
 
     connect(this, &AppletInterface::expandedChanged, [=](bool expanded) {
         //if both compactRepresentationItem and fullRepresentationItem exist,
         //the applet is in a popup
         if (expanded) {
             if (compactRepresentationItem() && fullRepresentationItem() &&
                 fullRepresentationItem()->window() && compactRepresentationItem()->window() &&
                 fullRepresentationItem()->window() != compactRepresentationItem()->window() &&
                 fullRepresentationItem()->parentItem()) {
                 fullRepresentationItem()->parentItem()->installEventFilter(this);
             } else if (fullRepresentationItem() && fullRepresentationItem()->parentItem()) {
                 fullRepresentationItem()->parentItem()->removeEventFilter(this);
             }
         }
     });
 }
 
 AppletInterface::~AppletInterface()
 {
 }
 
 DeclarativeAppletScript *AppletInterface::appletScript() const
 {
     return m_appletScriptEngine;
 }
 
 void AppletInterface::init()
 {
     if (qmlObject()->rootObject() && m_configuration) {
         return;
     }
 
     m_configuration = new KDeclarative::ConfigPropertyMap(applet()->configScheme(), this);
 
     AppletQuickItem::init();
 
     geometryChanged(QRectF(), QRectF(x(), y(), width(), height()));
     emit busyChanged();
 
     applet()->updateConstraints(Plasma::Types::UiReadyConstraint);
 
     connect(applet(), &Plasma::Applet::activated,
     [ = ]() {
         // in case the applet doesn't want to get shrinked on reactivation,
         // we always expand it again (only in order to conform with legacy behaviour)
         bool activate = !( isExpanded() && isActivationTogglesExpanded() );
 
         setExpanded(activate);
         if (activate) {
             if (QQuickItem *i = qobject_cast<QQuickItem *>(fullRepresentationItem())) {
                 // Bug 372476: never pull focus away from it, only setFocus(true)
                 i->setFocus(true, Qt::ShortcutFocusReason);
             }
         }
     });
 
     if (m_args.count() == 1) {
         emit externalData(QString(), m_args.first());
-    } else if (m_args.count() > 0) {
+    } else if (!m_args.isEmpty()) {
         emit externalData(QString(), m_args);
     }
 }
 
 void AppletInterface::destroyedChanged(bool destroyed)
 {
     //if an item loses its scene before losing the focus, will never
     //be able to gain focus again
     if (destroyed && window() && window()->activeFocusItem()) {
         QQuickItem *focus = window()->activeFocusItem();
         QQuickItem *candidate = focus;
         bool isAncestor = false;
 
         //search if the current focus item is a child or grandchild of the applet
         while (candidate) {
             if (candidate == this) {
                 isAncestor = true;
                 break;
             }
             candidate = candidate->parentItem();
         }
 
         if (isAncestor) {
             //Found? remove focus for the whole hierarchy
             candidate = focus;
 
             while (candidate && candidate != this) {
                 candidate->setFocus(false);
                 candidate = candidate->parentItem();
             }
         }
     }
 
     setVisible(!destroyed);
 }
 
 Plasma::Types::FormFactor AppletInterface::formFactor() const
 {
     return applet()->formFactor();
 }
 
 Plasma::Types::Location AppletInterface::location() const
 {
     return applet()->location();
 }
 
 QString AppletInterface::currentActivity() const
 {
     if (applet()->containment()) {
         return applet()->containment()->activity();
     } else {
         return QString();
     }
 }
 
 QObject *AppletInterface::configuration() const
 {
     return m_configuration;
 }
 
 uint AppletInterface::id() const
 {
     return applet()->id();
 }
 
 QString AppletInterface::pluginName() const
 {
     return applet()->pluginMetaData().isValid() ? applet()->pluginMetaData().pluginId() : QString();
 }
 
 QString AppletInterface::icon() const
 {
     return applet()->icon();
 }
 
 void AppletInterface::setIcon(const QString &icon)
 {
     if (applet()->icon() == icon) {
         return;
     }
 
     applet()->setIcon(icon);
 }
 
 QString AppletInterface::title() const
 {
     return applet()->title();
 }
 
 void AppletInterface::setTitle(const QString &title)
 {
     if (applet()->title() == title) {
         return;
     }
 
     applet()->setTitle(title);
 }
 
 QString AppletInterface::toolTipMainText() const
 {
     if (m_toolTipMainText.isNull()) {
         return title();
     } else {
         return m_toolTipMainText;
     }
 }
 
 void AppletInterface::setToolTipMainText(const QString &text)
 {
     //Here we are abusing the difference between a null and an empty string.
     //by default is null so falls back to the name
     //the fist time it gets set, an empty non null one is set, and won't fallback anymore
     if (!m_toolTipMainText.isNull() && m_toolTipMainText == text) {
         return;
     }
 
     if (text.isEmpty()) {
         m_toolTipMainText = QStringLiteral("");//this "" makes it non-null
     } else {
         m_toolTipMainText = text;
     }
 
     emit toolTipMainTextChanged();
 }
 
 QString AppletInterface::toolTipSubText() const
 {
     if (m_toolTipSubText.isNull() && applet()->pluginMetaData().isValid()) {
         return applet()->pluginMetaData().description();
     } else {
         return m_toolTipSubText;
     }
 }
 
 void AppletInterface::setToolTipSubText(const QString &text)
 {
     //Also there the difference between null and empty gets exploited
     if (!m_toolTipSubText.isNull() && m_toolTipSubText == text) {
         return;
     }
 
     if (text.isEmpty()) {
         m_toolTipSubText = QStringLiteral("");//this "" makes it non-null
     } else {
         m_toolTipSubText = text;
     }
 
     emit toolTipSubTextChanged();
 }
 
 int AppletInterface::toolTipTextFormat() const
 {
     return m_toolTipTextFormat;
 }
 
 void AppletInterface::setToolTipTextFormat(int format)
 {
     if (m_toolTipTextFormat == format) {
         return;
     }
 
     m_toolTipTextFormat = format;
     emit toolTipTextFormatChanged();
 }
 
 QQuickItem *AppletInterface::toolTipItem() const
 {
     return m_toolTipItem.data();
 }
 
 void AppletInterface::setToolTipItem(QQuickItem *toolTipItem)
 {
     if (m_toolTipItem.data() == toolTipItem) {
         return;
     }
 
     m_toolTipItem = toolTipItem;
     connect(m_toolTipItem.data(), &QObject::destroyed,
             this, &AppletInterface::toolTipItemChanged);
 
     emit toolTipItemChanged();
 }
 
 bool AppletInterface::isBusy() const
 {
     return applet()->isBusy();
 }
 
 void AppletInterface::setBusy(bool busy)
 {
     applet()->setBusy(busy);
 }
 
 Plasma::Types::BackgroundHints AppletInterface::backgroundHints() const
 {
     return m_backgroundHints;
 }
 
 void AppletInterface::setBackgroundHints(Plasma::Types::BackgroundHints hint)
 {
     if (m_backgroundHints == hint) {
         return;
     }
 
     m_backgroundHints = hint;
     emit backgroundHintsChanged();
 }
 
 void AppletInterface::setConfigurationRequired(bool needsConfiguring, const QString &reason)
 {
     appletScript()->setConfigurationRequired(needsConfiguring, reason);
 }
 
 QString AppletInterface::file(const QString &fileType)
 {
     return appletScript()->filePath(fileType, QString());
 }
 
 QString AppletInterface::file(const QString &fileType, const QString &filePath)
 {
     return appletScript()->filePath(fileType, filePath);
 }
 
 QList<QAction *> AppletInterface::contextualActions() const
 {
     QList<QAction *> actions;
     Plasma::Applet *a = applet();
     if (a->failedToLaunch()) {
         return actions;
     }
 
     foreach (const QString &name, m_actions) {
         QAction *action = a->actions()->action(name);
 
         if (action) {
             actions << action;
         }
     }
 
     return actions;
 }
 
 void AppletInterface::setActionSeparator(const QString &name)
 {
     Plasma::Applet *a = applet();
     QAction *action = a->actions()->action(name);
 
     if (action) {
         action->setSeparator(true);
     } else {
         action = new QAction(this);
         action->setSeparator(true);
         a->actions()->addAction(name, action);
         m_actions.append(name);
     }
 }
 
 void AppletInterface::setAction(const QString &name, const QString &text, const QString &icon, const QString &shortcut)
 {
     Plasma::Applet *a = applet();
     QAction *action = a->actions()->action(name);
 
     if (action) {
         action->setText(text);
     } else {
         action = new QAction(text, this);
         a->actions()->addAction(name, action);
 
         Q_ASSERT(!m_actions.contains(name));
         m_actions.append(name);
 
         connect(action, &QAction::triggered, this, [this, name] {
             executeAction(name);
         });
     }
 
     if (!icon.isEmpty()) {
         action->setIcon(QIcon::fromTheme(icon));
     }
 
     if (!shortcut.isEmpty()) {
         action->setShortcut(shortcut);
     }
 
     action->setObjectName(name);
 }
 
 void AppletInterface::removeAction(const QString &name)
 {
     Plasma::Applet *a = applet();
     QAction *action = a->actions()->action(name);
     delete action;
     m_actions.removeAll(name);
 }
 
 void AppletInterface::clearActions()
 {
     Q_FOREACH (const QString &action, m_actions) {
         removeAction(action);
     }
 }
 
 QAction *AppletInterface::action(QString name) const
 {
     return applet()->actions()->action(name);
 }
 
 bool AppletInterface::immutable() const
 {
     return applet()->immutability() != Plasma::Types::Mutable;
 }
 
 Plasma::Types::ImmutabilityType AppletInterface::immutability() const
 {
     return applet()->immutability();
 }
 
 bool AppletInterface::userConfiguring() const
 {
     return applet()->isUserConfiguring();
 }
 
 int AppletInterface::apiVersion() const
 {
     // Look for C++ plugins first
     auto filter = [](const KPluginMetaData &md) -> bool
     {
         return md.value(QStringLiteral("X-Plasma-API")) == QLatin1String("declarativeappletscript")
             && md.value(QStringLiteral("X-Plasma-ComponentTypes")).contains(QLatin1String("Applet"));
     };
     QVector<KPluginMetaData> plugins = KPluginLoader::findPlugins(QStringLiteral("plasma/scriptengines"), filter);
     if (plugins.isEmpty()) {
         return -1;
     }
 
     return plugins.first().value(QStringLiteral("X-KDE-PluginInfo-Version")).toInt();
 }
 
 void AppletInterface::setAssociatedApplication(const QString &string)
 {
     if (applet()->associatedApplication() == string) {
         return;
     }
 
     applet()->setAssociatedApplication(string);
     emit associatedApplicationChanged();
 }
 
 QString AppletInterface::associatedApplication() const
 {
     return applet()->associatedApplication();
 }
 
 void AppletInterface::setAssociatedApplicationUrls(const QList<QUrl> &urls)
 {
     if (applet()->associatedApplicationUrls() == urls) {
         return;
     }
 
     applet()->setAssociatedApplicationUrls(urls);
     emit associatedApplicationUrlsChanged();
 }
 
 QList<QUrl> AppletInterface::associatedApplicationUrls() const
 {
     return applet()->associatedApplicationUrls();
 }
 
 void AppletInterface::setStatus(const Plasma::Types::ItemStatus &status)
 {
     applet()->setStatus(status);
 }
 
 Plasma::Types::ItemStatus AppletInterface::status() const
 {
     return applet()->status();
 }
 
 int AppletInterface::screen() const
 {
     if (Plasma::Containment* c = applet()->containment()) {
         return c->screen();
     }
 
     return -1;
 }
 
 QRect AppletInterface::screenGeometry() const
 {
     if (!applet() || !applet()->containment()) {
         return QRect();
     }
     return applet()->containment()->corona()->screenGeometry(applet()->containment()->screen());
 }
 
 void AppletInterface::setHideOnWindowDeactivate(bool hide)
 {
     if (m_hideOnDeactivate != hide) {
         m_hideOnDeactivate = hide;
         emit hideOnWindowDeactivateChanged();
     }
 }
 
 bool AppletInterface::hideOnWindowDeactivate() const
 {
     return m_hideOnDeactivate;
 }
 
 QKeySequence AppletInterface::globalShortcut() const
 {
     return applet()->globalShortcut();
 }
 
 void AppletInterface::setGlobalShortcut(const QKeySequence &sequence)
 {
     applet()->setGlobalShortcut(sequence);
 }
 
 QObject *AppletInterface::nativeInterface()
 {
     if (qstrcmp(applet()->metaObject()->className(),"Plasma::Applet") != 0) {
         return applet();
     } else {
         if (!m_dummyNativeInterface) {
             m_dummyNativeInterface = new QObject(this);
         }
         return m_dummyNativeInterface;
     }
 }
 
 bool AppletInterface::configurationRequired() const
 {
     return applet()->configurationRequired();
 }
 
 void AppletInterface::setConfigurationRequiredProperty(bool needsConfiguring)
 {
     appletScript()->setConfigurationRequired(needsConfiguring, applet()->configurationRequiredReason());
 }
 
 QString AppletInterface::configurationRequiredReason() const
 {
     return applet()->configurationRequiredReason();
 }
 
 void AppletInterface::setConfigurationRequiredReason(const QString &reason)
 {
     appletScript()->setConfigurationRequired(applet()->configurationRequired(), reason);
 }
 
 QString AppletInterface::downloadPath(const QString &file)
 {
     Q_UNUSED(file);
     return downloadPath();
 }
 
 QString AppletInterface::downloadPath() const
 {
     const QString downloadDir = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation) + QStringLiteral("/Plasma/") + applet()->pluginMetaData().pluginId() + QLatin1Char('/');
 
     if (!QFile::exists(downloadDir)) {
         QDir dir({ QLatin1Char('/') });
         dir.mkpath(downloadDir);
     }
 
     return downloadDir;
 }
 
 QStringList AppletInterface::downloadedFiles() const
 {
     const QString downloadDir = QStandardPaths::writableLocation(QStandardPaths::DownloadLocation) + QStringLiteral("/Plasma/") + applet()->pluginMetaData().pluginId() + QLatin1Char('/');
     QDir dir(downloadDir);
     return dir.entryList(QDir::Files | QDir::NoSymLinks | QDir::Readable);
 }
 
 void AppletInterface::executeAction(const QString &name)
 {
     if (qmlObject()->rootObject()) {
         const QMetaObject *metaObj = qmlObject()->rootObject()->metaObject();
         const QByteArray actionMethodName = "action_" + name.toUtf8();
         const QByteArray actionFunctionName = actionMethodName + QByteArray("()");
         if (metaObj->indexOfMethod(QMetaObject::normalizedSignature(actionFunctionName.constData()).constData()) != -1) {
             QMetaObject::invokeMethod(qmlObject()->rootObject(), actionMethodName.constData(), Qt::DirectConnection);
         } else {
             QMetaObject::invokeMethod(qmlObject()->rootObject(), "actionTriggered", Qt::DirectConnection, Q_ARG(QVariant, name));
         }
     }
 }
 
 QVariantList AppletInterface::availableScreenRegion() const
 {
     QVariantList regVal;
 
     if (!applet()->containment() || !applet()->containment()->corona()) {
         return regVal;
     }
 
     QRegion reg = QRect(0, 0, width(), height());
     int screenId = screen();
     if (screenId > -1) {
         reg = applet()->containment()->corona()->availableScreenRegion(screenId);
     }
 
     foreach (QRect rect, reg.rects()) {
         //make it relative
         QRect geometry = applet()->containment()->corona()->screenGeometry(screenId);
         rect.moveTo(rect.topLeft() - geometry.topLeft());
         regVal << QVariant::fromValue(QRectF(rect));
     }
     return regVal;
 }
 
 QRect AppletInterface::availableScreenRect() const
 {
     if (!applet()->containment() || !applet()->containment()->corona()) {
         return QRect();
     }
 
     QRect rect(0, 0, width(), height());
 
     int screenId = screen();
 
     if (screenId > -1) {
         rect = applet()->containment()->corona()->availableScreenRect(screenId);
         //make it relative
         QRect geometry = applet()->containment()->corona()->screenGeometry(screenId);
         rect.moveTo(rect.topLeft() - geometry.topLeft());
     }
 
     return rect;
 }
 
 bool AppletInterface::event(QEvent *event)
 {
     // QAction keyboard shortcuts cannot work with QML2 (and probably newver will
     // since in Qt qtquick and qwidgets cannot depend from each other in any way)
     // so do a simple keyboard shortcut matching here
     if (event->type() == QEvent::KeyPress) {
         QKeyEvent *ke = static_cast<QKeyEvent *>(event);
         QKeySequence seq(ke->key()|ke->modifiers());
 
         QList <QAction *> actions = applet()->actions()->actions();
         //find the wallpaper action if we are a containment
         ContainmentInterface *ci = qobject_cast<ContainmentInterface *>(this);
         if (ci) {
             WallpaperInterface *wi = ci->wallpaperInterface();
             if (wi) {
                 actions << wi->contextualActions();
             }
         }
 
         //add any actions of the corona
         if (applet()->containment() && applet()->containment()->corona()) {
             actions << applet()->containment()->corona()->actions()->actions();
         }
 
         bool keySequenceUsed = false;
         foreach (auto a, actions) {
 
             if (a->shortcut().isEmpty()) {
                 continue;
             }
 
             //this will happen on a normal, non emacs shortcut
             if (seq.matches(a->shortcut()) == QKeySequence::ExactMatch) {
                 event->accept();
                 a->trigger();
                 m_oldKeyboardShortcut = 0;
                 return true;
 
             //first part of an emacs style shortcut?
             } else if (seq.matches(a->shortcut()) == QKeySequence::PartialMatch) {
                 keySequenceUsed = true;
                 m_oldKeyboardShortcut = ke->key()|ke->modifiers();
 
             //no match at all, but it can be the second part of an emacs style shortcut
             } else {
                 QKeySequence seq(m_oldKeyboardShortcut, ke->key()|ke->modifiers());
 
                 if (seq.matches(a->shortcut()) == QKeySequence::ExactMatch) {
                     event->accept();
                     a->trigger();
 
                     return true;
                 }
             }
         }
 
         if (!keySequenceUsed) {
             m_oldKeyboardShortcut = 0;
         }
     }
 
     return AppletQuickItem::event(event);
 }
 
 bool AppletInterface::eventFilter(QObject *watched, QEvent *event)
 {
     if (event->type() == QEvent::MouseButtonPress) {
         QMouseEvent *e = static_cast<QMouseEvent *>(event);
 
         //pass it up to the applet
         //well, actually we have to pass it to the *containment*
         //because all the code for showing an applet's contextmenu is actually in Containment.
         Plasma::Containment *c = applet()->containment();
         if (c) {
             const QString trigger = Plasma::ContainmentActions::eventToString(event);
             Plasma::ContainmentActions *plugin = c->containmentActions().value(trigger);
             if (!plugin) {
                 return false;
             }
 
             ContainmentInterface *ci = c->property("_plasma_graphicObject").value<ContainmentInterface *>();
             if (!ci) {
                 return false;
             }
 
             //the plugin can be a single action or a context menu
             //Don't have an action list? execute as single action
             //and set the event position as action data
             if (plugin->contextualActions().length() == 1) {
                 // but first check whether we are not a popup
                 // we don't want to randomly creates applets without confirmation
                 if (static_cast<QQuickItem *>(watched)->window() != ci->window()) {
                     return true;
                 }
 
                 QAction *action = plugin->contextualActions().at(0);
                 action->setData(e->globalPos());
                 action->trigger();
                 return true;
             }
 
             QMenu *desktopMenu = new QMenu;
             if (desktopMenu->winId()) {
                 desktopMenu->windowHandle()->setTransientParent(window());
             }
             emit applet()->contextualActionsAboutToShow();
             ci->addAppletActions(desktopMenu, applet(), event);
 
             if (!desktopMenu->isEmpty()) {
                 desktopMenu->setAttribute(Qt::WA_DeleteOnClose);
                 desktopMenu->popup(e->globalPos());
                 return true;
             }
 
             delete desktopMenu;
             return false;
         }
     }
 
     return AppletQuickItem::eventFilter(watched, event);
 }
 
 
 #include "moc_appletinterface.cpp"