lua_debugger_code_editor.h

Go to the documentation of this file.

/* lua_debugger_code_editor.h
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <[email protected]>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

 
#ifndef LUA_DEBUGGER_CODE_EDITOR_H
#define LUA_DEBUGGER_CODE_EDITOR_H
 
#include <QColor>
#include <QFont>
#include <QObject>
#include <QPlainTextEdit>
#include <QPoint>
#include <QRegularExpression>
#include <QString>
#include <QSyntaxHighlighter>
#include <QTextCharFormat>
#include <QTextCursor>
#include <QVector>
#include <QtGlobal>
 
class LuaDebuggerCodeView;
class LuaDebuggerDialog;
class QContextMenuEvent;
class QEvent;
class QPlainTextEdit;
class QStandardItemModel;
class QSyntaxHighlighter;
class QTabWidget;
class QTextDocument;
class QTreeView;
 
/* ===== code_palette ===== */

struct LuaDebuggerEditorPalette
{
    QColor editorBackground;
    QColor editorText;
    QColor selection;
    QColor selectionText;
 
    QColor gutterBackground;
    QColor gutterText;

    QColor pausedLine;
};

bool luaDebuggerThemeIsDark();

LuaDebuggerEditorPalette luaDebuggerEditorPaletteFor(bool isDark);
 
/* ===== lua_highlighter ===== */

class LuaSyntaxHighlighter : public QSyntaxHighlighter
{
  public:
    explicit LuaSyntaxHighlighter(QTextDocument *parent, bool isDark);

    void setTheme(bool isDark);
 
  protected:
    void highlightBlock(const QString &text) override;
 
  private:
    struct Rule
    {
        QRegularExpression pattern;  
        QTextCharFormat format;      
    };
 
 
    QVector<Rule> rules_;                    
    QTextCharFormat stringFormat_;           
    QTextCharFormat commentFormat_;          
    QRegularExpression singleLineComment_;   

    bool highlightLongBlock(const QString &text, bool isComment, bool continuingPrevious, qint32 eqCountFromState,
                            qint32 &nextStateEqCount);
    qint32 findLongBlockStart(const QString &text, qint32 from, bool isComment, qint32 &eqCount,
                              qint32 &tokenLength) const;
    qint32 findLongBlockEnd(const QString &text, qint32 from, qint32 eqCount) const;

    void buildRules(bool isDark);
};
 
/* ===== code_view ===== */

class LuaDebuggerCodeView : public QPlainTextEdit
{
    Q_OBJECT
 
  public:
    LuaDebuggerCodeView(QWidget *parent = nullptr);

    void lineNumberAreaPaintEvent(QPaintEvent *event);
    qint32 lineNumberAreaWidth();

    void setFilename(const QString &f) { filename = f; }

    QString getFilename() const { return filename; }

    void setCurrentLine(qint32 line);
    void clearCurrentLineHighlight();
    void moveCaretToLineStart(qint32 line);
    void setEditorFont(const QFont &font);

    void updateBreakpointMarkers();

    void applyTheme();

    QString luaIdentifierUnderCursor(const QTextCursor &cursor) const;

    QString watchExpressionForContextMenu(const QPoint &viewportPos) const;
 
  signals:
    void breakpointToggled(const QString &filename, qint32 line, bool toggleActive);

    void breakpointMoveRequested(const QString &filename, qint32 fromLine, qint32 toLine);

    void breakpointGutterMenuRequested(const QString &filename, qint32 line, const QPoint &globalPos);
 
  protected:
    void resizeEvent(QResizeEvent *event) override;
    bool eventFilter(QObject *watched, QEvent *event) override;
 
  private slots:
    void updateLineNumberAreaWidth(int newBlockCount);
    void rebuildLineHighlights();
    void updateLineNumberArea(const QRect &rect, int dy);
 
  private:
    QWidget *lineNumberArea;
    QSyntaxHighlighter *syntaxHighlighter;
    qint32 pausedExecutionLine_ = -1;

    friend class LineNumberArea;

    QString filename;
    void applyEditorPalette();
};

class LineNumberArea : public QWidget
{
  public:
    LineNumberArea(LuaDebuggerCodeView *editor) : QWidget(editor), codeEditor(editor) {}

