SchemaClassEditor.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: yes (from src/SchemaEditor/SchemaClassEditor.cpp to apps/SchemaEditor/SchemaClassEditor.cpp).

#include <QInputDialog>
#include <QLineEdit>
#include <QListWidget>
#include <QListWidgetItem>
#include <QMessageBox>
#include <QString>
#include <QStringList>

#include "dbe/SchemaAttributeEditor.hpp"
#include "dbe/SchemaClassEditor.hpp"
#include "dbe/SchemaKernelWrapper.hpp"
#include "dbe/SchemaMethodEditor.hpp"
#include "dbe/SchemaRelationshipEditor.hpp"
#include "ui_SchemaClassEditor.h"
 
#include "oks/file.hpp"
 
#include <map>
 
using namespace dunedaq::oks;
 
dbse::SchemaClassEditor::SchemaClassEditor(OksClass* ClassInfo, QWidget* parent)
  : QWidget(parent)
  , ui(new Ui::SchemaClassEditor)
  , SchemaClass(ClassInfo)
  , MethodModel(nullptr)
  , AttributeModel(nullptr)
  , RelationshipModel(nullptr)
  , SuperClassModel(nullptr)
  , SubClassModel(nullptr)
  , ContextMenuAttribute(nullptr)
  , ContextMenuRelationship(nullptr)
  , ContextMenuMethod(nullptr)
  , ContextMenuClass(nullptr)
{
  QWidget::setAttribute(Qt::WA_DeleteOnClose);

  ui->setupUi(this);
  setWindowTitle(QString("Class Editor : %1").arg(QString::fromStdString(SchemaClass->get_name())));
  setObjectName(QString::fromStdString(SchemaClass->get_name()));
  BuildModels();
  SetController();
  InitialSettings();
}
 
dbse::SchemaClassEditor::~SchemaClassEditor() = default;
 
void
dbse::SchemaClassEditor::keyPressEvent(QKeyEvent* event)
{
  if (event->key() == Qt::Key_Escape) {
    close();
  }
  QWidget::keyPressEvent(event);
}
void
dbse::SchemaClassEditor::SetController()
{
  connect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(ParseToSave()));
  connect(ui->buttonBox, SIGNAL(rejected()), this, SLOT(close_slot()));
  connect(ui->moveButton, SIGNAL(clicked()), this, SLOT(move_class()));
  connect(ui->AddButtonAttribute, SIGNAL(clicked()), this, SLOT(AddNewAttribute()));
  connect(ui->AddButtonSuperClass, SIGNAL(clicked()), this, SLOT(AddNewSuperClass()));
  connect(ui->AddButtonRelationship, SIGNAL(clicked()), this, SLOT(AddNewRelationship()));
  connect(ui->AddButtonMethod, SIGNAL(clicked()), this, SLOT(AddNewMethod()));
  connect(ui->RelationshipView, SIGNAL(activated(QModelIndex)), this, SLOT(OpenRelationshipEditor(QModelIndex)));
  connect(ui->MethodsView, SIGNAL(activated(QModelIndex)), this, SLOT(OpenMethodEditor(QModelIndex)));
  connect(ui->AttributeView, SIGNAL(activated(QModelIndex)), this, SLOT(OpenAttributeEditor(QModelIndex)));
  connect(ui->SuperClassView, SIGNAL(activated(QModelIndex)), this, SLOT(OpenSuperClass(QModelIndex)));
  connect(ui->SubClassView, SIGNAL(activated(QModelIndex)), this, SLOT(OpenSubClass(QModelIndex)));
  connect(ui->AttributeView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(CustomMenuAttributeView(QPoint)));
  connect(
    ui->RelationshipView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(CustomMenuRelationshipView(QPoint)));
  connect(ui->MethodsView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(CustomMenuMethodView(QPoint)));
  connect(ui->SuperClassView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(CustomMenuClassView(QPoint)));
  connect(ui->ShowDerivedAttributes, &QCheckBox::toggled, this, &SchemaClassEditor::BuildAttributeModelSlot);
  connect(ui->ShowDerivedRelationships, &QCheckBox::toggled, this, &SchemaClassEditor::BuildRelationshipModelSlot);
  connect(ui->ShowDerivedMethods, &QCheckBox::toggled, this, &SchemaClassEditor::BuildMethodModelSlot);
  connect(ui->ShowAllSuperClasses, &QCheckBox::toggled, this, &SchemaClassEditor::BuildSuperClassModelSlot);
  connect(&KernelWrapper::GetInstance(), SIGNAL(ClassRemoved(QString)), this, SLOT(ClassRemoved(QString)));
  connect(&KernelWrapper::GetInstance(), SIGNAL(ClassUpdated(QString)), this, SLOT(ClassUpdated(QString)));
}
 
void
dbse::SchemaClassEditor::ClassRemoved(QString className)
{
  if (className == objectName()) {
    QWidget::close();
  }
}
 
void
dbse::SchemaClassEditor::ClassUpdated(QString className)
{
  if (className == objectName()) {
    BuildModels();
    InitialSettings();
  }
}
 
void
dbse::SchemaClassEditor::BuildModels()
{
  BuildSubClassModelSlot();
  BuildSuperClassModelSlot();
  BuildMethodModelSlot();
  BuildAttributeModelSlot();
  BuildRelationshipModelSlot();
}
 
void
dbse::SchemaClassEditor::InitialSettings()
{
  ui->AttributeView->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
  ui->RelationshipView->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
  ui->MethodsView->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
  ui->SuperClassView->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
  ui->SubClassView->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);

  ui->ClassNameLineEdit->setText(QString::fromStdString(SchemaClass->get_name()));
  // ui->ClassNameLineEdit->setEnabled ( false );
  ui->SchemaFileLineEdit->setText(QString::fromStdString(SchemaClass->get_file()->get_short_file_name()));
  // ui->SchemaFileLineEdit->setEnabled ( false );
 
  if (KernelWrapper::GetInstance().IsFileWritable(SchemaClass->get_file()->get_full_file_name())) {
    ui->AddButtonAttribute->setEnabled(true);
    ui->AddButtonSuperClass->setEnabled(true);
    ui->AddButtonRelationship->setEnabled(true);
    ui->AddButtonMethod->setEnabled(true);
    ui->moveButton->setEnabled(true);
  } else {
    ui->SchemaFileLineEdit->setStyleSheet("color:rgb(128,0,0);");
    // ui->DescriptionTextEdit->setEnabled(false);
    ui->DescriptionTextEdit->setReadOnly(true);
 
    ui->AddButtonAttribute->setEnabled(false);
    ui->AddButtonSuperClass->setEnabled(false);
    ui->AddButtonRelationship->setEnabled(false);
    ui->AddButtonMethod->setEnabled(false);
    ui->moveButton->setEnabled(false);
    ui->AbstractComboBox->setEnabled(false);
  }

  ui->DescriptionTextEdit->setPlainText(QString::fromStdString(SchemaClass->get_description()));
  ui->DescriptionTextEdit->setTabChangesFocus(true);
  if (SchemaClass->get_is_abstract()) {
    ui->AbstractComboBox->setCurrentIndex(0);
  } else {
    ui->AbstractComboBox->setCurrentIndex(1);
  }
}
 
void
dbse::SchemaClassEditor::move_class()
{
  move_class(SchemaClass, this);
}
 
