ScriptEditor.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/ScriptEditor.h"
#include "MantidQtWidgets/Common/AlternateCSPythonLexer.h"
#include "MantidQtWidgets/Common/FindReplaceDialog.h"
 
// Qt
#include <QApplication>
#include <QFile>
#include <QFileDialog>
 
#include <QAction>
#include <QClipboard>
#include <QKeyEvent>
#include <QMenu>
#include <QMessageBox>
#include <QMimeData>
#include <QMouseEvent>
#include <QPrintDialog>
#include <QPrinter>
#include <QScrollBar>
#include <QSettings>
#include <QShortcut>
#include <QTextStream>
#include <QThread>
 
// Qscintilla
#include <Qsci/qsciapis.h>
#include <Qsci/qscicommandset.h>
 
// std
#include <cmath>
#include <stdexcept>
#include <utility>
 
namespace {
 
QsciLexer *createLexerFromName(const QString &lexerName, const QFont &font) {
  if (lexerName == "Python") {
    return new QsciLexerPython;
  } else if (lexerName == "AlternateCSPython") {
    return new AlternateCSPythonLexer(font);
  } else {
    throw std::invalid_argument("createLexerFromLanguage: Unsupported "
                                "name. Supported names=Python, AlternateCSPython");
  }
}
} // namespace
 
// The colour for a success marker
QColor ScriptEditor::g_success_colour = QColor("lightgreen");
// The colour for an error marker
QColor ScriptEditor::g_error_colour = QColor("red");
 
//------------------------------------------------
// Public member functions
//------------------------------------------------
ScriptEditor::ScriptEditor(const QString &lexerName, const QFont &font, QWidget *parent)
    : ScriptEditor(parent, createLexerFromName(lexerName, font)) {}
 
ScriptEditor::ScriptEditor(QWidget *parent, QsciLexer *codelexer, QString settingsGroup)
    : QsciScintilla(parent), m_filename(""), m_progressArrowKey(markerDefine(QsciScintilla::RightArrow)),
      m_currentExecLine(0), m_completer(nullptr), m_previousKey(0), m_findDialog(new FindReplaceDialog(this)),
      m_settingsGroup(std::move(settingsGroup)) {
// Older versions of QScintilla still use just CR as the line ending, which is
// pre-OSX.
// New versions just use unix-style for everything but Windows.
#if defined(Q_OS_WIN)
  setEolMode(EolWindows);
#else
  setEolMode(EolUnix);
#endif
 
  // Remove the shortcut for zooming in because this is dealt with in
  // keyPressEvent
  clearKeyBinding("Ctrl++");
 
  // Syntax highlighting and code completion
  setLexer(codelexer);
  readSettings();
 
  setMarginLineNumbers(1, true);
 
  // Editor properties
  setAutoIndent(true);
  setFocusPolicy(Qt::StrongFocus);
  emit undoAvailable(isUndoAvailable());
  emit redoAvailable(isRedoAvailable());
}
 
ScriptEditor::~ScriptEditor() {
  if (m_completer) {
    delete m_completer;
  }
  if (QsciLexer *current = lexer()) {
    delete current;
  }
}
 
void ScriptEditor::setSettingsGroup(const QString &name) { m_settingsGroup = name; }
 
 
QString ScriptEditor::settingsGroup() const { return m_settingsGroup; }
 
void ScriptEditor::readSettings() {}
 
void ScriptEditor::writeSettings() {}
 
void ScriptEditor::setLexer(QsciLexer *codelexer) {
  if (!codelexer) {
    if (m_completer) {
      delete m_completer;
      m_completer = nullptr;
    }
    return;
  }
 
  // Delete the current lexer if one is installed
  if (QsciLexer *current = lexer()) {
    delete current;
  }
  this->QsciScintilla::setLexer(codelexer);
 
  if (m_completer) {
    delete m_completer;
    m_completer = nullptr;
  }
 
  m_completer = new QsciAPIs(codelexer);
}
 
void ScriptEditor::setAutoMarginResize() { connect(this, SIGNAL(linesChanged()), this, SLOT(padMargin())); }
 
void ScriptEditor::enableAutoCompletion(AutoCompletionSource source) {
  setAutoCompletionSource(source);
  setAutoCompletionThreshold(2);
  setCallTipsStyle(QsciScintilla::CallTipsNoAutoCompletionContext);
  setCallTipsVisible(0); // This actually makes all of them visible
}
 
void ScriptEditor::disableAutoCompletion() {
  setAutoCompletionSource(QsciScintilla::AcsNone);
  setAutoCompletionThreshold(-1);
  setCallTipsVisible(-1);
}
 
QSize ScriptEditor::sizeHint() const { return QSize(600, 500); }
 
void ScriptEditor::saveAs() {
  QString selectedFilter;
  QString filter = "Scripts (*.py *.PY);;All Files (*)";
  QString filename = QFileDialog::getSaveFileName(nullptr, "Save file...", "", filter, &selectedFilter);
 
  if (filename.isEmpty()) {
    throw SaveCancelledException();
  }
  if (QFileInfo(filename).suffix().isEmpty()) {
    QString ext = selectedFilter.section('(', 1).section(' ', 0, 0);
    ext.remove(0, 1);
    if (ext != ")")
      filename += ext;
  }
  saveScript(filename);
}
 
