diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4fa38de6..42a303f2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,127 +1,129 @@
 cmake_minimum_required(VERSION 3.0)
 
 set(KF5_VERSION "5.47.0") # handled by release scripts
 set(KF5_DEP_VERSION "5.46.0") # handled by release scripts
 
 project(kirigami2 VERSION ${KF5_VERSION})
 
 set(REQUIRED_QT_VERSION 5.8.0)
 
 SET(CMAKE_CXX_STANDARD 11)
 
 ################# Disallow in-source build #################
 
 if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
    message(FATAL_ERROR "kirigami requires an out of source build. Please create a separate build directory and run 'cmake path_to_kirigami [options]' there.")
 endif()
 
 option(BUILD_SHARED_LIBS "Build a shared module" ON)
 option(DESKTOP_ENABLED "Build and install The Desktop style" ON)
 option(STATIC_LIBRARY "Build as a static library (deprecated, use BUILD_SHARED_LIBS instead)" OFF)
 option(BUILD_EXAMPLES "Build and install examples" OFF)
+option(DISABLE_DBUS "Build without D-Bus support" OFF)
 
 if(NOT BUILD_SHARED_LIBS)
     set(STATIC_LIBRARY 1)
 elseif(STATIC_LIBRARY)
     set(BUILD_SHARED_LIBS 0)
 endif()
 
 # Make CPack available to easy generate binary packages
 include(CPack)
 include(FeatureSummary)
 
 find_package(Qt5 ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE COMPONENTS Core Quick Gui Svg QuickControls2)
 find_package(Qt5Test ${REQUIRED_QT_VERSION} CONFIG QUIET)
 
 set(CMAKE_AUTOMOC ON)
 set(AUTOMOC_MOC_OPTIONS -Muri=org.kde.kirigami)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 if(STATIC_LIBRARY)
     add_definitions(-DKIRIGAMI_BUILD_TYPE_STATIC)
     add_definitions(-DQT_PLUGIN)
     add_definitions(-DQT_STATICPLUGIN=1)
 else(STATIC_LIBRARY)
     add_subdirectory(autotests)
 endif(STATIC_LIBRARY)
 
 ################# set KDE specific information #################
 
 find_package(ECM 5.46.0 NO_MODULE)
 set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules")
 
 # 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})
 
 include(GenerateExportHeader)
 include(ECMSetupVersion)
 include(ECMGenerateHeaders)
 include(CMakePackageConfigHelpers)
 include(ECMPoQmTools)
 include(ECMQMLModules)
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(ECMQtDeclareLoggingCategory)
 include(ECMAddQch)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 
 set(CMAKECONFIG_INSTALL_DIR "${KDE_INSTALL_CMAKEPACKAGEDIR}/KF5Kirigami2")
 
 option(BUILD_QCH "Build API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)" OFF)
 add_feature_info(QCH ${BUILD_QCH} "API documentation in QCH format (for e.g. Qt Assistant, Qt Creator & KDevelop)")
 
 configure_package_config_file(
     "${CMAKE_CURRENT_SOURCE_DIR}/KF5Kirigami2Config.cmake.in"
     "${CMAKE_CURRENT_BINARY_DIR}/KF5Kirigami2Config.cmake"
     INSTALL_DESTINATION  ${CMAKECONFIG_INSTALL_DIR}
     PATH_VARS  KF5_INCLUDE_INSTALL_DIR CMAKE_INSTALL_PREFIX
 )
 
 install(FILES
     "${CMAKE_CURRENT_BINARY_DIR}/KF5Kirigami2Config.cmake"
     "${CMAKE_CURRENT_BINARY_DIR}/KF5Kirigami2ConfigVersion.cmake"
     "${CMAKE_CURRENT_SOURCE_DIR}/KF5Kirigami2Macros.cmake"
     DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
     COMPONENT Devel
 )
 
 install(EXPORT KF5Kirigami2Targets
     DESTINATION "${CMAKECONFIG_INSTALL_DIR}"
     FILE KF5Kirigami2Targets.cmake
     NAMESPACE KF5::
 )
 
 
 ecm_setup_version(${KF5_VERSION}
     VARIABLE_PREFIX KIRIGAMI2
     VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/kirigami_version.h"
     PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5Kirigami2ConfigVersion.cmake"
     SOVERSION 5
 )
 
 #use dbus on linux, bsd etc, but not andoid and apple stuff
-if (UNIX AND NOT CMAKE_SYSTEM_NAME STREQUAL "Android" AND NOT(APPLE))
+if (UNIX AND NOT CMAKE_SYSTEM_NAME STREQUAL "Android" AND NOT(APPLE) AND NOT(DISABLE_DBUS))
     find_package(Qt5DBus)
