TabbedSetOfTreeEditors.cpp

Go to the documentation of this file.

#include <DatabaseUtils/GUI/TabbedSetOfTreeEditors.h>
#include <DatabaseUtils/GUI/ConfigDataTreeEditor.h>
#include <DatabaseUtils/GUI/DataTreeCreatorThread.h>
#include <DatabaseUtils/GUI/CustomTabBehaviors.h>
#include <DatabaseUtils/DAQConfig/NamedConfigUtils.h>
#include <boost/shared_ptr.hpp>
#include <QtGui/QProgressDialog>

using namespace dbutils::daqconfig;

namespace dbutils {
namespace gui {

TabbedSetOfTreeEditors::
TabbedSetOfTreeEditors(const std::string& subsystemName,
                       const std::string& configType,
                       const std::vector<std::string>& tableDefinitionList,
                       QWidget *parent) : QTabWidget(parent),
                                          _isTopLevel(false)
{
    _subsystemName = subsystemName;
    _configType = configType;
    _tableDefinitionList = tableDefinitionList;

    for (uint32_t idx = 0; idx < _tableDefinitionList.size(); ++idx) {
        ConfigDataTreeEditor* editor = new ConfigDataTreeEditor(this);
        this->addTab(editor, "unknown table");

        connect(editor, SIGNAL(aChangeWasMade()),
                this, SLOT(reactToEditorDataChange()));
        connect(editor, SIGNAL(dataWasSaved()),
                this, SLOT(reactToDataSave()));
    }
}

bool TabbedSetOfTreeEditors::
loadData(const dbutils::daqconfig::IDSpec& idSpec)
{
    if (idSpec.getConfigId() == -1) {return false;}

    boost::shared_ptr<QProgressDialog> progressBar;
    if (_isTopLevel) {
        progressBar.reset(new QProgressDialog("Loading data...", "Close", 0,
                                              this->count(), this));
        progressBar->setWindowModality(Qt::WindowModal);
        progressBar->setMinimumDuration(250);
    }

    std::vector<int64_t> subsystemConfigIdList;
    if (! NamedConfigUtils::
        getSubsystemConfigIdAncestryFromGlobalId(idSpec,
                                                 _subsystemName,
                                                 _configType,
                                                 subsystemConfigIdList)) {
        return false;
    }

    boost::shared_ptr<DataTreeCreatorThread> treeThreadPtr;
    std::vector<boost::shared_ptr<DataTreeCreatorThread> > treeThreadList;
    for (uint32_t idx = 0; idx < _tableDefinitionList.size(); ++idx) {
        std::string filename = _tableDefinitionList[idx];
        treeThreadPtr.reset(new DataTreeCreatorThread(filename,
                                                      subsystemConfigIdList,this));
        treeThreadList.push_back(treeThreadPtr);
    }

    bool status = true;
    for (uint32_t idx = 0; idx < treeThreadList.size(); ++idx) {
        if (_isTopLevel) {progressBar->setValue(idx);}
        treeThreadPtr = treeThreadList[idx];
        treeThreadPtr->wait();
        boost::shared_ptr<ConfigDataTree> dataTreePtr=treeThreadPtr->getTree();

        QWidget* theWidget = widget(idx);
        ConfigDataTreeEditor* editor =
            static_cast<ConfigDataTreeEditor*>(theWidget);
        if (! editor->loadData(dataTreePtr)) {status = false;}
        this->setTabText(idx, dataTreePtr->getTableName().c_str());
    }
    if (_isTopLevel) {progressBar->setValue(this->count());}

    return status;
}

bool TabbedSetOfTreeEditors::hasChanges() const
{
    for (int idx = 0; idx < this->count(); ++idx) {
        QWidget* theWidget = widget(idx);
        ConfigDataTreeEditor* editor =
            static_cast<ConfigDataTreeEditor*>(theWidget);
        if (editor->hasChanges()) {return true;}
    }
    return false;
}

bool TabbedSetOfTreeEditors::
saveChanges(const dbutils::daqconfig::IDSpec& oldGlobalIdSpec,
            const dbutils::daqconfig::IDSpec& newGlobalIdSpec,
            const dbutils::daqconfig::GlobalNameSpec& newGlobalNameSpec)
{
    if (! this->hasChanges()) {return true;}

    boost::shared_ptr<QProgressDialog> progressBar;
    if (_isTopLevel) {
        progressBar.reset(new QProgressDialog("Loading data...", "Close", 0,
                                              this->count(), this));
        progressBar->setWindowModality(Qt::WindowModal);
        progressBar->setMinimumDuration(250);
    }

    // ** create the new subsystem named configuration ***
    std::vector<int64_t> existingSubystemConfigIdList;
    if (! NamedConfigUtils::
        getSubsystemConfigIdAncestryFromGlobalId(oldGlobalIdSpec,
                                    _subsystemName, _configType,
                                    existingSubystemConfigIdList)) {
        std::cerr << "ERROR: unable to fetch the existing named subsystem " 
                  << "configurations." << std::endl;
        return false;
    }
    int64_t oldSubsystemConfigId = existingSubystemConfigIdList[0];
    IDSpec oldSubsystemIdSpec(oldSubsystemConfigId, IDSpec::SUBSYSTEM,
                              (oldGlobalIdSpec.isDAQConfiguration() ?
                               IDSpec::DAQ : IDSpec::SLOWCONTROLS));

    dbutils::SimpleParameterSet paramSet;
    if (newGlobalNameSpec.getConfigName() != "InitialGlobalConfig" &&
        newGlobalNameSpec.getConfigName() != "ColdDetectorSettings") {
        std::string newName = newGlobalNameSpec.getConfigName() + "_" +
            _subsystemName + "_" + _configType;
        paramSet.put(NamedConfigUtils::NAME_COLUMN_NAME, newName);
    }
    paramSet.put(NamedConfigUtils::DCMOPMODE_COLUMN_NAME,
                 newGlobalNameSpec.getDCMOpMode());
    paramSet.put(NamedConfigUtils::DESCRIPTION_COLUMN_NAME,
                 "New values from the Configuration Editor GUI.");
    paramSet.put(NamedConfigUtils::GLOBALCFGID_COLUMN_NAME,
                 boost::lexical_cast<std::string>
                 (newGlobalIdSpec.getConfigId()));
    int64_t subsystemConfigId;
    novadaq::Status resultStatus =
        NamedConfigUtils::copySubsystemConfig(oldSubsystemIdSpec, true,
                                              paramSet, "", true,
                                              subsystemConfigId);
    if (resultStatus.code ==
        NamedConfigUtils::COPY_FOUND_UPDATE_IN_PROGRESS) {
        std::cerr << "Unable to create a copy of the named "
                  << "subsystem configuration with ID = "
                  << oldSubsystemConfigId
                  << ": the creation of a new configuration is "
                  << "already in progress ("
                  << resultStatus.message << ")"
                  << std::endl;
        return false;
    }
    else if (resultStatus.code ==
             NamedConfigUtils::COPY_FOUND_INTERMEDIATE_UPDATE) {
        std::cerr << "Unable to create a copy of the named "
                  << "subsystem configuration with ID = "
                  << oldSubsystemConfigId
                  << ": intermediate changes would be overwritten by "
                  << "this change (" << resultStatus.message << ")"
                  << std::endl;
        return false;
    }
    else if (resultStatus.code != NamedConfigUtils::COPY_SUCCEEDED) {
        std::cerr << "Unable to create a copy of the named "
                  << "subsystem configuration with ID = "
                  << oldSubsystemConfigId
                  << ": " << resultStatus.message
                  << std::endl;
        return false;
    }

    bool status = true;
    for (int idx = 0; idx < this->count(); ++idx) {
        if (_isTopLevel) {progressBar->setValue(idx);}
        QWidget* theWidget = widget(idx);
        ConfigDataTreeEditor* editor =
            static_cast<ConfigDataTreeEditor*>(theWidget);
        if (! editor->saveChanges(oldSubsystemConfigId, subsystemConfigId)) {
            status = false;
        }
    }

    IDSpec subsystemIdSpec(subsystemConfigId, IDSpec::SUBSYSTEM,
                           (oldGlobalIdSpec.isDAQConfiguration() ?
                            IDSpec::DAQ : IDSpec::SLOWCONTROLS));
    if (status) {
        NamedConfigUtils::markConfigDone(subsystemIdSpec, true);
    }
    else {
        NamedConfigUtils::markConfigDone(subsystemIdSpec, false);
    }
    if (_isTopLevel) {progressBar->setValue(this->count());}

    return status;
}

bool TabbedSetOfTreeEditors::addInitialRow()
{
    bool status = true;
    for (int idx = 0; idx < this->count(); ++idx) {
        QWidget* theWidget = widget(idx);
        ConfigDataTreeEditor* editor =
            static_cast<ConfigDataTreeEditor*>(theWidget);
        if (! editor->addInitialRow()) {status = false;}
    }
    return status;
}

void TabbedSetOfTreeEditors::reactToEditorDataChange()
{
    CustomTabBehaviors::updateTabTextColors(this, this->tabBar());
    emit aChangeWasMade();
}

void TabbedSetOfTreeEditors::reactToDataSave()
{
    CustomTabBehaviors::updateTabTextColors(this, this->tabBar());
    emit dataWasSaved();
}

} // end of namespace gui
} // end of namespace dbutils