lua_editor.cpp

Go to the documentation of this file.

#include "lua_editor.h"
#include "ui_lua_editor.h"
#include <QSettings>
#include <QPushButton>
#include <QLineEdit>
#include <QSettings>
#include <memory>
#include <QWheelEvent>
#include <QMessageBox>

#include "PlotJuggler/reactive_function.h"
#include "PlotJuggler/svg_util.h"

#include "QSyntaxStyle"

ToolboxLuaEditor::ToolboxLuaEditor()
{
  _widget = new QWidget(nullptr);
  ui = new Ui::LuaEditor;
  ui->setupUi(_widget);

  QString library_default_code = ui->textLibrary->toPlainText();

  ui->textGlobal->installEventFilter(this);
  ui->textFunction->installEventFilter(this);
  ui->textLibrary->installEventFilter(this);

  ui->labelSemaphore->setToolTipDuration(5000);

  ui->textGlobal->setAcceptDrops(true);
  ui->textFunction->setAcceptDrops(true);

  connect(ui->pushButtonSave, &QPushButton::clicked, this, &ToolboxLuaEditor::onSave);

  connect(ui->pushButtonDelete, &QPushButton::clicked, this, &ToolboxLuaEditor::onDelete);

  connect(ui->lineEditFunctionName, &QLineEdit::textChanged, this, [this]()
          {
            bool has_name = ui->lineEditFunctionName->text().isEmpty() == false;
            ui->pushButtonSave->setEnabled( has_name );
          } );

  connect(ui->buttonBox, &QDialogButtonBox::rejected, this, &ToolboxPlugin::closed);

  connect(ui->listWidgetRecent, &QListWidget::doubleClicked, this, &ToolboxLuaEditor::restoreRecent);

  connect(ui->listWidgetFunctions, &QListWidget::doubleClicked, this, &ToolboxLuaEditor::restoreFunction);

  connect(ui->listWidgetFunctions, &QListWidget::itemSelectionChanged, this,
          [this]() {
            auto selected = ui->listWidgetFunctions->selectedItems();
            ui->pushButtonDelete->setEnabled(selected.size()>0);
          });

  _delay_library_check.connectCallback([this]() {
    onLibraryUpdated();
  } );

  connect(ui->textLibrary, &QTextEdit::textChanged,
          [this]() {
            _delay_library_check.triggerSignal(250); }
          );

  connect(ui->pushButtonDefaultLibrary, &QPushButton::clicked,
          [=]() { ui->textLibrary->setPlainText( library_default_code ); } );

  connect(ui->pushButtonApplyLibrary, &QPushButton::clicked,
          this, &ToolboxLuaEditor::onReloadLibrary);


  ui->textGlobal->setHighlighter( new QLuaHighlighter );
  ui->textFunction->setHighlighter( new QLuaHighlighter );
  ui->textLibrary->setHighlighter( new QLuaHighlighter );

  _completer = new QLuaCompleter(this);
  ui->textGlobal->setCompleter( _completer );
  ui->textFunction->setCompleter( _completer );
  ui->textLibrary->setCompleter( _completer );

  // restore recent functions
  QSettings settings;
  auto previous_functions = settings.value("ToolboxLuaEditor/recent_functions", "").toString();
  if( previous_functions.isEmpty() == false)
  {
    QDomDocument xml_doc;
    if(xml_doc.setContent(previous_functions))
    {
      auto root = xml_doc.firstChild();
      for(auto elem = root.firstChildElement("function"); !elem.isNull();
          elem = elem.nextSiblingElement("function") )
      {
        auto name = elem.attribute("name");
        auto item = new QListWidgetItem(name);
        setItemData(item, name, elem.attribute("global"), elem.attribute("function"));
        ui->listWidgetRecent->addItem(item);
      }
    }
  }

  if( settings.contains("ToolboxLuaEditor/library"))
  {
    QString code = settings.value("ToolboxLuaEditor/library").toString();
    ui->textLibrary->setPlainText(code);
  }

  _previous_library = ui->textLibrary->toPlainText();

  onLibraryUpdated();
}

ToolboxLuaEditor::~ToolboxLuaEditor()
{
  delete ui;
}

const char *ToolboxLuaEditor::name() const
{
  return "Reactive Script Editor";
}

void ToolboxLuaEditor::init(PlotDataMapRef &src_data,
                            TransformsMap &transform_map)
{
  _plot_data = &src_data;
  _transforms = &transform_map;

}

std::pair<QWidget *, ToolboxPlugin::WidgetType>
ToolboxLuaEditor::providedWidget() const
{
  return { _widget, PJ::ToolboxPlugin::FIXED };
}

