ScriptInspector.cpp

#include "Inspectors.h"
#include "Context.h"
#include "InspectorGuiHelper.h"
 
#include "Systems/Core/ScriptSystem.h"
 
#include "Scripting/ScriptingManager.h"
 
#include "Utilities/Parsing.h"
 
#include "Renderer/IRenderer.h"
 
#include "Foundation/Reflection/TypeDatabase.h"
 
#include "imgui.h"
 
#include <algorithm>
#include <string.h>
 
namespace
{
  int editorCallback(ImGuiInputTextCallbackData* data)
  {
    auto engine = (Cogs::Core::ScriptingEngine *)data->UserData;
    auto & editor = engine->editorContext;
 
    auto & io = ImGui::GetIO();
 
    if (editor.currentCompletions.size() > 1) {
      ImGui::SetNextWindowPos(ImVec2(ImGui::GetItemRectMin().x + editor.completionOffset * 7.0f, ImGui::GetItemRectMax().y - 15.0f));
      ImGui::SetNextWindowSize(ImVec2(200, 300));
      ImGui::PushStyleColor(ImGuiCol_PopupBg, ImGui::GetStyle().Colors[ImGuiCol_Border]);
      ImGui::BeginTooltip();
      for (size_t i = 0; i < editor.currentCompletions.size(); ++i) {
        auto & completion = editor.currentCompletions[i];
        const ImColor col = i == static_cast<size_t>(editor.completionIndex) ? ImColor(1.0f, 1.0f, 1.0f, 1.0f) : ImColor(0.7f, 0.7f, 0.7f, 1.0f);
        ImGui::PushStyleColor(ImGuiCol_Text, col.Value);
        ImGui::TextUnformatted(std::string(completion).c_str());
        ImGui::PopStyleColor();
 
        if (i == static_cast<size_t>(editor.completionIndex)) {
          ImGui::SetScrollHereY(0.5f);
        }
      }
      ImGui::EndTooltip();
      ImGui::PopStyleColor();
    }
 
    if (data->EventFlag == ImGuiInputTextFlags_CallbackCompletion) {
      if (editor.currentCompletions.empty()) {
        editor.original = std::string(data->Buf, data->BufTextLen);
 
        static thread_local Cogs::Core::TokenStream splits;
        static thread_local Cogs::Core::TokenStream tokens;
        static thread_local Cogs::Core::TokenStream completions;
        splits.clear();
        tokens.clear();
        completions.clear();
 
        Cogs::Core::split(editor.original, " =\t,:[](){};", splits);
 
        if (splits.empty()) return 0;
 
        Cogs::Core::split(splits.back(), ".", tokens);
 
        if (editor.original.back() == '.') {
          tokens.push_back(nullptr);
          editor.completionOffset = editor.original.size();
        } else {
          editor.completionOffset = tokens.back().data() - editor.original.data();
        }
 
        engine->completions(tokens, completions);
 
        std::sort(completions.begin(), completions.end());
 
        editor.currentCompletions = completions;
        editor.completionIndex = 0;
 
        if (tokens.back().size()) {
          editor.currentCompletions.push_back(tokens.back());
        }
      } else {
        editor.completionIndex += io.KeyShift ? -1 : 1;
      }
 
      if (editor.currentCompletions.empty()) return 0;
 
      if (editor.completionIndex >= (int)editor.currentCompletions.size()) editor.completionIndex = 0;
      else if (editor.completionIndex < 0) editor.completionIndex = (int)editor.currentCompletions.size() - 1;
 
      auto & suggestion = editor.currentCompletions[editor.completionIndex];
      data->DeleteChars((int)editor.completionOffset, data->BufTextLen - (int)editor.completionOffset);
      data->InsertChars((int)editor.completionOffset, suggestion.data(), suggestion.data() + suggestion.size());
      data->CursorPos = data->BufTextLen;
      data->BufDirty = true;
      editor.suggested = std::string(data->Buf, data->BufTextLen);
    } else if (!editor.currentCompletions.empty() && std::string_view(data->Buf, data->BufTextLen) != std::string_view(editor.suggested)) {
      editor.currentCompletions.clear();
      editor.completionIndex = 0;
    }
 
    // History
 
    if (editor.commandHistory.empty()) return 0;
 
    auto modifyHistory = [&](int offset) {
      editor.historyIndex += offset;
      editor.historyIndex = std::max(0, std::min(editor.historyIndex, (int)editor.commandHistory.size() - 1));
 
      data->BufTextLen = snprintf(data->Buf, data->BufSize, "%s", editor.commandHistory[editor.historyIndex].c_str());
      data->BufDirty = true;
      data->CursorPos = data->BufTextLen;
    };
 
    if (ImGui::IsKeyPressed(ImGuiKey_UpArrow) && (io.KeyShift || data->CursorPos == 0) && !editor.movedUp) {
      modifyHistory(-1);
 
      editor.movedUp = true;
 
      return 1;
    } else if (editor.movedUp && !ImGui::IsKeyPressed(ImGuiKey_UpArrow)) {
      editor.movedUp = false;
    }
 
    if (ImGui::IsKeyPressed(ImGuiKey_DownArrow) && io.KeyShift && !editor.movedDown) {
      modifyHistory(+1);
 
      editor.movedDown = true;
 
      return 1;
    } else if (editor.movedDown && !ImGui::IsKeyPressed(ImGuiKey_DownArrow)) {
      editor.movedDown = false;
    }
 
    return 0;
  }
}
 