void
dbse::SchemaClassEditor::move_class(dunedaq::oks::OksClass* schema_class, QWidget* pwidget)
{
  std::string current_file = schema_class->get_file()->get_full_file_name();
  std::vector<OksFile*> files;
  KernelWrapper::GetInstance().GetSchemaFiles(files);
  QStringList writable_files;
  std::map<QString, OksFile*> file_map;
  int current_row = -1;
  for (auto file : files) {
    auto fn = file->get_full_file_name();
    if (KernelWrapper::GetInstance().IsFileWritable(fn)) {
      if (fn == current_file) {
        current_row = writable_files.size();
      }
      writable_files.append(QString::fromStdString(fn));
      file_map[QString::fromStdString(fn)] = file;
    }
  }
  if (writable_files.empty()) {
    QMessageBox::warning(0, "Schema editor", QString("No writable schema files to move class to."));
    return;
  }
 
  QWidget* widget = new QWidget();
  QString text = "Select file to hold class " + QString::fromStdString(schema_class->get_name());
  QLabel* label = new QLabel(text);
  QListWidget* qlw = new QListWidget();
  qlw->addItems(writable_files);
  if (current_row != -1) {
    qlw->setCurrentRow(current_row);
  }
 
  connect(qlw, &QListWidget::itemActivated, pwidget, [=]() {
    QListWidgetItem* it = qlw->currentItem();
    auto fn = it->text();
    if (fn.toStdString() != current_file) {
      schema_class->set_file(file_map.at(fn));
      emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(schema_class -> get_name()));
    }
    delete widget;
  });
 
  auto bb = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
  connect(bb, &QDialogButtonBox::accepted, pwidget, [=]() {
    auto it = qlw->currentItem();
    if (it != nullptr) {
      auto fn = it->text();
      if (fn.toStdString() != current_file) {
        schema_class->set_file(file_map.at(fn));
        emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(schema_class -> get_name()));
      }
      delete widget;
    } else {
      QMessageBox::warning(0, "Schema editor", QString("No schema file selected to move class to."));
      return;
    }
  });
  connect(bb, &QDialogButtonBox::rejected, pwidget, [=]() { delete widget; });
 
  QVBoxLayout* layout = new QVBoxLayout();
  layout->addWidget(label);
  layout->addWidget(qlw);
  layout->addWidget(bb);
  widget->setWindowTitle("Select new file for class");
  widget->setLayout(layout);
  widget->setParent(pwidget, Qt::Dialog);
  widget->show();
}
 
bool
dbse::SchemaClassEditor::ShouldOpenAttributeEditor(QString attrName)
{
  QString name = QString::fromStdString(SchemaClass->get_name() + "::") + attrName;
  for (QWidget* widget : QApplication::allWidgets()) {
    if (dynamic_cast<SchemaAttributeEditor*>(widget) != nullptr) {
      if ((widget->objectName()).compare(name) == 0) {
        widget->raise();
        widget->setVisible(true);
        widget->activateWindow();
        return false;
      }
    }
  }
 
  return true;
}
 
bool
dbse::SchemaClassEditor::ShouldOpenRelationshipEditor(QString relName)
{
  QString name = QString::fromStdString(SchemaClass->get_name() + "::") + relName;
 
  for (QWidget* widget : QApplication::allWidgets()) {
    if (dynamic_cast<SchemaRelationshipEditor*>(widget) != nullptr) {
      if ((widget->objectName()).compare(name) == 0) {
        widget->raise();
        widget->setVisible(true);
        widget->activateWindow();
        return false;
      }
    }
  }
 
  return true;
}
 
bool
dbse::SchemaClassEditor::ShouldOpenMethodEditor(QString Name)
{
  bool WidgetFound = false;
 
  for (QWidget* Editor : QApplication::allWidgets()) {
    SchemaMethodEditor* Widget = dynamic_cast<SchemaMethodEditor*>(Editor);
 
    if (Widget != nullptr) {
      if ((Widget->objectName()).compare(Name) == 0) {
        Widget->raise();
        Widget->setVisible(true);
        Widget->activateWindow();
        WidgetFound = true;
      }
    }
  }
 
  return !WidgetFound;
}
 
void
dbse::SchemaClassEditor::RemoveAttribute()
{
  const std::string& attributeName = CurrentRow.at(0).toStdString();
  OksAttribute* SchemaAttribute = SchemaClass->find_direct_attribute(attributeName);
  if (SchemaAttribute != nullptr) {
    KernelWrapper::GetInstance().PushRemoveAttributeCommand(SchemaClass,
                                                            SchemaAttribute,
                                                            SchemaAttribute->get_name(),
                                                            SchemaAttribute->get_type(),
                                                            SchemaAttribute->get_is_multi_values(),
                                                            SchemaAttribute->get_range(),
                                                            SchemaAttribute->get_init_value(),
                                                            SchemaAttribute->get_description(),
                                                            SchemaAttribute->get_is_no_null(),
                                                            SchemaAttribute->get_format());
  } else {
    QMessageBox::warning(0,
                         "Schema editor",
                         QString::fromStdString("Cannot remove attribute \"" + attributeName +
                                                "\" because it is not a direct attribute of \"" +
                                                SchemaClass->get_name() + "\""));
  }
}
 
void
dbse::SchemaClassEditor::RemoveRelationship()
{
  const std::string& relationshipName = CurrentRow.at(0).toStdString();
  OksRelationship* SchemaRelationship = SchemaClass->find_direct_relationship(relationshipName);
  if (SchemaRelationship != nullptr) {
    KernelWrapper::GetInstance().PushRemoveRelationship(SchemaClass,
                                                        SchemaRelationship,
                                                        SchemaRelationship->get_name(),
                                                        SchemaRelationship->get_description(),
                                                        SchemaRelationship->get_type(),
                                                        SchemaRelationship->get_is_composite(),
                                                        SchemaRelationship->get_is_exclusive(),
                                                        SchemaRelationship->get_is_dependent(),
                                                        SchemaRelationship->get_low_cardinality_constraint(),
                                                        SchemaRelationship->get_high_cardinality_constraint());
  } else {
    QMessageBox::warning(0,
                         "Schema editor",
                         QString::fromStdString("Cannot remove relationship \"" + relationshipName +
                                                "\" because it is not a direct relationship of \"" +
                                                SchemaClass->get_name() + "\""));
  }
}
 
void
dbse::SchemaClassEditor::RemoveMethod()
{
  const std::string& methodName = CurrentRow.at(0).toStdString();
  OksMethod* SchemaMethod = SchemaClass->find_direct_method(methodName);
  if (SchemaMethod != nullptr) {
    KernelWrapper::GetInstance().PushRemoveMethodCommand(
      SchemaClass, SchemaMethod, SchemaMethod->get_name(), SchemaMethod->get_description());
  } else {
    QMessageBox::warning(0,
                         "Schema editor",
                         QString::fromStdString("Cannot remove method \"" + methodName +
                                                "\" because it is not a direct method of \"" + SchemaClass->get_name() +
                                                "\""));
  }
}
 
void
dbse::SchemaClassEditor::RemoveSuperClass()
{
  const std::string& superClassName = CurrentRow.at(0).toStdString();
  if (SchemaClass->has_direct_super_class(superClassName)) {
    KernelWrapper::GetInstance().PushRemoveSuperClassCommand(SchemaClass, superClassName);
  } else {
    QMessageBox::warning(0,
                         "Schema editor",
                         QString::fromStdString("Cannot remove super-class \"" + superClassName +
                                                "\" because it is not a direct super-class of \"" +
                                                SchemaClass->get_name() + "\""));
  }
}
 
void
dbse::SchemaClassEditor::ParseToSave()
{
  std::string NewDescription = ui->DescriptionTextEdit->toPlainText().toStdString();
 
  bool Abstract = false;
 
  if (ui->AbstractComboBox->currentIndex() == 0) {
    Abstract = true;
  } else {
    Abstract = false;
  }
 
  if (Abstract != SchemaClass->get_is_abstract()) {
    KernelWrapper::GetInstance().PushSetAbstractClassCommand(SchemaClass, Abstract);
  }
 
  if (NewDescription != SchemaClass->get_description()) {
    KernelWrapper::GetInstance().PushSetDescriptionClassCommand(SchemaClass, NewDescription);
  }
 
  close();
}
 
