scriptEditorWidget.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2020, Institut fuer Technische Optik (ITO),
    Universitaet 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 "../global.h"

#include <qfilesystemwatcher.h>
#include <qwidget.h>
#include <qstring.h>
#include <qmenu.h>
#include <qevent.h>
#include <qmetaobject.h>
#include <qsharedpointer.h>
#include <qregularexpression.h>
#include "../models/outlineItem.h"
#include "../models/bookmarkModel.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(QString file, bool ignorePresentDocument = false);

    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;

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

    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;
    QString m_autoCodeFormatCmd; 

    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();
    void menuGenerateDocstring();
    void menuInsertCodec();

    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