diff --git a/CMakeLists.txt b/CMakeLists.txt
index 72523181ef..e89dd86049 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -383,6 +383,7 @@ set(kwin_KDEINIT_SRCS
    scene_xrender.cpp
    scene_opengl.cpp
    scene_qpainter.cpp
+   screenlockerwatcher.cpp
    thumbnailitem.cpp
    lanczosfilter.cpp
    deleted.cpp
diff --git a/effects.cpp b/effects.cpp
index 2fe0efd4e6..4d0ecc5e22 100644
--- a/effects.cpp
+++ b/effects.cpp
@@ -40,16 +40,13 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "screenedge.h"
 #include "scripting/scriptedeffect.h"
 #include "screens.h"
+#include "screenlockerwatcher.h"
 #include "thumbnailitem.h"
 #include "virtualdesktops.h"
 #include "workspace.h"
 #include "kwinglutils.h"
 
 #include <QDebug>
-#include <QFutureWatcher>
-#include <QtConcurrentRun>
-#include <QDBusServiceWatcher>
-#include <QDBusPendingCallWatcher>
 
 #include <Plasma/Theme>
 
@@ -63,104 +60,8 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #include "decorations/decorationbridge.h"
 #include <KDecoration2/DecorationSettings>
 
-// dbus generated
-#include "screenlocker_interface.h"
-
-
 namespace KWin
 {
-
-static const QString SCREEN_LOCKER_SERVICE_NAME = QStringLiteral("org.freedesktop.ScreenSaver");
-
-ScreenLockerWatcher::ScreenLockerWatcher(QObject *parent)
-    : QObject(parent)
-    , m_interface(NULL)
-    , m_serviceWatcher(new QDBusServiceWatcher(this))
-    , m_locked(false)
-{
-    connect(m_serviceWatcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)), SLOT(serviceOwnerChanged(QString,QString,QString)));
-    m_serviceWatcher->setWatchMode(QDBusServiceWatcher::WatchForOwnerChange);
-    m_serviceWatcher->addWatchedService(SCREEN_LOCKER_SERVICE_NAME);
-    // check whether service is registered
-    QFutureWatcher<QDBusReply<bool> > *watcher = new QFutureWatcher<QDBusReply<bool> >(this);
-    connect(watcher, SIGNAL(finished()), SLOT(serviceRegisteredQueried()));
-    connect(watcher, SIGNAL(canceled()), watcher, SLOT(deleteLater()));
-    watcher->setFuture(QtConcurrent::run(QDBusConnection::sessionBus().interface(),
-                                         &QDBusConnectionInterface::isServiceRegistered,
-                                         SCREEN_LOCKER_SERVICE_NAME));
-}
-
-ScreenLockerWatcher::~ScreenLockerWatcher()
-{
-}
-
-void ScreenLockerWatcher::serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner)
-{
-    Q_UNUSED(oldOwner)
-    if (serviceName != SCREEN_LOCKER_SERVICE_NAME) {
-        return;
-    }
-    delete m_interface;
-    m_interface = NULL;
-    m_locked = false;
-    if (!newOwner.isEmpty()) {
-        m_interface = new OrgFreedesktopScreenSaverInterface(newOwner, QStringLiteral("/ScreenSaver"), QDBusConnection::sessionBus(), this);
-        connect(m_interface, SIGNAL(ActiveChanged(bool)), SLOT(setLocked(bool)));
-        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(m_interface->GetActive(), this);
-        connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), SLOT(activeQueried(QDBusPendingCallWatcher*)));
-    }
-}
-
-void ScreenLockerWatcher::serviceRegisteredQueried()
-{
-    QFutureWatcher<QDBusReply<bool> > *watcher = dynamic_cast<QFutureWatcher<QDBusReply<bool> > *>(sender());
-    if (!watcher) {
-        return;
-    }
-    const QDBusReply<bool> &reply = watcher->result();
-    if (reply.isValid() && reply.value()) {
-        QFutureWatcher<QDBusReply<QString> > *ownerWatcher = new QFutureWatcher<QDBusReply<QString> >(this);
-        connect(ownerWatcher, SIGNAL(finished()), SLOT(serviceOwnerQueried()));
-        connect(ownerWatcher, SIGNAL(canceled()), ownerWatcher, SLOT(deleteLater()));
-        ownerWatcher->setFuture(QtConcurrent::run(QDBusConnection::sessionBus().interface(),
-                                                  &QDBusConnectionInterface::serviceOwner,
-                                                  SCREEN_LOCKER_SERVICE_NAME));
-    }
-    watcher->deleteLater();
-}
-
-void ScreenLockerWatcher::serviceOwnerQueried()
-{
-    QFutureWatcher<QDBusReply<QString> > *watcher = dynamic_cast<QFutureWatcher<QDBusReply<QString> > *>(sender());
-    if (!watcher) {
-        return;
-    }
-    const QDBusReply<QString> reply = watcher->result();
-    if (reply.isValid()) {
-        serviceOwnerChanged(SCREEN_LOCKER_SERVICE_NAME, QString(), reply.value());
-    }
-
-    watcher->deleteLater();
-}
-
-void ScreenLockerWatcher::activeQueried(QDBusPendingCallWatcher *watcher)
-{
-    QDBusPendingReply<bool> reply = *watcher;
-    if (!reply.isError()) {
-        setLocked(reply.value());
-    }
-    watcher->deleteLater();
-}
-
-void ScreenLockerWatcher::setLocked(bool activated)
-{
-    if (m_locked == activated) {
-        return;
-    }
-    m_locked = activated;
-    emit locked(m_locked);
-}
-
 //---------------------
 // Static
 