void
dbse::SchemaClassEditor::AddNewSuperClass()
{
  bool widgetFound = false;
  QString class_name = QString::fromStdString(SchemaClass->get_name());
 
  QString wname = "add_sc_" + class_name;
  for (QWidget* widget : QApplication::allWidgets()) {
    if (widget->objectName().compare(wname) == 0) {
      widget->raise();
      widget->setVisible(true);
      widget->activateWindow();
      widgetFound = true;
      break;
    }
  }
 
  if (!widgetFound) {
    QWidget* widget = new QWidget();
    widget->setObjectName(wname);
    QLabel* label = new QLabel("Select a super-class to add to " + class_name);
    label->setWordWrap(true);
 
    // QLabel* status = new QLabel();
    // status->setStyleSheet("QLabel { color : green; }");
 
    auto search = new QLineEdit(widget);
    search->setPlaceholderText("Search classes");
    search->setClearButtonEnabled(true);
 
    QListWidget* qlwidget = new QListWidget();
    QStringList allClasses;
    KernelWrapper::GetInstance().GetClassListString(allClasses);
    qlwidget->addItems(allClasses);
 
    connect(qlwidget, &QListWidget::itemActivated, this, [=]() {
      const std::string& className = qlwidget->currentItem()->text().toStdString();
      KernelWrapper::GetInstance().PushAddSuperClassCommand(SchemaClass, className);
      BuildModels();
      // status->setText(QString::fromStdString(className + " added as a super-class of " + SchemaClass->get_name()));
    });
 
    connect(search, &QLineEdit::textChanged, this, [search, qlwidget]() {
      auto items = qlwidget->findItems(search->text(), Qt::MatchRegularExpression);
      if (!items.empty()) {
        qlwidget->setCurrentItem(items[0]);
      }
    });
 
    auto close_button = new QPushButton("Close");
    connect(close_button, SIGNAL(clicked()), widget, SLOT(close()));
    QVBoxLayout* lout = new QVBoxLayout();
    lout->addWidget(label);
    lout->addWidget(qlwidget);
    lout->addWidget(search);
    lout->addWidget(close_button);
    // l->addWidget(status);
 
    widget->setWindowTitle("Select super-class(es) for " + class_name);
    widget->setLayout(lout);
    widget->setParent(this, Qt::Dialog);
    widget->show();
  }
}
 
void
dbse::SchemaClassEditor::AddNewAttribute()
{
  if (ShouldOpenAttributeEditor("")) {
    SchemaAttributeEditor* Editor = new SchemaAttributeEditor(SchemaClass);
    connect(Editor, SIGNAL(RebuildModel()), this, SLOT(BuildAttributeModelSlot()));
    Editor->show();
  }
}
 
void
dbse::SchemaClassEditor::AddNewRelationship()
{
  if (ShouldOpenRelationshipEditor("")) {
    SchemaRelationshipEditor* Editor = new SchemaRelationshipEditor(SchemaClass);
    connect(Editor, SIGNAL(RebuildModel()), this, SLOT(BuildRelationshipModelSlot()));
    Editor->show();
  }
}
 
void
dbse::SchemaClassEditor::AddNewMethod()
{
  SchemaMethodEditor* Editor = new SchemaMethodEditor(SchemaClass);
  connect(Editor, SIGNAL(RebuildModel()), this, SLOT(BuildMethodModelSlot()));
  Editor->show();
}
 
void
dbse::SchemaClassEditor::OpenAttributeEditor(QModelIndex Index)
{
  QStringList Row = AttributeModel->getRowFromIndex(Index);
  bool ShouldOpen = ShouldOpenAttributeEditor(Row.at(0));
 
  if (!Row.isEmpty() && ShouldOpen) {
    SchemaAttributeEditor* Editor =
      new SchemaAttributeEditor(SchemaClass, SchemaClass->find_attribute(Row.at(0).toStdString()));
    connect(Editor, SIGNAL(RebuildModel()), this, SLOT(BuildAttributeModelSlot()));
    Editor->show();
  }
}
 
void
dbse::SchemaClassEditor::OpenRelationshipEditor(QModelIndex Index)
{
  QStringList Row = RelationshipModel->getRowFromIndex(Index);
  bool ShouldOpen = ShouldOpenRelationshipEditor(Row.at(0));
 
  if (!Row.isEmpty() && ShouldOpen) {
    SchemaRelationshipEditor* Editor =
      new SchemaRelationshipEditor(SchemaClass, SchemaClass->find_relationship(Row.at(0).toStdString()));
    connect(Editor, SIGNAL(RebuildModel()), this, SLOT(BuildRelationshipModelSlot()));
    Editor->show();
  }
}
 
