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 23 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 251 of file SchemaFileInfo.cpp.

{
  close();
}

activate_class_context_menu

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

privateslot

Definition at line 464 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 377 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 395 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 555 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 121 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 155 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 322 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 493 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 93 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 263 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 272 of file SchemaFileInfo.cpp.

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

move_class

void dbse::SchemaFileInfo::move_class ( )

privateslot

Definition at line 498 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 414 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 257 of file SchemaFileInfo.cpp.

{
  close();
}

remove_class

void dbse::SchemaFileInfo::remove_class ( )

privateslot

Definition at line 504 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 243 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 187 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 333 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 548 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 524 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 539 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 570 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 575 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 580 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 348 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 278 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