bool ToolboxLuaEditor::xmlSaveState(QDomDocument &doc, QDomElement &parent_element) const
{
  if( ui->listWidgetFunctions->count() > 0 )
  {
    QString msg = "Do you want to save the current active scripts?\n\n";

    for(int row = 0; row < ui->listWidgetFunctions->count(); row++)
    {
      auto item = ui->listWidgetFunctions->item(row);
      msg += QString("  - %1\n").arg(item->text());
    }

    auto ret = QMessageBox::question(nullptr, this->name(), msg);
    if( ret == QMessageBox::No )
    {
      return false;
    }
  }

  auto library_elem = doc.createElement("library");
  library_elem.setAttribute("code", ui->textLibrary->toPlainText());
  parent_element.appendChild(library_elem);

  auto scripts_elem = doc.createElement("scripts");

  for(int row = 0; row < ui->listWidgetFunctions->count(); row++)
  {
    auto item = ui->listWidgetFunctions->item(row);
    auto fields = getItemData(item);
    auto elem = doc.createElement("script");
    elem.setAttribute("name", fields.name);
    elem.setAttribute("function", fields.function_code);
    elem.setAttribute("global", fields.global_code);
    scripts_elem.appendChild(elem);
  }
  parent_element.appendChild(scripts_elem);

  return true;
}

bool ToolboxLuaEditor::xmlLoadState(const QDomElement &parent_element)
{
  auto library_elem = parent_element.firstChildElement("library");
  if(!library_elem.isNull())
  {
    ui->textLibrary->setPlainText( library_elem.attribute("code") );
  }

  auto scripts_elem = parent_element.firstChildElement("scripts");
  if(!scripts_elem.isNull())
  {
    for (auto elem = scripts_elem.firstChildElement("script");
         elem.isNull() == false; elem = elem.nextSiblingElement("script"))
    {
      ui->listWidgetFunctions->clear();
      QString name = elem.attribute("name");
      QString function = elem.attribute("function");
      QString global = elem.attribute("global");
      auto item = new QListWidgetItem(name);
      setItemData(item, name, global, function);
      ui->listWidgetFunctions->addItem(item);

      auto lua_function = std::make_shared<ReactiveLuaFunction>(
          _plot_data, global, function, ui->textLibrary->toPlainText() );

      (*_transforms)[name.toStdString()] = lua_function;
    }
    ui->listWidgetFunctions->sortItems();
  }

  return true;
}

bool ToolboxLuaEditor::onShowWidget()
{
  ui->listWidgetFunctions->clear();

  // check the already existing functions.
  for(auto it : *_transforms)
  {
    if( auto lua_function = std::dynamic_pointer_cast<ReactiveLuaFunction>( it.second ))
    {
      QString name = QString::fromStdString(it.first);
      auto item = new QListWidgetItem(name);
      setItemData(item, name, lua_function->getGlobalCode(), lua_function->getFunctionCode());
      ui->listWidgetFunctions->addItem(item);
    }
    ui->listWidgetFunctions->sortItems();
  }

  QSettings settings;
  QString theme = settings.value("StyleSheet::theme", "light").toString();

  ui->pushButtonDelete->setIcon(LoadSvg(":/resources/svg/clear.svg", theme));

  _font_size = settings.value("ToolboxLuaEditor/fonts_size", 12).toInt();

  QFont fixedFont = QFontDatabase::systemFont(QFontDatabase::FixedFont);
  fixedFont.setPointSize(_font_size);

  ui->textGlobal->setFont( fixedFont );
  ui->textFunction->setFont( fixedFont );
  ui->textLibrary->setFont( fixedFont );

  auto style_path = (theme == "light" ) ? ":/resources/lua_style_light.xml" :
                                          ":/resources/lua_style_dark.xml";

  QFile fl(style_path);
  if (fl.open(QIODevice::ReadOnly))
  {
    auto style = new QSyntaxStyle(this);
    if (style->load(fl.readAll()))
    {
      ui->textGlobal->setSyntaxStyle( style );
      ui->textFunction->setSyntaxStyle( style );
      ui->textLibrary->setSyntaxStyle( style );
    }
  }

  return true;
}

