PropertyWidget.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/PropertyWidget.h"
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/IWorkspaceProperty.h"
#include "MantidKernel/EmptyValues.h"
#include "MantidKernel/System.h"
 
#include <cfloat>
#include <climits>
#include <cmath>
 
#include <algorithm>
#include <sstream>
 
#include <QLineEdit>
 
using namespace Mantid::Kernel;
using namespace Mantid::API;
using Mantid::API::IWorkspaceProperty;
 
namespace // anonymous
{
double stringToRoundedNumber(const std::string &s) {
  // Using std::istringstream is a nice way to do string-to-double conversion
  // in this situation as it rounds numbers for us at the same time.
  // Unfortunately,
  // commas seem to confuse it ("0,0,0" is converted to "0" without any
  // warning).
  const bool containsComma = s.find(",") != std::string::npos;
  if (containsComma)
    throw std::runtime_error("string contains a comma");
 
  return std::stod(s);
}
 
bool isValidPropertyValue(Mantid::Kernel::Property *prop, const std::string &value) {
  const auto guineaPig = std::shared_ptr<Property>(prop->clone());
  return guineaPig->setValue(value).empty();
}
 
bool isEmptyNumMacro(const std::string &value, const double value_d) {
  using namespace Mantid;
 
  // Catch instances of Python's "sys.maxint" which otherwise seem to fall
  // through our net.
  if (value == "2.14748e+09")
    return true;
 
  static const std::vector<double> EMPTY_NUM_MACROS = {EMPTY_DBL(),
                                                       -DBL_MAX,
                                                       DBL_MAX,
                                                       static_cast<double>(EMPTY_INT()),
                                                       static_cast<double>(EMPTY_LONG()),
                                                       static_cast<double>(-INT_MAX),
                                                       static_cast<double>(-LONG_MAX)};
 
  return std::find(EMPTY_NUM_MACROS.begin(), EMPTY_NUM_MACROS.end(), value_d) != EMPTY_NUM_MACROS.end();
}
 
bool isOptionalProperty(Mantid::Kernel::Property *prop) {
  return isValidPropertyValue(prop, "") || isValidPropertyValue(prop, prop->getDefault());
}
 
std::string createFieldPlaceholderText(Mantid::Kernel::Property *prop) {
  const std::string defaultValue = prop->getDefault();
  if (defaultValue.empty())
    return "";
 
  if (!isValidPropertyValue(prop, defaultValue))
    return "";
 
  // It seems likely that any instance of "-0" or "-0.0" should be replaced with
  // an appropriate
  // EMPTY_* macro, but for now just display them as they appear in the Wiki.
  if (defaultValue == "-0" || defaultValue == "-0.0")
    return "0";
 
  // If it can't be converted to a double, there is no reason to give
  // it special handling
  double roundedNumber;
  try {
    roundedNumber = stringToRoundedNumber(defaultValue);
  } catch (std::exception &) {
    return defaultValue;
  }
 
  if (isEmptyNumMacro(prop->getDefault(), roundedNumber))
    return "";
 
  // We'd like to round off any instances of "2.7999999999999998",
  // "0.050000000000000003", or similar, but we want to keep the
  // decimal point in values like "0.0" or "1.0" since they can be a
  // visual clue that a double is expected.
  static const std::size_t STRING_ROUNDING_LENGTH = 15;
  if (defaultValue.length() >= STRING_ROUNDING_LENGTH) {
    std::stringstream roundedValue;
    roundedValue << roundedNumber;
    return roundedValue.str();
  }
 
  return defaultValue;
}
} // anonymous namespace
 
namespace MantidQt::API {
ClickableLabel::ClickableLabel(QWidget *parent) : QLabel(parent) {}
ClickableLabel::~ClickableLabel() = default;
 
void ClickableLabel::mousePressEvent(QMouseEvent *event) {
  UNUSED_ARG(event);
  emit clicked();
}
 
PropertyWidget::PropertyWidget(Mantid::Kernel::Property *prop, QWidget *parent, QGridLayout *layout, int row)
    : QWidget(parent), m_prop(prop), m_gridLayout(layout), m_parent(nullptr), m_row(row), // m_info(NULL),
      m_doc(), m_replaceWSButton(nullptr), m_widgets(), m_error(), m_isOutputWsProp(false), m_previousValue(),
      m_enteredValue(), m_icons(), m_useHistory(true) {
  if (!prop)
    throw std::runtime_error("NULL Property passed to the PropertyWidget constructor.");
  setObjectName(QString::fromStdString(prop->name()));
 
  if (!m_gridLayout) {
    // Create a LOCAL grid layout
    m_gridLayout = new QGridLayout(this);
 
    m_gridLayout->setSpacing(5);
    this->setLayout(m_gridLayout);
    m_row = 0;
    m_parent = this;
  } else {
    // Use the parent of the provided QGridLayout when adding widgets
    m_parent = parent;
    // HACK - In this mode a property widget is not a true self-contained
    // widget: it has no children
    //        of its own. By default, when added to a parent widget, it will be
    //        drawn invisble
    //        at the top left of the parent widget and obscure mouse clicks etc.
    //        The hack fix is to lower it down the visible stack.
    this->lower();
  }
 
  auto *infoWidget = new QWidget();
  infoWidget->setLayout(new QHBoxLayout(this));
  infoWidget->layout()->setSpacing(1);
  infoWidget->layout()->setContentsMargins(0, 0, 0, 0);
  m_gridLayout->addWidget(infoWidget, m_row, 4);
 
  QMap<Info, QPair<QString, QString>> pathsAndToolTips;
  pathsAndToolTips[RESTORE] =
      QPair<QString, QString>(":/history.png", "This property had a previously-entered value.  Click "
                                               "to toggle it off and on.");
  pathsAndToolTips[REPLACE] =
      QPair<QString, QString>(":/replace.png", "A workspace with this name already exists and so will be overwritten.");
  pathsAndToolTips[INVALID] = QPair<QString, QString>(":/invalid.png", "");
 
  std::vector<Info> labelOrder = {RESTORE, REPLACE, INVALID};
 
  for (const Info &info : labelOrder) {
    const QString iconPath = pathsAndToolTips[info].first;
    const QString toolTip = pathsAndToolTips[info].second;
 
    auto icon = new ClickableLabel(this);
    icon->setPixmap(QPixmap(iconPath).scaledToHeight(15));
    icon->setVisible(false);
    icon->setToolTip(toolTip);
 
    infoWidget->layout()->addWidget(icon);
    m_icons[info] = icon;
  }
 
  connect(m_icons[RESTORE], SIGNAL(clicked()), this, SLOT(toggleUseHistory()));
 
  m_doc = QString::fromStdString(prop->documentation());
 
  if (!isOptionalProperty(prop)) {
    if (!m_doc.isEmpty())
      m_doc += ".\n\n";
    m_doc += "This property is required.";
  }
 
  if (prop->direction() == Direction::Output && dynamic_cast<IWorkspaceProperty *>(prop))
    m_isOutputWsProp = true;
}
 
PropertyWidget::~PropertyWidget() = default;
 
void PropertyWidget::setValue(const QString &value) {
  setValueImpl(value);
  valueChangedSlot();
  updateIconVisibility();
}
 
void PropertyWidget::setPreviousValue(const QString &previousValue) {
  m_previousValue = previousValue;
  setValue(m_previousValue);
 
  // Handle input workspace options that have been set to a workspace
  // previously, but where the workspace no longer exists.
  if (getValue() != previousValue) {
    m_previousValue = "";
    setValue(m_previousValue);
  }
 
  // Once we've made the history icon visible, it will stay that way for
  // the lifetime of the property widget.
  if (m_previousValue.toStdString() != m_prop->getDefault() && !m_previousValue.isEmpty())
    m_icons[RESTORE]->setVisible(true);
}
 
void PropertyWidget::updateIconVisibility(const QString &error) {
  QString userError(error);
  if (userError.isEmpty()) {
    // Show "*" icon if the value is invalid for this property.
    QString value = this->getValue().trimmed();
    // Use the default if empty
    if (value.isEmpty())
      value = QString::fromStdString(m_prop->getDefault());
 
    try {
      userError = QString::fromStdString(m_prop->setValue(value.toStdString()));
    } catch (std::exception &err_details) {
      userError = QString::fromLatin1(err_details.what());
    }
  }
  this->setError(userError.trimmed());
 
  m_icons[INVALID]->setVisible(!m_error.isEmpty());
  m_icons[INVALID]->setToolTip(m_error);
  // Show "!" icon if a workspace would be overwritten.
  if (m_isOutputWsProp) {
    const bool wsExists = Mantid::API::AnalysisDataService::Instance().doesExist(getValue().toStdString());
    m_icons[REPLACE]->setVisible(wsExists);
  }
}
 
void PropertyWidget::replaceWSButtonClicked() { emit replaceWorkspaceName(QString::fromStdString(m_prop->name())); }
 
void PropertyWidget::valueChangedSlot() {
  // This will be caught by the GenericDialog.
  emit valueChanged(QString::fromStdString(m_prop->name()));
}
 
void PropertyWidget::userEditedProperty() {
  setUseHistoryIcon(getValue() == m_previousValue);
  if (getValue() != m_previousValue)
    m_enteredValue = getValue();
  updateIconVisibility();
  valueChangedSlot();
}
 
void PropertyWidget::toggleUseHistory() {
  setUseHistoryIcon(!m_useHistory);
  if (m_useHistory)
    setValue(m_previousValue);
  else
    setValue(m_enteredValue);
}
 
void PropertyWidget::setUseHistoryIcon(bool useHistory) {
  if (m_useHistory != useHistory) {
    m_useHistory = useHistory;
    const QString iconPath = useHistory ? ":/history.png" : ":/history_off.png";
    m_icons[RESTORE]->setPixmap(QPixmap(iconPath).scaledToHeight(15));
  }
}
 
void PropertyWidget::addReplaceWSButton() {
  // Don't re-create it if it already exists
  if (m_replaceWSButton)
    return;
 
  auto *wsProp = dynamic_cast<IWorkspaceProperty *>(m_prop);
  if (wsProp && (m_prop->direction() == Direction::Output)) {
    m_replaceWSButton = new QPushButton(QIcon(":/data_replace.png"), "", m_parent);
    // MG: There is no way with the QIcon class to actually ask what size it is
    // so I had to hard
    // code this number here to get it to a sensible size
    m_replaceWSButton->setMaximumWidth(32);
    // m_wsbtn_tracker[btn ] = 1;
    m_replaceWSButton->setToolTip("Replace input workspace");
    connect(m_replaceWSButton, SIGNAL(clicked()), this, SLOT(replaceWSButtonClicked()));
    connect(m_replaceWSButton, SIGNAL(clicked()), this, SLOT(valueChangedSlot()));
    m_widgets.push_back(m_replaceWSButton);
    // Place in the grid on column 2.
    m_gridLayout->addWidget(m_replaceWSButton, m_row, 2);
    m_replaceWSButton->setVisible(true);
  }
}
 
void PropertyWidget::setError(const QString &error) { m_error = error.trimmed(); }
 
void PropertyWidget::setEnabled(bool val) {
  for (auto &widget : m_widgets)
    widget->setEnabled(val);
  QWidget::setEnabled(val);
}
 
void PropertyWidget::setVisible(bool val) {
  for (auto &widget : m_widgets)
    widget->setVisible(val);
  QWidget::setVisible(val);
}
 
void PropertyWidget::setLabelFont(Mantid::Kernel::Property *prop, QWidget *label) {
  if (!isOptionalProperty(prop)) {
    auto font = label->font();
    font.setBold(true);
    label->setFont(font);
  }
}
 
void PropertyWidget::setFieldPlaceholderText(Mantid::Kernel::Property *prop, QLineEdit *field) {
  field->setPlaceholderText(QString::fromStdString(createFieldPlaceholderText(prop)));
}
 
} // namespace MantidQt::API