+    add_definitions(-DKIRIGAMI_ENABLE_DBUS)
 endif()
 
 if(BUILD_EXAMPLES AND CMAKE_SYSTEM_NAME STREQUAL "Android")
     find_package(Qt5AndroidExtras ${REQUIRED_QT_VERSION} REQUIRED)
 endif()
 
 
 ecm_find_qmlmodule(QtGraphicalEffects 1.0)
 
 add_definitions(-DQT_NO_URL_CAST_FROM_STRING)
 
 add_subdirectory(src)
 
 if (BUILD_EXAMPLES AND NOT STATIC_LIBRARY)
     add_subdirectory(examples)
 endif()
 
 if (IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/po")
     ecm_install_po_files_as_qm(po)
 endif()
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
diff --git a/src/libkirigami/CMakeLists.txt b/src/libkirigami/CMakeLists.txt
index 624f3787..88d11587 100644
--- a/src/libkirigami/CMakeLists.txt
+++ b/src/libkirigami/CMakeLists.txt
@@ -1,94 +1,94 @@
 
 
 set(libkirigami_SRCS
     platformtheme.cpp
     basictheme.cpp
     kirigamipluginfactory.cpp
     tabletmodewatcher.cpp
 )
 
 #use dbus on linux, bsd etc, but not andoid and apple stuff
-if (UNIX AND NOT CMAKE_SYSTEM_NAME STREQUAL "Android" AND NOT(APPLE))
+if (UNIX AND NOT CMAKE_SYSTEM_NAME STREQUAL "Android" AND NOT(APPLE) AND NOT(DISABLE_DBUS))
     qt5_add_dbus_interface(libkirigami_SRCS org.kde.KWin.TabletModeManager.xml tabletmodemanager_interface)
     set(LIBKIRIGAMKI_EXTRA_LIBS Qt5::DBus)
 endif()
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 
 ecm_qt_declare_logging_category(libkirigami_SRCS
     HEADER loggingcategory.h
     IDENTIFIER KirigamiLog
     CATEGORY_NAME kf5.kirigami
     DEFAULT_SEVERITY Warning
 )
 
 add_library(KF5Kirigami2 ${libkirigami_SRCS})
 generate_export_header(KF5Kirigami2 BASE_NAME Kirigami2)
 add_library(KF5::Kirigami2 ALIAS KF5Kirigami2)
 
 target_include_directories(KF5Kirigami2
     INTERFACE "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5}/Kirigami2>"
 )
 
 target_link_libraries(KF5Kirigami2
     PUBLIC
         Qt5::Core
     PRIVATE
         Qt5::Qml
         Qt5::Quick
         Qt5::QuickControls2
         ${LIBKIRIGAMKI_EXTRA_LIBS}
 )
 
 set_target_properties(KF5Kirigami2 PROPERTIES
     VERSION     ${KIRIGAMI2_VERSION_STRING}
     SOVERSION   ${KIRIGAMI2_SOVERSION}
     EXPORT_NAME "Kirigami2"
 )
 
 ecm_generate_headers(Kirigami2_HEADERS
     HEADER_NAMES
     PlatformTheme
     KirigamiPluginFactory
     TabletModeWatcher
 
     REQUIRED_HEADERS Kirigami2_HEADERS
 )
 
 install(TARGETS KF5Kirigami2
         EXPORT KF5Kirigami2Targets
         ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})
 
 
 install(FILES
             ${CMAKE_CURRENT_BINARY_DIR}/kirigami2_export.h
             ${Kirigami2_HEADERS}
         DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/Kirigami2
         COMPONENT Devel)
 
 if(BUILD_QCH)
     ecm_add_qch(
         KF5Kirigami2_QCH
         NAME Kirigami2
         BASE_NAME KF5Kirigami2
         VERSION ${KF5_VERSION}
         ORG_DOMAIN org.kde
         SOURCES # using only public headers, to cover only public API
             ${Kirigami2_HEADERS}
         MD_MAINPAGE "${CMAKE_SOURCE_DIR}/README.md"
         LINK_QCHS
             Qt5Core_QCH
         BLANK_MACROS
             KIRIGAMI_EXPORT
             KIRIGAMI_DEPRECATED
         TAGFILE_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR}
         QCH_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR}
         COMPONENT Devel
     )
 endif()
 
 include(ECMGeneratePriFile)
 ecm_generate_pri_file(BASE_NAME Kirigami2 LIB_NAME KF5Kirigami2 DEPS "core" FILENAME_VAR PRI_FILENAME INCLUDE_INSTALL_DIR ${KDE_INSTALL_INCLUDEDIR_KF5}/Kirigami2)
 install(FILES ${PRI_FILENAME}
         DESTINATION ${ECM_MKSPECS_INSTALL_DIR})
 
