scriptEditorWidget.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2020, Institut für Technische Optik (ITO),
    Universität Stuttgart, Germany
 
    This file is part of itom.
 
    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.
 
    itom is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library
    General Public Licence for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */
 
#ifndef SCRIPTEDITORWIDGET_H
#define SCRIPTEDITORWIDGET_H
 
#include "../models/breakPointModel.h"
 
#include "abstractCodeEditorWidget.h"
#include "../codeEditor/panels/foldingPanel.h"
#include "../codeEditor/panels/checkerBookmarkPanel.h"
#include "../codeEditor/panels/breakpointPanel.h"
#include "../codeEditor/modes/errorLineHighlight.h"
#include "../codeEditor/modes/pyGotoAssignment.h"
#include "../codeEditor/modes/pyDocstringGenerator.h"
#include "../codeEditor/modes/wordHoverTooltip.h"
#include "../codeEditor/panels/lineNumber.h"
#include "../codeEditor/codeCheckerItem.h"
#include "../codeEditor/pyCodeFormatter.h"
#include "../codeEditor/pyCodeReferenceRenamer.h"
#include "../global.h"
 
#include <qfilesystemwatcher.h>
#include <qwidget.h>
#include <qstring.h>
#include <qmenu.h>
#include <qevent.h>
#include <qpointer.h>
#include <qmetaobject.h>
#include <qsharedpointer.h>
#include <qregularexpression.h>
#include "../models/outlineItem.h"
#include "../models/bookmarkModel.h"
#include "../helper/IOHelper.h"
#include "../ui/dialogScriptCharsetEncoding.h"
 
#include <QtPrintSupport/qprinter.h>
 
QT_BEGIN_NAMESPACE
 
QT_END_NAMESPACE
 
 
 
namespace ito
{
 
class BreakPointModel;
 
struct ScriptEditorStorage
{
    QString     filename;
    int         firstVisibleLine;
    QList<int>  bookmarkLines; 
};
 
 
struct GoBackNavigationItem
{
    QString filename;
    int UID;
    QString shortText;
    int line;
    int column;
    QString origin;
};
 
}
 
Q_DECLARE_METATYPE(ito::ScriptEditorStorage) //must be outside of namespace
Q_DECLARE_METATYPE(QList<ito::ScriptEditorStorage>) //must be outside of namespace
Q_DECLARE_METATYPE(ito::GoBackNavigationItem) //must be outside of namespace
Q_DECLARE_METATYPE(QList<ito::GoBackNavigationItem>) //must be outside of namespace
 
namespace ito
{
 
 
class ScriptEditorWidget : public AbstractCodeEditorWidget
{
    Q_OBJECT
 
public:
    ScriptEditorWidget(BookmarkModel *bookmarkModel, QWidget* parent = nullptr);
    ~ScriptEditorWidget();
 
    RetVal saveFile(bool askFirst = true);
    RetVal saveAsFile(bool askFirst = true);
 
    RetVal openFile(const QString &fileName, bool ignorePresentDocument = false, QWidget *parent = nullptr);
 
    bool keepIndentationOnPaste() const;
    void setKeepIndentationOnPaste(bool value);
 
    inline QString getFilename() const {return m_filename; }
    inline bool hasNoFilename() const { return m_filename.isNull(); }
    inline int getUID() const { return m_uid; }
    bool getCanCopy() const;
    inline QString getUntitledName() const { return tr("Untitled%1").arg(m_uid); }
 
    RetVal setCursorPosAndEnsureVisible(const int line, bool errorMessageClick = false, bool showSelectedCallstackLine = false);
    RetVal showLineAndHighlightWord(const int line, const QString &highlightedText, Qt::CaseSensitivity caseSensitivity = Qt::CaseInsensitive);
 
    void removeCurrentCallstackLine(); 
 
    const ScriptEditorStorage saveState() const;
    RetVal restoreState(const ScriptEditorStorage &data);
 
    RetVal toggleBookmark(int line);
 
    virtual bool removeTextBlockUserData(TextBlockUserData* userData);
 
