diff --git a/CMakeLists.txt b/CMakeLists.txt
index c042ff78f..108d64669 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,678 +1,677 @@
 project(KWIN)
 set(PROJECT_VERSION "5.10.90")
 set(PROJECT_VERSION_MAJOR 5)
 
 cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
 set(QT_MIN_VERSION "5.7.0")
 set(KF5_MIN_VERSION "5.34.0")
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH} )
 
 find_package(ECM 0.0.11 REQUIRED NO_MODULE)
 
 include(FeatureSummary)
 include(WriteBasicConfigVersionFile)
 include(GenerateExportHeader)
 
 # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
 find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS
     Concurrent
     Core
     DBus
     Quick
     QuickWidgets
     Script
     UiTools
     Widgets
     X11Extras
 )
 
 find_package(Qt5Test ${QT_MIN_VERSION} CONFIG QUIET)
 set_package_properties(Qt5Test PROPERTIES
          PURPOSE "Required for tests"
          TYPE OPTIONAL
          )
 add_feature_info("Qt5Test" Qt5Test_FOUND "Required for building tests")
 if (NOT Qt5Test_FOUND)
     set(BUILD_TESTING OFF CACHE BOOL "Build the testing tree.")
 endif()
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 
 include(ECMInstallIcons)
 include(ECMOptionalAddSubdirectory)
 
 add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0 -DQT_USE_QSTRINGBUILDER)
 
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-inconsistent-missing-override")
 endif()
 
 find_package(Qt5Multimedia QUIET)
 set_package_properties(Qt5Multimedia PROPERTIES
          PURPOSE "Runtime-only dependency for effect video playback"
          TYPE RUNTIME
          )
 
 
 # required frameworks by Core
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Config
     ConfigWidgets
     CoreAddons
     Crash
     GlobalAccel
     I18n
     Init
     Notifications
     Package
     Plasma
     WidgetsAddons
     WindowSystem
     IconThemes
     IdleTime
     Wayland
 )
 # required frameworks by config modules
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Completion
     Declarative
     KCMUtils
     KIO
     TextWidgets
     NewStuff
     Service
     XmlGui
 )
 
 find_package(Threads)
 set_package_properties(Threads PROPERTIES
          PURPOSE "Needed for VirtualTerminal support in KWin Wayland"
          TYPE REQUIRED
          )
 
 # optional frameworks
 find_package(KF5Activities ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Activities PROPERTIES
          PURPOSE "Enable building of KWin with kactivities support"
          TYPE OPTIONAL
          )
 add_feature_info("KF5Activities" KF5Activities_FOUND "Enable building of KWin with kactivities support")
 
 find_package(KF5DocTools ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5DocTools PROPERTIES
          PURPOSE "Enable building documentation"
          TYPE OPTIONAL
          )
 add_feature_info("KF5DocTools" KF5DocTools_FOUND "Enable building documentation")
 
 find_package(KDecoration2 CONFIG REQUIRED)
 
 find_package(KScreenLocker CONFIG REQUIRED)
 set_package_properties(KScreenLocker PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "For screenlocker integration in kwin_wayland")
 
 find_package(Breeze 5.9.0 CONFIG)
 set_package_properties(Breeze PROPERTIES
                        TYPE OPTIONAL
                        PURPOSE "For setting the default window decoration plugin")
 if(${Breeze_FOUND})
     if(${BREEZE_WITH_KDECORATION})
         set(HAVE_BREEZE_DECO true)
     else()
         set(HAVE_BREEZE_DECO FALSE)
     endif()
 else()
     set(HAVE_BREEZE_DECO FALSE)
 endif()
 add_feature_info("Breeze-Decoration" HAVE_BREEZE_DECO "Default decoration plugin Breeze")
 
 find_package(EGL)
 set_package_properties(EGL PROPERTIES
                        TYPE RUNTIME
                        PURPOSE "Required to build KWin with EGL support"
                       )
 
 find_package(epoxy)
 set_package_properties(epoxy PROPERTIES DESCRIPTION "libepoxy"
                        URL "http://github.com/anholt/libepoxy"
                        TYPE REQUIRED
                        PURPOSE "OpenGL dispatch library"
                       )
 
 set(HAVE_DL_LIBRARY FALSE)
 if(epoxy_HAS_GLX)
     find_library(DL_LIBRARY dl)
     if(DL_LIBRARY)
         set(HAVE_DL_LIBRARY TRUE)
     endif()
 endif()
 
 find_package(Wayland 1.2 REQUIRED COMPONENTS Cursor OPTIONAL_COMPONENTS Egl)
 set_package_properties(Wayland PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "Required for building KWin with Wayland support"
                       )
 add_feature_info("Wayland::EGL" Wayland_Egl_FOUND "Enable building of Wayland backend and QPA with EGL support.")
 set(HAVE_WAYLAND_EGL FALSE)
 if(Wayland_Egl_FOUND)
     set(HAVE_WAYLAND_EGL TRUE)
 endif()
 
 find_package(XKB 0.7.0)
 set_package_properties(XKB PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "Required for building KWin with Wayland support"
                       )
 
 find_package(Libinput 1.5)
 set_package_properties(Libinput PROPERTIES TYPE OPTIONAL PURPOSE "Required for input handling on Wayland.")
 
 find_package(UDev)
 set_package_properties(UDev PROPERTIES  URL "http://www.freedesktop.org/software/systemd/libudev/"
                                         DESCRIPTION "Linux device library."
                                         TYPE OPTIONAL
                                         PURPOSE "Required for input handling on Wayland."
                         )
 set(HAVE_INPUT FALSE)
 if (Libinput_FOUND AND UDEV_FOUND)
     set(HAVE_INPUT TRUE)
 endif()
 set(HAVE_UDEV FALSE)
 if (UDEV_FOUND)
     set(HAVE_UDEV TRUE)
 endif()
 
 find_package(Libdrm 2.4.62)
 set_package_properties(Libdrm PROPERTIES TYPE OPTIONAL PURPOSE "Required for drm output on Wayland.")
 set(HAVE_DRM FALSE)
 if(Libdrm_FOUND AND UDEV_FOUND)
     set(HAVE_DRM TRUE)
 endif()
 
 find_package(gbm)
 set_package_properties(gbm PROPERTIES TYPE OPTIONAL PURPOSE "Required for egl ouput of drm backend.")
 set(HAVE_GBM FALSE)
 if(HAVE_DRM AND gbm_FOUND)
     set(HAVE_GBM TRUE)
 endif()
 
 find_package(libhybris)
 set_package_properties(libhybris PROPERTIES TYPE OPTIONAL PURPOSE "Required for libhybris backend")
 set(HAVE_LIBHYBRIS ${libhybris_FOUND})
 
 find_package(X11)
 set_package_properties(X11 PROPERTIES DESCRIPTION "X11 libraries"
                         URL "http://www.x.org"
                         TYPE REQUIRED
                     )
 add_feature_info("XInput" X11_Xinput_FOUND "Required for poll-free mouse cursor updates")
 set(HAVE_X11_XINPUT ${X11_Xinput_FOUND})
 
 # All the required XCB components
 find_package(XCB 1.10
     REQUIRED COMPONENTS
         XCB
         XFIXES
         DAMAGE
         COMPOSITE
         SHAPE
         SYNC
         RENDER
         RANDR
         KEYSYMS
         IMAGE
         SHM
         GLX
         CURSOR
         ICCCM
 )
 set_package_properties(XCB PROPERTIES TYPE REQUIRED)
 
 # and the optional XCB dependencies
 if (XCB_ICCCM_VERSION VERSION_LESS "0.4")
     set(XCB_ICCCM_FOUND FALSE)
 endif()
 add_feature_info("XCB-ICCCM" XCB_ICCCM_FOUND "Required for building test applications for KWin")
 
 find_package(X11_XCB)
 set_package_properties(X11_XCB PROPERTIES
                        PURPOSE "Required for building X11 windowed backend of kwin_wayland"
                        TYPE OPTIONAL)
 
 # dependencies for QPA plugin
 if(Qt5Core_VERSION VERSION_LESS "5.8.0")
     find_package(Qt5PlatformSupport REQUIRED)
 else()
     find_package(Qt5FontDatabaseSupport REQUIRED)
     find_package(Qt5ThemeSupport REQUIRED)
     find_package(Qt5EventDispatcherSupport REQUIRED)
 endif()
 
 find_package(Freetype REQUIRED)
 set_package_properties(Freetype PROPERTIES DESCRIPTION "A font rendering engine"
                        URL "http://www.freetype.org"
                        TYPE REQUIRED
                        PURPOSE "Needed for KWin's QPA plugin."
                       )
 find_package(Fontconfig REQUIRED)
 set_package_properties(Fontconfig PROPERTIES DESCRIPTION "Font access configuration library"
                        URL "http://www.freedesktop.org/wiki/Software/fontconfig"
                        TYPE REQUIRED
                        PURPOSE "Needed for KWin's QPA plugin."
                       )
 
 find_package(Xwayland)
 set_package_properties(Xwayland PROPERTIES
     URL "http://x.org"
     DESCRIPTION "Xwayland X server"
     TYPE RUNTIME
     PURPOSE "Needed for running kwin_wayland"
     )
 
 ########### configure tests ###############
 include(CMakeDependentOption)
 
 option(KWIN_BUILD_DECORATIONS "Enable building of KWin decorations." ON)
 option(KWIN_BUILD_KCMS "Enable building of KWin configuration modules." ON)
 option(KWIN_BUILD_TABBOX "Enable building of KWin Tabbox functionality" ON)
 option(KWIN_BUILD_XRENDER_COMPOSITING "Enable building of KWin with XRender Compositing support" ON)
 cmake_dependent_option(KWIN_BUILD_ACTIVITIES "Enable building of KWin with kactivities support" ON "KF5Activities_FOUND" OFF)
 
 # Binary name of KWin
 set(KWIN_NAME "kwin")
 set(KWIN_INTERNAL_NAME_X11 "kwin_x11")
 set(KWIN_INTERNAL_NAME_WAYLAND "kwin_wayland")
 set(KWIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 # KWIN_HAVE_XRENDER_COMPOSITING - whether XRender-based compositing support is available: may be disabled
 if( KWIN_BUILD_XRENDER_COMPOSITING )
     set( KWIN_HAVE_XRENDER_COMPOSITING 1 )
 endif()
 
 include_directories(${XKB_INCLUDE_DIR})
 
 include_directories(${epoxy_INCLUDE_DIR})
 set(HAVE_EPOXY_GLX ${epoxy_HAS_GLX})
 
 # for things that are also used by kwin libraries
 configure_file(libkwineffects/kwinconfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/libkwineffects/kwinconfig.h )
 # for kwin internal things
 set(HAVE_X11_XCB ${X11_XCB_FOUND})
 
 include(CheckIncludeFile)
 include(CheckIncludeFiles)
 include(CheckSymbolExists)
 check_include_files(unistd.h HAVE_UNISTD_H)
 check_include_files(malloc.h HAVE_MALLOC_H)
 
 check_include_file("sys/prctl.h" HAVE_SYS_PRCTL_H)
 check_symbol_exists(PR_SET_DUMPABLE "sys/prctl.h" HAVE_PR_SET_DUMPABLE)
 check_symbol_exists(PR_SET_PDEATHSIG "sys/prctl.h" HAVE_PR_SET_PDEATHSIG)
 check_include_file("sys/procctl.h" HAVE_SYS_PROCCTL_H)
 check_symbol_exists(PROC_TRACE_CTL "sys/procctl.h" HAVE_PROC_TRACE_CTL)
 if (HAVE_PR_SET_DUMPABLE OR HAVE_PROC_TRACE_CTL)
     set(CAN_DISABLE_PTRACE TRUE)
 endif()
 add_feature_info("prctl/procctl tracing control"
                  CAN_DISABLE_PTRACE
                  "Required for disallowing ptrace on kwin_wayland process")
 
 check_include_file("sys/sysmacros.h" HAVE_SYS_SYSMACROS_H)
 configure_file(config-kwin.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kwin.h )
 
 check_include_file("linux/vt.h" HAVE_LINUX_VT_H)
 add_feature_info("linux/vt.h"
                  HAVE_LINUX_VT_H
                  "Required for virtual terminal support under wayland")
 check_include_file("linux/fb.h"    HAVE_LINUX_FB_H)
 add_feature_info("linux/fb.h"
                  HAVE_LINUX_FB_H
                  "Required for the fbdev backend")
 
 ########### global ###############
 set(kwin_effects_dbus_xml ${CMAKE_CURRENT_SOURCE_DIR}/org.kde.kwin.Effects.xml)
 
 include_directories(BEFORE
     ${CMAKE_CURRENT_BINARY_DIR}/libkwineffects
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/libkwineffects
     ${CMAKE_CURRENT_SOURCE_DIR}/effects
     ${CMAKE_CURRENT_SOURCE_DIR}/tabbox
     )
 
 add_subdirectory( libkwineffects )
 if(KWIN_BUILD_KCMS)
     add_subdirectory( kcmkwin )
 endif()
 
 add_subdirectory( data )
 
 add_subdirectory( effects )
 add_subdirectory( scripts )
 add_subdirectory( tabbox )
 add_subdirectory(scripting)
 add_subdirectory(helpers)
 
 ########### next target ###############
 
 set(kwin_KDEINIT_SRCS
    workspace.cpp
    dbusinterface.cpp
    abstract_client.cpp
    client.cpp
    client_machine.cpp
    cursor.cpp
    debug_console.cpp
    tabgroup.cpp
    focuschain.cpp
    globalshortcuts.cpp
    input.cpp
    input_event.cpp
    input_event_spy.cpp
    keyboard_input.cpp
    keyboard_layout.cpp
    keyboard_layout_switching.cpp
    keyboard_repeat.cpp
    pointer_input.cpp
    touch_input.cpp
    netinfo.cpp
    placement.cpp
    atoms.cpp
    utils.cpp
    layers.cpp
    main.cpp
    options.cpp
    outline.cpp
    events.cpp
    killwindow.cpp
    geometrytip.cpp
    screens.cpp
    shadow.cpp
    sm.cpp
    group.cpp
    manage.cpp
    overlaywindow.cpp
    activation.cpp
    useractions.cpp
    geometry.cpp
    rules.cpp
    composite.cpp
    toplevel.cpp
    unmanaged.cpp
    scene.cpp
-   scene_xrender.cpp
    scene_opengl.cpp
    scene_qpainter.cpp
    screenlockerwatcher.cpp
    thumbnailitem.cpp
    lanczosfilter.cpp
    deleted.cpp
    effects.cpp
    effectloader.cpp
    virtualdesktops.cpp
    xcbutils.cpp
    x11eventfilter.cpp
    logind.cpp
    onscreennotification.cpp
    osd.cpp
     screenedge.cpp
     scripting/scripting.cpp
     scripting/workspace_wrapper.cpp
     scripting/meta.cpp
     scripting/scriptedeffect.cpp
     scripting/scriptingutils.cpp
     scripting/timer.cpp
     scripting/scripting_model.cpp
     scripting/dbuscall.cpp
     scripting/screenedgeitem.cpp
     scripting/scripting_logging.cpp
     decorations/decoratedclient.cpp
     decorations/decorationbridge.cpp
     decorations/decorationpalette.cpp
     decorations/settings.cpp
     decorations/decorationrenderer.cpp
     decorations/decorations_logging.cpp
     abstract_egl_backend.cpp
     platform.cpp
     shell_client.cpp
     wayland_server.cpp
     wayland_cursor_theme.cpp
     virtualkeyboard.cpp
     appmenu.cpp
     modifier_only_shortcuts.cpp
     xkb.cpp
     gestures.cpp
     popup_input_filter.cpp
     abstract_opengl_context_attribute_builder.cpp
     egl_context_attribute_builder.cpp
     was_user_interaction_x11_filter.cpp
     moving_client_x11_filter.cpp
    )
 
 if(KWIN_BUILD_TABBOX)
     set(
         kwin_KDEINIT_SRCS ${kwin_KDEINIT_SRCS}
         tabbox/tabbox.cpp
         tabbox/clientmodel.cpp
         tabbox/desktopchain.cpp
         tabbox/desktopmodel.cpp
         tabbox/switcheritem.cpp
         tabbox/tabboxconfig.cpp
         tabbox/tabboxhandler.cpp
         tabbox/tabbox_logging.cpp
         tabbox/x11_filter.cpp
   )
 endif()
 
 if(KWIN_BUILD_ACTIVITIES)
     set(
         kwin_KDEINIT_SRCS ${kwin_KDEINIT_SRCS}
         activities.cpp
     )
 endif()
 
 if(UDEV_FOUND)
     set(kwin_KDEINIT_SRCS
         ${kwin_KDEINIT_SRCS}
         udev.cpp
     )
 endif()
 
 if(HAVE_INPUT)
     set(kwin_KDEINIT_SRCS
         ${kwin_KDEINIT_SRCS}
         libinput/context.cpp
         libinput/connection.cpp
         libinput/device.cpp
         libinput/events.cpp
         libinput/libinput_logging.cpp
     )
     if (HAVE_LINUX_VT_H)
          set(kwin_KDEINIT_SRCS
              ${kwin_KDEINIT_SRCS}
              virtual_terminal.cpp
          )
     endif()
 endif()
 
 kconfig_add_kcfg_files(kwin_KDEINIT_SRCS settings.kcfgc)
 
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS org.kde.KWin.xml dbusinterface.h KWin::DBusInterface )
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS org.kde.kwin.Compositing.xml dbusinterface.h KWin::CompositorDBusInterface )
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS ${kwin_effects_dbus_xml} effects.h KWin::EffectsHandlerImpl )
 
 qt5_add_dbus_interface( kwin_KDEINIT_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/org.freedesktop.ScreenSaver.xml screenlocker_interface)
 
 qt5_add_dbus_interface( kwin_KDEINIT_SRCS org.kde.kappmenu.xml appmenu_interface )
 
 qt5_add_resources( kwin_KDEINIT_SRCS resources.qrc )
 
 ki18n_wrap_ui(kwin_KDEINIT_SRCS
     debug_console.ui
     shortcutdialog.ui
 )
 
 ########### target link libraries ###############
 
 set(kwin_OWN_LIBS
     kwineffects
     kwinxrenderutils
     kwin4_effect_builtins
 )
 
 set(kwin_QT_LIBS
     Qt5::Concurrent
     Qt5::DBus
     Qt5::Quick
     Qt5::Script
 )
 
 set(kwin_KDE_LIBS
     KF5::ConfigCore
     KF5::CoreAddons
     KF5::ConfigWidgets
     KF5::GlobalAccel
     KF5::GlobalAccelPrivate
     KF5::I18n
     KF5::Notifications
     KF5::Package
     KF5::Plasma
     KF5::WindowSystem
     KDecoration2::KDecoration
     KDecoration2::KDecoration2Private
     PW::KScreenLocker
 )
 
 set(kwin_XLIB_LIBS
     ${X11_X11_LIB}
     ${X11_ICE_LIB}
     ${X11_SM_LIB}
 )
 
 set(kwin_XCB_LIBS
     XCB::XCB
     XCB::XFIXES
     XCB::DAMAGE
     XCB::COMPOSITE
     XCB::SHAPE
     XCB::SYNC
     XCB::RENDER
     XCB::RANDR
     XCB::KEYSYMS
     XCB::SHM
     XCB::GLX
     XCB::ICCCM
 )
 
 set(kwin_WAYLAND_LIBS
     XKB::XKB
     KF5::WaylandClient
     KF5::WaylandServer
     Wayland::Cursor
     ${CMAKE_THREAD_LIBS_INIT}
 )
 
 if(KWIN_BUILD_ACTIVITIES)
     set(kwin_KDE_LIBS ${kwin_KDE_LIBS} KF5::Activities)
 endif()
 
 set(kwinLibs
     ${kwin_OWN_LIBS}
     ${kwin_QT_LIBS}
     ${kwin_KDE_LIBS}
     ${kwin_XLIB_LIBS}
     ${kwin_XCB_LIBS}
     ${kwin_WAYLAND_LIBS}
 )
 
 if(UDEV_FOUND)
     set(kwinLibs ${kwinLibs} ${UDEV_LIBS})
 endif()
 
 if(HAVE_INPUT)
     set(kwinLibs ${kwinLibs} Libinput::Libinput)
 endif()
 
 add_library(kwin SHARED ${kwin_KDEINIT_SRCS})
 
 set_target_properties(kwin PROPERTIES
    VERSION ${PROJECT_VERSION}
    SOVERSION ${PROJECT_VERSION_MAJOR}
    )
 
 target_link_libraries(kwin ${kwinLibs})
 generate_export_header(kwin EXPORT_FILE_NAME kwin_export.h)
 
 target_link_libraries(kwin kwinglutils ${epoxy_LIBRARY})
 
 kf5_add_kdeinit_executable(kwin_x11 main_x11.cpp)
 target_link_libraries(kdeinit_kwin_x11 kwin KF5::Crash Qt5::X11Extras)
 
 install(TARGETS kwin             ${INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELINK_SKIP )
 install(TARGETS kdeinit_kwin_x11 ${INSTALL_TARGETS_DEFAULT_ARGS} )
 install(TARGETS kwin_x11         ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 add_executable(kwin_wayland main_wayland.cpp)
 target_link_libraries(kwin_wayland kwin)
 
 install(TARGETS kwin_wayland         ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 add_subdirectory(plugins)
 
 ########### install files ###############
 
 install( FILES kwin.kcfg  DESTINATION  ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}.kcfg )
 install( FILES kwin.notifyrc  DESTINATION  ${KNOTIFYRC_INSTALL_DIR} RENAME ${KWIN_NAME}.notifyrc)
 install(
     FILES
         org.kde.KWin.xml
         org.kde.kwin.Compositing.xml
         org.kde.kwin.Effects.xml
     DESTINATION
         ${KDE_INSTALL_DBUSINTERFACEDIR}
 )
 install( FILES ${CMAKE_CURRENT_BINARY_DIR}/kwin_export.h DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
 
 # Install the KWin/Script service type
 install( FILES scripting/kwinscript.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} )
 
 ecm_install_icons(
     ICONS
         16-apps-kwin.png
         32-apps-kwin.png
         48-apps-kwin.png
         sc-apps-kwin.svgz
     DESTINATION
         ${ICON_INSTALL_DIR}
     THEME
         hicolor
 )
 
 add_subdirectory(qml)
 add_subdirectory(autotests)
 add_subdirectory(tests)
 add_subdirectory(packageplugins)
 
 if (KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 include(ECMPackageConfigHelpers)
 set(CMAKECONFIG_INSTALL_DIR "${CMAKECONFIG_INSTALL_PREFIX}/KWinDBusInterface")
 ecm_configure_package_config_file(KWinDBusInterfaceConfig.cmake.in
     "${CMAKE_CURRENT_BINARY_DIR}/KWinDBusInterfaceConfig.cmake"
     PATH_VARS KDE_INSTALL_DBUSINTERFACEDIR
     INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KWinDBusInterfaceConfig.cmake
     DESTINATION ${CMAKECONFIG_INSTALL_DIR})
diff --git a/composite.cpp b/composite.cpp
index 4bb816869..d10913c44 100644
--- a/composite.cpp
+++ b/composite.cpp
@@ -1,1205 +1,1225 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "composite.h"
 
 #include "abstract_egl_backend.h"
 #include "dbusinterface.h"
 #include "utils.h"
 #include <QTextStream>
 #include "workspace.h"
 #include "client.h"
 #include "unmanaged.h"
 #include "deleted.h"
 #include "effects.h"
 #include "overlaywindow.h"
 #include "scene.h"
-#include "scene_xrender.h"
 #include "scene_opengl.h"
 #include "scene_qpainter.h"
 #include "screens.h"
 #include "shadow.h"
 #include "useractions.h"
 #include "xcbutils.h"
 #include "platform.h"
 #include "shell_client.h"
 #include "wayland_server.h"
 #include "decorations/decoratedclient.h"
 
 #include <KWayland/Server/surface_interface.h>
 
 #include <stdio.h>
 
 #include <QtConcurrentRun>
 #include <QFutureWatcher>
 #include <QMenu>
 #include <QTimerEvent>
 #include <QDateTime>
 #include <QOpenGLContext>
 #include <KGlobalAccel>
 #include <KLocalizedString>
+#include <KPluginLoader>
+#include <KPluginMetaData>
 #include <KNotification>
 #include <KSelectionWatcher>
 
 #include <xcb/composite.h>
 #include <xcb/damage.h>
 
 Q_DECLARE_METATYPE(KWin::Compositor::SuspendReason)
 
 namespace KWin
 {
 
 extern int currentRefreshRate();
 
 CompositorSelectionOwner::CompositorSelectionOwner(const char *selection) : KSelectionOwner(selection, connection(), rootWindow()), owning(false)
 {
     connect (this, SIGNAL(lostOwnership()), SLOT(looseOwnership()));
 }
 
 void CompositorSelectionOwner::looseOwnership()
 {
     owning = false;
 }
 
 KWIN_SINGLETON_FACTORY_VARIABLE(Compositor, s_compositor)
 
 static inline qint64 milliToNano(int milli) { return qint64(milli) * 1000 * 1000; }
 static inline qint64 nanoToMilli(int nano) { return nano / (1000*1000); }
 
 Compositor::Compositor(QObject* workspace)
     : QObject(workspace)
     , m_suspended(options->isUseCompositing() ? NoReasonSuspend : UserSuspend)
     , cm_selection(NULL)
     , vBlankInterval(0)
     , fpsInterval(0)
     , m_xrrRefreshRate(0)
     , m_finishing(false)
     , m_starting(false)
     , m_timeSinceLastVBlank(0)
     , m_scene(NULL)
     , m_bufferSwapPending(false)
     , m_composeAtSwapCompletion(false)
 {
     qRegisterMetaType<Compositor::SuspendReason>("Compositor::SuspendReason");
     connect(&compositeResetTimer, SIGNAL(timeout()), SLOT(restart()));
     connect(options, &Options::configChanged, this, &Compositor::slotConfigChanged);
     compositeResetTimer.setSingleShot(true);
     nextPaintReference.invalidate(); // Initialize the timer
 
     // 2 sec which should be enough to restart the compositor
     static const int compositorLostMessageDelay = 2000;
 
     m_releaseSelectionTimer.setSingleShot(true);
     m_releaseSelectionTimer.setInterval(compositorLostMessageDelay);
     connect(&m_releaseSelectionTimer, SIGNAL(timeout()), SLOT(releaseCompositorSelection()));
 
     m_unusedSupportPropertyTimer.setInterval(compositorLostMessageDelay);
     m_unusedSupportPropertyTimer.setSingleShot(true);
     connect(&m_unusedSupportPropertyTimer, SIGNAL(timeout()), SLOT(deleteUnusedSupportProperties()));
 
     // delay the call to setup by one event cycle
     // The ctor of this class is invoked from the Workspace ctor, that means before
     // Workspace is completely constructed, so calling Workspace::self() would result
     // in undefined behavior. This is fixed by using a delayed invocation.
     if (kwinApp()->platform()->isReady()) {
         QMetaObject::invokeMethod(this, "setup", Qt::QueuedConnection);
     }
     connect(kwinApp()->platform(), &Platform::readyChanged, this,
         [this] (bool ready) {
             if (ready) {
                 setup();
             } else {
                 finish();
             }
         }, Qt::QueuedConnection
     );
     connect(kwinApp(), &Application::x11ConnectionAboutToBeDestroyed, this,
         [this] {
             delete cm_selection;
             cm_selection = nullptr;
         }
     );
 
     if (qEnvironmentVariableIsSet("KWIN_MAX_FRAMES_TESTED"))
        m_framesToTestForSafety = qEnvironmentVariableIntValue("KWIN_MAX_FRAMES_TESTED");
 
     // register DBus
     new CompositorDBusInterface(this);
 }
 
 Compositor::~Compositor()
 {
     emit aboutToDestroy();
     AbstractEglBackend::unbindWaylandDisplay();
     finish();
     deleteUnusedSupportProperties();
     delete cm_selection;
     s_compositor = NULL;
 }
 
 
 void Compositor::setup()
 {
     if (hasScene())
         return;
     if (m_suspended) {
         QStringList reasons;
         if (m_suspended & UserSuspend) {
             reasons << QStringLiteral("Disabled by User");
         }
         if (m_suspended & BlockRuleSuspend) {
             reasons << QStringLiteral("Disabled by Window");
         }
         if (m_suspended & ScriptSuspend) {
             reasons << QStringLiteral("Disabled by Script");
         }
         qCDebug(KWIN_CORE) << "Compositing is suspended, reason:" << reasons;
         return;
     } else if (!kwinApp()->platform()->compositingPossible()) {
         qCCritical(KWIN_CORE) << "Compositing is not possible";
         return;
     }
     m_starting = true;
 
     if (!options->isCompositingInitialized()) {
         options->reloadCompositingSettings(true);
         slotCompositingOptionsInitialized();
     } else {
         slotCompositingOptionsInitialized();
     }
 }
 
 extern int screen_number; // main.cpp
 extern bool is_multihead;
 
 void Compositor::slotCompositingOptionsInitialized()
 {
     claimCompositorSelection();
 
     // There might still be a deleted around, needs to be cleared before creating the scene (BUG 333275)
     if (Workspace::self()) {
         while (!Workspace::self()->deletedList().isEmpty()) {
             Workspace::self()->deletedList().first()->discard();
         }
     }
 
-    switch(options->compositingMode()) {
-    case OpenGLCompositing: {
-        qCDebug(KWIN_CORE) << "Initializing OpenGL compositing";
+    const auto availablePlugins = KPluginLoader::findPlugins(QStringLiteral("org.kde.kwin.scenes"));
 
-        // Some broken drivers crash on glXQuery() so to prevent constant KWin crashes:
-        if (kwinApp()->platform()->openGLCompositingIsBroken())
-            qCWarning(KWIN_CORE) << "KWin has detected that your OpenGL library is unsafe to use";
-        else {
-            kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreInit);
+    const auto pluginIt = std::find_if(availablePlugins.begin(), availablePlugins.end(),
+        [] (const auto &plugin) {
+            const auto &metaData = plugin.rawData();
+            auto it = metaData.find(QStringLiteral("CompositingType"));
+            if (it != metaData.end()) {
+                if ((*it).toInt() == int{options->compositingMode()}) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    if (pluginIt != availablePlugins.end()) {
+        std::unique_ptr<SceneFactory> factory{qobject_cast<SceneFactory*>(pluginIt->instantiate())};
+        if (factory) {
+            m_scene = factory->create(this);
+            if (m_scene) {
+                qCDebug(KWIN_CORE) << "Instantiated compositing plugin:" << pluginIt->name();
+            }
+        }
+    }
+
+    if (!m_scene) {
+        switch(options->compositingMode()) {
+        case OpenGLCompositing: {
+            qCDebug(KWIN_CORE) << "Initializing OpenGL compositing";
 
-            m_scene = SceneOpenGL::createScene(this);
+            // Some broken drivers crash on glXQuery() so to prevent constant KWin crashes:
+            if (kwinApp()->platform()->openGLCompositingIsBroken())
+                qCWarning(KWIN_CORE) << "KWin has detected that your OpenGL library is unsafe to use";
+            else {
+                kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreInit);
 
-            kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostInit);
+                m_scene = SceneOpenGL::createScene(this);
 
-            if (m_scene && !m_scene->initFailed()) {
-                connect(static_cast<SceneOpenGL*>(m_scene), &SceneOpenGL::resetCompositing, this, &Compositor::restart);
-                break; // -->
+                kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostInit);
+
+                if (m_scene && !m_scene->initFailed()) {
+                    connect(static_cast<SceneOpenGL*>(m_scene), &SceneOpenGL::resetCompositing, this, &Compositor::restart);
+                    break; // -->
+                }
+                delete m_scene;
+                m_scene = NULL;
             }
-            delete m_scene;
-            m_scene = NULL;
-        }
 
-        // Do not Fall back to XRender - it causes problems when selfcheck fails during startup, but works later on
-        break;
-    }
-#ifdef KWIN_HAVE_XRENDER_COMPOSITING
-    case XRenderCompositing:
-        qCDebug(KWIN_CORE) << "Initializing XRender compositing";
-        m_scene = SceneXrender::createScene(this);
-        break;
-#endif
-    case QPainterCompositing:
-        qCDebug(KWIN_CORE) << "Initializing QPainter compositing";
-        m_scene = SceneQPainter::createScene(this);
-        break;
-    default:
-        qCDebug(KWIN_CORE) << "No compositing enabled";
-        m_starting = false;
-        if (cm_selection) {
-            cm_selection->owning = false;
-            cm_selection->release();
+            // Do not Fall back to XRender - it causes problems when selfcheck fails during startup, but works later on
+            break;
         }
-        if (kwinApp()->platform()->requiresCompositing()) {
-            qCCritical(KWIN_CORE) << "The used windowing system requires compositing";
-            qCCritical(KWIN_CORE) << "We are going to quit KWin now as it is broken";
-            qApp->quit();
+        case QPainterCompositing:
+            qCDebug(KWIN_CORE) << "Initializing QPainter compositing";
+            m_scene = SceneQPainter::createScene(this);
+            break;
+        default:
+            qCDebug(KWIN_CORE) << "No compositing enabled";
+            m_starting = false;
+            if (cm_selection) {
+                cm_selection->owning = false;
+                cm_selection->release();
+            }
+            if (kwinApp()->platform()->requiresCompositing()) {
+                qCCritical(KWIN_CORE) << "The used windowing system requires compositing";
+                qCCritical(KWIN_CORE) << "We are going to quit KWin now as it is broken";
+                qApp->quit();
+            }
+            return;
         }
-        return;
     }
     if (m_scene == NULL || m_scene->initFailed()) {
         qCCritical(KWIN_CORE) << "Failed to initialize compositing, compositing disabled";
         delete m_scene;
         m_scene = NULL;
         m_starting = false;
         if (cm_selection) {
             cm_selection->owning = false;
             cm_selection->release();
         }
         if (kwinApp()->platform()->requiresCompositing()) {
             qCCritical(KWIN_CORE) << "The used windowing system requires compositing";
             qCCritical(KWIN_CORE) << "We are going to quit KWin now as it is broken";
             qApp->quit();
         }
         return;
     }
     emit sceneCreated();
 
     if (Workspace::self()) {
         startupWithWorkspace();
     } else {
         connect(kwinApp(), &Application::workspaceCreated, this, &Compositor::startupWithWorkspace);
     }
 }
 
 void Compositor::claimCompositorSelection()
 {
     if (!cm_selection && kwinApp()->x11Connection()) {
         char selection_name[ 100 ];
         sprintf(selection_name, "_NET_WM_CM_S%d", Application::x11ScreenNumber());
         cm_selection = new CompositorSelectionOwner(selection_name);
         connect(cm_selection, SIGNAL(lostOwnership()), SLOT(finish()));
     }
 
     if (!cm_selection) // no X11 yet
         return;
 
     if (!cm_selection->owning) {
         cm_selection->claim(true);   // force claiming
         cm_selection->owning = true;
     }
 }
 
 void Compositor::startupWithWorkspace()
 {
     if (!m_starting) {
         return;
     }
     Workspace::self()->markXStackingOrderAsDirty();
     Q_ASSERT(m_scene);
     connect(workspace(), &Workspace::destroyed, this, [this] { compositeTimer.stop(); });
     claimCompositorSelection();
     m_xrrRefreshRate = KWin::currentRefreshRate();
     fpsInterval = options->maxFpsInterval();
     if (m_scene->syncsToVBlank()) {  // if we do vsync, set the fps to the next multiple of the vblank rate
         vBlankInterval = milliToNano(1000) / m_xrrRefreshRate;
         fpsInterval = qMax((fpsInterval / vBlankInterval) * vBlankInterval, vBlankInterval);
     } else
         vBlankInterval = milliToNano(1); // no sync - DO NOT set "0", would cause div-by-zero segfaults.
     m_timeSinceLastVBlank = fpsInterval - (options->vBlankTime() + 1); // means "start now" - we don't have even a slight idea when the first vsync will occur
     scheduleRepaint();
     xcb_composite_redirect_subwindows(connection(), rootWindow(), XCB_COMPOSITE_REDIRECT_MANUAL);
     new EffectsHandlerImpl(this, m_scene);   // sets also the 'effects' pointer
     connect(Workspace::self(), &Workspace::deletedRemoved, m_scene, &Scene::windowDeleted);
     connect(effects, SIGNAL(screenGeometryChanged(QSize)), SLOT(addRepaintFull()));
     addRepaintFull();
     foreach (Client * c, Workspace::self()->clientList()) {
         c->setupCompositing();
         c->getShadow();
     }
     foreach (Client * c,  Workspace::self()->desktopList())
         c->setupCompositing();
     foreach (Unmanaged * c, Workspace::self()->unmanagedList()) {
         c->setupCompositing();
         c->getShadow();
     }
     if (auto w = waylandServer()) {
         const auto clients = w->clients();
         for (auto c : clients) {
             c->setupCompositing();
             c->getShadow();
         }
         const auto internalClients = w->internalClients();
         for (auto c : internalClients) {
             c->setupCompositing();
             c->getShadow();
         }
     }
 
     emit compositingToggled(true);
 
     m_starting = false;
     if (m_releaseSelectionTimer.isActive()) {
         m_releaseSelectionTimer.stop();
     }
 
     // render at least once
     performCompositing();
 }
 
 void Compositor::scheduleRepaint()
 {
     if (!compositeTimer.isActive())
         setCompositeTimer();
 }
 
 void Compositor::finish()
 {
     if (!hasScene())
         return;
     m_finishing = true;
     m_releaseSelectionTimer.start();
     if (Workspace::self()) {
         foreach (Client * c, Workspace::self()->clientList())
             m_scene->windowClosed(c, NULL);
         foreach (Client * c, Workspace::self()->desktopList())
             m_scene->windowClosed(c, NULL);
         foreach (Unmanaged * c, Workspace::self()->unmanagedList())
             m_scene->windowClosed(c, NULL);
         foreach (Deleted * c, Workspace::self()->deletedList())
             m_scene->windowDeleted(c);
         foreach (Client * c, Workspace::self()->clientList())
         c->finishCompositing();
         foreach (Client * c, Workspace::self()->desktopList())
         c->finishCompositing();
         foreach (Unmanaged * c, Workspace::self()->unmanagedList())
         c->finishCompositing();
         foreach (Deleted * c, Workspace::self()->deletedList())
         c->finishCompositing();
         xcb_composite_unredirect_subwindows(connection(), rootWindow(), XCB_COMPOSITE_REDIRECT_MANUAL);
     }
     if (waylandServer()) {
         foreach (ShellClient *c, waylandServer()->clients()) {
             m_scene->windowClosed(c, nullptr);
         }
         foreach (ShellClient *c, waylandServer()->internalClients()) {
             m_scene->windowClosed(c, nullptr);
         }
         foreach (ShellClient *c, waylandServer()->clients()) {
             c->finishCompositing();
         }
         foreach (ShellClient *c, waylandServer()->internalClients()) {
             c->finishCompositing();
         }
     }
     delete effects;
     effects = NULL;
     delete m_scene;
     m_scene = NULL;
     compositeTimer.stop();
     repaints_region = QRegion();
     if (Workspace::self()) {
         for (ClientList::ConstIterator it = Workspace::self()->clientList().constBegin();
                 it != Workspace::self()->clientList().constEnd();
                 ++it) {
             // forward all opacity values to the frame in case there'll be other CM running
             if ((*it)->opacity() != 1.0) {
                 NETWinInfo i(connection(), (*it)->frameId(), rootWindow(), 0, 0);
                 i.setOpacity(static_cast< unsigned long >((*it)->opacity() * 0xffffffff));
             }
         }
         // discard all Deleted windows (#152914)
         while (!Workspace::self()->deletedList().isEmpty())
             Workspace::self()->deletedList().first()->discard();
     }
     m_finishing = false;
     emit compositingToggled(false);
 }
 
 void Compositor::releaseCompositorSelection()
 {
     if (hasScene() && !m_finishing) {
         // compositor is up and running again, no need to release the selection
         return;
     }
     if (m_starting) {
         // currently still starting the compositor, it might fail, so restart the timer to test again
         m_releaseSelectionTimer.start();
         return;
     }
 
     if (m_finishing) {
         // still shutting down, a restart might follow, so restart the timer to test again
         m_releaseSelectionTimer.start();
         return;
     }
     qCDebug(KWIN_CORE) << "Releasing compositor selection";
     if (cm_selection) {
         cm_selection->owning = false;
         cm_selection->release();
     }
 }
 
 void Compositor::keepSupportProperty(xcb_atom_t atom)
 {
     m_unusedSupportProperties.removeAll(atom);
 }
 
 void Compositor::removeSupportProperty(xcb_atom_t atom)
 {
     m_unusedSupportProperties << atom;
     m_unusedSupportPropertyTimer.start();
 }
 
 void Compositor::deleteUnusedSupportProperties()
 {
     if (m_starting) {
         // currently still starting the compositor
         m_unusedSupportPropertyTimer.start();
         return;
     }
     if (m_finishing) {
         // still shutting down, a restart might follow
         m_unusedSupportPropertyTimer.start();
         return;
     }
     if (const auto c = kwinApp()->x11Connection()) {
         foreach (const xcb_atom_t &atom, m_unusedSupportProperties) {
             // remove property from root window
             xcb_delete_property(c, kwinApp()->x11RootWindow(), atom);
         }
     }
 }
 
 // OpenGL self-check failed, fallback to XRender
 void Compositor::fallbackToXRenderCompositing()
 {
     finish();
     KConfigGroup config(kwinApp()->config(), "Compositing");
     config.writeEntry("Backend", "XRender");
     config.sync();
     options->setCompositingMode(XRenderCompositing);
     setup();
 }
 
 void Compositor::slotConfigChanged()
 {
     if (!m_suspended) {
         setup();
         if (effects)   // setupCompositing() may fail
             effects->reconfigure();
         addRepaintFull();
     } else
         finish();
 }
 
 void Compositor::slotReinitialize()
 {
     // Reparse config. Config options will be reloaded by setup()
     kwinApp()->config()->reparseConfiguration();
 
     // Restart compositing
     finish();
     // resume compositing if suspended
     m_suspended = NoReasonSuspend;
     options->setCompositingInitialized(false);
     setup();
 
     if (effects) { // setup() may fail
         effects->reconfigure();
     }
 }
 
 // for the shortcut
 void Compositor::slotToggleCompositing()
 {
     if (kwinApp()->platform()->requiresCompositing()) {
         // we are not allowed to turn on/off compositing
         return;
     }
     if (m_suspended) { // direct user call; clear all bits
         resume(AllReasonSuspend);
     } else { // but only set the user one (sufficient to suspend)
         suspend(UserSuspend);
     }
 }
 
 void Compositor::updateCompositeBlocking()
 {
     updateCompositeBlocking(NULL);
 }
 
 void Compositor::updateCompositeBlocking(Client *c)
 {
     if (kwinApp()->platform()->requiresCompositing()) {
         return;
     }
     if (c) { // if c == 0 we just check if we can resume
         if (c->isBlockingCompositing()) {
             if (!(m_suspended & BlockRuleSuspend)) // do NOT attempt to call suspend(true); from within the eventchain!
                 QMetaObject::invokeMethod(this, "suspend", Qt::QueuedConnection, Q_ARG(Compositor::SuspendReason, BlockRuleSuspend));
         }
     }
     else if (m_suspended & BlockRuleSuspend) {  // lost a client and we're blocked - can we resume?
         bool resume = true;
         for (ClientList::ConstIterator it = Workspace::self()->clientList().constBegin(); it != Workspace::self()->clientList().constEnd(); ++it) {
             if ((*it)->isBlockingCompositing()) {
                 resume = false;
                 break;
             }
         }
         if (resume) { // do NOT attempt to call suspend(false); from within the eventchain!
             QMetaObject::invokeMethod(this, "resume", Qt::QueuedConnection, Q_ARG(Compositor::SuspendReason, BlockRuleSuspend));
         }
     }
 }
 
 void Compositor::suspend(Compositor::SuspendReason reason)
 {
     if (kwinApp()->platform()->requiresCompositing()) {
         return;
     }
     Q_ASSERT(reason != NoReasonSuspend);
     m_suspended |= reason;
     if (reason & KWin::Compositor::ScriptSuspend) {
         // when disabled show a shortcut how the user can get back compositing
         const auto shortcuts = KGlobalAccel::self()->shortcut(workspace()->findChild<QAction*>(QStringLiteral("Suspend Compositing")));
         if (!shortcuts.isEmpty()) {
             // display notification only if there is the shortcut
             const QString message = i18n("Desktop effects have been suspended by another application.<br/>"
                                          "You can resume using the '%1' shortcut.", shortcuts.first().toString(QKeySequence::NativeText));
             KNotification::event(QStringLiteral("compositingsuspendeddbus"), message);
         }
     }
     finish();
 }
 
 void Compositor::resume(Compositor::SuspendReason reason)
 {
     Q_ASSERT(reason != NoReasonSuspend);
     m_suspended &= ~reason;
     setup(); // signal "toggled" is eventually emitted from within setup
 }
 
 void Compositor::restart()
 {
     if (hasScene()) {
         finish();
         QTimer::singleShot(0, this, SLOT(setup()));
     }
 }
 
 void Compositor::addRepaint(int x, int y, int w, int h)
 {
     if (!hasScene())
         return;
     repaints_region += QRegion(x, y, w, h);
     scheduleRepaint();
 }
 
 void Compositor::addRepaint(const QRect& r)
 {
     if (!hasScene())
         return;
     repaints_region += r;
     scheduleRepaint();
 }
 
 void Compositor::addRepaint(const QRegion& r)
 {
     if (!hasScene())
         return;
     repaints_region += r;
     scheduleRepaint();
 }
 
 void Compositor::addRepaintFull()
 {
     if (!hasScene())
         return;
     const QSize &s = screens()->size();
     repaints_region = QRegion(0, 0, s.width(), s.height());
     scheduleRepaint();
 }
 
 void Compositor::timerEvent(QTimerEvent *te)
 {
     if (te->timerId() == compositeTimer.timerId()) {
         performCompositing();
     } else
         QObject::timerEvent(te);
 }
 
 void Compositor::aboutToSwapBuffers()
 {
     assert(!m_bufferSwapPending);
 
     m_bufferSwapPending = true;
 }
 
 void Compositor::bufferSwapComplete()
 {
     assert(m_bufferSwapPending);
     m_bufferSwapPending = false;
 
     if (m_composeAtSwapCompletion) {
         m_composeAtSwapCompletion = false;
         performCompositing();
     }
 }
 
 void Compositor::performCompositing()
 {
     if (m_scene->usesOverlayWindow() && !isOverlayWindowVisible())
         return; // nothing is visible anyway
 
     // If a buffer swap is still pending, we return to the event loop and
     // continue processing events until the swap has completed.
     if (m_bufferSwapPending) {
         m_composeAtSwapCompletion = true;
         compositeTimer.stop();
         return;
     }
 
     // If outputs are disabled, we return to the event loop and
     // continue processing events until the outputs are enabled again
     if (!kwinApp()->platform()->areOutputsEnabled()) {
         compositeTimer.stop();
         return;
     }
 
     // Create a list of all windows in the stacking order
     ToplevelList windows = Workspace::self()->xStackingOrder();
     ToplevelList damaged;
 
     // Reset the damage state of each window and fetch the damage region
     // without waiting for a reply
     foreach (Toplevel *win, windows) {
         if (win->resetAndFetchDamage())
             damaged << win;
     }
 
     if (damaged.count() > 0) {
         m_scene->triggerFence();
         xcb_flush(connection());
     }
 
     // Move elevated windows to the top of the stacking order
     foreach (EffectWindow *c, static_cast<EffectsHandlerImpl *>(effects)->elevatedWindows()) {
         Toplevel* t = static_cast< EffectWindowImpl* >(c)->window();
         windows.removeAll(t);
         windows.append(t);
     }
 
     // Get the replies
     foreach (Toplevel *win, damaged) {
         // Discard the cached lanczos texture
         if (win->effectWindow()) {
             const QVariant texture = win->effectWindow()->data(LanczosCacheRole);
             if (texture.isValid()) {
                 delete static_cast<GLTexture *>(texture.value<void*>());
                 win->effectWindow()->setData(LanczosCacheRole, QVariant());
             }
         }
 
         win->getDamageRegionReply();
     }
 
     if (repaints_region.isEmpty() && !windowRepaintsPending()) {
         m_scene->idle();
         m_timeSinceLastVBlank = fpsInterval - (options->vBlankTime() + 1); // means "start now"
         m_timeSinceStart += m_timeSinceLastVBlank;
         // Note: It would seem here we should undo suspended unredirect, but when scenes need
         // it for some reason, e.g. transformations or translucency, the next pass that does not
         // need this anymore and paints normally will also reset the suspended unredirect.
         // Otherwise the window would not be painted normally anyway.
         compositeTimer.stop();
         return;
     }
 
     // skip windows that are not yet ready for being painted and if screen is locked skip windows that are
     // neither lockscreen nor inputmethod windows
     // TODO ?
     // this cannot be used so carelessly - needs protections against broken clients, the window
     // should not get focus before it's displayed, handle unredirected windows properly and so on.
     foreach (Toplevel *t, windows) {
         if (!t->readyForPainting()) {
             windows.removeAll(t);
         }
         if (waylandServer() && waylandServer()->isScreenLocked()) {
             if(!t->isLockScreen() && !t->isInputMethod()) {
                 windows.removeAll(t);
             }
         }
     }
 
     QRegion repaints = repaints_region;
     // clear all repaints, so that post-pass can add repaints for the next repaint
     repaints_region = QRegion();
 
     if (m_framesToTestForSafety > 0 && (m_scene->compositingType() & OpenGLCompositing)) {
         kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreFrame);
     }
     m_timeSinceLastVBlank = m_scene->paint(repaints, windows);
     if (m_framesToTestForSafety > 0) {
         if (m_scene->compositingType() & OpenGLCompositing) {
             kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostFrame);
         }
         m_framesToTestForSafety--;
         if (m_framesToTestForSafety == 0 && (m_scene->compositingType() & OpenGLCompositing)) {
             kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostLastGuardedFrame);
         }
     }
     m_timeSinceStart += m_timeSinceLastVBlank;
 
     if (waylandServer()) {
         for (Toplevel *win : damaged) {
             if (auto surface = win->surface()) {
                 surface->frameRendered(m_timeSinceStart);
             }
         }
     }
 
     compositeTimer.stop(); // stop here to ensure *we* cause the next repaint schedule - not some effect through m_scene->paint()
 
     // Trigger at least one more pass even if there would be nothing to paint, so that scene->idle()
     // is called the next time. If there would be nothing pending, it will not restart the timer and
     // scheduleRepaint() would restart it again somewhen later, called from functions that
     // would again add something pending.
     if (m_bufferSwapPending && m_scene->syncsToVBlank()) {
         m_composeAtSwapCompletion = true;
     } else {
         scheduleRepaint();
     }
 }
 
 template <class T>
 static bool repaintsPending(const QList<T*> &windows)
 {
     return std::any_of(windows.begin(), windows.end(), [] (T *t) { return !t->repaints().isEmpty(); });
 }
 
 bool Compositor::windowRepaintsPending() const
 {
     if (repaintsPending(Workspace::self()->clientList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->desktopList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->unmanagedList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->deletedList())) {
         return true;
     }
     if (auto w = waylandServer()) {
         const auto &clients = w->clients();
         auto test = [] (ShellClient *c) {
             return c->readyForPainting() && !c->repaints().isEmpty();
         };
         if (std::any_of(clients.begin(), clients.end(), test)) {
             return true;
         }
         const auto &internalClients = w->internalClients();
         auto internalTest = [] (ShellClient *c) {
             return c->isShown(true) && !c->repaints().isEmpty();
         };
         if (std::any_of(internalClients.begin(), internalClients.end(), internalTest)) {
             return true;
         }
     }
     return false;
 }
 
 void Compositor::setCompositeResetTimer(int msecs)
 {
     compositeResetTimer.start(msecs);
 }
 
 void Compositor::setCompositeTimer()
 {
     if (!hasScene())  // should not really happen, but there may be e.g. some damage events still pending
         return;
     if (m_starting || !Workspace::self()) {
         return;
     }
 
     // Don't start the timer if we're waiting for a swap event
     if (m_bufferSwapPending && m_composeAtSwapCompletion)
         return;
 
     // Don't start the timer if all outputs are disabled
     if (!kwinApp()->platform()->areOutputsEnabled()) {
         return;
     }
 
     uint waitTime = 1;
 
     if (m_scene->blocksForRetrace()) {
 
         // TODO: make vBlankTime dynamic?!
         // It's required because glXWaitVideoSync will *likely* block a full frame if one enters
         // a retrace pass which can last a variable amount of time, depending on the actual screen
         // Now, my ooold 19" CRT can do such retrace so that 2ms are entirely sufficient,
         // while another ooold 15" TFT requires about 6ms
 
         qint64 padding = m_timeSinceLastVBlank;
         if (padding > fpsInterval) {
             // we're at low repaints or spent more time in painting than the user wanted to wait for that frame
             padding = vBlankInterval - (padding%vBlankInterval); // -> align to next vblank
         } else {  // -> align to the next maxFps tick
             padding = ((vBlankInterval - padding%vBlankInterval) + (fpsInterval/vBlankInterval-1)*vBlankInterval);
             //               "remaining time of the first vsync" + "time for the other vsyncs of the frame"
         }
 
         if (padding < options->vBlankTime()) { // we'll likely miss this frame
             waitTime = nanoToMilli(padding + vBlankInterval - options->vBlankTime()); // so we add one
         } else {
             waitTime = nanoToMilli(padding - options->vBlankTime());
         }
     }
     else { // w/o blocking vsync we just jump to the next demanded tick
         if (fpsInterval > m_timeSinceLastVBlank) {
             waitTime = nanoToMilli(fpsInterval - m_timeSinceLastVBlank);
             if (!waitTime) {
                 waitTime = 1; // will ensure we don't block out the eventloop - the system's just not faster ...
             }
         }/* else if (m_scene->syncsToVBlank() && m_timeSinceLastVBlank - fpsInterval < (vBlankInterval<<1)) {
             // NOTICE - "for later" ------------------------------------------------------------------
             // It can happen that we push two frames within one refresh cycle.
             // Swapping will then block even with triple buffering when the GPU does not discard but
             // queues frames
             // now here's the mean part: if we take that as "OMG, we're late - next frame ASAP",
             // there'll immediately be 2 frames in the pipe, swapping will block, we think we're
             // late ... ewww
             // so instead we pad to the clock again and add 2ms safety to ensure the pipe is really
             // free
             // NOTICE: obviously m_timeSinceLastVBlank can be too big because we're too slow as well
             // So if this code was enabled, we'd needlessly half the framerate once more (15 instead of 30)
             waitTime = nanoToMilli(vBlankInterval - (m_timeSinceLastVBlank - fpsInterval)%vBlankInterval) + 2;
         }*/ else {
             waitTime = 1; // ... "0" would be sufficient, but the compositor isn't the WMs only task
         }
     }
     compositeTimer.start(qMin(waitTime, 250u), this); // force 4fps minimum
 }
 
 bool Compositor::isActive()
 {
     return !m_finishing && hasScene();
 }
 
 bool Compositor::checkForOverlayWindow(WId w) const
 {
     if (!hasScene()) {
         // no scene, so it cannot be the overlay window
         return false;
     }
     if (!m_scene->overlayWindow()) {
         // no overlay window, it cannot be the overlay
         return false;
     }
     // and compare the window ID's
     return w == m_scene->overlayWindow()->window();
 }
 
 bool Compositor::isOverlayWindowVisible() const
 {
     if (!hasScene()) {
         return false;
     }
     if (!m_scene->overlayWindow()) {
         return false;
     }
     return m_scene->overlayWindow()->isVisible();
 }
 
 /*****************************************************
  * Workspace
  ****************************************************/
 
 bool Workspace::compositing() const
 {
     return m_compositor && m_compositor->hasScene();
 }
 
 //****************************************
 // Toplevel
 //****************************************
 
 bool Toplevel::setupCompositing()
 {
     if (!compositing())
         return false;
 
     if (damage_handle != XCB_NONE)
         return false;
 
     if (kwinApp()->operationMode() == Application::OperationModeX11 && !surface()) {
         damage_handle = xcb_generate_id(connection());
         xcb_damage_create(connection(), damage_handle, frameId(), XCB_DAMAGE_REPORT_LEVEL_NON_EMPTY);
     }
 
     damage_region = QRegion(0, 0, width(), height());
     effect_window = new EffectWindowImpl(this);
 
     Compositor::self()->scene()->windowAdded(this);
 
     // With unmanaged windows there is a race condition between the client painting the window
     // and us setting up damage tracking.  If the client wins we won't get a damage event even
     // though the window has been painted.  To avoid this we mark the whole window as damaged
     // and schedule a repaint immediately after creating the damage object.
     if (dynamic_cast<Unmanaged*>(this))
         addDamageFull();
 
     return true;
 }
 
 void Toplevel::finishCompositing(ReleaseReason releaseReason)
 {
     if (kwinApp()->operationMode() == Application::OperationModeX11 && damage_handle == XCB_NONE)
         return;
     if (effect_window->window() == this) { // otherwise it's already passed to Deleted, don't free data
         discardWindowPixmap();
         delete effect_window;
     }
 
     if (damage_handle != XCB_NONE &&
             releaseReason != ReleaseReason::Destroyed) {
         xcb_damage_destroy(connection(), damage_handle);
     }
 
     damage_handle = XCB_NONE;
     damage_region = QRegion();
     repaints_region = QRegion();
     effect_window = NULL;
 }
 
 void Toplevel::discardWindowPixmap()
 {
     addDamageFull();
     if (effectWindow() != NULL && effectWindow()->sceneWindow() != NULL)
         effectWindow()->sceneWindow()->pixmapDiscarded();
 }
 
 void Toplevel::damageNotifyEvent()
 {
     m_isDamaged = true;
 
     // Note: The rect is supposed to specify the damage extents,
     //       but we don't know it at this point. No one who connects
     //       to this signal uses the rect however.
     emit damaged(this, QRect());
 }
 
 bool Toplevel::compositing() const
 {
     if (!Workspace::self()) {
         return false;
     }
     return Workspace::self()->compositing();
 }
 
 void Client::damageNotifyEvent()
 {
     if (syncRequest.isPending && isResize()) {
         emit damaged(this, QRect());
         m_isDamaged = true;
         return;
     }
 
     if (!ready_for_painting) { // avoid "setReadyForPainting()" function calling overhead
         if (syncRequest.counter == XCB_NONE) {  // cannot detect complete redraw, consider done now
             setReadyForPainting();
             setupWindowManagementInterface();
         }
     }
 
     Toplevel::damageNotifyEvent();
 }
 
 bool Toplevel::resetAndFetchDamage()
 {
     if (!m_isDamaged)
         return false;
 
     if (damage_handle == XCB_NONE) {
         m_isDamaged = false;
         return true;
     }
 
     xcb_connection_t *conn = connection();
 
     // Create a new region and copy the damage region to it,
     // resetting the damaged state.
     xcb_xfixes_region_t region = xcb_generate_id(conn);
     xcb_xfixes_create_region(conn, region, 0, 0);
     xcb_damage_subtract(conn, damage_handle, 0, region);
 
     // Send a fetch-region request and destroy the region
     m_regionCookie = xcb_xfixes_fetch_region_unchecked(conn, region);
     xcb_xfixes_destroy_region(conn, region);
 
     m_isDamaged = false;
     m_damageReplyPending = true;
 
     return m_damageReplyPending;
 }
 
 void Toplevel::getDamageRegionReply()
 {
     if (!m_damageReplyPending)
         return;
 
     m_damageReplyPending = false;
 
     // Get the fetch-region reply
     xcb_xfixes_fetch_region_reply_t *reply =
             xcb_xfixes_fetch_region_reply(connection(), m_regionCookie, 0);
 
     if (!reply)
         return;
 
     // Convert the reply to a QRegion
     int count = xcb_xfixes_fetch_region_rectangles_length(reply);
     QRegion region;
 
     if (count > 1 && count < 16) {
         xcb_rectangle_t *rects = xcb_xfixes_fetch_region_rectangles(reply);
 
         QVector<QRect> qrects;
         qrects.reserve(count);
 
         for (int i = 0; i < count; i++)
             qrects << QRect(rects[i].x, rects[i].y, rects[i].width, rects[i].height);
 
         region.setRects(qrects.constData(), count);
     } else
         region += QRect(reply->extents.x, reply->extents.y,
                         reply->extents.width, reply->extents.height);
 
     damage_region += region;
     repaints_region += region;
 
     free(reply);
 }
 
 void Toplevel::addDamageFull()
 {
     if (!compositing())
         return;
 
     damage_region = rect();
     repaints_region |= rect();
 
     emit damaged(this, rect());
 }
 
 void Toplevel::resetDamage()
 {
     damage_region = QRegion();
 }
 
 void Toplevel::addRepaint(const QRect& r)
 {
     if (!compositing()) {
         return;
     }
     repaints_region += r;
     emit needsRepaint();
 }
 
 void Toplevel::addRepaint(int x, int y, int w, int h)
 {
     QRect r(x, y, w, h);
     addRepaint(r);
 }
 
 void Toplevel::addRepaint(const QRegion& r)
 {
     if (!compositing()) {
         return;
     }
     repaints_region += r;
     emit needsRepaint();
 }
 
 void Toplevel::addLayerRepaint(const QRect& r)
 {
     if (!compositing()) {
         return;
     }
     layer_repaints_region += r;
     emit needsRepaint();
 }
 
 void Toplevel::addLayerRepaint(int x, int y, int w, int h)
 {
     QRect r(x, y, w, h);
     addLayerRepaint(r);
 }
 
 void Toplevel::addLayerRepaint(const QRegion& r)
 {
     if (!compositing())
         return;
     layer_repaints_region += r;
     emit needsRepaint();
 }
 
 void Toplevel::addRepaintFull()
 {
     repaints_region = visibleRect().translated(-pos());
     emit needsRepaint();
 }
 
 void Toplevel::resetRepaints()
 {
     repaints_region = QRegion();
     layer_repaints_region = QRegion();
 }
 
 void Toplevel::addWorkspaceRepaint(int x, int y, int w, int h)
 {
     addWorkspaceRepaint(QRect(x, y, w, h));
 }
 
 void Toplevel::addWorkspaceRepaint(const QRect& r2)
 {
     if (!compositing())
         return;
     Compositor::self()->addRepaint(r2);
 }
 
 //****************************************
 // Client
 //****************************************
 
 bool Client::setupCompositing()
 {
     if (!Toplevel::setupCompositing()){
         return false;
     }
     if (isDecorated()) {
         decoratedClient()->destroyRenderer();
     }
     updateVisibility(); // for internalKeep()
     return true;
 }
 
 void Client::finishCompositing(ReleaseReason releaseReason)
 {
     Toplevel::finishCompositing(releaseReason);
     updateVisibility();
     if (!deleting) {
         if (isDecorated()) {
             decoratedClient()->destroyRenderer();
         }
     }
     // for safety in case KWin is just resizing the window
     resetHaveResizeEffect();
 }
 
 } // namespace
diff --git a/data/org_kde_kwin.categories b/data/org_kde_kwin.categories
index 4f5d231d2..890068025 100644
--- a/data/org_kde_kwin.categories
+++ b/data/org_kde_kwin.categories
@@ -1,18 +1,19 @@
 kwin_core KWin Core
 kwineffects KWin Effects
 libkwineffects KWin Effects Library
 libkwinglutils KWin OpenGL utility Library
 libkwinxrenderutils KWin XRender utility Library
 kwin_wayland_drm KWin Wayland (DRM backend)
 kwin_wayland_framebuffer KWin Wayland (Framebuffer backend)
 kwin_wayland_hwcomposer KWin Wayland (hwcomposer backend)
 kwin_wayland_backend KWin Wayland (Wayland backend)
 kwin_wayland_x11windowed KWin Wayland (X11 backend)
 kwin_platform_x11_standalone KWin X11 Standalone Platform
 kwin_libinput KWin Libinput Integration
 kwin_tabbox KWin Window Switcher
 kwin_decorations KWin Decorations
 kwin_scripting KWin Scripting
 aurorae KWin Aurorae Window Decoration Engine
 kwin_xkbcommon KWin xkbcommon integration
 kwin_qpa_plugin KWin QtPlatformAbstraction plugin
+kwin_scene_xrender KWin XRender based compositor scene plugin
diff --git a/decorations/decorationrenderer.h b/decorations/decorationrenderer.h
index e216e2687..17d184bda 100644
--- a/decorations/decorationrenderer.h
+++ b/decorations/decorationrenderer.h
@@ -1,105 +1,107 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2014 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_DECORATION_RENDERER_H
 #define KWIN_DECORATION_RENDERER_H
 
 #include <QObject>
 #include <QRegion>
 
 #include <xcb/xcb.h>
 
+#include <kwin_export.h>
+
 class QTimer;
 
 namespace KWin
 {
 
 class Deleted;
 
 namespace Decoration
 {
 
 class DecoratedClientImpl;
 
-class Renderer : public QObject
+class KWIN_EXPORT Renderer : public QObject
 {
     Q_OBJECT
 public:
     virtual ~Renderer();
 
     void schedule(const QRect &rect);
 
     /**
      * Reparents this Renderer to the @p deleted.
      * After this call the Renderer is no longer able to render
      * anything, client() returns a nullptr.
      **/
     virtual void reparent(Deleted *deleted);
 
 Q_SIGNALS:
     void renderScheduled(const QRect &geo);
 
 protected:
     explicit Renderer(DecoratedClientImpl *client);
     /**
      * @returns the scheduled paint region and resets
      **/
     QRegion getScheduled();
 
     virtual void render() = 0;
 
     DecoratedClientImpl *client() {
         return m_client;
     }
 
     bool areImageSizesDirty() const {
         return m_imageSizesDirty;
     }
     void resetImageSizesDirty() {
         m_imageSizesDirty = false;
     }
     QImage renderToImage(const QRect &geo);
 
 private:
     DecoratedClientImpl *m_client;
     QRegion m_scheduled;
     bool m_imageSizesDirty;
 };
 
 class X11Renderer : public Renderer
 {
     Q_OBJECT
 public:
     explicit X11Renderer(DecoratedClientImpl *client);
     virtual ~X11Renderer();
 
     void reparent(Deleted *deleted) override;
 
 protected:
     void render() override;
 
 private:
     QTimer *m_scheduleTimer;
     xcb_gcontext_t m_gc;
 };
 
 }
 }
 
 #endif
diff --git a/effects.h b/effects.h
index ba24902b0..b9eb3d36a 100644
--- a/effects.h
+++ b/effects.h
@@ -1,535 +1,535 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_EFFECTSIMPL_H
 #define KWIN_EFFECTSIMPL_H
 
 #include "kwineffects.h"
 
 #include "client.h"
 #include "scene.h"
 #include "xcbutils.h"
 
 #include <QHash>
 #include <Plasma/FrameSvg>
 
 namespace Plasma {
 class Theme;
 }
 
 namespace KWayland
 {
 namespace Server
 {
 class Display;
 }
 }
 
 class QDBusPendingCallWatcher;
 class QDBusServiceWatcher;
 
 
 namespace KWin
 {
 
 class AbstractThumbnailItem;
 class DesktopThumbnailItem;
 class WindowThumbnailItem;
 
 class Client;
 class Compositor;
 class Deleted;
 class EffectLoader;
 class Unmanaged;
 
 class KWIN_EXPORT EffectsHandlerImpl : public EffectsHandler
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Effects")
     Q_PROPERTY(QStringList activeEffects READ activeEffects)
     Q_PROPERTY(QStringList loadedEffects READ loadedEffects)
     Q_PROPERTY(QStringList listOfEffects READ listOfEffects)
 public:
     EffectsHandlerImpl(Compositor *compositor, Scene *scene);
     virtual ~EffectsHandlerImpl();
     void prePaintScreen(ScreenPrePaintData& data, int time) override;
     void paintScreen(int mask, QRegion region, ScreenPaintData& data) override;
     /**
      * Special hook to perform a paintScreen but just with the windows on @p desktop.
      **/
     void paintDesktop(int desktop, int mask, QRegion region, ScreenPaintData& data);
     void postPaintScreen() override;
     void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) override;
     void paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) override;
     void postPaintWindow(EffectWindow* w) override;
     void paintEffectFrame(EffectFrame* frame, QRegion region, double opacity, double frameOpacity) override;
 
     Effect *provides(Effect::Feature ef);
 
     void drawWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data) override;
 
     void buildQuads(EffectWindow* w, WindowQuadList& quadList) override;
 
     void activateWindow(EffectWindow* c) override;
     EffectWindow* activeWindow() const override;
     void moveWindow(EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0) override;
     void windowToDesktop(EffectWindow* w, int desktop) override;
     void windowToScreen(EffectWindow* w, int screen) override;
     void setShowingDesktop(bool showing) override;
 
     QString currentActivity() const override;
     int currentDesktop() const override;
     int numberOfDesktops() const override;
     void setCurrentDesktop(int desktop) override;
     void setNumberOfDesktops(int desktops) override;
     QSize desktopGridSize() const override;
     int desktopGridWidth() const override;
     int desktopGridHeight() const override;
     int workspaceWidth() const override;
     int workspaceHeight() const override;
     int desktopAtCoords(QPoint coords) const override;
     QPoint desktopGridCoords(int id) const override;
     QPoint desktopCoords(int id) const override;
     int desktopAbove(int desktop = 0, bool wrap = true) const override;
     int desktopToRight(int desktop = 0, bool wrap = true) const override;
     int desktopBelow(int desktop = 0, bool wrap = true) const override;
     int desktopToLeft(int desktop = 0, bool wrap = true) const override;
     QString desktopName(int desktop) const override;
     bool optionRollOverDesktops() const override;
 
     QPoint cursorPos() const override;
     bool grabKeyboard(Effect* effect) override;
     void ungrabKeyboard() override;
     // not performing XGrabPointer
     void startMouseInterception(Effect *effect, Qt::CursorShape shape) override;
     void stopMouseInterception(Effect *effect) override;
     bool isMouseInterception() const;
     void registerGlobalShortcut(const QKeySequence &shortcut, QAction *action) override;
     void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action) override;
     void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action) override;
     void registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action) override;
     void* getProxy(QString name) override;
     void startMousePolling() override;
     void stopMousePolling() override;
     EffectWindow* findWindow(WId id) const override;
     EffectWindow* findWindow(KWayland::Server::SurfaceInterface *surf) const override;
     EffectWindowList stackingOrder() const override;
     void setElevatedWindow(KWin::EffectWindow* w, bool set) override;
 
     void setTabBoxWindow(EffectWindow*) override;
     void setTabBoxDesktop(int) override;
     EffectWindowList currentTabBoxWindowList() const override;
     void refTabBox() override;
     void unrefTabBox() override;
     void closeTabBox() override;
     QList< int > currentTabBoxDesktopList() const override;
     int currentTabBoxDesktop() const override;
     EffectWindow* currentTabBoxWindow() const override;
 
     void setActiveFullScreenEffect(Effect* e) override;
     Effect* activeFullScreenEffect() const override;
 
     void addRepaintFull() override;
     void addRepaint(const QRect& r) override;
     void addRepaint(const QRegion& r) override;
     void addRepaint(int x, int y, int w, int h) override;
     int activeScreen() const override;
     int numScreens() const override;
     int screenNumber(const QPoint& pos) const override;
     QRect clientArea(clientAreaOption, int screen, int desktop) const override;
     QRect clientArea(clientAreaOption, const EffectWindow* c) const override;
     QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const override;
     QSize virtualScreenSize() const override;
     QRect virtualScreenGeometry() const override;
     double animationTimeFactor() const override;
     WindowQuadType newWindowQuadType() override;
 
     void defineCursor(Qt::CursorShape shape) override;
     bool checkInputWindowEvent(xcb_button_press_event_t *e);
     bool checkInputWindowEvent(xcb_motion_notify_event_t *e);
     bool checkInputWindowEvent(QMouseEvent *e);
     bool checkInputWindowEvent(QWheelEvent *e);
     void checkInputWindowStacking();
 
     void reserveElectricBorder(ElectricBorder border, Effect *effect) override;
     void unreserveElectricBorder(ElectricBorder border, Effect *effect) override;
 
     void registerTouchBorder(ElectricBorder border, QAction *action) override;
     void unregisterTouchBorder(ElectricBorder border, QAction *action) override;
 
     unsigned long xrenderBufferPicture() override;
     QPainter* scenePainter() override;
     void reconfigure() override;
     QByteArray readRootProperty(long atom, long type, int format) const override;
     xcb_atom_t announceSupportProperty(const QByteArray& propertyName, Effect* effect) override;
     void removeSupportProperty(const QByteArray& propertyName, Effect* effect) override;
 
     bool hasDecorationShadows() const override;
 
     bool decorationsHaveAlpha() const override;
 
     bool decorationSupportsBlurBehind() const override;
 
     EffectFrame* effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const override;
 
     QVariant kwinOption(KWinOption kwopt) override;
     bool isScreenLocked() const override;
 
     bool makeOpenGLContextCurrent() override;
     void doneOpenGLContextCurrent() override;
 
     xcb_connection_t *xcbConnection() const override;
     xcb_window_t x11RootWindow() const override;
 
     // internal (used by kwin core or compositing code)
     void startPaint();
     void grabbedKeyboardEvent(QKeyEvent* e);
     bool hasKeyboardGrab() const;
     void desktopResized(const QSize &size);
 
     void reloadEffect(Effect *effect) override;
     QStringList loadedEffects() const;
     QStringList listOfEffects() const;
     void unloadAllEffects();
 
     QList<EffectWindow*> elevatedWindows() const;
     QStringList activeEffects() const;
 
     /**
      * @returns Whether we are currently in a desktop rendering process triggered by paintDesktop hook
      **/
     bool isDesktopRendering() const {
         return m_desktopRendering;
     }
     /**
      * @returns the desktop currently being rendered in the paintDesktop hook.
      **/
     int currentRenderedDesktop() const {
         return m_currentRenderedDesktop;
     }
 
     KWayland::Server::Display *waylandDisplay() const override;
 
     bool animationsSupported() const override;
 
     PlatformCursorImage cursorImage() const override;
 
     void hideCursor() override;
     void showCursor() override;
 
     void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) override;
     void startInteractivePositionSelection(std::function<void(const QPoint &)> callback) override;
 
     void showOnScreenMessage(const QString &message, const QString &iconName = QString()) override;
     void hideOnScreenMessage(OnScreenMessageHideFlags flags = OnScreenMessageHideFlags()) override;
 
     KSharedConfigPtr config() const override;
     KSharedConfigPtr inputConfig() const override;
 
     Scene *scene() const {
         return m_scene;
     }
 
     bool touchDown(quint32 id, const QPointF &pos, quint32 time);
     bool touchMotion(quint32 id, const QPointF &pos, quint32 time);
     bool touchUp(quint32 id, quint32 time);
 
     void highlightWindows(const QVector<EffectWindow *> &windows);
 
 public Q_SLOTS:
     void slotCurrentTabAboutToChange(EffectWindow* from, EffectWindow* to);
     void slotTabAdded(EffectWindow* from, EffectWindow* to);
     void slotTabRemoved(EffectWindow* c, EffectWindow* newActiveWindow);
 
     // slots for D-Bus interface
     Q_SCRIPTABLE void reconfigureEffect(const QString& name);
     Q_SCRIPTABLE bool loadEffect(const QString& name);
     Q_SCRIPTABLE void toggleEffect(const QString& name);
     Q_SCRIPTABLE void unloadEffect(const QString& name);
     Q_SCRIPTABLE bool isEffectLoaded(const QString& name) const;
     Q_SCRIPTABLE bool isEffectSupported(const QString& name);
     Q_SCRIPTABLE QList<bool> areEffectsSupported(const QStringList &names);
     Q_SCRIPTABLE QString supportInformation(const QString& name) const;
     Q_SCRIPTABLE QString debug(const QString& name, const QString& parameter = QString()) const;
 
 protected Q_SLOTS:
     void slotClientShown(KWin::Toplevel*);
     void slotShellClientShown(KWin::Toplevel*);
     void slotUnmanagedShown(KWin::Toplevel*);
     void slotWindowClosed(KWin::Toplevel *c, KWin::Deleted *d);
     void slotClientMaximized(KWin::AbstractClient *c, MaximizeMode maxMode);
     void slotOpacityChanged(KWin::Toplevel *t, qreal oldOpacity);
     void slotClientModalityChanged();
     void slotGeometryShapeChanged(KWin::Toplevel *t, const QRect &old);
     void slotPaddingChanged(KWin::Toplevel *t, const QRect &old);
     void slotWindowDamaged(KWin::Toplevel *t, const QRect& r);
     void slotPropertyNotify(KWin::Toplevel *t, long atom);
 
 protected:
     void connectNotify(const QMetaMethod &signal) override;
     void disconnectNotify(const QMetaMethod &signal) override;
     void effectsChanged();
     void setupAbstractClientConnections(KWin::AbstractClient *c);
     void setupClientConnections(KWin::Client *c);
     void setupUnmanagedConnections(KWin::Unmanaged *u);
 
     Effect* keyboard_grab_effect;
     Effect* fullscreen_effect;
     QList<EffectWindow*> elevated_windows;
     QMultiMap< int, EffectPair > effect_order;
     QHash< long, int > registered_atoms;
     int next_window_quad_type;
 
 private:
     void registerPropertyType(long atom, bool reg);
     typedef QVector< Effect*> EffectsList;
     typedef EffectsList::const_iterator EffectsIterator;
     EffectsList m_activeEffects;
     EffectsIterator m_currentDrawWindowIterator;
     EffectsIterator m_currentPaintWindowIterator;
     EffectsIterator m_currentPaintEffectFrameIterator;
     EffectsIterator m_currentPaintScreenIterator;
     EffectsIterator m_currentBuildQuadsIterator;
     typedef QHash< QByteArray, QList< Effect*> > PropertyEffectMap;
     PropertyEffectMap m_propertiesForEffects;
     QHash<QByteArray, qulonglong> m_managedProperties;
     Compositor *m_compositor;
     Scene *m_scene;
     bool m_desktopRendering;
     int m_currentRenderedDesktop;
     Xcb::Window m_mouseInterceptionWindow;
     QList<Effect*> m_grabbedMouseEffects;
     EffectLoader *m_effectLoader;
     int m_trackingCursorChanges;
 };
 
 class EffectWindowImpl : public EffectWindow
 {
     Q_OBJECT
 public:
     explicit EffectWindowImpl(Toplevel *toplevel);
     virtual ~EffectWindowImpl();
 
     void enablePainting(int reason) override;
     void disablePainting(int reason) override;
     bool isPaintingEnabled() override;
 
     void refWindow() override;
     void unrefWindow() override;
 
     const EffectWindowGroup* group() const override;
 
     QRegion shape() const override;
     QRect decorationInnerRect() const override;
     QByteArray readProperty(long atom, long type, int format) const override;
     void deleteProperty(long atom) const override;
 
     EffectWindow* findModal() override;
     EffectWindowList mainWindows() const override;
 
     WindowQuadList buildQuads(bool force = false) const override;
 
     void referencePreviousWindowPixmap() override;
     void unreferencePreviousWindowPixmap() override;
 
     const Toplevel* window() const;
     Toplevel* window();
 
     void setWindow(Toplevel* w);   // internal
     void setSceneWindow(Scene::Window* w);   // internal
     const Scene::Window* sceneWindow() const; // internal
     Scene::Window* sceneWindow(); // internal
 
     void elevate(bool elevate);
 
     void setData(int role, const QVariant &data);
     QVariant data(int role) const;
 
     void registerThumbnail(AbstractThumbnailItem *item);
     QHash<WindowThumbnailItem*, QWeakPointer<EffectWindowImpl> > const &thumbnails() const {
         return m_thumbnails;
     }
     QList<DesktopThumbnailItem*> const &desktopThumbnails() const {
         return m_desktopThumbnails;
     }
 private Q_SLOTS:
     void thumbnailDestroyed(QObject *object);
     void thumbnailTargetChanged();
     void desktopThumbnailDestroyed(QObject *object);
 private:
     void insertThumbnail(WindowThumbnailItem *item);
     Toplevel* toplevel;
     Scene::Window* sw; // This one is used only during paint pass.
     QHash<int, QVariant> dataMap;
     QHash<WindowThumbnailItem*, QWeakPointer<EffectWindowImpl> > m_thumbnails;
     QList<DesktopThumbnailItem*> m_desktopThumbnails;
 };
 
 class EffectWindowGroupImpl
     : public EffectWindowGroup
 {
 public:
     explicit EffectWindowGroupImpl(Group* g);
     EffectWindowList members() const override;
 private:
     Group* group;
 };
 
