de/d48/ScriptRepositoryView_8cpp_source.html

// Mantid Repository : https://github.com/mantidproject/mantid

//

// Copyright &copy; 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/ScriptRepositoryView.h"

#include "MantidAPI/ScriptRepository.h"

#include "MantidAPI/ScriptRepositoryFactory.h"

#include "MantidKernel/ConfigService.h"

#include "MantidKernel/Logger.h"

#include "MantidQtIcons/Icon.h"

#include "MantidQtWidgets/Common/HelpWindow.h"

#include "MantidQtWidgets/Common/MantidDesktopServices.h"

#include "MantidQtWidgets/Common/RepoModel.h"


#include <QCoreApplication>

#include <QDebug>

#include <QFileDialog>

#include <QLabel>

#include <QMessageBox>

#include <QPainter>

#include <QPushButton>

#include <QTime>

#include <QVBoxLayout>


namespace MantidQt::API {

namespace {

Mantid::Kernel::Logger g_log("ScriptRepositoryView");

} // namespace


const QString install_mantid_label =

    "<html><head/><body><p>The <span style=\" font-weight:600;\">"

    "Script Repository</span> allows you to:</p>"

    "<p>  * Get <span style=\" font-weight:600;\">Mantid</span> Scripts from "

    "the mantid developers and the community;</p>"

    "<p>  * Keep those scripts up to date automatically. </p>"

    "<p><span style=\" font-style:italic;\">"

    "N.B. The installation usually requires a couple of minutes, depending on "

    "your network bandwidth. </span></p>"

    "<p>More Information available at "

    "<a href=\"http://docs.mantidproject.org/workbench/scriptrepository\"><span style=\" "

    "text-decoration: underline; color:#0000ff;\">"

    "http://docs.mantidproject.org/workbench/scriptrepository</span></a></p></br><p><span "

    "style=\" font-weight:600;\">"

    "Would you like to install it now?</span></p></body></html>";


const QString installation_in_progress = "<html><head/><body><p><span style=\" font-weight:600;\">"

                                         "Installing Script Repository Installation in background!</span></p>"

                                         "<p>You may continue to use mantid.</p>"

                                         "<p>The Result Log willl give you information of the installation "

                                         "progress.</p>"

                                         "<p>When finished, please, reopen the <span style=\" "

                                         "font-weight:600;\">Script Repository</span>. </p></body></html>";


const QString installation_failed = "<html><head/><body><p>The installation of Script Repository "

                                    "<span style=\" font-weight:600;\">Failed</span>!</p>"

                                    "<p>Please, check the Result Log to see why the installation failed. "

                                    "</p></body></html>";


const QString dir_not_empty_label = "<html><head/><body><p>The directory/folder that you have selected is not "

                                    "empty</p>"

                                    "<p>Are you sure that you want to install the script repository here? All "

                                    "the files and directories found in "

                                    "the selected directory/folder will be listed as part of the "

                                    "repository.</p>"

                                    "<p>If you are not sure, please choose 'no' and then select an empty (or "

                                    "newly created) directory/folder.</p>"

                                    "<p>If this is your home directory, desktop or similar you should "

                                    "definitely choose 'no'.</p>"

                                    "<p>If you are sure of what you are doing, please choose 'yes'. The "

                                    "installation may take a couple of minutes.</p>"

