-

Author: aiekick

3rdparty/imguipack

@@ -100,6 +100,24 @@ struct CompletionEntry {
     std::string type;
 };
 
+// One argument descriptor inside a SignatureInfo. `type` is a free-form display string
+// ("number", "string", "table", "any", ...) — informational, no runtime semantics.
+struct SignatureArg {
+    std::string name;
+    std::string type;
+};
+
+// One function/method signature surfaced by the plugin for the signature-help tooltip (the IDE
+// hint that appears when the user types `(`, and that highlights the arg currently being typed).
+// `label` is what the tooltip displays before the parens (e.g. "ltg:addSignalTag"); `args` is
+// the ordered list of parameter descriptors. The plugin owns a curated catalog — Lua/LuaJIT
+// cannot introspect C-binding param names, and Lua function param names are not portable across
+// 5.1/5.2 / LuaJIT.
+struct SignatureInfo {
+    std::string label;
+    std::vector<SignatureArg> args;
+};
+
 // chunk name passed to the scripting runtime when compiling the in-memory project script.
 // the host's CodePane uses the SAME string as the sheet id, so a ScriptingError's `file` field
 // can be routed back to the matching sheet. keep both sides in sync.
@@ -156,6 +174,11 @@ struct ScriptingModule : public PluginModule, public IScriptDebugger {
     // table or sol2 usertype). default no-op so non-Lua plugins compile unchanged. consumed by the
     // host's autocompletion popup; called from the UI thread, fast (one Lua table walk).
     virtual void getCompletionEntries(const std::string& /*aTarget*/, std::vector<CompletionEntry>& /*aoEntries*/) {}
+    // returns the signature info for `aTarget:aFunctionName` (or `aTarget.aFunctionName`, or just
+    // `aFunctionName` when aTarget is empty) — used by the host signature-help tooltip when the
+    // user types `(`. default no-op so non-Lua plugins compile unchanged. An empty aoSignature
+    // (no label, no args) means "no signature known" — host then doesn't open the tooltip.
+    virtual void getSignatureInfo(const std::string& /*aTarget*/, const std::string& /*aFunctionName*/, SignatureInfo& /*aoSignature*/) {}
 };
 
 typedef std::shared_ptr<ScriptingModule> ScriptingModulePtr;

apis/LtgPluginApi.h

@@ -5,6 +5,7 @@
 #include <ezlibs/ezFile.hpp>
 #include <ezlibs/ezTime.hpp>
 #include <ezlibs/ezLog.hpp>
+#include <algorithm>
 #include <exception>
 #include <chrono>
 #include <ctime>
@@ -329,16 +330,36 @@ void Module::m_ensureCompletionState() {
     (*m_completionLuaPtr)["ltg"] = m_completionDatasModelPtr;
 }
 
+// Filter out keys that are Lua-internal metamethods (`__name`, `__index`, `__gc`, `__eq`,
+// `__pairs`, `__newindex`, `__type`, ...) and sol2-internal helpers (`class_check`, `class_cast`,
+// `new`). These appear in the metatable iteration but are noise from the user's POV — they
+// don't help write Lua, they expose implementation details.
+static bool s_isCompletionNoise(const std::string& aName) {
+    if (aName.size() >= 2 && aName[0] == '_' && aName[1] == '_') {
+        return true;  // any `__*` metamethod
+    }
+    if (aName.compare(0, 6, "class_") == 0) {
+        return true;  // sol2 inheritance bookkeeping (class_check, class_cast)
+    }
+    if (aName == "new") {
+        return true;  // sol2 default constructor binding — never useful through `:method()` autocompletion
+    }
+    return false;
+}
+
 void Module::m_iterateLuaTable(lua_State* apLua, int aTableIndex, std::vector<Ltg::CompletionEntry>& aoEntries) {
     // aTableIndex must be an absolute stack index (lua_next manipulates the stack, breaking relative refs).
     lua_pushnil(apLua);
     while (lua_next(apLua, aTableIndex) != 0) {
         // -2 is the key, -1 is the value
         if (lua_type(apLua, -2) == LUA_TSTRING) {
-            Ltg::CompletionEntry entry;
-            entry.name = lua_tostring(apLua, -2);
-            entry.type = lua_typename(apLua, lua_type(apLua, -1));
-            aoEntries.push_back(entry);
+            std::string keyName = lua_tostring(apLua, -2);
+            if (!s_isCompletionNoise(keyName)) {
+                Ltg::CompletionEntry entry;
+                entry.name = std::move(keyName);
+                entry.type = lua_typename(apLua, lua_type(apLua, -1));
+                aoEntries.push_back(std::move(entry));
+            }
         }
         lua_pop(apLua, 1);  // pop value, keep key for next iter
     }
@@ -368,6 +389,72 @@ void Module::getCompletionEntries(const std::string& aTarget, std::vector<Ltg::C
         }
     }
     lua_settop(L, topBefore);
