lua_debugger_dialog.h

Go to the documentation of this file.

/* lua_debugger_dialog.h
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */

 
#ifndef LUA_DEBUGGER_DIALOG_H
#define LUA_DEBUGGER_DIALOG_H
 
#include <QBrush>
#include <QCheckBox>
#include <QComboBox>
#include <QFont>
#include <QHash>
#include <QIcon>
#include <QKeySequence>
#include <QList>
#include <QModelIndex>
#include <QObject>
#include <QPair>
#include <QPlainTextEdit>
#include <QPointer>
#include <QPushButton>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QStandardItem>
#include <QStandardItemModel>
#include <QTreeView>
#include <QVariantMap>
#include <QVector>
 
#include "epan/wslua/wslua_debugger.h"
#include "geometry_state_dialog.h"
#include "lua_debugger_breakpoints.h"
#include "lua_debugger_code_editor.h"
#include "lua_debugger_evaluate.h"
#include "lua_debugger_files.h"
#include "lua_debugger_pause.h"
#include "lua_debugger_settings.h"
#include "lua_debugger_stack.h"
#include "lua_debugger_utils.h"
#include "lua_debugger_variables.h"
#include "lua_debugger_watch.h"
 
class QToolButton;
 
struct _capture_session;
 
class AccordionFrame;
class CollapsibleSection;
class QAction;
class QEvent;
class QChildEvent;
class QCloseEvent;
class QShowEvent;
class QSplitter;
 
namespace Ui
{
class LuaDebuggerDialog;
}
 
class LuaDebuggerCodeView;
class LuaDebuggerDialog;

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

    void handlePreReload();

    void handlePostReload();

    bool takeDeferredReload();
 
  public slots:
    void onReloadLuaPluginsRequested();
 
  private:
    void enterReloadUiStateIfEnabled();

    void exitReloadUiState();

    void reloadAllScriptFilesFromDisk();
 
    LuaDebuggerDialog *host_ = nullptr; 
    bool reloadDeferred_ = false;       
    bool reloadUiActive_ = false;       
    bool reloadUiRequestWasEnabled_ = false; 
};

namespace LuaDebuggerMainClosePolicy
{

bool handleMainCloseIfPaused(QCloseEvent *event);

void deliverDeferredMainCloseIfPending();

void markQuitRequested();

void cancelPendingClose();
 
} // namespace LuaDebuggerMainClosePolicy

class LuaDebuggerDialog : public GeometryStateDialog
{
    Q_OBJECT
 
  public:
    explicit LuaDebuggerDialog(QWidget *parent = nullptr);

    ~LuaDebuggerDialog();

    static LuaDebuggerDialog *instance(QWidget *parent = nullptr);

    static LuaDebuggerDialog *instanceIfExists();

    static bool handleMainCloseIfPaused(QCloseEvent *event);

    void handlePause(const char *file_path, int64_t line);

    void reject() override;

    void addWatchFromSpec(const QString &watchSpec);

    LuaDebuggerChangeHighlightTracker &changeHighlight() { return changeHighlight_; }

    LuaDebuggerStackController &stackController() { return stackController_; }

    bool isDebuggerPaused() const { return debuggerPaused; }

    bool changeHighlightAllowed() const
    {
        return changeHighlight_.changeHighlightAllowed(stackController_.selectionLevel());
    }

    void applyChangedVisuals(QStandardItem *valueCell, bool changed)
    {
        changeHighlight_.applyChangedVisuals(this, valueCell, changed);
    }

    QKeySequence addWatchShortcut() const;


    LuaDebuggerVariablesController &variablesController() { return variablesController_; }
    LuaDebuggerCodeTabsController &codeTabsController() { return codeTabsController_; }
    LuaDebuggerFilesController &filesController() { return filesController_; }
    LuaDebuggerWatchController &watchController() { return watchController_; }
    LuaDebuggerBreakpointsController &breakpointsController() { return breakpointsController_; }
    LuaDebuggerPauseController &pauseController() { return pauseController_; }
    LuaDebuggerLuaReloadCoordinator &reloadCoordinator() { return reloadCoordinator_; }
    LuaDebuggerEvalController &evalController() { return evalController_; }
    LuaDebuggerFontPolicy &fontPolicy() { return fontPolicy_; }

    QString pausedFile() const { return pausedFile_; }

    qlonglong pausedLine() const { return pausedLine_; }

    QCheckBox *enabledToggle() { return enabledCheckBox; }

    QString normalizedFilePath(const QString &file_path) const;

    void refreshDebuggerStateUi();

    void updateWidgets();

    void ensureDebuggerEnabledForActiveBreakpoints();

    void refreshVariablesForCurrentStackFrame();

    void syncVariablesTreeToCurrentWatch();

    void updateLuaEditorAuxFrames();

    void updatePausedErrorFrame();

    void scheduleErrorFrameHide(int delayMs);

    void cancelErrorFrameHide();

    void updateContinueActionState();

    void clearPausedStateUi();

    void setSaveActionEnabled(bool enabled);

    bool tearDownPauseLoopForReload();
 
  public slots:
    void onCodeViewContextMenu(const QPoint &pos);

    void handleEscapeKey();

    void runToCurrentLineInPausedEditor(LuaDebuggerCodeView *codeView, qint32 line);
 
  protected:
    void closeEvent(QCloseEvent *event) override;

    void showEvent(QShowEvent *event) override;

    bool event(QEvent *event) override;

    bool eventFilter(QObject *obj, QEvent *event) override;

    void childEvent(QChildEvent *event) override;
 
  private slots:
    void onContinue();

    void onStepOver();

    void onStepIn();

    void onStepOut();

    void onRunToLine();

    void onAddWatch();

