scripting: allow creation of custom variables

src/CMakeLists.txt

@@ -84,6 +84,9 @@ set(libinputactions_SRCS
     libinputactions/interfaces/WindowProvider.cpp
     libinputactions/scripting/modules/core/Config.cpp
     libinputactions/scripting/modules/core/CoreModule.cpp
+    libinputactions/scripting/modules/core/StoredVariableWrapper.cpp
+    libinputactions/scripting/modules/core/VariableRegistryWrapper.cpp
+    libinputactions/scripting/modules/core/VariableWrapper.cpp
     libinputactions/scripting/modules/fs/File.cpp
     libinputactions/scripting/modules/main/MainModule.cpp
     libinputactions/scripting/modules/main/Script.cpp

src/libinputactions/InputActionsMain.cpp

@@ -98,9 +98,12 @@ void InputActionsMain::setMissingImplementations()
     setMissingImplementation(g_configLoader);
     setMissingImplementation(g_globalConfig);
     setMissingImplementation(g_inputBackend);
-    setMissingImplementation(g_scriptingEngine);
     setMissingImplementation(g_strokeRecorder);
     setMissingImplementation(g_variableRegistry);
+
+    if (!g_scriptingEngine) {
+        g_scriptingEngine = std::make_shared<ScriptingEngine>(*g_variableRegistry.get());
+    }
 }
 
 void InputActionsMain::registerGlobalVariables(VariableRegistry *variableRegistry, std::shared_ptr<PointerPositionGetter> pointerPositionGetter,

src/libinputactions/config/ConfigLoader.cpp

@@ -17,11 +17,11 @@
 */
 
 #include "ConfigLoader.h"
+#include "ConfigIssue.h"
 #include "ConfigIssueManager.h"
 #include "GlobalConfig.h"
+#include "InputActionsMain.h"
 #include "Node.h"
-#include "config/ConfigIssue.h"
-#include "interfaces/ConfigProvider.h"
 #include "parsers/containers.h"
 #include "parsers/core.h"
 #include "parsers/utils.h"
@@ -35,11 +35,13 @@
 #include <libinputactions/handlers/TouchscreenTriggerHandler.h>
 #include <libinputactions/input/backends/LibevdevComplementaryInputBackend.h>
 #include <libinputactions/input/devices/InputDeviceRule.h>
+#include <libinputactions/interfaces/ConfigProvider.h>
 #include <libinputactions/interfaces/NotificationManager.h>
 #include <libinputactions/scripting/ScriptingEngine.h>
 #include <libinputactions/scripting/modules/core/Config.h>
 #include <libinputactions/scripting/modules/core/CoreModule.h>
 #include <libinputactions/scripting/modules/main/Script.h>
+#include <libinputactions/variables/VariableRegistry.h>
 
 namespace InputActions
 {
@@ -79,18 +81,22 @@ bool ConfigLoader::load(const ConfigLoadSettings &settings)
     };
 
     auto currentEngine = g_scriptingEngine;
+    auto currentVariableRegistry = g_variableRegistry;
     try {
         qCDebug(INPUTACTIONS, "Reloading config");
         const auto rawConfig = settings.config.value_or(g_configProvider->currentConfig());
 
         g_configIssueManager = std::make_shared<ConfigIssueManager>(rawConfig);
-        g_scriptingEngine = std::make_shared<ScriptingEngine>();
+        g_variableRegistry = std::make_shared<VariableRegistry>();
+        g_inputActions->registerGlobalVariables(g_variableRegistry.get());
+        g_scriptingEngine = std::make_shared<ScriptingEngine>(*g_variableRegistry.get());
         auto config = createConfig(rawConfig);
         destroyEngine(currentEngine);
         activateConfig(std::move(config), true);
     } catch (const ConfigException &e) {
         destroyEngine(g_scriptingEngine);
         g_scriptingEngine = currentEngine;
+        g_variableRegistry = currentVariableRegistry;
         g_configIssueManager->addIssue(e);
     }
 
@@ -158,6 +164,10 @@ ConfigData ConfigLoader::createConfig(const QString &raw)
         }
     }
 