                                    "</body></html>";


//----------------------------------------------------------------------------------------------


ScriptRepositoryView::ScriptRepositoryView(QWidget *parent) : MantidDialog(parent), ui(new Ui::ScriptRepositoryView) {

  using Mantid::API::ScriptRepositoryFactory;

  using Mantid::Kernel::ConfigService;

  using Mantid::Kernel::ConfigServiceImpl;


  ui->setupUi(this);


  try {

    // create and instance of ScriptRepository

    Mantid::API::ScriptRepository_sptr repo_ptr = ScriptRepositoryFactory::Instance().create("ScriptRepositoryImpl");


    // check if the ScriptRepository was ever installed

    if (!repo_ptr->isValid()) {

      bool successful = chooseLocationAndInstall(std::move(repo_ptr));

      if (!successful) {

        return;

      }

    }

    // create the model

    model = new RepoModel(this);


  } catch (Mantid::API::ScriptRepoException &ex) {

    // means that the installation failed

    g_log.warning() << "ScriptRepository installation: " << ex.what() << '\n';

    g_log.information() << "ScriptRepository installation failed with this information: " << ex.systemError() << '\n';

    QMessageBox::warning(this, "Installation Failed", QString(ex.what()));

    close();

    deleteLater();

    return;

  } catch (...) {

    g_log.error() << "Unknown error occurred to install ScriptRepository. It "

                     "will not be shown.\n";

    close();

    deleteLater();

    return;

  }

  // from this point, it is assumed that ScriptRepository is installed.


  // configure the Ui

  connect(ui->reloadPushButton, SIGNAL(clicked()), this, SLOT(updateModel()));

  connect(ui->pbHelp, SIGNAL(clicked()), this, SLOT(helpClicked()));

  connect(model, SIGNAL(executingThread(bool)), ui->reloadPushButton, SLOT(setDisabled(bool)));


  // setup the model and delegates

  ui->repo_treeView->setModel(model);

  ui->repo_treeView->setItemDelegateForColumn(1, new RepoDelegate(this));

  ui->repo_treeView->setItemDelegateForColumn(2, new CheckBoxDelegate(this));

  ui->repo_treeView->setColumnWidth(0, 290);


  // stablish the connections.

  connect(ui->repo_treeView, SIGNAL(activated(const QModelIndex &)), this, SLOT(cell_activated(const QModelIndex &)));

  connect(ui->repo_treeView, SIGNAL(currentCell(const QModelIndex &)), this, SLOT(currentChanged(const QModelIndex &)));

  const ConfigServiceImpl &config = ConfigService::Instance();

  updateLocationString(config.getString("ScriptLocalRepository"));

  connect(ui->folderPathLabel, SIGNAL(linkActivated(QString)), this, SLOT(openFolderLink(QString)));

}


bool ScriptRepositoryView::chooseLocationAndInstall(Mantid::API::ScriptRepository_sptr repo_ptr) {

  using Mantid::Kernel::ConfigService;

  using Mantid::Kernel::ConfigServiceImpl;

  enum EXC_OPTIONS { NOTWANTED, NODIRECTORY };


  QString dir;

  try {

    // Ask the user if he wants to install the ScriptRepository

    if (QMessageBox::Ok != QMessageBox::question(this, "Install Script Repository?", install_mantid_label,

                                                 QMessageBox::Ok | QMessageBox::Cancel)) {

      throw NOTWANTED;

    }

    // get the directory to install the script repository

    const ConfigServiceImpl &config = ConfigService::Instance();

    QString loc = QString::fromStdString(config.getString("ScriptLocalRepository"));


    bool sureAboutDir = false;


    while (!sureAboutDir) {

      dir = QFileDialog::getExistingDirectory(this, tr("Where do you want to install Script Repository?"), loc,

                                              QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);


      // configuring

      if (dir.isEmpty()) {

        throw NODIRECTORY;

      }


      // warn if dir is not empty

      if (0 == QDir(dir).entryInfoList(QDir::AllEntries | QDir::NoDotAndDotDot).count()) {

        // empty dir, just go ahead

        sureAboutDir = true;

      } else {

        // warn user in case the repo is being installed in its home, etc.

        // directory

        QMessageBox::StandardButton sel =

            QMessageBox::question(this, "Are you sure you want to install the Script Repository here?",

                                  dir_not_empty_label, QMessageBox::Yes | QMessageBox::No);

        if (QMessageBox::Yes == sel)

          sureAboutDir = true;

      }

    }

  } catch (EXC_OPTIONS &ex) {

    if (ex == NODIRECTORY) {

      // probably the user change mind. He does not want to install any more.

      QMessageBox::warning(this, "Installation Failed", "Invalid Folder to install Script Repository!\n");

    }


    close();

    deleteLater();

    return false;

  }

  // attempt to install

  repo_ptr->install(dir.toStdString());

  updateLocationString(dir.toStdString());

  g_log.information() << "ScriptRepository installed at " << dir.toStdString() << '\n';

  return true;

}


void ScriptRepositoryView::updateLocationString(const std::string &installDir) {

  const QString loc = QString::fromStdString(installDir);

  const QString loc_info = "<html><head/><body><p><a href=\"%1\"><span style=\" "

                           "text-decoration: underline; "

                           "color:#0000ff;\">%2</span></a></p></body></html>";

  QString path_label;

  if (loc.size() < 50)

    path_label = loc;

  else {

    path_label = QString("%1...%2").arg(loc.left(20)).arg(loc.right(27));

  }


  ui->folderPathLabel->setText(loc_info.arg(loc).arg(path_label));

  ui->folderPathLabel->setToolTip(QString("Click here to open Script Repository Folder: %1.").arg(loc));

}


void ScriptRepositoryView::updateModel() {

  RepoModel *before = model;

  auto model_repo_ptr = model->getRepoPtr();

  if (!model_repo_ptr->isValid()) {

    const bool success = chooseLocationAndInstall(std::move(model_repo_ptr));

    if (!success) {

      return;

    }

  }

  model = new RepoModel();

  connect(model, SIGNAL(executingThread(bool)), ui->reloadPushButton, SLOT(setDisabled(bool)));

  ui->repo_treeView->setModel(model);

  delete before;

}


//----------------------------------------------------------------------------------------------

ScriptRepositoryView::~ScriptRepositoryView() { delete ui; }


void ScriptRepositoryView::cell_activated(const QModelIndex &in) {


  RepoModel *_model = qobject_cast<RepoModel *>(ui->repo_treeView->model());

  if (_model) {

    QString path = _model->filePath(in);

    if (path.isEmpty()) {

      // no real file to be opened.

      return;

    }

    emit loadScript(path);

  }

}


void ScriptRepositoryView::currentChanged(const QModelIndex &in) {

  RepoModel *_model = qobject_cast<RepoModel *>(ui->repo_treeView->model());

  if (_model) {

    // try to get the description of the file pointed at the current index.

    // and update the description text browser.

    QString description = _model->fileDescription(in);

    ui->desc_textBrowser->setText(description);

    QString author_name = _model->author(in);

    if (author_name.isEmpty())

      ui->authorNameLabel->setText("");

    else

      ui->authorNameLabel->setText(QString("<b>Author:</b> ") + author_name);

    return;

  }

}


void ScriptRepositoryView::helpClicked() { HelpWindow::showPage(QStringLiteral("workbench/scriptrepository.html")); }


// DELEGATE : Allow to display and interact with the View in a nicer way.

// Improve the User Experience.


ScriptRepositoryView::RepoDelegate::RepoDelegate(QObject *parent) : QStyledItemDelegate(parent) {}


void ScriptRepositoryView::RepoDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,

                                               const QModelIndex &index) const {


  if (!index.isValid())

    return;

  if (painter->device() == nullptr)

    return;


  // get the state and chose the best fit icon

  QString state = index.model()->data(index, Qt::DisplayRole).toString();

  auto icon = getIcon(state);

  // entries with no action available (purely local ones) get no button at all

  if (icon.isNull())

    return;


  // define the region to draw the icon

  QRect iconRect(option.rect);

  int min_val = iconRect.width() < iconRect.height() ? iconRect.width() : iconRect.height();

  // make it square

  iconRect.setWidth(min_val);

  iconRect.setHeight(min_val);

  iconRect.moveCenter(option.rect.center());


  int icon_size = (int)(min_val * .8);


  // the locally-modified state is informational only, so draw the icon flat

  // (no push-button chrome) to make clear there is nothing to click

  if (state == RepoModel::localChangedSt()) {

    icon.paint(painter, iconRect, Qt::AlignCenter);

    return;

  }


  // define the options to draw a push button with the icon displayed

  QStyleOptionButton button;

  button.rect = iconRect;

  button.icon = icon;

  button.iconSize = QSize(icon_size, icon_size);

  button.state = QStyle::State_Enabled;

  // draw a push button

  QApplication::style()->drawControl(QStyle::CE_PushButton, &button, painter);

}


QIcon ScriptRepositoryView::RepoDelegate::getIcon(const QString &state) const {

  QIcon icon;

  if (state == RepoModel::remoteOnlySt())

    icon = Icons::getIcon("mdi.download");

  else if (state == RepoModel::remoteChangedSt() || state == RepoModel::bothChangedSt()) {

    icon = Icons::getIcon("mdi.transfer-down");

  } else if (state == RepoModel::updatedSt())

    icon = Icons::getIcon("mdi.check-bold");

  else if (state == RepoModel::downloadSt())

    icon = Icons::getIcon("mdi.progress-download");

  else if (state == RepoModel::localChangedSt())

    icon = Icons::getIcon("mdi.pencil");

  // local-only entries have no remote action, so they deliberately get a null

  // icon

  return icon;

}


