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 void	createNewClass ()

Private Slots
void	OpenSuperClass (QModelIndex Index)
void	OpenSubClass (QModelIndex Index)
void	ProxySlot ()
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)

Private Member Functions
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 16 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 338 of file SchemaClassEditor.cpp.

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

AddNewMethod

void dbse::SchemaClassEditor::AddNewMethod ( )

privateslot

Definition at line 352 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 345 of file SchemaClassEditor.cpp.

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

AddNewSuperClass

void dbse::SchemaClassEditor::AddNewSuperClass ( )

privateslot

Definition at line 304 of file SchemaClassEditor.cpp.

{
    QWidget* w = new QWidget();
 
    QLabel* label = new QLabel("Double click on a list item to add the corresponding super-class");
    label->setWordWrap(true);
 
    QLabel* status = new QLabel();
    status->setStyleSheet("QLabel { color : green; }");
 
    QListWidget* qlw = new QListWidget();
    QStringList allClasses;
    KernelWrapper::GetInstance().GetClassListString(allClasses);
    qlw->addItems(allClasses);
 
    connect ( qlw, &QListWidget::itemDoubleClicked,
              this, [=] () {
                                const std::string& className = qlw->currentItem()->text().toStdString();
                                KernelWrapper::GetInstance().PushAddSuperClassCommand(SchemaClass, className);
                                BuildModels();
                                status->setText(QString::fromStdString(className + " added as a super-class of " + SchemaClass->get_name()));
                           });
 
    QVBoxLayout* l = new QVBoxLayout();
    l->addWidget(label);
    l->addWidget(qlw);
    l->addWidget(status);
 
    w->setWindowTitle("Select super-classe(s)");
    w->setLayout(l);
    w->setParent(this, Qt::Dialog);
    w->show();
}

BuildAttributeModelSlot

void dbse::SchemaClassEditor::BuildAttributeModelSlot ( )

privateslot

Definition at line 451 of file SchemaClassEditor.cpp.

{
  QStringList AttributeHeaders
  { "Name", "Type" };
 
  if ( AttributeModel == nullptr ) AttributeModel = new CustomAttributeModel ( SchemaClass,
                                                                               AttributeHeaders,
                                                                               ui->ShowDerivedAttributes->isChecked());
  else
  {
    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 488 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 98 of file SchemaClassEditor.cpp.

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

BuildRelationshipModelSlot

void dbse::SchemaClassEditor::BuildRelationshipModelSlot ( )

privateslot

Definition at line 470 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 528 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 508 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 83 of file SchemaClassEditor.cpp.

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

ClassUpdated

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

privateslot

Definition at line 90 of file SchemaClassEditor.cpp.

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

createNewClass()

void dbse::SchemaClassEditor::createNewClass ( )

static

Definition at line 664 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();
        }
    }
}

CustomMenuAttributeView

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

privateslot

Context Menu Functions.

Definition at line 577 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 548 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 635 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 606 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 107 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 );
  ui->DescriptionTextEdit->setPlainText ( QString::fromStdString ( SchemaClass->get_description() ) );
 
  if ( SchemaClass->get_is_abstract() )
  {
      ui->AbstractComboBox->setCurrentIndex ( 0 );
  }
  else
  {
      ui->AbstractComboBox->setCurrentIndex ( 1 );
  }
}

OpenAttributeEditor

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

privateslot

Definition at line 359 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 387 of file SchemaClassEditor.cpp.

{
  QStringList Row = MethodModel->getRowFromIndex ( Index );
  bool ShouldOpen = ShouldOpenMethodEditor ( Row.at ( 0 ) );
 
  if ( !Row.isEmpty() && ShouldOpen )
  {
    SchemaMethodEditor * Editor = new SchemaMethodEditor (
      SchemaClass, SchemaClass->find_method ( Row.at ( 0 ).toStdString() ) );
    connect ( Editor, SIGNAL ( RebuildModel() ), this, SLOT ( BuildMethodModelSlot() ) );
    Editor->show();
  }
}

OpenNewClassEditor()

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

private

Definition at line 423 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 373 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 412 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 401 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 276 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();
}

ProxySlot

void dbse::SchemaClassEditor::ProxySlot ( )

privateslot

