dbse::SchemaFileInfo Class Reference

#include <SchemaFileInfo.hpp>

Inheritance diagram for dbse::SchemaFileInfo:

Collaboration diagram for dbse::SchemaFileInfo:

Signals
void	files_updated ()
void	new_window (SchemaFileInfo *win)

Public Member Functions
	SchemaFileInfo (std::string filename, QWidget *parent=0)
	~SchemaFileInfo ()=default
void	show_file_info (QString fn)
void	keyPressEvent (QKeyEvent *event) override

Private Slots
void	accept ()
void	reject ()
void	add_include ()
void	remove_include ()
void	set_active ()
void	add_missing_includes ()
void	launch_class_editor (QListWidgetItem *)
void	show_file_info ()
void	show_file_info (QListWidgetItem *)
void	activate_include_context_menu (QPoint point)
void	activate_class_context_menu (QPoint point)
void	add_new_class ()
void	edit_class ()
void	move_class ()
void	remove_class ()
void	set_schemafile_active ()
void	show_status ()
void	class_updated (QString class_name)
void	save_schema ()

Private Member Functions
void	get_includes ()
void	add_file (std::string file)
bool	check_relationships (dunedaq::oks::OksClass *cls)
bool	check_superclasses (dunedaq::oks::OksClass *cls)
std::string	prune_path (std::string file)
bool	set_active (std::string filename)
void	remove_include (std::string filename)
void	update_class_list ()

Private Attributes
Ui::SchemaFileInfo *	m_ui
std::string	m_filename
std::set< std::string >	m_missing_includes
std::set< std::string >	m_all_includes
QMenu *	m_include_menu
QMenu *	m_class_menu
QStringList	m_path_list
QList< QUrl >	m_path_urls
QPushButton *	m_add_button
QPushButton *	m_missing_button

Detailed Description

Definition at line 25 of file SchemaFileInfo.hpp.

Constructor & Destructor Documentation

SchemaFileInfo()

dbse::SchemaFileInfo::SchemaFileInfo	(	std::string	filename,
		QWidget *	parent = 0 )

Definition at line 20 of file SchemaFileInfo.cpp.

  : m_ui(new Ui::SchemaFileInfo), m_filename(filename),
    m_include_menu(nullptr), m_class_menu(nullptr) {
 
  QWidget::setAttribute(Qt::WA_DeleteOnClose);
 
  m_ui->setupUi(this);
  // m_ui->buttonBox->setStandardButtons(QDialogButtonBox::Ok);
  m_ui->missing_button->hide();
  // m_ui->class_list->setDragEnabled ( true );
  // m_ui->class_list->setAcceptDrops ( true );
  setObjectName(QString::fromStdString(filename));
  auto sp = filename.find_last_of('/');
  if (sp == std::string::npos) {
    sp = 0;
  }
  else {
    sp++;
  }
  setWindowTitle(
    QString("Schema File:  %1").arg(QString::fromStdString(filename.substr(sp))));
 
  m_ui->label->setText(QString::fromStdString(filename));
  if (!KernelWrapper::GetInstance().IsFileWritable ( m_filename )) {
    QPalette pal;
    pal.setColor(QPalette::Active, QPalette::WindowText,SchemaStyle::get_color("foreground", "readonly"));
    m_ui->label->setPalette(pal);
//    m_ui->label->setStyleSheet("color:rgb(128,0,0);");
  }
  show_status();
 
 
  QString DUNEDAQ_DB_PATH = getenv ( "DUNEDAQ_DB_PATH" );
  m_path_list = DUNEDAQ_DB_PATH.split (QLatin1Char(':'), Qt::SkipEmptyParts );
  for ( QString & path : m_path_list ) {
    if ( !path.endsWith ( "/" ) ) {
      path.append ( "/" );
    }
    m_path_urls.append(QUrl::fromLocalFile(path));
  }
 
  get_includes();
 
  m_ui->textBrowser->hide();
 
  update_class_list();
 
  m_ui->include_list->setContextMenuPolicy ( Qt::ContextMenuPolicy::CustomContextMenu );
  m_ui->class_list->setContextMenuPolicy ( Qt::ContextMenuPolicy::CustomContextMenu );
  connect (m_ui->include_list, SIGNAL (itemActivated(QListWidgetItem*)),
           this, SLOT (show_file_info(QListWidgetItem*)) );
  connect (m_ui->include_list, SIGNAL (customContextMenuRequested(QPoint)),
           this, SLOT (activate_include_context_menu(QPoint)));
 
 
  if (KernelWrapper::GetInstance().IsFileWritable ( m_filename )) {
    connect (m_ui->active_button, SIGNAL(pressed()), this, SLOT(set_active()));
    connect (m_ui->add_button, SIGNAL(pressed()), this, SLOT(add_include()));
    connect (m_ui->missing_button, SIGNAL (pressed()), this, SLOT(add_missing_includes()));
    connect (&KernelWrapper::GetInstance(), SIGNAL (ClassUpdated(QString)),
             this, SLOT(class_updated(QString)));
    connect (m_ui->class_list, SIGNAL (customContextMenuRequested(QPoint)),
             this, SLOT (activate_class_context_menu(QPoint)));
  }
  else {
    m_ui->add_button->setEnabled(false);
    m_ui->active_button->setEnabled(false);
    m_ui->save_button->setEnabled(false);
  }
  connect (m_ui->save_button, SIGNAL(pressed()), this, SLOT(save_schema()));
  connect (m_ui->close_button, SIGNAL(pressed()), this, SLOT(close()));
  connect (&KernelWrapper::GetInstance(), SIGNAL (active_updated()),
           this, SLOT(show_status()));
 
  connect (m_ui->class_list, SIGNAL (itemActivated(QListWidgetItem*)),
           this, SLOT (launch_class_editor(QListWidgetItem*)));
}

~SchemaFileInfo()

dbse::SchemaFileInfo::~SchemaFileInfo ( )

default

Member Function Documentation

accept

void dbse::SchemaFileInfo::accept ( )

privateslot

Definition at line 263 of file SchemaFileInfo.cpp.

                            {
  close();
}

activate_class_context_menu

void dbse::SchemaFileInfo::activate_class_context_menu ( QPoint point )

privateslot

Definition at line 463 of file SchemaFileInfo.cpp.

{
  if (m_class_menu == nullptr) {
    m_class_menu = new QMenu (this);
 
    QAction * add = new QAction (tr("&Add New Class"), this );
    connect (add, SIGNAL (triggered()), this, SLOT (add_new_class()));
 
    QAction* remove = new QAction(tr("&Remove Selected Class"), this );
    connect (remove, SIGNAL(triggered()), this, SLOT(remove_class()));
 
    QAction* edit = new QAction(tr( "&Edit Selected Class"), this );
    connect (edit, SIGNAL (triggered()), this, SLOT (edit_class()));
 
    QAction* move = new QAction(tr( "&Move Selected Class"), this );
    connect (move, SIGNAL (triggered()), this, SLOT (move_class()));
 
    m_class_menu->addAction (add);
    m_class_menu->addAction (edit);
    m_class_menu->addAction (move);
    m_class_menu->addAction (remove);
  }
 
  if (m_ui->class_list->currentIndex().isValid()) {
    m_class_menu->exec (m_ui->class_list->mapToGlobal(pos));
  }
}

activate_include_context_menu

void dbse::SchemaFileInfo::activate_include_context_menu ( QPoint point )

privateslot

Definition at line 439 of file SchemaFileInfo.cpp.

{
  if (m_include_menu == nullptr) {
    m_include_menu = new QMenu (this);
 
    if (KernelWrapper::GetInstance().IsFileWritable ( m_filename )) {
      QAction* add = new QAction ( tr ( "Add New Include File" ), this );
      connect (add, SIGNAL ( triggered() ), this, SLOT ( add_include() ) );
      QAction* remove = new QAction ( tr ( "Remove Selected Include File" ), this );
      connect (remove, SIGNAL ( triggered() ), this, SLOT ( remove_include() ) );
      m_include_menu->addAction ( add );
      m_include_menu->addAction ( remove );
    }
    QAction* info = new QAction ( tr ( "Show file info" ), this );
    connect (info, SIGNAL ( triggered() ), this, SLOT ( show_file_info() ) );
 
    m_include_menu->addAction ( info );
  }
 
  if (m_ui->include_list->currentIndex().isValid()) {
    m_include_menu->exec (m_ui->include_list->mapToGlobal(pos));
  }
}

add_file()

void dbse::SchemaFileInfo::add_file ( std::string file )

private

Definition at line 425 of file SchemaFileInfo.cpp.

                                                  {
  std::cout << "   " << file << "\n";
  try {
    KernelWrapper::GetInstance().AddInclude(m_filename, prune_path(file));
    emit files_updated();
  }
  catch (std::exception& exc) {
    QString message = QString(
      "Failed to add %1 to included files, %2" ).arg(
        QString::fromStdString(file)).arg(exc.what());
    QMessageBox::warning ( 0, "Schema editor", message );
  }
}

add_include

void dbse::SchemaFileInfo::add_include ( )

privateslot

Definition at line 382 of file SchemaFileInfo.cpp.

                                 {
  auto fd = new QFileDialog ( this, tr ( "Open File" ), ".",
                              tr ( "XML schema files (*.schema.xml)" ) );
  fd->setFileMode ( QFileDialog::ExistingFiles );
  fd->setViewMode ( QFileDialog::Detail );
  fd->setAcceptMode ( QFileDialog::AcceptOpen );
  fd->setSidebarUrls(m_path_urls);
  fd->exec();
  auto files = fd->selectedFiles();
  for (auto file: files) {
    add_file(file.toStdString());
  }
  get_includes();
  update_class_list();
  show_status();
}

add_missing_includes

void dbse::SchemaFileInfo::add_missing_includes ( )

privateslot

Definition at line 399 of file SchemaFileInfo.cpp.

                                          {
  std::cout << "\nAdding missing include files:\n";
 
  for (auto file: m_missing_includes) {
    add_file(file);
  }
  m_missing_includes.clear();
 
  get_includes();
  m_ui->textBrowser->clear();
  m_ui->textBrowser->hide();
 
  get_includes();
  update_class_list();
  show_status();
}

add_new_class

void dbse::SchemaFileInfo::add_new_class ( )

privateslot

Definition at line 557 of file SchemaFileInfo.cpp.

{
  if (set_active (m_filename)) {
    auto nc = SchemaClassEditor::createNewClass();
    if (!nc.isEmpty()) {
      auto item = new QListWidgetItem(nc);
      m_ui->class_list->addItem(item);
      m_ui->class_list->sortItems();
      m_ui->class_list->setCurrentItem(item);
      m_ui->class_list->update();
    }
  }
}

check_relationships()

bool dbse::SchemaFileInfo::check_relationships ( dunedaq::oks::OksClass * cls )

private

Definition at line 126 of file SchemaFileInfo.cpp.

                                                                {
  bool ok = true;
  auto relationships = cls->direct_relationships();
  if (relationships != nullptr) {
    for (auto rel: *relationships) {
      auto rel_class = rel->get_class_type();
      if (rel_class == nullptr) {
        QString warning = "<b>Warning</b> class <i>"
          + QString::fromStdString(cls->get_name())
          + "</i> has relationship "
          + QString::fromStdString(rel->get_name())
          + " referring to class <i>"
          + QString::fromStdString(rel->get_type())
          + "</i> which is not loaded<br>";
        m_ui->textBrowser->insertHtml(warning);
        m_ui->textBrowser->show();
        ok = false;
        continue;
      }
      auto file = rel_class->get_file()->get_full_file_name();
      if (file != m_filename && !m_all_includes.contains(file)) {
        m_missing_includes.insert(file);
        QString warning = "<b>Warning</b> class <i>"
          + QString::fromStdString(cls->get_name())
          + "</i> has relationship "
          + QString::fromStdString(rel->get_name())
          + " referring to class <i>"
          + QString::fromStdString(rel->get_class_type()->get_name())
          + "</i> from " + QString::fromStdString(file)
          + " which is not included<br>";
        m_ui->textBrowser->insertHtml(warning);
        m_ui->textBrowser->show();
        ok = false;
      }
    }
  }
  return ok;
}

check_superclasses()

bool dbse::SchemaFileInfo::check_superclasses ( dunedaq::oks::OksClass * cls )

private

Definition at line 165 of file SchemaFileInfo.cpp.

                                                               {
  bool ok = true;
  auto super_classes = cls->direct_super_classes();
  if (super_classes != nullptr) {
    for (auto sc: *super_classes) {
      auto sclass = KernelWrapper::GetInstance().FindClass(*sc);
      if (sclass == nullptr) {
        QString warning = "<b>Warning</b> class <i>"
          + QString::fromStdString(cls->get_name())
          + "</i> refers to super class <i>" + QString::fromStdString(*sc)
          + "</i> which is not known<br>";
        m_ui->textBrowser->insertHtml(warning);
        m_ui->textBrowser->show();
        ok = false;
        continue;
      }
      auto file = sclass->get_file()->get_full_file_name();
      if (file != m_filename && !m_all_includes.contains(file)) {
        m_missing_includes.insert(file);
        QString warning = "<b>Warning</b> class <i>"
          + QString::fromStdString(cls->get_name())
          + "</i> refers to super class <i>" + QString::fromStdString(*sc)
          + "</i> from " + QString::fromStdString(file)
          + " which is not included<br>";
        m_ui->textBrowser->insertHtml(warning);
        m_ui->textBrowser->show();
        ok = false;
      }
    }
  }
  return ok;
}

class_updated

void dbse::SchemaFileInfo::class_updated ( QString class_name )

privateslot

Definition at line 326 of file SchemaFileInfo.cpp.

                                            {
  // auto cls = KernelWrapper::GetInstance().FindClass(class_name.toStdString());
  // auto file = cls->get_file()->get_full_file_name();
  // if (file == m_filename) {
    show_status();
    update_class_list();
  // }
}

edit_class

void dbse::SchemaFileInfo::edit_class ( )

privateslot

Definition at line 491 of file SchemaFileInfo.cpp.

{
  SchemaClassEditor::launch(m_ui->class_list->currentItem()->text());
}

files_updated

void dbse::SchemaFileInfo::files_updated ( )

signal

get_includes()

void dbse::SchemaFileInfo::get_includes ( )

private

Definition at line 98 of file SchemaFileInfo.cpp.

                                  {
  m_ui->include_list->clear();
  m_all_includes.clear();
  KernelWrapper::GetInstance().get_all_includes(m_filename, m_all_includes);
 
  std::set<std::string> direct_includes;
  KernelWrapper::GetInstance().get_direct_includes(m_filename, direct_includes);
 
  for (auto inc: m_all_includes) {
    auto file = prune_path(inc);
    auto item = new QListWidgetItem(QString::fromStdString(file));
    item->setToolTip(QString::fromStdString(inc));
    m_ui->include_list->addItem(item);
    if (!direct_includes.contains(file)) {
      item->setForeground(QBrush(SchemaStyle::get_color("foreground", "inherited")));
    }
    else if (!KernelWrapper::GetInstance().IsFileWritable (inc)) {
      item->setForeground(QBrush(SchemaStyle::get_color("foreground", "readonly")));
      item->setBackground(QBrush(SchemaStyle::get_color("background", "readonly")));
    }
    else {
      item->setForeground(QBrush(SchemaStyle::get_color("foreground", "default")));
      item->setBackground(QBrush(SchemaStyle::get_color("background", "default")));
    }
  }
  m_ui->include_list->update();
}

keyPressEvent()

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

override

Definition at line 271 of file SchemaFileInfo.cpp.

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

launch_class_editor

void dbse::SchemaFileInfo::launch_class_editor ( QListWidgetItem * item )

privateslot

Definition at line 278 of file SchemaFileInfo.cpp.

                                                              {
  SchemaClassEditor::launch(item->text());
}

move_class

void dbse::SchemaFileInfo::move_class ( )

privateslot

Definition at line 495 of file SchemaFileInfo.cpp.

{
  auto oks_class = KernelWrapper::GetInstance().FindClass(
    m_ui->class_list->currentItem()->text().toStdString());
  SchemaClassEditor::move_class(oks_class, this);
}

new_window

void dbse::SchemaFileInfo::new_window ( SchemaFileInfo * win )

signal

prune_path()

std::string dbse::SchemaFileInfo::prune_path ( std::string file )

private

Definition at line 416 of file SchemaFileInfo.cpp.

                                                   {
  for ( QString & element : m_path_list ) {
    if (file.starts_with(element.toStdString())) {
      file = file.substr (element.size());
      break;
    }
  }
  return file;
}

reject

void dbse::SchemaFileInfo::reject ( )

privateslot

Definition at line 267 of file SchemaFileInfo.cpp.

                            {
  close();
}

remove_class

void dbse::SchemaFileInfo::remove_class ( )

privateslot

Definition at line 501 of file SchemaFileInfo.cpp.

{
  auto item = m_ui->class_list->currentItem();
  QString cn = item->text();
  dunedaq::oks::OksClass* schema_class =
    KernelWrapper::GetInstance().FindClass(cn.toStdString());
  if (schema_class->all_sub_classes()->size() != 0) {
    QMessageBox::warning ( 0, "Schema editor",
                           QString ( "Cannot delete class because it has sub-classes." ) );
    return;
  }
  else if (KernelWrapper::GetInstance().AnyClassReferenceThis(schema_class)) {
    QMessageBox::warning (0, "Schema editor",
                          QString ( "Cannot delete class because some other classes references it."));
    return;
  }
 
  KernelWrapper::GetInstance().PushRemoveClassCommand (schema_class,
                                                       schema_class->get_name(),
                                                       schema_class->get_description(),
                                                       schema_class->get_is_abstract() );
  delete item;
  m_ui->class_list->update();
}

remove_include [1/2]

void dbse::SchemaFileInfo::remove_include ( )

privateslot

Definition at line 256 of file SchemaFileInfo.cpp.

                                        {
  auto item = m_ui->include_list->currentItem();
  std::string fn = item->text().toStdString();
  remove_include (fn);
}

remove_include() [2/2]

void dbse::SchemaFileInfo::remove_include ( std::string filename )

private

Definition at line 198 of file SchemaFileInfo.cpp.

                                                      {
  std::cout << "Removing include file " << filename << "\n";
 
  auto temp_files = m_all_includes;
  temp_files.erase(filename);
  temp_files.insert(m_filename);
 
  auto classes = KernelWrapper::GetInstance().get_schema_classes(m_filename);
  for (auto cls: classes) {
    // Ignore classes in file we're removing
    if (cls->get_file()->get_full_file_name() != filename) {
      auto relationships = cls->direct_relationships();
      if (relationships != nullptr) {
        for (auto rel: *relationships) {
          auto file = rel->get_class_type()->get_file()->get_full_file_name();
          if (!temp_files.contains(file)) {
            auto message = QString(
              "Cannot remove %1 as class %2 has relationship to its %3 class").arg(
                QString::fromStdString(filename)).arg(
                  QString::fromStdString(cls->get_name())).arg(
                    QString::fromStdString(rel->get_class_type()->get_name()));
            QMessageBox::warning ( 0, "Schema editor", message );
            return;
          }
        }
      }
      auto super_classes = cls->direct_super_classes();
      if (super_classes != nullptr) {
        for (auto sc: *super_classes) {
          auto sclass = KernelWrapper::GetInstance().FindClass(*sc);
          auto file = sclass->get_file()->get_full_file_name();
          if (!temp_files.contains(file)) {
            auto message = QString(
              "Cannot remove %1 as class %2 has superclass %3 in %1").arg(
                QString::fromStdString(filename)).arg(
                  QString::fromStdString(cls->get_name())).arg(
                    QString::fromStdString(*sc));
            QMessageBox::warning ( 0, "Schema editor", message );
            return;
          }
        }
      }
    }
  }
  try {
    dbse::KernelWrapper::GetInstance().RemoveInclude(m_filename,
                                                     prune_path(filename));
    m_all_includes.erase(filename);
  }
  catch (dunedaq::oks::FailedRemoveInclude& exc) {
    QMessageBox::warning (0, "Schema editor", QString::fromStdString(exc.what()));
  }
 
  get_includes();
  update_class_list();
  show_status();
}

save_schema

void dbse::SchemaFileInfo::save_schema ( )

privateslot

Definition at line 335 of file SchemaFileInfo.cpp.

                                 {
  try {
    KernelWrapper::GetInstance().SaveSchema (m_filename);
  }
  catch (const dunedaq::oks::exception& exc) {
    QMessageBox::warning(0,
                         "Save Schema",
                         QString("Failed to save file %1" )
                         .arg (m_filename.c_str())
                         .append(QString(exc.what())),
                         QMessageBox::Ok);
  }
  show_status();
  emit files_updated();
}

set_active [1/2]

void dbse::SchemaFileInfo::set_active ( )

privateslot

Definition at line 551 of file SchemaFileInfo.cpp.

                                    {
  set_active (m_filename);
  show_status();
}

set_active() [2/2]

bool dbse::SchemaFileInfo::set_active ( std::string filename )

private

Definition at line 526 of file SchemaFileInfo.cpp.

                                                      {
  try {
    KernelWrapper::GetInstance().SetActiveSchema (filename);
  }
  catch (dunedaq::oks::CanNotSetActiveFile& exc) {
    auto qfn = QString::fromStdString(m_filename);
    auto text = QString("Could not make schema file %1 active!\n\n").arg(qfn);
    QMessageBox::warning(0,
                         "Set Active Schema",
                         text.append(QString(exc.what())),
                         QMessageBox::Ok);
    return false;
  }
  show_status();
  return true;
}

set_schemafile_active

void dbse::SchemaFileInfo::set_schemafile_active ( )

privateslot

Definition at line 544 of file SchemaFileInfo.cpp.

                                               {
  auto item = m_ui->include_list->currentItem();
  std::string fn = item->text().toStdString();
  set_active (fn);
  show_status();
}

show_file_info [1/3]

void dbse::SchemaFileInfo::show_file_info ( )

privateslot

Definition at line 573 of file SchemaFileInfo.cpp.

                                        {
  show_file_info(m_ui->include_list->currentItem());
}

show_file_info [2/3]

void dbse::SchemaFileInfo::show_file_info ( QListWidgetItem * item )

privateslot

Definition at line 576 of file SchemaFileInfo.cpp.

                                                             {
  show_file_info(item->text());
}

show_file_info() [3/3]

void dbse::SchemaFileInfo::show_file_info

(

QString

fn

)

Definition at line 579 of file SchemaFileInfo.cpp.

                                                  {
  bool widget_found = false;
  for ( QWidget * widget : QApplication::allWidgets() ) {
    auto sfi = dynamic_cast<SchemaFileInfo *> ( widget );
    if ( sfi != nullptr ) {
      if ( (sfi->objectName() ).compare ( fn ) == 0 ) {
        sfi->raise();
        sfi->setVisible ( true );
        sfi->activateWindow();
        widget_found = true;
        break;
      }
    }
  }
  if ( !widget_found ) {
    auto info = new SchemaFileInfo(fn.toStdString());
    // connect (info, &SchemaFileInfo::files_updated,
    //          this, &SchemaMainWindow::update_models);
    emit new_window(this);
    info->show();
  }
}

show_status

void dbse::SchemaFileInfo::show_status ( )

privateslot

Definition at line 351 of file SchemaFileInfo.cpp.

                                 {
  QString status;
  if (KernelWrapper::GetInstance().IsFileWritable ( m_filename )) {
    status.append("Read/Write");
  }
  else {
    status.append("Read only");
  }
  if (KernelWrapper::GetInstance().is_file_modified ( m_filename )) {
    status.append("  Modified");
    if (m_missing_includes.empty()) {
      m_ui->save_button->setEnabled(true);
    }
    else {
      m_ui->save_button->setEnabled(false);
    }
  }
  else {
    m_ui->save_button->setEnabled(false);
  }
 
  if (m_filename == KernelWrapper::GetInstance().GetActiveSchema()) {
    status.append("  Active");
    m_ui->active_button->setEnabled(false);
  }
  else if (KernelWrapper::GetInstance().IsFileWritable (m_filename)) {
    m_ui->active_button->setEnabled(true);
  }
  m_ui->status->setText(status);
}

update_class_list()

void dbse::SchemaFileInfo::update_class_list ( )

private

Definition at line 282 of file SchemaFileInfo.cpp.

                                       {
  m_ui->class_list->clear();
  m_ui->textBrowser->clear();
  auto classes = KernelWrapper::GetInstance().get_schema_classes(m_filename);
  for (auto cls: classes) {
    auto item = new QListWidgetItem(QString::fromStdString(cls->get_name()));
 
    if (!KernelWrapper::GetInstance().IsFileWritable ( m_filename )) {
      item->setForeground(QBrush(SchemaStyle::get_color("foreground", "readonly")));
      item->setBackground(QBrush(SchemaStyle::get_color("background", "readonly")));
    }
    if (!check_relationships(cls)) {
      item->setForeground(QBrush(SchemaStyle::get_color("foreground", "error")));
      item->setBackground(QBrush(SchemaStyle::get_color("background", "error")));
    }
    if (!check_superclasses(cls)) {
      item->setForeground(QBrush(SchemaStyle::get_color("foreground", "error")));
      item->setBackground(QBrush(SchemaStyle::get_color("background", "error")));
    }
 
    m_ui->class_list->addItem(item);
  }
  m_ui->class_summary->setText (
    QString("Total of %1 classes").arg(classes.size()));
 
  // if (!m_missing_includes.empty() && m_missing_button == nullptr) {
  //   m_missing_button = m_ui->buttonBox->addButton("Add missing includes", QDialogButtonBox::ApplyRole);
  //   if (m_missing_button != nullptr) {
  //     connect ( m_missing_button, SIGNAL (pressed()), this, SLOT(add_missing_includes()));
  //   }
  //   else {
  //     std::cout << "Failed to add button\n";
  //   }
  // }
  if (m_missing_includes.empty()) {
    m_ui->missing_button->setEnabled(false);
    m_ui->missing_button->hide();
  }
  else {
    m_ui->missing_button->setEnabled(true);
    m_ui->missing_button->show();
  }
}

Member Data Documentation

m_add_button

QPushButton* dbse::SchemaFileInfo::m_add_button

private

Definition at line 76 of file SchemaFileInfo.hpp.

m_all_includes

std::set<std::string> dbse::SchemaFileInfo::m_all_includes

private

Definition at line 70 of file SchemaFileInfo.hpp.

m_class_menu

QMenu* dbse::SchemaFileInfo::m_class_menu

private

Definition at line 72 of file SchemaFileInfo.hpp.

m_filename

std::string dbse::SchemaFileInfo::m_filename

private

Definition at line 68 of file SchemaFileInfo.hpp.

m_include_menu

QMenu* dbse::SchemaFileInfo::m_include_menu

private

Definition at line 71 of file SchemaFileInfo.hpp.

m_missing_button

QPushButton* dbse::SchemaFileInfo::m_missing_button

private

Definition at line 77 of file SchemaFileInfo.hpp.

m_missing_includes

std::set<std::string> dbse::SchemaFileInfo::m_missing_includes

private

Definition at line 69 of file SchemaFileInfo.hpp.

m_path_list

QStringList dbse::SchemaFileInfo::m_path_list

private

Definition at line 74 of file SchemaFileInfo.hpp.

m_path_urls

QList<QUrl> dbse::SchemaFileInfo::m_path_urls

private

Definition at line 75 of file SchemaFileInfo.hpp.

m_ui

Ui::SchemaFileInfo* dbse::SchemaFileInfo::m_ui

private

Definition at line 67 of file SchemaFileInfo.hpp.

---

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

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