+
+    // alphabetic order — lua_next returns hash-table order which has no stable meaning to the user.
+    std::sort(aoEntries.begin(), aoEntries.end(), [](const Ltg::CompletionEntry& aLhs, const Ltg::CompletionEntry& aRhs) {
+        return aLhs.name < aRhs.name;
+    });
+}
+
+namespace {
+
+// Hand-maintained signature catalog for the Lua plugin. Must be kept in sync with the bindings
+// in Module::load (and m_ensureCompletionState). For overloaded methods we list the widest
+// variant — the host shows a single line in v1, no overload picker yet. v1 covers `ltg:`
+// methods only; `math.*` / `string.*` curated entries will land next.
+struct CatalogArg {
+    const char* name;
+    const char* type;
+};
+struct SignatureEntry {
+    const char* target;        // "" for globals
+    const char* functionName;
+    std::vector<CatalogArg> args;
+};
+
+const std::vector<SignatureEntry>& s_signatureCatalog() {
+    static const std::vector<SignatureEntry> catalog = {
+        // ltg: usertype methods (cf. new_usertype<LuaDatasModel> in Module::load)
+        {"ltg", "stringToEpoch",      {{"dateTime","string"}, {"hourOffset","number"}}},
+        {"ltg", "epochToString",      {{"epochTime","number"}, {"hourOffset","number"}}},
+        {"ltg", "addSignalTag",       {{"epoch","number"}, {"r","number"}, {"g","number"}, {"b","number"}, {"a","number"}, {"name","string"}, {"help","string"}}},
+        {"ltg", "addSignalStatus",    {{"category","string"}, {"name","string"}, {"epoch","number"}, {"status","string"}}},
+        {"ltg", "addSignalValue",     {{"category","string"}, {"name","string"}, {"epoch","number"}, {"value","number"}, {"desc","string"}}},
+        {"ltg", "addSignalStartZone", {{"category","string"}, {"name","string"}, {"epoch","number"}, {"startMsg","string"}}},
+        {"ltg", "addSignalEndZone",   {{"category","string"}, {"name","string"}, {"epoch","number"}, {"endMsg","string"}}},
+        {"ltg", "logInfo",            {{"message","string"}}},
+        {"ltg", "logWarning",         {{"message","string"}}},
+        {"ltg", "logError",           {{"message","string"}}},
+        {"ltg", "logDebug",           {{"message","string"}}},
+        {"ltg", "getRowIndex",        {}},
+        {"ltg", "getRowCount",        {}},
+    };
+    return catalog;
+}
+
+}  // namespace
+
+void Module::getSignatureInfo(const std::string& aTarget, const std::string& aFunctionName, Ltg::SignatureInfo& aoSignature) {
+    if (aFunctionName.empty()) {
+        return;
+    }
+    for (const auto& entry : s_signatureCatalog()) {
+        if (aTarget == entry.target && aFunctionName == entry.functionName) {
+            aoSignature.label = entry.target[0] != '\0'
+                ? std::string(entry.target) + ":" + entry.functionName
+                : entry.functionName;
+            aoSignature.args.clear();
+            aoSignature.args.reserve(entry.args.size());
+            for (const auto& catArg : entry.args) {
+                Ltg::SignatureArg arg;
+                arg.name = catArg.name;
+                arg.type = catArg.type;
+                aoSignature.args.push_back(std::move(arg));
+            }
+            return;
+        }
+    }
+    // not in the catalog — leave aoSignature empty, the host won't open the tooltip
 }
 
 bool Module::callScriptStart(Ltg::ErrorContainer& vOutErrors) {

plugins/LuaScripting/src/modules/Module.cpp

@@ -59,6 +59,7 @@ class Module : public Ltg::ScriptingModule {
     void setRowCount(int32_t vRowCount) final;
 
     void getCompletionEntries(const std::string& aTarget, std::vector<Ltg::CompletionEntry>& aoEntries) final;
+    void getSignatureInfo(const std::string& aTarget, const std::string& aFunctionName, Ltg::SignatureInfo& aoSignature) final;
 
     // IScriptDebugger — driven by the host
     void enableDebug(Ltg::IScriptDebugHost* apHost) final;

plugins/LuaScripting/src/modules/Module.h

@@ -36,8 +36,9 @@
 #include <systems/AppSettings.h>
 
 // we include the cpp just for embedded fonts
-#include <res/fontIcons.cpp>
-#include <res/Roboto_Medium.cpp>
+#include <fonts/fontIcons.cpp>
+#include <fonts/Roboto_Medium.cpp>
+#include <fonts/DejaVuSansMono-Bold.h>
 
 #include <filesystem>
 namespace fs = std::filesystem;
@@ -244,9 +245,15 @@ void MainBackend::m_MainLoop() {
         {
             // idle wait — runtime toggle + timeout from AppSettings (cf. SettingsDialog "app/general").
             // gated by IsJoinable so the threading progress bar keeps animating during analyse.
-            if (AppSettings::ref()->isWaitEventsEnabled() && !ScriptingEngine::ref()->IsJoinable()) {
+            const bool waitEventsActive = AppSettings::ref()->isWaitEventsEnabled() && !ScriptingEngine::ref()->IsJoinable();
+            if (waitEventsActive) {
                 glfwWaitEventsTimeout(AppSettings::ref()->getWaitEventsTimeoutSec());
             }
+            // disable text-caret blink when frames are gated by wait-events: there isn't a steady
+            // frame stream to animate the blink timer with, so the caret would freeze in whatever
+            // half of the cycle it last landed (looks like a bug). With blink off, the caret stays
+            // fixed visible — still hidden by TextEditor when the editor loses focus.
+            ImGui::GetIO().ConfigInputTextCursorBlink = !waitEventsActive;
             IAGPNewFrame("GPU Frame", "GPU Frame");  // a main Zone is always needed
 
             ProjectFile::ref()->NewFrame();
@@ -421,6 +428,11 @@ bool MainBackend::m_InitImGui() {
                 assert(0);  // failed to load font
             }
         }
+        {  // dev font
+            if (ImGui::GetIO().Fonts->AddFontFromMemoryCompressedBase85TTF(DVSMB_compressed_data_base85, 15.0f) == nullptr) {
+                assert(0);  // failed to load font
+            }
+        }
     }
 
     // Setup Platform/Renderer bindings