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_debuginfo_message (QString const, QString const)
void	slot_information_message (QString const, QString const)
void	slot_notice_message (QString const, QString const)
void	slot_warning_message (QString const, QString const)
void	slot_error_message (QString const, QString const)
void	slot_failure_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	LoadDefaultSetting ()
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)

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	load_settings (bool LoadSettings=false)
void	WriteSettings ()
void	argsparse (QMap< QString, QString > const &)
void	init_tabs ()
void	edit_object_at (const QModelIndex &Index)
void	update_total_objects ()

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 42 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 49 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();
 
  load_settings ( false );
  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

argsparse()

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

private

Definition at line 882 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 174 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 ( 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 ( LoadDefaultSetting() ) );
  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_debuginfo_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_notice_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_failure_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 298 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 403 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 1352 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 1921 of file MainWindow.cpp.

{
  return not m_batch_change_in_progress;
}

closeEvent()

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

private

Definition at line 1289 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 742 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 1439 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 712 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;
  }
}

edit_object_at()

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

private

Definition at line 343 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 1338 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 649 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 1662 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 1842 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

Color Management

Definition at line 130 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);
 
 
  StyleUtility::InitColorManagement();
}

init_tabs()

void dbe::MainWindow::init_tabs ( )

private

Definition at line 92 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_settings()

void dbe::MainWindow::load_settings ( bool LoadSettings = false )

private

Load Settings means default settings

Definition at line 821 of file MainWindow.cpp.

{
  QSettings * Settings;
  QString userPath = QDir::homePath() + "/.conffwk/ATLAS_TDAQ_DBE";
  QString userFile = "DBE_User_Settings.conf";
 
  if ( !LoadSettings )
  {
    if ( QDir ( userPath ).exists ( userFile ) )
      Settings = new QSettings ( "ATLAS_TDAQ_DBE",
                                 "DBE_User_Settings" );
    else
      Settings = new QSettings ( ":theme/DBE_Default_User_Settings.conf",
                                 QSettings::NativeFormat );
  }
  else
  {
    Settings = new QSettings ( ":theme/DBE_Default_User_Settings.conf",
                               QSettings::NativeFormat );
  }
 
  Settings->beginGroup ( "MainWindow-layout" );
  resize ( Settings->value ( "size" ).toSize() );
  move ( Settings->value ( "pos" ).toPoint() );
  DisplayTableView->setChecked ( Settings->value ( "TableView" ).toBool() );
  DisplayClassView->setChecked ( Settings->value ( "ClassView" ).toBool() );
 
  DisplayMessages->setChecked ( Settings->value ( "Messages" ).toBool() );
  restoreGeometry ( Settings->value ( "geometry" ).toByteArray() );
  restoreState ( Settings->value ( "state" ).toByteArray() );
  Settings->endGroup();
 
  Settings->beginGroup ( "MainWindow-checkboxes" );
  CaseSensitiveCheckBoxTree->setChecked (
    Settings->value ( "tree-case-sensitive" ).toBool() );
  CaseSensitiveCheckBoxTable->setChecked (
    Settings->value ( "table-case-sensitive" ).toBool() );
  Settings->endGroup();
}

LoadDefaultSetting

void dbe::MainWindow::LoadDefaultSetting ( )

privateslot

Definition at line 644 of file MainWindow.cpp.

{
  load_settings ( false );
}

ProcessQuery()

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

private

Definition at line 1305 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
    {};
}

setinternals()

void dbe::MainWindow::setinternals ( )

private

Disconnecting models from views

Definition at line 802 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 515 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 532 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 106 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 1847 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 1852 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 436 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 667 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_debuginfo_message

void dbe::MainWindow::slot_debuginfo_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 1743 of file MainWindow.cpp.

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

slot_edit_object_from_class_view

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

privateslot

Definition at line 1429 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 1795 of file MainWindow.cpp.

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

slot_failure_message

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

slot

Definition at line 1691 of file MainWindow.cpp.

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

slot_fetch_data

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

privateslot

Definition at line 427 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 1185 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 1208 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 1164 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 1717 of file MainWindow.cpp.

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

slot_launch_batchchange

void dbe::MainWindow::slot_launch_batchchange ( )

privateslot

Definition at line 575 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 589 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 548 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_load_db_from_create_widget

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

privateslot

Definition at line 676 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 1926 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 1143 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_notice_message

void dbe::MainWindow::slot_notice_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 1769 of file MainWindow.cpp.

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

slot_open_database_from_file

void dbe::MainWindow::slot_open_database_from_file ( )

privateslot

Definition at line 1466 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 1496 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 113 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 1099 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 1121 of file MainWindow.cpp.

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

slot_show_userguide

void dbe::MainWindow::slot_show_userguide ( )

privateslot

Definition at line 1116 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 1131 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 1884 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 1235 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 1126 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 1910 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 1821 of file MainWindow.cpp.

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

slot_whatisthis

void dbe::MainWindow::slot_whatisthis ( )

privateslot

Create Rdb menu based on the available Rdb information Add rdb servers for each partition

Parameters

p	is the partition source for which to populate with server information

Definition at line 1094 of file MainWindow.cpp.

{
  QWhatsThis::enterWhatsThisMode();
}

update_total_objects()

void dbe::MainWindow::update_total_objects ( )

private

Definition at line 1277 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 862 of file MainWindow.cpp.

{
  QSettings Settings ( "ATLAS_TDAQ_DBE", "DBE_User_Settings" );
  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 62 of file MainWindow.hpp.

isArchivedConf

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

private

Definition at line 73 of file MainWindow.hpp.

m_batch_change_in_progress

bool dbe::MainWindow::m_batch_change_in_progress

private

Definition at line 64 of file MainWindow.hpp.

this_classes

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

private

Definition at line 68 of file MainWindow.hpp.

this_files

FileModel* dbe::MainWindow::this_files

private

Definition at line 65 of file MainWindow.hpp.

this_filesort

QSortFilterProxyModel dbe::MainWindow::this_filesort

private

Definition at line 66 of file MainWindow.hpp.

this_treefilter

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

private

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