dbse::SchemaClassEditor Class Reference

#include <SchemaClassEditor.hpp>

Inheritance diagram for dbse::SchemaClassEditor:

Collaboration diagram for dbse::SchemaClassEditor:

Public Member Functions
	~SchemaClassEditor ()
	SchemaClassEditor (dunedaq::oks::OksClass *ClassInfo, QWidget *parent=nullptr)

Static Public Member Functions
static QString	createNewClass ()
static void	launch (QString class_name)
static void	move_class (dunedaq::oks::OksClass *schema_class, QWidget *widget)

Private Slots
void	close_slot ()
void	OpenSuperClass (QModelIndex Index)
void	OpenSubClass (QModelIndex Index)
void	ParseToSave ()
void	AddNewSuperClass ()
void	AddNewAttribute ()
void	AddNewRelationship ()
void	AddNewMethod ()
void	OpenAttributeEditor (QModelIndex Index)
void	OpenRelationshipEditor (QModelIndex Index)
void	OpenMethodEditor (QModelIndex Index)
void	BuildAttributeModelSlot ()
void	BuildRelationshipModelSlot ()
void	BuildSuperClassModelSlot ()
void	BuildSubClassModelSlot ()
void	BuildMethodModelSlot ()
void	CustomMenuAttributeView (QPoint pos)
	Context Menu Functions.
void	CustomMenuRelationshipView (QPoint pos)
void	CustomMenuMethodView (QPoint pos)
void	CustomMenuClassView (QPoint pos)
void	RemoveAttribute ()
	Remove Functions.
void	RemoveRelationship ()
void	RemoveMethod ()
void	RemoveSuperClass ()
void	ClassRemoved (QString className)
void	ClassUpdated (QString className)
void	move_class ()

Private Member Functions
void	keyPressEvent (QKeyEvent *event)
void	SetController ()
void	BuildModels ()
void	InitialSettings ()
bool	ShouldOpenAttributeEditor (QString Name)
	Helper functions.
bool	ShouldOpenRelationshipEditor (QString Name)
bool	ShouldOpenMethodEditor (QString Name)
void	OpenNewClassEditor (const QString &ClassName)

Private Attributes
std::unique_ptr< dbse::Ui::SchemaClassEditor >	ui
dunedaq::oks::OksClass *	SchemaClass
CustomMethodModel *	MethodModel
CustomAttributeModel *	AttributeModel
CustomRelationshipModel *	RelationshipModel
CustomSuperClassModel *	SuperClassModel
CustomSubClassModel *	SubClassModel
QMenu *	ContextMenuAttribute
QMenu *	ContextMenuRelationship
QMenu *	ContextMenuMethod
QMenu *	ContextMenuClass
QStringList	CurrentRow

Detailed Description

Definition at line 25 of file SchemaClassEditor.hpp.

Constructor & Destructor Documentation

~SchemaClassEditor()

dbse::SchemaClassEditor::~SchemaClassEditor ( )

default

SchemaClassEditor()

dbse::SchemaClassEditor::SchemaClassEditor ( dunedaq::oks::OksClass * ClassInfo, QWidget * parent = nullptr )

explicit

Settings

Settings

Editing Settings

Definition at line 25 of file SchemaClassEditor.cpp.

  : 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();
}

Member Function Documentation

AddNewAttribute

void dbse::SchemaClassEditor::AddNewAttribute ( )

privateslot

Definition at line 480 of file SchemaClassEditor.cpp.

{
  if (ShouldOpenAttributeEditor("")) {
    SchemaAttributeEditor * Editor = new SchemaAttributeEditor ( SchemaClass );
    connect ( Editor, SIGNAL ( RebuildModel() ), this, SLOT ( BuildAttributeModelSlot() ) );
    Editor->show();
  }
}

AddNewMethod

void dbse::SchemaClassEditor::AddNewMethod ( )

privateslot

Definition at line 498 of file SchemaClassEditor.cpp.

