GuiContainer.cpp

#include <numbers>
 
#include "GuiContainer.h"
#include "GuiExtension.h"
 
#include "Renderer/Tasks/RenderTask.h"
#include "Renderer/RenderTexture.h"
#include "Renderer/RenderResources.h"
#include "Renderer/InspectorGui/InspectorGuiRenderer.h"
 
#include "Resources/TextureManager.h"
#include "Resources/ResourceStore.h"
 
#include "Systems/Core/ScriptSystem.h"
 
#include "Scripting/ScriptingManager.h"
#include "Scripting/ScriptingEngine.h"
 
#include "GuiSystem.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/ComponentModel/Entity.h"
 
#include "el_text.h"
#include "el_script.h"
 
#define IMGUI_DEFINE_MATH_OPERATORS
#include "imgui.h"
#include "imgui_internal.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GuiContainer");
}
 
namespace Cogs
{
  namespace Core
  {
    std::shared_ptr<litehtml::element> findElement(const std::shared_ptr<litehtml::element> & e, const StringView & id)
    {
      auto a = e->get_attr("id");
      if (a && id == a) return e;
 
      auto numChildren = e->get_children_count();
 
      for (size_t i = 0; i < numChildren; ++i) {
        auto child = e->get_child(i);
        auto found = findElement(child, id);
 
        if (found) return found;
      }
 
      return nullptr;
    };
 
    std::string findFont(const StringView & family, int /*weight*/)
    {
#if defined(__linux__)
      if (family.find(".ttf") != StringView::NoPosition) {
        return family.to_string();
      }
      return "/usr/share/fonts/truetype/freefont/FreeSans.ttf";
#else
      if (family == "default") {
        return "C:/Windows/Fonts/times.ttf";
      }
      else if (family == "sans-serif" || family == "arial") {
        return "C:/Windows/Fonts/arial.ttf";
      }
      else if (family.find(".ttf") != StringView::NoPosition) {
        return family.to_string();
      }
      return "C:/Windows/Fonts/times.ttf";
#endif
    }
 
    ImVec4 toImVec4(const litehtml::web_color & color)
    {
      return { color.red / 255.0f, color.green / 255.0f, color.blue / 255.0f, color.alpha / 255.0f };
    }
 
    ImVec2 toImVec2(int x, int y)
    {
      return ImVec2(static_cast<float>(x), static_cast<float>(y));
    }
  }
}
 
litehtml::uint_ptr Cogs::Core::GuiContainer::create_font(const litehtml::tchar_t * faceName, int size, int weight, litehtml::font_style /*italic*/, unsigned int /*decoration*/, litehtml::font_metrics * fm)
{
  const size_t code = hashSequence(faceName, size, weight);
 
  auto imRenderer = inspectorGuiRenderer->getImguiRenderer();
 
  GuiFont * font;
 
  auto it = imRenderer->fontRegistry.fonts.find(code);
  if (it != imRenderer->fontRegistry.fonts.end()) {
    font = &it->second;
  }
  else {
    font = &imRenderer->fontRegistry.fonts[code];
    font->load(renderContext->context, findFont(faceName, weight), static_cast<float>(size), nullptr);
  }
 
  fm->height = static_cast<int>(font->font[0]->FontSize);
  fm->descent = static_cast<int>(font->font[0]->Descent);
  fm->ascent = static_cast<int>(font->font[0]->Ascent);
 
  return reinterpret_cast<litehtml::uint_ptr>(font);
}
 
void Cogs::Core::GuiContainer::delete_font(litehtml::uint_ptr /*hFont*/)
{
  return;
}
 
int Cogs::Core::GuiContainer::text_width(const litehtml::tchar_t * text, litehtml::uint_ptr hFont)
{
  auto font = (GuiFont *)hFont;
 
  StringView view{ text };
 
  auto size = font->font[0]->CalcTextSizeA(font->font[0]->FontSize, 100000, 0, view.begin(), view.end());
 
  return static_cast<int>(size.x);
}
 
void Cogs::Core::GuiContainer::draw_text(litehtml::uint_ptr /*hdc*/, const litehtml::tchar_t * text, litehtml::uint_ptr hFont, litehtml::web_color color, const litehtml::position & pos)
{
  auto font = (GuiFont *)hFont;
 
  auto col = toImVec4(color);
 
  ImGui::PushFont(font->font[0]);
 
  ImGui::SetCursorPos(toImVec2(pos.left(), pos.top() - (int)font->font[0]->FontSize / 2));
 
  ImGui::PushStyleColor(ImGuiCol_Text, col);
  ImGui::Text("%s", text);
  ImGui::PopStyleColor();
 
  ImGui::PopFont();
}
 
