lua_debugger_utils.h

Go to the documentation of this file.

/* lua_debugger_utils.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_UTILS_H
#define LUA_DEBUGGER_UTILS_H
 
#include <QBrush>
#include <QChar>
#include <QColor>
#include <QFont>
#include <QHash>
#include <QIcon>
#include <QKeySequence>
#include <QModelIndex>
#include <QSet>
#include <QStandardItem>
#include <QStandardItemModel>
#include <QString>
#include <QStringList>
#include <QTreeView>
#include <QVariant>
#include <QtGlobal>
 
#include "epan/wslua/wslua_debugger.h"
 
class LuaDebuggerDialog;
class QFont;
class QKeyEvent;
class QObject;
class QPalette;
class QPainter;
class QToolButton;
class QTreeView;
class QWidget;
 
namespace Ui
{
class LuaDebuggerDialog;
}
 
/* ===== from internal ===== */
 
 
inline QStandardItem *luaDbgWatchRootItem(QStandardItem *item)
{
    while (item && item->parent())
    {
        item = item->parent();
    }
    return item;
}
 
struct LuaDbgTreeSectionExpansionState
{
    bool rootExpanded = false;
    QStringList subpaths;
};
 
void luaDbgRecordTreeSectionRootExpansion(QHash<QString, LuaDbgTreeSectionExpansionState> &map, const QString &rootKey,
                                          bool expanded);
 
void luaDbgRecordTreeSectionSubpathExpansion(QHash<QString, LuaDbgTreeSectionExpansionState> &map,
                                             const QString &rootKey, const QString &key, bool expanded);
 
QStringList luaDbgTreeSectionExpandedSubpaths(const QHash<QString, LuaDbgTreeSectionExpansionState> &map,
                                              const QString &rootKey);
 
QString luaDebuggerSettingsFilePath();
 
namespace LuaDebuggerSettingsKeys
{
constexpr const char *Theme = "theme";
constexpr const char *DebuggerEnabled = "debuggerEnabled";
constexpr const char *MainSplitter = "mainSplitterState";
constexpr const char *LeftSplitter = "leftSplitterState";
constexpr const char *EvalSplitter = "evalSplitterState";
constexpr const char *SectionVariables = "sectionVariables";
constexpr const char *SectionStack = "sectionStack";
constexpr const char *SectionFiles = "sectionFiles";
constexpr const char *SectionBreakpoints = "sectionBreakpoints";
constexpr const char *SectionEval = "sectionEval";
constexpr const char *SectionSettings = "sectionSettings";
constexpr const char *SectionWatch = "sectionWatch";
constexpr const char *Breakpoints = "breakpoints";
constexpr const char *Watches = "watches";
constexpr const char *BreakOnError = "breakOnError";
} // namespace LuaDebuggerSettingsKeys
 
// Tree widget UserRoles (must stay stable for persisted settings / model code).
constexpr qint32 FileTreePathRole = static_cast<qint32>(Qt::UserRole);
constexpr qint32 FileTreeIsDirectoryRole = static_cast<qint32>(Qt::UserRole + 1);
constexpr qint32 BreakpointFileRole = static_cast<qint32>(Qt::UserRole + 2);
constexpr qint32 BreakpointLineRole = static_cast<qint32>(Qt::UserRole + 3);
constexpr qint32 BreakpointConditionRole = static_cast<qint32>(Qt::UserRole + 30);
constexpr qint32 BreakpointHitCountRole = static_cast<qint32>(Qt::UserRole + 31);
constexpr qint32 BreakpointHitTargetRole = static_cast<qint32>(Qt::UserRole + 32);
constexpr qint32 BreakpointConditionErrRole = static_cast<qint32>(Qt::UserRole + 33);
constexpr qint32 BreakpointLogMessageRole = static_cast<qint32>(Qt::UserRole + 34);
constexpr qint32 BreakpointHitModeRole = static_cast<qint32>(Qt::UserRole + 35);
constexpr qint32 BreakpointLogAlsoPauseRole = static_cast<qint32>(Qt::UserRole + 36);
constexpr qint32 StackItemFileRole = static_cast<qint32>(Qt::UserRole + 4);
constexpr qint32 StackItemLineRole = static_cast<qint32>(Qt::UserRole + 5);
constexpr qint32 StackItemNavigableRole = static_cast<qint32>(Qt::UserRole + 6);
constexpr qint32 StackItemLevelRole = static_cast<qint32>(Qt::UserRole + 7);
constexpr qint32 VariablePathRole = static_cast<qint32>(Qt::UserRole + 8);
constexpr qint32 VariableTypeRole = static_cast<qint32>(Qt::UserRole + 9);
constexpr qint32 VariableCanExpandRole = static_cast<qint32>(Qt::UserRole + 10);
constexpr qint32 WatchSpecRole = static_cast<qint32>(Qt::UserRole + 11);
constexpr qint32 WatchSubpathRole = static_cast<qint32>(Qt::UserRole + 13);
constexpr qint32 WatchPendingNewRole = static_cast<qint32>(Qt::UserRole + 15);
constexpr qint32 ChangedFlashSerialRole = static_cast<qint32>(Qt::UserRole + 20);
 
