AlgorithmInputHistory.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 +
//----------------------------------
// Includes
//----------------------------------
#include "MantidQtWidgets/Common/AlgorithmInputHistory.h"
#include "MantidAPI/IAlgorithm.h"
 
#include <QSettings>
#include <QStringList>
#include <utility>
 
using namespace MantidQt::API;
 
//----------------------------------
// Public member functions
//----------------------------------
 
AbstractAlgorithmInputHistory::AbstractAlgorithmInputHistory(const QString &settingsGroup)
    : m_lastInput(), m_previousDirectory(""), m_algorithmsGroup(settingsGroup), m_dirKey("LastDirectory") {
  // Fill the stored map from the QSettings information
  load();
}
 
AbstractAlgorithmInputHistory::~AbstractAlgorithmInputHistory() {
  // Can't write the history out here since, in Linux, the singletons are
  // destroyed after
  // the QApplication object and then we get a crash
}
 
void AbstractAlgorithmInputHistory::storeNewValue(const QString &algName, const QPair<QString, QString> &property) {
  m_lastInput[algName][property.first] = property.second;
}
 
void AbstractAlgorithmInputHistory::clearAlgorithmInput(const QString &algName) {
  if (m_lastInput.contains(algName))
    m_lastInput[algName].clear();
}
 
QString AbstractAlgorithmInputHistory::previousInput(const QString &algName, const QString &propName) const {
  if (!m_lastInput.contains(algName))
    return "";
 
  if (m_lastInput.value(algName).contains(propName))
    return m_lastInput.value(algName).value(propName);
  else
    return "";
}
 
void AbstractAlgorithmInputHistory::setPreviousDirectory(const QString &lastdir) { m_previousDirectory = lastdir; }
 
const QString &AbstractAlgorithmInputHistory::getPreviousDirectory() const { return m_previousDirectory; }
 
void AbstractAlgorithmInputHistory::save() const {
  QSettings settings;
  this->writeSettings(settings);
}
 
void AbstractAlgorithmInputHistory::readSettings(const QSettings &storage) {
  // unfortunately QSettings does not allow const when using beginGroup and
  // endGroup
  m_lastInput.clear();
  const_cast<QSettings &>(storage).beginGroup(m_algorithmsGroup);
  //  QStringList algorithms = settings.childGroups();
  QListIterator<QString> algNames(storage.childGroups());
 
  // Each property is a key of the algorithm group
  while (algNames.hasNext()) {
    QHash<QString, QString> algorithmProperties;
    QString group = algNames.next();
    const_cast<QSettings &>(storage).beginGroup(group);
    QListIterator<QString> properties(storage.childKeys());
    while (properties.hasNext()) {
      QString propName = properties.next();
      QString value = storage.value(propName).toString();
      if (!value.isEmpty())
        algorithmProperties.insert(propName, value);
    }
    m_lastInput.insert(group, algorithmProperties);
    const_cast<QSettings &>(storage).endGroup();
  }
 
  // The previous dir
  m_previousDirectory = storage.value(m_dirKey).toString();
 
  const_cast<QSettings &>(storage).endGroup();
}
 
void AbstractAlgorithmInputHistory::writeSettings(QSettings &storage) const {
  storage.beginGroup(m_algorithmsGroup);
  QHashIterator<QString, QHash<QString, QString>> inputHistory(m_lastInput);
  while (inputHistory.hasNext()) {
    inputHistory.next();
    storage.beginGroup(inputHistory.key());
    // Remove all keys for this group that exist at the moment
    storage.remove("");
    QHash<QString, QString>::const_iterator iend = inputHistory.value().end();
    for (QHash<QString, QString>::const_iterator itr = inputHistory.value().begin(); itr != iend; ++itr) {
      storage.setValue(itr.key(), itr.value());
    }
    storage.endGroup();
  }
 
  // Store the previous directory
  storage.setValue(m_dirKey, m_previousDirectory);
 
  storage.endGroup();
}
 
//----------------------------------
// Private member functions
//----------------------------------
 
void AbstractAlgorithmInputHistory::load() {
  QSettings settings;
  this->readSettings(settings);
}