    void reportCurrentCursorAsGoBackNavigationItem(const QString &reason, int UIDFilter = -1);
 
    void startUndoRedo(bool unundoNotRedo);
 
    QSharedPointer<OutlineItem> parseOutline(bool forceParsing = false) const;
 
    bool currentLineCanHaveDocstring() const;
 
    IOHelper::CharsetEncodingItem charsetEncoding() const { return m_charsetEncoding; }
 
    void replaceOccurencesInCurrentScript(const QString &newValue, const QVector<ito::FileRenameItem> &renameItems);
 
    static QString filenameFromUID(int UID, bool &found);
 
protected:
 
    bool canInsertFromMimeData(const QMimeData *source) const;
    void insertFromMimeData(const QMimeData *source);
 
    void dropEvent(QDropEvent *event);
    void dragEnterEvent(QDragEnterEvent *event);
    void dragLeaveEvent(QDragLeaveEvent *event);
    virtual void loadSettings();
    bool event(QEvent *event);
    void mouseReleaseEvent(QMouseEvent *event);
    void mousePressEvent(QMouseEvent *event);
    void keyPressEvent(QKeyEvent *event);
 
    virtual void contextMenuAboutToShow(int contextMenuLine);
 
    void reportGoBackNavigationCursorMovement(const CursorPosition &cursor, const QString &origin) const;
 
    void replaceSelectionAndKeepBookmarksAndBreakpoints(QTextCursor &cursor, const QString &newString);
    QVector<int> compareTexts(const QString &oldText, const QString &newText);
 
    BreakPointModel* getBreakPointModel();
    const BreakPointModel* getBreakPointModel() const;
 
private:
    enum markerType
    {
        markerBookmark = 1,
        markerPyBug = 2,
        markerBookmarkAndPyBug = markerBookmark | markerPyBug
    };
 
    RetVal initEditor();
    void initMenus();
 
    bool lineAcceptsBPs(int line);
 
    RetVal changeFilename(const QString &newFilename);
 
    IOHelper::CharsetEncodingItem guessEncoding(const QByteArray &content) const;
 
    void changeFileSaveEncoding(const IOHelper::CharsetEncodingItem &encoding);
 
    QFileSystemWatcher *m_pFileSysWatcher;
 
    // the following variables are related to the code checker feature of Python
    bool m_codeCheckerEnabled;
    int m_codeCheckerInterval;      
    QTimer *m_codeCheckerCallTimer; 
 
    Qt::CaseSensitivity m_filenameCaseSensitivity;
 
    std::map<QString,QAction*> m_editorMenuActions;
 
    QString m_filename; 
    int m_uid;
 
    //go back navigation features
    bool m_cursorJumpLastAction; 
    CursorPosition m_cursorBeforeMouseClick;
 
    bool m_pythonBusy; 
    bool m_pythonExecutable;
 
    bool m_wasReadonly;
    bool m_canCopy;
    bool m_keepIndentationOnPaste;
    int m_textBlockLineIdxAboutToBeDeleted; 
    BookmarkModel *m_pBookmarkModel; 
 
    QSharedPointer<PyCodeFormatter> m_pyCodeFormatter;
    QSharedPointer<PyCodeReferenceRenamer> m_pyCodeReferenceRenamer;
 
    QString m_autoCodeFormatCmd;
 
    QString m_autoCodeFormatPreCmd;
 
    IOHelper::CharsetEncodingItem m_charsetEncoding;
    bool m_charsetDefined;
    bool m_charsetEncodingAutoGuess;
 
    QSharedPointer<FoldingPanel> m_foldingPanel;
    QSharedPointer<CheckerBookmarkPanel> m_checkerBookmarkPanel;
    QSharedPointer<BreakpointPanel> m_breakpointPanel;
    QSharedPointer<ErrorLineHighlighterMode> m_errorLineHighlighterMode;
    QSharedPointer<LineNumberPanel> m_lineNumberPanel;
    QSharedPointer<PyGotoAssignmentMode> m_pyGotoAssignmentMode;
    QSharedPointer<WordHoverTooltipMode> m_wordHoverTooltipMode;
    QSharedPointer<PyDocstringGeneratorMode> m_pyDocstringGeneratorMode;
 
