Files
ClassicAPI/src/embed/AddOns/ClassicAPI_DebugTools/DebugTools.lua
T
Brues 4472c81137 feat(lua): retail SharedXML helpers, Spline, ExportUtil and MixinUtil
Ports from retail's Blizzard_ObjectAPI, SharedXML, SharedXMLBase and
FrameXMLUtil, in Blizzard's own text, from the _forever_ build:
- ObjectCache.lua and SpellBookItemLocation.lua (ObjectAPI).
- TypeUtil.lua: ValueToBoolean and StringToBoolean.
- SortUtil.lua: SortUtil.CreateSortManager and the comparators.
- Sequencer.lua, Spline.lua (Catmull-Rom splines), TaggableObject.lua,
  ObjectUpdater.lua and ExportUtil.lua (base64 export/import streams).
- AnimationSystem.lua: SetUpAnimation and CancelAnimations.
- SmoothStatusBar.lua: SmoothStatusBarMixin.
- MixinUtil.lua: DrawLine, LineMixin, SparseGridMixin,
  DoublyLinkedListMixin, DirtiableMixin, DirtyPhaseMixin and more. 1.12
  has no global wipe, so the file reads table.wipe, as the other ports do.

FrameDeltaLerp now takes retail's three arguments and reads the frame
time from GetTickTime(). The old form needed a fourth elapsed argument,
so SmoothStatusBar's per-frame ticker would have errored. Nothing else
called it.

DebugTools drops its private StringToBoolean copy and calls the global
one from TypeUtil for the /framestack arguments.

FadingFrame.lua is not ported: 1.12's own FrameXML defines the same
FadingFrame_* names with no-argument `this` signatures, and ZoneText
calls FadingFrame_OnUpdate() every frame.

Verified in game: StringToBoolean, ValueToBoolean and
SpellBookItemLocation return the expected values, a 2D spline's midpoint
is (5, 10), an export stream round-trips 200 and 9, the sort manager
orders {3,1,2}, the linked list enumerates 0 1 2, ObjectUpdater,
Sequencer and SetUpAnimation finish, a smoothed status bar reaches 100,
and /framestack still opens.
2026-10-31 05:01:37 -05:00

1260 lines
47 KiB
Lua

