Files
WeakestAuras/StateMachine.lua
T
github-actions[bot] 2f7eb61a7f WeakestAuras 0.3.0
First public release

WeakestAuras brings WeakAuras-style custom aura displays to the 1.12 client:
icons, progress bars and groups, driven by triggers and conditions and
configured entirely in-game.

Requires the ClassicAPI, SuperWoW and Nampower client patches. The addon
refuses to load without them rather than running degraded.

Much of the engine is newly written and has had little time in front of a real
client. Expect rough edges, and please report them.
2026-08-07 07:39:27 +00:00

911 lines
36 KiB
Lua

-- WeakestAuras -- the state machine: the glue between trigger systems (which
-- produce states) and regions (which consume them). Everything meets at the
-- state table. Mirrors WA2's WeakAuras.lua glue (§2/§3/§6-7).
-- Upstream section refs (§N) point at design/architecture/weakauras2-reference.md
--
-- Two things cross the producer<->glue boundary and nothing else: a trigger
-- system fetches its per-trigger allstates via WA.GetTriggerStateForTrigger,
-- mutates them (setting state.changed on any field change), then calls
-- WA.UpdatedTriggerState(id). The glue combines states across triggers, decides
-- visibility, and drives regions through region:Update()/Expand()/Collapse().
if WeakestAuras.disabled then return end
local WA = WeakestAuras
-- triggerState[id] (§3): per-display combination state + per-trigger
-- allstates. [triggernum] = allstates (cloneId -> state; "" is the sole,
-- non-clone key produced). Kept file-local; Debug reads it via
-- WA.GetDisplayTriggerState.
local triggerState = {}
-- regions[id] = { regionType = "icon", byClone = { [cloneId] = frame } }. Keyed
-- by display id and re-keyed on rename (WA.Rename) -- everything the engine owns
-- is id-keyed, matching upstream. CloneId is plumbed throughout but "" is the
-- only value ever produced, so the "pool" is a create-on-demand stub; real
-- pooling arrives with clones.
local regions = {}
-- loaded[id] = true while a display's load conditions pass (Load.lua, §11).
-- "Loaded" is distinct from "added": WA.Add compiles every display's
-- triggers/region/conditions; only a loaded display is *registered* with its
-- trigger systems (in their scan/event index) and allowed to show. An unloaded
-- display keeps its compiled state but produces nothing and stays hidden.
local loaded = {}
-- standby[id] = true while a display is *not* loaded but every character-level
-- constraint passes -- only a transient one (combat, zone, group, stance, ...)
-- is holding it back. A label for the options window and nothing more: the
-- engine decides what to register and show from `loaded` alone, so this must
-- stay a table of its own rather than an extra value in `loaded`, which is read
-- as a bare truthy in WA.Add's two paths below.
local standby = {}
-- Forward decl: WA.Add (above the preview section) re-injects a forced aura's
-- fake state synchronously after a recompile. Assigned in the preview section.
local fakeForced
-- forced[id] = true for every leaf whose fake state the preview ticker injects
-- (forced visibility, §14 FakeStatesFor). A group in the options list
-- contributes its leaf descendants here, so selecting or eye-toggling a group
-- fake-shows its children -- which is what makes an inactive dynamic group's
-- layout visible to debug. Read by WA.Add (a forced leaf is collapse-exempt)
-- and the trigger watchers (they skip a forced leaf so a real scan doesn't fight
-- the fake). The union of the selection preview + eye pins; see WA.SetPreview.
WA.forced = {}
-- True while the /wa options window is open. Mutes every non-forced display's
-- real state (see UpdatedTriggerState) so config starts from a blank board and
-- reveals only what you're editing -- WA2's SetFakeStates behavior.
WA.optionsOpen = false
-- Trigger *systems* (runtime state producers), keyed by trigger.type. Distinct
-- from Data.lua's WA.triggerTypes (the options-side registry).
WA.triggerSystems = {}
-- ---------------------------------------------------------------------------
-- Trigger system registration + lookup
-- ---------------------------------------------------------------------------
function WA.RegisterTriggerSystem(types, system)
for i = 1, table.getn(types) do
WA.triggerSystems[types[i]] = system
end
end
-- The system owning triggernum n of this display, or nil.
function WA.GetTriggerSystem(data, triggernum)
local trigger = WA.GetTrigger(data, triggernum)
return trigger and trigger.type and WA.triggerSystems[trigger.type] or nil
end
-- Each distinct registered system exactly once -- Delete/Rename fan out to all
-- of them since a display's own systems may already be gone by then.
-- safecall-wrapped so one system's error (e.g. a loadFunc side effect
-- throwing) can't silently abort the rest of applyLoad -- previously an
-- uncaught error here left loaded[id] claiming success (WA.Add sets it before
-- this runs) while the system that threw never actually finished
-- registering, with nothing printed to explain why.
local function eachSystem(fn)
local seen = {}
for _, system in pairs(WA.triggerSystems) do
if not seen[system] then
seen[system] = true
WA.safecall("trigger system", fn, system)
end
end
end
-- ---------------------------------------------------------------------------
-- Regions (create-on-demand stub pool)
-- ---------------------------------------------------------------------------
-- Creates or returns the region frame for (id, cloneId). Rebuilds the whole
-- entry when the display's regionType changed under it. Regions are created
-- lazily and start collapsed (hidden); the state machine expands them.
local function EnsureRegion(id, cloneId)
local data = WeakestAurasDB.displays[id]
if not data then return nil end
local rt = WA.regionTypes[data.regionType]
if not rt or not rt.create then return nil end
local entry = regions[id]
if not entry or entry.regionType ~= data.regionType then
if entry then
for _, frame in pairs(entry.byClone) do frame:Hide() end
end
entry = { regionType = data.regionType, byClone = {} }
regions[id] = entry
end
local frame = entry.byClone[cloneId]
if not frame then
frame = rt.create(UIParent, data)
frame.cloneId = cloneId
entry.byClone[cloneId] = frame
if rt.modify then rt.modify(frame, data) end
end
return frame
end
-- (Re)applies saved config to every existing clone of a display -- the single
-- code path both "apply saved config" (WA.Add) and a regionType switch run.
local function SetRegion(data)
local rt = WA.regionTypes[data.regionType]
if not rt or not rt.create then return end
EnsureRegion(data.id, "")
local entry = regions[data.id]
if entry and rt.modify then
for _, frame in pairs(entry.byClone) do
rt.modify(frame, data)
end
end
end
local function CollapseAll(id)
local entry = regions[id]
if not entry then return end
local data = WeakestAurasDB.displays[id]
for _, frame in pairs(entry.byClone) do
-- Re-run conditions in hide mode first (restores base property values,
-- clears activation bookkeeping) while the region still has its states.
if data and data.uid then WA.RunConditions(frame, data.uid, true) end
frame:Collapse()
end
end
-- Collapse clones whose cloneId no longer has a state (Show->Show pruning).
local function CollapseStaleClones(id, allstates)
local entry = regions[id]
if not entry then return end
local data = WeakestAurasDB.displays[id]
for cloneId, frame in pairs(entry.byClone) do
if not allstates[cloneId] then
if data and data.uid then WA.RunConditions(frame, data.uid, true) end
frame:Collapse()
end
end
end
-- Iterate every live region frame (all clones of all displays). Conditions.lua
-- uses this to re-run conditions for shown regions on a global-condition event.
function WA.ForEachRegion(fn)
for id, entry in pairs(regions) do
for _, frame in pairs(entry.byClone) do fn(frame, id) end
end
end
-- Every live clone frame of one display. Regions.lua's dynamicgroup grower uses
-- it to collect a child's visible clones for layout.
function WA.ForEachClone(id, fn)
local entry = regions[id]
if not entry then return end
for cloneId, frame in pairs(entry.byClone) do fn(frame, cloneId) end
end
-- The live on-screen frame for a display (default the base "" clone). The mover
-- grabs the previewed region through this. nil if the
-- display hasn't been rendered yet. Ensures the region so the options preview,
-- which always targets the base clone, can attach a mover before any state.
function WA.GetRegion(id, cloneId)
return EnsureRegion(id, cloneId or "")
end
-- Like GetRegion but never creates -- returns nil if the frame doesn't exist
-- yet. Regions.lua's WA.RelayoutGroup uses it so recomputing a group's box
-- after a child edit doesn't spuriously spin up an unrendered group.
function WA.PeekRegion(id, cloneId)
local entry = regions[id]
return entry and entry.byClone[cloneId or ""]
end
-- ---------------------------------------------------------------------------
-- Producer-side API + conditions hook
-- ---------------------------------------------------------------------------
-- A trigger system's handle on its own allstates for one trigger -- it mutates
-- this table directly (add/update/remove states, set state.changed), then calls
-- WA.UpdatedTriggerState. nil if the display hasn't been Added yet.
function WA.GetTriggerStateForTrigger(id, triggernum)
local ts = triggerState[id]
if not ts then return nil end
if not ts[triggernum] then ts[triggernum] = {} end
return ts[triggernum]
end
-- Runs a display's condition function against the just-applied states.
-- Conditions.lua overrides this; the no-op default keeps the apply path
-- (ApplyStatesToRegions) working when that file hasn't loaded.
function WA.RunConditions(region, uid, hide) end
-- ---------------------------------------------------------------------------
-- Apply states to regions (§3 ApplyStatesToRegions)
-- ---------------------------------------------------------------------------
local function ApplyStatesToRegions(id, activeTrigger, allstates)
local ts = triggerState[id]
local data = WeakestAurasDB.displays[id]
for cloneId, state in pairs(allstates) do
local region = EnsureRegion(id, cloneId)
if region then
region.state = state
region.states = region.states or {}
-- Every trigger's state for this clone is readable (falling back to
-- the "" state), so text can say %2.p and conditions can check
-- trigger 3 while another trigger drives the display (§3).
for triggernum = 1, ts.numTriggers do
local as = ts[triggernum]
region.states[triggernum] = as and (as[cloneId] or as[""]) or nil
end
if state.changed or not region.toShow then
WA.safecall(id, region.Update, region)
region.subRegionEvents:Notify("Update", state, region.states)
region:Expand()
WA.RunConditions(region, data.uid, false)
end
end
end
end
-- ---------------------------------------------------------------------------
-- UpdatedTriggerState (§3): the seven steps
-- ---------------------------------------------------------------------------
function WA.UpdatedTriggerState(id)
local ts = triggerState[id]
if not ts then return end
local data = WeakestAurasDB.displays[id]
if not data then return end
local numTriggers = ts.numTriggers
-- 1. Prune states flagged hidden (show == false is the legacy removal path;
-- deleting the key is the other one, both handled).
for triggernum = 1, numTriggers do
local as = ts[triggernum]
if as then
for cloneId, state in pairs(as) do
if state.show == false then as[cloneId] = nil end
end
end
end
-- 2. Per-trigger active flag + count. Every surviving state is also stamped
-- with the identity fields upstream guarantees (WA2's WeakAuras.lua own
-- UpdatedTriggerState): a trigger system only has to fill in what it knows,
-- and anything downstream can rely on these being there. `id` in particular
-- is what makes %n fall back to the display's own name for a trigger that
-- reports no name of its own (TextReplace's `n` symbol reads name or id).
local triggerCount = 0
for triggernum = 1, numTriggers do
local as = ts[triggernum]
local anyShown = false
if as then
local entry = data.triggers[triggernum]
for _, state in pairs(as) do
state.id = id
state.triggernum = triggernum
state.trigger = entry and entry.trigger
if state.show then anyShown = true end
end
end
if ts.triggers[triggernum] ~= anyShown then
ts.triggers[triggernum] = anyShown
if anyShown then ts.activationTime[triggernum] = GetTime() end
end
if anyShown then triggerCount = triggerCount + 1 end
end
ts.triggerCount = triggerCount
-- 3. Overall show via the disjunctive.
local newShow
if ts.disjunctive == "any" then
newShow = triggerCount > 0
elseif ts.disjunctive == "custom" and ts.triggerLogicFunc then
local ok, res = WA.safecall(id, ts.triggerLogicFunc, ts.triggers)
newShow = (ok and res) and true or false
else -- "all"
newShow = numTriggers > 0 and triggerCount == numTriggers
end
-- While the options window is open, mute every display except the ones the
-- user is actively viewing (selection + eye pins, which the preview ticker
-- force-shows). Everything else is hidden regardless of its real trigger, so
-- config starts from a blank board and you reveal what you work on -- WA2's
-- SetFakeStates/FakeStatesFor. WA.forced leaves are exempt (fakeOne owns them).
if WA.optionsOpen and not WA.forced[id] then
newShow = false
end
-- 4. Resolve the active trigger (fixed number, or first_active scan).
local activeTrigger = ts.activeTriggerMode
if activeTrigger == WA.trigger_modes.first_active then
activeTrigger = 1
for triggernum = 1, numTriggers do
if ts.triggers[triggernum] then activeTrigger = triggernum; break end
end
end
local allstates = ts[activeTrigger]
-- 5. Shown but the active trigger has no state: synthesize a fallback.
if newShow and (not allstates or not next(allstates)) then
local system = WA.GetTriggerSystem(data, activeTrigger)
local fallback = {}
if system and system.CreateFallbackState then
system.CreateFallbackState(data, activeTrigger, fallback)
end
fallback.show = true
fallback.changed = true
ts[activeTrigger] = ts[activeTrigger] or {}
ts[activeTrigger][""] = fallback
allstates = ts[activeTrigger]
end
ts.activeStates = allstates
-- 6. Apply by transition.
local wasShown = ts.show
ts.show = newShow
if newShow then
ApplyStatesToRegions(id, activeTrigger, allstates)
if wasShown then CollapseStaleClones(id, allstates) end
elseif wasShown then
CollapseAll(id)
end
-- 7. Reset changed flags.
for triggernum = 1, numTriggers do
local as = ts[triggernum]
if as then
for _, state in pairs(as) do state.changed = false end
end
end
-- This display's clones just changed visibility, which changes its parent
-- group's layout: a dynamicgroup re-arranges its now-visible children, a
-- static group refreshes its box. Cheap and idempotent; the batching happens
-- naturally since all of this id's clones settle within this one call.
if data.parent then WA.RelayoutGroup(data.parent) end
end
-- Toggle the config-mode mute (WA2 SetFakeStates/ClearFakeStates). Opening
-- re-evaluates every rendered display so non-forced ones hide; closing restores
-- their real states. OptionsFrame calls this from the panel's show/hide.
function WA.SetOptionsOpen(open)
WA.optionsOpen = open and true or false
for id in pairs(triggerState) do
WA.safecall(id, WA.UpdatedTriggerState, id)
end
end
-- ---------------------------------------------------------------------------
-- Add / Remove / Rename (§3 pAdd, scaled)
-- ---------------------------------------------------------------------------
-- Recomputes the standby label for a display whose load state is `isLoaded`.
-- Returns whether it changed, so a caller that skipped the load transition can
-- still repaint the list. A loaded display is never on standby.
local function setStandby(data, isLoaded)
local id = data.id
local was = standby[id]
standby[id] = (not isLoaded and WA.EvalLoadStatic(data)) and true or nil
return standby[id] ~= was
end
-- Registers or unregisters a compiled display with its trigger systems by its
-- desired load state, and shows/hides accordingly (§11). Loading hands
-- the display to each system's LoadDisplays (which starts scanning / registers
-- events); unloading calls UnloadDisplays, wipes the produced states, and
-- collapses the region. Sets loaded[id] to the new state. Callers decide when to
-- (re)run UpdatedTriggerState -- LoadDisplays already force-initializes status
-- triggers, so WA.Add/SetDisplayLoaded only need it for the aura watcher path.
--
-- Repaints the aura list whenever the label it renders moved. Both routes here
-- need it and neither is the options window: a zone/combat change comes through
-- ScanForLoads, and an edit on the Load tab comes through WA.Add, which never
-- touched WA.RefreshList -- the row's load state would sit stale until the user
-- next clicked something. WA.RefreshList is itself a no-op while the panel is
-- closed, so the login-time AddAllDisplays sweep costs nothing.
local function applyLoad(data, shouldLoad)
local id = data.id
shouldLoad = shouldLoad and true or false
local wasLoaded, wasStandby = loaded[id], standby[id]
loaded[id] = shouldLoad
setStandby(data, shouldLoad)
if shouldLoad then
eachSystem(function(system) if system.LoadDisplays then system.LoadDisplays({ id }) end end)
else
eachSystem(function(system) if system.UnloadDisplays then system.UnloadDisplays({ id }) end end)
local ts = triggerState[id]
if ts then
-- Drop every produced state so a later reload starts clean (§11:
-- unloading wipes trigger state); ts.show=false so the reload's first
-- UpdatedTriggerState sees the region as currently hidden.
for triggernum = 1, ts.numTriggers do ts[triggernum] = {} end
ts.show = false
end
CollapseAll(id)
end
if (loaded[id] ~= wasLoaded or standby[id] ~= wasStandby) and WA.RefreshList then
WA.RefreshList()
end
end
-- The load system's entry point when a display's load state may have flipped
-- (Load.lua's ScanForLoads, §11). Idempotent -- a no-op when the state is
-- unchanged or the display isn't compiled (a group, or not yet Added).
function WA.SetDisplayLoaded(data, shouldLoad)
local id = data.id
if not triggerState[id] then return end
shouldLoad = shouldLoad and true or false
if (loaded[id] and true or false) == shouldLoad then
-- No load transition, but a character-level constraint can still have
-- flipped under an unloaded display (a level-up, a spell learned), which
-- moves it between Standby and Not Loaded.
if setStandby(data, shouldLoad) and WA.RefreshList then WA.RefreshList() end
return
end
applyLoad(data, shouldLoad)
if shouldLoad then WA.UpdatedTriggerState(id) end
end
-- Read-only (Debug.lua's /wa load): is this display currently loaded?
function WA.IsDisplayLoaded(id)
return loaded[id] and true or false
end
-- The three-state load label the aura list renders, plus the leaf counts its
-- tooltip needs: "loaded" / "standby" / "unloaded", nLoaded, nStandby, nLeaves.
-- A group rolls its whole subtree up by priority, matching WA2's own header
-- test -- any leaf loaded makes the group loaded, else any leaf on standby
-- makes it standby. A leaf counts as one leaf, so both cases read the same.
function WA.DisplayLoadState(id)
local data = WeakestAurasDB.displays[id]
if not data then return "unloaded", 0, 0, 0 end
if not WA.IsGroup(data) then
if loaded[id] then return "loaded", 1, 0, 1 end
if standby[id] then return "standby", 0, 1, 1 end
return "unloaded", 0, 0, 1
end
local nLoaded, nStandby, nLeaves = 0, 0, 0
local children = data.controlledChildren or {}
for i = 1, table.getn(children) do
local _, cl, cs, cn = WA.DisplayLoadState(children[i])
nLoaded, nStandby, nLeaves = nLoaded + cl, nStandby + cs, nLeaves + cn
end
local state = "unloaded"
if nLoaded > 0 then state = "loaded" elseif nStandby > 0 then state = "standby" end
return state, nLoaded, nStandby, nLeaves
end
-- Compiles a customTriggerLogic string ("function(t) return t[1] and not t[2]
-- end") into a callable. loadstring works on this client; disjunctive="custom"
-- has no UI yet, but wiring it now costs nothing and keeps §3 faithful.
local function compileTriggerLogic(str)
if not str or str == "" then return nil end
local fn, err = loadstring("return " .. str)
if not fn then
DEFAULT_CHAT_FRAME:AddMessage("|cffff0000WeakestAuras|r bad customTriggerLogic: " .. tostring(err), 1, 0.3, 0.3)
return nil
end
local ok, result = pcall(fn)
return ok and result or nil
end
-- Renders/repositions a group's container frame (no triggers/state -- see
-- WA.Add's group branch). Re-anchors existing child frames to it afterward, so
-- a group (re)built after its children already have frames pulls them in;
-- children created later resolve the group on demand via ApplyPosition. Nested
-- child groups recurse.
function WA.AddGroup(data)
SetRegion(data) -- runs groupModify: positions frame, sizes box, draws border
local kids = data.controlledChildren or {}
for i = 1, table.getn(kids) do
local cd = WeakestAurasDB.displays[kids[i]]
if cd and WA.IsGroup(cd) then
WA.AddGroup(cd)
elseif cd then
local cf = WA.PeekRegion(cd.id, "")
if cf then WA.regionPrototype.ApplyPosition(cf, cd) end
end
end
end
-- Re-anchors a child whose group membership just changed and refreshes the
-- boxes of the groups it left and joined. The runtime side of Data.lua's
-- reparent primitives (WA.AddChildToGroup/RemoveChildFromGroup/ReorderAura):
-- a child's frame is parented by data.parent now (ApplyPosition), so moving it
-- between groups must re-anchor it. Safe before render -- an unrendered child
-- simply anchors correctly when first shown. A moved child that is itself a
-- group carries its own children (they SetParent to its frame).
function WA.RefreshMembership(childId, oldParent, newParent)
local cd = WeakestAurasDB.displays[childId]
if cd then
local cf = WA.PeekRegion(childId, "")
if cf then WA.regionPrototype.ApplyPosition(cf, cd) end
end
if oldParent then WA.RelayoutGroup(oldParent) end
if newParent and newParent ~= oldParent then WA.RelayoutGroup(newParent) end
end
function WA.Add(data, simpleChange)
-- The aura list's row previews render this display's own appearance fields
-- (Regions.lua's modifyThumbnail), so any edit that reaches here -- including
-- the pure-visual fast path below -- has to repaint the row, not just the
-- region. WA.RefreshList is a no-op while the options panel is closed.
if WA.RefreshList then WA.RefreshList() end
if WA.IsGroup(data) then WA.AddGroup(data); return end
local id = data.id
-- Fast-path (WA2's pAdd simpleChange): a pure-visual edit (region/subregion
-- appearance) doesn't change which states are produced or the load status, so
-- skip the collapse + trigger/condition/load recompile. Re-apply the region's
-- visuals -- modify rebuilds subregions too (RegionPrototype.modifyFinish) -- and
-- let UpdatedTriggerState re-layer states + conditions on the fresh base. Only
-- valid once the display has been fully Added (triggerState exists); the first
-- Add and any structural edit (trigger/load/condition/regionType) fall through.
if simpleChange and triggerState[id] then
SetRegion(data)
-- A size/offset edit shifts this aura's contribution to its group's box.
if data.parent then WA.RelayoutGroup(data.parent) end
if WA.forced[id] then
if fakeForced then fakeForced(id) end
elseif loaded[id] then
WA.UpdatedTriggerState(id)
end
return
end
local triggers = data.triggers
local numTriggers = table.getn(triggers)
-- Collapse-first baseline (WA2's pAdd): a recompile reuses the live region
-- frame, so force it hidden before re-deriving -- otherwise a recompile that now
-- resolves to hidden (e.g. switching Show always->on-cooldown while off cooldown)
-- strands the previously-visible frame on screen. The re-derivation below re-shows
-- it synchronously if it should stay up (GenericTrigger via force_events, aura via
-- TriggerAura.LoadDisplays' sync rescan), so there's no visible flicker. The
-- previewed aura is exempt -- its visibility is owned by the preview ticker, which
-- we re-run synchronously at the end instead (WA2's FakeStatesFor snapshot).
if not WA.forced[id] then CollapseAll(id) end
-- The fresh ts's `show` must describe the region as it actually is right now,
-- since UpdatedTriggerState only collapses on a shown->hidden transition. The
-- collapse above makes that false for the normal path -- but the forced path
-- skipped it, so a still-expanded preview must carry its `show` over or a
-- recompile that now resolves to hidden strands the frame on screen with no
-- transition left to take it down (e.g. flipping the disjunctive back to "all").
local prev = triggerState[id]
local ts = {
disjunctive = triggers.disjunctive or "all",
numTriggers = numTriggers,
activeTriggerMode = triggers.activeTriggerMode or WA.trigger_modes.first_active,
triggerLogicFunc = nil,
triggers = {},
triggerCount = 0,
activationTime = {},
activatedConditions = {},
show = (WA.forced[id] and prev and prev.show) and true or false,
activeStates = nil,
}
if ts.disjunctive == "custom" then
ts.triggerLogicFunc = compileTriggerLogic(triggers.customTriggerLogic)
end
for i = 1, numTriggers do ts[i] = {} end
triggerState[id] = ts
-- Clear every system's prior registration for this id first, so a trigger
-- switched across systems (e.g. aura -> a generic prototype) doesn't leave
-- the old system still producing states into this id's slots. Cheap and safe
-- (each Delete no-ops on an id it doesn't own); the current systems re-Add
-- below.
eachSystem(function(system) if system.Delete then system.Delete(id) end end)
-- Each system compiles its own triggers out of data.triggers (it iterates,
-- picking its own types), so call each owning system once.
local called = {}
for i = 1, numTriggers do
local system = WA.GetTriggerSystem(data, i)
if system and not called[system] then
called[system] = true
if system.Add then system.Add(data) end
end
end
SetRegion(data)
-- Compile this display's conditions before the first state application, so
-- the RunConditions call inside UpdatedTriggerState has something to run
-- (a no-op unless Conditions.lua has overridden it).
WA.LoadConditions(data)
-- The systems above only compiled this display (they don't self-register into
-- their active scan/event index anymore). applyLoad registers it iff its load
-- conditions currently pass -- so an unloaded aura is compiled-but-dark, and a
-- recompile (this WA.Add) re-decides load state every time (§11). Runs
-- unconditionally rather than through SetDisplayLoaded's transition guard: the
-- Delete above cleared the systems' registration, so even an unchanged load
-- state must re-register.
applyLoad(data, WA.EvalLoad(data))
if WA.forced[id] then
-- Re-establish the fake state in the same frame (the recompile wiped it and
-- the region was left untouched above), so an edit doesn't drop the preview
-- until the 0.1s ticker's next fire.
if fakeForced then fakeForced(id) end
elseif loaded[id] then
WA.UpdatedTriggerState(id)
end
-- A recompile can change this aura's size/offset (regionType switch, etc.),
-- so refresh its group's box now that its frame reflects the new config.
if data.parent then WA.RelayoutGroup(data.parent) end
end
function WA.Remove(data)
local id = data.id
CollapseAll(id)
local entry = regions[id]
if entry then
for _, frame in pairs(entry.byClone) do frame:Hide() end
regions[id] = nil
end
triggerState[id] = nil
loaded[id] = nil
standby[id] = nil
WA.UnloadConditions(data)
eachSystem(function(system) if system.Delete then system.Delete(id) end end)
-- Its group's box no longer needs to cover this child.
if data.parent then WA.RelayoutGroup(data.parent) end
end
function WA.Rename(oldId, newId)
if triggerState[oldId] then
triggerState[newId] = triggerState[oldId]
triggerState[oldId] = nil
end
if regions[oldId] then
regions[newId] = regions[oldId]
regions[oldId] = nil
end
if loaded[oldId] ~= nil then
loaded[newId] = loaded[oldId]
loaded[oldId] = nil
end
if standby[oldId] ~= nil then
standby[newId] = standby[oldId]
standby[oldId] = nil
end
eachSystem(function(system) if system.Rename then system.Rename(oldId, newId) end end)
end
-- Builds runtime state + regions for every display (leaf and group). Called
-- once after all Register*/NormalizeAll have run (OptionsFrame.lua, the last
-- file). WA.Add routes groups to WA.AddGroup; order is irrelevant since a
-- child's ApplyPosition ensures its group frame on demand and AddGroup
-- re-anchors children that already exist.
function WA.AddAllDisplays()
for id, data in pairs(WeakestAurasDB.displays) do
WA.safecall(id, WA.Add, data)
end
end
-- Debug read-only accessor (Debug.lua's /wa states).
function WA.GetDisplayTriggerState(id)
return triggerState[id]
end
-- ---------------------------------------------------------------------------
-- Forced visibility / fake states (§14 + FakeStatesFor). While the
-- options window is open, any number of leaves can be "forced" -- shown with a
-- looping fake state so they can be sized/positioned/debugged even when their
-- real trigger doesn't match. A group forces its leaf descendants, so selecting
-- (or eye-toggling) a dynamic group fake-shows its children and the grower lays
-- them out instead of stacking them at the baseline. Two sources merge into
-- WA.forced: the current selection preview (transient) and per-row eye pins
-- (persist across selection until options closes).
-- ---------------------------------------------------------------------------
local pinned = {} -- leaf id -> true: eye-pinned (persists across selection)
local selectionLeaves = {} -- leaf id -> true: from the current selection preview
local previewTicker
local PREVIEW_CYCLE = 7 -- seconds; matches WA2's fake-timer loop length
-- The leaf ids under id (id itself if it's a leaf), accumulated into `into`.
local function collectLeaves(id, into)
local data = WeakestAurasDB.displays[id]
if not data then return end
if WA.IsGroup(data) then
local kids = data.controlledChildren or {}
for i = 1, table.getn(kids) do collectLeaves(kids[i], into) end
else
into[id] = true
end
end
-- Injects one leaf's looping fake state (name/icon from each trigger) and
-- re-runs the state machine so the region shows. *Every* trigger is faked, not
-- just trigger 1 (WA2's UpdateFakeStatesFor, which loops data.triggers): the
-- combination in UpdatedTriggerState still runs over the fakes, so faking only
-- one leaves disjunctive="all" (and any custom logic) unsatisfied -- the preview
-- would stay dark for exactly the multi-trigger displays that need it most.
local function fakeOne(id)
local data = WeakestAurasDB.displays[id]
local ts = triggerState[id]
if not data or not ts then return end
local remain = PREVIEW_CYCLE - math.mod(GetTime(), PREVIEW_CYCLE)
for triggernum = 1, ts.numTriggers do
local system = WA.GetTriggerSystem(data, triggernum)
local name, icon = data.id, "Interface\\Icons\\INV_Misc_QuestionMark"
if system and system.GetNameAndIcon then
local n, i = system.GetNameAndIcon(data, triggernum)
-- An unconfigured trigger reports "" rather than nil, and "" is truthy
-- in Lua -- so test for content, not just presence, or the preview shows
-- a blank %n. The display's own id is the fallback, matching what %n
-- itself falls back to (TextReplace).
if n and n ~= "" then name = n end
if i then icon = i end
end
local states = ts[triggernum] or {}
ts[triggernum] = states
local state = states[""]
if not state then state = {}; states[""] = state end
state.show = true
state.changed = true
state.progressType = "timed"
state.name = name
state.icon = icon
state.stacks = 3
state.duration = PREVIEW_CYCLE
state.expirationTime = GetTime() + remain
end
WA.UpdatedTriggerState(id)
end
fakeForced = fakeOne -- resolve the forward decl WA.Add uses
-- Retires a leaf's fake state; the watcher re-establishes the real one (or the
-- region goes dark) on its next scan.
local function retireFake(id)
local ts = triggerState[id]
if not ts then return end
for triggernum = 1, ts.numTriggers do
local as = ts[triggernum]
if as and as[""] then
as[""].show = false
as[""].changed = true
end
end
WA.UpdatedTriggerState(id)
-- The wipe above deleted every state, including ones a still-true status
-- trigger owns -- and an event-driven system only writes state when its event
-- fires, so "in combat" would read as inactive until the next regen event.
-- Re-run each system's force pass now (the aura scanner's 0.2s poll, which
-- skips forced ids, needs no help).
eachSystem(function(system) if system.ForceUpdate then system.ForceUpdate({ id }) end end)
end
local function previewTick()
for id in pairs(WA.forced) do fakeOne(id) end
end
-- Rebuilds WA.forced = pinned + selectionLeaves, retiring the fakes that dropped
-- out and (re)starting/stopping the ticker to match.
local function recomputeForced()
local nextSet = {}
for id in pairs(pinned) do nextSet[id] = true end
for id in pairs(selectionLeaves) do nextSet[id] = true end
for id in pairs(WA.forced) do
if not nextSet[id] then WA.forced[id] = nil; retireFake(id) end
end
for id in pairs(nextSet) do WA.forced[id] = true end
if next(WA.forced) then
if not previewTicker then previewTicker = C_Timer.NewTicker(0.1, previewTick) end
previewTick()
elseif previewTicker then
previewTicker:Cancel()
previewTicker = nil
end
end
-- The selection preview: fake the selected aura, replacing whatever the previous
-- selection contributed. Selecting a group reveals all its children; selecting a
-- *child* reveals its whole parent group too, so you edit a member in the
-- context of the group's layout rather than in isolation (the mover still
-- attaches to just the selected node). Called on every selection change; nil
-- clears the selection contribution.
function WA.SetPreview(id)
selectionLeaves = {}
if id then
local data = WeakestAurasDB.displays[id]
local revealId = id
if data and data.parent and WeakestAurasDB.displays[data.parent] then
revealId = data.parent
end
collectLeaves(revealId, selectionLeaves)
end
recomputeForced()
end
-- Eye toggle for a list row: pins/unpins id's leaves so they stay forced across
-- selection changes. A group toggles all its leaf descendants together -- pin
-- all unless already all-pinned, then unpin all (WA2's Priority/Recheck).
-- The eye toggle over several displays at once, for the aura list's bucket
-- headers: every leaf under any of them is pinned, unless they all already are,
-- in which case they're all released. Mirrors WA2's header view button, which
-- drives PriorityShow/PriorityHide across the bucket's children.
function WA.ToggleForcedMany(ids)
local leaves = {}
for i = 1, table.getn(ids) do collectLeaves(ids[i], leaves) end
local allPinned = true
for lid in pairs(leaves) do if not pinned[lid] then allPinned = false; break end end
for lid in pairs(leaves) do
if allPinned then pinned[lid] = nil else pinned[lid] = true end
end
recomputeForced()
end
function WA.ToggleForced(id)
local leaves = {}
collectLeaves(id, leaves)
local allPinned = true
for lid in pairs(leaves) do if not pinned[lid] then allPinned = false; break end end
for lid in pairs(leaves) do
if allPinned then pinned[lid] = nil else pinned[lid] = true end
end
recomputeForced()
end
-- A single leaf's config visibility for the eye: 2 = eye-pinned (stays shown
-- across selection), 1 = shown only because it's the current selection, 0 =
-- hidden/muted. Mirrors WA2's view.visibility priorities (2 eye, 1 pick, 0 off).
local function leafVis(id)
if pinned[id] then return 2 elseif selectionLeaves[id] then return 1 else return 0 end
end
-- Eye state for rendering a row. A leaf reads leafVis directly; a group rolls up
-- its leaves the WA2 way (all shown-and-pinned -> 2, all hidden -> 0, else 1
-- partial), so the icon shows at a glance whether the whole subtree is pinned,
-- partly visible, or dark.
-- The same roll-up across several displays (a bucket header's eye).
function WA.ForcedStateMany(ids)
local leaves = {}
for i = 1, table.getn(ids) do collectLeaves(ids[i], leaves) end
local count, all2, all0 = 0, 0, 0
for lid in pairs(leaves) do
count = count + 1
local v = leafVis(lid)
if v == 2 then all2 = all2 + 1 end
if v == 0 then all0 = all0 + 1 end
end
if count == 0 then return 0 end
if all2 == count then return 2 end
if all0 == count then return 0 end
return 1
end
function WA.ForcedState(id)
local data = WeakestAurasDB.displays[id]
if not data then return 0 end
if not WA.IsGroup(data) then return leafVis(id) end
local leaves = {}
collectLeaves(id, leaves)
local count, all2, all0 = 0, 0, 0
for lid in pairs(leaves) do
count = count + 1
local v = leafVis(lid)
if v == 2 then all2 = all2 + 1 end
if v == 0 then all0 = all0 + 1 end
end
if count == 0 then return 0 end
if all2 == count then return 2 end
if all0 == count then return 0 end
return 1
end
-- Wipe every forced contribution (options closing); retires all fakes.
function WA.ClearForced()
pinned = {}
selectionLeaves = {}
recomputeForced()
end