dt-internal.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef DIRECTOR_DEBUGER_DT_INTERNAL_H
#define DIRECTOR_DEBUGER_DT_INTERNAL_H

#ifndef IMGUI_DEFINE_MATH_OPERATORS
#define IMGUI_DEFINE_MATH_OPERATORS
#endif

#include "graphics/surface.h"

#include "backends/imgui/imgui.h"
#include "backends/imgui/imgui_fonts.h"
#include "backends/imgui/components/imgui_logger.h"
#include "backends/imgui/components/imgui_memory_editor.h"

#include "director/types.h"
#include "director/window.h"
#include "director/lingo/lingo.h"
#include "director/lingo/lingodec/ast.h"
#include "director/lingo/lingodec/handler.h"

namespace Director {
namespace DT {

#define kMaxColumnsInTable 512

typedef struct ImGuiImage {
    ImTextureID id;
    int16 width;
    int16 height;
} ImGuiImage;

typedef struct ImGuiScriptCodeLine {
    uint32 pc;
    Common::String codeLine;
} ImGuiScriptCodeLine;

typedef struct ImGuiScript {
    bool score = false;
    bool showByteCode = false;
    CastMemberID id;
    ScriptType type;
    Common::String handlerId;
    Common::String handlerName;
    Common::String moviePath;
    Common::Array<uint32> byteOffsets;
    uint pc = 0;

    bool isMethod = false;
    bool isGenericEvent = false;
    Common::StringArray argumentNames;
    Common::StringArray propertyNames;
    Common::StringArray globalNames;
    Common::SharedPtr<LingoDec::HandlerNode> root;
    Common::Array<LingoDec::Bytecode> bytecodeArray;
    Common::Array<uint> startOffsets;
    Common::SharedPtr<Node> oldAst;
    Common::String rawText;

    bool operator==(const ImGuiScript &c) const {
        return moviePath == c.moviePath && score == c.score && id == c.id && handlerId == c.handlerId;
    }
    bool operator!=(const ImGuiScript &c) const {
        return !(*this == c);
    }
} ImGuiScript;

typedef struct ImGuiWindows {
    bool controlPanel = true;
    bool vars = false;
    bool channels = false;
    bool cast = false;
    bool castDetails = false;
    bool funcList = false;
    bool score = false;
    bool bpList = false;
    bool settings = false;
    bool logger = false;
    bool archive = false;
    bool watchedVars = false;
    bool executionContext = false;
    bool scripts = false;
    bool search = false;
    bool imageViewer = false;
    bool windows = false;
    bool help = false;
    bool profiler = false;
} ImGuiWindows;

// Rebindable debugger actions. Keep in sync with kShortcutDefs (dt-help.cpp).
enum DebuggerAction {
    kActContinue = 0,
    kActStepOver,
    kActStepInto,
    kActStepOut,
    kActQuickOpen,
    kActPickFromStage,
    kActToggleControlPanel,
    kActToggleCast,
    kActToggleScore,
    kActToggleMouseIgnore,
    kActCount
};

typedef struct ShortcutDef {
    const char *id;    // stable key for save/load
    const char *label; // display name
    const char *help;  // what it does
    ImGuiKeyChord defaultChord;
} ShortcutDef;


enum SearchMode {
    kSearchAll = 0,
    kSearchHandlers,
    kSearchVariables,
    kSearchBody,
};

typedef struct ScriptData {
    Common::Array<ImGuiScript> _scripts;
    uint _current = 0;
    bool _showByteCode = false;
    bool _showScript = false;
    bool _scrollToCurrent = false; // pending scroll to the current script, consumed on render
} ScriptData;

typedef struct WindowFlag {
    const char *name;
    bool *flag;
} WindowFlag;

enum ThemeID {
    kThemeDark = 0,
    kThemeLight,
    kThemeCount
};

struct DebuggerTheme {
    ImU32 tableLightColor;
    ImU32 tableDarkColor;
    ImU32 borderColor;
    ImU32 sidebarTextColor;
    ImU32 gridTextColor;
    ImU32 playhead_color;
    ImU32 current_statement_bg;
    ImU32 channel_toggle;
    ImU32 channel_hide_bg;
    ImU32 channelSelectedCol;
    ImU32 channelHoveredCol;
    ImU32 contColors[6];

