DataSelector.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidQtWidgets/Common/DataSelector.h"
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/AlgorithmProperties.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/FileFinder.h"
#include "MantidAPI/Workspace.h"
#include "MantidAPI/WorkspaceGroup.h"
#include "MantidKernel/Exception.h"
 
#include <QFileInfo>
 
#include <QDebug>
#include <QDropEvent>
#include <QMimeData>
#include <QUrl>
 
using namespace Mantid::API;
 
namespace {
auto &ads = AnalysisDataService::Instance();
 
std::string cutLastOf(const std::string &str, const std::string &delimiter) {
  const auto cutIndex = str.rfind(delimiter);
  if (cutIndex != std::string::npos)
    return str.substr(0, cutIndex);
  return str;
}
 
std::string extractLastOf(const std::string &str, const std::string &delimiter) {
  const auto cutIndex = str.rfind(delimiter);
  if (cutIndex != std::string::npos)
    return str.substr(cutIndex + 1, str.size() - cutIndex);
  return str;
}
 
bool fileFound(std::string const &file) { return !FileFinder::Instance().getFullPath(file).empty(); }
 
std::string loadAlgName(const std::string &filePath) {
  const auto suffix = extractLastOf(filePath, ".");
  return suffix == "dave" ? "LoadDaveGrp" : "Load";
}
 
void makeGroup(std::string const &workspaceName) {
  if (!ads.retrieveWS<WorkspaceGroup>(workspaceName)) {
    const auto groupAlg = AlgorithmManager::Instance().createUnmanaged("GroupWorkspaces");
    groupAlg->initialize();
    groupAlg->setProperty("InputWorkspaces", workspaceName);
    groupAlg->setProperty("OutputWorkspace", workspaceName);
    groupAlg->execute();
  }
}
 
} // namespace
 