void ToolboxLuaEditor::onSave()
{
  auto name = ui->lineEditFunctionName->text();
  if(ui->listWidgetFunctions->findItems(name, Qt::MatchExactly).size()>0)
  {
    QMessageBox msgBox(_widget);
    msgBox.setWindowTitle("Warning");
    msgBox.setText(tr("A dfunction with the same name exists already.\n"
                      " Do you want to overwrite it?\n"));
    msgBox.addButton(QMessageBox::Cancel);
    QPushButton* button = msgBox.addButton(tr("Overwrite"), QMessageBox::YesRole);
    msgBox.setDefaultButton(button);

    int res = msgBox.exec();
    if (res < 0 || res == QMessageBox::Cancel)
    {
      return;
    }
  }

  try {
    auto lua_function = std::make_shared<ReactiveLuaFunction>(
        _plot_data,
        ui->textGlobal->toPlainText(),
        ui->textFunction->toPlainText(),
        ui->textLibrary->toPlainText() );

    (*_transforms)[name.toStdString()] = lua_function;

    if( ui->listWidgetFunctions->findItems(name, Qt::MatchExactly).empty() )
    {
      ui->listWidgetFunctions->addItem(name);
      ui->listWidgetFunctions->sortItems();
    }

    auto item = ui->listWidgetFunctions->findItems(name, Qt::MatchExactly).first();
    setItemData(item, name, ui->textGlobal->toPlainText(), ui->textFunction->toPlainText());

    for( auto& new_name: lua_function->createdCurves() )
    {
      emit plotCreated(new_name);
    }
  }
  catch(std::runtime_error& err)
  {
    QMessageBox::warning(nullptr, "Error in Lua code",  QString(err.what()), QMessageBox::Cancel);
  }

  auto prev_items = ui->listWidgetRecent->findItems(name, Qt::MatchExactly);
  // new name, delete oldest and append
  if( prev_items.empty() )
  {
    while( ui->listWidgetRecent->count() >= 10 )
    {
      delete ui->listWidgetRecent->takeItem(0);
    }
  }
  else{
    // overwrite item with same name
    auto row = ui->listWidgetRecent->row( prev_items.first() );
    delete ui->listWidgetRecent->takeItem(row);
  }

  // save recent functions
  auto new_item = new QListWidgetItem(name);
  setItemData(new_item, name, ui->textGlobal->toPlainText(), ui->textFunction->toPlainText());
  ui->listWidgetRecent->addItem(new_item);

  QDomDocument xml_doc;
  auto root = xml_doc.createElement("functions");

  for(int row = 0; row < ui->listWidgetRecent->count(); row++)
  {
    auto item = ui->listWidgetRecent->item(row);
    auto fields = getItemData(item);

    auto elem = xml_doc.createElement("function");
    elem.setAttribute("name", fields.name);
    elem.setAttribute("global", fields.global_code);
    elem.setAttribute("function", fields.function_code);
    root.appendChild(elem);
  }
  xml_doc.appendChild(root);

  QSettings settings;
  settings.setValue("ToolboxLuaEditor/recent_functions", xml_doc.toString());
}

void ToolboxLuaEditor::onDelete()
{
  for(auto item: ui->listWidgetFunctions->selectedItems())
  {
    _transforms->erase(item->text().toStdString());

    int row = ui->listWidgetFunctions->row(item);
    delete ui->listWidgetFunctions->takeItem(row);
  }
}

void ToolboxLuaEditor::restoreRecent(const QModelIndex &index)
{
  auto item = ui->listWidgetRecent->item(index.row());
  auto fields = getItemData(item);
  ui->lineEditFunctionName->setText(fields.name);
  ui->textGlobal->setPlainText(fields.global_code);
  ui->textFunction->setPlainText(fields.function_code);
}

void ToolboxLuaEditor::restoreFunction(const QModelIndex &index)
{
  auto item = ui->listWidgetFunctions->item(index.row());
  auto fields = getItemData(item);
  ui->lineEditFunctionName->setText(fields.name);
  ui->textGlobal->setPlainText(fields.global_code);
  ui->textFunction->setPlainText(fields.function_code);
}

