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/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>  * Share your scripts and reduction algorithms;</p>"

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

                                     "the mantid developers and the community. </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://www.mantidproject.org/ScriptRepository\"><span style=\" "

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

                                     "http://www.mantidproject.org/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 could be shared in the repository by "

                                    "mistake.</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;

  enum EXC_OPTIONS { NOTWANTED, NODIRECTORY };


  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()) {

      // No. It has never been installed.

      // 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

      ConfigServiceImpl &config = ConfigService::Instance();

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


      bool sureAboutDir = false;


      QString dir;

      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;

        }

      }


      // attempt to install

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

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

    }

    // create the model

    model = new RepoModel(this);


  } 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;

  } 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

  ui->setupUi(this);

  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->setItemDelegateForColumn(3, new RemoveEntryDelegate(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();

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

  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));

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

}


void ScriptRepositoryView::updateModel() {

  RepoModel *before = model;

  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() {

  MantidDesktopServices::openUrl(QUrl("http://www.mantidproject.org/ScriptRepository"));

}


// 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);


  // define the region to draw the icon

  QRect buttonRect(option.rect);

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

  // make it square

  buttonRect.setWidth(min_val);

  buttonRect.setHeight(min_val);

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


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

  QStyleOptionButton button;

  button.rect = buttonRect;

  button.icon = icon;

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

  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::localOnlySt() || state == RepoModel::localChangedSt())

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

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

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

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

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

  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();

    QString action = "Download";

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

      action = "Upload";

    if (value == RepoModel::updatedSt())

      return false; // ignore

    return model->setData(index, action, 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

  }

}

// RemoveEntryDelegate


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

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

                                                      const QModelIndex &index) const {


  if (!index.isValid())

    return;

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

    return;


  QIcon icon;

  // get the state and chose the best fit icon

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


  if (entry_type == "protected")

    return;


  icon = Icons::getIcon("mdi.trash-can");


  // define the region to draw the icon

  QRect buttonRect(option.rect);

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

  // make it square

  buttonRect.setWidth(min_val);

  buttonRect.setHeight(min_val);

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


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

  QStyleOptionButton button;

  button.rect = buttonRect;

  button.icon = icon;

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

  button.iconSize = QSize(icon_size, icon_size);

  button.state = QStyle::State_Enabled;

  // draw a push button

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

}


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

                                                            const QStyleOptionViewItem & /*option*/,

                                                            const QModelIndex &index) {

  // if event is mouse click

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

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

    if (entry == "protected")

      return true;

    QString action = "delete";

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

  } else {

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

                 // double-click)

  }

}


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

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::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:75

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

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

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

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

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

MantidQt::API::RepoModel::uploadSt
static const QString & uploadSt()
Definition: RepoModel.cpp:947

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

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

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

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

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

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

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

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

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:474

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:424

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

MantidQt::API::ScriptRepositoryView::RemoveEntryDelegate
Delegate to show the icon to remove the entry from the local and central repository.
Definition: ScriptRepositoryView.h:49

MantidQt::API::ScriptRepositoryView::RemoveEntryDelegate::paint
void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const override
Draws the column 3 (delete) of ScriptRepositoryView.
Definition: ScriptRepositoryView.cpp:506

MantidQt::API::ScriptRepositoryView::RemoveEntryDelegate::RemoveEntryDelegate
RemoveEntryDelegate(QObject *parent=nullptr)
Definition: ScriptRepositoryView.cpp:492

MantidQt::API::ScriptRepositoryView::RemoveEntryDelegate::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:561

MantidQt::API::ScriptRepositoryView::RepoDelegate
Delegate to show the icons Download and Upload.
Definition: ScriptRepositoryView.h:29

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

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

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:373

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:303

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:393

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

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

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

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

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

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

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:252

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

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

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

Mantid::API::ScriptRepoException
The ScriptRepository class is intended to be used mainly by the users, who will be willing to share a...
Definition: ScriptRepository.h:97

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:52

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

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

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

Mantid::Kernel::SingletonHolder
Manage the lifetime of a class intended to be a singleton.
Definition: SingletonHolder.h:41

MantidQt::API
Definition: AlgorithmDialog.h:62

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

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

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

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

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

Mantid::API::g_log
Kernel::Logger g_log("ExperimentInfo")
static logger object

Ui
Definition: SelectFunctionDialog.h:19