FileFinderWidget.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/FileFinderWidget.h"
#include "MantidQtWidgets/Common/DropEventHelper.h"
#include "MantidQtWidgets/Common/QSettingsChangeAware.h"
 
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/FileProperty.h"
#include "MantidAPI/LiveListenerFactory.h"
#include "MantidAPI/MultipleFileProperty.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/FacilityInfo.h"
#include "MantidKernel/VectorHelper.h"
 
#include <Poco/File.h>
#include <QDragEnterEvent>
#include <QDropEvent>
#include <QFileInfo>
#include <QHash>
#include <QMimeData>
#include <QStringList>
#include <QUrl>
#include <QtConcurrentRun>
 
#include <boost/algorithm/string.hpp>
#include <boost/regex.hpp>
 
using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace MantidQt::API;
namespace DropEventHelper = MantidQt::MantidWidgets::DropEventHelper;
 
// FileFinderWidget
 
FileFinderWidget::FileFinderWidget(QWidget *parent)
    : MantidWidget(parent), m_findRunFiles(true), m_isForDirectory(false), m_allowMultipleFiles(false),
      m_isOptional(false), m_multiEntry(false), m_buttonOpt(Text), m_fileProblem(""), m_entryNumProblem(""),
      m_algorithmProperty(""), m_fileExtensions(), m_extsAsSingleOption(true), m_liveButtonState(Hide),
      m_showValidator(true), m_foundFiles(), m_lastFoundFiles(), m_lastDir(), m_fileFilter(), m_pool(), m_dialog(),
      m_useNativeDialog(true) {
 
  m_uiForm.setupUi(this);
 
  connect(m_uiForm.fileEditor, SIGNAL(textChanged(const QString &)), this, SIGNAL(fileTextChanged(const QString &)));
  connect(m_uiForm.fileEditor, SIGNAL(editingFinished()), this, SIGNAL(fileEditingFinished()));
  connect(m_uiForm.browseBtn, SIGNAL(clicked()), this, SLOT(browseClicked()));
  connect(m_uiForm.browseIco, SIGNAL(clicked()), this, SLOT(browseClicked()));
 
  connect(this, SIGNAL(fileEditingFinished()), this, SLOT(findFiles()));
  connect(m_uiForm.entryNum, SIGNAL(textChanged(const QString &)), this, SLOT(checkEntry()));
  connect(m_uiForm.entryNum, SIGNAL(editingFinished()), this, SLOT(checkEntry()));
 
  m_uiForm.fileEditor->clear();
 
  if (m_multiEntry) {
    m_uiForm.entryNum->show();
    m_uiForm.numEntries->show();
  } else {
    m_uiForm.entryNum->hide();
    m_uiForm.numEntries->hide();
  }
 
  doButtonOpt(m_buttonOpt);
 
  liveButtonState(m_liveButtonState);
  connect(m_uiForm.liveButton, SIGNAL(toggled(bool)), this, SIGNAL(liveButtonPressed(bool)));
 
  setFocusPolicy(Qt::StrongFocus);
  setFocusProxy(m_uiForm.fileEditor);
 
  // First try default save directory
  m_lastDir = QString::fromStdString(Mantid::Kernel::ConfigService::Instance().getString("defaultsave.directory"));
 
  // If that fails pick the first data search directory
  if (m_lastDir.isEmpty()) {
    QStringList dataDirs =
        QString::fromStdString(Mantid::Kernel::ConfigService::Instance().getString("datasearch.directories"))
            .split(";", Qt::SkipEmptyParts);
 
    if (!dataDirs.isEmpty())
      m_lastDir = dataDirs[0];
  }
 
  // this for accepts drops, but the underlying text input does not.
  this->setAcceptDrops(true);
  m_uiForm.fileEditor->setAcceptDrops(false);
}
 
bool FileFinderWidget::isForRunFiles() const { return m_findRunFiles; }
 
void FileFinderWidget::isForRunFiles(const bool mode) { m_findRunFiles = mode; }
 
bool FileFinderWidget::isForDirectory() const { return m_isForDirectory; }
 
void FileFinderWidget::isForDirectory(const bool mode) {
  clear();
  m_isForDirectory = mode;
}
 
QString FileFinderWidget::getLabelText() const { return m_uiForm.textLabel->text(); }
 