constexpr qsizetype WATCH_TOOLTIP_MAX_CHARS = 4096;
constexpr int WATCH_EXPR_MAX_CHARS = 65536;
constexpr int CHANGED_FLASH_MS = 500;
constexpr int WATCH_PLACEHOLDER_DEFER_MS = 250;
constexpr QChar CHANGE_KEY_SEP = QChar(0x1F);
 
constexpr int kLuaDbgEvalOutputMaxLines = 5000;
 
extern const QKeySequence kLuaDbgCtxGoToLine;
extern const QKeySequence kLuaDbgCtxRunToLine;
extern const QKeySequence kLuaDbgCtxWatchEdit;
extern const QKeySequence kLuaDbgCtxWatchCopyValue;
extern const QKeySequence kLuaDbgCtxWatchDuplicate;
extern const QKeySequence kLuaDbgCtxWatchRemoveAll;
extern const QKeySequence kLuaDbgCtxAddWatch;
extern const QKeySequence kLuaDbgCtxToggleBreakpoint;
extern const QKeySequence kLuaDbgCtxReloadLuaPlugins;
extern const QKeySequence kLuaDbgCtxRemoveAllBreakpoints;
 
QKeySequence luaDbgSeqFromKeyEvent(const QKeyEvent *ke);
 
/* ===== from item_utils ===== */
 
namespace LuaDebuggerItems
{
 
inline QString rowColumnDisplayText(const QModelIndex &indexInRow, int col)
{
    if (!indexInRow.isValid())
    {
        return QString();
    }
    return indexInRow.sibling(indexInRow.row(), col).data(Qt::DisplayRole).toString();
}
 
inline QStandardItem *rowCol0(QStandardItemModel *model, QStandardItem *cell)
{
    if (!model || !cell)
    {
        return nullptr;
    }
    const QModelIndex ix = model->indexFromItem(cell);
    if (!ix.isValid())
    {
        return nullptr;
    }
    return model->itemFromIndex(ix.sibling(ix.row(), 0));
}
 
inline QStandardItem *cellAt(QStandardItemModel *model, QStandardItem *col0, int col)
{
    if (!model || !col0 || col0->column() != 0)
    {
        return nullptr;
    }
    QStandardItem *par = col0->parent();
    if (!par)
    {
        return model->item(col0->row(), col);
    }
    return par->child(col0->row(), col);
}
 
inline QString text(QStandardItemModel *model, QStandardItem *col0, int col)
{
    QStandardItem *c = cellAt(model, col0, col);
    return c ? c->text() : QString();
}
 
inline void setText(QStandardItemModel *model, QStandardItem *col0, int col, const QString &t)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setText(t);
    }
}
 
inline void setToolTip(QStandardItemModel *model, QStandardItem *col0, int col, const QString &tip)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setToolTip(tip);
    }
}
 
inline void setFont(QStandardItemModel *model, QStandardItem *col0, int col, const QFont &font)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setFont(font);
    }
}
 
inline void setForeground(QStandardItemModel *model, QStandardItem *col0, int col, const QBrush &brush)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setForeground(brush);
    }
}
 
inline void setBackground(QStandardItemModel *model, QStandardItem *col0, int col, const QBrush &brush)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setBackground(brush);
    }
}
 
inline void setIcon(QStandardItemModel *model, QStandardItem *col0, int col, const QIcon &icon)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setIcon(icon);
    }
}
 
inline void setTextAlignment(QStandardItemModel *model, QStandardItem *col0, int col, Qt::Alignment align)
{
    QStandardItem *c = cellAt(model, col0, col);
    if (c)
    {
        c->setTextAlignment(align);
    }
}
 
inline QModelIndex indexCol0(QStandardItemModel *model, QStandardItem *col0)
{
    if (!model || !col0 || col0->column() != 0)
    {
        return QModelIndex();
    }
    return model->indexFromItem(col0);
}
 
inline bool isExpanded(QTreeView *tree, QStandardItemModel *model, QStandardItem *col0)
{
    const QModelIndex ix = indexCol0(model, col0);
    return ix.isValid() && tree->isExpanded(ix);
}
 
inline void setExpanded(QTreeView *tree, QStandardItemModel *model, QStandardItem *col0, bool expanded)
{
    const QModelIndex ix = indexCol0(model, col0);
    if (ix.isValid())
    {
        tree->setExpanded(ix, expanded);
    }
}
 
} // namespace LuaDebuggerItems
 
/* ===== from path_utils ===== */
 
namespace LuaDebuggerPath
{
 
struct LuaDbgInvalidFilterColors
{
    QColor fg;
    QColor bg;
};
 
LuaDbgInvalidFilterColors invalidFilterColors();
 
bool watchSpecIsGlobalScoped(const QString &spec);
 
bool variablesPathIsGlobalScoped(const QString &path);
 
QString changeKey(int stackLevel, const QString &path);
 
QString watchSpecFromChangeKey(const QString &key);
 
QString stripWatchExpressionErrorPrefix(const QString &errStr);
 
template <class Key, class Map>
bool shouldMarkChanged(const Map &baseline, const Key &key, const QString &newVal, bool flashNew = false)
{
    const auto it = baseline.constFind(key);
    if (it != baseline.constEnd())
    {
        return *it != newVal;
    }
    return flashNew && !baseline.isEmpty();
}
 
QString variableSectionRootKeyFromItem(const QStandardItem *item);
 
bool watchSpecUsesPathResolution(const QString &spec);
 
QString variableTreeChildPath(const QString &parentPath, const QString &nameText);
 
QString expressionWatchChildSubpath(const QString &parentSubpath, const QString &nameText);
 
bool variableChildrenShouldSortByName(const QString &parentPath);
 
struct VariableRowFields
{
    QString name;
    QString value;
    QString type;
    bool canExpand = false;
    QString childPath;
};
 
VariableRowFields readVariableRowFields(const wslua_variable_t &v, const QString &parentPath);
 
void applyVariableExpansionIndicator(QStandardItem *anchor, bool canExpand, bool enabledOnlyPlaceholder,
                                     int columnCount = 3);
 
QString watchVariablePathForSpec(const QString &spec);
 
QString watchResolvedVariablePathForTooltip(const QString &spec);
 
void watchRootSetVariablePathRoleFromSpec(QStandardItem *row, const QString &spec);
 
QString watchPathOriginSuffix(const QStandardItem *item, const QString &spec);
 
QString capWatchTooltipText(const QString &s);
 
QString watchPathParentKey(const QString &path);
 
void applyWatchChildRowTextAndTooltip(QStandardItem *specItem, const QString &rawVal, const QString &typeText);
 
int watchSubpathBoundaryCount(const QString &subpath);
 
QStandardItem *findWatchItemBySubpathOrPathKey(QStandardItem *subtree, const QString &key);
 
QStandardItem *findVariableTreeItemByPathKey(QStandardItem *subtree, const QString &key);
 
using TreePathKeyFinder = QStandardItem *(*)(QStandardItem *, const QString &);
 
void reexpandTreeDescendantsByPathKeys(QTreeView *tree, QStandardItemModel *model, QStandardItem *subtree,
                                       QStringList pathKeys, TreePathKeyFinder findByKey);
 
void reexpandWatchDescendantsByPathKeys(QTreeView *tree, QStandardItemModel *model, QStandardItem *subtree,
                                        QStringList pathKeys);
 
void clearWatchFilterErrorChrome(QStandardItem *specItem, QTreeView *tree);
 
void applyWatchFilterErrorChrome(QStandardItem *specItem, QTreeView *tree);
 
void setupWatchRootItemFromSpec(QStandardItem *specItem, QStandardItem *valueItem, const QString &spec);
 
QStandardItem *findVariableItemByPathRecursive(QStandardItem *node, const QString &path);
 
QString watchItemExpansionKey(const QStandardItem *item);
 
} // namespace LuaDebuggerPath
 
/* ===== from header_styles ===== */
 
QIcon luaDbgMakeSelectionAwareIcon(const QIcon &base, const QPalette &palette);
 
 
QIcon luaDbgPaintedGlyphIcon(const QString &glyph, int side, qreal dpr,
                             const QFont &baseFont, const QColor &color,
                             int margin = 1);
 
QIcon luaDbgPaintedGlyphButtonIcon(const QString &glyph, int side, qreal dpr,
                                   const QFont &baseFont, const QPalette &palette,
                                   int margin = 2);
 
extern const QString kLuaDbgHeaderPlus;
extern const QString kLuaDbgHeaderMinus;
extern const QString kLuaDbgHeaderEdit;
extern const QString kLuaDbgRowLog;
extern const QString kLuaDbgRowExtras;
extern const QString kLuaDbgHeaderRemoveAll;
extern const QString kLuaDbgHeaderToolButtonStyle;
 
