UserInputValidator.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/UserInputValidator.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/WorkspaceGroup.h"
 
#include <QLabel>
#include <QLineEdit>
#include <QString>
#include <QValidator>
 
#include <algorithm>
#include <cmath>
 
using namespace Mantid::API;
using namespace MantidQt::MantidWidgets;
 
namespace // anonymous
{
template <typename T> void sortPair(std::pair<T, T> &pair) {
  if (pair.first > pair.second) {
    T temp = pair.first;
    pair.first = pair.second;
    pair.second = temp;
  }
}
 
bool doesExistInADS(std::string const &workspaceName) {
  return AnalysisDataService::Instance().doesExist(workspaceName);
}
 
boost::optional<std::string> containsInvalidWorkspace(const WorkspaceGroup_const_sptr &group) {
  if (group->isEmpty())
    return "The group workspace " + group->getName() + " is empty.";
 
  const auto it =
      std::find_if(std::cbegin(*group), std::cend(*group), [](const auto &workspace) { return !workspace; });
  if (it != std::cend(*group))
    return "The group workspace " + group->getName() + " contains an invalid workspace.";
  return boost::none;
}
 
} // anonymous namespace
 
namespace MantidQt::CustomInterfaces {
UserInputValidator::UserInputValidator() : m_errorMessages(), m_error(false) {}
 
bool UserInputValidator::checkFieldIsNotEmpty(const QString &name, QLineEdit *field, QLabel *errorLabel) {
  if (field->text().trimmed().isEmpty()) {
    setErrorLabel(errorLabel, false);
    addErrorMessage(name + " has been left blank.");
    return false;
  } else {
    setErrorLabel(errorLabel, true);
    return true;
  }
}
 
bool UserInputValidator::checkFieldIsValid(const QString &errorMessage, QLineEdit *field, QLabel *errorLabel) {
  int dummyPos = 0;
  QString text = field->text();
  QValidator::State fieldState = field->validator()->validate(text, dummyPos);
 
  if (fieldState == QValidator::Acceptable) {
    setErrorLabel(errorLabel, true);
    return true;
  } else {
    setErrorLabel(errorLabel, false);
    addErrorMessage(errorMessage);
    return false;
  }
}
 
bool UserInputValidator::checkWorkspaceSelectorIsNotEmpty(const QString &name, WorkspaceSelector *workspaceSelector) {
  if (workspaceSelector->currentText() == "") {
    addErrorMessage("No " + name + " workspace has been selected.");
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkFileFinderWidgetIsValid(const QString &name, FileFinderWidget *widget) {
  if (!widget->isValid()) {
    addErrorMessage(name + " file error: " + widget->getFileProblem());
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkDataSelectorIsValid(const QString &name, DataSelector *widget, bool silent) {
  if (!widget->isValid()) {
    addErrorMessage(name + " error: " + widget->getProblem(), silent);
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkValidRange(const QString &name, std::pair<double, double> range) {
  if (range.second == range.first) {
    addErrorMessage(name + " must have a non-zero width.");
    return false;
  }
 
  if (range.second < range.first) {
    addErrorMessage("The start of " + name + " must be less than the end.");
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkRangesDontOverlap(std::pair<double, double> rangeA, std::pair<double, double> rangeB) {
  sortPair(rangeA);
  sortPair(rangeB);
 
  if (!(rangeA.second < rangeB.first || rangeB.second < rangeA.first)) {
    QString message = QString("The ranges must not overlap: [%1,%2], [%3,%4].")
                          .arg(rangeA.first)
                          .arg(rangeA.second)
                          .arg(rangeB.first)
                          .arg(rangeB.second);
    addErrorMessage(message);
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkRangeIsEnclosed(const QString &outerName, std::pair<double, double> outer,
                                              const QString &innerName, std::pair<double, double> inner) {
  sortPair(inner);
  sortPair(outer);
 
  if (inner.first < outer.first || inner.second > outer.second) {
    addErrorMessage(outerName + " must completely enclose " + innerName + ".");
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkBins(double lower, double binWidth, double upper, double tolerance) {
  double range = upper - lower;
  if (range < 0) {
    addErrorMessage("The start of a binning range must be less than the end.");
    return false;
  }
  if (range == 0) {
    addErrorMessage("Binning ranges must be non-zero.");
    return false;
  }
  if (binWidth == 0) {
    addErrorMessage("Bin width must be non-zero.");
    return false;
  }
  if (binWidth < 0) {
    addErrorMessage("Bin width must be a positive value.");
    return false;
  }
 
  while (range > tolerance)
    range -= binWidth;
 
  if (std::abs(range) > tolerance) {
    addErrorMessage("Bin width must allow for even splitting of the range.");
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkNotEqual(const QString &name, double x, double y, double tolerance) {
  double delta = x - y;
 
  if (std::abs(delta) <= tolerance) {
    std::stringstream msg;
    msg << name.toStdString() << " (" << x << ")"
        << " should not be equal to " << y << ".";
    QString msgStr = QString::fromStdString(msg.str());
    addErrorMessage(msgStr);
    return false;
  }
 
  return true;
}
 
bool UserInputValidator::checkWorkspaceExists(QString const &workspaceName, bool silent) {
  if (workspaceName.isEmpty())
    return false;
 
  if (!doesExistInADS(workspaceName.toStdString())) {
    addErrorMessage(workspaceName + " could not be found.", silent);
    return false;
  }
  return true;
}
 
bool UserInputValidator::checkWorkspaceNumberOfHistograms(QString const &workspaceName, std::size_t const &validSize) {
  if (checkWorkspaceExists(workspaceName))
    return checkWorkspaceNumberOfHistograms(getADSWorkspace(workspaceName.toStdString()), validSize);
  return false;
}
 
bool UserInputValidator::checkWorkspaceNumberOfHistograms(const MatrixWorkspace_sptr &workspace,
                                                          std::size_t const &validSize) {
  if (workspace->getNumberHistograms() != validSize) {
    addErrorMessage(QString::fromStdString(workspace->getName()) + " should contain " +
                    QString::fromStdString(std::to_string(validSize)) + " spectra.");
    return false;
  }
  return true;
}
 
bool UserInputValidator::checkWorkspaceNumberOfBins(QString const &workspaceName, std::size_t const &validSize) {
  if (checkWorkspaceExists(workspaceName))
    return checkWorkspaceNumberOfBins(getADSWorkspace(workspaceName.toStdString()), validSize);
  return false;
}
 
bool UserInputValidator::checkWorkspaceNumberOfBins(const MatrixWorkspace_sptr &workspace,
                                                    std::size_t const &validSize) {
  if (workspace->x(0).size() != validSize) {
    addErrorMessage(QString::fromStdString(workspace->getName()) + " should contain " +
                    QString::fromStdString(std::to_string(validSize)) + " bins.");
    return false;
  }
  return true;
}
 
bool UserInputValidator::checkWorkspaceGroupIsValid(QString const &groupName, QString const &inputType, bool silent) {
  if (checkWorkspaceType<WorkspaceGroup>(groupName, inputType, "WorkspaceGroup", silent)) {
    if (auto const group = getADSWorkspace<WorkspaceGroup>(groupName.toStdString())) {
      if (auto const error = containsInvalidWorkspace(group)) {
        addErrorMessage(QString::fromStdString(error.get()), silent);
        return false;
      }
      return true;
    }
  }
  return false;
}
 
void UserInputValidator::addErrorMessage(const QString &message, bool silent) {
  if (!silent && !m_errorMessages.contains(message))
    m_errorMessages.append(message);
  m_error = true;
}
 
QString UserInputValidator::generateErrorMessage() {
  if (m_errorMessages.isEmpty())
    return "";
 
  return "Please correct the following:\n" + m_errorMessages.join("\n");
}
 
bool UserInputValidator::isAllInputValid() { return !m_error; }
 
void UserInputValidator::setErrorLabel(QLabel *errorLabel, bool valid) {
  // Do nothing if no error label was provided
  if (errorLabel == nullptr)
    return;
 
  if (!valid) {
    // Set the label to be red
    QPalette palette = errorLabel->palette();
    palette.setColor(errorLabel->foregroundRole(), Qt::red);
    errorLabel->setPalette(palette);
 
    errorLabel->setText("*");
  } else {
    errorLabel->setText("");
  }
 
  // Only show the label if input is invalid
  errorLabel->setVisible(!valid);
}
} // namespace MantidQt::CustomInterfaces