Git commit 3ed7cbd8efa5b8de2a50f8b9ccb9e639c1b5ea1c by David Edmundson.
Committed on 31/07/2018 at 20:22.
Pushed by davidedmundson into branch 'scripting2'.

port to QJSEngine

M  +23   -11   autotests/integration/effects/scripted_effects_test.cpp
M  +1    -1    autotests/test_scripted_effectloader.cpp
M  +315  -300  scripting/scriptedeffect.cpp
M  +10   -11   scripting/scriptedeffect.h

https://commits.kde.org/kwin/3ed7cbd8efa5b8de2a50f8b9ccb9e639c1b5ea1c

diff --git a/autotests/integration/effects/scripted_effects_test.cpp b/auto=
tests/integration/effects/scripted_effects_test.cpp
index fd00a8711..0276ec965 100644
--- a/autotests/integration/effects/scripted_effects_test.cpp
+++ b/autotests/integration/effects/scripted_effects_test.cpp
@@ -34,9 +34,8 @@ along with this program.  If not, see <http:// www.gnu.or=
g/licenses/>.
 #include "wayland_server.h"
 #include "workspace.h"
 =

-#include <QScriptContext>
-#include <QScriptEngine>
-#include <QScriptValue>
+#include <QJSValue>
+#include <QJSEngine>
 =

 #include <KConfigGroup>
 #include <KGlobalAccel>
@@ -74,15 +73,15 @@ class ScriptedEffectWithDebugSpy : public KWin::Scripte=
dEffect
 {
     Q_OBJECT
 public:
-    ScriptedEffectWithDebugSpy();
     bool load(const QString &name);
     using AnimationEffect::state;
 signals:
     void testOutput(const QString &data);
 };
 =

