Pools and FrameWatcher

This commit is contained in:
Brues
2026-05-14 01:41:54 -05:00
parent c8db9a07f3
commit 73581c4ebc
3 changed files with 564 additions and 0 deletions
+2
View File
@@ -20,3 +20,5 @@ Util\EventUtil.lua
Util\ItemUtil.lua
Util\AddOnCompat.lua
Util\FunctionUtil.lua
Util\Pools.lua
Util\FrameWatcher.lua
@@ -0,0 +1,41 @@
FrameWatcher = {};
function FrameWatcher:Init()
self.pool = CreateFramePool("Frame");
self.watchedFrames = {};
end
function FrameWatcher:WatchFrame(frame, onShow, onHide)
if not self.watchedFrames[frame] then
local watcher = self.pool:Acquire();
watcher:Show(); -- watcher always shows so that it matches parent shown state
watcher:SetParent(frame);
watcher:SetScript("OnShow", function(w)
if onShow then
onShow();
end
end);
watcher:SetScript("OnHide", function(w)
if onHide then
onHide();
end
end);
self.watchedFrames[frame] = { watcher = watcher }; -- Could do multiple watchers per frame
end
end
function FrameWatcher:StopWatchingFrame(frame)
if self.watchedFrames[frame] then
local watcher = self.watchedFrames[frame].watcher;
self.watchedFrames[frame] = nil;
watcher:SetParent(nil);
watcher:SetScript("OnShow", nil);
watcher:SetScript("OnHide", nil);
self.pool:Release(watcher);
end
end
FrameWatcher:Init();
+521
View File
@@ -0,0 +1,521 @@
-- Backport of FrameXML/Pools.lua to vanilla 1.12 / Lua 5.0.
--
-- Implementation differences from the modern source:
-- - 1.12 has no taint/secure system, so the entire Secure*/Proxy
-- machinery (SecureTypes, ProxyUtil, securecallfunction,
-- CreateForbiddenFrame) is dropped. Only the Unsecured pools and
-- pool collections exist; the canonical `CreateObjectPool` /
-- `CreateFramePool` / etc. globals are aliased to them at the
-- bottom of the file.
-- - FrameUtil.SpecializeFrameWithMixins isn't a thing in 1.12; the
-- "table specialization" branch is inlined as a plain Mixin().
-- - CreateMaskTexture and CreateActor aren't in 1.12 — the
-- corresponding pool creators are kept as stubs so chunk-load of
-- consumer addons doesn't fail; they'll error at Acquire() time
-- if anything actually invokes them.
-- - Lua 5.0 has no `...` as expression; the converter mixins use
-- `unpack(arg, 1, arg.n)` to forward varargs.
-- - assertsafe / nop aren't globals in stock 1.12; defined as local
-- fallbacks (same pattern as FunctionUtil.lua).
local function nop() end
local function assertsafe(condition, msg)
if not condition then
local h = geterrorhandler and geterrorhandler()
if h then h(msg or "assertion failed!") end
end
end
local ObjectPoolBaseMixin = {};
--[[
Reserve() is not exposed on the pool to prevent the attack vector of addons having control
over the quantity of objects available to a preexisting pool.
]]--
local function Reserve(pool, capacity)
pool.capacity = capacity or math.huge;
if pool.capacity ~= math.huge then
for index = 1, pool.capacity do
pool:Acquire();
end
pool:ReleaseAll();
end
end
local function GetObjectIsInvalidMsg(object, poolOrCollection)
if poolOrCollection:DoesObjectBelongToPool(object) then
return string.format("Attempted to release inactive object '%s'", tostring(object));
else
return string.format("Attempted to release object '%s' that doesn't belong to this pool", tostring(object));
end
end
function ObjectPoolBaseMixin:Acquire()
if self:GetNumActive() == self.capacity then
return nil, false;
end
local object = self:PopInactiveObject();
local new = object == nil;
if new then
object = self:CallCreate();
--[[
While pools don't necessarily need to only contain tables, support for other types
has not been tested, and therefore isn't allowed until we can justify a use for them.
]]--
assert(type(object) == "table");
self:CallReset(object, new);
end
self:AddObject(object);
return object, new;
end
function ObjectPoolBaseMixin:Release(object, canFailToFindObject)
local active = self:IsActive(object);
--[[
If Release() is called on a pool directly from external code, then we expect
an assert if the object is not found. However, if it was called from a pool
collection, the object not being active is expected as the pool collection iterates
all the pools until it is found. A separate assert in pool collections accounts for
the case where the object was not found in any pool.
]]--
if not canFailToFindObject then
assertsafe(active, GetObjectIsInvalidMsg(object, self));
end
if active then
self:CallReset(object);
self:ReclaimObject(object);
end
return active;
end
function ObjectPoolBaseMixin:Dump()
for index, object in self:EnumerateActive() do
print(tostring(object));
end
end
local ObjectPoolMixin = CreateFromMixins(ObjectPoolBaseMixin);
function ObjectPoolMixin:Init(createFunc, resetFunc, capacity)
self.createFunc = createFunc;
self.resetFunc = resetFunc;
self.activeObjects = {};
self.inactiveObjects = {};
self.activeObjectCount = 0;
Reserve(self, capacity);
end
function ObjectPoolMixin:CallReset(object, new)
self.resetFunc(self, object, new);
end
function ObjectPoolMixin:CallCreate()
-- The pool argument 'self' is passed only for addons already reliant on it.
return self.createFunc(self);
end
function ObjectPoolMixin:PopInactiveObject()
return tremove(self.inactiveObjects);
end
function ObjectPoolMixin:AddObject(object)
local dummy = true;
self.activeObjects[object] = dummy;
self.activeObjectCount = self.activeObjectCount + 1;
end
function ObjectPoolMixin:ReclaimObject(object)
tinsert(self.inactiveObjects, object);
self.activeObjects[object] = nil;
self.activeObjectCount = self.activeObjectCount - 1;
end
function ObjectPoolMixin:ReleaseAll()
for object in pairs(self.activeObjects) do
self:Release(object);
end
end
function ObjectPoolMixin:EnumerateActive()
return pairs(self.activeObjects);
end
function ObjectPoolMixin:GetNextActive(current)
return next(self.activeObjects, current);
end
function ObjectPoolMixin:IsActive(object)
return self.activeObjects[object] ~= nil;
end
function ObjectPoolMixin:DoesObjectBelongToPool(object)
if self:IsActive(object) then
return true;
end
for index, candidate in pairs(self.inactiveObjects) do
if candidate == object then
return true;
end
end
return false;
end
function ObjectPoolMixin:GetNumActive()
return self.activeObjectCount;
end
local function GetPoolKey(template, specialization)
if specialization == nil then
return template.."nil";
end
return template..tostring(specialization);
end
local PoolCollectionBaseMixin = {};
function PoolCollectionBaseMixin:GetPool(template, specialization)
local poolKey = GetPoolKey(template, specialization);
return self:GetPoolByKey(poolKey);
end
function PoolCollectionBaseMixin:HasPool(poolKey)
return self:GetPoolByKey(poolKey) ~= nil;
end
function PoolCollectionBaseMixin:Acquire(template, specialization)
local pool = self:GetPool(template, specialization);
return pool:Acquire();
end
function PoolCollectionBaseMixin:ReleaseAllByTemplate(template, specialization)
local pool = self:GetPool(template, specialization);
if pool then
pool:ReleaseAll();
end
end
function PoolCollectionBaseMixin:EnumerateActiveByTemplate(template, specialization)
local pool = self:GetPool(template, specialization);
if pool then
return pool:EnumerateActive();
end
return nop;
end
function PoolCollectionBaseMixin:GetOrCreatePool(...)
assert(false);
end
function PoolCollectionBaseMixin:CreatePool(...)
assert(false);
end
function PoolCollectionBaseMixin:CreatePoolWithArgs(args)
local poolKey = self:CreatePoolKeyFromPoolArgs(args);
assert(not self:HasPool(poolKey));
local pool = self:CreatePoolInternal(args);
self:SetPool(poolKey, pool);
return pool;
end
function PoolCollectionBaseMixin:GetOrCreatePoolWithArgs(args)
local poolKey = self:CreatePoolKeyFromPoolArgs(args);
local pool = self:GetPoolByKey(poolKey);
local new = pool == nil;
if new then
pool = self:CreatePoolWithArgs(args);
end
return pool, new;
end
function PoolCollectionBaseMixin:Dump()
for object in self:EnumerateActive() do
print(tostring(object));
end
end
local PoolCollectionMixin = CreateFromMixins(PoolCollectionBaseMixin);
function PoolCollectionMixin:Init()
self.pools = {};
end
function PoolCollectionMixin:GetNumActive()
local total = 0;
for poolKey, pool in pairs(self.pools) do
total = total + pool:GetNumActive();
end
return total;
end
function PoolCollectionMixin:SetPool(poolKey, pool)
self.pools[poolKey] = pool;
end
function PoolCollectionMixin:GetPoolByKey(poolKey)
return self.pools[poolKey];
end
function PoolCollectionMixin:Release(object)
local canFailToFindObject = true;
for poolKey, pool in pairs(self.pools) do
if pool:Release(object, canFailToFindObject) then
return;
end
end
assertsafe(false, GetObjectIsInvalidMsg(object, self));
end
function PoolCollectionMixin:DoesObjectBelongToPool(object)
for poolKey, pool in pairs(self.pools) do
if pool:DoesObjectBelongToPool(object) then
return true;
end
end
return false;
end
function PoolCollectionMixin:ReleaseAll()
for poolKey, pool in pairs(self.pools) do
pool:ReleaseAll();
end
end
-- Warning: this function only returns the object, unlike a pool that also returns the key.
function PoolCollectionMixin:EnumerateActive()
local currentObject = nil;
local currentPoolKey, currentPool = next(self.pools, currentObject);
return function()
if currentPool then
currentObject = currentPool:GetNextActive(currentObject);
while not currentObject do
currentPoolKey, currentPool = next(self.pools, currentPoolKey)
if currentPool then
currentObject = currentPool:GetNextActive(nil);
else
break;
end
end
end
return currentObject;
end, nil;
end
function Pool_HideAndClearAnchors(pool, region)
region:Hide();
region:ClearAllPoints();
end
function ActorPool_HideAndClearModel(actorPool, actor)
actor:ClearModel();
actor:Hide();
end
--[[
In addition to a specialization being used to create separate pools for the same template, it can
be used to modify a frame after being created. On modern WoW this delegates to
FrameUtil.SpecializeFrameWithMixins (which also wires up conventional script handlers); on 1.12
we just Mixin() the table into the frame and let the consumer call SetScript() if needed.
]]--
local function ConvertSpecializationToPostCreate(specialization)
local specializationType = type(specialization);
if specializationType == "function" then
return specialization;
elseif specializationType == "table" then
local function Initializer(frame)
Mixin(frame, specialization);
end
return Initializer;
end
return nil;
end
function CreateUnsecuredRegionPoolInstance(template, createFunc, resetFunc, capacity)
local pool = CreateFromMixins(ObjectPoolMixin);
pool:Init(createFunc, resetFunc or Pool_HideAndClearAnchors, capacity);
pool.GetTemplate = function(self)
return template;
end
return pool;
end
--[[
Args are packed into a table for ease of implementation in PoolCollectionBaseMixin, which is
derived with different argument signatures. This also makes it easy to access named fields
like `parent` off the table without dealing with argument position.
]]--
local function FramePoolCollection_ArgsToTable(frameType, parent, template, resetFunc, forbidden, specialization, capacity)
return {
frameType = frameType,
parent = parent,
template = template,
resetFunc = resetFunc,
forbidden = forbidden, -- ignored on 1.12 (no CreateForbiddenFrame)
specialization = specialization,
capacity = capacity,
};
end
local FramePoolCollectionConverterMixin = {};
function FramePoolCollectionConverterMixin:CreatePoolKeyFromPoolArgs(args)
return GetPoolKey(args.template, args.specialization);
end
function FramePoolCollectionConverterMixin:GetOrCreatePool(...)
local args = FramePoolCollection_ArgsToTable(unpack(arg, 1, arg.n));
return self:GetOrCreatePoolWithArgs(args);
end
function FramePoolCollectionConverterMixin:CreatePool(...)
local args = FramePoolCollection_ArgsToTable(unpack(arg, 1, arg.n));
return self:CreatePoolWithArgs(args);
end
local FramePoolCollectionMixin = CreateFromMixins(PoolCollectionMixin, FramePoolCollectionConverterMixin);
do
local function CreateFramePoolInstance(frameType, parent, template, resetFunc, postCreate, capacity)
local function Create()
local name = nil;
local frame = CreateFrame(frameType, name, parent, template);
if postCreate then
postCreate(frame);
end
return frame;
end
return CreateUnsecuredRegionPoolInstance(template, Create, resetFunc, capacity);
end
function FramePoolCollectionMixin:CreatePoolInternal(args)
local postCreate = ConvertSpecializationToPostCreate(args.specialization);
return CreateFramePoolInstance(args.frameType, args.parent, args.template, args.resetFunc, postCreate, args.capacity);
end
end
local FontStringPoolCollectionMixin = CreateFromMixins(PoolCollectionMixin);
function FontStringPoolCollectionMixin:CreatePoolKeyFromPoolArgs(args)
return args.template;
end
local function FontStringPoolCollection_ArgsToTable(parent, layer, subLayer, template, resetFunc, capacity)
return {
parent = parent,
layer = layer,
subLayer = subLayer,
template = template,
resetFunc = resetFunc,
capacity = capacity,
};
end
function FontStringPoolCollectionMixin:GetOrCreatePool(...)
local args = FontStringPoolCollection_ArgsToTable(unpack(arg, 1, arg.n));
return self:GetOrCreatePoolWithArgs(args);
end
function FontStringPoolCollectionMixin:CreatePool(...)
local args = FontStringPoolCollection_ArgsToTable(unpack(arg, 1, arg.n));
return self:CreatePoolWithArgs(args);
end
function FontStringPoolCollectionMixin:CreatePoolInternal(args)
return CreateUnsecuredFontStringPool(args.parent, args.layer, args.subLayer, args.template, args.resetFunc, args.capacity);
end
function CreateUnsecuredObjectPool(createFunc, resetFunc, capacity)
local pool = CreateFromMixins(ObjectPoolMixin);
pool:Init(createFunc, resetFunc, capacity);
return pool;
end
function CreateUnsecuredFramePool(frameType, parent, template, resetFunc, capacity)
local function Create()
local name = nil;
return CreateFrame(frameType, name, parent, template);
end
return CreateUnsecuredRegionPoolInstance(template, Create, resetFunc, capacity);
end
function CreateUnsecuredTexturePool(parent, layer, subLayer, template, resetFunc, capacity)
local function Create()
local name = nil;
return parent:CreateTexture(name, layer, template, subLayer);
end
return CreateUnsecuredRegionPoolInstance(template, Create, resetFunc, capacity);
end
function CreateUnsecuredFontStringPool(parent, layer, subLayer, template, resetFunc, capacity)
local function Create()
local name = nil;
return parent:CreateFontString(name, layer, template, subLayer);
end
return CreateUnsecuredRegionPoolInstance(template, Create, resetFunc, capacity);
end
-- Stub: 1.12 has no CreateActor (model actors are Cataclysm+). Acquire()
-- will raise once it actually tries to call parent:CreateActor — kept so
-- that addon code merely referencing the symbol doesn't fail to load.
function CreateUnsecuredActorPool(parent, template, resetFunc, capacity)
local function Create()
local name = nil;
return parent:CreateActor(name, template);
end
return CreateUnsecuredRegionPoolInstance(template, Create, resetFunc or ActorPool_HideAndClearModel, capacity);
end
-- Stub: 1.12 has no CreateMaskTexture (mask textures are post-vanilla).
-- Same caveat as CreateUnsecuredActorPool.
function CreateUnsecuredMaskTexturePool(parent, layer, subLayer, template, resetFunc, capacity)
local function Create()
local name = nil;
return parent:CreateMaskTexture(name, layer, template, subLayer);
end
return CreateUnsecuredRegionPoolInstance(template, Create, resetFunc, capacity);
end
function CreateUnsecuredFramePoolCollection()
local poolCollection = CreateFromMixins(FramePoolCollectionMixin);
poolCollection:Init();
return poolCollection;
end
function CreateUnsecuredFontStringPoolCollection()
local poolCollection = CreateFromMixins(FontStringPoolCollectionMixin);
poolCollection:Init();
return poolCollection;
end
-- Canonical API aliases. On modern WoW these point at the Secure variants;
-- on 1.12 there's no taint system, so they all go straight to the Unsecured
-- implementations.
CreateObjectPool = CreateUnsecuredObjectPool;
CreateFramePool = CreateUnsecuredFramePool;
CreateTexturePool = CreateUnsecuredTexturePool;
CreateFontStringPool = CreateUnsecuredFontStringPool;
CreateActorPool = CreateUnsecuredActorPool;
CreateFramePoolCollection = CreateUnsecuredFramePoolCollection;
CreateFontStringPoolCollection = CreateUnsecuredFontStringPoolCollection;
CreateMaskTexturePool = CreateUnsecuredMaskTexturePool;