FunctionTreeView.cpp

// 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/FunctionTreeView.h"
#include "MantidQtWidgets/Common/FunctionBrowser/FunctionBrowserUtils.h"

#include "MantidAPI/CompositeFunction.h"
#include "MantidAPI/Expression.h"
#include "MantidAPI/FunctionFactory.h"
#include "MantidAPI/IConstraint.h"
#include "MantidAPI/MultiDomainFunction.h"
#include "MantidAPI/ParameterTie.h"

#include "MantidKernel/Logger.h"

#include "MantidQtWidgets/Common/EditLocalParameterDialog.h"
#include "MantidQtWidgets/Common/InterfaceManager.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/DoubleDialogEditor.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/FilenameDialogEditor.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/FormulaDialogEditor.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/WorkspaceEditorFactory.h"
#include "MantidQtWidgets/Common/SelectFunctionDialog.h"
#include "MantidQtWidgets/Common/UserFunctionDialog.h"

#include "MantidQtWidgets/Common/QtPropertyBrowser/CompositeEditorFactory.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/DoubleEditorFactory.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/qteditorfactory.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/qtpropertymanager.h"
#include "MantidQtWidgets/Common/QtPropertyBrowser/qttreepropertybrowser.h"

#include <QApplication>
#include <QClipboard>
#include <QFileInfo>
#include <QGridLayout>
#include <QHBoxLayout>
#include <QInputDialog>
#include <QMenu>
#include <QMessageBox>
#include <QMetaMethod>
#include <QPushButton>
#include <QSettings>
#include <QSignalMapper>
#include <QTreeWidget>
#include <QVBoxLayout>

#include <algorithm>
#include <boost/lexical_cast.hpp>
#include <regex>
#include <utility>

using namespace Mantid::API;

namespace {
const char *globalOptionName = "Global";
Mantid::Kernel::Logger g_log("Function Browser");
const std::regex PREFIX_REGEX("(^[f][0-9](.*))");
inline bool variableIsPrefixed(const std::string &name) { return std::regex_match(name, PREFIX_REGEX); }

QString insertPrefix(const QString &param) {
  return param.left(param.indexOf(".") + 1) + "f0." + param.right(param.size() - param.indexOf(".") - 1);
}

QString addPrefix(const QString &param) { return "f0." + param; }

QString removeEmbeddedPrefix(const QString &param) {
  if (variableIsPrefixed(param.toStdString())) {
    const auto paramSplit = param.split(".");
    return paramSplit[0] + "." + paramSplit[paramSplit.size() - 1];
  } else {
    return param;
  }
}

QString removePrefix(const QString &param) {
  if (variableIsPrefixed(param.toStdString())) {
    const auto paramSplit = param.split(".");
    return paramSplit[paramSplit.size() - 1];
  } else {
    return param;
  }
}

bool containsOneOf(std::string const &str, std::string const &delimiters) {
  return !str.empty() && str.find_first_of(delimiters) != std::string::npos;
}

// These attributes require the function to be fully reconstructed, as a
// different number of properties will be required
const std::vector<QString> REQUIRESRECONSTRUCTIONATTRIBUTES = {QString("n")};
} // namespace

