diff --git a/CMakeLists.txt b/CMakeLists.txt
index c37f7ea03..a176c2f23 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,715 +1,716 @@
 cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
 
 project(KWIN)
 set(PROJECT_VERSION "5.13.80")
 set(PROJECT_VERSION_MAJOR 5)
 
 set(QT_MIN_VERSION "5.9.0")
 set(KF5_MIN_VERSION "5.42.0")
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH} )
 
 find_package(ECM 5.38 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
     Sensors
     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 5.13.0 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.9)
 set_package_properties(Libinput PROPERTIES TYPE REQUIRED 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 REQUIRED
                                         PURPOSE "Required for input handling on Wayland."
                         )
 
 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)
     set(HAVE_DRM TRUE)
 endif()
 
 find_package(gbm)
 set_package_properties(gbm PROPERTIES TYPE OPTIONAL PURPOSE "Required for egl output 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
 find_package(Qt5FontDatabaseSupport REQUIRED)
 find_package(Qt5ThemeSupport REQUIRED)
 find_package(Qt5EventDispatcherSupport REQUIRED)
 
 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"
     )
 
 find_package(Libcap)
 set_package_properties(Libcap PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Needed for running kwin_wayland with real-time scheduling policy"
 )
 set(HAVE_LIBCAP ${Libcap_FOUND})
 
 include(ECMQMLModules)
 ecm_find_qmlmodule(QtQuick 2.3)
 ecm_find_qmlmodule(QtQuick.Controls 1.2)
 ecm_find_qmlmodule(QtQuick.Layouts 1.3)
 ecm_find_qmlmodule(QtQuick.VirtualKeyboard 2.1)
 ecm_find_qmlmodule(QtQuick.Window 2.1)
 ecm_find_qmlmodule(QtMultimedia 5.0)
 ecm_find_qmlmodule(org.kde.kquickcontrolsaddons 2.0)
 ecm_find_qmlmodule(org.kde.plasma.core 2.0)
 ecm_find_qmlmodule(org.kde.plasma.components 2.0)
 
 ########### 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")
 
 check_symbol_exists(SCHED_RESET_ON_FORK "sched.h" HAVE_SCHED_RESET_ON_FORK)
 add_feature_info("SCHED_RESET_ON_FORK"
                  HAVE_SCHED_RESET_ON_FORK
                  "Required for running kwin_wayland with real-time scheduling")
 
 ########### 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
     ${CMAKE_CURRENT_SOURCE_DIR}/platformsupport
     )
 
 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
    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
     platform.cpp
+    abstract_output.cpp
     shell_client.cpp
     wayland_server.cpp
     wayland_cursor_theme.cpp
     virtualkeyboard.cpp
     virtualkeyboard_dbus.cpp
     appmenu.cpp
     modifier_only_shortcuts.cpp
     xkb.cpp
     gestures.cpp
     popup_input_filter.cpp
     colorcorrection/manager.cpp
     colorcorrection/colorcorrectdbusinterface.cpp
     colorcorrection/suncalc.cpp
     abstract_opengl_context_attribute_builder.cpp
     egl_context_attribute_builder.cpp
     was_user_interaction_x11_filter.cpp
     moving_client_x11_filter.cpp
     window_property_notify_x11_filter.cpp
     rootinfo_filter.cpp
     orientation_sensor.cpp
     idle_inhibition.cpp
     libinput/context.cpp
     libinput/connection.cpp
     libinput/device.cpp
     libinput/events.cpp
     libinput/libinput_logging.cpp
     udev.cpp
    )
 
 include(ECMQtDeclareLoggingCategory)
 ecm_qt_declare_logging_category(kwin_KDEINIT_SRCS
     HEADER
         colorcorrect_logging.h
     IDENTIFIER
         KWIN_COLORCORRECTION
     CATEGORY_NAME
         kwin_colorcorrection
     DEFAULT_SEVERITY
         Critical
 )
 
 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 (HAVE_LINUX_VT_H)
         set(kwin_KDEINIT_SRCS
             ${kwin_KDEINIT_SRCS}
             virtual_terminal.cpp
         )
 endif()
 
 kconfig_add_kcfg_files(kwin_KDEINIT_SRCS settings.kcfgc)
 kconfig_add_kcfg_files(kwin_KDEINIT_SRCS colorcorrection/colorcorrect_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 org.kde.kwin.ColorCorrect.xml colorcorrection/colorcorrectdbusinterface.h KWin::ColorCorrect::ColorCorrectDBusInterface )
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS ${kwin_effects_dbus_xml} effects.h KWin::EffectsHandlerImpl )
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS org.kde.kwin.OrientationSensor.xml orientation_sensor.h KWin::OrientationSensor)
 
 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
     kwin4_effect_builtins
 )
 
 set(kwin_QT_LIBS
     Qt5::Concurrent
     Qt5::DBus
     Qt5::Quick
     Qt5::Sensors
     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
     KF5::QuickAddons
     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}
     ${UDEV_LIBS}
     Libinput::Libinput
 )
 
 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 tabletmodemanager.cpp main_wayland.cpp)
 target_link_libraries(kwin_wayland kwin)
 if (HAVE_LIBCAP)
     target_link_libraries(kwin_wayland ${Libcap_LIBRARIES})
 endif()
 
 install(TARGETS kwin_wayland         ${INSTALL_TARGETS_DEFAULT_ARGS} )
 if (HAVE_LIBCAP)
     install(
     CODE "execute_process(
             COMMAND
                 ${SETCAP_EXECUTABLE}
                 CAP_SYS_NICE=+ep
                 \$ENV{DESTDIR}${CMAKE_INSTALL_FULL_BINDIR}/kwin_wayland)"
     )
 endif()
 
 add_subdirectory(platformsupport)
 add_subdirectory(plugins)
 
 ########### install files ###############
 
 install( FILES kwin.kcfg  DESTINATION  ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}.kcfg )
 install( FILES colorcorrection/colorcorrect_settings.kcfg  DESTINATION  ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}_colorcorrect.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.ColorCorrect.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(packageplugins)
 
 if (BUILD_TESTING)
     add_subdirectory(autotests)
     add_subdirectory(tests)
 endif()
 
 if (KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
 
 add_subdirectory(kconf_update)
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 include(CMakePackageConfigHelpers)
 set(CMAKECONFIG_INSTALL_DIR "${CMAKECONFIG_INSTALL_PREFIX}/KWinDBusInterface")
 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/abstract_output.cpp b/abstract_output.cpp
new file mode 100644
index 000000000..81922e615
--- /dev/null
+++ b/abstract_output.cpp
@@ -0,0 +1,130 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright 2018 Roman Gilg <subdiff@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+#include "abstract_output.h"
+#include "wayland_server.h"
+
+// KWayland
+#include <KWayland/Server/output_interface.h>
+#include <KWayland/Server/outputchangeset.h>
+#include <KWayland/Server/outputdevice_interface.h>
+#include <KWayland/Server/xdgoutput_interface.h>
+// KF5
+#include <KLocalizedString>
+
+#include <cmath>
+
+namespace KWin
+{
+
+AbstractOutput::AbstractOutput(QObject *parent)
+    : QObject(parent)
+{
+}
+
+AbstractOutput::~AbstractOutput()
+{
+    delete m_waylandOutputDevice.data();
+    delete m_xdgOutput.data();
+    delete m_waylandOutput.data();
+}
+
+QString AbstractOutput::name() const
+{
+    if (!m_waylandOutput) {
+        return i18n("unknown");
+    }
+    return QStringLiteral("%1 %2").arg(m_waylandOutput->manufacturer()).arg(m_waylandOutput->model());
+}
+
+QRect AbstractOutput::geometry() const
+{
+    return QRect(m_globalPos, pixelSize() / scale());
+}
+
+QSize AbstractOutput::physicalSize() const
+{
+    if (m_orientation == Qt::PortraitOrientation || m_orientation == Qt::InvertedPortraitOrientation) {
+        return m_physicalSize.transposed();
+    }
+    return m_physicalSize;
+}
+
+void AbstractOutput::setGlobalPos(const QPoint &pos)
+{
+    m_globalPos = pos;
+    if (m_waylandOutput) {
+        m_waylandOutput->setGlobalPosition(pos);
+    }
+    if (m_waylandOutputDevice) {
+        m_waylandOutputDevice->setGlobalPosition(pos);
+    }
+    if (m_xdgOutput) {
+        m_xdgOutput->setLogicalPosition(pos);
+        m_xdgOutput->done();
+    }
+}
+
+void AbstractOutput::setScale(qreal scale)
+{
+    m_scale = scale;
+    if (m_waylandOutput) {
+        // this is the scale that clients will ideally use for their buffers
+        // this has to be an int which is fine
+
+        // I don't know whether we want to round or ceil
+        // or maybe even set this to 3 when we're scaling to 1.5
+        // don't treat this like it's chosen deliberately
+        m_waylandOutput->setScale(std::ceil(scale));
+    }
+    if (m_waylandOutputDevice) {
+        m_waylandOutputDevice->setScaleF(scale);
+    }
+    if (m_xdgOutput) {
+        m_xdgOutput->setLogicalSize(pixelSize() / m_scale);
+        m_xdgOutput->done();
+    }
+}
+
+void AbstractOutput::setChanges(KWayland::Server::OutputChangeSet *changes)
+{
+    m_changeset = changes;
+    qCDebug(KWIN_CORE) << "set changes in AbstractOutput";
+    commitChanges();
+}
+
+void AbstractOutput::setWaylandOutput(KWayland::Server::OutputInterface *set)
+{
+    m_waylandOutput = set;
+}
+
+void AbstractOutput::createXdgOutput()
+{
+    if (!m_waylandOutput || m_xdgOutput) {
+        return;
+    }
+    m_xdgOutput = waylandServer()->xdgOutputManager()->createXdgOutput(m_waylandOutput, m_waylandOutput);
+}
+
+void AbstractOutput::setWaylandOutputDevice(KWayland::Server::OutputDeviceInterface *set)
+{
+    m_waylandOutputDevice = set;
+}
+
+}
diff --git a/abstract_output.h b/abstract_output.h
new file mode 100644
index 000000000..e061b812b
--- /dev/null
+++ b/abstract_output.h
@@ -0,0 +1,146 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright 2018 Roman Gilg <subdiff@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+#ifndef KWIN_OUTPUT_H
+#define KWIN_OUTPUT_H
+
+#include <utils.h>
+#include <kwin_export.h>
+
+#include <QObject>
+#include <QPoint>
+#include <QPointer>
+#include <QRect>
+#include <QSize>
+#include <QVector>
+
+namespace KWayland
+{
+namespace Server
+{
+class OutputInterface;
+class OutputDeviceInterface;
+class OutputChangeSet;
+class OutputManagementInterface;
+class XdgOutputInterface;
+}
+}
+
+namespace KWin
+{
+
+/**
+ * Generic output representation in a Wayland session
+ **/
+class KWIN_EXPORT AbstractOutput : public QObject
+{
+    Q_OBJECT
+public:
+    explicit AbstractOutput(QObject *parent = nullptr);
+    virtual ~AbstractOutput();
+
+    QString name() const;
+    bool isEnabled() const {
+        return !m_waylandOutput.isNull();
+    }
+
+    virtual QSize pixelSize() const = 0;
+    qreal scale() const {
+        return m_scale;
+    }
+    /*
+     * The geometry of this output in global compositor co-ordinates (i.e scaled)
+     */
+    QRect geometry() const;
+    QSize physicalSize() const;
+    Qt::ScreenOrientation orientation() const {
+        return m_orientation;
+    }
+
+    bool isInternal() const {
+        return m_internal;
+    }
+
+    void setGlobalPos(const QPoint &pos);
+    void setScale(qreal scale);
+
+    /**
+     * This sets the changes and tests them against the specific output
+     */
+    void setChanges(KWayland::Server::OutputChangeSet *changeset);
+    virtual bool commitChanges() { return false; }
+
+    QPointer<KWayland::Server::OutputInterface> waylandOutput() const {
+        return m_waylandOutput;
+    }
+
+protected:
+    QPointer<KWayland::Server::OutputChangeSet> changes() const {
+        return m_changeset;
+    }
+
+    void setWaylandOutput(KWayland::Server::OutputInterface *set);
+
+    QPointer<KWayland::Server::XdgOutputInterface> xdgOutput() const {
+        return m_xdgOutput;
+    }
+    void createXdgOutput();
+
+    QPointer<KWayland::Server::OutputDeviceInterface> waylandOutputDevice() const {
+        return m_waylandOutputDevice;
+    }
+    void setWaylandOutputDevice(KWayland::Server::OutputDeviceInterface *set);
+
+    QPoint globalPos() const {
+        return m_globalPos;
+    }
+
+    QSize rawPhysicalSize() const {
+        return m_physicalSize;
+    }
+    void setRawPhysicalSize(const QSize &set) {
+        m_physicalSize = set;
+    }
+
+    void setOrientation(Qt::ScreenOrientation set) {
+        m_orientation = set;
+    }
+    bool internal() const {
+        return m_internal;
+    }
+    void setInternal(bool set) {
+        m_internal = set;
+    }
+
+private:
+    QPointer<KWayland::Server::OutputChangeSet> m_changeset;
+    QPointer<KWayland::Server::OutputInterface> m_waylandOutput;
+    QPointer<KWayland::Server::XdgOutputInterface> m_xdgOutput;
+    QPointer<KWayland::Server::OutputDeviceInterface> m_waylandOutputDevice;
+
+    QPoint m_globalPos;
+    qreal m_scale = 1;
+    QSize m_physicalSize;
+    Qt::ScreenOrientation m_orientation = Qt::PrimaryOrientation;
+    bool m_internal = false;
+};
+
+}
+
+#endif // KWIN_OUTPUT_H
diff --git a/platform.h b/platform.h
index ff40db7b9..eb4290d33 100644
--- a/platform.h
+++ b/platform.h
@@ -1,530 +1,551 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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_PLATFORM_H
 #define KWIN_PLATFORM_H
 #include <kwin_export.h>
 #include <kwinglobals.h>
 #include <epoxy/egl.h>
 #include "fixqopengl.h"
 
 #include <fixx11h.h>
 #include <QImage>
 #include <QObject>
 
 #include <functional>
 
 class QAction;
 
 namespace KWayland {
     namespace Server {
         class OutputConfigurationInterface;
     }
 }
 
 namespace KWin
 {
 namespace ColorCorrect {
 class Manager;
 struct GammaRamp;
 }
 
+class AbstractOutput;
 class Edge;
 class Compositor;
 class OverlayWindow;
 class OpenGLBackend;
 class Outline;
 class OutlineVisual;
 class QPainterBackend;
 class Scene;
 class Screens;
 class ScreenEdges;
 class Toplevel;
 class WaylandCursorTheme;
 
 namespace Decoration
 {
 class Renderer;
 class DecoratedClientImpl;
 }
 
+class KWIN_EXPORT Outputs : public QVector<AbstractOutput*>
+{
+public:
+    Outputs(){};
+    template <typename T>
+    Outputs(const QVector<T> &other) {
+        resize(other.size());
+        std::copy(other.constBegin(), other.constEnd(), begin());
+    }
+};
+
 class KWIN_EXPORT Platform : public QObject
 {
     Q_OBJECT
 public:
     virtual ~Platform();
 
     virtual void init() = 0;
     virtual Screens *createScreens(QObject *parent = nullptr);
     virtual OpenGLBackend *createOpenGLBackend();
     virtual QPainterBackend *createQPainterBackend();
     /**
      * Allows the platform to create a platform specific screen edge.
      * The default implementation creates a Edge.
      **/
     virtual Edge *createScreenEdge(ScreenEdges *parent);
     /**
      * Allows the platform to create a platform specific Cursor.
      * The default implementation creates an InputRedirectionCursor.
      **/
     virtual void createPlatformCursor(QObject *parent = nullptr);
     virtual void warpPointer(const QPointF &globalPos);
     /**
      * Whether our Compositing EGL display allows a surface less context
      * so that a sharing context could be created.
      **/
     virtual bool supportsQpaContext() const;
     /**
      * The EGLDisplay used by the compositing scene.
      **/
     EGLDisplay sceneEglDisplay() const;
     void setSceneEglDisplay(EGLDisplay display);
     /**
      * The EGLContext used by the compositing scene.
      **/
     virtual EGLContext sceneEglContext() const {
         return m_context;
     }
     /**
      * Sets the @p context used by the compositing scene.
      **/
     void setSceneEglContext(EGLContext context) {
         m_context = context;
     }
     /**
      * The first (in case of multiple) EGLSurface used by the compositing scene.
      **/
     EGLSurface sceneEglSurface() const {
         return m_surface;
     }
     /**
      * Sets the first @p surface used by the compositing scene.
      * @see sceneEglSurface
      **/
     void setSceneEglSurface(EGLSurface surface) {
         m_surface = surface;
     }
 
     /**
      * The EglConfig used by the compositing scene.
      **/
     EGLConfig sceneEglConfig() const {
         return m_eglConfig;
     }
     /**
      * Sets the @p config used by the compositing scene.
      * @see sceneEglConfig
      **/
     void setSceneEglConfig(EGLConfig config) {
         m_eglConfig = config;
     }
 
     /**
      * Implementing subclasses should provide a size in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns an invalid size.
      **/
     virtual QSize screenSize() const;
     /**
      * Implementing subclasses should provide all geometries in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns one QRect positioned at 0/0 with screenSize() as size.
      **/
     virtual QVector<QRect> screenGeometries() const;
 
     /**
      * Implementing subclasses should provide all geometries in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns a screen with a scale of 1.
      **/
     virtual QVector<qreal> screenScales() const;
     /**
      * Implement this method to receive configuration change requests through KWayland's
      * OutputManagement interface.
      *
      * Base implementation warns that the current backend does not implement this
      * functionality.
      */
     virtual void configurationChangeRequested(KWayland::Server::OutputConfigurationInterface *config);
 
     /**
      * Whether the Platform requires compositing for rendering.
      * Default implementation returns @c true. If the implementing Platform allows to be used
      * without compositing (e.g. rendering is done by the windowing system), re-implement this method.
      **/
     virtual bool requiresCompositing() const;
     /**
      * Whether Compositing is possible in the Platform.
      * Returning @c false in this method makes only sense if @link{requiresCompositing} returns @c false.
      *
      * The default implementation returns @c true.
      * @see requiresCompositing
      **/
     virtual bool compositingPossible() const;
     /**
      * Returns a user facing text explaining why compositing is not possible in case
      * @link{compositingPossible} returns @c false.
      *
      * The default implementation returns an empty string.
      * @see compositingPossible
      **/
     virtual QString compositingNotPossibleReason() const;
     /**
      * Whether OpenGL compositing is broken.
      * The Platform can implement this method if it is able to detect whether OpenGL compositing
      * broke (e.g. triggered a crash in a previous run).
      *
      * Default implementation returns @c false.
      * @see createOpenGLSafePoint
      **/
     virtual bool openGLCompositingIsBroken() const;
     enum class OpenGLSafePoint {
         PreInit,
         PostInit,
         PreFrame,
         PostFrame,
         PostLastGuardedFrame
     };
     /**
      * This method is invoked before and after creating the OpenGL rendering Scene.
      * An implementing Platform can use it to detect crashes triggered by the OpenGL implementation.
      * This can be used for @link{openGLCompositingIsBroken}.
      *
      * The default implementation does nothing.
      * @see openGLCompositingIsBroken.
      **/
     virtual void createOpenGLSafePoint(OpenGLSafePoint safePoint);
 
     /**
      * Starts an interactive window selection process.
      *
      * Once the user selected a window the @p callback is invoked with the selected Toplevel as
      * argument. In case the user cancels the interactive window selection or selecting a window is currently
      * not possible (e.g. screen locked) the @p callback is invoked with a @c nullptr argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor unless
      * @p cursorName is provided. The argument @p cursorName is a QByteArray instead of Qt::CursorShape
      * to support the "pirate" cursor for kill window which is not wrapped by Qt::CursorShape.
      *
      * The default implementation forwards to InputRedirection.
      *
      * @param callback The function to invoke once the interactive window selection ends
      * @param cursorName The optional name of the cursor shape to use, default is crosshair
      **/
     virtual void startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName = QByteArray());
 
     /**
      * Starts an interactive position selection process.
      *
      * Once the user selected a position on the screen the @p callback is invoked with
      * the selected point as argument. In case the user cancels the interactive position selection
      * or selecting a position is currently not possible (e.g. screen locked) the @p callback
      * is invoked with a point at @c -1 as x and y argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor.
      *
      * The default implementation forwards to InputRedirection.
      *
      * @param callback The function to invoke once the interactive position selection ends
      **/
     virtual void startInteractivePositionSelection(std::function<void(const QPoint &)> callback);
 
     /**
      * Platform specific preparation for an @p action which is used for KGlobalAccel.
      *
      * A platform might need to do preparation for an @p action before
      * it can be used with KGlobalAccel.
      *
      * Code using KGlobalAccel should invoke this method for the @p action
      * prior to setting up any shortcuts and connections.
      *
      * The default implementation does nothing.
      *
      * @param action The action which will be used with KGlobalAccel.
      * @since 5.10
      **/
     virtual void setupActionForGlobalAccel(QAction *action);
 
     bool usesSoftwareCursor() const {
         return m_softWareCursor;
     }
     QImage softwareCursor() const;
     QPoint softwareCursorHotspot() const;
     void markCursorAsRendered();
 
     /**
      * Returns a PlatformCursorImage. By default this is created by softwareCursor and
      * softwareCursorHotspot. An implementing subclass can use this to provide a better
      * suited PlatformCursorImage.
      *
      * @see softwareCursor
      * @see softwareCursorHotspot
      * @since 5.9
      **/
     virtual PlatformCursorImage cursorImage() const;
 
     /**
      * The Platform cursor image should be hidden.
      * @see showCursor
      * @see doHideCursor
      * @see isCursorHidden
      * @since 5.9
      **/
     void hideCursor();
 
     /**
      * The Platform cursor image should be shown again.
      * @see hideCursor
      * @see doShowCursor
      * @see isCursorHidden
      * @since 5.9
      **/
     void showCursor();
 
     /**
      * Whether the cursor is currently hidden.
      * @see showCursor
      * @see hideCursor
      * @since 5.9
      **/
     bool isCursorHidden() const {
         return m_hideCursorCounter > 0;
     }
 
     bool handlesOutputs() const {
         return m_handlesOutputs;
     }
     bool isReady() const {
         return m_ready;
     }
     void setInitialWindowSize(const QSize &size) {
         m_initialWindowSize = size;
     }
     void setDeviceIdentifier(const QByteArray &identifier) {
         m_deviceIdentifier = identifier;
     }
     bool supportsPointerWarping() const {
         return m_pointerWarping;
     }
     bool areOutputsEnabled() const {
         return m_outputsEnabled;
     }
     void setOutputsEnabled(bool enabled) {
         m_outputsEnabled = enabled;
     }
     int initialOutputCount() const {
         return m_initialOutputCount;
     }
     void setInitialOutputCount(int count) {
         m_initialOutputCount = count;
     }
     qreal initialOutputScale() const {
         return m_initialOutputScale;
     }
     void setInitialOutputScale(qreal scale) {
         m_initialOutputScale = scale;
     }
 
     /**
      * Creates the OverlayWindow required for X11 based compositors.
      * Default implementation returns @c nullptr.
      **/
     virtual OverlayWindow *createOverlayWindow();
 
     /**
      * Allows a platform to update the X11 timestamp.
      * Mostly for the X11 standalone platform to interact with QX11Info.
      *
      * Default implementation does nothing. This means code relying on the X timestamp being up to date,
      * might not be working. E.g. synced X11 window resizing
      **/
     virtual void updateXTime();
 
     /**
      * Creates the OutlineVisual for the given @p outline.
      * Default implementation creates an OutlineVisual suited for composited usage.
      **/
     virtual OutlineVisual *createOutline(Outline *outline);
 
     /**
      * Creates the Decoration::Renderer for the given @p client.
      *
      * The default implementation creates a Renderer suited for the Compositor, @c nullptr if there is no Compositor.
      **/
     virtual Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *client);
 
     /**
      * Platform specific way to invert the screen.
      * Default implementation invokes the invert effect
      **/
     virtual void invertScreen();
 
     /**
      * Default implementation creates an EffectsHandlerImp;
      **/
     virtual void createEffectsHandler(Compositor *compositor, Scene *scene);
     /**
      * The CompositingTypes supported by the Platform.
      * The first item should be the most preferred one.
      * @since 5.11
      **/
     virtual QVector<CompositingType> supportedCompositors() const = 0;
 
     /**
      * Whether gamma control is supported by the backend.
      * @since 5.12
      **/
     bool supportsGammaControl() const {
         return m_supportsGammaControl;
     }
 
     ColorCorrect::Manager *colorCorrectManager() {
         return m_colorCorrect;
     }
 
     virtual int gammaRampSize(int screen) const {
         Q_UNUSED(screen);
         return 0;
     }
     virtual bool setGammaRamp(int screen, ColorCorrect::GammaRamp &gamma) {
         Q_UNUSED(screen);
         Q_UNUSED(gamma);
         return false;
     }
 
+    // outputs with connections (org_kde_kwin_outputdevice)
+    virtual Outputs outputs() const {
+        return Outputs();
+    }
+    // actively compositing outputs (wl_output)
+    virtual Outputs enabledOutputs() const {
+        return Outputs();
+    }
+
     /*
      * A string of information to include in kwin debug output
      * It should not be translated.
      *
      * The base implementation prints the name.
      * @since 5.12
      */
     virtual QString supportInformation() const;
 
 public Q_SLOTS:
     void pointerMotion(const QPointF &position, quint32 time);
     void pointerButtonPressed(quint32 button, quint32 time);
     void pointerButtonReleased(quint32 button, quint32 time);
     void pointerAxisHorizontal(qreal delta, quint32 time);
     void pointerAxisVertical(qreal delta, quint32 time);
     void keyboardKeyPressed(quint32 key, quint32 time);
     void keyboardKeyReleased(quint32 key, quint32 time);
     void keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
     void keymapChange(int fd, uint32_t size);
     void touchDown(qint32 id, const QPointF &pos, quint32 time);
     void touchUp(qint32 id, quint32 time);
     void touchMotion(qint32 id, const QPointF &pos, quint32 time);
     void touchCancel();
     void touchFrame();
 
     void processSwipeGestureBegin(int fingerCount, quint32 time);
     void processSwipeGestureUpdate(const QSizeF &delta, quint32 time);
     void processSwipeGestureEnd(quint32 time);
     void processSwipeGestureCancelled(quint32 time);
     void processPinchGestureBegin(int fingerCount, quint32 time);
     void processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time);
     void processPinchGestureEnd(quint32 time);
     void processPinchGestureCancelled(quint32 time);
 
 Q_SIGNALS:
     void screensQueried();
     void initFailed();
     void cursorChanged();
     void readyChanged(bool);
     /**
      * Emitted by backends using a one screen (nested window) approach and when the size of that changes.
      **/
     void screenSizeChanged();
 
 protected:
     explicit Platform(QObject *parent = nullptr);
     void setSoftWareCursor(bool set);
     void handleOutputs() {
         m_handlesOutputs = true;
     }
     void repaint(const QRect &rect);
     void setReady(bool ready);
     QSize initialWindowSize() const {
         return m_initialWindowSize;
     }
     QByteArray deviceIdentifier() const {
         return m_deviceIdentifier;
     }
     void setSupportsPointerWarping(bool set) {
         m_pointerWarping = set;
     }
     void setSupportsGammaControl(bool set) {
         m_supportsGammaControl = set;
     }
 
     /**
      * Actual platform specific way to hide the cursor.
      * Sub-classes need to implement if they support hiding the cursor.
      *
      * This method is invoked by hideCursor if the cursor needs to be hidden.
      * The default implementation does nothing.
      *
      * @see doShowCursor
      * @see hideCursor
      * @see showCursor
      **/
     virtual void doHideCursor();
     /**
      * Actual platform specific way to show the cursor.
      * Sub-classes need to implement if they support showing the cursor.
      *
      * This method is invoked by showCursor if the cursor needs to be shown again.
      *
      * @see doShowCursor
      * @see hideCursor
      * @see showCursor
      **/
     virtual void doShowCursor();
 
 private:
     void triggerCursorRepaint();
     bool m_softWareCursor = false;
     struct {
         QRect lastRenderedGeometry;
     } m_cursor;
     bool m_handlesOutputs = false;
     bool m_ready = false;
     QSize m_initialWindowSize;
     QByteArray m_deviceIdentifier;
     bool m_pointerWarping = false;
     bool m_outputsEnabled = true;
     int m_initialOutputCount = 1;
     qreal m_initialOutputScale = 1;
     EGLDisplay m_eglDisplay;
     EGLConfig m_eglConfig = nullptr;
     EGLContext m_context = EGL_NO_CONTEXT;
     EGLSurface m_surface = EGL_NO_SURFACE;
     int m_hideCursorCounter = 0;
     ColorCorrect::Manager *m_colorCorrect = nullptr;
     bool m_supportsGammaControl = false;
 };
 
 }
 
 Q_DECLARE_INTERFACE(KWin::Platform, "org.kde.kwin.Platform")
 
 #endif
diff --git a/plugins/platforms/drm/drm_backend.cpp b/plugins/platforms/drm/drm_backend.cpp
index 71f2d63f1..835f5a464 100644
--- a/plugins/platforms/drm/drm_backend.cpp
+++ b/plugins/platforms/drm/drm_backend.cpp
@@ -1,795 +1,810 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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 "drm_backend.h"
 #include "drm_output.h"
 #include "drm_object_connector.h"
 #include "drm_object_crtc.h"
 #include "drm_object_plane.h"
 #include "composite.h"
 #include "cursor.h"
 #include "logging.h"
 #include "logind.h"
 #include "main.h"
 #include "scene_qpainter_drm_backend.h"
 #include "screens_drm.h"
 #include "udev.h"
 #include "wayland_server.h"
 #include <colorcorrection/gammaramp.h>
 #if HAVE_GBM
 #include "egl_gbm_backend.h"
 #include <gbm.h>
 #endif
 // KWayland
 #include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/outputconfiguration_interface.h>
 // KF5
 #include <KConfigGroup>
 #include <KCoreAddons>
 #include <KLocalizedString>
 #include <KSharedConfig>
 // Qt
 #include <QCryptographicHash>
 #include <QSocketNotifier>
 #include <QPainter>
 // system
+#include <algorithm>
 #include <unistd.h>
 // drm
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 #include <libdrm/drm_mode.h>
 
 #ifndef DRM_CAP_CURSOR_WIDTH
 #define DRM_CAP_CURSOR_WIDTH 0x8
 #endif
 
 #ifndef DRM_CAP_CURSOR_HEIGHT
 #define DRM_CAP_CURSOR_HEIGHT 0x9
 #endif
 
 #define KWIN_DRM_EVENT_CONTEXT_VERSION 2
 
 namespace KWin
 {
 
 DrmBackend::DrmBackend(QObject *parent)
     : Platform(parent)
     , m_udev(new Udev)
     , m_udevMonitor(m_udev->monitor())
     , m_dpmsFilter()
 {
     setSupportsGammaControl(true);
     handleOutputs();
 }
 
 DrmBackend::~DrmBackend()
 {
 #if HAVE_GBM
     if (m_gbmDevice) {
         gbm_device_destroy(m_gbmDevice);
     }
 #endif
     if (m_fd >= 0) {
         // wait for pageflips
         while (m_pageFlipsPending != 0) {
             QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
         }
+        // we need to first remove all outputs
         qDeleteAll(m_outputs);
+        m_outputs.clear();
+        m_enabledOutputs.clear();
+
         qDeleteAll(m_planes);
         qDeleteAll(m_crtcs);
         qDeleteAll(m_connectors);
         close(m_fd);
     }
 }
 
 void DrmBackend::init()
 {
     LogindIntegration *logind = LogindIntegration::self();
     auto takeControl = [logind, this]() {
         if (logind->hasSessionControl()) {
             openDrm();
         } else {
             logind->takeControl();
             connect(logind, &LogindIntegration::hasSessionControlChanged, this, &DrmBackend::openDrm);
         }
     };
     if (logind->isConnected()) {
         takeControl();
     } else {
         connect(logind, &LogindIntegration::connectedChanged, this, takeControl);
     }
 }
 
+Outputs DrmBackend::outputs() const
+{
+    return m_outputs;
+}
+
+Outputs DrmBackend::enabledOutputs() const
+{
+    return m_enabledOutputs;
+}
+
 void DrmBackend::outputWentOff()
 {
     if (!m_dpmsFilter.isNull()) {
         // already another output is off
         return;
     }
     m_dpmsFilter.reset(new DpmsInputEventFilter(this));
     input()->prependInputEventFilter(m_dpmsFilter.data());
 }
 
 void DrmBackend::turnOutputsOn()
 {
     m_dpmsFilter.reset();
     for (auto it = m_enabledOutputs.constBegin(), end = m_enabledOutputs.constEnd(); it != end; it++) {
         (*it)->setDpms(DrmOutput::DpmsMode::On);
     }
 }
 
 void DrmBackend::checkOutputsAreOn()
 {
     if (m_dpmsFilter.isNull()) {
         // already disabled, all outputs are on
         return;
     }
     for (auto it = m_enabledOutputs.constBegin(), end = m_enabledOutputs.constEnd(); it != end; it++) {
         if (!(*it)->isDpmsEnabled()) {
             // dpms still disabled, need to keep the filter
             return;
         }
     }
     // all outputs are on, disable the filter
     m_dpmsFilter.reset();
 }
 
 void DrmBackend::activate(bool active)
 {
     if (active) {
         qCDebug(KWIN_DRM) << "Activating session.";
         reactivate();
     } else {
         qCDebug(KWIN_DRM) << "Deactivating session.";
         deactivate();
     }
 }
 
 void DrmBackend::reactivate()
 {
     if (m_active) {
         return;
     }
     m_active = true;
     if (!usesSoftwareCursor()) {
         const QPoint cp = Cursor::pos() - softwareCursorHotspot();
         for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
             DrmOutput *o = *it;
             // only relevant in atomic mode
             o->m_modesetRequested = true;
             o->pageFlipped();   // TODO: Do we really need this?
             o->m_crtc->blank();
             o->showCursor();
             o->moveCursor(cp);
         }
     }
     // restart compositor
     m_pageFlipsPending = 0;
     if (Compositor *compositor = Compositor::self()) {
         compositor->bufferSwapComplete();
         compositor->addRepaintFull();
     }
 }
 
 void DrmBackend::deactivate()
 {
     if (!m_active) {
         return;
     }
     // block compositor
     if (m_pageFlipsPending == 0 && Compositor::self()) {
         Compositor::self()->aboutToSwapBuffers();
     }
     // hide cursor and disable
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         DrmOutput *o = *it;
         o->hideCursor();
     }
     m_active = false;
 }
 
 void DrmBackend::pageFlipHandler(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void *data)
 {
     Q_UNUSED(fd)
     Q_UNUSED(frame)
     Q_UNUSED(sec)
     Q_UNUSED(usec)
     auto output = reinterpret_cast<DrmOutput*>(data);
     output->pageFlipped();
     output->m_backend->m_pageFlipsPending--;
     if (output->m_backend->m_pageFlipsPending == 0) {
         // TODO: improve, this currently means we wait for all page flips or all outputs.
         // It would be better to driver the repaint per output
 
         if (output->m_dpmsAtomicOffPending) {
             output->m_modesetRequested = true;
             output->dpmsAtomicOff();
         }
 
         if (Compositor::self()) {
             Compositor::self()->bufferSwapComplete();
         }
     }
 }
 
 void DrmBackend::openDrm()
 {
     connect(LogindIntegration::self(), &LogindIntegration::sessionActiveChanged, this, &DrmBackend::activate);
     UdevDevice::Ptr device = m_udev->primaryGpu();
     if (!device) {
         qCWarning(KWIN_DRM) << "Did not find a GPU";
         return;
     }
     int fd = LogindIntegration::self()->takeDevice(device->devNode());
     if (fd < 0) {
         qCWarning(KWIN_DRM) << "failed to open drm device at" << device->devNode();
         return;
     }
     m_fd = fd;
     m_active = true;
     QSocketNotifier *notifier = new QSocketNotifier(m_fd, QSocketNotifier::Read, this);
     connect(notifier, &QSocketNotifier::activated, this,
         [this] {
             if (!LogindIntegration::self()->isActiveSession()) {
                 return;
             }
             drmEventContext e;
             memset(&e, 0, sizeof e);
             e.version = KWIN_DRM_EVENT_CONTEXT_VERSION;
             e.page_flip_handler = pageFlipHandler;
             drmHandleEvent(m_fd, &e);
         }
     );
     m_drmId = device->sysNum();
 
     // trying to activate Atomic Mode Setting (this means also Universal Planes)
     if (!qEnvironmentVariableIsSet("KWIN_DRM_NO_AMS")) {
         if (drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1) == 0) {
             qCDebug(KWIN_DRM) << "Using Atomic Mode Setting.";
             m_atomicModeSetting = true;
 
             ScopedDrmPointer<drmModePlaneRes, &drmModeFreePlaneResources> planeResources(drmModeGetPlaneResources(m_fd));
             if (!planeResources) {
                 qCWarning(KWIN_DRM) << "Failed to get plane resources. Falling back to legacy mode";
                 m_atomicModeSetting = false;
             }
 
             if (m_atomicModeSetting) {
                 qCDebug(KWIN_DRM) << "Number of planes:" << planeResources->count_planes;
 
                 // create the plane objects
                 for (unsigned int i = 0; i < planeResources->count_planes; ++i) {
                     drmModePlane *kplane = drmModeGetPlane(m_fd, planeResources->planes[i]);
                     DrmPlane *p = new DrmPlane(kplane->plane_id, m_fd);
                     if (p->atomicInit()) {
                         m_planes << p;
                         if (p->type() == DrmPlane::TypeIndex::Overlay) {
                             m_overlayPlanes << p;
                         }
                     } else {
                         delete p;
                     }
                 }
 
                 if (m_planes.isEmpty()) {
                     qCWarning(KWIN_DRM) << "Failed to create any plane. Falling back to legacy mode";
                     m_atomicModeSetting = false;
                 }
             }
         } else {
             qCWarning(KWIN_DRM) << "drmSetClientCap for Atomic Mode Setting failed. Using legacy mode.";
         }
     }
 
     ScopedDrmPointer<_drmModeRes, &drmModeFreeResources> resources(drmModeGetResources(m_fd));
     drmModeRes *res = resources.data();
     if (!resources) {
         qCWarning(KWIN_DRM) << "drmModeGetResources failed";
         return;
     }
 
     for (int i = 0; i < res->count_connectors; ++i) {
         m_connectors << new DrmConnector(res->connectors[i], m_fd);
     }
     for (int i = 0; i < res->count_crtcs; ++i) {
         m_crtcs << new DrmCrtc(res->crtcs[i], this, i);
     }
 
     if (m_atomicModeSetting) {
         auto tryAtomicInit = [] (DrmObject *obj) -> bool {
             if (obj->atomicInit()) {
                 return false;
             } else {
                 delete obj;
                 return true;
             }
         };
         m_connectors.erase(std::remove_if(m_connectors.begin(), m_connectors.end(), tryAtomicInit), m_connectors.end());
         m_crtcs.erase(std::remove_if(m_crtcs.begin(), m_crtcs.end(), tryAtomicInit), m_crtcs.end());
     }
 
     initCursor();
     updateOutputs();
 
     if (m_outputs.isEmpty()) {
         qCWarning(KWIN_DRM) << "No outputs, cannot render, will terminate now";
         emit initFailed();
         return;
     }
 
     // setup udevMonitor
     if (m_udevMonitor) {
         m_udevMonitor->filterSubsystemDevType("drm");
         const int fd = m_udevMonitor->fd();
         if (fd != -1) {
             QSocketNotifier *notifier = new QSocketNotifier(fd, QSocketNotifier::Read, this);
             connect(notifier, &QSocketNotifier::activated, this,
                 [this] {
                     auto device = m_udevMonitor->getDevice();
                     if (!device) {
                         return;
                     }
                     if (device->sysNum() != m_drmId) {
                         return;
                     }
                     if (device->hasProperty("HOTPLUG", "1")) {
                         qCDebug(KWIN_DRM) << "Received hot plug event for monitored drm device";
                         updateOutputs();
                         updateCursor();
                     }
                 }
             );
             m_udevMonitor->enable();
         }
     }
     setReady(true);
 }
 
 void DrmBackend::updateOutputs()
 {
     if (m_fd < 0) {
         return;
     }
 
     ScopedDrmPointer<_drmModeRes, &drmModeFreeResources> resources(drmModeGetResources(m_fd));
     if (!resources) {
         qCWarning(KWIN_DRM) << "drmModeGetResources failed";
         return;
     }
 
     QVector<DrmOutput*> connectedOutputs;
     QVector<DrmConnector*> pendingConnectors;
 
     // split up connected connectors in already or not yet assigned ones
     for (DrmConnector *con : qAsConst(m_connectors)) {
         if (!con->isConnected()) {
             continue;
         }
 
         if (DrmOutput *o = findOutput(con->id())) {
             connectedOutputs << o;
         } else {
             pendingConnectors << con;
         }
     }
 
     // check for outputs which got removed
     auto it = m_outputs.begin();
     while (it != m_outputs.end()) {
         if (connectedOutputs.contains(*it)) {
             it++;
             continue;
         }
         DrmOutput *removed = *it;
         it = m_outputs.erase(it);
         m_enabledOutputs.removeOne(removed);
         emit outputRemoved(removed);
         removed->teardown();
     }
 
     // now check new connections
     for (DrmConnector *con : qAsConst(pendingConnectors)) {
         ScopedDrmPointer<_drmModeConnector, &drmModeFreeConnector> connector(drmModeGetConnector(m_fd, con->id()));
         if (!connector) {
             continue;
         }
         if (connector->count_modes == 0) {
             continue;
         }
         bool outputDone = false;
 
         QVector<uint32_t> encoders = con->encoders();
         for (auto encId : qAsConst(encoders)) {
             ScopedDrmPointer<_drmModeEncoder, &drmModeFreeEncoder> encoder(drmModeGetEncoder(m_fd, encId));
             if (!encoder) {
                 continue;
             }
             for (DrmCrtc *crtc : qAsConst(m_crtcs)) {
                 if (!(encoder->possible_crtcs & (1 << crtc->resIndex()))) {
                         continue;
                 }
 
                 // check if crtc isn't used yet -- currently we don't allow multiple outputs on one crtc (cloned mode)
                 auto it = std::find_if(connectedOutputs.constBegin(), connectedOutputs.constEnd(),
                     [crtc] (DrmOutput *o) {
                         return o->m_crtc == crtc;
                     }
                 );
                 if (it != connectedOutputs.constEnd()) {
                     continue;
                 }
 
                 // we found a suitable encoder+crtc
                 // TODO: we could avoid these lib drm calls if we store all struct data in DrmCrtc and DrmConnector in the beginning
                 ScopedDrmPointer<_drmModeCrtc, &drmModeFreeCrtc> modeCrtc(drmModeGetCrtc(m_fd, crtc->id()));
                 if (!modeCrtc) {
                     continue;
                 }
 
                 DrmOutput *output = new DrmOutput(this);
                 con->setOutput(output);
                 output->m_conn = con;
                 crtc->setOutput(output);
                 output->m_crtc = crtc;
                 connect(output, &DrmOutput::dpmsChanged, this, &DrmBackend::outputDpmsChanged);
 
                 if (modeCrtc->mode_valid) {
                     output->m_mode = modeCrtc->mode;
                 } else {
                     output->m_mode = connector->modes[0];
                 }
                 qCDebug(KWIN_DRM) << "For new output use mode " << output->m_mode.name;
 
                 if (!output->init(connector.data())) {
                     qCWarning(KWIN_DRM) << "Failed to create output for connector " << con->id();
                     delete output;
                     continue;
                 }
                 if (!output->initCursor(m_cursorSize)) {
                     setSoftWareCursor(true);
                 }
                 qCDebug(KWIN_DRM) << "Found new output with uuid" << output->uuid();
 
                 connectedOutputs << output;
                 emit outputAdded(output);
                 outputDone = true;
                 break;
             }
             if (outputDone) {
                 break;
             }
         }
     }
     std::sort(connectedOutputs.begin(), connectedOutputs.end(), [] (DrmOutput *a, DrmOutput *b) { return a->m_conn->id() < b->m_conn->id(); });
     m_outputs = connectedOutputs;
     m_enabledOutputs = connectedOutputs;
     readOutputsConfiguration();
     if (!m_outputs.isEmpty()) {
         emit screensQueried();
     }
 }
 
 void DrmBackend::readOutputsConfiguration()
 {
     if (m_outputs.isEmpty()) {
         return;
     }
     const QByteArray uuid = generateOutputConfigurationUuid();
     const auto outputGroup = kwinApp()->config()->group("DrmOutputs");
     const auto configGroup = outputGroup.group(uuid);
     // default position goes from left to right
     QPoint pos(0, 0);
     for (auto it = m_outputs.begin(); it != m_outputs.end(); ++it) {
         qCDebug(KWIN_DRM) << "Reading output configuration for [" << uuid << "] ["<< (*it)->uuid() << "]";
         const auto outputConfig = configGroup.group((*it)->uuid());
         (*it)->setGlobalPos(outputConfig.readEntry<QPoint>("Position", pos));
         // TODO: add mode
         (*it)->setScale(outputConfig.readEntry("Scale", 1.0));
         pos.setX(pos.x() + (*it)->geometry().width());
     }
 }
 
 QByteArray DrmBackend::generateOutputConfigurationUuid() const
 {
     auto it = m_outputs.constBegin();
     if (m_outputs.size() == 1) {
         // special case: one output
         return (*it)->uuid();
     }
     QCryptographicHash hash(QCryptographicHash::Md5);
     for (; it != m_outputs.constEnd(); ++it) {
         hash.addData((*it)->uuid());
     }
     return hash.result().toHex().left(10);
 }
 
 void DrmBackend::configurationChangeRequested(KWayland::Server::OutputConfigurationInterface *config)
 {
     const auto changes = config->changes();
     bool countChanged = false;
 
     //process all non-disabling changes
     for (auto it = changes.begin(); it != changes.end(); it++) {
         KWayland::Server::OutputChangeSet *changeset = it.value();
 
         auto drmoutput = findOutput(it.key()->uuid());
         if (drmoutput == nullptr) {
             qCWarning(KWIN_DRM) << "Could NOT find DrmOutput matching " << it.key()->uuid();
             continue;
         }
         if (changeset->enabledChanged() && changeset->enabled() == KWayland::Server::OutputDeviceInterface::Enablement::Enabled) {
             drmoutput->setEnabled(true);
             m_enabledOutputs << drmoutput;
             emit outputAdded(drmoutput);
             countChanged = true;
         }
         drmoutput->setChanges(changeset);
     }
     //process any disable requests
     for (auto it = changes.begin(); it != changes.end(); it++) {
         KWayland::Server::OutputChangeSet *changeset = it.value();
         if (changeset->enabledChanged() && changeset->enabled() == KWayland::Server::OutputDeviceInterface::Enablement::Disabled) {
             if (m_enabledOutputs.count() == 1) {
                 qCWarning(KWIN_DRM) << "Not disabling final screen" << it.key()->uuid();
                 continue;
             }
             auto drmoutput = findOutput(it.key()->uuid());
             if (drmoutput == nullptr) {
                 qCWarning(KWIN_DRM) << "Could NOT find DrmOutput matching " << it.key()->uuid();
                 continue;
             }
             drmoutput->setEnabled(false);
             m_enabledOutputs.removeOne(drmoutput);
             emit outputRemoved(drmoutput);
             countChanged = true;
         }
     }
 
     if (countChanged) {
         emit screensQueried();
     } else {
         emit screens()->changed();
     }
     // KCoreAddons needs kwayland's 2b3f9509ac1 to not crash
     if (KCoreAddons::version() >= QT_VERSION_CHECK(5, 39, 0)) {
         config->setApplied();
     }
 }
 
 DrmOutput *DrmBackend::findOutput(quint32 connector)
 {
     auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(), [connector] (DrmOutput *o) {
         return o->m_conn->id() == connector;
     });
     if (it != m_outputs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 DrmOutput *DrmBackend::findOutput(const QByteArray &uuid)
 {
     auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(), [uuid] (DrmOutput *o) {
         return o->m_uuid == uuid;
     });
     if (it != m_outputs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 void DrmBackend::present(DrmBuffer *buffer, DrmOutput *output)
 {
     if (!buffer || buffer->bufferId() == 0) {
         if (m_deleteBufferAfterPageFlip) {
             delete buffer;
         }
         return;
     }
 
     if (output->present(buffer)) {
         m_pageFlipsPending++;
         if (m_pageFlipsPending == 1 && Compositor::self()) {
             Compositor::self()->aboutToSwapBuffers();
         }
     } else if (m_deleteBufferAfterPageFlip) {
         delete buffer;
     }
 }
 
 void DrmBackend::initCursor()
 {
     m_cursorEnabled = waylandServer()->seat()->hasPointer();
     connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::hasPointerChanged, this,
         [this] {
             m_cursorEnabled = waylandServer()->seat()->hasPointer();
             if (usesSoftwareCursor()) {
                 return;
             }
             for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
                 if (m_cursorEnabled) {
                     if (!(*it)->showCursor()) {
                         setSoftWareCursor(true);
                     }
                 } else {
                     (*it)->hideCursor();
                 }
             }
         }
     );
     uint64_t capability = 0;
     QSize cursorSize;
     if (drmGetCap(m_fd, DRM_CAP_CURSOR_WIDTH, &capability) == 0) {
         cursorSize.setWidth(capability);
     } else {
         cursorSize.setWidth(64);
     }
     if (drmGetCap(m_fd, DRM_CAP_CURSOR_HEIGHT, &capability) == 0) {
         cursorSize.setHeight(capability);
     } else {
         cursorSize.setHeight(64);
     }
     m_cursorSize = cursorSize;
     // now we have screens and can set cursors, so start tracking
     connect(this, &DrmBackend::cursorChanged, this, &DrmBackend::updateCursor);
     connect(Cursor::self(), &Cursor::posChanged, this, &DrmBackend::moveCursor);
 }
 
 void DrmBackend::setCursor()
 {
     if (m_cursorEnabled) {
         for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
             if (!(*it)->showCursor()) {
                 setSoftWareCursor(true);
             }
         }
     }
     markCursorAsRendered();
 }
 
 void DrmBackend::updateCursor()
 {
     if (usesSoftwareCursor()) {
         return;
     }
     if (isCursorHidden()) {
         return;
     }
     const QImage &cursorImage = softwareCursor();
     if (cursorImage.isNull()) {
         doHideCursor();
         return;
     }
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->updateCursor();
     }
 
     setCursor();
     moveCursor();
 }
 
 void DrmBackend::doShowCursor()
 {
     updateCursor();
 }
 
 void DrmBackend::doHideCursor()
 {
     if (!m_cursorEnabled) {
         return;
     }
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->hideCursor();
     }
 }
 
 void DrmBackend::moveCursor()
 {
     if (!m_cursorEnabled || isCursorHidden()) {
         return;
     }
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->moveCursor(Cursor::pos());
     }
 }
 
 Screens *DrmBackend::createScreens(QObject *parent)
 {
     return new DrmScreens(this, parent);
 }
 
 QPainterBackend *DrmBackend::createQPainterBackend()
 {
     m_deleteBufferAfterPageFlip = false;
     return new DrmQPainterBackend(this);
 }
 
 OpenGLBackend *DrmBackend::createOpenGLBackend()
 {
 #if HAVE_GBM
     m_deleteBufferAfterPageFlip = true;
     return new EglGbmBackend(this);
 #else
     return Platform::createOpenGLBackend();
 #endif
 }
 
 DrmDumbBuffer *DrmBackend::createBuffer(const QSize &size)
 {
     DrmDumbBuffer *b = new DrmDumbBuffer(m_fd, size);
     return b;
 }
 
 #if HAVE_GBM
 DrmSurfaceBuffer *DrmBackend::createBuffer(const std::shared_ptr<GbmSurface> &surface)
 {
     DrmSurfaceBuffer *b = new DrmSurfaceBuffer(m_fd, surface);
     return b;
 }
 #endif
 
 void DrmBackend::outputDpmsChanged()
 {
     if (m_enabledOutputs.isEmpty()) {
         return;
     }
     bool enabled = false;
     for (auto it = m_enabledOutputs.constBegin(); it != m_enabledOutputs.constEnd(); ++it) {
         enabled = enabled || (*it)->isDpmsEnabled();
     }
     setOutputsEnabled(enabled);
 }
 
 QVector<CompositingType> DrmBackend::supportedCompositors() const
 {
 #if HAVE_GBM
     return QVector<CompositingType>{OpenGLCompositing, QPainterCompositing};
 #else
     return QVector<CompositingType>{QPainterCompositing};
 #endif
 }
 
 int DrmBackend::gammaRampSize(int screen) const
 {
   if (m_outputs.size() <= screen) {
       return 0;
   }
   return m_outputs.at(screen)->m_crtc->getGammaRampSize();
 }
 
 bool DrmBackend::setGammaRamp(int screen, ColorCorrect::GammaRamp &gamma)
 {
   if (m_outputs.size() <= screen) {
       return false;
   }
   return m_outputs.at(screen)->m_crtc->setGammaRamp(gamma);
 }
 
 QString DrmBackend::supportInformation() const
 {
     QString supportInfo;
     QDebug s(&supportInfo);
     s.nospace();
     s << "Name: " << "DRM" << endl;
     s << "Active: " << m_active << endl;
     s << "Atomic Mode Setting: " << m_atomicModeSetting << endl;
     return supportInfo;
 }
 
 }