void
dbse::SchemaClassEditor::OpenMethodEditor(QModelIndex Index)
{
  QStringList Row = MethodModel->getRowFromIndex(Index);
  auto method = Row.at(0).toStdString();
  if (SchemaClass->find_direct_method(method) == nullptr) {
    std::string message{
      "Method '" + method + "' is not a direct method of " + SchemaClass->get_name() +
      ". Please open the method editor from the base class or add a local implementation to overrride it."
    };
    QMessageBox::warning(0, "Schema editor", QString::fromStdString(message));
    return;
  }
 
  bool ShouldOpen = ShouldOpenMethodEditor(Row.at(0));
 
  if (!Row.isEmpty() && ShouldOpen) {
    SchemaMethodEditor* Editor = new SchemaMethodEditor(SchemaClass, SchemaClass->find_method(method));
    connect(Editor, SIGNAL(RebuildModel()), this, SLOT(BuildMethodModelSlot()));
    Editor->show();
  }
}
 
void
dbse::SchemaClassEditor::OpenSuperClass(QModelIndex Index)
{
  QStringList Row = SuperClassModel->getRowFromIndex(Index);
 
  if (!Row.isEmpty()) {
    QString ClassName = Row.at(0);
    OpenNewClassEditor(ClassName);
  }
}
 
void
dbse::SchemaClassEditor::OpenSubClass(QModelIndex Index)
{
  QStringList Row = SubClassModel->getRowFromIndex(Index);
 
  if (!Row.isEmpty()) {
    QString ClassName = Row.at(0);
    OpenNewClassEditor(ClassName);
  }
}
 
void
dbse::SchemaClassEditor::OpenNewClassEditor(const QString& ClassName)
{
  bool WidgetFound = false;
  OksClass* ClassInfo = KernelWrapper::GetInstance().FindClass(ClassName.toStdString());
 
  for (QWidget* Editor : QApplication::allWidgets()) {
    SchemaClassEditor* Widget = dynamic_cast<SchemaClassEditor*>(Editor);
 
    if (Widget != nullptr) {
      if ((Widget->objectName()).compare(ClassName) == 0) {
        Widget->raise();
        Widget->setVisible(true);
        Widget->activateWindow();
        WidgetFound = true;
      }
    }
  }
 
  if (!WidgetFound) {
    SchemaClassEditor* Editor = new SchemaClassEditor(ClassInfo);
    Editor->show();
  }
}
 
void
dbse::SchemaClassEditor::BuildAttributeModelSlot()
{
  QStringList AttributeHeaders{ "Name", "Type" };
 
  if (AttributeModel != nullptr) {
    delete AttributeModel;
  }
  AttributeModel = new CustomAttributeModel(SchemaClass, AttributeHeaders, ui->ShowDerivedAttributes->isChecked());
 
  ui->AttributeView->setModel(AttributeModel);
  ui->AttributeView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
  ui->AttributeView->setSelectionBehavior(QAbstractItemView::SelectRows);
}
 
void
dbse::SchemaClassEditor::BuildRelationshipModelSlot()
{
  QStringList RelationshipHeaders{ "Name", "Type", "Low cc", "High cc" };
 
  if (RelationshipModel == nullptr)
    RelationshipModel =
      new CustomRelationshipModel(SchemaClass, RelationshipHeaders, ui->ShowDerivedRelationships->isChecked());
  else {
    delete RelationshipModel;
    RelationshipModel =
      new CustomRelationshipModel(SchemaClass, RelationshipHeaders, ui->ShowDerivedRelationships->isChecked());
  }
 
  ui->RelationshipView->setModel(RelationshipModel);
  ui->RelationshipView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
  ui->RelationshipView->setSelectionBehavior(QAbstractItemView::SelectRows);
}
 
void
dbse::SchemaClassEditor::BuildMethodModelSlot()
{
  QStringList MethodHeaders{ "Method Name" };
 
  if (MethodModel == nullptr) {
    MethodModel = new CustomMethodModel(SchemaClass, MethodHeaders, ui->ShowDerivedMethods->isChecked());
  } else {
    delete MethodModel;
    MethodModel = new CustomMethodModel(SchemaClass, MethodHeaders, ui->ShowDerivedMethods->isChecked());
  }
 
  ui->MethodsView->setModel(MethodModel);
  ui->MethodsView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
  ui->MethodsView->setSelectionBehavior(QAbstractItemView::SelectRows);
}
 
