lua_debugger_dialog.h

Go to the documentation of this file.

/* lua_debugger_dialog.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_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 reloadUiActive() const { return reloadUiActive_; }
 
    bool takeDeferredReload();
 
  public slots:
    void onReloadLuaPluginsRequested();
 
  private:
    void enterReloadUiStateIfEnabled();
    void exitReloadUiState();
    void reloadAllScriptFilesFromDisk();
 
    LuaDebuggerDialog *host_ = nullptr;
    bool reloadDeferred_ = false;
    bool reloadUiActive_ = false;
    bool reloadUiSavedCheckboxChecked_ = false;
    bool reloadUiSavedCheckboxEnabled_ = true;
    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 int32_t currentTheme();
 
    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 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 onThemeChanged(int idx);
    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;
    static int32_t currentTheme_;
 
    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;
    /* True when this dialog is in a pause entry / nested event-loop UI
     * (Continue/step, freeze, chrome). The C side reports an actual
     * breakpoint with wslua_debugger_is_paused(); the two are usually
     * aligned but are updated on different call paths. */
    bool debuggerPaused;
 
    // Collapsible sections (created programmatically)
    CollapsibleSection *variablesSection;
    CollapsibleSection *watchSection;
    CollapsibleSection *stackSection;
    CollapsibleSection *breakpointsSection;
    CollapsibleSection *filesSection;
    CollapsibleSection *evalSection;
    CollapsibleSection *settingsSection;
 
    // 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;
 
    // Settings panel widgets (created programmatically)
    QComboBox *themeComboBox;
    QToolButton *breakpointHeaderToggleButton_ = nullptr;
    QToolButton *breakpointHeaderRemoveButton_ = nullptr;
    QToolButton *breakpointHeaderRemoveAllButton_ = nullptr;
    QToolButton *breakpointHeaderEditButton_ = nullptr;
    QAction *actionRemoveAllBreakpoints_ = nullptr;
 
    void showAccordionFrame(AccordionFrame *frame, bool toggle = false);
    void installDescendantShortcutFilters();
    void syncDebuggerToggleWithCore();
    enum class DebuggerUiStatus
    {
        Paused,
        DisabledLiveCapture,
        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;
 
    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