void FileFinderWidget::setLabelText(const QString &text) {
  m_uiForm.textLabel->setText(text);
  m_uiForm.textLabel->setVisible(!text.isEmpty());
}
 
void FileFinderWidget::setLabelMinWidth(const int width) { m_uiForm.textLabel->setMinimumWidth(width); }
 
bool FileFinderWidget::allowMultipleFiles() const { return m_allowMultipleFiles; }
 
void FileFinderWidget::allowMultipleFiles(const bool allow) {
  m_allowMultipleFiles = allow;
  findFiles();
}
 
bool FileFinderWidget::isOptional() const { return m_isOptional; }
 
void FileFinderWidget::isOptional(const bool optional) {
  m_isOptional = optional;
  findFiles();
}
 
FileFinderWidget::ButtonOpts FileFinderWidget::doButtonOpt() const { return m_buttonOpt; }
 
void FileFinderWidget::doButtonOpt(const FileFinderWidget::ButtonOpts buttonOpt) {
  m_buttonOpt = buttonOpt;
  if (buttonOpt == None) {
    m_uiForm.browseBtn->hide();
    m_uiForm.browseIco->hide();
  } else if (buttonOpt == Text) {
    m_uiForm.browseBtn->show();
    m_uiForm.browseIco->hide();
  } else if (buttonOpt == Icon) {
    m_uiForm.browseBtn->hide();
    m_uiForm.browseIco->show();
  }
}
 
bool FileFinderWidget::doMultiEntry() const { return m_multiEntry; }
 
void FileFinderWidget::doMultiEntry(const bool multiEntry) {
  m_multiEntry = multiEntry;
  if (m_multiEntry) {
    m_uiForm.entryNum->show();
    m_uiForm.numEntries->show();
  } else {
    m_uiForm.entryNum->hide();
    m_uiForm.numEntries->hide();
  }
  refreshValidator();
}
 
const QString &FileFinderWidget::getAlgorithmProperty() const { return m_algorithmProperty; }
 
void FileFinderWidget::setAlgorithmProperty(const QString &text) { m_algorithmProperty = text; }
const QStringList &FileFinderWidget::getFileExtensions() const { return m_fileExtensions; }
 
std::vector<std::string> FileFinderWidget::getStringFileExtensions() const {
  std::vector<std::string> extensions;
  std::transform(m_fileExtensions.begin(), m_fileExtensions.end(), std::back_inserter(extensions),
                 [](const QString &extension) { return extension.toStdString(); });
 
  return extensions;
}
 
void FileFinderWidget::setFileExtensions(const QStringList &extensions) {
  m_fileExtensions = extensions;
  m_fileFilter.clear();
}
 
bool FileFinderWidget::extsAsSingleOption() const { return m_extsAsSingleOption; }
 
void FileFinderWidget::extsAsSingleOption(const bool value) { m_extsAsSingleOption = value; }
 
FileFinderWidget::LiveButtonOpts FileFinderWidget::liveButtonState() const { return m_liveButtonState; }
 
void FileFinderWidget::liveButtonState(const LiveButtonOpts option) {
  m_liveButtonState = option;
  if (m_liveButtonState == Hide) {
    m_uiForm.liveButton->hide();
  } else if (m_liveButtonState == Show) {
    m_uiForm.liveButton->show();
  }
}
 
void FileFinderWidget::liveButtonSetChecked(const bool checked) { m_uiForm.liveButton->setChecked(checked); }
 
bool FileFinderWidget::liveButtonIsChecked() const { return m_uiForm.liveButton->isChecked(); }
 
bool FileFinderWidget::isValid() const { return m_uiForm.valid->isHidden(); }
 
bool FileFinderWidget::isSearching() const { return m_pool.isSearchRunning(); }
 
const QStringList &FileFinderWidget::getFilenames() const { return m_foundFiles; }
 
QString FileFinderWidget::getFirstFilename() const {
  if (m_foundFiles.isEmpty())
    return "";
  else
    return m_foundFiles[0];
}
 
bool FileFinderWidget::isEmpty() const { return m_uiForm.fileEditor->text().isEmpty(); }
 
QString FileFinderWidget::getText() const { return m_uiForm.fileEditor->text(); }
 
int FileFinderWidget::getEntryNum() const {
  if (m_uiForm.entryNum->text().isEmpty() || (!m_multiEntry)) {
    return ALL_ENTRIES;
  }
  if (isValid()) {
    bool isANumber;
    const int period = m_uiForm.entryNum->text().toInt(&isANumber);
    if (isANumber) {
      return period;
    }
  }
  return NO_ENTRY_NUM;
}
 