int Cogs::Core::GuiContainer::pt_to_px(int pt)
{
  return pt;
}
 
int Cogs::Core::GuiContainer::get_default_font_size() const
{
  return 16;
}
 
const litehtml::tchar_t * Cogs::Core::GuiContainer::get_default_font_name() const
{
  return "default";
}
 
void Cogs::Core::GuiContainer::draw_list_marker(litehtml::uint_ptr /*hdc*/, const litehtml::list_marker & /*marker*/)
{
}
 
void Cogs::Core::GuiContainer::load_image(const litehtml::tchar_t * src, const litehtml::tchar_t * /*baseurl*/, bool /*redraw_on_ready*/)
{
  auto name = StringView(src);
  auto code = name.hash();
 
  auto it = guiTextures.find(code);
 
  if (it != guiTextures.end()) return;
 
  if (name[0] == '$') {
    guiTextures[code] = renderContext->context->textureManager->getTexture(name);
  } else {
    guiTextures[code] = renderContext->context->textureManager->loadTexture(name, NoResourceId, TextureLoadFlags::None);
  }
}
 
void Cogs::Core::GuiContainer::get_image_size(const litehtml::tchar_t * src, const litehtml::tchar_t * /*baseurl*/, litehtml::size & sz)
{
  auto name = StringView(src);
 
  auto it = guiTextures.find(name.hash());
 
  if (it == guiTextures.end()) return;
 
  auto & texture = it->second;
 
  if (!texture) return;
 
  sz.height = texture->description.height;
  sz.width = texture->description.width;
}
 
namespace Cogs
{
  namespace Core
  {
    bool hasRadius(const litehtml::border_radiuses & radius)
    {
      return radius.bottom_left_x != 0;
    }
 
    float getBorderWidth(const litehtml::borders & borders)
    {
      int width = borders.left.width;
 
      if (borders.right.width != width ||
        borders.bottom.width != width ||
        borders.top.width != width) {
        LOG_WARNING(logger, "Multiple border widths not supported.");
      }
 
      return static_cast<float>(width);
    }
 
    int calculateSegments(float radius)
    {
      return radius > 1.0f ? 16 : -1;
    }
 
    void createRoundedPath(const ImVec2 & a, const ImVec2 & b, const litehtml::border_radiuses & radius, float width = 1.0f)
    {
      auto imguiDrawList = ImGui::GetWindowDrawList();
 
      constexpr float halfPi = 0.5f * std::numbers::pi_v<float>;
      float           halfWidth = width * 0.5f;
 
      const float r0 = glm::max(0.0f, radius.top_left_x - halfWidth);
      const float r1 = glm::max(0.0f, radius.top_right_x - halfWidth);
      const float r2 = glm::max(0.0f, radius.bottom_right_x - halfWidth);
      const float r3 = glm::max(0.0f, radius.bottom_left_x - halfWidth);
 
      imguiDrawList->PathArcTo(ImVec2(a.x + r0, a.y + r0), r0, 2 * halfPi, 3 * halfPi, calculateSegments(r0));
      imguiDrawList->PathArcTo(ImVec2(b.x - r1, a.y + r1), r1, 3 * halfPi, 4 * halfPi, calculateSegments(r1));
      imguiDrawList->PathArcTo(ImVec2(b.x - r2, b.y - r2), r2, 0, halfPi, calculateSegments(r2));
      imguiDrawList->PathArcTo(ImVec2(a.x + r3, b.y - r3), r3, halfPi, 2 * halfPi, calculateSegments(r3));
    }
  }
}
 
void Cogs::Core::GuiContainer::draw_background(litehtml::uint_ptr /*hdc*/, const litehtml::background_paint & bg)
{
  ImVec2 p0 = toImVec2(bg.origin_box.left(), bg.origin_box.top());
  ImVec2 p1 = toImVec2(bg.origin_box.right(), bg.origin_box.bottom());
 
  ImVec4 color = toImVec4(bg.color);
 
  auto imguiDrawList = ImGui::GetWindowDrawList();
  
  const float borderWidth = static_cast<float>(bg.origin_box.x - bg.border_box.x);
  const float radius = static_cast<float>(bg.border_radius.bottom_left_x) - borderWidth;
 
  const auto u32Color = ImGui::ColorConvertFloat4ToU32(color);
 
  if (bg.image.empty()) {
    if (hasRadius(bg.border_radius)) {
      createRoundedPath(p0, p1, bg.border_radius, borderWidth * 2);
      imguiDrawList->PathFillConvex(u32Color);
    } else {
      imguiDrawList->AddRectFilled(p0, p1, u32Color);
    }
  } else {
    auto name = StringView(bg.image);
    auto & texture = guiTextures[name.hash()];
    auto renderTexture = renderContext->resources->getRenderTexture(texture);
 
    if (renderTexture) {
      const auto texId = ImTextureID(renderTexture->textureHandle.handle);
      
      if (radius != 0) {
        imguiDrawList->PushTextureID(texId);
        createRoundedPath(p0, p1, bg.border_radius, borderWidth * 2);
        imguiDrawList->PathFillConvex(u32Color);
        imguiDrawList->PopTextureID();
      } else {
        imguiDrawList->AddImage(texId, p0, p1, ImVec2(), ImVec2(1, 1), u32Color);
      }
    } else {
      imguiDrawList->AddRectFilled(p0, p1, u32Color, radius);
    }
  }
}
 
void Cogs::Core::GuiContainer::draw_borders(litehtml::uint_ptr /*hdc*/, const litehtml::borders & borders, const litehtml::position & pos, bool /*root*/)
{
  //TODO:  Fix me!
 
  if (borders.left.style == litehtml::border_style_none) return;
 
  if (borders.left.style != litehtml::border_style_solid) {
    LOG_WARNING(logger, "Only solid border style supported.");
  }
 
  auto width = getBorderWidth(borders);
 
  if (width == 0) return;
 
  ImVec4 color = toImVec4(borders.left.color);
 
  const float halfWidth = width / 2;
  const float offset = 0.5f;
 
  const auto a = ImVec2((float)pos.left() + halfWidth + offset, (float)pos.top() + halfWidth + offset);
  const auto b = ImVec2((float)pos.right() - halfWidth - offset, (float)pos.bottom() - halfWidth - offset);
 
  auto imguiDrawList = ImGui::GetWindowDrawList();
 
  if (!hasRadius(borders.radius)) {
    imguiDrawList->PathRect(a, b);
  } else {
    createRoundedPath(a, b, borders.radius, width);
  }
 
  imguiDrawList->PathStroke(ImGui::ColorConvertFloat4ToU32(color), true, width);
}
 
void Cogs::Core::GuiContainer::on_load(const std::shared_ptr<litehtml::document> & document)
{
  // FIXME: 2017-08-25 chrisdy. This fails if document is missing <head>, I'm guessing we sould search for <body>?
  auto attribute = document->root()->get_child(2)->get_attr("onload");
 
  if (attribute) {
    auto scriptContext = context->scriptSystem->getScriptContext(entity->getComponent<ScriptComponent>(), ScriptFlags::JavaScript);
    scriptContext->eval(attribute);
  }
}
 