bool ScriptRepositoryView::RepoDelegate::editorEvent(QEvent *event, QAbstractItemModel *model,

                                                     const QStyleOptionViewItem & /*option*/,

                                                     const QModelIndex &index) {

  // if event is mouse click

  if (event->type() == QEvent::MouseButtonPress) {

    QString value = model->data(index, Qt::DisplayRole).toString();

    // these entries have nothing to fetch from the central repository

    if (value == RepoModel::updatedSt() || value == RepoModel::localOnlySt() || value == RepoModel::localChangedSt())

      return false; // ignore

    return model->setData(index, "Download", Qt::EditRole);

  } else {

    return true; // Does not allow others events to be processed (example:

                 // double-click)

  }

}


QSize ScriptRepositoryView::RepoDelegate::sizeHint(const QStyleOptionViewItem & /*option*/,

                                                   const QModelIndex & /*index*/) const {

  return QSize(35, 35);

}


// CheckBoxDelegate


ScriptRepositoryView::CheckBoxDelegate::CheckBoxDelegate(QObject *parent) : QStyledItemDelegate(parent) {}


void ScriptRepositoryView::CheckBoxDelegate::paint(QPainter *painter, const QStyleOptionViewItem &option,

                                                   const QModelIndex &index) const {

  if (!index.isValid())

    return;

  if (painter->device() == nullptr)

    return;


  QStyleOptionViewItem modifiedOption(option);


  QPoint p = modifiedOption.rect.center();

  QSize curr = modifiedOption.rect.size();

  int min_value = (int)((curr.width() < curr.height()) ? curr.width() : curr.height() * .8);

  // make the checkbox a square in the center of the cell

  modifiedOption.rect.setSize(QSize(min_value, min_value));

  modifiedOption.rect.moveCenter(p);

  // get the current state of this entry

  QString state = index.model()->data(index, Qt::DisplayRole).toString();


  if (state == "true")

    modifiedOption.state |= QStyle::State_On;

  else if (state == "false")

    modifiedOption.state |= QStyle::State_Off;

  else

    return;

  // draw it

  QApplication::style()->drawPrimitive(QStyle::PE_IndicatorItemViewItemCheck, &modifiedOption, painter);

}


bool ScriptRepositoryView::CheckBoxDelegate::editorEvent(QEvent *event, QAbstractItemModel *model,

                                                         const QStyleOptionViewItem & /*option*/,

                                                         const QModelIndex &index) {

  if (event->type() == QEvent::MouseButtonPress) {

    QString value = model->data(index, Qt::DisplayRole).toString();

    QString action = "setFalse";

    if (value == "false")

      action = "setTrue";

    return model->setData(index, action, Qt::EditRole);

  } else {

    // QStyledItemDelegate::editorEvent(event, model, option, index);

    return true; // Does not allow the event to be catched by another one

  }

}


void ScriptRepositoryView::openFolderLink(const QString &link) {

  const std::string error_msg = "Unable to open \"" + link.toStdString() + "\".  Reason: ";


  // QUrl::fromLocalFile seems to be the most robust way of constructing QUrls

  // on

  // the local file system for all platforms.

  const QUrl url = QUrl::fromLocalFile(link);

  if (!url.isValid()) {

    g_log.error() << error_msg << "Invalid (malformed) URL.\n";

    return;

  }


  const bool openSuccessful = MantidDesktopServices::openUrl(url);

  if (!openSuccessful)

    g_log.error() << error_msg << "Could not find directory.\n";

}


} // namespace MantidQt::API

ConfigService.h

value
double value
The value of the point.
Definition FitMW.cpp:51

HelpWindow.h

index
std::map< DeltaEMode::Type, std::string > index
Definition DeltaEMode.cpp:19

Logger.h

MantidDesktopServices.h

count
int count
counter
Definition Matrix.cpp:37

RepoModel.h

ScriptRepositoryFactory.h

ScriptRepositoryView.h

ScriptRepository.h

MantidQt::API::HelpWindow::showPage
static void showPage(const std::string &url=std::string())
Definition HelpWindow.cpp:28

MantidQt::API::MantidDesktopServices::openUrl
static bool openUrl(const QUrl &url)
Opens a url in the appropriate web browser.
Definition MantidDesktopServices.cpp:35

MantidQt::API::MantidDialog
Definition MantidDialog.h:54

MantidQt::API::RepoModel
RepoModel : Wrapper for ScriptRepository to fit the Model View Qt Framework.
Definition RepoModel.h:68