void ScriptEditor::saveToCurrentFile() {
  QString filename = fileName();
  if (filename.isEmpty()) {
    saveAs();
    return;
  } else {
    saveScript(filename);
  }
}
 
void ScriptEditor::saveScript(const QString &filename) {
  QFile file(filename);
  if (!file.open(QIODevice::WriteOnly)) {
    QString msg = QString("Could not open file \"%1\" for writing.").arg(filename);
    throw std::runtime_error(qPrintable(msg));
  }
 
  m_filename = filename;
  writeToDevice(file);
  file.close();
  setModified(false);
}
 
void ScriptEditor::setText(int lineno, const QString &txt, int index) {
  int line_length = txt.length();
  // Index is max of the length of current/new text
  setSelection(lineno, index, lineno, qMax(line_length, this->text(lineno).length()));
  removeSelectedText();
  insertAt(txt, lineno, index);
  setCursorPosition(lineno, line_length);
}
 
void ScriptEditor::keyPressEvent(QKeyEvent *event) {
  // The built-in shortcut Ctrl++ from QScintilla doesn't work for some reason
  // Creating a new QShortcut makes Ctrl++ to zoom in on the IPython console
  // stop working
  // So here is where Ctrl++ is detected to zoom in
  if (QApplication::keyboardModifiers() & Qt::ControlModifier &&
      (event->key() == Qt::Key_Plus || event->key() == Qt::Key_Equal)) {
    zoomIn();
    emit textZoomedIn();
  } else {
    // Avoids a bug in QScintilla
    forwardKeyPressToBase(event);
  }
 
  // There is a built in Ctrl+- shortcut for zooming out, but a signal is
  // emitted here to tell the other editor tabs to also zoom out
  if (QApplication::keyboardModifiers() & Qt::ControlModifier && (event->key() == Qt::Key_Minus)) {
    emit textZoomedOut();
  }
}
 
/*
 * @param filename The new filename
 */
void ScriptEditor::setFileName(const QString &filename) {
  m_filename = filename;
  emit fileNameChanged(filename);
}
 
void ScriptEditor::wheelEvent(QWheelEvent *e) {
  if (e->modifiers() == Qt::ControlModifier) {
    if (e->angleDelta().y() > 0) {
      zoomIn();
      emit textZoomedIn(); // allows tracking
    } else {
      zoomOut();
      emit textZoomedOut(); // allows tracking
    }
  } else {
    QsciScintilla::wheelEvent(e);
  }
}
/*
 *  Remove shortcut key binding from its command.
 *  @param keyCombination :: QString of the key combination e.g. "Ctrl+/".
 */
void ScriptEditor::clearKeyBinding(const QString &keyCombination) {
  int keyIdentifier = QKeySequence(keyCombination)[0];
  if (QsciCommand::validKey(keyIdentifier)) {
    QsciCommand *cmd = standardCommands()->boundTo(keyIdentifier);
    if (cmd) { 
      cmd->setKey(0);
    } else {
      throw std::invalid_argument("Key combination is not set by Scintilla.");
    }
  } else {
    throw std::invalid_argument("Key combination is not valid!");
  }
}
 
//-----------------------------------------------
// Public slots
//-----------------------------------------------
void ScriptEditor::padMargin() {
  const int minWidth = 38;
  int width = minWidth;
  int ntens = static_cast<int>(std::log10(static_cast<double>(lines())));
  if (ntens > 1) {
    width += 5 * ntens;
  }
  setMarginWidth(1, width);
}
 
void ScriptEditor::setMarkerState(bool enabled) {
  if (enabled) {
    setMarkerBackgroundColor(QColor("gray"), m_progressArrowKey);
    markerAdd(0, m_progressArrowKey);
  } else {
    markerDeleteAll();
  }
}
 
void ScriptEditor::updateProgressMarkerFromThread(int lineno, bool error) {
  if (QThread::currentThread() != QApplication::instance()->thread()) {
    QMetaObject::invokeMethod(this, "updateProgressMarker", Qt::AutoConnection, Q_ARG(int, lineno), Q_ARG(bool, error));
  } else {
    updateProgressMarker(lineno, error);
  }
}
 
void ScriptEditor::updateProgressMarker(int lineno, bool error) {
 
  m_currentExecLine = lineno;
  if (error) {
    setMarkerBackgroundColor(g_error_colour, m_progressArrowKey);
  } else {
    setMarkerBackgroundColor(g_success_colour, m_progressArrowKey);
  }
  markerDeleteAll();
  // Check the lineno actually exists, -1 means delete
  if (lineno <= 0 || lineno > this->lines())
    return;
 
  ensureLineVisible(lineno);
  markerAdd(m_currentExecLine - 1, m_progressArrowKey);
  progressMade(lineno);
}
 
