InstrumentSelector.cpp

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 +
#include "MantidQtWidgets/Common/InstrumentSelector.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/FacilityInfo.h"
#include "MantidKernel/InstrumentInfo.h"
#include "MantidKernel/Logger.h"
 
#include <set>
 
namespace {
Mantid::Kernel::Logger g_log("InstrumentSelector");
}
 
namespace MantidQt::MantidWidgets {
using namespace Mantid::Kernel;
 
InstrumentSelector::InstrumentSelector(QWidget *parent, bool init)
    : QComboBox(parent), m_changeObserver(*this, &InstrumentSelector::handleConfigChange), m_techniques(),
      m_currentFacility(nullptr), m_init(init), m_storeChanges(false), m_updateOnFacilityChange(true),
      m_selectedInstrument() {
  setEditable(false);
 
  if (init) {
    fillWithInstrumentsFromFacility();
 
    Mantid::Kernel::ConfigServiceImpl const &config = Mantid::Kernel::ConfigService::Instance();
    config.addObserver(m_changeObserver);
  }
 
  connect(this, SIGNAL(currentIndexChanged(int)), this, SLOT(updateInstrument()));
}
 
InstrumentSelector::~InstrumentSelector() {
  if (m_init) {
    Mantid::Kernel::ConfigService::Instance().removeObserver(m_changeObserver);
  }
}
 
const QStringList &InstrumentSelector::getTechniques() const { return m_techniques; }
 
bool InstrumentSelector::getAutoUpdate() { return m_updateOnFacilityChange; }
 
void InstrumentSelector::setAutoUpdate(bool autoUpdate) { m_updateOnFacilityChange = autoUpdate; }
 
void InstrumentSelector::setTechniques(const QStringList &techniques) {
  m_techniques = techniques;
  if (count() > 0 && m_currentFacility) {
    filterByTechniquesAtFacility(techniques, *m_currentFacility);
  }
}
 
QString InstrumentSelector::getFacility() { return QString::fromStdString(m_currentFacility->name()); }
 
void InstrumentSelector::setFacility(const QString &facilityName) { fillWithInstrumentsFromFacility(facilityName); }
 
void InstrumentSelector::handleConfigChange(Mantid::Kernel::ConfigValChangeNotification_ptr pNf) {
  if (!m_updateOnFacilityChange)
    return;
 
  QString prop = QString::fromStdString(pNf->key());
  QString newV = QString::fromStdString(pNf->curValue());
  QString oldV = QString::fromStdString(pNf->preValue());
 
  if (newV != oldV) {
    if ((prop == "default.facility") && (newV != QString::fromStdString(m_currentFacility->name()))) {
      fillWithInstrumentsFromFacility(newV);
    } else if ((prop == "default.instrument") && (newV != this->currentText())) {
      this->setCurrentIndex(this->findText(newV));
    }
  }
}
 
//------------------------------------------------------
// Public slot member functions
//------------------------------------------------------
 
void InstrumentSelector::fillWithInstrumentsFromFacility(const QString &name) {
  const ConfigServiceImpl &mantidSettings = ConfigService::Instance();
 
  this->blockSignals(true);
  this->clear();
 
  try {
    if (name.isEmpty()) {
      m_currentFacility = &(mantidSettings.getFacility());
    } else {
      m_currentFacility = &(mantidSettings.getFacility(name.toStdString()));
    }
  } catch (Mantid::Kernel::Exception::NotFoundError &) {
    // could not find the facility
    // pick the first facility from the valid list
    m_currentFacility = &(mantidSettings.getFacility(mantidSettings.getFacilityNames()[0]));
  }
 
  const auto &instruments = m_currentFacility->instruments();
  std::set<std::string> alphabetizedNames;
  for (const auto &instrument : instruments) {
    alphabetizedNames.insert(instrument.name());
  }
  for (const auto &name_std_str : alphabetizedNames) {
    QString instrumentName = QString::fromStdString(name_std_str);
    std::string prefix = m_currentFacility->instrument(name_std_str).shortName();
    QString shortName = QString::fromStdString(prefix);
    this->addItem(instrumentName, QVariant(shortName));
  }
  filterByTechniquesAtFacility(m_techniques, *m_currentFacility);
 
  QString defaultName;
  try {
    defaultName = QString::fromStdString(ConfigService::Instance().getString("default.instrument"));
  } catch (Exception::NotFoundError &) {
    defaultName = "";
  }
  int index = this->findText(defaultName);
  if (index < 0) {
    index = 0;
  }
 
  // Don't affect the default instrument
  this->setCurrentIndex(index);
  this->blockSignals(false);
 
  emit instrumentListUpdated();
  updateInstrument(this->currentText());
}
 
void InstrumentSelector::updateInstrumentOnSelection(const bool storeChanges) { m_storeChanges = storeChanges; }
 
//------------------------------------------------------
// Private slot member functions
//------------------------------------------------------
void InstrumentSelector::updateInstrument(const QString &name) {
  // If enabled, set instrument default
  if (!name.isEmpty() && m_storeChanges) {
    ConfigService::Instance().setString("default.instrument", name.toStdString());
  }
 
  // If this instrument is different emit the changed signal
  if (name != m_selectedInstrument) {
    m_selectedInstrument = name;
    g_log.debug() << "New instrument selected: " << m_selectedInstrument.toStdString() << '\n';
    emit instrumentSelectionChanged(m_selectedInstrument);
  }
}
 
void InstrumentSelector::updateInstrument() { updateInstrument(currentText()); }
 
//------------------------------------------------------
// Private non-slot member functions
//------------------------------------------------------
 
void InstrumentSelector::filterByTechniquesAtFacility(const QStringList &techniques,
                                                      const Mantid::Kernel::FacilityInfo &facility) {
  if (techniques.isEmpty())
    return;
 
  this->blockSignals(true);
 
  QStringList supportedInstruments;
  QStringListIterator techItr(techniques);
  while (techItr.hasNext()) {
    const std::vector<InstrumentInfo> instruments = facility.instruments(techItr.next().toStdString());
    const size_t nInstrs = instruments.size();
    for (size_t i = 0; i < nInstrs; ++i) {
      supportedInstruments.append(QString::fromStdString(instruments[i].name()));
    }
  }
 
  // Remove those not supported
  for (int i = 0; i < this->count();) {
    if (!supportedInstruments.contains(itemText(i))) {
      removeItem(i);
    } else {
      ++i;
    }
  }
 
  this->blockSignals(false);
 
  emit instrumentListUpdated();
}
 
} // namespace MantidQt::MantidWidgets