dbe::MainWindow Class Reference

#include <MainWindow.hpp>

Inheritance diagram for dbe::MainWindow:

Collaboration diagram for dbe::MainWindow:

Public Slots
void	slot_batch_change_start ()
void	slot_batch_change_stop (const QList< QPair< QString, QString > > &)
void	slot_information_message (QString const, QString const)
void	slot_warning_message (QString const, QString const)
void	slot_error_message (QString const, QString const)

Signals
void	signal_batch_change_stopped (const QList< QPair< QString, QString > > &)
void	signal_db_loaded ()
void	signal_externalchanges_processed ()
void	signal_new_file_model ()

Public Member Functions
	MainWindow (QMap< QString, QString > const &CommandLine, QWidget *parent=nullptr)
bool	check_ready () const
cptr< dbe::CustomTreeView >	get_view () const
QString	find_db_repository_dir ()
void	build_file_model ()

Static Public Member Functions
static MainWindow *	findthis ()

Private Slots
void	slot_create_newdb ()
void	slot_open_database_from_file ()
void	slot_load_db_from_create_widget (const QString &)
bool	slot_commit_database (bool Exit=false)
void	slot_abort_changes ()
void	slot_abort_external_changes ()
void	slot_launch_object_editor (tref)
void	slot_edit_object_from_class_view (QModelIndex const &)
void	slot_fetch_data (treenode const *)
void	slot_launch_batchchange ()
void	slot_launch_batchchange_on_table ()
void	reload_default_settings ()
void	slot_filter_query ()
void	slot_filter_textchange (const QString &)
void	slot_filter_table_textchange (const QString &)
void	slot_tree_reset ()
void	slot_model_rebuild ()
void	slot_whatisthis ()
void	slot_show_information_about_dbe ()
void	slot_show_userguide ()
void	slot_show_userchanges ()
void	slot_process_externalchanges ()
void	slot_undo_allchanges ()
void	slot_toggle_casesensitive_for_treeview (bool)
void	slot_add_tab ()
void	slot_remove_tab (int i)
void	slot_toggle_commit_button ()
void	slot_update_committed_files (const std::list< std::string > &, const std::string &)
void	slot_loaded_db_file (QString)
void	slot_launch_preferences ()

Private Member Functions
std::vector< dbe::tref >	ProcessQuery (QString const &)
void	closeEvent (QCloseEvent *event)
bool	eventFilter (QObject *Target, QEvent *Event)
bool	check_close ()
void	init ()
void	attach ()
bool	dbopen (QString const &, dbinfo const &)
bool	dbload ()
bool	dbreload ()
void	setinternals ()
void	build_class_tree_model ()
void	build_table_model ()
void	apply_settings (QSettings &setting)
void	WriteSettings ()
void	argsparse (QMap< QString, QString > const &)
void	init_tabs ()
void	edit_object_at (const QModelIndex &Index)
void	update_total_objects ()
void	display_message_box (const QString &title, const QString &msg, const QMessageBox::Icon &icon)
void	load_default_settings ()

Private Attributes
QSet< QString >	allFiles
bool	m_batch_change_in_progress
FileModel *	this_files
QSortFilterProxyModel	this_filesort
dbe::models::tree *	this_classes
models::treeselection *	this_treefilter
std::atomic< bool >	isArchivedConf

Detailed Description

Definition at line 46 of file MainWindow.hpp.

Constructor & Destructor Documentation

MainWindow()

dbe::MainWindow::MainWindow ( QMap< QString, QString > const & CommandLine, QWidget * parent = nullptr )

explicit

Setting up ui

Initial Settings

Setting up application controller

Reading Applications Settings/CommandLine

Definition at line 59 of file MainWindow.cpp.

  : QMainWindow(parent)
  , m_batch_change_in_progress(false)
  , this_files(nullptr)
  , this_filesort(new QSortFilterProxyModel(this))
  , this_classes(nullptr)
  , this_treefilter(nullptr)
  , isArchivedConf(false)
{
  // qRegisterMetaType<RDBMap>("RDBMap");

  setupUi(this);

  init();
  init_tabs();
  // init_rdb_menu();

  attach();

  QCoreApplication::setOrganizationName("dunedaq");
  QCoreApplication::setApplicationName("dbe_main");
  load_default_settings(); // Start with defaults in case no user setting saved
  QSettings settings;      // Then try user settings
  apply_settings(settings);
  argsparse(cmdargs);
 
  if (isArchivedConf == true) {
    OpenDB->setEnabled(false);
    // OpenOracleDB->setEnabled(false);
    // ConnectToRdb->setEnabled(false);
    CreateDatabase->setEnabled(false);
    Commit->setEnabled(false);
 
    QMessageBox::information(this,
                             "DBE",
                             QString("The configuration is opened in archival/detached mode.")
                               .append("\nYou can browse or modify objects, but changes cannot be saved or commited."));
  }
 
  UndoView->show();
}

Member Function Documentation

apply_settings()

void dbe::MainWindow::apply_settings ( QSettings & setting )

private

Definition at line 781 of file MainWindow.cpp.

{
  settings.beginGroup("MainWindow-layout");
  if (settings.contains("size")) {
    resize(settings.value("size").toSize());
  }
  if (settings.contains("pos")) {
    move(settings.value("pos").toPoint());
  }
  if (settings.contains("TableView")) {
    DisplayTableView->setChecked(settings.value("TableView").toBool());
  }
  if (settings.contains("ClassView")) {
    DisplayClassView->setChecked(settings.value("ClassView").toBool());
  }
  if (settings.contains("Messages")) {
    DisplayMessages->setChecked(settings.value("Messages").toBool());
  }
  if (settings.contains("geometry")) {
    restoreGeometry(settings.value("geometry").toByteArray());
  }
  if (settings.contains("state")) {
    restoreState(settings.value("state").toByteArray());
  }
  settings.endGroup();
 
  settings.beginGroup("MainWindow-checkboxes");
  if (settings.contains("tree-case-sensitive")) {
    CaseSensitiveCheckBoxTree->setChecked(settings.value("tree-case-sensitive").toBool());
  }
  if (settings.contains("table-case-sensitive")) {
    CaseSensitiveCheckBoxTable->setChecked(settings.value("table-case-sensitive").toBool());
  }
  settings.endGroup();
 
  StyleUtility::InitColorManagement();
}

argsparse()

void dbe::MainWindow::argsparse ( QMap< QString, QString > const & opts )

private

Definition at line 841 of file MainWindow.cpp.

{
  if (!opts.isEmpty()) {
    dbinfo LoadConfig;
    QString FileToLoad;
 
    QString FileName = opts.value("f");
    QString RdbFileName = opts.value("r");
    QString RoksFileName = opts.value("o");
    QString HashVersion = opts.value("v");
 
    if (!FileName.isEmpty()) {
      FileToLoad = FileName;
      LoadConfig = dbinfo::oks;
 
      if (!HashVersion.isEmpty()) {
        ::setenv("TDAQ_DB_VERSION", QString("hash:").append(HashVersion).toStdString().c_str(), 1);
        ::setenv("OKS_GIT_PROTOCOL", "http", 1);
        isArchivedConf = true;
      }
    } else if (!RdbFileName.isEmpty()) {
      FileToLoad = RdbFileName;
      LoadConfig = dbinfo::rdb;
    } else if (!RoksFileName.isEmpty()) {
      FileToLoad = RoksFileName;
      LoadConfig = dbinfo::roks;
    }
 
    if (not FileToLoad.isEmpty()) {
      dbopen(FileToLoad, LoadConfig);
    }
  }
}

attach()

void dbe::MainWindow::attach ( )

private

Definition at line 185 of file MainWindow.cpp.

{
  connect(OpenDB, SIGNAL(triggered()), this, SLOT(slot_open_database_from_file()));
  connect(Commit, SIGNAL(triggered()), this, SLOT(slot_commit_database()));
  connect(Exit, SIGNAL(triggered()), this, SLOT(close()));
  connect(actionPreferences, SIGNAL(triggered()), this, SLOT(slot_launch_preferences()));
  connect(UndoAction, SIGNAL(triggered()), UndoView->stack(), SLOT(undo()));
  connect(RedoAction, SIGNAL(triggered()), UndoView->stack(), SLOT(redo()));
  connect(UndoAll, SIGNAL(triggered()), this, SLOT(slot_undo_allchanges()));
  connect(BatchChange, SIGNAL(triggered()), this, SLOT(slot_launch_batchchange()));
  connect(BatchChangeTable, SIGNAL(triggered()), this, SLOT(slot_launch_batchchange_on_table()));
 
  connect(DisplayClassView, SIGNAL(triggered(bool)), TreeDockWidget, SLOT(setVisible(bool)));
  connect(DisplayTableView, SIGNAL(triggered(bool)), TableGroupBox, SLOT(setVisible(bool)));
  connect(DisplayMessages, SIGNAL(triggered(bool)), InfoDockWidget, SLOT(setVisible(bool)));
  connect(DisplayToolbar, SIGNAL(triggered(bool)), MainToolBar, SLOT(setVisible(bool)));
 
  connect(TreeDockWidget, SIGNAL(visibilityChanged(bool)), DisplayTableView, SLOT(setChecked(bool)));
  connect(InfoDockWidget, SIGNAL(visibilityChanged(bool)), DisplayMessages, SLOT(setChecked(bool)));
  connect(MainToolBar, SIGNAL(visibilityChanged(bool)), DisplayToolbar, SLOT(setChecked(bool)));
 
  connect(LoadDefaultSettings, SIGNAL(triggered()), this, SLOT(reload_default_settings()));
  connect(CreateDatabase, SIGNAL(triggered()), this, SLOT(slot_create_newdb()));
  // connect ( OpenOracleDB, SIGNAL ( triggered() ), this, SLOT ( slot_oracle_prepare() ) );
 
  connect(WhatThisAction, SIGNAL(triggered()), this, SLOT(slot_whatisthis()));
  connect(UserGuide, SIGNAL(triggered()), this, SLOT(slot_show_userguide()));
  connect(UserChanges, SIGNAL(triggered()), this, SLOT(slot_show_userchanges()));
 
  connect(TreeView, SIGNAL(activated(QModelIndex)), this, SLOT(slot_edit_object_from_class_view(QModelIndex)));
 
  connect(&confaccessor::ref(),
          SIGNAL(db_committed(const std::list<std::string>&, const std::string&)),
          this,
          SLOT(slot_update_committed_files(const std::list<std::string>&, const std::string&)));
 
  connect(confaccessor::gethandler().get(),
          SIGNAL(FetchMoreData(const treenode*)),
          this,
          SLOT(slot_fetch_data(const treenode*)));
 
  connect(&confaccessor::ref(), SIGNAL(object_created(QString, dref)), this, SLOT(slot_toggle_commit_button()));
  connect(&confaccessor::ref(), SIGNAL(object_renamed(QString, dref)), this, SLOT(slot_toggle_commit_button()));
  connect(&confaccessor::ref(), SIGNAL(object_changed(QString, dref)), this, SLOT(slot_toggle_commit_button()));
  connect(&confaccessor::ref(), SIGNAL(object_deleted(QString, dref)), this, SLOT(slot_toggle_commit_button()));
  connect(&confaccessor::ref(),
          SIGNAL(db_committed(const std::list<std::string>&, const std::string&)),
          this,
          SLOT(slot_toggle_commit_button()));
  connect(&confaccessor::ref(), SIGNAL(IncludeFileDone()), this, SLOT(slot_toggle_commit_button()));
  connect(&confaccessor::ref(), SIGNAL(RemoveFileDone()), this, SLOT(slot_toggle_commit_button()));
  connect(&confaccessor::ref(), SIGNAL(ExternalChangesDetected()), this, SLOT(slot_toggle_commit_button()));
  connect(&confaccessor::ref(), SIGNAL(ExternalChangesAccepted()), this, SLOT(slot_toggle_commit_button()));
  connect(this,
          SIGNAL(signal_batch_change_stopped(const QList<QPair<QString, QString>>&)),
          this,
          SLOT(slot_toggle_commit_button()));
 
  connect(&confaccessor::ref(), SIGNAL(IncludeFileDone()), this, SLOT(slot_model_rebuild()));
  connect(&confaccessor::ref(), SIGNAL(RemoveFileDone()), this, SLOT(slot_model_rebuild()));
  connect(&confaccessor::ref(), SIGNAL(ExternalChangesAccepted()), this, SLOT(slot_process_externalchanges()));
 
  connect(SearchBox, SIGNAL(currentIndexChanged(int)), this, SLOT(slot_filter_query()));
  connect(SearchTreeLine, SIGNAL(textChanged(const QString&)), this, SLOT(slot_filter_textchange(const QString&)));
  connect(SearchTreeLine, SIGNAL(textEdited(const QString&)), this, SLOT(slot_filter_query()));
  connect(SearchTreeLine, SIGNAL(returnPressed()), this, SLOT(slot_filter_query()));
  connect(
    SearchLineTable, SIGNAL(textChanged(const QString&)), this, SLOT(slot_filter_table_textchange(const QString&)));
  connect(CaseSensitiveCheckBoxTree, SIGNAL(clicked(bool)), this, SLOT(slot_toggle_casesensitive_for_treeview(bool)));
  // connect ( ConnectToRdb, SIGNAL ( triggered ( QAction * ) ), this,
  //         SLOT ( slot_rdb_selected ( QAction * ) ) );
 
  connect(information_about_dbe, SIGNAL(triggered()), this, SLOT(slot_show_information_about_dbe()));
 
  // Connect to signals from the messenger system
 
  connect(&dbe::interface::messenger_proxy::ref(),
          SIGNAL(signal_debug(QString const, QString const)),
          this,
          SLOT(slot_information_message(QString, QString)),
          Qt::QueuedConnection);
 
  connect(&dbe::interface::messenger_proxy::ref(),
          SIGNAL(signal_info(QString const, QString const)),
          this,
          SLOT(slot_information_message(QString, QString)),
          Qt::QueuedConnection);
 
  connect(&dbe::interface::messenger_proxy::ref(),
          SIGNAL(signal_note(QString const, QString const)),
          this,
          SLOT(slot_information_message(QString, QString)),
          Qt::QueuedConnection);
 
  connect(&dbe::interface::messenger_proxy::ref(),
          SIGNAL(signal_warn(QString const, QString const)),
          this,
          SLOT(slot_warning_message(QString, QString)),
          Qt::QueuedConnection);
 
  connect(&dbe::interface::messenger_proxy::ref(),
          SIGNAL(signal_error(QString const, QString const)),
          this,
          SLOT(slot_error_message(QString, QString)),
          Qt::QueuedConnection);
 
  connect(&dbe::interface::messenger_proxy::ref(),
          SIGNAL(signal_fail(QString const, QString const)),
          this,
          SLOT(slot_error_message(QString, QString)),
          Qt::QueuedConnection);
 
  // connect ( this, SIGNAL ( signal_rdb_found(const QString&, const RDBMap& ) ),
  //           this, SLOT ( slot_rdb_found(const QString&, const RDBMap&) ), Qt::AutoConnection );
}

build_class_tree_model()

void dbe::MainWindow::build_class_tree_model ( )

private

Creating new Main Model

Resetting attached models

Definition at line 302 of file MainWindow.cpp.

{
  QStringList Headers{ "Class Name", "# Objects" };
 
  if (this_classes != nullptr) {
    delete this_classes;
    delete this_treefilter;
  }
  this_classes = new dbe::models::tree(Headers);
  this_treefilter = new models::treeselection();
  this_treefilter->setFilterRegExp("");
 
  connect(this_classes, SIGNAL(ObjectFile(QString)), this, SLOT(slot_loaded_db_file(QString)));
 
  this_treefilter->setDynamicSortFilter(true);
  this_treefilter->setSourceModel(this_classes);
  slot_toggle_casesensitive_for_treeview(true);
  TreeView->setModel(this_treefilter);
  TreeView->setSortingEnabled(true);
  TreeView->resizeColumnToContents(0);
  TreeView->resizeColumnToContents(1);
 
  connect(HideCheckBox, SIGNAL(toggled(bool)), this_treefilter, SLOT(ToggleEmptyClasses(bool)));
 
  connect(ShowDerivedObjects, SIGNAL(toggled(bool)), this_classes, SLOT(ToggleAbstractClassesSelectable(bool)));
 
  update_total_objects();
}

build_file_model()

void dbe::MainWindow::build_file_model

(

)

Changed -> Now accepting rdbconfig this means || !ConfigWrapper::GetInstance().GetDatabaseImplementation().contains("rdbconfig") was removed

Definition at line 399 of file MainWindow.cpp.

{
 
  if (!confaccessor::db_implementation_name().contains("roksconflibs")) {
    if (this_files != nullptr) {
      delete this_files;
    }
    this_files = new FileModel();
 
    this_filesort.setSourceModel(this_files);
    FileView->setModel(&this_filesort);
 
    FileView->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
    FileView->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
    FileView->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
    FileView->horizontalHeader()->setSectionResizeMode(3, QHeaderView::ResizeToContents);
 
    emit signal_new_file_model();
  }
}

build_table_model()

void dbe::MainWindow::build_table_model ( )

private

Displaying table widgets

Definition at line 334 of file MainWindow.cpp.

{
  SearchLineTable->clear();
  SearchLineTable->show();
  SearchLineTable->setProperty("placeholderText", QVariant(QString("Table Filter")));
  CaseSensitiveCheckBoxTable->show();
}

check_close()

bool dbe::MainWindow::check_close ( )

private

Definition at line 1299 of file MainWindow.cpp.

{
  bool OK = true;
 
  foreach (QWidget* widget, QApplication::allWidgets()) {
    ObjectCreator* ObjectCreatorInstance = dynamic_cast<ObjectCreator*>(widget);
    ObjectEditor* ObjectEditorInstance = dynamic_cast<ObjectEditor*>(widget);
 
    if (ObjectEditorInstance) {
      OK = ObjectEditorInstance->CanCloseWindow();
    }
 
    if (!OK) {
      return false;
    }
 
    if (ObjectCreatorInstance) {
      OK = ObjectCreatorInstance->CanClose();
    }
 
    if (!OK) {
      return false;
    }
  }
 
  {
    cptr<QUndoStack> undo_stack(confaccessor::get_commands());
 
    if (undo_stack->isClean()) {
      if (undo_stack->count() == 0) {
        return true;
      } else {
        slot_abort_changes();
        return true;
      }
    } else {
      int ret =
        QMessageBox::question(0,
                              tr("DBE"),
                              QString("There are unsaved changes.\n\nDo you want to save and commit them to the DB?\n"),
                              QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel,
                              QMessageBox::Save);
 
      if (ret == QMessageBox::Discard) {
        slot_abort_changes();
        return true;
      } else if (ret == QMessageBox::Save) {
        return slot_commit_database(true);
      } else if (ret == QMessageBox::Cancel) {
        return false;
      } else {
        return true;
      }
    }
  }
}

check_ready()

bool dbe::MainWindow::check_ready ( ) const

nodiscard

Definition at line 1738 of file MainWindow.cpp.

{
  return not m_batch_change_in_progress;
}

closeEvent()

void dbe::MainWindow::closeEvent ( QCloseEvent * event )

private

Definition at line 1246 of file MainWindow.cpp.

{
  if (isArchivedConf || check_close()) {
    WriteSettings();
 
    foreach (QWidget* widget, QApplication::allWidgets())
      widget->close();
 
    event->accept();
  } else {
    event->ignore();
  }
}

dbload()

bool dbe::MainWindow::dbload ( )

private

Definition at line 707 of file MainWindow.cpp.

{
  // For issues related to loading the configuration in a separate thread, see ATLASDBE-229
 
  const bool alreadyLoaded = confaccessor::is_database_loaded();
 
  // The QueuedConnection is mandatory to let the loop receive the signal even if
  // it is emitted before "exec" is called
  QEventLoop loop;
  connect(this, SIGNAL(signal_db_loaded()), &loop, SLOT(quit()), Qt::QueuedConnection);
 
  // Make life of the progress dialog longer
  // Show only the first time, when the configuration is not loaded
  // In other cases, just show a busy cursor
  std::unique_ptr<QProgressDialog> progress_bar;
  if (!alreadyLoaded) {
    progress_bar.reset(new QProgressDialog("Loading Configuration...", QString(), 0, 0, this));
    progress_bar->setWindowModality(Qt::WindowModal);
    progress_bar->show();
  }
 
  BOOST_SCOPE_EXIT(void)
  {
    QApplication::restoreOverrideCursor();
  }
  BOOST_SCOPE_EXIT_END
 
  QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 
  // Close widgets
  for (QWidget* widget : QApplication::allWidgets()) {
    if (dynamic_cast<ObjectEditor*>(widget)) {
      widget->close();
    } else if (dynamic_cast<widgets::editors::base*>(widget)) {
      widget->close();
    }
  }
 
  // Asynchronous execution only the first time the configuration is loaded
  std::future<bool> waiter = std::async(alreadyLoaded ? std::launch::deferred : std::launch::async, [this] {
    const bool result = confaccessor::load(!isArchivedConf);
    emit signal_db_loaded(); // "loop.exec()" will return now
    return result;
  });
 
  // Do not call "exec" if the previous call is not asynchronous
  if (!alreadyLoaded) {
    loop.exec(QEventLoop::ExcludeUserInputEvents);
  }
 
  // If "deferred", the async call is executed now and here
  return waiter.get();
}

dbopen()

bool dbe::MainWindow::dbopen ( QString const & dbpath, dbinfo const & loadtype )

private

Takes necessary actions to load a database from a file provided

Parameters

dbpath

is the path (absolute or relative to the DUNEDAQ_DB_PATH) of the associated file

Returns

Definition at line 1368 of file MainWindow.cpp.

{
  if (dbreload()) {
    confaccessor::setdbinfo(dbpath, loadtype);
 
    BOOST_SCOPE_EXIT(void)
    {
      QApplication::restoreOverrideCursor();
    }
    BOOST_SCOPE_EXIT_END
 
    QApplication::setOverrideCursor(Qt::WaitCursor);
 
    if (dbload()) {
      setinternals();
      build_class_tree_model();
      // build_partition_tree_model();
      // build_resource_tree_model();
      build_file_model();
    }
  }
 
  return true;
}

dbreload()

bool dbe::MainWindow::dbreload ( )

private

Definition at line 681 of file MainWindow.cpp.

{
  if (confaccessor::is_database_loaded()) {
    QMessageBox MessageBox;
    MessageBox.setText("Do you really wish to abandon the current database and load a new one ?");
    MessageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
    MessageBox.setDefaultButton(QMessageBox::Cancel);
    int UserOption = MessageBox.exec();
 
    switch (UserOption) {
 
      case QMessageBox::Yes:
        return true;
 
      case QMessageBox::Cancel:
        return false;
 
      default:
        return false;
    }
  } else {
    return true;
  }
}

display_message_box()

void dbe::MainWindow::display_message_box ( const QString & title, const QString & msg, const QMessageBox::Icon & icon )

private

Definition at line 1591 of file MainWindow.cpp.

{
  QMessageBox mb(this);
  mb.setIcon(icon);
  mb.setWindowTitle(title);
  mb.setStandardButtons(QMessageBox::Ok);
  if (msg.length() > MAX_MESSAGE_LENGTH) {
    QString&& truncated_msg = msg.left(MAX_MESSAGE_LENGTH);
    truncated_msg.append("...");
    mb.setText(
      "<b>The message has been truncated because it is too long, look at the details for the full message</b>");
    mb.setInformativeText(truncated_msg);
    mb.setDetailedText(msg);
  } else {
    mb.setText(msg);
  }
 
  mb.exec();
}

edit_object_at()

void dbe::MainWindow::edit_object_at ( const QModelIndex & Index )

private

Definition at line 344 of file MainWindow.cpp.

{
  treenode* tree_node = this_classes->getnode(Index);
 
  /*
   * If an object node is linked to this index then launch the object editor
   * else build a table for the class , showing all objects
   */
 
  if (dynamic_cast<ObjectNode*>(tree_node)) {
    ObjectNode* NodeObject = dynamic_cast<ObjectNode*>(tree_node);
    tref ObjectToBeEdited = NodeObject->GetObject();
    slot_launch_object_editor(ObjectToBeEdited);
  } else {
    // Class node
    QString const cname = tree_node->GetData(0).toString();
    dunedaq::conffwk::class_t cinfo = dbe::config::api::info::onclass::definition(cname.toStdString(), false);
 
    if (not cinfo.p_abstract or ShowDerivedObjects->isChecked()) {
      if (TableTab* CurrentTab = dynamic_cast<TableTab*>(tableholder->currentWidget())) {
        CurrentTab->CreateModels();
        dbe::models::table* CurrentTabModel = CurrentTab->GetTableModel();
        CustomDelegate* CurrentDelegate = CurrentTab->GetTableDelegate();
        CustomTableView* CurrentView = CurrentTab->GetTableView();
 
        connect(
          CurrentView, SIGNAL(OpenEditor(tref)), this, SLOT(slot_launch_object_editor(tref)), Qt::UniqueConnection);
        connect(CurrentDelegate,
                SIGNAL(CreateObjectEditorSignal(tref)),
                this,
                SLOT(slot_launch_object_editor(tref)),
                Qt::UniqueConnection);
 
        if (dynamic_cast<ClassNode*>(tree_node)) {
          BOOST_SCOPE_EXIT(CurrentTabModel)
          {
            emit CurrentTabModel->layoutChanged();
          }
          BOOST_SCOPE_EXIT_END
 
          emit CurrentTabModel->layoutAboutToBeChanged();
 
          CurrentTabModel->BuildTableFromClass(cname, ShowDerivedObjects->isChecked());
          build_table_model();
          tableholder->setTabText(tableholder->currentIndex(), cname);
          CurrentTab->ResetTableView();
        }
 
        CurrentTab->ResizeHeaders();
      }
    }
  }
}

eventFilter()

bool dbe::MainWindow::eventFilter ( QObject * Target, QEvent * Event )

private

Definition at line 1286 of file MainWindow.cpp.

{
  if (Target == SearchBox->lineEdit() && Event->type() == QEvent::MouseButtonRelease) {
    if (!SearchBox->lineEdit()->hasSelectedText()) {
      SearchBox->lineEdit()->selectAll();
      return true;
    }
  }
 
  return false;
}

find_db_repository_dir()

QString dbe::MainWindow::find_db_repository_dir ( )

nodiscard

Definition at line 619 of file MainWindow.cpp.

{
  if (confaccessor::dbfullname().isEmpty()) {
    return "";
  }
 
  const QStringList& incs = dbe::config::api::get::file::inclusions({ confaccessor::dbfullname() });
  for (QString f : allFiles) {
    for (const QString& j : incs) {
      if (f.endsWith(j)) {
        return f.remove(j);
      }
    }
  }
 
  return "";
}

findthis()

dbe::MainWindow * dbe::MainWindow::findthis ( )

static

Permits to retrieve the main window pointer throughout the application

Returns

a pointer of type MainWindow to the first class of type MainWindow

Definition at line 1562 of file MainWindow.cpp.

{
  QWidgetList allwidgets = QApplication::topLevelWidgets();
 
  QWidgetList::iterator it = allwidgets.begin();
  MainWindow* main_win = qobject_cast<MainWindow*>(*it);
 
  for (; it != allwidgets.end() and main_win == nullptr; ++it) {
    main_win = qobject_cast<MainWindow*>(*it);
  }
 
  return main_win;
}

get_view()

cptr< dbe::CustomTreeView > dbe::MainWindow::get_view ( ) const

nodiscard

Definition at line 1653 of file MainWindow.cpp.

{
  return cptr<CustomTreeView>(TreeView);
}

init()

void dbe::MainWindow::init ( )

private

Window Settings

Table Settings

Menus Settings

Commands Settings

Search Box Settings

What is this

Definition at line 144 of file MainWindow.cpp.

{
  setWindowTitle("DUNE DAQ Configuration Database Editor (DBE)");
  UndoView->setStack(confaccessor::get_commands().get());
  SearchLineTable->hide();
  SearchLineTable->setClearButtonEnabled(true);
  SearchTreeLine->setClearButtonEnabled(true);
  CaseSensitiveCheckBoxTable->hide();
  tableholder->removeTab(1);

  HelpMenu->setEnabled(false); // Until help is updated to be useful!!!

  Commit->setEnabled(false);
  UndoAction->setEnabled(true);
  RedoAction->setEnabled(true);

  SearchBox->setFocusPolicy(Qt::ClickFocus);

  TreeView->setWhatsThis("This view shows the classes and objects of the database");
  FileView->setWhatsThis("This view shows the file structure of the database");
  UndoView->setWhatsThis("This view shows the commands in the Undo Command stack");
 
  CommittedTable->setHorizontalHeaderLabels(QStringList() << "File" << "Comment" << "Date");
  CommittedTable->setAlternatingRowColors(true);
  CommittedTable->horizontalHeader()->setSectionResizeMode(QHeaderView::Interactive);
  CommittedTable->horizontalHeader()->setDefaultSectionSize(250);
  CommittedTable->setWordWrap(true);
  CommittedTable->setTextElideMode(Qt::ElideRight);
  CommittedTable->setItemDelegate(new DummyEditorDelegate());
 
  // Make Files the current tab
  InfoWidget->setCurrentIndex(0);
}

init_tabs()

void dbe::MainWindow::init_tabs ( )

private

Definition at line 106 of file MainWindow.cpp.

{
  tableholder->addTab(new TableTab(tableholder), "Table View");
  tableholder->removeTab(0);
 
  QPushButton* addtab_button = new QPushButton("+");
  tableholder->setCornerWidget(addtab_button, Qt::TopLeftCorner);
  connect(addtab_button, SIGNAL(clicked()), this, SLOT(slot_add_tab()));
 
  tableholder->setTabsClosable(true);
  connect(tableholder, SIGNAL(tabCloseRequested(int)), this, SLOT(slot_remove_tab(int)));
}

load_default_settings()

void dbe::MainWindow::load_default_settings ( )

private

Definition at line 612 of file MainWindow.cpp.

{
  QSettings defaults(":theme/DBE_Default_User_Settings.conf", QSettings::NativeFormat);
  apply_settings(defaults);
}

ProcessQuery()

std::vector< dbe::tref > dbe::MainWindow::ProcessQuery ( QString const & Tmp )

private

Definition at line 1261 of file MainWindow.cpp.

{
  if (not Tmp.isEmpty()) {
    QString const Query = QString("(this (object-id \".*%1.*\" ~=))").arg(Tmp);
 
    try {
      std::vector<dbe::tref> result;
 
      for (std::string const& cname : dbe::config::api::info::onclass::allnames<std::vector<std::string>>()) {
        std::vector<dbe::tref> class_matching_objects = inner::dbcontroller::gets(cname, Query.toStdString());
 
        result.insert(result.end(), class_matching_objects.begin(), class_matching_objects.end());
      }
 
      return result;
    } catch (dunedaq::conffwk::Exception const& ex) {
      ers::error(ex);
      ERROR("Query process error", dbe::config::errors::parse(ex).c_str());
    }
  }
 
  return {};
}

reload_default_settings

void dbe::MainWindow::reload_default_settings ( )

privateslot

Definition at line 605 of file MainWindow.cpp.

{
  QSettings settings;
  settings.clear();
  load_default_settings();
}

setinternals()

void dbe::MainWindow::setinternals ( )

private

Disconnecting models from views

Definition at line 762 of file MainWindow.cpp.

{
  confaccessor::clear_commands();
  confaccessor::gethandler()->ResetData();
  confaccessor::set_total_objects(0);

 
  for (int i = 0; i < tableholder->count(); i++) {
    TableTab* CurrentTab = dynamic_cast<TableTab*>(tableholder->widget(i));
    if (CurrentTab) {
      CurrentTab->DisconnectView();
    }
  }
 
  FileView->setModel(NULL);
}

signal_batch_change_stopped

void dbe::MainWindow::signal_batch_change_stopped ( const QList< QPair< QString, QString > > & )

signal

signal_db_loaded

void dbe::MainWindow::signal_db_loaded ( )

signal

signal_externalchanges_processed

void dbe::MainWindow::signal_externalchanges_processed ( )

signal

signal_new_file_model

void dbe::MainWindow::signal_new_file_model ( )

signal

slot_abort_changes

void dbe::MainWindow::slot_abort_changes ( )

privateslot

Definition at line 498 of file MainWindow.cpp.

{
  try {
    if (confaccessor::is_database_loaded()) {
      confaccessor::abort();
      confaccessor::clear_commands();
    }
  } catch (dunedaq::conffwk::Exception const& e) {
    ERROR("Database changes aborted", dbe::config::errors::parse(e).c_str());
    ers::error(e);
  }
}

slot_abort_external_changes

void dbe::MainWindow::slot_abort_external_changes ( )

privateslot

Definition at line 512 of file MainWindow.cpp.

{
  try {
    if (confaccessor::is_database_loaded()) {
      confaccessor::abort();
    }
  } catch (dunedaq::conffwk::Exception const& e) {
    ERROR("External changes aborted", dbe::config::errors::parse(e).c_str());
    ers::error(e);
  }
}

slot_add_tab

void dbe::MainWindow::slot_add_tab ( )

privateslot

Definition at line 120 of file MainWindow.cpp.

{
  tableholder->addTab(new TableTab(tableholder), "Table View");
  tableholder->setCurrentIndex(tableholder->count() - 1);
  tableholder->show();
}

slot_batch_change_start

void dbe::MainWindow::slot_batch_change_start ( )

slot

Definition at line 1659 of file MainWindow.cpp.

{
  m_batch_change_in_progress = true;
}

slot_batch_change_stop

void dbe::MainWindow::slot_batch_change_stop ( const QList< QPair< QString, QString > > & objs )

slot

Definition at line 1665 of file MainWindow.cpp.

{
  std::vector<dbe::dref> objects;
  for (const auto& o : objs) {
    objects.push_back(inner::dbcontroller::get({ o.second.toStdString(), o.first.toStdString() }));
  }
 
  // This allows to not reset the main tree
  this_classes->objectsUpdated(objects);
 
  // In this case the corresponding trees are reset
  // In order to apply the same policy as in the class tree
  // the subtree_proxy class needs to be completed with proper
  // implementation of slots when objects are modified
 
  // Proper "refresh" of table tabs
  for (int i = 0; i < tableholder->count(); i++) {
    TableTab* CurrentTab = dynamic_cast<TableTab*>(tableholder->widget(i));
    if (CurrentTab) {
      dbe::models::table* m = CurrentTab->GetTableModel();
      if (m) {
        m->objectsUpdated(objects);
      }
    }
  }
 
  emit signal_batch_change_stopped(objs);
 
  m_batch_change_in_progress = false;
}

slot_commit_database

bool dbe::MainWindow::slot_commit_database ( bool Exit = false )

privateslot

Definition at line 431 of file MainWindow.cpp.

{
  CommitDialog* SaveDialog = new CommitDialog();
  int DialogResult = SaveDialog->exec();
 
  if (DialogResult) {
    FileInfo::parse_all_objects();
    for (auto file : dbe::confaccessor::uncommitted_files()) {
      auto message = FileInfo::check_file_includes(QString::fromStdString(file));
      if (!message.isEmpty()) {
        QMessageBox::warning(0, "Save database", message);
        FileInfo::show_file_info(QString::fromStdString(file));
        return false;
      }
    }
 
    QString CommitMessage = SaveDialog->GetCommitMessage();
 
    try {
      std::list<std::string> const& modified = confaccessor::save(CommitMessage);
      confaccessor::clear_commands();
 
      build_file_model();
 
      if (not modified.empty()) {
        std::string msg;
 
        for (std::string const& f : modified) {
          msg += "\n" + f;
        }
 
        INFO("List of modified files committed to the database ", "Program execution success", msg);
      } else {
        WARN("Changes where committed successfully but list of modified files could not be retrieved",
             "Unexpected program execution");
      }
 
    } catch (dunedaq::conffwk::Exception const& e) {
      WARN("The changes could not be committed", dbe::config::errors::parse(e).c_str())
      ers::error(e);
      return false;
    }
    // Gaahhh confaccessor catches dunedaq::conffwk::Exception and
    // rethrows it as daq::dbe::CouldNotCommitChanges!!
    catch (daq::dbe::CouldNotCommitChanges const& exc) {
      std::string reason{ exc.what() };
      auto cause = exc.cause();
      while (cause != nullptr) {
        reason = cause->what();
        cause = cause->cause();
      }
      WARN("The changes could not be committed",
           // dbe::config::errors::parse(exc).c_str(),
           reason,
           "\n\nTry fixing includes from File Info window")
      ers::error(exc);
      return false;
    }
  } else {
    if (Exit) {
      slot_abort_changes();
    }
  }
  return true;
}

slot_create_newdb

void dbe::MainWindow::slot_create_newdb ( )

privateslot

Definition at line 638 of file MainWindow.cpp.

{
 
  CreateDatabaseWidget* CreateDatabaseW = new CreateDatabaseWidget(nullptr, false, find_db_repository_dir());
  CreateDatabaseW->show();
  connect(CreateDatabaseW,
          SIGNAL(CanLoadDatabase(const QString&)),
          this,
          SLOT(slot_load_db_from_create_widget(const QString&)));
}

slot_edit_object_from_class_view

void dbe::MainWindow::slot_edit_object_from_class_view ( QModelIndex const & ProxyIndex )

privateslot

Definition at line 1357 of file MainWindow.cpp.

{
  edit_object_at(this_treefilter->mapToSource(ProxyIndex));
}

slot_error_message

void dbe::MainWindow::slot_error_message ( QString const title, QString const msg )

slot

This method permits to propagate and display messages from the messaging subsytem.

It is important that the arguments are pass-by-copy because references will become invalid, even if they are bound to consted temporaries, once the deleter from the other thread is called.

Definition at line 1632 of file MainWindow.cpp.

{
  display_message_box(title, msg, QMessageBox::Icon::Critical);
}

slot_fetch_data

void dbe::MainWindow::slot_fetch_data ( treenode const * ClassNode )

privateslot

Definition at line 423 of file MainWindow.cpp.

{
  if (this_classes->canFetchMore(this_classes->index(ClassNode->GetRow(), 0, QModelIndex()))) {
    this_classes->fetchMore(this_classes->index(ClassNode->GetRow(), 0, QModelIndex()));
  }
}

slot_filter_query

void dbe::MainWindow::slot_filter_query ( )

privateslot

Definition at line 1146 of file MainWindow.cpp.

{
  if (this_treefilter == nullptr) {
    return;
  }
 
  QString Tmp = SearchTreeLine->text();
  if (SearchBox->currentIndex() == 1) {
    this_treefilter->SetFilterType(models::treeselection::ObjectFilterType);
    std::vector<dbe::tref> Objects = ProcessQuery(Tmp);
 
    this_treefilter->SetQueryObjects(Objects);
    this_treefilter->setFilterRegExp(Tmp);
    update_total_objects();
  } else {
    this_treefilter->ResetQueryObjects();
    slot_filter_textchange(Tmp);
  }
}

slot_filter_table_textchange

void dbe::MainWindow::slot_filter_table_textchange ( const QString & FilterText )

privateslot

Definition at line 1167 of file MainWindow.cpp.

{
  TableTab* CurrentTab = dynamic_cast<TableTab*>(tableholder->currentWidget());
 
  if (CurrentTab) {
    dbe::models::tableselection* TableFilter = CurrentTab->GetTableFilter();
 
    if (TableFilter == nullptr) {
      return;
    }
 
    TableFilter->SetFilterType(dbe::models::tableselection::RegExpFilter);
 
    if (CaseSensitiveCheckBoxTable->isChecked())
      TableFilter->setFilterCaseSensitivity(Qt::CaseSensitive);
    else {
      TableFilter->setFilterCaseSensitivity(Qt::CaseInsensitive);
    }
 
    TableFilter->setFilterRegExp(FilterText);
  }
}

slot_filter_textchange

void dbe::MainWindow::slot_filter_textchange ( const QString & FilterText )

privateslot

Definition at line 1128 of file MainWindow.cpp.

{
  if (this_treefilter != nullptr and SearchBox->currentIndex() != 1) {
    this_treefilter->SetFilterType(models::treeselection::RegExpFilterType);
 
    if (SearchBox->currentIndex() == 2) {
      this_treefilter->SetFilterRestrictionLevel(1000);
    } else {
      this_treefilter->SetFilterRestrictionLevel(1);
    }
 
    this_treefilter->setFilterRegExp(FilterText);
  }
 
  update_total_objects();
}

slot_information_message

void dbe::MainWindow::slot_information_message ( QString const title, QString const msg )

slot

This method permits to propagate and display messages from the messaging subsytem.

It is important that the arguments are pass-by-copy because references will become invalid, even if they are bound to consted temporaries, once the deleter from the other thread is called.

Definition at line 1619 of file MainWindow.cpp.

{
  display_message_box(title, msg, QMessageBox::Icon::Information);
}

slot_launch_batchchange

void dbe::MainWindow::slot_launch_batchchange ( )

privateslot

Definition at line 548 of file MainWindow.cpp.

{
  if (confaccessor::is_database_loaded()) {
    BatchChangeWidget* Batch = new BatchChangeWidget(nullptr);
    Batch->setWindowModality(Qt::WindowModal);
    Batch->show();
  } else {
    ERROR("Database must have been loaded", "No database loaded");
  }
}

slot_launch_batchchange_on_table

void dbe::MainWindow::slot_launch_batchchange_on_table ( )

privateslot

Definition at line 560 of file MainWindow.cpp.

{
  if (!confaccessor::is_database_loaded()) {
    ERROR("Database must have been loaded", "No database loaded");
    return;
  }
 
  dbe::models::table* CurrentTableModel = nullptr;
  TableTab* CurrentTab = dynamic_cast<TableTab*>(tableholder->currentWidget());
  if (CurrentTab) {
    CurrentTableModel = CurrentTab->GetTableModel();
  }
 
  std::vector<dref> TableObject;
 
  if (!CurrentTab || !CurrentTableModel) {
    ERROR("Table cannot be processed", "Table is empty");
    return;
  }
 
  if ((*CurrentTableModel->GetTableObjects()).isEmpty()) {
    ERROR("Table cannot be processed", "Table is empty");
    return;
  }
 
  QString Filter = SearchLineTable->text();
 
  for (dref Object : *CurrentTableModel->GetTableObjects()) {
    if (Filter.isEmpty()) {
      TableObject.push_back(Object);
    } else {
      QString ObjectString = QString::fromStdString(Object.UID());
 
      if (ObjectString.contains(Filter, Qt::CaseInsensitive)) {
        TableObject.push_back(Object);
      }
    }
  }
 
  BatchChangeWidget* Batch = new BatchChangeWidget(true, CurrentTableModel->get_class_name(), TableObject, nullptr);
  Batch->setWindowModality(Qt::WindowModal);
  Batch->show();
}

slot_launch_object_editor

void dbe::MainWindow::slot_launch_object_editor ( tref Object )

privateslot

Definition at line 525 of file MainWindow.cpp.

{
  bool WidgetFound = false;
  QString ObjectEditorName = QString("%1@%2").arg(Object.UID().c_str()).arg(Object.class_name().c_str());
 
  for (QWidget* Editor : QApplication::allWidgets()) {
    ObjectEditor* Widget = dynamic_cast<ObjectEditor*>(Editor);
 
    if (Widget != nullptr) {
      if ((Widget->objectName()).compare(ObjectEditorName) == 0) {
        Widget->raise();
        Widget->setVisible(true);
        WidgetFound = true;
      }
    }
  }
 
  if (!WidgetFound) {
    (new ObjectEditor(Object))->show();
  }
}

slot_launch_preferences

void dbe::MainWindow::slot_launch_preferences ( )

privateslot

Definition at line 1750 of file MainWindow.cpp.

{
  auto prefs = new Preferences();
  prefs->show();
}

slot_load_db_from_create_widget

void dbe::MainWindow::slot_load_db_from_create_widget ( const QString & DatabaseName )

privateslot

Definition at line 650 of file MainWindow.cpp.

{
  if (!DatabaseName.isEmpty()) {
    QFileInfo DatabaseFile = QFileInfo(DatabaseName);
 
    if (DatabaseFile.exists()) {
      QString Path = QString(DatabaseFile.absoluteFilePath());
 
      if (dbreload()) {
        confaccessor::setdbinfo(Path);
 
        if (dbload()) {
          setinternals();
          build_class_tree_model();
          // // build_partition_tree_model();
          // build_resource_tree_model();
          build_file_model();
        }
      }
    } else {
      WARN("File not found during database load",
           "File does not exist",
           "\n\n Filename:",
           DatabaseFile.fileName().toStdString());
    }
  } else {
    ERROR("Database load error", "File was not selected");
  }
}

slot_loaded_db_file

void dbe::MainWindow::slot_loaded_db_file ( QString file )

privateslot

Definition at line 1744 of file MainWindow.cpp.

{
  allFiles.insert(file);
}

slot_model_rebuild

void dbe::MainWindow::slot_model_rebuild ( )

privateslot

Preparing data

Disconnecting models from views

Definition at line 1107 of file MainWindow.cpp.

{
  confaccessor::gethandler()->ResetData();
  confaccessor::set_total_objects(0);
 
  for (int i = 0; i < tableholder->count(); i++) {
    TableTab* CurrentTab = dynamic_cast<TableTab*>(tableholder->widget(i));
    if (CurrentTab) {
      CurrentTab->DisconnectView();
    }
  }
 
  FileView->setModel(NULL);
 
  build_class_tree_model();
  build_file_model();
}

slot_open_database_from_file

void dbe::MainWindow::slot_open_database_from_file ( )

privateslot

Definition at line 1394 of file MainWindow.cpp.

{
  QFileDialog FileDialog(this, tr("Open File"), ".", tr("XML files (*.xml)"));
  FileDialog.setAcceptMode(QFileDialog::AcceptOpen);
  FileDialog.setFileMode(QFileDialog::ExistingFile);
  FileDialog.setViewMode(QFileDialog::Detail);
 
  if (FileDialog.exec()) {
    QStringList FilesSelected = FileDialog.selectedFiles();
 
    if (FilesSelected.size()) {
      QString DatabasePath = FilesSelected.value(0);
      dbopen(DatabasePath, dbinfo::oks);
    }
  }
}

slot_process_externalchanges

void dbe::MainWindow::slot_process_externalchanges ( )

privateslot

The purpose of this method is to replay local changes after the database has been externally modified.

It is called when there is a callback from config layer.

The user is being given the option to ignore the external change and proceed without bringing his current database to a consistent state. This will cause the database to be overwritten when local changes are going to be applied.

"Emptying" the command so it does nothing at all

Definition at line 1422 of file MainWindow.cpp.

{
  auto user_confirmation = [](QString const& msg) {
    QMessageBox ExternalMessageBox;
    ExternalMessageBox.setText(msg);
    ExternalMessageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
    ExternalMessageBox.setDefaultButton(QMessageBox::Yes);
    return ExternalMessageBox.exec() == QMessageBox::Yes;
  };
 
  confaccessor::t_undo_stack_cptr undo_stack = confaccessor::get_commands();
 
  auto rewind_stack = [&undo_stack]() {
    std::vector<bool> commands_original_undo_state;
 
    // Loop over the commands and set their undo-state to false such that when the undostack
    // index is rewind to zero they will not be undone. The purpose is to replay them on top of
    // current changes.
 
    for (int i = 0; i < undo_stack->count(); ++i) {
      if (dbe::actions::onobject const* Command = dynamic_cast<dbe::actions::onobject const*>(undo_stack->command(i))) {
        commands_original_undo_state.push_back(Command->undoable());
        Command->setundoable(false);
      }
    }
 
    // Rewind the command stack by setting the index to zero
    // Commands will not be replayed since we have set their state to false
    undo_stack->setIndex(0);
 
    // Reset the state of all commands one by one
    {
      auto cmdstate = commands_original_undo_state.begin();
 
      for (int i = 0; i != undo_stack->count(); ++i) {
        if (dbe::actions::onobject const* Command =
              dynamic_cast<dbe::actions::onobject const*>(undo_stack->command(i))) {
          Command->setundoable(*cmdstate++);
        }
      }
    }
  };
 
  // Close active editor widgets before replaying changes
  for (QWidget* widget : QApplication::allWidgets()) {
    if (dynamic_cast<widgets::editors::relation*>(widget)) {
      widget->close();
    }
  }
 
  if (undo_stack->count() != 0) {
    const QString msg =
      QString("External changes to the database have been applied. Do you want to replay your changes on top? ") +
      QString(" Otherwise any local change will be lost.\n");
    if (user_confirmation(msg)) {
      rewind_stack();
 
      // Empty the internal stack and place the changes in a reverse order in a local stack
      confaccessor::t_internal_changes_stack internal_changes_reverse_copy;
      auto internal_changes = confaccessor::get_internal_change_stack();
 
      while (not internal_changes->empty()) {
        internal_changes_reverse_copy.push(internal_changes->top());
        internal_changes->pop();
      }
 
      // Replay the commands one by one
      for (int i = 0; i < undo_stack->count(); ++i) {
        config_internal_change Change = internal_changes_reverse_copy.top();
        internal_changes_reverse_copy.pop();
        internal_changes->push(Change);
 
        try {
 
          dbe::actions::onobject const* Command = dynamic_cast<dbe::actions::onobject const*>(undo_stack->command(i));
 
          if (not Command->redoable()) {
            undo_stack->redo();
          } else {
            // If the object we are trying to make the changes to does not exist it means it was deleted
 
            if ((dbe::config::api::info::has_obj(Change.classname, Change.uid) and
                 Change.request != config_internal_change::CREATED) or
                Change.request == config_internal_change::FILE_INCLUDED or
                Change.request == config_internal_change::FILE_DELETED) {
              // If in virtue of external modification the object still exists and our action was not a creation
              Command->reload();
              undo_stack->redo();
            } else if (not dbe::config::api::info::has_obj(Change.classname, Change.uid) and
                       Change.request == config_internal_change::CREATED) {
              // If the external changes have removed the object and we have created it
              undo_stack->redo();
              Command->reload();
            } else {
              Command->setredoable(false);
              Command->setundoable(false);
 
              // Advance the stack by redoing an non-redoable (i.e. the redo action has no effect) command
              undo_stack->redo();
            }
          }
 
        } catch (dunedaq::conffwk::Exception const& e) {
          WARN("Object reference could not be changed",
               dbe::config::errors::parse(e).c_str(),
               "for object with UID:",
               Change.uid,
               "of class",
               Change.classname);
        } catch (...) {
          WARN("Unknown exception during object modification",
               "s",
               "\n\nFor object with UID:",
               Change.uid.c_str(),
               "of class:",
               Change.classname.c_str());
        }
      }
    } else {
      confaccessor::clear_commands();
    }
  } else {
    INFO("Database reloaded due external changes", "Database consistency enforcement");
    confaccessor::clear_commands();
  }
 
  slot_tree_reset();
  build_file_model();
 
  // Emit the signal for connected listeners (e.g., the object editors)
  emit signal_externalchanges_processed();
}

slot_remove_tab

void dbe::MainWindow::slot_remove_tab ( int i )

privateslot

Definition at line 128 of file MainWindow.cpp.

{
  if (i == -1 || ((tableholder->count() == 1) && i == 0)) {
    return;
  }
 
  QWidget* Widget = tableholder->widget(i);
 
  tableholder->removeTab(i);
 
  delete Widget;
 
  Widget = nullptr;
}

slot_show_information_about_dbe

void dbe::MainWindow::slot_show_information_about_dbe ( )

privateslot

Definition at line 1052 of file MainWindow.cpp.

{
  static QString const title("About DBE");
  static QString const msg = QString()
                               .append("DBE is an editor to work with OKS and RDB backends that manages most of the "
                                       "hard work for you in editing the configuration database\n")
                               .append("\n\nMaintained :\t\tC&C Working group \n\t\t\t(atlas-tdaq-cc-wg@cern.ch)")
                               .append("\nProgram version:\t\t")
                               .append(dbe_compiled_version)
                               .append("\nLibraries version:\t")
                               .append("\n\t\t\tdbecore(")
                               .append(dbe_lib_core_version)
                               .append("),\n\t\t\tdbe_config_api(")
                               .append(dbe_lib_config_api_version)
                               .append("),\n\t\t\tdbe_structure(")
                               .append(dbe_lib_structure_version)
                               .append("),\n\t\t\tdbe_internal(")
                               .append(dbe_lib_internal_version)
                               .append(')')
                               .append("\nRepo commit hash:\t")
                               .append(dbe_compiled_commit);
 
  QMessageBox::about(this, title, msg);
}

slot_show_userchanges

void dbe::MainWindow::slot_show_userchanges ( )

privateslot

Definition at line 1084 of file MainWindow.cpp.

{
  InfoWidget->setCurrentIndex(InfoWidget->indexOf(CommitedTab));
}

slot_show_userguide

void dbe::MainWindow::slot_show_userguide ( )

privateslot

Definition at line 1078 of file MainWindow.cpp.

{
  QDesktopServices::openUrl(QUrl("https://atlasdaq.cern.ch/dbe/"));
}

slot_toggle_casesensitive_for_treeview

void dbe::MainWindow::slot_toggle_casesensitive_for_treeview ( bool )

privateslot

Definition at line 1096 of file MainWindow.cpp.

{
  if (CaseSensitiveCheckBoxTree->isChecked())
    this_treefilter->setFilterCaseSensitivity(Qt::CaseSensitive);
  else {
    this_treefilter->setFilterCaseSensitivity(Qt::CaseInsensitive);
  }
  update_total_objects();
}

slot_toggle_commit_button

void dbe::MainWindow::slot_toggle_commit_button ( )

privateslot

Definition at line 1697 of file MainWindow.cpp.

{
  if (isArchivedConf == false) {
    const auto& uncommittedFiles = confaccessor::uncommitted_files();
 
    if (uncommittedFiles.empty() == true) {
      Commit->setEnabled(false);
      Commit->setToolTip("There is nothing to commit");
    } else {
      Commit->setEnabled(true);
 
      std::string l;
      for (const std::string& f : uncommittedFiles) {
        l += "  " + f + "\n";
      }
 
      Commit->setToolTip(QString::fromStdString("Commit changes.\nHere are the uncommitted files:\n" + l));
    }
 
    build_file_model();
 
  } else {
    Commit->setEnabled(false);
  }
}

slot_tree_reset

void dbe::MainWindow::slot_tree_reset ( )

privateslot

Definition at line 1191 of file MainWindow.cpp.

{
  // Keep track of the selected tab
  int IndexOfCurrentTab = tableholder->currentIndex();
 
  // Here are the all the open tabs
  std::vector<QModelIndex> idxs;
 
  for (int i = 0; i < tableholder->count(); ++i) {
    TableTab* CurrentTab = dynamic_cast<TableTab*>(tableholder->widget(i));
    if (CurrentTab) {
      if (CurrentTab->GetTableModel()) {
        const QString& TableClassName = CurrentTab->GetTableModel()->get_class_name();
        if (!TableClassName.isEmpty()) {
          treenode* NodeClass = confaccessor::gethandler()->getnode(TableClassName);
          if (NodeClass != nullptr) {
            idxs.push_back(this_classes->getindex(NodeClass));
          }
        }
      }
    }
  }
 
  // Remove all the tabs
  while (tableholder->count() != 0) {
    tableholder->widget(0)->deleteLater();
    tableholder->removeTab(0);
  }
 
  // Disconnecting models from views
  build_class_tree_model();
 
  // Re-create all the tabs
  for (const auto& idx : idxs) {
    slot_add_tab();
    edit_object_at(idx);
  }
 
  // Set the current tab
  tableholder->setCurrentIndex(IndexOfCurrentTab);
}

slot_undo_allchanges

void dbe::MainWindow::slot_undo_allchanges ( )

privateslot

Definition at line 1090 of file MainWindow.cpp.

{
  UndoView->stack()->setIndex(0);
}

slot_update_committed_files

void dbe::MainWindow::slot_update_committed_files ( const std::list< std::string > & files, const std::string & msg )

privateslot

Definition at line 1724 of file MainWindow.cpp.

{
  for (const std::string& f : files) {
    CommittedTable->insertRow(0);
    CommittedTable->setItem(0, 0, new QTableWidgetItem(QString::fromStdString(f)));
    CommittedTable->setItem(0, 1, new QTableWidgetItem(QString::fromStdString(msg)));
    CommittedTable->setItem(
      0, 2, new QTableWidgetItem(QDate::currentDate().toString() + " " + QTime::currentTime().toString()));
  }
 
  CommittedTable->resizeColumnsToContents();
}

slot_warning_message

void dbe::MainWindow::slot_warning_message ( QString const title, QString const msg )

slot

This method permits to propagate and display messages from the messaging subsytem.

It is important that the arguments are pass-by-copy because references will become invalid, even if they are bound to consted temporaries, once the deleter from the other thread is called.

Definition at line 1645 of file MainWindow.cpp.

{
  display_message_box(title, msg, QMessageBox::Icon::Warning);
}

slot_whatisthis

void dbe::MainWindow::slot_whatisthis ( )

privateslot

Definition at line 1046 of file MainWindow.cpp.

{
  QWhatsThis::enterWhatsThisMode();
}

update_total_objects()

void dbe::MainWindow::update_total_objects ( )

private

Definition at line 1234 of file MainWindow.cpp.

{
  int total = 0;
  for (int item = 0; item < this_treefilter->rowCount(); item++) {
    auto index = this_treefilter->index(item, 1);
    auto data = this_treefilter->data(index);
    total += data.toInt();
  }
  TotalObjectsLabel->setText(QString("Total Objects: %1").arg(total));
}

WriteSettings()

void dbe::MainWindow::WriteSettings ( )

private

Definition at line 820 of file MainWindow.cpp.

{
  QSettings Settings("dunedaq", "dbe_main");
  Settings.beginGroup("MainWindow-layout");
  Settings.setValue("size", size());
  Settings.setValue("pos", pos());
  Settings.setValue("TableView", DisplayTableView->isChecked());
  Settings.setValue("ClassView", DisplayClassView->isChecked());
 
  Settings.setValue("Messages", DisplayMessages->isChecked());
  Settings.setValue("geometry", saveGeometry());
  Settings.setValue("state", saveState());
  Settings.endGroup();
 
  Settings.beginGroup("MainWindow-checkboxes");
  Settings.setValue("tree-case-sensitive", CaseSensitiveCheckBoxTree->isChecked());
  Settings.setValue("table-case-sensitive", CaseSensitiveCheckBoxTable->isChecked());
  Settings.endGroup();
}

Member Data Documentation

allFiles

QSet<QString> dbe::MainWindow::allFiles

private

Definition at line 65 of file MainWindow.hpp.

isArchivedConf

std::atomic<bool> dbe::MainWindow::isArchivedConf

private

Definition at line 76 of file MainWindow.hpp.

m_batch_change_in_progress

bool dbe::MainWindow::m_batch_change_in_progress

private

Definition at line 67 of file MainWindow.hpp.

this_classes

dbe::models::tree* dbe::MainWindow::this_classes

private

Definition at line 71 of file MainWindow.hpp.

this_files

FileModel* dbe::MainWindow::this_files

private

Definition at line 68 of file MainWindow.hpp.

this_filesort

QSortFilterProxyModel dbe::MainWindow::this_filesort

private

Definition at line 69 of file MainWindow.hpp.

this_treefilter

models::treeselection* dbe::MainWindow::this_treefilter

private

Definition at line 72 of file MainWindow.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/dbe/include/dbe/MainWindow.hpp
• /github/workspace/dunedaq/sourcecode/dbe/src/internal/MainWindow.cpp