-class EffectFrameImpl
+class KWIN_EXPORT EffectFrameImpl
     : public QObject, public EffectFrame
 {
     Q_OBJECT
 public:
     explicit EffectFrameImpl(EffectFrameStyle style, bool staticSize = true, QPoint position = QPoint(-1, -1),
                              Qt::Alignment alignment = Qt::AlignCenter);
     virtual ~EffectFrameImpl();
 
     void free() override;
     void render(QRegion region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0) override;
     Qt::Alignment alignment() const override;
     void setAlignment(Qt::Alignment alignment) override;
     const QFont& font() const override;
     void setFont(const QFont& font) override;
     const QRect& geometry() const override;
     void setGeometry(const QRect& geometry, bool force = false) override;
     const QIcon& icon() const override;
     void setIcon(const QIcon& icon) override;
     const QSize& iconSize() const override;
     void setIconSize(const QSize& size) override;
     void setPosition(const QPoint& point) override;
     const QString& text() const override;
     void setText(const QString& text) override;
     EffectFrameStyle style() const override {
         return m_style;
     };
     Plasma::FrameSvg& frame() {
         return m_frame;
     }
     bool isStatic() const {
         return m_static;
     };
     void finalRender(QRegion region, double opacity, double frameOpacity) const;
     void setShader(GLShader* shader) override {
         m_shader = shader;
     }
     GLShader* shader() const override {
         return m_shader;
     }
     void setSelection(const QRect& selection) override;
     const QRect& selection() const {
         return m_selectionGeometry;
     }
     Plasma::FrameSvg& selectionFrame() {
         return m_selection;
     }
     /**
      * The foreground text color as specified by the default Plasma theme.
      */
     QColor styledTextColor();
 
 private Q_SLOTS:
     void plasmaThemeChanged();
 
 private:
     Q_DISABLE_COPY(EffectFrameImpl)   // As we need to use Qt slots we cannot copy this class
     void align(QRect &geometry);   // positions geometry around m_point respecting m_alignment
     void autoResize(); // Auto-resize if not a static size
 
     EffectFrameStyle m_style;
     Plasma::FrameSvg m_frame; // TODO: share between all EffectFrames
     Plasma::FrameSvg m_selection;
 
     // Position
     bool m_static;
     QPoint m_point;
     Qt::Alignment m_alignment;
     QRect m_geometry;
 
     // Contents
     QString m_text;
     QFont m_font;
     QIcon m_icon;
     QSize m_iconSize;
     QRect m_selectionGeometry;
 
     Scene::EffectFrame* m_sceneFrame;
     GLShader* m_shader;
 
     Plasma::Theme *m_theme;
 };
 
 inline
 QList<EffectWindow*> EffectsHandlerImpl::elevatedWindows() const
 {
     if (isScreenLocked())
         return QList<EffectWindow*>();
     return elevated_windows;
 }
 
 inline
 xcb_window_t EffectsHandlerImpl::x11RootWindow() const
 {
     return rootWindow();
 }
 
 inline
 xcb_connection_t *EffectsHandlerImpl::xcbConnection() const
 {
     return connection();
 }
 
 inline
 EffectWindowGroupImpl::EffectWindowGroupImpl(Group* g)
     : group(g)
 {
 }
 
 EffectWindow* effectWindow(Toplevel* w);
 EffectWindow* effectWindow(Scene::Window* w);
 
 inline
 const Scene::Window* EffectWindowImpl::sceneWindow() const
 {
     return sw;
 }
 
 inline
 Scene::Window* EffectWindowImpl::sceneWindow()
 {
     return sw;
 }
 
 inline
 const Toplevel* EffectWindowImpl::window() const
 {
     return toplevel;
 }
 
 inline
 Toplevel* EffectWindowImpl::window()
 {
     return toplevel;
 }
 
 
 } // namespace
 
 #endif