diff --git a/plugins/platforms/drm/drm_backend.h b/plugins/platforms/drm/drm_backend.h
index 13af3121c..ae768cc0e 100644
--- a/plugins/platforms/drm/drm_backend.h
+++ b/plugins/platforms/drm/drm_backend.h
@@ -1,199 +1,203 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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_DRM_BACKEND_H
 #define KWIN_DRM_BACKEND_H
 #include "platform.h"
 #include "input.h"
 
 #include "drm_buffer.h"
 #if HAVE_GBM
 #include "drm_buffer_gbm.h"
 #endif
 #include "drm_inputeventfilter.h"
 #include "drm_pointer.h"
 
 #include <QElapsedTimer>
 #include <QImage>
 #include <QPointer>
 #include <QSize>
+#include <QVector>
 #include <xf86drmMode.h>
 
 #include <memory>
 
 struct gbm_bo;
 struct gbm_device;
 struct gbm_surface;
 
 namespace KWayland
 {
 namespace Server
 {
 class OutputInterface;
 class OutputDeviceInterface;
 class OutputChangeSet;
 class OutputManagementInterface;
 }
 }
 
 namespace KWin
 {
 
 namespace ColorCorrect {
 struct GammaRamp;
 }
 
 class Udev;
 class UdevMonitor;
 
 class DrmOutput;
 class DrmPlane;
 class DrmCrtc;
 class DrmConnector;
 class GbmSurface;
 
 
 class KWIN_EXPORT DrmBackend : public Platform
 {
     Q_OBJECT
     Q_INTERFACES(KWin::Platform)
     Q_PLUGIN_METADATA(IID "org.kde.kwin.Platform" FILE "drm.json")
 public:
     explicit DrmBackend(QObject *parent = nullptr);
     virtual ~DrmBackend();
 
     void configurationChangeRequested(KWayland::Server::OutputConfigurationInterface *config) override;
     Screens *createScreens(QObject *parent = nullptr) override;
     QPainterBackend *createQPainterBackend() override;
     OpenGLBackend* createOpenGLBackend() override;
 
     void init() override;
     DrmDumbBuffer *createBuffer(const QSize &size);
 #if HAVE_GBM
     DrmSurfaceBuffer *createBuffer(const std::shared_ptr<GbmSurface> &surface);
 #endif
     void present(DrmBuffer *buffer, DrmOutput *output);
 
     int fd() const {
         return m_fd;
     }
-    QVector<DrmOutput*> outputs() const {
+    Outputs outputs() const override;
+    Outputs enabledOutputs() const override;
+    QVector<DrmOutput*> drmOutputs() const {
         return m_outputs;
     }
-    QVector<DrmOutput*> enabledOutputs() const {
+    QVector<DrmOutput*> drmEnabledOutputs() const {
         return m_enabledOutputs;
     }
+
     QVector<DrmPlane*> planes() const {
         return m_planes;
     }
     QVector<DrmPlane*> overlayPlanes() const {
         return m_overlayPlanes;
     }
 
     void outputWentOff();
     void checkOutputsAreOn();
 
     // QPainter reuses buffers
     bool deleteBufferAfterPageFlip() const {
         return m_deleteBufferAfterPageFlip;
     }
     // returns use of AMS, default is not/legacy
     bool atomicModeSetting() const {
         return m_atomicModeSetting;
     }
 
     void setGbmDevice(gbm_device *device) {
         m_gbmDevice = device;
     }
     gbm_device *gbmDevice() const {
         return m_gbmDevice;
     }
     int gammaRampSize(int screen) const override;
     bool setGammaRamp(int screen, ColorCorrect::GammaRamp &gamma) override;
 
     QVector<CompositingType> supportedCompositors() const override;
 
     QString supportInformation() const override;
 
 public Q_SLOTS:
     void turnOutputsOn();
 
 Q_SIGNALS:
     /**
      * Emitted whenever an output is removed/disabled
      */
     void outputRemoved(KWin::DrmOutput *output);
     /**
      * Emitted whenever an output is added/enabled
      */
     void outputAdded(KWin::DrmOutput *output);
 
 protected:
 
     void doHideCursor() override;
     void doShowCursor() override;
 
 private:
     static void pageFlipHandler(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void *data);
     void openDrm();
     void activate(bool active);
     void reactivate();
     void deactivate();
     void updateOutputs();
     void setCursor();
     void updateCursor();
     void moveCursor();
     void initCursor();
     void outputDpmsChanged();
     void readOutputsConfiguration();
     QByteArray generateOutputConfigurationUuid() const;
     DrmOutput *findOutput(quint32 connector);
     DrmOutput *findOutput(const QByteArray &uuid);
     QScopedPointer<Udev> m_udev;
     QScopedPointer<UdevMonitor> m_udevMonitor;
     int m_fd = -1;
     int m_drmId = 0;
     // all crtcs
     QVector<DrmCrtc*> m_crtcs;
     // all connectors
     QVector<DrmConnector*> m_connectors;
     // active output pipelines (planes + crtc + encoder + connector)
     QVector<DrmOutput*> m_outputs;
     // active and enabled pipelines (above + wl_output)
     QVector<DrmOutput*> m_enabledOutputs;
 
     bool m_deleteBufferAfterPageFlip;
     bool m_atomicModeSetting = false;
     bool m_cursorEnabled = false;
     QSize m_cursorSize;
     int m_pageFlipsPending = 0;
     bool m_active = false;
     // all available planes: primarys, cursors and overlays
     QVector<DrmPlane*> m_planes;
     QVector<DrmPlane*> m_overlayPlanes;
     QScopedPointer<DpmsInputEventFilter> m_dpmsFilter;
     KWayland::Server::OutputManagementInterface *m_outputManagement = nullptr;
     gbm_device *m_gbmDevice = nullptr;
 };
 
 
 }
 
 #endif
 
diff --git a/plugins/platforms/drm/drm_output.cpp b/plugins/platforms/drm/drm_output.cpp
index 0d08ec440..9ed22ae42 100644
--- a/plugins/platforms/drm/drm_output.cpp
+++ b/plugins/platforms/drm/drm_output.cpp
@@ -1,1345 +1,1285 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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 "drm_output.h"
 #include "drm_backend.h"
 #include "drm_object_plane.h"
 #include "drm_object_crtc.h"
 #include "drm_object_connector.h"
 
 #include <errno.h>
 
 #include "composite.h"
 #include "logind.h"
 #include "logging.h"
 #include "main.h"
 #include "orientation_sensor.h"
 #include "screens_drm.h"
 #include "wayland_server.h"
 // KWayland
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/output_interface.h>
 #include <KWayland/Server/outputchangeset.h>
-#include <KWayland/Server/outputdevice_interface.h>
 #include <KWayland/Server/outputmanagement_interface.h>
 #include <KWayland/Server/outputconfiguration_interface.h>
 #include <KWayland/Server/xdgoutput_interface.h>
 // KF5
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 // Qt
 #include <QMatrix4x4>
 #include <QCryptographicHash>
 #include <QPainter>
 // drm
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 #include <libdrm/drm_mode.h>
 
-#include <cmath>
-
 namespace KWin
 {
 
 DrmOutput::DrmOutput(DrmBackend *backend)
-    : QObject()
+    : AbstractOutput(backend)
     , m_backend(backend)
 {
 }
 
 DrmOutput::~DrmOutput()
 {
     Q_ASSERT(!m_pageFlipPending);
     if (!m_deleted) {
         teardown();
     }
 }
 
 void DrmOutput::teardown()
 {
     m_deleted = true;
     hideCursor();
     m_crtc->blank();
 
     if (m_primaryPlane) {
         // TODO: when having multiple planes, also clean up these
         m_primaryPlane->setOutput(nullptr);
 
         if (m_backend->deleteBufferAfterPageFlip()) {
             delete m_primaryPlane->current();
         }
         m_primaryPlane->setCurrent(nullptr);
     }
 
     m_crtc->setOutput(nullptr);
     m_conn->setOutput(nullptr);
 
-    delete m_waylandOutput.data();
-    delete m_waylandOutputDevice.data();
     delete m_cursor[0];
     delete m_cursor[1];
     if (!m_pageFlipPending) {
         deleteLater();
     } //else will be deleted in the page flip handler
     //this is needed so that the pageflipcallback handle isn't deleted
 }
 
 void DrmOutput::releaseGbm()
 {
     if (DrmBuffer *b = m_crtc->current()) {
         b->releaseGbm();
     }
     if (m_primaryPlane && m_primaryPlane->current()) {
         m_primaryPlane->current()->releaseGbm();
     }
 }
 
 bool DrmOutput::hideCursor()
 {
     return drmModeSetCursor(m_backend->fd(), m_crtc->id(), 0, 0, 0) == 0;
 }
 
 bool DrmOutput::showCursor(DrmDumbBuffer *c)
 {
     const QSize &s = c->size();
     return drmModeSetCursor(m_backend->fd(), m_crtc->id(), c->handle(), s.width(), s.height()) == 0;
 }
 
 bool DrmOutput::showCursor()
 {
     const bool ret = showCursor(m_cursor[m_cursorIndex]);
     if (!ret) {
         return ret;
     }
 
     if (m_hasNewCursor) {
         m_cursorIndex = (m_cursorIndex + 1) % 2;
         m_hasNewCursor = false;
     }
 
     return ret;
 }
 
 void DrmOutput::updateCursor()
 {
     QImage cursorImage = m_backend->softwareCursor();
     if (cursorImage.isNull()) {
         return;
     }
     m_hasNewCursor = true;
     QImage *c = m_cursor[m_cursorIndex]->image();
     c->fill(Qt::transparent);
-    c->setDevicePixelRatio(m_scale);
+    c->setDevicePixelRatio(scale());
 
     QPainter p;
     p.begin(c);
-    if (m_orientation == Qt::InvertedLandscapeOrientation) {
+    if (orientation() == Qt::InvertedLandscapeOrientation) {
         QMatrix4x4 matrix;
         matrix.translate(cursorImage.width() / 2.0, cursorImage.height() / 2.0);
         matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
         matrix.translate(-cursorImage.width() / 2.0, -cursorImage.height() / 2.0);
         p.setWorldTransform(matrix.toTransform());
     }
     p.drawImage(QPoint(0, 0), cursorImage);
     p.end();
 }
 
 void DrmOutput::moveCursor(const QPoint &globalPos)
 {
     QMatrix4x4 matrix;
     QMatrix4x4 hotspotMatrix;
-    if (m_orientation == Qt::InvertedLandscapeOrientation) {
+    if (orientation() == Qt::InvertedLandscapeOrientation) {
         matrix.translate(pixelSize().width() /2.0, pixelSize().height() / 2.0);
         matrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
         matrix.translate(-pixelSize().width() /2.0, -pixelSize().height() / 2.0);
         const auto cursorSize = m_backend->softwareCursor().size();
         hotspotMatrix.translate(cursorSize.width()/2.0, cursorSize.height()/2.0);
         hotspotMatrix.rotate(180.0f, 0.0f, 0.0f, 1.0f);
         hotspotMatrix.translate(-cursorSize.width()/2.0, -cursorSize.height()/2.0);
     }
-    hotspotMatrix.scale(m_scale);
-    matrix.scale(m_scale);
-    matrix.translate(-m_globalPos.x(), -m_globalPos.y());
+    hotspotMatrix.scale(scale());
+    matrix.scale(scale());
+    const auto outputGlobalPos = AbstractOutput::globalPos();
+    matrix.translate(-outputGlobalPos.x(), -outputGlobalPos.y());
     const QPoint p = matrix.map(globalPos) - hotspotMatrix.map(m_backend->softwareCursorHotspot());
     drmModeMoveCursor(m_backend->fd(), m_crtc->id(), p.x(), p.y());
 }
 
 QSize DrmOutput::pixelSize() const
 {
-    if (m_orientation == Qt::PortraitOrientation || m_orientation == Qt::InvertedPortraitOrientation) {
+    auto orient = orientation();
+    if (orient == Qt::PortraitOrientation || orient == Qt::InvertedPortraitOrientation) {
         return QSize(m_mode.vdisplay, m_mode.hdisplay);
     }
     return QSize(m_mode.hdisplay, m_mode.vdisplay);
 }
 
-QSize DrmOutput::physicalSize() const
-{
-    if (m_orientation == Qt::PortraitOrientation || m_orientation == Qt::InvertedPortraitOrientation) {
-        return QSize(m_physicalSize.height(), m_physicalSize.width());
-    }
-    return m_physicalSize;
-}
-
-QRect DrmOutput::geometry() const
-{
-    return QRect(m_globalPos, pixelSize() / m_scale);
-}
-
-qreal DrmOutput::scale() const
-{
-    return m_scale;
-}
-
 void DrmOutput::setEnabled(bool enabled)
 {
     if (enabled == isEnabled()) {
         return;
     }
     if (enabled) {
         setDpms(DpmsMode::On);
         initOutput();
     } else {
         setDpms(DpmsMode::Off);
-        delete m_waylandOutput.data();
+        delete waylandOutput().data();
     }
-    m_waylandOutputDevice->setEnabled(enabled ?
+    waylandOutputDevice()->setEnabled(enabled ?
     KWayland::Server::OutputDeviceInterface::Enablement::Enabled : KWayland::Server::OutputDeviceInterface::Enablement::Disabled);
 }
 
-bool DrmOutput::isEnabled() const
-{
-    return !m_waylandOutput.isNull();
-}
-
 static KWayland::Server::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode)
 {
     using namespace KWayland::Server;
     switch (mode) {
     case DrmOutput::DpmsMode::On:
         return OutputInterface::DpmsMode::On;
     case DrmOutput::DpmsMode::Standby:
         return OutputInterface::DpmsMode::Standby;
     case DrmOutput::DpmsMode::Suspend:
         return OutputInterface::DpmsMode::Suspend;
     case DrmOutput::DpmsMode::Off:
         return OutputInterface::DpmsMode::Off;
     default:
         Q_UNREACHABLE();
     }
 }
 
 static DrmOutput::DpmsMode fromWaylandDpmsMode(KWayland::Server::OutputInterface::DpmsMode wlMode)
 {
     using namespace KWayland::Server;
     switch (wlMode) {
     case OutputInterface::DpmsMode::On:
         return DrmOutput::DpmsMode::On;
     case OutputInterface::DpmsMode::Standby:
         return DrmOutput::DpmsMode::Standby;
     case OutputInterface::DpmsMode::Suspend:
         return DrmOutput::DpmsMode::Suspend;
     case OutputInterface::DpmsMode::Off:
         return DrmOutput::DpmsMode::Off;
     default:
         Q_UNREACHABLE();
     }
 }
 
 static QHash<int, QByteArray> s_connectorNames = {
     {DRM_MODE_CONNECTOR_Unknown, QByteArrayLiteral("Unknown")},
     {DRM_MODE_CONNECTOR_VGA, QByteArrayLiteral("VGA")},
     {DRM_MODE_CONNECTOR_DVII, QByteArrayLiteral("DVI-I")},
     {DRM_MODE_CONNECTOR_DVID, QByteArrayLiteral("DVI-D")},
     {DRM_MODE_CONNECTOR_DVIA, QByteArrayLiteral("DVI-A")},
     {DRM_MODE_CONNECTOR_Composite, QByteArrayLiteral("Composite")},
     {DRM_MODE_CONNECTOR_SVIDEO, QByteArrayLiteral("SVIDEO")},
     {DRM_MODE_CONNECTOR_LVDS, QByteArrayLiteral("LVDS")},
     {DRM_MODE_CONNECTOR_Component, QByteArrayLiteral("Component")},
     {DRM_MODE_CONNECTOR_9PinDIN, QByteArrayLiteral("DIN")},
     {DRM_MODE_CONNECTOR_DisplayPort, QByteArrayLiteral("DP")},
     {DRM_MODE_CONNECTOR_HDMIA, QByteArrayLiteral("HDMI-A")},
     {DRM_MODE_CONNECTOR_HDMIB, QByteArrayLiteral("HDMI-B")},
     {DRM_MODE_CONNECTOR_TV, QByteArrayLiteral("TV")},
     {DRM_MODE_CONNECTOR_eDP, QByteArrayLiteral("eDP")},
     {DRM_MODE_CONNECTOR_VIRTUAL, QByteArrayLiteral("Virtual")},
     {DRM_MODE_CONNECTOR_DSI, QByteArrayLiteral("DSI")}
 };
 
 namespace {
 quint64 refreshRateForMode(_drmModeModeInfo *m)
 {
     // Calculate higher precision (mHz) refresh rate
     // logic based on Weston, see compositor-drm.c
     quint64 refreshRate = (m->clock * 1000000LL / m->htotal + m->vtotal / 2) / m->vtotal;
     if (m->flags & DRM_MODE_FLAG_INTERLACE) {
         refreshRate *= 2;
     }
     if (m->flags & DRM_MODE_FLAG_DBLSCAN) {
         refreshRate /= 2;
     }
     if (m->vscan > 1) {
         refreshRate /= m->vscan;
     }
     return refreshRate;
 }
 }
 
 bool DrmOutput::init(drmModeConnector *connector)
 {
     initEdid(connector);
     initDpms(connector);
     initUuid();
     if (m_backend->atomicModeSetting()) {
         if (!initPrimaryPlane()) {
             return false;
         }
     } else if (!m_crtc->blank()) {
         return false;
     }
 
-    m_internal = connector->connector_type == DRM_MODE_CONNECTOR_LVDS || connector->connector_type == DRM_MODE_CONNECTOR_eDP;
+    setInternal(connector->connector_type == DRM_MODE_CONNECTOR_LVDS || connector->connector_type == DRM_MODE_CONNECTOR_eDP);
 
-    if (m_internal) {
+    if (internal()) {
         connect(kwinApp(), &Application::screensCreated, this,
             [this] {
                 connect(screens()->orientationSensor(), &OrientationSensor::orientationChanged, this, &DrmOutput::automaticRotation);
             }
         );
     }
 
     QSize physicalSize = !m_edid.physicalSize.isEmpty() ? m_edid.physicalSize : QSize(connector->mmWidth, connector->mmHeight);
     // the size might be completely borked. E.g. Samsung SyncMaster 2494HS reports 160x90 while in truth it's 520x292
     // as this information is used to calculate DPI info, it's going to result in everything being huge
     const QByteArray unknown = QByteArrayLiteral("unknown");
     KConfigGroup group = kwinApp()->config()->group("EdidOverwrite").group(m_edid.eisaId.isEmpty() ? unknown : m_edid.eisaId)
                                                        .group(m_edid.monitorName.isEmpty() ? unknown : m_edid.monitorName)
                                                        .group(m_edid.serialNumber.isEmpty() ? unknown : m_edid.serialNumber);
     if (group.hasKey("PhysicalSize")) {
         const QSize overwriteSize = group.readEntry("PhysicalSize", physicalSize);
         qCWarning(KWIN_DRM) << "Overwriting monitor physical size for" << m_edid.eisaId << "/" << m_edid.monitorName << "/" << m_edid.serialNumber << " from " << physicalSize << "to " << overwriteSize;
         physicalSize = overwriteSize;
     }
-    m_physicalSize = physicalSize;
+    setRawPhysicalSize(physicalSize);
 
     initOutputDevice(connector);
 
     setEnabled(true);
     return true;
 }
 
 void DrmOutput::initUuid()
 {
     QCryptographicHash hash(QCryptographicHash::Md5);
     hash.addData(QByteArray::number(m_conn->id()));
     hash.addData(m_edid.eisaId);
     hash.addData(m_edid.monitorName);
     hash.addData(m_edid.serialNumber);
     m_uuid = hash.result().toHex().left(10);
 }
 
 void DrmOutput::initOutput()
 {
-    Q_ASSERT(m_waylandOutputDevice);
-    if (!m_waylandOutput.isNull()) {
-        delete m_waylandOutput.data();
-        m_waylandOutput.clear();
+    auto wlOutputDevice = waylandOutputDevice();
+    Q_ASSERT(wlOutputDevice);
+
+    auto wlOutput = waylandOutput();
+    if (!wlOutput.isNull()) {
+        delete wlOutput.data();
+        wlOutput.clear();
     }
-    m_waylandOutput = waylandServer()->display()->createOutput();
-    m_xdgOutput = waylandServer()->xdgOutputManager()->createXdgOutput(m_waylandOutput, m_waylandOutput);
+    wlOutput = waylandServer()->display()->createOutput();
+    setWaylandOutput(wlOutput.data());
+    createXdgOutput();
     connect(this, &DrmOutput::modeChanged, this,
         [this] {
-            if (m_waylandOutput.isNull()) {
+            auto wlOutput = waylandOutput();
+            if (wlOutput.isNull()) {
                 return;
             }
-            m_waylandOutput->setCurrentMode(QSize(m_mode.hdisplay, m_mode.vdisplay), refreshRateForMode(&m_mode));
-            if (m_xdgOutput) {
-                m_xdgOutput->setLogicalSize(pixelSize() / m_scale);
-                m_xdgOutput->done();
+            wlOutput->setCurrentMode(QSize(m_mode.hdisplay, m_mode.vdisplay),
+                                          refreshRateForMode(&m_mode));
+            auto xdg = xdgOutput();
+            if (xdg) {
+                xdg->setLogicalSize(pixelSize() / scale());
+                xdg->done();
             }
         }
     );
-    m_waylandOutput->setManufacturer(m_waylandOutputDevice->manufacturer());
-    m_waylandOutput->setModel(m_waylandOutputDevice->model());
-    m_waylandOutput->setPhysicalSize(m_physicalSize);
+    wlOutput->setManufacturer(wlOutputDevice->manufacturer());
+    wlOutput->setModel(wlOutputDevice->model());
+    wlOutput->setPhysicalSize(rawPhysicalSize());
 
     // set dpms
     if (!m_dpms.isNull()) {
-        m_waylandOutput->setDpmsSupported(true);
-        m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsMode));
-        connect(m_waylandOutput.data(), &KWayland::Server::OutputInterface::dpmsModeRequested, this,
+        wlOutput->setDpmsSupported(true);
+        wlOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsMode));
+        connect(wlOutput.data(), &KWayland::Server::OutputInterface::dpmsModeRequested, this,
             [this] (KWayland::Server::OutputInterface::DpmsMode mode) {
                 setDpms(fromWaylandDpmsMode(mode));
             }, Qt::QueuedConnection
         );
     }
 
-    for(const auto &mode: m_waylandOutputDevice->modes()) {
+    for(const auto &mode: wlOutputDevice->modes()) {
         KWayland::Server::OutputInterface::ModeFlags flags;
         if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Current) {
             flags |= KWayland::Server::OutputInterface::ModeFlag::Current;
         }
         if (mode.flags & KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred) {
             flags |= KWayland::Server::OutputInterface::ModeFlag::Preferred;
         }
-        m_waylandOutput->addMode(mode.size, flags, mode.refreshRate);
+        wlOutput->addMode(mode.size, flags, mode.refreshRate);
     }
 
-    m_waylandOutput->create();
+    wlOutput->create();
 }
 
 void DrmOutput::initOutputDevice(drmModeConnector *connector)
 {
-    if (!m_waylandOutputDevice.isNull()) {
-        delete m_waylandOutputDevice.data();
-        m_waylandOutputDevice.clear();
+    auto wlOutputDevice = waylandOutputDevice();
+    if (!wlOutputDevice.isNull()) {
+        delete wlOutputDevice.data();
+        wlOutputDevice.clear();
     }
-    m_waylandOutputDevice = waylandServer()->display()->createOutputDevice();
-    m_waylandOutputDevice->setUuid(m_uuid);
+    wlOutputDevice = waylandServer()->display()->createOutputDevice();
+    wlOutputDevice->setUuid(m_uuid);
 
     if (!m_edid.eisaId.isEmpty()) {
-        m_waylandOutputDevice->setManufacturer(QString::fromLatin1(m_edid.eisaId));
+        wlOutputDevice->setManufacturer(QString::fromLatin1(m_edid.eisaId));
     } else {
-        m_waylandOutputDevice->setManufacturer(i18n("unknown"));
+        wlOutputDevice->setManufacturer(i18n("unknown"));
     }
 
     QString connectorName = s_connectorNames.value(connector->connector_type, QByteArrayLiteral("Unknown"));
     QString modelName;
 
     if (!m_edid.monitorName.isEmpty()) {
         QString model = QString::fromLatin1(m_edid.monitorName);
         if (!m_edid.serialNumber.isEmpty()) {
             model.append('/');
             model.append(QString::fromLatin1(m_edid.serialNumber));
         }
         modelName = model;
     } else if (!m_edid.serialNumber.isEmpty()) {
         modelName = QString::fromLatin1(m_edid.serialNumber);
     } else {
         modelName = i18n("unknown");
     }
 
-    m_waylandOutputDevice->setModel(connectorName + QStringLiteral("-") + QString::number(connector->connector_type_id) + QStringLiteral("-") + modelName);
+    wlOutputDevice->setModel(connectorName + QStringLiteral("-") + QString::number(connector->connector_type_id) + QStringLiteral("-") + modelName);
 
-    m_waylandOutputDevice->setPhysicalSize(m_physicalSize);
+    wlOutputDevice->setPhysicalSize(rawPhysicalSize());
 
     // read in mode information
     for (int i = 0; i < connector->count_modes; ++i) {
         // TODO: in AMS here we could read and store for later every mode's blob_id
         // would simplify isCurrentMode(..) and presentAtomically(..) in case of mode set
         auto *m = &connector->modes[i];
         KWayland::Server::OutputDeviceInterface::ModeFlags deviceflags;
         if (isCurrentMode(m)) {
             deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Current;
         }
         if (m->type & DRM_MODE_TYPE_PREFERRED) {
             deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred;
         }
 
         const auto refreshRate = refreshRateForMode(m);
 
         KWayland::Server::OutputDeviceInterface::Mode mode;
         mode.id = i;
         mode.size = QSize(m->hdisplay, m->vdisplay);
         mode.flags = deviceflags;
         mode.refreshRate = refreshRate;
         qCDebug(KWIN_DRM) << "Adding mode: " << i << mode.size;
-        m_waylandOutputDevice->addMode(mode);
+        wlOutputDevice->addMode(mode);
     }
-    m_waylandOutputDevice->create();
+    wlOutputDevice->create();
+    setWaylandOutputDevice(wlOutputDevice.data());
 }
 
 bool DrmOutput::isCurrentMode(const drmModeModeInfo *mode) const
 {
     return mode->clock       == m_mode.clock
         && mode->hdisplay    == m_mode.hdisplay
         && mode->hsync_start == m_mode.hsync_start
         && mode->hsync_end   == m_mode.hsync_end
         && mode->htotal      == m_mode.htotal
         && mode->hskew       == m_mode.hskew
         && mode->vdisplay    == m_mode.vdisplay
         && mode->vsync_start == m_mode.vsync_start
         && mode->vsync_end   == m_mode.vsync_end
         && mode->vtotal      == m_mode.vtotal
         && mode->vscan       == m_mode.vscan
         && mode->vrefresh    == m_mode.vrefresh
         && mode->flags       == m_mode.flags
         && mode->type        == m_mode.type
         && qstrcmp(mode->name, m_mode.name) == 0;
 }
 
 static bool verifyEdidHeader(drmModePropertyBlobPtr edid)
 {
     const uint8_t *data = reinterpret_cast<uint8_t*>(edid->data);
     if (data[0] != 0x00) {
         return false;
     }
     for (int i = 1; i < 7; ++i) {
         if (data[i] != 0xFF) {
             return false;
         }
     }
     if (data[7] != 0x00) {
         return false;
     }
     return true;
 }
 
 static QByteArray extractEisaId(drmModePropertyBlobPtr edid)
 {
     /*
      * From EDID standard section 3.4:
      * The ID Manufacturer Name field, shown in Table 3.5, contains a 2-byte representation of the monitor's
      * manufacturer. This is the same as the EISA ID. It is based on compressed ASCII, “0001=A” ... “11010=Z”.
      *
      * The table:
      * | Byte |        Bit                    |
      * |      | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
      * ----------------------------------------
      * |  1   | 0)| (4| 3 | 2 | 1 | 0)| (4| 3 |
      * |      | * |    Character 1    | Char 2|
      * ----------------------------------------
      * |  2   | 2 | 1 | 0)| (4| 3 | 2 | 1 | 0)|
      * |      | Character2|      Character 3  |
      * ----------------------------------------
      **/
     const uint8_t *data = reinterpret_cast<uint8_t*>(edid->data);
     static const uint offset = 0x8;
     char id[4];
     if (data[offset] >> 7) {
         // bit at position 7 is not a 0
         return QByteArray();
     }
     // shift two bits to right, and with 7 right most bits
     id[0] = 'A' + ((data[offset] >> 2) & 0x1f) -1;
     // for first byte: take last two bits and shift them 3 to left (000xx000)
     // for second byte: shift 5 bits to right and take 3 right most bits (00000xxx)
     // or both together
     id[1] = 'A' + (((data[offset] & 0x3) << 3) | ((data[offset + 1] >> 5) & 0x7)) - 1;
     // take five right most bits
     id[2] = 'A' + (data[offset + 1] & 0x1f) - 1;
     id[3] = '\0';
     return QByteArray(id);
 }
 
 static void extractMonitorDescriptorDescription(drmModePropertyBlobPtr blob, DrmOutput::Edid &edid)
 {
     // see section 3.10.3
     const uint8_t *data = reinterpret_cast<uint8_t*>(blob->data);
     static const uint offset = 0x36;
     static const uint blockLength = 18;
     for (int i = 0; i < 5; ++i) {
         const uint co = offset + i * blockLength;
         // Flag = 0000h when block used as descriptor
         if (data[co] != 0) {
             continue;
         }
         if (data[co + 1] != 0) {
             continue;
         }
         // Reserved = 00h when block used as descriptor
         if (data[co + 2] != 0) {
             continue;
         }
         /*
          * FFh: Monitor Serial Number - Stored as ASCII, code page # 437, ≤ 13 bytes.
          * FEh: ASCII String - Stored as ASCII, code page # 437, ≤ 13 bytes.
          * FDh: Monitor range limits, binary coded
          * FCh: Monitor name, stored as ASCII, code page # 437
          * FBh: Descriptor contains additional color point data
          * FAh: Descriptor contains additional Standard Timing Identifications
          * F9h - 11h: Currently undefined
          * 10h: Dummy descriptor, used to indicate that the descriptor space is unused
          * 0Fh - 00h: Descriptor defined by manufacturer.
          */
         if (data[co + 3] == 0xfc && edid.monitorName.isEmpty()) {
             edid.monitorName = QByteArray((const char *)(&data[co + 5]), 12).trimmed();
         }
         if (data[co + 3] == 0xfe) {
             const QByteArray id = QByteArray((const char *)(&data[co + 5]), 12).trimmed();
             if (!id.isEmpty()) {
                 edid.eisaId = id;
             }
         }
         if (data[co + 3] == 0xff) {
             edid.serialNumber = QByteArray((const char *)(&data[co + 5]), 12).trimmed();
         }
     }
 }
 
 static QByteArray extractSerialNumber(drmModePropertyBlobPtr edid)
 {
     // see section 3.4
     const uint8_t *data = reinterpret_cast<uint8_t*>(edid->data);
     static const uint offset = 0x0C;
     /*
      * The ID serial number is a 32-bit serial number used to differentiate between individual instances of the same model
      * of monitor. Its use is optional. When used, the bit order for this field follows that shown in Table 3.6. The EDID
      * structure Version 1 Revision 1 and later offer a way to represent the serial number of the monitor as an ASCII string
      * in a separate descriptor block.
      */
     uint32_t serialNumber = 0;
     serialNumber  = (uint32_t) data[offset + 0];
     serialNumber |= (uint32_t) data[offset + 1] << 8;
     serialNumber |= (uint32_t) data[offset + 2] << 16;
     serialNumber |= (uint32_t) data[offset + 3] << 24;
     if (serialNumber == 0) {
         return QByteArray();
     }
     return QByteArray::number(serialNumber);
 }
 
 static QSize extractPhysicalSize(drmModePropertyBlobPtr edid)
 {
     const uint8_t *data = reinterpret_cast<uint8_t*>(edid->data);
     return QSize(data[0x15], data[0x16]) * 10;
 }
 
 void DrmOutput::initEdid(drmModeConnector *connector)
 {
     ScopedDrmPointer<_drmModePropertyBlob, &drmModeFreePropertyBlob> edid;
     for (int i = 0; i < connector->count_props; ++i) {
         ScopedDrmPointer<_drmModeProperty, &drmModeFreeProperty> property(drmModeGetProperty(m_backend->fd(), connector->props[i]));
         if (!property) {
             continue;
         }
         if ((property->flags & DRM_MODE_PROP_BLOB) && qstrcmp(property->name, "EDID") == 0) {
             edid.reset(drmModeGetPropertyBlob(m_backend->fd(), connector->prop_values[i]));
         }
     }
     if (!edid) {
         return;
     }
 
     // for documentation see: http://read.pudn.com/downloads110/ebook/456020/E-EDID%20Standard.pdf
     if (edid->length < 128) {
         return;
     }
     if (!verifyEdidHeader(edid.data())) {
         return;
     }
     m_edid.eisaId = extractEisaId(edid.data());
     m_edid.serialNumber = extractSerialNumber(edid.data());
 
     // parse monitor descriptor description
     extractMonitorDescriptorDescription(edid.data(), m_edid);
 
     m_edid.physicalSize = extractPhysicalSize(edid.data());
 }
 
 bool DrmOutput::initPrimaryPlane()
 {
     for (int i = 0; i < m_backend->planes().size(); ++i) {
         DrmPlane* p = m_backend->planes()[i];
         if (!p) {
             continue;
         }
         if (p->type() != DrmPlane::TypeIndex::Primary) {
             continue;
         }
         if (p->output()) {     // Plane already has an output
             continue;
         }
         if (m_primaryPlane) {     // Output already has a primary plane
             continue;
         }
         if (!p->isCrtcSupported(m_crtc->resIndex())) {
             continue;
         }
         p->setOutput(this);
         m_primaryPlane = p;
         qCDebug(KWIN_DRM) << "Initialized primary plane" << p->id() << "on CRTC" << m_crtc->id();
         return true;
     }
     qCCritical(KWIN_DRM) << "Failed to initialize primary plane.";
     return false;
 }
 
 bool DrmOutput::initCursorPlane()       // TODO: Add call in init (but needs layer support in general first)
 {
     for (int i = 0; i < m_backend->planes().size(); ++i) {
         DrmPlane* p = m_backend->planes()[i];
         if (!p) {
             continue;
         }
         if (p->type() != DrmPlane::TypeIndex::Cursor) {
             continue;
         }
         if (p->output()) {     // Plane already has an output
             continue;
         }
         if (m_cursorPlane) {     // Output already has a cursor plane
             continue;
         }
         if (!p->isCrtcSupported(m_crtc->resIndex())) {
             continue;
         }
         p->setOutput(this);
         m_cursorPlane = p;
         qCDebug(KWIN_DRM) << "Initialized cursor plane" << p->id() << "on CRTC" << m_crtc->id();
         return true;
     }
     return false;
 }
 
 void DrmOutput::initDpms(drmModeConnector *connector)
 {
     for (int i = 0; i < connector->count_props; ++i) {
         ScopedDrmPointer<_drmModeProperty, &drmModeFreeProperty> property(drmModeGetProperty(m_backend->fd(), connector->props[i]));
         if (!property) {
             continue;
         }
         if (qstrcmp(property->name, "DPMS") == 0) {
             m_dpms.swap(property);
             break;
         }
     }
 }
 
 void DrmOutput::setDpms(DrmOutput::DpmsMode mode)
 {
     if (m_dpms.isNull()) {
         return;
     }
     if (mode == m_dpmsModePending) {
         qCDebug(KWIN_DRM) << "New DPMS mode equals old mode. DPMS unchanged.";
         return;
     }
 
     m_dpmsModePending = mode;
 
     if (m_backend->atomicModeSetting()) {
         m_modesetRequested = true;
         if (mode == DpmsMode::On) {
             if (m_pageFlipPending) {
                 m_pageFlipPending = false;
                 Compositor::self()->bufferSwapComplete();
             }
             dpmsOnHandler();
         } else {
             m_dpmsAtomicOffPending = true;
             if (!m_pageFlipPending) {
                 dpmsAtomicOff();
             }
         }
     } else {
         if (drmModeConnectorSetProperty(m_backend->fd(), m_conn->id(), m_dpms->prop_id, uint64_t(mode)) < 0) {
             m_dpmsModePending = m_dpmsMode;
             qCWarning(KWIN_DRM) << "Setting DPMS failed";
             return;
         }
         if (mode == DpmsMode::On) {
             dpmsOnHandler();
         } else {
             dpmsOffHandler();
         }
         m_dpmsMode = m_dpmsModePending;
     }
 }
 
 void DrmOutput::dpmsOnHandler()
 {
     qCDebug(KWIN_DRM) << "DPMS mode set for output" << m_crtc->id() << "to On.";
 
-    if (m_waylandOutput) {
-        m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
+    auto wlOutput = waylandOutput();
+    if (wlOutput) {
+        wlOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
     }
     emit dpmsChanged();
 
     m_backend->checkOutputsAreOn();
     if (!m_backend->atomicModeSetting()) {
         m_crtc->blank();
     }
     if (Compositor *compositor = Compositor::self()) {
         compositor->addRepaintFull();
     }
 }
 
 void DrmOutput::dpmsOffHandler()
 {
     qCDebug(KWIN_DRM) << "DPMS mode set for output" << m_crtc->id() << "to Off.";
 
-    if (m_waylandOutput) {
-        m_waylandOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
+    auto wlOutput = waylandOutput();
+    if (wlOutput) {
+        wlOutput->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
     }
     emit dpmsChanged();
 
     m_backend->outputWentOff();
 }
 
-QString DrmOutput::name() const
-{
-    if (!m_waylandOutput) {
-        return i18n("unknown");
-    }
-    return QStringLiteral("%1 %2").arg(m_waylandOutput->manufacturer()).arg(m_waylandOutput->model());
-}
-
 int DrmOutput::currentRefreshRate() const
 {
-    if (!m_waylandOutput) {
+    auto wlOutput = waylandOutput();
+    if (!wlOutput) {
         return 60000;
     }
-    return m_waylandOutput->refreshRate();
-}
-
-void DrmOutput::setGlobalPos(const QPoint &pos)
-{
-    m_globalPos = pos;
-    if (m_waylandOutput) {
-        m_waylandOutput->setGlobalPosition(pos);
-    }
-    if (m_waylandOutputDevice) {
-        m_waylandOutputDevice->setGlobalPosition(pos);
-    }
-    if (m_xdgOutput) {
-        m_xdgOutput->setLogicalPosition(pos);
-        m_xdgOutput->done();
-    }
-}
-
-void DrmOutput::setScale(qreal scale)
-{
-    m_scale = scale;
-    if (m_waylandOutput) {
-        // this is the scale that clients will ideally use for their buffers
-        // this has to be an int which is fine
-
-        // I don't know whether we want to round or ceil
-        // or maybe even set this to 3 when we're scaling to 1.5
-        // don't treat this like it's chosen deliberately
-        m_waylandOutput->setScale(std::ceil(scale));
-    }
-    if (m_waylandOutputDevice) {
-        m_waylandOutputDevice->setScaleF(scale);
-    }
-    if (m_xdgOutput) {
-        m_xdgOutput->setLogicalSize(pixelSize() / m_scale);
-        m_xdgOutput->done();
-    }
-}
-
-void DrmOutput::setChanges(KWayland::Server::OutputChangeSet *changes)
-{
-    m_changeset = changes;
-    qCDebug(KWIN_DRM) << "set changes in DrmOutput";
-    commitChanges();
+    return wlOutput->refreshRate();
 }
 
 bool DrmOutput::commitChanges()
 {
-    Q_ASSERT(!m_waylandOutputDevice.isNull());
+    auto wlOutputDevice = waylandOutputDevice();
+    Q_ASSERT(!wlOutputDevice.isNull());
 
-    if (m_changeset.isNull()) {
+    auto changeset = changes();
+
+    if (changeset.isNull()) {
         qCDebug(KWIN_DRM) << "no changes";
         // No changes to an output is an entirely valid thing
         return true;
     }
     //enabledChanged is handled by drmbackend
-    if (m_changeset->modeChanged()) {
-        qCDebug(KWIN_DRM) << "Setting new mode:" << m_changeset->mode();
-        m_waylandOutputDevice->setCurrentMode(m_changeset->mode());
-        updateMode(m_changeset->mode());
-    }
-    if (m_changeset->transformChanged()) {
-        qCDebug(KWIN_DRM) << "Server setting transform: " << (int)(m_changeset->transform());
-        transform(m_changeset->transform());
-    }
-    if (m_changeset->positionChanged()) {
-        qCDebug(KWIN_DRM) << "Server setting position: " << m_changeset->position();
-        setGlobalPos(m_changeset->position());
+    if (changeset->modeChanged()) {
+        qCDebug(KWIN_DRM) << "Setting new mode:" << changeset->mode();
+        wlOutputDevice->setCurrentMode(changeset->mode());
+        updateMode(changeset->mode());
+    }
+    if (changeset->transformChanged()) {
+        qCDebug(KWIN_DRM) << "Server setting transform: " << (int)(changeset->transform());
+        transform(changeset->transform());
+    }
+    if (changeset->positionChanged()) {
+        qCDebug(KWIN_DRM) << "Server setting position: " << changeset->position();
+        setGlobalPos(changeset->position());
         // may just work already!
     }
-    if (m_changeset->scaleChanged()) {
-        qCDebug(KWIN_DRM) << "Setting scale:" << m_changeset->scale();
-        setScale(m_changeset->scaleF());
+    if (changeset->scaleChanged()) {
+        qCDebug(KWIN_DRM) << "Setting scale:" << changeset->scale();
+        setScale(changeset->scaleF());
     }
     return true;
 }
 
 void DrmOutput::transform(KWayland::Server::OutputDeviceInterface::Transform transform)
 {
-    m_waylandOutputDevice->setTransform(transform);
+    waylandOutputDevice()->setTransform(transform);
     using KWayland::Server::OutputDeviceInterface;
     using KWayland::Server::OutputInterface;
+    auto wlOutput = waylandOutput();
+
     switch (transform) {
     case OutputDeviceInterface::Transform::Normal:
         if (m_primaryPlane) {
             m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate0);
         }
-        if (m_waylandOutput) {
-            m_waylandOutput->setTransform(OutputInterface::Transform::Normal);
+        if (wlOutput) {
+            wlOutput->setTransform(OutputInterface::Transform::Normal);
         }
-        m_orientation = Qt::PrimaryOrientation;
+        setOrientation(Qt::PrimaryOrientation);
         break;
     case OutputDeviceInterface::Transform::Rotated90:
         if (m_primaryPlane) {
             m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate90);
         }
-        if (m_waylandOutput) {
-            m_waylandOutput->setTransform(OutputInterface::Transform::Rotated90);
+        if (wlOutput) {
+            wlOutput->setTransform(OutputInterface::Transform::Rotated90);
         }
-        m_orientation = Qt::PortraitOrientation;
+        setOrientation(Qt::PortraitOrientation);
         break;
     case OutputDeviceInterface::Transform::Rotated180:
         if (m_primaryPlane) {
             m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate180);
         }
-        if (m_waylandOutput) {
-            m_waylandOutput->setTransform(OutputInterface::Transform::Rotated180);
+        if (wlOutput) {
+            wlOutput->setTransform(OutputInterface::Transform::Rotated180);
         }
-        m_orientation = Qt::InvertedLandscapeOrientation;
+        setOrientation(Qt::InvertedLandscapeOrientation);
         break;
     case OutputDeviceInterface::Transform::Rotated270:
         if (m_primaryPlane) {
             m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate270);
         }
-        if (m_waylandOutput) {
-            m_waylandOutput->setTransform(OutputInterface::Transform::Rotated270);
+        if (wlOutput) {
+            wlOutput->setTransform(OutputInterface::Transform::Rotated270);
         }
-        m_orientation = Qt::InvertedPortraitOrientation;
+        setOrientation(Qt::InvertedPortraitOrientation);
         break;
     case OutputDeviceInterface::Transform::Flipped:
         // TODO: what is this exactly?
-        if (m_waylandOutput) {
-            m_waylandOutput->setTransform(OutputInterface::Transform::Flipped);
+        if (wlOutput) {
+            wlOutput->setTransform(OutputInterface::Transform::Flipped);
         }
         break;
     case OutputDeviceInterface::Transform::Flipped90:
         // TODO: what is this exactly?
-        if (m_waylandOutput) {
-            m_waylandOutput->setTransform(OutputInterface::Transform::Flipped90);
+        if (wlOutput) {
+            wlOutput->setTransform(OutputInterface::Transform::Flipped90);
         }
         break;
     case OutputDeviceInterface::Transform::Flipped180:
         // TODO: what is this exactly?
-        if (m_waylandOutput) {
-            m_waylandOutput->setTransform(OutputInterface::Transform::Flipped180);
+        if (wlOutput) {
+            wlOutput->setTransform(OutputInterface::Transform::Flipped180);
         }
         break;
     case OutputDeviceInterface::Transform::Flipped270:
         // TODO: what is this exactly?
-        if (m_waylandOutput) {
-            m_waylandOutput->setTransform(OutputInterface::Transform::Flipped270);
+        if (wlOutput) {
+            wlOutput->setTransform(OutputInterface::Transform::Flipped270);
         }
         break;
     }
     m_modesetRequested = true;
     // the cursor might need to get rotated
     updateCursor();
     showCursor();
     emit modeChanged();
 }
 
 void DrmOutput::updateMode(int modeIndex)
 {
     // get all modes on the connector
     ScopedDrmPointer<_drmModeConnector, &drmModeFreeConnector> connector(drmModeGetConnector(m_backend->fd(), m_conn->id()));
     if (connector->count_modes <= modeIndex) {
         // TODO: error?
         return;
     }
     if (isCurrentMode(&connector->modes[modeIndex])) {
         // nothing to do
         return;
     }
     m_mode = connector->modes[modeIndex];
     m_modesetRequested = true;
     emit modeChanged();
 }
 
 void DrmOutput::pageFlipped()
 {
     m_pageFlipPending = false;
     if (m_deleted) {
         deleteLater();
         return;
     }
 
     if (!m_crtc) {
         return;
     }
     // Egl based surface buffers get destroyed, QPainter based dumb buffers not
     // TODO: split up DrmOutput in two for dumb and egl/gbm surface buffer compatible subclasses completely?
     if (m_backend->deleteBufferAfterPageFlip()) {
         if (m_backend->atomicModeSetting()) {
             if (!m_primaryPlane->next()) {
                 // on manual vt switch
                 // TODO: when we later use overlay planes it might happen, that we have a page flip with only
                 //       damage on one of these, and therefore the primary plane has no next buffer
                 //       -> Then we don't want to return here!
                 if (m_primaryPlane->current()) {
                     m_primaryPlane->current()->releaseGbm();
                 }
                 return;
             }
             for (DrmPlane *p : m_nextPlanesFlipList) {
                 p->flipBufferWithDelete();
             }
             m_nextPlanesFlipList.clear();
         } else {
             if (!m_crtc->next()) {
                 // on manual vt switch
                 if (DrmBuffer *b = m_crtc->current()) {
                     b->releaseGbm();
                 }
             }
             m_crtc->flipBuffer();
         }
     } else {
         if (m_backend->atomicModeSetting()){
             for (DrmPlane *p : m_nextPlanesFlipList) {
                 p->flipBuffer();
             }
             m_nextPlanesFlipList.clear();
         } else {
             m_crtc->flipBuffer();
         }
         m_crtc->flipBuffer();
     }
 }
 
 bool DrmOutput::present(DrmBuffer *buffer)
 {
     if (m_backend->atomicModeSetting()) {
         return presentAtomically(buffer);
     } else {
         return presentLegacy(buffer);
     }
 }
 
 bool DrmOutput::dpmsAtomicOff()
 {
     m_dpmsAtomicOffPending = false;
 
     // TODO: With multiple planes: deactivate all of them here
     delete m_primaryPlane->next();
     m_primaryPlane->setNext(nullptr);
     m_nextPlanesFlipList << m_primaryPlane;
 
     if (!doAtomicCommit(AtomicCommitMode::Test)) {
         qCDebug(KWIN_DRM) << "Atomic test commit to Dpms Off failed. Aborting.";
         return false;
     }
     if (!doAtomicCommit(AtomicCommitMode::Real)) {
         qCDebug(KWIN_DRM) << "Atomic commit to Dpms Off failed. This should have never happened! Aborting.";
         return false;
     }
     m_nextPlanesFlipList.clear();
     dpmsOffHandler();
 
     return true;
 
 }
 
 bool DrmOutput::presentAtomically(DrmBuffer *buffer)
 {
     if (!LogindIntegration::self()->isActiveSession()) {
         qCWarning(KWIN_DRM) << "Logind session not active.";
         return false;
     }
 
     if (m_pageFlipPending) {
         qCWarning(KWIN_DRM) << "Page not yet flipped.";
         return false;
     }
 
     m_primaryPlane->setNext(buffer);
     m_nextPlanesFlipList << m_primaryPlane;
 
     if (!doAtomicCommit(AtomicCommitMode::Test)) {
         //TODO: When we use planes for layered rendering, fallback to renderer instead. Also for direct scanout?
         //TODO: Probably should undo setNext and reset the flip list
         qCDebug(KWIN_DRM) << "Atomic test commit failed. Aborting present.";
         // go back to previous state
         if (m_lastWorkingState.valid) {
             m_mode = m_lastWorkingState.mode;
-            m_orientation = m_lastWorkingState.orientation;
+            setOrientation(m_lastWorkingState.orientation);
             setGlobalPos(m_lastWorkingState.globalPos);
             if (m_primaryPlane) {
                 m_primaryPlane->setTransformation(m_lastWorkingState.planeTransformations);
             }
             m_modesetRequested = true;
             // the cursor might need to get rotated
             updateCursor();
             showCursor();
             // TODO: forward to OutputInterface and OutputDeviceInterface
             emit modeChanged();
             emit screens()->changed();
         }
         return false;
     }
     const bool wasModeset = m_modesetRequested;
     if (!doAtomicCommit(AtomicCommitMode::Real)) {
         qCDebug(KWIN_DRM) << "Atomic commit failed. This should have never happened! Aborting present.";
         //TODO: Probably should undo setNext and reset the flip list
         return false;
     }
     if (wasModeset) {
         // store current mode set as new good state
         m_lastWorkingState.mode = m_mode;
-        m_lastWorkingState.orientation = m_orientation;
-        m_lastWorkingState.globalPos = m_globalPos;
+        m_lastWorkingState.orientation = orientation();
+        m_lastWorkingState.globalPos = globalPos();
         if (m_primaryPlane) {
             m_lastWorkingState.planeTransformations = m_primaryPlane->transformation();
         }
         m_lastWorkingState.valid = true;
     }
     m_pageFlipPending = true;
     return true;
 }
 
 bool DrmOutput::presentLegacy(DrmBuffer *buffer)
 {
     if (m_crtc->next()) {
         return false;
     }
     if (!LogindIntegration::self()->isActiveSession()) {
         m_crtc->setNext(buffer);
         return false;
     }
     if (m_dpmsMode != DpmsMode::On) {
         return false;
     }
 
     // Do we need to set a new mode first?
     if (!m_crtc->current() || m_crtc->current()->needsModeChange(buffer)) {
         if (!setModeLegacy(buffer)) {
             return false;
         }
     }
     const bool ok = drmModePageFlip(m_backend->fd(), m_crtc->id(), buffer->bufferId(), DRM_MODE_PAGE_FLIP_EVENT, this) == 0;
     if (ok) {
         m_crtc->setNext(buffer);
     } else {
         qCWarning(KWIN_DRM) << "Page flip failed:" << strerror(errno);
     }
     return ok;
 }
 
 bool DrmOutput::setModeLegacy(DrmBuffer *buffer)
 {
     uint32_t connId = m_conn->id();
     if (drmModeSetCrtc(m_backend->fd(), m_crtc->id(), buffer->bufferId(), 0, 0, &connId, 1, &m_mode) == 0) {
         return true;
     } else {
         qCWarning(KWIN_DRM) << "Mode setting failed";
         return false;
     }
 }
 
 bool DrmOutput::doAtomicCommit(AtomicCommitMode mode)
 {
     drmModeAtomicReq *req = drmModeAtomicAlloc();
 
     auto errorHandler = [this, mode, req] () {
         if (mode == AtomicCommitMode::Test) {
             // TODO: when we later test overlay planes, make sure we change only the right stuff back
         }
         if (req) {
             drmModeAtomicFree(req);
         }
 
         if (m_dpmsMode != m_dpmsModePending) {
             qCWarning(KWIN_DRM) << "Setting DPMS failed";
             m_dpmsModePending = m_dpmsMode;
             if (m_dpmsMode != DpmsMode::On) {
                 dpmsOffHandler();
             }
         }
 
         // TODO: see above, rework later for overlay planes!
         for (DrmPlane *p : m_nextPlanesFlipList) {
             p->setNext(nullptr);
         }
         m_nextPlanesFlipList.clear();
 
     };
 
     if (!req) {
             qCWarning(KWIN_DRM) << "DRM: couldn't allocate atomic request";
             errorHandler();
             return false;
     }
 
     uint32_t flags = 0;
 
     // Do we need to set a new mode?
     if (m_modesetRequested) {
         if (m_dpmsModePending == DpmsMode::On) {
             if (drmModeCreatePropertyBlob(m_backend->fd(), &m_mode, sizeof(m_mode), &m_blobId) != 0) {
                 qCWarning(KWIN_DRM) << "Failed to create property blob";
                 errorHandler();
                 return false;
             }
         }
         if (!atomicReqModesetPopulate(req, m_dpmsModePending == DpmsMode::On)){
             qCWarning(KWIN_DRM) << "Failed to populate Atomic Modeset";
             errorHandler();
             return false;
         }
         flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
     }
 
     if (mode == AtomicCommitMode::Real) {
         if (m_dpmsModePending == DpmsMode::On) {
             if (!(flags & DRM_MODE_ATOMIC_ALLOW_MODESET)) {
                 // TODO: Evaluating this condition should only be necessary, as long as we expect older kernels than 4.10.
                 flags |= DRM_MODE_ATOMIC_NONBLOCK;
             }
             flags |= DRM_MODE_PAGE_FLIP_EVENT;
         }
     } else {
         flags |= DRM_MODE_ATOMIC_TEST_ONLY;
     }
 
     bool ret = true;
     // TODO: Make sure when we use more than one plane at a time, that we go through this list in the right order.
     for (int i = m_nextPlanesFlipList.size() - 1; 0 <= i; i-- ) {
         DrmPlane *p = m_nextPlanesFlipList[i];
         ret &= p->atomicPopulate(req);
     }
 
     if (!ret) {
         qCWarning(KWIN_DRM) << "Failed to populate atomic planes. Abort atomic commit!";
         errorHandler();
         return false;
     }
 
     if (drmModeAtomicCommit(m_backend->fd(), req, flags, this)) {
         qCWarning(KWIN_DRM) << "Atomic request failed to commit:" << strerror(errno);
         errorHandler();
         return false;
     }
 
     if (mode == AtomicCommitMode::Real && (flags & DRM_MODE_ATOMIC_ALLOW_MODESET)) {
         qCDebug(KWIN_DRM) << "Atomic Modeset successful.";
         m_modesetRequested = false;
         m_dpmsMode = m_dpmsModePending;
     }
 
     drmModeAtomicFree(req);
     return true;
 }
 
 bool DrmOutput::atomicReqModesetPopulate(drmModeAtomicReq *req, bool enable)
 {
     if (enable) {
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcX), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcY), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcW), m_mode.hdisplay << 16);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcH), m_mode.vdisplay << 16);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcW), m_mode.hdisplay);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcH), m_mode.vdisplay);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcId), m_crtc->id());
     } else {
         if (m_backend->deleteBufferAfterPageFlip()) {
             delete m_primaryPlane->current();
             delete m_primaryPlane->next();
         }
         m_primaryPlane->setCurrent(nullptr);
         m_primaryPlane->setNext(nullptr);
 
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcX), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcY), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcW), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcH), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcW), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcH), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcId), 0);
     }
     m_conn->setValue(int(DrmConnector::PropertyIndex::CrtcId), enable ? m_crtc->id() : 0);
     m_crtc->setValue(int(DrmCrtc::PropertyIndex::ModeId), enable ? m_blobId : 0);
     m_crtc->setValue(int(DrmCrtc::PropertyIndex::Active), enable);
 
     bool ret = true;
     ret &= m_conn->atomicPopulate(req);
     ret &= m_crtc->atomicPopulate(req);
 
     return ret;
 }
 
 bool DrmOutput::initCursor(const QSize &cursorSize)
 {
     auto createCursor = [this, cursorSize] (int index) {
         m_cursor[index] = m_backend->createBuffer(cursorSize);
         if (!m_cursor[index]->map(QImage::Format_ARGB32_Premultiplied)) {
             return false;
         }
         return true;
     };
     if (!createCursor(0) || !createCursor(1)) {
         return false;
     }
     return true;
 }
 
 bool DrmOutput::supportsTransformations() const
 {
     if (!m_primaryPlane) {
         return false;
     }
     const auto transformations = m_primaryPlane->supportedTransformations();
     return transformations.testFlag(DrmPlane::Transformation::Rotate90)
         || transformations.testFlag(DrmPlane::Transformation::Rotate180)
         || transformations.testFlag(DrmPlane::Transformation::Rotate270);
 }
 
 void DrmOutput::automaticRotation()
 {
     if (!m_primaryPlane) {
         return;
     }
     const auto supportedTransformations = m_primaryPlane->supportedTransformations();
     const auto requestedTransformation = screens()->orientationSensor()->orientation();
     using KWayland::Server::OutputDeviceInterface;
     OutputDeviceInterface::Transform newTransformation = OutputDeviceInterface::Transform::Normal;
     switch (requestedTransformation) {
     case OrientationSensor::Orientation::TopUp:
         newTransformation = OutputDeviceInterface::Transform::Normal;
         break;
     case OrientationSensor::Orientation::TopDown:
         if (!supportedTransformations.testFlag(DrmPlane::Transformation::Rotate180)) {
             return;
         }
         newTransformation = OutputDeviceInterface::Transform::Rotated180;
         break;
     case OrientationSensor::Orientation::LeftUp:
         if (!supportedTransformations.testFlag(DrmPlane::Transformation::Rotate90)) {
             return;
         }
         newTransformation = OutputDeviceInterface::Transform::Rotated90;
         break;
     case OrientationSensor::Orientation::RightUp:
         if (!supportedTransformations.testFlag(DrmPlane::Transformation::Rotate270)) {
             return;
         }
         newTransformation = OutputDeviceInterface::Transform::Rotated270;
         break;
     case OrientationSensor::Orientation::FaceUp:
     case OrientationSensor::Orientation::FaceDown:
     case OrientationSensor::Orientation::Undefined:
         // unsupported
         return;
     }
     transform(newTransformation);
     emit screens()->changed();
 }
 
 }