void FileFinderWidget::setEntryNum(const int num) { m_uiForm.entryNum->setText(QString::number(num)); }
 
QVariant FileFinderWidget::getUserInput() const { return QVariant(m_valueForProperty); }
 
void FileFinderWidget::setText(const QString &value) { m_uiForm.fileEditor->setText(value); }
 
void FileFinderWidget::setUserInput(const QVariant &value) {
  m_uiForm.fileEditor->setText(value.toString());
  m_uiForm.fileEditor->setModified(true);
  emit fileEditingFinished(); // Which is connected to slot findFiles()
}
 
void FileFinderWidget::setFileProblem(const QString &message) {
  m_fileProblem = message;
  refreshValidator();
}
 
const QString &FileFinderWidget::getFileProblem() const { return m_fileProblem; }
 
void FileFinderWidget::saveSettings(QSettings &settings, const FileFinderSettings &values) const {
  MantidQt::MantidWidgets::QSettingsChangeAware(settings).setValue("last_directory", values.lastDirectory());
}
 
void FileFinderWidget::setNumberOfEntries(const int number) {
  const QString total = number > 0 ? QString::number(number) : "?";
  {
    m_uiForm.numEntries->setText("/" + total);
  }
}
 
void FileFinderWidget::setLiveAlgorithm(const IAlgorithm_sptr &monitorLiveData) { m_monitorLiveData = monitorLiveData; }
 
const QString &FileFinderWidget::getInstrumentOverride() const { return m_defaultInstrumentName; }
 
void FileFinderWidget::setInstrumentOverride(const QString &instName) {
  m_defaultInstrumentName = instName;
  findFiles(true);
}
 
void FileFinderWidget::setFileTextWithSearch(const QString &text) {
  setFileTextWithoutSearch(text);
  findFiles();
}
void FileFinderWidget::setFileTextWithoutSearch(const QString &text) {
  m_uiForm.fileEditor->setText(text);
  m_uiForm.fileEditor->setModified(true);
}
 
void FileFinderWidget::clear() {
  m_foundFiles.clear();
  m_uiForm.fileEditor->setText("");
}
 
void FileFinderWidget::findFiles() { findFiles(m_uiForm.fileEditor->isModified()); }
 
void FileFinderWidget::findFiles(bool isModified) {
  auto searchText = m_uiForm.fileEditor->text();
  if (m_isForDirectory) {
    m_foundFiles.clear();
    if (searchText.isEmpty()) {
      if (!m_isOptional)
        setFileProblem("A directory must be provided");
      else
        setFileProblem("");
    } else {
      setFileProblem("");
      m_foundFiles.append(searchText);
    }
    return;
  }
 
  if (isModified) {
    // Reset modified flag.
    m_uiForm.fileEditor->setModified(false);
    searchText = findFilesGetSearchText(searchText);
    runFindFiles(searchText);
  } else {
    // Make sure errors are correctly set if we didn't run
    inspectThreadResult(m_cachedResults);
  }
}
 
const QString FileFinderWidget::findFilesGetSearchText(QString &searchText) {
  // If we have an override instrument then add it in appropriate places to
  // the search text
  if (!m_defaultInstrumentName.isEmpty()) {
    // Regex to match a selection of run numbers as defined here:
    // mantidproject.org/MultiFileLoading
    // Also allowing spaces between delimiters as this seems to work fine
    const std::string runNumberString = "([0-9]+)([:+-] ?[0-9]+)? ?(:[0-9]+)?";
    boost::regex runNumberExp(runNumberString, boost::regex::extended);
    // Regex to match a list of run numbers delimited by commas
    const std::string runListString = "(" + runNumberString + ")(, ?(" + runNumberString + "))*";
    boost::regex runNumberListExp(runListString, boost::regex::extended);
 
    // See if we can just prepend the instrument and be done
    if (boost::regex_match(searchText.toStdString(), runNumberExp)) {
      searchText = m_defaultInstrumentName + searchText;
    }
    // If it is a list we need to prepend the instrument to all run numbers
    else if (boost::regex_match(searchText.toStdString(), runNumberListExp)) {
      QStringList runNumbers = searchText.split(",", Qt::SkipEmptyParts);
      QStringList newRunNumbers;
 
      for (const auto &runNumber : runNumbers)
        newRunNumbers << m_defaultInstrumentName + runNumber.simplified();
 
      searchText = newRunNumbers.join(",");
    }
  }
  return searchText;
}
 
