mirror of
https://github.com/fuffc/WeakestAuras.git
synced 2026-11-17 16:34:38 +00:00
WeakestAuras 0.11.0 Threat - The Threat trigger no longer needs TWThreat installed. WeakestAuras asks the server for the threat table itself, and the trigger is now just called "Threat". - Where another threat meter on your client is already asking, WeakestAuras stays quiet and reads its answers instead of adding a second request. - Threat updates as soon as you switch target or pull, rather than on the next tick of a meter's timer. - The trigger exposes the whole table: Aggro Race (%), Threat Until Swap, Threat Difference, Own Threat, Players Listed, Tanking, In Melee Range, Aggro Holder and their threat, Rival and their threat, and Target Name -- all usable in text replacements and conditions. - Threat is only available for your current target, and not for normal mobs. The server answers no other request. Per-aura warnings - An aura that fails to compile, or that errors while running, is marked on its row in the aura list and named on its Info tab, instead of only printing to chat once. - Auras that play a sound or use text-to-speech carry a mark of their own, so it is visible which of your auras will make noise. - A trigger naming a spell that could not be resolved, a corrupt custom option, and an anchoring loop are each reported the same way. - Hovering an aura's warning icon lists every message on it. Sub-region anchoring - Text, borders and glows on an Icon can be anchored to any of its 27 points. Icons previously offered nothing but "Whole region". - A sub-region's anchor is now two controls: which part of the aura it attaches to, and which of its own points attaches there. - WeakAuras2 auras carrying a combined anchor value are converted on import, and auras you imported before this release are converted when they load.
1052 lines
41 KiB
Lua
1052 lines
41 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
|
|
|
|
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).
|
|
-- `internal` types are never listed: `fallback` exists to stand in for a region
|
|
-- this addon does not have, so offering it as something to create or convert to
|
|
-- would be offering the absence itself.
|
|
function WA.RegionTypeList(onlyGroups)
|
|
local list = {}
|
|
for name, spec in pairs(WA.regionTypes) do
|
|
if not spec.internal and (onlyGroups == nil or (spec.isGroup == true) == onlyGroups) then
|
|
table.insert(list, name)
|
|
end
|
|
end
|
|
table.sort(list)
|
|
return list
|
|
end
|
|
|
|
-- The region spec that will actually build this display: its own type's, or the
|
|
-- `fallback` type's when the addon has no such region. An aura can name a
|
|
-- regionType we do not have -- upstream ships progresstexture, model and
|
|
-- stopmotion, all of which exist in the wild -- and nothing rejects one on
|
|
-- import, so without this it gets a row in the list and is then simply never
|
|
-- drawn, with nothing on screen to say why.
|
|
--
|
|
-- Resolved wherever a region is built rather than rewritten at import, so an aura
|
|
-- whose type we later gain starts working on its own, with no second migration.
|
|
function WA.RegionSpecFor(data)
|
|
local spec = data and WA.regionTypes[data.regionType]
|
|
if spec then
|
|
if data.regionType == "progresstexture"
|
|
and (data.orientation == "CLOCKWISE" or data.orientation == "ANTICLOCKWISE") then
|
|
return WA.regionTypes["fallback"]
|
|
end
|
|
return spec
|
|
end
|
|
return WA.regionTypes["fallback"]
|
|
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
|
|
|
|
-- A texture value this client can actually draw, or nil for one it cannot --
|
|
-- every caller already has a placeholder for nil, so an unusable value falls
|
|
-- back to it instead of painting the engine's missing-texture block.
|
|
--
|
|
-- Two forms reach us from a WeakAuras export and neither is a file here:
|
|
--
|
|
-- * A **fileID** (a bare number, e.g. 135274). Modern clients keep a numeric
|
|
-- handle per texture and `SetTexture` accepts it; this one has no such table
|
|
-- and nothing can map it back to a path. 125 of the 160 manual icons in the
|
|
-- corpus are fileIDs, so this is the common case, not an edge one.
|
|
-- * An **atlas name** (`Legionfall_BarSpark`, `GarrMission_EncounterBar-Spark`).
|
|
-- Atlases are a retail concept with no 1.12 equivalent, and they are
|
|
-- recognisable by having no path separator -- a real texture path here always
|
|
-- has one.
|
|
--
|
|
-- A path we *can* form may still be missing (someone else's addon folder), and
|
|
-- nothing offline can tell: `SetTexture` reports nothing and `GetTexture` hands
|
|
-- back whatever string it was given. That case still draws the block.
|
|
function WA.DrawableTexture(value)
|
|
if type(value) == "number" then return nil end
|
|
if type(value) ~= "string" or value == "" then return nil end
|
|
if not string.find(value, "\\", 1, true) and not string.find(value, "/", 1, true) then
|
|
return nil
|
|
end
|
|
return value
|
|
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 WA.DrawableTexture(data.displayIcon)
|
|
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)
|
|
icon = WA.DrawableTexture(icon)
|
|
if icon then return icon end
|
|
end
|
|
end
|
|
return WA.DrawableTexture(data.displayIcon)
|
|
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
|
|
|
|
local function renameField(target, oldKey, newKey)
|
|
if target[oldKey] ~= nil then
|
|
target[newKey] = target[oldKey]
|
|
target[oldKey] = nil
|
|
end
|
|
end
|
|
|
|
local TEXT_REGION_RENAMES = {
|
|
text_font = "font",
|
|
text_size = "fontSize",
|
|
text_flags = "outline",
|
|
text_color = "color",
|
|
text_justifyH = "justify",
|
|
text_justifyV = "justifyV",
|
|
text_spacing = "spacing",
|
|
text_shadowColor = "shadowColor",
|
|
text_shadowX = "shadowXOffset",
|
|
text_shadowY = "shadowYOffset",
|
|
}
|
|
local SUBTEXT_RENAMES = {
|
|
text_size = "text_fontSize",
|
|
text_flags = "text_fontType",
|
|
text_justifyH = "text_justify",
|
|
text_shadowX = "text_shadowXOffset",
|
|
text_shadowY = "text_shadowYOffset",
|
|
text_anchorPoint = "anchor_point",
|
|
text_x = "anchorXOffset",
|
|
text_y = "anchorYOffset",
|
|
}
|
|
|
|
local function migrateConditionProperties(data)
|
|
local conditions = data.conditions or {}
|
|
for i = 1, table.getn(conditions) do
|
|
local changes = conditions[i].changes or {}
|
|
for j = 1, table.getn(changes) do
|
|
local property = changes[j].property
|
|
if property == "text_size" then
|
|
changes[j].property = "fontSize"
|
|
elseif property == "text_color" then
|
|
changes[j].property = "color"
|
|
else
|
|
local _, _, prefix, suffix = string.find(property or "", "^(sub%.[0-9]+%.)(.*)$")
|
|
if suffix == "text_size" then
|
|
changes[j].property = prefix .. "text_fontSize"
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- A sub-region imported from upstream before the combined anchor was split
|
|
-- carries the anchored part where a bare point belongs ("OUTER_TOPLEFT"), which
|
|
-- SetPoint rejects outright.
|
|
local function migrateSchemaV4(data)
|
|
local proto = WA.regionPrototype
|
|
for i = 1, table.getn(data.subRegions or {}) do
|
|
local subData = data.subRegions[i]
|
|
local anchor = subData and subData.anchor_point
|
|
if type(anchor) == "string" and not proto.IsAnchorPoint(anchor) then
|
|
local point = proto.ResolveAnchorPoint(anchor, "CENTER")
|
|
subData.anchor_target = subData.anchor_target or anchor
|
|
subData.anchor_point = point
|
|
if not proto.IsAnchorPoint(subData.self_point) then
|
|
subData.self_point = proto.AutoSelfPoint(anchor, point, data.regionType)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function migrateSchemaV3(data)
|
|
if data.regionType == "text" then
|
|
for oldKey, newKey in pairs(TEXT_REGION_RENAMES) do
|
|
renameField(data, oldKey, newKey)
|
|
end
|
|
end
|
|
for i = 1, table.getn(data.subRegions or {}) do
|
|
local subData = data.subRegions[i]
|
|
if subData then
|
|
for oldKey, newKey in pairs(SUBTEXT_RENAMES) do
|
|
renameField(subData, oldKey, newKey)
|
|
end
|
|
if subData.tick_placement ~= nil then
|
|
subData.tick_placements = { subData.tick_placement }
|
|
subData.tick_placement = nil
|
|
end
|
|
end
|
|
end
|
|
if data.regionType == "progresstexture" then
|
|
renameField(data, "cropX", "crop_x")
|
|
renameField(data, "cropY", "crop_y")
|
|
renameField(data, "userX", "user_x")
|
|
renameField(data, "userY", "user_y")
|
|
end
|
|
migrateConditionProperties(data)
|
|
end
|
|
|
|
-- Fills in missing fields from the aura's regionType/trigger.type defaults, and
|
|
-- migrates saved data through the local schema versions (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.
|
|
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.untrigger = entry.untrigger 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 {}
|
|
data.authorOptions = data.authorOptions or {}
|
|
data.config = data.config or {}
|
|
WA.ValidateUserConfig(data)
|
|
data.actions = data.actions or {}
|
|
data.actions.init = data.actions.init or {}
|
|
data.actions.start = data.actions.start or {}
|
|
data.actions.finish = data.actions.finish or {}
|
|
data.animation = data.animation or {}
|
|
data.animation.start = data.animation.start or { type = "none" }
|
|
data.animation.main = data.animation.main or { type = "none" }
|
|
data.animation.finish = data.animation.finish or { type = "none" }
|
|
data.animation.start.duration_type = data.animation.start.duration_type or "seconds"
|
|
data.animation.main.duration_type = data.animation.main.duration_type or "seconds"
|
|
data.animation.finish.duration_type = data.animation.finish.duration_type or "seconds"
|
|
|
|
-- 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
|
|
|
|
if data.internalVersion < 3 then
|
|
migrateSchemaV3(data)
|
|
data.internalVersion = 3
|
|
end
|
|
|
|
if data.internalVersion < 4 then
|
|
migrateSchemaV4(data)
|
|
data.internalVersion = 4
|
|
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, RunConditions evaluates it
|
|
-- against the just-applied states, and ReleaseConditionsForClone discards
|
|
-- activation/timer bookkeeping when a pooled clone leaves a display. No-ops
|
|
-- until Conditions.lua loads, so the state machine 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
|
|
function WA.ReleaseConditionsForClone(uid, cloneId) 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"
|
|
local spec = WA.regionTypes[regionType]
|
|
if not spec or spec.internal 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
|
|
for _, other in pairs(WeakestAurasDB.displays) do
|
|
if other.anchorFrameType == "SELECTFRAME"
|
|
and other.anchorFrameFrame == "WeakestAuras:" .. id then
|
|
other.anchorFrameFrame = nil
|
|
other.anchorFrameType = "UIPARENT"
|
|
WA.Add(other, true)
|
|
end
|
|
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)
|
|
if WA.ClearWarningsFor then WA.ClearWarningsFor(data.uid) end
|
|
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
|
|
local dependants = {}
|
|
for _, other in pairs(WeakestAurasDB.displays) do
|
|
if other.anchorFrameType == "SELECTFRAME"
|
|
and other.anchorFrameFrame == "WeakestAuras:" .. id then
|
|
table.insert(dependants, other)
|
|
end
|
|
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)
|
|
for i = 1, table.getn(dependants) do
|
|
local other = dependants[i]
|
|
other.anchorFrameFrame = "WeakestAuras:" .. newId
|
|
WA.Add(other, true)
|
|
end
|
|
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
|