/**
* 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);
}
}
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();
}
/**
* 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();
}
/**
* 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"));
}