Definition at line 271 of file SchemaClassEditor.cpp.

{
  ParseToSave();
}

RemoveAttribute

void dbse::SchemaClassEditor::RemoveAttribute ( )

privateslot

Remove Functions.

Definition at line 204 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 240 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 221 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 255 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 47 of file SchemaClassEditor.cpp.

{
  connect ( ui->SaveButton, SIGNAL ( clicked() ), this, SLOT ( ProxySlot() ) );
  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 ( doubleClicked ( QModelIndex ) ), this,
            SLOT ( OpenRelationshipEditor ( QModelIndex ) ) );
  connect ( ui->MethodsView, SIGNAL ( doubleClicked ( QModelIndex ) ), this,
            SLOT ( OpenMethodEditor ( QModelIndex ) ) );
  connect ( ui->AttributeView, SIGNAL ( doubleClicked ( QModelIndex ) ), this,
            SLOT ( OpenAttributeEditor ( QModelIndex ) ) );
  connect ( ui->SuperClassView, SIGNAL ( doubleClicked ( QModelIndex ) ), this,
            SLOT ( OpenSuperClass ( QModelIndex ) ) );
  connect ( ui->SubClassView, SIGNAL ( doubleClicked ( 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 135 of file SchemaClassEditor.cpp.

{
  bool WidgetFound = false;
 
  for ( QWidget * Editor : QApplication::allWidgets() )
  {
    SchemaAttributeEditor * Widget = dynamic_cast<SchemaAttributeEditor *> ( Editor );
 
    if ( Widget != nullptr )
    {
      if ( ( Widget->objectName() ).compare ( Name ) == 0 )
      {
        Widget->raise();
        Widget->setVisible ( true );
        Widget->activateWindow();
        WidgetFound = true;
      }
    }
  }
 
  return !WidgetFound;
}

ShouldOpenMethodEditor()

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

private

Definition at line 181 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 158 of file SchemaClassEditor.cpp.

{
  bool WidgetFound = false;
 
  for ( QWidget * Editor : QApplication::allWidgets() )
  {
    SchemaRelationshipEditor * Widget = dynamic_cast<SchemaRelationshipEditor *> ( Editor );
 
    if ( Widget != nullptr )
    {
      if ( ( Widget->objectName() ).compare ( Name ) == 0 )
      {
        Widget->raise();
        Widget->setVisible ( true );
        Widget->activateWindow();
        WidgetFound = true;
      }
    }
  }
 
  return !WidgetFound;
}

Member Data Documentation

AttributeModel

CustomAttributeModel* dbse::SchemaClassEditor::AttributeModel

private

Definition at line 48 of file SchemaClassEditor.hpp.

ContextMenuAttribute

QMenu* dbse::SchemaClassEditor::ContextMenuAttribute

private

Definition at line 52 of file SchemaClassEditor.hpp.

ContextMenuClass

QMenu* dbse::SchemaClassEditor::ContextMenuClass

private

Definition at line 55 of file SchemaClassEditor.hpp.

ContextMenuMethod

QMenu* dbse::SchemaClassEditor::ContextMenuMethod

private

Definition at line 54 of file SchemaClassEditor.hpp.

ContextMenuRelationship

QMenu* dbse::SchemaClassEditor::ContextMenuRelationship

private

Definition at line 53 of file SchemaClassEditor.hpp.

CurrentRow

QStringList dbse::SchemaClassEditor::CurrentRow

private

Definition at line 56 of file SchemaClassEditor.hpp.

MethodModel

CustomMethodModel* dbse::SchemaClassEditor::MethodModel

private

Definition at line 47 of file SchemaClassEditor.hpp.

RelationshipModel

CustomRelationshipModel* dbse::SchemaClassEditor::RelationshipModel

private

Definition at line 49 of file SchemaClassEditor.hpp.

SchemaClass

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

private

Definition at line 46 of file SchemaClassEditor.hpp.

SubClassModel

CustomSubClassModel* dbse::SchemaClassEditor::SubClassModel

private

Definition at line 51 of file SchemaClassEditor.hpp.

SuperClassModel

CustomSuperClassModel* dbse::SchemaClassEditor::SuperClassModel

private

Definition at line 50 of file SchemaClassEditor.hpp.

ui

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

private

Definition at line 44 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