void
dbse::SchemaClassEditor::BuildSuperClassModelSlot()
{
  QStringList SuperClassHeaders{ "Class Name" };
 
  if (SuperClassModel != nullptr) {
    delete SuperClassModel;
  }
  SuperClassModel = new CustomSuperClassModel(SchemaClass, SuperClassHeaders, ui->ShowAllSuperClasses->isChecked());
 
  ui->SuperClassView->setModel(SuperClassModel);
  ui->SuperClassView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
  ui->SuperClassView->setSelectionBehavior(QAbstractItemView::SelectRows);
}
 
void
dbse::SchemaClassEditor::BuildSubClassModelSlot()
{
  QStringList SubClassHeaders{ "Class Name" };
 
  if (SubClassModel != nullptr) {
    delete SubClassModel;
  }
  SubClassModel = new CustomSubClassModel(SchemaClass, SubClassHeaders);
 
  ui->SubClassView->setModel(SubClassModel);
  ui->SubClassView->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
  ui->SubClassView->setSelectionBehavior(QAbstractItemView::SelectRows);
}
 
void
dbse::SchemaClassEditor::CustomMenuClassView(QPoint pos)
{
  if (ContextMenuClass == nullptr) {
    ContextMenuClass = new QMenu(this);
 
    QAction* Add = new QAction(tr("&Add"), this);
    Add->setShortcut(tr("Ctrl+A"));
    Add->setShortcutContext(Qt::WidgetShortcut);
    connect(Add, SIGNAL(triggered()), this, SLOT(AddNewSuperClass()));
 
    QAction* Remove = new QAction(tr("&Remove"), this);
    Remove->setShortcut(tr("Ctrl+R"));
    Remove->setShortcutContext(Qt::WidgetShortcut);
    connect(Remove, SIGNAL(triggered()), this, SLOT(RemoveSuperClass()));
 
    ContextMenuClass->addAction(Add);
    ContextMenuClass->addAction(Remove);
  }
 
  QModelIndex Index = ui->SuperClassView->currentIndex();
 
  if (Index.isValid()) {
    CurrentRow = SuperClassModel->getRowFromIndex(Index);
    ContextMenuClass->exec(ui->SuperClassView->mapToGlobal(pos));
  }
}
 
void
dbse::SchemaClassEditor::CustomMenuAttributeView(QPoint pos)
{
  if (ContextMenuAttribute == nullptr) {
    ContextMenuAttribute = new QMenu(this);
 
    QAction* Add = new QAction(tr("&Add"), this);
    Add->setShortcut(tr("Ctrl+A"));
    Add->setShortcutContext(Qt::WidgetShortcut);
    connect(Add, SIGNAL(triggered()), this, SLOT(AddNewAttribute()));
 
    QAction* Remove = new QAction(tr("&Remove"), this);
    Remove->setShortcut(tr("Ctrl+R"));
    Remove->setShortcutContext(Qt::WidgetShortcut);
    connect(Remove, SIGNAL(triggered()), this, SLOT(RemoveAttribute()));
 
    ContextMenuAttribute->addAction(Add);
    ContextMenuAttribute->addAction(Remove);
  }
 
  QModelIndex Index = ui->AttributeView->currentIndex();
 
  if (Index.isValid()) {
    CurrentRow = AttributeModel->getRowFromIndex(Index);
    ContextMenuAttribute->exec(ui->AttributeView->mapToGlobal(pos));
  }
}
 
