mirror of
https://github.com/fuffc/WeakestAuras.git
synced 2026-11-17 16:34:38 +00:00
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.
860 lines
35 KiB
Lua
860 lines
35 KiB
Lua
-- WeakestAuras -- data model: the saved aura shape, region/trigger type
|
|
-- registries (RegisterRegionType/RegisterTriggerType), and aura CRUD.
|
|
-- Upstream section refs (§N) point at design/architecture/weakauras2-reference.md
|
|
|
|
if WeakestAuras.disabled then return end
|
|
|
|
local WA = WeakestAuras
|
|
|
|
WeakestAurasDB.displays = WeakestAurasDB.displays or {}
|
|
|
|
-- Region types (Regions.lua) and trigger types (Triggers.lua) register themselves
|
|
-- here by name; the options window looks a data's regionType/trigger.type up in
|
|
-- these tables rather than switching on a fixed list, so adding a new display or
|
|
-- trigger kind never touches OptionsFrame.lua.
|
|
WA.regionTypes = {}
|
|
WA.triggerTypes = {}
|
|
-- Sub-region types (SubText.lua) register here; a display's data.subRegions is
|
|
-- an ordered array of instances of these (§8). Same
|
|
-- options/runtime split as region types: the spec carries defaults +
|
|
-- create/modify + a supports(regionType) gate + condition properties.
|
|
WA.subRegionTypes = {}
|
|
|
|
-- spec = { defaults = { field = value, ... }, options = function(data) return {...} end,
|
|
-- icon = "Interface\\Icons\\..." -- list-row fallback texture, used only
|
|
-- when this type registers no createThumbnail, or WA.AcquireThumbnail
|
|
-- returns nil (see OptionsFrame.lua's refreshList),
|
|
-- createThumbnail = function(parent) ... return frame end, -- optional
|
|
-- modifyThumbnail = function(frame, data) ... end } -- optional
|
|
-- createThumbnail/modifyThumbnail are the real per-region-type preview: a small
|
|
-- frame built once and repainted per aura, pooled below rather than created per
|
|
-- row since frames on this client can't be destroyed. modifyThumbnail runs after
|
|
-- the caller has already sized the frame (WA.AcquireThumbnail), so it can read
|
|
-- back frame:GetWidth()/GetHeight() for anything that scales with the box.
|
|
function WA.RegisterRegionType(name, spec)
|
|
WA.regionTypes[name] = spec
|
|
end
|
|
|
|
-- Per-region-type thumbnail pool: a released frame waits here for reuse rather
|
|
-- than being destroyed. Keyed by regionType so a group's thumbnail frame can
|
|
-- never be handed to an icon row -- WA.ReleaseThumbnail reads the type back off
|
|
-- the frame itself (stamped once, at creation) rather than trusting the caller.
|
|
WA.thumbnailPools = {}
|
|
local function thumbnailPool(regionType)
|
|
local pool = WA.thumbnailPools[regionType]
|
|
if not pool then
|
|
pool = {}
|
|
WA.thumbnailPools[regionType] = pool
|
|
end
|
|
return pool
|
|
end
|
|
|
|
-- Returns a frame parented to `parent`, sized size x size, modified for `data`
|
|
-- and Shown; nil when the type registers no createThumbnail. The caller anchors
|
|
-- it. Order matters: the frame is sized BEFORE modifyThumbnail runs, since a
|
|
-- mock bar/glyph derives its fill length from the box it's already been given.
|
|
function WA.AcquireThumbnail(regionType, parent, data, size)
|
|
local spec = WA.regionTypes[regionType]
|
|
if not spec or not spec.createThumbnail then return nil end
|
|
local pool = thumbnailPool(regionType)
|
|
local frame = table.remove(pool)
|
|
if not frame then
|
|
frame = spec.createThumbnail(parent)
|
|
if not frame then return nil end
|
|
frame.thumbType = regionType
|
|
end
|
|
frame:SetParent(parent)
|
|
-- A pooled frame still carries the anchor of the row it last sat on, whose
|
|
-- frame is a live object -- the caller's own SetPoint would otherwise be
|
|
-- laid over a point pinned to somebody else's row.
|
|
frame:ClearAllPoints()
|
|
frame:SetWidth(size)
|
|
frame:SetHeight(size)
|
|
if spec.modifyThumbnail then spec.modifyThumbnail(frame, data) end
|
|
frame:Show()
|
|
return frame
|
|
end
|
|
|
|
-- Hides `frame` and returns it to its own type's pool. Safe on nil. Guards
|
|
-- against inserting the same frame twice, in case a caller ever releases
|
|
-- without having reacquired in between.
|
|
function WA.ReleaseThumbnail(frame)
|
|
if not frame then return end
|
|
frame:Hide()
|
|
local pool = thumbnailPool(frame.thumbType)
|
|
for i = 1, table.getn(pool) do
|
|
if pool[i] == frame then return end
|
|
end
|
|
table.insert(pool, frame)
|
|
end
|
|
|
|
-- Re-paints an already-acquired thumbnail in place, for a caller that knows
|
|
-- the frame's type hasn't changed and only needs the display's fields
|
|
-- refreshed (OptionsFrame.lua's refreshList) -- the acquire/release dance is
|
|
-- for a type change only. No-op when the type registers no modifyThumbnail or
|
|
-- frame is nil.
|
|
function WA.ModifyThumbnail(regionType, frame, data)
|
|
if not frame then return end
|
|
local spec = WA.regionTypes[regionType]
|
|
if spec and spec.modifyThumbnail then spec.modifyThumbnail(frame, data) end
|
|
end
|
|
|
|
-- Read-only: how many released frames of this type are sitting in the pool
|
|
-- right now. Exists for the headless harness to assert the acquire/release
|
|
-- accounting never leaks a frame past what the visible rows need.
|
|
function WA.ThumbnailPoolSize(regionType)
|
|
local pool = WA.thumbnailPools[regionType]
|
|
return pool and table.getn(pool) or 0
|
|
end
|
|
|
|
-- spec = { defaults = ..., options = ..., summary = function(data) return "..." end,
|
|
-- migrate = function(trigger) ... end }
|
|
-- summary: one-line "what this watches" text for the aura list row's second line.
|
|
-- migrate: optional, in-place field-rename fixup for a saved trigger table of
|
|
-- this type (e.g. auraType -> debuffType); must be idempotent, MergeDefaults
|
|
-- runs it on every touch. This is the *options-side* registry (defaults +
|
|
-- options tab + summary per trigger.type); the *runtime* layer that actually
|
|
-- produces states is a trigger system registered via WA.RegisterTriggerSystem
|
|
-- (StateMachine.lua), mirroring upstream's triggerTypesOptions vs triggerSystems
|
|
-- split.
|
|
function WA.RegisterTriggerType(name, spec)
|
|
WA.triggerTypes[name] = spec
|
|
end
|
|
|
|
-- spec = { displayName, supports = function(regionType) return bool end,
|
|
-- default = {...}, create = function(parent) end,
|
|
-- modify = function(parent, subRegion, parentData, subRegionData) end,
|
|
-- addDefaultsForNewAura = function(data) end, properties = {...} }
|
|
function WA.RegisterSubRegionType(name, spec)
|
|
WA.subRegionTypes[name] = spec
|
|
end
|
|
|
|
-- Seeds a leaf display's data.subRegions with each supporting sub-region type's
|
|
-- defaults (§8: icon gets a %s stacks text, bar gets %n + %p). Run once
|
|
-- per display via the internalVersion gate in MergeDefaults, so it both
|
|
-- initializes new auras and preserves the (formerly hardcoded) text on auras
|
|
-- saved before subRegions existed, without re-adding on every load.
|
|
function WA.AddDefaultsForNewAura(data)
|
|
if WA.IsGroup(data) then return end
|
|
data.subRegions = data.subRegions or {}
|
|
for _, spec in pairs(WA.subRegionTypes) do
|
|
if spec.addDefaultsForNewAura and (not spec.supports or spec.supports(data.regionType)) then
|
|
spec.addDefaultsForNewAura(data)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- The trigger config table for triggernum n (data.triggers[n].trigger), or nil.
|
|
-- The options UI and summary read this instead of reaching into the array shape
|
|
-- directly.
|
|
function WA.GetTrigger(data, n)
|
|
if not data.triggers then return nil end
|
|
local entry = data.triggers[n]
|
|
return entry and entry.trigger
|
|
end
|
|
|
|
-- onlyGroups: if provided (true/false), lists only types whose isGroup flag
|
|
-- matches -- used to keep an existing aura's own Region type selector from
|
|
-- offering to convert across the leaf/group boundary (see OptionsFrame.lua's
|
|
-- getInfoOptions), matching upstream WeakAuras2's own behavior: its
|
|
-- "Convert to..." menu is simply never offered for a group (always has
|
|
-- controlledChildren) and never lists group/dynamicgroup as a target for a
|
|
-- leaf, rather than handling the conversion's fallout. Omitted (nil), lists
|
|
-- every registered type regardless of category (e.g. the "+ New" picker,
|
|
-- which is free to create either kind from scratch).
|
|
function WA.RegionTypeList(onlyGroups)
|
|
local list = {}
|
|
for name, spec in pairs(WA.regionTypes) do
|
|
if onlyGroups == nil or (spec.isGroup == true) == onlyGroups then
|
|
table.insert(list, name)
|
|
end
|
|
end
|
|
table.sort(list)
|
|
return list
|
|
end
|
|
|
|
-- True if this aura's regionType is a container (group/dynamicgroup) rather
|
|
-- than a leaf display: it has no trigger of its own, and is addressed by id
|
|
-- in another aura's controlledChildren instead of (or as well as) WA.GetOrder().
|
|
function WA.IsGroup(data)
|
|
local region = WA.regionTypes[data.regionType]
|
|
return region ~= nil and region.isGroup == true
|
|
end
|
|
|
|
-- Resolves the icon a leaf display currently shows: Manual mode uses
|
|
-- data.displayIcon outright; Automatic asks the first trigger that can name
|
|
-- one (WA.GetTriggerSystem's GetNameAndIcon), falling back to displayIcon.
|
|
-- nil when nothing resolves -- every caller applies its own placeholder.
|
|
-- Same rule region:UpdateIcon applies at runtime (Regions.lua); shared here so
|
|
-- the aura list row and the icon/progressbar thumbnails can't drift apart.
|
|
function WA.ResolveDisplayIcon(data)
|
|
if WA.IsGroup(data) then return nil end
|
|
if data.iconSource == 0 then
|
|
return (data.displayIcon and data.displayIcon ~= "" and data.displayIcon) or nil
|
|
end
|
|
for n = 1, table.getn(data.triggers or {}) do
|
|
local system = WA.GetTriggerSystem and WA.GetTriggerSystem(data, n)
|
|
if system and system.GetNameAndIcon then
|
|
local _, icon = system.GetNameAndIcon(data, n)
|
|
if icon then return icon end
|
|
end
|
|
end
|
|
return (data.displayIcon and data.displayIcon ~= "" and data.displayIcon) or nil
|
|
end
|
|
|
|
-- A table-valued default (e.g. a group's controlledChildren = {}) must be
|
|
-- copied per-instance, not handed out by reference -- mergeMissing used to
|
|
-- assign the defaults table itself, which would leave every new aura of that
|
|
-- type sharing one physical controlledChildren array. The same trap catches
|
|
-- anything copying a whole display, so the exporter and WA.DuplicateAura share
|
|
-- this rather than each carrying their own six lines.
|
|
function WA.DeepCopy(v)
|
|
if type(v) ~= "table" then return v end
|
|
local copy = {}
|
|
for k2, v2 in pairs(v) do copy[k2] = WA.DeepCopy(v2) end
|
|
return copy
|
|
end
|
|
|
|
local function mergeMissing(target, defaults)
|
|
if not defaults then return end
|
|
for k, v in pairs(defaults) do
|
|
if target[k] == nil then target[k] = WA.DeepCopy(v) end
|
|
end
|
|
end
|
|
|
|
-- Fills in missing fields from the aura's regionType/trigger.type defaults, and
|
|
-- migrates saved data to the schema v2 shape (upstream's `triggers` array +
|
|
-- combination metadata, §1). Safe to call repeatedly (e.g. after
|
|
-- switching regionType, or normalizing older saved data) -- never overwrites a
|
|
-- field the user already set. One-way migration, no internalVersion field yet:
|
|
-- add one the first time a *second* migration is needed (upstream's Modernize
|
|
-- pattern), rather than building the versioning speculatively.
|
|
function WA.MergeDefaults(data)
|
|
local region = WA.regionTypes[data.regionType]
|
|
mergeMissing(data, region and region.defaults)
|
|
|
|
if WA.IsGroup(data) then
|
|
-- Groups combine other displays; they have no trigger of their own.
|
|
-- Old NewAura seeded every aura (groups included) with a stray
|
|
-- trigger/triggers table -- clear it so a group never carries one.
|
|
data.trigger = nil
|
|
data.triggers = nil
|
|
else
|
|
-- Collapse the old single `data.trigger` into triggers[1].trigger,
|
|
-- unchanged inside (§1).
|
|
if data.trigger then
|
|
data.triggers = { { trigger = data.trigger } }
|
|
data.trigger = nil
|
|
end
|
|
data.triggers = data.triggers or {}
|
|
if not data.triggers[1] then data.triggers[1] = { trigger = {} } end
|
|
if data.triggers.disjunctive == nil then data.triggers.disjunctive = "all" end
|
|
if data.triggers.activeTriggerMode == nil then
|
|
data.triggers.activeTriggerMode = WA.trigger_modes.first_active
|
|
end
|
|
|
|
for i = 1, table.getn(data.triggers) do
|
|
local entry = data.triggers[i]
|
|
entry.trigger = entry.trigger or {}
|
|
entry.trigger.type = entry.trigger.type or "aura"
|
|
local ttype = WA.triggerTypes[entry.trigger.type]
|
|
if ttype and ttype.migrate then ttype.migrate(entry.trigger) end
|
|
mergeMissing(entry.trigger, ttype and ttype.defaults)
|
|
end
|
|
|
|
-- A fixed activeTriggerMode left pointing past the end (a trigger the
|
|
-- user deleted) self-heals back to first_active, so saved data never
|
|
-- resolves a shown-but-nonexistent trigger -- same self-repair spirit as
|
|
-- GetOrder (upstream clamps here too).
|
|
local atm = data.triggers.activeTriggerMode
|
|
if type(atm) == "number" and atm ~= WA.trigger_modes.first_active
|
|
and (atm < 1 or atm > table.getn(data.triggers)) then
|
|
data.triggers.activeTriggerMode = WA.trigger_modes.first_active
|
|
end
|
|
end
|
|
|
|
-- Always present, even on an aura that uses none, so adding one never needs
|
|
-- a migration pass.
|
|
data.subRegions = data.subRegions or {}
|
|
data.conditions = data.conditions or {}
|
|
data.load = data.load or {}
|
|
|
|
-- Second migration (upstream's internalVersion/Modernize pattern): seed the
|
|
-- default sub-region texts exactly once. internalVersion < 1 covers both a
|
|
-- brand-new aura (NewAura routes through here) and one predating sub-regions,
|
|
-- whose countdown/stacks text was hardcoded in the region -- both get the
|
|
-- defaults, and the bump keeps them from being re-added if the user later
|
|
-- clears every text. Depends on every RegisterSubRegionType having run, same
|
|
-- ordering constraint NormalizeAll already relies on (see OptionsFrame.lua).
|
|
data.internalVersion = data.internalVersion or 0
|
|
if not WA.IsGroup(data) and data.internalVersion < 1 then
|
|
WA.AddDefaultsForNewAura(data)
|
|
data.internalVersion = 1
|
|
end
|
|
|
|
-- Third migration: position moved from a fixed
|
|
-- CENTER/UIParent x/y to the full anchor tuple (selfPoint/anchorPoint/
|
|
-- xOffset/yOffset). mergeMissing above already seeded the tuple defaults;
|
|
-- carry a pre-tuple aura's old x/y onto the offsets before dropping them.
|
|
-- A brand-new aura has no x/y, so it keeps the seeded defaults untouched.
|
|
if not WA.IsGroup(data) and data.internalVersion < 2 then
|
|
if data.x ~= nil then data.xOffset = data.x end
|
|
if data.y ~= nil then data.yOffset = data.y end
|
|
data.x = nil
|
|
data.y = nil
|
|
data.internalVersion = 2
|
|
end
|
|
end
|
|
|
|
-- Re-ensures WeakestAurasDB.order is a table on every touch rather than trusting the
|
|
-- one-time `or {}` at file load up top: a SavedVariables table restored after that line
|
|
-- ran (e.g. one saved before this field existed) clobbers the whole WeakestAurasDB
|
|
-- global, wiping out that early init same as MergeDefaults re-ensures data.trigger
|
|
-- exists every call instead of assuming NewAura's initial `{}` stuck.
|
|
local function ensureOrder()
|
|
WeakestAurasDB.order = WeakestAurasDB.order or {}
|
|
return WeakestAurasDB.order
|
|
end
|
|
|
|
-- Addon-wide settings that belong to no single display (the mover's lock and
|
|
-- magnetism toggles). Re-ensured on every touch for the same reason
|
|
-- ensureOrder is -- a SavedVariables table restored from before this field
|
|
-- existed replaces the whole WeakestAurasDB global.
|
|
function WA.Options()
|
|
WeakestAurasDB.options = WeakestAurasDB.options or {}
|
|
return WeakestAurasDB.options
|
|
end
|
|
|
|
-- The ordered child-id array `id` currently sits in: its parent group's
|
|
-- controlledChildren if it has one, WeakestAurasDB.order otherwise. A dangling
|
|
-- .parent (the parent got deleted without going through WA.DeleteAura) falls
|
|
-- back to the top-level order, same as a plain unparented id -- repairOrder
|
|
-- below cleans up the inconsistency on the next read either way.
|
|
local function currentList(id)
|
|
local data = WeakestAurasDB.displays[id]
|
|
if data and data.parent then
|
|
local parent = WeakestAurasDB.displays[data.parent]
|
|
if parent then
|
|
parent.controlledChildren = parent.controlledChildren or {}
|
|
return parent.controlledChildren
|
|
end
|
|
end
|
|
return ensureOrder()
|
|
end
|
|
|
|
local function indexOf(list, id)
|
|
for i = 1, table.getn(list) do
|
|
if list[i] == id then return i end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function removeFromList(list, id)
|
|
local i = indexOf(list, id)
|
|
if i then table.remove(list, i) end
|
|
return i
|
|
end
|
|
|
|
-- Detaches id from wherever it currently sits (its parent's controlledChildren,
|
|
-- or the top-level order) without deciding where it goes next -- the shared
|
|
-- first step of AddChildToGroup, RemoveChildFromGroup, and (for a cross-list
|
|
-- move) ReorderAura.
|
|
local function detach(id)
|
|
local data = WeakestAurasDB.displays[id]
|
|
removeFromList(currentList(id), id)
|
|
if data then data.parent = nil end
|
|
end
|
|
|
|
-- Drops stale/misplaced ids from a group's controlledChildren (a child that
|
|
-- was deleted, or reparented elsewhere since this was last read), and appends
|
|
-- any child whose .parent points here but isn't listed yet. Same self-healing
|
|
-- spirit as repairOrder below, just scoped to one group's own list.
|
|
local function repairGroupChildren(groupId)
|
|
local group = WeakestAurasDB.displays[groupId]
|
|
if not group then return end
|
|
group.controlledChildren = group.controlledChildren or {}
|
|
local list = group.controlledChildren
|
|
local seen = {}
|
|
for i = table.getn(list), 1, -1 do
|
|
local id = list[i]
|
|
local child = WeakestAurasDB.displays[id]
|
|
if not child or child.parent ~= groupId or seen[id] then
|
|
table.remove(list, i)
|
|
else
|
|
seen[id] = true
|
|
end
|
|
end
|
|
for id, child in pairs(WeakestAurasDB.displays) do
|
|
if child.parent == groupId and not seen[id] then
|
|
table.insert(list, id)
|
|
seen[id] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Keeps WeakestAurasDB.order in sync with what's actually top-level in .displays
|
|
-- (drops ids a delete/rename left stale or that became a group's child since,
|
|
-- appends any top-level display order doesn't know about yet -- a fresh save, or
|
|
-- a DB saved before order existed), and reconciles every group's controlledChildren
|
|
-- the same way. Cheap and idempotent -- WA.GetOrder just calls it on every read
|
|
-- rather than special-casing each caller that mutates .displays or reparents a child.
|
|
local function repairOrder()
|
|
for id, data in pairs(WeakestAurasDB.displays) do
|
|
if WA.IsGroup(data) then repairGroupChildren(id) end
|
|
end
|
|
|
|
local order = ensureOrder()
|
|
local seen = {}
|
|
for i = table.getn(order), 1, -1 do
|
|
local id = order[i]
|
|
local data = WeakestAurasDB.displays[id]
|
|
if not data or data.parent ~= nil or seen[id] then
|
|
table.remove(order, i)
|
|
else
|
|
seen[id] = true
|
|
end
|
|
end
|
|
for id, data in pairs(WeakestAurasDB.displays) do
|
|
if data.parent == nil and not seen[id] then
|
|
table.insert(order, id)
|
|
seen[id] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
-- The display order the aura list (OptionsFrame.lua) renders in -- a user-arranged
|
|
-- order via drag-to-reorder, not alphabetical. Top-level only; a group's own
|
|
-- controlledChildren is its children's order.
|
|
function WA.GetOrder()
|
|
repairOrder()
|
|
return WeakestAurasDB.order
|
|
end
|
|
|
|
-- Detaches childId from whatever group currently owns it (a no-op if it's
|
|
-- already top-level) and returns it to the end of the top-level order. Also
|
|
-- what WA.DeleteAura promotes a deleted group's children with.
|
|
function WA.RemoveChildFromGroup(childId)
|
|
local child = WeakestAurasDB.displays[childId]
|
|
if not child or not child.parent then return end
|
|
local oldParent = child.parent
|
|
detach(childId)
|
|
table.insert(ensureOrder(), childId)
|
|
if WA.RefreshMembership then WA.RefreshMembership(childId, oldParent, nil) end
|
|
end
|
|
|
|
-- True if candidateId is groupId itself, or nested anywhere under it via
|
|
-- controlledChildren -- guards AddChildToGroup against creating a cycle
|
|
-- (dropping a group onto its own descendant in OptionsFrame.lua's tree).
|
|
local function isSelfOrDescendant(groupId, candidateId)
|
|
if groupId == candidateId then return true end
|
|
local data = WeakestAurasDB.displays[groupId]
|
|
if not data or not data.controlledChildren then return false end
|
|
for i = 1, table.getn(data.controlledChildren) do
|
|
if isSelfOrDescendant(data.controlledChildren[i], candidateId) then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Moves childId into parentId's controlledChildren, detaching it from any
|
|
-- previous group (or the top level) first. index positions it within the new
|
|
-- parent's list (1..n+1; omitted or out of range appends). See WA.ReorderAura
|
|
-- for the boundary-move version driven by drag-and-drop.
|
|
function WA.AddChildToGroup(parentId, childId, index)
|
|
local parent = WeakestAurasDB.displays[parentId]
|
|
local child = WeakestAurasDB.displays[childId]
|
|
if not parent or not child or not WA.IsGroup(parent) then return end
|
|
if isSelfOrDescendant(childId, parentId) then return end
|
|
|
|
local oldParent = child.parent
|
|
detach(childId)
|
|
parent.controlledChildren = parent.controlledChildren or {}
|
|
local list = parent.controlledChildren
|
|
local n = table.getn(list)
|
|
if not index or index < 1 or index > n + 1 then index = n + 1 end
|
|
table.insert(list, index, childId)
|
|
child.parent = parentId
|
|
if WA.RefreshMembership then WA.RefreshMembership(childId, oldParent, parentId) end
|
|
end
|
|
|
|
-- Moves `id` to sit just before whatever currently occupies `before` (1..n+1;
|
|
-- n+1 appends) within newParentId's child list (nil = top level, i.e.
|
|
-- WeakestAurasDB.order). Handles both a same-list reorder -- OptionsFrame.lua's
|
|
-- drag-to-reorder is the only caller today, always with newParentId = nil,
|
|
-- unchanged from the flat-list behavior this replaces -- and a cross-list move
|
|
-- (dragging a child out of a group, into a different one, or between top level
|
|
-- and a group), which the aura list's group drop-targets commit through.
|
|
function WA.ReorderAura(id, newParentId, before)
|
|
if newParentId == id then return end
|
|
if not WeakestAurasDB.displays[id] then return end
|
|
local oldParent = WeakestAurasDB.displays[id].parent
|
|
|
|
local newList
|
|
if newParentId == nil then
|
|
newList = ensureOrder()
|
|
else
|
|
local parent = WeakestAurasDB.displays[newParentId]
|
|
if not parent or not WA.IsGroup(parent) then return end
|
|
parent.controlledChildren = parent.controlledChildren or {}
|
|
newList = parent.controlledChildren
|
|
end
|
|
|
|
local oldList = currentList(id)
|
|
local sameList = (oldList == newList)
|
|
local from = indexOf(oldList, id)
|
|
if not from then return end
|
|
|
|
local n = table.getn(newList)
|
|
if before < 1 then before = 1 elseif before > n + 1 then before = n + 1 end
|
|
|
|
if sameList then
|
|
if before == from or before == from + 1 then return end
|
|
table.remove(oldList, from)
|
|
local insertAt = before > from and before - 1 or before
|
|
table.insert(newList, insertAt, id)
|
|
else
|
|
table.remove(oldList, from)
|
|
table.insert(newList, before, id)
|
|
WeakestAurasDB.displays[id].parent = newParentId
|
|
if WA.RefreshMembership then WA.RefreshMembership(id, oldParent, newParentId) end
|
|
end
|
|
end
|
|
|
|
local function newUID()
|
|
local s = ""
|
|
for i = 1, 8 do
|
|
s = s .. string.format("%x", math.random(0, 15))
|
|
end
|
|
return s
|
|
end
|
|
-- Exposed for the importer, which regenerates a stable-across-rename uid for
|
|
-- every imported display (ImportExport.lua).
|
|
WA.NewUID = newUID
|
|
|
|
-- Hook point for the display engine to (re)build this aura's runtime state and
|
|
-- on-screen region. Defined here as a no-op purely so every options callback in
|
|
-- Regions.lua/Triggers.lua has something to call regardless of load order;
|
|
-- StateMachine.lua (loaded later, see WeakestAuras.toc) overrides this with the
|
|
-- real pAdd-lite. `data` is already the live table stored in
|
|
-- WeakestAurasDB.displays, so edits persist even before that loads.
|
|
function WA.Add(data) end
|
|
|
|
-- Mirrors WA.Add: hook point to tear down whatever runtime state/region this
|
|
-- aura was driving, called from WA.DeleteAura right before the display itself
|
|
-- is dropped. Also overridden by StateMachine.lua.
|
|
function WA.Remove(data) end
|
|
|
|
-- Hook point to re-key runtime state (triggerState, regions, scan indexes) from
|
|
-- oldId to newId after WA.RenameAura moves the display's key -- everything in
|
|
-- the engine is keyed by the display id, which is the rename. No-op until
|
|
-- StateMachine.lua overrides it.
|
|
function WA.Rename(oldId, newId) end
|
|
|
|
-- Hook points for the conditions engine (Conditions.lua overrides these):
|
|
-- LoadConditions (re)compiles a display's condition list at WA.Add time,
|
|
-- UnloadConditions tears it down at WA.Remove, and RunConditions evaluates it
|
|
-- against the just-applied states. No-ops until Conditions.lua loads, so the
|
|
-- state machine (StateMachine.lua) can call them unconditionally. RunConditions
|
|
-- is declared in StateMachine.lua (its apply path is the primary caller).
|
|
function WA.LoadConditions(data) end
|
|
function WA.UnloadConditions(data) end
|
|
|
|
-- Hook points for the load system (Load.lua overrides these): EvalLoad returns
|
|
-- whether a display's data.load conditions currently pass (class/level/zone/
|
|
-- combat/...), EvalLoadStatic the same with the moment-dependent ones skipped
|
|
-- (the Standby label). No-op defaults return true, so before Load.lua loads
|
|
-- (and for a display with no load conditions) "loaded = added".
|
|
function WA.EvalLoad(data) return true end
|
|
function WA.EvalLoadStatic(data) return true end
|
|
|
|
-- Hook point for an option `set` to re-render the current options tab -- used by
|
|
-- toggles that reveal/hide dependent fields (e.g. "Use stacks" showing the
|
|
-- operator+value row), where a plain WA.Add persists the value but the tab needs
|
|
-- rebuilding to show the newly-relevant controls. No-op until OptionsFrame.lua
|
|
-- overrides it with its refreshTabContent; harmless when the window is closed.
|
|
function WA.RefreshOptions() end
|
|
|
|
-- The group that would own an aura created against targetId: the target itself
|
|
-- when it's a group, the target's parent when it's a leaf, nil for top level.
|
|
function WA.PlacementParent(targetId)
|
|
local target = targetId and WeakestAurasDB.displays[targetId]
|
|
if not target then return nil end
|
|
if WA.IsGroup(target) then return targetId end
|
|
return target.parent
|
|
end
|
|
|
|
-- Whether a display of regionType may be placed against targetId. A dynamic
|
|
-- group arranges its children itself and can't own a nested group -- the one
|
|
-- placement refused outright, so a caller offering the type (the aura list's
|
|
-- New picker) asks here before offering it rather than creating and discarding.
|
|
function WA.CanPlaceAura(regionType, targetId)
|
|
local spec = WA.regionTypes[regionType]
|
|
if not spec then return false end
|
|
if spec.isGroup ~= true then return true end
|
|
local parentId = WA.PlacementParent(targetId)
|
|
local parent = parentId and WeakestAurasDB.displays[parentId]
|
|
return not (parent and parent.regionType == "dynamicgroup")
|
|
end
|
|
|
|
-- Moves an already-registered display to where a creation targeted at targetId
|
|
-- belongs: into targetId when it's a group, immediately after it when it's a
|
|
-- leaf, the end of the top level with no target. Shared by WA.NewAura and any
|
|
-- other "put this one beside that one" caller.
|
|
-- `data` must already be in WeakestAurasDB.displays *and* in some sibling list
|
|
-- -- the move runs through WA.ReorderAura, which does nothing for an id it
|
|
-- can't find. WA.NewAura appends top-level before calling this for that reason.
|
|
function WA.PlaceAura(data, targetId)
|
|
if not data or WeakestAurasDB.displays[data.id] ~= data then return nil end
|
|
if targetId == data.id then return data end
|
|
if not WA.CanPlaceAura(data.regionType, targetId) then return nil end
|
|
|
|
local target = targetId and WeakestAurasDB.displays[targetId]
|
|
if not target then
|
|
WA.ReorderAura(data.id, nil, table.getn(ensureOrder()) + 1)
|
|
return data
|
|
end
|
|
|
|
local parentId = WA.PlacementParent(targetId)
|
|
if parentId and isSelfOrDescendant(data.id, parentId) then return nil end
|
|
|
|
if WA.IsGroup(target) then
|
|
WA.AddChildToGroup(targetId, data.id)
|
|
else
|
|
local list = currentList(targetId)
|
|
local at = indexOf(list, targetId)
|
|
WA.ReorderAura(data.id, target.parent, at and at + 1 or table.getn(list) + 1)
|
|
end
|
|
return data
|
|
end
|
|
|
|
-- The first free id of the form "Base", "Base 2", "Base 3", ... -- the naming
|
|
-- rule new auras, imports and duplicates all name themselves by.
|
|
function WA.UniqueId(base)
|
|
local id, n = base, 1
|
|
while WeakestAurasDB.displays[id] do
|
|
n = n + 1
|
|
id = base .. " " .. n
|
|
end
|
|
return id
|
|
end
|
|
|
|
function WA.NewAura(regionType, targetId)
|
|
regionType = regionType or "icon"
|
|
if not WA.regionTypes[regionType] then return nil end
|
|
if not WA.CanPlaceAura(regionType, targetId) then return nil end
|
|
|
|
local id = WA.UniqueId("New Aura")
|
|
|
|
-- No trigger seeded here: MergeDefaults builds the triggers array (or leaves
|
|
-- it nil for a group), so both a fresh aura and older saved data take the
|
|
-- one code path.
|
|
local data = { id = id, uid = newUID(), regionType = regionType }
|
|
WA.MergeDefaults(data)
|
|
WeakestAurasDB.displays[id] = data
|
|
table.insert(ensureOrder(), id)
|
|
WA.PlaceAura(data, targetId)
|
|
return data
|
|
end
|
|
|
|
-- A copy's name: bump a trailing number when the source has one
|
|
-- ("Rejuvenation 2" -> "Rejuvenation 3"), otherwise fall back to the shared
|
|
-- suffixing rule. `^(.-)(%d+)$` needs the non-greedy head, or "Aura 19" would
|
|
-- split as "Aura 1" + "9"; string.find returns the captures after its indices,
|
|
-- there being no string.match on this client.
|
|
local function duplicateId(id)
|
|
local _, _, base, digits = string.find(id, "^(.-)(%d+)$")
|
|
if not base then return WA.UniqueId(id) end
|
|
local n = tonumber(digits)
|
|
local candidate = base .. (n + 1)
|
|
while WeakestAurasDB.displays[candidate] do
|
|
n = n + 1
|
|
candidate = base .. (n + 1)
|
|
end
|
|
return candidate
|
|
end
|
|
|
|
-- One display copied to a fresh id/uid at top level, carrying no children and
|
|
-- no parent -- duplicateTree places it.
|
|
local function copyDisplay(data)
|
|
local copy = WA.DeepCopy(data)
|
|
copy.id = duplicateId(data.id)
|
|
copy.uid = newUID()
|
|
copy.parent = nil
|
|
copy.controlledChildren = WA.IsGroup(data) and {} or nil
|
|
WeakestAurasDB.displays[copy.id] = copy
|
|
table.insert(ensureOrder(), copy.id)
|
|
return copy
|
|
end
|
|
|
|
local function duplicateTree(data)
|
|
local copy = copyDisplay(data)
|
|
local children = data.controlledChildren
|
|
if children then
|
|
for i = 1, table.getn(children) do
|
|
local child = WeakestAurasDB.displays[children[i]]
|
|
if child then WA.AddChildToGroup(copy.id, duplicateTree(child).id) end
|
|
end
|
|
end
|
|
return copy
|
|
end
|
|
|
|
local function addTree(data)
|
|
WA.Add(data)
|
|
local children = data.controlledChildren
|
|
if children then
|
|
for i = 1, table.getn(children) do
|
|
local child = WeakestAurasDB.displays[children[i]]
|
|
if child then addTree(child) end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Copies `id`, placing the copy directly after the original among its siblings.
|
|
-- Groups copy recursively: upstream leaves that to its display-button layer,
|
|
-- which has no counterpart here, and a group duplicate that came out empty
|
|
-- would read as a bug. The whole tree is built before anything is added, so no
|
|
-- region is created against a half-assembled hierarchy. Returns the new id.
|
|
function WA.DuplicateAura(id)
|
|
local data = WeakestAurasDB.displays[id]
|
|
if not data then return nil end
|
|
|
|
local copy = duplicateTree(data)
|
|
local list = currentList(id)
|
|
local at = indexOf(list, id)
|
|
if data.parent then
|
|
WA.AddChildToGroup(data.parent, copy.id, at and at + 1 or nil)
|
|
elseif at then
|
|
WA.ReorderAura(copy.id, nil, at + 1)
|
|
end
|
|
|
|
addTree(copy)
|
|
return copy.id
|
|
end
|
|
|
|
-- Appends a new trigger (defaulting to an "aura" type) to a leaf display's
|
|
-- triggers array and seeds its defaults via MergeDefaults; returns the new
|
|
-- trigger's index. A group has no triggers, so it's a no-op there. The caller
|
|
-- runs WA.Add (StateMachine recompiles the whole triggers array).
|
|
function WA.AddTrigger(data)
|
|
if WA.IsGroup(data) then return nil end
|
|
data.triggers = data.triggers or {}
|
|
table.insert(data.triggers, { trigger = { type = "aura" } })
|
|
WA.MergeDefaults(data)
|
|
return table.getn(data.triggers)
|
|
end
|
|
|
|
-- Removes trigger n. Refuses to drop the last one (an aura always needs at
|
|
-- least trigger 1); MergeDefaults re-clamps a now-dangling activeTriggerMode.
|
|
-- The array reindexes implicitly (table.remove), so trigger n+1 becomes n --
|
|
-- the combination core keys everything by position, so nothing else needs
|
|
-- renumbering.
|
|
function WA.DeleteTrigger(data, n)
|
|
if not data.triggers or table.getn(data.triggers) <= 1 then return end
|
|
table.remove(data.triggers, n)
|
|
WA.MergeDefaults(data)
|
|
end
|
|
|
|
-- Deleting a group ungroups its children (promotes them to top-level) rather
|
|
-- than cascading the delete -- the less-destructive default, matching the
|
|
-- aura list's two-click delete confirm.
|
|
function WA.DeleteAura(id)
|
|
local data = WeakestAurasDB.displays[id]
|
|
if not data then return end
|
|
|
|
if WA.IsGroup(data) and data.controlledChildren then
|
|
-- Snapshot first: RemoveChildFromGroup mutates controlledChildren as
|
|
-- it goes, which would skip entries if we iterated the live array.
|
|
local children = {}
|
|
for i = 1, table.getn(data.controlledChildren) do
|
|
children[i] = data.controlledChildren[i]
|
|
end
|
|
for i = 1, table.getn(children) do
|
|
WA.RemoveChildFromGroup(children[i])
|
|
end
|
|
end
|
|
|
|
detach(id)
|
|
WA.Remove(data)
|
|
WeakestAurasDB.displays[id] = nil
|
|
end
|
|
|
|
-- Deletes a group *with* everything under it, the cascading counterpart to
|
|
-- WA.DeleteAura's promote-the-children default. The descendant set is
|
|
-- snapshotted before any of it is deleted, for the same reason DeleteAura
|
|
-- snapshots controlledChildren: the remove path mutates the lists this would
|
|
-- otherwise be walking. Post-order, so no group is deleted while it still
|
|
-- believes it has children.
|
|
function WA.DeleteAuraTree(id)
|
|
if not WeakestAurasDB.displays[id] then return end
|
|
|
|
local doomed = {}
|
|
local function collect(current)
|
|
local data = WeakestAurasDB.displays[current]
|
|
if not data then return end
|
|
local children = data.controlledChildren
|
|
for i = 1, table.getn(children or {}) do collect(children[i]) end
|
|
table.insert(doomed, current)
|
|
end
|
|
collect(id)
|
|
|
|
for i = 1, table.getn(doomed) do WA.DeleteAura(doomed[i]) end
|
|
end
|
|
|
|
-- Renames the display, moving it to the new key. Returns false (no-op) if the
|
|
-- name is blank or already taken.
|
|
function WA.RenameAura(id, newId)
|
|
if not newId or newId == "" or newId == id then return false end
|
|
if WeakestAurasDB.displays[newId] then return false end
|
|
local data = WeakestAurasDB.displays[id]
|
|
if not data then return false end
|
|
data.id = newId
|
|
WeakestAurasDB.displays[id] = nil
|
|
WeakestAurasDB.displays[newId] = data
|
|
|
|
-- id doubles as the display's key in .displays, so every other place that
|
|
-- references this one by id string -- its parent's controlledChildren
|
|
-- entry, or (if this is a group) each child's own .parent -- needs
|
|
-- repointing too, not just the top-level order below.
|
|
if data.parent then
|
|
local parent = WeakestAurasDB.displays[data.parent]
|
|
if parent and parent.controlledChildren then
|
|
local i = indexOf(parent.controlledChildren, id)
|
|
if i then parent.controlledChildren[i] = newId end
|
|
end
|
|
end
|
|
if data.controlledChildren then
|
|
for i = 1, table.getn(data.controlledChildren) do
|
|
local child = WeakestAurasDB.displays[data.controlledChildren[i]]
|
|
if child then child.parent = newId end
|
|
end
|
|
end
|
|
|
|
local order = ensureOrder()
|
|
for i = 1, table.getn(order) do
|
|
if order[i] == id then
|
|
order[i] = newId
|
|
break
|
|
end
|
|
end
|
|
|
|
-- Re-key the engine's runtime state to match the new id (no-op stub until
|
|
-- StateMachine.lua loads).
|
|
WA.Rename(id, newId)
|
|
return true
|
|
end
|
|
|
|
-- Normalizes every saved aura against the currently-registered region/trigger
|
|
-- types. Must run only after all RegisterRegionType/RegisterTriggerType calls
|
|
-- have happened -- see the call site in OptionsFrame.lua (the last file loaded)
|
|
-- for why it doesn't just run here at file load.
|
|
--
|
|
-- safecall-wrapped per aura: this runs unconditionally before
|
|
-- WA.AddAllDisplays (same call site, OptionsFrame.lua's last two lines), so an
|
|
-- unguarded error on one malformed aura previously aborted the whole loop --
|
|
-- silently, since nothing here printed -- and with it every *other* aura's
|
|
-- WA.Add for the rest of the session (AddAllDisplays never got reached).
|
|
function WA.NormalizeAll()
|
|
for id, data in pairs(WeakestAurasDB.displays) do
|
|
WA.safecall(id, WA.MergeDefaults, data)
|
|
end
|
|
end
|