From e850a938713e2c5db34feda976ef89d28f3affe7 Mon Sep 17 00:00:00 2001 From: Chani Armitage Date: Thu, 24 Apr 2008 02:21:22 +0000 Subject: [PATCH] dataengine api review: %s/UpdateInterval/PollingInterval/g svn path=/trunk/KDE/kdebase/workspace/libs/plasma/; revision=800376 --- datacontainer.cpp | 10 +++---- datacontainer.h | 4 +-- datacontainer_p.h | 12 ++++---- dataengine.cpp | 52 +++++++++++++++++----------------- dataengine.h | 26 ++++++++--------- scripting/dataenginescript.cpp | 12 ++++---- scripting/dataenginescript.h | 6 ++-- 7 files changed, 61 insertions(+), 61 deletions(-) diff --git a/datacontainer.cpp b/datacontainer.cpp index a50153d73..578a79164 100644 --- a/datacontainer.cpp +++ b/datacontainer.cpp @@ -113,9 +113,9 @@ void DataContainer::checkUsage() } } -void DataContainer::connectVisualization(QObject* visualization, uint updateInterval, Plasma::IntervalAlignment alignment) +void DataContainer::connectVisualization(QObject* visualization, uint pollingInterval, Plasma::IntervalAlignment alignment) { - //kDebug() << "connecting visualization" << visualization << "at interval of" << updateInterval; + //kDebug() << "connecting visualization" << visualization << "at interval of" << pollingInterval; QMap::iterator objIt = d->relayObjects.find(visualization); bool connected = objIt != d->relayObjects.end(); if (connected) { @@ -135,7 +135,7 @@ void DataContainer::connectVisualization(QObject* visualization, uint updateInte visualization, SLOT(dataUpdated(QString,Plasma::DataEngine::Data))); //relay->isUnused(); } - } else if (updateInterval < 1) { + } else if (pollingInterval < 1) { // the visualization was connected already, but not to a relay // and it still doesn't want to connect to a relay, so we have // nothing to do! @@ -151,14 +151,14 @@ void DataContainer::connectVisualization(QObject* visualization, uint updateInte } - if (updateInterval < 1) { + if (pollingInterval < 1) { // kDebug() << " connecting directly"; d->relayObjects[visualization] = 0; connect(this, SIGNAL(dataUpdated(QString,Plasma::DataEngine::Data)), visualization, SLOT(dataUpdated(QString,Plasma::DataEngine::Data))); } else { // kDebug() << " connecting to a relay"; - SignalRelay *relay = d->signalRelay(this, visualization, updateInterval, alignment); + SignalRelay *relay = d->signalRelay(this, visualization, pollingInterval, alignment); connect(relay, SIGNAL(dataUpdated(QString,Plasma::DataEngine::Data)), visualization, SLOT(dataUpdated(QString,Plasma::DataEngine::Data))); } diff --git a/datacontainer.h b/datacontainer.h index 8340daf56..8a308014f 100644 --- a/datacontainer.h +++ b/datacontainer.h @@ -114,9 +114,9 @@ class PLASMA_EXPORT DataContainer : public QObject * for the same visualization without side effects * * @param visualization the object to connect to this DataContainer - * @param updateInterval the time in milliseconds between updates + * @param pollingInterval the time in milliseconds between updates **/ - void connectVisualization(QObject* visualization, uint updateInterval, Plasma::IntervalAlignment alignment); + void connectVisualization(QObject* visualization, uint pollingInterval, Plasma::IntervalAlignment alignment); /** * Disconnects an object from this DataContainer. diff --git a/datacontainer_p.h b/datacontainer_p.h index 4d231e3d7..dedca3ade 100644 --- a/datacontainer_p.h +++ b/datacontainer_p.h @@ -36,7 +36,7 @@ public: {} SignalRelay* signalRelay(const DataContainer* dc, QObject *visualization, - uint updateInterval, Plasma::IntervalAlignment align); + uint pollingInterval, Plasma::IntervalAlignment align); DataEngine::Data data; QMap relayObjects; @@ -111,7 +111,7 @@ public: // constant queueing due to more-or-less constant time // async update time? this might make sense for // staggered accesses to the same source by multiple - // visualizations causing a minimumUpdateInterval violation. + // visualizations causing a minimumPollingInterval violation. // it may not make sense for purely async-and-takes-a-while // type operations (e.g. network fetching). // we need more real world data before making such a change @@ -158,15 +158,15 @@ protected: } }; -SignalRelay* DataContainer::Private::signalRelay(const DataContainer* dc, QObject *visualization, uint updateInterval, Plasma::IntervalAlignment align) +SignalRelay* DataContainer::Private::signalRelay(const DataContainer* dc, QObject *visualization, uint pollingInterval, Plasma::IntervalAlignment align) { - QMap::const_iterator relayIt = relays.find(updateInterval); + QMap::const_iterator relayIt = relays.find(pollingInterval); SignalRelay *relay = 0; //FIXME what if we have two applets with the same interval and different alignment? if (relayIt == relays.end()) { - relay = new SignalRelay(const_cast(dc), this, updateInterval, align); - relays[updateInterval] = relay; + relay = new SignalRelay(const_cast(dc), this, pollingInterval, align); + relays[pollingInterval] = relay; } else { relay = relayIt.value(); } diff --git a/dataengine.cpp b/dataengine.cpp index 85e6ba731..2a8e646a0 100644 --- a/dataengine.cpp +++ b/dataengine.cpp @@ -44,7 +44,7 @@ class DataEngine::Private : engine(e), ref(-1), // first ref updateTimerId(0), - minUpdateInterval(-1), + minPollingInterval(-1), limit(0), valid(true), script(0), @@ -125,20 +125,20 @@ class DataEngine::Private return s; } - void connectSource(DataContainer* s, QObject* visualization, uint updateInterval, + void connectSource(DataContainer* s, QObject* visualization, uint pollingInterval, Plasma::IntervalAlignment align, bool immediateCall = true) { - //kDebug() << "connect source called with interval" << updateInterval; - if (updateInterval > 0) { + //kDebug() << "connect source called with interval" << pollingInterval; + if (pollingInterval > 0) { // never more frequently than allowed, never more than 20 times per second - uint min = qMax(50, minUpdateInterval); // for qMin below - updateInterval = qMax(min, updateInterval); + uint min = qMax(50, minPollingInterval); // for qMin below + pollingInterval = qMax(min, pollingInterval); // align on the 50ms - updateInterval = updateInterval - (updateInterval % 50); + pollingInterval = pollingInterval - (pollingInterval % 50); } - s->connectVisualization(visualization, updateInterval, align); + s->connectVisualization(visualization, pollingInterval, align); if (immediateCall) { QMetaObject::invokeMethod(visualization, "dataUpdated", @@ -197,7 +197,7 @@ class DataEngine::Private DataEngine* engine; int ref; int updateTimerId; - int minUpdateInterval; + int minPollingInterval; QTime updateTimestamp; DataEngine::SourceDict sources; QQueue sourceQueue; @@ -237,7 +237,7 @@ QStringList DataEngine::sources() const } void DataEngine::connectSource(const QString& source, QObject* visualization, - uint updateInterval, Plasma::IntervalAlignment intervalAlignment) const + uint pollingInterval, Plasma::IntervalAlignment intervalAlignment) const { //kDebug() << "connectSource" << source; bool newSource; @@ -247,16 +247,16 @@ void DataEngine::connectSource(const QString& source, QObject* visualization, // we suppress the immediate invocation of dataUpdated here if the source was prexisting and they // don't request delayed updates (we want to do an immediate update in that case so they // don't have to wait for the first time out) - d->connectSource(s, visualization, updateInterval, intervalAlignment, !newSource || updateInterval > 0); + d->connectSource(s, visualization, pollingInterval, intervalAlignment, !newSource || pollingInterval > 0); //kDebug() << " ==> source connected"; } } -void DataEngine::connectAllSources(QObject* visualization, uint updateInterval, +void DataEngine::connectAllSources(QObject* visualization, uint pollingInterval, Plasma::IntervalAlignment intervalAlignment) const { foreach (DataContainer* s, d->sources) { - d->connectSource(s, visualization, updateInterval, intervalAlignment); + d->connectSource(s, visualization, pollingInterval, intervalAlignment); } } @@ -289,10 +289,10 @@ DataEngine::Data DataEngine::query(const QString& source) const void DataEngine::internalUpdateSource(DataContainer* source) { - if (d->minUpdateInterval > 0 && - source->timeSinceLastUpdate() < d->minUpdateInterval) { + if (d->minPollingInterval > 0 && + source->timeSinceLastUpdate() < d->minPollingInterval) { // skip updating this source; it's been too soon - //kDebug() << "internal update source is delaying" << source->timeSinceLastUpdate() << d->minUpdateInterval; + //kDebug() << "internal update source is delaying" << source->timeSinceLastUpdate() << d->minPollingInterval; //but fake an update so that the signalrelay that triggered this gets the data from the //recent update. this way we don't have to worry about queuing - the relay will send a //signal immediately and everyone else is undisturbed. @@ -426,17 +426,17 @@ void DataEngine::setSourceLimit(uint limit) } } -void DataEngine::setMinimumUpdateInterval(int minimumMs) +void DataEngine::setMinimumPollingInterval(int minimumMs) { - d->minUpdateInterval = minimumMs; + d->minPollingInterval = minimumMs; } -int DataEngine::minimumUpdateInterval() const +int DataEngine::minimumPollingInterval() const { - return d->minUpdateInterval; + return d->minPollingInterval; } -void DataEngine::setUpdateInterval(uint frequency) +void DataEngine::setPollingInterval(uint frequency) { killTimer(d->updateTimerId); d->updateTimerId = 0; @@ -451,9 +451,9 @@ NOTE: This is not implemented to prevent having to store the value internally. When there is a good use case for needing access to this value, we can add another member to the Private class and add this method. -void DataEngine::updateInterval() +void DataEngine::pollingInterval() { - return d->updateInterval; + return d->pollingInterval; } */ @@ -537,12 +537,12 @@ void DataEngine::timerEvent(QTimerEvent *event) event->accept(); // if the freq update is less than 0, don't bother - if (d->minUpdateInterval < 0) { + if (d->minPollingInterval < 0) { return; } - // minUpdateInterval - if (d->updateTimestamp.elapsed() < d->minUpdateInterval) { + // minPollingInterval + if (d->updateTimestamp.elapsed() < d->minPollingInterval) { return; } diff --git a/dataengine.h b/dataengine.h index 0dcdb3fa3..2a123fb05 100644 --- a/dataengine.h +++ b/dataengine.h @@ -109,7 +109,7 @@ class PLASMA_EXPORT DataEngine : public QObject * * @param source the name of the data source * @param visualization the object to connect the data source to - * @param updateInterval the frequency, in milliseconds, with which to check for updates; + * @param pollingInterval the frequency, in milliseconds, with which to check for updates; * a value of 0 (the default) means to update only * when there is new data spontaneously generated * (e.g. by the engine); any other value results in @@ -120,7 +120,7 @@ class PLASMA_EXPORT DataEngine : public QObject * @param intervalAlignment the number of ms to align the interval to **/ Q_INVOKABLE void connectSource(const QString& source, QObject* visualization, - uint updateInterval = 0, + uint pollingInterval = 0, Plasma::IntervalAlignment intervalAlignment = NoAlignment) const; /** @@ -133,14 +133,14 @@ class PLASMA_EXPORT DataEngine : public QObject * one data source to provide sets of related data. * * This method may be called multiple times for the same visualization - * without side-effects. This can be useful to change the updateInterval. + * without side-effects. This can be useful to change the pollingInterval. * * Note that this method does not automatically connect sources that * may appear later on. Connecting and responding to the sourceAdded sigal * is still required to achieve that. * * @param visualization the object to connect the data source to - * @param updateInterval the frequency, in milliseconds, with which to check for updates; + * @param pollingInterval the frequency, in milliseconds, with which to check for updates; * a value of 0 (the default) means to update only * when there is new data spontaneously generated * (e.g. by the engine); any other value results in @@ -150,7 +150,7 @@ class PLASMA_EXPORT DataEngine : public QObject * If the data has not changed, no update will be sent. * @param intervalAlignment the number of ms to align the interval to **/ - Q_INVOKABLE void connectAllSources(QObject* visualization, uint updateInterval = 0, + Q_INVOKABLE void connectAllSources(QObject* visualization, uint pollingInterval = 0, Plasma::IntervalAlignment intervalAlignment = NoAlignment) const; /** @@ -253,8 +253,8 @@ class PLASMA_EXPORT DataEngine : public QObject /** * Called by internal updating mechanisms to trigger the engine * to refresh the data contained in a given source. Reimplement this - * method when using facilities such as setUpdateInterval. - * @see setUpdateInterval + * method when using facilities such as setPollingInterval. + * @see setPollingInterval * * @param source the name of the source that should be updated * @return true if the data was changed, or false if there was no @@ -332,12 +332,12 @@ class PLASMA_EXPORT DataEngine : public QObject * a value of 0 means update immediately on every update request, * a value >0 will result in a minimum time lapse being enforced. **/ - void setMinimumUpdateInterval(int minimumMs); + void setMinimumPollingInterval(int minimumMs); /** - * @return the minimum time between updates. @see setMinimumupdateInterval + * @return the minimum time between updates. @see setMinimumPollingInterval **/ - int minimumUpdateInterval() const; + int minimumPollingInterval() const; /** * Sets up an internal update tick for all data sources. On every update, @@ -347,15 +347,15 @@ class PLASMA_EXPORT DataEngine : public QObject * @param frequency the time, in milliseconds, between updates. A value of 0 * will stop internally triggered updates. **/ - void setUpdateInterval(uint frequency); + void setPollingInterval(uint frequency); /** * Returns the current update frequency. - * @see setUpdateInterval + * @see setPollingInterval NOTE: This is not implemented to prevent having to store the value internally. When there is a good use case for needing access to this value, we can add another member to the Private class and add this method. - uint updateInterval(); + uint pollingInterval(); **/ /** diff --git a/scripting/dataenginescript.cpp b/scripting/dataenginescript.cpp index 68c220b9a..b22ec94ba 100644 --- a/scripting/dataenginescript.cpp +++ b/scripting/dataenginescript.cpp @@ -99,25 +99,25 @@ void DataEngineScript::setSourceLimit(uint limit) } } -void DataEngineScript::setMinimumUpdateInterval(int minimumMs) +void DataEngineScript::setMinimumPollingInterval(int minimumMs) { if (d->dataEngine) { - d->dataEngine->setMinimumUpdateInterval(minimumMs); + d->dataEngine->setMinimumPollingInterval(minimumMs); } } -int DataEngineScript::minimumUpdateInterval() const +int DataEngineScript::minimumPollingInterval() const { if (d->dataEngine) { - return d->dataEngine->minimumUpdateInterval(); + return d->dataEngine->minimumPollingInterval(); } return 0; } -void DataEngineScript::setUpdateInterval(uint frequency) +void DataEngineScript::setPollingInterval(uint frequency) { if (d->dataEngine) { - d->dataEngine->setUpdateInterval(frequency); + d->dataEngine->setPollingInterval(frequency); } } diff --git a/scripting/dataenginescript.h b/scripting/dataenginescript.h index 5d4dba102..4d42bd4af 100644 --- a/scripting/dataenginescript.h +++ b/scripting/dataenginescript.h @@ -81,9 +81,9 @@ protected: void clearData(const QString& source); void removeData(const QString& source, const QString& key); void setSourceLimit(uint limit); - void setMinimumUpdateInterval(int minimumMs); - int minimumUpdateInterval() const; - void setUpdateInterval(uint frequency); + void setMinimumPollingInterval(int minimumMs); + int minimumPollingInterval() const; + void setPollingInterval(uint frequency); void clearSources(); private: