Merge lp:~yofel/kubuntu-packaging/kde-runtime-active-4.7 into lp:~kubuntu-packagers/kubuntu-packaging/kde-runtime

[Philip Muškovac]

2nd batch of the mobile patches from rbelem.

[Michał Zając (quintasan)]

Hey, the patches are missing!

[lp:~yofel/kubuntu-packaging/kde-runtime-active-4.7]

224. By Philip Muškovac on 2011-08-18

Actually add the patches

[Michał Zając (quintasan)]

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2011-07-27 17:40:54 +0000
+++ debian/changelog	2011-08-18 09:25:23 +0000
@@ -1,3 +1,10 @@
+kde-runtime (4:4.7.0a-0ubuntu2) UNRELEASED; urgency=low
+
+  * Added plasma-active patches
+  * Added activitymanager files to install files
+
+ -- Rodrigo Belem <[e-mail]>  Sun, 07 Aug 2011 09:50:51 -0400
+
 kde-runtime (4:4.7.0a-0ubuntu1) oneiric; urgency=low
 
   [ Romain Perier ]
 
=== modified file 'debian/kde-runtime-data.install'
--- debian/kde-runtime-data.install	2011-06-25 20:12:29 +0000
+++ debian/kde-runtime-data.install	2011-08-18 09:25:23 +0000
@@ -449,6 +449,9 @@
 usr/share/kde4/config/kshorturifilterrc
 usr/share/kde4/config.kcfg/jpegcreatorsettings.kcfg
 usr/share/kde4/services/about.protocol
+usr/share/kde4/services/activitymanager-plugin-dummy.desktop
+usr/share/kde4/services/activitymanager-plugin-nepomuk.desktop
+usr/share/kde4/services/activitymanager-plugin-slc.desktop
 usr/share/kde4/services/applications.protocol
 usr/share/kde4/services/ar.protocol
 usr/share/kde4/services/bookmarks.protocol
@@ -668,6 +671,7 @@
 usr/share/kde4/services/windowsimagethumbnail.desktop
 usr/share/kde4/services/xz.protocol
 usr/share/kde4/services/zip.protocol
+usr/share/kde4/servicetypes/activitymanager-plugin.desktop
 usr/share/kde4/servicetypes/knotifynotifymethod.desktop
 usr/share/kde4/servicetypes/nepomukservice.desktop
 usr/share/kde4/servicetypes/phononbackend.desktop
 
=== modified file 'debian/kde-runtime.install'
--- debian/kde-runtime.install	2011-06-25 20:12:29 +0000
+++ debian/kde-runtime.install	2011-08-18 09:25:23 +0000
@@ -35,6 +35,9 @@
 usr/lib/attica_kde.so
 usr/lib/kconf_update_bin/phonon_devicepreference_update
 usr/lib/kconf_update_bin/phonon_deviceuids_update
+usr/lib/kde4/activitymanager_plugin_dummy.so
+usr/lib/kde4/activitymanager_plugin_nepomuk.so
+usr/lib/kde4/activitymanager_plugin_slc.so
 usr/lib/kde4/comicbookthumbnail.so
 usr/lib/kde4/cursorthumbnail.so
 usr/lib/kde4/djvuthumbnail.so
 