diff --git a/plugins/platforms/drm/drm_output.h b/plugins/platforms/drm/drm_output.h
index 63aac844a..c1b6a02bd 100644
--- a/plugins/platforms/drm/drm_output.h
+++ b/plugins/platforms/drm/drm_output.h
@@ -1,229 +1,181 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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_DRM_OUTPUT_H
 #define KWIN_DRM_OUTPUT_H
 
+#include "abstract_output.h"
 #include "drm_pointer.h"
 #include "drm_object.h"
 #include "drm_object_plane.h"
 
 #include <QObject>
 #include <QPoint>
-#include <QPointer>
 #include <QSize>
 #include <QVector>
 #include <xf86drmMode.h>
 
 #include <KWayland/Server/outputdevice_interface.h>
 
-namespace KWayland
-{
-namespace Server
-{
-class OutputInterface;
-class OutputDeviceInterface;
-class OutputChangeSet;
-class OutputManagementInterface;
-class XdgOutputInterface;
-}
-}
-
 namespace KWin
 {
 
 class DrmBackend;
 class DrmBuffer;
 class DrmDumbBuffer;
 class DrmPlane;
 class DrmConnector;
 class DrmCrtc;
 
-class DrmOutput : public QObject
+class KWIN_EXPORT DrmOutput : public AbstractOutput
 {
     Q_OBJECT
 public:
     struct Edid {
         QByteArray eisaId;
         QByteArray monitorName;
         QByteArray serialNumber;
         QSize physicalSize;
     };
     ///deletes the output, calling this whilst a page flip is pending will result in an error
     ~DrmOutput() override;
     ///queues deleting the output after a page flip has completed.
     void teardown();
     void releaseGbm();
     bool showCursor(DrmDumbBuffer *buffer);
     bool showCursor();
     bool hideCursor();
     void updateCursor();
     void moveCursor(const QPoint &globalPos);
     bool init(drmModeConnector *connector);
     bool present(DrmBuffer *buffer);
     void pageFlipped();
 
     /**
      * Enable or disable the output.
      * This differs from setDpms as it also
      * removes the wl_output
      * The default is on
      */
     void setEnabled(bool enabled);
-    bool isEnabled() const;
-
-    /**
-     * This sets the changes and tests them against the DRM output
-     */
-    void setChanges(KWayland::Server::OutputChangeSet *changeset);
-    bool commitChanges();
 
-    QSize pixelSize() const;
-    qreal scale() const;
+    bool commitChanges() override;
 
-    /*
-     * The geometry of this output in global compositor co-ordinates (i.e scaled)
-     */
-    QRect geometry() const;
+    QSize pixelSize() const override;
 
-    QString name() const;
     int currentRefreshRate() const;
     // These values are defined by the kernel
     enum class DpmsMode {
         On = DRM_MODE_DPMS_ON,
         Standby = DRM_MODE_DPMS_STANDBY,
         Suspend = DRM_MODE_DPMS_SUSPEND,
         Off = DRM_MODE_DPMS_OFF
     };
     void setDpms(DpmsMode mode);
     bool isDpmsEnabled() const {
         // We care for current as well as pending mode in order to allow first present in AMS.
         return m_dpmsModePending == DpmsMode::On;
     }
 
     QByteArray uuid() const {
         return m_uuid;
     }
 
-    QSize physicalSize() const;
-
     bool initCursor(const QSize &cursorSize);
 
     bool supportsTransformations() const;
 
-    bool isInternal() const {
-        return m_internal;
-    }
-
-    Qt::ScreenOrientation orientation() const {
-        return m_orientation;
-    }
-
-    const QPointer<KWayland::Server::OutputInterface> getWaylandInterface() const {
-        return m_waylandOutput;
-    }
-
 Q_SIGNALS:
     void dpmsChanged();
     void modeChanged();
 
 private:
     friend class DrmBackend;
     friend class DrmCrtc;   // TODO: For use of setModeLegacy. Remove later when we allow multiple connectors per crtc
                             //       and save the connector ids in the DrmCrtc instance.
     DrmOutput(DrmBackend *backend);
 
     bool presentAtomically(DrmBuffer *buffer);
 
     enum class AtomicCommitMode {
         Test,
         Real
     };
     bool doAtomicCommit(AtomicCommitMode mode);
 
     bool presentLegacy(DrmBuffer *buffer);
     bool setModeLegacy(DrmBuffer *buffer);
     void initEdid(drmModeConnector *connector);
     void initDpms(drmModeConnector *connector);
     void initOutputDevice(drmModeConnector *connector);
 
     bool isCurrentMode(const drmModeModeInfo *mode) const;
     void initUuid();
-    void setGlobalPos(const QPoint &pos);
-    void setScale(qreal scale);
     void initOutput();
     bool initPrimaryPlane();
     bool initCursorPlane();
 
     void dpmsOnHandler();
     void dpmsOffHandler();
     bool dpmsAtomicOff();
     bool atomicReqModesetPopulate(drmModeAtomicReq *req, bool enable);
     void updateMode(int modeIndex);
 
     void transform(KWayland::Server::OutputDeviceInterface::Transform transform);
     void automaticRotation();
 
     DrmBackend *m_backend;
     DrmConnector *m_conn = nullptr;
     DrmCrtc *m_crtc = nullptr;
-    QPoint m_globalPos;
-    qreal m_scale = 1;
     bool m_lastGbm = false;
     drmModeModeInfo m_mode;
     Edid m_edid;
-    QPointer<KWayland::Server::OutputInterface> m_waylandOutput;
-    QPointer<KWayland::Server::XdgOutputInterface> m_xdgOutput;
-    QPointer<KWayland::Server::OutputDeviceInterface> m_waylandOutputDevice;
-    QPointer<KWayland::Server::OutputChangeSet> m_changeset;
     KWin::ScopedDrmPointer<_drmModeProperty, &drmModeFreeProperty> m_dpms;
     DpmsMode m_dpmsMode = DpmsMode::On;
     DpmsMode m_dpmsModePending = DpmsMode::On;
     QByteArray m_uuid;
 
     uint32_t m_blobId = 0;
     DrmPlane* m_primaryPlane = nullptr;
     DrmPlane* m_cursorPlane = nullptr;
     QVector<DrmPlane*> m_nextPlanesFlipList;
     bool m_pageFlipPending = false;
     bool m_dpmsAtomicOffPending = false;
     bool m_modesetRequested = true;
-    QSize m_physicalSize;
-    Qt::ScreenOrientation m_orientation = Qt::PrimaryOrientation;
 
     struct {
         Qt::ScreenOrientation orientation;
         drmModeModeInfo mode;
         DrmPlane::Transformations planeTransformations;
         QPoint globalPos;
         bool valid = false;
     } m_lastWorkingState;
     DrmDumbBuffer *m_cursor[2] = {nullptr, nullptr};
     int m_cursorIndex = 0;
     bool m_hasNewCursor = false;
     bool m_internal = false;
     bool m_deleted = false;
 };
 
 }
 
 Q_DECLARE_METATYPE(KWin::DrmOutput*)
 
 #endif
 