{
  SchemaMethodEditor * Editor = new SchemaMethodEditor ( SchemaClass );
  connect ( Editor, SIGNAL ( RebuildModel() ), this, SLOT ( BuildMethodModelSlot() ) );
  Editor->show();
}

AddNewRelationship

void dbse::SchemaClassEditor::AddNewRelationship ( )

privateslot

Definition at line 489 of file SchemaClassEditor.cpp.

{
  if (ShouldOpenRelationshipEditor("")) {
    SchemaRelationshipEditor * Editor = new SchemaRelationshipEditor ( SchemaClass );
    connect ( Editor, SIGNAL ( RebuildModel() ), this, SLOT ( BuildRelationshipModelSlot() ) );
    Editor->show();
  }
}

AddNewSuperClass

void dbse::SchemaClassEditor::AddNewSuperClass ( )

privateslot

Definition at line 415 of file SchemaClassEditor.cpp.

{
  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();
  }
}

BuildAttributeModelSlot

void dbse::SchemaClassEditor::BuildAttributeModelSlot ( )

privateslot

Definition at line 608 of file SchemaClassEditor.cpp.

{
  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 );
}

BuildMethodModelSlot

void dbse::SchemaClassEditor::BuildMethodModelSlot ( )

privateslot

Definition at line 644 of file SchemaClassEditor.cpp.

{
  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 );
}

BuildModels()

void dbse::SchemaClassEditor::BuildModels ( )

private

Definition at line 115 of file SchemaClassEditor.cpp.

{
    BuildSubClassModelSlot();
    BuildSuperClassModelSlot();
    BuildMethodModelSlot();
    BuildAttributeModelSlot();
    BuildRelationshipModelSlot();
}

BuildRelationshipModelSlot

void dbse::SchemaClassEditor::BuildRelationshipModelSlot ( )

privateslot

Definition at line 626 of file SchemaClassEditor.cpp.

{
  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 );
}

BuildSubClassModelSlot

void dbse::SchemaClassEditor::BuildSubClassModelSlot ( )

privateslot

Definition at line 684 of file SchemaClassEditor.cpp.

{
  QStringList SubClassHeaders
  { "Class Name" };
 
  if ( SubClassModel == nullptr )
  {
    SubClassModel = new CustomSubClassModel ( SchemaClass, SubClassHeaders );
  }
  else
  {
    delete SubClassModel;
    SubClassModel = new CustomSubClassModel ( SchemaClass, SubClassHeaders );
  }
 
  ui->SubClassView->setModel ( SubClassModel );
  ui->SubClassView->horizontalHeader()->setSectionResizeMode ( QHeaderView::Stretch );
  ui->SubClassView->setSelectionBehavior ( QAbstractItemView::SelectRows );
}

BuildSuperClassModelSlot

void dbse::SchemaClassEditor::BuildSuperClassModelSlot ( )

privateslot

Definition at line 664 of file SchemaClassEditor.cpp.

{
  QStringList SuperClassHeaders
  { "Class Name" };
 
  if ( SuperClassModel == nullptr )
  {
    SuperClassModel = new CustomSuperClassModel ( SchemaClass, SuperClassHeaders, ui->ShowAllSuperClasses->isChecked() );
  }
  else
  {
    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 );
}

ClassRemoved

void dbse::SchemaClassEditor::ClassRemoved ( QString className )

privateslot

Definition at line 100 of file SchemaClassEditor.cpp.

{
    if(className == objectName()) {
        QWidget::close();
    }
}

ClassUpdated

void dbse::SchemaClassEditor::ClassUpdated ( QString className )

privateslot

Definition at line 107 of file SchemaClassEditor.cpp.

{
    if(className == objectName()) {
       BuildModels();
       InitialSettings();
    }
}

close_slot

void dbse::SchemaClassEditor::close_slot ( )

inlineprivateslot

Definition at line 64 of file SchemaClassEditor.hpp.

{close();}

createNewClass()

QString dbse::SchemaClassEditor::createNewClass ( )

static

Definition at line 820 of file SchemaClassEditor.cpp.

{
    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;
}

