Files
DucielandClaude Opus 5.5 1f6e8540ea Snapshot of the installed OctoWoW BigWigs addon
Full state of the live install: prodigeomix fork content plus local
OctoWoW patches (MC/Onyxia/ZG/Karazhan timers, Golemagg, Thaurissan,
aura-scan perf, world markers), and the BWL changes from raid feedback:
- Razorgore: exact egg count via SuperWoW cast events, count synced
- Firemaw: Flame Buffet timer on by default, retimed from logs
- Blackwing Alchemist: assist marking, no Skull/Cross or mob marks,
  mark follows the fire chain
- Wyrmguard/Overseer: vulnerability read from the buff, one bar per mob
  with its raid mark and click-to-target
- Bars: BigWigs_SetBarRaidMark event to show a raid mark beside a bar

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 16:57:02 +01:00

1586 lines
50 KiB
Lua

assert(BigWigs, "BigWigs not found!")
------------------------------
-- Are you local? --
------------------------------
local L = AceLibrary("AceLocale-2.2"):new("BigWigsBars")
local paint = AceLibrary("PaintChips-2.0")
local minscale, maxscale = 0.25, 2
local candybar = AceLibrary("CandyBar-2.2")
local surface = AceLibrary("Surface-1.0")
local count = 1
local new, del
do
local cache = setmetatable({}, { __mode = "k" })
function new()
local t = next(cache)
if t then
cache[t] = nil
return t
else
return {}
end
end
function del(t)
if not t then
return nil
end
for k in pairs(t) do
t[k] = nil
end
cache[t] = true
return nil
end
end
----------------------------
-- Localization --
----------------------------
L:RegisterTranslations("enUS", function()
return {
["Bars"] = true,
["bars"] = true,
["Options for the timer bars."] = true,
["Show the bar anchor frame."] = true,
["Set the bar scale."] = true,
["Group upwards"] = true,
["Toggle bars grow upwards/downwards from anchor."] = true,
["Timer bars"] = true,
["Show anchor"] = true,
["Grow bars upwards"] = true,
["Scale"] = true,
["Bar scale"] = true,
["Bars now grow %2$s"] = true,
["Scale is set to %2$s"] = true,
["Up"] = true,
["Down"] = true,
["Test"] = "Start/Stop Test",
["Close"] = true,
["Texture"] = true,
["Set the texture for the timerbars."] = true,
["Reset position"] = true,
["Reset the anchor position, moving it to the center of your screen."] = true,
["Reverse"] = true,
["Toggles if bars are reversed (fill up instead of emptying)."] = true,
["Emphasize"] = true,
["Emphasize bars that are close to completion (<10sec). Also note that bars started at less than 15 seconds initially will be emphasized right away."] = true,
["Enable"] = true,
["Enables emphasizing bars."] = true,
["Flash"] = true,
["Flashes the background red for bars that are emphasized."] = true,
["Move"] = true,
["Move bars that are emphasized to a second anchor."] = true,
["Set the scale for emphasized bars."] = true,
["Emphasize Bars"] = true,
["Enable IntervalBars"] = true,
["Keep timers visible untill the timed event happens"] = true,
["HP"] = true,
["Mana"] = true,
["dead"] = true,
}
end)
L:RegisterTranslations("deDE", function()
return {
["Bars"] = "Anzeigebalken",
["bars"] = "balken",
["Options for the timer bars."] = "Optionen für die Timer Anzeigebalken.",
["Show the bar anchor frame."] = "Verankerung der Anzeigebalken anzeigen.",
["Set the bar scale."] = "Skalierung der Anzeigebalken wählen.",
["Group upwards"] = "Nach oben fortsetzen",
["Toggle bars grow upwards/downwards from anchor."] = "Anzeigebalken von der Verankerung aus nach oben/unten fortsetzen.",
["Timer bars"] = "Timer Anzeigebalken",
["Show anchor"] = "Verankerung anzeigen",
["Grow bars upwards"] = "Anzeigebalken nach oben fortsetzen",
["Scale"] = "Skalierung",
["Bar scale"] = "Anzeigebalken Skalierung",
["Bars now grow %2$s"] = "Anzeigebalken werden nun fortgesetzt nach: %2$s",
["Scale is set to %2$s"] = "Skalierung jetzt: %2$s",
["Up"] = "oben",
["Down"] = "unten",
["Test"] = "Start/Stop Test",
["Close"] = "Schlie\195\159en",
["Texture"] = "Textur",
["Set the texture for the timerbars."] = "Textur der Anzeigebalken wählen.",
["Reset position"] = "Position zurücksetzen",
["Reset the anchor position, moving it to the center of your screen."] = "Die Verankerungsposition zurücksetzen (bewegt die Balken zur Mitte deines Interfaces).",
["Reverse"] = "Umkehren",
["Toggles if bars are reversed (fill up instead of emptying)."] = "Legt fest, ob sich die Anzeigebalken füllen oder leeren sollen.",
["Emphasize"] = "Hervorheben",
["Emphasize bars that are close to completion (<10sec). Also note that bars started at less than 15 seconds initially will be emphasized right away."] = "Anzeigebalken hervorheben die kurz vor Abschluss sind (<10sek). Anzeigebalken die mit einem Timer von weniger als 15 Sekunden starten werden von Beginn weg als hervorgehobene Balken dargestellt.",
["Enable"] = "Aktivieren",
["Enables emphasizing bars."] = "Aktiviert hervorgehobene Anzeigebalken.",
["Flash"] = "Blinken",
["Flashes the background red for bars that are emphasized."] = "Lässt den Hintergrund von hervorgehobenen Anzeigebalken rot blinken.",
["Move"] = "Bewegen",
["Move bars that are emphasized to a second anchor."] = "Hervorgehobene Anzeigebalken zu einem zweiten Ankerpunkt bewegen.",
["Set the scale for emphasized bars."] = "Die Skalierung für hervorgehobene Anzeigebalken festlegen.",
["Emphasize Bars"] = "Hervorgehobene Balken",
["HP"] = "HP",
["Mana"] = "Mana",
["dead"] = "tot",
}
end)
L:RegisterTranslations("esES", function()
return {
["Bars"] = "Barras",
["bars"] = "bars",
["Options for the timer bars."] = "Opciones para las barras temporizadoras",
["Show the bar anchor frame."] = "Muestra el marco de ancla de la barra",
["Set the bar scale."] = "Define la escala de la barra",
["Group upwards"] = "Grupo hacia arriba",
["Toggle bars grow upwards/downwards from anchor."] = "Alterna que las barras crecen hacia arriba/abajo de la ancla",
["Timer bars"] = "Barras Temporizadoras",
["Show anchor"] = "Mostrar Ancla",
["Grow bars upwards"] = "Crecer las barras hacia arriba",
["Scale"] = "Escala",
["Bar scale"] = "Escala de la barra",
["Bars now grow %2$s"] = "Barras crecen %2$s",
["Scale is set to %2$s"] = "Escala define a %2$s",
["Up"] = "Arriba",
["Down"] = "Abajo",
["Test"] = "Start/Stop Test",
["Close"] = "Cerrar",
["Texture"] = "Textura",
["Set the texture for the timerbars."] = "Define la textura para las barras temporizadoras",
["Reset position"] = "Restablecer posición",
["Reset the anchor position, moving it to the center of your screen."] = "Restablece la posición de la ancla al centro de la pantalla",
["Reverse"] = "Revertir",
["Toggles if bars are reversed (fill up instead of emptying)."] = "Alterna si las barras están revertidas",
["Emphasize"] = "Alerta",
["Emphasize bars that are close to completion (<10sec). Also note that bars started at less than 15 seconds initially will be emphasized right away."] = "Barras de alerta que casi están completas (<10seg). También nota que las barras que empiezan a menos que 15 segundos estarán enfatizadas primera",
["Enable"] = "Activar",
["Enables emphasizing bars."] = "Activa las barras de alerta",
["Flash"] = "Brillo",
["Flashes the background red for bars that are emphasized."] = "Brilla al fondo el color rojo para las barras que están enfatizadas",
["Move"] = "Mover",
["Move bars that are emphasized to a second anchor."] = "Mueve las barras que están enfatizadas a la ancla segunda",
["Set the scale for emphasized bars."] = "Define la escala para las barras de alerta",
["Emphasize Bars"] = "Barras de Alerta",
["Enable IntervalBars"] = "Activar las Barras de Intervalo",
["Keep timers visible untill the timed event happens"] = "Se queda visibles los temporizadores hasta que un evento medido occura",
["HP"] = "HP",
["Mana"] = "Mana",
["dead"] = "muerto",
}
end)
----------------------------------
-- Module Declaration --
----------------------------------
BigWigsBars = BigWigs:NewModule(L["Bars"])
BigWigsBars.revision = tonumber(string.sub("$Revision: 20004 $", 12, -3))
BigWigsBars.frames = {}
BigWigsBars.defaultDB = {
growup = false,
scale = 1.0,
texture = "BantoBar",
posx = nil,
posy = nil,
emphasize = true,
emphasizeMove = true,
emphasizeFlash = true,
emphasizePosX = nil,
emphasizePosY = nil,
emphasizeScale = 1.2,
emphasizeGrowup = false,
duration = 0.5,
width = nil,
height = nil,
reverse = nil,
intervalbar = true,
}
BigWigsBars.consoleCmd = L["bars"]
local function getOption(key)
if key == "anchor" then
return BigWigsBars.frames.anchor and BigWigsBars.frames.anchor:IsShown()
else
return BigWigsBars.db.profile[key]
end
end
local function setOption(key, value)
if key == "anchor" then
if value then
BigWigsBars:BigWigs_ShowAnchors()
else
BigWigsBars:BigWigs_HideAnchors()
end
else
BigWigsBars.db.profile[key] = value
end
if key == "growup" and BigWigsBars.frames.anchor then
BigWigsBars:SetCandyBarGroupPoint("BigWigsGroup", value and "BOTTOM" or "TOP", BigWigsBars.frames.anchor, value and "TOP" or "BOTTOM", 0, 0)
BigWigsBars:SetCandyBarGroupGrowth("BigWigsGroup", value)
elseif key == "emphasizeGrowup" and BigWigsBars.frames.emphasizeAnchor then
BigWigsBars:SetCandyBarGroupPoint("BigWigsEmphasizedGroup", value and "BOTTOM" or "TOP", BigWigsBars.frames.emphasizeAnchor, value and "TOP" or "BOTTOM", 0, 0)
BigWigsBars:SetCandyBarGroupGrowth("BigWigsEmphasizedGroup", value)
end
end
local function shouldDisableEmphasizeOption()
return not BigWigsBars.db.profile.emphasize
end
BigWigsBars.consoleOptions = {
type = "group",
name = L["Bars"],
desc = L["Options for the timer bars."],
args = {
anchor = {
type = "execute",
name = L["Show anchor"],
desc = L["Show the bar anchor frame."],
order = 1,
func = function()
BigWigsBars:BigWigs_ShowAnchors()
end,
},
reset = {
type = "execute",
name = L["Reset position"],
desc = L["Reset the anchor position, moving it to the center of your screen."],
order = 2,
func = function()
BigWigsBars:ResetAnchor()
end,
},
spacer = {
type = "header",
name = " ",
order = 10,
},
intervalbar = {
type = "toggle",
name = L["Enable IntervalBars"],
desc = L["Keep timers visible untill the timed event happens"],
order = 12,
get = function()
return BigWigsBars.db.profile.intervalbar
end,
set = function(v)
BigWigsBars.db.profile.intervalbar = v
end,
},
growup = {
type = "toggle",
name = L["Grow bars upwards"],
desc = L["Toggle bars grow upwards/downwards from anchor."],
order = 13,
get = function()
return BigWigsBars.db.profile.growup
end,
set = function(v)
BigWigsBars.db.profile.growup = v
BigWigsBars:SetCandyBarGroupPoint("BigWigsGroup", v and "BOTTOM" or "TOP", BigWigsBars.frames.anchor, v and "TOP" or "BOTTOM", 0, 0)
BigWigsBars:SetCandyBarGroupGrowth("BigWigsGroup", v)
end,
message = L["Bars now grow %2$s"],
current = L["Bars now grow %2$s"],
map = { [true] = L["Up"], [false] = L["Down"] },
},
reverse = {
type = "toggle",
name = L["Reverse"],
desc = L["Toggles if bars are reversed (fill up instead of emptying)."],
order = 14,
get = function()
return BigWigsBars.db.profile.reverse
end,
set = function(v)
BigWigsBars.db.profile.reverse = v
end,
--passValue = "reverse",
},
scale = {
type = "range",
name = L["Bar scale"],
desc = L["Set the bar scale."],
order = 15,
min = 0.2,
max = 2.0,
step = 0.1,
get = function()
return BigWigsBars.db.profile.scale
end,
set = function(v)
BigWigsBars.db.profile.scale = v
end,
},
texture = {
type = "text",
name = L["Texture"],
desc = L["Set the texture for the timerbars."],
order = 16,
get = function()
return BigWigsBars.db.profile.texture
end,
set = function(v)
BigWigsBars.db.profile.texture = v
end,
validate = surface:List(),
},
spacer2 = {
type = "header",
name = " ",
order = 20,
},
emphasize = {
type = "group",
name = L["Emphasize"],
desc = L["Emphasize bars that are close to completion (<10sec). Also note that bars started at less than 15 seconds initially will be emphasized right away."],
order = 21,
args = {
emphasize = {
type = "toggle",
name = L["Enable"],
desc = L["Enables emphasizing bars."],
get = function()
return BigWigsBars.db.profile.emphasize
end,
set = function(v)
BigWigsBars.db.profile.emphasize = v
end,
order = 1,
},
growup = {
type = "toggle",
name = L["Grow bars upwards"],
desc = L["Toggle bars grow upwards/downwards from anchor."],
order = 2,
get = function()
return BigWigsBars.db.profile.emphasizeGrowup
end,
set = function(v)
BigWigsBars.db.profile.emphasizeGrowup = v
BigWigsBars:SetCandyBarGroupPoint(BigWigsBars.frames.emphasizeAnchor.candyBarGroupId, v and "BOTTOM" or "TOP", BigWigsBars.frames.emphasizeAnchor, v and "TOP" or "BOTTOM", 0, 0)
BigWigsBars:SetCandyBarGroupGrowth(BigWigsBars.frames.emphasizeAnchor.candyBarGroupId, v)
end,
disabled = shouldDisableEmphasizeOption,
},
flash = {
type = "toggle",
name = L["Flash"],
desc = L["Flashes the background red for bars that are emphasized."],
get = function()
return BigWigsBars.db.profile.emphasizeFlash
end,
set = function(v)
BigWigsBars.db.profile.emphasizeFlash = v
end,
disabled = shouldDisableEmphasizeOption,
order = 3,
},
move = {
type = "toggle",
name = L["Move"],
desc = L["Move bars that are emphasized to a second anchor."],
get = function()
return BigWigsBars.db.profile.emphasizeMove
end,
set = function(v)
BigWigsBars.db.profile.emphasizeMove = v
end,
disabled = shouldDisableEmphasizeOption,
order = 4,
},
scale = {
type = "range",
name = L["Bar scale"],
desc = L["Set the scale for emphasized bars."],
min = 0.2,
max = 2.0,
step = 0.1,
get = function()
return BigWigsBars.db.profile.emphasizeScale
end,
set = function(v)
BigWigsBars.db.profile.emphasizeScale = v
end,
disabled = function()
if not BigWigsBars.db.profile.emphasizeMove then
return true
end
return shouldDisableEmphasizeOption()
end,
order = 5,
},
},
},
},
}
------------------------------
-- Initialization --
------------------------------
function BigWigsBars:OnRegister()
self.consoleOptions.args.texture.validate = surface:List()
self:RegisterEvent("Surface_Registered", function()
self.consoleOptions.args.texture.validate = surface:List()
end)
end
function BigWigsBars:OnEnable()
if not surface:Fetch(self.db.profile.texture) then
self.db.profile.texture = "BantoBar"
end
self.frames = {}
self:SetupFrames()
self:SetupFrames(true)
self:RegisterEvent("BigWigs_ShowAnchors")
self:RegisterEvent("BigWigs_HideAnchors")
self:RegisterEvent("BigWigs_StartBar")
self:RegisterEvent("BigWigs_StopBar")
self:RegisterEvent("BigWigs_UpdateBar")
self:RegisterEvent("BigWigs_SetBar")
self:RegisterEvent("BigWigs_ColorBar")
self:RegisterEvent("BigWigs_SetBarRaidMark")
self:RegisterEvent("BigWigs_StartCounterBar")
self:RegisterEvent("BigWigs_StopCounterBar")
self:RegisterEvent("BigWigs_SetCounterBar")
self:RegisterEvent("BigWigs_StartHPBar")
self:RegisterEvent("BigWigs_StopHPBar")
self:RegisterEvent("BigWigs_SetHPBar")
self:RegisterEvent("BigWigs_StartIntervalBar")
self:RegisterEvent("BigWigs_StartMonitorBar")
if not self:IsEventRegistered("Surface_Registered") then
self:RegisterEvent("Surface_Registered", function()
self.consoleOptions.args[L["Texture"]].validate = surface:List()
end)
end
if self.frames.emphasizeAnchor then
self.frames.emphasizeAnchor.flashTimers = new()
self.frames.emphasizeAnchor.emphasizeTimers = new()
self.frames.emphasizeAnchor.moduleBars = new()
self.frames.emphasizeAnchor.movingBars = new()
end
end
function BigWigsBars:OnDisable()
self:BigWigs_HideAnchors()
if self.frames and self.frames.emphasizeAnchor then
self.frames.emphasizeAnchor.flashTimers = del(self.frames.emphasizeAnchor.flashTimers)
self.frames.emphasizeAnchor.emphasizeTimers = del(self.frames.emphasizeAnchor.emphasizeTimers)
self.frames.emphasizeAnchor.moduleBars = del(self.frames.emphasizeAnchor.moduleBars)
self.frames.emphasizeAnchor.movingBars = del(self.frames.emphasizeAnchor.movingBars)
end
end
------------------------------
-- Event Handlers --
------------------------------
local barCache = {-- [i] = {text, module}
}
function BigWigsBars:Disable(module)
if not self.frames then return end
if self.frames.emphasizeAnchor and self.frames.emphasizeAnchor.moduleBars and self.frames.emphasizeAnchor.moduleBars[module] then
if self.frames.emphasizeAnchor.emphasizeTimers[module] then
for k, v in pairs(self.frames.emphasizeAnchor.emphasizeTimers[module]) do
self:CancelScheduledEvent(v)
self.frames.emphasizeAnchor.emphasizeTimers[module][k] = nil
end
end
if self.frames.emphasizeAnchor.flashTimers[module] then
for k, v in pairs(self.frames.emphasizeAnchor.flashTimers[module]) do
self:CancelScheduledEvent(v)
self.frames.emphasizeAnchor.flashTimers[module][k] = nil
end
end
for k in pairs(self.frames.emphasizeAnchor.moduleBars[module]) do
if self.frames.emphasizeAnchor.movingBars[k] then
self.frames.emphasizeAnchor.movingBars[k] = del(self.frames.emphasizeAnchor.movingBars[k])
end
self:UnregisterCandyBar(k)
self.frames.emphasizeAnchor.moduleBars[module][k] = nil
end
if not next(self.frames.emphasizeAnchor.movingBars) then
self:CancelScheduledEvent("BigWigsBarMover")
end
else
for i = table.getn(barCache), 1, -1 do
if barCache[i] and barCache[i][2] == module then
BigWigsBars:BigWigs_StopBar(barCache[i][2], barCache[i][1])
tremove(barCache, i)
end
end
--barCache = {}
end
end
function BigWigsBars:Ace2_AddonDisabled(module)
BigWigsBars:Disable(module)
end
function BigWigsBars:BigWigs_ShowAnchors()
if not self.frames then
self.frames = {}
end
if not self.frames.anchor then
self:SetupFrames()
end
self.frames.anchor:Show()
if self.db.profile.emphasize and self.db.profile.emphasizeMove then
if not self.frames.emphasizeAnchor then
self:SetupFrames(true)
end
self.frames.emphasizeAnchor:Show()
end
end
function BigWigsBars:BigWigs_HideAnchors()
if not self.frames or not self.frames.anchor then
return
end
self.frames.anchor:Hide()
if self.frames.emphasizeAnchor then
self.frames.emphasizeAnchor:Hide()
end
end
function BigWigsBars:BigWigs_StartBar(module, text, time, icon, otherc, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, emphasize, target, spell)
if not text or not time then
return
end
local id = "BigWigsBar " .. text
if emphasize == nil then emphasize = true end
if not self.frames then
self.frames = {}
end
if not self.frames.anchor then
self:SetupFrames()
end
if self.frames.emphasizeAnchor then
if not self.frames.emphasizeAnchor.moduleBars[module] then
self.frames.emphasizeAnchor.moduleBars[module] = {}
end
self.frames.emphasizeAnchor.moduleBars[module][id] = true
end
local bc, balpha, txtc
if BigWigsColors and type(BigWigsColors) == "table" then
if type(otherc) ~= "boolean" or not otherc then
c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 = BigWigsColors:BarColor(time)
end
end
local groupId = self.frames.anchor.candyBarGroupId
local scale = self.db.profile.scale or 1
if self.frames.emphasizeAnchor and self.db.profile.emphasize and emphasize == true and (self.db.profile.emphasizeMove or self.db.profile.emphasizeFlash) then
-- If the bar is started at more than 15 seconds, it won't be emphasized
-- right away, but if it's started at 15 or less, it will be.
if time > 20 then
if count == 100 then
count = 1
end
if self.db.profile.emphasizeMove then
if not self.frames.emphasizeAnchor.emphasizeTimers[module] then
self.frames.emphasizeAnchor.emphasizeTimers[module] = {}
end
if self.frames.emphasizeAnchor.emphasizeTimers[module][id] then
self:CancelScheduledEvent(self.frames.emphasizeAnchor.emphasizeTimers[module][id])
end
self.frames.emphasizeAnchor.emphasizeTimers[module][id] = string.format("%s%d", "BigWigs-EmphasizeBar-", count)
count = count + 1
self:ScheduleEvent(self.frames.emphasizeAnchor.emphasizeTimers[module][id], self.EmphasizeBar, time - 10, self, module, id)
end
if self.db.profile.emphasizeFlash then
if not self.frames.emphasizeAnchor.flashTimers[module] then
self.frames.emphasizeAnchor.flashTimers[module] = {}
end
if self.frames.emphasizeAnchor.flashTimers[module][id] then
self:CancelScheduledEvent(self.frames.emphasizeAnchor.flashTimers[module][id])
end
self.frames.emphasizeAnchor.flashTimers[module][id] = string.format("%s%d", "BigWigs-FlashBar-", count)
count = count + 1
self:ScheduleEvent(self.frames.emphasizeAnchor.flashTimers[module][id], self.FlashBar, time - 10, self, module, id)
end
else
-- Since it's 15 or less, just start it at the emphasized group
-- right away.
if self.db.profile.emphasizeMove then
groupId = self.frames.emphasizeAnchor.candyBarGroupId
if not self.frames.emphasizeAnchor then
self:SetupFrames(true)
end
scale = self.db.profile.emphasizeScale or 1
end
if self.db.profile.emphasizeFlash then
self:FlashBar(module, id)
end
end
end
-- When using the emphasize option, custom bar groups from the modules are
-- not used when the bar reaches 10 seconds left, but moved to the
-- emphasized group regardless of custom groups.
if groupId == self.frames.anchor.candyBarGroupId and type(module.GetBarGroupId) == "function" then
groupId = module:GetBarGroupId(text)
end
self:RegisterCandyBar(id, time, text, icon, c1, c2, c3, c4, c5, c6, c8, c9, c10)
self:RegisterCandyBarWithGroup(id, groupId)
self:SetCandyBarTexture(id, surface:Fetch(self.db.profile.texture))
if type(BigWigsColors) == "table" then
local bg = BigWigsColors.db.profile.bgc
local bga = BigWigsColors.db.profile.bga
if bg and bga then
self:SetCandyBarBackgroundColor(id, bg, bga)
end
local txt = BigWigsColors.db.profile.txtc
if txt then
self:SetCandyBarTextColor(id, txt)
end
end
if type(self.db.profile.width) == "number" then
self:SetCandyBarWidth(id, self.db.profile.width)
end
if type(self.db.profile.height) == "number" then
self:SetCandyBarHeight(id, self.db.profile.height)
end
self:SetCandyBarFade(id, .5)
if self.db.profile.reverse then
self:SetCandyBarReversed(id, self.db.profile.reverse)
end
self:SetCandyBarScale(id, scale)
self:StartCandyBar(id, true)
-- recycled frame: drop any raid mark left from a previous bar (BigWigs_SetBarRaidMark re-adds it)
local handler = candybar.var.handlers[id]
if handler and handler.frame and handler.frame.bwRaidMark then
handler.frame.bwRaidMark:SetScript("OnUpdate", nil)
handler.frame.bwRaidMark:Hide()
end
local barExist = false
for i = 1, table.getn(barCache) do
if barCache[i] and barCache[i][2] == module and barCache[i][1] == text then
barExist = true
end
end
if not barExist then
tinsert(barCache, { text, module })
end
local function OnBarClick(i)
local exists, t, elapsed, running, paused = self:CandyBarStatus(i)
if exists then
if arg1 == "RightButton" then
BigWigsBars:BigWigs_StopBar(module, text)
return
end
if IsControlKeyDown() then
SendChatMessage(text .. " in " .. SecondsToTime(math.floor(t - elapsed)), "RAID_WARNING");
elseif IsShiftKeyDown() then
SendChatMessage(text .. " in " .. SecondsToTime(math.floor(t - elapsed)), "RAID");
SendChatMessage(text .. " in " .. SecondsToTime(math.floor(t - elapsed)), "BATTLEGROUND");
else
if target and spell and SUPERWOW_VERSION then
-- SuperWoW can cast without retargeting if we can get a GUID
local superTarget = target
if string.sub(target,1,2) ~= "0x" then
superTarget = BigWigs:GetGUIDByName(target, 0) or BigWigs:GetGUIDByName(target, 1)
end
if superTarget then
CastSpellByName(spell, superTarget)
return
end
end
-- normal target & cast, also SuperWoW fall-back if no GUID found
if target then
if string.sub(target,1,2) == "0x" then -- GUID
TargetUnit(target)
else -- name
TargetByName(target,true)
end
end
if spell then
CastSpellByName(spell)
end
end
end
end
if not BigWigsBarClick then
BigWigsBarClick = '1'
end
if BigWigsBarClick == '1' then
self:SetCandyBarOnClick(id, OnBarClick, id)
end
end
------------------------------
-- Raid mark next to a bar --
------------------------------
-- BigWigs_SetBarRaidMark(module, text, unit, mark)
-- unit: unit id or GUID (SuperWoW) whose raid mark is shown and kept up to date
-- mark: fixed mark index (1-8), used when unit is nil or can't be read
-- The mark sits just left of the bar's icon and disappears with the bar.
local function SetRaidMarkTexture(tex, index)
if index and index >= 1 and index <= 8 then
local col = math.mod(index - 1, 4)
local row = math.floor((index - 1) / 4)
tex:SetTexCoord(col * 0.25, col * 0.25 + 0.25, row * 0.25, row * 0.25 + 0.25)
tex:Show()
else
tex:Hide()
end
end
local function RaidMarkRefresh(m)
-- frames are recycled by CandyBar: hide if this frame now belongs to another bar
local h = candybar.var.handlers[m.barId]
if not h or h.frame ~= m:GetParent() then
m:SetScript("OnUpdate", nil)
m:Hide()
return
end
local index = nil
if m.unit then
local ok, result = pcall(GetRaidTargetIndex, m.unit)
if ok then index = result end
end
if not index then index = m.mark end
SetRaidMarkTexture(m.tex, index)
end
local function RaidMarkOnUpdate()
this.elapsed = (this.elapsed or 0) + arg1
if this.elapsed >= 0.5 then
this.elapsed = 0
RaidMarkRefresh(this)
end
end
function BigWigsBars:BigWigs_SetBarRaidMark(module, text, unit, mark)
if not text then return end
local id = "BigWigsBar " .. text
local h = candybar.var.handlers[id]
if not h or not h.frame then return end
local f = h.frame
if not f.bwRaidMark then
local m = CreateFrame("Frame", nil, f)
m.tex = m:CreateTexture(nil, "OVERLAY")
m.tex:SetAllPoints(m)
m.tex:SetTexture("Interface\\TargetingFrame\\UI-RaidTargetingIcons")
f.bwRaidMark = m
end
local m = f.bwRaidMark
local size = f.icon and f.icon:GetHeight() or f:GetHeight()
m:ClearAllPoints()
m:SetWidth(size)
m:SetHeight(size)
m:SetPoint("RIGHT", f.icon or f, "LEFT", -2, 0)
m.barId = id
m.unit = unit
m.mark = mark
m.elapsed = 0
m:SetScript("OnUpdate", RaidMarkOnUpdate)
m:Show()
RaidMarkRefresh(m)
end
function BigWigsBars:BigWigs_StopBar(module, text)
if not text and type(text) ~= "string" then
return
end
if self.frames and self.frames.emphasizeAnchor and self.frames.emphasizeAnchor.moduleBars and self.frames.emphasizeAnchor.moduleBars[module] then
local id = "BigWigsBar " .. text
if self.frames.emphasizeAnchor.movingBars[id] then
self.frames.emphasizeAnchor.movingBars[id] = del(self.frames.emphasizeAnchor.movingBars[id])
end
if not next(self.frames.emphasizeAnchor.movingBars) then
self:CancelScheduledEvent("BigWigsBarMover")
end
if self.frames.emphasizeAnchor.emphasizeTimers[module] and self.frames.emphasizeAnchor.emphasizeTimers[module][id] then
self:CancelScheduledEvent(self.frames.emphasizeAnchor.emphasizeTimers[module][id])
self.frames.emphasizeAnchor.emphasizeTimers[module][id] = nil
end
if self.frames.emphasizeAnchor.flashTimers[module] and self.frames.emphasizeAnchor.flashTimers[module][id] then
self:CancelScheduledEvent(self.frames.emphasizeAnchor.flashTimers[module][id])
self.frames.emphasizeAnchor.flashTimers[module][id] = nil
end
self:UnregisterCandyBar(id)
self.frames.emphasizeAnchor.moduleBars[module][id] = nil
end
module:UnregisterCandyBar("BigWigsBar " .. text)
end
function BigWigsBars:BigWigs_UpdateBar(module, barName, value, text, paused, color, timeFormat)
if not barName then
return
end
local id = "BigWigsBar " .. barName
local bar = candybar.var.handlers[id]
if not bar then
return
end
-- adjust value
if type(value) == "number" and value < 0 and bar.time + value >= 0 then
bar.elapsed = math.abs(value)
candybar:Update(id)
elseif type(value) == "number" and value >= 0 and bar.time >= value then
bar.elapsed = bar.time - value
candybar:Update(id)
end
-- adjust display text
if text then
candybar:SetText(id, text)
end
-- adjust paused state (bar.paused is either nil or true)
if paused == true and not bar.paused then
module:PauseCandyBar(id)
elseif paused == false and bar.paused == true then
module:StartCandyBar(id)
end
-- adjust color
if color then
module:SetCandyBarColor(id, color)
end
-- adjust timer format
if timeFormat then
module:SetCandyBarTimeFormat(id, function(t)
return string.format(timeFormat, t)
end)
end
end
function BigWigsBars:BigWigs_SetBar(module, barName, timeLeft, timeTotal, timeFormat)
if not barName then
return
end
local id = "BigWigsBar " .. barName
local bar = candybar.var.handlers[id]
if not bar then
return
end
-- adjust total duration of bar
if timeTotal then
module:SetCandyBarTime(id, timeTotal)
end
-- adjust time left
if timeLeft then
module:SetCandyBarTimeLeft(id, timeLeft)
end
-- adjust timer format
if timeFormat then
module:SetCandyBarTimeFormat(id, function(t)
return string.format(timeFormat, t)
end)
end
-- update in case the bar is paused so changes become visible
candybar:Update(id)
end
function BigWigsBars:BigWigs_ColorBar(module, barName, color, bgcolor)
if not barName then
return
end
local id = "BigWigsBar " .. barName
local bar = candybar.var.handlers[id]
if not bar then
return
end
-- adjust color
if color then
module:SetCandyBarColor(id, color)
end
-- adjust background color
if bgcolor then
module:SetCandyBarBackgroundColor(id, bgcolor)
end
end
function BigWigsBars:GetBarStatus(module, text)
local id = "BigWigsBar " .. text
local registered, time, elapsed, running = self:CandyBarStatus(id)
return registered, time, elapsed, running
end
function BigWigsBars:BigWigs_StartCounterBar(module, text, max, icon, otherc, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, emphasize, target, spell, timeFormat)
if not text then
return
end
timeFormat = timeFormat or "%d"
local id = "BigWigsBar " .. text
BigWigsBars:BigWigs_StartBar(module, text, max, icon, otherc, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, emphasize, target, spell)
module:PauseCandyBar(id)
module:SetCandyBarTimeFormat(id, function(t)
return string.format(timeFormat, t)
end)
candybar:Update(id)
end
function BigWigsBars:BigWigs_StopCounterBar(module, text)
if not text then
return
end
BigWigsBars:BigWigs_StopBar(module, text)
end
function BigWigsBars:BigWigs_HideCounterBars()
-- All module bars are cleaned up via BigWigsBars:Disable(module)
end
function BigWigsBars:BigWigs_SetCounterBar(module, text, value)
if (not text) or (value == nil) or (value < 0) then
return
end
local id = "BigWigsBar " .. text
local bar = candybar.var.handlers[id]
if not bar then
return
end
bar.elapsed = value
candybar:Update(id)
if bar.time <= value then
BigWigsBars:BigWigs_StopBar(module, text)
end
end
function BigWigsBars:BigWigs_StartHPBar(module, text, max, icon, otherc, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
if not text then
return
end
local id = "BigWigsBar " .. text
BigWigsBars:BigWigs_StartBar(module, text, max, icon, otherc, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, false)
module:PauseCandyBar(id)
module:SetCandyBarTimeFormat(id, function(t)
local timetext
if t == 100 then
timetext = "100"
elseif t == 0 then
timetext = "0%%"
else
timetext = string.format("%d", t)
end
return timetext
end)
end
function BigWigsBars:BigWigs_StopHPBar(module, text)
if not text then
return
end
BigWigsBars:BigWigs_StopBar(module, text)
end
function BigWigsBars:BigWigs_SetHPBar(module, text, value)
if (not text) or (value == nil) or (value < 0) then
return
end
local id = "BigWigsBar " .. text
local bar = candybar.var.handlers[id]
if not bar then
return
end
bar.elapsed = value
candybar:Update(id)
if bar.time <= value then
BigWigsBars:BigWigs_StopBar(module, text)
end
end
function BigWigsBars:BigWigs_StartIntervalBar(module, text, intervalMin, intervalMax, icon, otherColor, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
self:TriggerEvent("BigWigs_StartBar", module, text, intervalMin, icon, otherColor, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
if self.db.profile.intervalbar then
self:SetCandyBarFade("BigWigsBar " .. text, intervalMax - intervalMin)
end
end
local monitorBarCache = {-- [i] = {id, GUID, type, barText, insertMark}
}
function BigWigsBars:BigWigs_StartMonitorBar(module, barName, icon, guid, type, displayText, insertMark, emphazise, otherc, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
if (not barName) or (not guid) then
return
end
-- set up defaults
type = type or "health"
displayText = displayText or barName
if emphazise == nil then
emphazise = false
end
if not otherc then
otherc = true
c1 = (type == "health" and "Green") or (type == "mana" and "Blue")
end
-- create bar, pause it, format timer
BigWigsBars:BigWigs_StartBar(module, barName, 100, icon, otherc, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, emphazise, guid)
local id = "BigWigsBar " .. barName
module:PauseCandyBar(id)
module:SetCandyBarTimeFormat(id, function(t)
return string.format("%d%%", floor(t))
end)
-- set the bar's background color to a darker hue
local _, r, g, b = paint:GetRGBPercent(c1)
module:SetCandyBarBackgroundColorRGB(id, r*0.7, g*0.7, b*0.7, 0.5)
-- enter/update bar's cache entry
local barExists = false
for i = 1, table.getn(monitorBarCache) do
if monitorBarCache[i] and monitorBarCache[i][1] == id then
barExists = true
monitorBarCache[i][2] = guid
monitorBarCache[i][3] = type
monitorBarCache[i][4] = displayText
monitorBarCache[i][5] = insertMark
-- vary endtime to guarantee stable sorting of bars created at the same time
candybar.var.handlers[id].endtime = candybar.var.handlers[id].endtime - 1 + i/10
end
end
if not barExists then
table.insert(monitorBarCache, { id, guid, type, displayText, insertMark })
candybar.var.handlers[id].endtime = candybar.var.handlers[id].endtime - 1 + table.getn(monitorBarCache)/10
end
BigWigsBars:UpdateAllMonitorBars()
end
function BigWigsBars:UpdateAllMonitorBars()
if table.getn(monitorBarCache) == 0 then
return
end
for i = 1,table.getn(monitorBarCache) do
local bar = candybar.var.handlers[monitorBarCache[i][1]]
if not bar then
table.remove(monitorBarCache, i)
self:UpdateAllMonitorBars()
return
end
-- check unit for health or mana
local currentValue = 0
local currentValueString = ""
local currentPercent = 0
if monitorBarCache[i][3] == "health" and UnitExists(monitorBarCache[i][2]) then
currentValue = UnitHealth(monitorBarCache[i][2])
currentValueString = BigWigs:FormatLargeNumber(currentValue).." "..L["HP"]
currentPercent = math.floor(currentValue/UnitHealthMax(monitorBarCache[i][2]) * 100)
elseif monitorBarCache[i][3] == "mana" and UnitExists(monitorBarCache[i][2]) then
currentValue = UnitMana(monitorBarCache[i][2])
currentValueString = BigWigs:FormatLargeNumber(currentValue).." "..L["Mana"]
currentPercent = math.floor(currentValue/UnitManaMax(monitorBarCache[i][2]) * 100)
end
-- update bar
bar.elapsed = 100 - currentPercent
candybar:Update(monitorBarCache[i][1])
-- piece together new bar text
local assembledText = monitorBarCache[i][4]
if monitorBarCache[i][5] == true and UnitExists(monitorBarCache[i][2]) then
assembledText = assembledText.." "..BigWigs:RaidTargetLookup(GetRaidTargetIndex(monitorBarCache[i][2]), true)
end
if UnitExists(monitorBarCache[i][2]) and not UnitIsDead(monitorBarCache[i][2]) then
assembledText = assembledText.." - "..currentValueString
else
assembledText = assembledText.." - "..L["dead"]
end
-- update bar
candybar:SetText(monitorBarCache[i][1], assembledText)
end
-- check again in quarter of a second; non-repeatable so it auto-cancels if bar cache is empty
self:ScheduleEvent("UpdateMonitorBars", self.UpdateAllMonitorBars, 0.25, self)
end
-----------------------------------------------------------------------
-- Emphasized Background Flashing
-----------------------------------------------------------------------
local flashColors
local generateColors
do
local function ColorGradient(perc, r1, g1, b1, r2, g2, b2)
if perc >= 1 then
return r2, g2, b2
elseif perc <= 0 then
return r1, g1, b1
end
return r1 + (r2 - r1) * perc, g1 + (g2 - g1) * perc, b1 + (b2 - b1) * perc
end
generateColors = function()
flashColors = {}
for i = 0.1, 1, 0.1 do
local r, g, b = ColorGradient(i, 1, 0, 0, 0, 0, 0)
table.insert(flashColors, { r, g, b, 0.5 })
end
end
end
local flashBarUp, flashBarDown
local currentColor = {}
local function tablelength(T)
local count = 0
for _ in pairs(T) do
count = count + 1
end
return count
end
flashBarUp = function(id)
--self:SetCandyBarBackgroundColor(id, bg.r, bg.g, bg.b, bg.a)
local r, g, b, a = unpack(flashColors[currentColor[id]])
--BigWigsBars:SetCandyBarBackgroundColor(id, unpack(flashColors[currentColor[id]]))
BigWigsBars:SetCandyBarBackgroundColorRGB(id, r, g, b, a)
--if currentColor[id] == #flashColors then
if currentColor[id] == tablelength(flashColors) then
BigWigsBars:ScheduleRepeatingEvent(id, flashBarDown, 0.1, id)
return
end
currentColor[id] = currentColor[id] + 1
end
flashBarDown = function(id)
local r, g, b, a = unpack(flashColors[currentColor[id]])
--BigWigsBars:SetCandyBarBackgroundColor(id, unpack(flashColors[currentColor[id]]))
BigWigsBars:SetCandyBarBackgroundColorRGB(id, r, g, b, a)
if currentColor[id] == 1 then
BigWigsBars:ScheduleRepeatingEvent(id, flashBarUp, 0.1, id)
return
end
currentColor[id] = currentColor[id] - 1
end
function BigWigsBars:FlashBar(module, id)
if not flashColors then
generateColors()
end
if self.frames.emphasizeAnchor and self.frames.emphasizeAnchor.flashTimers[module] then
self.frames.emphasizeAnchor.flashTimers[module][id] = nil
end
-- Start flashing the bar
currentColor[id] = 1
self:ScheduleRepeatingEvent(id, flashBarUp, 0.1, id)
self:ScheduleEvent(self.CancelScheduledEvent, 10, self, id)
end
-----------------------------------------------------------------------
-- Smooth Moving of Emphasized Bars
-----------------------------------------------------------------------
-- copied from PitBull_BarFader
local function CosineInterpolate(y1, y2, mu)
local mu2 = (1 - math.cos(mu * math.pi)) / 2
return y1 * (1 - mu2) + y2 * mu2
end
function BigWigsBars:UpdateBars()
local now, count = GetTime(), 0
if self.frames.emphasizeAnchor then
for bar, opt in pairs(self.frames.emphasizeAnchor.movingBars) do
local stop = opt.stop
local scale
count = count + 1
if stop < now then
self.frames.emphasizeAnchor.movingBars[bar] = del(self.frames.emphasizeAnchor.movingBars[bar])
self:RegisterCandyBarWithGroup(bar, self.frames.emphasizeAnchor.candyBarGroupId)
self:SetCandyBarScale(bar, self.db.profile.emphasizeScale or 1)
return
end
local centerX, centerY = self:GetCandyBarCenter(bar)
if type(centerX) == "number" and type(centerY) == "number" then
local effscale = self:GetCandyBarEffectiveScale(bar)
local tempX, tempY = centerX * effscale, centerY * effscale
tempX = CosineInterpolate(tempX, opt.targetX, 1 - ((stop - now) / self.db.profile.duration))
tempY = CosineInterpolate(tempY, opt.targetY, 1 - ((stop - now) / self.db.profile.duration))
scale = (opt.stopScale - opt.startScale) * (1 - ((stop - now) / self.db.profile.duration))
self:SetCandyBarScale(bar, scale + opt.startScale)
effscale = self:GetCandyBarEffectiveScale(bar)
local point, rframe, rpoint = self:GetCandyBarPoint(bar)
self:SetCandyBarPoint(bar, point, rframe, rpoint, tempX / effscale, tempY / effscale)
end
end
end
if count == 0 then
self:CancelScheduledEvent("BigWigsBarMover")
end
end
function BigWigsBars:EmphasizeBar(module, id)
local centerX, centerY = self:GetCandyBarCenter(id)
if type(centerX) ~= "number" or type(centerY) ~= "number" then
return
end
if self.frames.emphasizeAnchor and self.frames.emphasizeAnchor.emphasizeTimers[module] then
self.frames.emphasizeAnchor.emphasizeTimers[module][id] = nil
end
if not self.frames.emphasizeAnchor then
self:SetupFrames(true)
end
if not self:IsEventScheduled("BigWigsBarMover") then
self:ScheduleRepeatingEvent("BigWigsBarMover", self.UpdateBars, 0, self)
end
self:UnregisterCandyBarWithGroup(id, self.frames.anchor.candyBarGroupId)
self:SetCandyBarPoint(id, "CENTER", "UIParent", "BOTTOMLEFT", centerX, centerY)
local targetX, targetY = self:GetCandyBarNextBarPointInGroup(self.frames.emphasizeAnchor.candyBarGroupId)
local db = self.db.profile
local u = db.emphasizeGrowup
local _, offsetTop, offsetBottom = self:GetCandyBarOffsets(id)
local offsetY = u and centerY - offsetBottom or centerY - offsetTop
local frameX = self.frames.emphasizeAnchor:GetCenter()
local frameY = u and self.frames.emphasizeAnchor:GetTop() or self.frames.emphasizeAnchor:GetBottom()
local frameScale = self.frames.emphasizeAnchor:GetEffectiveScale()
self.frames.emphasizeAnchor.movingBars[id] = new()
self.frames.emphasizeAnchor.movingBars[id].stop = GetTime() + self.db.profile.duration
self.frames.emphasizeAnchor.movingBars[id].targetX = (targetX * (UIParent:GetEffectiveScale() * (db.emphasizeScale or 1))) + (frameX * frameScale)
self.frames.emphasizeAnchor.movingBars[id].targetY = (targetY * (UIParent:GetEffectiveScale() * (db.emphasizeScale or 1))) + ((frameY + offsetY) * frameScale)
self.frames.emphasizeAnchor.movingBars[id].startScale = db.scale or 1
self.frames.emphasizeAnchor.movingBars[id].stopScale = db.emphasizeScale or 1
end
------------------------------
-- Slash Handlers --
------------------------------
function BigWigsBars:SetScale(msg, supressreport)
local scale = tonumber(msg)
if scale and scale >= minscale and scale <= maxscale then
self.db.profile.scale = scale
if not supressreport then
self.core:Print(L["Scale is set to %s"], scale)
end
end
end
function BigWigsBars:ToggleUp(supressreport)
self.db.profile.growup = not self.db.profile.growup
local t = self.db.profile.growup
if not supressreport then
self.core:Print(L["Bars now grow %s"], (t and L["Up"] or L["Down"]))
end
end
------------------------------
-- Create the Anchor --
------------------------------
function BigWigsBars:SetupFrames(emphasize)
if not self.frames then
self.frames = {}
end
if not self.db.profile.emphasize and self.frames.anchor then
return
end
if self.db.profile.emphasize and self.frames.emphasizeAnchor then
return
end
local f, t
f, _, _ = GameFontNormal:GetFont()
local frame = CreateFrame("Frame", emphasize and "BigWigsEmphasizedBarAnchor" or "BigWigsBarAnchor", UIParent)
frame.owner = self
frame:Hide()
frame:SetWidth(170)
frame:SetHeight(75)
frame:SetBackdrop({
bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background",
tile = true,
tileSize = 16,
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
edgeSize = 16,
insets = { left = 4, right = 4, top = 4, bottom = 4 },
})
frame:SetBackdropBorderColor(.5, .5, .5)
frame:SetBackdropColor(0, 0, 0)
frame:ClearAllPoints()
frame:SetPoint("CENTER", UIParent, "CENTER", 0, 0)
frame:EnableMouse(true)
frame:RegisterForDrag("LeftButton")
frame:SetMovable(true)
frame:SetScript("OnDragStart", function()
this:StartMoving()
end)
frame:SetScript("OnDragStop", function()
this:StopMovingOrSizing()
this.owner:SavePosition()
end)
local cheader = frame:CreateFontString(nil, "OVERLAY")
cheader:SetFont(f, 14)
cheader:SetWidth(150)
cheader:SetText("Plugins -> Bars")
cheader:SetTextColor(1, .8, 0)
cheader:ClearAllPoints()
cheader:SetPoint("TOP", frame, "TOP", 0, -10)
frame.cheader = cheader
local leftbutton = CreateFrame("Button", nil, frame)
leftbutton.owner = self
leftbutton:SetWidth(40)
leftbutton:SetHeight(25)
leftbutton:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", 10, 10)
leftbutton:SetScript("OnClick", function()
self:TriggerEvent("BigWigs_Test")
end)
t = leftbutton:CreateTexture()
t:SetWidth(50)
t:SetHeight(32)
t:SetPoint("CENTER", leftbutton, "CENTER")
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Up")
t:SetTexCoord(0, 0.625, 0, 0.6875)
leftbutton:SetNormalTexture(t)
t = leftbutton:CreateTexture(nil, "BACKGROUND")
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Down")
t:SetTexCoord(0, 0.625, 0, 0.6875)
t:SetAllPoints(leftbutton)
leftbutton:SetPushedTexture(t)
t = leftbutton:CreateTexture()
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Highlight")
t:SetTexCoord(0, 0.625, 0, 0.6875)
t:SetAllPoints(leftbutton)
t:SetBlendMode("ADD")
leftbutton:SetHighlightTexture(t)
leftbuttontext = leftbutton:CreateFontString(nil, "OVERLAY")
leftbuttontext:SetFontObject(GameFontHighlight)
leftbuttontext:SetText(L["Test"])
leftbuttontext:SetAllPoints(leftbutton)
frame.leftbutton = leftbutton
local middlebutton = CreateFrame("Button", nil, frame)
middlebutton.owner = self
middlebutton:SetWidth(40)
middlebutton:SetHeight(25)
middlebutton:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", 65, 10)
middlebutton:SetScript("OnClick", function()
BigWigsOptions:OpenMenu(middlebutton)
end)
t = middlebutton:CreateTexture()
t:SetWidth(50)
t:SetHeight(32)
t:SetPoint("CENTER", middlebutton, "CENTER")
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Up")
t:SetTexCoord(0, 0.625, 0, 0.6875)
middlebutton:SetNormalTexture(t)
t = middlebutton:CreateTexture(nil, "BACKGROUND")
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Down")
t:SetTexCoord(0, 0.625, 0, 0.6875)
t:SetAllPoints(middlebutton)
middlebutton:SetPushedTexture(t)
t = middlebutton:CreateTexture()
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Highlight")
t:SetTexCoord(0, 0.625, 0, 0.6875)
t:SetAllPoints(middlebutton)
t:SetBlendMode("ADD")
middlebutton:SetHighlightTexture(t)
middlebuttontext = middlebutton:CreateFontString(nil, "OVERLAY")
middlebuttontext:SetFontObject(GameFontHighlight)
middlebuttontext:SetText("Edit")
middlebuttontext:SetAllPoints(middlebutton)
frame.middlebutton = middlebutton
local rightbutton = CreateFrame("Button", nil, frame)
rightbutton.owner = self
rightbutton:SetWidth(40)
rightbutton:SetHeight(25)
rightbutton:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", 120, 10)
rightbutton:SetScript("OnClick", function()
self:BigWigs_HideAnchors()
end)
t = rightbutton:CreateTexture()
t:SetWidth(50)
t:SetHeight(32)
t:SetPoint("CENTER", rightbutton, "CENTER")
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Up")
t:SetTexCoord(0, 0.625, 0, 0.6875)
rightbutton:SetNormalTexture(t)
t = rightbutton:CreateTexture(nil, "BACKGROUND")
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Down")
t:SetTexCoord(0, 0.625, 0, 0.6875)
t:SetAllPoints(rightbutton)
rightbutton:SetPushedTexture(t)
t = rightbutton:CreateTexture()
t:SetTexture("Interface\\Buttons\\UI-Panel-Button-Highlight")
t:SetTexCoord(0, 0.625, 0, 0.6875)
t:SetAllPoints(rightbutton)
t:SetBlendMode("ADD")
rightbutton:SetHighlightTexture(t)
rightbuttontext = rightbutton:CreateFontString(nil, "OVERLAY")
rightbuttontext:SetFontObject(GameFontHighlight)
rightbuttontext:SetText(L["Close"])
rightbuttontext:SetAllPoints(rightbutton)
frame.rightbutton = rightbutton
if emphasize then
self.frames.emphasizeAnchor = frame
self.frames.emphasizeAnchor.cheader:SetText("Plugins -> Bars -> Emphasize")
local x = self.db.profile.emphasizePosX
local y = self.db.profile.emphasizePosY
if x and y then
local scale = self.frames.emphasizeAnchor:GetEffectiveScale()
self.frames.emphasizeAnchor:ClearAllPoints()
self.frames.emphasizeAnchor:SetPoint("TOPLEFT", UIParent, "BOTTOMLEFT", x / scale, y / scale)
else
self:ResetAnchor("emphasize")
end
local value = self.db.profile.emphasizeGrowup
self.frames.emphasizeAnchor.candyBarGroupId = "BigWigsEmphasizedGroup"
self:RegisterCandyBarGroup(self.frames.emphasizeAnchor.candyBarGroupId)
self:SetCandyBarGroupPoint(self.frames.emphasizeAnchor.candyBarGroupId, value and "BOTTOM" or "TOP", self.frames.emphasizeAnchor, value and "TOP" or "BOTTOM", 0, 0)
self:SetCandyBarGroupGrowth(self.frames.emphasizeAnchor.candyBarGroupId, value)
self.frames.emphasizeAnchor.flashTimers = new()
self.frames.emphasizeAnchor.emphasizeTimers = new()
self.frames.emphasizeAnchor.moduleBars = new()
self.frames.emphasizeAnchor.movingBars = new()
else
self.frames.anchor = frame
local x = self.db.profile.posx
local y = self.db.profile.posy
if x and y then
local s = self.frames.anchor:GetEffectiveScale()
self.frames.anchor:ClearAllPoints()
self.frames.anchor:SetPoint("TOP", UIParent, "TOP", 0, 0) --self.frames.anchor:SetPoint("TOPLEFT", UIParent, "BOTTOMLEFT", x / s, y / s)
else
self:ResetAnchor("normal")
end
local value = self.db.profile.growup
self.frames.anchor.candyBarGroupId = "BigWigsGroup"
self:RegisterCandyBarGroup(self.frames.anchor.candyBarGroupId)
self:SetCandyBarGroupPoint(self.frames.anchor.candyBarGroupId, value and "BOTTOM" or "TOP", self.frames.anchor, value and "TOP" or "BOTTOM", 0, 0)
self:SetCandyBarGroupGrowth(self.frames.anchor.candyBarGroupId, value)
end
self:RestorePosition()
end
function BigWigsBars:ResetAnchor(specific)
if not specific or specific == "reset" or specific == "normal" then
if not self.frames.anchor then
self:SetupFrames()
end
self.frames.anchor:ClearAllPoints()
if self.db.profile.emphasize and self.db.profile.emphasizeMove then
self.frames.anchor:SetPoint("TOP", UIParent, "TOP", 0, 0)
else
self.frames.anchor:SetPoint("CENTER", UIParent, "CENTER")
end
self.db.profile.posx = nil
self.db.profile.posy = nil
end
if (not specific or specific == "reset" or specific == "emphasize") and self.db.profile.emphasize and self.db.profile.emphasizeMove then
if not self.frames.emphasizeAnchor then
self:SetupFrames(true)
end
self.frames.emphasizeAnchor:ClearAllPoints()
self.frames.emphasizeAnchor:SetPoint("CENTER", UIParent, "CENTER")
self.db.profile.emphasizePosX = nil
self.db.profile.emphasizePosY = nil
end
end
function BigWigsBars:SavePosition()
if not self.frames.anchor then
self:SetupFrames()
end
local s = self.frames.anchor:GetEffectiveScale()
self.db.profile.posx = self.frames.anchor:GetLeft() * s
self.db.profile.posy = self.frames.anchor:GetTop() * s
if self.db.profile.emphasize and self.db.profile.emphasizeMove then
if not self.frames.emphasizeAnchor then
self:SetupFrames(true)
end
s = self.frames.emphasizeAnchor:GetEffectiveScale()
self.db.profile.emphasizePosX = self.frames.emphasizeAnchor:GetLeft() * s
self.db.profile.emphasizePosY = self.frames.emphasizeAnchor:GetTop() * s
end
end
function BigWigsBars:RestorePosition()
local x = self.db.profile.posx
local y = self.db.profile.posy
if not x or not y then
return
end
local f = self.frames.anchor
local s = f:GetEffectiveScale()
f:ClearAllPoints()
f:SetPoint("TOPLEFT", UIParent, "BOTTOMLEFT", x / s, y / s)
end