diff --git a/plugins/CMakeLists.txt b/plugins/CMakeLists.txt
index 3a06fa63f..da3eed351 100644
--- a/plugins/CMakeLists.txt
+++ b/plugins/CMakeLists.txt
@@ -1,8 +1,9 @@
 add_subdirectory(kglobalaccel)
 add_subdirectory(qpa)
 add_subdirectory(idletime)
 add_subdirectory(platforms)
+add_subdirectory(scenes)
 
 if(KWIN_BUILD_DECORATIONS)
     add_subdirectory(kdecorations)
 endif()
diff --git a/plugins/scenes/CMakeLists.txt b/plugins/scenes/CMakeLists.txt
new file mode 100644
index 000000000..b93ce5b95
--- /dev/null
+++ b/plugins/scenes/CMakeLists.txt
@@ -0,0 +1,3 @@
+if( KWIN_BUILD_XRENDER_COMPOSITING )
+    add_subdirectory(xrender)
+endif()
diff --git a/plugins/scenes/xrender/CMakeLists.txt b/plugins/scenes/xrender/CMakeLists.txt
new file mode 100644
index 000000000..8e8c67ed3
--- /dev/null
+++ b/plugins/scenes/xrender/CMakeLists.txt
@@ -0,0 +1,25 @@
+set(SCENE_XRENDER_SRCS scene_xrender.cpp)
+
+include(ECMQtDeclareLoggingCategory)
+ecm_qt_declare_logging_category(
+    SCENE_XRENDER_SRCS HEADER
+        logging.h
+    IDENTIFIER
+        KWIN_XRENDER
+    CATEGORY_NAME
+        kwin_scene_xrender
+    DEFAULT_SEVERITY
+        Critical
+)
+
+add_library(KWinSceneXRender MODULE ${SCENE_XRENDER_SRCS})
+target_link_libraries(KWinSceneXRender
+    kwin
+)
+
+install(
+    TARGETS
+        KWinSceneXRender
+    DESTINATION
+        ${PLUGIN_INSTALL_DIR}/org.kde.kwin.scenes/
+)
diff --git a/scene_xrender.cpp b/plugins/scenes/xrender/scene_xrender.cpp
similarity index 99%
rename from scene_xrender.cpp
rename to plugins/scenes/xrender/scene_xrender.cpp
index 433480787..df1702699 100644
--- a/scene_xrender.cpp
+++ b/plugins/scenes/xrender/scene_xrender.cpp
@@ -1,1307 +1,1325 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009 Fredrik Höglund <fredrik@kde.org>
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "scene_xrender.h"
 
 #include "utils.h"
 
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 
+#include "logging.h"
 #include "toplevel.h"
 #include "client.h"
 #include "composite.h"
 #include "deleted.h"
 #include "effects.h"
 #include "main.h"
 #include "overlaywindow.h"
 #include "platform.h"
 #include "screens.h"
 #include "xcbutils.h"
 #include "kwinxrenderutils.h"
 #include "decorations/decoratedclient.h"
 
 #include <xcb/xfixes.h>
 
 #include <QDebug>
 #include <QtGui/QPainter>
 #include <qmath.h>
 
 namespace KWin
 {
 
 ScreenPaintData SceneXrender::screen_paint;
 
 #define DOUBLE_TO_FIXED(d) ((xcb_render_fixed_t) ((d) * 65536))
 #define FIXED_TO_DOUBLE(f) ((double) ((f) / 65536.0))
 
 
 //****************************************
 // XRenderBackend
 //****************************************
 XRenderBackend::XRenderBackend()
     : m_buffer(XCB_RENDER_PICTURE_NONE)
     , m_failed(false)
 {
     if (!Xcb::Extensions::self()->isRenderAvailable()) {
         setFailed("No XRender extension available");
         return;
     }
     if (!Xcb::Extensions::self()->isFixesRegionAvailable()) {
         setFailed("No XFixes v3+ extension available");
         return;
     }
 }
 
 XRenderBackend::~XRenderBackend()
 {
     if (m_buffer) {
         xcb_render_free_picture(connection(), m_buffer);
     }
 }
 
 OverlayWindow* XRenderBackend::overlayWindow()
 {
     return NULL;
 }
 
 void XRenderBackend::showOverlay()
 {
 }
 
 void XRenderBackend::setBuffer(xcb_render_picture_t buffer)
 {
     if (m_buffer != XCB_RENDER_PICTURE_NONE) {
         xcb_render_free_picture(connection(), m_buffer);
     }
     m_buffer = buffer;
 }
 
 void XRenderBackend::setFailed(const QString& reason)
 {
-    qCCritical(KWIN_CORE) << "Creating the XRender backend failed: " << reason;
+    qCCritical(KWIN_XRENDER) << "Creating the XRender backend failed: " << reason;
     m_failed = true;
 }
 
 void XRenderBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
 }
 
 
 //****************************************
 // X11XRenderBackend
 //****************************************
 X11XRenderBackend::X11XRenderBackend()
     : XRenderBackend()
     , m_overlayWindow(kwinApp()->platform()->createOverlayWindow())
     , m_front(XCB_RENDER_PICTURE_NONE)
     , m_format(0)
 {
     init(true);
 }
 
 X11XRenderBackend::~X11XRenderBackend()
 {
     if (m_front) {
         xcb_render_free_picture(connection(), m_front);
     }
     m_overlayWindow->destroy();
 }
 
 OverlayWindow* X11XRenderBackend::overlayWindow()
 {
     return m_overlayWindow.data();
 }
 
 void X11XRenderBackend::showOverlay()
 {
     if (m_overlayWindow->window())  // show the window only after the first pass, since
         m_overlayWindow->show();   // that pass may take long
 }
 
 void X11XRenderBackend::init(bool createOverlay)
 {
     if (m_front != XCB_RENDER_PICTURE_NONE)
         xcb_render_free_picture(connection(), m_front);
     bool haveOverlay = createOverlay ? m_overlayWindow->create() : (m_overlayWindow->window() != XCB_WINDOW_NONE);
     if (haveOverlay) {
         m_overlayWindow->setup(XCB_WINDOW_NONE);
         ScopedCPointer<xcb_get_window_attributes_reply_t> attribs(xcb_get_window_attributes_reply(connection(),
             xcb_get_window_attributes_unchecked(connection(), m_overlayWindow->window()), NULL));
         if (!attribs) {
             setFailed("Failed getting window attributes for overlay window");
             return;
         }
         m_format = XRenderUtils::findPictFormat(attribs->visual);
         if (m_format == 0) {
             setFailed("Failed to find XRender format for overlay window");
             return;
         }
         m_front = xcb_generate_id(connection());
         xcb_render_create_picture(connection(), m_front, m_overlayWindow->window(), m_format, 0, NULL);
     } else {
         // create XRender picture for the root window
         m_format = XRenderUtils::findPictFormat(defaultScreen()->root_visual);
         if (m_format == 0) {
             setFailed("Failed to find XRender format for root window");
             return; // error
         }
         m_front = xcb_generate_id(connection());
         const uint32_t values[] = {XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS};
         xcb_render_create_picture(connection(), m_front, rootWindow(), m_format, XCB_RENDER_CP_SUBWINDOW_MODE, values);
     }
     createBuffer();
 }
 
 void X11XRenderBackend::createBuffer()
 {
     xcb_pixmap_t pixmap = xcb_generate_id(connection());
     const auto displaySize = screens()->displaySize();
     xcb_create_pixmap(connection(), Xcb::defaultDepth(), pixmap, rootWindow(), displaySize.width(), displaySize.height());
     xcb_render_picture_t b = xcb_generate_id(connection());
     xcb_render_create_picture(connection(), b, pixmap, m_format, 0, NULL);
     xcb_free_pixmap(connection(), pixmap);   // The picture owns the pixmap now
     setBuffer(b);
 }
 
 void X11XRenderBackend::present(int mask, const QRegion &damage)
 {
     const auto displaySize = screens()->displaySize();
     if (mask & Scene::PAINT_SCREEN_REGION) {
         // Use the damage region as the clip region for the root window
         XFixesRegion frontRegion(damage);
         xcb_xfixes_set_picture_clip_region(connection(), m_front, frontRegion, 0, 0);
         // copy composed buffer to the root window
         xcb_xfixes_set_picture_clip_region(connection(), buffer(), XCB_XFIXES_REGION_NONE, 0, 0);
         xcb_render_composite(connection(), XCB_RENDER_PICT_OP_SRC, buffer(), XCB_RENDER_PICTURE_NONE,
                              m_front, 0, 0, 0, 0, 0, 0, displaySize.width(), displaySize.height());
         xcb_xfixes_set_picture_clip_region(connection(), m_front, XCB_XFIXES_REGION_NONE, 0, 0);
         xcb_flush(connection());
     } else {
         // copy composed buffer to the root window
         xcb_render_composite(connection(), XCB_RENDER_PICT_OP_SRC, buffer(), XCB_RENDER_PICTURE_NONE,
                              m_front, 0, 0, 0, 0, 0, 0, displaySize.width(), displaySize.height());
         xcb_flush(connection());
     }
 }
 
 void X11XRenderBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
     init(false);
 }
 
 bool X11XRenderBackend::usesOverlayWindow() const
 {
     return true;
 }
 
 //****************************************
 // SceneXrender
 //****************************************
 
 SceneXrender* SceneXrender::createScene(QObject *parent)
 {
     QScopedPointer<XRenderBackend> backend;
     backend.reset(new X11XRenderBackend);
     if (backend->isFailed()) {
         return NULL;
     }
     return new SceneXrender(backend.take(), parent);
 }
 
 SceneXrender::SceneXrender(XRenderBackend *backend, QObject *parent)
     : Scene(parent)
     , m_backend(backend)
 {
 }
 
 SceneXrender::~SceneXrender()
 {
     SceneXrender::Window::cleanup();
     SceneXrender::EffectFrame::cleanup();
 }
 
 bool SceneXrender::initFailed() const
 {
     return false;
 }
 
 // the entry point for painting
 qint64 SceneXrender::paint(QRegion damage, ToplevelList toplevels)
 {
     QElapsedTimer renderTimer;
     renderTimer.start();
 
     createStackingOrder(toplevels);
 
     int mask = 0;
     QRegion updateRegion, validRegion;
     paintScreen(&mask, damage, QRegion(), &updateRegion, &validRegion);
 
     m_backend->showOverlay();
 
     m_backend->present(mask, updateRegion);
     // do cleanup
     clearStackingOrder();
 
     return renderTimer.nsecsElapsed();
 }
 
 void SceneXrender::paintGenericScreen(int mask, ScreenPaintData data)
 {
     screen_paint = data; // save, transformations will be done when painting windows
     Scene::paintGenericScreen(mask, data);
 }
 
 void SceneXrender::paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data)
 {
     PaintClipper::push(region);
     KWin::Scene::paintDesktop(desktop, mask, region, data);
     PaintClipper::pop(region);
 }
 
 // fill the screen background
 void SceneXrender::paintBackground(QRegion region)
 {
     xcb_render_color_t col = { 0, 0, 0, 0xffff }; // black
     const QVector<xcb_rectangle_t> &rects = Xcb::regionToRects(region);
     xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, xrenderBufferPicture(), col, rects.count(), rects.data());
 }
 
 Scene::Window *SceneXrender::createWindow(Toplevel *toplevel)
 {
     return new Window(toplevel, this);
 }
 
 Scene::EffectFrame *SceneXrender::createEffectFrame(EffectFrameImpl *frame)
 {
     return new SceneXrender::EffectFrame(frame);
 }
 
 Shadow *SceneXrender::createShadow(Toplevel *toplevel)
 {
     return new SceneXRenderShadow(toplevel);
 }
 
 Decoration::Renderer *SceneXrender::createDecorationRenderer(Decoration::DecoratedClientImpl* client)
 {
     return new SceneXRenderDecorationRenderer(client);
 }
 
 //****************************************
 // SceneXrender::Window
 //****************************************
 
 XRenderPicture *SceneXrender::Window::s_tempPicture = 0;
 QRect SceneXrender::Window::temp_visibleRect;
 XRenderPicture *SceneXrender::Window::s_fadeAlphaPicture = nullptr;
 
 SceneXrender::Window::Window(Toplevel* c, SceneXrender *scene)
     : Scene::Window(c)
     , m_scene(scene)
     , format(XRenderUtils::findPictFormat(c->visual()))
 {
 }
 
 SceneXrender::Window::~Window()
 {
     discardShape();
 }
 
 void SceneXrender::Window::cleanup()
 {
     delete s_tempPicture;
     s_tempPicture = NULL;
     delete s_fadeAlphaPicture;
     s_fadeAlphaPicture = nullptr;
 }
 
 // Maps window coordinates to screen coordinates
 QRect SceneXrender::Window::mapToScreen(int mask, const WindowPaintData &data, const QRect &rect) const
 {
     QRect r = rect;
 
     if (mask & PAINT_WINDOW_TRANSFORMED) {
         // Apply the window transformation
         r.moveTo(r.x() * data.xScale() + data.xTranslation(),
                  r.y() * data.yScale() + data.yTranslation());
         r.setWidth(r.width() * data.xScale());
         r.setHeight(r.height() * data.yScale());
     }
 
     // Move the rectangle to the screen position
     r.translate(x(), y());
 
     if (mask & PAINT_SCREEN_TRANSFORMED) {
         // Apply the screen transformation
         r.moveTo(r.x() * screen_paint.xScale() + screen_paint.xTranslation(),
                  r.y() * screen_paint.yScale() + screen_paint.yTranslation());
         r.setWidth(r.width() * screen_paint.xScale());
         r.setHeight(r.height() * screen_paint.yScale());
     }
 
     return r;
 }
 
 // Maps window coordinates to screen coordinates
 QPoint SceneXrender::Window::mapToScreen(int mask, const WindowPaintData &data, const QPoint &point) const
 {
     QPoint pt = point;
 
     if (mask & PAINT_WINDOW_TRANSFORMED) {
         // Apply the window transformation
         pt.rx() = pt.x() * data.xScale() + data.xTranslation();
         pt.ry() = pt.y() * data.yScale() + data.yTranslation();
     }
 
     // Move the point to the screen position
     pt += QPoint(x(), y());
 
     if (mask & PAINT_SCREEN_TRANSFORMED) {
         // Apply the screen transformation
         pt.rx() = pt.x() * screen_paint.xScale() + screen_paint.xTranslation();
         pt.ry() = pt.y() * screen_paint.yScale() + screen_paint.yTranslation();
     }
 
     return pt;
 }
 
 void SceneXrender::Window::prepareTempPixmap()
 {
     const QSize oldSize = temp_visibleRect.size();
     temp_visibleRect = toplevel->visibleRect().translated(-toplevel->pos());
     if (s_tempPicture && (oldSize.width() < temp_visibleRect.width() || oldSize.height() < temp_visibleRect.height())) {
         delete s_tempPicture;
         s_tempPicture = NULL;
         scene_setXRenderOffscreenTarget(0); // invalidate, better crash than cause weird results for developers
     }
     if (!s_tempPicture) {
         xcb_pixmap_t pix = xcb_generate_id(connection());
         xcb_create_pixmap(connection(), 32, pix, rootWindow(), temp_visibleRect.width(), temp_visibleRect.height());
         s_tempPicture = new XRenderPicture(pix, 32);
         xcb_free_pixmap(connection(), pix);
     }
     const xcb_render_color_t transparent = {0, 0, 0, 0};
     const xcb_rectangle_t rect = {0, 0, uint16_t(temp_visibleRect.width()), uint16_t(temp_visibleRect.height())};
     xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, *s_tempPicture, transparent, 1, &rect);
 }
 
 // paint the window
 void SceneXrender::Window::performPaint(int mask, QRegion region, WindowPaintData data)
 {
     setTransformedShape(QRegion());  // maybe nothing will be painted
     // check if there is something to paint
     bool opaque = isOpaque() && qFuzzyCompare(data.opacity(), 1.0);
     /* HACK: It seems this causes painting glitches, disable temporarily
     if (( mask & PAINT_WINDOW_OPAQUE ) ^ ( mask & PAINT_WINDOW_TRANSLUCENT ))
         { // We are only painting either opaque OR translucent windows, not both
         if ( mask & PAINT_WINDOW_OPAQUE && !opaque )
             return; // Only painting opaque and window is translucent
         if ( mask & PAINT_WINDOW_TRANSLUCENT && opaque )
             return; // Only painting translucent and window is opaque
         }*/
     // Intersect the clip region with the rectangle the window occupies on the screen
     if (!(mask & (PAINT_WINDOW_TRANSFORMED | PAINT_SCREEN_TRANSFORMED)))
         region &= toplevel->visibleRect();
 
     if (region.isEmpty())
         return;
     XRenderWindowPixmap *pixmap = windowPixmap<XRenderWindowPixmap>();
     if (!pixmap || !pixmap->isValid()) {
         return;
     }
     xcb_render_picture_t pic = pixmap->picture();
     if (pic == XCB_RENDER_PICTURE_NONE)   // The render format can be null for GL and/or Xv visuals
         return;
     toplevel->resetDamage();
     // set picture filter
     if (options->isXrenderSmoothScale()) { // only when forced, it's slow
         if (mask & PAINT_WINDOW_TRANSFORMED)
             filter = ImageFilterGood;
         else if (mask & PAINT_SCREEN_TRANSFORMED)
             filter = ImageFilterGood;
         else
             filter = ImageFilterFast;
     } else
         filter = ImageFilterFast;
     // do required transformations
     const QRect wr = mapToScreen(mask, data, QRect(0, 0, width(), height()));
     QRect cr = QRect(toplevel->clientPos(), toplevel->clientSize()); // Client rect (in the window)
     qreal xscale = 1;
     qreal yscale = 1;
     bool scaled = false;
 
     Client *client = dynamic_cast<Client*>(toplevel);
     Deleted *deleted = dynamic_cast<Deleted*>(toplevel);
     const QRect decorationRect = toplevel->decorationRect();
     if (((client && !client->noBorder()) || (deleted && !deleted->noBorder())) &&
                                                         true) {
         // decorated client
         transformed_shape = decorationRect;
         if (toplevel->shape()) {
             // "xeyes" + decoration
             transformed_shape -= cr;
             transformed_shape += shape();
         }
     } else {
         transformed_shape = shape();
     }
     if (toplevel->hasShadow())
         transformed_shape |= toplevel->shadow()->shadowRegion();
 
     xcb_render_transform_t xform = {
         DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0),
         DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0),
         DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1)
     };
     static const xcb_render_transform_t identity = {
         DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0),
         DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0),
         DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1)
     };
 
     if (mask & PAINT_WINDOW_TRANSFORMED) {
         xscale = data.xScale();
         yscale = data.yScale();
     }
     if (mask & PAINT_SCREEN_TRANSFORMED) {
         xscale *= screen_paint.xScale();
         yscale *= screen_paint.yScale();
     }
     if (!qFuzzyCompare(xscale, 1.0) || !qFuzzyCompare(yscale, 1.0)) {
         scaled = true;
         xform.matrix11 = DOUBLE_TO_FIXED(1.0 / xscale);
         xform.matrix22 = DOUBLE_TO_FIXED(1.0 / yscale);
 
         // transform the shape for clipping in paintTransformedScreen()
         QVector<QRect> rects = transformed_shape.rects();
         for (int i = 0; i < rects.count(); ++i) {
             QRect& r = rects[ i ];
             r.setRect(qRound(r.x() * xscale), qRound(r.y() * yscale),
                       qRound(r.width() * xscale), qRound(r.height() * yscale));
         }
         transformed_shape.setRects(rects.constData(), rects.count());
     }
 
     transformed_shape.translate(mapToScreen(mask, data, QPoint(0, 0)));
     PaintClipper pcreg(region);   // clip by the region to paint
     PaintClipper pc(transformed_shape);   // clip by window's shape
 
     const bool wantShadow = m_shadow && !m_shadow->shadowRegion().isEmpty();
 
     // In order to obtain a pixel perfect rescaling
     // we need to blit the window content togheter with
     // decorations in a temporary pixmap and scale
     // the temporary pixmap at the end.
     // We should do this only if there is scaling and
     // the window has border
     // This solves a number of glitches and on top of this
     // it optimizes painting quite a bit
     const bool blitInTempPixmap = xRenderOffscreen() || (data.crossFadeProgress() < 1.0 && !opaque) ||
                                  (scaled && (wantShadow || (client && !client->noBorder()) || (deleted && !deleted->noBorder())));
 
     xcb_render_picture_t renderTarget = m_scene->xrenderBufferPicture();
     if (blitInTempPixmap) {
         if (scene_xRenderOffscreenTarget()) {
             temp_visibleRect = toplevel->visibleRect().translated(-toplevel->pos());
             renderTarget = *scene_xRenderOffscreenTarget();
         } else {
             prepareTempPixmap();
             renderTarget = *s_tempPicture;
         }
     } else {
         xcb_render_set_picture_transform(connection(), pic, xform);
         if (filter == ImageFilterGood) {
             setPictureFilter(pic, KWin::Scene::ImageFilterGood);
         }
 
         //BEGIN OF STUPID RADEON HACK
         // This is needed to avoid hitting a fallback in the radeon driver.
         // The Render specification states that sampling pixels outside the
         // source picture results in alpha=0 pixels. This can be achieved by
         // setting the border color to transparent black, but since the border
         // color has the same format as the texture, it only works when the
         // texture has an alpha channel. So the driver falls back to software
         // when the repeat mode is RepeatNone, the picture has a non-identity
         // transformation matrix, and doesn't have an alpha channel.
         // Since we only scale the picture, we can work around this by setting
         // the repeat mode to RepeatPad.
         if (!window()->hasAlpha()) {
             const uint32_t values[] = {XCB_RENDER_REPEAT_PAD};
             xcb_render_change_picture(connection(), pic, XCB_RENDER_CP_REPEAT, values);
         }
         //END OF STUPID RADEON HACK
     }
 #define MAP_RECT_TO_TARGET(_RECT_) \
         if (blitInTempPixmap) _RECT_.translate(-temp_visibleRect.topLeft()); else _RECT_ = mapToScreen(mask, data, _RECT_)
 
     //BEGIN deco preparations
     bool noBorder = true;
     xcb_render_picture_t left   = XCB_RENDER_PICTURE_NONE;
     xcb_render_picture_t top    = XCB_RENDER_PICTURE_NONE;
     xcb_render_picture_t right  = XCB_RENDER_PICTURE_NONE;
     xcb_render_picture_t bottom = XCB_RENDER_PICTURE_NONE;
     QRect dtr, dlr, drr, dbr;
     const SceneXRenderDecorationRenderer *renderer = nullptr;
     if (client) {
         if (client && !client->noBorder()) {
             if (client->isDecorated()) {
                 SceneXRenderDecorationRenderer *r = static_cast<SceneXRenderDecorationRenderer*>(client->decoratedClient()->renderer());
                 if (r) {
                     r->render();
                     renderer = r;
                 }
             }
             noBorder = client->noBorder();
             client->layoutDecorationRects(dlr, dtr, drr, dbr);
         }
     }
     if (deleted && !deleted->noBorder()) {
         renderer = static_cast<const SceneXRenderDecorationRenderer*>(deleted->decorationRenderer());
         noBorder = deleted->noBorder();
         deleted->layoutDecorationRects(dlr, dtr, drr, dbr);
     }
     if (renderer) {
         left   = renderer->picture(SceneXRenderDecorationRenderer::DecorationPart::Left);
         top    = renderer->picture(SceneXRenderDecorationRenderer::DecorationPart::Top);
         right  = renderer->picture(SceneXRenderDecorationRenderer::DecorationPart::Right);
         bottom = renderer->picture(SceneXRenderDecorationRenderer::DecorationPart::Bottom);
     }
     if (!noBorder) {
         MAP_RECT_TO_TARGET(dtr);
         MAP_RECT_TO_TARGET(dlr);
         MAP_RECT_TO_TARGET(drr);
         MAP_RECT_TO_TARGET(dbr);
     }
     //END deco preparations
 
     //BEGIN shadow preparations
     QRect stlr, str, strr, srr, sbrr, sbr, sblr, slr;
     SceneXRenderShadow* m_xrenderShadow = static_cast<SceneXRenderShadow*>(m_shadow);
 
     if (wantShadow) {
         m_xrenderShadow->layoutShadowRects(str, strr, srr, sbrr, sbr, sblr, slr, stlr);
         MAP_RECT_TO_TARGET(stlr);
         MAP_RECT_TO_TARGET(str);
         MAP_RECT_TO_TARGET(strr);
         MAP_RECT_TO_TARGET(srr);
         MAP_RECT_TO_TARGET(sbrr);
         MAP_RECT_TO_TARGET(sbr);
         MAP_RECT_TO_TARGET(sblr);
         MAP_RECT_TO_TARGET(slr);
     }
     //BEGIN end preparations
 
     //BEGIN client preparations
     QRect dr = cr;
     if (blitInTempPixmap) {
         dr.translate(-temp_visibleRect.topLeft());
     } else {
         dr = mapToScreen(mask, data, dr); // Destination rect
         if (scaled) {
             cr.moveLeft(cr.x() * xscale);
             cr.moveTop(cr.y() * yscale);
         }
     }
 
     const int clientRenderOp = (opaque || blitInTempPixmap) ? XCB_RENDER_PICT_OP_SRC : XCB_RENDER_PICT_OP_OVER;
     //END client preparations
 
 #undef MAP_RECT_TO_TARGET
 
     for (PaintClipper::Iterator iterator; !iterator.isDone(); iterator.next()) {
 
 #define RENDER_SHADOW_TILE(_TILE_, _RECT_) \
 xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, m_xrenderShadow->picture(SceneXRenderShadow::ShadowElement##_TILE_), \
                  shadowAlpha, renderTarget, 0, 0, 0, 0, _RECT_.x(), _RECT_.y(), _RECT_.width(), _RECT_.height())
 
         //shadow
         if (wantShadow) {
             xcb_render_picture_t shadowAlpha = XCB_RENDER_PICTURE_NONE;
             if (!opaque) {
                 shadowAlpha = xRenderBlendPicture(data.opacity());
             }
             RENDER_SHADOW_TILE(TopLeft, stlr);
             RENDER_SHADOW_TILE(Top, str);
             RENDER_SHADOW_TILE(TopRight, strr);
             RENDER_SHADOW_TILE(Left, slr);
             RENDER_SHADOW_TILE(Right, srr);
             RENDER_SHADOW_TILE(BottomLeft, sblr);
             RENDER_SHADOW_TILE(Bottom, sbr);
             RENDER_SHADOW_TILE(BottomRight, sbrr);
         }
 #undef RENDER_SHADOW_TILE
 
         // Paint the window contents
         if (!(client && client->isShade())) {
             xcb_render_picture_t clientAlpha = XCB_RENDER_PICTURE_NONE;
             if (!opaque) {
                 clientAlpha = xRenderBlendPicture(data.opacity());
             }
             xcb_render_composite(connection(), clientRenderOp, pic, clientAlpha, renderTarget,
                                  cr.x(), cr.y(), 0, 0, dr.x(), dr.y(), dr.width(), dr.height());
             if (data.crossFadeProgress() < 1.0 && data.crossFadeProgress() > 0.0) {
                 XRenderWindowPixmap *previous = previousWindowPixmap<XRenderWindowPixmap>();
                 if (previous && previous != pixmap) {
                     static xcb_render_color_t cFadeColor = {0, 0, 0, 0};
                     cFadeColor.alpha = uint16_t((1.0 - data.crossFadeProgress()) * 0xffff);
                     if (!s_fadeAlphaPicture) {
                         s_fadeAlphaPicture = new XRenderPicture(xRenderFill(cFadeColor));
                     } else {
                         xcb_rectangle_t rect = {0, 0, 1, 1};
                         xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, *s_fadeAlphaPicture, cFadeColor , 1, &rect);
                     }
                     if (previous->size() != pixmap->size()) {
                         xcb_render_transform_t xform2 = {
                             DOUBLE_TO_FIXED(FIXED_TO_DOUBLE(xform.matrix11) * previous->size().width() / pixmap->size().width()), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0),
                             DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(FIXED_TO_DOUBLE(xform.matrix22) * previous->size().height() / pixmap->size().height()), DOUBLE_TO_FIXED(0),
                             DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1)
                             };
                         xcb_render_set_picture_transform(connection(), previous->picture(), xform2);
                     }
 
                     xcb_render_composite(connection(), opaque ? XCB_RENDER_PICT_OP_OVER : XCB_RENDER_PICT_OP_ATOP,
                                          previous->picture(), *s_fadeAlphaPicture, renderTarget,
                                          cr.x(), cr.y(), 0, 0, dr.x(), dr.y(), dr.width(), dr.height());
 
                     if (previous->size() != pixmap->size()) {
                         xcb_render_set_picture_transform(connection(), previous->picture(), identity);
                     }
                 }
             }
             if (!opaque)
                 transformed_shape = QRegion();
         }
 
         if (client || deleted) {
             if (!noBorder) {
                 xcb_render_picture_t decorationAlpha = xRenderBlendPicture(data.opacity());
                 auto renderDeco = [decorationAlpha, renderTarget](xcb_render_picture_t deco, const QRect &rect) {
                     if (deco == XCB_RENDER_PICTURE_NONE) {
                         return;
                     }
                     xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, deco, decorationAlpha, renderTarget,
                                          0, 0, 0, 0, rect.x(), rect.y(), rect.width(), rect.height());
                 };
                 renderDeco(top, dtr);
                 renderDeco(left, dlr);
                 renderDeco(right, drr);
                 renderDeco(bottom, dbr);
             }
         }
 
         if (data.brightness() != 1.0) {
             // fake brightness change by overlaying black
             const float alpha = (1 - data.brightness()) * data.opacity();
             xcb_rectangle_t rect;
             if (blitInTempPixmap) {
                 rect.x = -temp_visibleRect.left();
                 rect.y = -temp_visibleRect.top();
                 rect.width = width();
                 rect.height = height();
             } else {
                 rect.x = wr.x();
                 rect.y = wr.y();
                 rect.width = wr.width();
                 rect.height = wr.height();
             }
             xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_OVER, renderTarget,
                                        preMultiply(data.brightness() < 1.0 ? QColor(0,0,0,255*alpha) : QColor(255,255,255,-alpha*255)),
                                        1, &rect);
         }
         if (blitInTempPixmap) {
             const QRect r = mapToScreen(mask, data, temp_visibleRect);
             xcb_render_set_picture_transform(connection(), *s_tempPicture, xform);
             setPictureFilter(*s_tempPicture, filter);
             xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *s_tempPicture,
                                  XCB_RENDER_PICTURE_NONE, m_scene->xrenderBufferPicture(),
                                  0, 0, 0, 0, r.x(), r.y(), r.width(), r.height());
             xcb_render_set_picture_transform(connection(), *s_tempPicture, identity);
         }
     }
     if (scaled && !blitInTempPixmap) {
         xcb_render_set_picture_transform(connection(), pic, identity);
         if (filter == ImageFilterGood)
             setPictureFilter(pic, KWin::Scene::ImageFilterFast);
         if (!window()->hasAlpha()) {
             const uint32_t values[] = {XCB_RENDER_REPEAT_NONE};
             xcb_render_change_picture(connection(), pic, XCB_RENDER_CP_REPEAT, values);
         }
     }
     if (xRenderOffscreen())
         scene_setXRenderOffscreenTarget(*s_tempPicture);
 }
 
 void SceneXrender::Window::setPictureFilter(xcb_render_picture_t pic, Scene::ImageFilterType filter)
 {
     QByteArray filterName;
     switch (filter) {
     case KWin::Scene::ImageFilterFast:
         filterName = QByteArray("fast");
         break;
     case KWin::Scene::ImageFilterGood:
         filterName = QByteArray("good");
         break;
     }
     xcb_render_set_picture_filter(connection(), pic, filterName.length(), filterName.constData(), 0, NULL);
 }
 
 WindowPixmap* SceneXrender::Window::createWindowPixmap()
 {
     return new XRenderWindowPixmap(this, format);
 }
 
 void SceneXrender::screenGeometryChanged(const QSize &size)
 {
     Scene::screenGeometryChanged(size);
     m_backend->screenGeometryChanged(size);
 }
 
 //****************************************
 // XRenderWindowPixmap
 //****************************************
 
 XRenderWindowPixmap::XRenderWindowPixmap(Scene::Window *window, xcb_render_pictformat_t format)
     : WindowPixmap(window)
     , m_picture(XCB_RENDER_PICTURE_NONE)
     , m_format(format)
 {
 }
 
 XRenderWindowPixmap::~XRenderWindowPixmap()
 {
     if (m_picture != XCB_RENDER_PICTURE_NONE) {
         xcb_render_free_picture(connection(), m_picture);
     }
 }
 
 void XRenderWindowPixmap::create()
 {
     if (isValid()) {
         return;
     }
     KWin::WindowPixmap::create();
     if (!isValid()) {
         return;
     }
     m_picture = xcb_generate_id(connection());
     xcb_render_create_picture(connection(), m_picture, pixmap(), m_format, 0, NULL);
 }
 
 //****************************************
 // SceneXrender::EffectFrame
 //****************************************
 
 XRenderPicture *SceneXrender::EffectFrame::s_effectFrameCircle = NULL;
 
 SceneXrender::EffectFrame::EffectFrame(EffectFrameImpl* frame)
     : Scene::EffectFrame(frame)
 {
     m_picture = NULL;
     m_textPicture = NULL;
     m_iconPicture = NULL;
     m_selectionPicture = NULL;
 }
 
 SceneXrender::EffectFrame::~EffectFrame()
 {
     delete m_picture;
     delete m_textPicture;
     delete m_iconPicture;
     delete m_selectionPicture;
 }
 
 void SceneXrender::EffectFrame::cleanup()
 {
     delete s_effectFrameCircle;
     s_effectFrameCircle = NULL;
 }
 
 void SceneXrender::EffectFrame::free()
 {
     delete m_picture;
     m_picture = NULL;
     delete m_textPicture;
     m_textPicture = NULL;
     delete m_iconPicture;
     m_iconPicture = NULL;
     delete m_selectionPicture;
     m_selectionPicture = NULL;
 }
 
 void SceneXrender::EffectFrame::freeIconFrame()
 {
     delete m_iconPicture;
     m_iconPicture = NULL;
 }
 
 void SceneXrender::EffectFrame::freeTextFrame()
 {
     delete m_textPicture;
     m_textPicture = NULL;
 }
 
 void SceneXrender::EffectFrame::freeSelection()
 {
     delete m_selectionPicture;
     m_selectionPicture = NULL;
 }
 
 void SceneXrender::EffectFrame::crossFadeIcon()
 {
     // TODO: implement me
 }
 
 void SceneXrender::EffectFrame::crossFadeText()
 {
     // TODO: implement me
 }
 
 void SceneXrender::EffectFrame::render(QRegion region, double opacity, double frameOpacity)
 {
     Q_UNUSED(region)
     if (m_effectFrame->geometry().isEmpty()) {
         return; // Nothing to display
     }
 
     // Render the actual frame
     if (m_effectFrame->style() == EffectFrameUnstyled) {
         renderUnstyled(effects->xrenderBufferPicture(), m_effectFrame->geometry(), opacity * frameOpacity);
     } else if (m_effectFrame->style() == EffectFrameStyled) {
         if (!m_picture) { // Lazy creation
             updatePicture();
         }
         if (m_picture) {
             qreal left, top, right, bottom;
             m_effectFrame->frame().getMargins(left, top, right, bottom);   // m_geometry is the inner geometry
             QRect geom = m_effectFrame->geometry().adjusted(-left, -top, right, bottom);
             xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *m_picture,
                                  XCB_RENDER_PICTURE_NONE, effects->xrenderBufferPicture(),
                                  0, 0, 0, 0, geom.x(), geom.y(), geom.width(), geom.height());
         }
     }
     if (!m_effectFrame->selection().isNull()) {
         if (!m_selectionPicture) { // Lazy creation
             const QPixmap pix = m_effectFrame->selectionFrame().framePixmap();
             if (!pix.isNull()) // don't try if there's no content
                 m_selectionPicture = new XRenderPicture(m_effectFrame->selectionFrame().framePixmap().toImage());
         }
         if (m_selectionPicture) {
             const QRect geom = m_effectFrame->selection();
             xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *m_selectionPicture,
                                  XCB_RENDER_PICTURE_NONE, effects->xrenderBufferPicture(),
                                  0, 0, 0, 0, geom.x(), geom.y(), geom.width(), geom.height());
         }
     }
 
     XRenderPicture fill = xRenderBlendPicture(opacity);
 
     // Render icon
     if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
         QPoint topLeft(m_effectFrame->geometry().x(), m_effectFrame->geometry().center().y() - m_effectFrame->iconSize().height() / 2);
 
         if (!m_iconPicture)   // lazy creation
             m_iconPicture = new XRenderPicture(m_effectFrame->icon().pixmap(m_effectFrame->iconSize()).toImage());
         QRect geom = QRect(topLeft, m_effectFrame->iconSize());
         xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *m_iconPicture, fill,
                              effects->xrenderBufferPicture(),
                              0, 0, 0, 0, geom.x(), geom.y(), geom.width(), geom.height());
     }
 
     // Render text
     if (!m_effectFrame->text().isEmpty()) {
         if (!m_textPicture) { // Lazy creation
             updateTextPicture();
         }
 
         if (m_textPicture) {
             xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *m_textPicture, fill, effects->xrenderBufferPicture(),
                              0, 0, 0, 0, m_effectFrame->geometry().x(), m_effectFrame->geometry().y(),
                              m_effectFrame->geometry().width(), m_effectFrame->geometry().height());
         }
     }
 }
 
 void SceneXrender::EffectFrame::renderUnstyled(xcb_render_picture_t pict, const QRect &rect, qreal opacity)
 {
     const int roundness = 5;
     const QRect area = rect.adjusted(-roundness, -roundness, roundness, roundness);
     xcb_rectangle_t rects[3];
     // center
     rects[0].x = area.left();
     rects[0].y = area.top() + roundness;
     rects[0].width = area.width();
     rects[0].height = area.height() - roundness * 2;
     // top
     rects[1].x = area.left() + roundness;
     rects[1].y = area.top();
     rects[1].width = area.width() - roundness * 2;
     rects[1].height = roundness;
     // bottom
     rects[2].x = area.left() + roundness;
     rects[2].y = area.top() + area.height() - roundness;
     rects[2].width = area.width() - roundness * 2;
     rects[2].height = roundness;
     xcb_render_color_t color = {0, 0, 0, uint16_t(opacity * 0xffff)};
     xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_OVER, pict, color, 3, rects);
 
     if (!s_effectFrameCircle) {
         // create the circle
         const int diameter = roundness * 2;
         xcb_pixmap_t pix = xcb_generate_id(connection());
         xcb_create_pixmap(connection(), 32, pix, rootWindow(), diameter, diameter);
         s_effectFrameCircle = new XRenderPicture(pix, 32);
         xcb_free_pixmap(connection(), pix);
 
         // clear it with transparent
         xcb_rectangle_t xrect = {0, 0, diameter, diameter};
         xcb_render_color_t tranparent = {0, 0, 0, 0};
         xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, *s_effectFrameCircle, tranparent, 1, &xrect);
 
         static const int num_segments = 80;
         static const qreal theta = 2 * M_PI / qreal(num_segments);
         static const qreal c = qCos(theta); //precalculate the sine and cosine
         static const qreal s = qSin(theta);
         qreal t;
 
         qreal x = roundness;//we start at angle = 0
         qreal y = 0;
 
         QVector<xcb_render_pointfix_t> points;
         xcb_render_pointfix_t point;
         point.x = DOUBLE_TO_FIXED(roundness);
         point.y = DOUBLE_TO_FIXED(roundness);
         points << point;
         for (int ii = 0; ii <= num_segments; ++ii) {
             point.x = DOUBLE_TO_FIXED(x + roundness);
             point.y = DOUBLE_TO_FIXED(y + roundness);
             points << point;
             //apply the rotation matrix
             t = x;
             x = c * x - s * y;
             y = s * t + c * y;
         }
         XRenderPicture fill = xRenderFill(Qt::black);
         xcb_render_tri_fan(connection(), XCB_RENDER_PICT_OP_OVER, fill, *s_effectFrameCircle,
                         0, 0, 0, points.count(), points.constData());
     }
     // TODO: merge alpha mask with SceneXrender::Window::alphaMask
     // alpha mask
     xcb_pixmap_t pix = xcb_generate_id(connection());
     xcb_create_pixmap(connection(), 8, pix, rootWindow(), 1, 1);
     XRenderPicture alphaMask(pix, 8);
     xcb_free_pixmap(connection(), pix);
     const uint32_t values[] = {true};
     xcb_render_change_picture(connection(), alphaMask, XCB_RENDER_CP_REPEAT, values);
     color.alpha = int(opacity * 0xffff);
     xcb_rectangle_t xrect = {0, 0, 1, 1};
     xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, alphaMask, color, 1, &xrect);
 
     // TODO: replace by lambda
 #define RENDER_CIRCLE(srcX, srcY, destX, destY) \
 xcb_render_composite(connection(), XCB_RENDER_PICT_OP_OVER, *s_effectFrameCircle, alphaMask, \
                      pict, srcX, srcY, 0, 0, destX, destY, roundness, roundness)
 
     RENDER_CIRCLE(0, 0, area.left(), area.top());
     RENDER_CIRCLE(0, roundness, area.left(), area.top() + area.height() - roundness);
     RENDER_CIRCLE(roundness, 0, area.left() + area.width() - roundness, area.top());
     RENDER_CIRCLE(roundness, roundness,
                   area.left() + area.width() - roundness, area.top() + area.height() - roundness);
 #undef RENDER_CIRCLE
 }
 
 void SceneXrender::EffectFrame::updatePicture()
 {
     delete m_picture;
     m_picture = 0L;
     if (m_effectFrame->style() == EffectFrameStyled) {
         const QPixmap pix = m_effectFrame->frame().framePixmap();
         if (!pix.isNull())
             m_picture = new XRenderPicture(pix.toImage());
     }
 }
 
 void SceneXrender::EffectFrame::updateTextPicture()
 {
     // Mostly copied from SceneOpenGL::EffectFrame::updateTextTexture() above
     delete m_textPicture;
     m_textPicture = 0L;
 
     if (m_effectFrame->text().isEmpty()) {
         return;
     }
 
     // Determine position on texture to paint text
     QRect rect(QPoint(0, 0), m_effectFrame->geometry().size());
     if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
         rect.setLeft(m_effectFrame->iconSize().width());
     }
 
     // If static size elide text as required
     QString text = m_effectFrame->text();
     if (m_effectFrame->isStatic()) {
         QFontMetrics metrics(m_effectFrame->text());
         text = metrics.elidedText(text, Qt::ElideRight, rect.width());
     }
 
     QPixmap pixmap(m_effectFrame->geometry().size());
     pixmap.fill(Qt::transparent);
     QPainter p(&pixmap);
     p.setFont(m_effectFrame->font());
     if (m_effectFrame->style() == EffectFrameStyled) {
         p.setPen(m_effectFrame->styledTextColor());
     } else {
         // TODO: What about no frame? Custom color setting required
         p.setPen(Qt::white);
     }
     p.drawText(rect, m_effectFrame->alignment(), text);
     p.end();
     m_textPicture = new XRenderPicture(pixmap.toImage());
 }
 
 SceneXRenderShadow::SceneXRenderShadow(Toplevel *toplevel)
     :Shadow(toplevel)
 {
     for (int i=0; i<ShadowElementsCount; ++i) {
         m_pictures[i] = NULL;
     }
 }
 
 SceneXRenderShadow::~SceneXRenderShadow()
 {
     for (int i=0; i<ShadowElementsCount; ++i) {
         delete m_pictures[i];
     }
 }
 
 void SceneXRenderShadow::layoutShadowRects(QRect& top, QRect& topRight,
                                            QRect& right, QRect& bottomRight,
                                            QRect& bottom, QRect& bottomLeft,
                                            QRect& left, QRect& topLeft)
 {
     WindowQuadList quads = shadowQuads();
 
     if (quads.count() == 0) {
         return;
     }
 
     WindowQuad topQuad = quads.select(WindowQuadShadowTop)[0];
     WindowQuad topRightQuad = quads.select(WindowQuadShadowTopRight)[0];
     WindowQuad topLeftQuad = quads.select(WindowQuadShadowTopLeft)[0];
     WindowQuad leftQuad = quads.select(WindowQuadShadowLeft)[0];
     WindowQuad rightQuad = quads.select(WindowQuadShadowRight)[0];
     WindowQuad bottomQuad = quads.select(WindowQuadShadowBottom)[0];
     WindowQuad bottomRightQuad = quads.select(WindowQuadShadowBottomRight)[0];
     WindowQuad bottomLeftQuad = quads.select(WindowQuadShadowBottomLeft)[0];
 
     top = QRect(topQuad.left(), topQuad.top(), (topQuad.right()-topQuad.left()), (topQuad.bottom()-topQuad.top()));
     topLeft = QRect(topLeftQuad.left(), topLeftQuad.top(), (topLeftQuad.right()-topLeftQuad.left()), (topLeftQuad.bottom()-topLeftQuad.top()));
     topRight = QRect(topRightQuad.left(), topRightQuad.top(), (topRightQuad.right()-topRightQuad.left()), (topRightQuad.bottom()-topRightQuad.top()));
     left = QRect(leftQuad.left(), leftQuad.top(), (leftQuad.right()-leftQuad.left()), (leftQuad.bottom()-leftQuad.top()));
     right = QRect(rightQuad.left(), rightQuad.top(), (rightQuad.right()-rightQuad.left()), (rightQuad.bottom()-rightQuad.top()));
     bottom = QRect(bottomQuad.left(), bottomQuad.top(), (bottomQuad.right()-bottomQuad.left()), (bottomQuad.bottom()-bottomQuad.top()));
     bottomLeft = QRect(bottomLeftQuad.left(), bottomLeftQuad.top(), (bottomLeftQuad.right()-bottomLeftQuad.left()), (bottomLeftQuad.bottom()-bottomLeftQuad.top()));
     bottomRight = QRect(bottomRightQuad.left(), bottomRightQuad.top(), (bottomRightQuad.right()-bottomRightQuad.left()), (bottomRightQuad.bottom()-bottomRightQuad.top()));
 }
 
 void SceneXRenderShadow::buildQuads()
 {
     Shadow::buildQuads();
 
     if (shadowQuads().count() == 0) {
         return;
     }
 
     QRect stlr, str, strr, srr, sbrr, sbr, sblr, slr;
     layoutShadowRects(str, strr, srr, sbrr, sbr, sblr, slr, stlr);
 }
 
 bool SceneXRenderShadow::prepareBackend()
 {
     if (hasDecorationShadow()) {
         const QImage shadowImage = decorationShadowImage();
         QPainter p;
         int x = 0;
         int y = 0;
         auto drawElement = [this, &x, &y, &p, &shadowImage] (ShadowElements element) {
             QPixmap pix(elementSize(element));
             pix.fill(Qt::transparent);
             p.begin(&pix);
             p.drawImage(0, 0, shadowImage, x, y, pix.width(), pix.height());
             p.end();
             setShadowElement(pix, element);
             return pix.size();
         };
         x += drawElement(ShadowElementTopLeft).width();
         x += drawElement(ShadowElementTop).width();
         y += drawElement(ShadowElementTopRight).height();
         drawElement(ShadowElementRight);
         x = 0;
         y += drawElement(ShadowElementLeft).height();
         x += drawElement(ShadowElementBottomLeft).width();
         x += drawElement(ShadowElementBottom).width();
         drawElement(ShadowElementBottomRight).width();
     }
     const uint32_t values[] = {XCB_RENDER_REPEAT_NORMAL};
     for (int i=0; i<ShadowElementsCount; ++i) {
         delete m_pictures[i];
         m_pictures[i] = new XRenderPicture(shadowPixmap(ShadowElements(i)).toImage());
         xcb_render_change_picture(connection(), *m_pictures[i], XCB_RENDER_CP_REPEAT, values);
     }
     return true;
 }
 
 xcb_render_picture_t SceneXRenderShadow::picture(Shadow::ShadowElements element) const
 {
     if (!m_pictures[element]) {
         return XCB_RENDER_PICTURE_NONE;
     }
     return *m_pictures[element];
 }
 
 SceneXRenderDecorationRenderer::SceneXRenderDecorationRenderer(Decoration::DecoratedClientImpl *client)
     : Renderer(client)
     , m_gc(XCB_NONE)
 {
     connect(this, &Renderer::renderScheduled, client->client(), static_cast<void (AbstractClient::*)(const QRect&)>(&AbstractClient::addRepaint));
     for (int i = 0; i < int(DecorationPart::Count); ++i) {
         m_pixmaps[i] = XCB_PIXMAP_NONE;
         m_pictures[i] = nullptr;
     }
 }
 
 SceneXRenderDecorationRenderer::~SceneXRenderDecorationRenderer()
 {
     for (int i = 0; i < int(DecorationPart::Count); ++i) {
         if (m_pixmaps[i] != XCB_PIXMAP_NONE) {
             xcb_free_pixmap(connection(), m_pixmaps[i]);
         }
         delete m_pictures[i];
     }
     if (m_gc != 0) {
         xcb_free_gc(connection(), m_gc);
     }
 }
 
 void SceneXRenderDecorationRenderer::render()
 {
     QRegion scheduled = getScheduled();
     if (scheduled.isEmpty()) {
         return;
     }
     if (areImageSizesDirty()) {
         resizePixmaps();
         resetImageSizesDirty();
         scheduled = client()->client()->decorationRect();
     }
 
     const QRect top(QPoint(0, 0), m_sizes[int(DecorationPart::Top)]);
     const QRect left(QPoint(0, top.height()), m_sizes[int(DecorationPart::Left)]);
     const QRect right(QPoint(top.width() - m_sizes[int(DecorationPart::Right)].width(), top.height()), m_sizes[int(DecorationPart::Right)]);
     const QRect bottom(QPoint(0, left.y() + left.height()), m_sizes[int(DecorationPart::Bottom)]);
 
     xcb_connection_t *c = connection();
     if (m_gc == 0) {
         m_gc = xcb_generate_id(connection());
         xcb_create_gc(c, m_gc, m_pixmaps[int(DecorationPart::Top)], 0, nullptr);
     }
     auto renderPart = [this, c](const QRect &geo, const QPoint &offset, int index) {
         if (geo.isNull()) {
             return;
         }
         QImage image = renderToImage(geo);
         xcb_put_image(c, XCB_IMAGE_FORMAT_Z_PIXMAP, m_pixmaps[index], m_gc,
                       image.width(), image.height(), geo.x() - offset.x(), geo.y() - offset.y(), 0, 32,
                       image.byteCount(), image.constBits());
     };
     const QRect geometry = scheduled.boundingRect();
     renderPart(left.intersected(geometry),   left.topLeft(),   int(DecorationPart::Left));
     renderPart(top.intersected(geometry),    top.topLeft(),    int(DecorationPart::Top));
     renderPart(right.intersected(geometry),  right.topLeft(),  int(DecorationPart::Right));
     renderPart(bottom.intersected(geometry), bottom.topLeft(), int(DecorationPart::Bottom));
     xcb_flush(c);
 }
 
 void SceneXRenderDecorationRenderer::resizePixmaps()
 {
     QRect left, top, right, bottom;
     client()->client()->layoutDecorationRects(left, top, right, bottom);
 
     xcb_connection_t *c = connection();
     auto checkAndCreate = [this, c](int border, const QRect &rect) {
         const QSize size = rect.size();
         if (m_sizes[border] != size) {
             m_sizes[border] = size;
             if (m_pixmaps[border] != XCB_PIXMAP_NONE) {
                 xcb_free_pixmap(c, m_pixmaps[border]);
             }
             delete m_pictures[border];
             if (!size.isEmpty()) {
                 m_pixmaps[border] = xcb_generate_id(connection());
                 xcb_create_pixmap(connection(), 32, m_pixmaps[border], rootWindow(), size.width(), size.height());
                 m_pictures[border] = new XRenderPicture(m_pixmaps[border], 32);
             } else {
                 m_pixmaps[border] = XCB_PIXMAP_NONE;
                 m_pictures[border] = nullptr;
             }
         }
         if (!m_pictures[border]) {
             return;
         }
         // fill transparent
         xcb_rectangle_t r = {0, 0, uint16_t(size.width()), uint16_t(size.height())};
         xcb_render_fill_rectangles(connection(), XCB_RENDER_PICT_OP_SRC, *m_pictures[border], preMultiply(Qt::transparent), 1, &r);
     };
 
     checkAndCreate(int(DecorationPart::Left), left);
     checkAndCreate(int(DecorationPart::Top), top);
     checkAndCreate(int(DecorationPart::Right), right);
     checkAndCreate(int(DecorationPart::Bottom), bottom);
 }
 
 xcb_render_picture_t SceneXRenderDecorationRenderer::picture(SceneXRenderDecorationRenderer::DecorationPart part) const
 {
     Q_ASSERT(part != DecorationPart::Count);
     XRenderPicture *picture = m_pictures[int(part)];
     if (!picture) {
         return XCB_RENDER_PICTURE_NONE;
     }
     return *picture;
 }
 
 void SceneXRenderDecorationRenderer::reparent(Deleted *deleted)
 {
     render();
     Renderer::reparent(deleted);
 }
 
 #undef DOUBLE_TO_FIXED
 #undef FIXED_TO_DOUBLE
 
