isolate calls to the QtScript libraries to an interface we control

Heather Anderson committed 5 years ago

Commit 1e018db1 parent 713b29e260 files · +6904 −5064Browse files

Showing the changes to plugins/JSAPIExample/src/JSAPIExample.cpp (1 of 260 files). Show all

Unified · Split

plugins/JSAPIExample/src/JSAPIExample.cpp+23−16

 #include <QtCore/QLoggingCategory>
 #include <QtCore/QThread>
 #include <QtCore/QTimer>
-#include <QtScript/QScriptEngine>
-#include <QtScript/QScriptable>
 #include <SettingHelpers.h>  // for ::settingsFilename()
 #include <SharedUtil.h>      // for ::usecTimestampNow()
 #include <shared/ScriptInitializerMixin.h>
+#include <ScriptContext.h>
+#include <ScriptEngine.h>
+#include <ScriptManager.h>
+#include <ScriptValue.h>
+#include <Scriptable.h>
 // NOTE: replace this with your own namespace when starting a new plugin (to avoid .so/.dll symbol clashes)
 namespace REPLACE_ME_WITH_UNIQUE_NAME {
     QLoggingCategory logger { "jsapiexample" };
-    inline QVariant raiseScriptingError(QScriptContext* context, const QString& message, const QVariant& returnValue = QVariant()) {
+    inline QVariant raiseScriptingError(ScriptContext* context, const QString& message, const QVariant& returnValue = QVariant()) {
         if (context) {
-            // when a QScriptContext is available throw an actual JS Exception (which can be caught using try/catch on JS side)
+            // when a ScriptContext is available throw an actual JS Exception (which can be caught using try/catch on JS side)
             context->throwError(message);
         } else {
             // otherwise just log the error
     QObject* createScopedSettings(const QString& scope, QObject* parent, QString& error);
-    class JSAPIExample : public QObject, public QScriptable {
+    class JSAPIExample : public QObject, public Scriptable {
         Q_OBJECT
         Q_PLUGIN_METADATA(IID "JSAPIExample" FILE "plugin.json")
         Q_PROPERTY(QString version MEMBER _version CONSTANT)
                 return;
             }
             qCWarning(logger) << "registering w/ScriptInitializerMixin..." << scriptInit.data();
-            scriptInit->registerScriptInitializer([this](QScriptEngine* engine) {
+            scriptInit->registerScriptInitializer([this](ScriptEngine* engine) {
-                auto value = engine->newQObject(this, QScriptEngine::QtOwnership, QScriptEngine::ExcludeDeleteLater);
+                auto value = engine->newQObject(this, ScriptEngine::QtOwnership, ScriptEngine::ExcludeDeleteLater);
-                engine->globalObject().setProperty(objectName(), value);
+                engine->globalObject()->setProperty(objectName(), value);
                 // qCDebug(logger) << "setGlobalInstance" << objectName() << engine->property("fileName");
             });
             // qCInfo(logger) << "plugin loaded" << qApp << toString() << QThread::currentThread();
         // NOTES: everything within the "public slots:" section below will be available from JS via overall plugin QObject
         //    also, to demonstrate future-proofing JS API code, QVariant's are used throughout most of these examples --
-        //    which still makes them very Qt-specific, but avoids depending directly on deprecated QtScript/QScriptValue APIs.
+        //    which still makes them very Qt-specific, but avoids depending directly on deprecated ScriptValuePointer APIs.
         //    (as such this plugin class and its methods remain forward-compatible with other engines like QML's QJSEngine)
     public slots:
         /**
           * Example of exposing a custom "managed" C++ QObject to JS
-          * The lifecycle of the created QObject* instance becomes managed by the invoking QScriptEngine --
+          * The lifecycle of the created QObject* instance becomes managed by the invoking ScriptEngine --
           * it will be automatically cleaned up once no longer reachable from any JS variables/closures.
           * @example <caption>access persistent settings stored in separate .json files</caption>
           * var settings = JSAPIExample.getScopedSettings("example");
           * print("all example::* keys", settings.allKeys());
           * settings = null; // optional best pratice; allows the object to be reclaimed ASAP by the JS garbage collector
           */
-        QScriptValue getScopedSettings(const QString& scope) {
+        ScriptValuePointer getScopedSettings(const QString& scope) {
-            auto engine = QScriptable::engine();
+            auto engine = Scriptable::engine();
             if (!engine) {
-                return QScriptValue::NullValue;
+                return ScriptValuePointer();
+            }
+            auto manager = engine->manager();
+            if (!manager) {
+                return ScriptValuePointer();
             }
             QString error;
-            auto cppValue = createScopedSettings(scope, engine, error);
+            auto cppValue = createScopedSettings(scope, manager, error);
             if (!cppValue) {
                 raiseScriptingError(context(), "error creating scoped settings instance: " + error);
-                return QScriptValue::NullValue;
+                return engine->nullValue();
             }
-            return engine->newQObject(cppValue, QScriptEngine::ScriptOwnership, QScriptEngine::ExcludeDeleteLater);
+            return engine->newQObject(cppValue, ScriptEngine::ScriptOwnership, ScriptEngine::ExcludeDeleteLater);
         }
     private: