FunctionTreeView.h

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 +
#pragma once
 
#include "DllOption.h"
 
#include "MantidAPI/CompositeFunction.h"
#include "MantidAPI/IFunction_fwd.h"
#include "MantidKernel/EmptyValues.h"
#include "MantidQtWidgets/Common/FittingGlobals.h"
#include "MantidQtWidgets/Common/IFunctionView.h"
 
#include <QMap>
#include <QRect>
#include <QStringList>
#include <QWidget>
 
/* Forward declarations */
 
class QtTreePropertyBrowser;
class QtGroupPropertyManager;
class QtDoublePropertyManager;
class QtIntPropertyManager;
class QtBoolPropertyManager;
class QtStringPropertyManager;
class QtEnumPropertyManager;
class QtProperty;
class QtBrowserItem;
class ParameterPropertyManager;
class DoubleDialogEditorFactory;
 
class QPushButton;
class QLabel;
class QLineEdit;
class QComboBox;
class QSignalMapper;
class QMenu;
class QAction;
class QTreeWidget;
class QTreeWidgetItem;
 
namespace Mantid {
namespace API {
class Workspace;
class ParameterTie;
} // namespace API
} // namespace Mantid
 
namespace MantidQt {
namespace MantidWidgets {
 
class CreateAttributePropertyForFunctionTreeView;
class SelectFunctionDialog;
struct GlobalTie;
 
class EXPORT_OPT_MANTIDQT_COMMON FunctionTreeView : public IFunctionView {
  Q_OBJECT
public:
  struct AProperty {
    QtProperty *prop;
    QtBrowserItem *item;
    QtProperty *parent;
  };
  struct ATie {
    QtProperty *paramProp; 
    QString paramName;     
    QtProperty *tieProp;   
  };
  struct AConstraint {
    QtProperty *paramProp; 
    QtProperty *lower;     
    QtProperty *upper;     
  };
 
  FunctionTreeView(QWidget *parent, bool multi, std::vector<std::string> categories = std::vector<std::string>());
  ~FunctionTreeView() override;
  void clear() override;
  void setFunction(Mantid::API::IFunction_sptr fun) override;
  bool hasFunction() const override;
  void setParameter(const QString &paramName, double value) override;
  void setParameterError(const QString &paramName, double error) override;
  double getParameter(const QString &paramName) const override;
  IFunction::Attribute getAttribute(const QString &attrName) const override;
  void setErrorsEnabled(bool enabled) override;
  void clearErrors() override;
  boost::optional<QString> currentFunctionIndex() const override;
  void setParameterTie(const QString &paramName, const QString &tie) override;
  void setParameterConstraint(const QString &paramName, const QString &constraint) override;
  void setGlobalParameters(const QStringList &) override;
  QStringList getGlobalParameters() const;
 
  IFunction_sptr getSelectedFunction() override;
  void showFunctionHelp(const QString &functionName) const override;
 
  Mantid::API::IFunction_sptr getFunction(QtProperty *prop = nullptr, bool attributesOnly = false);
  void setColumnSizes(int s0, int s1, int s2 = -1);
  void setStretchLastColumn(bool stretch);
 
  // Hide global boxes
  void hideGlobals();
  // Show global boxes
  void showGlobals();
 