+    if (auto *coreModule = g_scriptingEngine->coreModule()) {
+        coreModule->variableRegistry()->disableRegistration();
+    }
+
     loadMember(config.autoReload, root->at("autoreload"));
     loadMember(config.allowExternalVariableAccess, root->at("external_variable_access"));
     if (const auto *notificationsNode = root->mapAt("notifications")) {
@@ -195,7 +205,7 @@ void ConfigLoader::activateConfig(ConfigData config, bool initialize)
     g_actionExecutor->clearQueue();
     g_actionExecutor->waitForDone();
 
-    const auto *coreModule = g_scriptingEngine->coreModule();
+    auto *coreModule = g_scriptingEngine->coreModule();
     if (coreModule) {
         Q_EMIT coreModule->config()->aboutToBeActivated();
     }

src/libinputactions/globals.h

@@ -133,6 +133,17 @@ Q_ENUM_NS(TriggerType)
 Q_DECLARE_FLAGS(TriggerTypes, TriggerType)
 Q_DECLARE_OPERATORS_FOR_FLAGS(TriggerTypes)
 
+enum class VariableType
+{
+    Boolean,
+    CursorShape,
+    KeyboardModifiers,
+    Number,
+    Point,
+    String,
+};
+Q_ENUM_NS(VariableType)
+
 static inline TriggerType operator~(TriggerType value)
 {
     return TriggerType(~static_cast<uint32_t>(value));

src/libinputactions/scripting/ScriptingEngine.cpp

@@ -37,7 +37,10 @@ namespace InputActions
 static const std::chrono::milliseconds WATCHDOG_TIMER_TIMEOUT{2000};
 static const std::chrono::milliseconds WATCHDOG_TIMER_RESET_INTERVAL{1000};
 
-ScriptingEngine::ScriptingEngine() = default;
+ScriptingEngine::ScriptingEngine(VariableRegistry &variableRegistry)
+    : m_variableRegistry(variableRegistry)
+{
+}
 
 ScriptingEngine::~ScriptingEngine()
 {
@@ -69,10 +72,11 @@ void ScriptingEngine::initialize()
         }
     )");
 
-    m_coreModule = std::make_unique<CoreModule>();
+    m_coreModule = std::make_unique<CoreModule>(*this, m_variableRegistry);
     QJSEngine::setObjectOwnership(m_coreModule.get(), QJSEngine::CppOwnership);
     auto coreModule = m_engine->newQObject(m_coreModule.get());
     coreModule.setProperty("KeyboardModifier", newEnum<KeyboardModifier>());
+    coreModule.setProperty("VariableType", newEnum<VariableType>());
     registerBuiltinModule("inputactions/core", coreModule);
 
     auto desktopModule = m_engine->newObject();

src/libinputactions/scripting/ScriptingEngine.h

@@ -24,11 +24,14 @@
 #include <QObject>
 #include <memory>
 
+Q_DECLARE_LOGGING_CATEGORY(INPUTACTIONS_SCRIPTING)
+
 namespace InputActions
 {
 
 class CoreModule;
 class Promise;
+class VariableRegistry;
 
 /**
  * Lazily initializated.
@@ -40,7 +43,7 @@ class ScriptingEngine : public QObject
     Q_OBJECT
 
 public:
-    ScriptingEngine();
+    ScriptingEngine(VariableRegistry &variableRegistry);
     ~ScriptingEngine() override;
 
     /**
@@ -98,8 +101,9 @@ private slots:
     }
     QJSValue newEnum(const QMetaEnum &metaEnum);
 
-    std::optional<QJSEngine> m_engine;
+    VariableRegistry &m_variableRegistry;
 
+    std::optional<QJSEngine> m_engine;
     std::unique_ptr<CoreModule> m_coreModule;
     std::map<QString, QJSValue> m_builtinModules;
 

src/libinputactions/scripting/modules/core/CoreModule.cpp

@@ -18,35 +18,36 @@
 
 #include "CoreModule.h"
 #include "Config.h"
+#include "VariableRegistryWrapper.h"
 #include <QJSEngine>
 #include <libinputactions/input/backends/InputBackend.h>
 #include <libinputactions/scripting/ScriptingEngine.h>
-#include <libinputactions/variables/VariableRegistry.h>
 
 namespace InputActions
 {
 
-CoreModule::CoreModule()
-    : m_config(std::make_unique<Config>())
+CoreModule::CoreModule(ScriptingEngine &engine, VariableRegistry &variableRegistry)
+    : m_variableRegistry(variableRegistry, engine)
 {
-    QJSEngine::setObjectOwnership(m_config.get(), QJSEngine::CppOwnership);
+    QJSEngine::setObjectOwnership(&m_config, QJSEngine::CppOwnership);
+    QJSEngine::setObjectOwnership(&m_variableRegistry, QJSEngine::CppOwnership);
 }
 
 CoreModule::~CoreModule() = default;
 
-Config *CoreModule::config() const
+Config *CoreModule::config()
 {
-    return m_config.get();
+    return &m_config;
 }
 
 InputBackend *CoreModule::input() const
 {
     return g_inputBackend.get();
 }
 
-VariableRegistry *CoreModule::variableRegistry() const
+VariableRegistryWrapper *CoreModule::variableRegistry()
 {
-    return g_variableRegistry.get();
+    return &m_variableRegistry;
 }
 
 }

src/libinputactions/scripting/modules/core/CoreModule.h

@@ -18,35 +18,35 @@
 
 #pragma once
 
+#include "Config.h"
+#include "VariableRegistryWrapper.h"
 #include <QObject>
 
 namespace InputActions
 {
 
-class Config;
 class InputBackend;
 class ScriptingEngine;
-class VariableRegistry;
 
 class CoreModule : public QObject
 {
     Q_OBJECT
 
     Q_PROPERTY(Config *config READ config)
     Q_PROPERTY(InputBackend *input READ input)
-    Q_PROPERTY(VariableRegistry *variableRegistry READ variableRegistry)
+    Q_PROPERTY(VariableRegistryWrapper *variableRegistry READ variableRegistry)
 
 public:
-    CoreModule();
+    CoreModule(ScriptingEngine &engine, VariableRegistry &variableRegistry);
     ~CoreModule() override;
 
-    Config *config() const;
+    Config *config();
     InputBackend *input() const;
-    VariableRegistry *variableRegistry() const;
+    VariableRegistryWrapper *variableRegistry();
 
 private:
-    ScriptingEngine *m_engine;
-    std::unique_ptr<Config> m_config;
+    Config m_config;
+    VariableRegistryWrapper m_variableRegistry;
 };
 
 }

src/libinputactions/scripting/modules/core/StoredVariableWrapper.cpp

@@ -0,0 +1,45 @@
+/*
+    Input Actions - Input handler that executes user-defined actions
+    Copyright (C) 2024-2026 Marcin Woźniak
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include "StoredVariableWrapper.h"
+#include "VariableRegistryWrapper.h"
+#include <libinputactions/scripting/ScriptingEngine.h>
+#include <libinputactions/variables/StoredVariable.h>
+
+namespace InputActions
+{
+
+StoredVariableWrapper::StoredVariableWrapper(StoredVariable &variable, ScriptingEngine &engine)
+    : VariableWrapper(variable, engine)
+    , m_variable(variable)
+    , m_engine(engine)
+{
+}
+
+void StoredVariableWrapper::setValue(const QJSValue &value) const
+{
+    const auto variant = VariableRegistryWrapper::jsValueToVariant(value, type());
+    if (!variant) {
+        m_engine.ensureEngine().throwError(QString("New value does not match the variable's type."));
+        return;
+    }
+
+    m_variable.setValue(variant.value());
+}
+
+}

src/libinputactions/scripting/modules/core/StoredVariableWrapper.h

@@ -0,0 +1,47 @@
+/*
+    Input Actions - Input handler that executes user-defined actions
+    Copyright (C) 2024-2026 Marcin Woźniak
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "VariableWrapper.h"
+#include <QJSValue>
+#include <QObject>
+
+namespace InputActions
+{
+
+class ScriptingEngine;
+class StoredVariable;
+
+class StoredVariableWrapper : public VariableWrapper
+{
+    Q_OBJECT
+    Q_PROPERTY(QJSValue value READ value WRITE setValue OVERRIDE)
+
+public:
+    StoredVariableWrapper(StoredVariable &variable, ScriptingEngine &engine);
+
+    void setValue(const QJSValue &value) const;
+
+private:
+    StoredVariable &m_variable;
+
+    ScriptingEngine &m_engine;
+};
+
+}