MantidQt::API::RepoModel::localChangedSt
static const QString & localChangedSt()
Definition RepoModel.cpp:696

MantidQt::API::RepoModel::filePath
QString filePath(const QModelIndex &index)
Return the operative system file path if it exists.
Definition RepoModel.cpp:516

MantidQt::API::RepoModel::getRepoPtr
Mantid::API::ScriptRepository_sptr getRepoPtr()
Definition RepoModel.h:153

MantidQt::API::RepoModel::author
QString author(const QModelIndex &index)
Definition RepoModel.cpp:499

MantidQt::API::RepoModel::remoteChangedSt
static const QString & remoteChangedSt()
Definition RepoModel.cpp:698

MantidQt::API::RepoModel::updatedSt
static const QString & updatedSt()
Definition RepoModel.cpp:700

MantidQt::API::RepoModel::bothChangedSt
static const QString & bothChangedSt()
Definition RepoModel.cpp:702

MantidQt::API::RepoModel::data
QVariant data(const QModelIndex &index, int role) const override
access to the ScriptRepository data
Definition RepoModel.cpp:153

MantidQt::API::RepoModel::setData
bool setData(const QModelIndex &index, const QVariant &value, int role=Qt::EditRole) override
change data
Definition RepoModel.cpp:302

MantidQt::API::RepoModel::fileDescription
QString fileDescription(const QModelIndex &index)
Return the description of the file for a defined entry.
Definition RepoModel.cpp:486

MantidQt::API::RepoModel::localOnlySt
static const QString & localOnlySt()
Definition RepoModel.cpp:692

MantidQt::API::RepoModel::downloadSt
static const QString & downloadSt()
Definition RepoModel.cpp:704

MantidQt::API::RepoModel::remoteOnlySt
static const QString & remoteOnlySt()
Definition RepoModel.cpp:694

MantidQt::API::ScriptRepositoryView::CheckBoxDelegate
Delegate to show the checkbox for configuring the auto update.
Definition ScriptRepositoryView.h:41

MantidQt::API::ScriptRepositoryView::CheckBoxDelegate::editorEvent
bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index) override
Reacts to the iteraction with the user when he clicks on the buttons displayed at paint.
Definition ScriptRepositoryView.cpp:510

MantidQt::API::ScriptRepositoryView::CheckBoxDelegate::paint
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
Draws the column 2 (AutoUpdate) of ScriptRepositoryView.
Definition ScriptRepositoryView.cpp:460

MantidQt::API::ScriptRepositoryView::CheckBoxDelegate::CheckBoxDelegate
CheckBoxDelegate(QObject *parent=nullptr)
Definition ScriptRepositoryView.cpp:438

MantidQt::API::ScriptRepositoryView::RepoDelegate
Delegate to show the Download icons.
Definition ScriptRepositoryView.h:30

MantidQt::API::ScriptRepositoryView::RepoDelegate::RepoDelegate
RepoDelegate(QObject *parent=nullptr)
Definition ScriptRepositoryView.cpp:305

MantidQt::API::ScriptRepositoryView::RepoDelegate::getIcon
QIcon getIcon(const QString &state) const
Definition ScriptRepositoryView.cpp:372

MantidQt::API::ScriptRepositoryView::RepoDelegate::editorEvent
bool editorEvent(QEvent *event, QAbstractItemModel *model, const QStyleOptionViewItem &option, const QModelIndex &index) override
Reacts to the iteraction with the user when he clicks on the buttons displayed at paint.
Definition ScriptRepositoryView.cpp:411

MantidQt::API::ScriptRepositoryView::RepoDelegate::paint
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
Draws the column 1 (Status) of ScriptRepositoryView.
Definition ScriptRepositoryView.cpp:330

MantidQt::API::ScriptRepositoryView::RepoDelegate::sizeHint
QSize sizeHint(const QStyleOptionViewItem &option, const QModelIndex &index) const override
Provides the ideal size for this column.
Definition ScriptRepositoryView.cpp:429

MantidQt::API::ScriptRepositoryView
ScriptRepositoryView : Provide the User Interface to the ScriptRepository.
Definition ScriptRepositoryView.h:26

MantidQt::API::ScriptRepositoryView::~ScriptRepositoryView
~ScriptRepositoryView() override
Destructor.
Definition ScriptRepositoryView.cpp:254