diff --git a/plugins/platforms/drm/egl_gbm_backend.cpp b/plugins/platforms/drm/egl_gbm_backend.cpp
index 2ee3c55e1..48ec495b2 100644
--- a/plugins/platforms/drm/egl_gbm_backend.cpp
+++ b/plugins/platforms/drm/egl_gbm_backend.cpp
@@ -1,426 +1,426 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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 "egl_gbm_backend.h"
 // kwin
 #include "composite.h"
 #include "drm_backend.h"
 #include "drm_output.h"
 #include "gbm_surface.h"
 #include "logging.h"
 #include "options.h"
 #include "screens.h"
 // kwin libs
 #include <kwinglplatform.h>
 // Qt
 #include <QOpenGLContext>
 // system
 #include <gbm.h>
 
 namespace KWin
 {
 
 EglGbmBackend::EglGbmBackend(DrmBackend *b)
     : AbstractEglBackend()
     , m_backend(b)
 {
     // Egl is always direct rendering
     setIsDirectRendering(true);
     setSyncsToVBlank(true);
     connect(m_backend, &DrmBackend::outputAdded, this, &EglGbmBackend::createOutput);
     connect(m_backend, &DrmBackend::outputRemoved, this,
         [this] (DrmOutput *output) {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                 [output] (const Output &o) {
                     return o.output == output;
                 }
             );
             if (it == m_outputs.end()) {
                 return;
             }
             cleanupOutput(*it);
             m_outputs.erase(it);
         }
     );
 }
 
 EglGbmBackend::~EglGbmBackend()
 {
     cleanup();
 }
 
 void EglGbmBackend::cleanupSurfaces()
 {
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         cleanupOutput(*it);
     }
     m_outputs.clear();
 }
 
 void EglGbmBackend::cleanupOutput(const Output &o)
 {
     o.output->releaseGbm();
 
     if (o.eglSurface != EGL_NO_SURFACE) {
         eglDestroySurface(eglDisplay(), o.eglSurface);
     }
 }
 
 bool EglGbmBackend::initializeEgl()
 {
     initClientExtensions();
     EGLDisplay display = m_backend->sceneEglDisplay();
 
     // Use eglGetPlatformDisplayEXT() to get the display pointer
     // if the implementation supports it.
     if (display == EGL_NO_DISPLAY) {
         const bool hasMesaGBM = hasClientExtension(QByteArrayLiteral("EGL_MESA_platform_gbm"));
         const bool hasKHRGBM = hasClientExtension(QByteArrayLiteral("EGL_KHR_platform_gbm"));
         const GLenum platform = hasMesaGBM ? EGL_PLATFORM_GBM_MESA : EGL_PLATFORM_GBM_KHR;
 
         if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base")) ||
                 (!hasMesaGBM && !hasKHRGBM)) {
             setFailed("missing one or more extensions between EGL_EXT_platform_base,  EGL_MESA_platform_gbm, EGL_KHR_platform_gbm");
             return false;
         }
 
         auto device = gbm_create_device(m_backend->fd());
         if (!device) {
             setFailed("Could not create gbm device");
             return false;
         }
         m_backend->setGbmDevice(device);
 
         display = eglGetPlatformDisplayEXT(platform, device, nullptr);
     }
 
     if (display == EGL_NO_DISPLAY)
         return false;
     setEglDisplay(display);
     return initEglAPI();
 }
 
 void EglGbmBackend::init()
 {
     if (!initializeEgl()) {
         setFailed("Could not initialize egl");
         return;
     }
     if (!initRenderingContext()) {
         setFailed("Could not initialize rendering context");
         return;
     }
 
     initKWinGL();
     initBufferAge();
     initWayland();
     initRemotePresent();
 }
 
 bool EglGbmBackend::initRenderingContext()
 {
     initBufferConfigs();
 
     if (!createContext()) {
         return false;
     }
 
-    const auto outputs = m_backend->outputs();
+    const auto outputs = m_backend->drmOutputs();
     for (DrmOutput *drmOutput: outputs) {
         createOutput(drmOutput);
     }
     if (m_outputs.isEmpty()) {
         qCCritical(KWIN_DRM) << "Create Window Surfaces failed";
         return false;
     }
     // set our first surface as the one for the abstract backend, just to make it happy
     setSurface(m_outputs.first().eglSurface);
 
     return makeContextCurrent(m_outputs.first());
 }
 
 void EglGbmBackend::initRemotePresent()
 {
     if (qEnvironmentVariableIsSet("KWIN_NO_REMOTE")) {
         return;
     }
 
     qCDebug(KWIN_DRM) << "Support for remote access enabled";
     m_remoteaccessManager.reset(new RemoteAccessManager);
 }
 
 bool EglGbmBackend::resetOutput(Output &o, DrmOutput *drmOutput)
 {
     o.output = drmOutput;
     auto size = drmOutput->pixelSize();
 
     auto gbmSurface = std::make_shared<GbmSurface>(m_backend->gbmDevice(), size.width(), size.height(),
                                         GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
     if (!gbmSurface) {
         qCCritical(KWIN_DRM) << "Create gbm surface failed";
         return false;
     }
     auto eglSurface = eglCreatePlatformWindowSurfaceEXT(eglDisplay(), config(), (void *)(gbmSurface->surface()), nullptr);
     if (eglSurface == EGL_NO_SURFACE) {
         qCCritical(KWIN_DRM) << "Create Window Surface failed";
         return false;
     } else {
         // destroy previous surface
         if (o.eglSurface != EGL_NO_SURFACE) {
             if (surface() == o.eglSurface) {
                 setSurface(eglSurface);
             }
             eglDestroySurface(eglDisplay(), o.eglSurface);
         }
         o.eglSurface = eglSurface;
         o.gbmSurface = gbmSurface;
     }
     return true;
 }
 
 void EglGbmBackend::createOutput(DrmOutput *drmOutput)
 {
     Output o;
     if (resetOutput(o, drmOutput)) {
         connect(drmOutput, &DrmOutput::modeChanged, this,
             [drmOutput, this] {
                 auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                     [drmOutput] (const auto &o) {
                         return o.output == drmOutput;
                     }
                 );
                 if (it == m_outputs.end()) {
                     return;
                 }
                 resetOutput(*it, drmOutput);
             }
         );
         m_outputs << o;
     }
 }
 
 bool EglGbmBackend::makeContextCurrent(const Output &output)
 {
     const EGLSurface surface = output.eglSurface;
     if (surface == EGL_NO_SURFACE) {
         return false;
     }
     if (eglMakeCurrent(eglDisplay(), surface, surface, context()) == EGL_FALSE) {
         qCCritical(KWIN_DRM) << "Make Context Current failed";
         return false;
     }
 
     EGLint error = eglGetError();
     if (error != EGL_SUCCESS) {
         qCWarning(KWIN_DRM) << "Error occurred while creating context " << error;
         return false;
     }
     // TODO: ensure the viewport is set correctly each time
     const QSize &overall = screens()->size();
     const QRect &v = output.output->geometry();
     // TODO: are the values correct?
 
     qreal scale = output.output->scale();
 
     glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
                overall.width() * scale, overall.height() * scale);
     return true;
 }
 
 bool EglGbmBackend::initBufferConfigs()
 {
     const EGLint config_attribs[] = {
         EGL_SURFACE_TYPE,         EGL_WINDOW_BIT,
         EGL_RED_SIZE,             1,
         EGL_GREEN_SIZE,           1,
         EGL_BLUE_SIZE,            1,
         EGL_ALPHA_SIZE,           0,
         EGL_RENDERABLE_TYPE,      isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
         EGL_CONFIG_CAVEAT,        EGL_NONE,
         EGL_NONE,
     };
 
     EGLint count;
     EGLConfig configs[1024];
     if (!eglChooseConfig(eglDisplay(), config_attribs, configs, sizeof(configs)/sizeof(EGLConfig), &count)) {
         qCCritical(KWIN_DRM) << "choose config failed";
         return false;
     }
 
     qCDebug(KWIN_DRM) << "EGL buffer configs count:" << count;
 
     // loop through all configs, chosing the first one that has suitable format
     for (EGLint i = 0; i < count; i++) {
         EGLint gbmFormat;
         // query some configuration parameters, to show in debug log
         eglGetConfigAttrib(eglDisplay(), configs[i], EGL_NATIVE_VISUAL_ID, &gbmFormat);
 
         if (KWIN_DRM().isDebugEnabled()) {
             // GBM formats are declared as FOURCC code (integer from ASCII chars, so use this fact)
             char gbmFormatStr[sizeof(EGLint) + 1] = {0};
             memcpy(gbmFormatStr, &gbmFormat, sizeof(EGLint));
             // query number of bits for color channel
             EGLint blueSize, redSize, greenSize, alphaSize;
             eglGetConfigAttrib(eglDisplay(), configs[i], EGL_RED_SIZE, &redSize);
             eglGetConfigAttrib(eglDisplay(), configs[i], EGL_GREEN_SIZE, &greenSize);
             eglGetConfigAttrib(eglDisplay(), configs[i], EGL_BLUE_SIZE, &blueSize);
             eglGetConfigAttrib(eglDisplay(), configs[i], EGL_ALPHA_SIZE, &alphaSize);
             qCDebug(KWIN_DRM) << "  EGL config #" << i << " has GBM FOURCC format:" << gbmFormatStr
                               << "; color sizes (RGBA order):" << redSize << greenSize << blueSize << alphaSize;
         }
 
         if ((gbmFormat == GBM_FORMAT_XRGB8888) || (gbmFormat == GBM_FORMAT_ARGB8888)) {
             setConfig(configs[i]);
             return true;
         }
     }
 
     qCCritical(KWIN_DRM) << "choose EGL config did not return a suitable config" << count;
     return false;
 }
 
 void EglGbmBackend::present()
 {
     for (auto &o: m_outputs) {
         makeContextCurrent(o);
         presentOnOutput(o);
     }
 }
 
 void EglGbmBackend::presentOnOutput(EglGbmBackend::Output &o)
 {
     eglSwapBuffers(eglDisplay(), o.eglSurface);
     o.buffer = m_backend->createBuffer(o.gbmSurface);
     if(m_remoteaccessManager && gbm_surface_has_free_buffers(o.gbmSurface->surface())) {
         // GBM surface is released on page flip so
         // we should pass the buffer before it's presented
         m_remoteaccessManager->passBuffer(o.output, o.buffer);
     }
     m_backend->present(o.buffer, o.output);
 
     if (supportsBufferAge()) {
         eglQuerySurface(eglDisplay(), o.eglSurface, EGL_BUFFER_AGE_EXT, &o.bufferAge);
     }
 
 }
 
 void EglGbmBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
     // TODO, create new buffer?
 }
 
 SceneOpenGLTexturePrivate *EglGbmBackend::createBackendTexture(SceneOpenGLTexture *texture)
 {
     return new EglGbmTexture(texture, this);
 }
 
 QRegion EglGbmBackend::prepareRenderingFrame()
 {
     startRenderTimer();
     return QRegion();
 }
 
 QRegion EglGbmBackend::prepareRenderingForScreen(int screenId)
 {
     const Output &o = m_outputs.at(screenId);
     makeContextCurrent(o);
     if (supportsBufferAge()) {
         QRegion region;
 
         // Note: An age of zero means the buffer contents are undefined
         if (o.bufferAge > 0 && o.bufferAge <= o.damageHistory.count()) {
             for (int i = 0; i < o.bufferAge - 1; i++)
                 region |= o.damageHistory[i];
         } else {
             region = o.output->geometry();
         }
 
         return region;
     }
     return QRegion();
 }
 
 void EglGbmBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Q_UNUSED(renderedRegion)
     Q_UNUSED(damagedRegion)
 }
 
 void EglGbmBackend::endRenderingFrameForScreen(int screenId, const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Output &o = m_outputs[screenId];
     if (damagedRegion.intersected(o.output->geometry()).isEmpty() && screenId == 0) {
 
         // If the damaged region of a window is fully occluded, the only
         // rendering done, if any, will have been to repair a reused back
         // buffer, making it identical to the front buffer.
         //
         // In this case we won't post the back buffer. Instead we'll just
         // set the buffer age to 1, so the repaired regions won't be
         // rendered again in the next frame.
         if (!renderedRegion.intersected(o.output->geometry()).isEmpty())
             glFlush();
 
         for (auto &o: m_outputs) {
             o.bufferAge = 1;
         }
         return;
     }
     presentOnOutput(o);
 
     // Save the damaged region to history
     // Note: damage history is only collected for the first screen. For any other screen full repaints
     // are triggered. This is due to a limitation in Scene::paintGenericScreen which resets the Toplevel's
     // repaint. So multiple calls to Scene::paintScreen as it's done in multi-output rendering only
     // have correct damage information for the first screen. If we try to track damage nevertheless,
     // it creates artifacts. So for the time being we work around the problem by only supporting buffer
     // age on the first output. To properly support buffer age on all outputs the rendering needs to
     // be refactored in general.
     if (supportsBufferAge() && screenId == 0) {
         if (o.damageHistory.count() > 10) {
             o.damageHistory.removeLast();
         }
 
         o.damageHistory.prepend(damagedRegion.intersected(o.output->geometry()));
     }
 }
 
 bool EglGbmBackend::usesOverlayWindow() const
 {
     return false;
 }
 
 bool EglGbmBackend::perScreenRendering() const
 {
     return true;
 }
 
 /************************************************
  * EglTexture
  ************************************************/
 
 EglGbmTexture::EglGbmTexture(KWin::SceneOpenGLTexture *texture, EglGbmBackend *backend)
     : AbstractEglTexture(texture, backend)
 {
 }
 
 EglGbmTexture::~EglGbmTexture() = default;
 
 } // namespace
