From 4c4b013b89b05fb6bb750fa7ea4c2936b14d0700 Mon Sep 17 00:00:00 2001 From: "Aaron J. Seigo" Date: Sat, 19 May 2007 08:38:46 +0000 Subject: [PATCH] * implement the engine, source and visualization classes * queue updates so that multiple calls to setData don't result in a storm of updated signals * some API cleanups, e.g. connect -> connectSource * provide and install a ServiceType .desktop; this adds the X-EngineName QString symbol. maybe that's too generic. svn path=/trunk/KDE/kdebase/workspace/plasma/lib/; revision=666241 --- CMakeLists.txt | 2 + dataengine.cpp | 175 +++++++++++++++++++++++++++++--------- dataengine.h | 31 ++++--- datavisualization.h | 4 +- plasma_dataengine.desktop | 10 +++ 5 files changed, 170 insertions(+), 52 deletions(-) create mode 100644 plasma_dataengine.desktop diff --git a/CMakeLists.txt b/CMakeLists.txt index e0de0b32c..bb55aabe5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -55,3 +55,5 @@ install( FILES includes/Svg DESTINATION ${INCLUDE_INSTALL_DIR}/KDE/Plasma ) +install( FILES plasma_dataengine.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} ) + diff --git a/dataengine.cpp b/dataengine.cpp index c468f7401..061ad207d 100644 --- a/dataengine.cpp +++ b/dataengine.cpp @@ -16,25 +16,33 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#include +#include #include -#include "dataengine.h" -#include "dataengine.moc" +#include -using namespace Plasma; +#include "dataengine.h" +#include "datavisualization.h" + +namespace Plasma +{ class DataSource::Private { public: - Private() {} - ~Private() {} + Private() + : dirty(false) + {} + + QString name; + Data data; + bool dirty; }; DataSource::DataSource(QObject* parent) - : QObject(parent) + : QObject(parent), + d(new Private()) { - d = new Private(); } DataSource::~DataSource() @@ -44,98 +52,189 @@ DataSource::~DataSource() QString DataSource::name() { - kDebug() << k_funcinfo << " not implemented"; - return QString(); + return objectName(); } +void DataSource::setName(const QString& name) +{ + setObjectName(name); +} +const Plasma::DataSource::Data DataSource::data() const +{ + return d->data; +} +void DataSource::setData(const QString& key, const QVariant& value) +{ + d->data[key] = value; + d->dirty = true; +} +void DataSource::checkForUpdate() +{ + if (d->dirty) { + emit updated(d->data); + d->dirty = false; + } +} + +class DataEngine::Private +{ + public: + Private(DataEngine* e) + : engine(e) + { + updateTimer = new QTimer(engine); + updateTimer->setSingleShot(true); + } + + DataSource* source(const QString& sourceName) + { + DataSource::Dict::const_iterator it = sources.find(sourceName); + if (it != sources.constEnd()) { + return it.value(); + } + + kDebug() << "DataEngine " << engine->objectName() + << ": could not find DataSource " << sourceName + << ", creating" << endl; + DataSource* s = new DataSource(engine); + s->setName(sourceName); + sources.insert(sourceName, s); + return s; + } + + void queueUpdate() + { + if (updateTimer->isActive()) { + return; + } + updateTimer->start(0); + } + + QAtomic ref; + DataSource::Dict sources; + DataEngine* engine; + QTimer* updateTimer; +}; DataEngine::DataEngine(QObject* parent) - : QObject(parent) + : QObject(parent), + d(new Private(this)) { + connect(d->updateTimer, SIGNAL(timeout()), this, SLOT(checkForUpdates())); + //FIXME: should we try and delay this call? + init(); } DataEngine::~DataEngine() { + delete d; } QStringList DataEngine::dataSources() { - kDebug() << k_funcinfo << " not implemented"; - return QStringList(); + return d->sources.keys(); } -void DataEngine::connect(const QString& source, DataVisualization* visualization) +void DataEngine::connectSource(const QString& source, DataVisualization* visualization) { Q_UNUSED(source) Q_UNUSED(visualization) - kDebug() << k_funcinfo << " not implemented"; + DataSource* s = d->source(source); +// if (!s) { +// kDebug() << "DataEngine " << objectName() << ": could not find DataSource " << source << endl; +// return; +// } + + connect(s, SIGNAL(updated(Plasma::DataSource::Data)), + visualization, SLOT(updated(Plasma::DataSource::Data))); } DataSource::Data DataEngine::query(const QString& source) { Q_UNUSED(source) - kDebug() << k_funcinfo << " not implemented"; - return DataSource::Data(); + DataSource* s = d->source(source); + return s->data(); } void DataEngine::init() { - kDebug() << k_funcinfo << " not implemented"; + // default implementation does nothing. this is for engines that have to + // start things in motion external to themselves before they can work } -void DataEngine::cleanup() +void DataEngine::setData(const QString& source, const QVariant& value) { - kDebug() << k_funcinfo << " not implemented"; + setData(source, source, value); } -void DataEngine::setDataSource(const QString& source, const QVariant& value) +void DataEngine::setData(const QString& source, const QString& key, const QVariant& value) { - Q_UNUSED(source) - Q_UNUSED(value) - - kDebug() << k_funcinfo << " not implemented"; + DataSource* s = d->source(source); + s->setData(key, value); + d->queueUpdate(); } -void DataEngine::createDataSource(const QString& source, const QString& domain) +/* +Plasma::DataSource* DataEngine::createDataSource(const QString& source, const QString& domain) { - Q_UNUSED(source) Q_UNUSED(domain) - - kDebug() << k_funcinfo << " not implemented"; -} + //TODO: add support for domains of sources + + if (d->source(source)) { + kDebug() << "DataEngine " << objectName() << ": source " << source << " already exists " << endl; + return s + } +}*/ void DataEngine::removeDataSource(const QString& source) { - Q_UNUSED(source) - - kDebug() << k_funcinfo << " not implemented"; + DataSource::Dict::iterator it = d->sources.find(source); + if (it != d->sources.end()) { + d->sources.erase(it); + } } void DataEngine::clearAllDataSources() { - kDebug() << k_funcinfo << " not implemented"; + QMutableHashIterator it(d->sources); + while (it.hasNext()) { + it.next(); + delete it.value(); + it.remove(); + } } void DataEngine::ref() { - kDebug() << k_funcinfo << " not implemented"; + d->ref.ref(); } void DataEngine::deref() { - kDebug() << k_funcinfo << " not implemented"; + d->ref.deref(); } bool DataEngine::isUsed() { - kDebug() << k_funcinfo << " not implemented"; - return false; + return d->ref != 0; } +void DataEngine::checkForUpdates() +{ + QHashIterator it(d->sources); + while (it.hasNext()) { + it.next(); + it.value()->checkForUpdate(); + } +} + +} + +#include "dataengine.moc" diff --git a/dataengine.h b/dataengine.h index ee3024186..17e4171f9 100644 --- a/dataengine.h +++ b/dataengine.h @@ -45,13 +45,18 @@ class KDE_EXPORT DataSource : public QObject virtual ~DataSource(); QString name(); + void setName(const QString&); + const Data data() const; + void setData(const QString& key, const QVariant& value); + + void checkForUpdate(); Q_SIGNALS: - void data(const DataSource::Data&); + void updated(const Plasma::DataSource::Data&); private: class Private; - Private* d; + Private* const d; }; class KDE_EXPORT DataEngine : public QObject @@ -65,7 +70,7 @@ class KDE_EXPORT DataEngine : public QObject virtual ~DataEngine(); virtual QStringList dataSources(); - void connect(const QString& source, DataVisualization* visualization); + void connectSource(const QString& source, DataVisualization* visualization); DataSource::Data query(const QString& source); void ref(); @@ -74,25 +79,27 @@ class KDE_EXPORT DataEngine : public QObject protected: virtual void init(); - virtual void cleanup(); - void setDataSource(const QString& source, const QVariant& value); - void createDataSource(const QString& source, - const QString& domain = QString()); + void setData(const QString& source, const QVariant& value); + void setData(const QString& source, const QString& key, const QVariant& value); +/* void createDataSource(const QString& source, + const QString& domain = QString());*/ void removeDataSource(const QString& source); void clearAllDataSources(); + protected slots: + void checkForUpdates(); + private: - QAtomic m_ref; class Private; - Private* d; + Private* const d; }; } // Plasma namespace -#define K_EXPORT_PLASMA_ENGINE(libname, classname) \ +#define K_EXPORT_PLASMA_DATAENGINE(libname, classname) \ K_EXPORT_COMPONENT_FACTORY( \ - plasmaengine_##libname, \ - KGenericFactory("libplasmaengine_" #libname)) + plasma_##libname##_engine, \ + KGenericFactory("plasma_" #libname "_engine")) #endif // multiple inclusion guard diff --git a/datavisualization.h b/datavisualization.h index 8acee0b5e..d0ead42b0 100644 --- a/datavisualization.h +++ b/datavisualization.h @@ -29,13 +29,13 @@ namespace Plasma // this will end up being multiple-inherited? class KDE_EXPORT DataVisualization : public QObject { - Q_OBJECT + Q_OBJECT public: DataVisualization(QObject* parent = 0); virtual ~DataVisualization(); public Q_SLOTS: - virtual void data(const DataSource::Data&) = 0; + virtual void updated(const Plasma::DataSource::Data&) = 0; private: class Private; diff --git a/plasma_dataengine.desktop b/plasma_dataengine.desktop new file mode 100644 index 000000000..dae976fa5 --- /dev/null +++ b/plasma_dataengine.desktop @@ -0,0 +1,10 @@ +[Desktop Entry] +Encoding=UTF-8 +Type=ServiceType +X-KDE-ServiceType=Plasma/DataEngine + +Comment=Plasma Data Engine + +[PropertyDef::X-EngineName] +Type=QString +