MantidQt::API::ScriptRepositoryView::ScriptRepositoryView
ScriptRepositoryView(QWidget *parent=nullptr)
Creates the widget for the ScriptRepositoryView.
Definition ScriptRepositoryView.cpp:92

MantidQt::API::ScriptRepositoryView::chooseLocationAndInstall
bool chooseLocationAndInstall(Mantid::API::ScriptRepository_sptr repo_ptr)
Prompt the user with where to install the script repository, and install it.
Definition ScriptRepositoryView.cpp:155

MantidQt::API::ScriptRepositoryView::openFolderLink
void openFolderLink(const QString &)
Attempt to open the given folder link using an appropriate application.
Definition ScriptRepositoryView.cpp:530

MantidQt::API::ScriptRepositoryView::helpClicked
void helpClicked()
Open the ScriptRepository Page on Web Browser.
Definition ScriptRepositoryView.cpp:298

MantidQt::API::ScriptRepositoryView::ui
Ui::ScriptRepositoryView * ui
Definition ScriptRepositoryView.h:72

MantidQt::API::ScriptRepositoryView::loadScript
void loadScript(const QString)

MantidQt::API::ScriptRepositoryView::currentChanged
void currentChanged(const QModelIndex &current)
This method will be executed every time the user change the selection.
Definition ScriptRepositoryView.cpp:281

MantidQt::API::ScriptRepositoryView::model
RepoModel * model
Definition ScriptRepositoryView.h:73

MantidQt::API::ScriptRepositoryView::updateModel
void updateModel()
This method refreshes the ScriptRepository and allows it to check list the files again.
Definition ScriptRepositoryView.cpp:236

MantidQt::API::ScriptRepositoryView::cell_activated
void cell_activated(const QModelIndex &)
Allows the user to open a file to investigate it.
Definition ScriptRepositoryView.cpp:262

MantidQt::API::ScriptRepositoryView::updateLocationString
void updateLocationString(const std::string &installDir)
Definition ScriptRepositoryView.cpp:213

Mantid::API::ScriptRepoException
The ScriptRepository class is intended to be used mainly by users, who will want to share and downloa...
Definition ScriptRepository.h:94

Mantid::API::ScriptRepoException::what
const char * what() const noexcept override
Returns the message string.
Definition ScriptRepository.cpp:25

Mantid::API::ScriptRepoException::systemError
const std::string & systemError() const
Returns the error description with technical details on the origin and cause.
Definition ScriptRepository.h:109

Mantid::Kernel::ConfigServiceImpl
The ConfigService class provides a simple facade to access the Configuration functionality of the Man...
Definition ConfigService.h:63

Mantid::Kernel::Logger
The Logger class is in charge of the publishing messages from the framework through various channels.
Definition Logger.h:51

Mantid::Kernel::Logger::error
void error(const std::string &msg)
Logs at error level.
Definition Logger.cpp:108

Mantid::Kernel::Logger::warning
void warning(const std::string &msg)
Logs at warning level.
Definition Logger.cpp:117

Mantid::Kernel::Logger::information
void information(const std::string &msg)
Logs at information level.
Definition Logger.cpp:136

MantidQt::API
Definition AlgorithmDialog.h:62

MantidQt::API::installation_in_progress
const QString installation_in_progress
Definition ScriptRepositoryView.cpp:49

MantidQt::API::install_mantid_label
const QString install_mantid_label
Definition ScriptRepositoryView.cpp:33

MantidQt::API::dir_not_empty_label
const QString dir_not_empty_label
Definition ScriptRepositoryView.cpp:62

MantidQt::API::installation_failed
const QString installation_failed
Definition ScriptRepositoryView.cpp:57

Mantid::API::ScriptRepository_sptr
std::shared_ptr< ScriptRepository > ScriptRepository_sptr
shared pointer to the ScriptRepository base class
Definition ScriptRepository.h:474

Mantid::API::ScriptRepositoryFactory
Mantid::Kernel::SingletonHolder< ScriptRepositoryFactoryImpl > ScriptRepositoryFactory
Definition ScriptRepositoryFactory.h:53

Mantid::Algorithms::g_log
Kernel::Logger g_log("DetermineSpinStateOrder")

Mantid::Kernel::ConfigService
Mantid::Kernel::SingletonHolder< ConfigServiceImpl > ConfigService
Definition ConfigService.h:309

Ui
Definition SelectFunctionDialog.h:19