diff --git a/plugins/platforms/drm/remoteaccess_manager.cpp b/plugins/platforms/drm/remoteaccess_manager.cpp
index a7034f088..201fd1994 100644
--- a/plugins/platforms/drm/remoteaccess_manager.cpp
+++ b/plugins/platforms/drm/remoteaccess_manager.cpp
@@ -1,88 +1,88 @@
 /********************************************************************
  *
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Oleg Chernovskiy <kanedias@xaker.ru>
 
 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 "drm_output.h"
 #include "remoteaccess_manager.h"
 #include "logging.h"
 #include "drm_backend.h"
 #include "../../../wayland_server.h"
 
 // system
 #include <KWayland/Server/output_interface.h>
 #include <unistd.h>
 #include <gbm.h>
 #include <errno.h>
 
 namespace KWin
 {
 
 RemoteAccessManager::RemoteAccessManager(QObject *parent)
     : QObject(parent)
 {
     if (waylandServer()) {
         m_interface = waylandServer()->display()->createRemoteAccessManager(this);
         m_interface->create();
 
         connect(m_interface, &RemoteAccessManagerInterface::bufferReleased,
                 this, &RemoteAccessManager::releaseBuffer);
     }
 }
 
 RemoteAccessManager::~RemoteAccessManager()
 {
     if (m_interface) {
         m_interface->destroy();
     }
 }
 
 void RemoteAccessManager::releaseBuffer(const BufferHandle *buf)
 {
     int ret = close(buf->fd());
     if (Q_UNLIKELY(ret)) {
         qCWarning(KWIN_DRM) << "Couldn't close released GBM fd:" << strerror(errno);
     }
     delete buf;
 }
 
 void RemoteAccessManager::passBuffer(DrmOutput *output, DrmBuffer *buffer)
 {
     DrmSurfaceBuffer* gbmbuf = static_cast<DrmSurfaceBuffer *>(buffer);
 
     // no connected RemoteAccess instance
     if (!m_interface || !m_interface->isBound()) {
         return;
     }
 
     // first buffer may be null
     if (!gbmbuf || !gbmbuf->hasBo()) {
         return;
     }
 
     auto buf = new BufferHandle;
     auto bo = gbmbuf->getBo();
     buf->setFd(gbm_bo_get_fd(bo));
     buf->setSize(gbm_bo_get_width(bo), gbm_bo_get_height(bo));
     buf->setStride(gbm_bo_get_stride(bo));
     buf->setFormat(gbm_bo_get_format(bo));
 
-    m_interface->sendBufferReady(output->getWaylandInterface().data(), buf);
+    m_interface->sendBufferReady(output->waylandOutput().data(), buf);
 }
 
 } // KWin namespace
diff --git a/plugins/platforms/drm/scene_qpainter_drm_backend.cpp b/plugins/platforms/drm/scene_qpainter_drm_backend.cpp
index 49b4656dd..7727ed61b 100644
--- a/plugins/platforms/drm/scene_qpainter_drm_backend.cpp
+++ b/plugins/platforms/drm/scene_qpainter_drm_backend.cpp
@@ -1,144 +1,144 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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_qpainter_drm_backend.h"
 #include "drm_backend.h"
 #include "drm_output.h"
 #include "logind.h"
 
 namespace KWin
 {
 
 DrmQPainterBackend::DrmQPainterBackend(DrmBackend *backend)
     : QObject()
     , QPainterBackend()
     , m_backend(backend)
 {
-    const auto outputs = m_backend->outputs();
+    const auto outputs = m_backend->drmOutputs();
     for (auto output: outputs) {
         initOutput(output);
     }
     connect(m_backend, &DrmBackend::outputAdded, this, &DrmQPainterBackend::initOutput);
     connect(m_backend, &DrmBackend::outputRemoved, this,
         [this] (DrmOutput *o) {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                 [o] (const Output &output) {
                     return output.output == o;
                 }
             );
             if (it == m_outputs.end()) {
                 return;
             }
             delete (*it).buffer[0];
             delete (*it).buffer[1];
             m_outputs.erase(it);
         }
     );
 }
 
 DrmQPainterBackend::~DrmQPainterBackend()
 {
     for (auto it = m_outputs.begin(); it != m_outputs.end(); ++it) {
         delete (*it).buffer[0];
         delete (*it).buffer[1];
     }
 }
 
 void DrmQPainterBackend::initOutput(DrmOutput *output)
 {
     Output o;
     auto initBuffer = [&o, output, this] (int index) {
         o.buffer[index] = m_backend->createBuffer(output->pixelSize());
         o.buffer[index]->map();
         o.buffer[index]->image()->fill(Qt::black);
     };
     connect(output, &DrmOutput::modeChanged, this,
         [output, this] {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                 [output] (const auto &o) {
                     return o.output == output;
                 }
             );
             if (it == m_outputs.end()) {
                 return;
             }
             delete (*it).buffer[0];
             delete (*it).buffer[1];
             auto initBuffer = [it, output, this] (int index) {
                 it->buffer[index] = m_backend->createBuffer(output->pixelSize());
                 it->buffer[index]->map();
                 it->buffer[index]->image()->fill(Qt::black);
             };
             initBuffer(0);
             initBuffer(1);
         }
     );
     initBuffer(0);
     initBuffer(1);
     o.output = output;
     m_outputs << o;
 }
 
 QImage *DrmQPainterBackend::buffer()
 {
     return bufferForScreen(0);
 }
 
 QImage *DrmQPainterBackend::bufferForScreen(int screenId)
 {
     const Output &o = m_outputs.at(screenId);
     return o.buffer[o.index]->image();
 }
 
 bool DrmQPainterBackend::needsFullRepaint() const
 {
     return true;
 }
 
 void DrmQPainterBackend::prepareRenderingFrame()
 {
     for (auto it = m_outputs.begin(); it != m_outputs.end(); ++it) {
         (*it).index = ((*it).index + 1) % 2;
     }
 }
 
 void DrmQPainterBackend::present(int mask, const QRegion &damage)
 {
     Q_UNUSED(mask)
     Q_UNUSED(damage)
     if (!LogindIntegration::self()->isActiveSession()) {
         return;
     }
     for (auto it = m_outputs.begin(); it != m_outputs.end(); ++it) {
         const Output &o = *it;
         m_backend->present(o.buffer[o.index], o.output);
     }
 }
 
 bool DrmQPainterBackend::usesOverlayWindow() const
 {
     return false;
 }
 
 bool DrmQPainterBackend::perScreenRendering() const
 {
     return true;
 }
 
 }
diff --git a/plugins/platforms/drm/screens_drm.cpp b/plugins/platforms/drm/screens_drm.cpp
index 400046b30..418fab2a8 100644
--- a/plugins/platforms/drm/screens_drm.cpp
+++ b/plugins/platforms/drm/screens_drm.cpp
@@ -1,152 +1,153 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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 "screens_drm.h"
 #include "drm_backend.h"
 #include "drm_output.h"
 
 namespace KWin
 {
 
 DrmScreens::DrmScreens(DrmBackend *backend, QObject *parent)
     : Screens(parent)
     , m_backend(backend)
 {
     connect(backend, &DrmBackend::screensQueried, this, &DrmScreens::updateCount);
     connect(backend, &DrmBackend::screensQueried, this, &DrmScreens::changed);
 }
 
 DrmScreens::~DrmScreens() = default;
 
 void DrmScreens::init()
 {
     updateCount();
     KWin::Screens::init();
     emit changed();
 }
 
 QRect DrmScreens::geometry(int screen) const
 {
     const auto outputs = m_backend->enabledOutputs();
     if (screen >= outputs.size()) {
         return QRect();
     }
     return outputs.at(screen)->geometry();
 }
 
 qreal DrmScreens::scale(int screen) const
 {
     const auto outputs = m_backend->enabledOutputs();
     if (screen >= outputs.size()) {
         return 1;
     }
     return outputs.at(screen)->scale();
 }
 
 QSize DrmScreens::size(int screen) const
 {
     const auto outputs = m_backend->enabledOutputs();
     if (screen >= outputs.size()) {
         return QSize();
     }
     return outputs.at(screen)->geometry().size();
 }
 
 void DrmScreens::updateCount()
 {
-    setCount(m_backend->enabledOutputs().size());
+    setCount(m_backend->drmEnabledOutputs().size());
 }
 
 int DrmScreens::number(const QPoint &pos) const
 {
     int bestScreen = 0;
     int minDistance = INT_MAX;
-    const auto outputs = m_backend->enabledOutputs();
+    const auto outputs = m_backend->drmEnabledOutputs();
     for (int i = 0; i < outputs.size(); ++i) {
-        const QRect &geo = outputs.at(i)->geometry();
+        auto o = outputs.at(i);
+        const QRect &geo = o->geometry();
         if (geo.contains(pos)) {
             return i;
         }
         int distance = QPoint(geo.topLeft() - pos).manhattanLength();
         distance = qMin(distance, QPoint(geo.topRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomLeft() - pos).manhattanLength());
         if (distance < minDistance) {
             minDistance = distance;
             bestScreen = i;
         }
     }
     return bestScreen;
 }
 
 QString DrmScreens::name(int screen) const
 {
-    const auto outputs = m_backend->enabledOutputs();
+    const auto outputs = m_backend->drmEnabledOutputs();
     if (screen >= outputs.size()) {
         return Screens::name(screen);
     }
     return outputs.at(screen)->name();
 }
 
 float DrmScreens::refreshRate(int screen) const
 {
-    const auto outputs = m_backend->enabledOutputs();
+    const auto outputs = m_backend->drmEnabledOutputs();
     if (screen >= outputs.size()) {
         return Screens::refreshRate(screen);
     }
     return outputs.at(screen)->currentRefreshRate() / 1000.0f;
 }
 
 QSizeF DrmScreens::physicalSize(int screen) const
 {
-    const auto outputs = m_backend->enabledOutputs();
+    const auto outputs = m_backend->drmEnabledOutputs();
     if (screen >= outputs.size()) {
         return Screens::physicalSize(screen);
     }
     return outputs.at(screen)->physicalSize();
 }
 
 bool DrmScreens::isInternal(int screen) const
 {
-    const auto outputs = m_backend->enabledOutputs();
+    const auto outputs = m_backend->drmEnabledOutputs();
     if (screen >= outputs.size()) {
         return false;
     }
     return outputs.at(screen)->isInternal();
 }
 
 bool DrmScreens::supportsTransformations(int screen) const
 {
-    const auto outputs = m_backend->enabledOutputs();
+    const auto outputs = m_backend->drmEnabledOutputs();
     if (screen >= outputs.size()) {
         return false;
     }
     return outputs.at(screen)->supportsTransformations();
 }
 
 Qt::ScreenOrientation DrmScreens::orientation(int screen) const
 {
-    const auto outputs = m_backend->outputs();
+    const auto outputs = m_backend->drmOutputs();
     if (screen >= outputs.size()) {
         return Qt::PrimaryOrientation;
     }
     return outputs.at(screen)->orientation();
 }
 
 }
diff --git a/plugins/platforms/virtual/screens_virtual.cpp b/plugins/platforms/virtual/screens_virtual.cpp
index 18f29680c..2c6b30145 100644
--- a/plugins/platforms/virtual/screens_virtual.cpp
+++ b/plugins/platforms/virtual/screens_virtual.cpp
@@ -1,94 +1,94 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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 "screens_virtual.h"
 #include "virtual_backend.h"
 #include "virtual_output.h"
 
 namespace KWin
 {
 
 VirtualScreens::VirtualScreens(VirtualBackend *backend, QObject *parent)
     : Screens(parent)
     , m_backend(backend)
 {
 }
 
 VirtualScreens::~VirtualScreens() = default;
 
 void VirtualScreens::init()
 {
     updateCount();
     KWin::Screens::init();
 
     connect(m_backend, &VirtualBackend::virtualOutputsSet, this,
         [this] (bool countChanged) {
             if (countChanged) {
                 setCount(m_backend->outputCount());
             } else {
                 emit changed();
             }
         }
     );
 
     emit changed();
 }
 
 QRect VirtualScreens::geometry(int screen) const
 {
-    const auto outputs = m_backend->outputs();
+    const auto outputs = m_backend->virtualOutputs();
     if (screen >= outputs.size()) {
         return QRect();
     }
     return outputs.at(screen)->geometry();
 }
 
 QSize VirtualScreens::size(int screen) const
 {
     return geometry(screen).size();
 }
 
 void VirtualScreens::updateCount()
 {
     setCount(m_backend->outputCount());
 }
 
 int VirtualScreens::number(const QPoint &pos) const
 {
     int bestScreen = 0;
     int minDistance = INT_MAX;
-    const auto outputs = m_backend->outputs();
+    const auto outputs = m_backend->virtualOutputs();
     for (int i = 0; i < outputs.size(); ++i) {
         const QRect &geo = outputs.at(i)->geometry();
         if (geo.contains(pos)) {
             return i;
         }
         int distance = QPoint(geo.topLeft() - pos).manhattanLength();
         distance = qMin(distance, QPoint(geo.topRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomRight() - pos).manhattanLength());
         distance = qMin(distance, QPoint(geo.bottomLeft() - pos).manhattanLength());
         if (distance < minDistance) {
             minDistance = distance;
             bestScreen = i;
         }
     }
     return bestScreen;
 }
 
 }
diff --git a/plugins/platforms/virtual/virtual_backend.h b/plugins/platforms/virtual/virtual_backend.h
index eda2c118a..bec9d9b78 100644
--- a/plugins/platforms/virtual/virtual_backend.h
+++ b/plugins/platforms/virtual/virtual_backend.h
@@ -1,108 +1,108 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 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_VIRTUAL_BACKEND_H
 #define KWIN_VIRTUAL_BACKEND_H
 #include "platform.h"
 
 #include <kwin_export.h>
 
 #include <QObject>
 #include <QRect>
 
 class QTemporaryDir;
 
 struct gbm_device;
 
 namespace KWin
 {
 class VirtualOutput;
 
 class KWIN_EXPORT VirtualBackend : public Platform
 {
     Q_OBJECT
     Q_INTERFACES(KWin::Platform)
     Q_PLUGIN_METADATA(IID "org.kde.kwin.Platform" FILE "virtual.json")
 
 public:
     VirtualBackend(QObject *parent = nullptr);
     virtual ~VirtualBackend();
     void init() override;
 
     int outputCount() const {
         return m_outputs.size();
     }
-    const QVector<VirtualOutput*> outputs() const {
+    const QVector<VirtualOutput*> virtualOutputs() const {
         return m_outputs;
     }
     qreal outputScale() const {
         return m_outputScale;
     }
 
     bool saveFrames() const {
         return !m_screenshotDir.isNull();
     }
     QString screenshotDirPath() const;
 
     Screens *createScreens(QObject *parent = nullptr) override;
     QPainterBackend* createQPainterBackend() override;
     OpenGLBackend *createOpenGLBackend() override;
 
     Q_INVOKABLE void setVirtualOutputs(int count, QVector<QRect> geometries = QVector<QRect>());
 
     Q_INVOKABLE void setOutputScale(qreal scale) {
         m_outputScale = scale;
     }
 
     int drmFd() const {
         return m_drmFd;
     }
     void setDrmFd(int fd) {
         m_drmFd = fd;
     }
 
     gbm_device *gbmDevice() const {
         return m_gbmDevice;
     }
     void setGbmDevice(gbm_device *device) {
         m_gbmDevice = device;
     }
     virtual int gammaRampSize(int screen) const override;
     virtual bool setGammaRamp(int screen, ColorCorrect::GammaRamp &gamma) override;
 
     QVector<CompositingType> supportedCompositors() const override {
         return QVector<CompositingType>{OpenGLCompositing, QPainterCompositing};
     }
 
 Q_SIGNALS:
     void virtualOutputsSet(bool countChanged);
 
 private:
     QVector<VirtualOutput*> m_outputs;
 
     qreal m_outputScale = 1;
 
     QScopedPointer<QTemporaryDir> m_screenshotDir;
     int m_drmFd = -1;
     gbm_device *m_gbmDevice = nullptr;
 };
 
 }
 
 #endif