From 5cf40dba79301e2d54d63c8da4607325159f26b6 Mon Sep 17 00:00:00 2001 From: Peter Penz Date: Sun, 6 May 2012 21:49:47 +0200 Subject: [PATCH] Remove kde-runtime dependency "nepomukdatamanagement" Follow the suggestion from Vishesh Handa and copy the ResourceWatcher code from kde-runtime instead of creating a dependency. This will of course get removed again as soon as Nepomuk's resource watcher will get a public API. --- src/CMakeLists.txt | 11 +- src/kitemviews/kfileitemmodelrolesupdater.cpp | 2 +- src/kitemviews/private/nepomuk/ReadMe.txt | 3 + .../org.kde.nepomuk.ResourceWatcher.xml | 14 + ....kde.nepomuk.ResourceWatcherConnection.xml | 65 ++++ .../private/nepomuk/resourcewatcher.cpp | 299 ++++++++++++++++++ .../resourcewatcher.h} | 61 +++- 7 files changed, 437 insertions(+), 18 deletions(-) create mode 100644 src/kitemviews/private/nepomuk/ReadMe.txt create mode 100644 src/kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcher.xml create mode 100644 src/kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcherConnection.xml create mode 100644 src/kitemviews/private/nepomuk/resourcewatcher.cpp rename src/kitemviews/private/{knepomukresourcewatcher.h => nepomuk/resourcewatcher.h} (85%) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 3a06d6093c..c00d29c209 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -77,7 +77,16 @@ if (Nepomuk_FOUND) set(dolphinprivate_LIB_SRCS ${dolphinprivate_LIB_SRCS} kitemviews/private/knepomukrolesprovider.cpp + kitemviews/private/nepomuk/resourcewatcher.cpp ) + + qt4_add_dbus_interface(dolphinprivate_LIB_SRCS + kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcherConnection.xml + resourcewatcherconnectioninterface) + + qt4_add_dbus_interface(dolphinprivate_LIB_SRCS + kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcher.xml + resourcewatchermanagerinterface) endif (Nepomuk_FOUND) kde4_add_kcfg_files(dolphinprivate_LIB_SRCS @@ -103,7 +112,6 @@ if (Nepomuk_FOUND) dolphinprivate ${NEPOMUK_LIBRARIES} ${NEPOMUK_QUERY_LIBRARIES} - nepomukdatamanagement nepomukutils ${SOPRANO_LIBRARIES} ) @@ -219,7 +227,6 @@ if (Nepomuk_FOUND) ${NEPOMUK_LIBRARIES} ${SOPRANO_LIBRARIES} ${NEPOMUK_QUERY_LIBRARIES} - nepomukdatamanagement nepomukutils ) endif (Nepomuk_FOUND) diff --git a/src/kitemviews/kfileitemmodelrolesupdater.cpp b/src/kitemviews/kfileitemmodelrolesupdater.cpp index 9e94d11918..a1773840d3 100644 --- a/src/kitemviews/kfileitemmodelrolesupdater.cpp +++ b/src/kitemviews/kfileitemmodelrolesupdater.cpp @@ -39,7 +39,7 @@ #ifdef HAVE_NEPOMUK #include "private/knepomukrolesprovider.h" - #include "private/knepomukresourcewatcher.h" + #include "private/nepomuk/resourcewatcher.h" #endif // Required includes for subItemsCount(): diff --git a/src/kitemviews/private/nepomuk/ReadMe.txt b/src/kitemviews/private/nepomuk/ReadMe.txt new file mode 100644 index 0000000000..c070f30908 --- /dev/null +++ b/src/kitemviews/private/nepomuk/ReadMe.txt @@ -0,0 +1,3 @@ +The files in this directory are a copy of kde-runtime/nepomuk. They +are updated manually until the Nepomuk resoure-watcher is made +public in a future release of the Nepomuk API. diff --git a/src/kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcher.xml b/src/kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcher.xml new file mode 100644 index 0000000000..7f414443b9 --- /dev/null +++ b/src/kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcher.xml @@ -0,0 +1,14 @@ + + + + + + + + + + + + + + diff --git a/src/kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcherConnection.xml b/src/kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcherConnection.xml new file mode 100644 index 0000000000..7848343a7d --- /dev/null +++ b/src/kitemviews/private/nepomuk/org.kde.nepomuk.ResourceWatcherConnection.xml @@ -0,0 +1,65 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/kitemviews/private/nepomuk/resourcewatcher.cpp b/src/kitemviews/private/nepomuk/resourcewatcher.cpp new file mode 100644 index 0000000000..2dcf567cae --- /dev/null +++ b/src/kitemviews/private/nepomuk/resourcewatcher.cpp @@ -0,0 +1,299 @@ +/* + This file is part of the Nepomuk KDE project. + Copyright (C) 2011 Vishesh Handa + Copyright (C) 2011-2012 Sebastian Trueg + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ + + +#include "resourcewatcher.h" +#include "resourcewatcherconnectioninterface.h" +#include "resourcewatchermanagerinterface.h" + +#include + +#include +#include + +#include +#include + +namespace { + QString convertUri(const QUrl& uri) { + return KUrl(uri).url(); + } + + QStringList convertUris(const QList& uris) { + QStringList cs; + foreach(const QUrl& uri, uris) { + cs << convertUri(uri); + } + return cs; + } + + QList convertUris(const QStringList& uris) { + QList us; + foreach(const QString& uri, uris) { + us << KUrl(uri); + } + return us; + } +} + +class Nepomuk::ResourceWatcher::Private { +public: + QList m_types; + QList m_resources; + QList m_properties; + + org::kde::nepomuk::ResourceWatcherConnection * m_connectionInterface; + org::kde::nepomuk::ResourceWatcher * m_watchManagerInterface; +}; + +Nepomuk::ResourceWatcher::ResourceWatcher(QObject* parent) + : QObject(parent), + d(new Private) +{ + d->m_watchManagerInterface + = new org::kde::nepomuk::ResourceWatcher( "org.kde.nepomuk.DataManagement", + "/resourcewatcher", + QDBusConnection::sessionBus() ); + d->m_connectionInterface = 0; +} + +Nepomuk::ResourceWatcher::~ResourceWatcher() +{ + stop(); + delete d; +} + +bool Nepomuk::ResourceWatcher::start() +{ + stop(); + + // + // Convert to list of strings + // + QList uris = convertUris(d->m_resources); + QList props = convertUris(d->m_properties); + QList types_ = convertUris(d->m_types); + + // + // Watch for the RW service to (re-)appear and then re-connect to make sure we always get updates + // We create this watcher even if we fail to connect below. Thus, once the rw service comes up we + // can re-attach. + // + connect(ResourceManager::instance(), SIGNAL(nepomukSystemStarted()), this, SLOT(start())); + + // + // Create the dbus object to watch + // + QDBusPendingReply reply = d->m_watchManagerInterface->watch( uris, props, types_ ); + QDBusObjectPath path = reply.value(); + + if(!path.path().isEmpty()) { + d->m_connectionInterface = new org::kde::nepomuk::ResourceWatcherConnection( "org.kde.nepomuk.DataManagement", + path.path(), + QDBusConnection::sessionBus() ); + connect( d->m_connectionInterface, SIGNAL(propertyAdded(QString,QString,QVariantList)), + this, SLOT(slotPropertyAdded(QString,QString,QVariantList)) ); + connect( d->m_connectionInterface, SIGNAL(propertyRemoved(QString,QString,QVariantList)), + this, SLOT(slotPropertyRemoved(QString,QString,QVariantList)) ); + connect( d->m_connectionInterface, SIGNAL(resourceCreated(QString,QStringList)), + this, SLOT(slotResourceCreated(QString,QStringList)) ); + connect( d->m_connectionInterface, SIGNAL(propertyChanged(QString,QString,QVariantList,QVariantList)), + this, SLOT(slotPropertyChanged(QString,QString,QVariantList,QVariantList)) ); + connect( d->m_connectionInterface, SIGNAL(resourceRemoved(QString,QStringList)), + this, SLOT(slotResourceRemoved(QString,QStringList)) ); + connect( d->m_connectionInterface, SIGNAL(resourceTypesAdded(QString,QStringList)), + this, SLOT(slotResourceTypesAdded(QString,QStringList)) ); + connect( d->m_connectionInterface, SIGNAL(resourceTypesRemoved(QString,QStringList)), + this, SLOT(slotResourceTypesRemoved(QString,QStringList)) ); + + kDebug() << "Successfully connected to watch service"; + return true; + } + else { + kDebug() << "Failed to connect to watch service" << reply.error().message(); + return false; + } +} + +void Nepomuk::ResourceWatcher::stop() +{ + if (d->m_connectionInterface) { + d->m_connectionInterface->close(); + delete d->m_connectionInterface; + d->m_connectionInterface = 0; + } + + disconnect(ResourceManager::instance(), SIGNAL(nepomukSystemStarted()), this, SLOT(start())); +} + +void Nepomuk::ResourceWatcher::addProperty(const Nepomuk::Types::Property& property) +{ + d->m_properties << property.uri(); + if(d->m_connectionInterface) { + d->m_connectionInterface->addProperty(convertUri(property.uri())); + } +} + +void Nepomuk::ResourceWatcher::addResource(const Nepomuk::Resource& res) +{ + d->m_resources << res.resourceUri(); + if(d->m_connectionInterface) { + d->m_connectionInterface->addResource(convertUri(res.resourceUri())); + } +} + +void Nepomuk::ResourceWatcher::addType(const Nepomuk::Types::Class& type) +{ + d->m_types << type.uri(); + if(d->m_connectionInterface) { + d->m_connectionInterface->addType(convertUri(type.uri())); + } +} + +void Nepomuk::ResourceWatcher::removeProperty(const Nepomuk::Types::Property& property) +{ + d->m_properties.removeAll(property.uri()); + if(d->m_connectionInterface) { + d->m_connectionInterface->removeProperty(convertUri(property.uri())); + } +} + +void Nepomuk::ResourceWatcher::removeResource(const Nepomuk::Resource& res) +{ + d->m_resources.removeAll(res.resourceUri()); + if(d->m_connectionInterface) { + d->m_connectionInterface->removeResource(convertUri(res.resourceUri())); + } +} + +void Nepomuk::ResourceWatcher::removeType(const Nepomuk::Types::Class& type) +{ + d->m_types.removeAll(type.uri()); + if(d->m_connectionInterface) { + d->m_connectionInterface->removeType(convertUri(type.uri())); + } +} + +QList< Nepomuk::Types::Property > Nepomuk::ResourceWatcher::properties() const +{ + QList< Nepomuk::Types::Property > props; + foreach(const QUrl& uri, d->m_properties) + props << Types::Property(uri); + return props; +} + +QList Nepomuk::ResourceWatcher::resources() const +{ + QList resources; + foreach(const QUrl& uri, d->m_resources) + resources << Resource::fromResourceUri(uri); + return resources; +} + +QList< Nepomuk::Types::Class > Nepomuk::ResourceWatcher::types() const +{ + QList types; + foreach(const QUrl& uri, d->m_types) + types << Types::Class(uri); + return types; +} + +void Nepomuk::ResourceWatcher::setProperties(const QList< Nepomuk::Types::Property >& properties_) +{ + d->m_properties.clear(); + foreach(const Nepomuk::Types::Property& p, properties_) { + d->m_properties << p.uri(); + } + + if(d->m_connectionInterface) { + d->m_connectionInterface->setProperties(convertUris(d->m_properties)); + } +} + +void Nepomuk::ResourceWatcher::setResources(const QList< Nepomuk::Resource >& resources_) +{ + d->m_resources.clear(); + foreach(const Nepomuk::Resource& res, resources_) { + d->m_resources << res.resourceUri(); + } + + if(d->m_connectionInterface) { + d->m_connectionInterface->setResources(convertUris(d->m_resources)); + } +} + +void Nepomuk::ResourceWatcher::setTypes(const QList< Nepomuk::Types::Class >& types_) +{ + d->m_types.clear(); + foreach(const Nepomuk::Types::Class& t, types_) { + d->m_types << t.uri(); + } + + if(d->m_connectionInterface) { + d->m_connectionInterface->setTypes(convertUris(d->m_types)); + } +} + +void Nepomuk::ResourceWatcher::slotResourceCreated(const QString &res, const QStringList &types) +{ + emit resourceCreated(Nepomuk::Resource::fromResourceUri(KUrl(res)), convertUris(types)); +} + +void Nepomuk::ResourceWatcher::slotResourceRemoved(const QString &res, const QStringList &types) +{ + emit resourceRemoved(KUrl(res), convertUris(types)); +} + +void Nepomuk::ResourceWatcher::slotResourceTypesAdded(const QString &res, const QStringList &types) +{ + foreach(const QString& type, types) { + emit resourceTypeAdded(KUrl(res), KUrl(type)); + } +} + +void Nepomuk::ResourceWatcher::slotResourceTypesRemoved(const QString &res, const QStringList &types) +{ + foreach(const QString& type, types) { + emit resourceTypeRemoved(KUrl(res), KUrl(type)); + } +} + +void Nepomuk::ResourceWatcher::slotPropertyAdded(const QString& res, const QString& prop, const QVariantList &objects) +{ + foreach(const QVariant& v, objects) { + emit propertyAdded( Resource::fromResourceUri(KUrl(res)), Types::Property( KUrl(prop) ), v ); + } +} + +void Nepomuk::ResourceWatcher::slotPropertyRemoved(const QString& res, const QString& prop, const QVariantList &objects) +{ + foreach(const QVariant& v, objects) { + emit propertyRemoved( Resource::fromResourceUri(KUrl(res)), Types::Property( KUrl(prop) ), v ); + } +} + +void Nepomuk::ResourceWatcher::slotPropertyChanged(const QString& res, const QString& prop, const QVariantList& oldObjs, const QVariantList& newObjs) +{ + emit propertyChanged( Resource::fromResourceUri(KUrl(res)), Types::Property( KUrl(prop) ), + oldObjs, newObjs ); +} + +#include "resourcewatcher.moc" + diff --git a/src/kitemviews/private/knepomukresourcewatcher.h b/src/kitemviews/private/nepomuk/resourcewatcher.h similarity index 85% rename from src/kitemviews/private/knepomukresourcewatcher.h rename to src/kitemviews/private/nepomuk/resourcewatcher.h index 3f6643fc8e..96a75ef94e 100644 --- a/src/kitemviews/private/knepomukresourcewatcher.h +++ b/src/kitemviews/private/nepomuk/resourcewatcher.h @@ -29,7 +29,7 @@ #include #include -#include "knepomukdatamanagement_export.h" +//#include "nepomukdatamanagement_export.h" namespace Nepomuk { @@ -77,7 +77,7 @@ namespace Nepomuk { * * \ingroup nepomuk_datamanagement */ - class NEPOMUK_DATA_MANAGEMENT_EXPORT ResourceWatcher : public QObject + class ResourceWatcher : public QObject { Q_OBJECT @@ -95,6 +95,7 @@ namespace Nepomuk { */ virtual ~ResourceWatcher(); + public Q_SLOTS: /** * \brief Add a type to be watched. * @@ -124,6 +125,35 @@ namespace Nepomuk { */ void addProperty( const Types::Property & property ); + /** + * \brief Remove a type to be watched. + * + * Every resource of this type will be watched for changes. + * + * \sa setTypes() + */ + void removeType( const Types::Class & type ); + + /** + * \brief Remove a resource to be watched. + * + * Every change to this resource will be + * signalled, depending on the configured properties(). + * + * \sa setResources() + */ + void removeResource( const Nepomuk::Resource & res ); + + /** + * \brief Remove a property to be watched. + * + * Every change to a value of this property + * will be signalled, depending on the configured resources() or types(). + * + * \sa setProperties() + */ + void removeProperty( const Types::Property & property ); + /** * \brief Set the types to be watched. * @@ -177,7 +207,6 @@ namespace Nepomuk { */ QList properties() const; - public Q_SLOTS: /** * \brief Start the signalling of changes. * @@ -218,7 +247,7 @@ namespace Nepomuk { * \param res The changed resource. * \param type The newly added type. If types() have been configured it will be one of them. */ - void resourceTypeAdded( const Nepomuk::Resource & res, const Types::Class & type ); + void resourceTypeAdded( const Nepomuk::Resource & res, const Nepomuk::Types::Class & type ); /** * \brief This signal is emitted when a type has been removed from a resource. @@ -228,7 +257,7 @@ namespace Nepomuk { * \param res The changed resource. * \param type The removed type. If types() have been configured it will be one of them. */ - void resourceTypeRemoved( const Nepomuk::Resource & res, const Types::Class & type ); + void resourceTypeRemoved( const Nepomuk::Resource & res, const Nepomuk::Types::Class & type ); /** * \brief This signal is emitted when a property value is added. @@ -253,29 +282,31 @@ namespace Nepomuk { /** * \brief This signal is emitted when a property value is changed. * - * This signal cannot be emitted for all changes. It doesn't work if a property is first - * removed and then set, cause the Data Mangement Service does not maintain an internal - * cache for the purpose of emitting the propertyChanged signal. + * This signal is essentially a combination of the propertyAdded and propertyRemoved signals. + * + * Be aware that removing and then adding a property will result in two separate + * propertyChanged signals. They are never combined. * * Specially, since one could theoretically take forever between the removal and the * setting of the property. * * \param resource The changed resource. * \param property The property which was changed. - * \param oldValue The removed property value. + * \param addedValues The values that have been added. + * \param removedValues The values that have been removed. */ void propertyChanged( const Nepomuk::Resource & resource, const Nepomuk::Types::Property & property, - const QVariantList & oldValue, - const QVariantList & newValue ); + const QVariantList & addedValues, + const QVariantList & removedValues ); private Q_SLOTS: void slotResourceCreated(const QString& res, const QStringList& types); void slotResourceRemoved(const QString& res, const QStringList& types); - void slotResourceTypeAdded(const QString& res, const QString& type); - void slotResourceTypeRemoved(const QString& res, const QString& type); - void slotPropertyAdded(const QString& res, const QString& prop, const QDBusVariant& object); - void slotPropertyRemoved(const QString& res, const QString& prop, const QDBusVariant& object); + void slotResourceTypesAdded(const QString& res, const QStringList& types); + void slotResourceTypesRemoved(const QString& res, const QStringList& types); + void slotPropertyAdded(const QString& res, const QString& prop, const QVariantList& objects); + void slotPropertyRemoved(const QString& res, const QString& prop, const QVariantList& objects); void slotPropertyChanged(const QString& res, const QString& prop, const QVariantList & oldObjs, const QVariantList & newObjs);