FitPropertyBrowser.cpp

    if (ix >= static_cast<int>(columns.size())) {
      QMessageBox::critical(nullptr, "Mantid - Error",
                            "X column was not found.");
      return boost::shared_ptr<Mantid::API::Workspace>();
    }
    auto xcol = tws->getColumn(columns[ix]);

    // get the y column
    int iy = m_columnManager->value(m_yColumn);
    if (iy >= static_cast<int>(columns.size())) {
      QMessageBox::critical(nullptr, "Mantid - Error",
                            "Y column was not found.");
      return boost::shared_ptr<Mantid::API::Workspace>();
    }
    auto ycol = tws->getColumn(columns[iy]);

    // get the err column
    int ie =
        m_columnManager->value(m_errColumn) - 1; // first entry is empty string
    if (ie >= 0 && ie >= static_cast<int>(columns.size())) {
      QMessageBox::critical(nullptr, "Mantid - Error",
                            "Error column was not found.");
      return boost::shared_ptr<Mantid::API::Workspace>();
    }
    auto ecol =
        ie < 0 ? Mantid::API::Column_sptr() : tws->getColumn(columns[ie]);

    // create the MatrixWorkspace
    Mantid::API::MatrixWorkspace_sptr mws =
        Mantid::API::WorkspaceFactory::Instance().create("Workspace2D", 1,
                                                         rowCount, rowCount);
    auto &X = mws->mutableX(0);
    auto &Y = mws->mutableY(0);
    auto &E = mws->mutableE(0);

    for (size_t row = 0; row < rowCount; ++row) {
      X[row] = xcol->toDouble(row);
      Y[row] = ycol->toDouble(row);
      E[row] = ecol ? ecol->toDouble(row) : 1.0;
    }

    return mws;
  } catch (std::exception &e) {
    QMessageBox::critical(nullptr, "Mantid - Error", e.what());
    return boost::shared_ptr<Mantid::API::Workspace>();
  }
}

/**
 * Do the fit.
 */
void FitPropertyBrowser::fit() {
  int maxIterations = m_intManager->value(m_maxIterations);
  doFit(maxIterations);
}

/**=================================================================================================
 * Slot connected to the change signals of properties m_xColumn, m_yColumn, and
 * m_errColumn.
 * @param prop :: Property that changed.
 */
void FitPropertyBrowser::columnChanged(QtProperty *prop) {
  if (prop == m_xColumn) { // update startX and endX
    try {
      auto ws = Mantid::API::AnalysisDataService::Instance().retrieve(
          workspaceName());
      auto tws = boost::dynamic_pointer_cast<Mantid::API::ITableWorkspace>(ws);
      if (!tws)
        return;
      int i = m_columnManager->value(m_xColumn);
      if (i < 0 || i >= static_cast<int>(tws->rowCount()) ||
          tws->rowCount() == 0)
        return;
      auto col = tws->getColumn(static_cast<size_t>(i));
      const double startX = col->toDouble(0);
      const double endX = col->toDouble(tws->rowCount() - 1);
      m_doubleManager->setValue(m_startX, startX);
      m_doubleManager->setValue(m_endX, endX);
    } catch (...) {
      // do nothing
    }
  }
}

/**=================================================================================================
 * Called when the minimizer changes. Creates minimizes's properties.
 */