-QScriptValue kwinEffectScriptTestOut(QScriptContext *context, QScriptEngin=
e *engine)
+class SendTestResponseContext : public QObject
 {
+<<<<<<< HEAD
     auto *script =3D qobject_cast<ScriptedEffectWithDebugSpy*>(context->ca=
llee().data().toQObject());
     QString result;
     for (int i =3D 0; i < context->argumentCount(); ++i) {
@@ -92,21 +91,34 @@ QScriptValue kwinEffectScriptTestOut(QScriptContext *co=
ntext, QScriptEngine *eng
         result.append(context->argument(i).toString());
     }
     emit script->testOutput(result);
+=3D=3D=3D=3D=3D=3D=3D
+    Q_OBJECT
+public:
+    SendTestResponseContext(ScriptedEffectWithDebugSpy *scriptedEffect);
+    Q_INVOKABLE void sendTestResponse(const QString &out);
+private:
+    ScriptedEffectWithDebugSpy *m_scriptedEffect;
+};
 =

-    return engine->undefinedValue();
+>>>>>>> 87ad4e45f... port to QJSEngine
+
+SendTestResponseContext::SendTestResponseContext(ScriptedEffectWithDebugSp=
y *scriptedEffect):
+    QObject(nullptr),
+    m_scriptedEffect(scriptedEffect)
+{
 }
 =

-ScriptedEffectWithDebugSpy::ScriptedEffectWithDebugSpy()
-    : ScriptedEffect()
+void SendTestResponseContext::sendTestResponse(const QString &out)
 {
-    QScriptValue testHookFunc =3D engine()->newFunction(kwinEffectScriptTe=
stOut);
-    testHookFunc.setData(engine()->newQObject(this));
-    engine()->globalObject().setProperty(QStringLiteral("sendTestResponse"=
), testHookFunc);
+    emit m_scriptedEffect->testOutput(out);
 }
 =

 bool ScriptedEffectWithDebugSpy::load(const QString &name)
 {
+    auto selfContext =3D engine()->newQObject(new SendTestResponseContext(=
this)); //JS ownership
+
     const QString path =3D QFINDTESTDATA("./scripts/" + name + ".js");
+    engine()->globalObject().setProperty("sendTestResponse", selfContext.p=
roperty("sendTestResponse"));
     if (!init(name, path)) {
         return false;
     }
diff --git a/autotests/test_scripted_effectloader.cpp b/autotests/test_scri=
pted_effectloader.cpp
index b308dc7f2..988e70689 100644
--- a/autotests/test_scripted_effectloader.cpp
+++ b/autotests/test_scripted_effectloader.cpp
@@ -59,7 +59,7 @@ void InputRedirection::registerShortcut(const QKeySequenc=
e &, QAction *)
 =

 namespace MetaScripting
 {
-void registration(QScriptEngine *)
+void registration(QJSEngine *)
 {
 }
 }
diff --git a/scripting/scriptedeffect.cpp b/scripting/scriptedeffect.cpp
index 4710bf6c2..e78f6315e 100644
--- a/scripting/scriptedeffect.cpp
+++ b/scripting/scriptedeffect.cpp
@@ -31,10 +31,12 @@ along with this program.  If not, see <http://www.gnu.o=
rg/licenses/>.
 #include <KPluginMetaData>
 // Qt
 #include <QFile>
-#include <QtScript/QScriptEngine>
-#include <QtScript/QScriptValueIterator>
+#include <QJSEngine>
+#include <QJSValueIterator>
 #include <QStandardPaths>
 =

+#include <QGridLayout>
+
 typedef KWin::EffectWindow* KEffectWindowRef;
 =

 Q_DECLARE_METATYPE(KSharedConfigPtr)
@@ -42,7 +44,7 @@ Q_DECLARE_METATYPE(KSharedConfigPtr)
 namespace KWin
 {
 =

-QScriptValue kwinEffectScriptPrint(QScriptContext *context, QScriptEngine =
*engine)
+QJSValue kwinEffectScriptPrint(QScriptContext *context, QJSEngine *engine)
 {
     ScriptedEffect *script =3D qobject_cast<ScriptedEffect*>(context->call=
ee().data().toQObject());
     QString result;
@@ -54,52 +56,56 @@ QScriptValue kwinEffectScriptPrint(QScriptContext *cont=
ext, QScriptEngine *engin
     }
     qCDebug(KWIN_SCRIPTING) << script->scriptFile() << ":" << result;
 =

-    return engine->undefinedValue();
+    return QJSValue();
 }
 =

-QScriptValue kwinEffectScriptAnimationTime(QScriptContext *context, QScrip=
tEngine *engine)
+QJSValue kwinEffectScriptAnimationTime(QScriptContext *context, QJSEngine =
*engine)
 {
     if (context->argumentCount() !=3D 1) {
-        return engine->undefinedValue();
+        return QJSValue();
     }
     if (!context->argument(0).isNumber()) {
-        return engine->undefinedValue();
+        return QJSValue();
     }
     return Effect::animationTime(context->argument(0).toInteger());
 }
 =

-QScriptValue kwinEffectDisplayWidth(QScriptContext *context, QScriptEngine=
 *engine)
+QJSValue kwinEffectDisplayWidth(QScriptContext *context, QJSEngine *engine)
 {
     Q_UNUSED(context)
     Q_UNUSED(engine)
     return screens()->displaySize().width();
 }
 =

-QScriptValue kwinEffectDisplayHeight(QScriptContext *context, QScriptEngin=
e *engine)
+QJSValue kwinEffectDisplayHeight(QScriptContext *context, QJSEngine *engin=
e)
 {
     Q_UNUSED(context)
     Q_UNUSED(engine)
     return screens()->displaySize().height();
 }
 =

-QScriptValue kwinScriptGlobalShortcut(QScriptContext *context, QScriptEngi=
ne *engine)
+QJSValue kwinScriptGlobalShortcut(QScriptContext *context, QJSEngine *engi=
ne)
 {
-    return globalShortcut<KWin::ScriptedEffect*>(context, engine);
+    return QJSValue();
+//    return globalShortcut<KWin::ScriptedEffect*>(context, engine);
 }
 =

-QScriptValue kwinScriptScreenEdge(QScriptContext *context, QScriptEngine *=
engine)
+QJSValue kwinScriptScreenEdge(QScriptContext *context, QJSEngine *engine)
 {
-    return registerScreenEdge<KWin::ScriptedEffect*>(context, engine);
+    return QJSValue();
+//    return registerScreenEdge<KWin::ScriptedEffect*>(context, engine);
 }
 =

-QScriptValue kwinRegisterTouchScreenEdge(QScriptContext *context, QScriptE=
ngine *engine)
+QJSValue kwinRegisterTouchScreenEdge(QScriptContext *context, QJSEngine *e=
ngine)
 {
-    return registerTouchScreenEdge<KWin::ScriptedEffect*>(context, engine);
+    return QJSValue();
+//    return registerTouchScreenEdge<KWin::ScriptedEffect*>(context, engin=
e);
 }
 =

-QScriptValue kwinUnregisterTouchScreenEdge(QScriptContext *context, QScrip=
tEngine *engine)
+QJSValue kwinUnregisterTouchScreenEdge(QScriptContext *context, QJSEngine =
*engine)
 {
-    return unregisterTouchScreenEdge<KWin::ScriptedEffect*>(context, engin=
e);
+    return QJSValue();
+//    return unregisterTouchScreenEdge<KWin::ScriptedEffect*>(context, eng=
ine);
 }
 =

 struct AnimationSettings {
@@ -114,42 +120,42 @@ struct AnimationSettings {
     uint metaData;
 };
 =

-AnimationSettings animationSettingsFromObject(QScriptValue &object)
+AnimationSettings animationSettingsFromObject(QJSValue &object)
 {
     AnimationSettings settings;
     settings.set =3D 0;
     settings.metaData =3D 0;
 =

-    settings.to =3D qscriptvalue_cast<FPx2>(object.property(QStringLiteral=
("to")));
-    settings.from =3D qscriptvalue_cast<FPx2>(object.property(QStringLiter=
al("from")));
+    settings.to =3D object.property(QStringLiteral("to")).toVariant().valu=
e<FPx2>();
+    settings.from =3D object.property(QStringLiteral("from")).toVariant().=
value<FPx2>();
 =

-    QScriptValue duration =3D object.property(QStringLiteral("duration"));
-    if (duration.isValid() && duration.isNumber()) {
-        settings.duration =3D duration.toUInt32();
+    QJSValue duration =3D object.property(QStringLiteral("duration"));
+    if (duration.isNumber()) {
+        settings.duration =3D duration.toUInt();
         settings.set |=3D AnimationSettings::Duration;
     } else {
         settings.duration =3D 0;
     }
 =

-    QScriptValue delay =3D object.property(QStringLiteral("delay"));
-    if (delay.isValid() && delay.isNumber()) {
-        settings.delay =3D delay.toInt32();
+    QJSValue delay =3D object.property(QStringLiteral("delay"));
+    if (delay.isNumber()) {
+        settings.delay =3D delay.toInt();
         settings.set |=3D AnimationSettings::Delay;
     } else {
         settings.delay =3D 0;
     }
 =

-    QScriptValue curve =3D object.property(QStringLiteral("curve"));
-    if (curve.isValid() && curve.isNumber()) {
-        settings.curve =3D static_cast<QEasingCurve::Type>(curve.toInt32()=
);
+    QJSValue curve =3D object.property(QStringLiteral("curve"));
+    if (curve.isNumber()) {
+        settings.curve =3D static_cast<QEasingCurve::Type>(curve.toInt());
         settings.set |=3D AnimationSettings::Curve;
     } else {
         settings.curve =3D QEasingCurve::Linear;
     }
 =

-    QScriptValue type =3D object.property(QStringLiteral("type"));
-    if (type.isValid() && type.isNumber()) {
-        settings.type =3D static_cast<AnimationEffect::Attribute>(type.toI=
nt32());
+    QJSValue type =3D object.property(QStringLiteral("type"));
+    if (type.isNumber()) {
+        settings.type =3D static_cast<AnimationEffect::Attribute>(type.toI=
nt());
         settings.set |=3D AnimationSettings::Type;
     } else {
         settings.type =3D static_cast<AnimationEffect::Attribute>(-1);
@@ -158,167 +164,171 @@ AnimationSettings animationSettingsFromObject(QScri=
ptValue &object)
     return settings;
 }
 =

-QList<AnimationSettings> animationSettings(QScriptContext *context, Script=
edEffect *effect, EffectWindow **window)
-{
-    QList<AnimationSettings> settings;
-    if (!effect) {
-        context->throwError(QScriptContext::ReferenceError, QStringLiteral=
("Internal Scripted KWin Effect error"));
-        return settings;
-    }
-    if (context->argumentCount() !=3D 1) {
-        context->throwError(QScriptContext::SyntaxError, QStringLiteral("E=
xactly one argument expected"));
-        return settings;
-    }
-    if (!context->argument(0).isObject()) {
-        context->throwError(QScriptContext::TypeError, QStringLiteral("Arg=
ument needs to be an object"));
-        return settings;
-    }
-    QScriptValue object =3D context->argument(0);
-    QScriptValue windowProperty =3D object.property(QStringLiteral("window=
"));
-    if (!windowProperty.isValid() || !windowProperty.isObject()) {
-        context->throwError(QScriptContext::TypeError, QStringLiteral("Win=
dow property missing in animation options"));
-        return settings;
-    }
-    *window =3D qobject_cast<EffectWindow*>(windowProperty.toQObject());
-
-    settings << animationSettingsFromObject(object); // global
-
-    QScriptValue animations =3D object.property(QStringLiteral("animations=
")); // array
-    if (animations.isValid()) {
-        if (!animations.isArray()) {
-            context->throwError(QScriptContext::TypeError, QStringLiteral(=
"Animations provided but not an array"));
-            settings.clear();
-            return settings;
-        }
-        const int length =3D static_cast<int>(animations.property(QStringL=
iteral("length")).toInteger());
-        for (int i=3D0; i<length; ++i) {
-            QScriptValue value =3D animations.property(QString::number(i));
-            if (!value.isValid()) {
-                continue;
-            }
-            if (value.isObject()) {
-                AnimationSettings s =3D animationSettingsFromObject(value);
-                const uint set =3D s.set | settings.at(0).set;
-                // Catch show stoppers (incompletable animation)
-                if (!(set & AnimationSettings::Type)) {
-                    context->throwError(QScriptContext::TypeError, QString=
Literal("Type property missing in animation options"));
-                    continue;
-                }
-                if (!(set & AnimationSettings::Duration)) {
-                    context->throwError(QScriptContext::TypeError, QString=
Literal("Duration property missing in animation options"));
-                    continue;
-                }
-                // Complete local animations from global settings
-                if (!(s.set & AnimationSettings::Duration)) {
-                    s.duration =3D settings.at(0).duration;
-                }
-                if (!(s.set & AnimationSettings::Curve)) {
-                    s.curve =3D settings.at(0).curve;
-                }
-                if (!(s.set & AnimationSettings::Delay)) {
-                    s.delay =3D settings.at(0).delay;
-                }
-
-                s.metaData =3D 0;
-                typedef QMap<AnimationEffect::MetaType, QString> MetaTypeM=
ap;
-                static MetaTypeMap metaTypes({
-                    {AnimationEffect::SourceAnchor, QStringLiteral("source=
Anchor")},
-                    {AnimationEffect::TargetAnchor, QStringLiteral("target=
Anchor")},
-                    {AnimationEffect::RelativeSourceX, QStringLiteral("rel=
ativeSourceX")},
-                    {AnimationEffect::RelativeSourceY, QStringLiteral("rel=
ativeSourceY")},
-                    {AnimationEffect::RelativeTargetX, QStringLiteral("rel=
ativeTargetX")},
-                    {AnimationEffect::RelativeTargetY, QStringLiteral("rel=
ativeTargetY")},
-                    {AnimationEffect::Axis, QStringLiteral("axis")}
-                });
-
-                for (MetaTypeMap::const_iterator it =3D metaTypes.constBeg=
in(),
-                                                end =3D metaTypes.constEnd=
(); it !=3D end; ++it) {
-                    QScriptValue metaVal =3D value.property(*it);
-                    if (metaVal.isValid() && metaVal.isNumber()) {
-                        AnimationEffect::setMetaData(it.key(), metaVal.toI=
nt32(), s.metaData);
-                    }
-                }
-
-                settings << s;
-            }
-        }
-    }
-
-    if (settings.count() =3D=3D 1) {
-        const uint set =3D settings.at(0).set;
-        if (!(set & AnimationSettings::Type)) {
-            context->throwError(QScriptContext::TypeError, QStringLiteral(=
"Type property missing in animation options"));
-            settings.clear();
-        }
-        if (!(set & AnimationSettings::Duration)) {
-            context->throwError(QScriptContext::TypeError, QStringLiteral(=
"Duration property missing in animation options"));
-            settings.clear();
-        }
-    } else if (!(settings.at(0).set & AnimationSettings::Type)) { // inval=
id global
-        settings.removeAt(0); // -> get rid of it, only used to complete t=
he others
-    }
-
-    return settings;
-}
-
-QScriptValue kwinEffectAnimate(QScriptContext *context, QScriptEngine *eng=
ine)
-{
-    ScriptedEffect *effect =3D qobject_cast<ScriptedEffect*>(context->call=
ee().data().toQObject());
-    EffectWindow *window;
-    QList<AnimationSettings> settings =3D animationSettings(context, effec=
t, &window);
-    if (settings.empty()) {
-        context->throwError(QScriptContext::TypeError, QStringLiteral("No =
animations provided"));
-        return engine->undefinedValue();
-    }
-    if (!window) {
-        context->throwError(QScriptContext::TypeError, QStringLiteral("Win=
dow property does not contain an EffectWindow"));
-        return engine->undefinedValue();
-    }
-
-    QScriptValue array =3D engine->newArray(settings.length());
-    int i =3D 0;
-    foreach (const AnimationSettings &setting, settings) {
-        array.setProperty(i, (uint)effect->animate(window,
-                                    setting.type,
-                                    setting.duration,
-                                    setting.to,
-                                    setting.from,
-                                    setting.metaData,
-                                    setting.curve,
-                                    setting.delay));
-        ++i;
-    }
-    return array;
-}
-
-QScriptValue kwinEffectSet(QScriptContext *context, QScriptEngine *engine)
-{
-    ScriptedEffect *effect =3D qobject_cast<ScriptedEffect*>(context->call=
ee().data().toQObject());
-
-    EffectWindow *window;
-    QList<AnimationSettings> settings =3D animationSettings(context, effec=
t, &window);
-    if (settings.empty()) {
-        context->throwError(QScriptContext::TypeError, QStringLiteral("No =
animations provided"));
-        return engine->undefinedValue();
-    }
-    if (!window) {
-        context->throwError(QScriptContext::TypeError, QStringLiteral("Win=
dow property does not contain an EffectWindow"));
-        return engine->undefinedValue();
-    }
-
-    QList<QVariant> animIds;
-    foreach (const AnimationSettings &setting, settings) {
-        animIds << QVariant(effect->set(window,
-                               setting.type,
-                               setting.duration,
-                               setting.to,
-                               setting.from,
-                               setting.metaData,
-                               setting.curve,
-                               setting.delay));
-    }
-
-    return engine->newVariant(animIds);
+//QList<AnimationSettings> animationSettings(QScriptContext *context, Scri=
ptedEffect *effect, EffectWindow **window)
+//{
+//    QList<AnimationSettings> settings;
+//    if (!effect) {
+//        context->throwError(QScriptContext::ReferenceError, QStringLiter=
al("Internal Scripted KWin Effect error"));
+//        return settings;
+//    }
+//    if (context->argumentCount() !=3D 1) {
+//        context->throwError(QScriptContext::SyntaxError, QStringLiteral(=
"Exactly one argument expected"));
+//        return settings;
+//    }
+//    if (!context->argument(0).isObject()) {
+//        context->throwError(QScriptContext::TypeError, QStringLiteral("A=
rgument needs to be an object"));
+//        return settings;
+//    }
+//    QJSValue object =3D context->argument(0);
+//    QJSValue windowProperty =3D object.property(QStringLiteral("window")=
);
+//    if (!windowProperty.isValid() || !windowProperty.isObject()) {
+//        context->throwError(QScriptContext::TypeError, QStringLiteral("W=
indow property missing in animation options"));
+//        return settings;
+//    }
+//    *window =3D qobject_cast<EffectWindow*>(windowProperty.toQObject());
+
+//    settings << animationSettingsFromObject(object); // global
+
+//    QJSValue animations =3D object.property(QStringLiteral("animations")=
); // array
+//    if (!animations.isNull()) {
+//        if (!animations.isArray()) {
+//            context->throwError(QScriptContext::TypeError, QStringLitera=
l("Animations provided but not an array"));
+//            settings.clear();
+//            return settings;
+//        }
+//        const int length =3D static_cast<int>(animations.property(QStrin=
gLiteral("length")).toInteger());
+//        for (int i=3D0; i<length; ++i) {
+//            QJSValue value =3D animations.property(QString::number(i));
+//            if (!value.isValid()) {
+//                continue;
+//            }
+//            if (value.isObject()) {
+//                AnimationSettings s =3D animationSettingsFromObject(valu=
e);
+//                const uint set =3D s.set | settings.at(0).set;
+//                // Catch show stoppers (incompletable animation)
+//                if (!(set & AnimationSettings::Type)) {
+//                    context->throwError(QScriptContext::TypeError, QStri=
ngLiteral("Type property missing in animation options"));
+//                    continue;
+//                }
+//                if (!(set & AnimationSettings::Duration)) {
+//                    context->throwError(QScriptContext::TypeError, QStri=
ngLiteral("Duration property missing in animation options"));
+//                    continue;
+//                }
+//                // Complete local animations from global settings
+//                if (!(s.set & AnimationSettings::Duration)) {
+//                    s.duration =3D settings.at(0).duration;
+//                }
+//                if (!(s.set & AnimationSettings::Curve)) {
+//                    s.curve =3D settings.at(0).curve;
+//                }
+//                if (!(s.set & AnimationSettings::Delay)) {
+//                    s.delay =3D settings.at(0).delay;
+//                }
+
+//                s.metaData =3D 0;
+//                typedef QMap<AnimationEffect::MetaType, QString> MetaTyp=
eMap;
+//                static MetaTypeMap metaTypes({
+//                    {AnimationEffect::SourceAnchor, QStringLiteral("sour=
ceAnchor")},
+//                    {AnimationEffect::TargetAnchor, QStringLiteral("targ=
etAnchor")},
+//                    {AnimationEffect::RelativeSourceX, QStringLiteral("r=
elativeSourceX")},
+//                    {AnimationEffect::RelativeSourceY, QStringLiteral("r=
elativeSourceY")},
+//                    {AnimationEffect::RelativeTargetX, QStringLiteral("r=
elativeTargetX")},
+//                    {AnimationEffect::RelativeTargetY, QStringLiteral("r=
elativeTargetY")},
+//                    {AnimationEffect::Axis, QStringLiteral("axis")}
+//                });
+
+//                for (MetaTypeMap::const_iterator it =3D metaTypes.constB=
egin(),
+//                                                end =3D metaTypes.constE=
nd(); it !=3D end; ++it) {
+//                    QJSValue metaVal =3D value.property(*it);
+//                    if (metaVal.isNumber()) {
+//                        AnimationEffect::setMetaData(it.key(), metaVal.t=
oInt(), s.metaData);
+//                    }
+//                }
+
+//                settings << s;
+//            }
+//        }
+//    }
+
+//    if (settings.count() =3D=3D 1) {
+//        const uint set =3D settings.at(0).set;
+//        if (!(set & AnimationSettings::Type)) {
+//            context->throwError(QScriptContext::TypeError, QStringLitera=
l("Type property missing in animation options"));
+//            settings.clear();
+//        }
+//        if (!(set & AnimationSettings::Duration)) {
+//            context->throwError(QScriptContext::TypeError, QStringLitera=
l("Duration property missing in animation options"));
+//            settings.clear();
+//        }
+//    } else if (!(settings.at(0).set & AnimationSettings::Type)) { // inv=
alid global
+//        settings.removeAt(0); // -> get rid of it, only used to complete=
 the others
+//    }
+
+//    return settings;
+//}
+
+QJSValue kwinEffectAnimate(QScriptContext *context, QJSEngine *engine)
+{
+//    ScriptedEffect *effect =3D qobject_cast<ScriptedEffect*>(context->ca=
llee().data().toQObject());
+//    EffectWindow *window;
+//    QList<AnimationSettings> settings =3D animationSettings(context, eff=
ect, &window);
+//    if (settings.empty()) {
+//        context->throwError(QScriptContext::TypeError, QStringLiteral("N=
o animations provided"));
+//        return QJSValue();
+//    }
+//    if (!window) {
+//        context->throwError(QScriptContext::TypeError, QStringLiteral("W=
indow property does not contain an EffectWindow"));
+//        return QJSValue();
+//    }
+
+//    QJSValue array =3D engine->newArray(settings.length());
+//    int i =3D 0;
+//    foreach (const AnimationSettings &setting, settings) {
+//        array.setProperty(i, (uint)effect->animate(window,
+//                                    setting.type,
+//                                    setting.duration,
+//                                    setting.to,
+//                                    setting.from,
+//                                    setting.metaData,
+//                                    setting.curve,
+//                                    setting.delay));
+//        ++i;
+//    }
+//    return array;
+    return QJSValue();
+}
+
+QJSValue kwinEffectSet(QScriptContext *context, QJSEngine *engine)
+{
+    return QJSValue();
+
+
+//    ScriptedEffect *effect =3D qobject_cast<ScriptedEffect*>(context->ca=
llee().data().toQObject());
+
+//    EffectWindow *window;
+//    QList<AnimationSettings> settings =3D animationSettings(context, eff=
ect, &window);
+//    if (settings.empty()) {
+//        context->throwError(QScriptContext::TypeError, QStringLiteral("N=
o animations provided"));
+//        return QJSValue();
+//    }
+//    if (!window) {
+//        context->throwError(QScriptContext::TypeError, QStringLiteral("W=
indow property does not contain an EffectWindow"));
+//        return QJSValue();
+//    }
+
+//    QList<QVariant> animIds;
+//    foreach (const AnimationSettings &setting, settings) {
+//        animIds << QVariant(effect->set(window,
+//                               setting.type,
+//                               setting.duration,
+//                               setting.to,
+//                               setting.from,
+//                               setting.metaData,
+//                               setting.curve,
+//                               setting.delay));
+//    }
+
+//    return engine->newVariant(animIds);
 }
 =

 QList<quint64> animations(const QVariant &v, bool *ok)
@@ -344,15 +354,15 @@ QList<quint64> animations(const QVariant &v, bool *ok)
     return animIds;
 }
 =

-QScriptValue fpx2ToScriptValue(QScriptEngine *eng, const KWin::FPx2 &fpx2)
+QJSValue fpx2ToScriptValue(QJSEngine *eng, const KWin::FPx2 &fpx2)
 {
-    QScriptValue val =3D eng->newObject();
+    QJSValue val =3D eng->newObject();
     val.setProperty(QStringLiteral("value1"), fpx2[0]);
     val.setProperty(QStringLiteral("value2"), fpx2[1]);
     return val;
 }
 =

-void fpx2FromScriptValue(const QScriptValue &value, KWin::FPx2 &fpx2)
+void fpx2FromScriptValue(const QJSValue &value, KWin::FPx2 &fpx2)
 {
     if (value.isNull()) {
         fpx2 =3D FPx2();
@@ -363,9 +373,9 @@ void fpx2FromScriptValue(const QScriptValue &value, KWi=
n::FPx2 &fpx2)
         return;
     }
     if (value.isObject()) {
-        QScriptValue value1 =3D value.property(QStringLiteral("value1"));
-        QScriptValue value2 =3D value.property(QStringLiteral("value2"));
-        if (!value1.isValid() || !value2.isValid() || !value1.isNumber() |=
| !value2.isNumber()) {
+        QJSValue value1 =3D value.property(QStringLiteral("value1"));
+        QJSValue value2 =3D value.property(QStringLiteral("value2"));
+        if (!value1.isNumber() || !value2.isNumber()) {
             qCDebug(KWIN_SCRIPTING) << "Cannot cast scripted FPx2 to C++";
             fpx2 =3D FPx2();
             return;
@@ -374,63 +384,66 @@ void fpx2FromScriptValue(const QScriptValue &value, K=
Win::FPx2 &fpx2)
     }
 }
 =

-QScriptValue kwinEffectRetarget(QScriptContext *context, QScriptEngine *en=
gine)
+QJSValue kwinEffectRetarget(QScriptContext *context, QJSEngine *engine)
 {
-    ScriptedEffect *effect =3D qobject_cast<ScriptedEffect*>(context->call=
ee().data().toQObject());
-    if (context->argumentCount() < 2 || context->argumentCount() > 3) {
-        context->throwError(QScriptContext::SyntaxError, QStringLiteral("2=
 or 3 arguments expected"));
-        return engine->undefinedValue();
-    }
-    QVariant v =3D context->argument(0).toVariant();
-    bool ok =3D false;
-    QList<quint64> animIds =3D animations(v, &ok);
-    if (!ok) {
-        context->throwError(QScriptContext::TypeError, QStringLiteral("Arg=
ument needs to be one or several quint64"));
-        return engine->undefinedValue();
-    }
-    FPx2 target;
-    fpx2FromScriptValue(context->argument(1), target);
+//    ScriptedEffect *effect =3D qobject_cast<ScriptedEffect*>(context->ca=
llee().data().toQObject());
+//    if (context->argumentCount() < 2 || context->argumentCount() > 3) {
+//        context->throwError(QScriptContext::SyntaxError, QStringLiteral(=
"2 or 3 arguments expected"));
+//        return QJSValue();
+//    }
+//    QVariant v =3D context->argument(0).toVariant();
+//    bool ok =3D false;
+//    QList<quint64> animIds =3D animations(v, &ok);
+//    if (!ok) {
+//        context->throwError(QScriptContext::TypeError, QStringLiteral("A=
rgument needs to be one or several quint64"));
+//        return QJSValue();
+//    }
+//    FPx2 target;
+//    fpx2FromScriptValue(context->argument(1), target);
 =

-    ok =3D false;
-    const int remainingTime =3D context->argumentCount() =3D=3D 3 ? contex=
t->argument(2).toVariant().toInt() : -1;
-    foreach (const quint64 &animId, animIds) {
-        ok =3D effect->retarget(animId, target, remainingTime);
-        if (!ok) {
-            break;
-        }
-    }
+//    ok =3D false;
+//    const int remainingTime =3D context->argumentCount() =3D=3D 3 ? cont=
ext->argument(2).toVariant().toInt() : -1;
+//    foreach (const quint64 &animId, animIds) {
+//        ok =3D effect->retarget(animId, target, remainingTime);
+//        if (!ok) {
+//            break;
+//        }
+//    }
 =

-    return QScriptValue(ok);
+    return QJSValue();
 }
 =

-QScriptValue kwinEffectCancel(QScriptContext *context, QScriptEngine *engi=
ne)
+QJSValue kwinEffectCancel(QScriptContext *context, QJSEngine *engine)
 {
     ScriptedEffect *effect =3D qobject_cast<ScriptedEffect*>(context->call=
ee().data().toQObject());
     if (context->argumentCount() !=3D 1) {
         context->throwError(QScriptContext::SyntaxError, QStringLiteral("E=
xactly one argument expected"));
-        return engine->undefinedValue();
+        return QJSValue();
     }
     QVariant v =3D context->argument(0).toVariant();
     bool ok =3D false;
     QList<quint64> animIds =3D animations(v, &ok);
     if (!ok) {
         context->throwError(QScriptContext::TypeError, QStringLiteral("Arg=
ument needs to be one or several quint64"));
-        return engine->undefinedValue();
+        return QJSValue();
     }
     foreach (const quint64 &animId, animIds) {
-        ok |=3D engine->newVariant(effect->cancel(animId)).toBool();
+        ok |=3D effect->cancel(animId);
     }
 =

-    return engine->newVariant(ok);
+    return QJSValue(ok);
 }
 =

-QScriptValue effectWindowToScriptValue(QScriptEngine *eng, const KEffectWi=
ndowRef &window)
+QJSValue effectWindowToScriptValue(QJSEngine *eng, const KEffectWindowRef =
&window)
 {
-    return eng->newQObject(window, QScriptEngine::QtOwnership,
-                           QScriptEngine::ExcludeChildObjects | QScriptEng=
ine::ExcludeDeleteLater | QScriptEngine::PreferExistingWrapperObject);
+
+    //TODO
+    return eng->newQObject(window);
+//    return eng->newQObject(window, QJSEngine::QtOwnership,
+//                           QJSEngine::ExcludeChildObjects | QJSEngine::E=
xcludeDeleteLater | QJSEngine::PreferExistingWrapperObject);
 }
 =

-void effectWindowFromScriptValue(const QScriptValue &value, EffectWindow* =
&window)
+void effectWindowFromScriptValue(const QJSValue &value, EffectWindow* &win=
dow)
 {
     window =3D qobject_cast<EffectWindow*>(value.toQObject());
 }
@@ -470,12 +483,12 @@ bool ScriptedEffect::supported()
 =

 ScriptedEffect::ScriptedEffect()
     : AnimationEffect()
-    , m_engine(new QScriptEngine(this))
+    , m_engine(new QJSEngine(this))
     , m_scriptFile(QString())
     , m_config(nullptr)
     , m_chainPosition(0)
 {
-    connect(m_engine, SIGNAL(signalHandlerException(QScriptValue)), SLOT(s=
ignalHandlerException(QScriptValue)));
+//    connect(m_engine, SIGNAL(signalHandlerException(QJSValue)), SLOT(sig=
nalHandlerException(QJSValue)));
 }
 =

 ScriptedEffect::~ScriptedEffect()
@@ -501,60 +514,61 @@ bool ScriptedEffect::init(const QString &effectName, =
const QString &pathToScript
         m_config->load();
     }
 =

-    QScriptValue effectsObject =3D m_engine->newQObject(effects, QScriptEn=
gine::QtOwnership, QScriptEngine::ExcludeDeleteLater);
-    m_engine->globalObject().setProperty(QStringLiteral("effects"), effect=
sObject, QScriptValue::Undeletable);
+//    QJSValue effectsObject =3D m_engine->newQObject(effects);
+//    m_engine->globalObject().setProperty(QStringLiteral("effects"), effe=
ctsObject);
     m_engine->globalObject().setProperty(QStringLiteral("Effect"), m_engin=
e->newQMetaObject(&ScriptedEffect::staticMetaObject));
 #ifndef KWIN_UNIT_TEST
     m_engine->globalObject().setProperty(QStringLiteral("KWin"), m_engine-=
>newQMetaObject(&QtScriptWorkspaceWrapper::staticMetaObject));
 #endif
     m_engine->globalObject().setProperty(QStringLiteral("QEasingCurve"), m=
_engine->newQMetaObject(&QEasingCurve::staticMetaObject));
-    m_engine->globalObject().setProperty(QStringLiteral("effect"), m_engin=
e->newQObject(this, QScriptEngine::QtOwnership, QScriptEngine::ExcludeDelet=
eLater), QScriptValue::Undeletable);
-    MetaScripting::registration(m_engine);
-    qScriptRegisterMetaType<KEffectWindowRef>(m_engine, effectWindowToScri=
ptValue, effectWindowFromScriptValue);
-    qScriptRegisterMetaType<KWin::FPx2>(m_engine, fpx2ToScriptValue, fpx2F=
romScriptValue);
-    qScriptRegisterSequenceMetaType<QList< KWin::EffectWindow* > >(m_engin=
e);
-    // add our print
-    QScriptValue printFunc =3D m_engine->newFunction(kwinEffectScriptPrint=
);
-    printFunc.setData(m_engine->newQObject(this));
-    m_engine->globalObject().setProperty(QStringLiteral("print"), printFun=
c);
-    // add our animationTime
-    QScriptValue animationTimeFunc =3D m_engine->newFunction(kwinEffectScr=
iptAnimationTime);
-    animationTimeFunc.setData(m_engine->newQObject(this));
-    m_engine->globalObject().setProperty(QStringLiteral("animationTime"), =
animationTimeFunc);
-    // add displayWidth and displayHeight
-    QScriptValue displayWidthFunc =3D m_engine->newFunction(kwinEffectDisp=
layWidth);
-    m_engine->globalObject().setProperty(QStringLiteral("displayWidth"), d=
isplayWidthFunc);
-    QScriptValue displayHeightFunc =3D m_engine->newFunction(kwinEffectDis=
playHeight);
-    m_engine->globalObject().setProperty(QStringLiteral("displayHeight"), =
displayHeightFunc);
-    // add global Shortcut
-    registerGlobalShortcutFunction(this, m_engine, kwinScriptGlobalShortcu=
t);
-    registerScreenEdgeFunction(this, m_engine, kwinScriptScreenEdge);
-    registerTouchScreenEdgeFunction(this, m_engine, kwinRegisterTouchScree=
nEdge);
-    unregisterTouchScreenEdgeFunction(this, m_engine, kwinUnregisterTouchS=
creenEdge);
-    // add the animate method
-    QScriptValue animateFunc =3D m_engine->newFunction(kwinEffectAnimate);
-    animateFunc.setData(m_engine->newQObject(this));
-    m_engine->globalObject().setProperty(QStringLiteral("animate"), animat=
eFunc);
-
-    // and the set variant
-    QScriptValue setFunc =3D m_engine->newFunction(kwinEffectSet);
-    setFunc.setData(m_engine->newQObject(this));
-    m_engine->globalObject().setProperty(QStringLiteral("set"), setFunc);
-
-    // retarget
-    QScriptValue retargetFunc =3D m_engine->newFunction(kwinEffectRetarget=
);
-    retargetFunc.setData(m_engine->newQObject(this));
-    m_engine->globalObject().setProperty(QStringLiteral("retarget"), retar=
getFunc);
-
-    // cancel...
-    QScriptValue cancelFunc =3D m_engine->newFunction(kwinEffectCancel);
-    cancelFunc.setData(m_engine->newQObject(this));
-    m_engine->globalObject().setProperty(QStringLiteral("cancel"), cancelF=
unc);
-
-    QScriptValue ret =3D m_engine->evaluate(QString::fromUtf8(scriptFile.r=
eadAll()));
-
+//    m_engine->globalObject().setProperty(QStringLiteral("effect"), m_eng=
ine->newQObject(this, QJSEngine::QtOwnership, QJSEngine::ExcludeDeleteLater=
), QJSValue::Undeletable);
+//    MetaScripting::registration(m_engine);
+//    qScriptRegisterMetaType<KEffectWindowRef>(m_engine, effectWindowToSc=
riptValue, effectWindowFromScriptValue);
+//    qScriptRegisterMetaType<KWin::FPx2>(m_engine, fpx2ToScriptValue, fpx=
2FromScriptValue);
+//    qScriptRegisterSequenceMetaType<QList< KWin::EffectWindow* > >(m_eng=
ine);
+//    // add our print
+//    QJSValue printFunc =3D m_engine->newFunction(kwinEffectScriptPrint);
+//    printFunc.setData(m_engine->newQObject(this));
+//    m_engine->globalObject().setProperty(QStringLiteral("print"), printF=
unc);
+//    // add our animationTime
+//    QJSValue animationTimeFunc =3D m_engine->newFunction(kwinEffectScrip=
tAnimationTime);
+//    animationTimeFunc.setData(m_engine->newQObject(this));
+//    m_engine->globalObject().setProperty(QStringLiteral("animationTime")=
, animationTimeFunc);
+//    // add displayWidth and displayHeight
+//    QJSValue displayWidthFunc =3D m_engine->newFunction(kwinEffectDispla=
yWidth);
+//    m_engine->globalObject().setProperty(QStringLiteral("displayWidth"),=
 displayWidthFunc);
+//    QJSValue displayHeightFunc =3D m_engine->newFunction(kwinEffectDispl=
ayHeight);
+//    m_engine->globalObject().setProperty(QStringLiteral("displayHeight")=
, displayHeightFunc);
+//    // add global Shortcut
+//    registerGlobalShortcutFunction(this, m_engine, kwinScriptGlobalShort=
cut);
+//    registerScreenEdgeFunction(this, m_engine, kwinScriptScreenEdge);
+//    registerTouchScreenEdgeFunction(this, m_engine, kwinRegisterTouchScr=
eenEdge);
+//    unregisterTouchScreenEdgeFunction(this, m_engine, kwinUnregisterTouc=
hScreenEdge);
+//    // add the animate method
+//    QJSValue animateFunc =3D m_engine->newFunction(kwinEffectAnimate);
+//    animateFunc.setData(m_engine->newQObject(this));
+//    m_engine->globalObject().setProperty(QStringLiteral("animate"), anim=
ateFunc);
+
+//    // and the set variant
+//    QJSValue setFunc =3D m_engine->newFunction(kwinEffectSet);
+//    setFunc.setData(m_engine->newQObject(this));
+//    m_engine->globalObject().setProperty(QStringLiteral("set"), setFunc);
+
+//    // retarget
+//    QJSValue retargetFunc =3D m_engine->newFunction(kwinEffectRetarget);
+//    retargetFunc.setData(m_engine->newQObject(this));
+//    m_engine->globalObject().setProperty(QStringLiteral("retarget"), ret=
argetFunc);
+
+//    // cancel...
+//    QJSValue cancelFunc =3D m_engine->newFunction(kwinEffectCancel);
+//    cancelFunc.setData(m_engine->newQObject(this));
+//    m_engine->globalObject().setProperty(QStringLiteral("cancel"), cance=
lFunc);
+
+    QJSValue ret =3D m_engine->evaluate(QString::fromUtf8(scriptFile.readA=
ll()));
+
+//    qDebug() <<" HERE! " << ret.toString();
     if (ret.isError()) {
-        signalHandlerException(ret);
+//        signalHandlerException(ret);
         return false;
     }
     scriptFile.close();
@@ -567,19 +581,20 @@ void ScriptedEffect::animationEnded(KWin::EffectWindo=
w *w, Attribute a, uint met
     emit animationEnded(w, 0);
 }
 =

-void ScriptedEffect::signalHandlerException(const QScriptValue &value)
-{
-    if (value.isError()) {
-        qCDebug(KWIN_SCRIPTING) << "KWin Effect script encountered an erro=
r at [Line " << m_engine->uncaughtExceptionLineNumber() << "]";
-        qCDebug(KWIN_SCRIPTING) << "Message: " << value.toString();
+//TODO port to QQmlEngine::warnings
+//void ScriptedEffect::signalHandlerException(const QJSValue &value)
+//{
+//    if (value.isError()) {
+//        qCDebug(KWIN_SCRIPTING) << "KWin Effect script encountered an er=
ror at [Line " << m_engine->uncaughtExceptionLineNumber() << "]";
+//        qCDebug(KWIN_SCRIPTING) << "Message: " << value.toString();
 =

-        QScriptValueIterator iter(value);
-        while (iter.hasNext()) {
-            iter.next();
-            qCDebug(KWIN_SCRIPTING) << " " << iter.name() << ": " << iter.=
value().toString();
-        }
-    }
-}
+//        QJSValueIterator iter(value);
+//        while (iter.hasNext()) {
+//            iter.next();
+//            qCDebug(KWIN_SCRIPTING) << " " << iter.name() << ": " << ite=
r.value().toString();
+//        }
+//    }
+//}
 =

 quint64 ScriptedEffect::animate(KWin::EffectWindow* w, KWin::AnimationEffe=
ct::Attribute a, int ms, KWin::FPx2 to, KWin::FPx2 from, uint metaData, QEa=
singCurve::Type curve, int delay)
 {
@@ -625,7 +640,7 @@ void ScriptedEffect::reconfigure(ReconfigureFlags flags)
     emit configChanged();
 }
 =

-void ScriptedEffect::registerShortcut(QAction *a, QScriptValue callback)
+void ScriptedEffect::registerShortcut(QAction *a, QJSValue callback)
 {
     m_shortcutCallbacks.insert(a, callback);
     connect(a, SIGNAL(triggered(bool)), SLOT(globalShortcutTriggered()));
@@ -633,12 +648,12 @@ void ScriptedEffect::registerShortcut(QAction *a, QSc=
riptValue callback)
 =

 void ScriptedEffect::globalShortcutTriggered()
 {
-    callGlobalShortcutCallback<KWin::ScriptedEffect*>(this, sender());
+//    callGlobalShortcutCallback<KWin::ScriptedEffect*>(this, sender());
 }
 =

 bool ScriptedEffect::borderActivated(ElectricBorder edge)
 {
-    screenEdgeActivated(this, edge);
+//    screenEdgeActivated(this, edge);
     return true;
 }
 =

@@ -650,7 +665,7 @@ QVariant ScriptedEffect::readConfig(const QString &key,=
 const QVariant defaultVa
     return m_config->property(key);
 }
 =

-bool ScriptedEffect::registerTouchScreenCallback(int edge, QScriptValue ca=
llback)
+bool ScriptedEffect::registerTouchScreenCallback(int edge, QJSValue callba=
ck)
 {
     if (m_touchScreenEdgeCallbacks.constFind(edge) !=3D m_touchScreenEdgeC=
allbacks.constEnd()) {
         return false;
@@ -658,7 +673,7 @@ bool ScriptedEffect::registerTouchScreenCallback(int ed=
ge, QScriptValue callback
     QAction *action =3D new QAction(this);
     connect(action, &QAction::triggered, this,
         [callback] {
-            QScriptValue invoke(callback);
+            QJSValue invoke(callback);
             invoke.call();
         }
     );
@@ -678,7 +693,7 @@ bool ScriptedEffect::unregisterTouchScreenCallback(int =
edge)
     return true;
 }
 =

-QScriptEngine *ScriptedEffect::engine() const
+QJSEngine *ScriptedEffect::engine() const
 {
     return m_engine;
 }
diff --git a/scripting/scriptedeffect.h b/scripting/scriptedeffect.h
index 0d6dea2e3..3fbdec51e 100644
--- a/scripting/scriptedeffect.h
+++ b/scripting/scriptedeffect.h
@@ -25,8 +25,8 @@ along with this program.  If not, see <http://www.gnu.org=
/licenses/>.
 =

 class KConfigLoader;
 class KPluginMetaData;
-class QScriptEngine;
-class QScriptValue;
+class QJSEngine;
+class QJSValue;
 =

 namespace KWin
 {
@@ -83,15 +83,15 @@ public:
      * @returns The config value if present
      **/
     Q_SCRIPTABLE QVariant readConfig(const QString &key, const QVariant de=
faultValue =3D QVariant());
-    void registerShortcut(QAction *a, QScriptValue callback);
-    const QHash<QAction*, QScriptValue> &shortcutCallbacks() const {
+    void registerShortcut(QAction *a, QJSValue callback);
+    const QHash<QAction*, QJSValue> &shortcutCallbacks() const {
         return m_shortcutCallbacks;
     }
-    QHash<int, QList<QScriptValue > > &screenEdgeCallbacks() {
+    QHash<int, QList<QJSValue > > &screenEdgeCallbacks() {
         return m_screenEdgeCallbacks;
     }
 =

-    bool registerTouchScreenCallback(int edge, QScriptValue callback);
+    bool registerTouchScreenCallback(int edge, QJSValue callback);
     bool unregisterTouchScreenCallback(int edge);
 =

 public Q_SLOTS:
@@ -110,19 +110,18 @@ Q_SIGNALS:
 =

 protected:
     ScriptedEffect();
-    QScriptEngine *engine() const;
+    QJSEngine *engine() const;
     bool init(const QString &effectName, const QString &pathToScript);
     void animationEnded(KWin::EffectWindow *w, Attribute a, uint meta);
 =

 private Q_SLOTS:
-    void signalHandlerException(const QScriptValue &value);
     void globalShortcutTriggered();
 private:
-    QScriptEngine *m_engine;
+    QJSEngine *m_engine;
     QString m_effectName;
     QString m_scriptFile;
-    QHash<QAction*, QScriptValue> m_shortcutCallbacks;
-    QHash<int, QList<QScriptValue> > m_screenEdgeCallbacks;
+    QHash<QAction*, QJSValue> m_shortcutCallbacks;
+    QHash<int, QList<QJSValue> > m_screenEdgeCallbacks;
     KConfigLoader *m_config;
     int m_chainPosition;
     QHash<int, QAction*> m_touchScreenEdgeCallbacks;