void FileFinderWidget::runFindFiles(const QString &searchText) {
  emit findingFiles();
 
  const auto parameters = createFindFilesSearchParameters(searchText.toStdString());
  m_pool.createWorker(this, parameters);
}
 
IAlgorithm_const_sptr FileFinderWidget::stopLiveAlgorithm() {
  IAlgorithm_const_sptr theAlgorithmBeingCancelled = m_monitorLiveData;
  if (m_monitorLiveData && m_monitorLiveData->isRunning()) {
    m_monitorLiveData->cancel();
    m_monitorLiveData.reset();
  }
  return theAlgorithmBeingCancelled;
}
 
void FileFinderWidget::inspectThreadResult(const FindFilesSearchResults &results) {
  // Update caches before we might exit early
  m_cachedResults = results;
  m_valueForProperty = QString::fromStdString(results.valueForProperty);
  m_foundFiles.clear();
  m_lastFoundFiles.clear();
 
  // Early exit on failure
  if (!results.error.empty()) {
    setFileProblem(QString::fromStdString(results.error));
    emit fileInspectionFinished();
    return;
  }
 
  for (const auto &filename : results.filenames) {
    m_foundFiles.append(QString::fromStdString(filename));
  }
  if (m_foundFiles.isEmpty() && !isOptional()) {
    setFileProblem("No files found. Check search paths and instrument selection.");
  } else if (m_foundFiles.count() > 1 && this->allowMultipleFiles() == false) {
    setFileProblem("Multiple files specified.");
  } else {
    setFileProblem("");
  }
 
  emit fileInspectionFinished();
 
  // Only emit the signal if file(s) were found
  if (!m_foundFiles.isEmpty())
    emit filesFound();
  if (m_lastFoundFiles != m_foundFiles)
    emit filesFoundChanged();
}
 
FileFinderSettings FileFinderWidget::readSettings(const QSettings &settings) {
  auto lastDirectory = settings.value("last_directory", "").toString();
 
  if (lastDirectory.isEmpty()) {
    QStringList datadirs =
        QString::fromStdString(Mantid::Kernel::ConfigService::Instance().getString("datasearch.directories"))
            .split(";", Qt::SkipEmptyParts);
    if (!datadirs.isEmpty())
      lastDirectory = datadirs[0];
  }
 
  return FileFinderSettings(lastDirectory);
}
 
void FileFinderWidget::restoreSettings(const FileFinderSettings &settings) { m_lastDir = settings.lastDirectory(); }
 
FileFinderSettings FileFinderWidget::captureSettings() const { return FileFinderSettings(m_lastDir); }
 
QString FileFinderWidget::createFileFilter() {
  QStringList fileExts;
  if (m_algorithmProperty.isEmpty()) {
    if (!m_fileExtensions.isEmpty()) {
      fileExts = m_fileExtensions;
    } else if (isForRunFiles()) {
      std::vector<std::string> exts = ConfigService::Instance().getFacility().extensions();
      for (const auto &ext : exts) {
        fileExts.append(QString::fromStdString(ext));
      }
    } else {
    }
  } else {
    QStringList elements = m_algorithmProperty.split("|");
    if (elements.size() == 2) {
      fileExts = getFileExtensionsFromAlgorithm(elements[0], elements[1]);
    }
  }
 
  QString allFiles("All Files (*)");
  if (!fileExts.isEmpty()) {
 
    // The list may contain upper and lower cased versions, ensure these are on
    // the same line
    // I want this ordered
    QList<std::pair<QString, QStringList>> finalIndex;
    QStringListIterator sitr(fileExts);
    QString ext = sitr.next();
    finalIndex.append(std::make_pair(ext.toUpper(), QStringList(ext)));
    while (sitr.hasNext()) {
      ext = sitr.next();
      QString key = ext.toUpper();
      const auto it = std::find_if(finalIndex.begin(), finalIndex.end(),
                                   [&key](const std::pair<QString, QStringList> &pair) { return pair.first == key; });
      if (it != finalIndex.end()) {
        it->second.append(ext);
      } else {
        finalIndex.append(std::make_pair(key, QStringList(ext)));
      }
    }
 
    // The file filter consists of three parts, which we will combine to create
    // the
    // complete file filter:
    QString dataFiles("Data Files (");
    QString individualFiles("");
 
    if (extsAsSingleOption()) {
      QListIterator<std::pair<QString, QStringList>> itr(finalIndex);
      while (itr.hasNext()) {
        const QStringList values = itr.next().second;
 
        individualFiles += "*" + values.join(" *") + ";;";
        dataFiles += "*" + values.join(" *") + " ";
      }
      // Don't remove final ;; from individualFiles as we are going to tack on
      // allFiles anyway
      dataFiles.chop(1); // Remove last space
      dataFiles += ");;";
    } else {
      QListIterator<std::pair<QString, QStringList>> itr(finalIndex);
      while (itr.hasNext()) {
        const QStringList values = itr.next().second;
        dataFiles += "*" + values.join(" *") + ";;";
      }
    }
    return dataFiles + individualFiles + allFiles;
  } else {
    return allFiles;
  }
}
 