    // Breakpoints
    ImVec4 bp_color_disabled;
    ImVec4 bp_color_enabled;
    ImVec4 bp_color_hover;

    // Syntax Highlighting
    ImVec4 current_statement;
    ImVec4 line_color;
    ImVec4 call_color;
    ImVec4 builtin_color;
    ImVec4 var_color;
    ImVec4 literal_color;
    ImVec4 comment_color;
    ImVec4 type_color;
    ImVec4 keyword_color;
    ImVec4 the_color;

    // Variable / Script References
    ImVec4 script_ref;
    ImVec4 var_ref;
    ImVec4 var_ref_changed;
    ImVec4 var_ref_out_of_scope;

    // Control Panel
    ImVec4 cp_color;
    ImVec4 cp_color_red;
    ImVec4 cp_active_color;
    ImVec4 cp_bgcolor;
    ImVec4 cp_playing_color;
    ImVec4 cp_path_color;

    // Logger
    ImVec4 logger_error_b;
    ImVec4 logger_warning_b;
    ImVec4 logger_info_b;
    ImVec4 logger_debug_b;
    ImVec4 logger_error;
    ImVec4 logger_warning;
    ImVec4 logger_info;
    ImVec4 logger_debug;

    // Profiler
    ImVec4 prof_ruler_bg;
    ImVec4 prof_grid_line;
    ImVec4 prof_freeze;
    ImVec4 prof_thaw;
    ImVec4 prof_zone_border;
    ImVec4 prof_zone_text;
    ImVec4 prof_selected;
    ImVec4 prof_highlight;
    ImVec4 prof_live_edge;
    ImVec4 prof_crosshair;
};

struct QuickOpenItem {
    Common::String label;
    bool isHandler = false;
    CastMemberID id;
    ScriptType scriptType = kScoreScript;
    Common::String handlerId;
    Common::String handlerName;
};

struct CastRowEntry {
    const Cast *cast = nullptr;
    CastMember *member = nullptr;
    int id = 0;
    Common::String name;
};

typedef struct ImGuiState {

    struct WatchLogEntry {
        Common::String varName;
        Common::String value;
        Common::String scriptRef;
    };

    struct ScoreConfig {
        float _sidebarWidth = 60.0f;
        float _cellWidth = 14.0f;
        float _cellHeight = 22.0f;
        int _visibleFrames = 60;
        int _visibleChannels = 20;
        float _tableWidth = _cellWidth * _visibleFrames;
        float _tableHeight = _cellHeight * _visibleChannels;
        float _rulerHeight = 30.0f;
        float _rulerWidth = _cellWidth * _visibleFrames;
        float _sidebar1Height = _cellHeight * 6;
        float _labelBarHeight = _cellHeight;
        float _cellHeightExtended = 5 * _cellHeight;
    } _scoreCfg;

    struct ScoreState {
        int xSliderValue = 1; // first visible frame, 1 indexed
        int channelScrollOffset = 1; // first visible channel, 1 indexed
    } _scoreState;

    struct {
        Common::HashMap<CastMember *, ImGuiImage> _textures;
        bool _listView = true;
        bool _showGridNumbers = false;
        int _thumbnailSize = 64;
        ImGuiTextFilter _nameFilter;
        int _typeFilter = 0xFFFF;
    } _cast;

    struct {
        ImGuiTextFilter _nameFilter;
        bool _showScriptContexts = true;
        Common::HashMap<Window *, ScriptData> _windowScriptData;
    } _functions;
    struct {
        // stored as an ID: raw CastMember pointers dangle on movie switch
        CastMemberID _castMemberID;
        // name of the window whose movie owns the member
        Common::String _window;
        Common::HashMap<CastMemberID, int> _filmLoopCurrentFrame;
    } _castDetails;

    struct {
        bool _isScriptDirty = false; // indicates whether or not we have to display the script corresponding to the current stackframe
        bool _hostExecutionContext = false; // true while the Execution Context window is rendering scripts
        bool _scrollToPC = false;
        uint _lastLinePC = 0;
        uint _callstackSize = 0;
        Common::String _highlightQuery; // lowercased, empty disables highlight
        bool _suppressHighlight = false; // used to disable highlighting in Execution Context
    } _dbg;

    struct {
        char input[256] = {};
        bool dirty = false;
        int mode = kSearchAll;
        Common::Array<ImGuiScript> results;
    } _search;

    struct {
        DatumHash _locals;
        DatumHash _globals;

        DatumHash _prevLocals;
        DatumHash _prevGlobals;

        uint32 _lastTimeRefreshed = 0;
        ImGuiTextFilter _nameFilter;
    } _vars;

    struct {
        ImGuiImage image;
        Common::String text;      // empty = no text panel
        Common::String title;     // optional title

        // cached normalized text
        Common::String cachedRaw;
        Common::String cachedNormalized;

        // reusable buffer
        char *buffer = nullptr;
        size_t bufferSize = 0;

    } _imageViewerState;

    ImGuiWindows _w;
    ImGuiWindows _savedW;
    bool _wasHidden = false;

    ScriptData _openScripts;
    bool _showCompleteScript = true;

    // Quick-open (command palette): jump to a cast member or handler by name.
    bool _quickOpen = false;
    char _quickOpenInput[256] = {};

    // Pick-from-stage: next stage click selects the sprite under the cursor.
    bool _pickMode = false;

    // Rebindable shortcut chords, indexed by DebuggerAction; -1 = not capturing.
    ImGuiKeyChord _shortcuts[kActCount] = {};
    int _shortcutCapture = -1;
    ImGuiKeyChord _shortcutPending = ImGuiKey_None; // chord being held during a rebind

    Common::HashMap<Common::String, bool, Common::IgnoreCase_Hash, Common::IgnoreCase_EqualTo> _variables;
    int _prevFrame = -1;
    struct {
        int frame = -1;
        int channel = -1;
        bool isMainChannel = false;
    } _selectedScoreCast;

    struct {
        int frame = -1;
        int channel = -1;
    } _hoveredScoreCast;

    Common::Array<Common::Array<Common::Pair<uint, uint>>> _continuationData;
    Common::String _loadedContinuationData;

    // archive paths of every window's movie, to detect movie switches
    Common::String _movieSignature;

    Common::Array<WatchLogEntry> _watchLog;

    Common::String _scoreWindow;
    Common::String _channelsWindow;
    Common::String _castWindow;
    Common::String _functionsWindow;
    Common::String _executionContextWindow;
    int _scoreMode = 0;
    int _scoreFrameOffset = 1;
    int _scorePageSlider = 0;
    int _selectedChannel = -1;
    bool _scrollToChannel = false;

    ImFont *_tinyFont = nullptr;

    int _activeThemeID = kThemeLight;
    const DebuggerTheme *theme = nullptr;

    struct {
        Common::Path path;
        uint32 resType = 0;
        uint32 resId = 0;

        byte *data = nullptr;
        uint32 dataSize = 0;

        MemoryEditor memEdit;
    } _archive;

    ImGuiEx::ImGuiLogger *_logger = nullptr;
    bool _ignoreMouse = false;
    bool _enableMultiViewport = true;

    Window *_windowToRedraw = nullptr;

    // Cached UI lists. Kept in the state (not file-static) so their Common::Strings
    // free in onImGuiCleanup while g_system is alive, not at process exit.
    Common::Array<CastRowEntry> _castRows;
    Common::String _castRowsKey;
    Common::Array<QuickOpenItem> _quickOpenItems;
    bool _quickOpenGathered = false;
} ImGuiState;

// debugtools.cpp
const LingoDec::Handler *getHandler(const Cast *cast, CastMemberID id, const Common::String &handlerId);
ImGuiScript toImGuiScript(ScriptType scriptType, CastMemberID id, const Common::String &handlerId);
ScriptContext *getScriptContext(CastMemberID id);
ScriptContext *getScriptContext(uint32 nameIndex, CastMemberID castId, Common::String handler);
ScriptContext *resolveHandlerContext(int32 nameIndex, const CastMemberID &refId, const Common::String &handlerName);
int getCastLibIDForContext(const ScriptContext *ctx);
ImGuiScript buildImGuiHandlerScript(ScriptContext *ctx, int castLibID, const Common::String &handlerName, const Common::String &moviePath);
void maybeHighlightLastItem(const Common::String &text);
void addToOpenHandlers(ImGuiScript handler);
void setScriptToDisplay(const ImGuiScript &script);
Director::Breakpoint *getBreakpoint(const Common::String &handlerName, uint16 scriptId, uint pc);
void displayScriptRef(CastMemberID &scriptId);
ImGuiImage getImageID(CastMember *castMember);
ImGuiImage getShapeID(CastMember *castMember);
ImGuiImage getTextID(CastMember *castMember);
Common::String getDisplayName(CastMember *castMember);
void showImage(const ImGuiImage &image, const char *name, float thumbnailSize);
void showImageWrappedBorder(const ImGuiImage &image, const char *name, float size);
ImVec4 convertColor(uint32 color);
void displayVariable(const Common::String &name, bool changed, bool outOfScope = false);
ImColor brightenColor(const ImColor &color, float factor);
Window *windowListCombo(Common::String *target);
Common::String movieId(const Movie *m);
Window *findWindowByName(const Common::String &name);
bool selectableViewButton(const char *label, bool selected);
Common::String formatHandlerName(int scriptId, int castId, Common::String handlerName, ScriptType scriptType, bool childScript);
void setTheme(int themeIndex);
void openImageViewer(ImGuiImage image, const Common::String &text = "", const Common::String &title = "");

// helper to draw thin rectangles for table grid
inline void addThinRect(ImDrawList *dl, ImVec2 min, ImVec2 max, ImU32 col, float thickness = 0.1f) {
    dl->AddLine(ImVec2(min.x, min.y), ImVec2(max.x, min.y), col, thickness); // top
    dl->AddLine(ImVec2(max.x, min.y), ImVec2(max.x, max.y), col, thickness); // right
    dl->AddLine(ImVec2(max.x, max.y), ImVec2(min.x, max.y), col, thickness); // bottom
    dl->AddLine(ImVec2(min.x, max.y), ImVec2(min.x, min.y), col, thickness); // left
}

void showCast();        // dt-cast.cpp
void showImageViewer(); // dt-castdetails.cpp
void showCastDetails(); // dt-castdetails.cpp
void showControlPanel();// dt-controlpanel.cpp
void handleDebuggerShortcuts(); // dt-controlpanel.cpp
void showProfiler();    // dt-profiler.cpp

// dt-help.cpp
extern const ShortcutDef kShortcutDefs[kActCount];
void initShortcuts();       // load defaults into _state->_shortcuts
void resetShortcuts();      // restore defaults
void showHelp();            // the Help window (shortcuts + tips)
bool actionTriggered(DebuggerAction act);   // Shortcut() honouring the current binding

// dt-lists.cpp
void showVars();
void showWatchedVars();
void showBreakpointList();
void showArchive();
void showWindows();

// dt-score.cpp
void showScore();
void showChannels();

void renderOldScriptAST(ImGuiScript &script, bool showByteCode, bool scrollTo); // dt-script-d2.cpp
void renderScriptAST(ImGuiScript &script, bool showByteCode, bool scrollTo);       // dt-script-d4.cpp

// dt-scripts.cpp
void showFuncList();
void showExecutionContext();
void showScriptsWindow();
void showQuickOpen();

// dt-save-state.cpp
void saveCurrentState();
void loadSavedState();
Common::Array<WindowFlag> getWindowFlags();

// dt-search.cpp
void showSearchBar();

extern ImGuiState *_state;

} // End of namespace DT

} // End of namespace Director

#endif