------------------------------------------------------------------------------
-- DebugTools.lua (1.12 / Lua 5.0 backport of Blizzard_DebugTools 3.3.5)
--
-- Major changes from the 3.3.5 source:
-- * Lua 5.0 has no "..." varargs and no select(); script handlers take
-- explicit (this, event, arg1..arg19) parameters from XML inline scripts.
-- * RegisterAllEvents is used when available; the curated default list is
-- a fallback if the client doesn't expose it.
-- * /fstack [showHidden [showRegions]] is the modern (10.x+)
-- FrameStackTooltip on ClassicAPI's SetFrameStack: Alt moves the
-- highlight, Ctrl inspects it, Shift shows texture info (see the
-- FrameStackTooltip section).
-- * No UIPanelDialogTemplate, no clampedToScreen, no
-- OnSizeChanged in vanilla -- frames have fixed dimensions.
-- * No debuglocals
--
-- UX additions cherry-picked from modern Blizzard_EventTrace
-- (10.x+, anniversary _classic_era_):
-- * SavedVariables persist the user filter list, pause state, and
-- Args/Time display toggles across sessions (DebugToolsSavedVars).
-- * Toolbar row inside EventTraceFrame: Pause/Resume button + Args /
-- Time checkboxes + Search EditBox. Search filters the visible
-- rows by substring match against the event name.
-- * Args toggle appends a comma-separated arg dump after the event
-- name in the row (was tooltip-only before). Time toggle blanks
-- the time column without re-anchoring frames.
--
-- The table inspector (/tinspect, Ctrl in /fstack) is retail's
-- Blizzard_TableInspector; see TableInspector.lua.
------------------------------------------------------------------------------
EVENT_TRACE_EVENT_HEIGHT = 16;
EVENT_TRACE_MAX_ENTRIES = 1000;
-- Toolbar above the event list (Pause + Args/Time toggles + Search) eats
-- one row's worth of vertical real estate; 26 visible rows instead of 28
-- keeps the frame the same height as before the enhancements landed.
EVENT_TRACE_NUM_BUTTONS = 26;
EVENT_TRACE_FRAME_HEIGHT = (EVENT_TRACE_NUM_BUTTONS * EVENT_TRACE_EVENT_HEIGHT) + 68;
DEBUGLOCALS_LEVEL = 4;
local _normalFontColor = { 1, .82, 0, 1 };
EVENT_TRACE_SYSTEM_TIMES = {};
EVENT_TRACE_SYSTEM_TIMES["System"] = true;
EVENT_TRACE_SYSTEM_TIMES["Elapsed"] = true;
EVENT_TRACE_EVENT_COLORS = {};
EVENT_TRACE_EVENT_COLORS["System"] = _normalFontColor;
EVENT_TRACE_EVENT_COLORS["Elapsed"] = { .6, .6, .6, 1 };
------------------------------------------------------------------------------
-- Saved variables — persist user filter list + display toggles across
-- sessions. WoW fills `DebugToolsSavedVars` from
-- `WTF\Account\<acct>\SavedVariables\DebugTools.lua` on ADDON_LOADED,
-- so any reference to it before that event fires is nil.
------------------------------------------------------------------------------
DebugToolsSavedVars = nil;
-- Defaults applied on a fresh install (no saved file yet) AND merged
-- field-by-field into older saved files so new fields don't require
-- a manual wipe to surface.
local _DEFAULT_FILTERS = {
"GLOBAL_MOUSE_DOWN", "GLOBAL_MOUSE_UP",
"MODIFIER_STATE_CHANGED",
"PLAYER_STARTED_LOOKING", "PLAYER_STOPPED_LOOKING",
"PLAYER_STARTED_TURNING", "PLAYER_STOPPED_TURNING",
"PLAYER_STARTED_MOVING", "PLAYER_STOPPED_MOVING",
"CHAT_MSG_ADDON",
};
local function _CloneArray(src)
local t = {};
for i = 1, table.getn(src) do t[i] = src[i]; end
return t;
end
local function _DefaultSavedVars()
return {
Filters = { User = _CloneArray(_DEFAULT_FILTERS) },
ShowArguments = false,
ShowTimestamp = true,
Paused = false,
};
end
local function _MergeDefaults(stored)
local defaults = _DefaultSavedVars();
if (type(stored) ~= "table") then return defaults; end
for k, v in pairs(defaults) do
if (stored[k] == nil) then stored[k] = v; end
end
if (type(stored.Filters) ~= "table") then
stored.Filters = { User = _CloneArray(_DEFAULT_FILTERS) };
end
if (type(stored.Filters.User) ~= "table") then
stored.Filters.User = _CloneArray(_DEFAULT_FILTERS);
end
return stored;
end
-- Apply the loaded saved-vars to the live frame state. Runs after both
-- the frame OnLoad (which sets _EventTraceFrame) and ADDON_LOADED
-- (which fills DebugToolsSavedVars). Idempotent — safe to re-run.
local function _ApplySavedVars()
if (not _EventTraceFrame or not DebugToolsSavedVars) then return; end
_EventTraceFrame.ignoredEvents = {};
for i = 1, table.getn(DebugToolsSavedVars.Filters.User) do
_EventTraceFrame.ignoredEvents[DebugToolsSavedVars.Filters.User[i]] = true;
end
_EventTraceFrame.paused = DebugToolsSavedVars.Paused and true or false;
_EventTraceFrame.showArguments = DebugToolsSavedVars.ShowArguments and true or false;
_EventTraceFrame.showTimestamp = DebugToolsSavedVars.ShowTimestamp and true or false;
-- Sync the toolbar widgets if they exist (XML may have loaded them
-- before or after this point depending on file order).
local pauseBtn = getglobal("EventTraceFramePauseButton");
if (pauseBtn) then
pauseBtn:SetText(_EventTraceFrame.paused and "Resume" or "Pause");
end
-- Vanilla 1.12 `CheckButton:SetChecked` takes 1 / nil, not true /
-- false — passing the bool directly silently leaves the box in
-- whatever state it had before, which is why the Time box looked
-- unchecked at first launch even though `showTimestamp` defaults
-- to true. (`true` was accepted starting in TBC.)
local argsChk = getglobal("EventTraceFrameArgsCheck");
if (argsChk) then
argsChk:SetChecked(_EventTraceFrame.showArguments and 1 or nil);
end
local timeChk = getglobal("EventTraceFrameTimeCheck");
if (timeChk) then
timeChk:SetChecked(_EventTraceFrame.showTimestamp and 1 or nil);
end
end
local _initFrame = CreateFrame("Frame");
_initFrame:RegisterEvent("ADDON_LOADED");
_initFrame:RegisterEvent("PLAYER_LOGOUT");
_initFrame:SetScript("OnEvent", function()
if (event == "ADDON_LOADED") then
if (arg1 ~= "ClassicAPI_DebugTools") then return; end
DebugToolsSavedVars = _MergeDefaults(DebugToolsSavedVars);
_ApplySavedVars();
_initFrame:UnregisterEvent("ADDON_LOADED");
elseif (event == "PLAYER_LOGOUT") then
-- Final sync on logout — captures any state changes made
-- after ADDON_LOADED (filter add/remove, toggle clicks).
if (DebugToolsSavedVars and _EventTraceFrame) then
DebugToolsSavedVars.Paused = _EventTraceFrame.paused;
DebugToolsSavedVars.ShowArguments = _EventTraceFrame.showArguments;
DebugToolsSavedVars.ShowTimestamp = _EventTraceFrame.showTimestamp;
-- Filters.User stays the source of truth — toolbar mutations
-- already write through to it directly.
end
end
end);
local _EventTraceFrame;
local _framesSinceLast = 0;
local _timeSinceLast = 0;
local _timer = CreateFrame("Frame");
_timer:SetScript("OnUpdate", function()
_framesSinceLast = _framesSinceLast + 1;
_timeSinceLast = _timeSinceLast + (arg1 or 0);
end);
------------------------------------------------------------------------------
-- EventTraceFrame
------------------------------------------------------------------------------
-- The engine sets at most arg1..arg19 for an event, so the XML OnEvent passes
-- all 19 globals and trailing nils mark the end.
EVENT_TRACE_MAX_ARGS = 19;
-- Entries keep an ever-growing index (lastIndex, filteredIndices,
-- button.index), but are stored in a ring of EVENT_TRACE_MAX_ENTRIES fixed
-- slots. Keys that only grow would make every column table rehash, and
-- reallocate, every few events.
local function _Slot(index)
local f = _EventTraceFrame;
if (not index or index < 1 or index > f.lastIndex
or index <= f.lastIndex - EVENT_TRACE_MAX_ENTRIES) then
return nil;
end
return math.mod(index - 1, EVENT_TRACE_MAX_ENTRIES) + 1;
end
-- An event row stores only its GetTime(); the text is built when the row
-- is drawn, so a closed window builds no strings.
local function _TimeText(slot)
local f = _EventTraceFrame;
local kind = f.times[slot];
if (kind) then return kind; end
local seconds = f.rawtimes[slot];
local minutes = math.floor(math.floor(seconds) / 60);
local hours = math.floor(minutes / 60);
seconds = seconds - 60 * minutes;
minutes = minutes - 60 * hours;
hours = math.mod(hours, 1000);
return string.format("%.2d:%.2d:%06.3f", hours, minutes, seconds);
end
local function _EventText(slot)
local f = _EventTraceFrame;
if (f.times[slot] == "Elapsed") then
return string.format("%.3f sec - %d frame(s)", f.elapsed[slot], f.frames[slot]);
end
return f.events[slot];
end
function EventTraceFrame_OnLoad(self)
self.buttons = {};
self.events = {};
self.times = {};
self.rawtimes = {};
self.elapsed = {};
self.frames = {};
self.args = {};
for i = 1, EVENT_TRACE_MAX_ARGS do self.args[i] = {}; end
self.ignoredEvents = {};
self.lastIndex = 0;
self.visibleButtons = EVENT_TRACE_NUM_BUTTONS;
-- Display state defaults — overwritten by `_ApplySavedVars` once
-- ADDON_LOADED fires. Set here so the first Update before saved
-- vars come in has sane values.
self.paused = false;
self.showArguments = false;
self.showTimestamp = true;
self.searchText = nil;
self.filteredIndices = nil;
_EventTraceFrame = self;
-- If saved-vars beat the frame OnLoad (unusual file order), apply now.
_ApplySavedVars();
self:EnableMouse(true);
self:EnableMouseWheel(true);
self:SetScript("OnMouseWheel", function() EventTraceFrame_OnMouseWheel(this, arg1); end);
-- Pre-create the fixed list of buttons.
for i = 1, EVENT_TRACE_NUM_BUTTONS do
local button = CreateFrame("Button", "EventTraceFrameButton" .. i,
self, "EventTraceEventTemplate");
button:SetPoint("BOTTOMLEFT", 12, (EVENT_TRACE_EVENT_HEIGHT * (i - 1)) + 12);
button:SetPoint("RIGHT", -28, 0);
table.insert(self.buttons, button);
button:Show();
end
end
function EventTraceFrame_OnEvent(self, event, a1, a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19)
if (self.ignoredEvents[event]) then return; end
-- Pause swallows real engine events but lets the synthetic
-- "Begin Capture"/"End Capture"/"On Update" markers through so the
-- log records the boundary clearly.
if (self.paused and event ~= "Begin Capture" and event ~= "End Capture"
and event ~= "On Update") then
return;
end
if (not self.ignoreElapsed and _framesSinceLast ~= 0) then
self.ignoreElapsed = true;
EventTraceFrame_OnEvent(self, "On Update");
self.ignoreElapsed = nil;
end
local nextIndex = self.lastIndex + 1;
local slot = math.mod(nextIndex - 1, EVENT_TRACE_MAX_ENTRIES) + 1;
-- Every column of the slot is written, so nothing from the entry it
-- replaces is left behind.
self.times[slot] = nil;
self.elapsed[slot] = nil;
self.frames[slot] = nil;
if (string.find(event, "Begin Capture", 1, true) or
string.find(event, "End Capture", 1, true)) then
self.times[slot] = "System";
if (self.eventsToCapture) then
self.events[slot] = string.format("%s (%s events)", event,
tostring(self.eventsToCapture));
else
self.events[slot] = event;
end
elseif (event == "On Update") then
self.times[slot] = "Elapsed";
self.events[slot] = event;
self.elapsed[slot] = _timeSinceLast;
self.frames[slot] = _framesSinceLast;
_timeSinceLast = 0;
_framesSinceLast = 0;
else
self.events[slot] = event;
if (self.eventsToCapture) then
self.eventsToCapture = self.eventsToCapture - 1;
end
end
-- Stored straight into the per-argument columns: a table to pack them
-- would be one more allocation per event. The markers pass none.
local args = self.args;
args[1][slot] = a1; args[2][slot] = a2; args[3][slot] = a3;
args[4][slot] = a4; args[5][slot] = a5; args[6][slot] = a6;
args[7][slot] = a7; args[8][slot] = a8; args[9][slot] = a9;
args[10][slot] = a10; args[11][slot] = a11; args[12][slot] = a12;
args[13][slot] = a13; args[14][slot] = a14; args[15][slot] = a15;
args[16][slot] = a16; args[17][slot] = a17; args[18][slot] = a18;
args[19][slot] = a19;
self.rawtimes[slot] = GetTime();
self.lastIndex = nextIndex;
-- Keep the filtered view in sync if a search is active. We append-
-- on-match here rather than re-walking the whole event list each
-- tick (would be O(n) per event for the most common case where
-- the search matches none / many).
if (self.filteredIndices and _EventTrace_MatchesSearch(self.events[slot])) then
table.insert(self.filteredIndices, nextIndex);
-- Bound the filtered list to the same MAX_ENTRIES window the
-- raw store enforces. Drop the head when we overflow.
while (table.getn(self.filteredIndices) > 0 and
self.filteredIndices[1] < (nextIndex - EVENT_TRACE_MAX_ENTRIES + 1)) do
table.remove(self.filteredIndices, 1);
end
end
-- No redraw here: OnUpdate redraws once per frame while the window is
-- shown, and a hidden window needs none.
if (self.eventsToCapture and self.eventsToCapture <= 0) then
self.eventsToCapture = nil;
EventTraceFrame_StopEventCapture();
end
end
function EventTraceFrame_OnUpdate(self, elapsed)
EventTraceFrame_Update();
end
------------------------------------------------------------------------------
-- EventTrace toolbar helpers — search filter, display flags, paused
-- toggle, filter list mutations. Keep these grouped together so the
-- toolbar XML scripts only need to reference one well-defined surface.
------------------------------------------------------------------------------
function _EventTrace_MatchesSearch(eventName)
if (not _EventTraceFrame) then return false; end
local needle = _EventTraceFrame.searchText;
if (not needle or needle == "") then return true; end
if (not eventName) then return false; end
return string.find(string.lower(eventName), needle, 1, true) ~= nil;
end
-- Walks the live event store and rebuilds the filtered-index list from
-- scratch. Called when search text changes; cheap (one pass over at
-- most EVENT_TRACE_MAX_ENTRIES entries) and matches the engine's own
-- "build then sort" pattern.
function _EventTrace_RebuildFilter()
if (not _EventTraceFrame) then return; end
local needle = _EventTraceFrame.searchText;
if (not needle or needle == "") then
_EventTraceFrame.filteredIndices = nil;
return;
end
needle = string.lower(needle);
local indices = {};
local first = math.max(1, (_EventTraceFrame.lastIndex or 0) - EVENT_TRACE_MAX_ENTRIES + 1);
for i = first, (_EventTraceFrame.lastIndex or 0) do
local ev = _EventTraceFrame.events[_Slot(i)];
if (ev and string.find(string.lower(ev), needle, 1, true)) then
table.insert(indices, i);
end
end
_EventTraceFrame.filteredIndices = indices;
end
-- Resolves a per-row event index. With a filter active, the scroll bar
-- range is over the filtered list — translate back to the underlying
-- event index here so the rest of the Update loop reads from `events[i]`
-- as usual.
function _EventTrace_ResolveIndex(scrollValue, rowOffset)
if (_EventTraceFrame.filteredIndices) then
return _EventTraceFrame.filteredIndices[scrollValue - rowOffset];
end
return scrollValue - rowOffset;
end
-- Returns (firstID, lastID) for the slider's current min/max. With a
-- filter active, the range is 1..#filtered. Without a filter it's the
-- raw event-store window.
function _EventTrace_ScrollRange()
if (_EventTraceFrame.filteredIndices) then
local n = table.getn(_EventTraceFrame.filteredIndices);
if (n == 0) then return 0, 0; end
return 1, n;
end
local first = math.max(1, _EventTraceFrame.lastIndex - EVENT_TRACE_MAX_ENTRIES + 1);
local last = _EventTraceFrame.lastIndex or 1;
return first, last;
end
-- Formats an event entry for in-line display. When `showArguments` is
-- on, appends a comma-separated rendering of the captured args after
-- the event name. System rows (Begin/End Capture, On Update markers)
-- never get args.
function _EventTrace_FormatRow(slot)
local ev = _EventText(slot);
if (not ev) then return nil; end
if (not _EventTraceFrame.showArguments) then return ev; end
if (EVENT_TRACE_SYSTEM_TIMES[_EventTraceFrame.times[slot]]) then return ev; end
local parts = {};
for i = 1, EVENT_TRACE_MAX_ARGS do
local argList = _EventTraceFrame.args[i];
if (argList and argList[slot] ~= nil) then
table.insert(parts, EventTrace_FormatArgValue(argList[slot]));
end
end
if (table.getn(parts) == 0) then return ev; end
return ev .. " (" .. table.concat(parts, ", ") .. ")";
end
------------------------------------------------------------------------------
-- Toolbar widget handlers — wired up from EventTraceFrame.xml.
------------------------------------------------------------------------------
function EventTraceFrame_TogglePause()
if (not _EventTraceFrame) then return; end
_EventTraceFrame.paused = not _EventTraceFrame.paused;
if (DebugToolsSavedVars) then
DebugToolsSavedVars.Paused = _EventTraceFrame.paused;
end
local pauseBtn = getglobal("EventTraceFramePauseButton");
if (pauseBtn) then
pauseBtn:SetText(_EventTraceFrame.paused and "Resume" or "Pause");
end
end
function EventTraceFrame_ToggleArgs(checked)
if (not _EventTraceFrame) then return; end
_EventTraceFrame.showArguments = checked and true or false;
if (DebugToolsSavedVars) then
DebugToolsSavedVars.ShowArguments = _EventTraceFrame.showArguments;
end
EventTraceFrame_Update();
end
function EventTraceFrame_ToggleTimestamp(checked)
if (not _EventTraceFrame) then return; end
_EventTraceFrame.showTimestamp = checked and true or false;
if (DebugToolsSavedVars) then
DebugToolsSavedVars.ShowTimestamp = _EventTraceFrame.showTimestamp;
end
EventTraceFrame_Update();
end
function EventTraceFrame_OnSearchChanged(editBox)
if (not _EventTraceFrame) then return; end
local text = editBox:GetText() or "";
local clearBtn = getglobal("EventTraceFrameSearchClear");
if (clearBtn) then
if (text == "") then clearBtn:Hide(); else clearBtn:Show(); end
end
if (text == "") then text = nil; end
if (text == _EventTraceFrame.searchText) then return; end
_EventTraceFrame.searchText = text;
_EventTrace_RebuildFilter();
-- Reset scroll to the newest end of the filtered view so the user
-- sees fresh matches first.
local scroll = getglobal("EventTraceFrameScroll");
if (scroll) then
local mn, mx = _EventTrace_ScrollRange();
scroll:SetMinMaxValues(mn, math.max(mn, mx));
scroll:SetValue(math.max(mn, mx));
end
EventTraceFrame_Update();
end
-- Programmatic filter list mutation — also exposed via `/etrace ignore`.
-- Updates both the runtime ignoredEvents map and the saved-vars list
-- so the addition persists across sessions.
function EventTraceFrame_AddFilter(eventName)
if (not _EventTraceFrame or not eventName or eventName == "") then return; end
eventName = string.upper(eventName);
if (_EventTraceFrame.ignoredEvents[eventName]) then return; end
_EventTraceFrame.ignoredEvents[eventName] = true;
if (DebugToolsSavedVars and DebugToolsSavedVars.Filters
and DebugToolsSavedVars.Filters.User) then
table.insert(DebugToolsSavedVars.Filters.User, eventName);
end
end
function EventTraceFrame_RemoveFilter(eventName)
if (not _EventTraceFrame or not eventName) then return; end
eventName = string.upper(eventName);
_EventTraceFrame.ignoredEvents[eventName] = nil;
if (DebugToolsSavedVars and DebugToolsSavedVars.Filters
and DebugToolsSavedVars.Filters.User) then
local list = DebugToolsSavedVars.Filters.User;
for i = table.getn(list), 1, -1 do
if (list[i] == eventName) then table.remove(list, i); end
end
end
end
function EventTraceFrame_Update()
if (not _EventTraceFrame or not _EventTraceFrame.buttons) then
-- Slider OnValueChanged can fire during slider OnLoad, which happens
-- before EventTraceFrame_OnLoad in 1.12 XML load order.
return;
end
local scrollBar = getglobal("EventTraceFrameScroll");
if (not scrollBar) then return; end
local scrollBarValue = scrollBar:GetValue();
local minValue, maxValue = scrollBar:GetMinMaxValues();
local firstID, lastID = _EventTrace_ScrollRange();
if (firstID >= lastID) then
scrollBar:SetMinMaxValues(firstID - 1, lastID);
else
scrollBar:SetMinMaxValues(firstID, lastID);
end
if (scrollBarValue < firstID) then
scrollBar:SetValue(firstID);
scrollBarValue = firstID;
end
if (scrollBarValue < 1) then
scrollBarValue = 1;
elseif (not _EventTraceFrame.selectedEvent) then
if (scrollBarValue == maxValue) then
scrollBar:SetValue(lastID);
end
end
for i = 1, _EventTraceFrame.visibleButtons do
local button = _EventTraceFrame.buttons[i];
if (button) then
local index = _EventTrace_ResolveIndex(scrollBarValue, i - 1);
local slot = _Slot(index);
local event = slot and _EventTraceFrame.events[slot];
if (event) then
local timeString = _EventTraceFrame.times[slot];
button.index = index;
local timeFS = getglobal(button:GetName() .. "Time");
local eventFS = getglobal(button:GetName() .. "Event");
-- ShowTimestamp toggle blanks the time column rather
-- than moving frames around — keeps the event column
-- left edge stable, which matters when toggling on/off
-- mid-session.
if (_EventTraceFrame.showTimestamp) then
timeFS:SetText(_TimeText(slot));
else
timeFS:SetText("");
end
eventFS:SetText(_EventTrace_FormatRow(slot));
local color = EVENT_TRACE_EVENT_COLORS[event]
or EVENT_TRACE_EVENT_COLORS[timeString];
if (color) then
timeFS:SetTextColor(unpack(color));
eventFS:SetTextColor(unpack(color));
else
timeFS:SetTextColor(1, 1, 1, 1);
eventFS:SetTextColor(1, 1, 1, 1);
end
button:Show();
if (_EventTraceFrame.selectedEvent) then
if (index == _EventTraceFrame.selectedEvent) then
EventTraceFrameEvent_DisplayTooltip(button);
button:GetHighlightTexture():SetVertexColor(.15, .25, 1, .35);
button:LockHighlight();
button.wasSelected = true;
elseif (button.wasSelected) then
button.wasSelected = nil;
button:GetHighlightTexture():SetVertexColor(.8, .8, 1, .15);
button:UnlockHighlight();
end
else
if (button.wasSelected) then
button.wasSelected = nil;
button:GetHighlightTexture():SetVertexColor(.8, .8, 1, .15);
button:UnlockHighlight();
end
if MouseIsOver(button) then
EventTraceFrameEvent_OnEnter(button);
end
end
else
button.index = index;
button:Hide();
end
end
end
end
function EventTraceFrame_StartEventCapture()
if (_EventTraceFrame.started) then return; end
_EventTraceFrame.started = true;
_framesSinceLast = 0;
_timeSinceLast = 0;
_EventTraceFrame:RegisterAllEvents();
EventTraceFrame_OnEvent(_EventTraceFrame, "Begin Capture");
end
function EventTraceFrame_StopEventCapture()
if (not _EventTraceFrame.started) then return; end
_EventTraceFrame.started = false;
_framesSinceLast = 0;
_timeSinceLast = 0;
_EventTraceFrame:UnregisterAllEvents();
EventTraceFrame_OnEvent(_EventTraceFrame, "End Capture");
end
local function _ChatPrint(msg)
DEFAULT_CHAT_FRAME:AddMessage("|cff88ff88EventTrace:|r " .. msg);
end
function EventTraceFrame_HandleSlashCmd(msg)
if (msg == nil) then msg = ""; end
msg = string.lower(msg);
-- /etrace add EVENT
local _, _, addEvent = string.find(msg, "^add%s+(%S+)");
if (addEvent) then
addEvent = string.upper(addEvent);
if (_EventTraceFrame.started) then
_EventTraceFrame:RegisterEvent(addEvent);
end
_ChatPrint("added " .. addEvent);
return;
end
-- /etrace remove EVENT
local _, _, rmEvent = string.find(msg, "^remove%s+(%S+)");
if (rmEvent) then
rmEvent = string.upper(rmEvent);
if (_EventTraceFrame.started) then
_EventTraceFrame:UnregisterEvent(rmEvent);
end
_ChatPrint("removed " .. rmEvent);
return;
end
-- /etrace ignore EVENT — persists across sessions via saved vars
local _, _, igEvent = string.find(msg, "^ignore%s+(%S+)");
if (igEvent) then
igEvent = string.upper(igEvent);
EventTraceFrame_AddFilter(igEvent);
_ChatPrint("ignoring " .. igEvent);
return;
end
-- /etrace unignore EVENT — opposite of ignore
local _, _, unEvent = string.find(msg, "^unignore%s+(%S+)");
if (unEvent) then
unEvent = string.upper(unEvent);
EventTraceFrame_RemoveFilter(unEvent);
_ChatPrint("unignored " .. unEvent);
return;
end
if (msg == "start") then
EventTraceFrame_StartEventCapture();
elseif (msg == "stop") then
EventTraceFrame_StopEventCapture();
elseif (msg == "pause") then
EventTraceFrame_TogglePause();
_ChatPrint(_EventTraceFrame.paused and "paused" or "resumed");
elseif (msg == "filters") then
if (DebugToolsSavedVars and DebugToolsSavedVars.Filters
and DebugToolsSavedVars.Filters.User) then
local list = DebugToolsSavedVars.Filters.User;
_ChatPrint(string.format("filters (%d):", table.getn(list)));
for i = 1, table.getn(list) do
_ChatPrint(" " .. list[i]);
end
else
_ChatPrint("no saved filters");
end
elseif (msg == "clear") then
_EventTraceFrame.events = {};
_EventTraceFrame.times = {};
_EventTraceFrame.rawtimes = {};
_EventTraceFrame.elapsed = {};
_EventTraceFrame.frames = {};
_EventTraceFrame.args = {};
for i = 1, EVENT_TRACE_MAX_ARGS do _EventTraceFrame.args[i] = {}; end
_EventTraceFrame.lastIndex = 0;
_EventTraceFrame.filteredIndices = nil;
EventTraceFrame_Update();
elseif (tonumber(msg) and tonumber(msg) > 0) then
if (not _EventTraceFrame.started) then
_EventTraceFrame.eventsToCapture = tonumber(msg);
EventTraceFrame_StartEventCapture();
end
elseif (msg == "" or msg == "toggle") then
if (not _EventTraceFrame:IsShown()) then
_EventTraceFrame:Show();
if (_EventTraceFrame.started == nil) then
EventTraceFrame_StartEventCapture();
end
else
_EventTraceFrame:Hide();
end
else
_ChatPrint("usage:");
_ChatPrint(" /etrace -- toggle window (auto-start first time)");
_ChatPrint(" /etrace start -- begin event capture");
_ChatPrint(" /etrace stop -- end event capture");
_ChatPrint(" /etrace pause -- pause/resume in-place");
_ChatPrint(" /etrace <N> -- capture next N events");
_ChatPrint(" /etrace add <EV> -- register additional event");
_ChatPrint(" /etrace remove <EV> -- unregister event");
_ChatPrint(" /etrace ignore <EV> -- hide event (persists)");
_ChatPrint(" /etrace unignore <EV> -- remove from ignore list");
_ChatPrint(" /etrace filters -- list saved ignored events");
_ChatPrint(" /etrace clear -- clear log");
_ChatPrint(" (toolbar has Pause + Args/Time toggles + Search)");
end
end
function EventTraceFrame_OnMouseWheel(self, delta)
local scrollBar = getglobal("EventTraceFrameScroll");
local minVal, maxVal = scrollBar:GetMinMaxValues();
local currentValue = scrollBar:GetValue();
local newValue = currentValue - (delta * 3);
if (newValue < minVal) then newValue = minVal; end
if (newValue > maxVal) then newValue = maxVal; end
if (newValue ~= currentValue) then
scrollBar:SetValue(newValue);
end
end
local TIME_ENTRY_FORMAT = "Time:";
local DETAILS_ENTRY_FORMAT = "Details:";
local ARGUMENT_ENTRY_FORMAT = "arg %d:";
-- `||` is WoW's escape for a literal pipe in FontString display text.
-- Arg values carrying `|c...|r` color codes or `|Hitem:...|h` hyperlinks
-- (chat-event args, combat-log fields, anything from a Lua addon that
-- pushed a colored string) would otherwise get re-interpreted by the
-- renderer when concatenated into a row. A stray unterminated color
-- code leaks state into the rest of the row text.
function _EventTrace_EscapePipes(s)
return (string.gsub(s, "|", "||"));
end
-- Global (not local) because `_EventTrace_FormatRow` defined earlier in
-- this chunk calls it — a `local function` here wouldn't be in scope at
-- that earlier declaration site in Lua 5.0.
function EventTrace_FormatArgValue(val)
local t = type(val);
if (t == "string") then
return string.format('"%s"', _EventTrace_EscapePipes(val));
elseif (t == "number") then
return tostring(val);
elseif (t == "boolean") then
return string.format('|cffaaaaff%s|r', tostring(val));
elseif (t == "table" or t == "function" or t == "userdata") then
return string.format('|cffffaaaa%s|r',
_EventTrace_EscapePipes(tostring(val)));
end
return _EventTrace_EscapePipes(tostring(val));
end
function EventTraceFrameEvent_DisplayTooltip(eventButton)
local slot = _Slot(eventButton.index);
if (not slot) then return; end
local tooltip = EventTraceTooltip;
tooltip:SetOwner(eventButton, "ANCHOR_NONE");
tooltip:SetPoint("TOPLEFT", eventButton, "TOPRIGHT", 24, 2);
local timeString = _EventTraceFrame.times[slot];
if (EVENT_TRACE_SYSTEM_TIMES[timeString]) then
tooltip:AddLine(timeString, 1, 1, 1);
tooltip:AddDoubleLine(TIME_ENTRY_FORMAT,
tostring(_EventTraceFrame.rawtimes[slot]),
1, .82, 0, 1, 1, 1);
tooltip:AddDoubleLine(DETAILS_ENTRY_FORMAT,
_EventText(slot),
1, .82, 0, 1, 1, 1);
else
tooltip:AddLine(_EventTraceFrame.events[slot], 1, 1, 1);
tooltip:AddDoubleLine(TIME_ENTRY_FORMAT,
tostring(_EventTraceFrame.rawtimes[slot]),
1, .82, 0, 1, 1, 1);
for k, v in ipairs(_EventTraceFrame.args) do
if (v[slot] ~= nil) then
tooltip:AddDoubleLine(string.format(ARGUMENT_ENTRY_FORMAT, k),
EventTrace_FormatArgValue(v[slot]),
1, .82, 0, 1, 1, 1);
end
end
end
tooltip:Show();
end
function EventTraceFrameEvent_OnEnter(self)
if (_EventTraceFrame.selectedEvent) then return; end
EventTraceFrameEvent_DisplayTooltip(self);
end
function EventTraceFrameEvent_OnLeave(self)
if (not _EventTraceFrame.selectedEvent) then
EventTraceTooltip:Hide();
end
end
function EventTraceFrameEvent_OnClick(self)
if (_EventTraceFrame.selectedEvent == self.index) then
_EventTraceFrame.selectedEvent = nil;
else
_EventTraceFrame.selectedEvent = self.index;
end
EventTraceFrame_Update();
end
------------------------------------------------------------------------------
-- ScriptErrorsFrame
------------------------------------------------------------------------------
local ERROR_FORMAT = "|cffffd200Message:|r|cffffffff %s|r\n"
.. "|cffffd200Time:|r|cffffffff %s|r\n"
.. "|cffffd200Count:|r|cffffffff %s|r\n"
.. "|cffffd200Stack:|r|cffffffff %s|r";
local INDEX_ORDER_FORMAT = "%d / %d";
local _ScriptErrorsFrame;
local _previousErrorHandler;
function ScriptErrorsFrame_OnLoad(self)
local titleFS = getglobal(self:GetName() .. "Title");
if (titleFS) then
titleFS:SetText("Lua Error");
end
self:RegisterForDrag("LeftButton");
self.seen = {};
self.order = {};
self.count = {};
self.messages = {};
self.times = {};
_ScriptErrorsFrame = self;
end
function ScriptErrorsFrame_OnShow(self)
ScriptErrorsFrame_Update();
end
function ScriptErrorsFrame_OnError(message, keepHidden)
if (message == nil) then return; end
local stack = debugstack(DEBUGLOCALS_LEVEL) or "";
local messageStack = message .. stack;
if (_ScriptErrorsFrame) then
local index = _ScriptErrorsFrame.seen[messageStack];
if (index) then
_ScriptErrorsFrame.count[index] = _ScriptErrorsFrame.count[index] + 1;
_ScriptErrorsFrame.messages[index] = message;
_ScriptErrorsFrame.times[index] = date();
else
table.insert(_ScriptErrorsFrame.order, stack);
index = table.getn(_ScriptErrorsFrame.order);
_ScriptErrorsFrame.count[index] = 1;
_ScriptErrorsFrame.messages[index] = message;
_ScriptErrorsFrame.times[index] = date();
_ScriptErrorsFrame.seen[messageStack] = index;
end
if (not _ScriptErrorsFrame:IsShown() and not keepHidden) then
_ScriptErrorsFrame.index = index;
_ScriptErrorsFrame:Show();
else
ScriptErrorsFrame_Update();
end
end
-- Chain through to whatever previous handler existed (e.g. BugGrabber)
if (_previousErrorHandler and _previousErrorHandler ~= ScriptErrorsFrame_OnError) then
pcall(_previousErrorHandler, message);
end
end
function ScriptErrorsFrame_Update()
local editBox = getglobal("ScriptErrorsFrameScrollFrameText");
local index = _ScriptErrorsFrame.index;
if (not index or not _ScriptErrorsFrame.order[index]) then
index = table.getn(_ScriptErrorsFrame.order);
_ScriptErrorsFrame.index = index;
end
if (index == 0) then
editBox:SetText("");
ScriptErrorsFrame_UpdateButtons();
return;
end
local text = string.format(ERROR_FORMAT,
_ScriptErrorsFrame.messages[index],
_ScriptErrorsFrame.times[index],
_ScriptErrorsFrame.count[index],
_ScriptErrorsFrame.order[index]);
editBox:SetText(text);
editBox:HighlightText(0);
editBox:SetCursorPosition(0);
local scrollFrame = getglobal("ScriptErrorsFrameScrollFrame");
if (scrollFrame and scrollFrame.SetVerticalScroll) then
scrollFrame:SetVerticalScroll(0);
end
ScriptErrorsFrame_UpdateButtons();
end
function ScriptErrorsFrame_UpdateButtons()
local index = _ScriptErrorsFrame.index;
local numErrors = table.getn(_ScriptErrorsFrame.order);
local nextBtn = getglobal("ScriptErrorsFrameNext");
local prevBtn = getglobal("ScriptErrorsFramePrevious");
local idxLbl = getglobal("ScriptErrorsFrameIndexLabel");
if (index == 0 or numErrors == 0) then
nextBtn:Disable();
prevBtn:Disable();
else
if (numErrors == 1) then
nextBtn:Disable();
prevBtn:Disable();
elseif (index == 1) then
nextBtn:Enable();
prevBtn:Disable();
elseif (index == numErrors) then
nextBtn:Disable();
prevBtn:Enable();
else
nextBtn:Enable();
prevBtn:Enable();
end
end
idxLbl:SetText(string.format(INDEX_ORDER_FORMAT, index, numErrors));
end
function ScriptErrorsFrameButton_OnClick(self)
local id = self:GetID();
if (id == 1) then
_ScriptErrorsFrame.index = _ScriptErrorsFrame.index + 1;
else
_ScriptErrorsFrame.index = _ScriptErrorsFrame.index - 1;
end
ScriptErrorsFrame_Update();
end
function ScriptErrorsFrame_TitleButton_OnDragStart()
_ScriptErrorsFrame.moving = true;
_ScriptErrorsFrame:StartMoving();
end
function ScriptErrorsFrame_TitleButton_OnDragStop()
_ScriptErrorsFrame.moving = nil;
_ScriptErrorsFrame:StopMovingOrSizing();
end
function ScriptErrorsFrame_HandleSlashCmd(msg)
if (msg == nil) then msg = ""; end
msg = string.lower(msg);
if (msg == "on" or msg == "install") then
_previousErrorHandler = geterrorhandler();
seterrorhandler(ScriptErrorsFrame_OnError);
_ChatPrint("Lua error capture installed.");
elseif (msg == "off" or msg == "uninstall") then
if (_previousErrorHandler) then
seterrorhandler(_previousErrorHandler);
end
_ChatPrint("Lua error capture uninstalled.");
elseif (msg == "test") then
ScriptErrorsFrame_OnError("test error from /luaerrors test");
elseif (msg == "clear") then
_ScriptErrorsFrame.seen = {};
_ScriptErrorsFrame.order = {};
_ScriptErrorsFrame.count = {};
_ScriptErrorsFrame.messages = {};
_ScriptErrorsFrame.times = {};
_ScriptErrorsFrame.index = 0;
ScriptErrorsFrame_Update();
else
if (_ScriptErrorsFrame:IsShown()) then
_ScriptErrorsFrame:Hide();
else
_ScriptErrorsFrame:Show();
end
end
end
------------------------------------------------------------------------------
-- FrameStackTooltip
------------------------------------------------------------------------------
function DebugTooltip_OnLoad(self)
self:SetFrameLevel(self:GetFrameLevel() + 2);
if (TOOLTIP_DEFAULT_COLOR and self.SetBackdropBorderColor) then
self:SetBackdropBorderColor(TOOLTIP_DEFAULT_COLOR.r,
TOOLTIP_DEFAULT_COLOR.g,
TOOLTIP_DEFAULT_COLOR.b);
end
if (TOOLTIP_DEFAULT_BACKGROUND_COLOR and self.SetBackdropColor) then
self:SetBackdropColor(TOOLTIP_DEFAULT_BACKGROUND_COLOR.r,
TOOLTIP_DEFAULT_BACKGROUND_COLOR.g,
TOOLTIP_DEFAULT_BACKGROUND_COLOR.b);
end
end
-- The modern (10.x+) FrameStackTooltip on ClassicAPI's
-- `SetFrameStack(showHidden, showRegions, highlightIndexChanged)`, which
-- returns the highlighted entry and lists its anchors and source:
-- * Left Alt / Right Alt move the highlight down / up the list;
-- * Ctrl (on release) opens the highlighted entry in the TableInspector;
-- * Shift toggles texture information for the highlighted entry;
-- * `fsobj` is the highlighted entry after an Alt press.
-- The modern tooltip polls a KeyCommand table from OnUpdate; here the
-- MODIFIER_STATE_CHANGED(key, down) event carries the same per-side state.
FRAMESTACK_UPDATE_TIME = .1;
local function _WrapColor(text, colorHex)
return "|c" .. colorHex .. text .. "|r";
end
-- Retail's frame highlight: a green cover over a frame, and with showAnchors
-- a yellow cover over each frame it is anchored to. The table inspector's
-- Highlight checkbox uses it.
local function AnchorHighlight(frame, highlight, relativePoint)
highlight:ClearAllPoints();
highlight:SetAllPoints(frame);
highlight:Show();
if highlight.AnchorPoint then
if relativePoint then
highlight.AnchorPoint:ClearAllPoints();
highlight.AnchorPoint:SetPoint("CENTER", highlight, relativePoint);
highlight.AnchorPoint:Show();
else
highlight.AnchorPoint:Hide();
end
end
end
AnchorHighlightMixin = {};
function AnchorHighlightMixin:RetrieveAnchorHighlight(pointIndex)
if not self.AnchorHighlights then
CreateFrame("FRAME", "FrameStackAnchorHighlightTemplate1", self, "FrameStackAnchorHighlightTemplate");
end
while pointIndex > #self.AnchorHighlights do
CreateFrame("FRAME", "FrameStackAnchorHighlightTemplate"..(#self.AnchorHighlights + 1), self, "FrameStackAnchorHighlightTemplate");
end
return self.AnchorHighlights[pointIndex];
end
function AnchorHighlightMixin:HighlightFrame(baseFrame, showAnchors)
AnchorHighlight(baseFrame, self);
local pointIndex = 1;
if (showAnchors and baseFrame.GetNumPoints and baseFrame.GetPoint) then -- TODO: Fix for lines
while pointIndex <= baseFrame:GetNumPoints() do
local _, anchorFrame, anchorRelativePoint = baseFrame:GetPoint(pointIndex);
AnchorHighlight(anchorFrame, self:RetrieveAnchorHighlight(pointIndex), anchorRelativePoint);
pointIndex = pointIndex + 1;
end
end
while self.AnchorHighlights and self.AnchorHighlights[pointIndex] do
self.AnchorHighlights[pointIndex]:Hide();
pointIndex = pointIndex + 1;
end
end
function FrameStackTooltip_OnLoad(self)
DebugTooltip_OnLoad(self);
self.nextUpdate = 0;
self.highlightIndexChanged = 0;
self:RegisterEvent("MODIFIER_STATE_CHANGED");
end
function FrameStackTooltip_OnEvent(self, event, key, down)
if (event ~= "MODIFIER_STATE_CHANGED" or not self:IsShown()) then
return;
end
if (key == "LALT") then
if (down == 1) then FrameStackTooltip_ChangeHighlight(self, 1); end
elseif (key == "RALT") then
if (down == 1) then FrameStackTooltip_ChangeHighlight(self, -1); end
elseif (key == "LCTRL" or key == "RCTRL") then
-- On release, as the modern RUN_ON_UP command.
if (down == 0) then FrameStackTooltip_InspectTable(self); end
elseif (key == "LSHIFT" or key == "RSHIFT") then
if (down == 1) then FrameStackTooltip_ToggleTextureInformation(self); end
end
end
function FrameStackTooltip_ChangeHighlight(self, direction)
self.highlightIndexChanged = direction;
self.shouldSetFSObj = true;
end
function FrameStackTooltip_InspectTable(self)
if (self.highlightFrame) then
TableAttributeDisplay:InspectTable(self.highlightFrame);
TableAttributeDisplay:Show();
end
end
function FrameStackTooltip_ToggleTextureInformation(self)
self.showTextureInfo = not self.showTextureInfo;
end
-- Blizzard_TextureInfoGenerator on 1.12's texture methods: the file a
-- texture shows and its coordinates when they are not the whole image.
local function _FormatTextureCoordinates(ulX, ulY, blX, blY, urX, urY, brX, brY)
if (type(brY) ~= "number") then
return "invalid coordinates";
end
if (ulX == 0 and ulY == 0 and blX == 0 and blY == 1 and
urX == 1 and urY == 0 and brX == 1 and brY == 1) then
return "";
end
return _WrapColor(string.format("UL:(%.2f, %.2f), BL:(%.2f, %.2f), UR:(%.2f, %.2f), BR:(%.2f, %.2f)",
ulX, ulY, blX, blY, urX, urY, brX, brY), "ff00ffff");
end
local function _FormatTextureInfo(region)
if (not region:IsObjectType("Texture") or not region:IsMouseOver()) then
return nil;
end
local file = region:GetTexture();
if (file == nil) then
return nil;
end
return string.format("%s : %s: %s %s", region:GetDebugName(), _WrapColor("File", "ffff0000"),
tostring(file), _FormatTextureCoordinates(region:GetTexCoord()));
end
function FrameStackTooltip_CheckFormatTextureInfo(obj)
local regions;
if (obj:IsObjectType("Frame")) then
regions = { obj:GetRegions() };
else
regions = { obj };
end
local info = {};
for _, region in ipairs(regions) do
local line = _FormatTextureInfo(region);
if (line) then
table.insert(info, line);
end
end
if (table.getn(info) > 0) then
return table.concat(info, "\n");
end
end
function FrameStackTooltip_OnTooltipSetFrameStack(self, highlightFrame)
self.highlightFrame = highlightFrame;
if (self.highlightFrame and self.showTextureInfo) then
local textureInfo = FrameStackTooltip_CheckFormatTextureInfo(self.highlightFrame);
if (textureInfo) then
self:AddLine(textureInfo);
end
end
if (self.shouldSetFSObj) then
fsobj = self.highlightFrame;
self.shouldSetFSObj = nil;
end
if (fsobj) then
self:AddLine(string.format("\nfsobj = %s", fsobj:GetDebugName()));
end
end
function FrameStackTooltip_Show(self, showHidden, showRegions)
self:SetOwner(UIParent, "ANCHOR_NONE");
self:SetPoint("BOTTOMRIGHT", UIParent, "BOTTOMRIGHT", -32, 96);
self.default = 1;
self.showRegions = showRegions;
self.showHidden = showHidden;
self:SetFrameStack(showHidden, showRegions);
end
function FrameStackTooltip_Hide(self)
self:Hide();
end
function FrameStackTooltip_Toggle(showHidden, showRegions)
local tooltip = FrameStackTooltip;
if (tooltip:IsVisible()) then
FrameStackTooltip_Hide(tooltip);
else
FrameStackTooltip_Show(tooltip, showHidden, showRegions);
end
end
function FrameStackTooltip_OnUpdate(self, elapsed)
local now = GetTime();
if (now >= self.nextUpdate or self.highlightIndexChanged ~= 0) then
self.nextUpdate = now + FRAMESTACK_UPDATE_TIME;
self.highlightFrame = self:SetFrameStack(self.showHidden, self.showRegions, self.highlightIndexChanged);
self.highlightIndexChanged = 0;
end
end
function FrameStackTooltip_OnShow(self)
local parent = self:GetParent() or UIParent;
local ps = parent:GetEffectiveScale();
local px, py = parent:GetCenter();
if (not px or not py) then return; end
px, py = px * ps, py * ps;
local x, y = GetCursorPosition();
self:ClearAllPoints();
if (x > px) then
if (y > py) then
self:SetPoint("BOTTOMLEFT", parent, "BOTTOMLEFT", 20, 20);
else
self:SetPoint("TOPLEFT", parent, "TOPLEFT", 20, -20);
end
else
if (y > py) then
self:SetPoint("BOTTOMRIGHT", parent, "BOTTOMRIGHT", -20, 20);
else
self:SetPoint("TOPRIGHT", parent, "TOPRIGHT", -20, -20);
end
end
end
FrameStackTooltip_OnEnter = FrameStackTooltip_OnShow;
-- /framestack [showHidden [showRegions]], as the modern slash
-- command reads it: each word through StringToBoolean, with the defaults
-- false, true. The modern third word, showAnchors, drives its highlight
-- frames (the green cover), which came after 4.3.4 and are not ported: the
-- tooltip's "-->" mark, ANCHORS and SOURCE lines carry that information.
function FrameStackTooltip_HandleSlashCmd(msg)
local showHiddenArg, showRegionsArg;
showHiddenArg, msg = string.match(msg or "", "^%s*(%S+)(.*)$");
showRegionsArg, msg = string.match(msg or "", "^%s*(%S+)(.*)$");
local showHidden = StringToBoolean(showHiddenArg or "", false);
local showRegions = StringToBoolean(showRegionsArg or "", true);
FrameStackTooltip_Toggle(showHidden, showRegions);
end