diff --git a/src/libkirigami/tabletmodewatcher.cpp b/src/libkirigami/tabletmodewatcher.cpp
index 7c9259f3..2d228eb7 100644
--- a/src/libkirigami/tabletmodewatcher.cpp
+++ b/src/libkirigami/tabletmodewatcher.cpp
@@ -1,142 +1,140 @@
 /*
  * Copyright 2018 Marco Martin <mart@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) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * 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 "tabletmodewatcher.h"
 
-#if defined(Q_OS_UNIX) && !defined(Q_OS_ANDROID) && !defined(Q_OS_IOS) && !defined(Q_OS_MACOS)
+#if defined(KIRIGAMI_ENABLE_DBUS)
 #include "tabletmodemanager_interface.h"
 #include <QDBusConnection>
 #endif
 
 //TODO: All the dbus stuff should be conditional, optional win32 support
 
 namespace Kirigami {
 
 class TabletModeWatcherSingleton
 {
 public:
     TabletModeWatcher self;
 };
 
 Q_GLOBAL_STATIC(TabletModeWatcherSingleton, privateTabletModeWatcherSelf)
 
 
 class TabletModeWatcherPrivate
 {
 public:
     TabletModeWatcherPrivate(TabletModeWatcher *watcher)
         : q(watcher)
     {
-#if defined(Q_OS_ANDROID) || defined(Q_OS_IOS)
+
+#if !defined(KIRIGAMI_ENABLE_DBUS) && (defined(Q_OS_ANDROID) || defined(Q_OS_IOS))
         isTabletModeAvailable = true;
         isTabletMode = true;
-#elif defined(Q_OS_MACOS)
-        isTabletModeAvailable = false;
-        isTabletMode = false;
-#elif defined(Q_OS_LINUX) || defined(Q_OS_UNIX)
+#elif defined(KIRIGAMI_ENABLE_DBUS)
         //Mostly for debug purposes and for platforms which are always mobile,
         //such as Plasma Mobile
         if (qEnvironmentVariableIsSet("QT_QUICK_CONTROLS_MOBILE") ||        
             qEnvironmentVariableIsSet("KDE_KIRIGAMI_TABLET_MODE")) {
             isTabletMode = (QString::fromLatin1(qgetenv("QT_QUICK_CONTROLS_MOBILE")) == QStringLiteral("1") ||
                 QString::fromLatin1(qgetenv("QT_QUICK_CONTROLS_MOBILE")) == QStringLiteral("true")) ||
                 (QString::fromLatin1(qgetenv("KDE_KIRIGAMI_TABLET_MODE")) == QStringLiteral("1") ||
                 QString::fromLatin1(qgetenv("KDE_KIRIGAMI_TABLET_MODE")) == QStringLiteral("true"));
             isTabletModeAvailable = isTabletMode;
         } else {
             m_interface = new OrgKdeKWinTabletModeManagerInterface(QStringLiteral("org.kde.KWin"), QStringLiteral("/org/kde/KWin"), QDBusConnection::sessionBus(), q);
 
             if (m_interface->isValid()) {
                 //NOTE: the initial call is actually sync, because is better a tiny freeze than having the ui always recalculated and changed at the start
                 isTabletModeAvailable = m_interface->tabletModeAvailable();
                 isTabletMode = m_interface->tabletMode();
                 QObject::connect(m_interface, &OrgKdeKWinTabletModeManagerInterface::tabletModeChanged,
                         q, [this](bool tabletMode) {
                     setIsTablet(tabletMode);
                 });
                 QObject::connect(m_interface, &OrgKdeKWinTabletModeManagerInterface::tabletModeAvailableChanged,
                         q, [this](bool avail) {
                     isTabletModeAvailable = avail;
                     emit q->tabletModeAvailableChanged(avail);
                 });
             } else {
                 isTabletModeAvailable = false;
                 isTabletMode = false;
             }
         }
 //TODO: case for Windows
 #else
         isTabletModeAvailable = false;
         isTabletMode = false;
 #endif
     }
     ~TabletModeWatcherPrivate() {};
     void setIsTablet(bool tablet);
 
     TabletModeWatcher *q;
-#if (defined(Q_OS_LINUX) || defined(Q_OS_UNIX)) && !defined(Q_OS_ANDROID) && !defined(Q_OS_MAC) && !defined(Q_OS_IOS)
+#if defined(KIRIGAMI_ENABLE_DBUS)
     OrgKdeKWinTabletModeManagerInterface *m_interface = nullptr;
 #endif
     bool isTabletModeAvailable = false;
     bool isTabletMode = false;
 };
 
 void TabletModeWatcherPrivate::setIsTablet(bool tablet)
 {
     if (isTabletMode == tablet) {
         return;
     }
 
     isTabletMode = tablet;
     emit q->tabletModeChanged(tablet);
 }
 
 
 
 TabletModeWatcher::TabletModeWatcher(QObject *parent)
     : QObject(parent),
       d(new TabletModeWatcherPrivate(this))
 {
 }
 
 TabletModeWatcher::~TabletModeWatcher()
 {
     delete d;
 }
 
 TabletModeWatcher *TabletModeWatcher::self()
 {
     return &privateTabletModeWatcherSelf()->self;
 }
 
 bool TabletModeWatcher::isTabletModeAvailable() const
 {
     return d->isTabletModeAvailable;
 }
 
 bool TabletModeWatcher::isTabletMode() const
 {
     return d->isTabletMode;
 }
 
 }
 
 #include "moc_tabletmodewatcher.cpp"