void
dbse::SchemaClassEditor::CustomMenuRelationshipView(QPoint pos)
{
  if (ContextMenuRelationship == nullptr) {
    ContextMenuRelationship = new QMenu(this);
 
    QAction* Add = new QAction(tr("&Add"), this);
    Add->setShortcut(tr("Ctrl+A"));
    Add->setShortcutContext(Qt::WidgetShortcut);
    connect(Add, SIGNAL(triggered()), this, SLOT(AddNewRelationship()));
 
    QAction* Remove = new QAction(tr("&Remove"), this);
    Remove->setShortcut(tr("Ctrl+R"));
    Remove->setShortcutContext(Qt::WidgetShortcut);
    connect(Remove, SIGNAL(triggered()), this, SLOT(RemoveRelationship()));
 
    ContextMenuRelationship->addAction(Add);
    ContextMenuRelationship->addAction(Remove);
  }
 
  QModelIndex Index = ui->RelationshipView->currentIndex();
 
  if (Index.isValid()) {
    CurrentRow = RelationshipModel->getRowFromIndex(Index);
    ContextMenuRelationship->exec(ui->RelationshipView->mapToGlobal(pos));
  }
}
 
void
dbse::SchemaClassEditor::CustomMenuMethodView(QPoint pos)
{
  if (ContextMenuMethod == nullptr) {
    ContextMenuMethod = new QMenu(this);
 
    QAction* Add = new QAction(tr("&Add"), this);
    Add->setShortcut(tr("Ctrl+A"));
    Add->setShortcutContext(Qt::WidgetShortcut);
    connect(Add, SIGNAL(triggered()), this, SLOT(AddNewMethod()));
 
    QAction* Remove = new QAction(tr("&Remove"), this);
    Remove->setShortcut(tr("Ctrl+R"));
    Remove->setShortcutContext(Qt::WidgetShortcut);
    connect(Remove, SIGNAL(triggered()), this, SLOT(RemoveMethod()));
 
    ContextMenuMethod->addAction(Add);
    ContextMenuMethod->addAction(Remove);
  }
 
  QModelIndex Index = ui->MethodsView->currentIndex();
 
  if (Index.isValid()) {
    CurrentRow = MethodModel->getRowFromIndex(Index);
    const std::string& methodName = CurrentRow.at(0).toStdString();
    OksMethod* SchemaMethod = SchemaClass->find_direct_method(methodName);
    if (SchemaMethod == nullptr) {
      // Can't remove inherited method
      ContextMenuMethod->actions().at(1)->setVisible(false);
    } else {
      ContextMenuMethod->actions().at(1)->setVisible(true);
    }
    ContextMenuMethod->exec(ui->MethodsView->mapToGlobal(pos));
  }
}
 
QString
dbse::SchemaClassEditor::createNewClass()
{
  auto createNewClass = [](const std::string& className) -> bool {
    if (!KernelWrapper::GetInstance().IsActive()) {
      QMessageBox::warning(
        0,
        "Schema editor",
        QString("There is no active schema set!\n\nPlease set a schema file as active and continue!"));
 
      return false;
    }
 
    if (!KernelWrapper::GetInstance().FindClass(className)) {
      KernelWrapper::GetInstance().PushCreateClassCommand(className, "", false);
      return true;
    } else {
      QMessageBox::warning(0, "Schema editor", QString("Can not create class because class already exist !"));
 
      return false;
    }
  };
 
  bool ok;
  QString text = QInputDialog::getText(
    nullptr, "Schema editor: create new class", "New class name:", QLineEdit::Normal, "NewOksClass", &ok);
 
  if (ok && !text.isEmpty()) {
    if (createNewClass(text.toStdString())) {
      SchemaClassEditor* Editor = new SchemaClassEditor(KernelWrapper::GetInstance().FindClass(text.toStdString()));
      Editor->show();
    }
  }
  return text;
}
 
void
dbse::SchemaClassEditor::launch(QString class_name)
{
  bool widgetFound = false;
  dunedaq::oks::OksClass* class_info = KernelWrapper::GetInstance().FindClass(class_name.toStdString());
  for (QWidget* widget : QApplication::allWidgets()) {
    SchemaClassEditor* editor = dynamic_cast<SchemaClassEditor*>(widget);
    if (editor != nullptr) {
      if ((editor->objectName()).compare(class_name) == 0) {
        widget->raise();
        widget->setVisible(true);
        widget->activateWindow();
        widgetFound = true;
        break;
      }
    }
  }
 
  if (!widgetFound) {
    SchemaClassEditor* editor = new SchemaClassEditor(class_info);
    editor->show();
  }
}