diff --git a/AddOns/!!!ClassicAPI/Util/AddOnCompat.lua b/AddOns/!!!ClassicAPI/Util/AddOnCompat.lua index bd3f5afd..fb1491c2 100644 --- a/AddOns/!!!ClassicAPI/Util/AddOnCompat.lua +++ b/AddOns/!!!ClassicAPI/Util/AddOnCompat.lua @@ -47,10 +47,6 @@ if C_AddOns.DoesAddOnExist('pfUI') then end) end -if C_AddOns.DoesAddOnExist("SpecialTalentUI") then - EventUtil.ContinueOnAddOnLoaded("SpecialTalentUI", CAPI_ApplyStandardColorGlobals) -end - -- ShaguTweaks libpredict register's TBC events that ClassicAPI backports. if C_AddOns.DoesAddOnExist("ShaguTweaks") then EventUtil.ContinueOnAddOnLoaded("ShaguTweaks", function() @@ -244,3 +240,18 @@ EventRegistry:RegisterFrameEventAndCallback("ADDON_LOADED", EventRegistry:RegisterFrameEventAndCallback("PLAYER_LOGIN", EnsureCompostErasesInPlace) EnsureCompostErasesInPlace() + +-- Some addons carry a copy of Blizzard's own color definitions -- a plain +-- `NORMAL_FONT_COLOR = {r=1.0, g=0.82, b=0}` and its friends -- and assign +-- them at file scope. That takes ColorMixin off those globals for every addon +-- that loads later, which is what breaks pfUI's who list when it calls +-- `NORMAL_FONT_COLOR:GetRGB()` (brues-code/pfUI#56). +-- +-- Re-apply after each addon loads, so a clobbered color is repaired before the +-- next addon reads it. This also covers an addon loaded on demand mid-session. +-- The pass mixes the methods back into the table that is there, and costs one +-- lookup per color when nothing is broken. +EventRegistry:RegisterFrameEventAndCallback("ADDON_LOADED", + CAPI_ApplyStandardColorGlobals) +EventRegistry:RegisterFrameEventAndCallback("PLAYER_LOGIN", + CAPI_ApplyStandardColorGlobals) diff --git a/AddOns/!!!ClassicAPI/Util/Color.lua b/AddOns/!!!ClassicAPI/Util/Color.lua index 6f290871..1f54ab6b 100644 --- a/AddOns/!!!ClassicAPI/Util/Color.lua +++ b/AddOns/!!!ClassicAPI/Util/Color.lua @@ -81,18 +81,89 @@ function ColorMixin:WrapTextInColorTableCode(text) return WrapTextInColorCode(text, self:GenerateHexColor()) end -for _, v in pairs(ITEM_QUALITY_COLORS) do - v.color = CreateColor(v.r, v.g, v.b, 1) +-- Publishes the standard color globals (NORMAL_FONT_COLOR and friends) as +-- ColorMixin objects, the way Blizzard_SharedXMLBase/Color.lua does. +-- +-- Runs at load and again after every addon loads (see Util/AddOnCompat.lua). +-- An addon that carries a copy of Blizzard's own definition -- a plain +-- `NORMAL_FONT_COLOR = {r=1.0, g=0.82, b=0}` -- assigns it over ours at file +-- scope, and every addon that loads after it then finds a color with no +-- methods. A later pass mixes ColorMixin INTO the table that is there instead +-- of replacing it, so the values that addon chose stay, and each reference it +-- gave out gets the methods too. +-- +-- Only a color that is absent or has lost its methods is touched. A tag that +-- holds something other than a color table belongs to some other addon, so it +-- is left alone. A `_CODE` string that is already set is never rewritten: +-- FrameXML writes those together with the values they go with. +local standardColors + +-- True for a table that carries r/g/b numbers. +local function HasRGB(value) + return type(value) == "table" + and type(value.r) == "number" + and type(value.g) == "number" + and type(value.b) == "number" end -function CAPI_ApplyStandardColorGlobals() - local envTbl = _G - for _, dbColor in ipairs(C_UIColor.GetColors()) do - if not envTbl[dbColor.baseTag] or not envTbl[dbColor.baseTag].GetRGB then - local color = CreateColor(dbColor.color.r, dbColor.color.g, dbColor.color.b, dbColor.color.a) - envTbl[dbColor.baseTag] = color - envTbl[dbColor.baseTag.."_CODE"] = color:GenerateHexColorMarkup() +-- True for a color table that still needs the mixin. +local function IsPlainColorTable(value) + return HasRGB(value) and not value.GetRGB +end + +-- ITEM_QUALITY_COLORS is the same story with one more level: FrameXML builds +-- each entry as a plain {r, g, b, hex} table, and the `color` object on it is +-- ours. An addon that carries its own copy of the table takes those objects +-- with it, so repair the entries on the same pass. Keys run from -1, so this +-- walks the table with pairs. +local function ApplyItemQualityColors() + if type(ITEM_QUALITY_COLORS) ~= "table" then return end + + for _, quality in pairs(ITEM_QUALITY_COLORS) do + if type(quality) == "table" then + if IsPlainColorTable(quality.color) then + quality.color = Mixin(quality.color, ColorMixin) + quality.color.a = quality.color.a or 1 + elseif quality.color == nil and HasRGB(quality) then + quality.color = CreateColor(quality.r, quality.g, quality.b, 1) + end end end end + +function CAPI_ApplyStandardColorGlobals() + -- `C_UIColor.GetColors()` makes a color object for each of its 187 rows, + -- so keep the values from the first call. Each later pass is then one + -- lookup per tag. + if not standardColors then + standardColors = {} + for _, dbColor in ipairs(C_UIColor.GetColors()) do + table.insert(standardColors, { + tag = dbColor.baseTag, + r = dbColor.color.r, + g = dbColor.color.g, + b = dbColor.color.b, + a = dbColor.color.a, + }) + end + end + + for _, entry in ipairs(standardColors) do + local current = _G[entry.tag] + local color + if current == nil then + color = CreateColor(entry.r, entry.g, entry.b, entry.a) + _G[entry.tag] = color + elseif IsPlainColorTable(current) then + color = Mixin(current, ColorMixin) + color.a = color.a or 1 + end + + if color and _G[entry.tag.."_CODE"] == nil then + _G[entry.tag.."_CODE"] = color:GenerateHexColorMarkup() + end + end + + ApplyItemQualityColors() +end CAPI_ApplyStandardColorGlobals()