    static const QString lineBreak;
    static int currentMaximumUID;
    static CursorPosition currentGlobalEditorCursorPos; 
    static QHash<int, ScriptEditorWidget*> editorByUID; 
 
    // Outline
    QTimer *m_outlineTimer; 
    bool m_outlineTimerEnabled; 
    int m_currentLineIndex; 
    mutable QSharedPointer<OutlineItem> m_rootOutlineItem; 
    mutable bool m_outlineDirty;
    QRegularExpression m_regExpClass; 
    QRegularExpression m_regExpDecorator; 
    QRegularExpression m_regExpMethodStart; 
    QRegularExpression m_regExpMethod; 
 
    void parseOutlineRecursive(QSharedPointer<OutlineItem> &parent) const;
    QSharedPointer<OutlineItem> checkBlockForOutlineItem(int startLineIdx, int endLineIdx) const;
 
signals:
    void pythonRunFile(QString filename);
    void pythonRunSelection(QString selectionText);
    void pythonDebugFile(QString filename);
    void closeRequest(ScriptEditorWidget* sew, bool ignoreModifications); //signal emitted if this tab should be closed without considering any save-state
    void marginChanged();
    void outlineModelChanged(ScriptEditorWidget *editor, QSharedPointer<OutlineItem> rootItem);
    void addGoBackNavigationItem(const GoBackNavigationItem &item);
    void tabChangeRequested();
    void findSymbolsShowRequested();
 
public slots:
    void triggerCodeChecker();
    void codeCheckResultsReady(QList<ito::CodeCheckerItem> codeCheckerItems);
    void codeCheckerResultsChanged(const QList<ito::CodeCheckerItem> &codeCheckerItems);
 
    void menuCut();
    void menuCopy();
    void menuPaste();
    void menuIndent();
    void menuUnindent();
    void menuComment();
    void menuUncomment();
 
    void menuFoldAll();
    void menuUnfoldAll();
    void menuFoldUnfoldToplevel();
    void menuFoldUnfoldAll();
 
    void menuRunScript();
    void menuRunSelection();
    void menuDebugScript();
    void menuStopScript();
 
    void menuPyCodeFormatting();
    bool menuPyCodeReferenceRenaming();
    void menuGenerateDocstring();
    void menuScriptCharsetEncoding();
 
    void pythonStateChanged(tPythonTransitions pyTransition);
    void pythonDebugPositionChanged(QString filename, int lineno);
 
    void breakPointAdd(BreakPointItem bp, int row);
    void breakPointDelete(QString filename, int lineIdx, int pyBpNumber);
    void breakPointChange(BreakPointItem oldBp, BreakPointItem newBp);
 
    void updateSyntaxCheck();
 
    void print();
 
private slots:
    void toggleBookmarkRequested(int line);
    void onBookmarkAdded(const BookmarkItem &item);
    void onBookmarkDeleted(const BookmarkItem &item);
 
    RetVal toggleBreakpoint(int line);
    RetVal toggleEnableBreakpoint(int line);
    RetVal editBreakpoint(int line);
    RetVal clearAllBreakpoints();
    RetVal gotoNextBreakPoint();
    RetVal gotoPreviousBreakPoint();
 
    void gotoAssignmentOutOfDoc(PyAssignment ref);
 
    void copyAvailable(const bool yes);
 
    void outlineTimerElapsed();
 
    void nrOfLinesChanged();
 
    void fileSysWatcherFileChanged(const QString &path);
    void fileSysWatcherFileChangedStep2(const QString &path);
    void printPreviewRequested(QPrinter *printer);
 
    void dumpFoldsToConsole(bool);
    void onCursorPositionChanged();
    void onTextChanged();
    void tabChangeRequest();
 
    void pyCodeFormatterDone(bool success, QString code);
};
 
} //end namespace ito
 
#endif