    void onDebuggerToggled(bool checked);

    void onOpenFile();

    void onMonospaceFontUpdated(const QFont &font);

    void onMainAppInitialized();

    void onPreferencesChanged();

    void onColorsChanged();

    void drainPendingLogs();

    void drainBreakpointStateUpdates();

    void onEditorFind();

    void onEditorGoToLine();

    void onVariablesCurrentItemChanged(const QModelIndex &current, const QModelIndex &previous);

    void onWatchCurrentItemChanged(const QModelIndex &current, const QModelIndex &previous);

    void updateLeftPanelStretch();
 
  private:
    Ui::LuaDebuggerDialog *ui;
    LuaDebuggerVariablesController variablesController_;
    LuaDebuggerStackController stackController_;
    LuaDebuggerEvalController evalController_;
    LuaDebuggerBreakpointsController breakpointsController_;
    LuaDebuggerFilesController filesController_;
    LuaDebuggerWatchController watchController_;
    LuaDebuggerCodeTabsController codeTabsController_;
    LuaDebuggerPauseController pauseController_;
    LuaDebuggerLuaReloadCoordinator reloadCoordinator_;
    LuaDebuggerFontPolicy fontPolicy_;
    LuaDebuggerKeyRouter keyRouter_;
    static LuaDebuggerDialog *_instance;

    void wireFilesPanel();
    void wireStackPanel();
    void wireVariablesPanel();
    void wireWatchPanel();
    void wireBreakpointsPanel();
    void wireEvaluatePanel();
    void wireCodeTabs();

    CollapsibleSection *createVariablesSection(QWidget *parent);

    CollapsibleSection *createWatchSection(QWidget *parent);

    CollapsibleSection *createStackSection(QWidget *parent);

    CollapsibleSection *createBreakpointsSection(QWidget *parent);

    CollapsibleSection *createFilesSection(QWidget *parent);

    CollapsibleSection *createEvaluateSection(QWidget *parent);

    void resetStackForPauseEntry();
    void clearStackPanel();

    QCheckBox *enabledCheckBox;

    bool debuggerPaused;
 
    // Collapsible sections (created programmatically)
    CollapsibleSection *variablesSection;
    CollapsibleSection *watchSection;
    CollapsibleSection *stackSection;
    CollapsibleSection *breakpointsSection;
    CollapsibleSection *filesSection;
    CollapsibleSection *evalSection;
 
    // Tree views and item models (created programmatically)
    QTreeView *variablesTree;
    QStandardItemModel *variablesModel;
    QTreeView *watchTree;
    QStandardItemModel *watchModel;
    QTreeView *stackTree;
    QStandardItemModel *stackModel;
    QTreeView *fileTree;
    QStandardItemModel *fileModel;
    QTreeView *breakpointsTree;
    QStandardItemModel *breakpointsModel;
 
    // Eval panel widgets (created programmatically)
    QPlainTextEdit *evalInputEdit;
    QPlainTextEdit *evalOutputEdit;
    QPushButton *evalButton;
    QPushButton *evalClearButton;

    QSplitter *evalSplitter_ = nullptr;

    QToolButton *breakpointHeaderToggleButton_ = nullptr;
    QToolButton *breakpointHeaderRemoveButton_ = nullptr;
    QToolButton *breakpointHeaderRemoveAllButton_ = nullptr;
    QToolButton *breakpointHeaderBreakOnErrorButton_ = nullptr;
    QToolButton *breakpointHeaderEditButton_ = nullptr;

    QAction *actionRemoveAllBreakpoints_ = nullptr;

    void showAccordionFrame(AccordionFrame *frame, bool toggle = false);

    void installDescendantShortcutFilters();

    void syncDebuggerToggleWithCore();

    enum class DebuggerUiStatus
    {
        Paused,
        DisabledLiveCapture,
        DisabledPreferences,
        Disabled,
        Running
    };

    DebuggerUiStatus currentDebuggerUiStatus() const;

    void updateEnabledCheckboxIcon();

    void updateStatusLabel();

    void applyCodeViewThemes();

    void updateStyleSheets();

    void resumeDebuggerAndExitLoop();

    void endPauseFreeze();

    void runDebuggerStep(void (*step_fn)(void));

    void createCollapsibleSections();
 
    // ---- Qt-based JSON settings persistence (like import_hexdump) ----

    LuaDebuggerSettingsStore settingsStore_;

    bool luaDebuggerJsonSaved_{false};

    void saveSettingsFile();

    void applyDialogSettings();

    void storeDialogSettings();

    QStandardItem *findVariablesItemByPath(const QString &path) const;

    QStandardItem *findWatchRootForVariablePath(const QString &path) const;

    static void expandAncestorsOf(QTreeView *tree, QStandardItemModel *model, QStandardItem *item);

    bool syncWatchVariablesSelection_ = false;

    LuaDebuggerChangeHighlightTracker changeHighlight_;

    QString pausedFile_;

    qlonglong pausedLine_ = 0;

    int errorFrameHideEpoch_ = 0;

    void refreshChangedValueBrushes() { changeHighlight_.refreshChangedValueBrushes(watchTree, this); }

    void snapshotBaselinesOnPauseEntry() { changeHighlight_.snapshotBaselinesOnPauseEntry(); }

    void clearAllChangeBaselines() { changeHighlight_.clearAllChangeBaselines(); }

    void pruneChangeBaselinesToLiveWatchSpecs() { changeHighlight_.pruneChangeBaselinesToLiveWatchSpecs(watchModel); }

    void updatePauseEntryFrameIdentity() { changeHighlight_.updatePauseEntryFrameIdentity(); }
};
 
#endif // LUA_DEBUGGER_DIALOG_H