+XRenderFactory::XRenderFactory(QObject *parent)
+    : SceneFactory(parent)
+{
+}
+
+XRenderFactory::~XRenderFactory() = default;
+
+Scene *XRenderFactory::create(QObject *parent) const
+{
+    auto s = SceneXrender::createScene(parent);
+    if (s && s->initFailed()) {
+        delete s;
+        s = nullptr;
+    }
+    return s;
+}
+
 } // namespace
 #endif
 
 
 void KWin::SceneXrender::paintCursor()
 {
 
 }
diff --git a/scene_xrender.h b/plugins/scenes/xrender/scene_xrender.h
similarity index 96%
rename from scene_xrender.h
rename to plugins/scenes/xrender/scene_xrender.h
index d4dacd361..04bc66cae 100644
--- a/scene_xrender.h
+++ b/plugins/scenes/xrender/scene_xrender.h
@@ -1,348 +1,361 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_SCENE_XRENDER_H
 #define KWIN_SCENE_XRENDER_H
 
 #include "scene.h"
 #include "shadow.h"
 #include "decorations/decorationrenderer.h"
 
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 
 namespace KWin
 {
 
 namespace Xcb
 {
     class Shm;
 }
 
 /**
  * @brief Backend for the SceneXRender to hold the compositing buffer and take care of buffer
  * swapping.
  *
  * This class is intended as a small abstraction to support multiple compositing backends in the
  * SceneXRender.
  *
  */
 class XRenderBackend
 {
 public:
     virtual ~XRenderBackend();
     virtual void present(int mask, const QRegion &damage) = 0;
 
     /**
      * @brief Returns the OverlayWindow used by the backend.
      *
      * A backend does not have to use an OverlayWindow, this is mostly for the X world.
      * In case the backend does not use an OverlayWindow it is allowed to return @c null.
      * It's the task of the caller to check whether it is @c null.
      *
      * @return :OverlayWindow*
      **/
     virtual OverlayWindow *overlayWindow();
     virtual bool usesOverlayWindow() const = 0;
     /**
      * @brief Shows the Overlay Window
      *
      * Default implementation does nothing.
      */
     virtual void showOverlay();
     /**
      * @brief React on screen geometry changes.
      *
      * Default implementation does nothing. Override if specific functionality is required.
      *
      * @param size The new screen size
      */
     virtual void screenGeometryChanged(const QSize &size);
     /**
      * @brief The compositing buffer hold by this backend.
      *
      * The Scene composites the new frame into this buffer.
      *
      * @return xcb_render_picture_t
      */
     xcb_render_picture_t buffer() const {
         return m_buffer;
     }
     /**
      * @brief Whether the creation of the Backend failed.
      *
      * The SceneXRender should test whether the Backend got constructed correctly. If this method
      * returns @c true, the SceneXRender should not try to start the rendering.
      *
      * @return bool @c true if the creation of the Backend failed, @c false otherwise.
      **/
     bool isFailed() const {
         return m_failed;
     }
 
 protected:
     XRenderBackend();
     /**
      * @brief A subclass needs to call this method once it created the compositing back buffer.
      *
      * @param buffer The buffer to use for compositing
      * @return void
      */
     void setBuffer(xcb_render_picture_t buffer);
     /**
      * @brief Sets the backend initialization to failed.
      *
      * This method should be called by the concrete subclass in case the initialization failed.
      * The given @p reason is logged as a warning.
      *
      * @param reason The reason why the initialization failed.
      **/
     void setFailed(const QString &reason);
 
 private:
     // Create the compositing buffer. The root window is not double-buffered,
     // so it is done manually using this buffer,
     xcb_render_picture_t m_buffer;
     bool m_failed;
 };
 
 /**
  * @brief XRenderBackend using an X11 Overlay Window as compositing target.
  *
  */
 class X11XRenderBackend : public XRenderBackend
 {
 public:
     X11XRenderBackend();
     ~X11XRenderBackend();
 
     virtual void present(int mask, const QRegion &damage);
     virtual OverlayWindow* overlayWindow();
     virtual void showOverlay();
     virtual void screenGeometryChanged(const QSize &size);
     virtual bool usesOverlayWindow() const;
 private:
     void init(bool createOverlay);
     void createBuffer();
     QScopedPointer<OverlayWindow> m_overlayWindow;
     xcb_render_picture_t m_front;
     xcb_render_pictformat_t m_format;
 };
 
 class SceneXrender
     : public Scene
 {
     Q_OBJECT
 public:
     class EffectFrame;
     virtual ~SceneXrender();
     virtual bool initFailed() const;
     virtual CompositingType compositingType() const {
         return XRenderCompositing;
     }
     virtual qint64 paint(QRegion damage, ToplevelList windows);
     virtual Scene::EffectFrame *createEffectFrame(EffectFrameImpl *frame);
     virtual Shadow *createShadow(Toplevel *toplevel);
     virtual void screenGeometryChanged(const QSize &size);
     xcb_render_picture_t xrenderBufferPicture() const override;
     virtual OverlayWindow *overlayWindow() {
         return m_backend->overlayWindow();
     }
     virtual bool usesOverlayWindow() const {
         return m_backend->usesOverlayWindow();
     }
     Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *client);
 
     bool animationsSupported() const override {
         return true;
     }
 
     static SceneXrender *createScene(QObject *parent);
 protected:
     virtual Scene::Window *createWindow(Toplevel *toplevel);
     virtual void paintBackground(QRegion region);
     virtual void paintGenericScreen(int mask, ScreenPaintData data);
     virtual void paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data);
     void paintCursor() override;
 private:
     explicit SceneXrender(XRenderBackend *backend, QObject *parent = nullptr);
     static ScreenPaintData screen_paint;
     class Window;
     QScopedPointer<XRenderBackend> m_backend;
 };
 
 class SceneXrender::Window
     : public Scene::Window
 {
 public:
     Window(Toplevel* c, SceneXrender *scene);
     virtual ~Window();
     virtual void performPaint(int mask, QRegion region, WindowPaintData data);
     QRegion transformedShape() const;
     void setTransformedShape(const QRegion& shape);
     static void cleanup();
 protected:
     virtual WindowPixmap* createWindowPixmap();
 private:
     QRect mapToScreen(int mask, const WindowPaintData &data, const QRect &rect) const;
     QPoint mapToScreen(int mask, const WindowPaintData &data, const QPoint &point) const;
     void prepareTempPixmap();
     void setPictureFilter(xcb_render_picture_t pic, ImageFilterType filter);
     SceneXrender *m_scene;
     xcb_render_pictformat_t format;
     QRegion transformed_shape;
     static QRect temp_visibleRect;
     static XRenderPicture *s_tempPicture;
     static XRenderPicture *s_fadeAlphaPicture;
 };
 
 class XRenderWindowPixmap : public WindowPixmap
 {
 public:
     explicit XRenderWindowPixmap(Scene::Window *window, xcb_render_pictformat_t format);
     virtual ~XRenderWindowPixmap();
     xcb_render_picture_t picture() const;
     virtual void create();
 private:
     xcb_render_picture_t m_picture;
     xcb_render_pictformat_t m_format;
 };
 
 class SceneXrender::EffectFrame
     : public Scene::EffectFrame
 {
 public:
     EffectFrame(EffectFrameImpl* frame);
     virtual ~EffectFrame();
 
     virtual void free();
     virtual void freeIconFrame();
     virtual void freeTextFrame();
     virtual void freeSelection();
     virtual void crossFadeIcon();
     virtual void crossFadeText();
     virtual void render(QRegion region, double opacity, double frameOpacity);
     static void cleanup();
 
 private:
     void updatePicture();
     void updateTextPicture();
     void renderUnstyled(xcb_render_picture_t pict, const QRect &rect, qreal opacity);
 
     XRenderPicture* m_picture;
     XRenderPicture* m_textPicture;
     XRenderPicture* m_iconPicture;
     XRenderPicture* m_selectionPicture;
     static XRenderPicture* s_effectFrameCircle;
 };
 
 inline
 xcb_render_picture_t SceneXrender::xrenderBufferPicture() const
 {
     return m_backend->buffer();
 }
 
 inline
 QRegion SceneXrender::Window::transformedShape() const
 {
     return transformed_shape;
 }
 
 inline
 void SceneXrender::Window::setTransformedShape(const QRegion& shape)
 {
     transformed_shape = shape;
 }
 
 inline
 xcb_render_picture_t XRenderWindowPixmap::picture() const
 {
     return m_picture;
 }
 
 /**
  * @short XRender implementation of Shadow.
  *
  * This class extends Shadow by the elements required for XRender rendering.
  * @author Jacopo De Simoi <wilderkde@gmail.org>
  **/
 
 class SceneXRenderShadow
     : public Shadow
 {
 public:
     explicit SceneXRenderShadow(Toplevel *toplevel);
     using Shadow::ShadowElements;
     using Shadow::ShadowElementTop;
     using Shadow::ShadowElementTopRight;
     using Shadow::ShadowElementRight;
     using Shadow::ShadowElementBottomRight;
     using Shadow::ShadowElementBottom;
     using Shadow::ShadowElementBottomLeft;
     using Shadow::ShadowElementLeft;
     using Shadow::ShadowElementTopLeft;
     using Shadow::ShadowElementsCount;
     using Shadow::shadowPixmap;
     virtual ~SceneXRenderShadow();
 
     void layoutShadowRects(QRect& top, QRect& topRight,
                            QRect& right, QRect& bottomRight,
                            QRect& bottom, QRect& bottomLeft,
                            QRect& Left, QRect& topLeft);
     xcb_render_picture_t picture(ShadowElements element) const;
 
 protected:
     virtual void buildQuads();
     virtual bool prepareBackend();
 private:
     XRenderPicture* m_pictures[ShadowElementsCount];
 };
 
 class SceneXRenderDecorationRenderer : public Decoration::Renderer
 {
     Q_OBJECT
 public:
     enum class DecorationPart : int {
         Left,
         Top,
         Right,
         Bottom,
         Count
     };
     explicit SceneXRenderDecorationRenderer(Decoration::DecoratedClientImpl *client);
     virtual ~SceneXRenderDecorationRenderer();
 
     void render() override;
     void reparent(Deleted *deleted) override;
 
     xcb_render_picture_t picture(DecorationPart part) const;
 
 private:
     void resizePixmaps();
     QSize m_sizes[int(DecorationPart::Count)];
     xcb_pixmap_t m_pixmaps[int(DecorationPart::Count)];
     xcb_gcontext_t m_gc;
     XRenderPicture* m_pictures[int(DecorationPart::Count)];
 };
 