void FitPropertyBrowser::minimizerChanged() {
  // delete old minimizer properties
  foreach (QtProperty *prop, m_minimizerProperties) {
    m_settingsGroup->property()->removeSubProperty(prop);
  }

  // add new minimizer properties
  auto minzer = Mantid::API::FuncMinimizerFactory::Instance().createMinimizer(
      this->minimizer());
  auto &properties = minzer->getProperties();
  for (auto it = properties.begin(); it != properties.end(); ++it) {
    QString propName = QString::fromStdString((**it).name());
    QtProperty *prop = nullptr;
    if (auto prp =
            dynamic_cast<Mantid::Kernel::PropertyWithValue<bool> *>(*it)) {
      prop = m_boolManager->addProperty(propName);
      bool val = *prp;
      m_boolManager->setValue(prop, val);
    } else if (auto prp =
                   dynamic_cast<Mantid::Kernel::PropertyWithValue<double> *>(
                       *it)) {
      prop = this->addDoubleProperty(propName);
      double val = *prp;
      m_doubleManager->setValue(prop, val);
    } else if (auto prp =
                   dynamic_cast<Mantid::Kernel::PropertyWithValue<int> *>(
                       *it)) {
      prop = m_intManager->addProperty(propName);
      int val = *prp;
      m_intManager->setValue(prop, val);
    } else if (auto prp =
                   dynamic_cast<Mantid::Kernel::PropertyWithValue<size_t> *>(
                       *it)) {
      prop = m_intManager->addProperty(propName);
      size_t val = *prp;
      m_intManager->setValue(prop, static_cast<int>(val));
    } else if (auto prp = dynamic_cast<
                   Mantid::Kernel::PropertyWithValue<std::string> *>(*it)) {
      prop = m_stringManager->addProperty(propName);
      QString val = QString::fromStdString(prp->value());
      m_stringManager->setValue(prop, val);
    } else if (dynamic_cast<Mantid::API::IWorkspaceProperty *>(*it)) {
      prop = m_stringManager->addProperty(propName);
      m_stringManager->setValue(prop, QString::fromStdString((**it).value()));
    } else {
      QMessageBox::warning(this, "MantidPlot - Error",
                           "Type of minimizer's property " + propName +
                               " is not yet supported by the browser.");
      continue;
    }

    if (!prop)
      continue;
    // set the tooltip from property doc string
    QString toolTip = QString::fromStdString((**it).documentation());
    if (!toolTip.isEmpty()) {
      prop->setToolTip(toolTip);
    }
    m_settingsGroup->property()->addSubProperty(prop);
    m_minimizerProperties.append(prop);
  }
}

/**=================================================================================================
 * Get function parameter values
 */
QList<double> FitPropertyBrowser::getParameterValues() const {
  auto fun = theFunction();
  size_t np = fun->nParams();
  QList<double> out;
  for (size_t i = 0; i < np; ++i) {
    const double parValue = fun->getParameter(i);
    out.append(parValue);
  }
  return out;
}

/**=================================================================================================
 * Get parameter names
 */
QStringList FitPropertyBrowser::getParameterNames() const {
  auto fun = theFunction();
  size_t np = fun->nParams();
  QStringList out;
  for (size_t i = 0; i < np; ++i) {
    std::string parName = fun->parameterName(i);
    out.append(QString::fromStdString(parName));
  }
  return out;
}

/**=================================================================================================
 * Show online function help
 */
void FitPropertyBrowser::functionHelp() {
  PropertyHandler *handler = currentHandler();
  if (handler) {
    MantidQt::API::HelpWindow::showFitFunction(this->nativeParentWidget(),
                                               handler->ifun()->name());
  }
}

/**=================================================================================================
 * Show online browser help
 */
void FitPropertyBrowser::browserHelp() {
  MantidDesktopServices::openUrl(
      QUrl("http://www.mantidproject.org/"
           "MantidPlot:_Simple_Peak_Fitting_with_the_Fit_"
           "Wizard#Fit_Properties_Browser"));
}

/**=================================================================================================
 * Allow/disallow sequential fits, depending on whether other conditions are met
 * @param allow :: [input] Allow or disallow
 */
void FitPropertyBrowser::allowSequentialFits(bool allow) {
  if (m_fitActionSeqFit) {
    if (allow) {
      m_fitActionSeqFit->setEnabled(m_compositeFunction->nFunctions() > 0);
    } else {
      m_fitActionSeqFit->setEnabled(false);
    }
  }
}

void FitPropertyBrowser::modifyFitMenu(QAction *fitAction, bool enabled) {
  if (enabled) {
    m_fitMenu->addAction(fitAction);
  } else {
    m_fitMenu->removeAction(fitAction);
  }
}
} // namespace MantidWidgets
} // namespace MantidQt