Esempio n. 1
0
/**
 * Takes a combobox and adds the allowed values of the given property to its
 * list.
 * It also sets the displayed value to the correct one based on either the
 * history
 * or a script input value
 * @param propName :: The name of the property
 * @param optionsBox :: A pointer to a QComoboBox object
 * @returns A newed QComboBox
 */
void AlgorithmDialog::fillAndSetComboBox(const QString &propName,
                                         QComboBox *optionsBox) const {
  if (!optionsBox)
    return;
  Mantid::Kernel::Property *property = getAlgorithmProperty(propName);
  if (!property)
    return;

  std::vector<std::string> items = property->allowedValues();
  std::vector<std::string>::const_iterator vend = items.end();
  for (std::vector<std::string>::const_iterator vitr = items.begin();
       vitr != vend; ++vitr) {
    optionsBox->addItem(QString::fromStdString(*vitr));
  }

  // Display the appropriate value
  QString displayed("");
  if (!isForScript()) {
    displayed =
        AlgorithmInputHistory::Instance().previousInput(m_algName, propName);
  }
  if (displayed.isEmpty()) {
    displayed = QString::fromStdString(property->value());
  }

  int index = optionsBox->findText(displayed);
  if (index >= 0) {
    optionsBox->setCurrentIndex(index);
  }
}
/** Loads and checks the values passed to the algorithm
 *
 *  @throw invalid_argument if there is an incapatible property value so the algorithm can't continue
 */
void DetectorEfficiencyCorUser::retrieveProperties() {

	// Get the workspaces
	m_inputWS = this->getProperty("InputWorkspace");

	m_outputWS = this->getProperty("OutputWorkspace");

	// If input and output workspaces are not the same, create a new workspace for the output
	if (m_outputWS != this->m_inputWS) {
		m_outputWS = API::WorkspaceFactory::Instance().create(m_inputWS);
	}

	// these first three properties are fully checked by validators
	m_Ei = this->getProperty("IncidentEnergy");
	// If we're not given an Ei, see if one has been set.
	if (m_Ei == EMPTY_DBL()) {
		Mantid::Kernel::Property* prop = m_inputWS->run().getProperty("Ei");
		double val;
		if (!prop || !Strings::convert(prop->value(), val)) {
			throw std::invalid_argument(
					"No Ei value has been set or stored within the run information.");
		}
		m_Ei = val;
		g_log.debug() << "Using stored Ei value " << m_Ei << "\n";
	} else {
		g_log.debug() << "Using user input Ei value: " << m_Ei << "\n";
	}
}
Esempio n. 3
0
/**
 * Check if the control should be enabled for this property
 * @param propName :: The name of the property
 */
bool AlgorithmDialog::isWidgetEnabled(const QString &propName) const {
  // To avoid errors
  if (propName.isEmpty())
    return true;

  // Otherwise it must be disabled but only if it is valid
  Mantid::Kernel::Property *property = getAlgorithmProperty(propName);
  if (!property)
    return true;

  if (!isForScript()) {
    // Regular C++ algo. Let the property tell us,
    // possibly using validators, if it is to be shown enabled
    if (property->getSettings())
      return property->getSettings()->isEnabled(getAlgorithm().get());
    else
      return true;
  } else {
    // Algorithm dialog was called from a script(i.e. Python)
    // Keep things enabled if requested
    if (m_enabled.contains(propName))
      return true;

    /**
     * The control is disabled if
     *   (1) It is contained in the disabled list or
     *   (2) A user passed a value into the dialog
     */

    return !(m_disabled.contains(propName) ||
             m_python_arguments.contains(propName));
  }
}
Esempio n. 4
0
/**
 * Tie together an input widget and a property
 * @param widget :: The widget that will collect the input
 * @param property :: The name of the property to tie the given widget to
 * @param parent_layout :: An optional pointer to a QLayout class that is reponsible for managing the passed widget.
 * If given, a validator label will be added for the given input widget
 * @param readHistory :: If true then a history value will be retrieved
 *
 * @return A NULL pointer if a valid label was successfully add to a passed parent_layout otherwise it
 *          returns a pointer to the QLabel instance marking the validity
 */
QWidget* AlgorithmDialog::tie(QWidget* widget, const QString & property, QLayout *parent_layout, 
                  bool readHistory)
{
  if( m_tied_properties.contains(property) )
    m_tied_properties.remove(property);

  Mantid::Kernel::Property * prop = getAlgorithmProperty(property);
  if( prop ) 
  { //Set a few things on the widget
    widget->setToolTip(QString::fromStdString(prop->documentation()));
  }
  widget->setEnabled(isWidgetEnabled(property));

  PropertyWidget * propWidget = qobject_cast<PropertyWidget*>(widget);

  // Save in the hashes
  m_tied_properties.insert(property, widget);

  // If the widget's layout has been given then assume that a validator is required, else assume not
  QWidget* validlbl(NULL);
  if( parent_layout )
  {
    // Check if the validator is already there
    validlbl = getValidatorMarker(property);
    if( validlbl )
    {
      // Find where it was sitting in the layout
      int item_index;
      if (propWidget)
        item_index = parent_layout->indexOf(propWidget->getMainWidget());
      else
        item_index = parent_layout->indexOf(widget);

      if( QBoxLayout *box = qobject_cast<QBoxLayout*>(parent_layout) )
      {
        box->insertWidget(item_index + 1, validlbl);
      }
      else if( QGridLayout *grid = qobject_cast<QGridLayout*>(parent_layout) )
      {
        int row(0), col(0), span(0);
        grid->getItemPosition(item_index, &row, &col, &span, &span);
        grid->addWidget(validlbl, row, col+2);
      }
      else
      {}
    }
  }
  else
  {
    m_noValidation.append(property);
  }

  if( readHistory )
  {
    setPreviousValue(widget, property);
  }

  return validlbl;
}
Esempio n. 5
0
/*
 * Get run property as double
 * @s - input property name
 *
 */
double ConvertToConstantL2::getRunProperty(std::string s) {
  Mantid::Kernel::Property *prop = m_inputWS->run().getProperty(s);
  double val;
  if (!prop || !Strings::convert(prop->value(), val)) {
    std::string mesg = "Run property " + s + "doesn't exist!";
    g_log.error(mesg);
    throw std::runtime_error(mesg);
  }
  return val;
}
Esempio n. 6
0
/**
 * Get an input value from the form, dealing with blank inputs etc
 * @param propName :: The name of the property
 */
QString AlgorithmDialog::getInputValue(const QString &propName) const {
  QString value = m_propertyValueMap.value(propName);
  if (value.isEmpty()) {
    Mantid::Kernel::Property *prop = getAlgorithmProperty(propName);
    if (prop)
      return QString::fromStdString(prop->getDefault());
    else
      return "";
  }

  return value;
}
Esempio n. 7
0
/**
 * Set the input for a text box based on either the history or a script value
 * @param propName :: The name of the property
 * @param textField :: The QLineEdit field
 */
void AlgorithmDialog::fillLineEdit(const QString &propName,
                                   QLineEdit *textField) {
  if (!isForScript()) {
    textField->setText(
        AlgorithmInputHistory::Instance().previousInput(m_algName, propName));
  } else {
    Mantid::Kernel::Property *property = getAlgorithmProperty(propName);
    if (property && property->isValid().empty() &&
        (m_python_arguments.contains(propName) || !property->isDefault())) {
      textField->setText(QString::fromStdString(property->value()));
    }
  }
}
Esempio n. 8
0
/**
 * Save the property values to the input history
 */
void AlgorithmDialog::saveInput() {
  AlgorithmInputHistory::Instance().clearAlgorithmInput(m_algName);
  QStringList::const_iterator pend = m_algProperties.end();
  for (QStringList::const_iterator pitr = m_algProperties.begin(); pitr != pend;
       ++pitr) {
    Mantid::Kernel::Property *p = getAlgorithmProperty(*pitr);
    if (p->remember()) {
      QString pName = *pitr;
      QString value = m_propertyValueMap.value(pName);
      AlgorithmInputHistory::Instance().storeNewValue(
          m_algName, QPair<QString, QString>(pName, value));
    }
  }
}
Esempio n. 9
0
/** Set the properties that have been parsed from the dialog.
 *
 * @param skipList :: An optional list of property names whose values will not be set
 * @returns A boolean that indicates if the validation was successful.
 */
bool AlgorithmDialog::setPropertyValues(const QStringList & skipList)
{
  QStringList::const_iterator pend = m_algProperties.end();
  bool allValid(true);
  for( QStringList::const_iterator pitr = m_algProperties.begin(); pitr != pend; ++pitr )
  {
    const QString pName = *pitr;
    if( skipList.contains(pName) )
    {
      // For the load dialog, skips setting some properties
      Mantid::Kernel::Property *p = getAlgorithmProperty(pName);
      std::string error = p->isValid();
      m_errors[pName] = QString::fromStdString(error).trimmed();
      if (!error.empty()) allValid = false;
    }
    else
    {
      bool thisValid = this->setPropertyValue(pName, false);
      allValid = allValid && thisValid;
    }
  }

  // Do additional validation on the WHOLE set of properties
  // But only if the individual validation passed
  if ( allValid )
  {
    std::map<std::string, std::string> errs = m_algorithm->validateInputs();
    for (auto it = errs.begin(); it != errs.end(); it++)
    {
      const QString pName = QString::fromStdString(it->first);
      const QString value = QString::fromStdString(it->second);
      if (m_errors.contains(pName))
      {
        if (!m_errors[pName].isEmpty())
          m_errors[pName] += "\n";
        m_errors[pName] += value;
      }
      else
        m_errors[pName] = value;
      // There is at least one whole-algo error
      allValid = false;
    }
  }

  // OK all the values have been set once. Time to look for which should be enabled
  this->showValidators();

  return allValid;
}
Esempio n. 10
0
/**
 * Set the algorithm pointer
 * @param alg :: A pointer to the algorithm
 */
void AlgorithmDialog::setAlgorithm(Mantid::API::IAlgorithm_sptr alg) {
  m_algorithm = alg;
  m_algName = QString::fromStdString(alg->name());
  m_algProperties.clear();
  m_tied_properties.clear();
  std::vector<Mantid::Kernel::Property *>::const_iterator iend =
      alg->getProperties().end();
  for (std::vector<Mantid::Kernel::Property *>::const_iterator itr =
           alg->getProperties().begin();
       itr != iend; ++itr) {
    Mantid::Kernel::Property *p = *itr;
    if (dynamic_cast<Mantid::API::IWorkspaceProperty *>(p) ||
        p->direction() != Mantid::Kernel::Direction::Output) {
      m_algProperties.append(QString::fromStdString(p->name()));
    }
  }

  m_validators.clear();
  m_noValidation.clear();
}
Esempio n. 11
0
std::string FrameworkManagerProxy::createAlgorithmDocs(const std::string& algName, const int version)
{
  const std::string EOL="\n";
  API::IAlgorithm_sptr algm = API::AlgorithmManager::Instance().createUnmanaged(algName, version);
  algm->initialize();

  // Put in the quick overview message
  std::stringstream buffer;
  std::string temp = algm->getOptionalMessage();
  if (temp.size() > 0)
    buffer << temp << EOL << EOL;

  // get a sorted copy of the properties
  PropertyVector properties(algm->getProperties());
  std::sort(properties.begin(), properties.end(), PropertyOrdering());

  // generate the sanitized names
  StringVector names(properties.size());
  size_t numProps = properties.size();
  for ( size_t i = 0; i < numProps; ++i) 
  {
    names[i] = removeCharacters(properties[i]->name(), "");
  }

  buffer << "Property descriptions: " << EOL << EOL;
  // write the actual property descriptions
  Mantid::Kernel::Property *prop;
  for ( size_t i = 0; i < numProps; ++i) 
  {
    prop = properties[i];
    buffer << names[i] << "("
           << Mantid::Kernel::Direction::asText(prop->direction());
    if (!prop->isValid().empty())
      buffer << ":req";
    buffer << ") *" << prop->type() << "* ";
    std::set<std::string> allowed = prop->allowedValues();
    if (!prop->documentation().empty() || !allowed.empty())
    {
      buffer << "      " << prop->documentation();
      if (!allowed.empty())
      {
        buffer << " [" << Kernel::Strings::join(allowed.begin(), allowed.end(), ", ");
        buffer << "]";
      }
      buffer << EOL;
      if( i < numProps - 1 ) buffer << EOL;
    }
  }

  return buffer.str();
}
Esempio n. 12
0
/** Set a value for a widget.
 *
 * The function needs to know about the types of widgets
 * that are being used. Currently it knows about QComboBox, QLineEdit and
 * QCheckBox
 * @param widget :: A pointer to the widget
 * @param propName :: The property name
 */
void AlgorithmDialog::setPreviousValue(QWidget *widget,
                                       const QString &propName) {
  // If is called from a script, check if we have such property
  if (isForScript() && !getAlgorithmProperty(propName))
    return;

  QString value = getPreviousValue(propName);

  Mantid::Kernel::Property *property = getAlgorithmProperty(propName);

  // Do the right thing for the widget type
  if (QComboBox *opts = qobject_cast<QComboBox *>(widget)) {
    if (property && value.isEmpty()) {
      value = QString::fromStdString(property->value());
    }
    int index = opts->findText(value);
    if (index >= 0) {
      opts->setCurrentIndex(index);
    }
    return;
  }
  if (QAbstractButton *checker = qobject_cast<QAbstractButton *>(widget)) {
    if (value.isEmpty() &&
        dynamic_cast<Mantid::Kernel::PropertyWithValue<bool> *>(property))
      value = QString::fromStdString(property->value());
    checker->setChecked(value != "0");
    return;
  }
  if (QDateTimeEdit *dateEdit = qobject_cast<QDateTimeEdit *>(widget)) {
    // String in ISO8601 format
    DateAndTime t = DateAndTime::getCurrentTime();
    try {
      t.setFromISO8601(verifyAndSanitizeISO8601(value.toStdString()));
    } catch (std::exception &) {
    }
    dateEdit->setDate(QDate(t.year(), t.month(), t.day()));
    dateEdit->setTime(QTime(t.hour(), t.minute(), t.second(), 0));
    return;
  }

  QLineEdit *textfield = qobject_cast<QLineEdit *>(widget);
  MantidWidget *mtdwidget = qobject_cast<MantidWidget *>(widget);
  if (textfield || mtdwidget) {
    if (!isForScript()) {
      if (textfield)
        textfield->setText(value);
      else
        mtdwidget->setUserInput(value);
    } else {
      // Need to check if this is the default value as we don't fill them in if
      // they are
      if (m_python_arguments.contains(propName) || !property->isDefault()) {
        if (textfield)
          textfield->setText(value);
        else
          mtdwidget->setUserInput(value);
      }
    }
    return;
  }

  PropertyWidget *propWidget = qobject_cast<PropertyWidget *>(widget);
  if (propWidget) {
    propWidget->setPreviousValue(value);

    return;
  }

  // Reaching here means we have a widget type we don't understand. Tell the
  // developer
  QMessageBox::warning(
      this, windowTitle(),
      QString("Cannot set value for ") + widget->metaObject()->className() +
          ". Update AlgorithmDialog::setValue() to cope with this widget.");
}
Esempio n. 13
0
/**
  * A helper function to create the simple API
  * @param algName :: A string giving the name of the algorithm
  * @param path :: The path to the .m file that we should create
  */
void CreateSimpleAPIHelper(const std::string &algName,
                           const std::string &path) {
  IAlgorithm *alg;
  try {
    alg = FrameworkManager::Instance().createAlgorithm(algName);
  } catch (std::exception &) {
    std::string err = "An error occurred while writing the ";
    err += algName + " function definition.\n";
    mexErrMsgTxt(err.c_str());
    return;
  }
  std::string fullpath(path + algName + ".m");
  std::ofstream mfile(fullpath.c_str());

  typedef std::vector<Mantid::Kernel::Property *> PropertyVector;
  // parameter list
  mfile << "function res = " << algName << "(varargin)\n";
  // help string
  PropertyVector orderedProperties(alg->getProperties());
  std::sort(orderedProperties.begin(), orderedProperties.end(),
            PropertyOrdering());
  PropertyVector::const_iterator pIter = orderedProperties.begin();
  PropertyVector::const_iterator pEnd = orderedProperties.end();
  mfile << "%\t" << algName << "(";
  for (; pIter != pEnd;) {
    mfile << (*pIter)->name();
    if (++pIter != pEnd)
      mfile << ", ";
  }
  mfile << ")\n";
  mfile << "%\t\tArgument description:\n";
  pIter = orderedProperties.begin();
  unsigned int iOpt(0);
  for (; pIter != pEnd; ++pIter) {
    Mantid::Kernel::Property *prop = *pIter;
    mfile << "%\t\tName: " << prop->name() << ", Optional: ";
    if (prop->isValid() == "") {
      ++iOpt;
      mfile << "Yes, Default value: " << santizePropertyValue(prop->value());
    } else
      mfile << "No";
    mfile << ", Direction: "
          << Mantid::Kernel::Direction::asText(prop->direction()); // << ", ";
    auto allowed = prop->allowedValues();
    if (!allowed.empty()) {
      mfile << ", Allowed values: ";
      auto sIter = allowed.begin();
      auto sEnd = allowed.end();
      for (; sIter != sEnd;) {
        mfile << (*sIter);
        if (++sIter != sEnd)
          mfile << ", ";
      }
    }
    mfile << "\n";
  }
  mfile << "%\n%\tNote: All string arguments must be wrapped in single quotes "
           "''.\n";

  // The function definition
  mfile << "if nargin < " << (orderedProperties.size() - iOpt) << "\n"
        << "\tfprintf('All mandatory arguments have not been supplied, type "
           "\"help " << algName << "\" for more information\\n');\n"
        << "\treturn\n"
        << "end\n";

  mfile << "alg = MantidAlgorithm('" << algName << "');\n"
        << "argstring = '';\n";
  // Build arguments list
  mfile << "for i = 1:nargin\n"
        << "\targstring = strcat(argstring,varargin{i});\n"
        << "\tif i < nargin\n"
        << "\t\targstring = strcat(argstring, ';');\n"
        << "\tend\n"
        << "end\n";
  // Run the algorithm
  mfile << "res = run(alg, argstring);\n";
  mfile.close();
}
Esempio n. 14
0
/**
 * Reimplemented virtual function to set up the dialog
 */
void LoadRawDialog::initLayout() {
  QVBoxLayout *main_layout = new QVBoxLayout(this);

  // Add the helpful summary message
  if (isMessageAvailable())
    this->addOptionalMessage(main_layout);

  //------------- Filename property ---------------------
  QHBoxLayout *prop_line = new QHBoxLayout;
  prop_line->addWidget(new QLabel("Select a file to load:"));

  m_pathBox = new QLineEdit;
  m_pathBox->setMinimumWidth(m_pathBox->fontMetrics().maxWidth() * 13);
  prop_line->addWidget(m_pathBox);
  tie(m_pathBox, "Filename", prop_line);

  QPushButton *browseBtn = new QPushButton("Browse");
  connect(browseBtn, SIGNAL(clicked()), this, SLOT(browseClicked()));
  browseBtn->setEnabled(isWidgetEnabled("Filename"));
  prop_line->addWidget(browseBtn);

  main_layout->addLayout(prop_line);

  //------------- OutputWorkspace property ---------------------
  m_wsBox = new QLineEdit;

  prop_line = new QHBoxLayout;
  prop_line->addWidget(new QLabel("Enter name for workspace:"));
  prop_line->addWidget(m_wsBox);
  tie(m_wsBox, "OutputWorkspace", prop_line);
  prop_line->addStretch();
  main_layout->addLayout(prop_line);

  //------------- Spectra properties ---------------------
  QGroupBox *groupbox = new QGroupBox("Spectra Options");
  prop_line = new QHBoxLayout;

  QLineEdit *text_field = new QLineEdit;
  text_field->setMaximumWidth(m_wsBox->fontMetrics().width("888888"));
  prop_line->addWidget(new QLabel("Start:"));
  prop_line->addWidget(text_field);
  tie(text_field, "SpectrumMin", prop_line);

  text_field = new QLineEdit;
  text_field->setMaximumWidth(m_wsBox->fontMetrics().width("888888"));
  prop_line->addWidget(new QLabel("End:"));
  prop_line->addWidget(text_field);
  tie(text_field, "SpectrumMax", prop_line);

  text_field = new QLineEdit;
  prop_line->addWidget(new QLabel("List:"));
  prop_line->addWidget(text_field);
  tie(text_field, "SpectrumList", prop_line);

  prop_line->addStretch();
  groupbox->setLayout(prop_line);
  main_layout->addWidget(groupbox);

  //------------- Period properties ---------------------
  prop_line = new QHBoxLayout;
  text_field = new QLineEdit;
  prop_line->addWidget(new QLabel("Periods:"));
  prop_line->addWidget(text_field);
  prop_line->addStretch();
  tie(text_field, "PeriodList", prop_line);

  main_layout->addLayout(prop_line);

  //------------- Cache option , log files options and Monitors Options
  //---------------------

  Mantid::Kernel::Property *cacheProp = getAlgorithmProperty("Cache");
  if (cacheProp) {
    QComboBox *cacheBox = new QComboBox;
    std::vector<std::string> items = cacheProp->allowedValues();
    std::vector<std::string>::const_iterator vend = items.end();
    for (std::vector<std::string>::const_iterator vitr = items.begin();
         vitr != vend; ++vitr) {
      cacheBox->addItem(QString::fromStdString(*vitr));
    }
    prop_line = new QHBoxLayout;
    prop_line->addWidget(new QLabel("Cache file locally:"), 0, Qt::AlignRight);
    prop_line->addWidget(cacheBox, 0, Qt::AlignLeft);
    tie(cacheBox, "Cache", prop_line);
  }

  prop_line->addStretch();
  // If the algorithm version supports the LoadLog property add a check box for
  // it
  Mantid::Kernel::Property *loadlogs = getAlgorithmProperty("LoadLogFiles");
  if (loadlogs) {
    QCheckBox *checkbox = new QCheckBox("Load Log Files", this);
    prop_line->addWidget(checkbox);
    tie(checkbox, "LoadLogFiles", prop_line);
  }
  prop_line->addStretch();
  //------------- If the algorithm version supports the LoadMonitors property
  // add a check box for it ----
  Mantid::Kernel::Property *loadMonitors = getAlgorithmProperty("LoadMonitors");
  if (loadMonitors) {
    QComboBox *monitorsBox = new QComboBox;
    std::vector<std::string> monitoritems = loadMonitors->allowedValues();
    std::vector<std::string>::const_iterator mend = monitoritems.end();
    for (std::vector<std::string>::const_iterator mitr = monitoritems.begin();
         mitr != mend; ++mitr) {
      monitorsBox->addItem(QString::fromStdString(*mitr));
    }
    prop_line->addWidget(new QLabel("LoadMonitors:"), 0, Qt::AlignRight);
    prop_line->addWidget(monitorsBox);
    tie(monitorsBox, "LoadMonitors", prop_line);
  }

  if (prop_line)
    main_layout->addLayout(prop_line);

  // Buttons
  main_layout->addLayout(createDefaultButtonLayout("?", "Load", "Cancel"));
}