+class KWIN_EXPORT XRenderFactory : public SceneFactory
+{
+    Q_OBJECT
+    Q_INTERFACES(KWin::SceneFactory)
+    Q_PLUGIN_METADATA(IID "org.kde.kwin.Scene" FILE "xrender.json")
+
+public:
+    explicit XRenderFactory(QObject *parent = nullptr);
+    ~XRenderFactory() override;
+
+    Scene *create(QObject *parent = nullptr) const override;
+};
+
 } // namespace
 
 #endif
 
 #endif
diff --git a/plugins/scenes/xrender/xrender.json b/plugins/scenes/xrender/xrender.json
new file mode 100644
index 000000000..d2af878b9
--- /dev/null
+++ b/plugins/scenes/xrender/xrender.json
@@ -0,0 +1,8 @@
+{
+    "KPlugin": {
+        "Description": "KWin Compositor plugin rendering through XRender",
+        "Id": "KWinSceneXRender",
+        "Name": "SceneXRender"
+    },
+    "CompositingType": 2
+}
diff --git a/scene.cpp b/scene.cpp
index a51bbe9be..bf5b7778d 100644
--- a/scene.cpp
+++ b/scene.cpp
@@ -1,1127 +1,1136 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 /*
  The base class for compositing, implementing shared functionality
  between the OpenGL and XRender backends.
 
  Design:
 
  When compositing is turned on, XComposite extension is used to redirect
  drawing of windows to pixmaps and XDamage extension is used to get informed
  about damage (changes) to window contents. This code is mostly in composite.cpp .
 
  Compositor::performCompositing() starts one painting pass. Painting is done
  by painting the screen, which in turn paints every window. Painting can be affected
  using effects, which are chained. E.g. painting a screen means that actually
  paintScreen() of the first effect is called, which possibly does modifications
  and calls next effect's paintScreen() and so on, until Scene::finalPaintScreen()
  is called.
 
  There are 3 phases of every paint (not necessarily done together):
  The pre-paint phase, the paint phase and the post-paint phase.
 
  The pre-paint phase is used to find out about how the painting will be actually
  done (i.e. what the effects will do). For example when only a part of the screen
  needs to be updated and no effect will do any transformation it is possible to use
  an optimized paint function. How the painting will be done is controlled
  by the mask argument, see PAINT_WINDOW_* and PAINT_SCREEN_* flags in scene.h .
  For example an effect that decides to paint a normal windows as translucent
  will need to modify the mask in its prePaintWindow() to include
  the PAINT_WINDOW_TRANSLUCENT flag. The paintWindow() function will then get
  the mask with this flag turned on and will also paint using transparency.
 
  The paint pass does the actual painting, based on the information collected
  using the pre-paint pass. After running through the effects' paintScreen()
  either paintGenericScreen() or optimized paintSimpleScreen() are called.
  Those call paintWindow() on windows (not necessarily all), possibly using
  clipping to optimize performance and calling paintWindow() first with only
  PAINT_WINDOW_OPAQUE to paint the opaque parts and then later
  with PAINT_WINDOW_TRANSLUCENT to paint the transparent parts. Function
  paintWindow() again goes through effects' paintWindow() until
  finalPaintWindow() is called, which calls the window's performPaint() to
  do the actual painting.
 
  The post-paint can be used for cleanups and is also used for scheduling
  repaints during the next painting pass for animations. Effects wanting to
  repaint certain parts can manually damage them during post-paint and repaint
  of these parts will be done during the next paint pass.
 
 */
 
 #include "scene.h"
 
 #include <QQuickWindow>
 #include <QVector2D>
 
 #include "client.h"
 #include "deleted.h"
 #include "effects.h"
 #include "overlaywindow.h"
 #include "screens.h"
 #include "shadow.h"
 #include "wayland_server.h"
 
 #include "thumbnailitem.h"
 
 #include <KWayland/Server/buffer_interface.h>
 #include <KWayland/Server/subcompositor_interface.h>
 #include <KWayland/Server/surface_interface.h>
 
 namespace KWin
 {
 
 //****************************************
 // Scene
 //****************************************
 
 Scene::Scene(QObject *parent)
     : QObject(parent)
 {
     last_time.invalidate(); // Initialize the timer
 }
 
 Scene::~Scene()
 {
     foreach (Window *w, m_windows) {
         delete w;
     }
 }
 
 // returns mask and possibly modified region
 void Scene::paintScreen(int* mask, const QRegion &damage, const QRegion &repaint,
                         QRegion *updateRegion, QRegion *validRegion, const QMatrix4x4 &projection, const QRect &outputGeometry)
 {
     const QSize &screenSize = screens()->size();
     const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
     *mask = (damage == displayRegion) ? 0 : PAINT_SCREEN_REGION;
 
     updateTimeDiff();
     // preparation step
     static_cast<EffectsHandlerImpl*>(effects)->startPaint();
 
     QRegion region = damage;
 
     ScreenPrePaintData pdata;
     pdata.mask = *mask;
     pdata.paint = region;
 
     effects->prePaintScreen(pdata, time_diff);
     *mask = pdata.mask;
     region = pdata.paint;
 
     if (*mask & (PAINT_SCREEN_TRANSFORMED | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS)) {
         // Region painting is not possible with transformations,
         // because screen damage doesn't match transformed positions.
         *mask &= ~PAINT_SCREEN_REGION;
         region = infiniteRegion();
     } else if (*mask & PAINT_SCREEN_REGION) {
         // make sure not to go outside visible screen
         region &= displayRegion;
     } else {
         // whole screen, not transformed, force region to be full
         region = displayRegion;
     }
 
     painted_region = region;
     repaint_region = repaint;
 
     if (*mask & PAINT_SCREEN_BACKGROUND_FIRST) {
         paintBackground(region);
     }
 
     ScreenPaintData data(projection, outputGeometry);
     effects->paintScreen(*mask, region, data);
 
     foreach (Window *w, stacking_order) {
         effects->postPaintWindow(effectWindow(w));
     }
 
     effects->postPaintScreen();
 
     // make sure not to go outside of the screen area
     *updateRegion = damaged_region;
     *validRegion = (region | painted_region) & displayRegion;
 
     repaint_region = QRegion();
     damaged_region = QRegion();
 
     // make sure all clipping is restored
     Q_ASSERT(!PaintClipper::clip());
 }
 
 // Compute time since the last painting pass.
 void Scene::updateTimeDiff()
 {
     if (!last_time.isValid()) {
         // Painting has been idle (optimized out) for some time,
         // which means time_diff would be huge and would break animations.
         // Simply set it to one (zero would mean no change at all and could
         // cause problems).
         time_diff = 1;
         last_time.start();
     } else
 
     time_diff = last_time.restart();
 
     if (time_diff < 0)   // check time rollback
         time_diff = 1;
 }
 
 // Painting pass is optimized away.
 void Scene::idle()
 {
     // Don't break time since last paint for the next pass.
     last_time.invalidate();
 }
 
 // the function that'll be eventually called by paintScreen() above
 void Scene::finalPaintScreen(int mask, QRegion region, ScreenPaintData& data)
 {
     if (mask & (PAINT_SCREEN_TRANSFORMED | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS))
         paintGenericScreen(mask, data);
     else
         paintSimpleScreen(mask, region);
 }
 
 // The generic painting code that can handle even transformations.
 // It simply paints bottom-to-top.
 void Scene::paintGenericScreen(int orig_mask, ScreenPaintData)
 {
     if (!(orig_mask & PAINT_SCREEN_BACKGROUND_FIRST)) {
         paintBackground(infiniteRegion());
     }
     QList< Phase2Data > phase2;
     foreach (Window * w, stacking_order) { // bottom to top
         Toplevel* topw = w->window();
 
         // Reset the repaint_region.
         // This has to be done here because many effects schedule a repaint for
         // the next frame within Effects::prePaintWindow.
         topw->resetRepaints();
 
         WindowPrePaintData data;
         data.mask = orig_mask | (w->isOpaque() ? PAINT_WINDOW_OPAQUE : PAINT_WINDOW_TRANSLUCENT);
         w->resetPaintingEnabled();
         data.paint = infiniteRegion(); // no clipping, so doesn't really matter
         data.clip = QRegion();
         data.quads = w->buildQuads();
         // preparation step
         effects->prePaintWindow(effectWindow(w), data, time_diff);
 #ifndef NDEBUG
         if (data.quads.isTransformed()) {
             qFatal("Pre-paint calls are not allowed to transform quads!");
         }
 #endif
         if (!w->isPaintingEnabled()) {
             continue;
         }
         phase2.append(Phase2Data(w, infiniteRegion(), data.clip, data.mask, data.quads));
     }
 
     foreach (const Phase2Data & d, phase2) {
         paintWindow(d.window, d.mask, d.region, d.quads);
     }
 
     const QSize &screenSize = screens()->size();
     damaged_region = QRegion(0, 0, screenSize.width(), screenSize.height());
 }
 
 // The optimized case without any transformations at all.
 // It can paint only the requested region and can use clipping
 // to reduce painting and improve performance.
 void Scene::paintSimpleScreen(int orig_mask, QRegion region)
 {
     assert((orig_mask & (PAINT_SCREEN_TRANSFORMED
                          | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS)) == 0);
     QList< QPair< Window*, Phase2Data > > phase2data;
 
     QRegion dirtyArea = region;
     bool opaqueFullscreen(false);
     for (int i = 0;  // do prePaintWindow bottom to top
             i < stacking_order.count();
             ++i) {
         Window* w = stacking_order[ i ];
         Toplevel* topw = w->window();
         WindowPrePaintData data;
         data.mask = orig_mask | (w->isOpaque() ? PAINT_WINDOW_OPAQUE : PAINT_WINDOW_TRANSLUCENT);
         w->resetPaintingEnabled();
         data.paint = region;
         data.paint |= topw->repaints();
 
         // Reset the repaint_region.
         // This has to be done here because many effects schedule a repaint for
         // the next frame within Effects::prePaintWindow.
         topw->resetRepaints();
 
         // Clip out the decoration for opaque windows; the decoration is drawn in the second pass
         opaqueFullscreen = false; // TODO: do we care about unmanged windows here (maybe input windows?)
         if (w->isOpaque()) {
             AbstractClient *c = dynamic_cast<AbstractClient*>(topw);
             if (c) {
                 opaqueFullscreen = c->isFullScreen();
             }
             Client *cc = dynamic_cast<Client*>(c);
             // the window is fully opaque
             if (cc && cc->decorationHasAlpha()) {
                 // decoration uses alpha channel, so we may not exclude it in clipping
                 data.clip = w->clientShape().translated(w->x(), w->y());
             } else {
                 // decoration is fully opaque
                 if (c && c->isShade()) {
                     data.clip = QRegion();
                 } else {
                     data.clip = w->shape().translated(w->x(), w->y());
                 }
             }
         } else if (topw->hasAlpha() && topw->opacity() == 1.0) {
             // the window is partially opaque
             data.clip = (w->clientShape() & topw->opaqueRegion().translated(topw->clientPos())).translated(w->x(), w->y());
         } else {
             data.clip = QRegion();
         }
         data.quads = w->buildQuads();
         // preparation step
         effects->prePaintWindow(effectWindow(w), data, time_diff);
 #ifndef NDEBUG
         if (data.quads.isTransformed()) {
             qFatal("Pre-paint calls are not allowed to transform quads!");
         }
 #endif
         if (!w->isPaintingEnabled()) {
             continue;
         }
         dirtyArea |= data.paint;
         // Schedule the window for painting
         phase2data.append(QPair< Window*, Phase2Data >(w,Phase2Data(w, data.paint, data.clip,
                                                                     data.mask, data.quads)));
     }
 
     // Save the part of the repaint region that's exclusively rendered to
     // bring a reused back buffer up to date. Then union the dirty region
     // with the repaint region.
     const QRegion repaintClip = repaint_region - dirtyArea;
     dirtyArea |= repaint_region;
 
     const QSize &screenSize = screens()->size();
     const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
     bool fullRepaint(dirtyArea == displayRegion); // spare some expensive region operations
     if (!fullRepaint) {
         extendPaintRegion(dirtyArea, opaqueFullscreen);
         fullRepaint = (dirtyArea == displayRegion);
     }
 
     QRegion allclips, upperTranslucentDamage;
     upperTranslucentDamage = repaint_region;
 
     // This is the occlusion culling pass
     for (int i = phase2data.count() - 1; i >= 0; --i) {
         QPair< Window*, Phase2Data > *entry = &phase2data[i];
         Phase2Data *data = &entry->second;
 
         if (fullRepaint)
             data->region = displayRegion;
         else
             data->region |= upperTranslucentDamage;
 
         // subtract the parts which will possibly been drawn as part of
         // a higher opaque window
         data->region -= allclips;
 
         // Here we rely on WindowPrePaintData::setTranslucent() to remove
         // the clip if needed.
         if (!data->clip.isEmpty() && !(data->mask & PAINT_WINDOW_TRANSFORMED)) {
             // clip away the opaque regions for all windows below this one
             allclips |= data->clip;
             // extend the translucent damage for windows below this by remaining (translucent) regions
             if (!fullRepaint)
                 upperTranslucentDamage |= data->region - data->clip;
         } else if (!fullRepaint) {
             upperTranslucentDamage |= data->region;
         }
     }
 
     QRegion paintedArea;
     // Fill any areas of the root window not covered by opaque windows
     if (!(orig_mask & PAINT_SCREEN_BACKGROUND_FIRST)) {
         paintedArea = dirtyArea - allclips;
         paintBackground(paintedArea);
     }
 
     // Now walk the list bottom to top and draw the windows.
     for (int i = 0; i < phase2data.count(); ++i) {
         Phase2Data *data = &phase2data[i].second;
 
         // add all regions which have been drawn so far
         paintedArea |= data->region;
         data->region = paintedArea;
 
         paintWindow(data->window, data->mask, data->region, data->quads);
     }
 
     if (fullRepaint) {
         painted_region = displayRegion;
         damaged_region = displayRegion;
     } else {
         painted_region |= paintedArea;
 
         // Clip the repainted region from the damaged region.
         // It's important that we don't add the union of the damaged region
         // and the repainted region to the damage history. Otherwise the
         // repaint region will grow with every frame until it eventually
         // covers the whole back buffer, at which point we're always doing
         // full repaints.
         damaged_region = paintedArea - repaintClip;
     }
 }
 
 void Scene::windowAdded(Toplevel *c)
 {
     assert(!m_windows.contains(c));
     Scene::Window *w = createWindow(c);
     m_windows[ c ] = w;
     connect(c, SIGNAL(geometryShapeChanged(KWin::Toplevel*,QRect)), SLOT(windowGeometryShapeChanged(KWin::Toplevel*)));
     connect(c, SIGNAL(windowClosed(KWin::Toplevel*,KWin::Deleted*)), SLOT(windowClosed(KWin::Toplevel*,KWin::Deleted*)));
     //A change of scale won't affect the geometry in compositor co-ordinates, but will affect the window quads.
     if (c->surface()) {
         connect(c->surface(), &KWayland::Server::SurfaceInterface::scaleChanged, this, std::bind(&Scene::windowGeometryShapeChanged, this, c));
     }
     c->effectWindow()->setSceneWindow(w);
     c->getShadow();
     w->updateShadow(c->shadow());
 }
 
 void Scene::windowClosed(Toplevel *c, Deleted *deleted)
 {
     assert(m_windows.contains(c));
     if (deleted != NULL) {
         // replace c with deleted
         Window* w = m_windows.take(c);
         w->updateToplevel(deleted);
         if (w->shadow()) {
             w->shadow()->setToplevel(deleted);
         }
         m_windows[ deleted ] = w;
     } else {
         delete m_windows.take(c);
         c->effectWindow()->setSceneWindow(NULL);
     }
 }
 
 void Scene::windowDeleted(Deleted *c)
 {
     assert(m_windows.contains(c));
     delete m_windows.take(c);
     c->effectWindow()->setSceneWindow(NULL);
 }
 
 void Scene::windowGeometryShapeChanged(Toplevel *c)
 {
     if (!m_windows.contains(c))    // this is ok, shape is not valid by default
         return;
     Window *w = m_windows[ c ];
     w->discardShape();
 }
 
 void Scene::createStackingOrder(ToplevelList toplevels)
 {
     // TODO: cache the stacking_order in case it has not changed
     foreach (Toplevel *c, toplevels) {
         assert(m_windows.contains(c));
         stacking_order.append(m_windows[ c ]);
     }
 }
 
 void Scene::clearStackingOrder()
 {
     stacking_order.clear();
 }
 
 static Scene::Window *s_recursionCheck = NULL;
 
 void Scene::paintWindow(Window* w, int mask, QRegion region, WindowQuadList quads)
 {
     // no painting outside visible screen (and no transformations)
     const QSize &screenSize = screens()->size();
     region &= QRect(0, 0, screenSize.width(), screenSize.height());
     if (region.isEmpty())  // completely clipped
         return;
     if (w->window()->isDeleted() && w->window()->skipsCloseAnimation()) {
         // should not get painted
         return;
     }
 
     if (s_recursionCheck == w) {
         return;
     }
 
     WindowPaintData data(w->window()->effectWindow(), screenProjectionMatrix());
     data.quads = quads;
     effects->paintWindow(effectWindow(w), mask, region, data);
     // paint thumbnails on top of window
     paintWindowThumbnails(w, region, data.opacity(), data.brightness(), data.saturation());
     // and desktop thumbnails
     paintDesktopThumbnails(w);
 }
 
 static void adjustClipRegion(AbstractThumbnailItem *item, QRegion &clippingRegion)
 {
     if (item->clip() && item->clipTo()) {
         // the x/y positions of the parent item are not correct. The margins are added, though the size seems fine
         // that's why we have to get the offset by inspecting the anchors properties
         QQuickItem *parentItem = item->clipTo();
         QPointF offset;
         QVariant anchors = parentItem->property("anchors");
         if (anchors.isValid()) {
             if (QObject *anchorsObject = anchors.value<QObject*>()) {
                 offset.setX(anchorsObject->property("leftMargin").toReal());
                 offset.setY(anchorsObject->property("topMargin").toReal());
             }
         }
         QRectF rect = QRectF(parentItem->position() - offset, QSizeF(parentItem->width(), parentItem->height()));
         if (QQuickItem *p = parentItem->parentItem()) {
             rect = p->mapRectToScene(rect);
         }
         clippingRegion &= rect.adjusted(0,0,-1,-1).translated(item->window()->position()).toRect();
     }
 }
 
 void Scene::paintWindowThumbnails(Scene::Window *w, QRegion region, qreal opacity, qreal brightness, qreal saturation)
 {
     EffectWindowImpl *wImpl = static_cast<EffectWindowImpl*>(effectWindow(w));
     for (QHash<WindowThumbnailItem*, QWeakPointer<EffectWindowImpl> >::const_iterator it = wImpl->thumbnails().constBegin();
             it != wImpl->thumbnails().constEnd();
             ++it) {
         if (it.value().isNull()) {
             continue;
         }
         WindowThumbnailItem *item = it.key();
         if (!item->isVisible()) {
             continue;
         }
         EffectWindowImpl *thumb = it.value().data();
         WindowPaintData thumbData(thumb, screenProjectionMatrix());
         thumbData.setOpacity(opacity);
         thumbData.setBrightness(brightness * item->brightness());
         thumbData.setSaturation(saturation * item->saturation());
 
         const QRect visualThumbRect(thumb->expandedGeometry());
 
         QSizeF size = QSizeF(visualThumbRect.size());
         size.scale(QSizeF(item->width(), item->height()), Qt::KeepAspectRatio);
         if (size.width() > visualThumbRect.width() || size.height() > visualThumbRect.height()) {
             size = QSizeF(visualThumbRect.size());
         }
         thumbData.setXScale(size.width() / static_cast<qreal>(visualThumbRect.width()));
         thumbData.setYScale(size.height() / static_cast<qreal>(visualThumbRect.height()));
 
         if (!item->window()) {
             continue;
         }
         const QPointF point = item->mapToScene(item->position());
         qreal x = point.x() + w->x() + (item->width() - size.width())/2;
         qreal y = point.y() + w->y() + (item->height() - size.height()) / 2;
         x -= thumb->x();
         y -= thumb->y();
         // compensate shadow topleft padding
         x += (thumb->x()-visualThumbRect.x())*thumbData.xScale();
         y += (thumb->y()-visualThumbRect.y())*thumbData.yScale();
         thumbData.setXTranslation(x);
         thumbData.setYTranslation(y);
         int thumbMask = PAINT_WINDOW_TRANSFORMED | PAINT_WINDOW_LANCZOS;
         if (thumbData.opacity() == 1.0) {
             thumbMask |= PAINT_WINDOW_OPAQUE;
         } else {
             thumbMask |= PAINT_WINDOW_TRANSLUCENT;
         }
         QRegion clippingRegion = region;
         clippingRegion &= QRegion(wImpl->x(), wImpl->y(), wImpl->width(), wImpl->height());
         adjustClipRegion(item, clippingRegion);
         effects->drawWindow(thumb, thumbMask, clippingRegion, thumbData);
     }
 }
 
 void Scene::paintDesktopThumbnails(Scene::Window *w)
 {
     EffectWindowImpl *wImpl = static_cast<EffectWindowImpl*>(effectWindow(w));
     for (QList<DesktopThumbnailItem*>::const_iterator it = wImpl->desktopThumbnails().constBegin();
             it != wImpl->desktopThumbnails().constEnd();
             ++it) {
         DesktopThumbnailItem *item = *it;
         if (!item->isVisible()) {
             continue;
         }
         if (!item->window()) {
             continue;
         }
         s_recursionCheck = w;
 
         ScreenPaintData data;
         const QSize &screenSize = screens()->size();
         QSize size = screenSize;
 
         size.scale(item->width(), item->height(), Qt::KeepAspectRatio);
         data *= QVector2D(size.width() / double(screenSize.width()),
                           size.height() / double(screenSize.height()));
         const QPointF point = item->mapToScene(item->position());
         const qreal x = point.x() + w->x() + (item->width() - size.width())/2;
         const qreal y = point.y() + w->y() + (item->height() - size.height()) / 2;
         const QRect region = QRect(x, y, item->width(), item->height());
         QRegion clippingRegion = region;
         clippingRegion &= QRegion(wImpl->x(), wImpl->y(), wImpl->width(), wImpl->height());
         adjustClipRegion(item, clippingRegion);
         data += QPointF(x, y);
         const int desktopMask = PAINT_SCREEN_TRANSFORMED | PAINT_WINDOW_TRANSFORMED | PAINT_SCREEN_BACKGROUND_FIRST;
         paintDesktop(item->desktop(), desktopMask, clippingRegion, data);
         s_recursionCheck = NULL;
     }
 }
 
 void Scene::paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data)
 {
     static_cast<EffectsHandlerImpl*>(effects)->paintDesktop(desktop, mask, region, data);
 }
 
 // the function that'll be eventually called by paintWindow() above
 void Scene::finalPaintWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data)
 {
     effects->drawWindow(w, mask, region, data);
 }
 
 // will be eventually called from drawWindow()
 void Scene::finalDrawWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data)
 {
     if (waylandServer() && waylandServer()->isScreenLocked() && !w->window()->isLockScreen() && !w->window()->isInputMethod()) {
         return;
     }
     w->sceneWindow()->performPaint(mask, region, data);
 }
 
 void Scene::extendPaintRegion(QRegion &region, bool opaqueFullscreen)
 {
     Q_UNUSED(region);
     Q_UNUSED(opaqueFullscreen);
 }
 
 bool Scene::blocksForRetrace() const
 {
     return false;
 }
 
 bool Scene::syncsToVBlank() const
 {
     return false;
 }
 
 void Scene::screenGeometryChanged(const QSize &size)
 {
     if (!overlayWindow()) {
         return;
     }
     overlayWindow()->resize(size);
 }
 
 bool Scene::makeOpenGLContextCurrent()
 {
     return false;
 }
 
 void Scene::doneOpenGLContextCurrent()
 {
 }
 
 void Scene::triggerFence()
 {
 }
 
 QMatrix4x4 Scene::screenProjectionMatrix() const
 {
     return QMatrix4x4();
 }
 
 xcb_render_picture_t Scene::xrenderBufferPicture() const
 {
     return XCB_RENDER_PICTURE_NONE;
 }
 
 QPainter *Scene::scenePainter() const
 {
     return nullptr;
 }
 
 //****************************************
 // Scene::Window
 //****************************************
 
 Scene::Window::Window(Toplevel * c)
     : toplevel(c)
     , filter(ImageFilterFast)
     , m_shadow(NULL)
     , m_currentPixmap()
     , m_previousPixmap()
     , m_referencePixmapCounter(0)
     , disable_painting(0)
     , shape_valid(false)
     , cached_quad_list(NULL)
 {
 }
 
 Scene::Window::~Window()
 {
     delete m_shadow;
 }
 
 void Scene::Window::referencePreviousPixmap()
 {
     if (!m_previousPixmap.isNull() && m_previousPixmap->isDiscarded()) {
         m_referencePixmapCounter++;
     }
 }
 
 void Scene::Window::unreferencePreviousPixmap()
 {
     if (m_previousPixmap.isNull() || !m_previousPixmap->isDiscarded()) {
         return;
     }
     m_referencePixmapCounter--;
     if (m_referencePixmapCounter == 0) {
         m_previousPixmap.reset();
     }
 }
 
 void Scene::Window::pixmapDiscarded()
 {
     if (!m_currentPixmap.isNull()) {
         if (m_currentPixmap->isValid()) {
             m_previousPixmap.reset(m_currentPixmap.take());
             m_previousPixmap->markAsDiscarded();
         } else {
             m_currentPixmap.reset();
         }
     }
 }
 
 void Scene::Window::discardShape()
 {
     // it is created on-demand and cached, simply
     // reset the flag
     shape_valid = false;
     cached_quad_list.reset();
 }
 
 // Find out the shape of the window using the XShape extension
 // or if shape is not set then simply it's the window geometry.
 const QRegion &Scene::Window::shape() const
 {
     if (!shape_valid) {
         if (toplevel->shape()) {
             auto cookie = xcb_shape_get_rectangles_unchecked(connection(), toplevel->frameId(), XCB_SHAPE_SK_BOUNDING);
             ScopedCPointer<xcb_shape_get_rectangles_reply_t> reply(xcb_shape_get_rectangles_reply(connection(), cookie, nullptr));
             if (!reply.isNull()) {
                 shape_region = QRegion();
                 auto *rects = xcb_shape_get_rectangles_rectangles(reply.data());
                 for (int i = 0;
                         i < xcb_shape_get_rectangles_rectangles_length(reply.data());
                         ++i)
                     shape_region += QRegion(rects[ i ].x, rects[ i ].y,
                                             rects[ i ].width, rects[ i ].height);
                 // make sure the shape is sane (X is async, maybe even XShape is broken)
                 shape_region &= QRegion(0, 0, width(), height());
             } else
                 shape_region = QRegion();
         } else
             shape_region = QRegion(0, 0, width(), height());
         shape_valid = true;
     }
     return shape_region;
 }
 
 QRegion Scene::Window::clientShape() const
 {
     if (AbstractClient *c = dynamic_cast< AbstractClient * > (toplevel)) {
         if (c->isShade())
             return QRegion();
     }
 
     // TODO: cache
     const QRegion r = shape() & QRect(toplevel->clientPos(), toplevel->clientSize());
     return r.isEmpty() ? QRegion() : r;
 }
 
 bool Scene::Window::isVisible() const
 {
     if (toplevel->isDeleted())
         return false;
     if (!toplevel->isOnCurrentDesktop())
         return false;
     if (!toplevel->isOnCurrentActivity())
         return false;
     if (AbstractClient *c = dynamic_cast<AbstractClient*>(toplevel))
         return c->isShown(true);
     return true; // Unmanaged is always visible
 }
 
 bool Scene::Window::isOpaque() const
 {
     return toplevel->opacity() == 1.0 && !toplevel->hasAlpha();
 }
 
 bool Scene::Window::isPaintingEnabled() const
 {
     return !disable_painting;
 }
 
 void Scene::Window::resetPaintingEnabled()
 {
     disable_painting = 0;
     if (toplevel->isDeleted())
         disable_painting |= PAINT_DISABLED_BY_DELETE;
     if (static_cast<EffectsHandlerImpl*>(effects)->isDesktopRendering()) {
         if (!toplevel->isOnDesktop(static_cast<EffectsHandlerImpl*>(effects)->currentRenderedDesktop())) {
             disable_painting |= PAINT_DISABLED_BY_DESKTOP;
         }
     } else {
         if (!toplevel->isOnCurrentDesktop())
             disable_painting |= PAINT_DISABLED_BY_DESKTOP;
     }
     if (!toplevel->isOnCurrentActivity())
         disable_painting |= PAINT_DISABLED_BY_ACTIVITY;
     if (AbstractClient *c = dynamic_cast<AbstractClient*>(toplevel)) {
         if (c->isMinimized())
             disable_painting |= PAINT_DISABLED_BY_MINIMIZE;
         if (c->tabGroup() && c != c->tabGroup()->current())
             disable_painting |= PAINT_DISABLED_BY_TAB_GROUP;
         if (c->isHiddenInternal()) {
             disable_painting |= PAINT_DISABLED;
         }
     }
 }
 
 void Scene::Window::enablePainting(int reason)
 {
     disable_painting &= ~reason;
 }
 
 void Scene::Window::disablePainting(int reason)
 {
     disable_painting |= reason;
 }
 
 WindowQuadList Scene::Window::buildQuads(bool force) const
 {
     if (cached_quad_list != NULL && !force)
         return *cached_quad_list;
     WindowQuadList ret;
     qreal scale = 1.0;
     if (toplevel->surface()) {
         scale = toplevel->surface()->scale();
     }
 
     if (toplevel->clientPos() == QPoint(0, 0) && toplevel->clientSize() == toplevel->decorationRect().size())
         ret = makeQuads(WindowQuadContents, shape(), QPoint(0,0), scale);  // has no decoration
     else {
         AbstractClient *client = dynamic_cast<AbstractClient*>(toplevel);
         QRegion contents = clientShape();
         QRegion center = toplevel->transparentRect();
         QRegion decoration = (client ? QRegion(client->decorationRect()) : shape()) - center;
         ret = makeQuads(WindowQuadContents, contents, toplevel->clientContentPos(), scale);
 
 
         QRect rects[4];
         bool isShadedClient = false;
 
         if (client) {
             client->layoutDecorationRects(rects[0], rects[1], rects[2], rects[3]);
             isShadedClient = client->isShade() || center.isEmpty();
         }
 
         if (isShadedClient) {
             const QRect bounding = rects[0] | rects[1] | rects[2] | rects[3];
             ret += makeDecorationQuads(rects, bounding);
         } else {
             ret += makeDecorationQuads(rects, decoration);
         }
 
     }
     if (m_shadow && toplevel->wantsShadowToBeRendered()) {
         ret << m_shadow->shadowQuads();
     }
     effects->buildQuads(toplevel->effectWindow(), ret);
     cached_quad_list.reset(new WindowQuadList(ret));
     return ret;
 }
 
 WindowQuadList Scene::Window::makeDecorationQuads(const QRect *rects, const QRegion &region) const
 {
     WindowQuadList list;
 
     const QPoint offsets[4] = {
         QPoint(-rects[0].x() + rects[1].height() + rects[3].height() + 2, -rects[0].y()),                    // Left
         QPoint(-rects[1].x(), -rects[1].y()),                                                                // Top
         QPoint(-rects[2].x() + rects[1].height() + rects[3].height() + rects[0].width() + 3, -rects[2].y()), // Right
         QPoint(-rects[3].x(), -rects[3].y() + rects[1].height() + 1)                                         // Bottom
     };
 
     const Qt::Orientation orientations[4] = {
         Qt::Vertical,   // Left
         Qt::Horizontal, // Top
         Qt::Vertical,   // Right
         Qt::Horizontal, // Bottom
     };
 
     for (int i = 0; i < 4; i++) {
         foreach (const QRect &r, (region & rects[i]).rects()) {
             if (!r.isValid())
                 continue;
 
             const bool swap = orientations[i] == Qt::Vertical;
 
             const int x0 = r.x();
             const int y0 = r.y();
             const int x1 = r.x() + r.width();
             const int y1 = r.y() + r.height();
 
             const int u0 = x0 + offsets[i].x();
             const int v0 = y0 + offsets[i].y();
             const int u1 = x1 + offsets[i].x();
             const int v1 = y1 + offsets[i].y();
 
             WindowQuad quad(WindowQuadDecoration);
             quad.setUVAxisSwapped(swap);
 
             if (swap) {
                 quad[0] = WindowVertex(x0, y0, v0, u0); // Top-left
                 quad[1] = WindowVertex(x1, y0, v0, u1); // Top-right
                 quad[2] = WindowVertex(x1, y1, v1, u1); // Bottom-right
                 quad[3] = WindowVertex(x0, y1, v1, u0); // Bottom-left
             } else {
                 quad[0] = WindowVertex(x0, y0, u0, v0); // Top-left
                 quad[1] = WindowVertex(x1, y0, u1, v0); // Top-right
                 quad[2] = WindowVertex(x1, y1, u1, v1); // Bottom-right
                 quad[3] = WindowVertex(x0, y1, u0, v1); // Bottom-left
             }
 
             list.append(quad);
         }
     }
 
     return list;
 }
 
 WindowQuadList Scene::Window::makeQuads(WindowQuadType type, const QRegion& reg, const QPoint &textureOffset, qreal scale) const
 {
     WindowQuadList ret;
     foreach (const QRect & r, reg.rects()) {
         WindowQuad quad(type);
         // TODO asi mam spatne pravy dolni roh - bud tady, nebo v jinych castech
         quad[ 0 ] = WindowVertex(QPointF(r.x(), r.y()),
                                  QPointF(r.x() + textureOffset.x(), r.y() + textureOffset.y()) * scale);
         quad[ 1 ] = WindowVertex(QPointF(r.x() + r.width(), r.y()),
                                  QPointF(r.x() + r.width() + textureOffset.x(), r.y() + textureOffset.y()) * scale);
         quad[ 2 ] = WindowVertex(QPointF(r.x() + r.width(), r.y() + r.height()),
                                  QPointF(r.x() + r.width() + textureOffset.x(), r.y() + r.height() + textureOffset.y()) * scale);
         quad[ 3 ] = WindowVertex(QPointF(r.x(), r.y() + r.height()),
                                  QPointF(r.x() + textureOffset.x(), r.y() + r.height() + textureOffset.y()) * scale);
 
         ret.append(quad);
     }
     return ret;
 }
 
 void Scene::Window::updateShadow(Shadow* shadow)
 {
     if (m_shadow == shadow) {
         return;
     }
     delete m_shadow;
     m_shadow = shadow;
 }
 
 //****************************************
 // WindowPixmap
 //****************************************
 WindowPixmap::WindowPixmap(Scene::Window *window)
     : m_window(window)
     , m_pixmap(XCB_PIXMAP_NONE)
     , m_discarded(false)
 {
 }
 
 WindowPixmap::WindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent)
     : m_window(parent->m_window)
     , m_pixmap(XCB_PIXMAP_NONE)
     , m_discarded(false)
     , m_parent(parent)
     , m_subSurface(subSurface)
 {
 }
 
 WindowPixmap::~WindowPixmap()
 {
     if (m_pixmap != XCB_WINDOW_NONE) {
         xcb_free_pixmap(connection(), m_pixmap);
     }
     if (m_buffer) {
         using namespace KWayland::Server;
         QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
         m_buffer->unref();
     }
 }
 
 void WindowPixmap::create()
 {
     if (isValid() || toplevel()->isDeleted()) {
         return;
     }
     // always update from Buffer on Wayland, don't try using XPixmap
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         // use Buffer
         updateBuffer();
         if ((m_buffer || !m_fbo.isNull()) && m_subSurface.isNull()) {
             m_window->unreferencePreviousPixmap();
         }
         return;
     }
     XServerGrabber grabber;
     xcb_pixmap_t pix = xcb_generate_id(connection());
     xcb_void_cookie_t namePixmapCookie = xcb_composite_name_window_pixmap_checked(connection(), toplevel()->frameId(), pix);
     Xcb::WindowAttributes windowAttributes(toplevel()->frameId());
     Xcb::WindowGeometry windowGeometry(toplevel()->frameId());
     if (xcb_generic_error_t *error = xcb_request_check(connection(), namePixmapCookie)) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << error->error_code;
         free(error);
         return;
     }
     // check that the received pixmap is valid and actually matches what we
     // know about the window (i.e. size)
     if (!windowAttributes || windowAttributes->map_state != XCB_MAP_STATE_VIEWABLE) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << this;
         xcb_free_pixmap(connection(), pix);
         return;
     }
     if (!windowGeometry ||
         windowGeometry->width != toplevel()->width() || windowGeometry->height != toplevel()->height()) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << this;
         xcb_free_pixmap(connection(), pix);
         return;
     }
     m_pixmap = pix;
     m_pixmapSize = QSize(toplevel()->width(), toplevel()->height());
     m_contentsRect = QRect(toplevel()->clientPos(), toplevel()->clientSize());
     m_window->unreferencePreviousPixmap();
 }
 
 WindowPixmap *WindowPixmap::createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface)
 {
     Q_UNUSED(subSurface)
     return nullptr;
 }
 
 bool WindowPixmap::isValid() const
 {
     if (!m_buffer.isNull() || !m_fbo.isNull()) {
         return true;
     }
     return m_pixmap != XCB_PIXMAP_NONE;
 }
 
 void WindowPixmap::updateBuffer()
 {
     using namespace KWayland::Server;
     if (SurfaceInterface *s = surface()) {
         QVector<WindowPixmap*> oldTree = m_children;
         QVector<WindowPixmap*> children;
         using namespace KWayland::Server;
         const auto subSurfaces = s->childSubSurfaces();
         for (const auto &subSurface : subSurfaces) {
             if (subSurface.isNull()) {
                 continue;
             }
             auto it = std::find_if(oldTree.begin(), oldTree.end(), [subSurface] (WindowPixmap *p) { return p->m_subSurface == subSurface; });
             if (it != oldTree.end()) {
                 children << *it;
                 (*it)->updateBuffer();
                 oldTree.erase(it);
             } else {
                 WindowPixmap *p = createChild(subSurface);
                 if (p) {
                     p->create();
                     children << p;
                 }
             }
         }
         setChildren(children);
         qDeleteAll(oldTree);
         if (auto b = s->buffer()) {
             if (b == m_buffer) {
                 // no change
                 return;
             }
             if (m_buffer) {
                 QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
                 m_buffer->unref();
             }
             m_buffer = b;
             m_buffer->ref();
             QObject::connect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
         } else if (m_subSurface) {
             if (m_buffer) {
                 QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
                 m_buffer->unref();
                 m_buffer.clear();
             }
         } else {
             // might be an internal window
             const auto &fbo = toplevel()->internalFramebufferObject();
             if (!fbo.isNull()) {
                 m_fbo = fbo;
             }
         }
     } else {
         if (m_buffer) {
             QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
             m_buffer->unref();
             m_buffer.clear();
         }
     }
 }
 
 KWayland::Server::SurfaceInterface *WindowPixmap::surface() const
 {
     if (!m_subSurface.isNull()) {
         return m_subSurface->surface().data();
     } else {
         return toplevel()->surface();
     }
 }
 
 //****************************************
 // Scene::EffectFrame
 //****************************************
 Scene::EffectFrame::EffectFrame(EffectFrameImpl* frame)
     : m_effectFrame(frame)
 {
 }
 
 Scene::EffectFrame::~EffectFrame()
 {
 }
 
