RealDataSelectorWidget.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Import/RealDataSelectorWidget.cpp
//! @brief     Implements class RealDataSelectorWidget
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/View/Import/RealDataSelectorWidget.h"
#include "Device/Data/DataUtils.h"
#include "Device/Data/Datafield.h"
#include "GUI/Application/ApplicationSettings.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Model/RealDataModel.h"
#include "GUI/Support/IO/AbstractDataLoader1D.h"
#include "GUI/Support/IO/DataLoaders1D.h"
#include "GUI/Util/Error.h"
#include "GUI/View/Common/ItemViewOverlayButtons.h"
#include "GUI/View/Common/StyledToolbar.h"
#include "GUI/View/Import/ImportDataUtils.h"
#include "GUI/View/Import/RealDataPropertiesWidget.h"
#include "GUI/View/Import/RealDataTreeModel.h"
#include "GUI/View/Info/MessageBox.h"
#include "GUI/View/Project/ProjectManager.h"
#include <QFileDialog>
#include <QItemSelectionModel>
#include <QLineEdit>
#include <QListView>
#include <QMenu>
#include <QSplitter>
#include <QTreeView>
#include <QVBoxLayout>
 
RealDataSelectorWidget::RealDataSelectorWidget(QWidget* parent, ProjectDocument* document)
    : QWidget(parent)
    , m_itemTree(new QTreeView(this))
    , m_itemTreeModel(new RealDataTreeModel(this, document->realDataModel()))
    , m_propertiesWidget(new RealDataPropertiesWidget(this, document))
    , m_document(document)
    , m_import1dDataAction(new QAction(this))
    , m_import2dDataAction(new QAction(this))
    , m_renameDataAction(new QAction(this))
    , m_removeDataAction(new QAction(this))
{
    setProperty("stylable", true);
    setAttribute(Qt::WA_StyledBackground, true);
 
    setMinimumSize(250, 600);
    setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding);
    setWindowTitle("RealDataSelectorWidget");
 
    m_import2dDataAction->setText("Import 2D data");
    m_import2dDataAction->setIcon(QIcon(":/images/shape-square-plus.svg"));
    m_import2dDataAction->setIconText("2D");
    m_import2dDataAction->setToolTip("Import 2D data");
    connect(m_import2dDataAction, &QAction::triggered, [this]() { importData2D(); });
 
    m_import1dDataAction->setText("Import 1D data");
    m_import1dDataAction->setIcon(QIcon(":/images/shape-square-plus.svg"));
    m_import1dDataAction->setIconText("1D");
    m_import1dDataAction->setToolTip("Import 1D data");
    connect(m_import1dDataAction, &QAction::triggered, [this]() { importData1D(); });
 
    m_renameDataAction->setText("Rename");
    m_renameDataAction->setIcon(QIcon()); // #baTODO: Icon needed?
    m_renameDataAction->setIconText("Rename");
    m_renameDataAction->setToolTip("Rename data");
    connect(m_renameDataAction, &QAction::triggered, this,
            &RealDataSelectorWidget::renameCurrentItem);
 
    m_removeDataAction->setText("Remove");
    m_removeDataAction->setIcon(QIcon(":/images/delete.svg"));
    m_removeDataAction->setIconText("Remove");
    m_removeDataAction->setToolTip("Remove selected data");
    connect(m_removeDataAction, &QAction::triggered, this,
            &RealDataSelectorWidget::removeCurrentItem);
 
    // #baimport ++ following line necessary for tree as well? relevant for RealItems at all?
    // m_itemTree->setAttribute(Qt::WA_MacShowFocusRect, false);
    m_itemTree->setItemsExpandable(false);
    m_itemTree->setRootIsDecorated(false);
    m_itemTree->setHeaderHidden(true);
    m_itemTree->setContextMenuPolicy(Qt::CustomContextMenu);
    m_itemTree->setModel(m_itemTreeModel);
 
    auto* splitter = new QSplitter;
    splitter->setOrientation(Qt::Vertical);
    splitter->addWidget(m_itemTree);
    splitter->addWidget(m_propertiesWidget);
    splitter->setChildrenCollapsible(true);
 
    auto* mainLayout = new QVBoxLayout;
    mainLayout->setMargin(0);
    mainLayout->setSpacing(0);
    mainLayout->setContentsMargins(0, 0, 0, 0);
    mainLayout->addWidget(splitter);
 
    setLayout(mainLayout);
 
    connect(m_itemTree, &QTreeView::customContextMenuRequested, this,
            &RealDataSelectorWidget::onContextMenuRequest);
 
    connect(m_document, &ProjectDocument::modified, this,
            &RealDataSelectorWidget::updateFunctionalities);
 
    connect(m_itemTreeModel, &QAbstractItemModel::modelReset,
            [this]() { m_itemTree->expandAll(); });
 
    connect(m_itemTreeModel, &QAbstractItemModel::rowsInserted,
            [this]() { m_itemTree->expandAll(); });
 
    connect(m_itemTree->selectionModel(), &QItemSelectionModel::selectionChanged, this,
            &RealDataSelectorWidget::onSelectionChanged, Qt::UniqueConnection);
 
    m_itemTree->expandAll();
    updateActionEnabling();
    updateFunctionalities();
 
    // ensure a current item when widget is shown
    setCurrentItem(m_itemTreeModel->topMostItem());
    if (currentItem())
        emit selectionChanged(currentItem());
 
    ItemViewOverlayButtons::install(
        m_itemTree, [=](const QModelIndex& i, bool h) { return getOverlayActions(i, h); });
}
 
QSize RealDataSelectorWidget::sizeHint() const
{
    return QSize(200, 400);
}
 
QSize RealDataSelectorWidget::minimumSizeHint() const
{
    return QSize(128, 200);
}
 
RealDataItem* RealDataSelectorWidget::currentItem()
{
    return m_itemTreeModel->itemForIndex(currentIndex());
}
 
void RealDataSelectorWidget::setCurrentItem(RealDataItem* item)
{
    m_itemTree->selectionModel()->clearSelection();
    QModelIndex index = m_itemTreeModel->indexForItem(item);
    if (index.isValid())
        m_itemTree->selectionModel()->setCurrentIndex(index, QItemSelectionModel::SelectCurrent);
}
 
QModelIndex RealDataSelectorWidget::currentIndex()
{
    return m_itemTree->selectionModel()->currentIndex();
}
 
QList<QAction*> RealDataSelectorWidget::getOverlayActions(const QModelIndex& index, bool asHover)
{
    if (m_itemTreeModel->isHeadline(index)) {
        if (asHover)
            return {};
 
        return (index == m_itemTreeModel->indexOfHeadline(1))
                   ? QList<QAction*>({m_import1dDataAction})
                   : QList<QAction*>({m_import2dDataAction});
    }
 
    // -- index belongs to item
    if (!asHover)
        return {};
 
    auto* item = m_itemTreeModel->itemForIndex(index);
    if (item == nullptr)
        return {};
 
    auto* removeAction = new QAction(this);
    removeAction->setText("Remove");
    removeAction->setIcon(QIcon(":/images/delete.svg"));
    removeAction->setIconText("Remove");
    removeAction->setToolTip("Remove this data");
    connect(removeAction, &QAction::triggered, [=]() { m_itemTreeModel->removeItem(item); });
 
    return {removeAction};
}
 
void RealDataSelectorWidget::onSelectionChanged()
{
    updateActionEnabling();
    m_propertiesWidget->setItem(currentItem());
    emit selectionChanged(currentItem());
}
 
void RealDataSelectorWidget::onContextMenuRequest(const QPoint& point)
{
    auto* realDataItemAtPoint = m_itemTreeModel->itemForIndex(m_itemTree->indexAt(point));
    updateActionEnabling(realDataItemAtPoint);
 
    QMenu menu;
    menu.setToolTipsVisible(true);
 
    if (realDataItemAtPoint != nullptr) {
        menu.addAction(m_renameDataAction);
        menu.addAction(m_removeDataAction);
        menu.addSeparator();
    }
 
    menu.addAction(m_import2dDataAction);
    menu.addAction(m_import1dDataAction);
    menu.exec(m_itemTree->mapToGlobal(point));
}
 
void RealDataSelectorWidget::importData1D()
{
    QMap<QString, AbstractDataLoader1D*> loaderOfFilter;
    QString filters;
    for (auto* loader : DataLoaders1D::instance().loaders()) {
        const QString filter =
            loader->name() + " (*.txt *.csv *.dat)"; // #baimport - take file filters from loader
        loaderOfFilter[filter] = loader;
 
        if (!filters.isEmpty())
            filters += ";;";
        filters += filter;
    }
    filters += ";;Other (*.*)";
 
    QString selectedFilter = ProjectManager::instance()->recentlyUsedImportFilter1D();
    const QString dirname = ProjectManager::instance()->userImportDir();
 
    const QStringList fileNames = QFileDialog::getOpenFileNames(
        Q_NULLPTR, "Open Intensity Files", dirname, filters, &selectedFilter,
        appSettings->useNativeFileDialog() ? QFileDialog::Options()
                                           : QFileDialog::DontUseNativeDialog);
 
    if (fileNames.isEmpty())
        return;
 
    ProjectManager::instance()->setImportDirFromFilePath(fileNames[0]);
    ProjectManager::instance()->setRecentlyUsedImportFilter1D(selectedFilter);
 
    const AbstractDataLoader* selectedLoader = loaderOfFilter.value(selectedFilter, nullptr);
    for (const auto& fileName : fileNames) {
        RealDataItem* realDataItem = m_itemTreeModel->insertSpecularDataItem();
        realDataItem->setDataName(QFileInfo(fileName).baseName());
        realDataItem->setNativeFileName(fileName);
 
        const QString errorText =
            GUI::View::ImportDataUtils::Import1dData(realDataItem, selectedLoader);
        if (errorText.isEmpty())
            setCurrentItem(realDataItem);
        else {
            m_itemTreeModel->removeItem(realDataItem);
            GUI::View::Helpers::warning(this, "File import",
                                        QString("The file '%1' could not be imported.")
                                            .arg(QDir::toNativeSeparators(fileName)),
                                        errorText);
        }
    }
}
 
