• Skip to content
  • Skip to link menu
KDE 4.3 API Reference
  • KDE API Reference
  • kdelibs
  • Sitemap
  • Contact Us
 

Plasma

scriptengine.cpp

Go to the documentation of this file.
00001 /*
00002  *   Copyright 2007 by Aaron Seigo <aseigo@kde.org>
00003  *
00004  *   This program is free software; you can redistribute it and/or modify
00005  *   it under the terms of the GNU Library General Public License as
00006  *   published by the Free Software Foundation; either version 2, or
00007  *   (at your option) any later version.
00008  *
00009  *   This program is distributed in the hope that it will be useful,
00010  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *   GNU General Public License for more details
00013  *
00014  *   You should have received a copy of the GNU Library General Public
00015  *   License along with this program; if not, write to the
00016  *   Free Software Foundation, Inc.,
00017  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00018  */
00019 
00020 #include "scripting/scriptengine.h"
00021 
00022 #include <kdebug.h>
00023 #include <kservice.h>
00024 #include <kservicetypetrader.h>
00025 
00026 #include "abstractrunner.h"
00027 #include "applet.h"
00028 #include "dataengine.h"
00029 #include "package.h"
00030 #include "scripting/appletscript.h"
00031 #include "scripting/dataenginescript.h"
00032 #include "scripting/runnerscript.h"
00033 
00034 #include "private/packages_p.h"
00035 
00036 namespace Plasma
00037 {
00038 
00039 ScriptEngine::ScriptEngine(QObject *parent)
00040     : QObject(parent),
00041       d(0)
00042 {
00043 }
00044 
00045 ScriptEngine::~ScriptEngine()
00046 {
00047 //    delete d;
00048 }
00049 
00050 bool ScriptEngine::init()
00051 {
00052     return true;
00053 }
00054 
00055 const Package *ScriptEngine::package() const
00056 {
00057     return 0;
00058 }
00059 
00060 QString ScriptEngine::mainScript() const
00061 {
00062     return QString();
00063 }
00064 
00065 QStringList knownLanguages(ComponentTypes types)
00066 {
00067     QString constraintTemplate = "'%1' in [X-Plasma-ComponentTypes]";
00068     QString constraint;
00069 
00070     if (types & AppletComponent) {
00071         // currently this if statement is not needed, but this future proofs
00072         // the code against someone initializing constraint to something
00073         // before we get here.
00074         if (!constraint.isEmpty()) {
00075             constraint.append(" or ");
00076         }
00077 
00078         constraint.append(constraintTemplate.arg("Applet"));
00079     }
00080 
00081     if (types & DataEngineComponent) {
00082         if (!constraint.isEmpty()) {
00083             constraint.append(" or ");
00084         }
00085 
00086         constraint.append(constraintTemplate.arg("DataEngine"));
00087     }
00088 
00089     if (types & RunnerComponent) {
00090         if (!constraint.isEmpty()) {
00091             constraint.append(" or ");
00092         }
00093 
00094         constraint.append(constraintTemplate.arg("Runner"));
00095     }
00096 
00097     KService::List offers = KServiceTypeTrader::self()->query("Plasma/ScriptEngine", constraint);
00098     //kDebug() << "Applet::knownApplets constraint was '" << constraint
00099     //         << "' which got us " << offers.count() << " matches";
00100 
00101     QStringList languages;
00102     foreach (const KService::Ptr &service, offers) {
00103         QString language = service->property("X-Plasma-API").toString();
00104         if (!languages.contains(language)) {
00105             languages.append(language);
00106         }
00107     }
00108 
00109     return languages;
00110 }
00111 
00112 KService::List engineOffers(const QString &language, ComponentType type)
00113 {
00114     if (language.isEmpty()) {
00115         return KService::List();
00116     }
00117 
00118     QRegExp re("[^a-zA-Z0-9\\-_]");
00119     if (re.indexIn(language) != -1) {
00120         kDebug() << "invalid language attempted:" << language;
00121         return KService::List();
00122     }
00123 
00124     QString component;
00125     switch (type) {
00126     case AppletComponent:
00127         component = "Applet";
00128         break;
00129     case DataEngineComponent:
00130         component = "DataEngine";
00131         break;
00132     case RunnerComponent:
00133         component = "Runner";
00134         break;
00135     default:
00136         return KService::List();
00137         break;
00138     }
00139 
00140     QString constraint = QString("[X-Plasma-API] == '%1' and "
00141                                  "'%2' in [X-Plasma-ComponentTypes]").arg(language, component);
00142     KService::List offers = KServiceTypeTrader::self()->query("Plasma/ScriptEngine", constraint);
00143 /*    kDebug() << "********************* loadingApplet with Plasma/ScriptEngine" << constraint
00144              << "resulting in" << offers.count() << "results";*/
00145     if (offers.isEmpty()) {
00146         kDebug() << "No offers for \"" << language << "\"";
00147     }
00148 
00149     return offers;
00150 }
00151 
00152 ScriptEngine *loadEngine(const QString &language, ComponentType type, QObject *parent)
00153 {
00154     KService::List offers = engineOffers(language, type);
00155 
00156     QVariantList args;
00157     QString error;
00158 
00159     ScriptEngine *engine = 0;
00160     foreach (const KService::Ptr &service, offers) {
00161         switch (type) {
00162             case AppletComponent:
00163                 engine = service->createInstance<Plasma::AppletScript>(parent, args, &error);
00164                 break;
00165             case DataEngineComponent:
00166                 engine = service->createInstance<Plasma::DataEngineScript>(parent, args, &error);
00167                 break;
00168             case RunnerComponent:
00169                 engine = service->createInstance<Plasma::RunnerScript>(parent, args, &error);
00170                 break;
00171             default:
00172                 return 0;
00173                 break;
00174         }
00175 
00176         if (engine) {
00177             return engine;
00178         }
00179 
00180         kDebug() << "Couldn't load script engine for language " << language
00181                  << "! error reported: " << error;
00182     }
00183 
00184     return 0;
00185 }
00186 
00187 AppletScript *loadScriptEngine(const QString &language, Applet *applet)
00188 {
00189     AppletScript *engine =
00190         static_cast<AppletScript*>(loadEngine(language, AppletComponent, applet));
00191 
00192     if (engine) {
00193         engine->setApplet(applet);
00194     }
00195 
00196     return engine;
00197 }
00198 
00199 DataEngineScript *loadScriptEngine(const QString &language, DataEngine *dataEngine)
00200 {
00201     DataEngineScript *engine =
00202         static_cast<DataEngineScript*>(loadEngine(language, DataEngineComponent, dataEngine));
00203 
00204     if (engine) {
00205         engine->setDataEngine(dataEngine);
00206     }
00207 
00208     return engine;
00209 }
00210 
00211 RunnerScript *loadScriptEngine(const QString &language, AbstractRunner *runner)
00212 {
00213     RunnerScript *engine =
00214         static_cast<RunnerScript*>(loadEngine(language, RunnerComponent, runner));
00215 
00216     if (engine) {
00217         engine->setRunner(runner);
00218     }
00219 
00220     return engine;
00221 }
00222 
00223 PackageStructure::Ptr defaultPackageStructure(ComponentType type)
00224 {
00225     switch (type) {
00226     case AppletComponent:
00227     case DataEngineComponent:
00228         return PackageStructure::Ptr(new PlasmoidPackage());
00229         break;
00230     case RunnerComponent:
00231     {
00232         PackageStructure::Ptr structure(new PackageStructure());
00233         structure->addFileDefinition("mainscript", "code/main", i18n("Main Script File"));
00234         structure->setRequired("mainscript", true);
00235         return structure;
00236         break;
00237     }
00238     default:
00239         // TODO: we don't have any special structures for other components yet
00240         break;
00241     }
00242 
00243     return PackageStructure::Ptr(new PackageStructure());
00244 }
00245 
00246 PackageStructure::Ptr packageStructure(const QString &language, ComponentType type)
00247 {
00248     KService::List offers = engineOffers(language, type);
00249 
00250     if (offers.isEmpty()) {
00251         return defaultPackageStructure(type);
00252     }
00253 
00254     KService::Ptr offer = offers.first();
00255     QString packageFormat = offer->property("X-Plasma-PackageFormat").toString();
00256 
00257     if (packageFormat.isEmpty()) {
00258         return defaultPackageStructure(type);
00259     } else {
00260         PackageStructure::Ptr structure = PackageStructure::load(packageFormat);
00261         return structure;
00262     }
00263 }
00264 
00265 } // namespace Plasma
00266 
00267 #include <scriptengine.moc>
00268 

Plasma

Skip menu "Plasma"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

kdelibs

Skip menu "kdelibs"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • Kate
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Generated for kdelibs by doxygen 1.6.1
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal