EnggDiffractionViewQtGUI.cpp

    MantidQt::API::AlgorithmInputHistory::Instance().setPreviousDirectory(
        filename);
  }

  return filename.toStdString();
}

void EnggDiffractionViewQtGUI::loadCalibrationClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::LoadExistingCalib);
}

void EnggDiffractionViewQtGUI::calibrateClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::CalcCalib);
}

void EnggDiffractionViewQtGUI::CroppedCalibrateClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::CropCalib);
}

void EnggDiffractionViewQtGUI::focusClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::FocusRun);
}

void EnggDiffractionViewQtGUI::focusCroppedClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::FocusCropped);
}

void EnggDiffractionViewQtGUI::focusTextureClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::FocusTexture);
}

void EnggDiffractionViewQtGUI::focusResetClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::ResetFocus);
}

void EnggDiffractionViewQtGUI::focusStopClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::StopFocus);
}

void EnggDiffractionViewQtGUI::rebinTimeClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::RebinTime);
}

void EnggDiffractionViewQtGUI::rebinMultiperiodClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::RebinMultiperiod);
}

void EnggDiffractionViewQtGUI::fitClicked() {
  m_presenter->notify(IEnggDiffractionPresenter::FitPeaks);
}

void EnggDiffractionViewQtGUI::browseInputDirCalib() {
  QString prevPath = QString::fromStdString(m_calibSettings.m_inputDirCalib);
  if (prevPath.isEmpty()) {
    prevPath =
        MantidQt::API::AlgorithmInputHistory::Instance().getPreviousDirectory();
  }
  QString dir = QFileDialog::getExistingDirectory(
      this, tr("Open Directory"), prevPath,
      QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);

  if (dir.isEmpty()) {
    return;
  }

  MantidQt::API::AlgorithmInputHistory::Instance().setPreviousDirectory(dir);
  m_calibSettings.m_inputDirCalib = dir.toStdString();
  m_uiTabSettings.lineEdit_input_dir_calib->setText(
      QString::fromStdString(m_calibSettings.m_inputDirCalib));
}

void EnggDiffractionViewQtGUI::browseInputDirRaw() {
  QString prevPath = QString::fromStdString(m_calibSettings.m_inputDirRaw);
  if (prevPath.isEmpty()) {
    prevPath =
        MantidQt::API::AlgorithmInputHistory::Instance().getPreviousDirectory();
  }
  QString dir = QFileDialog::getExistingDirectory(
      this, tr("Open Directory"), prevPath,
      QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);

  if (dir.isEmpty()) {
    return;
  }

  MantidQt::API::AlgorithmInputHistory::Instance().setPreviousDirectory(dir);
  m_calibSettings.m_inputDirRaw = dir.toStdString();
  m_uiTabSettings.lineEdit_input_dir_raw->setText(
      QString::fromStdString(m_calibSettings.m_inputDirRaw));
}

void EnggDiffractionViewQtGUI::browsePixelCalibFilename() {
  QString prevPath = QString::fromStdString(m_calibSettings.m_inputDirCalib);
  if (prevPath.isEmpty()) {
    QString prevPath =
        MantidQt::API::AlgorithmInputHistory::Instance().getPreviousDirectory();
  }

  QString filename = QFileDialog::getOpenFileName(
      this, tr("Open pixel calibration (full calibration) file"), prevPath,
      QString::fromStdString(g_pixelCalibExt));

  if (filename.isEmpty()) {
    return;
  }

  m_calibSettings.m_pixelCalibFilename = filename.toStdString();
  m_uiTabSettings.lineEdit_pixel_calib_filename->setText(
      QString::fromStdString(m_calibSettings.m_pixelCalibFilename));
}

void EnggDiffractionViewQtGUI::browseTemplateGSAS_PRM() {

  QString prevPath = QString::fromStdString(m_calibSettings.m_templateGSAS_PRM);
  QString path(QFileDialog::getOpenFileName(
      this, tr("Open GSAS IPAR template file"), prevPath,
      QString::fromStdString(g_iparmExtStr)));

  if (path.isEmpty()) {
    return;
  }

  m_calibSettings.m_templateGSAS_PRM = path.toStdString();
  m_uiTabSettings.lineEdit_template_gsas_prm->setText(
      QString::fromStdString(m_calibSettings.m_templateGSAS_PRM));
}

void EnggDiffractionViewQtGUI::browseDirFocusing() {
  QString prevPath = QString::fromStdString(m_focusDir);
  if (prevPath.isEmpty()) {
    prevPath =
        MantidQt::API::AlgorithmInputHistory::Instance().getPreviousDirectory();
  }
  QString dir = QFileDialog::getExistingDirectory(
      this, tr("Open Directory"), prevPath,
      QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);

  if (dir.isEmpty()) {
    return;
  }

  MantidQt::API::AlgorithmInputHistory::Instance().setPreviousDirectory(dir);
  m_focusDir = dir.toStdString();
  m_uiTabSettings.lineEdit_dir_focusing->setText(
      QString::fromStdString(m_focusDir));
}

void EnggDiffractionViewQtGUI::browseTextureDetGroupingFile() {
  QString prevPath = QString::fromStdString(m_calibSettings.m_inputDirRaw);
  if (prevPath.isEmpty()) {
    prevPath =
        MantidQt::API::AlgorithmInputHistory::Instance().getPreviousDirectory();
  }

  QString path(QFileDialog::getOpenFileName(
      this, tr("Open detector grouping file"), prevPath,
      QString::fromStdString(g_DetGrpExtStr)));

  if (path.isEmpty()) {
    return;
  }

  MantidQt::API::AlgorithmInputHistory::Instance().setPreviousDirectory(path);
  m_uiTabFocus.lineEdit_texture_grouping_file->setText(path);
}

void EnggDiffractionViewQtGUI::browseFitFocusedRun() {
  QString prevPath = QString::fromStdString(m_focusDir);
  if (prevPath.isEmpty()) {
    prevPath =
        MantidQt::API::AlgorithmInputHistory::Instance().getPreviousDirectory();
  }
  std::string nexusFormat = "Nexus file with calibration table: NXS, NEXUS"
                            "(*.nxs *.nexus);;";

  QString path(
      QFileDialog::getOpenFileName(this, tr("Open Focused File "), prevPath,
                                   QString::fromStdString(nexusFormat)));

  if (path.isEmpty()) {
    return;
  }

  MantidQt::API::AlgorithmInputHistory::Instance().setPreviousDirectory(path);
  setfittingRunNo(path);
  getBanks();
}

void EnggDiffractionViewQtGUI::browsePeaksToFit() {

  try {
    QString prevPath = QString::fromStdString(m_focusDir);
    if (prevPath.isEmpty()) {
      prevPath = MantidQt::API::AlgorithmInputHistory::Instance()
                     .getPreviousDirectory();
    }

    QString path(
        QFileDialog::getOpenFileName(this, tr("Open Peaks To Fit"), prevPath,
                                     QString::fromStdString(g_DetGrpExtStr)));

    if (path.isEmpty()) {
      return;
    }

    MantidQt::API::AlgorithmInputHistory::Instance().setPreviousDirectory(path);

    std::string peaksData = readPeaksFile(path.toStdString());

    m_uiTabFitting.lineEdit_fitting_peaks->setText(
        QString::fromStdString(peaksData));
  } catch (...) {
    userWarning("Unable to import the peaks from a file: ",
                "File corrupted or could not be opened. Please try again");
    return;
  }
}

std::vector<std::string> EnggDiffractionViewQtGUI::focusingRunNo() const {
  return qListToVector(m_uiTabFocus.MWRunFiles_run_num->getFilenames(),
                       m_uiTabFocus.MWRunFiles_run_num->isValid());
}

std::vector<std::string>
EnggDiffractionViewQtGUI::focusingCroppedRunNo() const {
  return qListToVector(m_uiTabFocus.MWRunFiles_cropped_run_num->getFilenames(),
                       m_uiTabFocus.MWRunFiles_cropped_run_num->isValid());
}

std::vector<std::string>
EnggDiffractionViewQtGUI::focusingTextureRunNo() const {
  return qListToVector(m_uiTabFocus.MWRunFiles_texture_run_num->getFilenames(),
                       m_uiTabFocus.MWRunFiles_texture_run_num->isValid());
}

std::vector<std::string>
EnggDiffractionViewQtGUI::qListToVector(QStringList list,
                                        bool validator) const {
  std::vector<std::string> vec;
  if (validator) {
    foreach (const QString &str, list) { vec.push_back(str.toStdString()); }
  }

  return vec;
}

std::string EnggDiffractionViewQtGUI::focusingDir() const {
  return m_uiTabSettings.lineEdit_dir_focusing->text().toStdString();
}

std::vector<bool> EnggDiffractionViewQtGUI::focusingBanks() const {
  std::vector<bool> res;
  res.push_back(m_uiTabFocus.checkBox_focus_bank1->isChecked());
  res.push_back(m_uiTabFocus.checkBox_focus_bank2->isChecked());
  return res;
}

std::string EnggDiffractionViewQtGUI::focusingCroppedSpectrumNos() const {
  return m_uiTabFocus.lineEdit_cropped_spec_nos->text().toStdString();
}

std::string EnggDiffractionViewQtGUI::focusingTextureGroupingFile() const {
  return m_uiTabFocus.lineEdit_texture_grouping_file->text().toStdString();
}

bool EnggDiffractionViewQtGUI::focusedOutWorkspace() const {
  return m_uiTabFocus.checkBox_plot_focused_ws->checkState();
}

bool EnggDiffractionViewQtGUI::plotCalibWorkspace() const {
  return m_uiTabCalib.checkBox_PlotData_Calib->checkState();
}

bool EnggDiffractionViewQtGUI::saveFocusedOutputFiles() const {
  return m_uiTabFocus.checkBox_save_output_files->checkState();
}

void EnggDiffractionViewQtGUI::plotFocusStatus() {
  if (focusedOutWorkspace()) {
    m_uiTabFocus.comboBox_PlotData->setEnabled(true);
  } else {
    m_uiTabFocus.comboBox_PlotData->setEnabled(false);
  }
}

void EnggDiffractionViewQtGUI::calibspecNoChanged(int /*idx*/) {
  QComboBox *BankName = m_uiTabCalib.comboBox_calib_cropped_bank_name;
  if (!BankName)
    return;
  m_currentCropCalibBankName = BankName->currentIndex();
}

void EnggDiffractionViewQtGUI::enableSpecNos() {
  if (m_currentCropCalibBankName == 0) {
    m_uiTabCalib.lineEdit_cropped_spec_nos->setEnabled(true);
    m_uiTabCalib.lineEdit_cropped_customise_bank_name->setEnabled(true);
  } else {
    m_uiTabCalib.lineEdit_cropped_spec_nos->setDisabled(true);
    m_uiTabCalib.lineEdit_cropped_customise_bank_name->setDisabled(true);
  }
}

std::string EnggDiffractionViewQtGUI::currentCalibSpecNos() const {
  return m_uiTabCalib.lineEdit_cropped_spec_nos->text().toStdString();
}

std::string EnggDiffractionViewQtGUI::currentCalibCustomisedBankName() const {
  return m_uiTabCalib.lineEdit_cropped_customise_bank_name->text()
      .toStdString();
}

void EnggDiffractionViewQtGUI::multiRunModeChanged(int /*idx*/) {
  QComboBox *plotType = m_uiTabFocus.comboBox_Multi_Runs;
  if (!plotType)
    return;
  m_currentRunMode = plotType->currentIndex();
}

void EnggDiffractionViewQtGUI::plotRepChanged(int /*idx*/) {
  QComboBox *plotType = m_uiTabFocus.comboBox_PlotData;
  if (!plotType)
    return;
  m_currentType = plotType->currentIndex();
}

void EnggDiffractionViewQtGUI::fittingBankIdChanged(int /*idx*/) {
  QComboBox *BankName = m_uiTabFitting.comboBox_bank;
  if (!BankName)
    return;
  m_fitting_bank_Id = BankName->currentIndex();
}

void EnggDiffractionViewQtGUI::setBankIdComboBox(int idx) {
  QComboBox *bankName = m_uiTabFitting.comboBox_bank;
  bankName->setCurrentIndex(idx);
}

void EnggDiffractionViewQtGUI::setfittingRunNo(QString path) {
  m_uiTabFitting.lineEdit_pushButton_run_num->setText(path);
}

std::string EnggDiffractionViewQtGUI::fittingRunNo() const {
  return m_uiTabFitting.lineEdit_pushButton_run_num->text().toStdString();
}

std::string EnggDiffractionViewQtGUI::fittingPeaksData() const {
  // this should be moved to Helper or could use the poco string tokenizers
  std::string exptPeaks =
      m_uiTabFitting.lineEdit_fitting_peaks->text().toStdString();
  size_t strLength = exptPeaks.length() - 1;

  if (!exptPeaks.empty()) {

    if (exptPeaks.at(size_t(0)) == ',') {
      exptPeaks.erase(size_t(0), 1);
      strLength -= size_t(1);
    }

    if (exptPeaks.at(strLength) == ',') {
      exptPeaks.erase(strLength, 1);
    }
  }
  return exptPeaks;
}

void EnggDiffractionViewQtGUI::fittingListWidgetBank(int /*idx*/) {

  QListWidget *BankSelected = m_uiTabFitting.listWidget_fitting_bank_preview;
  if (!BankSelected)
    return;
  m_fitting_bank_Id = BankSelected->currentRow();
}

void EnggDiffractionViewQtGUI::setListWidgetBank(int idx) {

  QListWidget *selectBank = m_uiTabFitting.listWidget_fitting_bank_preview;
  selectBank->setCurrentRow(idx);
}

void MantidQt::CustomInterfaces::EnggDiffractionViewQtGUI::
    fittingRunNoChanged() {
  // TODO: much of this should be moved to presenter
  try {
    QString focusedFile = m_uiTabFitting.lineEdit_pushButton_run_num->text();
    std::string strFocusedFile = focusedFile.toStdString();
    // file name
    Poco::Path selectedfPath(strFocusedFile);
    Poco::Path bankDir;

    // handling of vectors
    m_fitting_runno_dir_vec.clear();
    std::string strFPath = selectedfPath.toString();
    std::vector<std::string> splitBaseName = splitFittingDirectory(strFPath);

    if (selectedfPath.isFile() && !splitBaseName.empty()) {

#ifdef __unix__
      bankDir = selectedfPath.parent();
#else
      bankDir = (bankDir).expand(selectedfPath.parent().toString());
#endif

      if (!splitBaseName.empty() && splitBaseName.size() > 3) {
        std::string foc_file = splitBaseName[0] + "_" + splitBaseName[1] + "_" +
                               splitBaseName[2] + "_" + splitBaseName[3];
        std::string strBankDir = bankDir.toString();
        updateFittingDirVec(strBankDir, foc_file);
      }
      // if run number length greater
    } else if (focusedFile.count() > 4) {
      // if given a run number instead
      updateFittingDirVec(m_focusDir, strFocusedFile);
    } else {
      userWarning("Invalid Input", "Invalid directory or run number given. "
                                   "Please try again");
    }

    try {
      // add bank to the combo-box and list view
      addBankItems(splitBaseName, focusedFile);
    } catch (std::runtime_error &re) {
      userWarning("Unable to insert items: ",
                  "Could not add banks to "
                  "combo-box or list widget; " +
                      static_cast<std::string>(re.what()) +
                      ". Please try again");
    }
  } catch (std::runtime_error &re) {
    userWarning("Invalid file", "Unable to select the file; " +
                                    static_cast<std::string>(re.what()));
    return;
  }
}

void EnggDiffractionViewQtGUI::updateFittingDirVec(std::string &bankDir,
                                                   std::string &focusedFile) {

  try {

    std::string cwd(bankDir);
    Poco::DirectoryIterator it(cwd);
    Poco::DirectoryIterator end;
    while (it != end) {
      if (it->isFile()) {
        std::string itFilePath = it->path();
        Poco::Path itBankfPath(itFilePath);

        std::string itbankFileName = itBankfPath.getBaseName();
        // check if it not any other file.. e.g: texture
        if (itbankFileName.find(focusedFile) != std::string::npos) {
          m_fitting_runno_dir_vec.push_back(itFilePath);
        }
      }
      ++it;
    }
  } catch (std::runtime_error &re) {
    userWarning("Invalid file", "File not found in the following directory; " +
                                    bankDir + ". " +
                                    static_cast<std::string>(re.what()));
  }
}

std::vector<std::string>
EnggDiffractionViewQtGUI::splitFittingDirectory(std::string &selectedfPath) {

  Poco::Path PocofPath(selectedfPath);
  std::string selectedbankfName = PocofPath.getBaseName();
  std::vector<std::string> splitBaseName;
  if (selectedbankfName.find("ENGINX_") != std::string::npos) {
    boost::split(splitBaseName, selectedbankfName, boost::is_any_of("_."));
  }
  return splitBaseName;
}

