workspace/libs/plasma/scripting/scriptengine.cpp

   1 /*
   2  *   Copyright 2007 by 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 "scripting/scriptengine.h"
  21
  22 #include <KDebug>
  23 #include <KService>
  24 #include <KServiceTypeTrader>
  25
  26 #include "abstractrunner.h"
  27 #include "applet.h"
  28 #include "dataengine.h"
  29 #include "package.h"
  30 #include "scripting/appletscript.h"
  31 #include "scripting/dataenginescript.h"
  32 #include "scripting/runnerscript.h"
  33
  34 namespace Plasma
  35 {
  36
  37 ScriptEngine::ScriptEngine(QObject *parent)
  38     : QObject(parent),
  39       d(0)
  40 {
  41 }
  42
  43 ScriptEngine::~ScriptEngine()
  44 {
  45 //    delete d;
  46 }
  47
  48 bool ScriptEngine::init()
  49 {
  50     return true;
  51 }
  52
  53 QStringList knownLanguages(ComponentTypes types)
  54 {
  55     QString constraintTemplate = "'%1' in [X-Plasma-ComponentTypes]";
  56     QString constraint;
  57
  58     if (types & AppletComponent) {
  59         // currently this if statement is not needed, but this future proofs
  60         // the code against someone initializing constraint to something
  61         // before we get here.
  62         if (!constraint.isEmpty()) {
  63             constraint.append(" or ");
  64         }
  65
  66         constraint.append(constraintTemplate.arg("Applet"));
  67     }
  68
  69     if (types & DataEngineComponent) {
  70         if (!constraint.isEmpty()) {
  71             constraint.append(" or ");
  72         }
  73
  74         constraint.append(constraintTemplate.arg("DataEngine"));
  75     }
  76
  77     if (types & RunnerComponent) {
  78         if (!constraint.isEmpty()) {
  79             constraint.append(" or ");
  80         }
  81
  82         constraint.append(constraintTemplate.arg("Runner"));
  83     }
  84
  85     KService::List offers = KServiceTypeTrader::self()->query("Plasma/ScriptEngine", constraint);
  86     //kDebug() << "Applet::knownApplets constraint was '" << constraint << "' which got us " << offers.count() << " matches";
  87
  88     QStringList languages;
  89     foreach (KService::Ptr service, offers) {
  90         QString language = service->property("X-Plasma-Language").toString();
  91         if (!languages.contains(language)) {
  92             languages.append(language);
  93         }
  94     }
  95
  96     return languages;
  97 }
  98
  99 ScriptEngine* loadEngine(const QString &language, ComponentType type, QObject *parent)
 100 {
 101     if (language.isEmpty()) {
 102         return 0;
 103     }
 104
 105     QRegExp re("[^a-zA-Z0-9\\-_]");
 106     if (re.indexIn(language) != -1) {
 107         kDebug() << "invalid language attempted:" << language;
 108         return 0;
 109     }
 110
 111     QString component;
 112     switch (type) {
 113         case AppletComponent:
 114             component = "Applet";
 115             break;
 116         case DataEngineComponent:
 117             component = "DataEngine";
 118             break;
 119         case RunnerComponent:
 120             component = "Runner";
 121             break;
 122         default:
 123             return 0;
 124             break;
 125     }
 126
 127     QString constraint = QString("[X-Plasma-Language] == '%1' and "
 128                                  "'%2' in [X-Plasma-ComponentTypes]").arg(language, component);
 129     KService::List offers = KServiceTypeTrader::self()->query("Plasma/ScriptEngine", constraint);
 130 /*    kDebug() << "********************* loadingApplet with Plasma/ScriptEngine" << constraint
 131              << "resulting in" << offers.count() << "results";*/
 132     if (offers.isEmpty()) {
 133         kDebug() << "ScriptEngine::load: no offers for \"" << language << "\"";
 134         return 0;
 135     }
 136
 137     QVariantList args;
 138     QString error;
 139
 140     ScriptEngine *engine = 0;
 141     foreach (KService::Ptr service, offers) {
 142         switch (type) {
 143             case AppletComponent:
 144                 engine = service->createInstance<Plasma::AppletScript>(parent, args, &error);
 145                 break;
 146             case DataEngineComponent:
 147                 engine = service->createInstance<Plasma::DataEngineScript>(parent, args, &error);
 148                 break;
 149             case RunnerComponent:
 150                 engine = service->createInstance<Plasma::RunnerScript>(parent, args, &error);
 151                 break;
 152             default:
 153                 return 0;
 154                 break;
 155         }
 156
 157         if (engine) {
 158             return engine;
 159         }
 160
 161         kDebug() << "Couldn't load script engine for language " << language << "! error reported: " << error;
 162     }
 163
 164     return 0;
 165 }
 166
 167 AppletScript* loadScriptEngine(const QString &language, Applet *applet)
 168 {
 169     AppletScript *engine = static_cast<AppletScript*>(loadEngine(language, AppletComponent, applet));
 170
 171     if (engine) {
 172         engine->setApplet(applet);
 173     }
 174
 175     return engine;
 176 }
 177
 178 DataEngineScript* loadScriptEngine(const QString &language, DataEngine *dataEngine)
 179 {
 180     DataEngineScript *engine = static_cast<DataEngineScript*>(loadEngine(language, DataEngineComponent, dataEngine));
 181
 182     if (engine) {
 183         engine->setDataEngine(dataEngine);
 184     }
 185
 186     return engine;
 187 }
 188
 189 RunnerScript* loadScriptEngine(const QString &language, AbstractRunner *runner)
 190 {
 191     RunnerScript* engine = static_cast<RunnerScript*>(loadEngine(language, RunnerComponent, runner));
 192
 193     if (engine) {
 194         engine->setRunner(runner);
 195     }
 196
 197     return engine;
 198 }
 199
 200 } // namespace Plasma
 201
 202 #include <scriptengine.moc>
 203