+SceneFactory::SceneFactory(QObject *parent)
+    : QObject(parent)
+{
+}
+
+SceneFactory::~SceneFactory()
+{
+}
+
 } // namespace
diff --git a/scene.h b/scene.h
index e7c885ac9..5d9865eca 100644
--- a/scene.h
+++ b/scene.h
@@ -1,646 +1,666 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_SCENE_H
 #define KWIN_SCENE_H
 
 #include "toplevel.h"
 #include "utils.h"
 #include "kwineffects.h"
 
 #include <QElapsedTimer>
 #include <QMatrix4x4>
 
 class QOpenGLFramebufferObject;
 
 namespace KWayland
 {
 namespace Server
 {
 class BufferInterface;
 class SubSurfaceInterface;
 }
 }
 
 namespace KWin
 {
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 class Renderer;
 }
 
 class AbstractThumbnailItem;
 class Deleted;
 class EffectFrameImpl;
 class EffectWindowImpl;
 class OverlayWindow;
 class Shadow;
 class WindowPixmap;
 
 // The base class for compositing backends.
 class KWIN_EXPORT Scene : public QObject
 {
     Q_OBJECT
 public:
     explicit Scene(QObject *parent = nullptr);
     virtual ~Scene() = 0;
     class EffectFrame;
     class Window;
 
     // Returns true if the ctor failed to properly initialize.
     virtual bool initFailed() const = 0;
     virtual CompositingType compositingType() const = 0;
 
     virtual bool hasPendingFlush() const { return false; }
 
     // Repaints the given screen areas, windows provides the stacking order.
     // The entry point for the main part of the painting pass.
     // returns the time since the last vblank signal - if there's one
     // ie. "what of this frame is lost to painting"
     virtual qint64 paint(QRegion damage, ToplevelList windows) = 0;
 
     // Notification function - KWin core informs about changes.
     // Used to mainly discard cached data.
 
     // a new window has been created
     void windowAdded(Toplevel*);
     /**
      * @brief Creates the Scene backend of an EffectFrame.
      *
      * @param frame The EffectFrame this Scene::EffectFrame belongs to.
      */
     virtual Scene::EffectFrame *createEffectFrame(EffectFrameImpl *frame) = 0;
     /**
      * @brief Creates the Scene specific Shadow subclass.
      *
      * An implementing class has to create a proper instance. It is not allowed to
      * return @c null.
      *
      * @param toplevel The Toplevel for which the Shadow needs to be created.
      */
     virtual Shadow *createShadow(Toplevel *toplevel) = 0;
     /**
      * Method invoked when the screen geometry is changed.
      * Reimplementing classes should also invoke the parent method
      * as it takes care of resizing the overlay window.
      * @param size The new screen geometry size
      **/
     virtual void screenGeometryChanged(const QSize &size);
     // Flags controlling how painting is done.
     enum {
         // Window (or at least part of it) will be painted opaque.
         PAINT_WINDOW_OPAQUE         = 1 << 0,
         // Window (or at least part of it) will be painted translucent.
         PAINT_WINDOW_TRANSLUCENT    = 1 << 1,
         // Window will be painted with transformed geometry.
         PAINT_WINDOW_TRANSFORMED    = 1 << 2,
         // Paint only a region of the screen (can be optimized, cannot
         // be used together with TRANSFORMED flags).
         PAINT_SCREEN_REGION         = 1 << 3,
         // Whole screen will be painted with transformed geometry.
         PAINT_SCREEN_TRANSFORMED    = 1 << 4,
         // At least one window will be painted with transformed geometry.
         PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS = 1 << 5,
         // Clear whole background as the very first step, without optimizing it
         PAINT_SCREEN_BACKGROUND_FIRST = 1 << 6,
         // PAINT_DECORATION_ONLY = 1 << 7 has been removed
         // Window will be painted with a lanczos filter.
         PAINT_WINDOW_LANCZOS = 1 << 8
         // PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS = 1 << 9 has been removed
     };
     // types of filtering available
     enum ImageFilterType { ImageFilterFast, ImageFilterGood };
     // there's nothing to paint (adjust time_diff later)
     virtual void idle();
     virtual bool blocksForRetrace() const;
     virtual bool syncsToVBlank() const;
     virtual OverlayWindow* overlayWindow() = 0;
 
     virtual bool makeOpenGLContextCurrent();
     virtual void doneOpenGLContextCurrent();
 
     virtual QMatrix4x4 screenProjectionMatrix() const;
 
     /**
      * Whether the Scene uses an X11 overlay window to perform compositing.
      */
     virtual bool usesOverlayWindow() const = 0;
 
     virtual void triggerFence();
 
     virtual Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *) = 0;
 
     /**
      * Whether the Scene is able to drive animations.
      * This is used as a hint to the effects system which effects can be supported.
      * If the Scene performs software rendering it is supposed to return @c false,
      * if rendering is hardware accelerated it should return @c true.
      **/
     virtual bool animationsSupported() const = 0;
 
     /**
      * The render buffer used by an XRender based compositor scene.
      * Default implementation returns XCB_RENDER_PICTURE_NONE
      **/
     virtual xcb_render_picture_t xrenderBufferPicture() const;
 
     /**
      * The QPainter used by a QPainter based compositor scene.
      * Default implementation returns @c nullptr;
      **/
     virtual QPainter *scenePainter() const;
 
 Q_SIGNALS:
     void frameRendered();
 
 public Q_SLOTS:
     // a window has been destroyed
     void windowDeleted(KWin::Deleted*);
     // shape/size of a window changed
     void windowGeometryShapeChanged(KWin::Toplevel* c);
     // a window has been closed
     void windowClosed(KWin::Toplevel* c, KWin::Deleted* deleted);
 protected:
     virtual Window *createWindow(Toplevel *toplevel) = 0;
     void createStackingOrder(ToplevelList toplevels);
     void clearStackingOrder();
     // shared implementation, starts painting the screen
     void paintScreen(int *mask, const QRegion &damage, const QRegion &repaint,
                      QRegion *updateRegion, QRegion *validRegion, const QMatrix4x4 &projection = QMatrix4x4(), const QRect &outputGeometry = QRect());
     // Render cursor texture in case hardware cursor is disabled/non-applicable
     virtual void paintCursor() = 0;
     friend class EffectsHandlerImpl;
     // called after all effects had their paintScreen() called
     void finalPaintScreen(int mask, QRegion region, ScreenPaintData& data);
     // shared implementation of painting the screen in the generic
     // (unoptimized) way
     virtual void paintGenericScreen(int mask, ScreenPaintData data);
     // shared implementation of painting the screen in an optimized way
     virtual void paintSimpleScreen(int mask, QRegion region);
     // paint the background (not the desktop background - the whole background)
     virtual void paintBackground(QRegion region) = 0;
     // called after all effects had their paintWindow() called
     void finalPaintWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data);
     // shared implementation, starts painting the window
     virtual void paintWindow(Window* w, int mask, QRegion region, WindowQuadList quads);
     // called after all effects had their drawWindow() called
     virtual void finalDrawWindow(EffectWindowImpl* w, int mask, QRegion region, WindowPaintData& data);
     // let the scene decide whether it's better to paint more of the screen, eg. in order to allow a buffer swap
     // the default is NOOP
     virtual void extendPaintRegion(QRegion &region, bool opaqueFullscreen);
     virtual void paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data);
     // compute time since the last repaint
     void updateTimeDiff();
     // saved data for 2nd pass of optimized screen painting
     struct Phase2Data {
         Phase2Data(Window* w, QRegion r, QRegion c, int m, const WindowQuadList& q)
             : window(w), region(r), clip(c), mask(m), quads(q) {}
         Phase2Data()  {
             window = 0;
             mask = 0;
         }
         Window* window;
         QRegion region;
         QRegion clip;
         int mask;
         WindowQuadList quads;
     };
     // The region which actually has been painted by paintScreen() and should be
     // copied from the buffer to the screen. I.e. the region returned from Scene::paintScreen().
     // Since prePaintWindow() can extend areas to paint, these changes would have to propagate
     // up all the way from paintSimpleScreen() up to paintScreen(), so save them here rather
     // than propagate them up in arguments.
     QRegion painted_region;
     // Additional damage that needs to be repaired to bring a reused back buffer up to date
     QRegion repaint_region;
     // The dirty region before it was unioned with repaint_region
     QRegion damaged_region;
     // time since last repaint
     int time_diff;
     QElapsedTimer last_time;
 private:
     void paintWindowThumbnails(Scene::Window *w, QRegion region, qreal opacity, qreal brightness, qreal saturation);
     void paintDesktopThumbnails(Scene::Window *w);
     QHash< Toplevel*, Window* > m_windows;
     // windows in their stacking order
     QVector< Window* > stacking_order;
 };
 