void luaDbgDrawBreakpointDot(QPainter &painter, qreal dotLeft, qreal dotTop, qreal radius, bool enabled,
                             bool hasExtras = false, int alpha = 255);
 
enum class LuaDbgBpHeaderIconMode
{
    NoBreakpoints, 
    ActivateAll,   
    DeactivateAll, 
};
 
QIcon luaDbgBreakpointHeaderIconForMode(const QFont *editorFont, LuaDbgBpHeaderIconMode mode, int headerSide,
                                        qreal dpr);
 
void styleLuaDebuggerHeaderBreakpointToggleButton(QToolButton *btn, int side);
 
void styleLuaDebuggerHeaderFittedTextButton(QToolButton *btn, int side, const QFont &titleFont,
                                            const QStringList &glyphs);
 
void styleLuaDebuggerHeaderPlusMinusButton(QToolButton *btn, int side, const QFont &titleFont);
 
void styleLuaDebuggerHeaderIconOnlyButton(QToolButton *btn, int side);
 
QIcon luaDbgErrorBreakHeaderIcon(bool checked, int side, qreal dpr,
                                 const QFont &titleFont, const QPalette &palette);
 
/* ===== from key_router ===== */
 
class LuaDebuggerKeyRouter
{
public:
    explicit LuaDebuggerKeyRouter(LuaDebuggerDialog *host);
 
    void attach(Ui::LuaDebuggerDialog *ui, QTreeView *breakpointsTree);
 
    bool reserveShortcutOverride(const QKeyEvent *ke) const;
 
    bool handleKeyPress(QObject *obj, const QKeyEvent *ke);
 
private:
    LuaDebuggerDialog *host_;
    Ui::LuaDebuggerDialog *ui_ = nullptr;
    QTreeView *breakpointsTree_ = nullptr;
};
 
/* ===== from change_tracker ===== */
 
class LuaDebuggerChangeHighlightTracker
{
  public:
    LuaDebuggerChangeHighlightTracker() = default;
 
    void refreshChangedValueBrushes(QTreeView *watchTree, QWidget *paletteFallback);
 
    void snapshotBaselinesOnPauseEntry();
 
    void updatePauseEntryFrameIdentity();
 
    void setPauseEntryStackLevel(int level) { pauseEntryStackLevel_ = level; }
 
    void setPauseEntryRefresh(bool active) { isPauseEntryRefresh_ = active; }
 
    void applyChangedVisuals(QObject *timerOwner, QStandardItem *anchor, bool changed);
 
    void clearAllChangeBaselines();
 
    void clearWatchBaselines();
 
    void clearChangeBaselinesForWatchSpec(const QString &spec);
 
    void pruneChangeBaselinesToLiveWatchSpecs(QStandardItemModel *watchModel);
 
    bool changeHighlightAllowed(int stackSelectionLevel) const;
 
    bool observeWatchRootValue(const QString &rootKey, const QString &value);
 
    bool observeWatchChildParent(const QString &rootKey, const QString &parentPath);
 
    bool observeWatchChildValue(const QString &rootKey, const QString &childPath, const QString &value,
                                bool parentVisited);
 
    bool observeVariablesParent(const QString &parentKey);
 
    bool observeVariablesValue(const QString &variablesKey, const QString &value, bool parentVisited);
 
  private:
    QHash<QString /* rootKey */, QString> watchRootBaseline_;
 
    QHash<QString /* rootKey */, QString> watchRootCurrent_;
 
    QHash<QString /* rootKey */, QHash<QString /* childPath */, QString>> watchChildBaseline_;
 
    QHash<QString /* rootKey */, QHash<QString /* childPath */, QString>> watchChildCurrent_;
 
    QHash<QString /* variablesKey */, QString> variablesBaseline_;
 
    QHash<QString /* variablesKey */, QString> variablesCurrent_;
 
    QSet<QString /* variablesKey of parent */> variablesBaselineParents_;
 
    QSet<QString /* variablesKey of parent */> variablesCurrentParents_;
 
    QHash<QString /* rootKey */, QSet<QString /* parentPath */>> watchChildBaselineParents_;
 
    QHash<QString /* rootKey */, QSet<QString /* parentPath */>> watchChildCurrentParents_;
 
    QBrush changedValueBrush_;
 
    QBrush changedFlashBrush_;
 
    bool isPauseEntryRefresh_ = false;
 
    qint32 flashSerial_ = 0;
 
    int pauseEntryStackLevel_ = 0;
 
    QString pauseEntryFrame0Identity_;
 
    bool pauseEntryFrame0MatchesPrev_ = false;
};
 
#endif