void ScriptEditor::markExecutingLineAsError() { updateProgressMarker(m_currentExecLine, true); }
 
void ScriptEditor::updateCompletionAPI(const QStringList &keywords) {
  if (!m_completer)
    return;
  QStringListIterator iter(keywords);
  m_completer->clear();
  while (iter.hasNext()) {
    QString item = iter.next();
    m_completer->add(item);
  }
  m_completer->add("{");
 
  m_completer->prepare();
}
 
void ScriptEditor::dragMoveEvent(QDragMoveEvent *de) {
  if (!de->mimeData()->hasUrls())
    // pass to base class - This handles text appropriately
    QsciScintilla::dragMoveEvent(de);
}
 
void ScriptEditor::dragEnterEvent(QDragEnterEvent *de) {
  if (!de->mimeData()->hasUrls()) {
    QsciScintilla::dragEnterEvent(de);
  }
}
 
QByteArray ScriptEditor::fromMimeData(const QMimeData *source, bool &rectangular) const {
  return QsciScintilla::fromMimeData(source, rectangular);
}
 
void ScriptEditor::dropEvent(QDropEvent *de) {
  if (!de->mimeData()->hasUrls()) {
    QDropEvent localDrop(*de);
    // pass to base class - This handles text appropriately
    QsciScintilla::dropEvent(&localDrop);
  }
}
 
void ScriptEditor::print() {
  QPrinter printer(QPrinter::HighResolution);
  auto *print_dlg = new QPrintDialog(&printer, this);
  print_dlg->setWindowTitle(tr("Print Script"));
  if (print_dlg->exec() != QDialog::Accepted) {
    return;
  }
  QTextDocument document(text());
  document.print(&printer);
}
 
void ScriptEditor::showFindReplaceDialog() { m_findDialog->show(); }
 
void ScriptEditor::zoomTo(int level) {
#ifdef __APPLE__
  // Make all fonts 4 points bigger on the Mac because otherwise they're tiny!
  level += 4;
#endif
  QsciScintilla::zoomTo(level);
}
 
void ScriptEditor::writeToDevice(QIODevice &device) const { this->write(&device); }
 
//------------------------------------------------
// Private member functions
//------------------------------------------------
 
void ScriptEditor::forwardKeyPressToBase(QKeyEvent *event) {
  // Hack to get around a bug in QScitilla
  // If you pressed ( after typing in a autocomplete command the calltip does
  // not appear, you have to delete the ( and type it again
  // This does that for you!
  if (event->text() == "(") {
    auto *backspEvent = new QKeyEvent(QEvent::KeyPress, Qt::Key_Backspace, Qt::NoModifier);
    auto *bracketEvent = new QKeyEvent(*event);
    QsciScintilla::keyPressEvent(bracketEvent);
    QsciScintilla::keyPressEvent(backspEvent);
 
    delete backspEvent;
    delete bracketEvent;
  }
 
  QsciScintilla::keyPressEvent(event);
 
// Only need to do this for Unix and for QScintilla version < 2.4.2. Moreover,
// only Gnome but I don't think we can detect that
#ifdef Q_OS_LINUX
#if QSCINTILLA_VERSION < 0x020402
  // If an autocomplete box has surfaced, correct the window flags.
  // Unfortunately the only way to
  // do this is to search through the child objects.
  if (isListActive()) {
    QObjectList children = this->children();
    QListIterator<QObject *> itr(children);
    // Search is performed in reverse order as we want the last one created
    itr.toBack();
    while (itr.hasPrevious()) {
      QObject *child = itr.previous();
      if (child->inherits("QListWidget")) {
        QWidget *w = qobject_cast<QWidget *>(child);
        w->setWindowFlags(Qt::ToolTip | Qt::WindowStaysOnTopHint);
        w->show();
        break;
      }
    }
  }
#endif
#endif
}
 
void ScriptEditor::replaceAll(const QString &searchString, const QString &replaceString, bool regex, bool caseSensitive,
                              bool matchWords, bool wrap, bool forward) {
  int line(-1), index(-1), prevLine(-1), prevIndex(-1);
 
  // Mark this as a set of actions that can be undone as one
  this->beginUndoAction();
  bool found = this->findFirst(searchString, regex, caseSensitive, matchWords, wrap, forward, 0, 0);
  // If find first fails then there is nothing to replace
  if (!found) {
    QMessageBox::information(this, "Mantid - Find and Replace", "No matches found in current document.");
  }
 
  while (found) {
    this->getCursorPosition(&prevLine, &prevIndex);
    this->replace(replaceString);
    found = this->findNext();
    this->getCursorPosition(&line, &index);
    // if the next match is on the previous line
    // or if it is on the same line, but closer to the start
    // it means we have wrapped around the text in the editor
    if (line < prevLine || (line == prevLine && index <= prevIndex)) {
      break;
    }
  }
  this->endUndoAction();
}
 
int ScriptEditor::getZoom() const { return static_cast<int>(SendScintilla(SCI_GETZOOM)); }