namespace Cogs
{
  namespace Core
  {
    ScriptObject * createElement(const ScriptContextHandle & scriptContext, litehtml::document * document, const litehtml::element::ptr & found)
    {
      if (found->get_userdata()) {
        auto storedElement = (ScriptObject *)found->get_userdata();
 
        // The object/element may have been finalized/recycled in between usages. Check if it still
        // represents the same object.
        if (storedElement->generation == found->get_userdata_generation()) {
          return storedElement;
        }
      }
 
      auto htmlElement = scriptContext->createObject(ScriptValueType::Object, (void *)"HTMLElement");
 
      scriptContext->addProperty(htmlElement, "innerHTML", ScriptValueType::String,
        [=](ScriptObject *, const ScriptArgs & /*args*/) -> ScriptObject *
      {
        std::string text;
        found->get_text(text);
        return scriptContext->createObject(ScriptValueType::String, (void *)text.c_str());
      },
        [=](ScriptObject *, const ScriptArgs & args) -> ScriptObject *
      {
        found->set_inner_html(args[0].stringValue.c_str());
        found->get_document()->container()->invalidate_layout(found->get_document().get());
        return nullptr;
      });
 
      scriptContext->addProperty(htmlElement, "className", ScriptValueType::String,
        [=](ScriptObject *, const ScriptArgs & /*args*/) -> ScriptObject *
      {
        return scriptContext->createObject(ScriptValueType::String, (void *)found->get_attr("class"));
      },
        [=](ScriptObject *, const ScriptArgs & args) -> ScriptObject *
      {
        found->set_attr("class", args[0].stringValue.c_str());
        found->apply_stylesheet(document->get_styles());
        found->parse_styles();
 
        return nullptr;
      });
 
      auto styles = scriptContext->createObjectProxy(
        [=](ScriptObject * /*target*/, const StringView & key) -> ScriptObject *
      {
        auto style = found->get_style_property(key.data(), false);
 
        return style ? scriptContext->createObject(ScriptValueType::String, (void *)style) : nullptr;
      },
        [=](ScriptObject * /*target*/, const StringView & key, const ScriptArg & value) -> bool
      {
        litehtml::style style;
        style.add_property(key.data(), value.stringValue.data(), nullptr, true);
 
        found->add_style(style);
 
        found->parse_styles();
 
        found->get_document()->container()->invalidate_layout(found->get_document().get());
 
        return true;
      });
 
      scriptContext->setProperty(htmlElement, "styles", styles);
 
      auto attributes = scriptContext->createObjectProxy(
        [=](ScriptObject * /*target*/, const StringView & key) -> ScriptObject *
      {
        return scriptContext->createObject(ScriptValueType::String, (void *)found->get_attr(key.data()));
      },
        [=](ScriptObject * /*target*/, const StringView & key, const ScriptArg & value) -> bool
      {
        found->set_attr(key.data(), value.stringValue.data());
        return true;
      });
 
      scriptContext->setProperty(htmlElement, "attributes", attributes);
 
      scriptContext->setProperty(htmlElement, "id", found->get_attr("id"));
 
      found->set_userdata(htmlElement, htmlElement->generation);
 
      return htmlElement;
    }
 
    void createDocument(const ScriptContextHandle & scriptContext, litehtml::document * document, const litehtml::element::ptr & /*el*/)
    {
      auto doc = scriptContext->createObject(ScriptValueType::Object);
      scriptContext->setProperty(nullptr, "document", doc);
      scriptContext->addFunction(doc, "getElementById", ScriptValueType::Object, { ScriptValueType::String },
        [&, document, scriptContext](ScriptObject *, const ScriptArgs & args) -> ScriptObject *
      {
        auto root = document->root();
        auto found = findElement(root, args[0].stringValue);
 
        if (!found) return nullptr;
 
        return createElement(scriptContext, document, found);
      });
    }
 
    void dispatchMouseEvent(ScriptContextHandle scriptContext, const litehtml::element::ptr & el, const StringView & eventName, const StringView & attributeName, int x, int y)
    {
      auto attribute = el->get_attr(attributeName.data());
 
      if (attribute) {
        scriptContext->eval(attribute);
      }
 
      // Only emit event for elements that have script representations.
      if (!el->get_userdata()) return;
 
      auto elementObject = createElement(scriptContext, el->get_document().get(), el);
      auto eventObject = scriptContext->createObject(ScriptValueType::Object, (void *)"MouseEvent");
 
      scriptContext->setProperty(nullptr, "_event", eventObject);
 
      auto clientCoords = el->get_placement();
 
      //TODO: Include button id.
      scriptContext->setProperty(eventObject, "button", 0.0);
      scriptContext->setProperty(eventObject, "target", elementObject);
      scriptContext->setProperty(eventObject, "type", eventName);
      scriptContext->setProperty(eventObject, "screenX", x);
      scriptContext->setProperty(eventObject, "screenY", y);
      scriptContext->setProperty(eventObject, "clientX", x - clientCoords.x);
      scriptContext->setProperty(eventObject, "clientY", y - clientCoords.y);
 
      scriptContext->callFunction(elementObject, "_dispatchEvent", eventObject);
 
      scriptContext->setProperty(nullptr, "_event", nullptr);
    }
 
    ScriptContextHandle getScriptContext(Context * context, Entity * entity)
    {
      return context->scriptSystem->getScriptContext(entity->getComponent<ScriptComponent>(), ScriptFlags::JavaScript);
    }
  }
}
 
void Cogs::Core::GuiContainer::on_mouse_enter(const litehtml::element::ptr & el)
{
  dispatchMouseEvent(getScriptContext(context, entity), el, "mouseover", "onmouseover", 0, 0);
}
 
