1742 lines
49 KiB
Lua
1742 lines
49 KiB
Lua
--[[
|
|
Name: CandyBar-2.2
|
|
Revision: $Rev: 15772 $
|
|
Author: Ammo (wouter@muze.nl), improved by Dorann
|
|
Website: http://www.wowace.com/
|
|
Documentation: http://www.wowace.com/
|
|
SVN: svn://svn.wowace.com/root/trunk/CandyBar/CandyBar-2.0
|
|
Description: A timer bars library
|
|
Dependencies: AceLibrary, AceOO-2.0, PaintChips-2.0, (optional) Compost-2.0
|
|
]]
|
|
|
|
local vmajor, vminor = "CandyBar-2.2", "$Revision: 15772 $"
|
|
|
|
if not AceLibrary then
|
|
error(vmajor .. " requires AceLibrary.")
|
|
end
|
|
if not AceLibrary:IsNewVersion(vmajor, vminor) then
|
|
return
|
|
end
|
|
|
|
if not AceLibrary:HasInstance("AceOO-2.0") then
|
|
error(vmajor .. " requires AceOO-2.0")
|
|
end
|
|
|
|
if not AceLibrary:HasInstance("PaintChips-2.0") then
|
|
error(vmajor .. " requires PaintChips-2.0")
|
|
end
|
|
|
|
local compost = AceLibrary:HasInstance("Compost-2.0") and AceLibrary("Compost-2.0")
|
|
local paint = AceLibrary("PaintChips-2.0")
|
|
|
|
local AceOO = AceLibrary:GetInstance("AceOO-2.0")
|
|
local Mixin = AceOO.Mixin
|
|
local CandyBar = Mixin {
|
|
"RegisterCandyBar",
|
|
"UnregisterCandyBar",
|
|
"IsCandyBarRegistered",
|
|
"StartCandyBar",
|
|
"StopCandyBar",
|
|
"PauseCandyBar",
|
|
"CandyBarStatus",
|
|
"SetCandyBarTexture",
|
|
"SetCandyBarTime",
|
|
"SetCandyBarColor",
|
|
"SetCandyBarText",
|
|
"SetCandyBarIcon",
|
|
"SetCandyBarWidth",
|
|
"SetCandyBarHeight",
|
|
"SetCandyBarBackgroundColor",
|
|
"SetCandyBarBackgroundColorRGB",
|
|
"SetCandyBarTextColor",
|
|
"SetCandyBarTimerTextColor",
|
|
"SetCandyBarFontSize",
|
|
"SetCandyBarPoint",
|
|
"GetCandyBarPoint",
|
|
"GetCandyBarCenter",
|
|
"GetCandyBarOffsets",
|
|
"GetCandyBarEffectiveScale",
|
|
"SetCandyBarGradient",
|
|
"SetCandyBarScale",
|
|
"SetCandyBarTimeFormat",
|
|
"SetCandyBarTimeLeft",
|
|
"SetCandyBarCompletion",
|
|
"SetCandyBarFade",
|
|
"RegisterCandyBarGroup",
|
|
"UnregisterCandyBarGroup",
|
|
"IsCandyBarGroupRegistered",
|
|
"SetCandyBarGroupPoint",
|
|
"SetCandyBarGroupGrowth",
|
|
"UpdateCandyBarGroup",
|
|
"GetCandyBarNextBarPointInGroup",
|
|
"RegisterCandyBarWithGroup",
|
|
"UnregisterCandyBarWithGroup",
|
|
"IsCandyBarRegisteredWithGroup",
|
|
"SetCandyBarReversed",
|
|
"IsCandyBarReversed",
|
|
"SetCandyBarOnClick",
|
|
}
|
|
|
|
local function getnewtable()
|
|
return compost and compost:Acquire() or {}
|
|
end
|
|
local function reclaimtable(t)
|
|
if compost then
|
|
compost:Reclaim(t)
|
|
end
|
|
end
|
|
|
|
|
|
-- Registers a new candy bar
|
|
-- name - A unique identifier for your bar.
|
|
-- time - Time for the bar
|
|
-- text - text displayed on the bar [defaults to the name if not set]
|
|
-- icon - icon off the bar [optional]
|
|
-- c1 - c10 - color of the bar [optional]
|
|
-- returns true on a succesful register
|
|
function CandyBar:Register(name, time, text, icon, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(time, 3, "number")
|
|
if not name or not time then
|
|
return
|
|
end
|
|
if CandyBar.var.handlers[name] then
|
|
self:Unregister(name)
|
|
end
|
|
local t = getnewtable()
|
|
t.name, t.time, t.text, t.icon = name, time, text or name, icon
|
|
t.texture = CandyBar.var.defaults.texture
|
|
t.color = {}
|
|
if not paint:GetRGBPercent(c1) then
|
|
c1 = "green"
|
|
end
|
|
_, t.color[1], t.color[2], t.color[3] = paint:GetRGBPercent(c1)
|
|
t.color[4] = 1
|
|
t.running = nil
|
|
t.endtime = 0
|
|
t.reversed = nil
|
|
CandyBar.var.handlers[name] = t
|
|
CandyBar.var.handlers[name].frame = CandyBar:AcquireBarFrame(name)
|
|
CandyBar:SetIconText(name, "") -- clear out old icon text
|
|
|
|
if c1 and c2 then
|
|
CandyBar:SetGradient(name, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
|
|
end
|
|
return true
|
|
end
|
|
|
|
|
|
-- Removes a candy bar
|
|
-- a1 - a10 handlers that you wish to remove
|
|
-- returns true upon sucessful removal
|
|
function CandyBar:Unregister(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
CandyBar:argCheck(a1, 2, "string")
|
|
if not CandyBar.var.handlers[a1] then
|
|
return
|
|
end
|
|
CandyBar:UnregisterWithGroup(a1)
|
|
CandyBar:ReleaseBarFrame(a1)
|
|
reclaimtable(CandyBar.var.handlers[a1])
|
|
CandyBar.var.handlers[a1] = nil
|
|
if a2 then
|
|
CandyBar:Unregister(a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
elseif not CandyBar:HasHandlers() then
|
|
CandyBar.var.frame:Hide()
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Checks if a candy bar is registered
|
|
-- Args: name - name of the candybar
|
|
-- returns true if a the candybar is registered
|
|
function CandyBar:IsRegistered(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if CandyBar.var.handlers[name] then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Start a bar
|
|
-- Args: name - the candybar you want to start
|
|
-- fireforget [optional] - pass true if you want the bar to unregister upon completion
|
|
-- returns true if succesful
|
|
function CandyBar:Start(name, fireforget)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
local t = GetTime()
|
|
if CandyBar.var.handlers[name].paused then
|
|
local pauseoffset = t - CandyBar.var.handlers[name].pausetime
|
|
CandyBar.var.handlers[name].endtime = CandyBar.var.handlers[name].endtime + pauseoffset
|
|
CandyBar.var.handlers[name].starttime = CandyBar.var.handlers[name].starttime + pauseoffset
|
|
else
|
|
-- bar hasn't elapsed a second.
|
|
CandyBar.var.handlers[name].elapsed = 0
|
|
CandyBar.var.handlers[name].endtime = t + CandyBar.var.handlers[name].time
|
|
CandyBar.var.handlers[name].starttime = t
|
|
end
|
|
CandyBar.var.handlers[name].fireforget = fireforget
|
|
CandyBar.var.handlers[name].running = true
|
|
CandyBar.var.handlers[name].paused = nil
|
|
CandyBar.var.handlers[name].fading = nil
|
|
CandyBar:AcquireBarFrame(name) -- this will reset the barframe incase we were fading out when it was restarted
|
|
CandyBar.var.handlers[name].frame:Show()
|
|
CandyBar.var.handlers[name].frame.timertext:Show()
|
|
if CandyBar.var.handlers[name].group then
|
|
CandyBar:UpdateGroup(CandyBar.var.handlers[name].group)
|
|
end -- update the group
|
|
CandyBar.var.frame:Show()
|
|
return true
|
|
end
|
|
|
|
-- Stop a bar
|
|
-- Args: name - the candybar you want to stop
|
|
-- returns true if succesful
|
|
function CandyBar:Stop(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.handlers[name].running = nil
|
|
CandyBar.var.handlers[name].paused = nil
|
|
|
|
if CandyBar.var.handlers[name].fadeout then
|
|
CandyBar.var.handlers[name].frame.spark:Hide()
|
|
CandyBar.var.handlers[name].fading = true
|
|
CandyBar.var.handlers[name].fadeelapsed = 0
|
|
local t = GetTime()
|
|
if CandyBar.var.handlers[name].endtime > t then
|
|
CandyBar.var.handlers[name].endtime = t
|
|
end
|
|
|
|
local reversed = CandyBar.var.handlers[name].reversed
|
|
else
|
|
CandyBar.var.handlers[name].frame:Hide()
|
|
CandyBar.var.handlers[name].starttime = nil
|
|
CandyBar.var.handlers[name].endtime = 0
|
|
if CandyBar.var.handlers[name].group then
|
|
CandyBar:UpdateGroup(CandyBar.var.handlers[name].group)
|
|
end
|
|
if CandyBar.var.handlers[name].fireforget then
|
|
return CandyBar:Unregister(name)
|
|
end
|
|
end
|
|
if not CandyBar:HasHandlers() then
|
|
CandyBar.var.frame:Hide()
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Pause a bar
|
|
-- Name - the candybar you want to pause
|
|
-- returns true if succesful
|
|
function CandyBar:Pause(name, hideTimer)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
CandyBar.var.handlers[name].pausetime = GetTime()
|
|
CandyBar.var.handlers[name].paused = true
|
|
CandyBar.var.handlers[name].running = nil
|
|
CandyBar.var.handlers[name].frame.spark:Hide()
|
|
|
|
if hideTimer then
|
|
CandyBar.var.handlers[name].frame.timertext:Hide()
|
|
end
|
|
end
|
|
|
|
-- Query a timer's status
|
|
-- Args: name - the schedule you wish to look up
|
|
-- Returns: registered - true if a schedule exists with this name
|
|
-- time - time for this bar
|
|
-- elapsed - time elapsed for this bar
|
|
-- running - true if this schedule is currently running
|
|
function CandyBar:Status(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
return true, CandyBar.var.handlers[name].time, CandyBar.var.handlers[name].elapsed, CandyBar.var.handlers[name].running, CandyBar.var.handlers[name].paused
|
|
end
|
|
|
|
function CandyBar:IsRunning(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
return CandyBar.var.handlers[name].running
|
|
end
|
|
|
|
|
|
-- Set the time for a bar.
|
|
-- Args: name - the candybar name
|
|
-- time - the new time for this bar
|
|
-- returns true if succesful
|
|
function CandyBar:SetTime(name, time)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(time, 3, "number")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
CandyBar.var.handlers[name].time = time
|
|
if CandyBar.var.handlers[name].starttime and CandyBar.var.handlers[name].endtime then
|
|
CandyBar.var.handlers[name].endtime = CandyBar.var.handlers[name].starttime + time
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Set the time left for a bar.
|
|
-- Args: name - the candybar name
|
|
-- time - time left on the bar
|
|
-- returns true if succesful
|
|
|
|
function CandyBar:SetTimeLeft(name, time)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(time, 3, "number")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
if CandyBar.var.handlers[name].time < time or time < 0 then
|
|
return
|
|
end
|
|
|
|
local elapsed = 0
|
|
if CandyBar.var.handlers[name].elapsed then
|
|
elapsed = CandyBar.var.handlers[name].elapsed
|
|
end
|
|
|
|
local e = CandyBar.var.handlers[name].time - time
|
|
local d = elapsed - e
|
|
if CandyBar.var.handlers[name].starttime and CandyBar.var.handlers[name].endtime then
|
|
CandyBar.var.handlers[name].starttime = CandyBar.var.handlers[name].starttime + d
|
|
CandyBar.var.handlers[name].endtime = CandyBar.var.handlers[name].endtime + d
|
|
end
|
|
|
|
CandyBar.var.handlers[name].elapsed = e
|
|
|
|
return true
|
|
end
|
|
|
|
-- Sets smooth coloring of the bar depending on time elapsed
|
|
-- Args: name - the candybar name
|
|
-- c1 - c10 color order of the gradient
|
|
-- returns true when succesful
|
|
function CandyBar:SetGradient(name, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
|
|
CandyBar:argCheck(c1, 3, "string")
|
|
CandyBar:argCheck(c2, 4, "string")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
if not c1 or not c2 then
|
|
return
|
|
end
|
|
|
|
local gtable = {}
|
|
|
|
gtable[1] = {}
|
|
gtable[2] = {}
|
|
|
|
if not paint:GetRGBPercent(c1) then
|
|
c1 = "green"
|
|
end
|
|
if not paint:GetRGBPercent(c2) then
|
|
c2 = "green"
|
|
end
|
|
if c3 and not paint:GetRGBPercent(c3) then
|
|
c3 = "green"
|
|
end
|
|
if c4 and not paint:GetRGBPercent(c4) then
|
|
c4 = "green"
|
|
end
|
|
if c5 and not paint:GetRGBPercent(c5) then
|
|
c5 = "green"
|
|
end
|
|
if c6 and not paint:GetRGBPercent(c6) then
|
|
c6 = "green"
|
|
end
|
|
if c7 and not paint:GetRGBPercent(c7) then
|
|
c7 = "green"
|
|
end
|
|
if c8 and not paint:GetRGBPercent(c8) then
|
|
c8 = "green"
|
|
end
|
|
if c9 and not paint:GetRGBPercent(c9) then
|
|
c9 = "green"
|
|
end
|
|
if c10 and not paint:GetRGBPercent(c10) then
|
|
c10 = "green"
|
|
end
|
|
|
|
_, gtable[1][1], gtable[1][2], gtable[1][3] = paint:GetRGBPercent(c1)
|
|
_, gtable[2][1], gtable[2][2], gtable[2][3] = paint:GetRGBPercent(c2)
|
|
if c3 then
|
|
gtable[3] = {}
|
|
_, gtable[3][1], gtable[3][2], gtable[3][3] = paint:GetRGBPercent(c3)
|
|
end
|
|
if c4 then
|
|
gtable[4] = {}
|
|
_, gtable[4][1], gtable[4][2], gtable[4][3] = paint:GetRGBPercent(c4)
|
|
end
|
|
if c5 then
|
|
gtable[5] = {}
|
|
_, gtable[5][1], gtable[5][2], gtable[5][3] = paint:GetRGBPercent(c5)
|
|
end
|
|
if c6 then
|
|
gtable[6] = {}
|
|
_, gtable[6][1], gtable[6][2], gtable[6][3] = paint:GetRGBPercent(c6)
|
|
end
|
|
if c7 then
|
|
gtable[7] = {}
|
|
_, gtable[7][1], gtable[3][2], gtable[7][3] = paint:GetRGBPercent(c7)
|
|
end
|
|
if c8 then
|
|
gtable[8] = {}
|
|
_, gtable[8][1], gtable[8][2], gtable[8][3] = paint:GetRGBPercent(c8)
|
|
end
|
|
if c9 then
|
|
gtable[9] = {}
|
|
_, gtable[9][1], gtable[9][2], gtable[9][3] = paint:GetRGBPercent(c9)
|
|
end
|
|
if c10 then
|
|
gtable[10] = {}
|
|
_, gtable[10][1], gtable[10][2], gtable[10][3] = paint:GetRGBPercent(c10)
|
|
end
|
|
|
|
local max = table.getn(gtable)
|
|
|
|
for i = 1, max do
|
|
if not gtable[i][4] then
|
|
gtable[i][4] = 1
|
|
end
|
|
gtable[i][5] = (i - 1) / (max - 1)
|
|
end
|
|
|
|
self.var.handlers[name].gradienttable = gtable
|
|
self.var.handlers[name].gradient = true
|
|
|
|
CandyBar.var.handlers[name].frame.statusbar:SetStatusBarColor(gtable[1][1], gtable[1][2], gtable[1][3], gtable[1][4])
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the color of the bar
|
|
-- Args: name - the candybar name
|
|
-- color - new color of the bar
|
|
-- alpha - new alpha of the bar
|
|
-- Setting the color will override smooth settings.
|
|
function CandyBar:SetColor(name, color, alpha)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(color, 3, "string")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
if not paint:GetRGBPercent(color) then
|
|
return
|
|
end
|
|
|
|
local ctable = {}
|
|
|
|
_, ctable[1], ctable[2], ctable[3] = paint:GetRGBPercent(color)
|
|
|
|
if alpha then
|
|
ctable[4] = alpha
|
|
else
|
|
ctable[4] = 1
|
|
end
|
|
|
|
CandyBar.var.handlers[name].color = ctable
|
|
CandyBar.var.handlers[name].gradient = nil
|
|
|
|
CandyBar.var.handlers[name].frame.statusbar:SetStatusBarColor(ctable[1], ctable[2], ctable[3], ctable[4])
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the color of background of the bar
|
|
-- Args: name - the candybar name
|
|
-- color - new color of the bar
|
|
-- alpha - new alpha of the bar
|
|
-- Setting the color will override smooth settings.
|
|
function CandyBar:SetBackgroundColor(name, color, alpha)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(color, 3, "string")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
if not paint:GetRGBPercent(color) then
|
|
return
|
|
end
|
|
|
|
local ctable = {}
|
|
|
|
_, ctable[1], ctable[2], ctable[3] = paint:GetRGBPercent(color)
|
|
|
|
if alpha then
|
|
ctable[4] = alpha
|
|
else
|
|
ctable[4] = 1
|
|
end
|
|
|
|
CandyBar.var.handlers[name].bgcolor = ctable
|
|
|
|
CandyBar.var.handlers[name].frame.statusbarbg:SetStatusBarColor(ctable[1], ctable[2], ctable[3], ctable[4])
|
|
|
|
return true
|
|
end
|
|
function CandyBar:SetBackgroundColorRGB(name, r, g, b, alpha)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(r, 1, "number")
|
|
CandyBar:argCheck(g, 1, "number")
|
|
CandyBar:argCheck(b, 1, "number")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
local ctable = {}
|
|
|
|
ctable[1], ctable[2], ctable[3] = r, g, b
|
|
|
|
if alpha then
|
|
ctable[4] = alpha
|
|
else
|
|
ctable[4] = 1
|
|
end
|
|
|
|
CandyBar.var.handlers[name].bgcolor = ctable
|
|
|
|
CandyBar.var.handlers[name].frame.statusbarbg:SetStatusBarColor(ctable[1], ctable[2], ctable[3], ctable[4])
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the color for the bar text
|
|
-- Args: name - name of the candybar
|
|
-- color - new color of the text
|
|
-- alpha - new alpha of the text
|
|
-- returns true when succesful
|
|
function CandyBar:SetTextColor(name, color, alpha)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(color, 3, "string")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
if not paint:GetRGBPercent(color) then
|
|
return
|
|
end
|
|
|
|
local ctable = {}
|
|
|
|
_, ctable[1], ctable[2], ctable[3] = paint:GetRGBPercent(color)
|
|
|
|
if alpha then
|
|
ctable[4] = alpha
|
|
else
|
|
ctable[4] = 1
|
|
end
|
|
|
|
CandyBar.var.handlers[name].textcolor = ctable
|
|
|
|
CandyBar.var.handlers[name].frame.text:SetTextColor(ctable[1], ctable[2], ctable[3], ctable[4])
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the color for the timer text
|
|
-- Args: name - name of the candybar
|
|
-- color - new color of the text
|
|
-- alpha - new alpha of the text
|
|
-- returns true when succesful
|
|
function CandyBar:SetTimerTextColor(name, color, alpha)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(color, 3, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
if not paint:GetRGBPercent(color) then
|
|
return
|
|
end
|
|
|
|
local ctable = {}
|
|
|
|
_, ctable[1], ctable[2], ctable[3] = paint:GetRGBPercent(color)
|
|
|
|
if alpha then
|
|
ctable[4] = alpha
|
|
else
|
|
ctable[4] = 1
|
|
end
|
|
|
|
CandyBar.var.handlers[name].timertextcolor = ctable
|
|
|
|
CandyBar.var.handlers[name].frame.timertext:SetTextColor(ctable[1], ctable[2], ctable[3], ctable[4])
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the text for the bar
|
|
-- Args: name - name of the candybar
|
|
-- text - text to set it to
|
|
-- returns true when succesful
|
|
function CandyBar:SetText(name, text)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(text, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.handlers[name].text = text
|
|
CandyBar.var.handlers[name].frame.text:SetText(text)
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the fontsize
|
|
-- Args: name - name of the candybar
|
|
-- fontsize - new fontsize
|
|
-- returns true when succesful
|
|
function CandyBar:SetFontSize(name, fontsize)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(fontsize, 3, "number")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
local font, _, _ = GameFontHighlight:GetFont()
|
|
local timertextwidth = fontsize * 3
|
|
local width = CandyBar.var.handlers[name].width or CandyBar.var.defaults.width
|
|
local f = CandyBar.var.handlers[name].frame
|
|
|
|
CandyBar.var.handlers[name].fontsize = fontsize
|
|
f.timertext:SetFont(font, fontsize)
|
|
f.text:SetFont(font, fontsize)
|
|
f.timertext:SetWidth(timertextwidth)
|
|
f.text:SetWidth((width - timertextwidth) * .9)
|
|
|
|
return true
|
|
end
|
|
|
|
|
|
-- Set the point where a bar should be anchored
|
|
-- Args: name -- name of the bar
|
|
-- point -- anchor point
|
|
-- rframe -- relative frame
|
|
-- rpoint -- relative point
|
|
-- xoffset -- x offset
|
|
-- yoffset -- y offset
|
|
-- returns true when succesful
|
|
function CandyBar:SetPoint(name, point, rframe, rpoint, xoffset, yoffset)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.handlers[name].point = point
|
|
CandyBar.var.handlers[name].rframe = rframe
|
|
CandyBar.var.handlers[name].rpoint = rpoint
|
|
CandyBar.var.handlers[name].xoffset = xoffset
|
|
CandyBar.var.handlers[name].yoffset = yoffset
|
|
|
|
CandyBar.var.handlers[name].frame:ClearAllPoints()
|
|
CandyBar.var.handlers[name].frame:SetPoint(point, rframe, rpoint, xoffset, yoffset)
|
|
|
|
return true
|
|
end
|
|
|
|
function CandyBar:GetPoint(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
|
|
local handler = CandyBar.var.handlers[name]
|
|
if not handler then
|
|
return
|
|
end
|
|
|
|
return handler.point, handler.rframe, handler.rpoint, handler.xoffset, handler.yoffset
|
|
end
|
|
|
|
function CandyBar:GetCenter(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
|
|
local handler = CandyBar.var.handlers[name]
|
|
if not handler then
|
|
return
|
|
end
|
|
|
|
return handler.frame:GetCenter()
|
|
end
|
|
|
|
function CandyBar:GetOffsets(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
|
|
local handler = CandyBar.var.handlers[name]
|
|
if not handler then
|
|
return
|
|
end
|
|
|
|
local bottom = handler.frame:GetBottom()
|
|
local top = handler.frame:GetTop()
|
|
local left = handler.frame:GetLeft()
|
|
local right = handler.frame:GetRight()
|
|
|
|
return left, top, bottom, right
|
|
end
|
|
|
|
function CandyBar:GetEffectiveScale(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
|
|
local handler = CandyBar.var.handlers[name]
|
|
if not handler then
|
|
return
|
|
end
|
|
|
|
return handler.frame:GetEffectiveScale()
|
|
end
|
|
|
|
-- Set the width for a bar
|
|
-- Args: name - name of the candybar
|
|
-- width - new width of the candybar
|
|
-- returns true when succesful
|
|
function CandyBar:SetWidth(name, width)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(width, 3, "number")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
local height = CandyBar.var.handlers[name].height or CandyBar.var.defaults.height
|
|
local fontsize = CandyBar.var.handlers[name].fontsize or CandyBar.var.defaults.fontsize
|
|
local timertextwidth = fontsize * 3
|
|
local f = CandyBar.var.handlers[name].frame
|
|
f:SetWidth(width + height)
|
|
f.statusbar:SetWidth(width)
|
|
f.statusbarbg:SetWidth(width)
|
|
|
|
f.timertext:SetWidth(timertextwidth)
|
|
f.text:SetWidth((width - timertextwidth) * .9)
|
|
|
|
CandyBar.var.handlers[name].width = width
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the height for a bar
|
|
-- Args: name - name of the candybar
|
|
-- height - new height for the bar
|
|
-- returs true when succesful
|
|
function CandyBar:SetHeight(name, height)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(height, 3, "number")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
local width = CandyBar.var.handlers[name].width or CandyBar.var.defaults.width
|
|
local f = CandyBar.var.handlers[name].frame
|
|
|
|
f:SetWidth(width + height)
|
|
f:SetHeight(height)
|
|
f.icon:SetWidth(height)
|
|
f.icon:SetHeight(height)
|
|
f.statusbar:SetHeight(height)
|
|
f.statusbarbg:SetHeight(height)
|
|
f.spark:SetHeight(height + 25)
|
|
|
|
f.statusbarbg:SetPoint("TOPLEFT", f, "TOPLEFT", height, 0)
|
|
f.statusbar:SetPoint("TOPLEFT", f, "TOPLEFT", height, 0)
|
|
|
|
CandyBar.var.handlers[name].height = height
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the scale for a bar
|
|
-- Args: name - name of the candybar
|
|
-- scale - new scale of the bar
|
|
-- returns true when succesful
|
|
function CandyBar:SetScale(name, scale)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(scale, 3, "number")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.handlers[name].scale = scale
|
|
|
|
CandyBar.var.handlers[name].frame:SetScale(scale)
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the time formatting function for a bar
|
|
-- Args: name - name of the candybar
|
|
-- func - function that returns the formatted string
|
|
-- a1-a10 - optional arguments to that function
|
|
-- returns true when succesful
|
|
|
|
function CandyBar:SetTimeFormat(name, func, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(func, 3, "function")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
CandyBar.var.handlers[name].timeformat = func
|
|
CandyBar.var.handlers[name].timeformat1 = a1
|
|
CandyBar.var.handlers[name].timeformat2 = a2
|
|
CandyBar.var.handlers[name].timeformat3 = a3
|
|
CandyBar.var.handlers[name].timeformat4 = a4
|
|
CandyBar.var.handlers[name].timeformat5 = a5
|
|
CandyBar.var.handlers[name].timeformat6 = a6
|
|
CandyBar.var.handlers[name].timeformat7 = a7
|
|
CandyBar.var.handlers[name].timeformat8 = a8
|
|
CandyBar.var.handlers[name].timeformat9 = a9
|
|
CandyBar.var.handlers[name].timeformat10 = a10
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the completion function for a bar
|
|
-- Args: name - name of the candybar
|
|
-- func - function to call upon ending of the bar
|
|
-- a1 - a10 - arguments to pass to the function
|
|
-- returns true when succesful
|
|
function CandyBar:SetCompletion(name, func, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(func, 3, "function")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
CandyBar.var.handlers[name].completion = func
|
|
CandyBar.var.handlers[name].completion1 = a1
|
|
CandyBar.var.handlers[name].completion2 = a2
|
|
CandyBar.var.handlers[name].completion3 = a3
|
|
CandyBar.var.handlers[name].completion4 = a4
|
|
CandyBar.var.handlers[name].completion5 = a5
|
|
CandyBar.var.handlers[name].completion6 = a6
|
|
CandyBar.var.handlers[name].completion7 = a7
|
|
CandyBar.var.handlers[name].completion8 = a8
|
|
CandyBar.var.handlers[name].completion9 = a9
|
|
CandyBar.var.handlers[name].completion10 = a10
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
-- Set the on click function for a bar
|
|
-- Args: name - name of the candybar
|
|
-- func - function to call when the bar is clicked
|
|
-- a1 - a10 - arguments to pass to the function
|
|
-- returns true when succesful
|
|
function CandyBar:SetOnClick(name, func, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if func then
|
|
CandyBar:argCheck(func, 3, "function")
|
|
end
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
CandyBar.var.handlers[name].onclick = func
|
|
CandyBar.var.handlers[name].onclick1 = a1
|
|
CandyBar.var.handlers[name].onclick2 = a2
|
|
CandyBar.var.handlers[name].onclick3 = a3
|
|
CandyBar.var.handlers[name].onclick4 = a4
|
|
CandyBar.var.handlers[name].onclick5 = a5
|
|
CandyBar.var.handlers[name].onclick6 = a6
|
|
CandyBar.var.handlers[name].onclick7 = a7
|
|
CandyBar.var.handlers[name].onclick8 = a8
|
|
CandyBar.var.handlers[name].onclick9 = a9
|
|
CandyBar.var.handlers[name].onclick10 = a10
|
|
|
|
if func then
|
|
-- enable mouse
|
|
CandyBar.var.handlers[name].frame:EnableMouse(true)
|
|
CandyBar.var.handlers[name].frame:RegisterForClicks("LeftButtonUp", "RightButtonUp", "MiddleButtonUp", "Button4Up", "Button5Up")
|
|
CandyBar.var.handlers[name].frame:SetScript("OnClick", function()
|
|
CandyBar:OnClick()
|
|
end)
|
|
CandyBar.var.handlers[name].frame.icon:EnableMouse(true)
|
|
CandyBar.var.handlers[name].frame.icon:RegisterForClicks("LeftButtonUp", "RightButtonUp", "MiddleButtonUp", "Button4Up", "Button5Up")
|
|
CandyBar.var.handlers[name].frame.icon:SetScript("OnClick", function()
|
|
CandyBar:OnClick()
|
|
end)
|
|
else
|
|
CandyBar.var.handlers[name].frame:EnableMouse(false)
|
|
CandyBar.var.handlers[name].frame:RegisterForClicks()
|
|
CandyBar.var.handlers[name].frame:SetScript("OnClick", nil)
|
|
CandyBar.var.handlers[name].frame.icon:EnableMouse(false)
|
|
CandyBar.var.handlers[name].frame.icon:RegisterForClicks()
|
|
CandyBar.var.handlers[name].frame.icon:SetScript("OnClick", nil)
|
|
end
|
|
|
|
return true
|
|
|
|
end
|
|
-- Set the texture for a bar
|
|
-- Args: name - name of the candybar
|
|
-- texture - new texture, if passed nil, the texture is reset to default
|
|
-- returns true when succesful
|
|
function CandyBar:SetTexture(name, texture)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if texture then
|
|
CandyBar:argCheck(texture, 3, "string")
|
|
end
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
if not texture then
|
|
texture = CandyBar.var.defaults.texture
|
|
end
|
|
|
|
CandyBar.var.handlers[name].texture = texture
|
|
|
|
CandyBar.var.handlers[name].frame.statusbar:SetStatusBarTexture(texture)
|
|
CandyBar.var.handlers[name].frame.statusbarbg:SetStatusBarTexture(texture)
|
|
|
|
return true
|
|
end
|
|
|
|
-- Set the icon on a bar
|
|
-- Args: name - name of the candybar
|
|
-- icon - icon path, nil removes the icon
|
|
-- returns true when succesful
|
|
function CandyBar:SetIcon(name, icon)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(icon, 3, "string")
|
|
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
CandyBar.var.handlers[name].icon = icon
|
|
|
|
if not icon then
|
|
CandyBar.var.handlers[name].frame.icon:Hide()
|
|
else
|
|
CandyBar.var.handlers[name].frame.icon:SetNormalTexture(icon)
|
|
CandyBar.var.handlers[name].frame.icon:Show()
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
function CandyBar:SetIconText(name, text)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar.var.handlers[name].frame.icon.text:SetText(text)
|
|
end
|
|
|
|
-- Sets the fading style of a candybar
|
|
-- args: name - name of the candybar
|
|
-- time - duration of the fade (default .5 seconds), negative to keep the bar on screen
|
|
-- returns true when succesful
|
|
function CandyBar:SetFade(name, time, fade)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(time, 3, "number")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.handlers[name].fadetime = time
|
|
CandyBar.var.handlers[name].fadeout = true
|
|
|
|
return true
|
|
end
|
|
|
|
function CandyBar:SetReversed(name, reversed)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(reversed, 3, "boolean")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.handlers[name].reversed = reversed
|
|
return true
|
|
end
|
|
|
|
function CandyBar:IsReversed(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
return CandyBar.var.handlers[name].reversed
|
|
end
|
|
|
|
|
|
-- Registers a candybar with a certain candybar group
|
|
-- args: name - name of the candybar
|
|
-- group - group to register the bar with
|
|
-- returns true when succesful
|
|
function CandyBar:RegisterWithGroup(name, group, order)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(group, 3, "string")
|
|
|
|
if not CandyBar.var.handlers[name] or not CandyBar.var.groups[group] then
|
|
return
|
|
end
|
|
|
|
CandyBar:UnregisterWithGroup(name)
|
|
|
|
-- insert at beginning of the group
|
|
table.insert(CandyBar.var.groups[group].bars, name)
|
|
|
|
-- CandyBar.var.groups[group].bars[name] = name
|
|
CandyBar.var.handlers[name].group = group
|
|
CandyBar.var.handlers[name].order = order or 1
|
|
CandyBar:UpdateGroup(group)
|
|
|
|
return true
|
|
end
|
|
|
|
-- Unregisters a candybar from its group
|
|
-- args: name - name of the candybar
|
|
-- returns true when succesful
|
|
|
|
function CandyBar:UnregisterWithGroup(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
--if not CandyBar.var.handlers[name].group then return end
|
|
|
|
local group = CandyBar.var.handlers[name].group
|
|
if not CandyBar.var.groups[group] then
|
|
return
|
|
end
|
|
|
|
for k, v in pairs(CandyBar.var.groups[group].bars) do
|
|
if v == name then
|
|
table.remove(CandyBar.var.groups[group].bars, k)
|
|
end
|
|
end
|
|
-- CandyBar.var.groups[group].bars[name] = nil
|
|
CandyBar.var.handlers[name].group = nil
|
|
|
|
CandyBar:UpdateGroup(group)
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
|
|
|
|
-- Register a Candybar group
|
|
-- Args: name - name of the candybar group
|
|
-- returns true when succesful
|
|
function CandyBar:RegisterGroup(name, barSpacing, sortByTimeLeft)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(barSpacing, 3, "number", "nil")
|
|
if CandyBar.var.groups[name] then
|
|
return
|
|
end
|
|
|
|
local t = getnewtable()
|
|
|
|
t.point = "CENTER"
|
|
t.rframe = UIParent
|
|
t.rpoint = "CENTER"
|
|
t.xoffset = 0
|
|
t.yoffset = 0
|
|
t.barSpacing = barSpacing or 0
|
|
t.sortByTimeLeft = true
|
|
if sortByTimeLeft ~= nil then
|
|
t.sortByTimeLeft = sortByTimeLeft
|
|
end
|
|
|
|
t.bars = {}
|
|
|
|
CandyBar.var.groups[name] = t
|
|
return true
|
|
end
|
|
|
|
function CandyBar:UpdateBarSpacing(name, barSpacing)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(barSpacing, 3, "number", "nil")
|
|
if not CandyBar.var.groups[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.groups[name].barSpacing = barSpacing
|
|
CandyBar:UpdateGroup(name)
|
|
return true
|
|
end
|
|
|
|
-- Unregister a candybar group
|
|
-- Args: a1-a2 candybar group ids
|
|
-- returns true when succesful
|
|
|
|
function CandyBar:UnregisterGroup(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
CandyBar:argCheck(a1, 2, "string")
|
|
if not CandyBar.var.groups[a1] then
|
|
return
|
|
end
|
|
reclaimtable(CandyBar.var.groups[a1])
|
|
CandyBar.var.groups[a1] = nil
|
|
|
|
if a2 then
|
|
CandyBar:UnregisterGroup(a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
-- Checks if a group is registered
|
|
-- Args: name - Candybar group
|
|
-- returns true if the candybar group is registered
|
|
function CandyBar:IsGroupRegistered(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.groups[name] then
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Checks if a bar is registered with a group
|
|
-- Args: name - Candybar name
|
|
-- group - group id [optional]
|
|
-- returns true is the candybar is registered with a/the group
|
|
function CandyBar:IsRegisteredWithGroup(name, group)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
if group then
|
|
if not CandyBar.var.groups[group] then
|
|
return false
|
|
end
|
|
if CandyBar.var.handlers[name].group == group then
|
|
return true
|
|
end
|
|
elseif CandyBar.var.handlers[name].group then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
|
|
-- Set the point for a CandyBargroup
|
|
-- point -- anchor point
|
|
-- rframe -- relative frame
|
|
-- rpoint -- relative point
|
|
-- xoffset [optional] -- x offset
|
|
-- yoffset [optional] -- y offset
|
|
-- The first bar of the group will be anchored at the anchor.
|
|
-- returns true when succesful
|
|
|
|
function CandyBar:SetGroupPoint(name, point, rframe, rpoint, xoffset, yoffset)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
if not CandyBar.var.groups[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.groups[name].point = point
|
|
CandyBar.var.groups[name].rframe = rframe
|
|
CandyBar.var.groups[name].rpoint = rpoint
|
|
CandyBar.var.groups[name].xoffset = xoffset
|
|
CandyBar.var.groups[name].yoffset = yoffset
|
|
CandyBar:UpdateGroup(name)
|
|
return true
|
|
end
|
|
|
|
|
|
-- SetGroupGrowth - sets the group to grow up or down
|
|
-- Args: name - name of the candybar group
|
|
-- growup - true if growing up, false for growing down
|
|
-- returns true when succesful
|
|
function CandyBar:SetGroupGrowth(name, growup)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
CandyBar:argCheck(growup, 3, "boolean")
|
|
|
|
if not CandyBar.var.groups[name] then
|
|
return
|
|
end
|
|
|
|
CandyBar.var.groups[name].growup = growup
|
|
|
|
CandyBar:UpdateGroup(name)
|
|
|
|
return true
|
|
end
|
|
|
|
function CandyBar:SortGroup(name)
|
|
if not CandyBar.var.groups[name] then
|
|
return
|
|
end
|
|
|
|
if CandyBar.var.groups[name].sortByTimeLeft then
|
|
table.sort(CandyBar.var.groups[name].bars,
|
|
function(a, b)
|
|
return CandyBar.var.handlers[a].endtime < CandyBar.var.handlers[b].endtime
|
|
end
|
|
)
|
|
else
|
|
-- sort by bar name
|
|
table.sort(CandyBar.var.groups[name].bars,
|
|
function(a, b)
|
|
return CandyBar.var.handlers[a].order < CandyBar.var.handlers[b].order
|
|
end
|
|
)
|
|
end
|
|
end
|
|
|
|
-- internal method
|
|
-- UpdateGroup - updates the location of bars in a group
|
|
-- Args: name - name of the candybar group
|
|
-- returns true when succesful
|
|
|
|
function CandyBar:UpdateGroup(name)
|
|
if not CandyBar.var.groups[name] then
|
|
return
|
|
end
|
|
|
|
local point = CandyBar.var.groups[name].point
|
|
local rframe = CandyBar.var.groups[name].rframe
|
|
local rpoint = CandyBar.var.groups[name].rpoint
|
|
local xoffset = CandyBar.var.groups[name].xoffset
|
|
local yoffset = CandyBar.var.groups[name].yoffset
|
|
local m = -1
|
|
if CandyBar.var.groups[name].growup then
|
|
m = 1
|
|
end
|
|
|
|
local bar = 0
|
|
local barh = 0
|
|
|
|
CandyBar:SortGroup(name)
|
|
|
|
for _, n in ipairs(CandyBar.var.groups[name].bars) do
|
|
if CandyBar.var.handlers[n] then
|
|
if CandyBar.var.handlers[n].frame:IsShown() then
|
|
CandyBar:SetPoint(n, point, rframe, rpoint, xoffset, yoffset + (m * bar))
|
|
barh = CandyBar.var.handlers[n].height or CandyBar.var.defaults.height
|
|
bar = bar + barh + CandyBar.var.groups[name].barSpacing
|
|
end
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
function CandyBar:GetNextBarPointInGroup(name)
|
|
CandyBar:argCheck(name, 2, "string")
|
|
|
|
local group = CandyBar.var.groups[name]
|
|
if not CandyBar.var.groups[name] then
|
|
return
|
|
end
|
|
|
|
local xoffset = group.xoffset
|
|
local yoffset = group.yoffset
|
|
local m = -1
|
|
if group.growup then
|
|
m = 1
|
|
end
|
|
|
|
local bar = 0
|
|
local barh = 0
|
|
|
|
local barSpacing = group.barSpacing or 10
|
|
|
|
for c, n in pairs(group.bars) do
|
|
local handler = CandyBar.var.handlers[n]
|
|
if handler then
|
|
if handler.frame:IsShown() then
|
|
barh = handler.height or CandyBar.var.defaults.height
|
|
bar = bar + barh + barSpacing
|
|
end
|
|
end
|
|
end
|
|
|
|
return xoffset, yoffset + (m * bar)
|
|
end
|
|
|
|
-- Internal Method
|
|
-- Update a bar on screen
|
|
function CandyBar:Update(name)
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
local t = CandyBar.var.handlers[name].time - CandyBar.var.handlers[name].elapsed
|
|
|
|
local timetext
|
|
|
|
local reversed = CandyBar.var.handlers[name].reversed
|
|
|
|
if CandyBar.var.handlers[name].timeformat then
|
|
local c = CandyBar.var.handlers[name]
|
|
timetext = CandyBar.var.handlers[name].timeformat(t, c.timeformat1, c.timeformat2, c.timeformat3, c.timeformat4, c.timeformat5, c.timeformat6, c.timeformat7, c.timeformat8, c.timeformat9, c.timeformat10)
|
|
else
|
|
local h = floor(t / 3600)
|
|
local m = t - (h * 3600)
|
|
m = floor(m / 60)
|
|
local s = t - ((h * 3600) + (m * 60))
|
|
if h > 0 then
|
|
timetext = string.format("%d:%02d", h, m)
|
|
elseif m > 0 then
|
|
timetext = string.format("%d:%02d", m, s)
|
|
elseif s < 10 then
|
|
timetext = string.format("%1.1f", s)
|
|
else
|
|
timetext = string.format("%d", floor(s))
|
|
end
|
|
end
|
|
CandyBar.var.handlers[name].frame.timertext:SetText(timetext)
|
|
|
|
local perc = t / CandyBar.var.handlers[name].time
|
|
|
|
CandyBar.var.handlers[name].frame.statusbar:SetValue(reversed and 1 - perc or perc)
|
|
|
|
local width = CandyBar.var.handlers[name].width or CandyBar.var.defaults.width
|
|
|
|
local sp = width * perc
|
|
sp = reversed and -sp or sp
|
|
CandyBar.var.handlers[name].frame.spark:SetPoint("CENTER", CandyBar.var.handlers[name].frame.statusbar, reversed and "RIGHT" or "LEFT", sp, 0)
|
|
|
|
if CandyBar.var.handlers[name].gradient then
|
|
local p = CandyBar.var.handlers[name].elapsed / CandyBar.var.handlers[name].time
|
|
local gstart, gend, gp
|
|
-- find the appropriate start/end
|
|
for i = 1, table.getn(CandyBar.var.handlers[name].gradienttable) - 1 do
|
|
if CandyBar.var.handlers[name].gradienttable[i][5] < p and p <= CandyBar.var.handlers[name].gradienttable[i + 1][5] then
|
|
-- the bounds are to assure no divide by zero error here.
|
|
|
|
gstart = self.var.handlers[name].gradienttable[i]
|
|
gend = self.var.handlers[name].gradienttable[i + 1]
|
|
gp = (p - gstart[5]) / (gend[5] - gstart[5])
|
|
end
|
|
end
|
|
if gstart and gend then
|
|
local color = getnewtable()
|
|
-- calculate new gradient
|
|
local i
|
|
for i = 1, 4 do
|
|
-- these may be the same.. but I'm lazy to make sure.
|
|
color[i] = gstart[i] * (1 - gp) + gend[i] * (gp)
|
|
end
|
|
CandyBar.var.handlers[name].frame.statusbar:SetStatusBarColor(color[1], color[2], color[3], color[4])
|
|
|
|
reclaimtable(color)
|
|
color = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Intenal Method
|
|
-- Fades the bar out when it's complete.
|
|
function CandyBar:UpdateFade(name)
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
if not CandyBar.var.handlers[name].fading then
|
|
return
|
|
end
|
|
|
|
-- if the fade is done go and keel the bar.
|
|
if CandyBar.var.handlers[name].fadeelapsed > CandyBar.var.handlers[name].fadetime then
|
|
CandyBar.var.handlers[name].fading = nil
|
|
CandyBar.var.handlers[name].starttime = nil
|
|
CandyBar.var.handlers[name].endtime = 0
|
|
CandyBar.var.handlers[name].frame:Hide()
|
|
if CandyBar.var.handlers[name].group then
|
|
CandyBar:UpdateGroup(CandyBar.var.handlers[name].group)
|
|
end
|
|
if CandyBar.var.handlers[name].fireforget then
|
|
return CandyBar:Unregister(name)
|
|
end
|
|
else
|
|
-- we're fading, set the alpha for the texts, statusbar and background. fade from default to 0 in the time given.
|
|
local t = CandyBar.var.handlers[name].fadetime - CandyBar.var.handlers[name].fadeelapsed
|
|
local p = t / CandyBar.var.handlers[name].fadetime
|
|
local color = CandyBar.var.handlers[name].color or CandyBar.var.defaults.color
|
|
local bgcolor = CandyBar.var.handlers[name].bgcolor or CandyBar.var.defaults.bgcolor
|
|
local textcolor = CandyBar.var.handlers[name].textcolor or CandyBar.var.defaults.textcolor
|
|
local timertextcolor = CandyBar.var.handlers[name].timertextcolor or CandyBar.var.defaults.timertextcolor
|
|
local colora = color[4] * p
|
|
local bgcolora = bgcolor[4] * p
|
|
local textcolora = textcolor[4] * p
|
|
local timertextcolora = timertextcolor[4] * p
|
|
|
|
CandyBar.var.handlers[name].frame.statusbarbg:SetStatusBarColor(bgcolor[1], bgcolor[2], bgcolor[3], bgcolora)
|
|
CandyBar.var.handlers[name].frame.statusbar:SetStatusBarColor(color[1], color[2], color[3], colora)
|
|
CandyBar.var.handlers[name].frame.text:SetTextColor(textcolor[1], textcolor[2], textcolor[3], textcolora)
|
|
CandyBar.var.handlers[name].frame.timertext:SetTextColor(timertextcolor[1], timertextcolor[2], timertextcolor[3], timertextcolora)
|
|
CandyBar.var.handlers[name].frame.icon:SetAlpha(p)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Internal Method
|
|
-- Create and return a new bar frame, recycles where needed
|
|
-- Name - which candybar is this for
|
|
-- Returns the frame
|
|
function CandyBar:AcquireBarFrame(name)
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
|
|
local f = CandyBar.var.handlers[name].frame
|
|
|
|
local color = CandyBar.var.handlers[name].color or CandyBar.var.defaults.color
|
|
local bgcolor = CandyBar.var.handlers[name].bgcolor or CandyBar.var.defaults.bgcolor
|
|
local icon = CandyBar.var.handlers[name].icon or nil
|
|
local texture = CandyBar.var.handlers[name].texture or CandyBar.var.defaults.texture
|
|
local width = CandyBar.var.handlers[name].width or CandyBar.var.defaults.width
|
|
local height = CandyBar.var.handlers[name].height or CandyBar.var.defaults.height
|
|
local point = CandyBar.var.handlers[name].point or CandyBar.var.defaults.point
|
|
local rframe = CandyBar.var.handlers[name].rframe or CandyBar.var.defaults.rframe
|
|
local rpoint = CandyBar.var.handlers[name].rpoint or CandyBar.var.defaults.rpoint
|
|
local xoffset = CandyBar.var.handlers[name].xoffset or CandyBar.var.defaults.xoffset
|
|
local yoffset = CandyBar.var.handlers[name].yoffset or CandyBar.var.defaults.yoffset
|
|
local text = CandyBar.var.handlers[name].text or CandyBar.var.defaults.text
|
|
local fontsize = CandyBar.var.handlers[name].fontsize or CandyBar.var.defaults.fontsize
|
|
local textcolor = CandyBar.var.handlers[name].textcolor or CandyBar.var.defaults.textcolor
|
|
local timertextcolor = CandyBar.var.handlers[name].timertextcolor or CandyBar.var.defaults.timertextcolor
|
|
local scale = CandyBar.var.handlers[name].scale or CandyBar.var.defaults.scale
|
|
if not scale then
|
|
scale = 1
|
|
end
|
|
local timertextwidth = fontsize * 3
|
|
local font, _, _ = GameFontHighlight:GetFont()
|
|
|
|
if not f and table.getn(CandyBar.var.framepool) > 0 then
|
|
f = table.remove(CandyBar.var.framepool)
|
|
end
|
|
|
|
if not f then
|
|
f = CreateFrame("Button", nil, UIParent)
|
|
end
|
|
f:Hide()
|
|
f.owner = name
|
|
-- yes we add the height to the width for the icon.
|
|
f:SetWidth(width + height)
|
|
f:SetHeight(height)
|
|
f:ClearAllPoints()
|
|
f:SetPoint(point, rframe, rpoint, xoffset, yoffset)
|
|
-- disable mouse
|
|
f:EnableMouse(false)
|
|
f:RegisterForClicks()
|
|
f:SetScript("OnClick", nil)
|
|
f:SetScale(scale)
|
|
|
|
if not f.icon then
|
|
f.icon = CreateFrame("Button", nil, f)
|
|
end
|
|
f.icon:ClearAllPoints()
|
|
f.icon.owner = name
|
|
f.icon:EnableMouse(false)
|
|
f.icon:RegisterForClicks()
|
|
f.icon:SetScript("OnClick", nil)
|
|
-- an icno is square and the height of the bar, so yes 2x height there
|
|
f.icon:SetHeight(height)
|
|
f.icon:SetWidth(height)
|
|
f.icon:SetPoint("LEFT", f, "LEFT", 0, 0)
|
|
f.icon:SetNormalTexture(icon)
|
|
f.icon:SetAlpha(1)
|
|
|
|
if not f.icon.text then
|
|
f.icon.text = f.icon:CreateFontString(nil, "OVERLAY", "GameFontNormal")
|
|
end
|
|
f.icon.text:SetFontObject(GameFontHighlight)
|
|
f.icon.text:SetFont(font, fontsize * 1.5, "OUTLINE")
|
|
f.icon.text:SetTextColor(timertextcolor[1], timertextcolor[2], timertextcolor[3], timertextcolor[4])
|
|
f.icon.text:SetAllPoints(f.icon)
|
|
f.icon:Show()
|
|
|
|
if not f.statusbarbg then
|
|
f.statusbarbg = CreateFrame("StatusBar", nil, f)
|
|
f.statusbarbg:SetFrameLevel(f.statusbarbg:GetFrameLevel() - 1)
|
|
end
|
|
f.statusbarbg:ClearAllPoints()
|
|
f.statusbarbg:SetHeight(height)
|
|
f.statusbarbg:SetWidth(width)
|
|
-- offset the height of the frame on the x-axis for the icon.
|
|
f.statusbarbg:SetPoint("TOPLEFT", f, "TOPLEFT", height, 0)
|
|
f.statusbarbg:SetStatusBarTexture(texture)
|
|
f.statusbarbg:SetStatusBarColor(bgcolor[1], bgcolor[2], bgcolor[3], bgcolor[4])
|
|
f.statusbarbg:SetMinMaxValues(0, 100)
|
|
f.statusbarbg:SetValue(100)
|
|
|
|
if not f.statusbar then
|
|
f.statusbar = CreateFrame("StatusBar", nil, f)
|
|
end
|
|
f.statusbar:ClearAllPoints()
|
|
f.statusbar:SetHeight(height)
|
|
f.statusbar:SetWidth(width)
|
|
-- offset the height of the frame on the x-axis for the icon.
|
|
f.statusbar:SetPoint("TOPLEFT", f, "TOPLEFT", height, 0)
|
|
f.statusbar:SetStatusBarTexture(texture)
|
|
f.statusbar:SetStatusBarColor(color[1], color[2], color[3], color[4])
|
|
f.statusbar:SetMinMaxValues(0, 1)
|
|
f.statusbar:SetValue(1)
|
|
|
|
if not f.spark then
|
|
f.spark = f.statusbar:CreateTexture(nil, "OVERLAY")
|
|
end
|
|
f.spark:SetTexture("Interface\\CastingBar\\UI-CastingBar-Spark")
|
|
f.spark:SetWidth(16)
|
|
f.spark:SetHeight(height + 25)
|
|
f.spark:SetBlendMode("ADD")
|
|
f.spark:Show()
|
|
|
|
if not f.timertext then
|
|
f.timertext = f.statusbar:CreateFontString(nil, "OVERLAY")
|
|
end
|
|
f.timertext:SetFontObject(GameFontHighlight)
|
|
f.timertext:SetFont(font, fontsize)
|
|
f.timertext:SetHeight(height)
|
|
f.timertext:SetWidth(timertextwidth)
|
|
f.timertext:SetPoint("LEFT", f.statusbar, "LEFT", 0, 0)
|
|
f.timertext:SetJustifyH("RIGHT")
|
|
f.timertext:SetText("0")
|
|
f.timertext:SetTextColor(timertextcolor[1], timertextcolor[2], timertextcolor[3], timertextcolor[4])
|
|
|
|
if not f.text then
|
|
f.text = f.statusbar:CreateFontString(nil, "OVERLAY")
|
|
end
|
|
f.text:SetFontObject(GameFontHighlight)
|
|
f.text:SetFont(font, fontsize)
|
|
f.text:SetHeight(height)
|
|
f.text:SetWidth((width - timertextwidth) * .9)
|
|
f.text:SetPoint("RIGHT", f.statusbar, "RIGHT", 0, 0)
|
|
f.text:SetJustifyH("LEFT")
|
|
f.text:SetText(text)
|
|
f.text:SetTextColor(textcolor[1], textcolor[2], textcolor[3], textcolor[4])
|
|
|
|
if CandyBar.var.handlers[name].onclick then
|
|
f:EnableMouse(true)
|
|
f:RegisterForClicks("LeftButtonUp", "RightButtonUp", "MiddleButtonUp", "Button4Up", "Button5Up")
|
|
f:SetScript("OnClick", function()
|
|
CandyBar:OnClick()
|
|
end)
|
|
f.icon:EnableMouse(true)
|
|
f.icon:RegisterForClicks("LeftButtonUp", "RightButtonUp", "MiddleButtonUp", "Button4Up", "Button5Up")
|
|
f.icon:SetScript("OnClick", function()
|
|
CandyBar:OnClick()
|
|
end)
|
|
end
|
|
|
|
return f
|
|
end
|
|
|
|
|
|
-- Internal Method
|
|
-- Releases a bar frame into the pool
|
|
-- Name - which candybar's frame are we're releasing
|
|
-- Returns true when succesful
|
|
function CandyBar:ReleaseBarFrame(name)
|
|
if not CandyBar.var.handlers[name] then
|
|
return
|
|
end
|
|
if not CandyBar.var.handlers[name].frame then
|
|
return
|
|
end
|
|
CandyBar.var.handlers[name].frame:Hide()
|
|
table.insert(CandyBar.var.framepool, CandyBar.var.handlers[name].frame)
|
|
return true
|
|
end
|
|
|
|
|
|
-- Internal Method
|
|
-- Executes the OnClick function of a bar
|
|
|
|
function CandyBar:OnClick()
|
|
if not this.owner then
|
|
return
|
|
end
|
|
if not CandyBar.var.handlers[this.owner] then
|
|
return
|
|
end
|
|
if not CandyBar.var.handlers[this.owner].onclick then
|
|
return
|
|
end
|
|
-- pass the name of the handlers first, and the button clicked as the second argument
|
|
local c = CandyBar.var.handlers[this.owner]
|
|
local button = arg1
|
|
CandyBar.var.handlers[this.owner].onclick(this.owner, button, c.onclick1, c.onclick2, c.onclick3, c.onclick4, c.onclick5, c.onclick6, c.onclick7, c.onclick8, c.onclick9, c.onclick10)
|
|
return true
|
|
end
|
|
|
|
|
|
-- Internal Method
|
|
-- on update handler
|
|
function CandyBar:OnUpdate()
|
|
local t = GetTime()
|
|
for i, v in pairs(this.owner.var.handlers) do
|
|
if v.running then
|
|
v.elapsed = t - v.starttime
|
|
if v.endtime <= t then
|
|
if this.owner.var.handlers[i].completion then
|
|
local c = this.owner.var.handlers[i]
|
|
this.owner.var.handlers[i].completion(c.completion1, c.completion2, c.completion3, c.completion4, c.completion5, c.completion6, c.completion7, c.completion8, c.completion9, c.completion10)
|
|
end
|
|
this.owner:Stop(i)
|
|
else
|
|
this.owner:Update(i)
|
|
end
|
|
elseif v.fading then
|
|
v.fadeelapsed = (t - v.endtime)
|
|
this.owner:UpdateFade(i)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Internal Method
|
|
-- returns true if we have any handlers
|
|
function CandyBar:HasHandlers()
|
|
for i in pairs(CandyBar.var.handlers) do
|
|
return true
|
|
end
|
|
end
|
|
|
|
|
|
------------------------------
|
|
-- Mixins Methods --
|
|
------------------------------
|
|
|
|
CandyBar.IsCandyBarRegistered = CandyBar.IsRegistered
|
|
CandyBar.StartCandyBar = CandyBar.Start
|
|
CandyBar.StopCandyBar = CandyBar.Stop
|
|
CandyBar.PauseCandyBar = CandyBar.Pause
|
|
CandyBar.CandyBarStatus = CandyBar.Status
|
|
CandyBar.SetCandyBarTexture = CandyBar.SetTexture
|
|
CandyBar.SetCandyBarTime = CandyBar.SetTime
|
|
CandyBar.SetCandyBarColor = CandyBar.SetColor
|
|
CandyBar.SetCandyBarText = CandyBar.SetText
|
|
CandyBar.SetCandyBarIcon = CandyBar.SetIcon
|
|
CandyBar.SetCandyBarBackgroundColor = CandyBar.SetBackgroundColor
|
|
CandyBar.SetCandyBarBackgroundColorRGB = CandyBar.SetBackgroundColorRGB
|
|
CandyBar.SetCandyBarTextColor = CandyBar.SetTextColor
|
|
CandyBar.SetCandyBarTimerTextColor = CandyBar.SetTimerTextColor
|
|
CandyBar.SetCandyBarFontSize = CandyBar.SetFontSize
|
|
CandyBar.SetCandyBarPoint = CandyBar.SetPoint
|
|
CandyBar.GetCandyBarPoint = CandyBar.GetPoint
|
|
CandyBar.GetCandyBarCenter = CandyBar.GetCenter
|
|
CandyBar.GetCandyBarOffsets = CandyBar.GetOffsets
|
|
CandyBar.GetCandyBarEffectiveScale = CandyBar.GetEffectiveScale
|
|
CandyBar.SetCandyBarScale = CandyBar.SetScale
|
|
CandyBar.SetCandyBarTimeFormat = CandyBar.SetTimeFormat
|
|
CandyBar.SetCandyBarTimeLeft = CandyBar.SetTimeLeft
|
|
CandyBar.SetCandyBarCompletion = CandyBar.SetCompletion
|
|
CandyBar.RegisterCandyBarGroup = CandyBar.RegisterGroup
|
|
CandyBar.UnregisterCandyBarGroup = CandyBar.UnregisterGroup
|
|
CandyBar.IsCandyBarGroupRegistered = CandyBar.IsGroupRegistered
|
|
CandyBar.SetCandyBarGroupPoint = CandyBar.SetGroupPoint
|
|
CandyBar.SetCandyBarGroupGrowth = CandyBar.SetGroupGrowth
|
|
CandyBar.UpdateCandyBarGroup = CandyBar.UpdateGroup
|
|
CandyBar.GetCandyBarNextBarPointInGroup = CandyBar.GetNextBarPointInGroup
|
|
CandyBar.SetCandyBarOnClick = CandyBar.SetOnClick
|
|
CandyBar.SetCandyBarFade = CandyBar.SetFade
|
|
CandyBar.RegisterCandyBarWithGroup = CandyBar.RegisterWithGroup
|
|
CandyBar.UnregisterCandyBarWithGroup = CandyBar.UnregisterWithGroup
|
|
CandyBar.IsCandyBarRegisteredWithGroup = CandyBar.IsRegisteredWithGroup
|
|
CandyBar.SetCandyBarReversed = CandyBar.SetReversed
|
|
CandyBar.IsCandyBarReversed = CandyBar.IsReversed
|
|
CandyBar.SetCandyBarOnClick = CandyBar.SetOnClick
|
|
CandyBar.SetCandyBarHeight = CandyBar.SetHeight
|
|
CandyBar.SetCandyBarWidth = CandyBar.SetWidth
|
|
|
|
function CandyBar:RegisterCandyBar(name, time, text, icon, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
|
|
if not CandyBar.var.addons[self] then
|
|
CandyBar.var.addons[self] = getnewtable()
|
|
end
|
|
CandyBar.var.addons[self][name] = CandyBar:Register(name, time, text, icon, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10)
|
|
end
|
|
|
|
function CandyBar:UnregisterCandyBar(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
CandyBar:argCheck(a1, 2, "string")
|
|
if CandyBar.var.addons[self] then
|
|
CandyBar.var.addons[self][a1] = nil
|
|
end
|
|
CandyBar:Unregister(a1)
|
|
if a2 then
|
|
self:UnregisterCandyBar(a2, a3, a4, a5, a6, a7, a8, a9, a10)
|
|
end
|
|
end
|
|
|
|
function CandyBar:OnEmbedDisable(target)
|
|
if self.var.addons[target] then
|
|
for i in pairs(self.var.addons[target]) do
|
|
self:Unregister(i)
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
--------------------------------
|
|
-- Load this bitch! --
|
|
--------------------------------
|
|
|
|
|
|
function CandyBar:activate(oldLib, oldDeactivate)
|
|
CandyBar = self
|
|
|
|
if oldLib then
|
|
self.var = oldLib.var
|
|
else
|
|
local _, _, ourpath = string.find(debugstack(), "\\AddOns\\(.-)CandyBar%-2%.2%.lua")
|
|
ourpath = "Interface\\AddOns\\" .. ourpath .. "bar.tga"
|
|
self.var = { -- "Local" variables go here
|
|
frame = CreateFrame("Frame"),
|
|
handlers = {},
|
|
groups = {},
|
|
framepool = {},
|
|
addons = {},
|
|
defaults = {
|
|
texture = "Interface\\TargetingFrame\\UI-StatusBar",
|
|
width = 200,
|
|
height = 22,
|
|
scale = 1,
|
|
point = "CENTER",
|
|
rframe = UIParent,
|
|
rpoint = "CENTER",
|
|
xoffset = 0,
|
|
yoffset = 0,
|
|
fontsize = 11,
|
|
color = { 1, 0, 1, 1 },
|
|
bgcolor = { 0, .5, .5, .5 },
|
|
textcolor = { 1, 1, 1, 1 },
|
|
timertextcolor = { 1, 1, 1, 1 },
|
|
}
|
|
}
|
|
self.var.frame:Hide()
|
|
self.var.frame.name = "CandyBar-2.2 Frame"
|
|
end
|
|
self.var.frame:SetScript("OnUpdate", self.OnUpdate)
|
|
self.var.frame.owner = self
|
|
|
|
if oldDeactivate then
|
|
oldDeactivate(oldLib)
|
|
end
|
|
end
|
|
|
|
local function external(self, major, instance)
|
|
if major == "Compost-2.0" then
|
|
compost = instance
|
|
end
|
|
end
|
|
|
|
AceLibrary:Register(CandyBar, vmajor, vminor, CandyBar.activate, nil, external)
|