+/**
+ * Factory class to create a Scene. Needs to be implemented by the plugins.
+ **/
+class KWIN_EXPORT SceneFactory : public QObject
+{
+    Q_OBJECT
+public:
+    virtual ~SceneFactory();
+
+    /**
+     * @returns The created Scene, may be @c nullptr.
+     **/
+    virtual Scene *create(QObject *parent = nullptr) const = 0;
+
+protected:
+    explicit SceneFactory(QObject *parent);
+};
+
 // The base class for windows representations in composite backends
 class Scene::Window
 {
 public:
     Window(Toplevel* c);
     virtual ~Window();
     // perform the actual painting of the window
     virtual void performPaint(int mask, QRegion region, WindowPaintData data) = 0;
     // do any cleanup needed when the window's composite pixmap is discarded
     void pixmapDiscarded();
     int x() const;
     int y() const;
     int width() const;
     int height() const;
     QRect geometry() const;
     QPoint pos() const;
     QSize size() const;
     QRect rect() const;
     // access to the internal window class
     // TODO eventually get rid of this
     Toplevel* window() const;
     // should the window be painted
     bool isPaintingEnabled() const;
     void resetPaintingEnabled();
     // Flags explaining why painting should be disabled
     enum {
         // Window will not be painted
         PAINT_DISABLED                 = 1 << 0,
         // Window will not be painted because it is deleted
         PAINT_DISABLED_BY_DELETE       = 1 << 1,
         // Window will not be painted because of which desktop it's on
         PAINT_DISABLED_BY_DESKTOP      = 1 << 2,
         // Window will not be painted because it is minimized
         PAINT_DISABLED_BY_MINIMIZE     = 1 << 3,
         // Window will not be painted because it is not the active window in a client group
         PAINT_DISABLED_BY_TAB_GROUP = 1 << 4,
         // Window will not be painted because it's not on the current activity
         PAINT_DISABLED_BY_ACTIVITY     = 1 << 5
     };
     void enablePainting(int reason);
     void disablePainting(int reason);
     // is the window visible at all
     bool isVisible() const;
     // is the window fully opaque
     bool isOpaque() const;
     // shape of the window
     const QRegion &shape() const;
     QRegion clientShape() const;
     void discardShape();
     void updateToplevel(Toplevel* c);
     // creates initial quad list for the window
     virtual WindowQuadList buildQuads(bool force = false) const;
     void updateShadow(Shadow* shadow);
     const Shadow* shadow() const;
     Shadow* shadow();
     void referencePreviousPixmap();
     void unreferencePreviousPixmap();
 protected:
     WindowQuadList makeQuads(WindowQuadType type, const QRegion& reg, const QPoint &textureOffset = QPoint(0, 0), qreal textureScale = 1.0) const;
     WindowQuadList makeDecorationQuads(const QRect *rects, const QRegion &region) const;
     /**
      * @brief Returns the WindowPixmap for this Window.
      *
      * If the WindowPixmap does not yet exist, this method will invoke @link createWindowPixmap.
      * If the WindowPixmap is not valid it tries to create it, in case this succeeds the WindowPixmap is
      * returned. In case it fails, the previous (and still valid) WindowPixmap is returned.
      *
      * Note: this method can return @c NULL as there might neither be a valid previous nor current WindowPixmap
      * around.
      *
      * The WindowPixmap gets casted to the type passed in as a template parameter. That way this class does not
      * need to know the actual WindowPixmap subclass used by the concrete Scene implementations.
      *
      * @return The WindowPixmap casted to T* or @c NULL if there is no valid window pixmap.
      */
     template<typename T> T *windowPixmap();
     template<typename T> T *previousWindowPixmap();
     /**
      * @brief Factory method to create a WindowPixmap.
      *
      * The inheriting classes need to implement this method to create a new instance of their WindowPixmap subclass.
      * Note: do not use @link WindowPixmap::create on the created instance. The Scene will take care of that.
      */
     virtual WindowPixmap *createWindowPixmap() = 0;
     Toplevel* toplevel;
     ImageFilterType filter;
     Shadow *m_shadow;
 private:
     QScopedPointer<WindowPixmap> m_currentPixmap;
     QScopedPointer<WindowPixmap> m_previousPixmap;
     int m_referencePixmapCounter;
     int disable_painting;
     mutable QRegion shape_region;
     mutable bool shape_valid;
     mutable QScopedPointer<WindowQuadList> cached_quad_list;
     Q_DISABLE_COPY(Window)
 };
 
 /**
  * @brief Wrapper for a pixmap of the @link Scene::Window.
  *
  * This class encapsulates the functionality to get the pixmap for a window. When initialized the pixmap is not yet
  * mapped to the window and @link isValid will return @c false. The pixmap mapping to the window can be established
  * through @link create. If it succeeds @link isValid will return @c true, otherwise it will keep in the non valid
  * state and it can be tried to create the pixmap mapping again (e.g. in the next frame).
  *
  * This class is not intended to be updated when the pixmap is no longer valid due to e.g. resizing the window.
  * Instead a new instance of this class should be instantiated. The idea behind this is that a valid pixmap does not
  * get destroyed, but can continue to be used. To indicate that a newer pixmap should in generally be around, one can
  * use @link markAsDiscarded.
  *
  * This class is intended to be inherited for the needs of the compositor backends which need further mapping from
  * the native pixmap to the respective rendering format.
  */
