workspace/plasma/scriptengines/javascript/simplejavascriptapplet.cpp

   1 /*
   2  *   Copyright 2007-2008 Richard J. Moore <rich@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 version 2 as
   6  *   published by the Free Software Foundation
   7  *
   8  *   This program is distributed in the hope that it will be useful,
   9  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *   GNU General Public License for more details
  12  *
  13  *   You should have received a copy of the GNU Library General Public
  14  *   License along with this program; if not, write to the
  15  *   Free Software Foundation, Inc.,
  16  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #include "simplejavascriptapplet.h"
  20
  21 #include <QScriptEngine>
  22 #include <QFile>
  23 #include <QUiLoader>
  24 #include <QGraphicsLayout>
  25 #include <QWidget>
  26
  27 #include <KDebug>
  28 #include <KLocale>
  29 #include <KStandardDirs>
  30 #include <KConfigGroup>
  31
  32 #include <Plasma/Applet>
  33 #include <Plasma/Svg>
  34 #include <Plasma/FrameSvg>
  35 #include <Plasma/Package>
  36
  37 #include "appletinterface.h"
  38
  39 using namespace Plasma;
  40
  41 #include "bind_dataengine.h"
  42
  43 Q_DECLARE_METATYPE(QPainter*)
  44 Q_DECLARE_METATYPE(QStyleOptionGraphicsItem*)
  45 Q_DECLARE_METATYPE(SimpleJavaScriptApplet*)
  46 Q_DECLARE_METATYPE(AppletInterface*)
  47 Q_DECLARE_METATYPE(Applet*)
  48 Q_DECLARE_METATYPE(QGraphicsWidget*)
  49 Q_DECLARE_METATYPE(QGraphicsLayout*)
  50 Q_DECLARE_METATYPE(KConfigGroup)
  51
  52 Q_SCRIPT_DECLARE_QMETAOBJECT(AppletInterface, SimpleJavaScriptApplet*)
  53
  54 QScriptValue constructPainterClass(QScriptEngine *engine);
  55 QScriptValue constructGraphicsItemClass(QScriptEngine *engine);
  56 QScriptValue constructLinearLayoutClass(QScriptEngine *engine);
  57 QScriptValue constructTimerClass(QScriptEngine *engine);
  58 QScriptValue constructFontClass(QScriptEngine *engine);
  59 QScriptValue constructQRectFClass(QScriptEngine *engine);
  60 QScriptValue constructQPointClass(QScriptEngine *engine);
  61 QScriptValue constructQSizeFClass(QScriptEngine *engine);
  62
  63 class DummyService : public Service
  64 {
  65 public:
  66     ServiceJob *createJob(const QString &operation, QMap<QString, QVariant> &parameters)
  67     {
  68         Q_UNUSED(operation)
  69         Q_UNUSED(parameters)
  70         return 0;
  71     }
  72 };
  73
  74 /*
  75  * Workaround the fact that QtScripts handling of variants seems a bit broken.
  76  */
  77 QScriptValue variant2ScriptValue(QScriptEngine *engine, QVariant var)
  78 {
  79     if (var.isNull()) {
  80         return engine->nullValue();
  81     }
  82
  83     switch(var.type())
  84     {
  85         case QVariant::Invalid:
  86             return engine->nullValue();
  87         case QVariant::Bool:
  88             return QScriptValue(engine, var.toBool());
  89         case QVariant::Date:
  90             return engine->newDate(var.toDateTime());
  91         case QVariant::DateTime:
  92             return engine->newDate(var.toDateTime());
  93         case QVariant::Double:
  94             return QScriptValue(engine, var.toDouble());
  95         case QVariant::Int:
  96         case QVariant::LongLong:
  97             return QScriptValue(engine, var.toInt());
  98         case QVariant::String:
  99             return QScriptValue(engine, var.toString());
 100         case QVariant::Time: {
 101             QDateTime t(QDate::currentDate(), var.toTime());
 102             return engine->newDate(t);
 103         }
 104         case QVariant::UInt:
 105             return QScriptValue(engine, var.toUInt());
 106         default:
 107             break;
 108     }
 109
 110     return qScriptValueFromValue(engine, var);
 111 }
 112
 113 QScriptValue qScriptValueFromData(QScriptEngine *engine, const DataEngine::Data &data)
 114 {
 115     DataEngine::Data::const_iterator begin = data.begin();
 116     DataEngine::Data::const_iterator end = data.end();
 117     DataEngine::Data::const_iterator it;
 118
 119     QScriptValue obj = engine->newObject();
 120
 121     for (it = begin; it != end; ++it) {
 122         //kDebug() << "setting" << it.key() << "to" << it.value();
 123         QString prop = it.key();
 124         prop.replace(' ', '_');
 125         obj.setProperty(prop, variant2ScriptValue(engine, it.value()));
 126     }
 127
 128     return obj;
 129 }
 130
 131 QScriptValue qScriptValueFromKConfigGroup(QScriptEngine *engine, const KConfigGroup &config)
 132 {
 133     QScriptValue obj = engine->newObject();
 134
 135     if (!config.isValid()) {
 136         return obj;
 137     }
 138
 139     QMap<QString, QString> entryMap = config.entryMap();
 140     QMap<QString, QString>::const_iterator it = entryMap.constBegin();
 141     QMap<QString, QString>::const_iterator begin = it;
 142     QMap<QString, QString>::const_iterator end = entryMap.constEnd();
 143
 144     //setting the group name
 145     obj.setProperty("__name", QScriptValue(engine, config.name()));
 146
 147     //setting the key/value pairs
 148     for (it = begin; it != end; ++it) {
 149         //kDebug() << "setting" << it.key() << "to" << it.value();
 150         QString prop = it.key();
 151         prop.replace(' ', '_');
 152         obj.setProperty(prop, variant2ScriptValue(engine, it.value()));
 153     }
 154
 155     return obj;
 156 }
 157
 158 void kConfigGroupFromScriptValue(const QScriptValue& obj, KConfigGroup &config)
 159 {
 160     KConfigSkeleton *skel = new KConfigSkeleton();
 161     config = KConfigGroup(skel->config(), obj.property("__name").toString());
 162
 163     QScriptValueIterator it(obj);
 164
 165     while (it.hasNext()) {
 166         it.next();
 167         //kDebug() << it.name() << "is" << it.value().toString();
 168         if (it.name() != "__name") {
 169             config.writeEntry(it.name(), it.value().toString());
 170         }
 171     }
 172 }
 173
 174 KSharedPtr<UiLoader> SimpleJavaScriptApplet::s_widgetLoader;
 175
 176 SimpleJavaScriptApplet::SimpleJavaScriptApplet(QObject *parent, const QVariantList &args)
 177     : Plasma::AppletScript(parent)
 178 {
 179     //kDebug() << "Script applet launched, args" << args;
 180
 181     m_engine = new QScriptEngine(this);
 182     importExtensions();
 183 }
 184
 185 SimpleJavaScriptApplet::~SimpleJavaScriptApplet()
 186 {
 187     if (s_widgetLoader.count() == 1) {
 188         s_widgetLoader.clear();
 189     }
 190 }
 191
 192 void SimpleJavaScriptApplet::reportError()
 193 {
 194     kDebug() << "Error: " << m_engine->uncaughtException().toString()
 195              << " at line " << m_engine->uncaughtExceptionLineNumber() << endl;
 196     kDebug() << m_engine->uncaughtExceptionBacktrace();
 197 }
 198
 199 void SimpleJavaScriptApplet::showConfigurationInterface()
 200 {
 201     kDebug() << "Script: showConfigurationInterface";
 202
 203     // Here we'll load a ui file...
 204     QScriptValue global = m_engine->globalObject();
 205
 206     QScriptValue fun = m_self.property("showConfigurationInterface");
 207     if (!fun.isFunction()) {
 208         kDebug() << "Script: ShowConfiguratioInterface is not a function, " << fun.toString();
 209         return;
 210     }
 211
 212     QScriptContext *ctx = m_engine->pushContext();
 213     ctx->setActivationObject(m_self);
 214     fun.call(m_self);
 215     m_engine->popContext();
 216
 217     if (m_engine->hasUncaughtException()) {
 218         reportError();
 219     }
 220 }
 221
 222 void SimpleJavaScriptApplet::configAccepted()
 223 {
 224     QScriptValue fun = m_self.property("configAccepted");
 225     if (!fun.isFunction()) {
 226         kDebug() << "Script: configAccepted is not a function, " << fun.toString();
 227         return;
 228     }
 229
 230     QScriptContext *ctx = m_engine->pushContext();
 231     ctx->setActivationObject(m_self);
 232     fun.call(m_self);
 233     m_engine->popContext();
 234
 235     if (m_engine->hasUncaughtException()) {
 236         reportError();
 237     }
 238 }
 239
 240 void SimpleJavaScriptApplet::dataUpdated(const QString &name, const DataEngine::Data &data)
 241 {
 242     QScriptValue fun = m_self.property("dataUpdate");
 243     if (!fun.isFunction()) {
 244         kDebug() << "Script: dataUpdate is not a function, " << fun.toString();
 245         return;
 246     }
 247
 248     QScriptValueList args;
 249     args << m_engine->toScriptValue(name) << m_engine->toScriptValue(data);
 250
 251     QScriptContext *ctx = m_engine->pushContext();
 252     ctx->setActivationObject(m_self);
 253     fun.call(m_self, args);
 254     m_engine->popContext();
 255
 256     if (m_engine->hasUncaughtException()) {
 257         reportError();
 258     }
 259 }
 260
 261 void SimpleJavaScriptApplet::executeAction(const QString &name)
 262 {
 263     callFunction("action_" + name);
 264     /*
 265     QScriptValue fun = m_self.property("action_" + name);
 266     if (fun.isFunction()) {
 267         QScriptContext *ctx = m_engine->pushContext();
 268         ctx->setActivationObject(m_self);
 269         fun.call(m_self);
 270         m_engine->popContext();
 271
 272         if (m_engine->hasUncaughtException()) {
 273             reportError();
 274         }
 275     }*/
 276 }
 277
 278 void SimpleJavaScriptApplet::paintInterface(QPainter *p, const QStyleOptionGraphicsItem *option, const QRect &contentsRect)
 279 {
 280     Q_UNUSED(option)
 281     Q_UNUSED(contentsRect)
 282
 283     //kDebug() << "paintInterface() (c++)";
 284     QScriptValue fun = m_self.property("paintInterface");
 285     if (!fun.isFunction()) {
 286         //kDebug() << "Script: paintInterface is not a function, " << fun.toString();
 287         AppletScript::paintInterface(p, option, contentsRect);
 288         return;
 289     }
 290
 291     QScriptValueList args;
 292     args << m_engine->toScriptValue(p);
 293     args << m_engine->toScriptValue(const_cast<QStyleOptionGraphicsItem*>(option));
 294     args << m_engine->toScriptValue(contentsRect);
 295
 296     QScriptContext *ctx = m_engine->pushContext();
 297     ctx->setActivationObject(m_self);
 298     fun.call(m_self, args);
 299     m_engine->popContext();
 300
 301     if (m_engine->hasUncaughtException()) {
 302         reportError();
 303     }
 304 }
 305
 306 QList<QAction*> SimpleJavaScriptApplet::contextualActions()
 307 {
 308     return m_interface->contextualActions();
 309 }
 310
 311 void SimpleJavaScriptApplet::callFunction(const QString &functionName, const QScriptValueList &args)
 312 {
 313     QScriptValue fun = m_self.property(functionName);
 314     if (fun.isFunction()) {
 315         QScriptContext *ctx = m_engine->pushContext();
 316         ctx->setActivationObject(m_self);
 317         fun.call(m_self, args);
 318         m_engine->popContext();
 319
 320         if (m_engine->hasUncaughtException()) {
 321             reportError();
 322         }
 323     }
 324 }
 325
 326 void SimpleJavaScriptApplet::constraintsEvent(Plasma::Constraints constraints)
 327 {
 328     QString functionName;
 329
 330     if (constraints & Plasma::FormFactorConstraint) {
 331         callFunction("formFactorChanged");
 332     }
 333
 334     if (constraints & Plasma::LocationConstraint) {
 335         callFunction("locationChanged");
 336     }
 337
 338     if (constraints & Plasma::ContextConstraint) {
 339         callFunction("contextChanged");
 340     }
 341 }
 342
 343 bool SimpleJavaScriptApplet::init()
 344 {
 345     setupObjects();
 346
 347     kDebug() << "ScriptName:" << applet()->name();
 348     kDebug() << "ScriptCategory:" << applet()->category();
 349
 350     QFile file(mainScript());
 351     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
 352         kWarning() << "Unable to load script file";
 353         return false;
 354     }
 355
 356     QString script = file.readAll();
 357     //kDebug() << "Script says" << script;
 358
 359     m_engine->evaluate(script);
 360     if (m_engine->hasUncaughtException()) {
 361         reportError();
 362         return false;
 363     }
 364
 365     return true;
 366 }
 367
 368 void SimpleJavaScriptApplet::importExtensions()
 369 {
 370     return; // no extension, so do bother wasting cycles
 371
 372     /*
 373     QStringList extensions;
 374     //extensions << "qt.core" << "qt.gui" << "qt.svg" << "qt.xml" << "qt.plasma";
 375     //extensions << "qt.core" << "qt.gui" << "qt.xml";
 376     foreach (const QString &ext, extensions) {
 377         kDebug() << "importing " << ext << "...";
 378         QScriptValue ret = m_engine->importExtension(ext);
 379         if (ret.isError()) {
 380             kDebug() << "failed to import extension" << ext << ":" << ret.toString();
 381         }
 382     }
 383     kDebug() << "done importing extensions.";
 384     */
 385 }
 386
 387 void SimpleJavaScriptApplet::setupObjects()
 388 {
 389     QScriptValue global = m_engine->globalObject();
 390
 391     // Bindings for data engine
 392     m_engine->setDefaultPrototype(qMetaTypeId<DataEngine*>(), m_engine->newQObject(new DataEngine()));
 393     m_engine->setDefaultPrototype(qMetaTypeId<Service*>(), m_engine->newQObject(new DummyService()));
 394     m_engine->setDefaultPrototype(qMetaTypeId<ServiceJob*>(), m_engine->newQObject(new ServiceJob(QString(), QString(), QMap<QString, QVariant>())));
 395
 396     global.setProperty("dataEngine", m_engine->newFunction(SimpleJavaScriptApplet::dataEngine));
 397     global.setProperty("service", m_engine->newFunction(SimpleJavaScriptApplet::service));
 398     qScriptRegisterMetaType<DataEngine::Data>(m_engine, qScriptValueFromData, 0, QScriptValue());
 399     qScriptRegisterMetaType<KConfigGroup>(m_engine, qScriptValueFromKConfigGroup, kConfigGroupFromScriptValue, QScriptValue());
 400
 401     // Expose applet interface
 402     m_interface = new AppletInterface(this);
 403     m_self = m_engine->newQObject(m_interface);
 404     m_self.setScope(global);
 405     global.setProperty("plasmoid", m_self);
 406
 407     //manually create enum values. ugh
 408     QMetaObject meta = AppletInterface::staticMetaObject;
 409     for (int i=0; i < meta.enumeratorCount(); ++i) {
 410         QMetaEnum e = meta.enumerator(i);
 411         //kDebug() << e.name();
 412         for (int i=0; i < e.keyCount(); ++i) {
 413             //kDebug() << e.key(i) << e.value(i);
 414             global.setProperty(e.key(i), QScriptValue(m_engine, e.value(i)));
 415         }
 416     }
 417
 418     // Add a global loadui method for ui files
 419     QScriptValue fun = m_engine->newFunction(SimpleJavaScriptApplet::loadui);
 420     global.setProperty("loadui", fun);
 421
 422     fun = m_engine->newFunction(SimpleJavaScriptApplet::print);
 423     global.setProperty("print", fun);
 424
 425
 426     // Work around bug in 4.3.0
 427     qMetaTypeId<QVariant>();
 428
 429     // Add constructors
 430     global.setProperty("PlasmaSvg", m_engine->newFunction(SimpleJavaScriptApplet::newPlasmaSvg));
 431     global.setProperty("PlasmaFrameSvg", m_engine->newFunction(SimpleJavaScriptApplet::newPlasmaFrameSvg));
 432
 433     // Add stuff from 4.4
 434     global.setProperty("QPainter", constructPainterClass(m_engine));
 435     global.setProperty("QGraphicsItem", constructGraphicsItemClass(m_engine));
 436     global.setProperty("QTimer", constructTimerClass(m_engine));
 437     global.setProperty("QFont", constructFontClass(m_engine));
 438     global.setProperty("QRectF", constructQRectFClass(m_engine));
 439     global.setProperty("QSizeF", constructQSizeFClass(m_engine));
 440     global.setProperty("QPoint", constructQPointClass(m_engine));
 441     global.setProperty("LinearLayout", constructLinearLayoutClass(m_engine));
 442
 443     installWidgets(m_engine);
 444 }
 445
 446 QString SimpleJavaScriptApplet::findDataResource(const QString &filename)
 447 {
 448     QString path("plasma-script/%1");
 449     return KGlobal::dirs()->findResource("data", path.arg(filename));
 450 }
 451
 452 void SimpleJavaScriptApplet::debug(const QString &msg)
 453 {
 454     kDebug() << msg;
 455 }
 456
 457 #if 0
 458 QScriptValue SimpleJavaScriptApplet::dataEngine(QScriptContext *context, QScriptEngine *engine)
 459 {
 460     if (context->argumentCount() != 1)
 461         return context->throwError("dataEngine takes one argument");
 462
 463     QString dataEngine = context->argument(0).toString();
 464
 465     Script *self = engine->fromScriptValue<Script*>(context->thisObject());
 466
 467     DataEngine *data = self->dataEngine(dataEngine);
 468     return engine->newQObject(data);
 469 }
 470 #endif
 471
 472 QScriptValue SimpleJavaScriptApplet::dataEngine(QScriptContext *context, QScriptEngine *engine)
 473 {
 474     if (context->argumentCount() != 1) {
 475         return context->throwError(i18n("DataEngine takes one argument"));
 476     }
 477
 478     QString dataEngine = context->argument(0).toString();
 479
 480     QScriptValue appletValue = engine->globalObject().property("plasmoid");
 481     //kDebug() << "appletValue is " << appletValue.toString();
 482
 483     QObject *appletObject = appletValue.toQObject();
 484     if (!appletObject) {
 485         return context->throwError(i18n("Could not extract the AppletObject"));
 486     }
 487
 488     AppletInterface *interface = qobject_cast<AppletInterface*>(appletObject);
 489     if (!interface) {
 490         return context->throwError(i18n("Could not extract the Applet"));
 491     }
 492
 493     DataEngine *data = interface->dataEngine(dataEngine);
 494     return engine->newQObject(data);
 495 }
 496
 497 QScriptValue SimpleJavaScriptApplet::service(QScriptContext *context, QScriptEngine *engine)
 498 {
 499     if (context->argumentCount() != 2) {
 500         return context->throwError(i18n("Service takes two arguments"));
 501     }
 502
 503     QString dataEngine = context->argument(0).toString();
 504
 505     QScriptValue appletValue = engine->globalObject().property("plasmoid");
 506     //kDebug() << "appletValue is " << appletValue.toString();
 507
 508     QObject *appletObject = appletValue.toQObject();
 509     if (!appletObject) {
 510         return context->throwError(i18n("Could not extract the AppletObject"));
 511     }
 512
 513     AppletInterface *interface = qobject_cast<AppletInterface*>(appletObject);
 514     if (!interface) {
 515         return context->throwError(i18n("Could not extract the Applet"));
 516     }
 517
 518     DataEngine *data = interface->dataEngine(dataEngine);
 519     QString source = context->argument(1).toString();
 520     Service *service = data->serviceForSource(source);
 521     //kDebug( )<< "lets try to get" << source << "from" << dataEngine;
 522     return engine->newQObject(service);
 523 }
 524
 525 QScriptValue SimpleJavaScriptApplet::loadui(QScriptContext *context, QScriptEngine *engine)
 526 {
 527     if (context->argumentCount() != 1) {
 528         return context->throwError(i18n("loadUI takes one argument"));
 529     }
 530
 531     QString filename = context->argument(0).toString();
 532     QFile f(filename);
 533     if (!f.open(QIODevice::ReadOnly)) {
 534         return context->throwError(i18n("Unable to open '%1'",filename));
 535     }
 536
 537     QUiLoader loader;
 538     QWidget *w = loader.load(&f);
 539     f.close();
 540
 541     return engine->newQObject(w);
 542 }
 543
 544 QString SimpleJavaScriptApplet::findSvg(QScriptEngine *engine, const QString &file)
 545 {
 546     QScriptValue appletValue = engine->globalObject().property("plasmoid");
 547     //kDebug() << "appletValue is " << appletValue.toString();
 548
 549     QObject *appletObject = appletValue.toQObject();
 550     if (!appletObject) {
 551         return file;
 552     }
 553
 554     AppletInterface *interface = qobject_cast<AppletInterface*>(appletObject);
 555     if (!interface) {
 556         return file;
 557     }
 558
 559     QString path = interface->package()->filePath("images", file + ".svg");
 560     if (path.isEmpty()) {
 561         path = interface->package()->filePath("images", file + ".svgz");
 562
 563         if (path.isEmpty()) {
 564             return file;
 565         }
 566     }
 567
 568     return path;
 569 }
 570
 571 QScriptValue SimpleJavaScriptApplet::newPlasmaSvg(QScriptContext *context, QScriptEngine *engine)
 572 {
 573     if (context->argumentCount() == 0) {
 574         return context->throwError(i18n("Constructor takes at least 1 argument"));
 575     }
 576
 577     QString filename = context->argument(0).toString();
 578     QObject *parent = 0;
 579
 580     if (context->argumentCount() == 2) {
 581         parent = qscriptvalue_cast<QObject *>(context->argument(1));
 582     }
 583
 584     bool parentedToApplet = false;
 585     if (!parent) {
 586         QScriptValue appletValue = engine->globalObject().property("plasmoid");
 587         //kDebug() << "appletValue is " << appletValue.toString();
 588
 589         QObject *appletObject = appletValue.toQObject();
 590         if (appletObject) {
 591             AppletInterface *interface = qobject_cast<AppletInterface*>(appletObject);
 592             if (interface) {
 593                 parentedToApplet = true;
 594                 parent = interface->applet();
 595             }
 596         }
 597     }
 598
 599     Svg *svg = new Svg(parent);
 600     svg->setImagePath(parentedToApplet ? filename : findSvg(engine, filename));
 601     return engine->newQObject(svg);
 602 }
 603
 604 QScriptValue SimpleJavaScriptApplet::newPlasmaFrameSvg(QScriptContext *context, QScriptEngine *engine)
 605 {
 606     if (context->argumentCount() == 0) {
 607         return context->throwError(i18n("Constructor takes at least 1 argument"));
 608     }
 609
 610     QString filename = context->argument(0).toString();
 611     QObject *parent = 0;
 612
 613     if (context->argumentCount() == 2) {
 614         parent = qscriptvalue_cast<QObject *>(context->argument(1));
 615     }
 616
 617     bool parentedToApplet = false;
 618     if (!parent) {
 619         QScriptValue appletValue = engine->globalObject().property("plasmoid");
 620         //kDebug() << "appletValue is " << appletValue.toString();
 621
 622         QObject *appletObject = appletValue.toQObject();
 623         if (appletObject) {
 624             AppletInterface *interface = qobject_cast<AppletInterface*>(appletObject);
 625             if (interface) {
 626                 parentedToApplet = true;
 627                 parent = interface->applet();
 628             }
 629         }
 630     }
 631
 632     FrameSvg *frameSvg = new FrameSvg(parent);
 633     frameSvg->setImagePath(parentedToApplet ? filename : findSvg(engine, filename));
 634     return engine->newQObject(frameSvg);
 635 }
 636
 637 void SimpleJavaScriptApplet::installWidgets(QScriptEngine *engine)
 638 {
 639     QScriptValue globalObject = engine->globalObject();
 640     if (!s_widgetLoader) {
 641         s_widgetLoader = new UiLoader;
 642     }
 643
 644     foreach (const QString &widget, s_widgetLoader->availableWidgets()) {
 645         QScriptValue fun = engine->newFunction(createWidget);
 646         QScriptValue name = engine->toScriptValue(widget);
 647         fun.setProperty(QString("functionName"), name,
 648                          QScriptValue::ReadOnly | QScriptValue::Undeletable | QScriptValue::SkipInEnumeration);
 649         fun.setProperty(QString("prototype"), createPrototype(engine, name.toString()));
 650
 651         globalObject.setProperty(widget, fun);
 652     }
 653 }
 654
 655 QScriptValue SimpleJavaScriptApplet::createWidget(QScriptContext *context, QScriptEngine *engine)
 656 {
 657     if (context->argumentCount() > 1) {
 658         return context->throwError(i18n("CreateWidget takes one argument"));
 659     }
 660
 661     QGraphicsWidget *parent = 0;
 662     if (context->argumentCount()) {
 663         parent = qscriptvalue_cast<QGraphicsWidget*>(context->argument(0));
 664
 665         if (!parent) {
 666             return context->throwError(i18n("The parent must be a QGraphicsWidget"));
 667         }
 668     }
 669
 670     QString self = context->callee().property("functionName").toString();
 671     if (!s_widgetLoader) {
 672         s_widgetLoader = new UiLoader;
 673     }
 674
 675     QGraphicsWidget *w = s_widgetLoader->createWidget(self, parent);
 676
 677     if (!w) {
 678         return QScriptValue();
 679     }
 680
 681     QScriptValue fun = engine->newQObject(w);
 682     fun.setPrototype(context->callee().property("prototype"));
 683
 684     return fun;
 685 }
 686
 687 QScriptValue SimpleJavaScriptApplet::print(QScriptContext *context, QScriptEngine *engine)
 688 {
 689     if (context->argumentCount() != 1) {
 690         return context->throwError(i18n("print takes one argument"));
 691     }
 692
 693     kDebug() << context->argument(0).toString();
 694     return engine->undefinedValue();
 695 }
 696
 697 QScriptValue SimpleJavaScriptApplet::createPrototype(QScriptEngine *engine, const QString &name)
 698 {
 699     Q_UNUSED(name)
 700     QScriptValue proto = engine->newObject();
 701
 702     // Hook for adding extra properties/methods
 703     return proto;
 704 }
 705
 706 K_EXPORT_PLASMA_APPLETSCRIPTENGINE(qscriptapplet, SimpleJavaScriptApplet)
 707
 708 #include "simplejavascriptapplet.moc"
 709
 710