QStringList FileFinderWidget::getFileExtensionsFromAlgorithm(const QString &algName, const QString &propName) {
  Mantid::API::IAlgorithm_sptr algorithm =
      Mantid::API::AlgorithmManager::Instance().createUnmanaged(algName.toStdString());
  QStringList fileExts;
  if (!algorithm)
    return fileExts;
  algorithm->initialize();
  Property *prop = algorithm->getProperty(propName.toStdString());
  FileProperty *fileProp = dynamic_cast<FileProperty *>(prop);
  auto *multiFileProp = dynamic_cast<MultipleFileProperty *>(prop);
 
  std::vector<std::string> allowed;
  QString preferredExt;
 
  if (fileProp) {
    allowed = fileProp->allowedValues();
    preferredExt = QString::fromStdString(fileProp->getDefaultExt());
  } else if (multiFileProp) {
    allowed = multiFileProp->allowedValues();
    preferredExt = QString::fromStdString(multiFileProp->getDefaultExt());
  } else {
    return fileExts;
  }
 
  std::vector<std::string>::const_iterator iend = allowed.end();
  int index(0);
  for (std::vector<std::string>::const_iterator it = allowed.begin(); it != iend; ++it) {
    if (!it->empty()) {
      QString ext = QString::fromStdString(*it);
      fileExts.append(ext);
      if (ext == preferredExt) {
        fileExts.move(index, 0);
      }
      ++index;
    }
  }
 
  return fileExts;
}
 
QString FileFinderWidget::openFileDialog() {
  QStringList filenames;
  QString dir;
 
  auto prevFileNames = getText().split(",", Qt::SkipEmptyParts);
  for (auto &prevFileName : prevFileNames)
    prevFileName = prevFileName.trimmed();
 
  if (!prevFileNames.empty() && QFileInfo(prevFileNames[0]).isAbsolute()) {
    if (QFileInfo(prevFileNames[0]).isFile()) {
      dir = QFileInfo(prevFileNames[0]).absoluteDir().path();
    } else {
      dir = prevFileNames[0];
    }
  } else {
    dir = m_lastDir;
  }
 
  if (m_fileFilter.isEmpty()) {
    m_fileFilter = createFileFilter();
  }
 
  if (!m_useNativeDialog) {
    if (m_isForDirectory) {
      m_dialog.setOption(QFileDialog::DontResolveSymlinks, false);
      m_dialog.setFileMode(QFileDialog::Directory);
    } else {
      m_dialog.setNameFilter(m_fileFilter);
      m_dialog.setOption(QFileDialog::DontResolveSymlinks);
      if (m_allowMultipleFiles)
        m_dialog.setFileMode(QFileDialog::ExistingFiles);
      else
        m_dialog.setFileMode(QFileDialog::ExistingFile);
    }
    m_dialog.setDirectory(dir);
    if (m_dialog.exec())
      filenames = m_dialog.selectedFiles();
  } else {
    if (m_isForDirectory) {
      QString file = QFileDialog::getExistingDirectory(this, "Select directory", dir);
      if (!file.isEmpty())
        filenames.append(file);
    } else if (m_allowMultipleFiles) {
      filenames = QFileDialog::getOpenFileNames(this, "Open file", dir, m_fileFilter, nullptr,
                                                QFileDialog::DontResolveSymlinks);
    } else {
      QString file =
          QFileDialog::getOpenFileName(this, "Open file", dir, m_fileFilter, nullptr, QFileDialog::DontResolveSymlinks);
      if (!file.isEmpty())
        filenames.append(file);
    }
  }
 
  if (filenames.isEmpty()) {
    return "";
  }
  m_lastDir = QFileInfo(filenames.front()).absoluteDir().path();
  return filenames.join(", ");
}
 
