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/Property.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 const *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 const *prop) {
  return isValidPropertyValue(prop, "") || isValidPropertyValue(prop, prop->getDefault());
}
 
std::string createFieldPlaceholderText(Mantid::Kernel::Property const *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_lastValue(), m_error(), m_isOutputWsProp(false),
      m_previousValue(), m_previous_isDynamicDefault(false), m_enteredValue(), m_entered_isDynamicDefault(false),
      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);
  // `addLayout` sets parent of `infoWidget` correctly
  m_gridLayout->addWidget(infoWidget, m_row, 4);
 
  QMap<Info, std::pair<QString, QString>> pathsAndToolTips;
  pathsAndToolTips[RESTORE] =
      std::pair<QString, QString>(":/history.png", "This property had a previously-entered value.  Click "
                                                   "to toggle it off and on.");
  pathsAndToolTips[REPLACE] = std::pair<QString, QString>(
      ":/replace.png", "A workspace with this name already exists and so will be overwritten.");
  pathsAndToolTips[INVALID] = std::pair<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;
  }
 
  // Qt will have parented the `infoWidget` to `m_gridLayout`, and re-parented all of the icons to `infoWidget`.
  // However, some end-user classes need to be able to completely recreate the `PropertyWidget`,
  //   so for this reason we explicitly delete these objects when this widget is destroyed.
  connect(this, &QObject::destroyed, this, [infoWidget]() {
    infoWidget->deleteLater(); // Safe deferred deletion
  });
 
  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) {
  // Set the value in the widget itself.
  setValueImpl(value);
  m_lastValue = value;
 
  // Set the current value in the property, and check its validation.
  // TODO: this method could have a much better name!
  updateIconVisibility();
 
  // Emit the `valueChanged` signal only when both the widget (and its property)
  //   have their _current_ values, _AND_ those values are valid!
  if (m_error.isEmpty()) {
    valueChangedSlot();
  }
}
 
void PropertyWidget::setPreviousValue(const QString &previousValue) {
  m_useHistory = true;
  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.isEmpty() && m_previousValue.toStdString() != m_prop->getDefault()) {
    setUseHistoryIcon(m_useHistory, m_prop->isDynamicDefault());
    m_icons[RESTORE]->setVisible(true);
  }
}
 
void PropertyWidget::setPrevious_isDynamicDefault(bool flag) {
  m_previous_isDynamicDefault = flag;
  m_prop->setIsDynamicDefault(m_previous_isDynamicDefault);
}
 
void PropertyWidget::transferHistoryState(const PropertyWidget *other, const PropertyWidget *upstream) {
  QString value = QString::fromStdString(m_prop->value());
  bool isDynamicDefault = m_prop->isDynamicDefault();
 
  m_icons[RESTORE]->setVisible(other->m_icons[RESTORE]->isVisible());
  if (!upstream) {
    // This clause transfers the state details, while making the new
    //   property's state consistent with its new value.
    m_previousValue = other->m_previousValue;
    m_useHistory = (value == m_previousValue);
    m_previous_isDynamicDefault = other->m_previous_isDynamicDefault;
    m_enteredValue = (m_useHistory ? other->m_enteredValue : value);
    m_entered_isDynamicDefault = (m_useHistory ? other->m_entered_isDynamicDefault : isDynamicDefault);
  } else {
    // This clause treats the dynamic-default case:
    //   the use-history state for a dynamic-default value tracks the upstream state.
    m_useHistory = upstream->m_useHistory;
    m_previousValue = (m_useHistory ? value : other->m_previousValue);
    m_previous_isDynamicDefault = (m_useHistory ? isDynamicDefault : other->m_previous_isDynamicDefault);
    m_enteredValue = (m_useHistory ? other->m_enteredValue : value);
    m_entered_isDynamicDefault = (m_useHistory ? other->m_entered_isDynamicDefault : isDynamicDefault);
  }
 
  setUseHistoryIcon(m_useHistory, isDynamicDefault);
}
 
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() {
  QString value = this->getValue();
  if (value != m_lastValue) {
    // DO NOTHING if the value has not changed =>
    //   ignore focus changes that don't correspond to value changes.
    m_lastValue = value;
 
    if (value != m_previousValue) {
      m_useHistory = false;
      m_enteredValue = value;
 
      // The user has edited the property => disable dynamic-default values.
      m_entered_isDynamicDefault = false;
      m_prop->setIsDynamicDefault(m_entered_isDynamicDefault);
    } else {
      m_useHistory = true;
      m_prop->setIsDynamicDefault(m_previous_isDynamicDefault);
    }
 
    setUseHistoryIcon(m_useHistory, m_prop->isDynamicDefault());
 
    // The property's value is validated and updated here:
    updateIconVisibility();
 
    // As in `setValue`:
    //   emit the `valueChanged` signal only when both the widget (and its property)
    //   have their _current_ values, _AND_ those values are valid!
    if (m_error.isEmpty())
      valueChangedSlot();
  }
}
 
void PropertyWidget::toggleUseHistory() {
  m_useHistory = !m_useHistory;
  if (m_useHistory) {
    m_prop->setIsDynamicDefault(m_previous_isDynamicDefault);
    setValue(m_previousValue);
  } else {
    m_prop->setIsDynamicDefault(m_entered_isDynamicDefault);
    setValue(m_enteredValue);
  }
  setUseHistoryIcon(m_useHistory, m_prop->isDynamicDefault());
}
 
void PropertyWidget::setUseHistoryIcon(bool useHistory, bool isDynamicDefault) {
  const QString iconPath = useHistory ? (isDynamicDefault ? ":/history_dynamic_default.png" : ":/history.png")
                                      : (isDynamicDefault ? ":/history_off_dynamic_default.png" : ":/history_off.png");
  m_icons[RESTORE]->setPixmap(QPixmap(iconPath).scaledToHeight(15));
 
  // When any user-entered value exists:
  // OR when a value is a dynamic-default value:
  //   make the use-history icons visible.
  if (!m_enteredValue.isEmpty() || isDynamicDefault)
    m_icons[RESTORE]->setVisible(true);
}
 
void PropertyWidget::addReplaceWSButton() {
  // Don't re-create it if it already exists
  if (m_replaceWSButton)
    return;
 
  auto const *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