namespace MantidQt {
namespace MantidWidgets {

/**
 * Constructor
 * @param parent :: The parent widget.
 * @param multi  :: Option to use the browser for multi-dataset fitting.
 * @param categories :: Function categories to be included to the Add Function
 * dialog. An empty vector means include all available categories.
 */
FunctionTreeView::FunctionTreeView(QWidget *parent, bool multi, std::vector<std::string> categories)
    : IFunctionView(parent), m_multiDataset(multi), m_multiDomainFunctionPrefix(),
      m_allowedCategories(std::move(categories)), m_selectFunctionDialog(nullptr)

{
  // create m_browser
  createBrowser();
  createActions();

  QVBoxLayout *layout = new QVBoxLayout(this);
  layout->setContentsMargins(0, 0, 0, 0);
  layout->addWidget(m_browser);
}

/**
 * Destructor
 */
FunctionTreeView::~FunctionTreeView() {
  m_browser->unsetFactoryForManager(m_parameterManager);
  m_browser->unsetFactoryForManager(m_attributeStringManager);
  m_browser->unsetFactoryForManager(m_attributeDoubleManager);
  m_browser->unsetFactoryForManager(m_attributeIntManager);
  m_browser->unsetFactoryForManager(m_attributeBoolManager);
  m_browser->unsetFactoryForManager(m_indexManager);
  m_browser->unsetFactoryForManager(m_tieManager);
  m_browser->unsetFactoryForManager(m_constraintManager);
  m_browser->unsetFactoryForManager(m_filenameManager);
  m_browser->unsetFactoryForManager(m_formulaManager);
  m_browser->unsetFactoryForManager(m_workspaceManager);
  m_browser->unsetFactoryForManager(m_attributeSizeManager);
  m_browser->unsetFactoryForManager(m_attributeVectorDoubleManager);
}

/**
 * Create the Qt property browser and set up property managers.
 */
void FunctionTreeView::createBrowser() {
  QStringList options;
  if (m_multiDataset) {
    options << globalOptionName;
  }
  m_browser = new QtTreePropertyBrowser(this, options);

  /* Create property managers: they create, own properties, get and set values
   */
  m_functionManager = new QtGroupPropertyManager(this);
  m_parameterManager = new ParameterPropertyManager(this);
  m_attributeStringManager = new QtStringPropertyManager(this);
  m_attributeDoubleManager = new QtDoublePropertyManager(this);
  m_attributeIntManager = new QtIntPropertyManager(this);
  m_attributeBoolManager = new QtBoolPropertyManager(this);
  m_indexManager = new QtStringPropertyManager(this);
  m_tieManager = new QtStringPropertyManager(this);
  m_constraintManager = new QtDoublePropertyManager(this);
  m_filenameManager = new QtStringPropertyManager(this);
  m_formulaManager = new QtStringPropertyManager(this);
  m_workspaceManager = new QtStringPropertyManager(this);
  m_attributeVectorManager = new QtGroupPropertyManager(this);
  m_attributeSizeManager = new QtIntPropertyManager(this);
  m_attributeVectorDoubleManager = new QtDoublePropertyManager(this);

  // create editor factories
  QtSpinBoxFactory *spinBoxFactory = new QtSpinBoxFactory(this);
  DoubleEditorFactory *doubleEditorFactory = new DoubleEditorFactory(this);
  ParameterEditorFactory *paramEditorFactory = new ParameterEditorFactory(this);

  QtAbstractEditorFactory<ParameterPropertyManager> *parameterEditorFactory(nullptr);
  if (m_multiDataset) {
    m_doubleEditorFactory = new DoubleDialogEditorFactory(this);
    auto compositeFactory = new CompositeEditorFactory<ParameterPropertyManager>(this, m_doubleEditorFactory);
    compositeFactory->setSecondaryFactory(globalOptionName, paramEditorFactory);
    parameterEditorFactory = compositeFactory;
    connect(m_doubleEditorFactory, SIGNAL(buttonClicked(QtProperty *)), this,
            SLOT(parameterButtonClicked(QtProperty *)));
    connect(m_doubleEditorFactory, SIGNAL(closeEditor()), m_browser, SLOT(closeEditor()));
  } else {
    parameterEditorFactory = paramEditorFactory;
  }

  QtLineEditFactory *lineEditFactory = new QtLineEditFactory(this);
  QtCheckBoxFactory *checkBoxFactory = new QtCheckBoxFactory(this);
  FilenameDialogEditorFactory *filenameDialogEditorFactory = new FilenameDialogEditorFactory(this);
  FormulaDialogEditorFactory *formulaDialogEditFactory = new FormulaDialogEditorFactory(this);
  WorkspaceEditorFactory *workspaceEditorFactory = new WorkspaceEditorFactory(this);

  // assign factories to property managers
  m_browser->setFactoryForManager(m_parameterManager, parameterEditorFactory);
  m_browser->setFactoryForManager(m_attributeStringManager, lineEditFactory);
  m_browser->setFactoryForManager(m_attributeDoubleManager, doubleEditorFactory);
  m_browser->setFactoryForManager(m_attributeIntManager, spinBoxFactory);
  m_browser->setFactoryForManager(m_attributeBoolManager, checkBoxFactory);
  m_browser->setFactoryForManager(m_indexManager, lineEditFactory);
  m_browser->setFactoryForManager(m_tieManager, lineEditFactory);
  m_browser->setFactoryForManager(m_constraintManager, doubleEditorFactory);
  m_browser->setFactoryForManager(m_filenameManager, filenameDialogEditorFactory);
  m_browser->setFactoryForManager(m_formulaManager, formulaDialogEditFactory);
  m_browser->setFactoryForManager(m_workspaceManager, workspaceEditorFactory);
  m_browser->setFactoryForManager(m_attributeSizeManager, spinBoxFactory);
  m_browser->setFactoryForManager(m_attributeVectorDoubleManager, doubleEditorFactory);

  m_browser->setContextMenuPolicy(Qt::CustomContextMenu);
  connect(m_browser, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(popupMenu(const QPoint &)));
  connect(m_browser, SIGNAL(optionChanged(QtProperty *, const QString &, bool)), this,
          SLOT(globalChanged(QtProperty *, const QString &, bool)));

  connect(m_attributeStringManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(attributeChanged(QtProperty *)));
  connect(m_attributeDoubleManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(attributeChanged(QtProperty *)));
  connect(m_attributeIntManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(attributeChanged(QtProperty *)));
  connect(m_attributeBoolManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(attributeChanged(QtProperty *)));
  connect(m_formulaManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(attributeChanged(QtProperty *)));
  connect(m_filenameManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(attributeChanged(QtProperty *)));
  connect(m_workspaceManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(attributeChanged(QtProperty *)));
  connect(m_attributeVectorDoubleManager, SIGNAL(propertyChanged(QtProperty *)), this,
          SLOT(attributeVectorDoubleChanged(QtProperty *)));
  connect(m_attributeSizeManager, SIGNAL(propertyChanged(QtProperty *)), this,
          SLOT(attributeVectorSizeChanged(QtProperty *)));
  connect(m_tieManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(tieChanged(QtProperty *)));
  connect(m_constraintManager, SIGNAL(propertyChanged(QtProperty *)), this, SLOT(constraintChanged(QtProperty *)));
  connect(m_parameterManager, SIGNAL(valueChanged(QtProperty *, double)), SLOT(parameterPropertyChanged(QtProperty *)));

  connect(m_browser, SIGNAL(currentItemChanged(QtBrowserItem *)), SLOT(updateCurrentFunctionIndex()));

  m_browser->setFocusPolicy(Qt::StrongFocus);
}

/**
 * Create and connect actions
 */
void FunctionTreeView::createActions() {
  m_actionAddFunction = new QAction("Add function", this);
  m_actionAddFunction->setObjectName("add_function");
  connect(m_actionAddFunction, SIGNAL(triggered()), this, SLOT(addFunctionBegin()));

  m_actionRemoveFunction = new QAction("Remove function", this);
  m_actionRemoveFunction->setObjectName("remove_function");
  connect(m_actionRemoveFunction, SIGNAL(triggered()), this, SLOT(removeFunction()));

  m_actionFixParameter = new QAction("Fix", this);
  connect(m_actionFixParameter, SIGNAL(triggered()), this, SLOT(fixParameter()));

  m_actionRemoveTie = new QAction("Remove tie", this);
  connect(m_actionRemoveTie, SIGNAL(triggered()), this, SLOT(removeTie()));

  m_actionAddTie = new QAction("Add tie", this);
  connect(m_actionAddTie, SIGNAL(triggered()), this, SLOT(addTie()));

  m_actionFromClipboard = new QAction("Paste from clipboard", this);
  m_actionFromClipboard->setObjectName("paste_from_clipboard");
  connect(m_actionFromClipboard, SIGNAL(triggered()), this, SLOT(pasteFromClipboard()));

  m_actionToClipboard = new QAction("Copy to clipboard", this);
  m_actionToClipboard->setObjectName("copy_to_clipboard");
  connect(m_actionToClipboard, SIGNAL(triggered()), this, SLOT(copyToClipboard()));

  m_actionConstraints = new QAction("Custom", this);
  connect(m_actionConstraints, SIGNAL(triggered()), this, SLOT(addConstraints()));

  m_actionConstraints10 = new QAction("10%", this);
  connect(m_actionConstraints10, SIGNAL(triggered()), this, SLOT(addConstraints10()));

  m_actionConstraints50 = new QAction("50%", this);
  connect(m_actionConstraints50, SIGNAL(triggered()), this, SLOT(addConstraints50()));

  m_actionRemoveConstraints = new QAction("Remove constraints", this);
  connect(m_actionRemoveConstraints, SIGNAL(triggered()), this, SLOT(removeConstraints()));

  m_actionRemoveConstraint = new QAction("Remove", this);
  connect(m_actionRemoveConstraint, SIGNAL(triggered()), this, SLOT(removeConstraint()));

  m_actionFunctionHelp = new QAction("Help", this);
  connect(m_actionFunctionHelp, SIGNAL(triggered()), this, SIGNAL(functionHelpRequest()));

  setErrorsEnabled(false);
}

/**
 * Clear the contents
 */
void FunctionTreeView::clear() {
  m_browser->clear();
  m_properties.clear();
}

/**
 * Set the function in the browser
 * @param fun :: A function
 */
void FunctionTreeView::setFunction(Mantid::API::IFunction_sptr fun) {
  clear();
  if (fun) {
    addFunction(nullptr, fun);
  }
}

/**
 * Add a sub-property to a parent property
 * @param parent :: The parent property
 * @param subproperty :: New sub-property
 */
FunctionTreeView::AProperty FunctionTreeView::addProperty(QtProperty *parent, QtProperty *subproperty) {
  AProperty ap;
  ap.prop = subproperty;
  if (parent == nullptr) {
    ap.item = m_browser->addProperty(subproperty);
  } else {
    parent->addSubProperty(subproperty);
    auto items = m_browser->items(subproperty);
    if (items.isEmpty()) {
      throw std::runtime_error("Unexpected error in FunctionTreeView [1]");
    }
    ap.item = items[0];
  }
  ap.parent = parent;
  m_properties[subproperty] = ap;
  return ap;
}

/**
 * Remove and delete property
 * @param prop :: Property to remove.
 */
void FunctionTreeView::removeProperty(QtProperty *prop) {
  auto p = m_properties.find(prop);
  if (p == m_properties.end())
    return;
  AProperty ap = *p;

  // remove references to the children
  auto children = prop->subProperties();
  foreach (QtProperty *child, children) { removeProperty(child); }
  m_properties.erase(p);

  if (isFunction(prop)) {
    m_ties.remove(prop);
  }

  if (isTie(prop)) { //
    for (auto it = m_ties.begin(); it != m_ties.end(); ++it) {
      if (it.value().tieProp == prop) {
        m_ties.erase(it);
        break;
      }
    }
  }

  if (isConstraint(prop)) {
    for (auto it = m_constraints.begin(); it != m_constraints.end(); ++it) {
      auto &cp = it.value();
      if (cp.lower == prop) {
        if (!cp.upper) {
          m_constraints.erase(it);
        } else {
          cp.lower = nullptr;
        }
        break;
      } else if (cp.upper == prop) {
        if (!cp.lower) {
          m_constraints.erase(it);
        } else {
          cp.upper = nullptr;
        }
        break;
      }
    }
  }

  // remove property from Qt browser
  if (ap.parent) {
    ap.parent->removeSubProperty(prop);
  } else {
    m_browser->removeProperty(prop);
  }
  delete prop;
}

/**
 * Add a function property
 * @param parent :: Parent function property or NULL
 * @param funName :: Function name
 * @return :: A set AProperty struct
 */
FunctionTreeView::AProperty FunctionTreeView::addFunctionProperty(QtProperty *parent, const QString &funName) {
  // check that parent is a function property
  if (parent && dynamic_cast<QtAbstractPropertyManager *>(m_functionManager) != parent->propertyManager()) {
    throw std::runtime_error("Unexpected error in FunctionTreeView [2]");
  }
  QtProperty *prop = m_functionManager->addProperty(funName);
  return addProperty(parent, prop);
}

/**
 * Add a parameter property
 * @param parent :: Parent function property
 * @param paramName :: Parameter name
 * @param paramDesc :: Parameter description
 * @param paramValue :: Parameter value
 */
FunctionTreeView::AProperty FunctionTreeView::addParameterProperty(QtProperty *parent, const QString &paramName,
                                                                   const QString &paramDesc, double paramValue) {
  // check that parent is a function property
  if (!parent || dynamic_cast<QtAbstractPropertyManager *>(m_functionManager) != parent->propertyManager()) {
    throw std::runtime_error("Unexpected error in FunctionTreeView [3]");
  }
  QtProperty *prop = m_parameterManager->addProperty(paramName);
  m_parameterManager->blockSignals(true);
  m_parameterManager->setDecimals(prop, 6);
  m_parameterManager->setValue(prop, paramValue);
  m_parameterManager->setDescription(prop, paramDesc.toStdString());
  m_parameterManager->blockSignals(false);

  if (m_multiDataset) {
    prop->setOption(globalOptionName, false);
  }
  return addProperty(parent, prop);
}

/**
 * Set a function.
 * @param prop :: Property of the function or NULL
 * @param fun :: A function
 */
void FunctionTreeView::setFunction(QtProperty *prop, const Mantid::API::IFunction_sptr &fun) {
  auto children = prop->subProperties();
  foreach (QtProperty *child, children) { removeProperty(child); }
  // m_localParameterValues.clear();
  if (!m_multiDomainFunctionPrefix.isEmpty())
    addMultiDomainIndexProperty(prop);
  addAttributeAndParameterProperties(prop, fun);
}

/**
 * Add a function.
 * @param prop :: Property of the parent composite function or NULL
 * @param fun :: A function to add
 */
bool FunctionTreeView::addFunction(QtProperty *prop, const Mantid::API::IFunction_sptr &fun) {
  if (!fun)
    return false;
  if (!prop) {
    AProperty ap = addFunctionProperty(nullptr, QString::fromStdString(fun->name()));
    setFunction(ap.prop, fun);
  } else {
    Mantid::API::IFunction_sptr parentFun = getFunction(prop);
    if (!parentFun)
      return false;
    auto cf = std::dynamic_pointer_cast<Mantid::API::CompositeFunction>(parentFun);
    if (!cf) {
      throw std::logic_error("FunctionTreeView: CompositeFunction is expected for addFunction");
    }
    try {
      cf->addFunction(fun);
    } catch (const std::exception &e) {
      QMessageBox::warning(this, "Mantid - Warning", QString("Cannot Add function:\n\n%1").arg(e.what()));
      return false;
    }
    setFunction(prop, cf);
  }
  updateFunctionIndices();
  return true;
}

/**
 * Attribute visitor to create a QtProperty. Depending on the attribute type
 * the appropriate apply() method is used.
 */
class CreateAttributePropertyForFunctionTreeView
    : public Mantid::API::IFunction::ConstAttributeVisitor<FunctionTreeView::AProperty> {
public:
  CreateAttributePropertyForFunctionTreeView(FunctionTreeView *browser, QtProperty *parent, const QString &attName)
      : m_browser(browser), m_parent(parent), m_attName(attName) {
    // check that parent is a function property
    if (!m_parent ||
        dynamic_cast<QtAbstractPropertyManager *>(m_browser->m_functionManager) != m_parent->propertyManager()) {
      throw std::runtime_error("Unexpected error in FunctionTreeView [4]");
    }
  }

protected:
  /// Create string property
  FunctionTreeView::AProperty apply(const std::string &str) const override {
    QtProperty *prop = nullptr;
    if (m_attName.indexOf("FileName") != -1) {
      m_browser->m_filenameManager->blockSignals(true);
      prop = m_browser->m_filenameManager->addProperty(m_attName);
      m_browser->m_filenameManager->setValue(prop, QString::fromStdString(str));
      m_browser->m_filenameManager->blockSignals(false);
    } else if (m_attName.indexOf("Formula") != -1) {
      m_browser->m_formulaManager->blockSignals(true);
      prop = m_browser->m_formulaManager->addProperty(m_attName);
      m_browser->m_formulaManager->setValue(prop, QString::fromStdString(str));
      m_browser->m_formulaManager->blockSignals(false);
    } else if (m_attName.indexOf("Workspace") != -1) {
      m_browser->m_workspaceManager->blockSignals(true);
      prop = m_browser->m_workspaceManager->addProperty(m_attName);
      m_browser->m_workspaceManager->setValue(prop, QString::fromStdString(str));
      m_browser->m_workspaceManager->blockSignals(false);
    } else {
      m_browser->m_attributeStringManager->blockSignals(true);
      prop = m_browser->m_attributeStringManager->addProperty(m_attName);
      m_browser->m_attributeStringManager->setValue(prop, QString::fromStdString(str));
      m_browser->m_attributeStringManager->blockSignals(false);
    }
    return m_browser->addProperty(m_parent, prop);
  }
  /// Create double property
  FunctionTreeView::AProperty apply(const double &d) const override {
    m_browser->m_attributeDoubleManager->blockSignals(true);
    QtProperty *prop = m_browser->m_attributeDoubleManager->addProperty(m_attName);
    m_browser->m_attributeDoubleManager->setValue(prop, d);
    m_browser->m_attributeDoubleManager->blockSignals(false);
    return m_browser->addProperty(m_parent, prop);
  }
  /// Create int property
  FunctionTreeView::AProperty apply(const int &i) const override {
    m_browser->m_attributeIntManager->blockSignals(true);
    QtProperty *prop = m_browser->m_attributeIntManager->addProperty(m_attName);
    m_browser->m_attributeIntManager->setValue(prop, i);
    m_browser->m_attributeIntManager->blockSignals(false);
    return m_browser->addProperty(m_parent, prop);
  }
  /// Create bool property
  FunctionTreeView::AProperty apply(const bool &b) const override {
    m_browser->m_attributeBoolManager->blockSignals(true);
    QtProperty *prop = m_browser->m_attributeBoolManager->addProperty(m_attName);
    m_browser->m_attributeBoolManager->setValue(prop, b);
    m_browser->m_attributeBoolManager->blockSignals(false);
    return m_browser->addProperty(m_parent, prop);
  }
  /// Create vector property
  FunctionTreeView::AProperty apply(const std::vector<double> &v) const override {
    QtProperty *prop = m_browser->m_attributeVectorManager->addProperty(m_attName);
    FunctionTreeView::AProperty aprop = m_browser->addProperty(m_parent, prop);

    m_browser->m_attributeSizeManager->blockSignals(true);
    QtProperty *sizeProp = m_browser->m_attributeSizeManager->addProperty("Size");
    m_browser->m_attributeSizeManager->setValue(sizeProp, static_cast<int>(v.size()));
    m_browser->addProperty(prop, sizeProp);
    m_browser->m_attributeSizeManager->blockSignals(false);
    sizeProp->setEnabled(false);

    m_browser->m_attributeVectorDoubleManager->blockSignals(true);
    QString parName = "value[%1]";
    for (size_t i = 0; i < v.size(); ++i) {
      QtProperty *dprop = m_browser->m_attributeVectorDoubleManager->addProperty(parName.arg(i));
      m_browser->m_attributeVectorDoubleManager->setValue(dprop, v[i]);
      m_browser->addProperty(prop, dprop);
    }
    m_browser->m_attributeVectorDoubleManager->blockSignals(false);

    m_browser->m_browser->setExpanded(aprop.item, false);
    return aprop;
  }

private:
  FunctionTreeView *m_browser;
  QtProperty *m_parent;
  QString m_attName;
};

/**
 * Attribute visitor to set an attribute from a QtProperty. Depending on the
 * attribute type
 * the appropriate apply() method is used.
 */
class SetAttributeFromProperty : public Mantid::API::IFunction::AttributeVisitor<> {
public:
  SetAttributeFromProperty(FunctionTreeView *browser, QtProperty *prop) : m_browser(browser), m_prop(prop) {}

protected:
  /// Set string attribute
  void apply(std::string &str) const override {
    QString attName = m_prop->propertyName();
    if (attName == "FileName") {
      str = m_browser->m_filenameManager->value(m_prop).toStdString();
    } else if (attName == "Formula") {
      str = m_browser->m_formulaManager->value(m_prop).toStdString();
    } else if (attName == "Workspace") {
      str = m_browser->m_workspaceManager->value(m_prop).toStdString();
    } else {
      str = m_browser->m_attributeStringManager->value(m_prop).toStdString();
    }
  }
  /// Set double attribute
  void apply(double &d) const override { d = m_browser->m_attributeDoubleManager->value(m_prop); }
  /// Set int attribute
  void apply(int &i) const override { i = m_browser->m_attributeIntManager->value(m_prop); }
  /// Set bool attribute
  void apply(bool &b) const override { b = m_browser->m_attributeBoolManager->value(m_prop); }
  /// Set vector attribute
  void apply(std::vector<double> &v) const override {
    QList<QtProperty *> members = m_prop->subProperties();
    if (members.empty())
      throw std::runtime_error("FunctionTreeView: empty vector attribute group.");
    int n = members.size() - 1;
    if (n == 0) {
      v.clear();
      return;
    }
    v.resize(n);
    for (int i = 0; i < n; ++i) {
      v[i] = m_browser->m_attributeVectorDoubleManager->value(members[i + 1]);
    }
  }

private:
  FunctionTreeView *m_browser;
  QtProperty *m_prop;
};

/**
 * Add a attribute property
 * @param parent :: Parent function property
 * @param attName :: Attribute name
 * @param att :: Attribute value
 */
FunctionTreeView::AProperty FunctionTreeView::addAttributeProperty(QtProperty *parent, const QString &attName,
                                                                   const Mantid::API::IFunction::Attribute &att) {
  CreateAttributePropertyForFunctionTreeView cap(this, parent, attName);
  return att.apply(cap);
}

/**
 * Add attribute and parameter properties to a function property. For a
 * composite function
 *  adds all member functions' properties
 * @param prop :: A function property
 * @param fun :: Shared pointer to a created function
 * @param parentComposite :: If relevant, the composite the function is part of.
 * @param parentIndex :: If relevant, the index of the function within its
 * composite.
 */
void FunctionTreeView::addAttributeAndParameterProperties(QtProperty *prop, const IFunction_sptr &fun,
                                                          const CompositeFunction_sptr &parentComposite,
                                                          const std::size_t &parentIndex) {
  // add the function index property
  addIndexProperty(prop);

  // add attribute properties
  auto attributeNames = fun->getAttributeNames();
  for (const auto &att : attributeNames) {
    if (!variableIsPrefixed(att)) {
      QString attName = QString::fromStdString(att);
      addAttributeProperty(prop, attName, fun->getAttribute(att));
    }
  }

  auto cf = std::dynamic_pointer_cast<Mantid::API::CompositeFunction>(fun);
  if (cf) {
    // if composite add members
    for (size_t i = 0; i < cf->nFunctions(); ++i) {
      AProperty ap = addFunctionProperty(prop, QString::fromStdString(cf->getFunction(i)->name()));
      addAttributeAndParameterProperties(ap.prop, cf->getFunction(i), cf, i);
    }
  } else { // if simple add parameters
    for (size_t i = 0; i < fun->nParams(); ++i) {
      QString name = QString::fromStdString(fun->parameterName(i));
      QString desc = QString::fromStdString(fun->parameterDescription(i));
      double value = fun->getParameter(i);
      AProperty ap = addParameterProperty(prop, name, desc, value);
      // if parameter has a tie
      if (!fun->isActive(i))
        addParameterTie(ap.prop, fun, name.toStdString(), i, parentComposite, parentIndex);
      else
        addGlobalParameterTie(ap.prop, name.toStdString(), parentComposite, parentIndex);

      if (const auto constraint = fun->getConstraint(i)) {
        addConstraintProperties(ap.prop, QString::fromStdString(constraint->asString()));
      }
    }
  }
}

/**
 * Add a tie to a function property. If the tie is stored within the wider
 * composite function, it will find this tie and apply it.
 * @param property :: A function property.
 * @param function :: Shared pointer to the function.
 * @param parameterName :: The name of the parameter to be tied.
 * @param parameterIndex :: The index of the parameter within its function.
 * @param parentComposite :: If relevant, the composite the function is part of.
 * @param parentIndex :: If relevant, the index of the function within its
 * composite.
 */
void FunctionTreeView::addParameterTie(QtProperty *property, const IFunction_sptr &function,
                                       const std::string &parameterName, const std::size_t &parameterIndex,
                                       const CompositeFunction_sptr &parentComposite, const std::size_t &parentIndex) {
  if (const auto tie = function->getTie(parameterIndex)) {
    addTieProperty(property, QString::fromStdString(tie->asString()));
  } else {
    auto tieAdded = false;
    if (parentComposite)
      tieAdded = addParameterTieInComposite(property, parameterName, parentComposite, parentIndex);

    if (!tieAdded)
      addTieProperty(property, QString::number(function->getParameter(parameterIndex)));
  }
}

/**
 * Add a tie to a function property. Used if a tie is stored within the wider
 * composite function.
 * @param property :: A function property.
 * @param parameterName :: The name of the parameter to be tied.
 * @param composite :: The composite function containing the tie.
 * @param index :: The index of the function within the composite function.
 * @returns true if a tie was found, and a tie property was added.
 */
bool FunctionTreeView::addParameterTieInComposite(QtProperty *property, const std::string &parameterName,
                                                  const CompositeFunction_sptr &composite, const std::size_t &index) {
  for (auto i = 0u; i < composite->nParams(); ++i) {
    const auto fullName = "f" + std::to_string(index) + "." + parameterName;
    if (fullName == composite->parameterName(i)) {
      if (const auto tie = composite->getTie(i)) {
        const auto tieStr = QString::fromStdString(tie->asString());
        addTieProperty(property, tieStr.mid(tieStr.indexOf('=') + 1));
        return true;
      }
      return false;
    }
  }
  return false;
}

/**
 * Add a global tie to a function property if one exists for the specified
 * parameter.
 * @param property :: A function property.
 * @param parameterName :: The name of the parameter to check for a global tie.
 * @param parentComposite :: The composite function the parameter is in. This is
 * a nullptr if the parameter is not in a composite function.
 * @param parentIndex :: The index of the parameter within its composite.
 */
void FunctionTreeView::addGlobalParameterTie(QtProperty *property, const std::string &parameterName,
                                             const CompositeFunction_sptr &parentComposite,
                                             const std::size_t &parentIndex) {
  if (m_multiDomainFunctionPrefix.isEmpty() || m_globalTies.empty())
    return;

  auto const fullName = getFullParameterName(parameterName, parentComposite ? static_cast<int>(parentIndex) : -1);

  for (auto const &globalTie : m_globalTies) {
    if (fullName == globalTie.m_parameter) {
      addTieProperty(property, QString::fromStdString(globalTie.m_tie), true);
      break;
    }
  }
}

/**
 * Adds a property showing the function index of a domain within a
 * MultiDomainFunction. It is used when we don't want to display an entire
 * MultiDomainFunction, just a specific function within it.
 * @param prop :: The property to add the function index on to.
 */
void FunctionTreeView::addMultiDomainIndexProperty(QtProperty *prop) {
  QtProperty *indexProperty = m_indexManager->addProperty("Index");
  indexProperty->setEnabled(false);
  m_indexManager->setValue(indexProperty, m_multiDomainFunctionPrefix);
  (void)addProperty(prop, indexProperty);
}

/**
 * Add property showing function's index in the composite function
 * @param prop :: A function property
 * @return :: AProperty struct for added property. If all fields are NULL -
 * property wasn't added
 *  because it is the top function
 */
FunctionTreeView::AProperty FunctionTreeView::addIndexProperty(QtProperty *prop) {
  AProperty ap;
  ap.item = nullptr;
  ap.parent = nullptr;
  ap.prop = nullptr;
  if (!prop)
    return ap;
  if (!isFunction(prop))
    return ap;
  if (!m_properties[prop].parent)
    return ap;

  QString index = "fff";
  QtProperty *ip = m_indexManager->addProperty("Index");
  ip->setEnabled(false);
  m_indexManager->setValue(ip, index);
  auto retval = addProperty(prop, ip);
  updateFunctionIndices();
  return retval;
}

/**
 * Update function index properties
 * @param prop :: A function property
 * @param index :: The parent function's index
 */
void FunctionTreeView::updateFunctionIndices(QtProperty *prop, const QString &index) {
  if (prop == nullptr) {
    auto top = m_browser->properties();
    if (top.isEmpty())
      return;
    prop = top[0];
  }
  auto children = prop->subProperties();
  size_t i = 0;
  foreach (QtProperty *child, children) {
    if (isFunction(child)) {
      updateFunctionIndices(child, index + "f" + QString::number(i) + ".");
      ++i;
    } else if (isIndex(child)) {
      m_indexManager->setValue(child, m_multiDomainFunctionPrefix + index);
    }
  }
}

/**
 * Get property of the overall function.
 */
FunctionTreeView::AProperty FunctionTreeView::getFunctionProperty() const {
  auto props = m_browser->properties();
  if (props.isEmpty()) {
    AProperty ap;
    ap.item = nullptr;
    ap.parent = nullptr;
    ap.prop = nullptr;
    return ap;
  }
  QtProperty *prop = props[0];
  return m_properties[prop];
}

/**
 * Check if property is a function group
 * @param prop :: Property to check
 */
bool FunctionTreeView::isFunction(QtProperty *prop) const {
  return prop && dynamic_cast<QtAbstractPropertyManager *>(m_functionManager) == prop->propertyManager();
}

/**
 * Check if property is any of the string attributes
 * @param prop :: Property to check
 */
bool FunctionTreeView::isStringAttribute(QtProperty *prop) const {
  return prop && (dynamic_cast<QtAbstractPropertyManager *>(m_attributeStringManager) == prop->propertyManager() ||
                  dynamic_cast<QtAbstractPropertyManager *>(m_formulaManager) == prop->propertyManager() ||
                  dynamic_cast<QtAbstractPropertyManager *>(m_filenameManager) == prop->propertyManager() ||
                  dynamic_cast<QtAbstractPropertyManager *>(m_workspaceManager) == prop->propertyManager());
}

/**
 * Check if property is a function attribute
 * @param prop :: Property to check
 */
bool FunctionTreeView::isDoubleAttribute(QtProperty *prop) const {
  return prop && dynamic_cast<QtAbstractPropertyManager *>(m_attributeDoubleManager) == prop->propertyManager();
}

/**
 * Check if property is a function attribute
 * @param prop :: Property to check
 */
bool FunctionTreeView::isIntAttribute(QtProperty *prop) const {
  return prop && dynamic_cast<QtAbstractPropertyManager *>(m_attributeIntManager) == prop->propertyManager();
}

/**
 * Check if property is a function bool attribute
 * @param prop :: Property to check
 */
bool FunctionTreeView::isBoolAttribute(QtProperty *prop) const {
  return prop && dynamic_cast<QtAbstractPropertyManager *>(m_attributeBoolManager) == prop->propertyManager();
}

/**
 * Check if property is a function vector attribute
 * @param prop :: Property to check
 */
bool FunctionTreeView::isVectorAttribute(QtProperty *prop) const {
  return prop && dynamic_cast<QtAbstractPropertyManager *>(m_attributeVectorManager) == prop->propertyManager();
}

/**
 * Check if property is a function attribute
 * @param prop :: Property to check
 */
bool FunctionTreeView::isAttribute(QtProperty *prop) const {
  return isStringAttribute(prop) || isDoubleAttribute(prop) || isIntAttribute(prop) || isBoolAttribute(prop) ||
         isVectorAttribute(prop);
}

/**
 * Check if property is a function parameter
 * @param prop :: Property to check
 */
bool FunctionTreeView::isParameter(QtProperty *prop) const {
  return prop && dynamic_cast<QtAbstractPropertyManager *>(m_parameterManager) == prop->propertyManager();
}

/**
 * Get parameter value as a string
 * @param prop :: A parameter property
 */
double FunctionTreeView::getParameter(QtProperty *prop) const { return m_parameterManager->value(prop); }
/**
 * Check if a property is an index
 * @param prop :: A property
 */
bool FunctionTreeView::isIndex(QtProperty *prop) const {
  return prop && dynamic_cast<QtAbstractPropertyManager *>(m_indexManager) == prop->propertyManager();
}

/**
 * Get the function index for a property
 * @param prop :: A property
 */
QString FunctionTreeView::getIndex(QtProperty *prop) const {
  if (!prop)
    return "";
  if (isFunction(prop)) {
    auto props = prop->subProperties();
    if (props.isEmpty())
      return "";
    for (auto it = props.begin(); it != props.end(); ++it) {
      if (isIndex(*it)) {
        return m_indexManager->value(*it);
      }
    }
    return "";
  }

  auto ap = m_properties[prop];
  return getIndex(ap.parent);
}

/**
 * Get name of the parameter for a property
 * @param prop :: A property
 */
QString FunctionTreeView::getParameterName(QtProperty *prop) const {
  if (isParameter(prop)) {
    return getIndex(prop) + prop->propertyName();
  } else {
    auto parent = getParentParameterProperty(prop);
    return getIndex(prop) + parent->propertyName();
  }
}
/**
 * Get name of the attribute for a property
 * @param prop :: A property
 */
QString FunctionTreeView::getAttributeName(QtProperty *prop) const {
  if (isAttribute(prop)) {
    return getIndex(prop) + prop->propertyName();
  }
  throw std::logic_error("QtProperty " + prop->propertyName().toStdString() + " is not an attribute property.");
}

/**
 * Return function property for a function with given index.
 * @param index :: Function index to search, or empty string for top-level
 * function
 * @return Function property, or NULL if not found
 */
QtProperty *FunctionTreeView::getFunctionProperty(const QString &index) const {
  // Might not be the most efficient way to do it. m_functionManager might be
  // searched instead,
  // but it is not being kept up-to-date at the moment (is not cleared).
  foreach (auto property, m_properties.keys()) {
    if (isFunction(property) && getIndex(property) == index) {
      return property;
    }
  }

  // No function with such index
  return nullptr;
}

/**
 * Add a tie property
 * @param prop :: Parent parameter property
 * @param tie :: A tie string
 * @param globalTie :: true if the tie is a global tie.
 */
void FunctionTreeView::addTieProperty(QtProperty *prop, const QString &tie, bool globalTie) {
  if (!prop) {
    throw std::runtime_error("FunctionTreeView: null property pointer");
  }

  if (!isParameter(prop))
    return;

  QtProperty *funProp = getFunctionProperty().prop;

  // Create and add a QtProperty for the tie.
  m_tieManager->blockSignals(true);
  QtProperty *tieProp = m_tieManager->addProperty("Tie");
  m_tieManager->setValue(tieProp, globalTie ? tie : getFullTie(tie));