diff --git a/effects.h b/effects.h
index f7bd4ba1a0..4e8a5a9d82 100644
--- a/effects.h
+++ b/effects.h
@@ -45,7 +45,6 @@ class Display;
 
 class QDBusPendingCallWatcher;
 class QDBusServiceWatcher;
-class OrgFreedesktopScreenSaverInterface;
 
 
 namespace KWin
@@ -454,29 +453,6 @@ private:
     Plasma::Theme *m_theme;
 };
 
-class ScreenLockerWatcher : public QObject
-{
-    Q_OBJECT
-public:
-    explicit ScreenLockerWatcher(QObject *parent = 0);
-    virtual ~ScreenLockerWatcher();
-    bool isLocked() const {
-        return m_locked;
-    }
-Q_SIGNALS:
-    void locked(bool locked);
-private Q_SLOTS:
-    void setLocked(bool activated);
-    void activeQueried(QDBusPendingCallWatcher *watcher);
-    void serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner);
-    void serviceRegisteredQueried();
-    void serviceOwnerQueried();
-private:
-    OrgFreedesktopScreenSaverInterface *m_interface;
-    QDBusServiceWatcher *m_serviceWatcher;
-    bool m_locked;
-};
-
 inline
 QList<EffectWindow*> EffectsHandlerImpl::elevatedWindows() const
 {
diff --git a/screenlockerwatcher.cpp b/screenlockerwatcher.cpp
new file mode 100644
index 0000000000..5534c5ae9d
--- /dev/null
+++ b/screenlockerwatcher.cpp
@@ -0,0 +1,121 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+#include "screenlockerwatcher.h"
+
+#include <QFutureWatcher>
+#include <QtConcurrentRun>
+// dbus generated
+#include "screenlocker_interface.h"
+
+namespace KWin
+{
+
+static const QString SCREEN_LOCKER_SERVICE_NAME = QStringLiteral("org.freedesktop.ScreenSaver");
+
+ScreenLockerWatcher::ScreenLockerWatcher(QObject *parent)
+    : QObject(parent)
+    , m_interface(NULL)
+    , m_serviceWatcher(new QDBusServiceWatcher(this))
+    , m_locked(false)
+{
+    connect(m_serviceWatcher, SIGNAL(serviceOwnerChanged(QString,QString,QString)), SLOT(serviceOwnerChanged(QString,QString,QString)));
+    m_serviceWatcher->setWatchMode(QDBusServiceWatcher::WatchForOwnerChange);
+    m_serviceWatcher->addWatchedService(SCREEN_LOCKER_SERVICE_NAME);
+    // check whether service is registered
+    QFutureWatcher<QDBusReply<bool> > *watcher = new QFutureWatcher<QDBusReply<bool> >(this);
+    connect(watcher, SIGNAL(finished()), SLOT(serviceRegisteredQueried()));
+    connect(watcher, SIGNAL(canceled()), watcher, SLOT(deleteLater()));
+    watcher->setFuture(QtConcurrent::run(QDBusConnection::sessionBus().interface(),
+                                         &QDBusConnectionInterface::isServiceRegistered,
+                                         SCREEN_LOCKER_SERVICE_NAME));
+}
+
+ScreenLockerWatcher::~ScreenLockerWatcher()
+{
+}
+
+void ScreenLockerWatcher::serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner)
+{
+    Q_UNUSED(oldOwner)
+    if (serviceName != SCREEN_LOCKER_SERVICE_NAME) {
+        return;
+    }
+    delete m_interface;
+    m_interface = NULL;
+    m_locked = false;
+    if (!newOwner.isEmpty()) {
+        m_interface = new OrgFreedesktopScreenSaverInterface(newOwner, QStringLiteral("/ScreenSaver"), QDBusConnection::sessionBus(), this);
+        connect(m_interface, SIGNAL(ActiveChanged(bool)), SLOT(setLocked(bool)));
+        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(m_interface->GetActive(), this);
+        connect(watcher, SIGNAL(finished(QDBusPendingCallWatcher*)), SLOT(activeQueried(QDBusPendingCallWatcher*)));
+    }
+}
+
+void ScreenLockerWatcher::serviceRegisteredQueried()
+{
+    QFutureWatcher<QDBusReply<bool> > *watcher = dynamic_cast<QFutureWatcher<QDBusReply<bool> > *>(sender());
+    if (!watcher) {
+        return;
+    }
+    const QDBusReply<bool> &reply = watcher->result();
+    if (reply.isValid() && reply.value()) {
+        QFutureWatcher<QDBusReply<QString> > *ownerWatcher = new QFutureWatcher<QDBusReply<QString> >(this);
+        connect(ownerWatcher, SIGNAL(finished()), SLOT(serviceOwnerQueried()));
+        connect(ownerWatcher, SIGNAL(canceled()), ownerWatcher, SLOT(deleteLater()));
+        ownerWatcher->setFuture(QtConcurrent::run(QDBusConnection::sessionBus().interface(),
+                                                  &QDBusConnectionInterface::serviceOwner,
+                                                  SCREEN_LOCKER_SERVICE_NAME));
+    }
+    watcher->deleteLater();
+}
+
+void ScreenLockerWatcher::serviceOwnerQueried()
+{
+    QFutureWatcher<QDBusReply<QString> > *watcher = dynamic_cast<QFutureWatcher<QDBusReply<QString> > *>(sender());
+    if (!watcher) {
+        return;
+    }
+    const QDBusReply<QString> reply = watcher->result();
+    if (reply.isValid()) {
+        serviceOwnerChanged(SCREEN_LOCKER_SERVICE_NAME, QString(), reply.value());
+    }
+
+    watcher->deleteLater();
+}
+
+void ScreenLockerWatcher::activeQueried(QDBusPendingCallWatcher *watcher)
+{
+    QDBusPendingReply<bool> reply = *watcher;
+    if (!reply.isError()) {
+        setLocked(reply.value());
+    }
+    watcher->deleteLater();
+}
+
+void ScreenLockerWatcher::setLocked(bool activated)
+{
+    if (m_locked == activated) {
+        return;
+    }
+    m_locked = activated;
+    emit locked(m_locked);
+}
+
+}
diff --git a/screenlockerwatcher.h b/screenlockerwatcher.h
new file mode 100644
index 0000000000..ed6b79635e
--- /dev/null
+++ b/screenlockerwatcher.h
@@ -0,0 +1,56 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+#ifndef KWIN_SCREENLOCKERWATCHER_H
+#define KWIN_SCREENLOCKERWATCHER_H
+
+#include <QObject>
+
+class OrgFreedesktopScreenSaverInterface;
+class QDBusServiceWatcher;
+class QDBusPendingCallWatcher;
+
+namespace KWin
+{
+
+class ScreenLockerWatcher : public QObject
+{
+    Q_OBJECT
+public:
+    explicit ScreenLockerWatcher(QObject *parent = 0);
+    virtual ~ScreenLockerWatcher();
+    bool isLocked() const {
+        return m_locked;
+    }
+Q_SIGNALS:
+    void locked(bool locked);
+private Q_SLOTS:
+    void setLocked(bool activated);
+    void activeQueried(QDBusPendingCallWatcher *watcher);
+    void serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner);
+    void serviceRegisteredQueried();
+    void serviceOwnerQueried();
+private:
+    OrgFreedesktopScreenSaverInterface *m_interface;
+    QDBusServiceWatcher *m_serviceWatcher;
+    bool m_locked;
+};
+}
+
+#endif