void Cogs::Core::scriptConsole(Context * context, bool * show)
{
  if (*show) {
    ImGui::SetNextWindowSize(ImVec2(600, 1000), ImGuiCond_Once);
 
    guiBegin("Script Console", show);
 
    auto & scriptingManager = context->scriptingManager;
 
    for (auto & scriptEngine : scriptingManager->engines) {
      auto & editor = scriptEngine->editorContext;
 
      ImGui::Text("%s", scriptEngine->editorContext.name.c_str());
 
      ImGui::BeginChild((editor.name + " History").c_str(), ImVec2(0, 200), false, ImGuiWindowFlags_HorizontalScrollbar);
 
      ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4, 1));
 
      for (auto & h : editor.history) {
        ImColor col = ImColor(1.0f, 1.0f, 1.0f, 1.0f);
        if (h.find("Error:") != std::string::npos) {
          col = ImColor(1.0f, 0.4f, 0.4f, 1.0f);
        } else if (h.find("> ") == 0) {
          col = ImColor(0.7f, 0.7f, 0.7f, 1.0f);
        }
        ImGui::PushStyleColor(ImGuiCol_Text, col.Value);
        ImGui::TextUnformatted(h.c_str());
        ImGui::PopStyleColor();
      }
 
      if (editor.scrollToBottom) {
        ImGui::SetScrollHereY();
        editor.scrollToBottom = false;
      }
 
      ImGui::PopStyleVar();
      ImGui::EndChild();
 
      ImGui::PushItemWidth(-1);
      if (ImGui::InputTextMultiline((editor.name + " Source").c_str(),
                                    (char *)editor.buffer.data(),
                                    editor.buffer.size(),
                                    ImVec2(0, 0),
                                    ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CtrlEnterForNewLine | ImGuiInputTextFlags_CallbackAlways | ImGuiInputTextFlags_CallbackCompletion,
                                    editorCallback,
                                    scriptEngine.get())) {
 
        ImguiRenderer* guiRenderer = context->renderer->getGuiRenderer();
        if (guiRenderer) {
          guiRenderer->addTextToGlyphBuilder(editor.buffer.data());
        }
 
        auto command = std::string(editor.buffer.data());
 
        if (command.size()) {
          editor.history.emplace_back("> " + command + "\n");
 
          editor.commandHistory.emplace_back(std::move(command));
 
          std::string result(scriptEngine->eval(editor.buffer.data()));
 
          editor.history.emplace_back(result + "\n");
          editor.scrollToBottom = true;
 
          editor.buffer.clear();
          editor.buffer.resize(16384);
 
          editor.historyIndex = (int)editor.commandHistory.size();
        }
 
        ImGui::SetKeyboardFocusHere(1);
      }
    }
 
    guiEnd();
  }
}
 
void Cogs::Core::scriptInspector(Context * /*context*/, bool * /*show*/)
{
  // Enumerate and show all active scripts.
}