Files
WeakestAuras/Debug.lua
T
github-actions[bot] dfc8169fbf WeakestAuras 0.8.0
Texture displays and progress textures

- Add a standalone Texture display with custom texture paths, color, alpha, desaturation, mirror, rotation, blend mode, sizing, and position controls.
- Add a categorized texture picker with Shapes and Blizzard Alerts, live previews, current-texture selection, and manual path entry.
- Add linear Progress Texture displays with foreground/background textures, independent colors and desaturation, four linear orientations, inverse fill, alpha, mirror, texture rotation, Crop X/Y, and Re-center X/Y controls.
- Add the Same Texture option for Progress Texture displays so foreground and background textures can be linked or selected independently.
2026-08-10 12:19:09 +00:00

2024 lines
82 KiB
Lua

-- WeakestAuras -- in-game probes and verification commands for the runtime
-- engine. Registers /wa probe, states, libs, addons, gen, load, conditions,
-- codeprobe, textprobe, texprobe, and cdtest.
if WeakestAuras.disabled then return end
local WA = WeakestAuras
WA.Debug = {}
local D = WA.Debug
local MAX_LOG_LINES = 500
local MAX_SLOT = 40 -- safe superset of any plausible buff/debuff cap on this client
-- ---------------------------------------------------------------------------
-- Output window: a scrollable EditBox so dumps can be Ctrl+C'd out instead of
-- scrolling off in chat. UIPanelScrollFrameTemplate is a stock Blizzard
-- template referenced by name, same "no XML of our own" approach the aura
-- list already uses with FauxScrollFrameTemplate (see OptionsFrame.lua).
-- ---------------------------------------------------------------------------
local buffer = {}
local frame, editBox
local function refresh()
editBox:SetText(table.concat(buffer, "\n"))
end
local function ensureFrame()
if frame then return end
frame = CreateFrame("Frame", "WA_DebugFrame", UIParent)
frame:SetWidth(560); frame:SetHeight(400)
frame:SetPoint("CENTER", UIParent, "CENTER", 250, 0)
frame:SetBackdrop(WA.Widgets.PANEL_BACKDROP)
frame:SetBackdropColor(0, 0, 0, 1)
frame:SetFrameStrata("DIALOG")
frame:SetToplevel(true)
frame:SetMovable(true)
frame:EnableMouse(true)
frame:RegisterForDrag("LeftButton")
frame:SetScript("OnDragStart", function() frame:StartMoving() end)
frame:SetScript("OnDragStop", function() frame:StopMovingOrSizing() end)
frame:Hide()
local title = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
title:SetPoint("TOP", 0, -14)
title:SetText("WeakestAuras Debug")
title:SetTextColor(1, 0.82, 0)
local close = CreateFrame("Button", nil, frame, "UIPanelCloseButton")
close:SetPoint("TOPRIGHT", -4, -4)
close:SetScript("OnClick", function() frame:Hide() end)
local clearBtn = WA.Widgets.button(frame, "Clear", function() D.Clear() end)
clearBtn:SetWidth(70)
clearBtn:SetPoint("TOPLEFT", 12, -14)
local selectBtn = WA.Widgets.button(frame, "Select All", function()
editBox:SetFocus()
editBox:HighlightText()
end)
selectBtn:SetWidth(90)
selectBtn:SetPoint("LEFT", clearBtn, "RIGHT", 6, 0)
local scroll = CreateFrame("ScrollFrame", "WA_DebugFrameScroll", frame, "UIPanelScrollFrameTemplate")
scroll:SetPoint("TOPLEFT", 12, -44)
scroll:SetPoint("BOTTOMRIGHT", -30, 12)
editBox = CreateFrame("EditBox", "WA_DebugFrameEditBox", scroll)
editBox:SetMultiLine(true)
editBox:SetAutoFocus(false)
editBox:SetFontObject(ChatFontNormal)
editBox:SetWidth(500)
editBox:SetHeight(2000) -- generously tall; the scroll frame clips/scrolls it
editBox:SetTextInsets(4, 4, 4, 4)
editBox:SetScript("OnEscapePressed", function() editBox:ClearFocus() end)
scroll:SetScrollChild(editBox)
end
function D.Log(line)
ensureFrame()
table.insert(buffer, line)
if table.getn(buffer) > MAX_LOG_LINES then
table.remove(buffer, 1)
end
refresh()
frame:Show()
end
function D.Clear()
buffer = {}
if editBox then refresh() end
end
function D.Show()
ensureFrame()
frame:Show()
end
-- ---------------------------------------------------------------------------
-- /wa dump [unit] [filter] -- settles: exact AuraData field shapes, whether
-- `name` ever carries a "(Rank N)" suffix, and where the list actually
-- terminates (the buff-cap blind-spot question).
-- ---------------------------------------------------------------------------
local function dumpOne(unit, filter)
D.Log(string.format("--- dump unit=%s filter=%s ---", unit, filter))
local found, highest = 0, 0
for i = 1, MAX_SLOT do
local aura = C_UnitAuras.GetAuraDataByIndex(unit, i, filter)
if aura then
found = found + 1
highest = i
local remain = -1
if aura.expirationTime and aura.expirationTime > 0 then
remain = aura.expirationTime - GetTime()
end
D.Log(string.format(
" i=%d name=%s apps=%s spellId=%s dispel=%s helpful=%s harmful=%s dur=%s exp=%s remain=%.1f src=%s srcGUID=%s",
i, tostring(aura.name), tostring(aura.applications), tostring(aura.spellId), tostring(aura.dispelName),
tostring(aura.isHelpful), tostring(aura.isHarmful), tostring(aura.duration), tostring(aura.expirationTime),
remain, tostring(aura.sourceUnit), tostring(aura.sourceGUID)))
end
end
D.Log(string.format("--- end dump: %d aura(s), highest occupied slot=%d (scanned 1..%d) ---", found, highest, MAX_SLOT))
end
function D.Dump(unit, filter)
if not unit or unit == "" then unit = "player" end
if filter and filter ~= "" then
dumpOne(unit, string.upper(filter))
else
dumpOne(unit, "HELPFUL")
dumpOne(unit, "HARMFUL")
end
end
-- ---------------------------------------------------------------------------
-- /wa watch [unit] -- settles: does UNIT_AURA actually fire on every aura
-- change (including a same-buff refresh), or does it miss some the way
-- pfUI's own comment claims on their server? Diffs a snapshot on a timer and
-- flags any change that happened without a UNIT_AURA fire in that window.
-- ---------------------------------------------------------------------------
local WATCH_FILTERS = { "HELPFUL", "HARMFUL" }
local watch = {
active = {}, -- [unit] = true
lastSnapshot = {}, -- [unit] = { [filter..index] = packed string }
eventSeen = {}, -- [unit] = true/false since last tick
ticker = nil,
eventFrame = nil,
}
local function snapshotUnit(unit)
local snap = {}
for f = 1, table.getn(WATCH_FILTERS) do
local filter = WATCH_FILTERS[f]
for i = 1, MAX_SLOT do
local aura = C_UnitAuras.GetAuraDataByIndex(unit, i, filter)
if aura then
snap[filter .. i] = tostring(aura.name) .. "|" .. tostring(aura.applications) .. "|" ..
tostring(aura.duration) .. "|" .. tostring(aura.expirationTime)
end
end
end
return snap
end
local function diffAndLog(unit)
local old = watch.lastSnapshot[unit] or {}
local new = snapshotUnit(unit)
for f = 1, table.getn(WATCH_FILTERS) do
local filter = WATCH_FILTERS[f]
for i = 1, MAX_SLOT do
local key = filter .. i
if old[key] ~= new[key] then
D.Log(string.format("[watch:%s] %s slot %d changed: %s -> %s (UNIT_AURA seen: %s)",
unit, filter, i, tostring(old[key]), tostring(new[key]), tostring(watch.eventSeen[unit] and true or false)))
end
end
end
watch.lastSnapshot[unit] = new
watch.eventSeen[unit] = false
end
local function tickWatch()
for unit in pairs(watch.active) do
diffAndLog(unit)
end
end
local function ensureWatchRunning()
if not watch.eventFrame then
watch.eventFrame = CreateFrame("Frame")
watch.eventFrame:RegisterEvent("UNIT_AURA")
watch.eventFrame:SetScript("OnEvent", function()
if watch.active[arg1] then
watch.eventSeen[arg1] = true
end
end)
end
if not watch.ticker then
watch.ticker = C_Timer.NewTicker(0.5, tickWatch)
end
end
function D.ToggleWatch(unit)
if not unit or unit == "" then unit = "player" end
if watch.active[unit] then
watch.active[unit] = nil
D.Log("[watch] stopped watching " .. unit)
else
watch.active[unit] = true
watch.lastSnapshot[unit] = snapshotUnit(unit)
watch.eventSeen[unit] = false
D.Log("[watch] started watching " .. unit .. " (diffing every 0.5s against UNIT_AURA)")
ensureWatchRunning()
end
end
-- ---------------------------------------------------------------------------
-- /wa events [EVENT ...] -- raw event firehose, unfiltered and independent of
-- /wa watch's per-unit bookkeeping: logs every fire with its whole payload, so
-- the actual stream can be read instead of inferred from diffs (does it ever
-- double-fire for one change? fire for a unit nobody's watching?). Defaults to
-- UNIT_AURA. Naming events is how an unfamiliar one's argument order gets
-- settled -- a doc listing an order is not evidence of it on this client.
-- ---------------------------------------------------------------------------
local eventLogFrame
local eventLogActive = false
local eventLogCount = 0
local eventLogNames = {}
-- The payload as "arg1=x arg3=y", skipping the trailing nils a shorter event
-- leaves behind.
local function eventLogPayload()
local vals = { arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 }
local parts = {}
for i = 1, 9 do
if vals[i] ~= nil then
table.insert(parts, "arg" .. i .. "=" .. tostring(vals[i]))
end
end
if table.getn(parts) == 0 then return "(no args)" end
return table.concat(parts, " ")
end
function D.ToggleEventLog(rest)
if eventLogActive then
eventLogActive = false
for i = 1, table.getn(eventLogNames) do
eventLogFrame:UnregisterEvent(eventLogNames[i])
end
D.Log(string.format("[events] stopped (%d fire(s) logged this session)", eventLogCount))
return
end
local wanted = {}
for name in string.gfind(rest or "", "%S+") do
table.insert(wanted, string.upper(name))
end
if table.getn(wanted) == 0 then wanted = { "UNIT_AURA" } end
if not eventLogFrame then
eventLogFrame = CreateFrame("Frame")
eventLogFrame:SetScript("OnEvent", function()
eventLogCount = eventLogCount + 1
D.Log(string.format("[events] #%d t=%.2f %s %s",
eventLogCount, GetTime(), event, eventLogPayload()))
end)
end
eventLogNames = {}
for i = 1, table.getn(wanted) do
local name = wanted[i]
-- RegisterEvent throws on a name this client doesn't know, which is
-- itself the answer when the question is whether the event exists here.
if pcall(function() eventLogFrame:RegisterEvent(name) end) then
table.insert(eventLogNames, name)
else
D.Log("[events] " .. name .. " -- refused by the client, no such event")
end
end
eventLogActive = true
if table.getn(eventLogNames) == 0 then
D.Log("[events] started, but nothing registered")
else
D.Log("[events] started on: " .. table.concat(eventLogNames, ", "))
end
end
-- ---------------------------------------------------------------------------
-- /wa linkprobe -- which entry point, if any, a shift-clicked item actually
-- reaches on this client. Vanilla FrameXML routes a bag shift-click straight
-- into ChatEdit_InsertLink (and only when the chat box is open);
-- HandleModifiedItemClick is a later-expansion function that may not exist
-- here at all, and a replacement bag UI bypasses both. Wraps every candidate
-- and logs which one fires, so the answer comes from a click rather than a doc.
-- ---------------------------------------------------------------------------
local linkProbeOn = false
function D.LinkProbe()
local names = {
"HandleModifiedItemClick", "ChatEdit_InsertLink", "SetItemRef",
"ContainerFrameItemButton_OnClick", "PickupContainerItem",
"IsModifiedClick", "GetContainerItemLink",
}
for i = 1, table.getn(names) do
D.Log("[link] " .. names[i] .. " = " .. type(getglobal(names[i])))
end
D.Log("[link] chat edit box visible = "
.. tostring(ChatFrameEditBox and ChatFrameEditBox:IsVisible() and true or false))
if linkProbeOn then
D.Log("[link] already logging -- shift-click an item in your bags now")
return
end
linkProbeOn = true
-- Each wrapper logs and calls through, so nothing it touches changes
-- behaviour. Left installed for the session: these are cold paths.
for i = 1, table.getn(names) do
local name = names[i]
local orig = getglobal(name)
if type(orig) == "function" then
setglobal(name, function(a1, a2, a3, a4)
D.Log("[link] " .. name .. "(" .. tostring(a1) .. ", " .. tostring(a2) .. ")")
return orig(a1, a2, a3, a4)
end)
end
end
D.Log("[link] logging installed -- now shift-click an item in your bags")
end
-- ---------------------------------------------------------------------------
-- /wa timers -- what C_Timer offers a scheduler that has to retract a pending
-- callback. Two questions a type check cannot answer on its own: whether After
-- hands back any handle at all, and whether a Cancel that returns cleanly
-- actually suppresses the callback rather than just not erroring. Both are
-- settled behaviourally here, by scheduling one of each and reporting which
-- ones fired after the deadline has passed.
-- ---------------------------------------------------------------------------
function D.Timers()
if type(C_Timer) ~= "table" then
D.Log("[timers] C_Timer is " .. type(C_Timer) .. " -- nothing to probe")
return
end
D.Log("[timers] After=" .. type(C_Timer.After)
.. " NewTimer=" .. type(C_Timer.NewTimer)
.. " NewTicker=" .. type(C_Timer.NewTicker))
local fired = {}
local function shape(label, h)
local s = "[timers] " .. label .. " returned " .. type(h)
if type(h) == "table" then s = s .. " (Cancel=" .. type(h.Cancel) .. ")" end
D.Log(s)
end
if type(C_Timer.After) ~= "function" then
D.Log("[timers] no After -- the rest of this probe cannot run")
return
end
shape("After", C_Timer.After(1, function() fired.after = true end))
local cancelled
if type(C_Timer.NewTimer) == "function" then
shape("NewTimer", C_Timer.NewTimer(1, function() fired.newtimer = true end))
cancelled = C_Timer.NewTimer(1, function() fired.cancelled = true end)
end
if type(cancelled) == "table" and type(cancelled.Cancel) == "function" then
local ok, err = pcall(function() cancelled:Cancel() end)
D.Log("[timers] Cancel() " .. (ok and "returned cleanly" or ("errored: " .. tostring(err))))
else
D.Log("[timers] no cancellable handle -- a generation counter on the owner is the fallback")
end
local t0 = GetTime()
C_Timer.After(2, function()
D.Log(string.format("[timers] +%.2fs elapsed -- After fired=%s NewTimer fired=%s cancelled fired=%s",
GetTime() - t0,
tostring(fired.after and true or false),
tostring(fired.newtimer and true or false),
tostring(fired.cancelled and true or false)))
D.Log("[timers] a cancelled timer reading true means Cancel does not suppress the callback")
end)
D.Log("[timers] scheduled -- results in ~2s. No follow-up line at all means After never fired.")
end
-- ---------------------------------------------------------------------------
-- /wa cdtest -- settles: can we render a native cooldown swipe on this client?
-- CreateFrame("Cooldown", ...) throws "Unknown frame type" here, but in vanilla
-- the swipe is really a 3D Model, so the working constructor is a "Model" frame
-- inheriting CooldownFrameTemplate -- the technique CooldownTracker uses on this
-- exact client (../reference/CooldownTracker/CooldownTracker.lua:502). This
-- probes that path; if the spiral shows in-world, the Icon region can adopt it.
-- ---------------------------------------------------------------------------
local cdTestFrame
local cdTestFailed = false
-- Guarded with pcall so a client that lacks CooldownFrameTemplate/the Model type
-- re-logs the finding instead of erroring on every re-run.
function D.CooldownTest()
if cdTestFailed then
D.Log("[cdtest] native cooldown swipe is not available on this client -- already confirmed, see previous log line.")
return
end
if not cdTestFrame then
cdTestFrame = CreateFrame("Frame", nil, UIParent)
cdTestFrame:SetWidth(48); cdTestFrame:SetHeight(48)
cdTestFrame:SetPoint("CENTER", UIParent, "CENTER", 0, 150)
local icon = cdTestFrame:CreateTexture(nil, "ARTWORK")
icon:SetAllPoints(cdTestFrame)
icon:SetTexture("Interface\\Icons\\Spell_Nature_LightningShield")
local ok, cooldown = pcall(CreateFrame, "Model", nil, cdTestFrame, "CooldownFrameTemplate")
if not ok or not cooldown then
cdTestFailed = true
D.Log("[cdtest] CreateFrame(\"Model\", ..., \"CooldownFrameTemplate\") failed: " .. tostring(cooldown) ..
" -- no native cooldown swipe on this client; Icon region stays text-only.")
return
end
cdTestFrame.cooldown = cooldown
-- The Model swipe underfills and sits bottom-left at scale 1; CooldownTracker
-- fixes it with SetScale((1/32)*iconSize) + a two-corner anchor (its
-- CalculateCooldownScale, line 505-512). iconSize here is 48.
cooldown:SetAllPoints(cdTestFrame)
cooldown:SetScale(48 / 32)
cooldown:ClearAllPoints()
cooldown:SetPoint("TOPLEFT", cdTestFrame, "TOPLEFT")
cooldown:SetPoint("BOTTOMRIGHT", cdTestFrame, "BOTTOMRIGHT")
D.Log("[cdtest] CreateFrame(\"Model\", ..., \"CooldownFrameTemplate\") succeeded, scaled 48/32 -- watch for the swipe.")
end
cdTestFrame:Show()
cdTestFrame.cooldown:Show()
CooldownFrame_SetTimer(cdTestFrame.cooldown, GetTime(), 10, 1)
D.Log("[cdtest] armed a 10s swipe on a test icon at CENTER,0,150 -- watch it in-world (not in this window). If it sweeps, the Model swipe works here.")
end
-- ---------------------------------------------------------------------------
-- /wa swipetest [sizes...] + /wa swipenudge <k> [yflat] -- fast, no-/reload
-- loop for tuning RegionPrototype.lua's SizeSwipe alignment constants.
-- swipetest spawns one real icon+swipe rig per size (default 16/32/64/128)
-- side by side so drift across sizes is visible in one screenshot; swipenudge
-- writes WA.regionPrototype.swipeNudgeK/swipeYFlat live and re-sizes every
-- active rig immediately, since SizeSwipe re-reads those fields on every call.
-- ---------------------------------------------------------------------------
local swipeTestRigs = {}
local swipeTestTicker
local SWIPE_TEST_DURATION = 6
-- Re-arms every active rig on a fresh 6s cycle -- CooldownFrame_SetTimer
-- doesn't loop on its own, so this ticker (period == duration) restarts each
-- swipe right as the previous one finishes.
local function swipeTestLoop()
for i = 1, table.getn(swipeTestRigs) do
local rig = swipeTestRigs[i]
WA.regionPrototype.ArmSwipe(rig.swipe, GetTime() + SWIPE_TEST_DURATION, SWIPE_TEST_DURATION)
end
end
function D.SwipeTest(sizesStr)
for i = table.getn(swipeTestRigs), 1, -1 do
swipeTestRigs[i]:Hide()
swipeTestRigs[i] = nil
end
if swipeTestTicker then swipeTestTicker:Cancel(); swipeTestTicker = nil end
if sizesStr == "0" then
D.Log("[swipetest] cleared")
return
end
-- Each entry is {w=, h=} -- a bare "64" means square (w=h=64), "64x32"
-- means non-square, for testing swipeStretchMode against a real W ~= H.
local sizes = {}
if sizesStr and sizesStr ~= "" then
local rest = sizesStr
while true do
local _, e, wStr, hStr = string.find(rest, "^%s*(%d+)x(%d+)")
if wStr then
table.insert(sizes, { w = tonumber(wStr), h = tonumber(hStr) })
rest = string.sub(rest, e + 1)
else
local _, e2, numStr = string.find(rest, "^%s*(%d+)")
if not numStr then break end
table.insert(sizes, { w = tonumber(numStr), h = tonumber(numStr) })
rest = string.sub(rest, e2 + 1)
end
end
end
if table.getn(sizes) == 0 then
sizes = { { w = 16, h = 16 }, { w = 32, h = 32 }, { w = 64, h = 64 }, { w = 128, h = 128 } }
end
-- Enrage (5229) instead of a hardcoded texture -- brighter icon, easier to
-- eyeball the swipe edge against than the dark LightningShield art.
local _, _, testIcon = GetSpellInfo(5229)
testIcon = testIcon or "Interface\\Icons\\Spell_Nature_LightningShield"
-- Edge-tracked, not "prev size + gap": a flat per-icon increment ignores
-- the NEXT icon's own half-width, so consecutive very-different sizes
-- (64 -> 128) would actually overlap instead of just looking cramped.
local gap = 30
local rightEdge = -300
for i = 1, table.getn(sizes) do
local w, h = sizes[i].w, sizes[i].h
local x = rightEdge + gap + w / 2
rightEdge = x + w / 2
local rig = CreateFrame("Frame", nil, UIParent)
rig:SetWidth(w); rig:SetHeight(h)
rig:SetPoint("CENTER", UIParent, "CENTER", x, 150)
local tex = rig:CreateTexture(nil, "ARTWORK")
tex:SetAllPoints(rig)
tex:SetTexture(testIcon)
tex:SetTexCoord(0.07, 0.93, 0.07, 0.93)
rig.swipe = WA.regionPrototype.CreateSwipe(rig)
WA.regionPrototype.SizeSwipe(rig.swipe, w, h)
WA.regionPrototype.ArmSwipe(rig.swipe, GetTime() + SWIPE_TEST_DURATION, SWIPE_TEST_DURATION)
if rig.swipe then rig.swipe:Show() end
local label = rig:CreateFontString(nil, "OVERLAY", "GameFontNormal")
label:SetPoint("TOP", rig, "BOTTOM", 0, -4)
label:SetText(w == h and (tostring(w) .. "px") or (tostring(w) .. "x" .. tostring(h)))
rig:Show()
table.insert(swipeTestRigs, rig)
end
swipeTestTicker = C_Timer.NewTicker(SWIPE_TEST_DURATION, swipeTestLoop)
D.Log("[swipetest] spawned " .. table.getn(swipeTestRigs) .. " rig(s) at CENTER,*,150, looping every " ..
SWIPE_TEST_DURATION .. "s -- /wa swipenudge <k> [yflat] to tune live, /wa swipetest (no args) to respawn defaults, /wa swipetest 0 to clear")
end
function D.SwipeNudge(rest)
local _, _, kStr, yStr = string.find(rest or "", "^(%S*)%s*(%S*)$")
local k = tonumber(kStr)
if not k then
D.Log(string.format("[swipenudge] current: swipeNudgeK=%s swipeYFlat=%s -- usage: /wa swipenudge <k> [yflat]",
tostring(WA.regionPrototype.swipeNudgeK), tostring(WA.regionPrototype.swipeYFlat)))
return
end
local y = tonumber(yStr)
WA.regionPrototype.swipeNudgeK = k
if y then WA.regionPrototype.swipeYFlat = y end
for i = 1, table.getn(swipeTestRigs) do
local rig = swipeTestRigs[i]
WA.regionPrototype.SizeSwipe(rig.swipe, rig:GetWidth(), rig:GetHeight())
end
D.Log(string.format("[swipenudge] swipeNudgeK=%s swipeYFlat=%s -- re-sized %d active rig(s)",
tostring(WA.regionPrototype.swipeNudgeK), tostring(WA.regionPrototype.swipeYFlat), table.getn(swipeTestRigs)))
end
-- ---------------------------------------------------------------------------
-- /wa track <spellName> -- settles: is the player's own duration/
-- expirationTime actually monotonic and does it reset cleanly on recast, or
-- does it exhibit the same flakiness DoiteAuras had to work around?
-- ---------------------------------------------------------------------------
local trackSpell
local trackTicker
local function trackTick()
if not trackSpell then return end
local found
for i = 1, MAX_SLOT do
local aura = C_UnitAuras.GetAuraDataByIndex("player", i, "HELPFUL")
if not aura then break end
if aura.name == trackSpell then
found = aura
break
end
end
if found then
local remain = -1
if found.expirationTime and found.expirationTime > 0 then
remain = found.expirationTime - GetTime()
end
D.Log(string.format("[track] t=%.1f %s stacks=%s dur=%s exp=%s remain=%.1f",
GetTime(), trackSpell, tostring(found.applications), tostring(found.duration),
tostring(found.expirationTime), remain))
else
D.Log(string.format("[track] t=%.1f %s NOT FOUND", GetTime(), trackSpell))
end
end
function D.Track(spellName)
if not spellName or spellName == "" then
trackSpell = nil
if trackTicker then trackTicker:Cancel(); trackTicker = nil end
D.Log("[track] stopped")
return
end
trackSpell = spellName
D.Log("[track] now tracking \"" .. spellName .. "\" (logging every 1s)")
if not trackTicker then
trackTicker = C_Timer.NewTicker(1, trackTick)
end
end
-- ---------------------------------------------------------------------------
-- /wa states <id> -- dumps triggerState[id]: the combination flags and every
-- trigger's per-clone states. The single most useful command for debugging the
-- state machine -- shows what the producers wrote and what the glue resolved.
-- ---------------------------------------------------------------------------
local STATE_FIELDS = {
"show", "changed", "active", "progressType", "name", "stacks", "duration",
"expirationTime", "value", "total", "spellId", "unit", "unitCaster",
"initialTime", "refreshTime", "stackGainTime", "stackLostTime",
}
local function dumpState(triggernum, cloneId, state)
local parts = {}
for i = 1, table.getn(STATE_FIELDS) do
local f = STATE_FIELDS[i]
if state[f] ~= nil then
local v = state[f]
if f == "expirationTime" and type(v) == "number" and v > 0 then
v = string.format("%s (rem %.1f)", tostring(v), v - GetTime())
end
table.insert(parts, f .. "=" .. tostring(v))
end
end
D.Log(string.format(" [%d][%q] %s", triggernum, cloneId, table.concat(parts, " ")))
end
function D.States(id)
if not id or id == "" then
D.Log("[states] usage: /wa states <aura id>")
return
end
local ts = WA.GetDisplayTriggerState and WA.GetDisplayTriggerState(id)
if not ts then
D.Log(string.format("[states] no triggerState for %q (unknown id, or a group)", id))
return
end
local ftCount = WA.regionPrototype.CountFrameTick and WA.regionPrototype.CountFrameTick() or 0
D.Log(string.format("--- states %q: show=%s disjunctive=%s numTriggers=%d triggerCount=%d activeMode=%s (global FrameTick subscribers: %d) ---",
id, tostring(ts.show), tostring(ts.disjunctive), ts.numTriggers, ts.triggerCount, tostring(ts.activeTriggerMode), ftCount))
for triggernum = 1, ts.numTriggers do
D.Log(string.format(" trigger %d: active=%s", triggernum, tostring(ts.triggers[triggernum])))
local allstates = ts[triggernum]
if allstates then
for cloneId, state in pairs(allstates) do
dumpState(triggernum, cloneId, state)
end
end
end
D.Log("--- end states ---")
end
-- ---------------------------------------------------------------------------
-- /wa conditions <id> -- dumps data.conditions (each check + its changes) and
-- the live per-clone activation flags + whether an exact recheck timer is
-- pending. The verification tool for condition timing: confirms a
-- timer/elapsedTimer flip is scheduled rather than polled, and which
-- conditions the interpreter currently has active.
-- ---------------------------------------------------------------------------
function D.Conditions(id)
if not id or id == "" then
D.Log("[conditions] usage: /wa conditions <aura id>")
return
end
local data = WeakestAurasDB.displays[id]
if not data then
D.Log("[conditions] unknown id " .. tostring(id))
return
end
local conds = data.conditions or {}
D.Log(string.format("--- conditions %q: %d condition(s) ---", id, table.getn(conds)))
for i = 1, table.getn(conds) do
local c = conds[i]
local chk = c.check or {}
D.Log(string.format(" [%d] check: trigger=%s var=%s op=%s value=%s",
i, tostring(chk.trigger), tostring(chk.variable), tostring(chk.op), tostring(chk.value)))
local changes = c.changes or {}
for j = 1, table.getn(changes) do
D.Log(string.format(" change: %s = %s", tostring(changes[j].property), tostring(changes[j].value)))
end
end
if WA.GetConditionDebug then
local _, act, pending = WA.GetConditionDebug(data.uid)
if act then
for cloneId, flags in pairs(act) do
local parts = {}
for i = 1, table.getn(conds) do table.insert(parts, tostring(flags[i] and 1 or 0)) end
D.Log(string.format(" active[%q] = [%s]", cloneId, table.concat(parts, ",")))
end
end
if pending and table.getn(pending) > 0 then
D.Log(" pending recheck for clone(s): " .. table.concat(pending, ", "))
else
D.Log(" no pending timer recheck")
end
end
D.Log("--- end conditions ---")
end
-- ---------------------------------------------------------------------------
-- /wa gen <id> -- dumps the Lua source ConstructFunction generated for this
-- display's generic trigger(s). A string-
-- assembly bug surfaces as readable source here rather than an opaque
-- loadstring error at Add-time.
-- ---------------------------------------------------------------------------
function D.Gen(id)
if not id or id == "" then
D.Log("[gen] usage: /wa gen <aura id>")
return
end
local src = WA.GetGeneratedSource and WA.GetGeneratedSource(id)
if not src then
D.Log(string.format("[gen] no generated source for %q (not a generic trigger, or unknown id)", id))
return
end
D.Log(string.format("--- generated source for %q ---", id))
D.Log(src)
D.Log("--- end generated source ---")
end
-- ---------------------------------------------------------------------------
-- /wa load <id> -- dumps data.load (the enabled constraints) and whether the
-- display is currently loaded (WA.IsDisplayLoaded) + what a fresh WA.EvalLoad
-- says at the time of the check. The verification tool for load state:
-- confirms an aura loads/unloads as its class/level/zone/combat/... change, and
-- that a transient-only failure reads as standby rather than not loaded.
-- ---------------------------------------------------------------------------
function D.Load(id)
if not id or id == "" then
D.Log("[load] usage: /wa load <aura id>")
return
end
local data = WeakestAurasDB.displays[id]
if not data then
D.Log("[load] unknown id " .. tostring(id))
return
end
local state, nLoaded, nStandby, nLeaves = WA.DisplayLoadState(id)
if WA.IsGroup(data) then
D.Log(string.format("[load] %q is a group: state=%s (%d loaded, %d standby of %d leaves)",
id, state, nLoaded, nStandby, nLeaves))
return
end
local L = data.load or {}
local isLoaded = WA.IsDisplayLoaded and WA.IsDisplayLoaded(id)
local evalNow = WA.EvalLoad and WA.EvalLoad(data)
local evalStatic = WA.EvalLoadStatic and WA.EvalLoadStatic(data)
D.Log(string.format("--- load %q: state=%s loaded=%s evalNow=%s evalStatic=%s ---",
id, state, tostring(isLoaded), tostring(evalNow), tostring(evalStatic)))
if WA.IsGenericTriggerActive then
local genActive = WA.IsGenericTriggerActive(id)
if genActive ~= nil then
D.Log(string.format(" GenericTrigger registration: active=%s (if this is false while loaded=true above, the system's LoadDisplays never actually finished for this id)", tostring(genActive)))
end
end
if L.never then D.Log(" never = true (force-disabled)") end
local proto = WA.loadPrototype or {}
local anyConstraint = L.never
for i = 1, table.getn(proto) do
local arg = proto[i]
-- Branched, not `and`/`or`-ed -- see WA.EvalLoad's own gate.
local active
if arg.isActive then
active = arg.isActive(L) and true or false
else
active = L["use_" .. arg.name] and true or false
end
if active then
anyConstraint = true
if arg.name == "class" then
if L.use_class == "single" then
D.Log(" class = " .. tostring(L.class) .. " (single)")
else
local picked = {}
for ci = 1, table.getn(WA.CLASS_TOKENS) do
local token = WA.CLASS_TOKENS[ci]
if L.classes and L.classes[token] then table.insert(picked, token) end
end
D.Log(" class = " .. (table.getn(picked) > 0 and table.concat(picked, ",") or "(none picked)") .. " (multi)")
end
else
local opKey = arg.name .. "_operator"
local opPart = L[opKey] and (" op=" .. tostring(L[opKey])) or ""
D.Log(string.format(" %s =%s value=%s%s", arg.name, opPart, tostring(L[arg.name]),
arg.optional and " (transient -- ignored by evalStatic)" or ""))
end
end
end
if L.use_class ~= nil and L.use_class ~= "single" and L.use_class ~= "multi" then
D.Log(" note: use_class=" .. tostring(L.use_class) .. " is a stray/legacy value (ignored, not \"single\"/\"multi\")")
end
if not anyConstraint then D.Log(" (no constraints -- always loaded)") end
D.Log("--- end load ---")
end
-- ---------------------------------------------------------------------------
-- /wa probe -- checks two client capabilities before relying on either:
-- (1) is C_EncodingUtil's full CBOR chain present (import/
-- export), and (2) does the border's WHITE8X8 edge texture actually render on
-- this client. Also reports the glow overlay pool count (leak check). Spawns a
-- visible bordered test frame at CENTER,0,150 -- watch it in-world, not here.
-- ---------------------------------------------------------------------------
local probeFrame
-- ---------------------------------------------------------------------------
-- /wa rows -- measured geometry of the aura list: the box, how many rows it
-- decided fit and what that leaves unused, and every part of the first two
-- rows. The one thing the headless harness structurally cannot see is where a
-- frame actually lands (its mock has no geometry engine), so a row whose
-- highlight doesn't cover its own text, or a list wasting a row's worth of
-- height, is answered here rather than by reading anchors.
-- ---------------------------------------------------------------------------
function D.Rows()
local S = WA.OptionsState
if not S or not S.listBg then
D.Log("[rows] options window has never been built -- open it first")
return
end
local function edges(name, f)
if not f then D.Log(" " .. name .. " = (nil)") return end
D.Log(string.format(" %-7s top=%.1f bottom=%.1f h=%.1f left=%.1f right=%.1f w=%.1f shown=%s",
name, f:GetTop() or -1, f:GetBottom() or -1, f:GetHeight() or -1,
f:GetLeft() or -1, f:GetRight() or -1, f:GetWidth() or -1, tostring(f:IsShown() and true or false)))
end
local h = S.listBg:GetHeight() or 0
local used = S.visibleRows * S.ROW_H
D.Log(string.format("--- rows: listBg h=%.1f, ROW_H=%d, visibleRows=%d ---", h, S.ROW_H, S.visibleRows))
D.Log(string.format(" rows occupy %d px of %.1f, leaving %.1f unused (a further row needs %d)",
used, h, h - used - 2, S.ROW_H))
edges("listBg", S.listBg)
edges("scroll", S.scroll)
for i = 1, 2 do
local row = S.rows and S.rows[i]
if row then
D.Log(" -- row " .. i .. " (" .. tostring(row.id) .. ")")
edges("row", row)
edges("sel", row.sel)
edges("icon", row.icon)
edges("thumb", row.thumb)
edges("title", row.title)
edges("sub", row.sub)
edges("strip", row.statusStrip)
edges("eye", row.eye)
end
end
D.Log("--- end rows ---")
end
-- Which vendored LibWidgets actually won, and whether it still has everything
-- this addon calls. Every addon vendoring the library shares one global
-- instance (highest MINOR wins, ties to whoever registered first), so a sibling
-- addon's older copy can silently be the one running -- see libs\LibWidgetsDev.lua.
function D.Libs()
local W = WA.Widgets
D.Log("--- libs ---")
-- Whichever addon's LibStub loaded first is the one in force for everyone
-- (equal LIBSTUB_MINOR means later copies skip). Upstream's NewLibrary calls
-- string.match, absent here, so a copy that hasn't been patched to
-- string.find throws on every registration -- worth being able to see which
-- one is live rather than inferring it from a crash.
D.Log(" string.match available = " .. tostring(string.match ~= nil))
D.Log(" LibStub minor = " .. tostring(LibStub and LibStub.minor))
D.Log(" LIBWIDGETS_DEV = " .. tostring(LIBWIDGETS_DEV))
D.Log(" live LibWidgets MINOR = " .. tostring(LibWidgets and LibWidgets.MINOR))
if LibStub and LibStub.minors then
D.Log(" LibStub minors[LibWidgets-1.0] = " .. tostring(LibStub.minors["LibWidgets-1.0"]))
end
if LibWidgets then
-- How the live LibStub would have read our MINOR (9). A backported
-- string.match with string.find's return contract yields a position
-- rather than the captured digits, which silently turns every version
-- into the same number and hands the race to whoever registered first.
D.Log(" MINOR 9 parses as: via string.match = " .. tostring(LibWidgets.PARSE_MATCH)
.. ", via string.find capture = " .. tostring(LibWidgets.PARSE_FIND))
D.Log(" minors[LibWidgets-1.0] before our registration = " .. tostring(LibWidgets.PRE_MINOR))
end
if LibStub and LibStub.libs then
-- Every major reads back as LibStub's own minor (2) even though the
-- libraries declare 3/6/8/44, while our own write of 9 into the same
-- table reads back correctly. A plain table can't do that, so dump the
-- raw value beside the indexed one and the metatables: if rawget differs,
-- something has installed an __index on LibStub's bookkeeping.
D.Log(" metatables: LibStub=" .. tostring(getmetatable(LibStub))
.. " minors=" .. tostring(getmetatable(LibStub.minors))
.. " libs=" .. tostring(getmetatable(LibStub.libs)))
local majors = {}
for major in pairs(LibStub.libs) do
local raw, indexed = rawget(LibStub.minors, major), LibStub.minors[major]
local entry = major .. "=" .. tostring(indexed)
if raw ~= indexed then entry = entry .. "(raw " .. tostring(raw) .. ")" end
table.insert(majors, entry)
end
table.sort(majors)
D.Log(" all LibStub majors: " .. (table.getn(majors) > 0 and table.concat(majors, ", ") or "(none)"))
end
-- The decisive line: the numbers above look the same whether this copy won
-- the version race or the dev flag forced it, since forcing it rewrites the
-- registered minor to our own.
if LibWidgets and LibWidgets.REPAIRED then
D.Log(" LibStub refused the upgrade, so our MINOR " .. tostring(LibWidgets.MINOR)
.. " took over the older live copy (MINOR " .. tostring(LibWidgets.DISPLACED_MINOR)
.. ") on its own. This is the normal path on this client and needs no dev flag.")
elseif LibWidgets and LibWidgets.DEV_OVERRIDE then
D.Log(" our copy is live ONLY because LIBWIDGETS_DEV forced it -- it lost the"
.. " race to a copy registered at MINOR " .. tostring(LibWidgets.DISPLACED_MINOR))
elseif LibWidgets and LibWidgets.DEV_OVERRIDE == false then
D.Log(" our copy won the version race on its own (displaced MINOR "
.. tostring(LibWidgets.DISPLACED_MINOR) .. ") -- the dev flag isn't doing anything")
else
D.Log(" our copy is NOT live: some other addon's copy is (it predates DEV_OVERRIDE)")
end
-- Behavioural probe. Rather than keep hunting for whichever LibStub is live
-- (LibWindow-1.1 is registered with no file on disk anywhere, so it isn't an
-- addon's), just ask it: register a throwaway major at minor 1, then at 99.
-- A working LibStub returns a table for the second call and records 99.
local probeMajor = "WeakestAurasLibStubProbe-1.0"
if LibStub and not LibStub.libs[probeMajor] then
LibStub:NewLibrary(probeMajor, 1)
local second = LibStub:NewLibrary(probeMajor, 99)
D.probeResult = (second and "honours versions" or "IGNORES versions -- rejected minor 99 over minor 1")
.. " (recorded minor = " .. tostring(LibStub.minors[probeMajor]) .. ")"
end
if D.probeResult then D.Log(" LibStub arbitration probe: " .. D.probeResult) end
local missing = W and W.libWidgetsMissing or {}
if table.getn(missing) == 0 then
D.Log(" every required function present")
else
D.Log(" MISSING: " .. table.concat(missing, ", "))
end
end
-- Every addon the engine enumerated, loaded or not. MPQ-resident addons (packed
-- into Data\patch-X.mpq under Interface\AddOns\) enumerate exactly like disk
-- ones but load *before* them, so anything listed here with no folder in
-- Interface\AddOns is MPQ-resident -- which is how a library can be registered
-- with no file for it anywhere on disk. Cheaper than opening the archives.
function D.Addons()
D.Log("--- addons (" .. tostring(GetNumAddOns and GetNumAddOns() or "?") .. " enumerated) ---")
if not GetNumAddOns then D.Log(" GetNumAddOns unavailable"); return end
local line = {}
for i = 1, GetNumAddOns() do
local name = GetAddOnInfo(i)
local loaded = IsAddOnLoaded and IsAddOnLoaded(i)
table.insert(line, (name or "?") .. (loaded and "" or "(not loaded)"))
if table.getn(line) == 6 then
D.Log(" " .. table.concat(line, ", "))
line = {}
end
end
if table.getn(line) > 0 then D.Log(" " .. table.concat(line, ", ")) end
end
function D.Probe()
local E = C_EncodingUtil
D.Log("--- probe ---")
if E then
local fns = { "SerializeCBOR", "DeserializeCBOR", "CompressString", "DecompressString", "EncodeBase64", "DecodeBase64" }
local parts = {}
for i = 1, table.getn(fns) do
table.insert(parts, fns[i] .. "=" .. (E[fns[i]] and "yes" or "NO"))
end
D.Log(" C_EncodingUtil: " .. table.concat(parts, " "))
else
D.Log(" C_EncodingUtil: ABSENT (import/export disabled)")
end
D.Log(" WA.hasImportExport = " .. tostring(WA.hasImportExport))
if WA.hasImportExport then
-- Round-trip a small table to confirm the chain actually works, not just
-- that the functions exist.
local ok, err = pcall(function()
local blob = C_EncodingUtil.EncodeBase64(C_EncodingUtil.CompressString(C_EncodingUtil.SerializeCBOR({ a = 1, b = "x", c = { 2, 3 } })))
local back = C_EncodingUtil.DeserializeCBOR(C_EncodingUtil.DecompressString(C_EncodingUtil.DecodeBase64(blob)))
if type(back) ~= "table" or back.a ~= 1 or back.b ~= "x" or back.c[2] ~= 3 then
error("round-trip mismatch")
end
end)
D.Log(" CBOR round-trip: " .. (ok and "OK" or ("FAILED -- " .. tostring(err))))
end
if WA.GetGlowPoolStats then
local created, free = WA.GetGlowPoolStats()
D.Log(string.format(" glow overlay pool: %d created, %d free (in-use = %d)", created, free, created - free))
end
-- Does our Model+CooldownFrameTemplate swipe (RegionPrototype.lua's
-- CreateSwipe) support a reverse/inverse fill direction, the way retail's
-- modern Cooldown widget does via SetReverse? Vanilla's cooldown model has
-- no documented equivalent or addon reference on this client --
-- pfUI, OmniCC, GearMenu -- references one), but this client is a patched
-- fork, so check empirically rather than assume.
do
local testSwipe = WA.regionPrototype and WA.regionPrototype.CreateSwipe(UIParent)
if not testSwipe then
D.Log(" swipe reverse: CreateSwipe returned nil, can't probe")
else
D.Log(" swipe SetReverse method: " .. (testSwipe.SetReverse and "PRESENT" or "absent"))
if testSwipe.SetReverse then
local ok, err = pcall(testSwipe.SetReverse, testSwipe, true)
D.Log(" swipe SetReverse(true) call: " .. (ok and "OK" or ("FAILED -- " .. tostring(err))))
end
testSwipe:Hide()
testSwipe:SetParent(nil)
end
end
if not probeFrame then
probeFrame = CreateFrame("Frame", nil, UIParent)
probeFrame:SetWidth(48); probeFrame:SetHeight(48)
probeFrame:SetPoint("CENTER", UIParent, "CENTER", 0, 150)
local ic = probeFrame:CreateTexture(nil, "ARTWORK")
ic:SetAllPoints(probeFrame)
ic:SetTexture("Interface\\Icons\\Spell_Nature_LightningShield")
local border = CreateFrame("Frame", nil, probeFrame)
border:SetPoint("TOPLEFT", -2, 2)
border:SetPoint("BOTTOMRIGHT", 2, -2)
border:SetBackdrop({ edgeFile = "Interface\\Buttons\\WHITE8X8", edgeSize = 3 })
border:SetBackdropBorderColor(1, 0.2, 0.2, 1)
end
probeFrame:Show()
D.Log(" border texture: spawned a red WHITE8X8-edged test icon at CENTER,0,150 -- if you see a red border in-world, the border subregion renders here.")
D.Log("--- end probe ---")
end
-- ---------------------------------------------------------------------------
-- /wa texprobe -- the Texture questions no headless harness can answer.
--
-- The log records capability read-backs and the frame puts the visual tests
-- beside labels that say exactly what to compare. The client is the authority
-- for arbitrary-angle rotation, out-of-range texcoords, rect modification and
-- desaturation; the mock cannot model any of those results.
-- ---------------------------------------------------------------------------
local texProbeFrame
local TEXPROBE_ART = "Interface\\AddOns\\WeakestAuras\\textures\\shapes\\arrows_target.tga"
local TEXPROBE_COLOR_ART = "Interface\\Icons\\Spell_Nature_LightningShield"
local function texProbeLabel(parent, text, point, relative, relPoint, x, y)
local label = parent:CreateFontString(nil, "OVERLAY")
label:SetFont("Fonts\\FRIZQT__.TTF", 11, "")
label:SetJustifyH("CENTER")
label:SetText(text)
label:SetPoint(point, relative, relPoint, x, y)
return label
end
local function texProbeBox(parent, x, y)
local box = CreateFrame("Frame", nil, parent)
box:SetWidth(96); box:SetHeight(96)
box:SetPoint("TOPLEFT", parent, "TOPLEFT", x, y)
box:SetBackdrop({ edgeFile = "Interface\\Buttons\\WHITE8X8", edgeSize = 1 })
box:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
return box
end
local function texProbeTexture(box, rotation)
local texture = box:CreateTexture(nil, "ARTWORK")
texture:SetAllPoints(box)
texture:SetTexture(TEXPROBE_ART)
if rotation then
local angle = math.pi * (135 - rotation) / 180
local vx = math.cos(angle) / math.sqrt(2)
local vy = math.sin(angle) / math.sqrt(2)
local ulx, uly = 0.5 + vx, 0.5 - vy
local llx, lly = 0.5 - vy, 0.5 - vx
local urx, ury = 0.5 + vy, 0.5 + vx
local lrx, lry = 0.5 - vx, 0.5 + vy
texture:SetTexCoord(ulx, uly, llx, lly, urx, ury, lrx, lry)
else
texture:SetTexCoord(0, 0, 0, 1, 1, 0, 1, 1)
end
return texture
end
local function texProbeCall(texture, method, a, b, c, d)
local fn = texture and texture[method]
if not fn then return false, "ABSENT" end
return pcall(fn, texture, a, b, c, d)
end
function D.TexProbe()
D.Log("--- texprobe ---")
if not texProbeFrame then
texProbeFrame = CreateFrame("Frame", nil, UIParent)
texProbeFrame:SetWidth(620); texProbeFrame:SetHeight(300)
texProbeFrame:SetPoint("CENTER", UIParent, "CENTER", 0, 80)
texProbeFrame:SetBackdrop({ bgFile = "Interface\\Buttons\\WHITE8X8" })
texProbeFrame:SetBackdropColor(0, 0, 0, 0.8)
texProbeLabel(texProbeFrame, "Texture probe: compare each sample with its label", "TOP", texProbeFrame, "TOP", 0, -10)
local rotated = texProbeBox(texProbeFrame, 18, -34)
texProbeTexture(rotated, 30)
texProbeLabel(texProbeFrame, "30 deg rotation\n(inside-box / sqrt2)", "TOP", rotated, "BOTTOM", 0, -4)
local normal = texProbeBox(texProbeFrame, 128, -34)
texProbeTexture(normal)
texProbeLabel(texProbeFrame, "0 deg reference", "TOP", normal, "BOTTOM", 0, -4)
local outside = texProbeBox(texProbeFrame, 238, -34)
local outsideTexture = texProbeTexture(outside)
outsideTexture:SetTexCoord(-0.25, -0.25, -0.25, 1.25, 1.25, -0.25, 1.25, 1.25)
texProbeLabel(texProbeFrame, "out-of-range\n(-.25 to 1.25)", "TOP", outside, "BOTTOM", 0, -4)
local rectOn = texProbeBox(texProbeFrame, 348, -34)
local rectOnTexture = texProbeTexture(rectOn)
texProbeCall(rectOnTexture, "SetTexCoordModifiesRect", true)
rectOnTexture:SetTexCoord(0, 0, 0, 1, 0.5, 0, 0.5, 1)
texProbeLabel(texProbeFrame, "half texcoord\nrect setting ON", "TOP", rectOn, "BOTTOM", 0, -4)
local rectOff = texProbeBox(texProbeFrame, 458, -34)
local rectOffTexture = texProbeTexture(rectOff)
texProbeCall(rectOffTexture, "SetTexCoordModifiesRect", false)
rectOffTexture:SetTexCoord(0, 0, 0, 1, 0.5, 0, 0.5, 1)
texProbeLabel(texProbeFrame, "half texcoord\nrect setting OFF", "TOP", rectOff, "BOTTOM", 0, -4)
local regular = texProbeBox(texProbeFrame, 183, -174)
local regularTexture = texProbeTexture(regular)
regularTexture:SetTexture(TEXPROBE_COLOR_ART)
texProbeLabel(texProbeFrame, "colored normal", "TOP", regular, "BOTTOM", 0, -4)
local desaturated = texProbeBox(texProbeFrame, 293, -174)
local desaturatedTexture = texProbeTexture(desaturated)
desaturatedTexture:SetTexture(TEXPROBE_COLOR_ART)
local desatOK, desatReturn = texProbeCall(desaturatedTexture, "SetDesaturated", true)
texProbeLabel(texProbeFrame, "SetDesaturated(true)", "TOP", desaturated, "BOTTOM", 0, -4)
texProbeFrame._texProbe = {
regular = regular, desatOK = desatOK, desatReturn = desatReturn,
}
end
texProbeFrame:Show()
local p = texProbeFrame._texProbe
D.Log(" art: " .. TEXPROBE_ART)
D.Log(" desaturation comparison art: " .. TEXPROBE_COLOR_ART)
D.Log(" rotation sample: 30 degrees with the sqrt2-safe 8-argument SetTexCoord -- compare with 0 degree reference")
D.Log(" out-of-range sample: transparent margin, edge smear, or tiled art?")
local scratch = p.regular:CreateTexture(nil, "ARTWORK")
local getOK, defaultValue = texProbeCall(scratch, "GetTexCoordModifiesRect")
D.Log(" GetTexCoordModifiesRect default: " .. (getOK and tostring(defaultValue) or tostring(defaultValue)))
local setOnOK = texProbeCall(scratch, "SetTexCoordModifiesRect", true)
local setOffOK = texProbeCall(scratch, "SetTexCoordModifiesRect", false)
D.Log(" SetTexCoordModifiesRect calls: on=" .. tostring(setOnOK) .. " off=" .. tostring(setOffOK)
.. " -- compare the ON/OFF sample box widths")
local vertexOK, vertexReturn = texProbeCall(scratch, "SetVertexOffset", 0, 0)
D.Log(" SetVertexOffset: " .. (vertexOK and ("PRESENT (return " .. tostring(vertexReturn) .. ")") or "ABSENT"))
D.Log(" SetRotation: " .. ((scratch.SetRotation and "PRESENT") or "ABSENT"))
D.Log(" SetDesaturated(true): " .. (p.desatOK and "call accepted" or "ABSENT/FAILED")
.. " (return " .. tostring(p.desatReturn) .. ") -- compare normal and desaturated samples")
D.Log(" visual answers: rotate 30 degrees; margin behavior; whether ON changes the half-width box; whether art greys")
D.Log("--- end texprobe ---")
end
-- ---------------------------------------------------------------------------
-- /wa codeprobe -- checks the EditBox behavior needed by the code editor:
-- engine behaviour a syntax-highlighting code editor rests on, none of which
-- raw color escapes, indexing, caret movement, and sentinel round-trips.
--
-- Half of this is unavoidably a visual test -- whether a colour code *renders*
-- as colour, and where a selection actually lands, are things only an eye can
-- answer -- so the frame parks itself on screen with the steps that need
-- clicking, and only the machine-checkable parts go to the log.
-- ---------------------------------------------------------------------------
-- ---------------------------------------------------------------------------
-- /wa textprobe -- the FontString questions no headless harness can answer.
--
-- Every answer this reports is already recorded in design/client/gotchas.md; it
-- stays a command so a client patch can be re-tested in one keystroke rather
-- than re-argued.
--
-- The inline texture escape is the one that decided a feature. An engine that
-- does not honour |T...|t prints the texture path as text instead, which is
-- machine-checkable without an eye because the two outcomes have wildly
-- different string widths -- an icon is about one line wide, the literal path is
-- thirty-odd characters. Four escape forms are measured, since a client could
-- honour the sized form and not the auto-sized one; this one honours none. The
-- SimpleHTML and message-frame sections then ask whether any *other* text widget
-- has an inline-image path. None does.
--
-- Then the two Text-region unknowns (does GetHeight track wrapped text -- it
-- does, wrapping included) and the font list's own read-backs.
-- ---------------------------------------------------------------------------
local textProbeFrame
local TEXTPROBE_ICON = "Interface\\Icons\\INV_Misc_QuestionMark"
function D.TextProbe()
D.Log("--- textprobe ---")
if not textProbeFrame then
textProbeFrame = CreateFrame("Frame", nil, UIParent)
textProbeFrame:SetWidth(320); textProbeFrame:SetHeight(90)
textProbeFrame:SetPoint("CENTER", UIParent, "CENTER", 0, -160)
textProbeFrame:SetBackdrop({ bgFile = "Interface\\Buttons\\WHITE8X8" })
textProbeFrame:SetBackdropColor(0, 0, 0, 0.7)
textProbeFrame.lines = {}
for i = 1, 4 do
local fs = textProbeFrame:CreateFontString(nil, "OVERLAY")
fs:SetFont("Fonts\\FRIZQT__.TTF", 12, "")
fs:SetJustifyH("LEFT")
fs:SetPoint("TOPLEFT", 8, -6 - (i - 1) * 20)
textProbeFrame.lines[i] = fs
end
end
textProbeFrame:Show()
-- A scratch string with no size of its own, so GetStringWidth reports what
-- the engine actually laid out rather than a width we imposed.
local scratch = textProbeFrame:CreateFontString(nil, "OVERLAY")
scratch:SetFont("Fonts\\FRIZQT__.TTF", 12, "")
scratch:SetText("M")
local emWidth = scratch:GetStringWidth() or 0
D.Log(string.format(" reference: one 12px 'M' is %.1fpx wide", emWidth))
local forms = {
{ name = "auto |T<path>:0|t", text = "|T" .. TEXTPROBE_ICON .. ":0|t" },
{ name = "sized |T<path>:14|t", text = "|T" .. TEXTPROBE_ICON .. ":14|t" },
{ name = "h:w |T<path>:14:14|t", text = "|T" .. TEXTPROBE_ICON .. ":14:14|t" },
{ name = "offs |T<path>:14:14:0:0|t", text = "|T" .. TEXTPROBE_ICON .. ":14:14:0:0|t" },
}
local anyRendered = false
for i = 1, table.getn(forms) do
scratch:SetText(forms[i].text)
local w = scratch:GetStringWidth() or 0
-- An icon occupies roughly one line; the literal path is 35+ characters,
-- so the gap between the two outcomes is an order of magnitude.
local rendered = w > 0 and w < emWidth * 4
if rendered then anyRendered = true end
D.Log(string.format(" escape %s -> %.1fpx %s", forms[i].name, w,
rendered and "RENDERS AS ICON" or "printed as text"))
if textProbeFrame.lines[i] then
textProbeFrame.lines[i]:SetText(forms[i].name .. " " .. forms[i].text)
end
end
D.Log(" verdict: inline texture escapes " ..
(anyRendered and "WORK in a FontString here -- which contradicts the recorded answer"
or "do not work in a FontString here (the recorded answer)"))
D.Log(" ICON_LIST = " .. type(ICON_LIST) .. ", ICON_TAG_LIST = " .. type(ICON_TAG_LIST))
-- Height. Upstream's auto-width text region measures GetStringHeight, which
-- this client does not have; whether GetHeight stands in for it decides
-- whether an auto-sized text region is possible at all.
scratch:SetText("one line")
local h1 = scratch:GetHeight() or 0
scratch:SetText("a\nb\nc")
local h3 = scratch:GetHeight() or 0
D.Log(string.format(" GetHeight: 1 line = %.1f, 3 lines = %.1f -- %s", h1, h3,
(h3 > h1 * 2) and "tracks the rendered text" or "does NOT track line count"))
scratch:SetWidth(120)
scratch:SetText("a long enough string that it has to wrap across several lines at this width")
local hWrap = scratch:GetHeight() or 0
D.Log(string.format(" GetHeight at width 120 with wrapping text = %.1f -- %s", hWrap,
(hWrap > h1 * 1.5) and "sees the wrap" or "does NOT see the wrap"))
scratch:SetWidth(0)
-- The font list and the flag combinations, read back the way textCore does.
local core = WA.textCore
if core then
for i = 1, table.getn(core.FONTS) do
local f = core.FONTS[i]
scratch:SetFont(f.path, 12, "")
D.Log(" font " .. f.name .. " -> " .. (scratch:GetFont() and "loads" or "REFUSED"))
end
scratch:SetFont("Fonts\\FRIZQT__.TTF", 12, "")
for i = 1, table.getn(core.FLAGS) do
local flags = core.FLAGS[i]
local applied = (flags == "None") and "" or flags
scratch:SetFont("Fonts\\FRIZQT__.TTF", 12, applied)
D.Log(" flags " .. flags .. " -> " .. (scratch:GetFont() and "accepted" or "REFUSED"))
end
scratch:SetFont("Fonts\\FRIZQT__.TTF", 12, "")
end
-- The two text widgets nothing in this addon uses. A FontString having no
-- escape parser does not prove the engine has none, and these are the only
-- other places an icon could sit inside a run of text.
--
-- SimpleHTML is the interesting one: on later clients it takes <img src=...>,
-- which is a real inline-image path rather than an escape. It builds its
-- content out of child regions, so whether the tag was honoured is readable
-- without an eye -- an honoured <img> has to produce a Texture region.
local function regionKinds(f)
local counts = {}
if not f or not f.GetNumRegions then return counts end
local n = f:GetNumRegions() or 0
local regions = { f:GetRegions() }
for i = 1, n do
local r = regions[i]
if r and r.GetObjectType then
local t = r:GetObjectType()
counts[t] = (counts[t] or 0) + 1
end
end
return counts
end
local function describe(counts)
local parts = {}
for kind, n in pairs(counts) do table.insert(parts, kind .. "x" .. n) end
if table.getn(parts) == 0 then return "no regions" end
table.sort(parts)
return table.concat(parts, " ")
end
local madeHtml, html = pcall(CreateFrame, "SimpleHTML", nil, UIParent)
if not madeHtml or not html then
D.Log(" SimpleHTML: CreateFrame refused the type -- not available here")
else
html:SetWidth(300); html:SetHeight(40)
html:SetPoint("TOP", textProbeFrame, "BOTTOM", 0, -8)
-- SimpleHTML draws nothing until its element fonts are set, and the
-- per-element signature is not confirmed here, so try both shapes.
pcall(html.SetFontObject, html, "p", GameFontHighlight)
pcall(html.SetFontObject, html, GameFontHighlight)
pcall(html.SetFont, html, "p", "Fonts\\FRIZQT__.TTF", 12, "")
local okPlain = pcall(html.SetText, html, "<html><body><p>plain text</p></body></html>")
local before = regionKinds(html)
local okImg = pcall(html.SetText, html,
"<html><body><p><img src=\"" .. TEXTPROBE_ICON .. "\" width=\"16\" height=\"16\"/>after</p></body></html>")
local after = regionKinds(html)
D.Log(" SimpleHTML SetText: plain=" .. tostring(okPlain) .. " img=" .. tostring(okImg))
D.Log(" SimpleHTML regions plain -> " .. describe(before))
D.Log(" SimpleHTML regions with img -> " .. describe(after))
D.Log(" verdict: <img> " ..
(((after.Texture or 0) > (before.Texture or 0)) and "CREATES A TEXTURE -- inline images are possible"
or "adds no texture -- the tag is not honoured"))
end
local madeMsg, msg = pcall(CreateFrame, "MessageFrame", nil, UIParent)
if not madeMsg or not msg then
D.Log(" MessageFrame: CreateFrame refused the type")
else
msg:SetWidth(300); msg:SetHeight(20)
msg:SetPoint("TOP", textProbeFrame, "BOTTOM", 0, -56)
pcall(msg.SetFontObject, msg, GameFontHighlight)
local plainKinds, escKinds
pcall(msg.AddMessage, msg, "plain")
plainKinds = regionKinds(msg)
pcall(msg.AddMessage, msg, "|T" .. TEXTPROBE_ICON .. ":0|t")
escKinds = regionKinds(msg)
D.Log(" MessageFrame regions plain -> " .. describe(plainKinds))
D.Log(" MessageFrame regions escape -> " .. describe(escKinds))
end
-- The chat frame is a ScrollingMessageFrame and is the one widget Blizzard
-- would have needed an escape parser for. Straight to the user's own chat,
-- since that is the honest test of it.
DEFAULT_CHAT_FRAME:AddMessage("WA textprobe -- chat escape test: [|T" .. TEXTPROBE_ICON
.. ":0|t] <- an icon between the brackets, or a path?")
D.Log(" a chat line was printed: if it shows an icon between the brackets, a")
D.Log(" ScrollingMessageFrame honours escapes even though a FontString does not.")
D.Log(" panels are up under CENTER,0,-160: the escape forms, then SimpleHTML, then")
D.Log(" the MessageFrame. Report what each one reads as.")
D.Log("--- end textprobe ---")
end
-- pfUI's copy, used only as a test subject: it is a vendored monospace TTF
-- already on this client, so it answers "can SetFont load one at all" without
-- committing to vendoring our own before the answer is known.
local PROBE_FONT = "Interface\\AddOns\\pfUI\\fonts\\RobotoMono.ttf"
local codeProbeFrame, codeProbeEdit, codeProbeMeasure
-- The Q-INDEX/Q-ARROW subject. Raw byte offsets into "|cffff0000abc|rdef":
-- the escape is 0..9, "abc" 10..12, "|r" 13..14, "def" 15..17, end 18.
local PROBE_TEXT = "|cffff0000abc|rdef"
-- Confirmed in-game: a \1 survives Insert -> GetText intact, so the 1-byte
-- control character is the sentinel rather than upstream's 3-byte U+E000.
local SENTINEL = "\1"
-- Reads the caret as a raw byte offset. This client has no GetCursorPosition
-- (ClassicAPI TODO #96), so the position is recovered by inserting a byte the
-- text cannot contain and finding it -- the same trick the caret
-- save/restore rests on, which this therefore also proves out. Destructive:
-- restoring the text resets the caret, so each read needs the key presses
-- redone.
local function probeReadCaret()
local before = codeProbeEdit:GetText() or ""
codeProbeEdit:Insert(SENTINEL)
local at = string.find(codeProbeEdit:GetText() or "", SENTINEL, 1, true)
codeProbeEdit:SetText(before)
return at and (at - 1)
end
-- From the end of PROBE_TEXT, four Lefts land on raw 12 if the engine steps
-- over the |r escape as one unit, and on raw 14 if it walks through it byte by
-- byte (three presses to cross two invisible bytes -- the UX failure that kills
-- live colorizing).
local function probeCaretVerdict(at)
if at == 12 or at == 13 then
return "stepped OVER the escape -- Q-ARROW PASSES, live colorizing is viable"
elseif at == 14 then
return "stopped INSIDE the |r escape -- Q-ARROW FAILS, caret handling needs revision"
elseif at == 15 then
return "just before 'd' -- that is only 3 Lefts; redo with 4"
elseif at == 18 then
return "still at the end -- the arrow presses did not register"
end
return "unexpected; click at the very end, press Left exactly 4 times, then Tab"
end
local function codeProbeBuild()
if codeProbeFrame then return end
codeProbeFrame = CreateFrame("Frame", "WA_CodeProbeFrame", UIParent)
codeProbeFrame:SetWidth(420); codeProbeFrame:SetHeight(200)
codeProbeFrame:SetPoint("CENTER", UIParent, "CENTER", -260, 0)
codeProbeFrame:SetBackdrop(WA.Widgets.PANEL_BACKDROP)
codeProbeFrame:SetBackdropColor(0, 0, 0, 1)
codeProbeFrame:SetFrameStrata("DIALOG")
codeProbeFrame:SetToplevel(true)
codeProbeFrame:SetMovable(true)
codeProbeFrame:EnableMouse(true)
codeProbeFrame:RegisterForDrag("LeftButton")
codeProbeFrame:SetScript("OnDragStart", function() codeProbeFrame:StartMoving() end)
codeProbeFrame:SetScript("OnDragStop", function() codeProbeFrame:StopMovingOrSizing() end)
local title = codeProbeFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
title:SetPoint("TOP", 0, -12)
title:SetText("Code editor probe")
title:SetTextColor(1, 0.82, 0)
local close = CreateFrame("Button", nil, codeProbeFrame, "UIPanelCloseButton")
close:SetPoint("TOPRIGHT", -4, -4)
close:SetScript("OnClick", function() codeProbeFrame:Hide() end)
-- A real multi-line box, matching what NewCodeEditBox would decorate: the
-- answers must come from the same widget shape the editor will use.
codeProbeEdit = CreateFrame("EditBox", "WA_CodeProbeEdit", codeProbeFrame)
codeProbeEdit:SetMultiLine(true)
codeProbeEdit:SetAutoFocus(false)
codeProbeEdit:SetFontObject(GameFontHighlightSmall)
codeProbeEdit:SetTextInsets(4, 4, 4, 4)
codeProbeEdit:SetPoint("TOPLEFT", 14, -36)
codeProbeEdit:SetWidth(392); codeProbeEdit:SetHeight(60)
-- Colorizing multiplies the buffer, so an editor must lift both limits or
-- the user's code is silently truncated. Lift them here too, or a long
-- probe string would answer the wrong question.
codeProbeEdit:SetMaxBytes(0)
codeProbeEdit:SetMaxLetters(0)
codeProbeEdit:SetScript("OnEscapePressed", function() codeProbeEdit:ClearFocus() end)
-- Tab, not a button: clicking anything else risks moving focus, and a
-- refocused EditBox may reset its caret -- which would silently corrupt the
-- one measurement this is here to take.
codeProbeEdit:SetScript("OnTabPressed", function()
local at = probeReadCaret()
if not at then
D.Log(" [Q-ARROW] caret read FAILED -- sentinel did not survive Insert")
return
end
D.Log(" [Q-ARROW] caret at raw byte " .. at .. " -- " .. probeCaretVerdict(at))
end)
local bg = CreateFrame("Frame", nil, codeProbeFrame)
bg:SetPoint("TOPLEFT", codeProbeEdit, "TOPLEFT", -4, 4)
bg:SetPoint("BOTTOMRIGHT", codeProbeEdit, "BOTTOMRIGHT", 4, -4)
bg:SetBackdrop(WA.Widgets.EDITBOX_BACKDROP)
bg:SetBackdropColor(0, 0, 0, 0.7)
bg:SetBackdropBorderColor(0.4, 0.4, 0.4, 0.8)
local hint = codeProbeFrame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
hint:SetPoint("TOPLEFT", 14, -104)
hint:SetPoint("RIGHT", -14, 0)
hint:SetJustifyH("LEFT")
hint:SetText("Q-INDEX: click a button, see which run highlights.\n"
.. "Q-ARROW: click at the very END of the text, press Left 4 times,\n"
.. "then press TAB -- the caret offset and verdict go to the log.\n"
.. "(Each Tab read restores the text, so redo the presses to re-measure.)")
hint:SetTextColor(0.8, 0.8, 0.8)
-- The Q-INDEX pair. Raw bytes of "|cffff0000abc|rdef": the escape is 0..9,
-- "abc" 10..12, "|r" 13..14, "def" 15..17. Visible text is "abcdef", so
-- "def" is 3..5 there. Whichever button lights up "def" names the indexing.
local b1 = WA.Widgets.button(codeProbeFrame, "HighlightText(15,18)", function()
codeProbeEdit:SetText(PROBE_TEXT)
codeProbeEdit:SetFocus()
codeProbeEdit:HighlightText(15, 18)
D.Log(" [Q-INDEX] HighlightText(15,18) -- if 'def' is selected, indices are RAW BYTES")
end)
b1:SetWidth(150)
b1:SetPoint("BOTTOMLEFT", 14, 14)
local b2 = WA.Widgets.button(codeProbeFrame, "HighlightText(3,6)", function()
codeProbeEdit:SetText(PROBE_TEXT)
codeProbeEdit:SetFocus()
codeProbeEdit:HighlightText(3, 6)
D.Log(" [Q-INDEX] HighlightText(3,6) -- if 'def' is selected, indices are VISIBLE CHARS")
end)
b2:SetWidth(150)
b2:SetPoint("LEFT", b1, "RIGHT", 8, 0)
end
-- Inserts `s` at the caret and reports whether it survives a GetText()
-- round-trip -- the sentinel the caret save/restore relies on.
local function probeSentinel(label, s, wantByte)
codeProbeEdit:SetText("")
codeProbeEdit:SetFocus()
local ok, err = pcall(function() codeProbeEdit:Insert(s) end)
if not ok then
D.Log(" [Q-SENTINEL] " .. label .. ": Insert errored -- " .. tostring(err))
return
end
local got = codeProbeEdit:GetText() or ""
local found = nil
for i = 1, string.len(got) do
if string.byte(got, i) == wantByte then found = i; break end
end
D.Log(" [Q-SENTINEL] " .. label .. ": GetText len " .. string.len(got)
.. ", byte " .. wantByte .. (found and (" found at " .. found) or " NOT FOUND"))
codeProbeEdit:SetText("")
codeProbeEdit:ClearFocus()
end
function D.CodeProbe()
D.Log("--- code editor probe ---")
codeProbeBuild()
codeProbeFrame:Show()
-- Does GetText hand back the raw escapes, or the rendered text? Everything
-- else assumes the former: an editor that reads back stripped text would
-- lose the user's own literal pipes.
local src = "|cffff0000red|r plain"
codeProbeEdit:SetText(src)
local got = codeProbeEdit:GetText() or ""
D.Log(" [round-trip] set " .. string.len(src) .. " bytes, GetText returned " .. string.len(got)
.. " (raw = " .. string.len(src) .. ", stripped would be 9)")
D.Log(" [round-trip] identical: " .. (got == src and "YES" or "NO -- got \"" .. got .. "\""))
D.Log(" ^^ LOOK AT THE BOX: 'red' should be red with no visible |cffff0000.")
probeSentinel("\\1 (ASCII control)", "\1", 1)
-- U+E000 in UTF-8; upstream's own sentinel, kept as the fallback if the
-- control byte is eaten.
probeSentinel("U+E000", "\238\128\128", 238)
-- Restore the Q-INDEX subject so the two buttons act on the same text the
-- hint describes.
codeProbeEdit:SetText(PROBE_TEXT)
-- Which text-height reading this client offers. GetStringHeight is a 3.3.5
-- method and is absent here -- calling it errors, which is exactly how the
-- multiline box's text measuring first broke. A FontString sizes its own
-- region to its text, so GetHeight is the one that works.
if not codeProbeMeasure then
codeProbeMeasure = codeProbeFrame:CreateFontString(nil, "BACKGROUND", "GameFontHighlightSmall")
codeProbeMeasure:SetPoint("BOTTOMLEFT", codeProbeFrame, "BOTTOMLEFT", 14, 40)
codeProbeMeasure:SetAlpha(0)
codeProbeMeasure:SetJustifyH("LEFT")
end
codeProbeMeasure:SetWidth(200)
codeProbeMeasure:SetText("one\ntwo\nthree")
D.Log(" [measure] FontString:GetStringHeight = "
.. (codeProbeMeasure.GetStringHeight and "present" or "ABSENT")
.. ", GetHeight over 3 lines = "
.. tostring(codeProbeMeasure.GetHeight and codeProbeMeasure:GetHeight() or "ABSENT"))
local ok, err = pcall(function() codeProbeEdit:SetFont(PROBE_FONT, 12, "") end)
D.Log(" [Q-FONT] SetFont(RobotoMono, 12): " .. (ok and "no error" or ("FAILED -- " .. tostring(err))))
if ok then
local f, sz = codeProbeEdit:GetFont()
D.Log(" [Q-FONT] GetFont now: " .. tostring(f) .. " @ " .. tostring(sz)
.. " -- if this is not RobotoMono the call was a silent no-op")
end
-- Settled 2026-08-02 on this client; the buttons stay so another build can be
-- re-checked rather than assumed.
D.Log(" [Q-INDEX] answered: RAW BYTES. The two buttons re-check it.")
D.Log(" [Q-ARROW] OPEN: click at the very END of the box, press Left 4 times, then TAB.")
D.Log(" live colorizing: WeakestAurasDB.codeEditorLive = "
.. tostring(WeakestAurasDB and WeakestAurasDB.codeEditorLive)
.. " (nil = on, the default; toggle with /wa codelive)")
D.Log("--- end code probe ---")
end
-- Live colouring is on unless turned off here. Unset means on, so the toggle
-- resolves the default before negating it -- `not nil` would read as "it was
-- off" and leave the setting where it started.
function D.CodeLive()
if not WeakestAurasDB then D.Log("no saved variables yet"); return end
local on = WeakestAurasDB.codeEditorLive
if on == nil then on = true end
WeakestAurasDB.codeEditorLive = not on
D.Log("live code colouring: " .. (WeakestAurasDB.codeEditorLive and "ON" or "OFF")
.. " -- reopen the options tab to apply.")
if WA.RefreshOptions then WA.RefreshOptions() end
end
-- Point size of the code boxes' fixed-width face.
function D.CodeFont(rest)
if not WeakestAurasDB then D.Log("no saved variables yet"); return end
local n = tonumber(rest)
if n and n >= 6 and n <= 16 then
WeakestAurasDB.codeEditorFontSize = n
elseif rest and rest ~= "" then
D.Log("usage: /wa codefont <6-16>")
return
end
D.Log("code font size: "
.. tostring(WeakestAurasDB.codeEditorFontSize or WA.Widgets.CODE_FONT_SIZE)
.. " -- reopen the options tab to apply.")
if WA.RefreshOptions then WA.RefreshOptions() end
end
-- Spaces per indent level for Tab in a code box; "tabs" switches to hard tabs.
function D.CodeTab(rest)
if not WeakestAurasDB then D.Log("no saved variables yet"); return end
local arg = string.lower(rest or "")
if arg == "tabs" then
WeakestAurasDB.codeEditorTabWidth = false
else
local n = tonumber(arg)
if n and n >= 1 and n <= 8 then
WeakestAurasDB.codeEditorTabWidth = n
elseif arg ~= "" then
D.Log("usage: /wa codetab <1-8|tabs>")
return
end
end
local cur = WeakestAurasDB.codeEditorTabWidth
if cur == nil then cur = 2 end
D.Log("code indent width: " .. (cur == false and "hard tabs" or (tostring(cur) .. " spaces"))
.. " -- reopen the options tab to apply.")
if WA.RefreshOptions then WA.RefreshOptions() end
end
-- ---------------------------------------------------------------------------
-- /wa commprobe -- the server-side unknowns behind sharing auras through chat,
-- none of which a type check can answer: whether SendAddonMessage's WHISPER
-- channel delivers on this realm (every neighbouring addon only ever uses
-- RAID/PARTY/GUILD), what the byte cap really is, what send rate survives, and
-- whether a link type of our own renders, is clickable, and reaches SetItemRef.
-- ---------------------------------------------------------------------------
local COMM_PREFIX = "WKA"
-- Ladder bodies are cut from the base64 alphabet a real payload is made of, so
-- a byte this chat system mangles surfaces here rather than mid-transfer.
local COMM_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
local commFrame, commRefHooked
local commSent, commOrder = {}, {}
local function commBody(n)
local out, alen = {}, string.len(COMM_ALPHABET)
for i = 1, n do
local k = math.mod(i - 1, alen) + 1
table.insert(out, string.sub(COMM_ALPHABET, k, k))
end
return table.concat(out)
end
-- Logs every arrival as it lands rather than only tallying at the end: if the
-- realm reorders, delays or drops a chunk, the ordering is itself the finding.
local function commOnEvent()
if event ~= "CHAT_MSG_ADDON" or arg1 ~= COMM_PREFIX then return end
local msg, channel, sender = arg2 or "", arg3, arg4
local _, _, tag, body = string.find(msg, "^([^:]+):(.*)$")
if not tag then
D.Log(" [recv] unparseable from " .. tostring(sender) .. " (" .. tostring(channel)
.. "), " .. string.len(msg) .. "B: " .. string.sub(msg, 1, 40))
return
end
local rec = commSent[tag]
local got = string.len(body)
local note
if not rec then
note = "no record of sending this tag"
elseif got ~= rec.bodyLen then
note = "TRUNCATED/PADDED -- sent " .. rec.bodyLen .. "B body, got " .. got .. "B"
elseif body ~= commBody(got) then
note = "CORRUPT -- length right, bytes differ"
else
note = "intact"
rec.ok = true
end
if rec then rec.arrived = true end
D.Log(" [recv] " .. tag .. " from " .. tostring(sender) .. " via " .. tostring(channel)
.. ", msg " .. string.len(msg) .. "B: " .. note)
end
local function commEnsureListener()
if commFrame then return end
commFrame = CreateFrame("Frame")
commFrame:RegisterEvent("CHAT_MSG_ADDON")
commFrame:SetScript("OnEvent", commOnEvent)
-- Some servers drop addon traffic on prefixes nobody registered. Absent on
-- vanilla, so its absence is a result and not a failure.
if type(RegisterAddonMessagePrefix) == "function" then
pcall(RegisterAddonMessagePrefix, COMM_PREFIX)
end
end
-- ChatThrottleLib's v13/v14 global hook is `Hook_SendAddonMessage(prefix, text,
-- chattype)` -- three parameters, so it drops the whisper target and the client
-- rejects the call as an unknown chat type. Several addons vendor a copy (aux,
-- DPSMate), and whichever loads last owns the global, so a whisper here has to
-- go to the function CTL saved rather than through the global. Its own v15
-- rewrite neither hooks the global nor keeps that field, hence the fallback.
local function commRawSender()
if ChatThrottleLib and type(ChatThrottleLib.ORIG_SendAddonMessage) == "function" then
return ChatThrottleLib.ORIG_SendAddonMessage, "CTL.ORIG_SendAddonMessage"
end
return SendAddonMessage, "global SendAddonMessage (no ORIG saved)"
end
local function commSend(tag, bodyLen, channel, target, raw)
local msg = tag .. ":" .. commBody(bodyLen)
local rec = { bodyLen = bodyLen, wire = string.len(msg), channel = channel }
commSent[tag] = rec
table.insert(commOrder, tag)
local fn = raw and commRawSender() or SendAddonMessage
local ok, err = pcall(fn, COMM_PREFIX, msg, channel, target)
if not ok then
rec.sendFailed = true
D.Log(" [send] " .. tag .. " (" .. channel .. (raw and ", raw" or ", hooked") .. ", "
.. rec.wire .. "B) ERRORED -- " .. tostring(err))
end
return ok
end
local function commReport(header)
D.Log(header)
for i = 1, table.getn(commOrder) do
local tag = commOrder[i]
local rec = commSent[tag]
local state
if rec.sendFailed then state = "send errored"
elseif rec.ok then state = "OK"
elseif rec.arrived then state = "arrived MANGLED"
else state = "NEVER ARRIVED" end
D.Log(" " .. tag .. " (" .. rec.channel .. ", " .. rec.wire .. "B on the wire): " .. state)
end
end
-- Our own link type, end to end: rendered into a chat frame, clicked by hand,
-- caught here. Wrap-and-forward because this client's SetItemRef cannot be
-- hooked securely, and because pfUI replaces the same global -- logging the
-- function identity is how the composition question gets answered.
local function commHookSetItemRef()
if commRefHooked then return end
commRefHooked = true
local orig = SetItemRef
SetItemRef = function(link, text, button)
local _, _, sender, name = string.find(link or "", "^weakestauras:([^:]+):(.*)$")
if sender then
D.Log(" [link] SetItemRef REACHED -- sender=\"" .. sender .. "\" name=\"" .. name
.. "\" button=" .. tostring(button))
return
end
if orig then return orig(link, text, button) end
end
end
function D.CommProbe(rest)
local _, _, sub, tail = string.find(rest or "", "^(%S*)%s*(.-)$")
if string.lower(sub or "") == "throttle" then return D.CommThrottle(tail) end
commSent, commOrder = {}, {}
commEnsureListener()
D.Log("--- comm probe ---")
local names = {
"SendAddonMessage", "RegisterAddonMessagePrefix", "SetItemRef",
"ChatFrame_AddMessageEventFilter", "GetCurrentKeyBoardFocus",
}
for i = 1, table.getn(names) do
D.Log(" [api] " .. names[i] .. " = " .. type(getglobal(names[i])))
end
D.Log(" [api] NUM_CHAT_WINDOWS = " .. tostring(NUM_CHAT_WINDOWS)
.. ", ChatFrameEditBox = " .. type(ChatFrameEditBox)
.. (ChatFrameEditBox and (" (Insert=" .. type(ChatFrameEditBox.Insert)
.. " IsVisible=" .. type(ChatFrameEditBox.IsVisible)
.. " Show=" .. type(ChatFrameEditBox.Show) .. ")") or ""))
D.Log(" [api] pfUI = " .. type(pfUI) .. ", pfUI chat module = "
.. ((pfUI and pfUI.chat) and "loaded" or "not loaded"))
D.Log(" [api] SetItemRef identity before our wrap: " .. tostring(SetItemRef))
-- Whether AddMessage is already someone else's wrapper decides whether the
-- incoming-rewrite hook composes or clobbers.
local shared = 0
for i = 1, (NUM_CHAT_WINDOWS or 0) do
local cf = getglobal("ChatFrame" .. i)
if cf and cf.AddMessage then
if cf.AddMessage ~= ChatFrame1.AddMessage then shared = shared + 1 end
end
end
D.Log(" [api] chat frames with an AddMessage differing from ChatFrame1's: " .. shared
.. " (nonzero means at least one is individually wrapped)")
commHookSetItemRef()
DEFAULT_CHAT_FRAME:AddMessage(
"|Hweakestauras:Probe:Test Aura|h|cff8800ff[Probe - Test Aura]|h|r"
.. " <- CLICK THIS. Coloured and clickable = the link type works.")
D.Log(" [link] wrapper installed, sample line printed to the default chat frame.")
D.Log(" ^^ CLICK IT, and shift-click it too. Then run this again with pfUI's chat module toggled.")
local _, rawWhich = commRawSender()
D.Log(" [ctl] ChatThrottleLib = " .. type(ChatThrottleLib)
.. (ChatThrottleLib and (" v" .. tostring(ChatThrottleLib.version)
.. ", ORIG_SendAddonMessage = " .. type(ChatThrottleLib.ORIG_SendAddonMessage)) or ""))
D.Log(" [ctl] raw whisper attempts go through " .. rawWhich)
-- Sent through the hooked global and through the saved original both, so a
-- refusal separates "this realm has no whisper channel" from "a third-party
-- hook ate the target argument".
local me = UnitName("player")
commSend("S001", 60, "WHISPER", me)
commSend("R001", 60, "WHISPER", me, true)
if tail and tail ~= "" then commSend("R002", 60, "WHISPER", tail, true) end
local inGuild = IsInGuild and IsInGuild()
local inParty = GetNumPartyMembers and GetNumPartyMembers() > 0
commSend("G001", 60, "GUILD")
if inParty then
commSend("P001", 60, "PARTY")
else
D.Log(" [send] PARTY skipped -- not in a party, so silence would prove nothing.")
end
-- The cap is nominally 255 for prefix\tmessage, but nominal is exactly what
-- this is here to check. Ridden over whichever channel is known to deliver,
-- so the answer doesn't depend on the whisper question resolving first.
local ladderChan, ladderTarget, ladderRaw
if inGuild then ladderChan = "GUILD"
elseif inParty then ladderChan = "PARTY"
else ladderChan, ladderTarget, ladderRaw = "WHISPER", me, true end
D.Log(" [send] byte ladder rides " .. ladderChan)
local ladder = { 180, 200, 220, 240, 250 }
for i = 1, table.getn(ladder) do
local n = ladder[i]
commSend("L" .. n, n - 5, ladderChan, ladderTarget, ladderRaw)
end
D.Log(" [send] " .. table.getn(commOrder) .. " messages away; tally in 10s.")
C_Timer.After(10, function()
commReport(" --- comm probe tally ---")
D.Log(" S001 dead but R001 alive = a hooked global ate the target, not the realm.")
D.Log(" Both dead = no whisper channel here, and sharing takes the group-channel fallback.")
D.Log(" Then: /wa commprobe throttle [channel] [rate] [seconds]")
D.Log("--- end comm probe ---")
end)
end
-- Deliberately opt-in and separate: this is the one probe that can get the
-- character disconnected for addon spam, so it never runs as part of the sweep
-- above and it starts gentle.
function D.CommThrottle(rest)
local _, _, chan, rateStr, secsStr = string.find(rest or "", "^(%S*)%s*(%S*)%s*(%S*)$")
chan = string.upper(chan or "")
if chan == "" then chan = "WHISPER" end
local rate = tonumber(rateStr) or 4
local secs = tonumber(secsStr) or 5
if rate < 1 then rate = 1 elseif rate > 20 then rate = 20 end
if secs < 1 then secs = 1 elseif secs > 10 then secs = 10 end
local total = rate * secs
commSent, commOrder = {}, {}
commEnsureListener()
D.Log("--- comm throttle: " .. total .. " messages at " .. rate .. "/sec over "
.. secs .. "s on " .. chan .. " ---")
D.Log(" A disconnect here IS the answer. Step the rate up only after a clean run.")
local me = UnitName("player")
local sent = 0
local ticker
ticker = C_Timer.NewTicker(1 / rate, function()
sent = sent + 1
local isWhisper = (chan == "WHISPER")
commSend("T" .. sent, 95, chan, isWhisper and me or nil, isWhisper)
if sent >= total and ticker and ticker.Cancel then ticker:Cancel() end
end)
C_Timer.After(secs + 6, function()
local arrived = 0
for i = 1, table.getn(commOrder) do
if commSent[commOrder[i]].ok then arrived = arrived + 1 end
end
D.Log(" [throttle] " .. arrived .. " of " .. table.getn(commOrder)
.. " sent messages came back intact at " .. rate .. "/sec.")
if arrived < table.getn(commOrder) then
commReport(" --- which ones ---")
end
D.Log("--- end comm throttle ---")
end)
end
-- ---------------------------------------------------------------------------
-- /wa ver [version] -- what this client believes its own version is, and, with
-- an argument, a beacon injected as though a peer had sent it. The update notice
-- is otherwise unreachable without a second account running a build that does
-- not exist yet. The outcome is reported because most claims are *meant* to be
-- ignored -- equal, already beaten, unparseable, or too far ahead to believe.
-- ---------------------------------------------------------------------------
function D.Version(rest)
local C = WA.Comm
D.Log("--- version ---")
D.Log(" GetAddOnMetadata = " .. type(GetAddOnMetadata))
D.Log(" WA.version = " .. tostring(WA.version)
.. " (parses as " .. tostring(WA.ParseVersion(WA.version)) .. ")")
D.Log(" highest claim heard this session = " .. tostring(C.latestSeenVersion))
D.Log(" updateNotify = " .. tostring(WA.Options().updateNotify))
if not rest or rest == "" then
D.Log(" /wa ver <version> feeds a beacon as if a peer had sent it")
D.Log("--- end version ---")
return
end
local before = C.latestSeenVersion
C.FeedBeacon(rest)
if C.latestSeenVersion ~= before then
D.Log(" fed " .. rest .. " -- believed")
elseif not WA.ParseVersion(rest) then
D.Log(" fed " .. rest .. " -- dropped: not x.y or x.y.z with each part under 1000")
else
D.Log(" fed " .. rest .. " -- ignored: not newer than " .. tostring(WA.version)
.. ", not higher than " .. tostring(before) .. ", or more than one major ahead")
end
D.Log("--- end version ---")
end
-- ---------------------------------------------------------------------------
-- Slash dispatch. Called from OptionsFrame.lua's /wa handler whenever the
-- command has an argument; a bare /wa still opens the options window.
-- ---------------------------------------------------------------------------
function D.HandleSlash(msg)
local _, _, cmd, rest = string.find(msg, "^(%S+)%s*(.-)$")
cmd = string.lower(cmd or "")
if cmd == "dump" then
local _, _, unit, filter = string.find(rest, "^(%S*)%s*(%S*)$")
D.Dump(unit, filter)
elseif cmd == "watch" then
D.ToggleWatch(rest)
elseif cmd == "events" then
D.ToggleEventLog(rest)
elseif cmd == "timers" then
D.Timers()
elseif cmd == "linkprobe" then
D.LinkProbe()
elseif cmd == "commprobe" then
D.CommProbe(rest)
elseif cmd == "cdtest" then
D.CooldownTest()
elseif cmd == "swipetest" then
D.SwipeTest(rest)
elseif cmd == "swipenudge" then
D.SwipeNudge(rest)
elseif cmd == "track" then
D.Track(rest)
elseif cmd == "states" then
D.States(rest)
elseif cmd == "conditions" then
D.Conditions(rest)
elseif cmd == "gen" then
D.Gen(rest)
elseif cmd == "load" then
D.Load(rest)
elseif cmd == "probe" then
D.Probe()
elseif cmd == "ver" then
D.Version(rest)
elseif cmd == "codeprobe" then
D.CodeProbe()
elseif cmd == "textprobe" then
D.TextProbe()
elseif cmd == "texprobe" then
D.TexProbe()
elseif cmd == "codelive" then
D.CodeLive()
elseif cmd == "codetab" then
D.CodeTab(rest)
elseif cmd == "codefont" then
D.CodeFont(rest)
elseif cmd == "rows" then
D.Rows()
elseif cmd == "libs" then
D.Libs()
elseif cmd == "addons" then
D.Addons()
elseif cmd == "export" then
if WA.ShowExport then WA.ShowExport(rest) end
elseif cmd == "import" then
if WA.ShowImport then WA.ShowImport() end
elseif cmd == "clear" then
D.Clear()
elseif cmd == "show" then
D.Show()
elseif cmd == "hide" then
ensureFrame()
frame:Hide()
else
D.Log("[debug] unknown command \"" .. cmd .. "\". Available: dump [unit] [filter], watch [unit], events [EVENT ...], timers, linkprobe, commprobe [charname|throttle [channel] [rate] [secs]], cdtest, swipetest [sizes/WxH...], swipenudge <k> [yflat], track <spellName>, states <id>, conditions <id>, gen <id>, load <id>, probe, ver [version], codeprobe, textprobe, texprobe, codelive, codetab <1-8|tabs>, codefont <6-16>, rows, libs, addons, export <id>, import, clear, show, hide")
end
end