  // Sets the function prefix of a domain to be displayed within a
  // MultiDomainFunction
  void setMultiDomainFunctionPrefix(const QString &functionPrefix);
  // Sets the global ties to be displayed within a MultiDomainFunction
  void setGlobalTies(std::vector<GlobalTie> const &globalTies);
 
protected:
  void createBrowser();
  void createActions();
  AProperty addProperty(QtProperty *parent, QtProperty *subproperty);
  void removeProperty(QtProperty *prop);
  void setFunction(QtProperty *prop, const Mantid::API::IFunction_sptr &fun);
  bool addFunction(QtProperty *prop, const Mantid::API::IFunction_sptr &fun);
  AProperty addFunctionProperty(QtProperty *parent, const QString &funName);
  AProperty addParameterProperty(QtProperty *parent, const QString &paramName, const QString &paramDesc,
                                 double paramValue);
  AProperty addAttributeProperty(QtProperty *parent, const QString &attName,
                                 const Mantid::API::IFunction::Attribute &att);
  void addAttributeAndParameterProperties(QtProperty *prop, const Mantid::API::IFunction_sptr &fun,
                                          const Mantid::API::CompositeFunction_sptr &parentComposite = nullptr,
                                          const std::size_t &parentIndex = 0);
  void addParameterTie(QtProperty *property, const Mantid::API::IFunction_sptr &function,
                       const std::string &parameterName, const std::size_t &parameterIndex,
                       const Mantid::API::CompositeFunction_sptr &parentComposite = nullptr,
                       const std::size_t &parentIndex = 0);
  bool addParameterTieInComposite(QtProperty *property, const std::string &parameterName,
                                  const Mantid::API::CompositeFunction_sptr &composite, const std::size_t &index);
  void addGlobalParameterTie(QtProperty *property, const std::string &parameterName,
                             const CompositeFunction_sptr &parentComposite = nullptr,
                             const std::size_t &parentIndex = 0);
  void addMultiDomainIndexProperty(QtProperty *prop);
  AProperty addIndexProperty(QtProperty *prop);
  void updateFunctionIndices(QtProperty *prop = nullptr, const QString &index = "");
  AProperty getFunctionProperty() const;
  bool isFunction(QtProperty *prop) const;
  bool isAttribute(QtProperty *prop) const;
  bool isStringAttribute(QtProperty *prop) const;
  bool isDoubleAttribute(QtProperty *prop) const;
  bool isIntAttribute(QtProperty *prop) const;
  bool isBoolAttribute(QtProperty *prop) const;
  bool isVectorAttribute(QtProperty *prop) const;
  bool isParameter(QtProperty *prop) const;
  double getParameter(QtProperty *prop) const;
  bool isIndex(QtProperty *prop) const;
  QString getIndex(QtProperty *prop) const;
  QString getParameterName(QtProperty *prop) const;
  QString getAttributeName(QtProperty *prop) const;
  QtProperty *getFunctionProperty(const QString &index) const;
  QtProperty *getParameterProperty(const QString &paramName) const;
  QtProperty *getAttributeProperty(const QString &paramName) const;
  QtProperty *getParentParameterProperty(QtProperty *prop) const;
  QtProperty *getTieProperty(QtProperty *prop) const;
 
  void addTieProperty(QtProperty *prop, const QString &tie, bool globalTie = false);
  bool hasTie(QtProperty *prop) const;
  bool isTie(QtProperty *prop) const;
  QString getTie(QtProperty *prop) const;
 
  QList<AProperty> addConstraintProperties(QtProperty *prop, const QString &constraint);
  bool isConstraint(QtProperty *prop) const;
  bool hasConstraint(QtProperty *prop) const;
  bool hasLowerBound(QtProperty *prop) const;
  bool hasUpperBound(QtProperty *prop) const;
  QString getConstraint(const QString &paramName, const double &lowerBound = Mantid::EMPTY_DBL(),
                        const double &upperBound = Mantid::EMPTY_DBL()) const;
  std::pair<QString, QString> getFunctionAndConstraint(QtProperty *prop) const;
 
protected slots:
  void popupMenu(const QPoint &);
  void addFunctionBegin();
  void addFunctionEnd(int result);
  void removeFunction();
  void fixParameter();
  void removeTie();
  void addTie();
  void pasteFromClipboard();
  void copyToClipboard();
  void addConstraints();
  void removeConstraints();
  void addConstraints10();
  void addConstraints50();
  void removeConstraint();
  void updateCurrentFunctionIndex();
  //   Property change slots
  void attributeChanged(QtProperty *);
  void attributeVectorDoubleChanged(QtProperty *);
  void attributeVectorSizeChanged(QtProperty *);
  void parameterPropertyChanged(QtProperty *);
  void parameterButtonClicked(QtProperty *);
  void tieChanged(QtProperty *);
  void constraintChanged(QtProperty *);
  void globalChanged(QtProperty *, const QString &, bool);
  void setAttributeToFunction(Mantid::API::IFunction &fun, QtProperty *prop);
 
protected:
  void removeConstraintsQuiet(QtProperty *paramProp);
 
  DoubleDialogEditorFactory *m_doubleEditorFactory;
  QtGroupPropertyManager *m_functionManager;
  ParameterPropertyManager *m_parameterManager;
  QtStringPropertyManager *m_attributeStringManager;
  QtDoublePropertyManager *m_attributeDoubleManager;
  QtIntPropertyManager *m_attributeIntManager;
  QtBoolPropertyManager *m_attributeBoolManager;
  QtStringPropertyManager *m_indexManager;
  QtStringPropertyManager *m_tieManager;
  QtDoublePropertyManager *m_constraintManager;
  QtStringPropertyManager *m_filenameManager;
  QtStringPropertyManager *m_formulaManager;
  QtStringPropertyManager *m_workspaceManager;
  QtGroupPropertyManager *m_attributeVectorManager;
  QtDoublePropertyManager *m_attributeVectorDoubleManager;
  QtIntPropertyManager *m_attributeSizeManager;
 
  QtTreePropertyBrowser *m_browser;
  QMap<QtProperty *, AProperty> m_properties;
  QMultiMap<QtProperty *, ATie> m_ties;
  QMultiMap<QtProperty *, AConstraint> m_constraints;
 
  //   Actions
 
  QAction *m_actionAddFunction;
  QAction *m_actionRemoveFunction;
  QAction *m_actionFixParameter;
  QAction *m_actionRemoveTie;
  QAction *m_actionAddTie;
  QAction *m_actionFromClipboard;
  QAction *m_actionToClipboard;
  QAction *m_actionConstraints10;
  QAction *m_actionConstraints50;
  QAction *m_actionConstraints;
  QAction *m_actionRemoveConstraints;
  QAction *m_actionRemoveConstraint;
  QAction *m_actionFunctionHelp;
  boost::optional<QString> m_currentFunctionIndex;
  bool m_multiDataset;
  QString m_multiDomainFunctionPrefix;
  // A vector of global ties. E.g. f0.f0.A0=f1.f0.A0
  std::vector<GlobalTie> m_globalTies;
  std::vector<std::string> m_allowedCategories;
  SelectFunctionDialog *m_selectFunctionDialog;
  QtProperty *m_selectedFunctionProperty;
  bool m_emitParameterValueChange = true;
  bool m_emitAttributeValueChange = true;
 
  friend class CreateAttributePropertyForFunctionTreeView;
  friend class SetAttributeFromProperty;
 
private:
  void setDoubleAttribute(const QString &attrName, double value) override;
  void setIntAttribute(const QString &attrName, int value) override;
  void setStringAttribute(const QString &attrName, std::string &value) override;
  void setBooleanAttribute(const QString &attrName, bool value) override;
  void setVectorAttribute(const QString &attrName, std::vector<double> &val) override;
 
  QString getFullTie(const QString &tie) const;
  std::string getFullParameterName(const std::string &parameter, int compositeIndex = -1) const;
 
  // Intended for testing only
  QTreeWidgetItem *getPropertyWidgetItem(QtProperty *prop) const;
  QRect visualItemRect(QtProperty *prop) const;
 
public:
  // Intended for testing only
  int getNumberOfQtProperties() const { return m_properties.size(); }
  int getNumberOfTieProperties() const { return m_ties.size(); }
  int getNumberOfConstraintProperties() const { return m_constraints.size(); }
  QRect getVisualRectFunctionProperty(const QString &index) const;
  QRect getVisualRectParameterProperty(const QString &paramName) const;
  QTreeWidget *treeWidget() const;
  QtTreePropertyBrowser *treeBrowser();
  DoubleDialogEditorFactory *doubleEditorFactory();
  QWidget *getParamWidget(const QString &paramName) const;
};
 
} // namespace MantidWidgets
} // namespace MantidQt