    QSize sizeHint() const override { return QSize(codeEditor->lineNumberAreaWidth(), 0); }

    bool isDraggingBreakpoint() const { return draggingBreakpoint_; }

    qint32 dragTargetLine() const { return dragTargetLine_; }

    qint32 dragSourceLine() const { return pressedLine_; }
 
  protected:
    void paintEvent(QPaintEvent *event) override { codeEditor->lineNumberAreaPaintEvent(event); }

    void mousePressEvent(QMouseEvent *event) override;

    void mouseMoveEvent(QMouseEvent *event) override;

    void mouseReleaseEvent(QMouseEvent *event) override;

    void contextMenuEvent(QContextMenuEvent *event) override;
 
  private:
    LuaDebuggerCodeView *codeEditor;

    qint32 lineAtY(qint32 yPx) const;

    bool hasBreakpointAtLine(qint32 line) const;

    qint32 nearestVisibleDropLine(qint32 yPx, qint32 sourceLine) const;

    QPoint pressPos_;

    qint32 pressedLine_ = -1;

    qint32 dragTargetLine_ = -1;

    bool leftPressArmed_ = false;

    bool draggingBreakpoint_ = false;

    bool pressShiftToggle_ = false;

    bool pressHadBreakpoint_ = false;
};
 
/* ===== font_policy ===== */

class LuaDebuggerFontPolicy
{
  public:
    LuaDebuggerFontPolicy() = default;

    void attach(QTabWidget *codeTabs, QTreeView *variablesTree, QTreeView *watchTree, QStandardItemModel *watchModel,
                QTreeView *stackTree, QTreeView *fileTree, QTreeView *breakpointsTree,
                QPlainTextEdit *evalInputEdit, QPlainTextEdit *evalOutputEdit);

    void applyAll();

    void applyToCodeEditors(const QFont &font = QFont());

    void applyToPanels();

    void reapplyToWatchItemModel();

    QFont monospaceFont(bool zoomed) const;

    QFont regularFont() const;
 
  private:
    QTabWidget *codeTabs_ = nullptr;
    QTreeView *variablesTree_ = nullptr;
    QTreeView *watchTree_ = nullptr;
    QStandardItemModel *watchModel_ = nullptr;
    QTreeView *stackTree_ = nullptr;
    QTreeView *fileTree_ = nullptr;
    QTreeView *breakpointsTree_ = nullptr;
    QPlainTextEdit *evalInputEdit_ = nullptr;
    QPlainTextEdit *evalOutputEdit_ = nullptr;
};
 
/* ===== code_tabs_controller ===== */

class LuaDebuggerCodeTabsController : public QObject
{
    Q_OBJECT
 
  public:
    explicit LuaDebuggerCodeTabsController(LuaDebuggerDialog *host);

    void attach(QTabWidget *tabs);

    QTabWidget *tabs() const { return tabs_; }

    QString lastOpenDirectory();

    void setLastOpenDirectory(const QString &dir);

    LuaDebuggerCodeView *loadFile(const QString &file_path);

    LuaDebuggerCodeView *currentCodeView() const;

    qint32 unsavedOpenScriptTabCount() const;

    bool hasUnsavedChanges() const;

    bool ensureUnsavedChangesHandled(const QString &title);

    void clearAllDocumentModified();

    bool saveCodeView(LuaDebuggerCodeView *view);

    bool saveAllModified();

    void updateTabTextForCodeView(LuaDebuggerCodeView *view);

    void updateSaveActionState();

    void updateWindowModifiedState();

    void openInitialBreakpointFiles(const QVector<QString> &files);

    void clearAllCodeHighlights();

    void applyThemeToAllTabs();
 
  public slots:
    void onTabCloseRequested(int index);

    void onCurrentTabChanged(int index);

    void onSaveFile();
 
  private:
    void onCodeViewBreakpointToggled(const QString &file_path, qint32 line, bool toggleActive);

    LuaDebuggerDialog *host_ = nullptr;

    QTabWidget *tabs_ = nullptr;

    QString lastOpenDirectory_;
};
 
#endif