=== added file 'debian/patches/kubuntu_mobile_crash-move-after-first-call-to-applet.diff'
--- debian/patches/kubuntu_mobile_crash-move-after-first-call-to-applet.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/kubuntu_mobile_crash-move-after-first-call-to-applet.diff	2011-08-18 09:25:23 +0000
@@ -0,0 +1,54 @@
+From 6568d05788b8f019b12c33a195b70489c5ea29ed Mon Sep 17 00:00:00 2001
+From: Marco Martin <[e-mail]>
+Date: Mon, 11 Jul 2011 22:44:05 +0200
+Subject: [PATCH 3/6] crash-- move after first call to applet()
+
+---
+ .../plasmoid/declarativeappletscript.cpp           |    2 +-
+ .../javascript/plasmoid/simplejavascriptapplet.cpp |    3 +--
+ 2 files changed, 2 insertions(+), 3 deletions(-)
+
+diff --git a/plasma/scriptengines/javascript/plasmoid/declarativeappletscript.cpp b/plasma/scriptengines/javascript/plasmoid/declarativeappletscript.cpp
+index 5bd0b98..6f5cc95 100644
+--- a/plasma/scriptengines/javascript/plasmoid/declarativeappletscript.cpp
++++ b/plasma/scriptengines/javascript/plasmoid/declarativeappletscript.cpp
+@@ -70,7 +70,6 @@ DeclarativeAppletScript::DeclarativeAppletScript(QObject *parent, const QVariant
+       m_env(0),
+       m_auth(this)
+ {
+-    KGlobal::locale()->insertCatalog(description().pluginName());
+     Q_UNUSED(args);
+ }
+ 
+@@ -82,6 +81,7 @@ bool DeclarativeAppletScript::init()
+ {
+     m_declarativeWidget = new Plasma::DeclarativeWidget(applet());
+     m_declarativeWidget->setInitializationDelayed(true);
++    KGlobal::locale()->insertCatalog(description().pluginName());
+ 
+     //make possible to import extensions from the package
+     //FIXME: probably to be removed, would make possible to use native code from within the package :/
+diff --git a/plasma/scriptengines/javascript/plasmoid/simplejavascriptapplet.cpp b/plasma/scriptengines/javascript/plasmoid/simplejavascriptapplet.cpp
+index b0b13e5..dba71f2 100644
+--- a/plasma/scriptengines/javascript/plasmoid/simplejavascriptapplet.cpp
++++ b/plasma/scriptengines/javascript/plasmoid/simplejavascriptapplet.cpp
+@@ -105,8 +105,6 @@ SimpleJavaScriptApplet::SimpleJavaScriptApplet(QObject *parent, const QVariantLi
+     Q_UNUSED(args);
+ //    kDebug() << "Script applet launched, args" << applet()->startupArguments();
+ 
+-    KGlobal::locale()->insertCatalog(description().pluginName());
+-
+     // TODO this will be set to the engine we get from QML
+     m_engine = new QScriptEngine(this);
+     m_env = new ScriptEnv(this, m_engine);
+@@ -311,6 +309,7 @@ bool SimpleJavaScriptApplet::init()
+             this, SLOT(extenderItemRestored(Plasma::ExtenderItem*)));
+     connect(applet(), SIGNAL(activate()),
+             this, SLOT(activate()));
++    KGlobal::locale()->insertCatalog(description().pluginName());
+     setupObjects();
+ 
+     AppletAuthorization auth(this);
+-- 
+1.7.5.4
+
 
=== added file 'debian/patches/kubuntu_mobile_insert-a-catalog-named-as-the-plugin-name.diff'
--- debian/patches/kubuntu_mobile_insert-a-catalog-named-as-the-plugin-name.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/kubuntu_mobile_insert-a-catalog-named-as-the-plugin-name.diff	2011-08-18 09:25:23 +0000
@@ -0,0 +1,38 @@
+From 56b7574767ebaa1dcf667c663e1d98a2ee299a94 Mon Sep 17 00:00:00 2001
+From: Marco Martin <[e-mail]>
+Date: Mon, 11 Jul 2011 21:23:32 +0200
+Subject: [PATCH 2/6] insert a catalog named as the plugin name
+
+---
+ .../plasmoid/declarativeappletscript.cpp           |    1 +
+ .../javascript/plasmoid/simplejavascriptapplet.cpp |    2 ++
+ 2 files changed, 3 insertions(+), 0 deletions(-)
+
+diff --git a/plasma/scriptengines/javascript/plasmoid/declarativeappletscript.cpp b/plasma/scriptengines/javascript/plasmoid/declarativeappletscript.cpp
+index 08d53fa..5bd0b98 100644
+--- a/plasma/scriptengines/javascript/plasmoid/declarativeappletscript.cpp
++++ b/plasma/scriptengines/javascript/plasmoid/declarativeappletscript.cpp
+@@ -70,6 +70,7 @@ DeclarativeAppletScript::DeclarativeAppletScript(QObject *parent, const QVariant
+       m_env(0),
+       m_auth(this)
+ {
++    KGlobal::locale()->insertCatalog(description().pluginName());
+     Q_UNUSED(args);
+ }
+ 
+diff --git a/plasma/scriptengines/javascript/plasmoid/simplejavascriptapplet.cpp b/plasma/scriptengines/javascript/plasmoid/simplejavascriptapplet.cpp
+index 0076cd8..b0b13e5 100644
+--- a/plasma/scriptengines/javascript/plasmoid/simplejavascriptapplet.cpp
++++ b/plasma/scriptengines/javascript/plasmoid/simplejavascriptapplet.cpp
+@@ -105,6 +105,8 @@ SimpleJavaScriptApplet::SimpleJavaScriptApplet(QObject *parent, const QVariantLi
+     Q_UNUSED(args);
+ //    kDebug() << "Script applet launched, args" << applet()->startupArguments();
+ 
++    KGlobal::locale()->insertCatalog(description().pluginName());
++
+     // TODO this will be set to the engine we get from QML
+     m_engine = new QScriptEngine(this);
+     m_env = new ScriptEnv(this, m_engine);
+-- 
+1.7.5.4
+
 
=== added file 'debian/patches/kubuntu_mobile_ported-the-new-activity-manager.diff'
--- debian/patches/kubuntu_mobile_ported-the-new-activity-manager.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/kubuntu_mobile_ported-the-new-activity-manager.diff	2011-08-18 09:25:23 +0000
@@ -0,0 +1,2237 @@
+From 7bbbc379de69eab6164a6c7a33670e231b734768 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Ivan=20=C4=8Cuki=C4=87?= <[e-mail]>
+Date: Fri, 8 Jul 2011 17:22:59 +0200
+Subject: [PATCH 1/6] Ported the new activity manager
+
+---
+ activitymanager/ActivityManager.cpp                |   87 +++++---
+ activitymanager/ActivityManager.h                  |   83 ++-----
+ activitymanager/ActivityManager_p.h                |   16 +-
+ activitymanager/CMakeLists.txt                     |   44 ++++-
+ activitymanager/Event.cpp                          |    6 +-
+ activitymanager/Event.h                            |   29 ++-
+ activitymanager/EventBackend.cpp                   |   12 +
+ activitymanager/EventBackend.h                     |    3 +-
+ activitymanager/EventProcessor.cpp                 |   26 ++-
+ activitymanager/EventProcessor.h                   |    4 +-
+ activitymanager/NepomukCommon.h                    |   63 ++++++
+ activitymanager/NepomukEventBackend.cpp            |  235 ++++++++++++++------
+ activitymanager/NepomukResourceScoreCache.cpp      |  214 ++++++++++++++++++
+ activitymanager/NepomukResourceScoreCache.h        |   42 ++++
+ activitymanager/NepomukResourceScoreMaintainer.cpp |  145 ++++++++++++
+ activitymanager/NepomukResourceScoreMaintainer.h   |   47 ++++
+ activitymanager/SharedInfo.cpp                     |   51 +++++
+ activitymanager/SharedInfo.h                       |   63 ++++++
+ activitymanager/SlcEventBackend.cpp                |  127 +++++++++++
+ activitymanager/SlcEventBackend.h                  |   59 +++++
+ activitymanager/ZeitgeistEventBackend.cpp          |   44 ++--
+ activitymanager/main.cpp                           |    2 -
+ activitymanager/ontologies/CMakeLists.txt          |    8 +
+ activitymanager/ontologies/kamdrso.ontology.in     |    8 +
+ activitymanager/ontologies/kamdrso.trig            |  112 ++++++++++
+ activitymanager/org.kde.ActivityManager.SLC.xml    |   15 ++
+ activitymanager/org.kde.ActivityManager.xml        |   37 +---
+ activitymanager/queries.sparql                     |   43 ++++
+ activitymanager/scripts/delete-stats.sh            |    4 +
+ nepomuk/ontologies/kext.trig                       |   41 +++-
+ 30 files changed, 1413 insertions(+), 257 deletions(-)
+ create mode 100644 activitymanager/NepomukCommon.h
+ create mode 100644 activitymanager/NepomukResourceScoreCache.cpp
+ create mode 100644 activitymanager/NepomukResourceScoreCache.h
+ create mode 100644 activitymanager/NepomukResourceScoreMaintainer.cpp
+ create mode 100644 activitymanager/NepomukResourceScoreMaintainer.h
+ create mode 100644 activitymanager/SharedInfo.cpp
+ create mode 100644 activitymanager/SharedInfo.h
+ create mode 100644 activitymanager/SlcEventBackend.cpp
+ create mode 100644 activitymanager/SlcEventBackend.h
+ create mode 100644 activitymanager/ontologies/CMakeLists.txt
+ create mode 100644 activitymanager/ontologies/kamdrso.ontology.in
+ create mode 100644 activitymanager/ontologies/kamdrso.trig
+ create mode 100644 activitymanager/org.kde.ActivityManager.SLC.xml
+ create mode 100644 activitymanager/queries.sparql
+ create mode 100755 activitymanager/scripts/delete-stats.sh
+
+diff --git a/activitymanager/ActivityManager.cpp b/activitymanager/ActivityManager.cpp
+index ea95232..e821c92 100644
+--- a/activitymanager/ActivityManager.cpp
++++ b/activitymanager/ActivityManager.cpp
+@@ -66,9 +66,14 @@ __inline int toInt(WId wid)
+ 
+ // Private
+ 
+-ActivityManagerPrivate::ActivityManagerPrivate(ActivityManager * parent)
++ActivityManagerPrivate::ActivityManagerPrivate(ActivityManager * parent,
++            QHash < WId, SharedInfo::WindowData > & _windows,
++            QHash < KUrl, SharedInfo::ResourceData > & _resources
++        )
+     : haveSessions(false),
+     config("activitymanagerrc"),
++    windows(_windows),
++    resources(_resources),
+ #ifdef HAVE_NEPOMUK
+     m_nepomukInitCalled(false),
+ #endif
+@@ -99,6 +104,8 @@ ActivityManagerPrivate::ActivityManagerPrivate(ActivityManager * parent)
+ 
+     connect(KWindowSystem::self(), SIGNAL(windowRemoved(WId)),
+             this, SLOT(windowClosed(WId)));
++    connect(KWindowSystem::self(), SIGNAL(activeWindowChanged(WId)),
++            this, SLOT(activeWindowChanged(WId)));
+ 
+     //listen to ksmserver for starting/stopping
+     ksmserverInterface = new QDBusInterface("org.kde.ksmserver", "/KSMServer", "org.kde.KSMServerInterface");
+@@ -126,15 +133,26 @@ ActivityManagerPrivate::~ActivityManagerPrivate()
+ 
+ void ActivityManagerPrivate::windowClosed(WId windowId)
+ {
+-    if (!resourcesForWindow.contains(windowId)) {
++    // kDebug() << "Window closed..." << windowId
++    //          << "one of ours?" << windows.contains(windowId);
++
++    if (!windows.contains(windowId)) {
+         return;
+     }
+ 
+-    foreach(const KUrl & uri, resourcesForWindow[windowId]) {
+-        q->NotifyResourceClosed(toInt(windowId), uri.url());
++    foreach (const KUrl & uri, windows[windowId].resources) {
++        q->RegisterResourceEvent(windows[windowId].application,
++                toInt(windowId), uri.url(), Event::Closed, resources[uri].reason);
+     }
+ }
+ 
++void ActivityManagerPrivate::activeWindowChanged(WId windowId)
++{
++    // kDebug() << "Window focussed..." << windowId
++    //          << "one of ours?" << windows.contains(windowId);
++
++}
++
+ void ActivityManagerPrivate::setActivityState(const QString & id, ActivityManager::State state)
+ {
+     if (activities[id] == state) return;
+@@ -285,7 +303,9 @@ void ActivityManagerPrivate::backstoreAvailable()
+ // Main
+ 
+ ActivityManager::ActivityManager()
+-    : d(new ActivityManagerPrivate(this))
++    : d(new ActivityManagerPrivate(this,
++            SharedInfo::self()->m_windows,
++            SharedInfo::self()->m_resources))
+ {
+ 
+     QDBusConnection dbus = QDBusConnection::sessionBus();
+@@ -298,6 +318,8 @@ ActivityManager::ActivityManager()
+     // ensureCurrentActivityIsRunning();
+ 
+     KCrash::setFlags(KCrash::AutoRestart);
++
++    EventProcessor::self();
+ }
+ 
+ ActivityManager::~ActivityManager()
+@@ -656,49 +678,44 @@ void ActivityManager::SetActivityIcon(const QString & id, const QString & icon)
+ 
+ 
+ // Resource related mothods
+-
+-void ActivityManager::NotifyResourceAccessed(const QString & application, const QString & uri)
++void ActivityManager::RegisterResourceEvent(const QString & application, uint _windowId,
++        const QString & uri, uint event, uint reason)
+ {
+-    EventProcessor::self()->addEvent(application, uri, Event::Accessed);
+-}
++    if (event > Event::LastEventType || reason > Event::LastEventReason)
++        return;
+ 
+-void ActivityManager::NotifyResourceClosed(uint _windowId, const QString & uri)
+-{
+-    WId windowId = (WId)_windowId;
+-    d->resourcesForWindow[windowId].remove(KUrl(uri));
++    WId windowId = (WId) _windowId;
+ 
+-    EventProcessor::self()->addEvent(d->applicationForWindow[windowId], uri, Event::Closed);
++    kDebug() << "New event on the horizon" << application << _windowId << windowId << event << Event::Opened;
++    if (event == Event::Opened) {
+ 
+-    if (d->resourcesForWindow[windowId].size() == 0) {
+-        d->resourcesForWindow.remove(windowId);
+-        d->applicationForWindow.remove(windowId);
+-    }
+-}
++        KUrl kuri(uri);
+ 
+-void ActivityManager::NotifyResourceModified(uint windowId, const QString & uri)
+-{
+-    EventProcessor::self()->addEvent(d->applicationForWindow[(WId)windowId], uri, Event::Modified);
+-}
++        kDebug() << "Saving the open event for the window" << windowId;
++
++        d->windows[windowId].resources << kuri;
++        d->resources[kuri].activities << CurrentActivity();
++
++        kDebug() << d->windows.keys();
++
++    } else if (event == Event::Closed) {
++
++        // TODO: Remove from d->resources if needed
++        d->windows.remove(windowId);
+ 
+-void ActivityManager::NotifyResourceOpened(const QString & application, uint _windowId, const QString & uri)
+-{
+-    WId windowId = (WId)_windowId;
+-    if (!d->applicationForWindow.contains(windowId)) {
+-        d->applicationForWindow[windowId] = application;
+     }
+ 
+-    KUrl kuri(uri);
+-    d->resourcesForWindow[windowId] << kuri;
+-    d->activitiesForUrl[kuri] << CurrentActivity();
++    EventProcessor::self()->addEvent(application, windowId,
++            uri, (Event::Type) event, (Event::Reason) reason);
+ 
+-    EventProcessor::self()->addEvent(application, uri, Event::Opened);
+ }
+ 
+-QStringList ActivityManager::ActivitiesForResource(const QString & uri) const
++void ActivityManager::RegisterResourceMimeType(const QString & uri, const QString & mimetype)
+ {
+-    return d->activitiesForUrl.value(uri).toList();
+-}
++    KUrl kuri(uri);
+ 
++    d->resources[kuri].mimetype = mimetype;
++}
+ 
+ // static
+ ActivityManager * ActivityManager::self()
+diff --git a/activitymanager/ActivityManager.h b/activitymanager/ActivityManager.h
+index 6bc9ea5..79e66b4 100644
+--- a/activitymanager/ActivityManager.h
++++ b/activitymanager/ActivityManager.h
+@@ -51,6 +51,18 @@ public:
+     };
+ 
+     /**
++     * The event type
++     */
++    enum EventType {
++        Accessed = 1,
++        Opened = 2,
++        Modified = 3,
++        Closed = 4,
++        FocussedIn = 5,
++        FocussedOut = 6
++    };
++
++    /**
+      * Creates new ActivityManager
+      */
+     ActivityManager();
+@@ -222,70 +234,25 @@ Q_SIGNALS:
+ 
+ // Resource related mothods
+ public Q_SLOTS:
+-    /**
+-     * Should be called when the client application accesses
+-     * the file but is not interested in registering more advanced
+-     * events like open/modify/close.
+-     * @param application unformatted name of the application
+-     * @param uri uri of the resource
+-     */
+-    void NotifyResourceAccessed(const QString & application, const QString & uri);
+-
+-    /**
+-     * Should be called when the client application
+-     * opens a new resource identifiable by an uri.
+-     * @param application unformatted name of the application
+-     * @param windowId ID of the window that registers the resource
+-     * @param uri uri of the resource
+-     */
+-    void NotifyResourceOpened(const QString & application, uint windowId, const QString & uri);
+-
+-    /**
+-     * Should be called when the client application
+-     * modifies a resource already registered with NotifyResourceOpened
+-     * @param windowId ID of the window that registers the resource
+-     * @param uri uri of the resource
+-     */
+-    void NotifyResourceModified(uint windowId, const QString & uri);
+-
+-    /**
+-     * Should be called when the client application
+-     * closes a resource previously registered with
+-     * NotifyResourceOpened.
+-     * @param ID of the window that unregisters the resource
+-     * @param uri uri of the resource
+-     */
+-    void NotifyResourceClosed(uint windowId, const QString & uri);
+ 
+     /**
+-     * @returns the list of activities that are associated with
+-     * the specified resource
+-     * @param uri uri of the resource
++     * Registers a new event
++     * @param application the name of application that sent the event. Ignored if the event is not of type Opened
++     * @param windowId ID of the window that displays the resource. Ignored if the event is of type Accessed
++     * @param uri URI of the resource on which the event happened
++     * @param event type of the event
++     * @param reason reason for opening the resource
+      */
+-    QStringList ActivitiesForResource(const QString & uri) const;
++    void RegisterResourceEvent(const QString & application, uint windowId, const QString & uri, uint event, uint reason);
+ 
+-Q_SIGNALS:
+     /**
+-     * @see NotifyResourceAccessed
++     * Registers resource's mimetype. If not manually specified, it will
++     * be retrieved if needed from Nepomuk
++     *
++     * Note that this will be forgotten when the resource in question is closed.
++     * @param uri URI of the resource
+      */
+-    void ResourceAccessed(const QString & application, const QString & uri);
+-
+-    /**
+-     * @see NotifyResourceOpened
+-     */
+-    void ResourceOpened(const QString & application, uint windowId, const QString & uri);
+-
+-    /**
+-     * @see NotifyResourceModified
+-     */
+-    void ResourceModified(uint windowId, const QString & uri);
+-
+-    /**
+-     * @see NotifyResourceClosed
+-     */
+-    void ResourceClosed(uint windowId, const QString & uri);
+-
+-
++    void RegisterResourceMimeType(const QString & uri, const QString & mimetype);
+ 
+ private:
+     friend class ActivityManagerPrivate;
+diff --git a/activitymanager/ActivityManager_p.h b/activitymanager/ActivityManager_p.h
+index 3d9ec39..f68cb18 100644
+--- a/activitymanager/ActivityManager_p.h
++++ b/activitymanager/ActivityManager_p.h
+@@ -29,6 +29,8 @@
+ #include <KUrl>
+ 
+ #include "ActivityManager.h"
++#include "Event.h"
++#include "SharedInfo.h"
+ #include "config-features.h"
+ 
+ #ifdef HAVE_NEPOMUK
+@@ -46,7 +48,10 @@ class ActivityManagerPrivate: public QObject {
+     Q_OBJECT
+ 
+ public:
+-    ActivityManagerPrivate(ActivityManager * parent);
++    ActivityManagerPrivate(ActivityManager * parent,
++            QHash < WId, SharedInfo::WindowData > & _windows,
++            QHash < KUrl, SharedInfo::ResourceData > & _resources
++        );
+     ~ActivityManagerPrivate();
+ 
+     void addRunningActivity(const QString & id);
+@@ -55,11 +60,6 @@ public:
+     void ensureCurrentActivityIsRunning();
+     bool setCurrentActivity(const QString & id);
+ 
+-    // URIs and WIDs for open resources
+-    QHash < WId, QSet < KUrl > > resourcesForWindow;
+-    QHash < WId, QString > applicationForWindow;
+-    QHash < KUrl, QSet < QString > > activitiesForUrl;
+-
+     void setActivityState(const QString & id, ActivityManager::State state);
+     QHash < QString, ActivityManager::State > activities;
+ 
+@@ -74,6 +74,9 @@ public:
+     QTimer configSyncTimer;
+     KConfig config;
+ 
++    QHash < WId, SharedInfo::WindowData > & windows;
++    QHash < KUrl, SharedInfo::ResourceData > & resources;
++
+ public:
+     void initConifg();
+ 
+@@ -91,6 +94,7 @@ public Q_SLOTS:
+     void scheduleConfigSync();
+     void configSync();
+     void windowClosed(WId windowId);
++    void activeWindowChanged(WId windowId);
+ 
+     void startCompleted();
+     void stopCompleted();
+diff --git a/activitymanager/CMakeLists.txt b/activitymanager/CMakeLists.txt
+index 23dddae..726fcce 100644
+--- a/activitymanager/CMakeLists.txt
++++ b/activitymanager/CMakeLists.txt
+@@ -3,6 +3,7 @@ project(ActivityManager)
+ set (ADDITIONAL_LINK_LIBS)
+ 
+ add_subdirectory(kded)
++add_subdirectory(ontologies)
+ 
+ # Checking for Nepomuk
+ macro_optional_find_package(Nepomuk)
+@@ -56,23 +57,58 @@ include_directories(
+ set(activity_manager_SRCS
+     ActivityManager.cpp
+     EventProcessor.cpp
+-    ZeitgeistEventBackend.cpp
+-    NepomukEventBackend.cpp
+     EventBackend.cpp
+     Event.cpp
++    SharedInfo.cpp
+     main.cpp
+     )
+ 
++set(activity_manager_backends_SRCS
++    NepomukEventBackend.cpp
++    NepomukResourceScoreMaintainer.cpp
++    NepomukResourceScoreCache.cpp
++    ZeitgeistEventBackend.cpp
++    SlcEventBackend.cpp
++    )
++
+ qt4_add_dbus_adaptor(
+     activity_manager_SRCS org.kde.ActivityManager.xml
+     ActivityManager.h ActivityManager
+     )
+ 
++qt4_add_dbus_adaptor(
++    activity_manager_SRCS org.kde.ActivityManager.SLC.xml
++    SlcEventBackend.h SlcEventBackend
++    )
++
+ if(Nepomuk_FOUND)
+-    soprano_add_ontology(activity_manager_SRCS ${CMAKE_SOURCE_DIR}/nepomuk/ontologies/kext.trig "KExt" "Nepomuk::Vocabulary" "trig")
++    soprano_add_ontology(activity_manager_SRCS
++        ${CMAKE_SOURCE_DIR}/nepomuk/ontologies/kext.trig
++        "KExt" "Nepomuk::Vocabulary" "trig"
++        )
++
++    # soprano_add_ontology(activity_manager_SRCS
++    #     ${CMAKE_CURRENT_SOURCE_DIR}/ontologies/kamdrso.trig
++    #     "RSO" "Nepomuk::Vocabulary" "trig"
++    #     )
++
++    soprano_add_ontology(activity_manager_SRCS
++        ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nie/nie.trig
++        "NIE" "Nepomuk::Vocabulary" "trig"
++        )
++
++    soprano_add_ontology(activity_manager_SRCS
++        ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nepomuk/nao.trig
++        "NAO" "Nepomuk::Vocabulary" "trig"
++        )
++
++    soprano_add_ontology(activity_manager_SRCS
++        ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nepomuk/nuao.trig
++        "NUAO" "Nepomuk::Vocabulary" "trig"
++        )
+ endif()
+ 
+-kde4_add_executable(activity-manager ${activity_manager_SRCS})
++kde4_add_executable(activity-manager ${activity_manager_SRCS} ${activity_manager_backends_SRCS})
+ 
+ target_link_libraries(
+     activity-manager
+diff --git a/activitymanager/Event.cpp b/activitymanager/Event.cpp
+index ceabaf5..f8a964f 100644
+--- a/activitymanager/Event.cpp
++++ b/activitymanager/Event.cpp
+@@ -19,8 +19,9 @@
+ 
+ #include "Event.h"
+ 
+-Event::Event(const QString & vApplication, const QString & vUri, Type vType, Reason vReason)
+-    : application(vApplication), uri(vUri), type(vType), reason(vReason), timestamp(QDateTime::currentDateTime())
++
++Event::Event(const QString & vApplication, WId vWid, const QString & vUri, Type vType, Reason vReason)
++    : application(vApplication), wid(vWid), uri(vUri), type(vType), reason(vReason), timestamp(QDateTime::currentDateTime())
+ {
+ }
+ 
+@@ -28,6 +29,7 @@ bool Event::operator == (const Event & other) const
+ {
+     return
+         application == other.application &&
++        wid         == other.wid         &&
+         uri         == other.uri         &&
+         type        == other.type        &&
+         reason      == other.reason;
+diff --git a/activitymanager/Event.h b/activitymanager/Event.h
+index 5a05b7a..19b8187 100644
+--- a/activitymanager/Event.h
++++ b/activitymanager/Event.h
+@@ -21,6 +21,7 @@
+ #define EVENT_H_
+ 
+ #include <QString>
++#include <QWidget>
+ #include <QtCore/QDateTime>
+ 
+ /**
+@@ -29,26 +30,34 @@
+ class Event {
+ public:
+     enum Type {
+-        Accessed,   ///< resource was accessed, but we don't know for how long it will be open/used
+-        Opened,     ///< resource was opened
+-        Modified,   ///< previously opened resource was modified
+-        Closed      ///< previously opened resource was closed
++        Accessed = 0,    ///< resource was accessed, but we don't know for how long it will be open/used
++        Opened = 1,      ///< resource was opened
++        Modified = 2,    ///< previously opened resource was modified
++        Closed = 3,      ///< previously opened resource was closed
++        FocussedIn = 4,  ///< resource get the keyboard focus
++        FocussedOut = 5, ///< resource lost the focus
++
++        LastEventType = 5
++
+     };
+ 
+     enum Reason {
+-        User,
+-        Scheduled,
+-        Heuristic,
+-        System,
+-        World
++        User = 0,
++        Scheduled = 1,
++        Heuristic = 2,
++        System = 3,
++        World = 4,
++
++        LastEventReason = 4
+     };
+ 
+-    Event(const QString & application, const QString & uri, Type type = Accessed, Reason reason = User);
++    Event(const QString & application, WId wid, const QString & uri, Type type = Accessed, Reason reason = User);
+ 
+     bool operator == (const Event & other) const;
+ 
+ public:
+     QString application;
++    WId     wid;
+     QString uri;
+     Type    type;
+     Reason  reason;
+diff --git a/activitymanager/EventBackend.cpp b/activitymanager/EventBackend.cpp
+index e06c25d..2650dbf 100644
+--- a/activitymanager/EventBackend.cpp
++++ b/activitymanager/EventBackend.cpp
+@@ -26,3 +26,15 @@ EventBackend::EventBackend()
+ EventBackend::~EventBackend()
+ {
+ }
++
++void EventBackend::addEvents(const EventList & events)
++{
++    Q_UNUSED(events)
++}
++
++void EventBackend::setResourceMimeType(const QString & uri, const QString & mimetype)
++{
++    Q_UNUSED(uri)
++    Q_UNUSED(mimetype)
++}
++
+diff --git a/activitymanager/EventBackend.h b/activitymanager/EventBackend.h
+index 26bb925..bd7cbf9 100644
+--- a/activitymanager/EventBackend.h
++++ b/activitymanager/EventBackend.h
+@@ -31,7 +31,8 @@ public:
+     EventBackend();
+     virtual ~EventBackend();
+ 
+-    virtual void addEvents(const EventList & events) = 0;
++    virtual void addEvents(const EventList & events);
++    virtual void setResourceMimeType(const QString & uri, const QString & mimetype);
+ 
+ };
+ 
+diff --git a/activitymanager/EventProcessor.cpp b/activitymanager/EventProcessor.cpp
+index 6e38bf2..48bb405 100644
+--- a/activitymanager/EventProcessor.cpp
++++ b/activitymanager/EventProcessor.cpp
+@@ -31,6 +31,8 @@
+ #include "NepomukEventBackend.h"
+ #endif
+ 
++#include "SlcEventBackend.h"
++
+ #include <QDateTime>
+ #include <QList>
+ #include <QMutex>
+@@ -41,7 +43,9 @@
+ 
+ class EventProcessorPrivate: public QThread {
+ public:
+-    QList < EventBackend * > backends;
++    QList < EventBackend * > lazyBackends;
++    QList < EventBackend * > syncBackends;
++
+     QList < Event > events;
+     QMutex events_mutex;
+ 
+@@ -75,7 +79,7 @@ void EventProcessorPrivate::run()
+ 
+         EventProcessorPrivate::events_mutex.unlock();
+ 
+-        foreach (EventBackend * backend, backends) {
++        foreach (EventBackend * backend, lazyBackends) {
+             backend->addEvents(currentEvents);
+         }
+     }
+@@ -94,23 +98,29 @@ EventProcessor::EventProcessor()
+     : d(new EventProcessorPrivate())
+ {
+ #ifdef HAVE_QZEITGEIST
+-    d->backends.append(new ZeitgeistEventBackend());
++    d->lazyBackends.append(new ZeitgeistEventBackend());
+ #endif
+ #ifdef HAVE_NEPOMUK
+-    d->backends.append(new NepomukEventBackend());
++    d->lazyBackends.append(new NepomukEventBackend());
+ #endif
++    d->syncBackends.append(new SlcEventBackend());
+ }
+ 
+ EventProcessor::~EventProcessor()
+ {
+-    qDeleteAll(d->backends);
++    qDeleteAll(d->lazyBackends);
++    qDeleteAll(d->syncBackends);
+     delete d;
+ }
+ 
+-void EventProcessor::addEvent(const QString & application, const QString & uri,
+-        Event::Type type, Event::Reason reason)
++void EventProcessor::addEvent(const QString & application, WId wid, const QString & uri,
++            Event::Type type, Event::Reason reason)
+ {
+-    Event newEvent(application, uri, type, reason);
++    Event newEvent(application, wid, uri, type, reason);
++
++    foreach (EventBackend * backend, d->syncBackends) {
++        backend->addEvents(QList < Event > () << newEvent);
++    }
+ 
+     d->events_mutex.lock();
+ 
+diff --git a/activitymanager/EventProcessor.h b/activitymanager/EventProcessor.h
+index 59cdbad..64eeeb3 100644
+--- a/activitymanager/EventProcessor.h
++++ b/activitymanager/EventProcessor.h
+@@ -30,13 +30,13 @@ class EventProcessorPrivate;
+ /**
+  * Thread to process desktop/usage events
+  */
+-class EventProcessor: public QThread {
++class EventProcessor {
+ public:
+     static EventProcessor * self();
+ 
+     virtual ~EventProcessor();
+ 
+-    void addEvent(const QString & application, const QString & uri,
++    void addEvent(const QString & application, WId wid, const QString & uri,
+             Event::Type type = Event::Accessed, Event::Reason reason = Event::User);
+ 
+ private:
+diff --git a/activitymanager/NepomukCommon.h b/activitymanager/NepomukCommon.h
+new file mode 100644
+index 0000000..9df5a62
+--- /dev/null
++++ b/activitymanager/NepomukCommon.h
+@@ -0,0 +1,63 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifndef NEPOMUK_COMMON_H_
++#define NEPOMUK_COMMON_H_
++
++#include "nie.h"
++
++#define NUAO_targettedResource KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("targettedResource"))
++#define NUAO_initiatingAgent   KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("initiatingAgent"))
++// #define NUAO_involvesActivity  KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("involvesActivity"))
++
++#define activityResource(ID) Nepomuk::Resource(ID, KExt::Activity())
++#define agentResource(ID)    Nepomuk::Resource(ID, NAO::Agent())
++#define currentActivityRes   activityResource(ActivityManager::self()->CurrentActivity())
++
++// #define anyResource(ID) Nepomuk::Resource(KUrl(ID))
++
++inline Nepomuk::Resource anyResource(const QUrl & uri)
++{
++    Nepomuk::Resource result(uri);
++
++    kDebug() << "setting the URI" << result.isFile() << result.isValid();
++    result.setProperty(Nepomuk::Vocabulary::NIE::url(), uri);
++    kDebug() << "set the URI" << result.isFile() << result.isValid();
++
++    return result;
++}
++
++inline Nepomuk::Resource anyResource(const QString & uri)
++{
++    return anyResource(KUrl(uri));
++}
++
++#define litN3(A) Soprano::Node::literalToN3(A)
++
++inline QString resN3(const QUrl & uri)
++{
++    return Soprano::Node::resourceToN3(uri);
++}
++
++inline QString resN3(const Nepomuk::Resource & resource)
++{
++    return Soprano::Node::resourceToN3(resource.resourceUri());
++}
++
++#endif // NEPOMUK_COMMON_H_
+diff --git a/activitymanager/NepomukEventBackend.cpp b/activitymanager/NepomukEventBackend.cpp
+index 4fe3584..65c398c 100644
+--- a/activitymanager/NepomukEventBackend.cpp
++++ b/activitymanager/NepomukEventBackend.cpp
+@@ -31,6 +31,8 @@
+ #else // HAVE_NEPOMUK
+ 
+ #include "NepomukEventBackend.h"
++#include "NepomukResourceScoreMaintainer.h"
++
+ #include "Event.h"
+ #include "ActivityManager.h"
+ #include "kext.h"
+@@ -54,9 +56,11 @@
+ 
+ #include <kdebug.h>
+ 
++#include "NepomukCommon.h"
++
++using namespace Soprano::Vocabulary;
+ using namespace Nepomuk::Vocabulary;
+ using namespace Nepomuk::Query;
+-using namespace Soprano::Vocabulary;
+ 
+ NepomukEventBackend::NepomukEventBackend()
+ {
+@@ -64,21 +68,88 @@ NepomukEventBackend::NepomukEventBackend()
+ 
+ void NepomukEventBackend::addEvents(const EventList & events)
+ {
+-    foreach(const Event& event, events) {
+-        if(event.type == Event::Accessed) {
+-            // one-shot event
+-            Nepomuk::Resource eventRes = createDesktopEvent(event.uri, event.timestamp, event.application);
+-            eventRes.addType(NUAO::UsageEvent());
+-            eventRes.addProperty(NUAO::end(), event.timestamp);
+-        }
+-        else if(event.type == Event::Opened) {
+-            // create a new event
+-            createDesktopEvent(event.uri, event.timestamp, event.application);
++    foreach (const Event& event, events) {
++        kDebug() << "We are processing event" << event.type << event.uri;
++        kDebug() << "for agent" << event.application << agentResource(event.application).resourceUri();
++
++        switch (event.type) {
++            case Event::Accessed:
++            {
++                // one-shot event
++
++                Nepomuk::Resource eventRes = createDesktopEvent(event.uri, event.timestamp, event.application);
++                eventRes.addType(NUAO::UsageEvent());
++                eventRes.setProperty(NUAO::start(), event.timestamp);
++                eventRes.setProperty(NUAO::end(), event.timestamp);
++
++                kDebug() << "Created one-shot Accessed event" << eventRes;
++
++                NepomukResourceScoreMaintainer::self()->processResource(event.uri, event.application);
++
++                break;
++            }
++
++            case Event::Opened:
++                // create a new event
++                createDesktopEvent(event.uri, event.timestamp, event.application);
++
++                break;
++
++            case Event::Closed:
++            {
++                // We should find and close the last open event
++                // TODO: This can have a problem if an app closes a document
++                // while not in the current activity
++                const QString query
++                    = QString::fromLatin1(
++                            "select ?r where { "
++                                "?r a nuao:DesktopEvent . "
++                                "?r %1 %2 . "
++                                "?r %3 %4 . "
++                                "?r %5 %6 . "
++                                "?r nuao:start ?start . "
++                                "OPTIONAL { ?r nuao:end ?d . } . "
++                                "FILTER(!BOUND(?d)) . "
++                            "}"
++                            "ORDER BY DESC (?start) LIMIT 1"
++                    ).arg(
++                        /* %1 */ resN3(NUAO_targettedResource),
++                        /* %2 */ resN3(anyResource(KUrl(event.uri))),
++                        /* %3 */ resN3(NUAO_initiatingAgent),
++                        /* %4 */ resN3(agentResource(event.application)),
++                        /* %5 */ resN3(KExt::usedActivity()),
++                        /* %6 */ resN3(currentActivityRes)
++                    );
++                kDebug() << query;
++
++                Soprano::QueryResultIterator it
++                        = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(query, Soprano::Query::QueryLanguageSparql);
++
++                if (it.next()) {
++                    kDebug() << "Closing the event";
++
++                    Nepomuk::Resource eventRes(it[0].uri());
++                    it.close();
++
++                    eventRes.addProperty(NUAO::end(), event.timestamp);
++
++                    NepomukResourceScoreMaintainer::self()->processResource(event.uri, event.application);
++                }
++
++                break;
++            }
++
++            default:
++                // Nothing yet
++                // TODO: Add focus and modification
++                break;
+         }
+-        else {
+-            // find the corresponding event
+-            // FIXME: enable this once the range of nao:identifier has been fixed and is no longer assumed to be rdfs:Resource
+-            // resulting in a wrong query.
++
++
++//        } else {
++//            // find the corresponding event
++//            // FIXME: enable this once the range of nao:identifier has been fixed and is no longer assumed to be rdfs:Resource
++//            // resulting in a wrong query.
+ //            Query query(ResourceTypeTerm(NUAO::DesktopEvent())
+ //                        && ComparisonTerm(NUAO::involves(),
+ //                                          ResourceTerm(Nepomuk::Resource(KUrl(event.uri))), ComparisonTerm::Equal)
+@@ -88,77 +159,103 @@ void NepomukEventBackend::addEvents(const EventList & events)
+ //                        && !ComparisonTerm(NUAO::end(), Term()));
+ //            query.setLimit(1);
+ //            query.setQueryFlags(Query::NoResultRestrictions);
+-//            const QString queryS = query.toSparqlQuery();
+-            const QString queryS
+-                    = QString::fromLatin1("select ?r where { "
+-                                          "?r a nuao:DesktopEvent . "
+-                                          "?r nuao:involves %1 . "
+-                                          "?r nuao:involves ?a . "
+-                                          "?a a nao:Agent . "
+-                                          "?a nao:identifier %2 . "
+-                                          "OPTIONAL { ?r nuao:end ?d . } . "
+-                                          "FILTER(!BOUND(?d)) . } "
+-                                          "LIMIT 1")
+-                    .arg(Soprano::Node::resourceToN3(Nepomuk::Resource(KUrl(event.uri)).resourceUri()),
+-                         Soprano::Node::literalToN3(event.application));
+-            kDebug() << queryS;
+-            Soprano::QueryResultIterator it
+-                    = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(queryS, Soprano::Query::QueryLanguageSparql);
+-            if(it.next()) {
+-                Nepomuk::Resource eventRes(it[0].uri());
+-                it.close();
+-
+-                eventRes.addProperty(NUAO::end(), event.timestamp);
+-                if(event.type == Event::Modified) {
+-                    eventRes.addType(NUAO::ModificationEvent());
+-                }
+-                else {
+-                    eventRes.addType(NUAO::UsageEvent());
+-                }
+-
+-                // In case of a modification event we create a new event which will
+-                // be completed by the final Closed event since this one resource
+-                // modification is done now. It ended with saving the resource.
+-                if(event.type == Event::Modified) {
+-                    // create a new event
+-                    createDesktopEvent(event.uri, event.timestamp, event.application);
+-                }
+-            }
+-            else {
+-                kDebug() << "Failed to find matching Open event for resource" << event.uri << "and application" << event.application;
+-            }
+-        }
++//            const QString query = query.toSparqlQuery();
++//
++//            // TODO: Something strange is going on here - this should check for
++//            // the activity as well
++//            const QString query
++//                    = QString::fromLatin1("select ?r where { "
++//                                          "?r a nuao:DesktopEvent . "
++//                                          "?r %1 %2 . "
++//                                          "?r %3 %4 . "
++//                                          "OPTIONAL { ?r nuao:end ?d . } . "
++//                                          "FILTER(!BOUND(?d)) . } "
++//                                          "LIMIT 1")
++//                    .arg(
++//                        /* %1 */ resN3(NUAO_targettedResource),
++//                        /* %2 */ resN3(anyResource(KUrl(event.uri))),
++//                        /* %3 */ resN3(NUAO_initiatingAgent),
++//                        /* %4 */ resN3(agentResource(event.application))
++//                    );
++//
++//            kDebug() << query;
++//
++//            Soprano::QueryResultIterator it
++//                    = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(query, Soprano::Query::QueryLanguageSparql);
++//
++//            if (it.next()) {
++//                Nepomuk::Resource eventRes(it[0].uri());
++//                it.close();
++//
++//                eventRes.addProperty(NUAO::end(), event.timestamp);
++//                if (event.type == Event::Modified) {
++//                    eventRes.addType(NUAO::ModificationEvent());
++//                } else {
++//                    eventRes.addType(NUAO::UsageEvent());
++//                }
++//
++//                // TODO: We are not creating separate events for modifications
++//                // // In case of a modification event we create a new event which will
++//                // // be completed by the final Closed event since this one resource
++//                // // modification is done now. It ended with saving the resource.
++//                // if (event.type == Event::Modified) {
++//                //     // create a new event
++//                //     createDesktopEvent(event.uri, event.timestamp, event.application);
++//                // }
++//
++//            } else {
++//                kDebug() << "Failed to find matching Open event for resource" << event.uri << "and application" << event.application;
++//            }
++//
++//            if (event.type == Event::Closed) {
++//                NepomukResourceScoreMaintainer::self()->processResource(event.uri, event.application);
++//            }
++//        }
+     }
+ }
+ 
+ Nepomuk::Resource NepomukEventBackend::createDesktopEvent(const KUrl& uri, const QDateTime& startTime, const QString& app)
+ {
++    kDebug() << "Creating a new desktop event" << uri << startTime << app;
++
+     // one-shot event
+     Nepomuk::Resource eventRes(QUrl(), NUAO::DesktopEvent());
+-    eventRes.addProperty(NUAO::involves(), Nepomuk::Resource(uri));
++    eventRes.addProperty(NUAO_targettedResource, anyResource(uri));
+     eventRes.addProperty(NUAO::start(), startTime);
+ 
++    kDebug() << "Created event" << eventRes.resourceUri()
++             << "for resource" << ((Nepomuk::Resource(uri)).resourceUri());
++
+     // the app
+     Nepomuk::Resource appRes(app, NAO::Agent());
+-    eventRes.addProperty(NUAO::involves(), appRes);
++    eventRes.addProperty(NUAO_initiatingAgent, appRes);
+ 
+     // the activity
+-    if(!m_currentActivity.isValid()
++    if (!m_currentActivity.isValid()
+             || m_currentActivity.identifiers().isEmpty()
+             || m_currentActivity.identifiers().first() != ActivityManager::self()->CurrentActivity()) {
+         // update the current activity resource
+-        Soprano::QueryResultIterator it
+-                = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(QString::fromLatin1("select ?r where { ?r a %1 . ?r %2 %3 . } LIMIT 1")
+-                                                                                  .arg(Soprano::Node::resourceToN3(KExt::Activity()),
+-                                                                                       Soprano::Node::resourceToN3(KExt::activityIdentifier()),
+-                                                                                       Soprano::Node::literalToN3(ActivityManager::self()->CurrentActivity())),
+-                                                                                  Soprano::Query::QueryLanguageSparql);
+-        if(it.next()) {
++
++        kDebug() << "Assigning the activity to the event";
++
++        const QString query = QString::fromLatin1("select ?r where { "
++                " ?r a %1 . "
++                " ?r %2 %3 . "
++                "} LIMIT 1"
++            ).arg(
++                /* %1 */ resN3(KExt::Activity()),
++                /* %2 */ resN3(KExt::activityIdentifier()),
++                /* %3 */ resN3(currentActivityRes)
++            );
++
++        Soprano::QueryResultIterator it = Nepomuk::ResourceManager::instance()->mainModel()
++            ->executeQuery(query, Soprano::Query::QueryLanguageSparql);
++
++        if (it.next()) {
+             m_currentActivity = it[0].uri();
+-        }
+-        else {
+-            m_currentActivity = Nepomuk::Resource(ActivityManager::self()->CurrentActivity(), Nepomuk::Vocabulary::KExt::Activity());
+-            m_currentActivity.setProperty(Nepomuk::Vocabulary::KExt::activityIdentifier(), ActivityManager::self()->CurrentActivity());
++        } else {
++            m_currentActivity = currentActivityRes;
++            m_currentActivity.setProperty(KExt::activityIdentifier(), ActivityManager::self()->CurrentActivity());
+         }
+     }
+ 
+diff --git a/activitymanager/NepomukResourceScoreCache.cpp b/activitymanager/NepomukResourceScoreCache.cpp
+new file mode 100644
+index 0000000..8d1b66b
+--- /dev/null
++++ b/activitymanager/NepomukResourceScoreCache.cpp
+@@ -0,0 +1,214 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#include "NepomukResourceScoreCache.h"
++
++#include <cmath>
++
++#include <Soprano/Model>
++#include <Soprano/QueryResultIterator>
++
++#include <Nepomuk/Resource>
++#include <Nepomuk/ResourceManager>
++#include <Nepomuk/Variant>
++
++#include <KDebug>
++
++#include "kext.h"
++#include "nao.h"
++#include "nuao.h"
++
++#include "ActivityManager.h"
++
++using namespace Nepomuk::Vocabulary;
++
++#include "NepomukCommon.h"
++
++/**
++ *
++ */
++class NepomukResourceScoreCachePrivate {
++public:
++    Nepomuk::Resource self;
++    QString activity;
++    QString application;
++    QUrl resource;
++
++    qreal timeFactor(int days) const
++    {
++        // Exp is falling rather quickly, we are slowing it 32 times
++        return ::exp(- days / 32.0);
++    }
++
++    qreal timeFactor(QDateTime fromTime, QDateTime toTime = QDateTime::currentDateTime()) const
++    {
++        return timeFactor(fromTime.daysTo(toTime));
++    }
++
++};
++
++NepomukResourceScoreCache::NepomukResourceScoreCache(const QString & activity, const QString & application, const QUrl & resource)
++    : d(new NepomukResourceScoreCachePrivate())
++{
++    kDebug() << "Cache for" << activity << application << resource << anyResource(resource).resourceUri();
++
++    d->activity = activity;
++    d->application = application;
++    d->resource = resource;
++
++    const QString query
++        = QString::fromLatin1("select ?r where { "
++                                  "?r a %1 . "
++                                  "?r kext:usedActivity %2 . "
++                                  "?r kext:initiatingAgent %3 . "
++                                  "?r kext:targettedResource %4 . "
++                                  "} LIMIT 1"
++            ).arg(
++                /* %1 */ resN3(KExt::ResourceScoreCache()),
++                /* %2 */ resN3(currentActivityRes),
++                /* %3 */ resN3(agentResource(application)),
++                /* %4 */ resN3(anyResource(resource))
++            );
++
++    kDebug() << query;
++
++    Soprano::QueryResultIterator it
++        = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(query, Soprano::Query::QueryLanguageSparql);
++
++    if (it.next()) {
++        Nepomuk::Resource result(it[0].uri());
++        it.close();
++
++        d->self = result;
++
++        kDebug() << "Found an old cache" << d->self.resourceUri() << d->self.resourceType()
++                 << "With a score of" << d->self.property(KExt::cachedScore()) << d->self.property(NAO::score());
++
++    } else {
++        Nepomuk::Resource result(QUrl(), KExt::ResourceScoreCache());
++
++        result.setProperty(
++                KExt::targettedResource(),
++                Nepomuk::Resource(resource)
++            );
++        result.setProperty(
++                KExt::initiatingAgent(), agentResource(application)
++            );
++        result.setProperty(
++                KExt::usedActivity(), activityResource(activity)
++            );
++        result.setProperty(KExt::cachedScore(), 0);
++
++        d->self = result;
++
++        kDebug() << "Created a new cache resource" << d->self.resourceUri() << d->self.resourceType();
++
++    }
++}
++
++NepomukResourceScoreCache::~NepomukResourceScoreCache()
++{
++    delete d;
++}
++
++void NepomukResourceScoreCache::updateScore()
++{
++    kDebug() << "Updating the score for " << d->resource;
++    kDebug() << "Last modified as string" << d->self.property(NAO::lastModified());
++
++    QDateTime lastModified = d->self.property(NAO::lastModified()).toDateTime();
++
++    qreal score = d->self.property(KExt::cachedScore()).toDouble();
++
++    if (lastModified.isValid()) {
++        // Adjusting the score depending on the time that passed since the
++        // last update
++
++        kDebug() << "Previous score:" << score;
++        score *= d->timeFactor(lastModified);
++        kDebug() << "Adjusted score:" << score;
++
++    } else {
++        // If we haven't had previous calculation, set the score to 0
++        score = 0;
++
++    }
++
++    kDebug() << "Last modified timestamp is" << lastModified << lastModified.isValid();
++
++    const QString query
++        = QString::fromLatin1("select distinct ?r where { "
++                                  "?r a nuao:DesktopEvent . "
++                                  "?r %1 %2 . "
++                                  "?r %3 %4 . "
++                                  "?r %5 %6 . "
++                                  "?r nuao:end ?end . "
++                                  "FILTER(?end >= %7) ."
++                                  " } "
++            ).arg(
++                /* %1 */ resN3(KExt::usedActivity()),
++                /* %2 */ resN3(activityResource(d->activity)),
++                /* %3 */ resN3(NUAO_targettedResource),
++                /* %4 */ resN3(anyResource(d->resource)),
++                /* %5 */ resN3(NUAO_initiatingAgent),
++                /* %6 */ resN3(agentResource(d->application)),
++                /* %7 */ litN3(lastModified.isValid() ? lastModified : QDateTime::fromMSecsSinceEpoch(0))
++            );
++
++    kDebug() << query;
++
++    Soprano::QueryResultIterator it
++        = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(query, Soprano::Query::QueryLanguageSparql);
++
++    d->self.setProperty(NAO::lastModified(), QDateTime::currentDateTime());
++
++    while (it.next()) {
++        Nepomuk::Resource result(it[0].uri());
++        QDateTime eventStart = result.property(NUAO::start()).toDateTime();
++        QDateTime eventEnd = result.property(NUAO::end()).toDateTime();
++
++        if (!eventStart.isValid()) continue;
++
++        if (!eventEnd.isValid()) {
++            // If the end was not saved, we are treating it as a simple
++            // Accessed event
++            eventEnd = eventStart;
++        }
++
++        int intervalLength = eventStart.secsTo(eventEnd);
++
++        if (intervalLength == 0) {
++            // We have an Accessed event - otherwise, this wouldn't be 0
++
++            score += d->timeFactor(eventEnd); // like it is open for 1 minute
++
++        } else if (intervalLength >= 4) {
++            // Ignoring stuff that was open for less than 4 seconds
++
++            score += d->timeFactor(eventEnd) * intervalLength / 60.0;
++        }
++
++        kDebug() << result.resourceUri() << eventStart << eventEnd << intervalLength;
++
++    }
++
++    kDebug() << "New calculated score:" << score << d->self.isValid();
++    d->self.setProperty(KExt::cachedScore(), score);
++    d->self.setProperty(NAO::score(), score);
++}
+diff --git a/activitymanager/NepomukResourceScoreCache.h b/activitymanager/NepomukResourceScoreCache.h
+new file mode 100644
+index 0000000..a26b5a2
+--- /dev/null
++++ b/activitymanager/NepomukResourceScoreCache.h
+@@ -0,0 +1,42 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifndef NEPOMUK_RESOURCE_SCORE_CACHE_H_
++#define NEPOMUK_RESOURCE_SCORE_CACHE_H_
++
++#include <QString>
++#include <QUrl>
++
++class NepomukResourceScoreCachePrivate;
++
++/**
++ *
++ */
++class NepomukResourceScoreCache {
++public:
++    NepomukResourceScoreCache(const QString & activity, const QString & application, const QUrl & resource);
++    virtual ~NepomukResourceScoreCache();
++
++    void updateScore();
++
++private:
++    class NepomukResourceScoreCachePrivate * const d;
++};
++
++#endif // NEPOMUK_RESOURCE_SCORE_CACHE_H_
+diff --git a/activitymanager/NepomukResourceScoreMaintainer.cpp b/activitymanager/NepomukResourceScoreMaintainer.cpp
+new file mode 100644
+index 0000000..f5e4d3c
+--- /dev/null
++++ b/activitymanager/NepomukResourceScoreMaintainer.cpp
+@@ -0,0 +1,145 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#include "NepomukResourceScoreMaintainer.h"
++
++#include <QList>
++#include <QMutex>
++#include <QThread>
++
++#include <KDebug>
++
++#include <Nepomuk/Resource>
++
++#include <time.h>
++#include "kext.h"
++
++#include "ActivityManager.h"
++#include "NepomukResourceScoreCache.h"
++
++class NepomukResourceScoreMaintainerPrivate: public QThread {
++public:
++    typedef QString ApplicationName;
++    typedef QString ActivityID;
++    typedef QList < QUrl > ResourceList;
++
++    typedef QMap < ApplicationName, ResourceList > Applications;
++    typedef QMap < ActivityID, Applications > ResourceTree;
++
++    ResourceTree openResources;
++    QMutex openResources_mutex;
++
++    void run();
++    void processActivity(const ActivityID & activity, const Applications & applications);
++
++    static NepomukResourceScoreMaintainer * s_instance;
++
++};
++
++NepomukResourceScoreMaintainer * NepomukResourceScoreMaintainerPrivate::s_instance = NULL;
++
++void NepomukResourceScoreMaintainerPrivate::run()
++{
++    forever {
++        // initial delay before processing the resources
++        sleep(5);
++
++        NepomukResourceScoreMaintainerPrivate::openResources_mutex.lock();
++            ResourceTree resources = openResources;
++            openResources.clear();
++        NepomukResourceScoreMaintainerPrivate::openResources_mutex.unlock();
++
++        const QString & activity = ActivityManager::self()->CurrentActivity();
++
++        // Let us first process the events related to the current
++        // activity so that the stats are available quicker
++
++        if (resources.contains(activity)) {
++            kDebug() << "Processing current activity events";
++
++            processActivity(activity, resources[activity]);
++            resources.remove(activity);
++        }
++
++        foreach (const ActivityID & activity, resources.keys()) {
++            kDebug() << "Processing activity" << activity;
++
++            processActivity(activity, resources[activity]);
++        }
++    }
++}
++
++void NepomukResourceScoreMaintainerPrivate::processActivity(const ActivityID & activity, const Applications & applications)
++{
++    foreach (const ApplicationName & application, applications.keys()) {
++        // Processing resources for the pair (activity, application)
++        kDebug() << "  Processing application" << application;
++
++        foreach (const QUrl & resource, applications[application]) {
++            kDebug() << "    Updating score for" << activity, application, resource;
++            NepomukResourceScoreCache(activity, application, resource).updateScore();
++
++        }
++    }
++}
++
++NepomukResourceScoreMaintainer * NepomukResourceScoreMaintainer::self()
++{
++    if (!NepomukResourceScoreMaintainerPrivate::s_instance) {
++        NepomukResourceScoreMaintainerPrivate::s_instance = new NepomukResourceScoreMaintainer();
++    }
++
++    return NepomukResourceScoreMaintainerPrivate::s_instance;
++}
++
++NepomukResourceScoreMaintainer::NepomukResourceScoreMaintainer()
++    : d(new NepomukResourceScoreMaintainerPrivate())
++{
++}
++
++NepomukResourceScoreMaintainer::~NepomukResourceScoreMaintainer()
++{
++    delete d;
++}
++
++void NepomukResourceScoreMaintainer::processResource(const KUrl & resource, const QString & application)
++{
++    d->openResources_mutex.lock();
++
++    // Checking whether the item is already scheduled for
++    // processing
++
++    kDebug() << "Adding" << resource << application << "to the queue";
++
++    const QString & activity = ActivityManager::self()->CurrentActivity();
++
++    if (d->openResources.contains(activity) &&
++            d->openResources[activity].contains(application) &&
++            d->openResources[activity][application].contains(resource)) {
++        return;
++    }
++
++    d->openResources[activity][application] << resource;
++
++    d->openResources_mutex.unlock();
++
++    d->start();
++}
++
++
+diff --git a/activitymanager/NepomukResourceScoreMaintainer.h b/activitymanager/NepomukResourceScoreMaintainer.h
+new file mode 100644
+index 0000000..cbef9f9
+--- /dev/null
++++ b/activitymanager/NepomukResourceScoreMaintainer.h
+@@ -0,0 +1,47 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifndef NEPOMUK_RESOURCE_SCORE_MAINTAINER_H_
++#define NEPOMUK_RESOURCE_SCORE_MAINTAINER_H_
++
++#include <QThread>
++#include <Nepomuk/Resource>
++
++#include "Event.h"
++
++class NepomukResourceScoreMaintainerPrivate;
++
++/**
++ * Thread to process desktop/usage events
++ */
++class NepomukResourceScoreMaintainer {
++public:
++    static NepomukResourceScoreMaintainer * self();
++
++    virtual ~NepomukResourceScoreMaintainer();
++
++    void processResource(const KUrl & resource, const QString & application);
++
++private:
++    NepomukResourceScoreMaintainer();
++
++    class NepomukResourceScoreMaintainerPrivate * const d;
++};
++
++#endif // NEPOMUK_RESOURCE_SCORE_MAINTAINER_H_
+diff --git a/activitymanager/SharedInfo.cpp b/activitymanager/SharedInfo.cpp
+new file mode 100644
+index 0000000..8c71c34
+--- /dev/null
++++ b/activitymanager/SharedInfo.cpp
+@@ -0,0 +1,51 @@
++/*
++ *   Copyright (C) 2010 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#include "SharedInfo.h"
++
++SharedInfo * SharedInfo::s_instance = NULL;
++
++SharedInfo * SharedInfo::self()
++{
++    if (!s_instance) {
++        s_instance = new SharedInfo();
++    }
++
++    return s_instance;
++}
++
++SharedInfo::SharedInfo()
++{
++}
++
++SharedInfo::~SharedInfo()
++{
++}
++
++QHash < WId, SharedInfo::WindowData > const & SharedInfo::windows() const
++{
++    return m_windows;
++}
++
++QHash < KUrl, SharedInfo::ResourceData > const & SharedInfo::resources() const
++{
++    return m_resources;
++}
++
++
+diff --git a/activitymanager/SharedInfo.h b/activitymanager/SharedInfo.h
+new file mode 100644
+index 0000000..6e60612
+--- /dev/null
++++ b/activitymanager/SharedInfo.h
+@@ -0,0 +1,63 @@
++/*
++ *   Copyright (C) 2010 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifndef SHARED_INFO_H_
++#define SHARED_INFO_H_
++
++#include <KUrl>
++#include <QSet>
++#include <QString>
++#include <QHash>
++
++#include "Event.h"
++
++/**
++ *
++ */
++class SharedInfo {
++public:
++    static SharedInfo * self();
++
++    virtual ~SharedInfo();
++
++    struct WindowData {
++        QSet < KUrl > resources;
++        QString application;
++    };
++
++    struct ResourceData {
++        Event::Reason reason;
++        QSet < QString > activities;
++        QString mimetype;
++    };
++
++    QHash < WId, WindowData > const & windows() const;
++    QHash < KUrl, ResourceData > const & resources() const;
++
++private:
++    QHash < WId, WindowData > m_windows;
++    QHash < KUrl, ResourceData > m_resources;
++
++    static SharedInfo * s_instance;
++    SharedInfo();
++
++    friend class ActivityManager;
++};
++
++#endif // SHARED_INFO_H_
+diff --git a/activitymanager/SlcEventBackend.cpp b/activitymanager/SlcEventBackend.cpp
+new file mode 100644
+index 0000000..fe8f01d
+--- /dev/null
++++ b/activitymanager/SlcEventBackend.cpp
+@@ -0,0 +1,127 @@
++/*
++ *   Copyright (C) 2010 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#include "SlcEventBackend.h"
++#include "slcadaptor.h"
++
++#include <QDBusConnection>
++#include <KDebug>
++#include <KWindowSystem>
++#include <KUrl>
++
++#include "SharedInfo.h"
++
++SlcEventBackend::SlcEventBackend()
++    : focussedWindow(0)
++{
++    QDBusConnection dbus = QDBusConnection::sessionBus();
++    new SLCAdaptor(this);
++    dbus.registerObject("/SLC", this);
++
++    connect(KWindowSystem::self(), SIGNAL(activeWindowChanged(WId)),
++            this, SLOT(activeWindowChanged(WId)));
++}
++
++void SlcEventBackend::addEvents(const EventList & events)
++{
++    foreach (const Event & event, events) {
++        switch (event.type) {
++            case Event::FocussedIn:
++            case Event::Opened:
++                // kDebug() << "Event::FocussedIn" << focussedWindow << event.wid << event.uri;
++
++                lastFocussedResource[event.wid] = event.uri;
++
++                if (event.wid == focussedWindow) {
++                    updateFocus(focussedWindow);
++                }
++
++                break;
++
++            case Event::FocussedOut:
++            case Event::Closed:
++                // kDebug() << "Event::FocussedOut" << focussedWindow << event.wid << event.uri;
++
++                if (lastFocussedResource[event.wid] == event.uri) {
++                    lastFocussedResource[event.wid] = KUrl();
++                }
++
++                if (event.wid == focussedWindow) {
++                    updateFocus();
++                }
++
++                break;
++
++            default:
++                // nothing
++                break;
++        }
++    }
++}
++
++KUrl SlcEventBackend::_focussedResourceURI()
++{
++    KUrl kuri;
++
++    if (lastFocussedResource.contains(focussedWindow)) {
++        kuri = lastFocussedResource[focussedWindow];
++    } else {
++        foreach (const KUrl & uri, SharedInfo::self()->windows()[focussedWindow].resources) {
++            kuri = uri;
++            break;
++        }
++    }
++
++    return kuri;
++}
++
++QString SlcEventBackend::focussedResourceURI()
++{
++    return _focussedResourceURI().url();
++}
++
++QString SlcEventBackend::focussedResourceMimetype()
++{
++    return SharedInfo::self()->resources().contains(_focussedResourceURI()) ?
++        SharedInfo::self()->resources()[_focussedResourceURI()].mimetype : QString();
++}
++
++void SlcEventBackend::activeWindowChanged(WId wid)
++{
++    if (wid == focussedWindow) return;
++
++    focussedWindow = wid;
++
++    updateFocus(wid);
++}
++
++void SlcEventBackend::updateFocus(WId wid)
++{
++    // kDebug() << "Updating focus for " << wid;
++
++    if (wid == 0 || !SharedInfo::self()->windows().contains(wid)) {
++        // kDebug() << "Clearing focus";
++        emit focusChanged(QString(), QString());
++
++    } else if (wid == focussedWindow) {
++        // kDebug() << "It is the currently focussed window";
++        emit focusChanged(focussedResourceURI(), SharedInfo::self()->resources()[_focussedResourceURI()].mimetype);
++
++    }
++}
+diff --git a/activitymanager/SlcEventBackend.h b/activitymanager/SlcEventBackend.h
+new file mode 100644
+index 0000000..3c79792
+--- /dev/null
++++ b/activitymanager/SlcEventBackend.h
+@@ -0,0 +1,59 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifndef SLC_EVENT_BACKEND_H_
++#define SLC_EVENT_BACKEND_H_
++
++#include "EventBackend.h"
++
++#include <QObject>
++#include <KUrl>
++
++/**
++ *
++ */
++class SlcEventBackend: public QObject, public EventBackend {
++    Q_OBJECT
++    Q_CLASSINFO("D-Bus Interface", "org.kde.ActivityManager.SLC")
++
++public:
++    SlcEventBackend();
++
++    virtual void addEvents(const EventList & events);
++
++private Q_SLOTS:
++    void activeWindowChanged(WId windowId);
++
++public Q_SLOTS:
++    QString focussedResourceURI();
++    QString focussedResourceMimetype();
++
++Q_SIGNALS:
++    void focusChanged(const QString & uri, const QString & mimetype);
++
++private:
++    void updateFocus(WId wid = 0);
++
++    WId focussedWindow;
++    KUrl _focussedResourceURI();
++    QHash < WId, KUrl > lastFocussedResource;
++};
++
++#endif // SLC_EVENT_BACKEND_H_
++
+diff --git a/activitymanager/ZeitgeistEventBackend.cpp b/activitymanager/ZeitgeistEventBackend.cpp
+index 6ae0cf0..1bbd050 100644
+--- a/activitymanager/ZeitgeistEventBackend.cpp
++++ b/activitymanager/ZeitgeistEventBackend.cpp
+@@ -34,20 +34,20 @@
+ 
+ static QString eventInterpretation(Event::Type type)
+ {
+-    switch (type) {
+-        case Event::Accessed:
+-            return QtZeitgeist::Interpretation::Event::ZGAccessEvent;
++    // switch (type) {
++    //     case Event::Accessed:
++    //         return QtZeitgeist::Interpretation::Event::ZGAccessEvent;
+ 
+-        case Event::Opened:
+-            return QtZeitgeist::Interpretation::Event::ZGAccessEvent;
++    //     case Event::Opened:
++    //         return QtZeitgeist::Interpretation::Event::ZGAccessEvent;
+ 
+-        case Event::Modified:
+-            return QtZeitgeist::Interpretation::Event::ZGModifyEvent;
++    //     case Event::Modified:
++    //         return QtZeitgeist::Interpretation::Event::ZGModifyEvent;
+ 
+-        case Event::Closed:
+-            return QtZeitgeist::Interpretation::Event::ZGLeaveEvent;
++    //     case Event::Closed:
++    //         return QtZeitgeist::Interpretation::Event::ZGLeaveEvent;
+ 
+-    }
++    // }
+ 
+     // shut up GCC
+     return QString();
+@@ -55,22 +55,22 @@ static QString eventInterpretation(Event::Type type)
+ 
+ static QString eventManifestation(Event::Reason reason)
+ {
+-    switch (reason) {
+-        case Event::User:
+-            return QtZeitgeist::Manifestation::Event::ZGUserActivity;
++    // switch (reason) {
++    //     case Event::User:
++    //         return QtZeitgeist::Manifestation::Event::ZGUserActivity;
+ 
+-        case Event::Heuristic:
+-            return QtZeitgeist::Manifestation::Event::ZGHeuristicActivity;
++    //     case Event::Heuristic:
++    //         return QtZeitgeist::Manifestation::Event::ZGHeuristicActivity;
+ 
+-        case Event::Scheduled:
+-            return QtZeitgeist::Manifestation::Event::ZGScheduledActivity;
++    //     case Event::Scheduled:
++    //         return QtZeitgeist::Manifestation::Event::ZGScheduledActivity;
+ 
+-        case Event::System:
+-            return QtZeitgeist::Manifestation::Event::ZGSystemNotification;
++    //     case Event::System:
++    //         return QtZeitgeist::Manifestation::Event::ZGSystemNotification;
+ 
+-        case Event::World:
+-            return QtZeitgeist::Manifestation::Event::ZGWorldActivity;
+-    }
++    //     case Event::World:
++    //         return QtZeitgeist::Manifestation::Event::ZGWorldActivity;
++    // }
+ 
+     // shut up GCC
+     return QtZeitgeist::Manifestation::Event::ZGUserActivity;
+diff --git a/activitymanager/main.cpp b/activitymanager/main.cpp
+index cfaed00..2ce18ed 100644
+--- a/activitymanager/main.cpp
++++ b/activitymanager/main.cpp
+@@ -19,8 +19,6 @@
+ 
+ #include <ActivityManager.h>
+ 
+-#include <KDebug>
+-
+ #include <KAboutData>
+ #include <KCmdLineArgs>
+ 
+diff --git a/activitymanager/ontologies/CMakeLists.txt b/activitymanager/ontologies/CMakeLists.txt
+new file mode 100644
+index 0000000..838b1f4
+--- /dev/null
++++ b/activitymanager/ontologies/CMakeLists.txt
+@@ -0,0 +1,8 @@
++project(nepomuk_ontologies)
++
++configure_file(kamdrso.ontology.in ${CMAKE_CURRENT_BINARY_DIR}/kamdrso.ontology)
++
++install(FILES
++  kamdrso.trig
++  ${CMAKE_CURRENT_BINARY_DIR}/kamdrso.ontology
++DESTINATION ${CMAKE_INSTALL_PREFIX}/share/ontology/kde)
+diff --git a/activitymanager/ontologies/kamdrso.ontology.in b/activitymanager/ontologies/kamdrso.ontology.in
+new file mode 100644
+index 0000000..032dac0
+--- /dev/null
++++ b/activitymanager/ontologies/kamdrso.ontology.in
+@@ -0,0 +1,8 @@
++[Ontology]
++Version=1.0
++Name=KDE Activity Manager Daemon - Resource Scoring Ontology
++Comment=The KDE Resource Scoring Ontology contains classes related to KAMD's scoring mechanisms
++Namespace=http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso#" ;
++Path=${CMAKE_INSTALL_PREFIX}/share/ontology/kde/kamdrso.trig
++MimeType=application/x-trig
++Type=Data
+diff --git a/activitymanager/ontologies/kamdrso.trig b/activitymanager/ontologies/kamdrso.trig
+new file mode 100644
+index 0000000..b968231
+--- /dev/null
++++ b/activitymanager/ontologies/kamdrso.trig
+@@ -0,0 +1,112 @@
++#
++# Copyright (c) 2011 Ivan Cukic <[e-mail]>
++# All rights reserved, licensed under either CC-BY or BSD.
++#
++# You are free:
++#  * to Share - to copy, distribute and transmit the work
++#  * to Remix - to adapt the work
++# Under the following conditions:
++#  * Attribution - You must attribute the work in the manner specified by the author
++#    or licensor (but not in any way that suggests that they endorse you or your use
++#    of the work).
++#
++# Redistribution and use in source and binary forms, with or without modification,
++# are permitted provided that the following conditions are met:
++#  * Redistributions of source code must retain the above copyright notice, this
++#    list of conditions and the following disclaimer.
++#  * Redistributions in binary form must reproduce the above copyright notice, this
++#    list of conditions and the following disclaimer in the documentation and/or
++#    other materials provided with the distribution.
++#  * Neither the names of the authors nor the names of contributors may
++#    be used to endorse or promote products derived from this ontology without
++#    specific prior written permission.
++#
++# THIS ONTOLOGY IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++# THIS ONTOLOGY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++#
++
++@prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
++@prefix nao:     <http://www.semanticdesktop.org/ontologies/2007/08/15/nao#> .
++@prefix nrl:     <http://www.semanticdesktop.org/ontologies/2007/08/15/nrl#> .
++@prefix nie:     <http://www.semanticdesktop.org/ontologies/2007/01/19/nie#> .
++@prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .
++@prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
++@prefix kamdrso:    <http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso#> .
++@prefix nfo:     <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#> .
++
++kamdrso: {
++    kamdrso:unixFileMode
++          a      rdf:Property ;
++          rdfs:label "Unix file mode" ;
++          rdfs:comment "The file mode value as seen on unix file systems." ;
++          rdfs:domain nfo:FileDataObject ;
++          rdfs:range xsd:integer ;
++          nao:userVisible false .
++
++    kamdrso:unixFileOwner
++          a      rdf:Property ;
++          rdfs:label "Unix file owner" ;
++          rdfs:comment "The owner of the file as seen on unix file systems. This is intended as the low-level counterpart to nfo:owner." ;
++          rdfs:domain nfo:FileDataObject ;
++          rdfs:range xsd:string ;
++          nao:userVisible false .
++
++    kamdrso:unixFileGroup
++          a      rdf:Property ;
++          rdfs:label "Unix file group" ;
++          rdfs:comment "The group of the file as seen on unix file systems." ;
++          rdfs:domain nfo:FileDataObject ;
++          rdfs:range xsd:string ;
++          nao:userVisible false .
++
++    kamdrso:Activity
++          a rdfs:Class ;
++          rdfs:subClassOf rdfs:Resource ;
++          rdfs:label "activity" ;
++          rdfs:comment "A Plasma activity." .
++
++    kamdrso:usedActivity
++          a rdf:Property ;
++          rdfs:label "used activity" ;
++          rdfs:comment "The activity that was active when resource was created. This is mostly used for graphs or desktop events." ;
++          rdfs:domain rdfs:Resource ;
++          rdfs:range kamdrso:Activity ;
++          nao:userVisible false .
++
++    kamdrso:activityIdentifier
++          a rdf:Property ;
++          rdfs:subPropertyOf nao:identifier ;
++          rdfs:label "activity identifier" ;
++          rdfs:comment "The unique ID of the activity as used outside of Nepomuk. Typically this is a UUID." ;
++          rdfs:domain kamdrso:Activity ;
++          rdfs:range xsd:string ;
++          nao:userVisible false .
++
++}
++
++<http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso/metadata> {
++    <http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso/metadata>
++          a       nrl:GraphMetadata ;
++          nrl:coreGraphMetadataFor kamdrso: .
++
++
++    kamdrso:
++          a       nrl:Ontology , nrl:DocumentGraph ;
++          nao:prefLabel "KDE Extensions Ontology" ;
++          nao:hasDefaultNamespace "http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso#" ;
++          nao:hasDefaultNamespaceAbbreviation "kamdrso" ;
++          nao:lastModified "2011-06-02T12:31:43Z" ;
++          nao:serializationLanguage "TriG" ;
++          nao:status "Unstable" ;
++          nrl:updatable "0" ;
++          nao:version "2" .
++}
++
+diff --git a/activitymanager/org.kde.ActivityManager.SLC.xml b/activitymanager/org.kde.ActivityManager.SLC.xml
+new file mode 100644
+index 0000000..b9df419
+--- /dev/null
++++ b/activitymanager/org.kde.ActivityManager.SLC.xml
+@@ -0,0 +1,15 @@
++<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
++<node>
++  <interface name="org.kde.ActivityManager.SLC">
++    <signal name="focusChanged">
++      <arg name="uri" type="s" direction="out"/>
++      <arg name="mimetype" type="s" direction="out"/>
++    </signal>
++    <method name="focussedResourceURI">
++      <arg type="s" direction="out"/>
++    </method>
++    <method name="focussedResourceMimetype">
++      <arg type="s" direction="out"/>
++    </method>
++  </interface>
++</node>
+diff --git a/activitymanager/org.kde.ActivityManager.xml b/activitymanager/org.kde.ActivityManager.xml
+index b03e826..a09252b 100644
+--- a/activitymanager/org.kde.ActivityManager.xml
++++ b/activitymanager/org.kde.ActivityManager.xml
+@@ -23,23 +23,6 @@
+       <arg name="id" type="s" direction="out"/>
+       <arg name="state" type="i" direction="out"/>
+     </signal>
+-    <signal name="ResourceAccessed">
+-      <arg name="application" type="s" direction="out"/>
+-      <arg name="uri" type="s" direction="out"/>
+-    </signal>
+-    <signal name="ResourceOpened">
+-      <arg name="application" type="s" direction="out"/>
+-      <arg name="windowId" type="u" direction="out"/>
+-      <arg name="uri" type="s" direction="out"/>
+-    </signal>
+-    <signal name="ResourceModified">
+-      <arg name="windowId" type="u" direction="out"/>
+-      <arg name="uri" type="s" direction="out"/>
+-    </signal>
+-    <signal name="ResourceClosed">
+-      <arg name="windowId" type="u" direction="out"/>
+-      <arg name="uri" type="s" direction="out"/>
+-    </signal>
+     <method name="Start">
+     </method>
+     <method name="Stop">
+@@ -102,26 +85,16 @@
+     <method name="IsBackstoreAvailable">
+       <arg type="b" direction="out"/>
+     </method>
+-    <method name="NotifyResourceAccessed">
+-      <arg name="application" type="s" direction="in"/>
+-      <arg name="uri" type="s" direction="in"/>
+-    </method>
+-    <method name="NotifyResourceOpened">
++    <method name="RegisterResourceEvent">
+       <arg name="application" type="s" direction="in"/>
+       <arg name="windowId" type="u" direction="in"/>
+       <arg name="uri" type="s" direction="in"/>
++      <arg name="event" type="u" direction="in"/>
++      <arg name="reason" type="u" direction="in"/>
+     </method>
+-    <method name="NotifyResourceModified">
+-      <arg name="windowId" type="u" direction="in"/>
+-      <arg name="uri" type="s" direction="in"/>
+-    </method>
+-    <method name="NotifyResourceClosed">
+-      <arg name="windowId" type="u" direction="in"/>
+-      <arg name="uri" type="s" direction="in"/>
+-    </method>
+-    <method name="ActivitiesForResource">
+-      <arg type="as" direction="out"/>
++    <method name="RegisterResourceMimeType">
+       <arg name="uri" type="s" direction="in"/>
++      <arg name="mimetype" type="s" direction="in"/>
+     </method>
+   </interface>
+ </node>
+diff --git a/activitymanager/queries.sparql b/activitymanager/queries.sparql
+new file mode 100644
+index 0000000..680eef5
+--- /dev/null
++++ b/activitymanager/queries.sparql
+@@ -0,0 +1,43 @@
++// Getting the highest scored caches for (application/agent, activity)
++
++select distinct ?resource,
++   (
++       (
++           ?lastScore * bif:exp(-
++               bif:datediff('day', ?lastUpdate, ##CURRENT_DATETIME##)
++           )
++       )
++   as ?score) where {
++     ?cache kext:targettedResource ?resource .
++     ?cache a kext:ResourceScoreCache .
++     ?cache nao:lastModified ?lastUpdate .
++     ?cache kext:cachedScore ?lastScore .
++     ?cache kext:usedActivity ##ACTIVITY## .
++     ?cache kext:initiatingAgent ##AGENT## .
++     OPTIONAL { ?resource nie:url ?uri . } .
++}
++ORDER BY DESC (?score)
++LIMIT 10
++
++// Getting the highest scored caches for (activity)
++
++select distinct ?resource,
++    (
++        (
++            SUM (
++                ?lastScore * bif:exp(
++                    - bif:datediff('day', ?lastUpdate, ##CURRENT_DATETIME##)
++                )
++            )
++        )
++        as ?score
++    ) where {
++        ?cache kext:targettedResource ?resource .
++        ?cache a kext:ResourceScoreCache .
++        ?cache nao:lastModified ?lastUpdate .
++        ?cache kext:cachedScore ?lastScore .
++        ?cache kext:usedActivity ##ACTIVITY## .
++    }
++    GROUP BY (?resource)
++    ORDER BY DESC (?score)
++    LIMIT 10
+diff --git a/activitymanager/scripts/delete-stats.sh b/activitymanager/scripts/delete-stats.sh
+new file mode 100755
+index 0000000..a237c38
+--- /dev/null
++++ b/activitymanager/scripts/delete-stats.sh
+@@ -0,0 +1,4 @@
++#!/bin/zsh
++alias nepomukcmd="sopranocmd --socket `kde4-config --path socket`nepomuk-socket --model main --nrl"
++for res in `nepomukcmd --foo query 'select ?r { ?r a kext:ResourceScoreCache . }'`; nepomukcmd rm $res
++for res in `nepomukcmd --foo query 'select ?r { ?r a nuao:DesktopEvent . }'`; nepomukcmd rm $res
+diff --git a/nepomuk/ontologies/kext.trig b/nepomuk/ontologies/kext.trig
+index be5d041..b743638 100644
+--- a/nepomuk/ontologies/kext.trig
++++ b/nepomuk/ontologies/kext.trig
+@@ -7,18 +7,18 @@
+ #  * to Remix - to adapt the work
+ # Under the following conditions:
+ #  * Attribution - You must attribute the work in the manner specified by the author
+-#    or licensor (but not in any way that suggests that they endorse you or your use 
++#    or licensor (but not in any way that suggests that they endorse you or your use
+ #    of the work).
+ #
+-# Redistribution and use in source and binary forms, with or without modification, 
++# Redistribution and use in source and binary forms, with or without modification,
+ # are permitted provided that the following conditions are met:
+-#  * Redistributions of source code must retain the above copyright notice, this 
++#  * Redistributions of source code must retain the above copyright notice, this
+ #    list of conditions and the following disclaimer.
+-#  * Redistributions in binary form must reproduce the above copyright notice, this 
+-#    list of conditions and the following disclaimer in the documentation and/or 
++#  * Redistributions in binary form must reproduce the above copyright notice, this
++#    list of conditions and the following disclaimer in the documentation and/or
+ #    other materials provided with the distribution.
+ #  * Neither the names of the authors nor the names of contributors may
+-#    be used to endorse or promote products derived from this ontology without 
++#    be used to endorse or promote products derived from this ontology without
+ #    specific prior written permission.
+ #
+ # THIS ONTOLOGY IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+@@ -94,6 +94,35 @@ kext: {
+           rdfs:range xsd:string ;
+           nrl:cardinality 1 ;
+           nao:userVisible false .
++
++    kext:ResourceScoreCache
++          a rdfs:Class ;
++          rdfs:subClassOf rdfs:Resource ;
++          rdfs:label "Resource score cache" ;
++          rdfs:comment "For storing the automatically calculated score based on the usage statistics" ;
++          nao:userVisible false .
++
++    kext:targettedResource
++          a rdf:Property ;
++          rdfs:comment "Resource for which the score is calculated." ;
++          rdfs:domain kext:ResourceScoreCache ;
++          rdfs:label "resource" ;
++          rdfs:range rdfs:Resource .
++
++    kext:initiatingAgent
++          a rdf:Property ;
++          rdfs:comment "Relates the score to the agent initiating the events." ;
++          rdfs:domain kext:ResourceScoreCache ;
++          rdfs:label "involved agent" ;
++          rdfs:range nao:Agent .
++
++    kext:cachedScore
++          a rdf:Property ;
++          rdfs:subPropertyOf nao:score ;
++          rdfs:comment "The automatically calculated score" ;
++          rdfs:domain kext:ResourceScoreCache ;
++          rdfs:label "calculated score" ;
++          rdfs:range xsd:float .
+ }
+ 
+ <http://nepomuk.kde.org/ontologies/2010/11/29/kext/metadata> {
+-- 
+1.7.5.4
+
 
=== added file 'debian/patches/kubuntu_mobile_ported-the-new-plugin-system-to-active-development-4.diff'
--- debian/patches/kubuntu_mobile_ported-the-new-plugin-system-to-active-development-4.diff	1970-01-01 00:00:00 +0000
+++ debian/patches/kubuntu_mobile_ported-the-new-plugin-system-to-active-development-4.diff	2011-08-18 09:25:23 +0000
@@ -0,0 +1,3622 @@
+From 6f809ee3c098c9a89af74f3f3e731e9d4ddda1bd Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Ivan=20=C4=8Cuki=C4=87?= <[e-mail]>
+Date: Thu, 14 Jul 2011 18:21:12 +0200
+Subject: [PATCH 4/6] Ported the new plugin system to active-development/4.7
+
+---
+ activitymanager/ActivityManager.cpp                |    3 +-
+ activitymanager/CMakeLists.txt                     |   76 +-----
+ activitymanager/EventBackend.cpp                   |   40 ---
+ activitymanager/EventBackend.h                     |   40 ---
+ activitymanager/EventProcessor.cpp                 |   85 +++++--
+ activitymanager/EventProcessor.h                   |    5 +-
+ activitymanager/NepomukCommon.h                    |   63 -----
+ activitymanager/NepomukEventBackend.cpp            |  267 --------------------
+ activitymanager/NepomukEventBackend.h              |   47 ----
+ activitymanager/NepomukResourceScoreCache.cpp      |  214 ----------------
+ activitymanager/NepomukResourceScoreCache.h        |   42 ---
+ activitymanager/NepomukResourceScoreMaintainer.cpp |  145 -----------
+ activitymanager/NepomukResourceScoreMaintainer.h   |   47 ----
+ activitymanager/Plugin.cpp                         |   56 ++++
+ activitymanager/Plugin.h                           |   59 +++++
+ activitymanager/SharedInfo.cpp                     |   20 ++
+ activitymanager/SharedInfo.h                       |   17 ++-
+ activitymanager/SlcEventBackend.cpp                |  127 ----------
+ activitymanager/SlcEventBackend.h                  |   59 -----
+ activitymanager/ZeitgeistEventBackend.cpp          |   95 -------
+ activitymanager/ZeitgeistEventBackend.h            |   39 ---
+ activitymanager/activitymanager-plugin.desktop     |   12 +
+ activitymanager/krso.trig                          |  100 ++++++++
+ activitymanager/ontologies/CMakeLists.txt          |    8 -
+ activitymanager/ontologies/kamdrso.ontology.in     |    8 -
+ activitymanager/ontologies/kamdrso.trig            |  112 --------
+ activitymanager/org.kde.ActivityManager.SLC.xml    |   15 --
+ activitymanager/plugins/CMakeLists.txt             |    3 +
+ activitymanager/plugins/dummy/CMakeLists.txt       |   30 +++
+ .../dummy/activitymanager-plugin-dummy.desktop     |   19 ++
+ activitymanager/plugins/dummy/dummy.cpp            |   34 +++
+ activitymanager/plugins/dummy/dummy.h              |   35 +++
+ activitymanager/plugins/nepomuk/CMakeLists.txt     |   61 +++++
+ activitymanager/plugins/nepomuk/NepomukCommon.h    |   67 +++++
+ activitymanager/plugins/nepomuk/NepomukPlugin.cpp  |  264 +++++++++++++++++++
+ activitymanager/plugins/nepomuk/NepomukPlugin.h    |   47 ++++
+ .../plugins/nepomuk/NepomukResourceScoreCache.cpp  |  215 ++++++++++++++++
+ .../plugins/nepomuk/NepomukResourceScoreCache.h    |   42 +++
+ .../nepomuk/NepomukResourceScoreMaintainer.cpp     |  145 +++++++++++
+ .../nepomuk/NepomukResourceScoreMaintainer.h       |   47 ++++
+ .../nepomuk/activitymanager-plugin-nepomuk.desktop |   20 ++
+ activitymanager/plugins/slc/CMakeLists.txt         |   37 +++
+ .../plugins/slc/activitymanager-plugin-slc.desktop |   19 ++
+ .../plugins/slc/org.kde.ActivityManager.SLC.xml    |   15 ++
+ activitymanager/plugins/slc/slc.cpp                |  132 ++++++++++
+ activitymanager/plugins/slc/slc.h                  |   58 +++++
+ 46 files changed, 1634 insertions(+), 1457 deletions(-)
+ delete mode 100644 activitymanager/EventBackend.cpp
+ delete mode 100644 activitymanager/EventBackend.h
+ delete mode 100644 activitymanager/NepomukCommon.h
+ delete mode 100644 activitymanager/NepomukEventBackend.cpp
+ delete mode 100644 activitymanager/NepomukEventBackend.h
+ delete mode 100644 activitymanager/NepomukResourceScoreCache.cpp
+ delete mode 100644 activitymanager/NepomukResourceScoreCache.h
+ delete mode 100644 activitymanager/NepomukResourceScoreMaintainer.cpp
+ delete mode 100644 activitymanager/NepomukResourceScoreMaintainer.h
+ create mode 100644 activitymanager/Plugin.cpp
+ create mode 100644 activitymanager/Plugin.h
+ delete mode 100644 activitymanager/SlcEventBackend.cpp
+ delete mode 100644 activitymanager/SlcEventBackend.h
+ delete mode 100644 activitymanager/ZeitgeistEventBackend.cpp
+ delete mode 100644 activitymanager/ZeitgeistEventBackend.h
+ create mode 100644 activitymanager/activitymanager-plugin.desktop
+ create mode 100644 activitymanager/krso.trig
+ delete mode 100644 activitymanager/ontologies/CMakeLists.txt
+ delete mode 100644 activitymanager/ontologies/kamdrso.ontology.in
+ delete mode 100644 activitymanager/ontologies/kamdrso.trig
+ delete mode 100644 activitymanager/org.kde.ActivityManager.SLC.xml
+ create mode 100644 activitymanager/plugins/CMakeLists.txt
+ create mode 100644 activitymanager/plugins/dummy/CMakeLists.txt
+ create mode 100644 activitymanager/plugins/dummy/activitymanager-plugin-dummy.desktop
+ create mode 100644 activitymanager/plugins/dummy/dummy.cpp
+ create mode 100644 activitymanager/plugins/dummy/dummy.h
+ create mode 100644 activitymanager/plugins/nepomuk/CMakeLists.txt
+ create mode 100644 activitymanager/plugins/nepomuk/NepomukCommon.h
+ create mode 100644 activitymanager/plugins/nepomuk/NepomukPlugin.cpp
+ create mode 100644 activitymanager/plugins/nepomuk/NepomukPlugin.h
+ create mode 100644 activitymanager/plugins/nepomuk/NepomukResourceScoreCache.cpp
+ create mode 100644 activitymanager/plugins/nepomuk/NepomukResourceScoreCache.h
+ create mode 100644 activitymanager/plugins/nepomuk/NepomukResourceScoreMaintainer.cpp
+ create mode 100644 activitymanager/plugins/nepomuk/NepomukResourceScoreMaintainer.h
+ create mode 100644 activitymanager/plugins/nepomuk/activitymanager-plugin-nepomuk.desktop
+ create mode 100644 activitymanager/plugins/slc/CMakeLists.txt
+ create mode 100644 activitymanager/plugins/slc/activitymanager-plugin-slc.desktop
+ create mode 100644 activitymanager/plugins/slc/org.kde.ActivityManager.SLC.xml
+ create mode 100644 activitymanager/plugins/slc/slc.cpp
+ create mode 100644 activitymanager/plugins/slc/slc.h
+
+diff --git a/activitymanager/ActivityManager.cpp b/activitymanager/ActivityManager.cpp
+index e821c92..0e06cf5 100644
+--- a/activitymanager/ActivityManager.cpp
++++ b/activitymanager/ActivityManager.cpp
+@@ -123,7 +123,6 @@ ActivityManagerPrivate::ActivityManagerPrivate(ActivityManager * parent,
+         ksmserverInterface->deleteLater();
+         ksmserverInterface = 0;
+     }
+-
+ }
+ 
+ ActivityManagerPrivate::~ActivityManagerPrivate()
+@@ -148,6 +147,7 @@ void ActivityManagerPrivate::windowClosed(WId windowId)
+ 
+ void ActivityManagerPrivate::activeWindowChanged(WId windowId)
+ {
++    Q_UNUSED(windowId)
+     // kDebug() << "Window focussed..." << windowId
+     //          << "one of ours?" << windows.contains(windowId);
+ 
+@@ -234,6 +234,7 @@ bool ActivityManagerPrivate::setCurrentActivity(const QString & id)
+         scheduleConfigSync();
+     }
+ 
++    SharedInfo::self()->setCurrentActivity(id);
+     emit q->CurrentActivityChanged(id);
+     return true;
+ }
+diff --git a/activitymanager/CMakeLists.txt b/activitymanager/CMakeLists.txt
+index 726fcce..3e1ab10 100644
+--- a/activitymanager/CMakeLists.txt
++++ b/activitymanager/CMakeLists.txt
+@@ -1,9 +1,11 @@
+ project(ActivityManager)
+ 
+-set (ADDITIONAL_LINK_LIBS)
++set(ADDITIONAL_LINK_LIBS)
+ 
+ add_subdirectory(kded)
+-add_subdirectory(ontologies)
++# add_subdirectory(ontologies)
++
++add_subdirectory(plugins)
+ 
+ # Checking for Nepomuk
+ macro_optional_find_package(Nepomuk)
+@@ -22,26 +24,6 @@ if(Nepomuk_FOUND)
+     )
+ endif(Nepomuk_FOUND)
+ 
+-# Checking for QtZeitgeist
+-macro_optional_find_package(QZeitgeist)
+-
+-if (QZEITGEIST_INCLUDE_DIR)
+-    set(QZeitgeist_FOUND TRUE)
+-endif(QZEITGEIST_INCLUDE_DIR)
+-
+-macro_log_feature(
+-        QZeitgeist_FOUND
+-        "QtZeitgeist" "Qt bindings for Zeitgeist" "http://gitorious.org/kde-zeitgeist/libqzeitgeist/" FALSE ""
+-        "RECOMMENDED: Zeitgeist and QtZeitgeist is needed for resource tracking")
+-if (QZeitgeist_FOUND)
+-    set(HAVE_QZEITGEIST 1)
+-    include_directories(${QZEITGEIST_INCLUDE_DIR})
+-    set(ADDITIONAL_LINK_LIBS
+-        ${ADDITIONAL_LINK_LIBS}
+-        ${QZEITGEIST_LIBRARY}
+-    )
+-endif(QZeitgeist_FOUND)
+-
+ # config file
+ configure_file(config-features.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-features.h )
+ 
+@@ -57,58 +39,18 @@ include_directories(
+ set(activity_manager_SRCS
+     ActivityManager.cpp
+     EventProcessor.cpp
+-    EventBackend.cpp
++    Plugin.cpp
+     Event.cpp
+     SharedInfo.cpp
+     main.cpp
+     )
+ 
+-set(activity_manager_backends_SRCS
+-    NepomukEventBackend.cpp
+-    NepomukResourceScoreMaintainer.cpp
+-    NepomukResourceScoreCache.cpp
+-    ZeitgeistEventBackend.cpp
+-    SlcEventBackend.cpp
+-    )
+-
+ qt4_add_dbus_adaptor(
+     activity_manager_SRCS org.kde.ActivityManager.xml
+     ActivityManager.h ActivityManager
+     )
+ 
+-qt4_add_dbus_adaptor(
+-    activity_manager_SRCS org.kde.ActivityManager.SLC.xml
+-    SlcEventBackend.h SlcEventBackend
+-    )
+-
+-if(Nepomuk_FOUND)
+-    soprano_add_ontology(activity_manager_SRCS
+-        ${CMAKE_SOURCE_DIR}/nepomuk/ontologies/kext.trig
+-        "KExt" "Nepomuk::Vocabulary" "trig"
+-        )
+-
+-    # soprano_add_ontology(activity_manager_SRCS
+-    #     ${CMAKE_CURRENT_SOURCE_DIR}/ontologies/kamdrso.trig
+-    #     "RSO" "Nepomuk::Vocabulary" "trig"
+-    #     )
+-
+-    soprano_add_ontology(activity_manager_SRCS
+-        ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nie/nie.trig
+-        "NIE" "Nepomuk::Vocabulary" "trig"
+-        )
+-
+-    soprano_add_ontology(activity_manager_SRCS
+-        ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nepomuk/nao.trig
+-        "NAO" "Nepomuk::Vocabulary" "trig"
+-        )
+-
+-    soprano_add_ontology(activity_manager_SRCS
+-        ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nepomuk/nuao.trig
+-        "NUAO" "Nepomuk::Vocabulary" "trig"
+-        )
+-endif()
+-
+-kde4_add_executable(activity-manager ${activity_manager_SRCS} ${activity_manager_backends_SRCS})
++kde4_add_executable(activity-manager ${activity_manager_SRCS})
+ 
+ target_link_libraries(
+     activity-manager
+@@ -129,3 +71,9 @@ install(
+     TARGETS activity-manager ${INSTALL_TARGETS_DEFAULT_ARGS}
+     )
+ 
++install(FILES
++    activitymanager-plugin.desktop
++    DESTINATION ${SERVICETYPES_INSTALL_DIR}
++    )
++
++
+diff --git a/activitymanager/EventBackend.cpp b/activitymanager/EventBackend.cpp
+deleted file mode 100644
+index 2650dbf..0000000
+--- a/activitymanager/EventBackend.cpp
++++ /dev/null
+@@ -1,40 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#include "EventBackend.h"
+-
+-EventBackend::EventBackend()
+-{
+-}
+-
+-EventBackend::~EventBackend()
+-{
+-}
+-
+-void EventBackend::addEvents(const EventList & events)
+-{
+-    Q_UNUSED(events)
+-}
+-
+-void EventBackend::setResourceMimeType(const QString & uri, const QString & mimetype)
+-{
+-    Q_UNUSED(uri)
+-    Q_UNUSED(mimetype)
+-}
+-
+diff --git a/activitymanager/EventBackend.h b/activitymanager/EventBackend.h
+deleted file mode 100644
+index bd7cbf9..0000000
+--- a/activitymanager/EventBackend.h
++++ /dev/null
+@@ -1,40 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#ifndef EVENT_BACKEND_H_
+-#define EVENT_BACKEND_H_
+-
+-#include <EventProcessor.h>
+-#include "Event.h"
+-
+-/**
+- *
+- */
+-class EventBackend {
+-public:
+-    EventBackend();
+-    virtual ~EventBackend();
+-
+-    virtual void addEvents(const EventList & events);
+-    virtual void setResourceMimeType(const QString & uri, const QString & mimetype);
+-
+-};
+-
+-#endif // EVENT_BACKEND_H_
+-
+diff --git a/activitymanager/EventProcessor.cpp b/activitymanager/EventProcessor.cpp
+index 48bb405..a6c9d2e 100644
+--- a/activitymanager/EventProcessor.cpp
++++ b/activitymanager/EventProcessor.cpp
+@@ -19,32 +19,27 @@
+  */
+ 
+ #include "EventProcessor.h"
+-#include "EventBackend.h"
++#include "Plugin.h"
+ 
+ #include "config-features.h"
+ 
+-#ifdef HAVE_QZEITGEIST
+-#include "ZeitgeistEventBackend.h"
+-#endif
++#include "Plugin.h"
+ 
+-#ifdef HAVE_NEPOMUK
+-#include "NepomukEventBackend.h"
+-#endif
+-
+-#include "SlcEventBackend.h"
++#include <KDebug>
+ 
+ #include <QDateTime>
+ #include <QList>
+ #include <QMutex>
+ 
+ #include <KDebug>
++#include <KServiceTypeTrader>
+ 
+ #include <time.h>
+ 
+ class EventProcessorPrivate: public QThread {
+ public:
+-    QList < EventBackend * > lazyBackends;
+-    QList < EventBackend * > syncBackends;
++    QList < Plugin * > lazyBackends;
++    QList < Plugin * > syncBackends;
+ 
+     QList < Event > events;
+     QMutex events_mutex;
+@@ -79,7 +74,7 @@ void EventProcessorPrivate::run()
+ 
+         EventProcessorPrivate::events_mutex.unlock();
+ 
+-        foreach (EventBackend * backend, lazyBackends) {
++        foreach (Plugin * backend, lazyBackends) {
+             backend->addEvents(currentEvents);
+         }
+     }
+@@ -97,13 +92,63 @@ EventProcessor * EventProcessor::self()
+ EventProcessor::EventProcessor()
+     : d(new EventProcessorPrivate())
+ {
+-#ifdef HAVE_QZEITGEIST
+-    d->lazyBackends.append(new ZeitgeistEventBackend());
+-#endif
+-#ifdef HAVE_NEPOMUK
+-    d->lazyBackends.append(new NepomukEventBackend());
+-#endif
+-    d->syncBackends.append(new SlcEventBackend());
++    // Plugin loading
++
++    kDebug() << "Loading plugins...";
++
++    KService::List offers = KServiceTypeTrader::self()->query("ActivityManager/Plugin");
++
++    QStringList disabledPlugins = SharedInfo::self()->pluginConfig("Global").readEntry("disabledPlugins", QStringList());
++    kDebug() << disabledPlugins << "disabled due to the configuration in activitymanager-pluginsrc";
++
++    foreach(const KService::Ptr & service, offers) {
++        if (!disabledPlugins.contains(service->library())) {
++            disabledPlugins.append(
++                    service->property("X-ActivityManager-PluginOverrides", QVariant::StringList).toStringList()
++                );
++            kDebug() << service->name() << "disables" <<
++                    service->property("X-ActivityManager-PluginOverrides", QVariant::StringList);
++
++        }
++    }
++
++    foreach(const KService::Ptr & service, offers) {
++        if (disabledPlugins.contains(service->library())) {
++            continue;
++        }
++
++        kDebug() << "Loading plugin:"
++            << service->name() << service->storageId() << service->library()
++            << service->property("X-ActivityManager-PluginType", QVariant::String);
++
++        KPluginFactory * factory = KPluginLoader(service->library()).factory();
++
++        if (!factory) {
++            kDebug() << "Failed to load plugin:" << service->name();
++            continue;
++        }
++
++        Plugin * plugin = factory->create < Plugin > (this);
++        plugin->setSharedInfo(SharedInfo::self());
++
++        if (plugin) {
++            const QString & type = service->property("X-ActivityManager-PluginType", QVariant::String).toString();
++
++            if (type == "lazyeventhandler") {
++                d->lazyBackends << plugin;
++                kDebug() << "Added to lazy plugins";
++
++            } else if (type == "synceventhandler"){
++                d->syncBackends << plugin;
++                kDebug() << "Added to sync plugins";
++
++            }
++
++        } else {
++            kDebug() << "Failed to load plugin:" << service->name();
++        }
++
++    }
+ }
+ 
+ EventProcessor::~EventProcessor()
+@@ -118,7 +163,7 @@ void EventProcessor::addEvent(const QString & application, WId wid, const QStrin
+ {
+     Event newEvent(application, wid, uri, type, reason);
+ 
+-    foreach (EventBackend * backend, d->syncBackends) {
++    foreach (Plugin * backend, d->syncBackends) {
+         backend->addEvents(QList < Event > () << newEvent);
+     }
+ 
+diff --git a/activitymanager/EventProcessor.h b/activitymanager/EventProcessor.h
+index 64eeeb3..061e07c 100644
+--- a/activitymanager/EventProcessor.h
++++ b/activitymanager/EventProcessor.h
+@@ -20,17 +20,18 @@
+ #ifndef EVENT_PROCESSOR_H
+ #define EVENT_PROCESSOR_H
+ 
++#include <QObject>
+ #include <QThread>
+ 
+ #include "Event.h"
+ 
+-class EventBackend;
++class Plugin;
+ class EventProcessorPrivate;
+ 
+ /**
+  * Thread to process desktop/usage events
+  */
+-class EventProcessor {
++class EventProcessor: public QObject {
+ public:
+     static EventProcessor * self();
+ 
+diff --git a/activitymanager/NepomukCommon.h b/activitymanager/NepomukCommon.h
+deleted file mode 100644
+index 9df5a62..0000000
+--- a/activitymanager/NepomukCommon.h
++++ /dev/null
+@@ -1,63 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#ifndef NEPOMUK_COMMON_H_
+-#define NEPOMUK_COMMON_H_
+-
+-#include "nie.h"
+-
+-#define NUAO_targettedResource KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("targettedResource"))
+-#define NUAO_initiatingAgent   KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("initiatingAgent"))
+-// #define NUAO_involvesActivity  KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("involvesActivity"))
+-
+-#define activityResource(ID) Nepomuk::Resource(ID, KExt::Activity())
+-#define agentResource(ID)    Nepomuk::Resource(ID, NAO::Agent())
+-#define currentActivityRes   activityResource(ActivityManager::self()->CurrentActivity())
+-
+-// #define anyResource(ID) Nepomuk::Resource(KUrl(ID))
+-
+-inline Nepomuk::Resource anyResource(const QUrl & uri)
+-{
+-    Nepomuk::Resource result(uri);
+-
+-    kDebug() << "setting the URI" << result.isFile() << result.isValid();
+-    result.setProperty(Nepomuk::Vocabulary::NIE::url(), uri);
+-    kDebug() << "set the URI" << result.isFile() << result.isValid();
+-
+-    return result;
+-}
+-
+-inline Nepomuk::Resource anyResource(const QString & uri)
+-{
+-    return anyResource(KUrl(uri));
+-}
+-
+-#define litN3(A) Soprano::Node::literalToN3(A)
+-
+-inline QString resN3(const QUrl & uri)
+-{
+-    return Soprano::Node::resourceToN3(uri);
+-}
+-
+-inline QString resN3(const Nepomuk::Resource & resource)
+-{
+-    return Soprano::Node::resourceToN3(resource.resourceUri());
+-}
+-
+-#endif // NEPOMUK_COMMON_H_
+diff --git a/activitymanager/NepomukEventBackend.cpp b/activitymanager/NepomukEventBackend.cpp
+deleted file mode 100644
+index 65c398c..0000000
+--- a/activitymanager/NepomukEventBackend.cpp
++++ /dev/null
+@@ -1,267 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *   Copyright (c) 2011 Sebastian Trueg <[e-mail]>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#include "config-features.h"
+-
+-#ifndef HAVE_NEPOMUK
+-#ifdef _MSC_VER
+-#pragma warning()
+-#pragma message("No Nepomuk, disabling desktop events processing")
+-#else
+-    #warning "No Nepomuk, disabling desktop events processing"
+-#endif
+-
+-#else // HAVE_NEPOMUK
+-
+-#include "NepomukEventBackend.h"
+-#include "NepomukResourceScoreMaintainer.h"
+-
+-#include "Event.h"
+-#include "ActivityManager.h"
+-#include "kext.h"
+-
+-#include <nepomuk/resource.h>
+-#include <nepomuk/nuao.h>
+-#include <nepomuk/resourcemanager.h>
+-#include <nepomuk/variant.h>
+-
+-#include <Nepomuk/Query/Query>
+-#include <Nepomuk/Query/ResourceTerm>
+-#include <Nepomuk/Query/ResourceTypeTerm>
+-#include <Nepomuk/Query/ComparisonTerm>
+-#include <Nepomuk/Query/LiteralTerm>
+-#include <Nepomuk/Query/NegationTerm>
+-
+-#include <Soprano/Vocabulary/NAO>
+-#include <Soprano/QueryResultIterator>
+-#include <Soprano/Node>
+-#include <Soprano/Model>
+-
+-#include <kdebug.h>
+-
+-#include "NepomukCommon.h"
+-
+-using namespace Soprano::Vocabulary;
+-using namespace Nepomuk::Vocabulary;
+-using namespace Nepomuk::Query;
+-
+-NepomukEventBackend::NepomukEventBackend()
+-{
+-}
+-
+-void NepomukEventBackend::addEvents(const EventList & events)
+-{
+-    foreach (const Event& event, events) {
+-        kDebug() << "We are processing event" << event.type << event.uri;
+-        kDebug() << "for agent" << event.application << agentResource(event.application).resourceUri();
+-
+-        switch (event.type) {
+-            case Event::Accessed:
+-            {
+-                // one-shot event
+-
+-                Nepomuk::Resource eventRes = createDesktopEvent(event.uri, event.timestamp, event.application);
+-                eventRes.addType(NUAO::UsageEvent());
+-                eventRes.setProperty(NUAO::start(), event.timestamp);
+-                eventRes.setProperty(NUAO::end(), event.timestamp);
+-
+-                kDebug() << "Created one-shot Accessed event" << eventRes;
+-
+-                NepomukResourceScoreMaintainer::self()->processResource(event.uri, event.application);
+-
+-                break;
+-            }
+-
+-            case Event::Opened:
+-                // create a new event
+-                createDesktopEvent(event.uri, event.timestamp, event.application);
+-
+-                break;
+-
+-            case Event::Closed:
+-            {
+-                // We should find and close the last open event
+-                // TODO: This can have a problem if an app closes a document
+-                // while not in the current activity
+-                const QString query
+-                    = QString::fromLatin1(
+-                            "select ?r where { "
+-                                "?r a nuao:DesktopEvent . "
+-                                "?r %1 %2 . "
+-                                "?r %3 %4 . "
+-                                "?r %5 %6 . "
+-                                "?r nuao:start ?start . "
+-                                "OPTIONAL { ?r nuao:end ?d . } . "
+-                                "FILTER(!BOUND(?d)) . "
+-                            "}"
+-                            "ORDER BY DESC (?start) LIMIT 1"
+-                    ).arg(
+-                        /* %1 */ resN3(NUAO_targettedResource),
+-                        /* %2 */ resN3(anyResource(KUrl(event.uri))),
+-                        /* %3 */ resN3(NUAO_initiatingAgent),
+-                        /* %4 */ resN3(agentResource(event.application)),
+-                        /* %5 */ resN3(KExt::usedActivity()),
+-                        /* %6 */ resN3(currentActivityRes)
+-                    );
+-                kDebug() << query;
+-
+-                Soprano::QueryResultIterator it
+-                        = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(query, Soprano::Query::QueryLanguageSparql);
+-
+-                if (it.next()) {
+-                    kDebug() << "Closing the event";
+-
+-                    Nepomuk::Resource eventRes(it[0].uri());
+-                    it.close();
+-
+-                    eventRes.addProperty(NUAO::end(), event.timestamp);
+-
+-                    NepomukResourceScoreMaintainer::self()->processResource(event.uri, event.application);
+-                }
+-
+-                break;
+-            }
+-
+-            default:
+-                // Nothing yet
+-                // TODO: Add focus and modification
+-                break;
+-        }
+-
+-
+-//        } else {
+-//            // find the corresponding event
+-//            // FIXME: enable this once the range of nao:identifier has been fixed and is no longer assumed to be rdfs:Resource
+-//            // resulting in a wrong query.
+-//            Query query(ResourceTypeTerm(NUAO::DesktopEvent())
+-//                        && ComparisonTerm(NUAO::involves(),
+-//                                          ResourceTerm(Nepomuk::Resource(KUrl(event.uri))), ComparisonTerm::Equal)
+-//                        && ComparisonTerm(NUAO::involves(),
+-//                                          ResourceTypeTerm(NAO::Agent())
+-//                                          && ComparisonTerm(NAO::identifier(), LiteralTerm(event.application), ComparisonTerm::Equal))
+-//                        && !ComparisonTerm(NUAO::end(), Term()));
+-//            query.setLimit(1);
+-//            query.setQueryFlags(Query::NoResultRestrictions);
+-//            const QString query = query.toSparqlQuery();
+-//
+-//            // TODO: Something strange is going on here - this should check for
+-//            // the activity as well
+-//            const QString query
+-//                    = QString::fromLatin1("select ?r where { "
+-//                                          "?r a nuao:DesktopEvent . "
+-//                                          "?r %1 %2 . "
+-//                                          "?r %3 %4 . "
+-//                                          "OPTIONAL { ?r nuao:end ?d . } . "
+-//                                          "FILTER(!BOUND(?d)) . } "
+-//                                          "LIMIT 1")
+-//                    .arg(
+-//                        /* %1 */ resN3(NUAO_targettedResource),
+-//                        /* %2 */ resN3(anyResource(KUrl(event.uri))),
+-//                        /* %3 */ resN3(NUAO_initiatingAgent),
+-//                        /* %4 */ resN3(agentResource(event.application))
+-//                    );
+-//
+-//            kDebug() << query;
+-//
+-//            Soprano::QueryResultIterator it
+-//                    = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(query, Soprano::Query::QueryLanguageSparql);
+-//
+-//            if (it.next()) {
+-//                Nepomuk::Resource eventRes(it[0].uri());
+-//                it.close();
+-//
+-//                eventRes.addProperty(NUAO::end(), event.timestamp);
+-//                if (event.type == Event::Modified) {
+-//                    eventRes.addType(NUAO::ModificationEvent());
+-//                } else {
+-//                    eventRes.addType(NUAO::UsageEvent());
+-//                }
+-//
+-//                // TODO: We are not creating separate events for modifications
+-//                // // In case of a modification event we create a new event which will
+-//                // // be completed by the final Closed event since this one resource
+-//                // // modification is done now. It ended with saving the resource.
+-//                // if (event.type == Event::Modified) {
+-//                //     // create a new event
+-//                //     createDesktopEvent(event.uri, event.timestamp, event.application);
+-//                // }
+-//
+-//            } else {
+-//                kDebug() << "Failed to find matching Open event for resource" << event.uri << "and application" << event.application;
+-//            }
+-//
+-//            if (event.type == Event::Closed) {
+-//                NepomukResourceScoreMaintainer::self()->processResource(event.uri, event.application);
+-//            }
+-//        }
+-    }
+-}
+-
+-Nepomuk::Resource NepomukEventBackend::createDesktopEvent(const KUrl& uri, const QDateTime& startTime, const QString& app)
+-{
+-    kDebug() << "Creating a new desktop event" << uri << startTime << app;
+-
+-    // one-shot event
+-    Nepomuk::Resource eventRes(QUrl(), NUAO::DesktopEvent());
+-    eventRes.addProperty(NUAO_targettedResource, anyResource(uri));
+-    eventRes.addProperty(NUAO::start(), startTime);
+-
+-    kDebug() << "Created event" << eventRes.resourceUri()
+-             << "for resource" << ((Nepomuk::Resource(uri)).resourceUri());
+-
+-    // the app
+-    Nepomuk::Resource appRes(app, NAO::Agent());
+-    eventRes.addProperty(NUAO_initiatingAgent, appRes);
+-
+-    // the activity
+-    if (!m_currentActivity.isValid()
+-            || m_currentActivity.identifiers().isEmpty()
+-            || m_currentActivity.identifiers().first() != ActivityManager::self()->CurrentActivity()) {
+-        // update the current activity resource
+-
+-        kDebug() << "Assigning the activity to the event";
+-
+-        const QString query = QString::fromLatin1("select ?r where { "
+-                " ?r a %1 . "
+-                " ?r %2 %3 . "
+-                "} LIMIT 1"
+-            ).arg(
+-                /* %1 */ resN3(KExt::Activity()),
+-                /* %2 */ resN3(KExt::activityIdentifier()),
+-                /* %3 */ resN3(currentActivityRes)
+-            );
+-
+-        Soprano::QueryResultIterator it = Nepomuk::ResourceManager::instance()->mainModel()
+-            ->executeQuery(query, Soprano::Query::QueryLanguageSparql);
+-
+-        if (it.next()) {
+-            m_currentActivity = it[0].uri();
+-        } else {
+-            m_currentActivity = currentActivityRes;
+-            m_currentActivity.setProperty(KExt::activityIdentifier(), ActivityManager::self()->CurrentActivity());
+-        }
+-    }
+-
+-    eventRes.setProperty(KExt::usedActivity(), m_currentActivity);
+-
+-    return eventRes;
+-}
+-
+-#endif // HAVE_NEPOMUK
+diff --git a/activitymanager/NepomukEventBackend.h b/activitymanager/NepomukEventBackend.h
+deleted file mode 100644
+index a8cbc0f..0000000
+--- a/activitymanager/NepomukEventBackend.h
++++ /dev/null
+@@ -1,47 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *   Copyright (c) 2011 Sebastian Trueg <[e-mail]>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#ifndef NEPOMUK_EVENT_BACKEND_H_
+-#define NEPOMUK_EVENT_BACKEND_H_
+-
+-#include "EventBackend.h"
+-
+-#include <Nepomuk/Resource>
+-
+-class KUrl;
+-class QDateTime;
+-
+-/**
+- *
+- */
+-class NepomukEventBackend: public EventBackend {
+-public:
+-    NepomukEventBackend();
+-
+-    virtual void addEvents(const EventList & events);
+-
+-private:
+-    Nepomuk::Resource createDesktopEvent(const KUrl& uri, const QDateTime& startTime, const QString& app);
+-
+-    Nepomuk::Resource m_currentActivity;
+-};
+-
+-#endif // NEPOMUK_EVENT_BACKEND_H_
+-
+diff --git a/activitymanager/NepomukResourceScoreCache.cpp b/activitymanager/NepomukResourceScoreCache.cpp
+deleted file mode 100644
+index 8d1b66b..0000000
+--- a/activitymanager/NepomukResourceScoreCache.cpp
++++ /dev/null
+@@ -1,214 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#include "NepomukResourceScoreCache.h"
+-
+-#include <cmath>
+-
+-#include <Soprano/Model>
+-#include <Soprano/QueryResultIterator>
+-
+-#include <Nepomuk/Resource>
+-#include <Nepomuk/ResourceManager>
+-#include <Nepomuk/Variant>
+-
+-#include <KDebug>
+-
+-#include "kext.h"
+-#include "nao.h"
+-#include "nuao.h"
+-
+-#include "ActivityManager.h"
+-
+-using namespace Nepomuk::Vocabulary;
+-
+-#include "NepomukCommon.h"
+-
+-/**
+- *
+- */
+-class NepomukResourceScoreCachePrivate {
+-public:
+-    Nepomuk::Resource self;
+-    QString activity;
+-    QString application;
+-    QUrl resource;
+-
+-    qreal timeFactor(int days) const
+-    {
+-        // Exp is falling rather quickly, we are slowing it 32 times
+-        return ::exp(- days / 32.0);
+-    }
+-
+-    qreal timeFactor(QDateTime fromTime, QDateTime toTime = QDateTime::currentDateTime()) const
+-    {
+-        return timeFactor(fromTime.daysTo(toTime));
+-    }
+-
+-};
+-
+-NepomukResourceScoreCache::NepomukResourceScoreCache(const QString & activity, const QString & application, const QUrl & resource)
+-    : d(new NepomukResourceScoreCachePrivate())
+-{
+-    kDebug() << "Cache for" << activity << application << resource << anyResource(resource).resourceUri();
+-
+-    d->activity = activity;
+-    d->application = application;
+-    d->resource = resource;
+-
+-    const QString query
+-        = QString::fromLatin1("select ?r where { "
+-                                  "?r a %1 . "
+-                                  "?r kext:usedActivity %2 . "
+-                                  "?r kext:initiatingAgent %3 . "
+-                                  "?r kext:targettedResource %4 . "
+-                                  "} LIMIT 1"
+-            ).arg(
+-                /* %1 */ resN3(KExt::ResourceScoreCache()),
+-                /* %2 */ resN3(currentActivityRes),
+-                /* %3 */ resN3(agentResource(application)),
+-                /* %4 */ resN3(anyResource(resource))
+-            );
+-
+-    kDebug() << query;
+-
+-    Soprano::QueryResultIterator it
+-        = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(query, Soprano::Query::QueryLanguageSparql);
+-
+-    if (it.next()) {
+-        Nepomuk::Resource result(it[0].uri());
+-        it.close();
+-
+-        d->self = result;
+-
+-        kDebug() << "Found an old cache" << d->self.resourceUri() << d->self.resourceType()
+-                 << "With a score of" << d->self.property(KExt::cachedScore()) << d->self.property(NAO::score());
+-
+-    } else {
+-        Nepomuk::Resource result(QUrl(), KExt::ResourceScoreCache());
+-
+-        result.setProperty(
+-                KExt::targettedResource(),
+-                Nepomuk::Resource(resource)
+-            );
+-        result.setProperty(
+-                KExt::initiatingAgent(), agentResource(application)
+-            );
+-        result.setProperty(
+-                KExt::usedActivity(), activityResource(activity)
+-            );
+-        result.setProperty(KExt::cachedScore(), 0);
+-
+-        d->self = result;
+-
+-        kDebug() << "Created a new cache resource" << d->self.resourceUri() << d->self.resourceType();
+-
+-    }
+-}
+-
+-NepomukResourceScoreCache::~NepomukResourceScoreCache()
+-{
+-    delete d;
+-}
+-
+-void NepomukResourceScoreCache::updateScore()
+-{
+-    kDebug() << "Updating the score for " << d->resource;
+-    kDebug() << "Last modified as string" << d->self.property(NAO::lastModified());
+-
+-    QDateTime lastModified = d->self.property(NAO::lastModified()).toDateTime();
+-
+-    qreal score = d->self.property(KExt::cachedScore()).toDouble();
+-
+-    if (lastModified.isValid()) {
+-        // Adjusting the score depending on the time that passed since the
+-        // last update
+-
+-        kDebug() << "Previous score:" << score;
+-        score *= d->timeFactor(lastModified);
+-        kDebug() << "Adjusted score:" << score;
+-
+-    } else {
+-        // If we haven't had previous calculation, set the score to 0
+-        score = 0;
+-
+-    }
+-
+-    kDebug() << "Last modified timestamp is" << lastModified << lastModified.isValid();
+-
+-    const QString query
+-        = QString::fromLatin1("select distinct ?r where { "
+-                                  "?r a nuao:DesktopEvent . "
+-                                  "?r %1 %2 . "
+-                                  "?r %3 %4 . "
+-                                  "?r %5 %6 . "
+-                                  "?r nuao:end ?end . "
+-                                  "FILTER(?end >= %7) ."
+-                                  " } "
+-            ).arg(
+-                /* %1 */ resN3(KExt::usedActivity()),
+-                /* %2 */ resN3(activityResource(d->activity)),
+-                /* %3 */ resN3(NUAO_targettedResource),
+-                /* %4 */ resN3(anyResource(d->resource)),
+-                /* %5 */ resN3(NUAO_initiatingAgent),
+-                /* %6 */ resN3(agentResource(d->application)),
+-                /* %7 */ litN3(lastModified.isValid() ? lastModified : QDateTime::fromMSecsSinceEpoch(0))
+-            );
+-
+-    kDebug() << query;
+-
+-    Soprano::QueryResultIterator it
+-        = Nepomuk::ResourceManager::instance()->mainModel()->executeQuery(query, Soprano::Query::QueryLanguageSparql);
+-
+-    d->self.setProperty(NAO::lastModified(), QDateTime::currentDateTime());
+-
+-    while (it.next()) {
+-        Nepomuk::Resource result(it[0].uri());
+-        QDateTime eventStart = result.property(NUAO::start()).toDateTime();
+-        QDateTime eventEnd = result.property(NUAO::end()).toDateTime();
+-
+-        if (!eventStart.isValid()) continue;
+-
+-        if (!eventEnd.isValid()) {
+-            // If the end was not saved, we are treating it as a simple
+-            // Accessed event
+-            eventEnd = eventStart;
+-        }
+-
+-        int intervalLength = eventStart.secsTo(eventEnd);
+-
+-        if (intervalLength == 0) {
+-            // We have an Accessed event - otherwise, this wouldn't be 0
+-
+-            score += d->timeFactor(eventEnd); // like it is open for 1 minute
+-
+-        } else if (intervalLength >= 4) {
+-            // Ignoring stuff that was open for less than 4 seconds
+-
+-            score += d->timeFactor(eventEnd) * intervalLength / 60.0;
+-        }
+-
+-        kDebug() << result.resourceUri() << eventStart << eventEnd << intervalLength;
+-
+-    }
+-
+-    kDebug() << "New calculated score:" << score << d->self.isValid();
+-    d->self.setProperty(KExt::cachedScore(), score);
+-    d->self.setProperty(NAO::score(), score);
+-}
+diff --git a/activitymanager/NepomukResourceScoreCache.h b/activitymanager/NepomukResourceScoreCache.h
+deleted file mode 100644
+index a26b5a2..0000000
+--- a/activitymanager/NepomukResourceScoreCache.h
++++ /dev/null
+@@ -1,42 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#ifndef NEPOMUK_RESOURCE_SCORE_CACHE_H_
+-#define NEPOMUK_RESOURCE_SCORE_CACHE_H_
+-
+-#include <QString>
+-#include <QUrl>
+-
+-class NepomukResourceScoreCachePrivate;
+-
+-/**
+- *
+- */
+-class NepomukResourceScoreCache {
+-public:
+-    NepomukResourceScoreCache(const QString & activity, const QString & application, const QUrl & resource);
+-    virtual ~NepomukResourceScoreCache();
+-
+-    void updateScore();
+-
+-private:
+-    class NepomukResourceScoreCachePrivate * const d;
+-};
+-
+-#endif // NEPOMUK_RESOURCE_SCORE_CACHE_H_
+diff --git a/activitymanager/NepomukResourceScoreMaintainer.cpp b/activitymanager/NepomukResourceScoreMaintainer.cpp
+deleted file mode 100644
+index f5e4d3c..0000000
+--- a/activitymanager/NepomukResourceScoreMaintainer.cpp
++++ /dev/null
+@@ -1,145 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#include "NepomukResourceScoreMaintainer.h"
+-
+-#include <QList>
+-#include <QMutex>
+-#include <QThread>
+-
+-#include <KDebug>
+-
+-#include <Nepomuk/Resource>
+-
+-#include <time.h>
+-#include "kext.h"
+-
+-#include "ActivityManager.h"
+-#include "NepomukResourceScoreCache.h"
+-
+-class NepomukResourceScoreMaintainerPrivate: public QThread {
+-public:
+-    typedef QString ApplicationName;
+-    typedef QString ActivityID;
+-    typedef QList < QUrl > ResourceList;
+-
+-    typedef QMap < ApplicationName, ResourceList > Applications;
+-    typedef QMap < ActivityID, Applications > ResourceTree;
+-
+-    ResourceTree openResources;
+-    QMutex openResources_mutex;
+-
+-    void run();
+-    void processActivity(const ActivityID & activity, const Applications & applications);
+-
+-    static NepomukResourceScoreMaintainer * s_instance;
+-
+-};
+-
+-NepomukResourceScoreMaintainer * NepomukResourceScoreMaintainerPrivate::s_instance = NULL;
+-
+-void NepomukResourceScoreMaintainerPrivate::run()
+-{
+-    forever {
+-        // initial delay before processing the resources
+-        sleep(5);
+-
+-        NepomukResourceScoreMaintainerPrivate::openResources_mutex.lock();
+-            ResourceTree resources = openResources;
+-            openResources.clear();
+-        NepomukResourceScoreMaintainerPrivate::openResources_mutex.unlock();
+-
+-        const QString & activity = ActivityManager::self()->CurrentActivity();
+-
+-        // Let us first process the events related to the current
+-        // activity so that the stats are available quicker
+-
+-        if (resources.contains(activity)) {
+-            kDebug() << "Processing current activity events";
+-
+-            processActivity(activity, resources[activity]);
+-            resources.remove(activity);
+-        }
+-
+-        foreach (const ActivityID & activity, resources.keys()) {
+-            kDebug() << "Processing activity" << activity;
+-
+-            processActivity(activity, resources[activity]);
+-        }
+-    }
+-}
+-
+-void NepomukResourceScoreMaintainerPrivate::processActivity(const ActivityID & activity, const Applications & applications)
+-{
+-    foreach (const ApplicationName & application, applications.keys()) {
+-        // Processing resources for the pair (activity, application)
+-        kDebug() << "  Processing application" << application;
+-
+-        foreach (const QUrl & resource, applications[application]) {
+-            kDebug() << "    Updating score for" << activity, application, resource;
+-            NepomukResourceScoreCache(activity, application, resource).updateScore();
+-
+-        }
+-    }
+-}
+-
+-NepomukResourceScoreMaintainer * NepomukResourceScoreMaintainer::self()
+-{
+-    if (!NepomukResourceScoreMaintainerPrivate::s_instance) {
+-        NepomukResourceScoreMaintainerPrivate::s_instance = new NepomukResourceScoreMaintainer();
+-    }
+-
+-    return NepomukResourceScoreMaintainerPrivate::s_instance;
+-}
+-
+-NepomukResourceScoreMaintainer::NepomukResourceScoreMaintainer()
+-    : d(new NepomukResourceScoreMaintainerPrivate())
+-{
+-}
+-
+-NepomukResourceScoreMaintainer::~NepomukResourceScoreMaintainer()
+-{
+-    delete d;
+-}
+-
+-void NepomukResourceScoreMaintainer::processResource(const KUrl & resource, const QString & application)
+-{
+-    d->openResources_mutex.lock();
+-
+-    // Checking whether the item is already scheduled for
+-    // processing
+-
+-    kDebug() << "Adding" << resource << application << "to the queue";
+-
+-    const QString & activity = ActivityManager::self()->CurrentActivity();
+-
+-    if (d->openResources.contains(activity) &&
+-            d->openResources[activity].contains(application) &&
+-            d->openResources[activity][application].contains(resource)) {
+-        return;
+-    }
+-
+-    d->openResources[activity][application] << resource;
+-
+-    d->openResources_mutex.unlock();
+-
+-    d->start();
+-}
+-
+-
+diff --git a/activitymanager/NepomukResourceScoreMaintainer.h b/activitymanager/NepomukResourceScoreMaintainer.h
+deleted file mode 100644
+index cbef9f9..0000000
+--- a/activitymanager/NepomukResourceScoreMaintainer.h
++++ /dev/null
+@@ -1,47 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#ifndef NEPOMUK_RESOURCE_SCORE_MAINTAINER_H_
+-#define NEPOMUK_RESOURCE_SCORE_MAINTAINER_H_
+-
+-#include <QThread>
+-#include <Nepomuk/Resource>
+-
+-#include "Event.h"
+-
+-class NepomukResourceScoreMaintainerPrivate;
+-
+-/**
+- * Thread to process desktop/usage events
+- */
+-class NepomukResourceScoreMaintainer {
+-public:
+-    static NepomukResourceScoreMaintainer * self();
+-
+-    virtual ~NepomukResourceScoreMaintainer();
+-
+-    void processResource(const KUrl & resource, const QString & application);
+-
+-private:
+-    NepomukResourceScoreMaintainer();
+-
+-    class NepomukResourceScoreMaintainerPrivate * const d;
+-};
+-
+-#endif // NEPOMUK_RESOURCE_SCORE_MAINTAINER_H_
+diff --git a/activitymanager/Plugin.cpp b/activitymanager/Plugin.cpp
+new file mode 100644
+index 0000000..e1f9bc9
+--- /dev/null
++++ b/activitymanager/Plugin.cpp
+@@ -0,0 +1,56 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#include "Plugin.h"
++
++class Plugin::Private {
++public:
++    SharedInfo * sharedInfo;
++};
++
++Plugin::Plugin(QObject * parent)
++    : QObject(parent), d(new Private())
++{
++}
++
++Plugin::~Plugin()
++{
++    delete d;
++}
++
++void Plugin::addEvents(const EventList & events)
++{
++    Q_UNUSED(events)
++}
++
++void Plugin::setResourceMimeType(const QString & uri, const QString & mimetype)
++{
++    Q_UNUSED(uri)
++    Q_UNUSED(mimetype)
++}
++
++void Plugin::setSharedInfo(SharedInfo * sharedInfo)
++{
++    d->sharedInfo = sharedInfo;
++}
++
++SharedInfo * Plugin::sharedInfo() const
++{
++    return d->sharedInfo;
++}
+diff --git a/activitymanager/Plugin.h b/activitymanager/Plugin.h
+new file mode 100644
+index 0000000..cdf8b7f
+--- /dev/null
++++ b/activitymanager/Plugin.h
+@@ -0,0 +1,59 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifndef EVENT_BACKEND_H_
++#define EVENT_BACKEND_H_
++
++#include <EventProcessor.h>
++
++#include <kdemacros.h>
++#include <KPluginFactory>
++#include <KPluginLoader>
++
++#include "Event.h"
++#include "SharedInfo.h"
++
++#define KAMD_EXPORT_PLUGIN(ClassName, AboutData)                       \
++    K_PLUGIN_FACTORY(ClassName##Factory, registerPlugin<ClassName>();) \
++    K_EXPORT_PLUGIN(ClassName##Factory("AboutData"))
++
++
++/**
++ *
++ */
++class KDE_EXPORT Plugin: public QObject {
++    Q_OBJECT
++
++public:
++    Plugin(QObject * parent);
++    virtual ~Plugin();
++
++    virtual void addEvents(const EventList & events);
++    virtual void setResourceMimeType(const QString & uri, const QString & mimetype);
++
++    virtual void setSharedInfo(SharedInfo * sharedInfo);
++    SharedInfo * sharedInfo() const;
++
++private:
++    class Private;
++    Private * const d;
++};
++
++#endif // EVENT_BACKEND_H_
++
+diff --git a/activitymanager/SharedInfo.cpp b/activitymanager/SharedInfo.cpp
+index 8c71c34..1948075 100644
+--- a/activitymanager/SharedInfo.cpp
++++ b/activitymanager/SharedInfo.cpp
+@@ -18,6 +18,9 @@
+  */
+ 
+ #include "SharedInfo.h"
++#include "ActivityManager.h"
++
++#include <KDebug>
+ 
+ SharedInfo * SharedInfo::s_instance = NULL;
+ 
+@@ -25,12 +28,15 @@ SharedInfo * SharedInfo::self()
+ {
+     if (!s_instance) {
+         s_instance = new SharedInfo();
++
++        kDebug() << "SHARED INFO" << (void*) s_instance;
+     }
+ 
+     return s_instance;
+ }
+ 
+ SharedInfo::SharedInfo()
++    : m_config("activitymanager-pluginsrc")
+ {
+ }
+ 
+@@ -48,4 +54,18 @@ QHash < KUrl, SharedInfo::ResourceData > const & SharedInfo::resources() const
+     return m_resources;
+ }
+ 
++QString SharedInfo::currentActivity() const
++{
++    return m_currentActivity;
++}
++
++void SharedInfo::setCurrentActivity(const QString & activity)
++{
++    m_currentActivity = activity;
++}
++
++KConfigGroup SharedInfo::pluginConfig(const QString & pluginName) const
++{
++    return KConfigGroup(&m_config, pluginName);
++}
+ 
+diff --git a/activitymanager/SharedInfo.h b/activitymanager/SharedInfo.h
+index 6e60612..77f5683 100644
+--- a/activitymanager/SharedInfo.h
++++ b/activitymanager/SharedInfo.h
+@@ -25,6 +25,9 @@
+ #include <QString>
+ #include <QHash>
+ 
++#include <KConfigGroup>
++#include <KConfig>
++
+ #include "Event.h"
+ 
+ /**
+@@ -32,8 +35,6 @@
+  */
+ class SharedInfo {
+ public:
+-    static SharedInfo * self();
+-
+     virtual ~SharedInfo();
+ 
+     struct WindowData {
+@@ -50,14 +51,26 @@ public:
+     QHash < WId, WindowData > const & windows() const;
+     QHash < KUrl, ResourceData > const & resources() const;
+ 
++    QString currentActivity() const;
++
++    KConfigGroup pluginConfig(const QString & pluginName) const;
++
+ private:
++    static SharedInfo * self();
++
++    void setCurrentActivity(const QString & activity);
++
+     QHash < WId, WindowData > m_windows;
+     QHash < KUrl, ResourceData > m_resources;
++    QString m_currentActivity;
++    KConfig m_config;
+ 
+     static SharedInfo * s_instance;
+     SharedInfo();
+ 
+     friend class ActivityManager;
++    friend class ActivityManagerPrivate;
++    friend class EventProcessor;
+ };
+ 
+ #endif // SHARED_INFO_H_
+diff --git a/activitymanager/SlcEventBackend.cpp b/activitymanager/SlcEventBackend.cpp
+deleted file mode 100644
+index fe8f01d..0000000
+--- a/activitymanager/SlcEventBackend.cpp
++++ /dev/null
+@@ -1,127 +0,0 @@
+-/*
+- *   Copyright (C) 2010 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#include "SlcEventBackend.h"
+-#include "slcadaptor.h"
+-
+-#include <QDBusConnection>
+-#include <KDebug>
+-#include <KWindowSystem>
+-#include <KUrl>
+-
+-#include "SharedInfo.h"
+-
+-SlcEventBackend::SlcEventBackend()
+-    : focussedWindow(0)
+-{
+-    QDBusConnection dbus = QDBusConnection::sessionBus();
+-    new SLCAdaptor(this);
+-    dbus.registerObject("/SLC", this);
+-
+-    connect(KWindowSystem::self(), SIGNAL(activeWindowChanged(WId)),
+-            this, SLOT(activeWindowChanged(WId)));
+-}
+-
+-void SlcEventBackend::addEvents(const EventList & events)
+-{
+-    foreach (const Event & event, events) {
+-        switch (event.type) {
+-            case Event::FocussedIn:
+-            case Event::Opened:
+-                // kDebug() << "Event::FocussedIn" << focussedWindow << event.wid << event.uri;
+-
+-                lastFocussedResource[event.wid] = event.uri;
+-
+-                if (event.wid == focussedWindow) {
+-                    updateFocus(focussedWindow);
+-                }
+-
+-                break;
+-
+-            case Event::FocussedOut:
+-            case Event::Closed:
+-                // kDebug() << "Event::FocussedOut" << focussedWindow << event.wid << event.uri;
+-
+-                if (lastFocussedResource[event.wid] == event.uri) {
+-                    lastFocussedResource[event.wid] = KUrl();
+-                }
+-
+-                if (event.wid == focussedWindow) {
+-                    updateFocus();
+-                }
+-
+-                break;
+-
+-            default:
+-                // nothing
+-                break;
+-        }
+-    }
+-}
+-
+-KUrl SlcEventBackend::_focussedResourceURI()
+-{
+-    KUrl kuri;
+-
+-    if (lastFocussedResource.contains(focussedWindow)) {
+-        kuri = lastFocussedResource[focussedWindow];
+-    } else {
+-        foreach (const KUrl & uri, SharedInfo::self()->windows()[focussedWindow].resources) {
+-            kuri = uri;
+-            break;
+-        }
+-    }
+-
+-    return kuri;
+-}
+-
+-QString SlcEventBackend::focussedResourceURI()
+-{
+-    return _focussedResourceURI().url();
+-}
+-
+-QString SlcEventBackend::focussedResourceMimetype()
+-{
+-    return SharedInfo::self()->resources().contains(_focussedResourceURI()) ?
+-        SharedInfo::self()->resources()[_focussedResourceURI()].mimetype : QString();
+-}
+-
+-void SlcEventBackend::activeWindowChanged(WId wid)
+-{
+-    if (wid == focussedWindow) return;
+-
+-    focussedWindow = wid;
+-
+-    updateFocus(wid);
+-}
+-
+-void SlcEventBackend::updateFocus(WId wid)
+-{
+-    // kDebug() << "Updating focus for " << wid;
+-
+-    if (wid == 0 || !SharedInfo::self()->windows().contains(wid)) {
+-        // kDebug() << "Clearing focus";
+-        emit focusChanged(QString(), QString());
+-
+-    } else if (wid == focussedWindow) {
+-        // kDebug() << "It is the currently focussed window";
+-        emit focusChanged(focussedResourceURI(), SharedInfo::self()->resources()[_focussedResourceURI()].mimetype);
+-
+-    }
+-}
+diff --git a/activitymanager/SlcEventBackend.h b/activitymanager/SlcEventBackend.h
+deleted file mode 100644
+index 3c79792..0000000
+--- a/activitymanager/SlcEventBackend.h
++++ /dev/null
+@@ -1,59 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#ifndef SLC_EVENT_BACKEND_H_
+-#define SLC_EVENT_BACKEND_H_
+-
+-#include "EventBackend.h"
+-
+-#include <QObject>
+-#include <KUrl>
+-
+-/**
+- *
+- */
+-class SlcEventBackend: public QObject, public EventBackend {
+-    Q_OBJECT
+-    Q_CLASSINFO("D-Bus Interface", "org.kde.ActivityManager.SLC")
+-
+-public:
+-    SlcEventBackend();
+-
+-    virtual void addEvents(const EventList & events);
+-
+-private Q_SLOTS:
+-    void activeWindowChanged(WId windowId);
+-
+-public Q_SLOTS:
+-    QString focussedResourceURI();
+-    QString focussedResourceMimetype();
+-
+-Q_SIGNALS:
+-    void focusChanged(const QString & uri, const QString & mimetype);
+-
+-private:
+-    void updateFocus(WId wid = 0);
+-
+-    WId focussedWindow;
+-    KUrl _focussedResourceURI();
+-    QHash < WId, KUrl > lastFocussedResource;
+-};
+-
+-#endif // SLC_EVENT_BACKEND_H_
+-
+diff --git a/activitymanager/ZeitgeistEventBackend.cpp b/activitymanager/ZeitgeistEventBackend.cpp
+deleted file mode 100644
+index 1bbd050..0000000
+--- a/activitymanager/ZeitgeistEventBackend.cpp
++++ /dev/null
+@@ -1,95 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#include "config-features.h"
+-
+-#ifndef HAVE_QZEITGEIST
+-#ifdef __GNUC__
+-    #warning "No QtZeitgeist, disabling desktop events processing"
+-#endif
+-
+-#else // HAVE_QZEITGEIST
+-
+-#include "ZeitgeistEventBackend.h"
+-
+-#include <QtZeitgeist/QtZeitgeist>
+-#include <QtZeitgeist/Interpretation>
+-#include <QtZeitgeist/Manifestation>
+-
+-static QString eventInterpretation(Event::Type type)
+-{
+-    // switch (type) {
+-    //     case Event::Accessed:
+-    //         return QtZeitgeist::Interpretation::Event::ZGAccessEvent;
+-
+-    //     case Event::Opened:
+-    //         return QtZeitgeist::Interpretation::Event::ZGAccessEvent;
+-
+-    //     case Event::Modified:
+-    //         return QtZeitgeist::Interpretation::Event::ZGModifyEvent;
+-
+-    //     case Event::Closed:
+-    //         return QtZeitgeist::Interpretation::Event::ZGLeaveEvent;
+-
+-    // }
+-
+-    // shut up GCC
+-    return QString();
+-}
+-
+-static QString eventManifestation(Event::Reason reason)
+-{
+-    // switch (reason) {
+-    //     case Event::User:
+-    //         return QtZeitgeist::Manifestation::Event::ZGUserActivity;
+-
+-    //     case Event::Heuristic:
+-    //         return QtZeitgeist::Manifestation::Event::ZGHeuristicActivity;
+-
+-    //     case Event::Scheduled:
+-    //         return QtZeitgeist::Manifestation::Event::ZGScheduledActivity;
+-
+-    //     case Event::System:
+-    //         return QtZeitgeist::Manifestation::Event::ZGSystemNotification;
+-
+-    //     case Event::World:
+-    //         return QtZeitgeist::Manifestation::Event::ZGWorldActivity;
+-    // }
+-
+-    // shut up GCC
+-    return QtZeitgeist::Manifestation::Event::ZGUserActivity;
+-}
+-
+-static QString applicationUri(const QString & application)
+-{
+-    // TODO: Make this correct
+-    return "app://" + application + ".desktop";
+-}
+-
+-ZeitgeistEventBackend::ZeitgeistEventBackend()
+-{
+-    QtZeitgeist::init();
+-}
+-
+-void ZeitgeistEventBackend::addEvents(const EventList & events)
+-{
+-
+-}
+-
+-#endif // HAVE_QZEITGEIST
+diff --git a/activitymanager/ZeitgeistEventBackend.h b/activitymanager/ZeitgeistEventBackend.h
+deleted file mode 100644
+index 1b5fab7..0000000
+--- a/activitymanager/ZeitgeistEventBackend.h
++++ /dev/null
+@@ -1,39 +0,0 @@
+-/*
+- *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
+- *
+- *   This program is free software; you can redistribute it and/or modify
+- *   it under the terms of the GNU General Public License version 2,
+- *   or (at your option) any later version, as published by the Free
+- *   Software Foundation
+- *
+- *   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, write to the
+- *   Free Software Foundation, Inc.,
+- *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+- */
+-
+-#ifndef ZEITGEIST_EVENT_BACKEND_H_
+-#define ZEITGEIST_EVENT_BACKEND_H_
+-
+-#include "EventBackend.h"
+-
+-/**
+- *
+- */
+-class ZeitgeistEventBackend: public EventBackend {
+-public:
+-    ZeitgeistEventBackend();
+-
+-    virtual void addEvents(const EventList & events);
+-
+-private:
+-    /* data */
+-};
+-
+-#endif // ZEITGEIST_EVENT_BACKEND_H_
+-
+diff --git a/activitymanager/activitymanager-plugin.desktop b/activitymanager/activitymanager-plugin.desktop
+new file mode 100644
+index 0000000..f7a068f
+--- /dev/null
++++ b/activitymanager/activitymanager-plugin.desktop
+@@ -0,0 +1,12 @@
++[Desktop Entry]
++Type=ServiceType
++X-KDE-ServiceType=ActivityManager/Plugin
++
++Comment=Activity manager plugin
++
++[PropertyDef::X-ActivityManager-PluginType]
++Type=QString
++
++[PropertyDef::X-ActivityManager-PluginOverrides]
++Type=QString
++
+diff --git a/activitymanager/krso.trig b/activitymanager/krso.trig
+new file mode 100644
+index 0000000..a74aa69
+--- /dev/null
++++ b/activitymanager/krso.trig
+@@ -0,0 +1,100 @@
++#
++# Copyright (c) 2011 Ivan Cukic <[e-mail]>
++# All rights reserved, licensed under either CC-BY or BSD.
++#
++# You are free:
++#  * to Share - to copy, distribute and transmit the work
++#  * to Remix - to adapt the work
++# Under the following conditions:
++#  * Attribution - You must attribute the work in the manner specified by the author
++#    or licensor (but not in any way that suggests that they endorse you or your use
++#    of the work).
++#
++# Redistribution and use in source and binary forms, with or without modification,
++# are permitted provided that the following conditions are met:
++#  * Redistributions of source code must retain the above copyright notice, this
++#    list of conditions and the following disclaimer.
++#  * Redistributions in binary form must reproduce the above copyright notice, this
++#    list of conditions and the following disclaimer in the documentation and/or
++#    other materials provided with the distribution.
++#  * Neither the names of the authors nor the names of contributors may
++#    be used to endorse or promote products derived from this ontology without
++#    specific prior written permission.
++#
++# THIS ONTOLOGY IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
++# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
++# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
++# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
++# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
++# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
++# THIS ONTOLOGY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++#
++
++@prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
++@prefix nao:     <http://www.semanticdesktop.org/ontologies/2007/08/15/nao#> .
++@prefix nrl:     <http://www.semanticdesktop.org/ontologies/2007/08/15/nrl#> .
++@prefix nie:     <http://www.semanticdesktop.org/ontologies/2007/01/19/nie#> .
++@prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .
++@prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
++@prefix krso:    <http://nepomuk.kde.org/ontologies/2011/06/17/krso#> .
++@prefix nfo:     <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#> .
++
++krso: {
++    krso:ResourceScoreCache
++          a rdfs:Class ;
++          rdfs:subClassOf rdfs:Resource ;
++          rdfs:label "Resource score cache" ;
++          rdfs:comment "For storing the automatically calculated score based on the usage statistics" ;
++          nao:userVisible false .
++
++    krso:targettedResource
++          a rdf:Property ;
++          rdfs:comment "Resource for which the score is calculated." ;
++          rdfs:domain krso:ResourceScoreCache ;
++          rdfs:label "resource" ;
++          rdfs:range rdfs:Resource .
++
++    krso:initiatingAgent
++          a rdf:Property ;
++          rdfs:comment "Relates the score to the agent initiating the events." ;
++          rdfs:domain krso:ResourceScoreCache ;
++          rdfs:label "involved agent" ;
++          rdfs:range nao:Agent .
++
++    krso:involvesActivity
++          a rdf:Property ;
++          rdfs:comment "Relates the score to the activity in which the events happened." ;
++          rdfs:domain krso:ResourceScoreCache ;
++          rdfs:label "involved activity" ;
++          rdfs:range krso:Activity .
++
++    krso:cachedScore
++          a rdf:Property ;
++          rdfs:subPropertyOf nao:score ;
++          rdfs:comment "The automatically calculated score" ;
++          rdfs:domain krso:ResourceScoreCache ;
++          rdfs:label "calculated score" ;
++          rdfs:range xsd:float .
++}
++
++<http://nepomuk.kde.org/ontologies/2011/06/17/krso/metadata> {
++    <http://nepomuk.kde.org/ontologies/2011/06/17/krso/metadata>
++          a       nrl:GraphMetadata ;
++          nrl:coreGraphMetadataFor krso: .
++
++
++    krso:
++          a       nrl:Ontology , nrl:DocumentGraph ;
++          nao:prefLabel "KDE Resource Scoring Ontology" ;
++          nao:hasDefaultNamespace "http://nepomuk.kde.org/ontologies/2011/06/17/krso#" ;
++          nao:hasDefaultNamespaceAbbreviation "krso" ;
++          nao:lastModified "2011-06-17T11:00:43Z" ;
++          nao:serializationLanguage "TriG" ;
++          nao:status "Unstable" ;
++          nrl:updatable "0" ;
++          nao:version "2" .
++}
++
+diff --git a/activitymanager/ontologies/CMakeLists.txt b/activitymanager/ontologies/CMakeLists.txt
+deleted file mode 100644
+index 838b1f4..0000000
+--- a/activitymanager/ontologies/CMakeLists.txt
++++ /dev/null
+@@ -1,8 +0,0 @@
+-project(nepomuk_ontologies)
+-
+-configure_file(kamdrso.ontology.in ${CMAKE_CURRENT_BINARY_DIR}/kamdrso.ontology)
+-
+-install(FILES
+-  kamdrso.trig
+-  ${CMAKE_CURRENT_BINARY_DIR}/kamdrso.ontology
+-DESTINATION ${CMAKE_INSTALL_PREFIX}/share/ontology/kde)
+diff --git a/activitymanager/ontologies/kamdrso.ontology.in b/activitymanager/ontologies/kamdrso.ontology.in
+deleted file mode 100644
+index 032dac0..0000000
+--- a/activitymanager/ontologies/kamdrso.ontology.in
++++ /dev/null
+@@ -1,8 +0,0 @@
+-[Ontology]
+-Version=1.0
+-Name=KDE Activity Manager Daemon - Resource Scoring Ontology
+-Comment=The KDE Resource Scoring Ontology contains classes related to KAMD's scoring mechanisms
+-Namespace=http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso#" ;
+-Path=${CMAKE_INSTALL_PREFIX}/share/ontology/kde/kamdrso.trig
+-MimeType=application/x-trig
+-Type=Data
+diff --git a/activitymanager/ontologies/kamdrso.trig b/activitymanager/ontologies/kamdrso.trig
+deleted file mode 100644
+index b968231..0000000
+--- a/activitymanager/ontologies/kamdrso.trig
++++ /dev/null
+@@ -1,112 +0,0 @@
+-#
+-# Copyright (c) 2011 Ivan Cukic <[e-mail]>
+-# All rights reserved, licensed under either CC-BY or BSD.
+-#
+-# You are free:
+-#  * to Share - to copy, distribute and transmit the work
+-#  * to Remix - to adapt the work
+-# Under the following conditions:
+-#  * Attribution - You must attribute the work in the manner specified by the author
+-#    or licensor (but not in any way that suggests that they endorse you or your use
+-#    of the work).
+-#
+-# Redistribution and use in source and binary forms, with or without modification,
+-# are permitted provided that the following conditions are met:
+-#  * Redistributions of source code must retain the above copyright notice, this
+-#    list of conditions and the following disclaimer.
+-#  * Redistributions in binary form must reproduce the above copyright notice, this
+-#    list of conditions and the following disclaimer in the documentation and/or
+-#    other materials provided with the distribution.
+-#  * Neither the names of the authors nor the names of contributors may
+-#    be used to endorse or promote products derived from this ontology without
+-#    specific prior written permission.
+-#
+-# THIS ONTOLOGY IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+-# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+-# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+-# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+-# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+-# THIS ONTOLOGY, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+-#
+-
+-@prefix rdfs:    <http://www.w3.org/2000/01/rdf-schema#> .
+-@prefix nao:     <http://www.semanticdesktop.org/ontologies/2007/08/15/nao#> .
+-@prefix nrl:     <http://www.semanticdesktop.org/ontologies/2007/08/15/nrl#> .
+-@prefix nie:     <http://www.semanticdesktop.org/ontologies/2007/01/19/nie#> .
+-@prefix xsd:     <http://www.w3.org/2001/XMLSchema#> .
+-@prefix rdf:     <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+-@prefix kamdrso:    <http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso#> .
+-@prefix nfo:     <http://www.semanticdesktop.org/ontologies/2007/03/22/nfo#> .
+-
+-kamdrso: {
+-    kamdrso:unixFileMode
+-          a      rdf:Property ;
+-          rdfs:label "Unix file mode" ;
+-          rdfs:comment "The file mode value as seen on unix file systems." ;
+-          rdfs:domain nfo:FileDataObject ;
+-          rdfs:range xsd:integer ;
+-          nao:userVisible false .
+-
+-    kamdrso:unixFileOwner
+-          a      rdf:Property ;
+-          rdfs:label "Unix file owner" ;
+-          rdfs:comment "The owner of the file as seen on unix file systems. This is intended as the low-level counterpart to nfo:owner." ;
+-          rdfs:domain nfo:FileDataObject ;
+-          rdfs:range xsd:string ;
+-          nao:userVisible false .
+-
+-    kamdrso:unixFileGroup
+-          a      rdf:Property ;
+-          rdfs:label "Unix file group" ;
+-          rdfs:comment "The group of the file as seen on unix file systems." ;
+-          rdfs:domain nfo:FileDataObject ;
+-          rdfs:range xsd:string ;
+-          nao:userVisible false .
+-
+-    kamdrso:Activity
+-          a rdfs:Class ;
+-          rdfs:subClassOf rdfs:Resource ;
+-          rdfs:label "activity" ;
+-          rdfs:comment "A Plasma activity." .
+-
+-    kamdrso:usedActivity
+-          a rdf:Property ;
+-          rdfs:label "used activity" ;
+-          rdfs:comment "The activity that was active when resource was created. This is mostly used for graphs or desktop events." ;
+-          rdfs:domain rdfs:Resource ;
+-          rdfs:range kamdrso:Activity ;
+-          nao:userVisible false .
+-
+-    kamdrso:activityIdentifier
+-          a rdf:Property ;
+-          rdfs:subPropertyOf nao:identifier ;
+-          rdfs:label "activity identifier" ;
+-          rdfs:comment "The unique ID of the activity as used outside of Nepomuk. Typically this is a UUID." ;
+-          rdfs:domain kamdrso:Activity ;
+-          rdfs:range xsd:string ;
+-          nao:userVisible false .
+-
+-}
+-
+-<http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso/metadata> {
+-    <http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso/metadata>
+-          a       nrl:GraphMetadata ;
+-          nrl:coreGraphMetadataFor kamdrso: .
+-
+-
+-    kamdrso:
+-          a       nrl:Ontology , nrl:DocumentGraph ;
+-          nao:prefLabel "KDE Extensions Ontology" ;
+-          nao:hasDefaultNamespace "http://nepomuk.kde.org/ontologies/2011/06/01/kamdrso#" ;
+-          nao:hasDefaultNamespaceAbbreviation "kamdrso" ;
+-          nao:lastModified "2011-06-02T12:31:43Z" ;
+-          nao:serializationLanguage "TriG" ;
+-          nao:status "Unstable" ;
+-          nrl:updatable "0" ;
+-          nao:version "2" .
+-}
+-
+diff --git a/activitymanager/org.kde.ActivityManager.SLC.xml b/activitymanager/org.kde.ActivityManager.SLC.xml
+deleted file mode 100644
+index b9df419..0000000
+--- a/activitymanager/org.kde.ActivityManager.SLC.xml
++++ /dev/null
+@@ -1,15 +0,0 @@
+-<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+-<node>
+-  <interface name="org.kde.ActivityManager.SLC">
+-    <signal name="focusChanged">
+-      <arg name="uri" type="s" direction="out"/>
+-      <arg name="mimetype" type="s" direction="out"/>
+-    </signal>
+-    <method name="focussedResourceURI">
+-      <arg type="s" direction="out"/>
+-    </method>
+-    <method name="focussedResourceMimetype">
+-      <arg type="s" direction="out"/>
+-    </method>
+-  </interface>
+-</node>
+diff --git a/activitymanager/plugins/CMakeLists.txt b/activitymanager/plugins/CMakeLists.txt
+new file mode 100644
+index 0000000..6acca9e
+--- /dev/null
++++ b/activitymanager/plugins/CMakeLists.txt
+@@ -0,0 +1,3 @@
++macro_optional_add_subdirectory(dummy)
++macro_optional_add_subdirectory(slc)
++macro_optional_add_subdirectory(nepomuk)
+diff --git a/activitymanager/plugins/dummy/CMakeLists.txt b/activitymanager/plugins/dummy/CMakeLists.txt
+new file mode 100644
+index 0000000..7cced75
+--- /dev/null
++++ b/activitymanager/plugins/dummy/CMakeLists.txt
+@@ -0,0 +1,30 @@
++project(activitymanager-dummy)
++
++include_directories(
++   ${CMAKE_SOURCE_DIR}
++   ${CMAKE_BINARY_DIR}
++   ${CMAKE_CURRENT_SOURCE_DIR}
++   ${CMAKE_CURRENT_SOURCE_DIR}/../..
++   ${CMAKE_CURRENT_BINARY_DIR}
++   ${KDE4_INCLUDES}
++   )
++
++set(
++   dummy_SRCS
++   dummy.cpp
++   ../../Plugin.cpp
++   )
++
++kde4_add_plugin(
++   activitymanager_plugin_dummy
++   ${dummy_SRCS}
++   )
++
++target_link_libraries(
++   activitymanager_plugin_dummy
++   ${KDE4_KDECORE_LIBS}
++)
++
++install(TARGETS activitymanager_plugin_dummy DESTINATION ${PLUGIN_INSTALL_DIR})
++install(FILES activitymanager-plugin-dummy.desktop DESTINATION ${SERVICES_INSTALL_DIR})
++
+diff --git a/activitymanager/plugins/dummy/activitymanager-plugin-dummy.desktop b/activitymanager/plugins/dummy/activitymanager-plugin-dummy.desktop
+new file mode 100644
+index 0000000..34ec150
+--- /dev/null
++++ b/activitymanager/plugins/dummy/activitymanager-plugin-dummy.desktop
+@@ -0,0 +1,19 @@
++[Desktop Entry]
++Name=Dummy plugin
++Comment=Just testing
++Type=Service
++Icon=
++
++X-KDE-ServiceTypes=ActivityManager/Plugin
++X-KDE-Library=activitymanager_plugin_dummy
++X-KDE-PluginInfo-Author=Ivan Cukic
++X-KDE-PluginInfo-Email=[e-mail]
++X-KDE-PluginInfo-Name=org.kde.kactivitymanager.dummy
++X-KDE-PluginInfo-Version=1.0
++X-KDE-PluginInfo-Website=http://plasma.kde.org/
++X-KDE-PluginInfo-Category=Language
++X-KDE-PluginInfo-Depends=
++X-KDE-PluginInfo-License=GPL
++X-KDE-PluginInfo-EnabledByDefault=true
++
++X-ActivityManager-PluginType=normal
+diff --git a/activitymanager/plugins/dummy/dummy.cpp b/activitymanager/plugins/dummy/dummy.cpp
+new file mode 100644
+index 0000000..e20fb2b
+--- /dev/null
++++ b/activitymanager/plugins/dummy/dummy.cpp
+@@ -0,0 +1,34 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic ivan.cukic(at)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 "dummy.h"
++
++#include <KDebug>
++#include "ActivityManager.h"
++
++DummyPlugin::DummyPlugin(QObject * parent, const QVariantList & args)
++    : Plugin(parent)
++{
++    Q_UNUSED(args)
++    kDebug() << "We are in the DummyPlugin";
++}
++
++DummyPlugin::~DummyPlugin()
++{
++}
++
++KAMD_EXPORT_PLUGIN(DummyPlugin, "activitymanger_plugin_dummy")
+diff --git a/activitymanager/plugins/dummy/dummy.h b/activitymanager/plugins/dummy/dummy.h
+new file mode 100644
+index 0000000..e059a5e
+--- /dev/null
++++ b/activitymanager/plugins/dummy/dummy.h
+@@ -0,0 +1,35 @@
++/*
++ *   Copyright (C) 2008 Nick Shaforostoff <[e-mail]>
++ *
++ *   based on work by:
++ *   Copyright (C) 2007 Thomas Georgiou <[e-mail]> and Jeff Cooper <[e-mail]>
++ *
++ *   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 Dummy_H
++#define Dummy_H
++
++#include "../../Plugin.h"
++
++class DummyPlugin: public Plugin
++{
++    Q_OBJECT
++
++public:
++    DummyPlugin(QObject *parent, const QVariantList & args);
++    ~DummyPlugin();
++};
++
++#endif
+diff --git a/activitymanager/plugins/nepomuk/CMakeLists.txt b/activitymanager/plugins/nepomuk/CMakeLists.txt
+new file mode 100644
+index 0000000..7900519
+--- /dev/null
++++ b/activitymanager/plugins/nepomuk/CMakeLists.txt
+@@ -0,0 +1,61 @@
++project(activitymanager-plugin-nepomuk)
++
++# Checking for Nepomuk
++find_package(Nepomuk REQUIRED)
++
++set(
++   nepomuk_SRCS
++   NepomukPlugin.cpp
++   NepomukResourceScoreCache.cpp
++   NepomukResourceScoreMaintainer.cpp
++   ../../Plugin.cpp
++   ../../SharedInfo.cpp
++   )
++
++soprano_add_ontology(nepomuk_SRCS
++    ${CMAKE_SOURCE_DIR}/nepomuk/ontologies/kext.trig
++    "KExt" "Nepomuk::Vocabulary" "trig"
++    )
++
++soprano_add_ontology(nepomuk_SRCS
++    ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nie/nie.trig
++    "NIE" "Nepomuk::Vocabulary" "trig"
++    )
++
++soprano_add_ontology(nepomuk_SRCS
++    ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nepomuk/nao.trig
++    "NAO" "Nepomuk::Vocabulary" "trig"
++    )
++
++soprano_add_ontology(nepomuk_SRCS
++    ${SHAREDDESKTOPONTOLOGIES_ROOT_DIR}/nepomuk/nuao.trig
++    "NUAO" "Nepomuk::Vocabulary" "trig"
++    )
++
++include_directories(
++   ${CMAKE_SOURCE_DIR}
++   ${CMAKE_BINARY_DIR}
++   ${CMAKE_CURRENT_SOURCE_DIR}
++   ${CMAKE_CURRENT_SOURCE_DIR}/../..
++   ${CMAKE_CURRENT_BINARY_DIR}
++   ${CMAKE_CURRENT_BINARY_DIR}/../..
++   ${KDE4_INCLUDES}
++   )
++
++kde4_add_plugin(
++   activitymanager_plugin_nepomuk
++   ${nepomuk_SRCS}
++   )
++
++target_link_libraries(
++   activitymanager_plugin_nepomuk
++   ${KDE4_KDECORE_LIBS}
++   ${KDE4_KDEUI_LIBS}
++   ${NEPOMUK_LIBRARIES}
++   ${NEPOMUK_QUERY_LIBRARIES}
++   ${SOPRANO_LIBRARIES}
++   )
++
++install(TARGETS activitymanager_plugin_nepomuk DESTINATION ${PLUGIN_INSTALL_DIR})
++install(FILES activitymanager-plugin-nepomuk.desktop DESTINATION ${SERVICES_INSTALL_DIR})
++
+diff --git a/activitymanager/plugins/nepomuk/NepomukCommon.h b/activitymanager/plugins/nepomuk/NepomukCommon.h
+new file mode 100644
+index 0000000..222c9c0
+--- /dev/null
++++ b/activitymanager/plugins/nepomuk/NepomukCommon.h
+@@ -0,0 +1,67 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#ifndef NEPOMUK_COMMON_H_
++#define NEPOMUK_COMMON_H_
++
++#include "nie.h"
++#include "NepomukPlugin.h"
++
++#include <Nepomuk/Variant>
++
++#define NUAO_targettedResource KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("targettedResource"))
++#define NUAO_initiatingAgent   KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("initiatingAgent"))
++// #define NUAO_involvesActivity  KUrl(NUAO::nuaoNamespace().toString() + QLatin1String("involvesActivity"))
++
++#define activityResource(ID) Nepomuk::Resource(ID, KExt::Activity())
++#define agentResource(ID)    Nepomuk::Resource(ID, NAO::Agent())
++#define currentActivityId    NepomukPlugin::self()->sharedInfo()->currentActivity()
++#define currentActivityRes   activityResource(currentActivityId)
++
++// #define anyResource(ID) Nepomuk::Resource(KUrl(ID))
++
++inline Nepomuk::Resource anyResource(const QUrl & uri)
++{
++    Nepomuk::Resource result(uri);
++
++    kDebug() << "setting the URI" << result.isFile() << result.isValid();
++    result.setProperty(Nepomuk::Vocabulary::NIE::url(), uri);
++    kDebug() << "set the URI" << result.isFile() << result.isValid();
++
++    return result;
++}
++
++inline Nepomuk::Resource anyResource(const QString & uri)
++{
++    return anyResource(KUrl(uri));
++}
++
++#define litN3(A) Soprano::Node::literalToN3(A)
++
++inline QString resN3(const QUrl & uri)
++{
++    return Soprano::Node::resourceToN3(uri);
++}
++
++inline QString resN3(const Nepomuk::Resource & resource)
++{
++    return Soprano::Node::resourceToN3(resource.resourceUri());
++}
++
++#endif // NEPOMUK_COMMON_H_
+diff --git a/activitymanager/plugins/nepomuk/NepomukPlugin.cpp b/activitymanager/plugins/nepomuk/NepomukPlugin.cpp
+new file mode 100644
+index 0000000..9cbcda7
+--- /dev/null
++++ b/activitymanager/plugins/nepomuk/NepomukPlugin.cpp
+@@ -0,0 +1,264 @@
++/*
++ *   Copyright (C) 2011 Ivan Cukic <ivan.cukic(at)kde.org>
++ *   Copyright (c) 2011 Sebastian Trueg <[e-mail]>
++ *
++ *   This program is free software; you can redistribute it and/or modify
++ *   it under the terms of the GNU General Public License version 2,
++ *   or (at your option) any later version, as published by the Free
++ *   Software Foundation
++ *
++ *   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, write to the
++ *   Free Software Foundation, Inc.,
++ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
++ */
++
++#include "NepomukPlugin.h"
++#include "NepomukResourceScoreMaintainer.h"
++
++#include "../../Event.h"
++#include "kext.h"
++
++#include <nepomuk/resource.h>
++#include <nepomuk/nuao.h>
++#include <nepomuk/resourcemanager.h>
++#include <nepomuk/variant.h>
++
++#include <Nepomuk/Query/Query>
++#include <Nepomuk/Query/ResourceTerm>
++#include <Nepomuk/Query/ResourceTypeTerm>
++#include <Nepomuk/Query/ComparisonTerm>
++#include <Nepomuk/Query/LiteralTerm>
++#include <Nepomuk/Query/NegationTerm>
++
++#include <Soprano/Vocabulary/NAO>
++#include <Soprano/QueryResultIterator>
++#include <Soprano/Node>
++#include <Soprano/Model>
++
++#include <kdebug.h>
++
++#include "NepomukCommon.h"
++
++using namespace Soprano::Vocabulary;
++using namespace Nepomuk::Vocabulary;
++using namespace Nepomuk::Query;
++
++NepomukPlugin * NepomukPlugin::s_instance = NULL;
++
++NepomukPlugin::NepomukPlugin(QObject *parent, const QVariantList & args)
++    : Plugin(parent)
++{
++    Q_UNUSED(args)
++    s_instance = this;
++}
++
++NepomukPlugin * NepomukPlugin::self()
++{
++    return s_instance;
++}
++
++void NepomukPlugin::addEvents(const EventList & events)
++{
++    foreach (const Event& event, events) {
++        kDebug() << "We are processing event" << event.type << event.uri;
++        kDebug() << "for agent" << event.application << agentResource(event.application).resourceUri();
++
++        switch (event.type) {
++            case Event::Accessed:
++            {
++                // one-shot event
++
++                Nepomuk::Resource eventRes = createDesktopEvent(event.uri, event.timestamp, event.application);
++                eventRes.addType(NUAO::UsageEvent());
++                eventRes.setProperty(NUAO::start(), event.timestamp);
++                eventRes.setProperty(NUAO::end(), event.timestamp);
++
++                kDebug() << "Created one-shot Accessed event" << eventRes;
++
++                NepomukResourceScoreMaintainer::self()->processResource(event.uri, event.application);
++
++                break;
++            }
++
++            case Event::Opened: