MainWindow.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: no.
 
#include "dbe/MainWindow.hpp"
#include "dbe/BatchChangeWidget.hpp"
#include "dbe/BuildingBlockEditors.hpp"
#include "dbe/Command.hpp"
#include "dbe/CommitDialog.hpp"
#include "dbe/CreateDatabaseWidget.hpp"
#include "dbe/FileInfo.hpp"
#include "dbe/MyApplication.hpp"
#include "dbe/ObjectCreator.hpp"
#include "dbe/ObjectEditor.hpp"
#include "dbe/Preferences.hpp"
#include "dbe/StyleUtility.hpp"
#include "dbe/config_api.hpp"
#include "dbe/config_api_version.hpp"
#include "dbe/messenger.hpp"
#include "dbe/messenger_proxy.hpp"
#include "dbe/subtreeproxy.hpp"
#include "dbe/treenode.hpp"
#include "dbe/version.hpp"
 
#include "logging/Logging.hpp"
 
#include <QApplication>
#include <QCloseEvent>
#include <QDesktopServices>
#include <QFileDialog>
#include <QItemDelegate>
#include <QMessageBox>
#include <QProgressDialog>
#include <QSettings>
#include <QTime>
#include <QUndoStack>
#include <QUrl>
#include <QWhatsThis>
 
#include <future>
#include <thread>
 
#include <boost/scope_exit.hpp>
 
namespace {
// This allows to select data in the cells but to not modify them
class DummyEditorDelegate : public QItemDelegate
{
public:
  void setModelData(QWidget* /* editor */,
                    QAbstractItemModel* /* model */,
                    const QModelIndex& /* index */) const override
  {
  }
};
}
 
dbe::MainWindow::MainWindow(QMap<QString, QString> const& cmdargs, QWidget* parent)
  : 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();
}
 
void
dbe::MainWindow::init_tabs()
{
  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)));
}
 
void
dbe::MainWindow::slot_add_tab()
{
  tableholder->addTab(new TableTab(tableholder), "Table View");
  tableholder->setCurrentIndex(tableholder->count() - 1);
  tableholder->show();
}
 
void
dbe::MainWindow::slot_remove_tab(int i)
{
  if (i == -1 || ((tableholder->count() == 1) && i == 0)) {
    return;
  }
 
  QWidget* Widget = tableholder->widget(i);
 
  tableholder->removeTab(i);
 
  delete Widget;
 
  Widget = nullptr;
}
 
void
dbe::MainWindow::init()
{
  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);
}
 
void
dbe::MainWindow::attach()
{
  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 );
}
 
void
dbe::MainWindow::build_class_tree_model()
{
  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();
}
 
void
dbe::MainWindow::build_table_model()
{
  SearchLineTable->clear();
  SearchLineTable->show();
  SearchLineTable->setProperty("placeholderText", QVariant(QString("Table Filter")));
  CaseSensitiveCheckBoxTable->show();
}
 
void
dbe::MainWindow::edit_object_at(const QModelIndex& Index)
{
  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();
      }
    }
  }
}
 
void
dbe::MainWindow::build_file_model()
{
 
  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();
  }
}
 
void
dbe::MainWindow::slot_fetch_data(const treenode* ClassNode)
{
  if (this_classes->canFetchMore(this_classes->index(ClassNode->GetRow(), 0, QModelIndex()))) {
    this_classes->fetchMore(this_classes->index(ClassNode->GetRow(), 0, QModelIndex()));
  }
}
 
bool
dbe::MainWindow::slot_commit_database(bool Exit)
{
  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;
}
 
void
dbe::MainWindow::slot_abort_changes()
{
  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);
  }
}
 
void
dbe::MainWindow::slot_abort_external_changes()
{
  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);
  }
}
 
void
dbe::MainWindow::slot_launch_object_editor(tref Object)
{
  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();
  }
}
 
void
dbe::MainWindow::slot_launch_batchchange()
{
  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");
  }
}
 
void
dbe::MainWindow::slot_launch_batchchange_on_table()
{
  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();
}
 
void
dbe::MainWindow::reload_default_settings()
{
  QSettings settings;
  settings.clear();
  load_default_settings();
}
void
dbe::MainWindow::load_default_settings()
{
  QSettings defaults(":theme/DBE_Default_User_Settings.conf", QSettings::NativeFormat);
  apply_settings(defaults);
}
 
QString
dbe::MainWindow::find_db_repository_dir()
{
  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 "";
}
 
void
dbe::MainWindow::slot_create_newdb()
{
 
  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&)));
}
 
void
dbe::MainWindow::slot_load_db_from_create_widget(const QString& DatabaseName)
{
  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");
  }
}
 
bool
dbe::MainWindow::dbreload()
{
  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;
  }
}
 
bool
dbe::MainWindow::dbload()
{
  // 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();
}
 
void
dbe::MainWindow::setinternals()
{
  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);
}
 
void
dbe::MainWindow::apply_settings(QSettings& settings)
{
  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();
}
 
void
dbe::MainWindow::WriteSettings()
{
  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();
}
 
void
dbe::MainWindow::argsparse(QMap<QString, QString> const& opts)
{
  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);
    }
  }
}
 
// /**
//  * Create Rdb menu based on the available Rdb information
//  */
// void dbe::MainWindow::init_rdb_menu()
// {
//   ConnectToRdb->clear();
 
//   std::list<IPCPartition> pl;
//   IPCPartition::getPartitions(pl);
//   TLOG_DEBUG(1) <<  "Found " << pl.size() << " partitions"  ;
 
//   pl.push_front(IPCPartition("initial"));
 
//   auto f = [pl, this] () {
//       for ( auto it = pl.begin(); it != pl.end(); ++it )
//       {
//           lookForRDBServers ( *it );
//       }
//   };
 
//   std::thread t(f);
//   t.detach();
// }
 
// void dbe::MainWindow::slot_rdb_found(const QString& p, const RDBMap& rdbs) {
//     QMenu * part_menu = new QMenu(p);
 
//     for(auto it = rdbs.begin(); it != rdbs.end(); ++it) {
//         QAction * newAct = new QAction ( it.key(), part_menu );
 
//         QFont actFont = newAct->font();
//         if(it.value() == true) {
//             newAct->setToolTip ( QString ( "This is a Read-Only instance of the DB" ) );
//             actFont.setItalic ( true );
//         } else {
//             newAct->setToolTip ( QString ( "This is a Read/Write instance of the DB" ) );
//             actFont.setBold ( true );
//         }
 
//         newAct->setFont ( actFont );
 
//         part_menu->addAction ( newAct );
//     }
 
//     ConnectToRdb->addMenu ( part_menu );
// }
 
// /**
//  * Add rdb servers for each partition
//  *
//  * @param p is the partition source for which to populate with server information
//  */
// void dbe::MainWindow::lookForRDBServers ( const IPCPartition & p )
// {
//   TLOG_DEBUG(2) <<  "dbe::MainWindow::addRDBServers()"  ;
 
//   if ( p.isValid() )
//   {
//     TLOG_DEBUG(2) <<  "Inserting partition = " << p.name()  ;
 
//     RDBMap rdbs;
 
//     try
//     {
//         {
//             std::map<std::string, rdb::cursor_var> objects;
//             p.getObjects<rdb::cursor, ::ipc::use_cache, ::ipc::unchecked_narrow> ( objects );
//             std::map<std::string, rdb::cursor_var>::iterator rdb_it = objects.begin();
 
//             while ( rdb_it != objects.end() )
//             {
//                 TLOG_DEBUG(2) <<  "Found server : " << rdb_it->first  ;
 
//                 rdbs.insert(QString::fromStdString(rdb_it->first), true);
 
//                 ++rdb_it;
//             }
//         }
 
//         {
//             std::map<std::string, rdb::writer_var> objects;
//             p.getObjects<rdb::writer, ::ipc::use_cache, ::ipc::unchecked_narrow> ( objects );
//             std::map<std::string, rdb::writer_var>::iterator rdb_it = objects.begin();
 
//             while ( rdb_it != objects.end() )
//             {
//                 TLOG_DEBUG(2) <<  "Found server : " << rdb_it->first  ;
 
//                 rdbs.insert(QString::fromStdString(rdb_it->first), false);
 
//                 ++rdb_it;
//             }
//         }
//     }
//     catch ( daq::ipc::InvalidPartition& e )
//     {
//       ers::error ( e );
//     }
 
//     if(rdbs.isEmpty() == false) {
//         emit signal_rdb_found (QString::fromStdString(p.name()), rdbs);
//     }
//   }
// }
 
// void dbe::MainWindow::slot_rdb_selected ( QAction * action )
// {
//   QMenu * parentMenu = qobject_cast<QMenu *> ( action->parent() );
 
//   if ( parentMenu )
//   {
//     if ( dbreload() )
//     {
//       BOOST_SCOPE_EXIT(void)
//       {
//           QApplication::restoreOverrideCursor();
//        }
//       BOOST_SCOPE_EXIT_END
 
//       QApplication::setOverrideCursor(Qt::WaitCursor);
 
//       confaccessor::setdbinfo ( action->text() + "@" + parentMenu->title(), dbinfo::rdb );
 
//       if ( dbload() )
//       {
//         setinternals();
//         build_class_tree_model();
//         build_partition_tree_model();
//         build_resource_tree_model();
//         build_file_model();
//       }
//     }
//   }
// }
 
// void dbe::MainWindow::slot_oracle_prepare()
// {
//   if ( this_oraclewidget == nullptr )
//   {
//     this_oraclewidget = new OracleWidget();
//     connect ( this_oraclewidget, SIGNAL ( OpenOracleConfig ( const QString & ) ), this,
//               SLOT ( slot_load_oracle ( const QString & ) ) );
//   }
 
//   this_oraclewidget->raise();
//   this_oraclewidget->show();
// }
 
// void dbe::MainWindow::slot_load_oracle ( const QString & OracleDatabase )
// {
//   if ( dbreload() )
//   {
//     confaccessor::setdblocation ( OracleDatabase );
 
//     if ( dbload() )
//     {
//       setinternals();
//       build_class_tree_model();
//       build_partition_tree_model();
//       build_resource_tree_model();
//       build_file_model();
//     }
//   }
 
//   if ( this_oraclewidget != nullptr )
//   {
//     this_oraclewidget->close();
//   }
// }
 
void
dbe::MainWindow::slot_whatisthis()
{
  QWhatsThis::enterWhatsThisMode();
}
 
void
dbe::MainWindow::slot_show_information_about_dbe()
{
  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);
}
 
void
dbe::MainWindow::slot_show_userguide()
{
  QDesktopServices::openUrl(QUrl("https://atlasdaq.cern.ch/dbe/"));
}
 
void
dbe::MainWindow::slot_show_userchanges()
{
  InfoWidget->setCurrentIndex(InfoWidget->indexOf(CommitedTab));
}
 
void
dbe::MainWindow::slot_undo_allchanges()
{
  UndoView->stack()->setIndex(0);
}
 
void
dbe::MainWindow::slot_toggle_casesensitive_for_treeview(bool)
{
  if (CaseSensitiveCheckBoxTree->isChecked())
    this_treefilter->setFilterCaseSensitivity(Qt::CaseSensitive);
  else {
    this_treefilter->setFilterCaseSensitivity(Qt::CaseInsensitive);
  }
  update_total_objects();
}
 
void
dbe::MainWindow::slot_model_rebuild()
{
  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();
}
 
void
dbe::MainWindow::slot_filter_textchange(const QString& FilterText)
{
  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();
}
 
void
dbe::MainWindow::slot_filter_query()
{
  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);
  }
}
 
void
dbe::MainWindow::slot_filter_table_textchange(const QString& FilterText)
{
  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);
  }
}
 
void
dbe::MainWindow::slot_tree_reset()
{
  // 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);
}
 
void
dbe::MainWindow::update_total_objects()
{
  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));
}
 
void
dbe::MainWindow::closeEvent(QCloseEvent* event)
{
  if (isArchivedConf || check_close()) {
    WriteSettings();
 
    foreach (QWidget* widget, QApplication::allWidgets())
      widget->close();
 
    event->accept();
  } else {
    event->ignore();
  }
}
 
std::vector<dbe::tref>
dbe::MainWindow::ProcessQuery(QString const& Tmp)
{
  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 {};
}
 
bool
dbe::MainWindow::eventFilter(QObject* Target, QEvent* Event)
{
  if (Target == SearchBox->lineEdit() && Event->type() == QEvent::MouseButtonRelease) {
    if (!SearchBox->lineEdit()->hasSelectedText()) {
      SearchBox->lineEdit()->selectAll();
      return true;
    }
  }
 
  return false;
}
 
bool
dbe::MainWindow::check_close()
{
  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;
      }
    }
  }
}
 
void
dbe::MainWindow::slot_edit_object_from_class_view(QModelIndex const& ProxyIndex)
{
  edit_object_at(this_treefilter->mapToSource(ProxyIndex));
}

bool
dbe::MainWindow::dbopen(QString const& dbpath, dbinfo const& loadtype)
{
  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;
}
 
void
dbe::MainWindow::slot_open_database_from_file()
{
  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);
    }
  }
}

void
dbe::MainWindow::slot_process_externalchanges()
{
  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();
}

dbe::MainWindow*
dbe::MainWindow::findthis()
{
  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;
}
 
//-----------------------------------------------------------------------------------------------------------------------------
 
//-----------------------------------------------------------------------------------------------------------------------------
namespace {
const int MAX_MESSAGE_LENGTH = 500;
}
 
void
dbe::MainWindow::display_message_box(const QString& title, const QString& msg, const QMessageBox::Icon& icon)
{
  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();
}

void
dbe::MainWindow::slot_information_message(QString const title, QString const msg)
{
  display_message_box(title, msg, QMessageBox::Icon::Information);
}

void
dbe::MainWindow::slot_error_message(QString const title, QString const msg)
{
  display_message_box(title, msg, QMessageBox::Icon::Critical);
}

void
dbe::MainWindow::slot_warning_message(QString const title, QString const msg)
{
  display_message_box(title, msg, QMessageBox::Icon::Warning);
}
 
//-----------------------------------------------------------------------------------------------------------------------------
 
cptr<dbe::CustomTreeView>
dbe::MainWindow::get_view() const
{
  return cptr<CustomTreeView>(TreeView);
}
 
void
dbe::MainWindow::slot_batch_change_start()
{
  m_batch_change_in_progress = true;
}
 
void
dbe::MainWindow::slot_batch_change_stop(const QList<QPair<QString, QString>>& objs)
{
  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;
}
 
void
dbe::MainWindow::slot_toggle_commit_button()
{
  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);
  }
}
 
void
dbe::MainWindow::slot_update_committed_files(const std::list<std::string>& files, const std::string& msg)
{
  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();
}
 
bool
dbe::MainWindow::check_ready() const
{
  return not m_batch_change_in_progress;
}
 
void
dbe::MainWindow::slot_loaded_db_file(QString file)
{
  allFiles.insert(file);
}
 
void
dbe::MainWindow::slot_launch_preferences()
{
  auto prefs = new Preferences();
  prefs->show();
}