namespace MantidQt::MantidWidgets {
 
DataSelector::DataSelector(QWidget *parent)
    : API::MantidWidget(parent), m_loadProperties(), m_algRunner(), m_showLoad(true), m_alwaysLoadAsGroup(false) {
  m_uiForm.setupUi(this);
  connect(m_uiForm.cbInputType, SIGNAL(currentIndexChanged(int)), this, SLOT(handleViewChanged(int)));
  connect(m_uiForm.pbLoadFile, SIGNAL(clicked()), this, SIGNAL(loadClicked()));
 
  // data selected changes
  connect(m_uiForm.rfFileInput, SIGNAL(filesFoundChanged()), this, SLOT(handleFileInput()));
  connect(m_uiForm.wsWorkspaceInput, SIGNAL(currentIndexChanged(int)), this, SLOT(handleWorkspaceInput()));
  connect(m_uiForm.pbLoadFile, SIGNAL(clicked()), this, SLOT(handleFileInput()));
 
  connect(&m_algRunner, SIGNAL(algorithmComplete(bool)), this, SLOT(handleAutoLoadComplete(bool)));
  this->setAcceptDrops(true);
  m_uiForm.rfFileInput->setAcceptDrops(false);
}
 
DataSelector::~DataSelector() = default;
 
bool DataSelector::isOptional() const { return m_isOptional; }
 
void DataSelector::isOptional(bool optional) {
  m_isOptional = optional;
  m_uiForm.rfFileInput->isOptional(optional);
  m_uiForm.wsWorkspaceInput->setOptional(optional);
}
 
void DataSelector::handleFileInput() {
  // Get filename and check it's not empty
  QString filename = m_uiForm.rfFileInput->getUserInput().toString();
 
  if (filename.isEmpty()) {
    return;
  }
 
  if (autoLoadFile(filename)) {
    emit filesAutoLoaded();
  }
}
 
void DataSelector::setSelectorIndex(int index) { m_uiForm.cbInputType->setCurrentIndex(index); }
 
void DataSelector::setTypeSelectorVisible(bool visible) { m_uiForm.cbInputType->setVisible(visible); }
 
bool DataSelector::isFileSelectorVisible() const {
  int index = m_uiForm.stackedDataSelect->currentIndex();
  return (index == 0);
}
 
bool DataSelector::isWorkspaceSelectorVisible() const { return !isFileSelectorVisible(); }
 
bool DataSelector::isValid(bool const autoLoad) {
  bool isValid = false;
 
  if (isFileSelectorVisible()) {
    isValid = m_uiForm.rfFileInput->isValid();
 
    // check to make sure the user hasn't deleted the auto-loaded file
    // since choosing it.
    if (isValid && autoLoad) {
      auto const wsName = getCurrentDataName().toStdString();
 
      isValid = !wsName.empty();
      if (isValid && !ads.doesExist(wsName)) {
        // attempt to reload if we can
        // don't use algorithm runner because we need to know instantly.
        auto const filepath = m_uiForm.rfFileInput->getUserInput().toString().toStdString();
        if (!filepath.empty())
          executeLoadAlgorithm(filepath, wsName);
 
        isValid = ads.doesExist(wsName);
 
        if (!isValid) {
          m_uiForm.rfFileInput->setFileProblem("The specified workspace is "
                                               "missing from the analysis data "
                                               "service");
        }
      } else {
        if (!ads.doesExist(wsName)) {
          return isValid;
        }
        auto const workspaceTypes = m_uiForm.wsWorkspaceInput->getWorkspaceTypes();
        auto const workspace = ads.retrieveWS<Workspace>(wsName);
        isValid = workspaceTypes.empty() || workspaceTypes.indexOf(QString::fromStdString(workspace->id())) != -1;
        if (!isValid) {
          m_uiForm.rfFileInput->setFileProblem("The specified workspace type (" +
                                               QString::fromStdString(workspace->id()) +
                                               ") is "
                                               "not one of the allowed types: " +
                                               workspaceTypes.join(", "));
        }
      }
    }
  } else {
    isValid = m_uiForm.wsWorkspaceInput->isValid();
  }
 
  return isValid;
}
 
QString DataSelector::getProblem() const {
  QString problem = "";
  if (isFileSelectorVisible()) {
    problem = m_uiForm.rfFileInput->getFileProblem();
    if (problem.compare("") == 0) {
      problem = "Input field is empty";
    }
  } else {
    problem = "A valid workspace has not been selected";
  }
 
  return problem;
}
 
bool DataSelector::autoLoadFile(const QString &filepath) {
  const auto baseName = getWsNameFromFiles().toStdString();
  return executeLoadAlgorithm(filepath.toStdString(), baseName);
}
 
bool DataSelector::executeLoadAlgorithm(std::string const &filename, std::string const &outputWorkspace) {
  const auto loadAlg = AlgorithmManager::Instance().createUnmanaged(loadAlgName(filename));
  loadAlg->initialize();
  try {
    loadAlg->setProperty("Filename", filename);
    loadAlg->setProperty("OutputWorkspace", outputWorkspace);
  } catch (std::exception const &ex) {
    m_uiForm.rfFileInput->setFileProblem(ex.what());
    return false;
  }
  loadAlg->updatePropertyValues(m_loadProperties);
 
  m_algRunner.startAlgorithm(loadAlg);
  return true;
}
 
void DataSelector::setLoadProperty(std::string const &propertyName, bool const value) {
  Mantid::API::AlgorithmProperties::update(propertyName, value, m_loadProperties);
}
 
void DataSelector::setLoadProperty(std::string const &propertyName, std::string const &value) {
  Mantid::API::AlgorithmProperties::update(propertyName, value, m_loadProperties);
}
 
void DataSelector::handleAutoLoadComplete(bool error) {
  m_uiForm.rfFileInput->setFileProblem(error ? "Could not load file. See log for details." : "");
 
  if (error) {
    return;
  }
  if (m_alwaysLoadAsGroup) {
    makeGroup(getWsNameFromFiles().toStdString());
  }
  emit dataReady(getWsNameFromFiles());
}
 
void DataSelector::handleWorkspaceInput() {
  if (m_uiForm.stackedDataSelect->currentIndex() > 0) {
    // Get text of name of workspace to use
    QString filename = m_uiForm.wsWorkspaceInput->currentText();
    if (filename.isEmpty())
      return;
 
    // emit that we got a valid workspace/file to work with
    emit dataReady(filename);
  }
}
 
void DataSelector::handleViewChanged(int index) {
  // Index indicates which view is visible.
  m_uiForm.stackedDataSelect->setCurrentIndex(index);
 
  // 0 is always file view
  switch (index) {
  case 0:
    emit fileViewVisible();
    break;
  case 1:
    emit workspaceViewVisible();
    handleWorkspaceInput();
    break;
  }
}
 
QString DataSelector::getFullFilePath() const { return m_uiForm.rfFileInput->getUserInput().toString(); }
 
QString DataSelector::getWsNameFromFiles() const {
  QString filepath = DataSelector::getFullFilePath();
  QFileInfo qfio(filepath);
  QString baseName = qfio.completeBaseName();
 
  // make up a name for the group workspace, if multiple files are specified
  if (m_uiForm.rfFileInput->allowMultipleFiles() && filepath.count(",") > 0) {
    baseName += "_group";
  }
 
  return baseName;
}
 
QString DataSelector::getCurrentDataName(bool const autoLoad) const {
  QString filename("");
 
  int index = m_uiForm.stackedDataSelect->currentIndex();
 
  switch (index) {
  case 0:
    // the file selector is visible
    if (m_uiForm.rfFileInput->isValid()) {
      if (m_uiForm.rfFileInput->allowMultipleFiles() && !autoLoad) {
        // if multiple files are allowed, auto-loading is not on, return the
        // full user input
        filename = getFullFilePath();
      } else {
        filename = getWsNameFromFiles();
      }
    }
    break;
  case 1:
    // the workspace selector is visible
    filename = m_uiForm.wsWorkspaceInput->currentText();
    break;
  }
 
  return filename;
}
 
QString DataSelector::getLoadBtnText() const { return m_uiForm.pbLoadFile->text(); }
 
void DataSelector::setLoadBtnText(const QString &text) { m_uiForm.pbLoadFile->setText(text); }
 
void DataSelector::setAlwaysLoadAsGroup(bool const loadAsGroup) { m_alwaysLoadAsGroup = loadAsGroup; }
 
API::FileFinderSettings DataSelector::readSettings(const QSettings &settings) {
  return API::FileFinderWidget::readSettings(settings);
}
 
void DataSelector::restoreSettings(const API::FileFinderSettings &settings) {
  m_uiForm.rfFileInput->restoreSettings(settings);
}
 
API::FileFinderSettings DataSelector::captureSettings() const { return m_uiForm.rfFileInput->captureSettings(); }
 
void DataSelector::saveSettings(QSettings &settings, const API::FileFinderSettings &values) const {
  m_uiForm.rfFileInput->saveSettings(settings, values);
}
 
bool DataSelector::willShowLoad() { return m_showLoad; }
 
void DataSelector::setShowLoad(bool load) {
  m_uiForm.pbLoadFile->setEnabled(load);
  m_uiForm.pbLoadFile->setVisible(load);
  m_showLoad = load;
}
 
void DataSelector::dropEvent(QDropEvent *de) {
  const QMimeData *mimeData = de->mimeData();
  auto before_action = de->dropAction();
 
  auto const dragData = mimeData->text().toStdString();
 
  if (de->mimeData() && ads.doesExist(dragData)) {
    m_uiForm.wsWorkspaceInput->dropEvent(de);
    if (de->dropAction() == before_action) {
      setWorkspaceSelectorIndex(mimeData->text());
      m_uiForm.cbInputType->setCurrentIndex(1);
      return;
    }
    de->setDropAction(before_action);
  }
 
  m_uiForm.rfFileInput->dropEvent(de);
  if (de->dropAction() == before_action) {
    m_uiForm.cbInputType->setCurrentIndex(0);
  }
 
  auto const filepath = m_uiForm.rfFileInput->getText().toStdString();
  if (de->mimeData() && !ads.doesExist(dragData) && !filepath.empty()) {
    auto const file = extractLastOf(filepath, "/");
    if (fileFound(file)) {
      auto const workspaceName = cutLastOf(file, ".");
      executeLoadAlgorithm(filepath, workspaceName);
 
      setWorkspaceSelectorIndex(QString::fromStdString(workspaceName));
      m_uiForm.cbInputType->setCurrentIndex(1);
    }
  }
}
 
void DataSelector::setWorkspaceSelectorIndex(QString const &workspaceName) {
  auto const index = m_uiForm.wsWorkspaceInput->findText(workspaceName);
  m_uiForm.wsWorkspaceInput->setCurrentIndex(index != -1 ? index : 0);
}
 
void DataSelector::dragEnterEvent(QDragEnterEvent *de) {
  const QMimeData *mimeData = de->mimeData();
  if (mimeData->hasText() || mimeData->hasUrls())
    de->acceptProposedAction();
}
 
} // namespace MantidQt::MantidWidgets