void Cogs::Core::GuiContainer::on_mouse_move(const litehtml::element::ptr & el, int x, int y)
{
  dispatchMouseEvent(getScriptContext(context, entity), el, "mousemove", "onmousemove", x, y);
}
 
void Cogs::Core::GuiContainer::on_mouse_leave(const litehtml::element::ptr & el)
{
  dispatchMouseEvent(getScriptContext(context, entity), el, "mouseout", "onmouseout", 0, 0);
}
 
void Cogs::Core::GuiContainer::on_click(const litehtml::element::ptr & el)
{
  dispatchMouseEvent(getScriptContext(context, entity), el, "click", "onclick", 0, 0);
}
 
void Cogs::Core::GuiContainer::import_css(litehtml::tstring & text, const litehtml::tstring & url, litehtml::tstring & /*baseurl*/)
{
  text = context->resourceStore->getResourceContentString(url, ResourceStoreFlags::NoCachedContent);
}
 
void Cogs::Core::GuiContainer::on_anchor_click(const litehtml::tchar_t * url, const litehtml::element::ptr & el)
{
  if (std::strstr(url, "cogs:") == url) {
    //TODO: Add a callback to GuiComponent for when a Cogs URL is clicked and call it here.
  }
  else {
    auto clicked = el->get_attr("onclick");
 
    if (clicked) {
      auto scriptContext = context->scriptSystem->getScriptContext(entity->getComponent<ScriptComponent>(), ScriptFlags::JavaScript);
 
      scriptContext->eval(std::string(clicked) + "();");
    }
  }
}
 
void Cogs::Core::GuiContainer::get_client_rect(litehtml::position & client) const
{
  client.width = (int)size.x;
  client.height = (int)size.y;
  client.x = 0;
  client.y = 0;
}
 
std::shared_ptr<litehtml::element> Cogs::Core::GuiContainer::create_element(const litehtml::tchar_t * /*tag_name*/, const litehtml::string_map & /*attributes*/, const std::shared_ptr<litehtml::document>& /*doc*/)
{
  return nullptr;
}
 
void Cogs::Core::GuiContainer::get_media_features(litehtml::media_features & media) const
{
  media.width = (int)size.x;
  media.height = (int)size.y;
  media.device_width = (int)size.x;
  media.device_height = (int)size.y;
  media.type = litehtml::media_type_screen;
  media.resolution = 96;
}
 
void Cogs::Core::GuiContainer::execute_script(litehtml::document * document, const litehtml::element::ptr el)
{
  if (!entity) return;
 
  auto scriptElement = (litehtml::el_script *)el.get();
 
  if (scriptElement->get_text()) {
    auto scriptContext = context->scriptSystem->getScriptContext(entity->getComponent<ScriptComponent>(), ScriptFlags::JavaScript);
 
    createDocument(scriptContext, document, el);
 
    auto source = scriptElement->get_attr("src", nullptr);
    if (source) {
      auto content = context->resourceStore->getResourceContentString(source);
 
      scriptContext->addScript(content);
    } else {
      scriptContext->addScript(scriptElement->get_text());
    }
  }
}
 
void Cogs::Core::GuiContainer::invalidate_layout(litehtml::document * document)
{
  if (entity) {
    invalidated = true;
  } else {
    auto entity = (Entity *)document->get_userdata();
 
    if (entity) {
      auto guiComponent = entity->getComponent<GuiComponent>();
      auto * guiSystem = static_cast<GuiSystem*>(context->getExtensionSystem(GuiSystem::getTypeId()));
      assert(guiSystem);
 
      auto & data = guiSystem->getData(guiComponent);
 
      data.invalidated = true;
    }
  }
}
 
void Cogs::Core::GuiContainer::initialize(RenderTaskContext * renderContext, InspectorGuiRenderer * guiRenderer)
{
  this->renderContext = renderContext;
  context = renderContext->context;
  this->inspectorGuiRenderer = guiRenderer;
}
 
void Cogs::Core::GuiContainer::pushState(ComponentModel::Entity * entity, glm::vec2 size)
{
  assert(renderContext && inspectorGuiRenderer && context && "Gui container not ready.");
 
  invalidated = false;
  this->entity = entity;
  this->size = size;
  this->scriptComponent = entity->getComponentHandle<ScriptComponent>();
}
 
void Cogs::Core::GuiContainer::popState()
{
  entity = nullptr;
  scriptComponent = ComponentHandle::Empty();
}
 
void Cogs::Core::GuiContainer::clear()
{
  guiTextures.clear();
}