void EnggDiffractionViewQtGUI::addBankItems(
    std::vector<std::string> splittedBaseName, QString selectedFile) {

  if (!m_fitting_runno_dir_vec.empty()) {

    // delete previous bank added to the list
    m_uiTabFitting.comboBox_bank->clear();
    m_uiTabFitting.listWidget_fitting_bank_preview->clear();

    for (size_t i = 0; i < m_fitting_runno_dir_vec.size(); i++) {
      Poco::Path vecFile(m_fitting_runno_dir_vec[i]);
      std::string strVecFile = vecFile.toString();
      // split the directory from m_fitting_runno_dir_vec
      std::vector<std::string> vecFileSplit = splitFittingDirectory(strVecFile);
      // assign the file bank id
      std::string bankID = (vecFileSplit[vecFileSplit.size() - 1]);

      bool isDigit = false;
      for (size_t i = 0; i < bankID.size(); i++) {
        char *str = &bankID[i];
        if (std::isdigit(*str)) {
          isDigit = true;
        }
      }

      if (isDigit) {
        m_uiTabFitting.comboBox_bank->addItem(QString::fromStdString(bankID));
        m_uiTabFitting.listWidget_fitting_bank_preview->addItem(
            QString::fromStdString(bankID));
      } else {
        m_uiTabFitting.comboBox_bank->addItem(QString("Bank %1").arg(i + 1));
        m_uiTabFitting.listWidget_fitting_bank_preview->addItem(
            QString("%1").arg(i + 1));
      }
    }
    m_uiTabFitting.comboBox_bank->setEnabled(true);
    m_uiTabFitting.listWidget_fitting_bank_preview->setEnabled(true);
  } else {
    // upon invalid file
    // disable the widgets when only one related file found
    m_uiTabFitting.comboBox_bank->setEnabled(false);
    m_uiTabFitting.listWidget_fitting_bank_preview->setEnabled(false);

    m_uiTabFitting.comboBox_bank->clear();
    m_uiTabFitting.listWidget_fitting_bank_preview->clear();
  }

  setDefaultBank(splittedBaseName, selectedFile);
}

void EnggDiffractionViewQtGUI::setDefaultBank(
    std::vector<std::string> splittedBaseName, QString selectedFile) {

  if (!splittedBaseName.empty()) {

    std::string bankID = (splittedBaseName[splittedBaseName.size() - 1]);
    auto combo_data =
        m_uiTabFitting.comboBox_bank->findText(QString::fromStdString(bankID));

    if (combo_data > -1) {
      setBankIdComboBox(combo_data);
    } else {
      setfittingRunNo(selectedFile);
    }
  } else {
    setfittingRunNo(selectedFile);
  }
}

void MantidQt::CustomInterfaces::EnggDiffractionViewQtGUI::setPeakPick() {
  auto bk2bk =
      FunctionFactory::Instance().createFunction("BackToBackExponential");
  auto bk2bkFunc = boost::dynamic_pointer_cast<IPeakFunction>(bk2bk);
  // set the peak to BackToBackExponential function
  setPeakPicker(bk2bkFunc);
  setPeakPickerEnabled(true);
}

void MantidQt::CustomInterfaces::EnggDiffractionViewQtGUI::addPeakToList() {

  if (m_peakPicker->isEnabled()) {
    auto peakCentre = getPeakCentre();

    std::stringstream stream;
    stream << std::fixed << std::setprecision(4) << peakCentre;
    auto strPeakCentre = stream.str();

    auto curExpPeaksList = m_uiTabFitting.lineEdit_fitting_peaks->text();

    if (!curExpPeaksList.isEmpty()) {

      std::string expPeakStr = curExpPeaksList.toStdString();
      std::string lastTwoChr = expPeakStr.substr(expPeakStr.size() - 2);
      auto lastChr = expPeakStr.back();
      char comma = ',';
      if (lastChr == comma || lastTwoChr == ", ") {
        curExpPeaksList.append(QString::fromStdString(" " + strPeakCentre));
      } else {
        QString comma = ", ";
        curExpPeaksList.append(comma + QString::fromStdString(strPeakCentre));
      }
      m_uiTabFitting.lineEdit_fitting_peaks->setText(curExpPeaksList);
    }
  }
}

void MantidQt::CustomInterfaces::EnggDiffractionViewQtGUI::savePeakList() {
  // call function in EnggPresenter..

  try {
    QString prevPath = QString::fromStdString(m_focusDir);
    if (prevPath.isEmpty()) {
      prevPath = MantidQt::API::AlgorithmInputHistory::Instance()
                     .getPreviousDirectory();
    }

    QString path(QFileDialog::getSaveFileName(
        this, tr("Save Expected Peaks List"), prevPath,
        QString::fromStdString(g_DetGrpExtStr)));

    if (path.isEmpty()) {
      return;
    }
    const std::string strPath = path.toStdString();
    fittingWriteFile(strPath);
  } catch (...) {
    userWarning("Unable to save the peaks file: ",
                "Invalid file path or or could not be saved. Please try again");
    return;
  }
}

void EnggDiffractionViewQtGUI::instrumentChanged(int /*idx*/) {
  QComboBox *inst = m_ui.comboBox_instrument;
  if (!inst)
    return;
  m_currentInst = inst->currentText().toStdString();
  m_presenter->notify(IEnggDiffractionPresenter::InstrumentChange);
}

void EnggDiffractionViewQtGUI::RBNumberChanged() {
  m_presenter->notify(IEnggDiffractionPresenter::RBNumberChange);
}

void EnggDiffractionViewQtGUI::userSelectInstrument(const QString &prefix) {
  // Set file browsing to current instrument
  setPrefix(prefix.toStdString());
}

void EnggDiffractionViewQtGUI::setPrefix(std::string prefix) {
  QString prefixInput = QString::fromStdString(prefix);
  // focus tab
  m_uiTabFocus.MWRunFiles_run_num->setInstrumentOverride(prefixInput);
  m_uiTabFocus.MWRunFiles_texture_run_num->setInstrumentOverride(prefixInput);

  // calibration tab
  m_uiTabCalib.MWRunFiles_new_ceria_num->setInstrumentOverride(prefixInput);
  m_uiTabCalib.MWRunFiles_new_vanadium_num->setInstrumentOverride(prefixInput);

  // rebin tab
  m_uiTabPreproc.MWRunFiles_preproc_run_num->setInstrumentOverride(prefixInput);
}

void EnggDiffractionViewQtGUI::closeEvent(QCloseEvent *event) {
  int answer = QMessageBox::AcceptRole;

  QMessageBox msgBox;
  if (false /* TODO: get this from user settings if eventually used */) {
    msgBox.setWindowTitle("Close the engineering diffraction interface");
    // with something like this, we'd have layout issues:
    // msgBox.setStandardButtons(QMessageBox::No | QMessageBox::Yes);
    // msgBox.setDefaultButton(QMessageBox::Yes);
    msgBox.setIconPixmap(QPixmap(":/win/unknown.png"));
    QCheckBox confirmCheckBox("Always ask for confirmation", &msgBox);
    confirmCheckBox.setCheckState(Qt::Checked);
    msgBox.layout()->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding));
    msgBox.layout()->addWidget(&confirmCheckBox);
    QPushButton *bYes = msgBox.addButton("Yes", QMessageBox::YesRole);
    bYes->setIcon(style()->standardIcon(QStyle::SP_DialogYesButton));
    QPushButton *bNo = msgBox.addButton("No", QMessageBox::NoRole);
    bNo->setIcon(style()->standardIcon(QStyle::SP_DialogNoButton));
    msgBox.setDefaultButton(bNo);
    msgBox.setText("You are about to close this interface");
    msgBox.setInformativeText("Are you sure?");
    answer = msgBox.exec();
  }

  if (answer == QMessageBox::AcceptRole && m_ui.pushButton_close->isEnabled()) {
    m_presenter->notify(IEnggDiffractionPresenter::ShutDown);
    event->accept();
  } else {
    event->ignore();
  }
}

void EnggDiffractionViewQtGUI::openHelpWin() {
  MantidQt::API::HelpWindow::showCustomInterface(
      NULL, QString("Engineering_Diffraction"));
}

} // namespace CustomInterfaces
} // namespace MantidQt