void RealDataSelectorWidget::importData2D()
{
    QMap<QString, IOFactory::LoaderSelector> loaderOfFilter;
    QString filters;
 
    const auto addFilter = [&](IOFactory::LoaderSelector loaderSelector, const QString& filter) {
        if (!filters.isEmpty())
            filters += ";;";
        filters += filter;
        loaderOfFilter[filter] = loaderSelector;
    };
    addFilter(IOFactory::tiff, "TIFF (*.tif *.tiff *.tif.gz)");
    addFilter(IOFactory::nicos, "Nicos/SANSDRaw (*.001)");
    addFilter(IOFactory::bornagain, "BornAgain (*.int.gz)");
    addFilter(IOFactory::automatic, "CSV (*.txt *.csv *.dat)");
    addFilter(IOFactory::automatic, "All (*.*)");
 
    QString selectedFilter = ProjectManager::instance()->recentlyUsedImportFilter2D();
 
    const QString dirname = ProjectManager::instance()->userImportDir();
    const QStringList fileNames = QFileDialog::getOpenFileNames(
        Q_NULLPTR, "Open Intensity Files", dirname, filters, &selectedFilter,
        appSettings->useNativeFileDialog() ? QFileDialog::Options()
                                           : QFileDialog::DontUseNativeDialog);
    if (fileNames.isEmpty())
        return;
 
    ProjectManager::instance()->setImportDirFromFilePath(fileNames[0]);
    ProjectManager::instance()->setRecentlyUsedImportFilter2D(selectedFilter);
 
    const auto selectedLoader = loaderOfFilter.value(selectedFilter, IOFactory::automatic);
 
    for (const auto& fileName : fileNames) {
        std::unique_ptr<Datafield> data =
            GUI::View::ImportDataUtils::Import2dData(fileName, selectedLoader);
        if (!data)
            continue;
        RealDataItem* realDataItem = m_itemTreeModel->insertIntensityDataItem();
        realDataItem->setDataName(QFileInfo(fileName).baseName());
 
        try {
            if (data->rank() != 2)
                throw Error("The content could not be interpreted correctly as 2-dimensional.");
 
            realDataItem->setDatafield(data.release());
            setCurrentItem(realDataItem);
        } catch (std::exception& ex) {
            m_itemTreeModel->removeItem(realDataItem);
 
            const QString message = QString("Error while trying to read file\n\n'%1'\n\n%2")
                                        .arg(fileName)
                                        .arg(QString::fromStdString(std::string(ex.what())));
            GUI::View::Helpers::warning(this, "File import", message);
        }
    }
}
 
void RealDataSelectorWidget::renameCurrentItem()
{
    if (currentIndex().isValid()) {
        // First delete any existing index widget. This is necessary if overlay buttons are used,
        // because these buttons use the indexWidget() functionality, which itself uses the same
        // internals as an item editor
        m_itemTree->setIndexWidget(currentIndex(), nullptr);
        m_itemTree->edit(currentIndex());
    }
}
 
void RealDataSelectorWidget::removeCurrentItem()
{
    m_itemTreeModel->removeItem(currentItem());
}
 
void RealDataSelectorWidget::updateActionEnabling()
{
    updateActionEnabling(currentItem());
}
 
void RealDataSelectorWidget::updateActionEnabling(const RealDataItem* item) const
{
    m_import2dDataAction->setEnabled(true);
    m_import1dDataAction->setEnabled(true);
 
    m_removeDataAction->setEnabled(item != nullptr);
    m_renameDataAction->setEnabled(item != nullptr);
}
 
void RealDataSelectorWidget::updateFunctionalities()
{
    QSet<int> visibleRanks;
    if (m_document->functionalities().testFlag(ProjectDocument::Specular))
        visibleRanks << 1;
    if (m_document->functionalities().testFlag(ProjectDocument::Gisas)
        || m_document->functionalities().testFlag(ProjectDocument::Offspec)
        || m_document->functionalities().testFlag(ProjectDocument::DepthProbe))
        visibleRanks << 2;
 
    m_itemTreeModel->setVisibleRanks(visibleRanks);
}