-class WindowPixmap
+class KWIN_EXPORT WindowPixmap
 {
 public:
     virtual ~WindowPixmap();
     /**
      * @brief Tries to create the mapping between the Window and the pixmap.
      *
      * In case this method succeeds in creating the pixmap for the window, @link isValid will return @c true otherwise
      * @c false.
      *
      * Inheriting classes should re-implement this method in case they need to add further functionality for mapping the
      * native pixmap to the rendering format.
      */
     virtual void create();
     /**
      * @return @c true if the pixmap has been created and is valid, @c false otherwise
      */
     virtual bool isValid() const;
     /**
      * @return The native X11 pixmap handle
      */
     xcb_pixmap_t pixmap() const;
     /**
      * @return The Wayland BufferInterface for this WindowPixmap.
      **/
     QPointer<KWayland::Server::BufferInterface> buffer() const;
     const QSharedPointer<QOpenGLFramebufferObject> &fbo() const;
     /**
      * @brief Whether this WindowPixmap is considered as discarded. This means the window has changed in a way that a new
      * WindowPixmap should have been created already.
      *
      * @return @c true if this WindowPixmap is considered as discarded, @c false otherwise.
      * @see markAsDiscarded
      */
     bool isDiscarded() const;
     /**
      * @brief Marks this WindowPixmap as discarded. From now on @link isDiscarded will return @c true. This method should
      * only be used by the Window when it changes in a way that a new pixmap is required.
      *
      * @see isDiscarded
      */
     void markAsDiscarded();
     /**
      * The size of the pixmap.
      */
     const QSize &size() const;
     /**
      * The geometry of the Client's content inside the pixmap. In case of a decorated Client the
      * pixmap also contains the decoration which is not rendered into this pixmap, though. This
      * contentsRect tells where inside the complete pixmap the real content is.
      */
     const QRect &contentsRect() const;
     /**
      * @brief Returns the Toplevel this WindowPixmap belongs to.
      * Note: the Toplevel can change over the lifetime of the WindowPixmap in case the Toplevel is copied to Deleted.
      */
     Toplevel *toplevel() const;
 
     /**
      * @returns the parent WindowPixmap in the sub-surface tree
      **/
     WindowPixmap *parent() const {
         return m_parent;
     }
 
     /**
      * @returns the current sub-surface tree
      **/
     QVector<WindowPixmap*> children() const {
         return m_children;
     }
 
     /**
      * @returns the subsurface this WindowPixmap is for if it is not for a root window
      **/
     QPointer<KWayland::Server::SubSurfaceInterface> subSurface() const {
         return m_subSurface;
     }
 
     /**
      * @returns the surface this WindowPixmap references, might be @c null.
      **/
     KWayland::Server::SurfaceInterface *surface() const;
 
 protected:
     explicit WindowPixmap(Scene::Window *window);
     explicit WindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent);
     virtual WindowPixmap *createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface);
     /**
      * @return The Window this WindowPixmap belongs to
      */
     Scene::Window *window();
 
     /**
      * Should be called by the implementing subclasses when the Wayland Buffer changed and needs
      * updating.
      **/
     virtual void updateBuffer();
 
     /**
      * Sets the sub-surface tree to @p children.
      **/
     void setChildren(const QVector<WindowPixmap*> &children) {
         m_children = children;
     }
 
 private:
     Scene::Window *m_window;
     xcb_pixmap_t m_pixmap;
     QSize m_pixmapSize;
     bool m_discarded;
     QRect m_contentsRect;
     QPointer<KWayland::Server::BufferInterface> m_buffer;
     QSharedPointer<QOpenGLFramebufferObject> m_fbo;
     WindowPixmap *m_parent = nullptr;
     QVector<WindowPixmap*> m_children;
     QPointer<KWayland::Server::SubSurfaceInterface> m_subSurface;
 };
 
 class Scene::EffectFrame
 {
 public:
     EffectFrame(EffectFrameImpl* frame);
     virtual ~EffectFrame();
     virtual void render(QRegion region, double opacity, double frameOpacity) = 0;
     virtual void free() = 0;
     virtual void freeIconFrame() = 0;
     virtual void freeTextFrame() = 0;
     virtual void freeSelection() = 0;
     virtual void crossFadeIcon() = 0;
     virtual void crossFadeText() = 0;
 
 protected:
     EffectFrameImpl* m_effectFrame;
 };
 
 inline
 int Scene::Window::x() const
 {
     return toplevel->x();
 }
 
 inline
 int Scene::Window::y() const
 {
     return toplevel->y();
 }
 
 inline
 int Scene::Window::width() const
 {
     return toplevel->width();
 }
 
 inline
 int Scene::Window::height() const
 {
     return toplevel->height();
 }
 
 inline
 QRect Scene::Window::geometry() const
 {
     return toplevel->geometry();
 }
 
 inline
 QSize Scene::Window::size() const
 {
     return toplevel->size();
 }
 
 inline
 QPoint Scene::Window::pos() const
 {
     return toplevel->pos();
 }
 
 inline
 QRect Scene::Window::rect() const
 {
     return toplevel->rect();
 }
 
 inline
 Toplevel* Scene::Window::window() const
 {
     return toplevel;
 }
 
 inline
 void Scene::Window::updateToplevel(Toplevel* c)
 {
     toplevel = c;
 }
 
 inline
 const Shadow* Scene::Window::shadow() const
 {
     return m_shadow;
 }
 
 inline
 Shadow* Scene::Window::shadow()
 {
     return m_shadow;
 }
 
 inline
 QPointer<KWayland::Server::BufferInterface> WindowPixmap::buffer() const
 {
     return m_buffer;
 }
 
 inline
 const QSharedPointer<QOpenGLFramebufferObject> &WindowPixmap::fbo() const
 {
     return m_fbo;
 }
 
 template <typename T>
 inline
 T* Scene::Window::windowPixmap()
 {
     if (m_currentPixmap.isNull()) {
         m_currentPixmap.reset(createWindowPixmap());
     }
     if (m_currentPixmap->isValid()) {
         return static_cast<T*>(m_currentPixmap.data());
     }
     m_currentPixmap->create();
     if (m_currentPixmap->isValid()) {
         return static_cast<T*>(m_currentPixmap.data());
     } else {
         return static_cast<T*>(m_previousPixmap.data());
     }
 }
 
 template <typename T>
 inline
 T* Scene::Window::previousWindowPixmap()
 {
     return static_cast<T*>(m_previousPixmap.data());
 }
 
 inline
 Toplevel* WindowPixmap::toplevel() const
 {
     return m_window->window();
 }
 
 inline
 xcb_pixmap_t WindowPixmap::pixmap() const
 {
     return m_pixmap;
 }
 
 inline
 bool WindowPixmap::isDiscarded() const
 {
     return m_discarded;
 }
 
 inline
 void WindowPixmap::markAsDiscarded()
 {
     m_discarded = true;
     m_window->referencePreviousPixmap();
 }
 
 inline
 const QRect &WindowPixmap::contentsRect() const
 {
     return m_contentsRect;
 }
 
 inline
 const QSize &WindowPixmap::size() const
 {
     return m_pixmapSize;
 }
 
 } // namespace
 
+Q_DECLARE_INTERFACE(KWin::SceneFactory, "org.kde.kwin.Scene")
+
 #endif
diff --git a/shadow.h b/shadow.h
index d47ff88b9..b64cf7a47 100644
--- a/shadow.h
+++ b/shadow.h
@@ -1,193 +1,193 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_SHADOW_H
 #define KWIN_SHADOW_H
 
 #include <QObject>
 #include <QtGui/QPixmap>
 #include <kwineffects.h>
 #include <qvarlengtharray.h>
 
 namespace KDecoration2
 {
 class Decoration;
 class DecorationShadow;
 }
 
 namespace KWayland
 {
 namespace Server
 {
 class ShadowInterface;
 }
 }
 
 namespace KWin {
 
 class Toplevel;
 
 /**
  * @short Class representing a Window's Shadow to be rendered by the Compositor.
  *
  * This class holds all information about the Shadow to be rendered together with the
  * window during the Compositing stage. The Shadow consists of several pixmaps and offsets.
  * For a complete description please refer to http://community.kde.org/KWin/Shadow
  *
  * To create a Shadow instance use the static factory method @link createShadow which will
  * create an instance for the currently used Compositing Backend. It will read the X11 Property
  * and create the Shadow and all required data (such as WindowQuads). If there is no Shadow
  * defined for the Toplevel the factory method returns @c NULL.
  * 
  * @author Martin Gräßlin <mgraesslin@kde.org>
  * @todo React on Toplevel size changes.
  **/
-class Shadow : public QObject
+class KWIN_EXPORT Shadow : public QObject
 {
     Q_OBJECT
 public:
     virtual ~Shadow();
 
     /**
      * @return Region of the shadow.
      **/
     const QRegion &shadowRegion() const {
         return m_shadowRegion;
     };
     /**
      * @return Cached Shadow Quads
      **/
     const WindowQuadList &shadowQuads() const {
         return m_shadowQuads;
     };
     WindowQuadList &shadowQuads() {
         return m_shadowQuads;
     };
 
     /**
      * This method updates the Shadow when the property has been changed.
      * It is the responsibility of the owner of the Shadow to call this method
      * whenever the owner receives a PropertyNotify event.
      * This method will invoke a re-read of the Property. In case the Property has
      * been withdrawn the method returns @c false. In that case the owner should
      * delete the Shadow.
      * @returns @c true when the shadow has been updated, @c false if the property is not set anymore.
      **/
     virtual bool updateShadow();
 
     /**
      * Factory Method to create the shadow from the property.
      * This method takes care of creating an instance of the
      * Shadow class for the current Compositing Backend.
      *
      * If there is no shadow defined for @p toplevel this method
      * will return @c NULL.
      * @param toplevel The Toplevel for which the shadow should be created
      * @return Created Shadow or @c NULL in case there is no shadow defined.
      **/
     static Shadow *createShadow(Toplevel *toplevel);
 
     /**
      * Reparents the shadow to @p toplevel.
      * Used when a window is deleted.
      * @param toplevel The new parent
      **/
     void setToplevel(Toplevel *toplevel);
 
     bool hasDecorationShadow() const {
         return !m_decorationShadow.isNull();
     }
     QImage decorationShadowImage() const;
 
     QWeakPointer<KDecoration2::DecorationShadow> decorationShadow() const {
         return m_decorationShadow.toWeakRef();
     }
 
 public Q_SLOTS:
     void geometryChanged();
 
 protected:
     Shadow(Toplevel *toplevel);
     enum ShadowElements {
         ShadowElementTop,
         ShadowElementTopRight,
         ShadowElementRight,
         ShadowElementBottomRight,
         ShadowElementBottom,
         ShadowElementBottomLeft,
         ShadowElementLeft,
         ShadowElementTopLeft,
         ShadowElementsCount
     };
 
     inline const QPixmap &shadowPixmap(ShadowElements element) const {
         return m_shadowElements[element];
     };
     QSize elementSize(ShadowElements element) const;
 
     int topOffset() const {
         return m_topOffset;
     };
     int rightOffset() const {
         return m_rightOffset;
     };
     int bottomOffset() const {
         return m_bottomOffset;
     };
     int leftOffset() const {
         return m_leftOffset;
     };
     virtual void buildQuads();
     void updateShadowRegion();
     Toplevel *topLevel() {
         return m_topLevel;
     };
     void setShadowRegion(const QRegion &region) {
         m_shadowRegion = region;
     };
     virtual bool prepareBackend() = 0;
     WindowQuadList m_shadowQuads;
     void setShadowElement(const QPixmap &shadow, ShadowElements element);
 
 private:
     static Shadow *createShadowFromX11(Toplevel *toplevel);
     static Shadow *crateShadowFromDecoration(Toplevel *toplevel);
     static Shadow *createShadowFromWayland(Toplevel *toplevel);
     static QVector<uint32_t> readX11ShadowProperty(xcb_window_t id);
     bool init(const QVector<uint32_t> &data);
     bool init(KDecoration2::Decoration *decoration);
     bool init(const QPointer<KWayland::Server::ShadowInterface> &shadow);
     Toplevel *m_topLevel;
     // shadow pixmaps
     QPixmap m_shadowElements[ShadowElementsCount];
     // shadow offsets
     int m_topOffset;
     int m_rightOffset;
     int m_bottomOffset;
     int m_leftOffset;
     // caches
     QRegion m_shadowRegion;
     QSize m_cachedSize;
     // Decoration based shadows
     QSharedPointer<KDecoration2::DecorationShadow> m_decorationShadow;
 };
 
 }
 
 #endif // KWIN_SHADOW_H