CustomMenuAttributeView

void dbse::SchemaClassEditor::CustomMenuAttributeView ( QPoint pos )

privateslot

Context Menu Functions.

Definition at line 733 of file SchemaClassEditor.cpp.

{
  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 ) );
  }
}

CustomMenuClassView

void dbse::SchemaClassEditor::CustomMenuClassView ( QPoint pos )

privateslot

Definition at line 704 of file SchemaClassEditor.cpp.

{
  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 ) );
  }
}

CustomMenuMethodView

void dbse::SchemaClassEditor::CustomMenuMethodView ( QPoint pos )

privateslot

Definition at line 791 of file SchemaClassEditor.cpp.

{
  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 );
    ContextMenuMethod->exec ( ui->MethodsView->mapToGlobal ( pos ) );
  }
}

CustomMenuRelationshipView

void dbse::SchemaClassEditor::CustomMenuRelationshipView ( QPoint pos )

privateslot

Definition at line 762 of file SchemaClassEditor.cpp.

{
  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 ) );
  }
}

InitialSettings()

void dbse::SchemaClassEditor::InitialSettings ( )

private

Class Name

Schema File

Description

Abstract

Definition at line 124 of file SchemaClassEditor.cpp.

{
  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 );
  }
}

keyPressEvent()

void dbse::SchemaClassEditor::keyPressEvent ( QKeyEvent * event )

private

Definition at line 56 of file SchemaClassEditor.cpp.

                                                          {
  if (event->key() == Qt::Key_Escape) {
    close();
  }
  QWidget::keyPressEvent(event);
}

launch()

void dbse::SchemaClassEditor::launch ( QString class_name )

static

Definition at line 863 of file SchemaClassEditor.cpp.

                                                     {
  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();
    }
}

move_class [1/2]

void dbse::SchemaClassEditor::move_class ( )

privateslot

Definition at line 174 of file SchemaClassEditor.cpp.

                                       {
  move_class(SchemaClass, this);
}

move_class() [2/2]

void dbse::SchemaClassEditor::move_class ( dunedaq::oks::OksClass * schema_class, QWidget * widget )

static

Definition at line 179 of file SchemaClassEditor.cpp.

                    {
  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();
}

OpenAttributeEditor

void dbse::SchemaClassEditor::OpenAttributeEditor ( QModelIndex Index )

privateslot

Definition at line 505 of file SchemaClassEditor.cpp.

{
  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();
  }
}

OpenMethodEditor

void dbse::SchemaClassEditor::OpenMethodEditor ( QModelIndex Index )

privateslot

Definition at line 533 of file SchemaClassEditor.cpp.

{
  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();
  }
}

OpenNewClassEditor()

void dbse::SchemaClassEditor::OpenNewClassEditor ( const QString & ClassName )

private

Definition at line 580 of file SchemaClassEditor.cpp.

{
  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();
  }
}

OpenRelationshipEditor

void dbse::SchemaClassEditor::OpenRelationshipEditor ( QModelIndex Index )

privateslot

Definition at line 519 of file SchemaClassEditor.cpp.

{
  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();
  }
}

OpenSubClass

void dbse::SchemaClassEditor::OpenSubClass ( QModelIndex Index )

privateslot

Definition at line 569 of file SchemaClassEditor.cpp.

{
    QStringList Row = SubClassModel->getRowFromIndex ( Index );
 
    if ( !Row.isEmpty() )
    {
      QString ClassName = Row.at ( 0 );
      OpenNewClassEditor(ClassName);
    }
}

OpenSuperClass

void dbse::SchemaClassEditor::OpenSuperClass ( QModelIndex Index )

privateslot

Definition at line 558 of file SchemaClassEditor.cpp.

{
    QStringList Row = SuperClassModel->getRowFromIndex ( Index );
 
    if ( !Row.isEmpty() )
    {
      QString ClassName = Row.at ( 0 );
      OpenNewClassEditor(ClassName);
    }
}

ParseToSave

void dbse::SchemaClassEditor::ParseToSave ( )

privateslot

Definition at line 387 of file SchemaClassEditor.cpp.

{
  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();
}

RemoveAttribute

void dbse::SchemaClassEditor::RemoveAttribute ( )

privateslot

Remove Functions.

Definition at line 320 of file SchemaClassEditor.cpp.

{
  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() + "\"") );
  }
}

RemoveMethod

void dbse::SchemaClassEditor::RemoveMethod ( )

privateslot

Definition at line 356 of file SchemaClassEditor.cpp.

{
  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() + "\"") );
  }
}

RemoveRelationship

void dbse::SchemaClassEditor::RemoveRelationship ( )

privateslot

Definition at line 337 of file SchemaClassEditor.cpp.

{
  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() + "\"") );
  }
}

RemoveSuperClass

void dbse::SchemaClassEditor::RemoveSuperClass ( )

privateslot

Definition at line 371 of file SchemaClassEditor.cpp.

{
  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() + "\"") );
  }
}

SetController()

void dbse::SchemaClassEditor::SetController ( )

private

Definition at line 62 of file SchemaClassEditor.cpp.

{
  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 ) ) );
}

ShouldOpenAttributeEditor()

bool dbse::SchemaClassEditor::ShouldOpenAttributeEditor ( QString Name )

private

Helper functions.

Definition at line 254 of file SchemaClassEditor.cpp.

{
  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;
}

ShouldOpenMethodEditor()

bool dbse::SchemaClassEditor::ShouldOpenMethodEditor ( QString Name )

private

Definition at line 297 of file SchemaClassEditor.cpp.

{
  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;
}

ShouldOpenRelationshipEditor()

bool dbse::SchemaClassEditor::ShouldOpenRelationshipEditor ( QString Name )

private

Definition at line 275 of file SchemaClassEditor.cpp.

{
  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;
}

Member Data Documentation

AttributeModel

CustomAttributeModel* dbse::SchemaClassEditor::AttributeModel

private

Definition at line 51 of file SchemaClassEditor.hpp.

ContextMenuAttribute

QMenu* dbse::SchemaClassEditor::ContextMenuAttribute

private

Definition at line 55 of file SchemaClassEditor.hpp.

ContextMenuClass

QMenu* dbse::SchemaClassEditor::ContextMenuClass

private

Definition at line 58 of file SchemaClassEditor.hpp.

ContextMenuMethod

QMenu* dbse::SchemaClassEditor::ContextMenuMethod

private

Definition at line 57 of file SchemaClassEditor.hpp.

ContextMenuRelationship

QMenu* dbse::SchemaClassEditor::ContextMenuRelationship

private

Definition at line 56 of file SchemaClassEditor.hpp.

CurrentRow

QStringList dbse::SchemaClassEditor::CurrentRow

private

Definition at line 59 of file SchemaClassEditor.hpp.

MethodModel

CustomMethodModel* dbse::SchemaClassEditor::MethodModel

private

Definition at line 50 of file SchemaClassEditor.hpp.

RelationshipModel

CustomRelationshipModel* dbse::SchemaClassEditor::RelationshipModel

private

Definition at line 52 of file SchemaClassEditor.hpp.

SchemaClass

dunedaq::oks::OksClass* dbse::SchemaClassEditor::SchemaClass

private

Definition at line 49 of file SchemaClassEditor.hpp.

SubClassModel

CustomSubClassModel* dbse::SchemaClassEditor::SubClassModel

private

Definition at line 54 of file SchemaClassEditor.hpp.

SuperClassModel

CustomSuperClassModel* dbse::SchemaClassEditor::SuperClassModel

private

Definition at line 53 of file SchemaClassEditor.hpp.

ui

std::unique_ptr<dbse::Ui::SchemaClassEditor> dbse::SchemaClassEditor::ui

private

Definition at line 47 of file SchemaClassEditor.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/SchemaClassEditor.hpp
• /github/workspace/dunedaq/sourcecode/dbe/apps/SchemaEditor/SchemaClassEditor.cpp