void FileFinderWidget::setEntryNumProblem(const QString &message) {
  m_entryNumProblem = message;
  refreshValidator();
}
 
void FileFinderWidget::refreshValidator() {
  if (m_showValidator) {
    if (!m_fileProblem.isEmpty()) {
      m_uiForm.valid->setToolTip(m_fileProblem);
      m_uiForm.valid->show();
    } else if (!m_entryNumProblem.isEmpty() && m_multiEntry) {
      m_uiForm.valid->setToolTip(m_entryNumProblem);
      m_uiForm.valid->show();
    } else {
      m_uiForm.valid->hide();
    }
  } else {
    m_uiForm.valid->hide();
  }
}
 
void FileFinderWidget::browseClicked() {
  QString uFile = openFileDialog();
  if (uFile.trimmed().isEmpty())
    return;
 
  m_uiForm.fileEditor->setText(uFile);
  m_uiForm.fileEditor->setModified(true);
 
  emit fileEditingFinished();
}
 
void FileFinderWidget::checkEntry() {
  if (m_uiForm.entryNum->text().isEmpty()) {
    setEntryNumProblem("");
    return;
  }
 
  bool good;
  const int num = m_uiForm.entryNum->text().toInt(&good);
  if (!good) {
    setEntryNumProblem("The entry number must be an integer");
    return;
  }
  if (num < 1) {
    setEntryNumProblem("The entry number must be an integer > 0");
    return;
  }
 
  setEntryNumProblem("");
}
 
void FileFinderWidget::dropEvent(QDropEvent *de) {
  const QMimeData *mimeData = de->mimeData();
  const auto filenames = DropEventHelper::getFileNames(de);
  if (!filenames.empty()) {
    m_uiForm.fileEditor->setText(filenames[0]);
    de->acceptProposedAction();
  } else if (mimeData->hasText()) {
    QString text = mimeData->text();
    m_uiForm.fileEditor->setText(text);
    de->acceptProposedAction();
  }
}
 
void FileFinderWidget::dragEnterEvent(QDragEnterEvent *de) {
  const QMimeData *mimeData = de->mimeData();
  if (mimeData->hasUrls()) {
    auto listurl = mimeData->urls();
    if (listurl.empty())
      return;
    if (!listurl[0].isLocalFile())
      return;
    de->acceptProposedAction();
  } else if (mimeData->hasText()) {
    QString text = mimeData->text();
    if (text.contains(" = mtd[\""))
      de->setDropAction(Qt::IgnoreAction);
    else
      de->acceptProposedAction();
  }
}
 
void FileFinderWidget::setReadOnly(bool readOnly) {
  m_uiForm.fileEditor->setReadOnly(readOnly);
  m_uiForm.browseBtn->setEnabled(!readOnly);
  setValidatorDisplay(!readOnly);
  refreshValidator();
}
 
void FileFinderWidget::setValidatorDisplay(bool display) { m_showValidator = display; }
 
FindFilesSearchParameters FileFinderWidget::createFindFilesSearchParameters(const std::string &text) const {
  FindFilesSearchParameters parameters;
  parameters.searchText = text;
  parameters.isOptional = isOptional();
  parameters.isForRunFiles = isForRunFiles();
  parameters.extensions = getStringFileExtensions();
 
  // parse the algorithm - property name string
  QStringList elements = m_algorithmProperty.split("|");
  if (elements.size() == 2) {
    parameters.algorithmName = elements[0].toStdString();
    parameters.algorithmProperty = elements[1].toStdString();
  }
 
  return parameters;
}
 
void FileFinderWidget::setTextValidator(const QValidator *validator) { m_uiForm.fileEditor->setValidator(validator); }
 
void FileFinderWidget::setUseNativeWidget(bool native) {
  m_useNativeDialog = native;
  m_dialog.setOption(QFileDialog::DontUseNativeDialog);
  m_dialog.setOption(QFileDialog::ReadOnly);
}
 
void FileFinderWidget::setProxyModel(QAbstractProxyModel *proxyModel) { m_dialog.setProxyModel(proxyModel); }