void ToolboxLuaEditor::onLibraryUpdated()
{
  if( ui->textLibrary->toPlainText() == _previous_library )
  {
    ui->pushButtonApplyLibrary->setEnabled(false);
    return;
  }

  QString svg_name = ":/resources/svg/green_circle.svg";
  try {
    ReactiveLuaFunction tmp(_plot_data, "", "", ui->textLibrary->toPlainText());
    ui->labelSemaphore->setToolTip("Everything is fine :)");
    int active_series = ui->listWidgetFunctions->count();
    ui->pushButtonApplyLibrary->setEnabled( active_series > 0 );
    _previous_library = ui->textLibrary->toPlainText();

    QSettings settings;
    settings.setValue("ToolboxLuaEditor/library", ui->textLibrary->toPlainText());
  }
  catch(std::runtime_error& ex)
  {
    QString error_msg = ex.what();
    ui->labelSemaphore->setToolTip(error_msg);
    svg_name = ":/resources/svg/red_circle.svg";
    ui->pushButtonApplyLibrary->setEnabled(false);
  }

  QFile file(svg_name);
  file.open(QFile::ReadOnly | QFile::Text);
  QByteArray content(file.readAll());
  QSvgRenderer rr(content);
  QImage image(ui->labelSemaphore->width(), ui->labelSemaphore->height(), QImage::Format_ARGB32);
  QPainter painter(&image);
  image.fill(Qt::transparent);
  rr.render(&painter);
  ui->labelSemaphore->setPixmap( QPixmap::fromImage(image) );
}

void ToolboxLuaEditor::onReloadLibrary()
{
  for(int row = 0; row < ui->listWidgetFunctions->count(); row++)
  {
    auto item = ui->listWidgetFunctions->item(row);
    auto name = item->text();
    auto fields = getItemData(item);
    try{
      auto lua_function = std::make_shared<ReactiveLuaFunction>(
          _plot_data, fields.global_code, fields.function_code, ui->textLibrary->toPlainText() );

      (*_transforms)[fields.name.toStdString()] = lua_function;
    }
    catch(std::runtime_error& err)
    {
      QMessageBox::warning(nullptr, "Error in Lua code",  QString(err.what()), QMessageBox::Cancel);
    }
  }
  ui->pushButtonApplyLibrary->setEnabled(false);
}

bool ToolboxLuaEditor::eventFilter(QObject *obj, QEvent *ev)
{
  if(obj != ui->textGlobal && obj != ui->textFunction && obj != ui->textLibrary )
  {
    return false;
  }

  if (ev->type() == QEvent::DragEnter)
  {
    _dragging_curves.clear();
    auto event = static_cast<QDragEnterEvent*>(ev);
    const QMimeData* mimeData = event->mimeData();
    QStringList mimeFormats = mimeData->formats();
    for (const QString& format : mimeFormats)
    {
      QByteArray encoded = mimeData->data(format);
      QDataStream stream(&encoded, QIODevice::ReadOnly);

      if (format != "curveslist/add_curve")
      {
        return false;
      }

      while (!stream.atEnd())
      {
        QString curve_name;
        stream >> curve_name;
        if (!curve_name.isEmpty())
        {
          _dragging_curves.push_back(curve_name);
        }
      }
      if( !_dragging_curves.empty() )
      {
        event->acceptProposedAction();
      }
    }
    return true;
  }
  else if (ev->type() == QEvent::Drop)
  {
    auto text_edit = qobject_cast<QPlainTextEdit*>(obj);
    for(const auto& name: _dragging_curves)
    {
      text_edit->insertPlainText(QString("\"%1\"\n").arg(name));
    }
    _dragging_curves.clear();
    return true;
  }
  else if (ev->type() == QEvent::Wheel)
  {
    QWheelEvent* wheel_event = dynamic_cast<QWheelEvent*>(ev);
    bool ctrl_modifier_pressed =
        (QGuiApplication::keyboardModifiers() == Qt::ControlModifier);

    if (ctrl_modifier_pressed)
    {
      int prev_size = _font_size;
      if (wheel_event->delta() < 0)
      {
        _font_size = std::max(8, prev_size - 1);
      }
      else if (wheel_event->delta() > 0)
      {
        _font_size = std::min(14, prev_size + 1);
      }
      if (_font_size != prev_size)
      {
        auto font = ui->textGlobal->font();
        font.setPointSize(_font_size);
        ui->textGlobal->setFont( font );
        ui->textFunction->setFont( font );
        ui->textLibrary->setFont( font );

        QSettings settings;
        settings.setValue("ToolboxLuaEditor/fonts_size", _font_size);
      }
      return true;
    }
  }
  return false;
}

ToolboxLuaEditor::SavedData ToolboxLuaEditor::getItemData(const QListWidgetItem *item) const
{
  auto fields = item->data(Qt::UserRole).toStringList();
  SavedData data;
  data.name = fields[0];
  data.global_code = fields[1];
  data.function_code = fields[2];
  return data;
}

void ToolboxLuaEditor::setItemData(QListWidgetItem *item,
                                   QString name,
                                   QString global_code,
                                   QString function_code)
{
  QStringList save_fields;
  save_fields.push_back(name);
  save_fields.push_back(global_code);
  save_fields.push_back(function_code);
  item->setData(Qt::UserRole, save_fields);
}