Sattva
1679 lines
54 KiB
Lua
1679 lines
54 KiB
Lua
----------------------------------------------------------------------
|
|
-- L00: Leatrix Plus Library
|
|
----------------------------------------------------------------------
|
|
|
|
-- LibDBIcon 10.0.1:
|
|
-- 11: LibStub: (?s)-- LibStubStart\R?\K.*?(?=-- LibStubEnd)
|
|
-- 12: LibCallbackHandler: (?s)-- CallbackStart\R?\K.*?(?=-- CallbackEnd)
|
|
-- 13: LibDataBroker: (?s)-- DataBrokerStart\R?\K.*?(?=-- DataBrokerEnd)
|
|
-- 14: LibDBIcon: (?s)-- LibDBIconStart\R?\K.*?(?=-- LibDBIconEnd)
|
|
|
|
-- LibChatAnims 10.0.1:
|
|
-- 15: LibChatAnims: (?s)-- LibChatAnimsStart\R?\K.*?(?=-- LibChatAnimsEnd)
|
|
|
|
-- LibCandyBar 10.0.1:
|
|
-- 16: LibCandyBar: (?s)-- LibCandyBarStart\R?\K.*?(?=-- LibCandyBarEnd)
|
|
|
|
local void, Leatrix_Plus = ...
|
|
|
|
----------------------------------------------------------------------
|
|
-- L11: LibDBIcon: LibStub
|
|
----------------------------------------------------------------------
|
|
|
|
local function LeaLibStub()
|
|
|
|
-- LibStubStart
|
|
-- $Id: LibStub.lua 76 2007-09-03 01:50:17Z mikk $
|
|
-- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/wiki/LibStub for more info
|
|
-- LibStub is hereby placed in the Public Domain
|
|
-- Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke
|
|
local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2 -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS!
|
|
local LibStub = _G[LIBSTUB_MAJOR]
|
|
|
|
-- Check to see is this version of the stub is obsolete
|
|
if not LibStub or LibStub.minor < LIBSTUB_MINOR then
|
|
LibStub = LibStub or {libs = {}, minors = {} }
|
|
_G[LIBSTUB_MAJOR] = LibStub
|
|
LibStub.minor = LIBSTUB_MINOR
|
|
|
|
-- LibStub:NewLibrary(major, minor)
|
|
-- major (string) - the major version of the library
|
|
-- minor (string or number ) - the minor version of the library
|
|
--
|
|
-- returns nil if a newer or same version of the lib is already present
|
|
-- returns empty library object or old library object if upgrade is needed
|
|
function LibStub:NewLibrary(major, minor)
|
|
assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)")
|
|
minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.")
|
|
|
|
local oldminor = self.minors[major]
|
|
if oldminor and oldminor >= minor then return nil end
|
|
self.minors[major], self.libs[major] = minor, self.libs[major] or {}
|
|
return self.libs[major], oldminor
|
|
end
|
|
|
|
-- LibStub:GetLibrary(major, [silent])
|
|
-- major (string) - the major version of the library
|
|
-- silent (boolean) - if true, library is optional, silently return nil if its not found
|
|
--
|
|
-- throws an error if the library can not be found (except silent is set)
|
|
-- returns the library object if found
|
|
function LibStub:GetLibrary(major, silent)
|
|
if not self.libs[major] and not silent then
|
|
error(("Cannot find a library instance of %q."):format(tostring(major)), 2)
|
|
end
|
|
return self.libs[major], self.minors[major]
|
|
end
|
|
|
|
-- LibStub:IterateLibraries()
|
|
--
|
|
-- Returns an iterator for the currently registered libraries
|
|
function LibStub:IterateLibraries()
|
|
return pairs(self.libs)
|
|
end
|
|
|
|
setmetatable(LibStub, { __call = LibStub.GetLibrary })
|
|
end
|
|
-- LibStubEnd
|
|
|
|
end
|
|
LeaLibStub()
|
|
|
|
----------------------------------------------------------------------
|
|
-- L12: LibDBIcon: CallbackHandler
|
|
----------------------------------------------------------------------
|
|
|
|
local function LeaCallbackHandler()
|
|
|
|
-- CallbackStart
|
|
--[[ $Id: CallbackHandler-1.0.lua 26 2022-12-12 15:09:39Z nevcairiel $ ]]
|
|
local MAJOR, MINOR = "CallbackHandler-1.0", 8
|
|
local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR)
|
|
|
|
if not CallbackHandler then return end -- No upgrade needed
|
|
|
|
local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end}
|
|
|
|
-- Lua APIs
|
|
local securecallfunction, error = securecallfunction, error
|
|
local setmetatable, rawget = setmetatable, rawget
|
|
local next, select, pairs, type, tostring = next, select, pairs, type, tostring
|
|
|
|
|
|
local function Dispatch(handlers, ...)
|
|
local index, method = next(handlers)
|
|
if not method then return end
|
|
repeat
|
|
securecallfunction(method, ...)
|
|
index, method = next(handlers, index)
|
|
until not method
|
|
end
|
|
|
|
--------------------------------------------------------------------------
|
|
-- CallbackHandler:New
|
|
--
|
|
-- target - target object to embed public APIs in
|
|
-- RegisterName - name of the callback registration API, default "RegisterCallback"
|
|
-- UnregisterName - name of the callback unregistration API, default "UnregisterCallback"
|
|
-- UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API.
|
|
|
|
function CallbackHandler.New(_self, target, RegisterName, UnregisterName, UnregisterAllName)
|
|
|
|
RegisterName = RegisterName or "RegisterCallback"
|
|
UnregisterName = UnregisterName or "UnregisterCallback"
|
|
if UnregisterAllName==nil then -- false is used to indicate "don't want this method"
|
|
UnregisterAllName = "UnregisterAllCallbacks"
|
|
end
|
|
|
|
-- we declare all objects and exported APIs inside this closure to quickly gain access
|
|
-- to e.g. function names, the "target" parameter, etc
|
|
|
|
|
|
-- Create the registry object
|
|
local events = setmetatable({}, meta)
|
|
local registry = { recurse=0, events=events }
|
|
|
|
-- registry:Fire() - fires the given event/message into the registry
|
|
function registry:Fire(eventname, ...)
|
|
if not rawget(events, eventname) or not next(events[eventname]) then return end
|
|
local oldrecurse = registry.recurse
|
|
registry.recurse = oldrecurse + 1
|
|
|
|
Dispatch(events[eventname], eventname, ...)
|
|
|
|
registry.recurse = oldrecurse
|
|
|
|
if registry.insertQueue and oldrecurse==0 then
|
|
-- Something in one of our callbacks wanted to register more callbacks; they got queued
|
|
for event,callbacks in pairs(registry.insertQueue) do
|
|
local first = not rawget(events, event) or not next(events[event]) -- test for empty before. not test for one member after. that one member may have been overwritten.
|
|
for object,func in pairs(callbacks) do
|
|
events[event][object] = func
|
|
-- fire OnUsed callback?
|
|
if first and registry.OnUsed then
|
|
registry.OnUsed(registry, target, event)
|
|
first = nil
|
|
end
|
|
end
|
|
end
|
|
registry.insertQueue = nil
|
|
end
|
|
end
|
|
|
|
-- Registration of a callback, handles:
|
|
-- self["method"], leads to self["method"](self, ...)
|
|
-- self with function ref, leads to functionref(...)
|
|
-- "addonId" (instead of self) with function ref, leads to functionref(...)
|
|
-- all with an optional arg, which, if present, gets passed as first argument (after self if present)
|
|
target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]])
|
|
if type(eventname) ~= "string" then
|
|
error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2)
|
|
end
|
|
|
|
method = method or eventname
|
|
|
|
local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten.
|
|
|
|
if type(method) ~= "string" and type(method) ~= "function" then
|
|
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2)
|
|
end
|
|
|
|
local regfunc
|
|
|
|
if type(method) == "string" then
|
|
-- self["method"] calling style
|
|
if type(self) ~= "table" then
|
|
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2)
|
|
elseif self==target then
|
|
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2)
|
|
elseif type(self[method]) ~= "function" then
|
|
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2)
|
|
end
|
|
|
|
if select("#",...)>=1 then -- this is not the same as testing for arg==nil!
|
|
local arg=select(1,...)
|
|
regfunc = function(...) self[method](self,arg,...) end
|
|
else
|
|
regfunc = function(...) self[method](self,...) end
|
|
end
|
|
else
|
|
-- function ref with self=object or self="addonId" or self=thread
|
|
if type(self)~="table" and type(self)~="string" and type(self)~="thread" then
|
|
error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string or thread expected.", 2)
|
|
end
|
|
|
|
if select("#",...)>=1 then -- this is not the same as testing for arg==nil!
|
|
local arg=select(1,...)
|
|
regfunc = function(...) method(arg,...) end
|
|
else
|
|
regfunc = method
|
|
end
|
|
end
|
|
|
|
|
|
if events[eventname][self] or registry.recurse<1 then
|
|
-- if registry.recurse<1 then
|
|
-- we're overwriting an existing entry, or not currently recursing. just set it.
|
|
events[eventname][self] = regfunc
|
|
-- fire OnUsed callback?
|
|
if registry.OnUsed and first then
|
|
registry.OnUsed(registry, target, eventname)
|
|
end
|
|
else
|
|
-- we're currently processing a callback in this registry, so delay the registration of this new entry!
|
|
-- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency
|
|
registry.insertQueue = registry.insertQueue or setmetatable({},meta)
|
|
registry.insertQueue[eventname][self] = regfunc
|
|
end
|
|
end
|
|
|
|
-- Unregister a callback
|
|
target[UnregisterName] = function(self, eventname)
|
|
if not self or self==target then
|
|
error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2)
|
|
end
|
|
if type(eventname) ~= "string" then
|
|
error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2)
|
|
end
|
|
if rawget(events, eventname) and events[eventname][self] then
|
|
events[eventname][self] = nil
|
|
-- Fire OnUnused callback?
|
|
if registry.OnUnused and not next(events[eventname]) then
|
|
registry.OnUnused(registry, target, eventname)
|
|
end
|
|
end
|
|
if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then
|
|
registry.insertQueue[eventname][self] = nil
|
|
end
|
|
end
|
|
|
|
-- OPTIONAL: Unregister all callbacks for given selfs/addonIds
|
|
if UnregisterAllName then
|
|
target[UnregisterAllName] = function(...)
|
|
if select("#",...)<1 then
|
|
error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2)
|
|
end
|
|
if select("#",...)==1 and ...==target then
|
|
error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2)
|
|
end
|
|
|
|
|
|
for i=1,select("#",...) do
|
|
local self = select(i,...)
|
|
if registry.insertQueue then
|
|
for eventname, callbacks in pairs(registry.insertQueue) do
|
|
if callbacks[self] then
|
|
callbacks[self] = nil
|
|
end
|
|
end
|
|
end
|
|
for eventname, callbacks in pairs(events) do
|
|
if callbacks[self] then
|
|
callbacks[self] = nil
|
|
-- Fire OnUnused callback?
|
|
if registry.OnUnused and not next(callbacks) then
|
|
registry.OnUnused(registry, target, eventname)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return registry
|
|
end
|
|
|
|
|
|
-- CallbackHandler purposefully does NOT do explicit embedding. Nor does it
|
|
-- try to upgrade old implicit embeds since the system is selfcontained and
|
|
-- relies on closures to work.
|
|
|
|
-- CallbackEnd
|
|
end
|
|
|
|
LeaCallbackHandler()
|
|
|
|
----------------------------------------------------------------------
|
|
-- L13: LibDBIcon: LibDataBroker
|
|
----------------------------------------------------------------------
|
|
|
|
local function LeaDataBroker()
|
|
|
|
-- DataBrokerStart
|
|
|
|
assert(LibStub, "LibDataBroker-1.1 requires LibStub")
|
|
assert(LibStub:GetLibrary("CallbackHandler-1.0", true), "LibDataBroker-1.1 requires CallbackHandler-1.0")
|
|
|
|
local lib, oldminor = LibStub:NewLibrary("LibDataBroker-1.1", 4)
|
|
if not lib then return end
|
|
oldminor = oldminor or 0
|
|
|
|
|
|
lib.callbacks = lib.callbacks or LibStub:GetLibrary("CallbackHandler-1.0"):New(lib)
|
|
lib.attributestorage, lib.namestorage, lib.proxystorage = lib.attributestorage or {}, lib.namestorage or {}, lib.proxystorage or {}
|
|
local attributestorage, namestorage, callbacks = lib.attributestorage, lib.namestorage, lib.callbacks
|
|
|
|
if oldminor < 2 then
|
|
lib.domt = {
|
|
__metatable = "access denied",
|
|
__index = function(self, key) return attributestorage[self] and attributestorage[self][key] end,
|
|
}
|
|
end
|
|
|
|
if oldminor < 3 then
|
|
lib.domt.__newindex = function(self, key, value)
|
|
if not attributestorage[self] then attributestorage[self] = {} end
|
|
if attributestorage[self][key] == value then return end
|
|
attributestorage[self][key] = value
|
|
local name = namestorage[self]
|
|
if not name then return end
|
|
callbacks:Fire("LibDataBroker_AttributeChanged", name, key, value, self)
|
|
callbacks:Fire("LibDataBroker_AttributeChanged_"..name, name, key, value, self)
|
|
callbacks:Fire("LibDataBroker_AttributeChanged_"..name.."_"..key, name, key, value, self)
|
|
callbacks:Fire("LibDataBroker_AttributeChanged__"..key, name, key, value, self)
|
|
end
|
|
end
|
|
|
|
if oldminor < 2 then
|
|
function lib:NewDataObject(name, dataobj)
|
|
if self.proxystorage[name] then return end
|
|
|
|
if dataobj then
|
|
assert(type(dataobj) == "table", "Invalid dataobj, must be nil or a table")
|
|
self.attributestorage[dataobj] = {}
|
|
for i,v in pairs(dataobj) do
|
|
self.attributestorage[dataobj][i] = v
|
|
dataobj[i] = nil
|
|
end
|
|
end
|
|
dataobj = setmetatable(dataobj or {}, self.domt)
|
|
self.proxystorage[name], self.namestorage[dataobj] = dataobj, name
|
|
self.callbacks:Fire("LibDataBroker_DataObjectCreated", name, dataobj)
|
|
return dataobj
|
|
end
|
|
end
|
|
|
|
if oldminor < 1 then
|
|
function lib:DataObjectIterator()
|
|
return pairs(self.proxystorage)
|
|
end
|
|
|
|
function lib:GetDataObjectByName(dataobjectname)
|
|
return self.proxystorage[dataobjectname]
|
|
end
|
|
|
|
function lib:GetNameByDataObject(dataobject)
|
|
return self.namestorage[dataobject]
|
|
end
|
|
end
|
|
|
|
if oldminor < 4 then
|
|
local next = pairs(attributestorage)
|
|
function lib:pairs(dataobject_or_name)
|
|
local t = type(dataobject_or_name)
|
|
assert(t == "string" or t == "table", "Usage: ldb:pairs('dataobjectname') or ldb:pairs(dataobject)")
|
|
|
|
local dataobj = self.proxystorage[dataobject_or_name] or dataobject_or_name
|
|
assert(attributestorage[dataobj], "Data object not found")
|
|
|
|
return next, attributestorage[dataobj], nil
|
|
end
|
|
|
|
local ipairs_iter = ipairs(attributestorage)
|
|
function lib:ipairs(dataobject_or_name)
|
|
local t = type(dataobject_or_name)
|
|
assert(t == "string" or t == "table", "Usage: ldb:ipairs('dataobjectname') or ldb:ipairs(dataobject)")
|
|
|
|
local dataobj = self.proxystorage[dataobject_or_name] or dataobject_or_name
|
|
assert(attributestorage[dataobj], "Data object not found")
|
|
|
|
return ipairs_iter, attributestorage[dataobj], 0
|
|
end
|
|
end
|
|
-- DataBrokerEnd
|
|
|
|
end
|
|
LeaDataBroker()
|
|
|
|
----------------------------------------------------------------------
|
|
-- L14: LibDBIcon: LibDBIcon
|
|
----------------------------------------------------------------------
|
|
|
|
local function LeaLibDBIcon()
|
|
|
|
-- LibDBIconStart
|
|
--@curseforge-project-slug: libdbicon-1-0@
|
|
-----------------------------------------------------------------------
|
|
-- LibDBIcon-1.0
|
|
--
|
|
-- Allows addons to easily create a lightweight minimap icon as an alternative to heavier LDB displays.
|
|
--
|
|
|
|
local DBICON10 = "LibDBIcon-1.0"
|
|
local DBICON10_MINOR = 45 -- Bump on changes
|
|
if not LibStub then error(DBICON10 .. " requires LibStub.") end
|
|
local ldb = LibStub("LibDataBroker-1.1", true)
|
|
if not ldb then error(DBICON10 .. " requires LibDataBroker-1.1.") end
|
|
local lib = LibStub:NewLibrary(DBICON10, DBICON10_MINOR)
|
|
if not lib then return end
|
|
|
|
lib.objects = lib.objects or {}
|
|
lib.callbackRegistered = lib.callbackRegistered or nil
|
|
lib.callbacks = lib.callbacks or LibStub("CallbackHandler-1.0"):New(lib)
|
|
lib.notCreated = lib.notCreated or {}
|
|
lib.radius = lib.radius or 5
|
|
local next, Minimap, CreateFrame = next, Minimap, CreateFrame
|
|
lib.tooltip = lib.tooltip or CreateFrame("GameTooltip", "LibDBIconTooltip", UIParent, "GameTooltipTemplate")
|
|
local isDraggingButton = false
|
|
|
|
function lib:IconCallback(event, name, key, value)
|
|
if lib.objects[name] then
|
|
if key == "icon" then
|
|
lib.objects[name].icon:SetTexture(value)
|
|
elseif key == "iconCoords" then
|
|
lib.objects[name].icon:UpdateCoord()
|
|
elseif key == "iconR" then
|
|
local _, g, b = lib.objects[name].icon:GetVertexColor()
|
|
lib.objects[name].icon:SetVertexColor(value, g, b)
|
|
elseif key == "iconG" then
|
|
local r, _, b = lib.objects[name].icon:GetVertexColor()
|
|
lib.objects[name].icon:SetVertexColor(r, value, b)
|
|
elseif key == "iconB" then
|
|
local r, g = lib.objects[name].icon:GetVertexColor()
|
|
lib.objects[name].icon:SetVertexColor(r, g, value)
|
|
end
|
|
end
|
|
end
|
|
if not lib.callbackRegistered then
|
|
ldb.RegisterCallback(lib, "LibDataBroker_AttributeChanged__icon", "IconCallback")
|
|
ldb.RegisterCallback(lib, "LibDataBroker_AttributeChanged__iconCoords", "IconCallback")
|
|
ldb.RegisterCallback(lib, "LibDataBroker_AttributeChanged__iconR", "IconCallback")
|
|
ldb.RegisterCallback(lib, "LibDataBroker_AttributeChanged__iconG", "IconCallback")
|
|
ldb.RegisterCallback(lib, "LibDataBroker_AttributeChanged__iconB", "IconCallback")
|
|
lib.callbackRegistered = true
|
|
end
|
|
|
|
local function getAnchors(frame)
|
|
local x, y = frame:GetCenter()
|
|
if not x or not y then return "CENTER" end
|
|
local hhalf = (x > UIParent:GetWidth()*2/3) and "RIGHT" or (x < UIParent:GetWidth()/3) and "LEFT" or ""
|
|
local vhalf = (y > UIParent:GetHeight()/2) and "TOP" or "BOTTOM"
|
|
return vhalf..hhalf, frame, (vhalf == "TOP" and "BOTTOM" or "TOP")..hhalf
|
|
end
|
|
|
|
local function onEnter(self)
|
|
if isDraggingButton then return end
|
|
|
|
for _, button in next, lib.objects do
|
|
if button.showOnMouseover then
|
|
button.fadeOut:Stop()
|
|
button:SetAlpha(1)
|
|
end
|
|
end
|
|
|
|
local obj = self.dataObject
|
|
if obj.OnTooltipShow then
|
|
lib.tooltip:SetOwner(self, "ANCHOR_NONE")
|
|
lib.tooltip:SetPoint(getAnchors(self))
|
|
obj.OnTooltipShow(lib.tooltip)
|
|
lib.tooltip:Show()
|
|
elseif obj.OnEnter then
|
|
obj.OnEnter(self)
|
|
end
|
|
end
|
|
|
|
local function onLeave(self)
|
|
lib.tooltip:Hide()
|
|
|
|
if not isDraggingButton then
|
|
for _, button in next, lib.objects do
|
|
if button.showOnMouseover then
|
|
button.fadeOut:Play()
|
|
end
|
|
end
|
|
end
|
|
|
|
local obj = self.dataObject
|
|
if obj.OnLeave then
|
|
obj.OnLeave(self)
|
|
end
|
|
end
|
|
|
|
--------------------------------------------------------------------------------
|
|
|
|
local onDragStart, updatePosition
|
|
|
|
do
|
|
local minimapShapes = {
|
|
["ROUND"] = {true, true, true, true},
|
|
["SQUARE"] = {false, false, false, false},
|
|
["CORNER-TOPLEFT"] = {false, false, false, true},
|
|
["CORNER-TOPRIGHT"] = {false, false, true, false},
|
|
["CORNER-BOTTOMLEFT"] = {false, true, false, false},
|
|
["CORNER-BOTTOMRIGHT"] = {true, false, false, false},
|
|
["SIDE-LEFT"] = {false, true, false, true},
|
|
["SIDE-RIGHT"] = {true, false, true, false},
|
|
["SIDE-TOP"] = {false, false, true, true},
|
|
["SIDE-BOTTOM"] = {true, true, false, false},
|
|
["TRICORNER-TOPLEFT"] = {false, true, true, true},
|
|
["TRICORNER-TOPRIGHT"] = {true, false, true, true},
|
|
["TRICORNER-BOTTOMLEFT"] = {true, true, false, true},
|
|
["TRICORNER-BOTTOMRIGHT"] = {true, true, true, false},
|
|
}
|
|
|
|
local rad, cos, sin, sqrt, max, min = math.rad, math.cos, math.sin, math.sqrt, math.max, math.min
|
|
function updatePosition(button, position)
|
|
local angle = rad(position or 225)
|
|
local x, y, q = cos(angle), sin(angle), 1
|
|
if x < 0 then q = q + 1 end
|
|
if y > 0 then q = q + 2 end
|
|
local minimapShape = GetMinimapShape and GetMinimapShape() or "ROUND"
|
|
local quadTable = minimapShapes[minimapShape]
|
|
local w = (Minimap:GetWidth() / 2) + lib.radius
|
|
local h = (Minimap:GetHeight() / 2) + lib.radius
|
|
if quadTable[q] then
|
|
x, y = x*w, y*h
|
|
else
|
|
local diagRadiusW = sqrt(2*(w)^2)-10
|
|
local diagRadiusH = sqrt(2*(h)^2)-10
|
|
x = max(-w, min(x*diagRadiusW, w))
|
|
y = max(-h, min(y*diagRadiusH, h))
|
|
end
|
|
button:SetPoint("CENTER", Minimap, "CENTER", x, y)
|
|
end
|
|
end
|
|
|
|
local function onClick(self, b)
|
|
if self.dataObject.OnClick then
|
|
self.dataObject.OnClick(self, b)
|
|
end
|
|
end
|
|
|
|
local function onMouseDown(self)
|
|
self.isMouseDown = true
|
|
self.icon:UpdateCoord()
|
|
end
|
|
|
|
local function onMouseUp(self)
|
|
self.isMouseDown = false
|
|
self.icon:UpdateCoord()
|
|
end
|
|
|
|
do
|
|
local deg, atan2 = math.deg, math.atan2
|
|
local function onUpdate(self)
|
|
local mx, my = Minimap:GetCenter()
|
|
local px, py = GetCursorPosition()
|
|
local scale = Minimap:GetEffectiveScale()
|
|
px, py = px / scale, py / scale
|
|
local pos = 225
|
|
if self.db then
|
|
pos = deg(atan2(py - my, px - mx)) % 360
|
|
self.db.minimapPos = pos
|
|
else
|
|
pos = deg(atan2(py - my, px - mx)) % 360
|
|
self.minimapPos = pos
|
|
end
|
|
updatePosition(self, pos)
|
|
end
|
|
|
|
function onDragStart(self)
|
|
self:LockHighlight()
|
|
self.isMouseDown = true
|
|
self.icon:UpdateCoord()
|
|
self:SetScript("OnUpdate", onUpdate)
|
|
isDraggingButton = true
|
|
lib.tooltip:Hide()
|
|
for _, button in next, lib.objects do
|
|
if button.showOnMouseover then
|
|
button.fadeOut:Stop()
|
|
button:SetAlpha(1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function onDragStop(self)
|
|
self:SetScript("OnUpdate", nil)
|
|
self.isMouseDown = false
|
|
self.icon:UpdateCoord()
|
|
self:UnlockHighlight()
|
|
isDraggingButton = false
|
|
for _, button in next, lib.objects do
|
|
if button.showOnMouseover then
|
|
button.fadeOut:Play()
|
|
end
|
|
end
|
|
end
|
|
|
|
local defaultCoords = {0, 1, 0, 1}
|
|
local function updateCoord(self)
|
|
local coords = self:GetParent().dataObject.iconCoords or defaultCoords
|
|
local deltaX, deltaY = 0, 0
|
|
if not self:GetParent().isMouseDown then
|
|
deltaX = (coords[2] - coords[1]) * 0.05
|
|
deltaY = (coords[4] - coords[3]) * 0.05
|
|
end
|
|
self:SetTexCoord(coords[1] + deltaX, coords[2] - deltaX, coords[3] + deltaY, coords[4] - deltaY)
|
|
end
|
|
|
|
local function createButton(name, object, db)
|
|
local button = CreateFrame("Button", "LibDBIcon10_"..name, Minimap)
|
|
button.dataObject = object
|
|
button.db = db
|
|
button:SetFrameStrata("MEDIUM")
|
|
-- button:SetFixedFrameStrata(true)
|
|
button:SetFrameLevel(8)
|
|
-- button:SetFixedFrameLevel(true)
|
|
button:SetSize(31, 31)
|
|
button:RegisterForClicks("anyUp")
|
|
button:RegisterForDrag("LeftButton")
|
|
button:SetHighlightTexture(136477) --"Interface\\Minimap\\UI-Minimap-ZoomButton-Highlight"
|
|
if WOW_PROJECT_ID == WOW_PROJECT_MAINLINE then
|
|
local overlay = button:CreateTexture(nil, "OVERLAY")
|
|
overlay:SetSize(50, 50)
|
|
overlay:SetTexture(136430) --"Interface\\Minimap\\MiniMap-TrackingBorder"
|
|
overlay:SetPoint("TOPLEFT", button, "TOPLEFT", 0, 0)
|
|
local background = button:CreateTexture(nil, "BACKGROUND")
|
|
background:SetSize(24, 24)
|
|
background:SetTexture(136467) --"Interface\\Minimap\\UI-Minimap-Background"
|
|
background:SetPoint("CENTER", button, "CENTER", 0, 1)
|
|
local icon = button:CreateTexture(nil, "ARTWORK")
|
|
icon:SetSize(18, 18)
|
|
icon:SetTexture(object.icon)
|
|
icon:SetPoint("CENTER", button, "CENTER", 0, 1)
|
|
button.icon = icon
|
|
else
|
|
local overlay = button:CreateTexture(nil, "OVERLAY")
|
|
overlay:SetSize(53, 53)
|
|
overlay:SetTexture(136430) --"Interface\\Minimap\\MiniMap-TrackingBorder"
|
|
overlay:SetPoint("TOPLEFT")
|
|
local background = button:CreateTexture(nil, "BACKGROUND")
|
|
background:SetSize(20, 20)
|
|
background:SetTexture(136467) --"Interface\\Minimap\\UI-Minimap-Background"
|
|
background:SetPoint("TOPLEFT", 7, -5)
|
|
local icon = button:CreateTexture(nil, "ARTWORK")
|
|
icon:SetSize(17, 17)
|
|
icon:SetTexture(object.icon)
|
|
icon:SetPoint("TOPLEFT", 7, -6)
|
|
button.icon = icon
|
|
end
|
|
|
|
button.isMouseDown = false
|
|
local r, g, b = button.icon:GetVertexColor()
|
|
button.icon:SetVertexColor(object.iconR or r, object.iconG or g, object.iconB or b)
|
|
|
|
button.icon.UpdateCoord = updateCoord
|
|
button.icon:UpdateCoord()
|
|
|
|
button:SetScript("OnEnter", onEnter)
|
|
button:SetScript("OnLeave", onLeave)
|
|
button:SetScript("OnClick", onClick)
|
|
if not db or not db.lock then
|
|
button:SetScript("OnDragStart", onDragStart)
|
|
button:SetScript("OnDragStop", onDragStop)
|
|
end
|
|
button:SetScript("OnMouseDown", onMouseDown)
|
|
button:SetScript("OnMouseUp", onMouseUp)
|
|
|
|
button.fadeOut = button:CreateAnimationGroup()
|
|
local animOut = button.fadeOut:CreateAnimation("Alpha")
|
|
-- animOut:SetOrder(1)
|
|
-- animOut:SetDuration(0.2)
|
|
-- animOut:SetFromAlpha(1)
|
|
-- animOut:SetToAlpha(0)
|
|
-- animOut:SetStartDelay(1)
|
|
-- button.fadeOut:SetToFinalAlpha(true)
|
|
|
|
lib.objects[name] = button
|
|
|
|
if lib.loggedIn then
|
|
updatePosition(button, db and db.minimapPos)
|
|
if not db or not db.hide then
|
|
button:Show()
|
|
else
|
|
button:Hide()
|
|
end
|
|
end
|
|
lib.callbacks:Fire("LibDBIcon_IconCreated", button, name) -- Fire 'Icon Created' callback
|
|
end
|
|
|
|
-- We could use a metatable.__index on lib.objects, but then we'd create
|
|
-- the icons when checking things like :IsRegistered, which is not necessary.
|
|
local function check(name)
|
|
if lib.notCreated[name] then
|
|
createButton(name, lib.notCreated[name][1], lib.notCreated[name][2])
|
|
lib.notCreated[name] = nil
|
|
end
|
|
end
|
|
|
|
-- Wait a bit with the initial positioning to let any GetMinimapShape addons
|
|
-- load up.
|
|
if not lib.loggedIn then
|
|
local f = CreateFrame("Frame")
|
|
f:SetScript("OnEvent", function(f)
|
|
for _, button in next, lib.objects do
|
|
updatePosition(button, button.db and button.db.minimapPos)
|
|
if not button.db or not button.db.hide then
|
|
button:Show()
|
|
else
|
|
button:Hide()
|
|
end
|
|
end
|
|
lib.loggedIn = true
|
|
f:SetScript("OnEvent", nil)
|
|
end)
|
|
f:RegisterEvent("PLAYER_LOGIN")
|
|
end
|
|
|
|
local function getDatabase(name)
|
|
return lib.notCreated[name] and lib.notCreated[name][2] or lib.objects[name].db
|
|
end
|
|
|
|
function lib:Register(name, object, db)
|
|
if not object.icon then error("Can't register LDB objects without icons set!") end
|
|
if lib.objects[name] or lib.notCreated[name] then error(DBICON10.. ": Object '".. name .."' is already registered.") end
|
|
if not db or not db.hide then
|
|
createButton(name, object, db)
|
|
else
|
|
lib.notCreated[name] = {object, db}
|
|
end
|
|
end
|
|
|
|
function lib:Lock(name)
|
|
if not lib:IsRegistered(name) then return end
|
|
if lib.objects[name] then
|
|
lib.objects[name]:SetScript("OnDragStart", nil)
|
|
lib.objects[name]:SetScript("OnDragStop", nil)
|
|
end
|
|
local db = getDatabase(name)
|
|
if db then
|
|
db.lock = true
|
|
end
|
|
end
|
|
|
|
function lib:Unlock(name)
|
|
if not lib:IsRegistered(name) then return end
|
|
if lib.objects[name] then
|
|
lib.objects[name]:SetScript("OnDragStart", onDragStart)
|
|
lib.objects[name]:SetScript("OnDragStop", onDragStop)
|
|
end
|
|
local db = getDatabase(name)
|
|
if db then
|
|
db.lock = nil
|
|
end
|
|
end
|
|
|
|
function lib:Hide(name)
|
|
if not lib.objects[name] then return end
|
|
lib.objects[name]:Hide()
|
|
end
|
|
|
|
function lib:Show(name)
|
|
check(name)
|
|
local button = lib.objects[name]
|
|
if button then
|
|
button:Show()
|
|
updatePosition(button, button.db and button.db.minimapPos or button.minimapPos)
|
|
end
|
|
end
|
|
|
|
function lib:IsRegistered(name)
|
|
return (lib.objects[name] or lib.notCreated[name]) and true or false
|
|
end
|
|
|
|
function lib:Refresh(name, db)
|
|
check(name)
|
|
local button = lib.objects[name]
|
|
if db then
|
|
button.db = db
|
|
end
|
|
updatePosition(button, button.db and button.db.minimapPos or button.minimapPos)
|
|
if not button.db or not button.db.hide then
|
|
button:Show()
|
|
else
|
|
button:Hide()
|
|
end
|
|
if not button.db or not button.db.lock then
|
|
button:SetScript("OnDragStart", onDragStart)
|
|
button:SetScript("OnDragStop", onDragStop)
|
|
else
|
|
button:SetScript("OnDragStart", nil)
|
|
button:SetScript("OnDragStop", nil)
|
|
end
|
|
end
|
|
|
|
function lib:GetMinimapButton(name)
|
|
return lib.objects[name]
|
|
end
|
|
|
|
do
|
|
local function OnMinimapEnter()
|
|
if isDraggingButton then return end
|
|
for _, button in next, lib.objects do
|
|
if button.showOnMouseover then
|
|
button.fadeOut:Stop()
|
|
button:SetAlpha(1)
|
|
end
|
|
end
|
|
end
|
|
local function OnMinimapLeave()
|
|
if isDraggingButton then return end
|
|
for _, button in next, lib.objects do
|
|
if button.showOnMouseover then
|
|
button.fadeOut:Play()
|
|
end
|
|
end
|
|
end
|
|
Minimap:HookScript("OnEnter", OnMinimapEnter)
|
|
Minimap:HookScript("OnLeave", OnMinimapLeave)
|
|
|
|
function lib:ShowOnEnter(name, value)
|
|
local button = lib.objects[name]
|
|
if button then
|
|
if value then
|
|
button.showOnMouseover = true
|
|
button.fadeOut:Stop()
|
|
button:SetAlpha(0)
|
|
else
|
|
button.showOnMouseover = false
|
|
button.fadeOut:Stop()
|
|
button:SetAlpha(1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function lib:GetButtonList()
|
|
local t = {}
|
|
for name in next, lib.objects do
|
|
t[#t+1] = name
|
|
end
|
|
return t
|
|
end
|
|
|
|
function lib:SetButtonRadius(radius)
|
|
if type(radius) == "number" then
|
|
lib.radius = radius
|
|
for _, button in next, lib.objects do
|
|
updatePosition(button, button.db and button.db.minimapPos or button.minimapPos)
|
|
end
|
|
end
|
|
end
|
|
|
|
function lib:SetButtonToPosition(button, position)
|
|
updatePosition(lib.objects[button] or button, position)
|
|
end
|
|
|
|
-- Upgrade!
|
|
for name, button in next, lib.objects do
|
|
local db = getDatabase(name)
|
|
if not db or not db.lock then
|
|
button:SetScript("OnDragStart", onDragStart)
|
|
button:SetScript("OnDragStop", onDragStop)
|
|
end
|
|
button:SetScript("OnEnter", onEnter)
|
|
button:SetScript("OnLeave", onLeave)
|
|
button:SetScript("OnClick", onClick)
|
|
button:SetScript("OnMouseDown", onMouseDown)
|
|
button:SetScript("OnMouseUp", onMouseUp)
|
|
|
|
if not button.fadeOut then -- Upgrade to 39
|
|
button.fadeOut = button:CreateAnimationGroup()
|
|
local animOut = button.fadeOut:CreateAnimation("Alpha")
|
|
animOut:SetOrder(1)
|
|
animOut:SetDuration(0.2)
|
|
animOut:SetFromAlpha(1)
|
|
animOut:SetToAlpha(0)
|
|
animOut:SetStartDelay(1)
|
|
button.fadeOut:SetToFinalAlpha(true)
|
|
end
|
|
end
|
|
lib:SetButtonRadius(lib.radius) -- Upgrade to 40
|
|
-- LibDBIconEnd
|
|
|
|
end
|
|
-- LeaLibDBIcon() -- disabled in 3.3.5, was causing red things
|
|
|
|
|
|
----------------------------------------------------------------------
|
|
-- L15: LibChatAnims (load on demand)
|
|
----------------------------------------------------------------------
|
|
|
|
function Leatrix_Plus:LeaPlusLCA()
|
|
|
|
-- LibChatAnimsStart
|
|
--@curseforge-project-slug: libchatanims@
|
|
local MAJOR, MINOR = "LibChatAnims", 4 -- Bump minor on changes
|
|
local LCA = LibStub:NewLibrary(MAJOR, MINOR)
|
|
if not LCA then return end -- No upgrade needed
|
|
|
|
LCA.animations = LCA.animations or {} -- Animation storage
|
|
LCA.alerting = LCA.alerting or {} -- Chat tab alerting storage
|
|
local anims = LCA.animations
|
|
local alerting = LCA.alerting
|
|
|
|
function LCA:IsAlerting(tab)
|
|
if alerting[tab] then
|
|
return true
|
|
end
|
|
end
|
|
|
|
----------------------------------------------------
|
|
-- Note, most of this code is simply replicated from
|
|
-- Blizzard's FloatingChatFrame.lua file.
|
|
-- The only real changes are the creation and use
|
|
-- of animations vs the use of UIFrameFlash.
|
|
--
|
|
|
|
--FCFDockOverflowButton_UpdatePulseState = function(self)
|
|
-- local dock = self:GetParent()
|
|
-- local shouldPulse = false
|
|
-- for _, chatFrame in pairs(FCFDock_GetChatFrames(dock)) do
|
|
-- local chatTab = _G[chatFrame:GetName().."Tab"]
|
|
-- if ( not chatFrame.isStaticDocked and chatTab.alerting) then
|
|
-- -- Make sure the rects are valid. (Not always the case when resizing the WoW client
|
|
-- if ( not chatTab:GetRight() or not dock.scrollFrame:GetRight() ) then
|
|
-- return false
|
|
-- end
|
|
-- -- Check if it's off the screen.
|
|
-- local DELTA = 3 -- Chosen through experimentation
|
|
-- if ( chatTab:GetRight() < (dock.scrollFrame:GetLeft() + DELTA) or chatTab:GetLeft() > (dock.scrollFrame:GetRight() - DELTA) ) then
|
|
-- shouldPulse = true
|
|
-- break
|
|
-- end
|
|
-- end
|
|
-- end
|
|
--
|
|
-- local tex = self:GetHighlightTexture()
|
|
-- if shouldPulse then
|
|
-- if not anims[tex] then
|
|
-- anims[tex] = tex:CreateAnimationGroup()
|
|
--
|
|
-- local fade1 = anims[tex]:CreateAnimation("Alpha")
|
|
-- fade1:SetDuration(1)
|
|
-- fade1:SetFromAlpha(0)
|
|
-- fade1:SetToAlpha(1)
|
|
-- fade1:SetOrder(1)
|
|
--
|
|
-- local fade2 = anims[tex]:CreateAnimation("Alpha")
|
|
-- fade2:SetDuration(1)
|
|
-- fade2:SetFromAlpha(1)
|
|
-- fade2:SetToAlpha(0)
|
|
-- fade2:SetOrder(2)
|
|
-- end
|
|
-- tex:Show()
|
|
-- tex:SetAlpha(0)
|
|
-- anims[tex]:SetLooping("REPEAT")
|
|
-- anims[tex]:Play()
|
|
--
|
|
-- self:LockHighlight()
|
|
-- self.alerting = true
|
|
-- else
|
|
-- if anims[tex] then
|
|
-- anims[tex]:Stop()
|
|
-- end
|
|
-- self:UnlockHighlight()
|
|
-- tex:SetAlpha(1)
|
|
-- tex:Show()
|
|
-- self.alerting = false
|
|
-- end
|
|
--
|
|
-- if self.list:IsShown() then
|
|
-- FCFDockOverflowList_Update(self.list, dock)
|
|
-- end
|
|
-- return true
|
|
--end
|
|
|
|
--FCFDockOverflowListButton_SetValue = function(button, chatFrame)
|
|
-- local chatTab = _G[chatFrame:GetName().."Tab"]
|
|
-- button.chatFrame = chatFrame
|
|
-- button:SetText(chatFrame.name)
|
|
--
|
|
-- local colorTable = chatTab.selectedColorTable or DEFAULT_TAB_SELECTED_COLOR_TABLE
|
|
--
|
|
-- if chatTab.selectedColorTable then
|
|
-- button:GetFontString():SetTextColor(colorTable.r, colorTable.g, colorTable.b)
|
|
-- else
|
|
-- button:GetFontString():SetTextColor(NORMAL_FONT_COLOR.r, NORMAL_FONT_COLOR.g, NORMAL_FONT_COLOR.b)
|
|
-- end
|
|
--
|
|
-- button.glow:SetVertexColor(colorTable.r, colorTable.g, colorTable.b)
|
|
--
|
|
-- if chatTab.conversationIcon then
|
|
-- button.conversationIcon:SetVertexColor(colorTable.r, colorTable.g, colorTable.b)
|
|
-- button.conversationIcon:Show()
|
|
-- else
|
|
-- button.conversationIcon:Hide()
|
|
-- end
|
|
--
|
|
-- if chatTab.alerting then
|
|
-- button.alerting = true
|
|
-- if not anims[button.glow] then
|
|
-- anims[button.glow] = button.glow:CreateAnimationGroup()
|
|
--
|
|
-- local fade1 = anims[button.glow]:CreateAnimation("Alpha")
|
|
-- fade1:SetDuration(1)
|
|
-- fade1:SetFromAlpha(0)
|
|
-- fade1:SetToAlpha(1)
|
|
-- fade1:SetOrder(1)
|
|
--
|
|
-- local fade2 = anims[button.glow]:CreateAnimation("Alpha")
|
|
-- fade2:SetDuration(1)
|
|
-- fade2:SetFromAlpha(1)
|
|
-- fade2:SetToAlpha(0)
|
|
-- fade2:SetOrder(2)
|
|
-- end
|
|
-- button.glow:Show()
|
|
-- button.glow:SetAlpha(0)
|
|
-- anims[button.glow]:SetLooping("REPEAT")
|
|
-- anims[button.glow]:Play()
|
|
-- else
|
|
-- button.alerting = false
|
|
-- if anims[button.glow] then
|
|
-- anims[button.glow]:Stop()
|
|
-- end
|
|
-- button.glow:Hide()
|
|
-- end
|
|
-- button:Show()
|
|
--end
|
|
|
|
FCF_StartAlertFlash = function(chatFrame)
|
|
local chatTab = _G[chatFrame:GetName().."Tab"]
|
|
|
|
if chatFrame.minFrame then
|
|
if not anims[chatFrame.minFrame] then
|
|
anims[chatFrame.minFrame] = chatFrame.minFrame.glow:CreateAnimationGroup()
|
|
|
|
local fade1 = anims[chatFrame.minFrame]:CreateAnimation("Alpha")
|
|
fade1:SetDuration(1)
|
|
fade1:SetFromAlpha(0)
|
|
fade1:SetToAlpha(1)
|
|
fade1:SetOrder(1)
|
|
|
|
local fade2 = anims[chatFrame.minFrame]:CreateAnimation("Alpha")
|
|
fade2:SetDuration(1)
|
|
fade2:SetFromAlpha(1)
|
|
fade2:SetToAlpha(0)
|
|
fade2:SetOrder(2)
|
|
end
|
|
chatFrame.minFrame.glow:Show()
|
|
chatFrame.minFrame.glow:SetAlpha(0)
|
|
anims[chatFrame.minFrame]:SetLooping("REPEAT")
|
|
anims[chatFrame.minFrame]:Play()
|
|
--chatFrame.minFrame.alerting = true
|
|
alerting[chatFrame.minFrame] = true
|
|
end
|
|
|
|
if not anims[chatTab.glow] then
|
|
anims[chatTab.glow] = chatTab.glow:CreateAnimationGroup()
|
|
|
|
local fade1 = anims[chatTab.glow]:CreateAnimation("Alpha")
|
|
fade1:SetDuration(1)
|
|
fade1:SetFromAlpha(0)
|
|
fade1:SetToAlpha(1)
|
|
fade1:SetOrder(1)
|
|
|
|
local fade2 = anims[chatTab.glow]:CreateAnimation("Alpha")
|
|
fade2:SetDuration(1)
|
|
fade2:SetFromAlpha(1)
|
|
fade2:SetToAlpha(0)
|
|
fade2:SetOrder(2)
|
|
end
|
|
chatTab.glow:Show()
|
|
chatTab.glow:SetAlpha(0)
|
|
anims[chatTab.glow]:SetLooping("REPEAT")
|
|
anims[chatTab.glow]:Play()
|
|
--chatTab.alerting = true
|
|
alerting[chatTab] = true
|
|
|
|
|
|
-- START function FCFTab_UpdateAlpha(chatFrame)
|
|
local mouseOverAlpha, noMouseAlpha = 0, 0
|
|
if not chatFrame.isDocked or chatFrame == FCFDock_GetSelectedWindow(GENERAL_CHAT_DOCK) then
|
|
mouseOverAlpha = 1.0 --CHAT_FRAME_TAB_SELECTED_MOUSEOVER_ALPHA
|
|
noMouseAlpha = 0.4 -- CHAT_FRAME_TAB_SELECTED_NOMOUSE_ALPHA
|
|
else
|
|
mouseOverAlpha = 1.0 -- CHAT_FRAME_TAB_ALERTING_MOUSEOVER_ALPHA
|
|
noMouseAlpha = 1.0 -- CHAT_FRAME_TAB_ALERTING_NOMOUSE_ALPHA
|
|
end
|
|
if chatFrame.hasBeenFaded then
|
|
chatTab:SetAlpha(mouseOverAlpha)
|
|
else
|
|
chatTab:SetAlpha(noMouseAlpha)
|
|
end
|
|
--END function FCFTab_UpdateAlpha(chatFrame)
|
|
|
|
--FCFDockOverflowButton_UpdatePulseState(GENERAL_CHAT_DOCK.overflowButton)
|
|
end
|
|
|
|
FCF_StopAlertFlash = function(chatFrame)
|
|
local chatTab = _G[chatFrame:GetName().."Tab"]
|
|
|
|
if chatFrame.minFrame then
|
|
if anims[chatFrame.minFrame] then
|
|
anims[chatFrame.minFrame]:Stop()
|
|
end
|
|
chatFrame.minFrame.glow:Hide()
|
|
--chatFrame.minFrame.alerting = false
|
|
alerting[chatFrame.minFrame] = nil
|
|
end
|
|
|
|
if anims[chatTab.glow] then
|
|
anims[chatTab.glow]:Stop()
|
|
end
|
|
chatTab.glow:Hide()
|
|
--chatTab.alerting = false
|
|
alerting[chatTab] = nil
|
|
|
|
-- START function FCFTab_UpdateAlpha(chatFrame)
|
|
local mouseOverAlpha, noMouseAlpha = 0, 0
|
|
if not chatFrame.isDocked or chatFrame == FCFDock_GetSelectedWindow(GENERAL_CHAT_DOCK) then
|
|
mouseOverAlpha = 1.0 --CHAT_FRAME_TAB_SELECTED_MOUSEOVER_ALPHA
|
|
noMouseAlpha = 0.4 -- CHAT_FRAME_TAB_SELECTED_NOMOUSE_ALPHA
|
|
else
|
|
mouseOverAlpha = 0.6 --CHAT_FRAME_TAB_NORMAL_MOUSEOVER_ALPHA
|
|
noMouseAlpha = 0.2 --CHAT_FRAME_TAB_NORMAL_NOMOUSE_ALPHA
|
|
end
|
|
if chatFrame.hasBeenFaded then
|
|
chatTab:SetAlpha(mouseOverAlpha)
|
|
else
|
|
chatTab:SetAlpha(noMouseAlpha)
|
|
end
|
|
--END function FCFTab_UpdateAlpha(chatFrame)
|
|
|
|
--FCFDockOverflowButton_UpdatePulseState(GENERAL_CHAT_DOCK.overflowButton)
|
|
end
|
|
|
|
-- LibChatAnimsEnd
|
|
|
|
end
|
|
|
|
----------------------------------------------------------------------
|
|
-- L16: LibDBIcon: LibCandyBar
|
|
----------------------------------------------------------------------
|
|
|
|
function Leatrix_Plus:LeaPlusCandyBar()
|
|
|
|
-- LibCandyBarStart
|
|
--@curseforge-project-slug: libcandybar-3-0@
|
|
--- **LibCandyBar-3.0** provides elegant timerbars with icons for use in addons.
|
|
-- It is based of the original ideas of the CandyBar and CandyBar-2.0 library.
|
|
-- In contrary to the earlier libraries LibCandyBar-3.0 provides you with a timerbar object with a simple API.
|
|
--
|
|
-- Creating a new timerbar using the ':New' function will return a new timerbar object. This timerbar object inherits all of the barPrototype functions listed here. \\
|
|
--
|
|
-- @usage
|
|
-- local candy = LibStub("LibCandyBar-3.0")
|
|
-- local texture = "Interface\\AddOns\\MyAddOn\\statusbar"
|
|
-- local mybar = candy:New(texture, 100, 16)
|
|
-- mybar:SetLabel("Yay!")
|
|
-- mybar:SetDuration(60)
|
|
-- mybar:Start()
|
|
-- @class file
|
|
-- @name LibCandyBar-3.0
|
|
|
|
local GetTime, floor, next = GetTime, floor, next
|
|
local CreateFrame, error, setmetatable, UIParent = CreateFrame, error, setmetatable, UIParent
|
|
|
|
if not LibStub then error("LibCandyBar-3.0 requires LibStub.") end
|
|
local cbh = LibStub:GetLibrary("CallbackHandler-1.0")
|
|
if not cbh then error("LibCandyBar-3.0 requires CallbackHandler-1.0") end
|
|
local lib = LibStub:NewLibrary("LibCandyBar-3.0", 100) -- Bump minor on changes
|
|
if not lib then return end
|
|
lib.callbacks = lib.callbacks or cbh:New(lib)
|
|
local cb = lib.callbacks
|
|
lib.dummyFrame = lib.dummyFrame or CreateFrame("Frame")
|
|
lib.barFrameMT = lib.barFrameMT or {__index = lib.dummyFrame}
|
|
lib.barPrototype = lib.barPrototype or setmetatable({}, lib.barFrameMT)
|
|
lib.barPrototype_mt = lib.barPrototype_mt or {__index = lib.barPrototype}
|
|
lib.barCache = lib.barCache or {}
|
|
|
|
local barPrototype = lib.barPrototype
|
|
local barPrototype_meta = lib.barPrototype_mt
|
|
local barCache = lib.barCache
|
|
|
|
local scripts = {
|
|
"OnUpdate", "OnDragStart", "OnDragStop",
|
|
"OnEnter", "OnLeave", "OnHide",
|
|
"OnShow", "OnMouseDown", "OnMouseUp",
|
|
"OnMouseWheel", "OnSizeChanged", "OnEvent"
|
|
}
|
|
local numScripts = #scripts
|
|
local GameFontHighlightSmallOutline = GameFontHighlightSmallOutline
|
|
local _fontName, _fontSize = GameFontHighlightSmallOutline:GetFont()
|
|
local _fontShadowX, _fontShadowY = GameFontHighlightSmallOutline:GetShadowOffset()
|
|
local _fontShadowR, _fontShadowG, _fontShadowB, _fontShadowA = GameFontHighlightSmallOutline:GetShadowColor()
|
|
local SetWidth, SetHeight, SetSize = lib.dummyFrame.SetWidth, lib.dummyFrame.SetHeight, lib.dummyFrame.SetSize
|
|
|
|
local function stopBar(bar)
|
|
bar.updater:Stop()
|
|
bar.data = nil
|
|
bar.funcs = nil
|
|
bar.running = nil
|
|
bar.paused = nil
|
|
bar:Hide()
|
|
bar:SetParent(UIParent)
|
|
end
|
|
|
|
local tformat1 = "%d:%02d:%02d"
|
|
local tformat2 = "%d:%02d"
|
|
local tformat3 = "%.1f"
|
|
local tformat4 = "%.0f"
|
|
local function barUpdate(updater)
|
|
local bar = updater.parent
|
|
local t = GetTime()
|
|
if t >= bar.exp then
|
|
bar:Stop()
|
|
else
|
|
local time = bar.exp - t
|
|
bar.remaining = time
|
|
|
|
bar.candyBarBar:SetValue(bar.fill and (t-bar.start)+bar.gap or time)
|
|
|
|
if time > 3599.9 then -- > 1 hour
|
|
local h = floor(time/3600)
|
|
local m = floor((time - (h*3600))/60)
|
|
local s = (time - (m*60)) - (h*3600)
|
|
bar.candyBarDuration:SetFormattedText(tformat1, h, m, s)
|
|
elseif time > 59.9 then -- 1 minute to 1 hour
|
|
local m = floor(time/60)
|
|
local s = time - (m*60)
|
|
bar.candyBarDuration:SetFormattedText(tformat2, m, s)
|
|
elseif time < 10 then -- 0 to 10 seconds
|
|
bar.candyBarDuration:SetFormattedText(tformat3, time)
|
|
else -- 10 seconds to one minute
|
|
bar.candyBarDuration:SetFormattedText(tformat4, time)
|
|
end
|
|
|
|
if bar.funcs then
|
|
for i = 1, #bar.funcs do
|
|
bar.funcs[i](bar)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local atformat1 = "~%d:%02d:%02d"
|
|
local atformat2 = "~%d:%02d"
|
|
local atformat3 = "~%.1f"
|
|
local atformat4 = "~%.0f"
|
|
local function barUpdateApprox(updater)
|
|
local bar = updater.parent
|
|
local t = GetTime()
|
|
if t >= bar.exp then
|
|
bar:Stop()
|
|
else
|
|
local time = bar.exp - t
|
|
bar.remaining = time
|
|
|
|
bar.candyBarBar:SetValue(bar.fill and (t-bar.start)+bar.gap or time)
|
|
|
|
if time > 3599.9 then -- > 1 hour
|
|
local h = floor(time/3600)
|
|
local m = floor((time - (h*3600))/60)
|
|
local s = (time - (m*60)) - (h*3600)
|
|
bar.candyBarDuration:SetFormattedText(atformat1, h, m, s)
|
|
elseif time > 59.9 then -- 1 minute to 1 hour
|
|
local m = floor(time/60)
|
|
local s = time - (m*60)
|
|
bar.candyBarDuration:SetFormattedText(atformat2, m, s)
|
|
elseif time < 10 then -- 0 to 10 seconds
|
|
bar.candyBarDuration:SetFormattedText(atformat3, time)
|
|
else -- 10 seconds to one minute
|
|
bar.candyBarDuration:SetFormattedText(atformat4, time)
|
|
end
|
|
|
|
if bar.funcs then
|
|
for i = 1, #bar.funcs do
|
|
bar.funcs[i](bar)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- ------------------------------------------------------------------------------
|
|
-- Bar functions
|
|
--
|
|
|
|
local function restyleBar(self)
|
|
if not self.running then return end
|
|
self.candyBarIconFrame:ClearAllPoints()
|
|
self.candyBarBar:ClearAllPoints()
|
|
-- In the past we used a :GetTexture check here, but as of WoW v5 it randomly returns nil, so use our own trustworthy variable.
|
|
if self.candyBarIconFrame.icon then
|
|
self.candyBarIconFrame:SetWidth(self.height)
|
|
if self.iconPosition == "RIGHT" then
|
|
self.candyBarIconFrame:SetPoint("TOPRIGHT", self)
|
|
self.candyBarIconFrame:SetPoint("BOTTOMRIGHT", self)
|
|
self.candyBarBar:SetPoint("TOPRIGHT", self.candyBarIconFrame, "TOPLEFT")
|
|
self.candyBarBar:SetPoint("BOTTOMRIGHT", self.candyBarIconFrame, "BOTTOMLEFT")
|
|
self.candyBarBar:SetPoint("TOPLEFT", self)
|
|
self.candyBarBar:SetPoint("BOTTOMLEFT", self)
|
|
else
|
|
self.candyBarIconFrame:SetPoint("TOPLEFT")
|
|
self.candyBarIconFrame:SetPoint("BOTTOMLEFT")
|
|
self.candyBarBar:SetPoint("TOPLEFT", self.candyBarIconFrame, "TOPRIGHT")
|
|
self.candyBarBar:SetPoint("BOTTOMLEFT", self.candyBarIconFrame, "BOTTOMRIGHT")
|
|
self.candyBarBar:SetPoint("TOPRIGHT", self)
|
|
self.candyBarBar:SetPoint("BOTTOMRIGHT", self)
|
|
end
|
|
self.candyBarIconFrame:Show()
|
|
else
|
|
self.candyBarBar:SetPoint("TOPLEFT", self)
|
|
self.candyBarBar:SetPoint("BOTTOMRIGHT", self)
|
|
self.candyBarIconFrame:Hide()
|
|
end
|
|
if self.showLabel and self.candyBarLabel.text then
|
|
self.candyBarLabel:Show()
|
|
else
|
|
self.candyBarLabel:Hide()
|
|
end
|
|
if self.showTime then
|
|
self.candyBarDuration:Show()
|
|
else
|
|
self.candyBarDuration:Hide()
|
|
end
|
|
end
|
|
|
|
--- Set whether the bar should drain (default) or fill up.
|
|
-- @param fill Boolean true/false
|
|
function barPrototype:SetFill(fill)
|
|
self.fill = fill
|
|
end
|
|
--- Adds a function to the timerbar. The function will run every update and will receive the bar as a parameter.
|
|
-- @param func Function to run every update.
|
|
-- @usage
|
|
-- -- The example below will print the time remaining to the chatframe every update. Yes, that's a whole lot of spam
|
|
-- mybar:AddUpdateFunction( function(bar) print(bar.remaining) end )
|
|
function barPrototype:AddUpdateFunction(func) if not self.funcs then self.funcs = {} end; self.funcs[#self.funcs+1] = func end
|
|
--- Sets user data in the timerbar object.
|
|
-- @param key Key to use for the data storage.
|
|
-- @param data Data to store.
|
|
function barPrototype:Set(key, data) if not self.data then self.data = {} end; self.data[key] = data end
|
|
--- Retrieves user data from the timerbar object.
|
|
-- @param key Key to retrieve
|
|
function barPrototype:Get(key) return self.data and self.data[key] end
|
|
--- Sets the color of the bar.
|
|
-- This is basically a wrapper to SetStatusBarColor.
|
|
-- @paramsig r, g, b, a
|
|
-- @param r Red component (0-1)
|
|
-- @param g Green component (0-1)
|
|
-- @param b Blue component (0-1)
|
|
-- @param a Alpha (0-1)
|
|
function barPrototype:SetColor(...) self.candyBarBar:SetStatusBarColor(...) end
|
|
--- Sets the color of the bar label and bar duration text.
|
|
-- @paramsig r, g, b, a
|
|
-- @param r Red component (0-1)
|
|
-- @param g Green component (0-1)
|
|
-- @param b Blue component (0-1)
|
|
-- @param a Alpha (0-1)
|
|
function barPrototype:SetTextColor(...)
|
|
self.candyBarLabel:SetTextColor(...)
|
|
self.candyBarDuration:SetTextColor(...)
|
|
end
|
|
--- Sets the shadow color of the bar label and bar duration text.
|
|
-- @paramsig r, g, b, a
|
|
-- @param r Red component (0-1)
|
|
-- @param g Green component (0-1)
|
|
-- @param b Blue component (0-1)
|
|
-- @param a Alpha (0-1)
|
|
function barPrototype:SetShadowColor(...)
|
|
self.candyBarLabel:SetShadowColor(...)
|
|
self.candyBarDuration:SetShadowColor(...)
|
|
end
|
|
--- Sets the texture of the bar.
|
|
-- This should only be needed on running bars that get changed on the fly.
|
|
-- @param texture Path to the bar texture.
|
|
function barPrototype:SetTexture(texture)
|
|
self.candyBarBar:SetStatusBarTexture(texture)
|
|
self.candyBarBackground:SetTexture(texture)
|
|
end
|
|
--- Sets the width of the bar.
|
|
-- This should only be needed on running bars that get changed on the fly.
|
|
-- @param width Width of the bar.
|
|
function barPrototype:SetWidth(width)
|
|
self.width = width
|
|
SetWidth(self, width)
|
|
end
|
|
--- Sets the height of the bar.
|
|
-- This should only be needed on running bars that get changed on the fly.
|
|
-- @param height Height of the bar.
|
|
function barPrototype:SetHeight(height)
|
|
self.height = height
|
|
SetHeight(self, height)
|
|
restyleBar(self)
|
|
end
|
|
--- Sets the size of the bar.
|
|
-- This should only be needed on running bars that get changed on the fly.
|
|
-- @param width Width of the bar.
|
|
-- @param height Height of the bar.
|
|
function barPrototype:SetSize(width, height)
|
|
self.width = width
|
|
self.height = height
|
|
SetSize(self, width, height)
|
|
restyleBar(self)
|
|
end
|
|
--- Returns the label (text) currently set on the bar.
|
|
function barPrototype:GetLabel()
|
|
return self.candyBarLabel.text
|
|
end
|
|
--- Sets the label on the bar.
|
|
-- @param text Label text.
|
|
function barPrototype:SetLabel(text)
|
|
self.candyBarLabel.text = text
|
|
self.candyBarLabel:SetText(text)
|
|
if text then
|
|
self.candyBarLabel:Show()
|
|
else
|
|
self.candyBarLabel:Hide()
|
|
end
|
|
end
|
|
--- Returns the icon texture path currently set on the bar, if it has an icon set.
|
|
function barPrototype:GetIcon()
|
|
return self.candyBarIconFrame.icon
|
|
end
|
|
--- Sets the icon next to the bar.
|
|
-- @param icon Path to the icon texture or nil to not display an icon.
|
|
-- @param ... Optional icon coordinates for texture trimming.
|
|
function barPrototype:SetIcon(icon, ...)
|
|
self.candyBarIconFrame.icon = icon
|
|
self.candyBarIconFrame:SetTexture(icon)
|
|
if ... then
|
|
self.candyBarIconFrame:SetTexCoord(...)
|
|
else
|
|
self.candyBarIconFrame:SetTexCoord(0.07, 0.93, 0.07, 0.93)
|
|
end
|
|
restyleBar(self)
|
|
end
|
|
--- Sets which side of the bar the icon should appear.
|
|
-- @param position Position of the icon according to the bar, either "LEFT" or "RIGHT" as a string. Set to "LEFT" by default.
|
|
function barPrototype:SetIconPosition(position)
|
|
self.iconPosition = position
|
|
restyleBar(self)
|
|
end
|
|
--- Sets wether or not the time indicator on the right of the bar should be shown.
|
|
-- Time is shown by default.
|
|
-- @param bool true to show the time, false/nil to hide the time.
|
|
function barPrototype:SetTimeVisibility(bool)
|
|
self.showTime = bool
|
|
if bool then
|
|
self.candyBarDuration:Show()
|
|
else
|
|
self.candyBarDuration:Hide()
|
|
end
|
|
end
|
|
--- Sets wether or not the label on the left of the bar should be shown.
|
|
-- label is shown by default.
|
|
-- @param bool true to show the label, false/nil to hide the label.
|
|
function barPrototype:SetLabelVisibility(bool)
|
|
self.showLabel = bool
|
|
if bool then
|
|
self.candyBarLabel:Show()
|
|
else
|
|
self.candyBarLabel:Hide()
|
|
end
|
|
end
|
|
--- Sets the duration of the bar.
|
|
-- This can also be used while the bar is running to adjust the time remaining, within the bounds of the original duration.
|
|
-- @param duration Duration of the bar in seconds.
|
|
-- @param isApprox Boolean. True if you wish the time display to be an approximate "~5" instead of "5"
|
|
function barPrototype:SetDuration(duration, isApprox) self.remaining = duration; self.isApproximate = isApprox end
|
|
--- Shows the bar and starts it.
|
|
-- @param maxValue Number. If you don't wish your bar to start full, you can set a max value. A maxValue of 10 on a bar with a duration of 5 would start it at 50%.
|
|
function barPrototype:Start(maxValue)
|
|
self.running = true
|
|
local time = self.remaining
|
|
self.gap = maxValue and maxValue-time or 0
|
|
restyleBar(self)
|
|
self.start = GetTime()
|
|
self.exp = self.start + time
|
|
|
|
self.candyBarBar:SetMinMaxValues(0, maxValue or time)
|
|
self.candyBarBar:SetValue(self.fill and 0 or time)
|
|
|
|
if self.isApproximate then
|
|
if time > 3599.9 then -- > 1 hour
|
|
local h = floor(time/3600)
|
|
local m = floor((time - (h*3600))/60)
|
|
local s = (time - (m*60)) - (h*3600)
|
|
self.candyBarDuration:SetFormattedText(atformat1, h, m, s)
|
|
elseif time > 59.9 then -- 1 minute to 1 hour
|
|
local m = floor(time/60)
|
|
local s = time - (m*60)
|
|
self.candyBarDuration:SetFormattedText(atformat2, m, s)
|
|
elseif time < 10 then -- 0 to 10 seconds
|
|
self.candyBarDuration:SetFormattedText(atformat3, time)
|
|
else -- 10 seconds to one minute
|
|
self.candyBarDuration:SetFormattedText(atformat4, time)
|
|
end
|
|
self.updater:SetScript("OnLoop", barUpdateApprox)
|
|
else
|
|
if time > 3599.9 then -- > 1 hour
|
|
local h = floor(time/3600)
|
|
local m = floor((time - (h*3600))/60)
|
|
local s = (time - (m*60)) - (h*3600)
|
|
self.candyBarDuration:SetFormattedText(tformat1, h, m, s)
|
|
elseif time > 59.9 then -- 1 minute to 1 hour
|
|
local m = floor(time/60)
|
|
local s = time - (m*60)
|
|
self.candyBarDuration:SetFormattedText(tformat2, m, s)
|
|
elseif time < 10 then -- 0 to 10 seconds
|
|
self.candyBarDuration:SetFormattedText(tformat3, time)
|
|
else -- 10 seconds to one minute
|
|
self.candyBarDuration:SetFormattedText(tformat4, time)
|
|
end
|
|
self.updater:SetScript("OnLoop", barUpdate)
|
|
end
|
|
self.updater:Play()
|
|
self:Show()
|
|
end
|
|
--- Pauses a running bar
|
|
function barPrototype:Pause()
|
|
if not self.paused then
|
|
self.updater:Pause()
|
|
self.paused = GetTime()
|
|
end
|
|
end
|
|
--- Resumes a paused bar
|
|
function barPrototype:Resume()
|
|
if self.paused then
|
|
local t = GetTime()
|
|
self.exp = t + self.remaining
|
|
self.start = self.start + (t-self.paused)
|
|
self.updater:Play()
|
|
self.paused = nil
|
|
end
|
|
end
|
|
--- Stops the bar.
|
|
-- This will stop the bar, fire the LibCandyBar_Stop callback, and recycle the bar into the candybar pool.
|
|
-- Note: make sure you remove all references to the bar in your addon upon receiving the LibCandyBar_Stop callback.
|
|
-- @usage
|
|
-- -- The example below shows the use of the LibCandyBar_Stop callback by printing the contents of the label in the chatframe
|
|
-- local function barstopped( callback, bar )
|
|
-- print( bar:GetLabel(), "stopped")
|
|
-- end
|
|
-- LibStub("LibCandyBar-3.0"):RegisterCallback(myaddonobject, "LibCandyBar_Stop", barstopped)
|
|
-- @param ... Optional args to pass across in the LibCandyBar_Stop callback.
|
|
function barPrototype:Stop(...)
|
|
cb:Fire("LibCandyBar_Stop", self, ...)
|
|
stopBar(self)
|
|
barCache[self] = true
|
|
end
|
|
|
|
-- ------------------------------------------------------------------------------
|
|
-- Library functions
|
|
--
|
|
|
|
--- Creates a new timerbar object and returns it. Don't forget to set the duration, label and :Start the timer bar after you get a hold of it!
|
|
-- @paramsig texture, width, height
|
|
-- @param texture Path to the texture used for the bar.
|
|
-- @param width Width of the bar.
|
|
-- @param height Height of the bar.
|
|
-- @usage
|
|
-- mybar = LibStub("LibCandyBar-3.0"):New("Interface\\AddOns\\MyAddOn\\media\\statusbar", 100, 16)
|
|
function lib:New(texture, width, height)
|
|
local bar = next(barCache)
|
|
if not bar then
|
|
local frame = CreateFrame("Frame", nil, UIParent)
|
|
bar = setmetatable(frame, barPrototype_meta)
|
|
|
|
local icon = bar:CreateTexture()
|
|
icon:SetPoint("TOPLEFT")
|
|
icon:SetPoint("BOTTOMLEFT")
|
|
icon:Show()
|
|
bar.candyBarIconFrame = icon
|
|
|
|
local statusbar = CreateFrame("StatusBar", nil, bar)
|
|
statusbar:SetPoint("TOPRIGHT")
|
|
statusbar:SetPoint("BOTTOMRIGHT")
|
|
bar.candyBarBar = statusbar
|
|
|
|
local bg = statusbar:CreateTexture(nil, "BACKGROUND")
|
|
bg:SetAllPoints()
|
|
bar.candyBarBackground = bg
|
|
|
|
local backdrop = CreateFrame("Frame", nil, bar, "BackdropTemplate") -- Used by bar stylers for backdrops
|
|
backdrop:SetFrameLevel(0)
|
|
bar.candyBarBackdrop = backdrop
|
|
|
|
local iconBackdrop = CreateFrame("Frame", nil, bar, "BackdropTemplate") -- Used by bar stylers for backdrops
|
|
iconBackdrop:SetFrameLevel(0)
|
|
bar.candyBarIconFrameBackdrop = iconBackdrop
|
|
|
|
local duration = statusbar:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmallOutline")
|
|
duration:SetPoint("TOPLEFT", statusbar, "TOPLEFT", 2, 0)
|
|
duration:SetPoint("BOTTOMRIGHT", statusbar, "BOTTOMRIGHT", -2, 0)
|
|
bar.candyBarDuration = duration
|
|
|
|
local label = statusbar:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmallOutline")
|
|
label:SetPoint("TOPLEFT", statusbar, "TOPLEFT", 2, 0)
|
|
label:SetPoint("BOTTOMRIGHT", statusbar, "BOTTOMRIGHT", -2, 0)
|
|
bar.candyBarLabel = label
|
|
|
|
local updater = bar:CreateAnimationGroup()
|
|
updater:SetLooping("REPEAT")
|
|
updater.parent = bar
|
|
local anim = updater:CreateAnimation()
|
|
anim:SetDuration(0.04)
|
|
bar.updater = updater
|
|
bar.repeater = anim
|
|
else
|
|
barCache[bar] = nil
|
|
end
|
|
|
|
bar:SetFrameStrata("MEDIUM")
|
|
bar:SetFrameLevel(100) -- Lots of room to create above or below this level
|
|
bar.candyBarBar:SetStatusBarTexture(texture)
|
|
bar.candyBarBackground:SetTexture(texture)
|
|
bar.width = width
|
|
bar.height = height
|
|
|
|
-- RESET ALL THE THINGS!
|
|
bar.fill = nil
|
|
bar.showTime = true
|
|
bar.showLabel = true
|
|
bar.iconPosition = nil
|
|
for i = 1, numScripts do -- Update if scripts table is changed, faster than doing #scripts
|
|
bar:SetScript(scripts[i], nil)
|
|
end
|
|
|
|
bar.candyBarBackground:SetVertexColor(0.5, 0.5, 0.5, 0.3)
|
|
bar.candyBarBar:SetStatusBarColor(0.5, 0.5, 0.5, 1)
|
|
bar:ClearAllPoints()
|
|
SetWidth(bar, width)
|
|
SetHeight(bar, height)
|
|
bar:SetMovable(1)
|
|
bar:SetScale(1)
|
|
bar:SetAlpha(1)
|
|
bar:SetClampedToScreen(false)
|
|
bar:EnableMouse(false)
|
|
|
|
bar.candyBarLabel:SetTextColor(1,1,1,1)
|
|
bar.candyBarLabel:SetJustifyH("LEFT")
|
|
bar.candyBarLabel:SetJustifyV("MIDDLE")
|
|
bar.candyBarLabel:SetFont(_fontName, _fontSize)
|
|
bar.candyBarLabel:SetShadowOffset(_fontShadowX, _fontShadowY)
|
|
bar.candyBarLabel:SetShadowColor(_fontShadowR, _fontShadowG, _fontShadowB, _fontShadowA)
|
|
|
|
bar.candyBarDuration:SetTextColor(1,1,1,1)
|
|
bar.candyBarDuration:SetJustifyH("RIGHT")
|
|
bar.candyBarDuration:SetJustifyV("MIDDLE")
|
|
bar.candyBarDuration:SetFont(_fontName, _fontSize)
|
|
bar.candyBarDuration:SetShadowOffset(_fontShadowX, _fontShadowY)
|
|
bar.candyBarDuration:SetShadowColor(_fontShadowR, _fontShadowG, _fontShadowB, _fontShadowA)
|
|
|
|
|
|
bar:SetLabel()
|
|
bar:SetIcon()
|
|
bar:SetDuration()
|
|
|
|
return bar
|
|
end
|
|
|
|
-- LibCandyBarEnd
|
|
|
|
end
|
|
|
|
-- L17: End
|