plasma/abstractrunner.cpp

   1 /*
   2  *   Copyright 2006-2007 Aaron Seigo <aseigo@kde.org>
   3  *
   4  *   This program is free software; you can redistribute it and/or modify
   5  *   it under the terms of the GNU Library General Public License as
   6  *   published by the Free Software Foundation; either version 2, or
   7  *   (at your option) any later version.
   8  *
   9  *   This program is distributed in the hope that it will be useful,
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *   GNU General Public License for more details
  13  *
  14  *   You should have received a copy of the GNU Library General Public
  15  *   License along with this program; if not, write to the
  16  *   Free Software Foundation, Inc.,
  17  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "abstractrunner.h"
  21
  22 #include <QAction>
  23 #include <QHash>
  24 #include <QMutex>
  25 #include <QMutexLocker>
  26 #include <QTimer>
  27
  28 #include <kdebug.h>
  29 #include <kplugininfo.h>
  30 #include <kservicetypetrader.h>
  31 #include <kstandarddirs.h>
  32
  33 #include <plasma/querymatch.h>
  34 #include <plasma/package.h>
  35
  36 #include "scripting/runnerscript.h"
  37
  38 #include "runnercontext.h"
  39
  40 namespace Plasma
  41 {
  42
  43 class AbstractRunnerPrivate
  44 {
  45 public:
  46     AbstractRunnerPrivate(AbstractRunner *r, KService::Ptr service)
  47       : priority(AbstractRunner::NormalPriority),
  48         speed(AbstractRunner::NormalSpeed),
  49         blackListed(0),
  50         script(0),
  51         runnerDescription(service),
  52         runner(r),
  53         fastRuns(0),
  54         package(0)
  55     {
  56         if (runnerDescription.isValid()) {
  57             const QString api = runnerDescription.property("X-Plasma-API").toString();
  58             if (!api.isEmpty()) {
  59                 const QString path = KStandardDirs::locate("data",
  60                                     "plasma/runners/" + runnerDescription.pluginName() + '/');
  61                 PackageStructure::Ptr structure =
  62                     Plasma::packageStructure(api, Plasma::RunnerComponent);
  63                 structure->setPath(path);
  64                 package = new Package(path, structure);
  65
  66                 script = Plasma::loadScriptEngine(api, runner);
  67                 if (!script) {
  68                     kDebug() << "Could not create a(n)" << api << "ScriptEngine for the"
  69                              << runnerDescription.name() << "Runner.";
  70                     delete package;
  71                     package = 0;
  72                 } else {
  73                     QTimer::singleShot(0, runner, SLOT(init()));
  74                 }
  75             }
  76         }
  77     }
  78
  79     ~AbstractRunnerPrivate()
  80     {
  81         delete script;
  82         script = 0;
  83         delete package;
  84         package = 0;
  85     }
  86
  87     bool hasRunOptions;
  88     bool hasConfig;
  89     AbstractRunner::Priority priority;
  90     AbstractRunner::Speed speed;
  91     RunnerContext::Types blackListed;
  92     RunnerScript *script;
  93     KPluginInfo runnerDescription;
  94     AbstractRunner *runner;
  95     QTime runtime;
  96     int fastRuns;
  97     Package *package;
  98     QHash<QString, QAction*> actions;
  99 };
 100
 101 K_GLOBAL_STATIC(QMutex, s_bigLock)
 102
 103 AbstractRunner::AbstractRunner(QObject *parent, const QString &serviceId)
 104     : QObject(parent),
 105     d(new AbstractRunnerPrivate(this, KService::serviceByStorageId(serviceId)))
 106 {
 107 }
 108
 109 AbstractRunner::AbstractRunner(QObject *parent, const QVariantList &args)
 110     : QObject(parent),
 111       d(new AbstractRunnerPrivate(this, KService::serviceByStorageId(args.count() > 0 ? args[0].toString() : QString())))
 112 {
 113 }
 114
 115 AbstractRunner::~AbstractRunner()
 116 {
 117     delete d;
 118 }
 119
 120 KConfigGroup AbstractRunner::config() const
 121 {
 122     QString group = objectName();
 123     if (group.isEmpty()) {
 124         group = "UnnamedRunner";
 125     }
 126
 127     KConfigGroup runners(KGlobal::config(), "Runners");
 128     return KConfigGroup(&runners, group);
 129 }
 130
 131 void AbstractRunner::reloadConfiguration()
 132 {
 133 }
 134
 135 void AbstractRunner::performMatch(Plasma::RunnerContext &localContext)
 136 {
 137     static const int reasonableRunTime = 1500;
 138     static const int fastEnoughTime = 250;
 139
 140     d->runtime.restart();
 141
 142     //The local copy is already obtained in the job
 143     match(localContext);
 144
 145     // automatically rate limit runners that become slooow
 146     const int runtime = d->runtime.elapsed();
 147     bool slowed = speed() == SlowSpeed;
 148
 149     if (!slowed && runtime > reasonableRunTime) {
 150         // we punish runners that return too slowly, even if they don't bring
 151         // back matches
 152         kDebug() << id() << "runner is too slow, putting it on the back burner.";
 153         d->fastRuns = 0;
 154         setSpeed(SlowSpeed);
 155     }
 156
 157     if (slowed && runtime < fastEnoughTime && localContext.query().size() > 2) {
 158         ++d->fastRuns;
 159
 160         if (d->fastRuns > 2) {
 161             // we reward slowed runners who bring back matches fast enough
 162             // 3 times in a row
 163             kDebug() << id() << "runner is faster than we thought, kicking it up a notch";
 164             setSpeed(NormalSpeed);
 165         }
 166     }
 167 }
 168
 169 QList<QAction*> AbstractRunner::actionsForMatch(const Plasma::QueryMatch &match)
 170 {
 171     Q_UNUSED(match)
 172     QList<QAction*> ret;
 173     return ret;
 174 }
 175
 176 QAction* AbstractRunner::addAction(const QString &id, const QIcon &icon, const QString &text)
 177 {
 178     QAction *a = new QAction(icon, text, this);
 179     d->actions.insert(id, a);
 180     return a;
 181 }
 182
 183 void AbstractRunner::addAction(const QString &id, QAction *action)
 184 {
 185     d->actions.insert(id, action);
 186 }
 187
 188 void AbstractRunner::removeAction(const QString &id)
 189 {
 190     QAction *a = d->actions.take(id);
 191     delete a;
 192 }
 193
 194 QAction* AbstractRunner::action(const QString &id) const
 195 {
 196     return d->actions.value(id);
 197 }
 198
 199 QHash<QString, QAction*> AbstractRunner::actions() const
 200 {
 201     return d->actions;
 202 }
 203
 204 void AbstractRunner::clearActions()
 205 {
 206     qDeleteAll(d->actions);
 207     d->actions.clear();
 208 }
 209
 210 bool AbstractRunner::hasRunOptions()
 211 {
 212     return d->hasRunOptions;
 213 }
 214
 215 void AbstractRunner::setHasRunOptions(bool hasRunOptions)
 216 {
 217     d->hasRunOptions = hasRunOptions;
 218 }
 219
 220 void AbstractRunner::createRunOptions(QWidget *parent)
 221 {
 222     Q_UNUSED(parent)
 223 }
 224
 225 AbstractRunner::Speed AbstractRunner::speed() const
 226 {
 227     return d->speed;
 228 }
 229
 230 void AbstractRunner::setSpeed(Speed speed)
 231 {
 232     d->speed = speed;
 233 }
 234
 235 AbstractRunner::Priority AbstractRunner::priority() const
 236 {
 237     return d->priority;
 238 }
 239
 240 void AbstractRunner::setPriority(Priority priority)
 241 {
 242     d->priority = priority;
 243 }
 244
 245 RunnerContext::Types AbstractRunner::ignoredTypes() const
 246 {
 247     return d->blackListed;
 248 }
 249
 250 void AbstractRunner::setIgnoredTypes(RunnerContext::Types types)
 251 {
 252     d->blackListed = types;
 253 }
 254
 255 KService::List AbstractRunner::serviceQuery(const QString &serviceType, const QString &constraint) const
 256 {
 257     return KServiceTypeTrader::self()->query(serviceType, constraint);
 258 }
 259
 260 QMutex* AbstractRunner::bigLock()
 261 {
 262     return s_bigLock;
 263 }
 264
 265 void AbstractRunner::run(const Plasma::RunnerContext &search, const Plasma::QueryMatch &action)
 266 {
 267     if (d->script) {
 268         return d->script->run(search, action);
 269     }
 270 }
 271
 272 void AbstractRunner::match(Plasma::RunnerContext &search)
 273 {
 274     if (d->script) {
 275         return d->script->match(search);
 276     }
 277 }
 278
 279 QString AbstractRunner::name() const
 280 {
 281     if (!d->runnerDescription.isValid()) {
 282         return objectName();
 283     }
 284     return d->runnerDescription.name();
 285 }
 286
 287 QString AbstractRunner::id() const
 288 {
 289     if (!d->runnerDescription.isValid()) {
 290         return objectName();
 291     }
 292     return d->runnerDescription.pluginName();
 293 }
 294
 295 QString AbstractRunner::description() const
 296 {
 297     if (!d->runnerDescription.isValid()) {
 298         return objectName();
 299     }
 300     return d->runnerDescription.property("Comment").toString();
 301 }
 302
 303 const Package* AbstractRunner::package() const
 304 {
 305     return d->package;
 306 }
 307
 308 void AbstractRunner::init()
 309 {
 310     if (d->script) {
 311         d->script->init();
 312     }
 313 }
 314
 315 } // Plasma namespace
 316
 317 #include "abstractrunner.moc"