WoWInterface SVN mikma
Compare Revisions
- This comparison shows the changes necessary to convert path
/Duh/libs
- from Rev 650 to Rev 719
- ↔ Reverse comparison
Rev 650 → Rev 719
LibDBIcon-1.0/LibDBIcon-1.0.lua
1,6 → 1,6
| --[[ |
| Name: DBIcon-1.0 |
| Revision: $Rev: 25 $ |
| Revision: $Rev: 34 $ |
| Author(s): Rabbit (rabbit.magtheridon@gmail.com) |
| Description: Allows addons to register to recieve a lightweight minimap icon as an alternative to more heavy LDB displays. |
| Dependencies: LibStub |
33,7 → 33,7
| -- |
| local DBICON10 = "LibDBIcon-1.0" |
| local DBICON10_MINOR = tonumber(("$Rev: 25 $"):match("(%d+)")) |
| local DBICON10_MINOR = tonumber(("$Rev: 34 $"):match("(%d+)")) |
| 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 |
43,6 → 43,7
| lib.disabled = lib.disabled or nil |
| 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 {} |
| function lib:IconCallback(event, name, key, value, dataobj) |
51,12 → 52,24
| 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 |
90,7 → 103,7
| -------------------------------------------------------------------------------- |
| local onClick, onMouseUp, onMouseDown, onDragStart, onDragEnd, updatePosition |
| local onClick, onMouseUp, onMouseDown, onDragStart, onDragStop, onDragEnd, updatePosition |
| do |
| local minimapShapes = { |
180,26 → 193,29
| button.dataObject = object |
| button.db = db |
| button:SetFrameStrata("MEDIUM") |
| button:SetWidth(31); button:SetHeight(31) |
| button:SetSize(31, 31) |
| button:SetFrameLevel(8) |
| button:RegisterForClicks("anyUp") |
| button:RegisterForDrag("LeftButton") |
| button:SetHighlightTexture("Interface\\Minimap\\UI-Minimap-ZoomButton-Highlight") |
| local overlay = button:CreateTexture(nil, "OVERLAY") |
| overlay:SetWidth(53); overlay:SetHeight(53) |
| overlay:SetSize(53, 53) |
| overlay:SetTexture("Interface\\Minimap\\MiniMap-TrackingBorder") |
| overlay:SetPoint("TOPLEFT") |
| local background = button:CreateTexture(nil, "BACKGROUND") |
| background:SetWidth(20); background:SetHeight(20) |
| background:SetSize(20, 20) |
| background:SetTexture("Interface\\Minimap\\UI-Minimap-Background") |
| background:SetPoint("TOPLEFT", 7, -5) |
| local icon = button:CreateTexture(nil, "ARTWORK") |
| icon:SetWidth(17); icon:SetHeight(17) |
| icon:SetSize(17, 17) |
| icon:SetTexture(object.icon) |
| icon:SetPoint("TOPLEFT", 7, -6) |
| button.icon = icon |
| button.isMouseDown = false |
| local r, g, b = icon:GetVertexColor() |
| icon:SetVertexColor(object.iconR or r, object.iconG or g, object.iconB or b) |
| icon.UpdateCoord = updateCoord |
| icon:UpdateCoord() |
220,6 → 236,7
| 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 |
LibStub/LibStub.lua
1,30 → 1,51
| -- 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] |
| if not LibStub or LibStub.minor < LIBSTUB_MINOR then |
| LibStub = LibStub or {libs = {}, minors = {} } |
| _G[LIBSTUB_MAJOR] = LibStub |
| LibStub.minor = LIBSTUB_MINOR |
| 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 |
| 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 |
| function LibStub:IterateLibraries() return pairs(self.libs) end |
| setmetatable(LibStub, { __call = LibStub.GetLibrary }) |
| end |
| -- $Id: LibStub.lua 103 2014-10-16 03:02:50Z mikk $ |
| -- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/addons/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 |
CallbackHandler-1.0/CallbackHandler-1.0.xml
1,4 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="CallbackHandler-1.0.lua"/> |
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="CallbackHandler-1.0.lua"/> |
| </Ui> |
CallbackHandler-1.0/CallbackHandler-1.0.lua
1,240 → 1,238
| --[[ $Id: CallbackHandler-1.0.lua 965 2010-08-09 00:47:52Z mikk $ ]] |
| local MAJOR, MINOR = "CallbackHandler-1.0", 6 |
| 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 tconcat = table.concat |
| local assert, error, loadstring = assert, error, loadstring |
| local setmetatable, rawset, rawget = setmetatable, rawset, rawget |
| local next, select, pairs, type, tostring = next, select, pairs, type, tostring |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: geterrorhandler |
| local xpcall = xpcall |
| local function errorhandler(err) |
| return geterrorhandler()(err) |
| end |
| local function CreateDispatcher(argCount) |
| local code = [[ |
| local next, xpcall, eh = ... |
| local method, ARGS |
| local function call() method(ARGS) end |
| local function dispatch(handlers, ...) |
| local index |
| index, method = next(handlers) |
| if not method then return end |
| local OLD_ARGS = ARGS |
| ARGS = ... |
| repeat |
| xpcall(call, eh) |
| index, method = next(handlers, index) |
| until not method |
| ARGS = OLD_ARGS |
| end |
| return dispatch |
| ]] |
| local ARGS, OLD_ARGS = {}, {} |
| for i = 1, argCount do ARGS[i], OLD_ARGS[i] = "arg"..i, "old_arg"..i end |
| code = code:gsub("OLD_ARGS", tconcat(OLD_ARGS, ", ")):gsub("ARGS", tconcat(ARGS, ", ")) |
| return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(next, xpcall, errorhandler) |
| end |
| local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
| local dispatcher = CreateDispatcher(argCount) |
| rawset(self, argCount, dispatcher) |
| return dispatcher |
| 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(target, RegisterName, UnregisterName, UnregisterAllName, OnUsed, OnUnused) |
| -- TODO: Remove this after beta has gone out |
| assert(not OnUsed and not OnUnused, "ACE-80: OnUsed/OnUnused are deprecated. Callbacks are now done to registry.OnUsed and registry.OnUnused") |
| 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 |
| Dispatchers[select('#', ...) + 1](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 eventname,callbacks in pairs(registry.insertQueue) do |
| 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. |
| for self,func in pairs(callbacks) do |
| events[eventname][self] = func |
| -- fire OnUsed callback? |
| if first and registry.OnUsed then |
| registry.OnUsed(registry, target, eventname) |
| 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. |
| --[[ $Id: CallbackHandler-1.0.lua 18 2014-10-16 02:52:20Z mikk $ ]] |
| local MAJOR, MINOR = "CallbackHandler-1.0", 6 |
| 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 tconcat = table.concat |
| local assert, error, loadstring = assert, error, loadstring |
| local setmetatable, rawset, rawget = setmetatable, rawset, rawget |
| local next, select, pairs, type, tostring = next, select, pairs, type, tostring |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: geterrorhandler |
| local xpcall = xpcall |
| local function errorhandler(err) |
| return geterrorhandler()(err) |
| end |
| local function CreateDispatcher(argCount) |
| local code = [[ |
| local next, xpcall, eh = ... |
| local method, ARGS |
| local function call() method(ARGS) end |
| local function dispatch(handlers, ...) |
| local index |
| index, method = next(handlers) |
| if not method then return end |
| local OLD_ARGS = ARGS |
| ARGS = ... |
| repeat |
| xpcall(call, eh) |
| index, method = next(handlers, index) |
| until not method |
| ARGS = OLD_ARGS |
| end |
| return dispatch |
| ]] |
| local ARGS, OLD_ARGS = {}, {} |
| for i = 1, argCount do ARGS[i], OLD_ARGS[i] = "arg"..i, "old_arg"..i end |
| code = code:gsub("OLD_ARGS", tconcat(OLD_ARGS, ", ")):gsub("ARGS", tconcat(ARGS, ", ")) |
| return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(next, xpcall, errorhandler) |
| end |
| local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
| local dispatcher = CreateDispatcher(argCount) |
| rawset(self, argCount, dispatcher) |
| return dispatcher |
| 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(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 |
| Dispatchers[select('#', ...) + 1](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 eventname,callbacks in pairs(registry.insertQueue) do |
| 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. |
| for self,func in pairs(callbacks) do |
| events[eventname][self] = func |
| -- fire OnUsed callback? |
| if first and registry.OnUsed then |
| registry.OnUsed(registry, target, eventname) |
| 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. |
AceDB-3.0/AceDB-3.0.xml
1,4 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="AceDB-3.0.lua"/> |
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="AceDB-3.0.lua"/> |
| </Ui> |
AceDB-3.0/AceDB-3.0.lua
1,728 → 1,745
| --- **AceDB-3.0** manages the SavedVariables of your addon. |
| -- It offers profile management, smart defaults and namespaces for modules.\\ |
| -- Data can be saved in different data-types, depending on its intended usage. |
| -- The most common data-type is the `profile` type, which allows the user to choose |
| -- the active profile, and manage the profiles of all of his characters.\\ |
| -- The following data types are available: |
| -- * **char** Character-specific data. Every character has its own database. |
| -- * **realm** Realm-specific data. All of the players characters on the same realm share this database. |
| -- * **class** Class-specific data. All of the players characters of the same class share this database. |
| -- * **race** Race-specific data. All of the players characters of the same race share this database. |
| -- * **faction** Faction-specific data. All of the players characters of the same faction share this database. |
| -- * **factionrealm** Faction and realm specific data. All of the players characters on the same realm and of the same faction share this database. |
| -- * **global** Global Data. All characters on the same account share this database. |
| -- * **profile** Profile-specific data. All characters using the same profile share this database. The user can control which profile should be used. |
| -- |
| -- Creating a new Database using the `:New` function will return a new DBObject. A database will inherit all functions |
| -- of the DBObjectLib listed here. \\ |
| -- If you create a new namespaced child-database (`:RegisterNamespace`), you'll get a DBObject as well, but note |
| -- that the child-databases cannot individually change their profile, and are linked to their parents profile - and because of that, |
| -- the profile related APIs are not available. Only `:RegisterDefaults` and `:ResetProfile` are available on child-databases. |
| -- |
| -- For more details on how to use AceDB-3.0, see the [[AceDB-3.0 Tutorial]]. |
| -- |
| -- You may also be interested in [[libdualspec-1-0|LibDualSpec-1.0]] to do profile switching automatically when switching specs. |
| -- |
| -- @usage |
| -- MyAddon = LibStub("AceAddon-3.0"):NewAddon("DBExample") |
| -- |
| -- -- declare defaults to be used in the DB |
| -- local defaults = { |
| -- profile = { |
| -- setting = true, |
| -- } |
| -- } |
| -- |
| -- function MyAddon:OnInitialize() |
| -- -- Assuming the .toc says ## SavedVariables: MyAddonDB |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
| -- end |
| -- @class file |
| -- @name AceDB-3.0.lua |
| -- @release $Id: AceDB-3.0.lua 940 2010-06-19 08:01:47Z nevcairiel $ |
| local ACEDB_MAJOR, ACEDB_MINOR = "AceDB-3.0", 21 |
| local AceDB, oldminor = LibStub:NewLibrary(ACEDB_MAJOR, ACEDB_MINOR) |
| if not AceDB then return end -- No upgrade needed |
| -- Lua APIs |
| local type, pairs, next, error = type, pairs, next, error |
| local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget |
| -- WoW APIs |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: LibStub |
| AceDB.db_registry = AceDB.db_registry or {} |
| AceDB.frame = AceDB.frame or CreateFrame("Frame") |
| local CallbackHandler |
| local CallbackDummy = { Fire = function() end } |
| local DBObjectLib = {} |
| --[[------------------------------------------------------------------------- |
| AceDB Utility Functions |
| ---------------------------------------------------------------------------]] |
| -- Simple shallow copy for copying defaults |
| local function copyTable(src, dest) |
| if type(dest) ~= "table" then dest = {} end |
| if type(src) == "table" then |
| for k,v in pairs(src) do |
| if type(v) == "table" then |
| -- try to index the key first so that the metatable creates the defaults, if set, and use that table |
| v = copyTable(v, dest[k]) |
| end |
| dest[k] = v |
| end |
| end |
| return dest |
| end |
| -- Called to add defaults to a section of the database |
| -- |
| -- When a ["*"] default section is indexed with a new key, a table is returned |
| -- and set in the host table. These tables must be cleaned up by removeDefaults |
| -- in order to ensure we don't write empty default tables. |
| local function copyDefaults(dest, src) |
| -- this happens if some value in the SV overwrites our default value with a non-table |
| --if type(dest) ~= "table" then return end |
| for k, v in pairs(src) do |
| if k == "*" or k == "**" then |
| if type(v) == "table" then |
| -- This is a metatable used for table defaults |
| local mt = { |
| -- This handles the lookup and creation of new subtables |
| __index = function(t,k) |
| if k == nil then return nil end |
| local tbl = {} |
| copyDefaults(tbl, v) |
| rawset(t, k, tbl) |
| return tbl |
| end, |
| } |
| setmetatable(dest, mt) |
| -- handle already existing tables in the SV |
| for dk, dv in pairs(dest) do |
| if not rawget(src, dk) and type(dv) == "table" then |
| copyDefaults(dv, v) |
| end |
| end |
| else |
| -- Values are not tables, so this is just a simple return |
| local mt = {__index = function(t,k) return k~=nil and v or nil end} |
| setmetatable(dest, mt) |
| end |
| elseif type(v) == "table" then |
| if not rawget(dest, k) then rawset(dest, k, {}) end |
| if type(dest[k]) == "table" then |
| copyDefaults(dest[k], v) |
| if src['**'] then |
| copyDefaults(dest[k], src['**']) |
| end |
| end |
| else |
| if rawget(dest, k) == nil then |
| rawset(dest, k, v) |
| end |
| end |
| end |
| end |
| -- Called to remove all defaults in the default table from the database |
| local function removeDefaults(db, defaults, blocker) |
| -- remove all metatables from the db, so we don't accidentally create new sub-tables through them |
| setmetatable(db, nil) |
| -- loop through the defaults and remove their content |
| for k,v in pairs(defaults) do |
| if k == "*" or k == "**" then |
| if type(v) == "table" then |
| -- Loop through all the actual k,v pairs and remove |
| for key, value in pairs(db) do |
| if type(value) == "table" then |
| -- if the key was not explicitly specified in the defaults table, just strip everything from * and ** tables |
| if defaults[key] == nil and (not blocker or blocker[key] == nil) then |
| removeDefaults(value, v) |
| -- if the table is empty afterwards, remove it |
| if next(value) == nil then |
| db[key] = nil |
| end |
| -- if it was specified, only strip ** content, but block values which were set in the key table |
| elseif k == "**" then |
| removeDefaults(value, v, defaults[key]) |
| end |
| end |
| end |
| elseif k == "*" then |
| -- check for non-table default |
| for key, value in pairs(db) do |
| if defaults[key] == nil and v == value then |
| db[key] = nil |
| end |
| end |
| end |
| elseif type(v) == "table" and type(db[k]) == "table" then |
| -- if a blocker was set, dive into it, to allow multi-level defaults |
| removeDefaults(db[k], v, blocker and blocker[k]) |
| if next(db[k]) == nil then |
| db[k] = nil |
| end |
| else |
| -- check if the current value matches the default, and that its not blocked by another defaults table |
| if db[k] == defaults[k] and (not blocker or blocker[k] == nil) then |
| db[k] = nil |
| end |
| end |
| end |
| end |
| -- This is called when a table section is first accessed, to set up the defaults |
| local function initSection(db, section, svstore, key, defaults) |
| local sv = rawget(db, "sv") |
| local tableCreated |
| if not sv[svstore] then sv[svstore] = {} end |
| if not sv[svstore][key] then |
| sv[svstore][key] = {} |
| tableCreated = true |
| end |
| local tbl = sv[svstore][key] |
| if defaults then |
| copyDefaults(tbl, defaults) |
| end |
| rawset(db, section, tbl) |
| return tableCreated, tbl |
| end |
| -- Metatable to handle the dynamic creation of sections and copying of sections. |
| local dbmt = { |
| __index = function(t, section) |
| local keys = rawget(t, "keys") |
| local key = keys[section] |
| if key then |
| local defaultTbl = rawget(t, "defaults") |
| local defaults = defaultTbl and defaultTbl[section] |
| if section == "profile" then |
| local new = initSection(t, section, "profiles", key, defaults) |
| if new then |
| -- Callback: OnNewProfile, database, newProfileKey |
| t.callbacks:Fire("OnNewProfile", t, key) |
| end |
| elseif section == "profiles" then |
| local sv = rawget(t, "sv") |
| if not sv.profiles then sv.profiles = {} end |
| rawset(t, "profiles", sv.profiles) |
| elseif section == "global" then |
| local sv = rawget(t, "sv") |
| if not sv.global then sv.global = {} end |
| if defaults then |
| copyDefaults(sv.global, defaults) |
| end |
| rawset(t, section, sv.global) |
| else |
| initSection(t, section, section, key, defaults) |
| end |
| end |
| return rawget(t, section) |
| end |
| } |
| local function validateDefaults(defaults, keyTbl, offset) |
| if not defaults then return end |
| offset = offset or 0 |
| for k in pairs(defaults) do |
| if not keyTbl[k] or k == "profiles" then |
| error(("Usage: AceDBObject:RegisterDefaults(defaults): '%s' is not a valid datatype."):format(k), 3 + offset) |
| end |
| end |
| end |
| local preserve_keys = { |
| ["callbacks"] = true, |
| ["RegisterCallback"] = true, |
| ["UnregisterCallback"] = true, |
| ["UnregisterAllCallbacks"] = true, |
| ["children"] = true, |
| } |
| local realmKey = GetRealmName() |
| local charKey = UnitName("player") .. " - " .. realmKey |
| local _, classKey = UnitClass("player") |
| local _, raceKey = UnitRace("player") |
| local factionKey = UnitFactionGroup("player") |
| local factionrealmKey = factionKey .. " - " .. realmKey |
| -- Actual database initialization function |
| local function initdb(sv, defaults, defaultProfile, olddb, parent) |
| -- Generate the database keys for each section |
| -- map "true" to our "Default" profile |
| if defaultProfile == true then defaultProfile = "Default" end |
| local profileKey |
| if not parent then |
| -- Make a container for profile keys |
| if not sv.profileKeys then sv.profileKeys = {} end |
| -- Try to get the profile selected from the char db |
| profileKey = sv.profileKeys[charKey] or defaultProfile or charKey |
| -- save the selected profile for later |
| sv.profileKeys[charKey] = profileKey |
| else |
| -- Use the profile of the parents DB |
| profileKey = parent.keys.profile or defaultProfile or charKey |
| -- clear the profileKeys in the DB, namespaces don't need to store them |
| sv.profileKeys = nil |
| end |
| -- This table contains keys that enable the dynamic creation |
| -- of each section of the table. The 'global' and 'profiles' |
| -- have a key of true, since they are handled in a special case |
| local keyTbl= { |
| ["char"] = charKey, |
| ["realm"] = realmKey, |
| ["class"] = classKey, |
| ["race"] = raceKey, |
| ["faction"] = factionKey, |
| ["factionrealm"] = factionrealmKey, |
| ["profile"] = profileKey, |
| ["global"] = true, |
| ["profiles"] = true, |
| } |
| validateDefaults(defaults, keyTbl, 1) |
| -- This allows us to use this function to reset an entire database |
| -- Clear out the old database |
| if olddb then |
| for k,v in pairs(olddb) do if not preserve_keys[k] then olddb[k] = nil end end |
| end |
| -- Give this database the metatable so it initializes dynamically |
| local db = setmetatable(olddb or {}, dbmt) |
| if not rawget(db, "callbacks") then |
| -- try to load CallbackHandler-1.0 if it loaded after our library |
| if not CallbackHandler then CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0", true) end |
| db.callbacks = CallbackHandler and CallbackHandler:New(db) or CallbackDummy |
| end |
| -- Copy methods locally into the database object, to avoid hitting |
| -- the metatable when calling methods |
| if not parent then |
| for name, func in pairs(DBObjectLib) do |
| db[name] = func |
| end |
| else |
| -- hack this one in |
| db.RegisterDefaults = DBObjectLib.RegisterDefaults |
| db.ResetProfile = DBObjectLib.ResetProfile |
| end |
| -- Set some properties in the database object |
| db.profiles = sv.profiles |
| db.keys = keyTbl |
| db.sv = sv |
| --db.sv_name = name |
| db.defaults = defaults |
| db.parent = parent |
| -- store the DB in the registry |
| AceDB.db_registry[db] = true |
| return db |
| end |
| -- handle PLAYER_LOGOUT |
| -- strip all defaults from all databases |
| -- and cleans up empty sections |
| local function logoutHandler(frame, event) |
| if event == "PLAYER_LOGOUT" then |
| for db in pairs(AceDB.db_registry) do |
| db.callbacks:Fire("OnDatabaseShutdown", db) |
| db:RegisterDefaults(nil) |
| -- cleanup sections that are empty without defaults |
| local sv = rawget(db, "sv") |
| for section in pairs(db.keys) do |
| if rawget(sv, section) then |
| -- global is special, all other sections have sub-entrys |
| -- also don't delete empty profiles on main dbs, only on namespaces |
| if section ~= "global" and (section ~= "profiles" or rawget(db, "parent")) then |
| for key in pairs(sv[section]) do |
| if not next(sv[section][key]) then |
| sv[section][key] = nil |
| end |
| end |
| end |
| if not next(sv[section]) then |
| sv[section] = nil |
| end |
| end |
| end |
| end |
| end |
| end |
| AceDB.frame:RegisterEvent("PLAYER_LOGOUT") |
| AceDB.frame:SetScript("OnEvent", logoutHandler) |
| --[[------------------------------------------------------------------------- |
| AceDB Object Method Definitions |
| ---------------------------------------------------------------------------]] |
| --- Sets the defaults table for the given database object by clearing any |
| -- that are currently set, and then setting the new defaults. |
| -- @param defaults A table of defaults for this database |
| function DBObjectLib:RegisterDefaults(defaults) |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDBObject:RegisterDefaults(defaults): 'defaults' - table or nil expected.", 2) |
| end |
| validateDefaults(defaults, self.keys) |
| -- Remove any currently set defaults |
| if self.defaults then |
| for section,key in pairs(self.keys) do |
| if self.defaults[section] and rawget(self, section) then |
| removeDefaults(self[section], self.defaults[section]) |
| end |
| end |
| end |
| -- Set the DBObject.defaults table |
| self.defaults = defaults |
| -- Copy in any defaults, only touching those sections already created |
| if defaults then |
| for section,key in pairs(self.keys) do |
| if defaults[section] and rawget(self, section) then |
| copyDefaults(self[section], defaults[section]) |
| end |
| end |
| end |
| end |
| --- Changes the profile of the database and all of it's namespaces to the |
| -- supplied named profile |
| -- @param name The name of the profile to set as the current profile |
| function DBObjectLib:SetProfile(name) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:SetProfile(name): 'name' - string expected.", 2) |
| end |
| -- changing to the same profile, dont do anything |
| if name == self.keys.profile then return end |
| local oldProfile = self.profile |
| local defaults = self.defaults and self.defaults.profile |
| -- Callback: OnProfileShutdown, database |
| self.callbacks:Fire("OnProfileShutdown", self) |
| if oldProfile and defaults then |
| -- Remove the defaults from the old profile |
| removeDefaults(oldProfile, defaults) |
| end |
| self.profile = nil |
| self.keys["profile"] = name |
| -- if the storage exists, save the new profile |
| -- this won't exist on namespaces. |
| if self.sv.profileKeys then |
| self.sv.profileKeys[charKey] = name |
| end |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.SetProfile(db, name) |
| end |
| end |
| -- Callback: OnProfileChanged, database, newProfileKey |
| self.callbacks:Fire("OnProfileChanged", self, name) |
| end |
| --- Returns a table with the names of the existing profiles in the database. |
| -- You can optionally supply a table to re-use for this purpose. |
| -- @param tbl A table to store the profile names in (optional) |
| function DBObjectLib:GetProfiles(tbl) |
| if tbl and type(tbl) ~= "table" then |
| error("Usage: AceDBObject:GetProfiles(tbl): 'tbl' - table or nil expected.", 2) |
| end |
| -- Clear the container table |
| if tbl then |
| for k,v in pairs(tbl) do tbl[k] = nil end |
| else |
| tbl = {} |
| end |
| local curProfile = self.keys.profile |
| local i = 0 |
| for profileKey in pairs(self.profiles) do |
| i = i + 1 |
| tbl[i] = profileKey |
| if curProfile and profileKey == curProfile then curProfile = nil end |
| end |
| -- Add the current profile, if it hasn't been created yet |
| if curProfile then |
| i = i + 1 |
| tbl[i] = curProfile |
| end |
| return tbl, i |
| end |
| --- Returns the current profile name used by the database |
| function DBObjectLib:GetCurrentProfile() |
| return self.keys.profile |
| end |
| --- Deletes a named profile. This profile must not be the active profile. |
| -- @param name The name of the profile to be deleted |
| -- @param silent If true, do not raise an error when the profile does not exist |
| function DBObjectLib:DeleteProfile(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:DeleteProfile(name): 'name' - string expected.", 2) |
| end |
| if self.keys.profile == name then |
| error("Cannot delete the active profile in an AceDBObject.", 2) |
| end |
| if not rawget(self.profiles, name) and not silent then |
| error("Cannot delete profile '" .. name .. "'. It does not exist.", 2) |
| end |
| self.profiles[name] = nil |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.DeleteProfile(db, name, true) |
| end |
| end |
| -- Callback: OnProfileDeleted, database, profileKey |
| self.callbacks:Fire("OnProfileDeleted", self, name) |
| end |
| --- Copies a named profile into the current profile, overwriting any conflicting |
| -- settings. |
| -- @param name The name of the profile to be copied into the current profile |
| -- @param silent If true, do not raise an error when the profile does not exist |
| function DBObjectLib:CopyProfile(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:CopyProfile(name): 'name' - string expected.", 2) |
| end |
| if name == self.keys.profile then |
| error("Cannot have the same source and destination profiles.", 2) |
| end |
| if not rawget(self.profiles, name) and not silent then |
| error("Cannot copy profile '" .. name .. "'. It does not exist.", 2) |
| end |
| -- Reset the profile before copying |
| DBObjectLib.ResetProfile(self, nil, true) |
| local profile = self.profile |
| local source = self.profiles[name] |
| copyTable(source, profile) |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.CopyProfile(db, name, true) |
| end |
| end |
| -- Callback: OnProfileCopied, database, sourceProfileKey |
| self.callbacks:Fire("OnProfileCopied", self, name) |
| end |
| --- Resets the current profile to the default values (if specified). |
| -- @param noChildren if set to true, the reset will not be populated to the child namespaces of this DB object |
| -- @param noCallbacks if set to true, won't fire the OnProfileReset callback |
| function DBObjectLib:ResetProfile(noChildren, noCallbacks) |
| local profile = self.profile |
| for k,v in pairs(profile) do |
| profile[k] = nil |
| end |
| local defaults = self.defaults and self.defaults.profile |
| if defaults then |
| copyDefaults(profile, defaults) |
| end |
| -- populate to child namespaces |
| if self.children and not noChildren then |
| for _, db in pairs(self.children) do |
| DBObjectLib.ResetProfile(db, nil, noCallbacks) |
| end |
| end |
| -- Callback: OnProfileReset, database |
| if not noCallbacks then |
| self.callbacks:Fire("OnProfileReset", self) |
| end |
| end |
| --- Resets the entire database, using the string defaultProfile as the new default |
| -- profile. |
| -- @param defaultProfile The profile name to use as the default |
| function DBObjectLib:ResetDB(defaultProfile) |
| if defaultProfile and type(defaultProfile) ~= "string" then |
| error("Usage: AceDBObject:ResetDB(defaultProfile): 'defaultProfile' - string or nil expected.", 2) |
| end |
| local sv = self.sv |
| for k,v in pairs(sv) do |
| sv[k] = nil |
| end |
| local parent = self.parent |
| initdb(sv, self.defaults, defaultProfile, self) |
| -- fix the child namespaces |
| if self.children then |
| if not sv.namespaces then sv.namespaces = {} end |
| for name, db in pairs(self.children) do |
| if not sv.namespaces[name] then sv.namespaces[name] = {} end |
| initdb(sv.namespaces[name], db.defaults, self.keys.profile, db, self) |
| end |
| end |
| -- Callback: OnDatabaseReset, database |
| self.callbacks:Fire("OnDatabaseReset", self) |
| -- Callback: OnProfileChanged, database, profileKey |
| self.callbacks:Fire("OnProfileChanged", self, self.keys["profile"]) |
| return self |
| end |
| --- Creates a new database namespace, directly tied to the database. This |
| -- is a full scale database in it's own rights other than the fact that |
| -- it cannot control its profile individually |
| -- @param name The name of the new namespace |
| -- @param defaults A table of values to use as defaults |
| function DBObjectLib:RegisterNamespace(name, defaults) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - string expected.", 2) |
| end |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'defaults' - table or nil expected.", 2) |
| end |
| if self.children and self.children[name] then |
| error ("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - a namespace with that name already exists.", 2) |
| end |
| local sv = self.sv |
| if not sv.namespaces then sv.namespaces = {} end |
| if not sv.namespaces[name] then |
| sv.namespaces[name] = {} |
| end |
| local newDB = initdb(sv.namespaces[name], defaults, self.keys.profile, nil, self) |
| if not self.children then self.children = {} end |
| self.children[name] = newDB |
| return newDB |
| end |
| --- Returns an already existing namespace from the database object. |
| -- @param name The name of the new namespace |
| -- @param silent if true, the addon is optional, silently return nil if its not found |
| -- @usage |
| -- local namespace = self.db:GetNamespace('namespace') |
| -- @return the namespace object if found |
| function DBObjectLib:GetNamespace(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:GetNamespace(name): 'name' - string expected.", 2) |
| end |
| if not silent and not (self.children and self.children[name]) then |
| error ("Usage: AceDBObject:GetNamespace(name): 'name' - namespace does not exist.", 2) |
| end |
| if not self.children then self.children = {} end |
| return self.children[name] |
| end |
| --[[------------------------------------------------------------------------- |
| AceDB Exposed Methods |
| ---------------------------------------------------------------------------]] |
| --- Creates a new database object that can be used to handle database settings and profiles. |
| -- By default, an empty DB is created, using a character specific profile. |
| -- |
| -- You can override the default profile used by passing any profile name as the third argument, |
| -- or by passing //true// as the third argument to use a globally shared profile called "Default". |
| -- |
| -- Note that there is no token replacement in the default profile name, passing a defaultProfile as "char" |
| -- will use a profile named "char", and not a character-specific profile. |
| -- @param tbl The name of variable, or table to use for the database |
| -- @param defaults A table of database defaults |
| -- @param defaultProfile The name of the default profile. If not set, a character specific profile will be used as the default. |
| -- You can also pass //true// to use a shared global profile called "Default". |
| -- @usage |
| -- -- Create an empty DB using a character-specific default profile. |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB") |
| -- @usage |
| -- -- Create a DB using defaults and using a shared default profile |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
| function AceDB:New(tbl, defaults, defaultProfile) |
| if type(tbl) == "string" then |
| local name = tbl |
| tbl = _G[name] |
| if not tbl then |
| tbl = {} |
| _G[name] = tbl |
| end |
| end |
| if type(tbl) ~= "table" then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'tbl' - table expected.", 2) |
| end |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaults' - table expected.", 2) |
| end |
| if defaultProfile and type(defaultProfile) ~= "string" and defaultProfile ~= true then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaultProfile' - string or true expected.", 2) |
| end |
| return initdb(tbl, defaults, defaultProfile) |
| end |
| -- upgrade existing databases |
| for db in pairs(AceDB.db_registry) do |
| if not db.parent then |
| for name,func in pairs(DBObjectLib) do |
| db[name] = func |
| end |
| else |
| db.RegisterDefaults = DBObjectLib.RegisterDefaults |
| db.ResetProfile = DBObjectLib.ResetProfile |
| end |
| end |
| --- **AceDB-3.0** manages the SavedVariables of your addon. |
| -- It offers profile management, smart defaults and namespaces for modules.\\ |
| -- Data can be saved in different data-types, depending on its intended usage. |
| -- The most common data-type is the `profile` type, which allows the user to choose |
| -- the active profile, and manage the profiles of all of his characters.\\ |
| -- The following data types are available: |
| -- * **char** Character-specific data. Every character has its own database. |
| -- * **realm** Realm-specific data. All of the players characters on the same realm share this database. |
| -- * **class** Class-specific data. All of the players characters of the same class share this database. |
| -- * **race** Race-specific data. All of the players characters of the same race share this database. |
| -- * **faction** Faction-specific data. All of the players characters of the same faction share this database. |
| -- * **factionrealm** Faction and realm specific data. All of the players characters on the same realm and of the same faction share this database. |
| -- * **global** Global Data. All characters on the same account share this database. |
| -- * **profile** Profile-specific data. All characters using the same profile share this database. The user can control which profile should be used. |
| -- |
| -- Creating a new Database using the `:New` function will return a new DBObject. A database will inherit all functions |
| -- of the DBObjectLib listed here. \\ |
| -- If you create a new namespaced child-database (`:RegisterNamespace`), you'll get a DBObject as well, but note |
| -- that the child-databases cannot individually change their profile, and are linked to their parents profile - and because of that, |
| -- the profile related APIs are not available. Only `:RegisterDefaults` and `:ResetProfile` are available on child-databases. |
| -- |
| -- For more details on how to use AceDB-3.0, see the [[AceDB-3.0 Tutorial]]. |
| -- |
| -- You may also be interested in [[libdualspec-1-0|LibDualSpec-1.0]] to do profile switching automatically when switching specs. |
| -- |
| -- @usage |
| -- MyAddon = LibStub("AceAddon-3.0"):NewAddon("DBExample") |
| -- |
| -- -- declare defaults to be used in the DB |
| -- local defaults = { |
| -- profile = { |
| -- setting = true, |
| -- } |
| -- } |
| -- |
| -- function MyAddon:OnInitialize() |
| -- -- Assuming the .toc says ## SavedVariables: MyAddonDB |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
| -- end |
| -- @class file |
| -- @name AceDB-3.0.lua |
| -- @release $Id: AceDB-3.0.lua 1124 2014-10-27 21:00:07Z funkydude $ |
| local ACEDB_MAJOR, ACEDB_MINOR = "AceDB-3.0", 26 |
| local AceDB, oldminor = LibStub:NewLibrary(ACEDB_MAJOR, ACEDB_MINOR) |
| if not AceDB then return end -- No upgrade needed |
| -- Lua APIs |
| local type, pairs, next, error = type, pairs, next, error |
| local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget |
| -- WoW APIs |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: LibStub |
| AceDB.db_registry = AceDB.db_registry or {} |
| AceDB.frame = AceDB.frame or CreateFrame("Frame") |
| local CallbackHandler |
| local CallbackDummy = { Fire = function() end } |
| local DBObjectLib = {} |
| --[[------------------------------------------------------------------------- |
| AceDB Utility Functions |
| ---------------------------------------------------------------------------]] |
| -- Simple shallow copy for copying defaults |
| local function copyTable(src, dest) |
| if type(dest) ~= "table" then dest = {} end |
| if type(src) == "table" then |
| for k,v in pairs(src) do |
| if type(v) == "table" then |
| -- try to index the key first so that the metatable creates the defaults, if set, and use that table |
| v = copyTable(v, dest[k]) |
| end |
| dest[k] = v |
| end |
| end |
| return dest |
| end |
| -- Called to add defaults to a section of the database |
| -- |
| -- When a ["*"] default section is indexed with a new key, a table is returned |
| -- and set in the host table. These tables must be cleaned up by removeDefaults |
| -- in order to ensure we don't write empty default tables. |
| local function copyDefaults(dest, src) |
| -- this happens if some value in the SV overwrites our default value with a non-table |
| --if type(dest) ~= "table" then return end |
| for k, v in pairs(src) do |
| if k == "*" or k == "**" then |
| if type(v) == "table" then |
| -- This is a metatable used for table defaults |
| local mt = { |
| -- This handles the lookup and creation of new subtables |
| __index = function(t,k) |
| if k == nil then return nil end |
| local tbl = {} |
| copyDefaults(tbl, v) |
| rawset(t, k, tbl) |
| return tbl |
| end, |
| } |
| setmetatable(dest, mt) |
| -- handle already existing tables in the SV |
| for dk, dv in pairs(dest) do |
| if not rawget(src, dk) and type(dv) == "table" then |
| copyDefaults(dv, v) |
| end |
| end |
| else |
| -- Values are not tables, so this is just a simple return |
| local mt = {__index = function(t,k) return k~=nil and v or nil end} |
| setmetatable(dest, mt) |
| end |
| elseif type(v) == "table" then |
| if not rawget(dest, k) then rawset(dest, k, {}) end |
| if type(dest[k]) == "table" then |
| copyDefaults(dest[k], v) |
| if src['**'] then |
| copyDefaults(dest[k], src['**']) |
| end |
| end |
| else |
| if rawget(dest, k) == nil then |
| rawset(dest, k, v) |
| end |
| end |
| end |
| end |
| -- Called to remove all defaults in the default table from the database |
| local function removeDefaults(db, defaults, blocker) |
| -- remove all metatables from the db, so we don't accidentally create new sub-tables through them |
| setmetatable(db, nil) |
| -- loop through the defaults and remove their content |
| for k,v in pairs(defaults) do |
| if k == "*" or k == "**" then |
| if type(v) == "table" then |
| -- Loop through all the actual k,v pairs and remove |
| for key, value in pairs(db) do |
| if type(value) == "table" then |
| -- if the key was not explicitly specified in the defaults table, just strip everything from * and ** tables |
| if defaults[key] == nil and (not blocker or blocker[key] == nil) then |
| removeDefaults(value, v) |
| -- if the table is empty afterwards, remove it |
| if next(value) == nil then |
| db[key] = nil |
| end |
| -- if it was specified, only strip ** content, but block values which were set in the key table |
| elseif k == "**" then |
| removeDefaults(value, v, defaults[key]) |
| end |
| end |
| end |
| elseif k == "*" then |
| -- check for non-table default |
| for key, value in pairs(db) do |
| if defaults[key] == nil and v == value then |
| db[key] = nil |
| end |
| end |
| end |
| elseif type(v) == "table" and type(db[k]) == "table" then |
| -- if a blocker was set, dive into it, to allow multi-level defaults |
| removeDefaults(db[k], v, blocker and blocker[k]) |
| if next(db[k]) == nil then |
| db[k] = nil |
| end |
| else |
| -- check if the current value matches the default, and that its not blocked by another defaults table |
| if db[k] == defaults[k] and (not blocker or blocker[k] == nil) then |
| db[k] = nil |
| end |
| end |
| end |
| end |
| -- This is called when a table section is first accessed, to set up the defaults |
| local function initSection(db, section, svstore, key, defaults) |
| local sv = rawget(db, "sv") |
| local tableCreated |
| if not sv[svstore] then sv[svstore] = {} end |
| if not sv[svstore][key] then |
| sv[svstore][key] = {} |
| tableCreated = true |
| end |
| local tbl = sv[svstore][key] |
| if defaults then |
| copyDefaults(tbl, defaults) |
| end |
| rawset(db, section, tbl) |
| return tableCreated, tbl |
| end |
| -- Metatable to handle the dynamic creation of sections and copying of sections. |
| local dbmt = { |
| __index = function(t, section) |
| local keys = rawget(t, "keys") |
| local key = keys[section] |
| if key then |
| local defaultTbl = rawget(t, "defaults") |
| local defaults = defaultTbl and defaultTbl[section] |
| if section == "profile" then |
| local new = initSection(t, section, "profiles", key, defaults) |
| if new then |
| -- Callback: OnNewProfile, database, newProfileKey |
| t.callbacks:Fire("OnNewProfile", t, key) |
| end |
| elseif section == "profiles" then |
| local sv = rawget(t, "sv") |
| if not sv.profiles then sv.profiles = {} end |
| rawset(t, "profiles", sv.profiles) |
| elseif section == "global" then |
| local sv = rawget(t, "sv") |
| if not sv.global then sv.global = {} end |
| if defaults then |
| copyDefaults(sv.global, defaults) |
| end |
| rawset(t, section, sv.global) |
| else |
| initSection(t, section, section, key, defaults) |
| end |
| end |
| return rawget(t, section) |
| end |
| } |
| local function validateDefaults(defaults, keyTbl, offset) |
| if not defaults then return end |
| offset = offset or 0 |
| for k in pairs(defaults) do |
| if not keyTbl[k] or k == "profiles" then |
| error(("Usage: AceDBObject:RegisterDefaults(defaults): '%s' is not a valid datatype."):format(k), 3 + offset) |
| end |
| end |
| end |
| local preserve_keys = { |
| ["callbacks"] = true, |
| ["RegisterCallback"] = true, |
| ["UnregisterCallback"] = true, |
| ["UnregisterAllCallbacks"] = true, |
| ["children"] = true, |
| } |
| local realmKey = GetRealmName() |
| local charKey = UnitName("player") .. " - " .. realmKey |
| local _, classKey = UnitClass("player") |
| local _, raceKey = UnitRace("player") |
| local factionKey = UnitFactionGroup("player") |
| local factionrealmKey = factionKey .. " - " .. realmKey |
| local localeKey = GetLocale():lower() |
| local regionTable = { "US", "KR", "EU", "TW", "CN" } |
| local regionKey = regionTable[GetCurrentRegion()] |
| local factionrealmregionKey = factionrealmKey .. " - " .. regionKey |
| -- Actual database initialization function |
| local function initdb(sv, defaults, defaultProfile, olddb, parent) |
| -- Generate the database keys for each section |
| -- map "true" to our "Default" profile |
| if defaultProfile == true then defaultProfile = "Default" end |
| local profileKey |
| if not parent then |
| -- Make a container for profile keys |
| if not sv.profileKeys then sv.profileKeys = {} end |
| -- Try to get the profile selected from the char db |
| profileKey = sv.profileKeys[charKey] or defaultProfile or charKey |
| -- save the selected profile for later |
| sv.profileKeys[charKey] = profileKey |
| else |
| -- Use the profile of the parents DB |
| profileKey = parent.keys.profile or defaultProfile or charKey |
| -- clear the profileKeys in the DB, namespaces don't need to store them |
| sv.profileKeys = nil |
| end |
| -- This table contains keys that enable the dynamic creation |
| -- of each section of the table. The 'global' and 'profiles' |
| -- have a key of true, since they are handled in a special case |
| local keyTbl= { |
| ["char"] = charKey, |
| ["realm"] = realmKey, |
| ["class"] = classKey, |
| ["race"] = raceKey, |
| ["faction"] = factionKey, |
| ["factionrealm"] = factionrealmKey, |
| ["factionrealmregion"] = factionrealmregionKey, |
| ["profile"] = profileKey, |
| ["locale"] = localeKey, |
| ["global"] = true, |
| ["profiles"] = true, |
| } |
| validateDefaults(defaults, keyTbl, 1) |
| -- This allows us to use this function to reset an entire database |
| -- Clear out the old database |
| if olddb then |
| for k,v in pairs(olddb) do if not preserve_keys[k] then olddb[k] = nil end end |
| end |
| -- Give this database the metatable so it initializes dynamically |
| local db = setmetatable(olddb or {}, dbmt) |
| if not rawget(db, "callbacks") then |
| -- try to load CallbackHandler-1.0 if it loaded after our library |
| if not CallbackHandler then CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0", true) end |
| db.callbacks = CallbackHandler and CallbackHandler:New(db) or CallbackDummy |
| end |
| -- Copy methods locally into the database object, to avoid hitting |
| -- the metatable when calling methods |
| if not parent then |
| for name, func in pairs(DBObjectLib) do |
| db[name] = func |
| end |
| else |
| -- hack this one in |
| db.RegisterDefaults = DBObjectLib.RegisterDefaults |
| db.ResetProfile = DBObjectLib.ResetProfile |
| end |
| -- Set some properties in the database object |
| db.profiles = sv.profiles |
| db.keys = keyTbl |
| db.sv = sv |
| --db.sv_name = name |
| db.defaults = defaults |
| db.parent = parent |
| -- store the DB in the registry |
| AceDB.db_registry[db] = true |
| return db |
| end |
| -- handle PLAYER_LOGOUT |
| -- strip all defaults from all databases |
| -- and cleans up empty sections |
| local function logoutHandler(frame, event) |
| if event == "PLAYER_LOGOUT" then |
| for db in pairs(AceDB.db_registry) do |
| db.callbacks:Fire("OnDatabaseShutdown", db) |
| db:RegisterDefaults(nil) |
| -- cleanup sections that are empty without defaults |
| local sv = rawget(db, "sv") |
| for section in pairs(db.keys) do |
| if rawget(sv, section) then |
| -- global is special, all other sections have sub-entrys |
| -- also don't delete empty profiles on main dbs, only on namespaces |
| if section ~= "global" and (section ~= "profiles" or rawget(db, "parent")) then |
| for key in pairs(sv[section]) do |
| if not next(sv[section][key]) then |
| sv[section][key] = nil |
| end |
| end |
| end |
| if not next(sv[section]) then |
| sv[section] = nil |
| end |
| end |
| end |
| end |
| end |
| end |
| AceDB.frame:RegisterEvent("PLAYER_LOGOUT") |
| AceDB.frame:SetScript("OnEvent", logoutHandler) |
| --[[------------------------------------------------------------------------- |
| AceDB Object Method Definitions |
| ---------------------------------------------------------------------------]] |
| --- Sets the defaults table for the given database object by clearing any |
| -- that are currently set, and then setting the new defaults. |
| -- @param defaults A table of defaults for this database |
| function DBObjectLib:RegisterDefaults(defaults) |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDBObject:RegisterDefaults(defaults): 'defaults' - table or nil expected.", 2) |
| end |
| validateDefaults(defaults, self.keys) |
| -- Remove any currently set defaults |
| if self.defaults then |
| for section,key in pairs(self.keys) do |
| if self.defaults[section] and rawget(self, section) then |
| removeDefaults(self[section], self.defaults[section]) |
| end |
| end |
| end |
| -- Set the DBObject.defaults table |
| self.defaults = defaults |
| -- Copy in any defaults, only touching those sections already created |
| if defaults then |
| for section,key in pairs(self.keys) do |
| if defaults[section] and rawget(self, section) then |
| copyDefaults(self[section], defaults[section]) |
| end |
| end |
| end |
| end |
| --- Changes the profile of the database and all of it's namespaces to the |
| -- supplied named profile |
| -- @param name The name of the profile to set as the current profile |
| function DBObjectLib:SetProfile(name) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:SetProfile(name): 'name' - string expected.", 2) |
| end |
| -- changing to the same profile, dont do anything |
| if name == self.keys.profile then return end |
| local oldProfile = self.profile |
| local defaults = self.defaults and self.defaults.profile |
| -- Callback: OnProfileShutdown, database |
| self.callbacks:Fire("OnProfileShutdown", self) |
| if oldProfile and defaults then |
| -- Remove the defaults from the old profile |
| removeDefaults(oldProfile, defaults) |
| end |
| self.profile = nil |
| self.keys["profile"] = name |
| -- if the storage exists, save the new profile |
| -- this won't exist on namespaces. |
| if self.sv.profileKeys then |
| self.sv.profileKeys[charKey] = name |
| end |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.SetProfile(db, name) |
| end |
| end |
| -- Callback: OnProfileChanged, database, newProfileKey |
| self.callbacks:Fire("OnProfileChanged", self, name) |
| end |
| --- Returns a table with the names of the existing profiles in the database. |
| -- You can optionally supply a table to re-use for this purpose. |
| -- @param tbl A table to store the profile names in (optional) |
| function DBObjectLib:GetProfiles(tbl) |
| if tbl and type(tbl) ~= "table" then |
| error("Usage: AceDBObject:GetProfiles(tbl): 'tbl' - table or nil expected.", 2) |
| end |
| -- Clear the container table |
| if tbl then |
| for k,v in pairs(tbl) do tbl[k] = nil end |
| else |
| tbl = {} |
| end |
| local curProfile = self.keys.profile |
| local i = 0 |
| for profileKey in pairs(self.profiles) do |
| i = i + 1 |
| tbl[i] = profileKey |
| if curProfile and profileKey == curProfile then curProfile = nil end |
| end |
| -- Add the current profile, if it hasn't been created yet |
| if curProfile then |
| i = i + 1 |
| tbl[i] = curProfile |
| end |
| return tbl, i |
| end |
| --- Returns the current profile name used by the database |
| function DBObjectLib:GetCurrentProfile() |
| return self.keys.profile |
| end |
| --- Deletes a named profile. This profile must not be the active profile. |
| -- @param name The name of the profile to be deleted |
| -- @param silent If true, do not raise an error when the profile does not exist |
| function DBObjectLib:DeleteProfile(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:DeleteProfile(name): 'name' - string expected.", 2) |
| end |
| if self.keys.profile == name then |
| error("Cannot delete the active profile in an AceDBObject.", 2) |
| end |
| if not rawget(self.profiles, name) and not silent then |
| error("Cannot delete profile '" .. name .. "'. It does not exist.", 2) |
| end |
| self.profiles[name] = nil |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.DeleteProfile(db, name, true) |
| end |
| end |
| -- switch all characters that use this profile back to the default |
| if self.sv.profileKeys then |
| for key, profile in pairs(self.sv.profileKeys) do |
| if profile == name then |
| self.sv.profileKeys[key] = nil |
| end |
| end |
| end |
| -- Callback: OnProfileDeleted, database, profileKey |
| self.callbacks:Fire("OnProfileDeleted", self, name) |
| end |
| --- Copies a named profile into the current profile, overwriting any conflicting |
| -- settings. |
| -- @param name The name of the profile to be copied into the current profile |
| -- @param silent If true, do not raise an error when the profile does not exist |
| function DBObjectLib:CopyProfile(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:CopyProfile(name): 'name' - string expected.", 2) |
| end |
| if name == self.keys.profile then |
| error("Cannot have the same source and destination profiles.", 2) |
| end |
| if not rawget(self.profiles, name) and not silent then |
| error("Cannot copy profile '" .. name .. "'. It does not exist.", 2) |
| end |
| -- Reset the profile before copying |
| DBObjectLib.ResetProfile(self, nil, true) |
| local profile = self.profile |
| local source = self.profiles[name] |
| copyTable(source, profile) |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.CopyProfile(db, name, true) |
| end |
| end |
| -- Callback: OnProfileCopied, database, sourceProfileKey |
| self.callbacks:Fire("OnProfileCopied", self, name) |
| end |
| --- Resets the current profile to the default values (if specified). |
| -- @param noChildren if set to true, the reset will not be populated to the child namespaces of this DB object |
| -- @param noCallbacks if set to true, won't fire the OnProfileReset callback |
| function DBObjectLib:ResetProfile(noChildren, noCallbacks) |
| local profile = self.profile |
| for k,v in pairs(profile) do |
| profile[k] = nil |
| end |
| local defaults = self.defaults and self.defaults.profile |
| if defaults then |
| copyDefaults(profile, defaults) |
| end |
| -- populate to child namespaces |
| if self.children and not noChildren then |
| for _, db in pairs(self.children) do |
| DBObjectLib.ResetProfile(db, nil, noCallbacks) |
| end |
| end |
| -- Callback: OnProfileReset, database |
| if not noCallbacks then |
| self.callbacks:Fire("OnProfileReset", self) |
| end |
| end |
| --- Resets the entire database, using the string defaultProfile as the new default |
| -- profile. |
| -- @param defaultProfile The profile name to use as the default |
| function DBObjectLib:ResetDB(defaultProfile) |
| if defaultProfile and type(defaultProfile) ~= "string" then |
| error("Usage: AceDBObject:ResetDB(defaultProfile): 'defaultProfile' - string or nil expected.", 2) |
| end |
| local sv = self.sv |
| for k,v in pairs(sv) do |
| sv[k] = nil |
| end |
| local parent = self.parent |
| initdb(sv, self.defaults, defaultProfile, self) |
| -- fix the child namespaces |
| if self.children then |
| if not sv.namespaces then sv.namespaces = {} end |
| for name, db in pairs(self.children) do |
| if not sv.namespaces[name] then sv.namespaces[name] = {} end |
| initdb(sv.namespaces[name], db.defaults, self.keys.profile, db, self) |
| end |
| end |
| -- Callback: OnDatabaseReset, database |
| self.callbacks:Fire("OnDatabaseReset", self) |
| -- Callback: OnProfileChanged, database, profileKey |
| self.callbacks:Fire("OnProfileChanged", self, self.keys["profile"]) |
| return self |
| end |
| --- Creates a new database namespace, directly tied to the database. This |
| -- is a full scale database in it's own rights other than the fact that |
| -- it cannot control its profile individually |
| -- @param name The name of the new namespace |
| -- @param defaults A table of values to use as defaults |
| function DBObjectLib:RegisterNamespace(name, defaults) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - string expected.", 2) |
| end |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'defaults' - table or nil expected.", 2) |
| end |
| if self.children and self.children[name] then |
| error ("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - a namespace with that name already exists.", 2) |
| end |
| local sv = self.sv |
| if not sv.namespaces then sv.namespaces = {} end |
| if not sv.namespaces[name] then |
| sv.namespaces[name] = {} |
| end |
| local newDB = initdb(sv.namespaces[name], defaults, self.keys.profile, nil, self) |
| if not self.children then self.children = {} end |
| self.children[name] = newDB |
| return newDB |
| end |
| --- Returns an already existing namespace from the database object. |
| -- @param name The name of the new namespace |
| -- @param silent if true, the addon is optional, silently return nil if its not found |
| -- @usage |
| -- local namespace = self.db:GetNamespace('namespace') |
| -- @return the namespace object if found |
| function DBObjectLib:GetNamespace(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:GetNamespace(name): 'name' - string expected.", 2) |
| end |
| if not silent and not (self.children and self.children[name]) then |
| error ("Usage: AceDBObject:GetNamespace(name): 'name' - namespace does not exist.", 2) |
| end |
| if not self.children then self.children = {} end |
| return self.children[name] |
| end |
| --[[------------------------------------------------------------------------- |
| AceDB Exposed Methods |
| ---------------------------------------------------------------------------]] |
| --- Creates a new database object that can be used to handle database settings and profiles. |
| -- By default, an empty DB is created, using a character specific profile. |
| -- |
| -- You can override the default profile used by passing any profile name as the third argument, |
| -- or by passing //true// as the third argument to use a globally shared profile called "Default". |
| -- |
| -- Note that there is no token replacement in the default profile name, passing a defaultProfile as "char" |
| -- will use a profile named "char", and not a character-specific profile. |
| -- @param tbl The name of variable, or table to use for the database |
| -- @param defaults A table of database defaults |
| -- @param defaultProfile The name of the default profile. If not set, a character specific profile will be used as the default. |
| -- You can also pass //true// to use a shared global profile called "Default". |
| -- @usage |
| -- -- Create an empty DB using a character-specific default profile. |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB") |
| -- @usage |
| -- -- Create a DB using defaults and using a shared default profile |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
| function AceDB:New(tbl, defaults, defaultProfile) |
| if type(tbl) == "string" then |
| local name = tbl |
| tbl = _G[name] |
| if not tbl then |
| tbl = {} |
| _G[name] = tbl |
| end |
| end |
| if type(tbl) ~= "table" then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'tbl' - table expected.", 2) |
| end |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaults' - table expected.", 2) |
| end |
| if defaultProfile and type(defaultProfile) ~= "string" and defaultProfile ~= true then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaultProfile' - string or true expected.", 2) |
| end |
| return initdb(tbl, defaults, defaultProfile) |
| end |
| -- upgrade existing databases |
| for db in pairs(AceDB.db_registry) do |
| if not db.parent then |
| for name,func in pairs(DBObjectLib) do |
| db[name] = func |
| end |
| else |
| db.RegisterDefaults = DBObjectLib.RegisterDefaults |
| db.ResetProfile = DBObjectLib.ResetProfile |
| end |
| end |
WoWInterface
AddOn Sites
© 2004 - 2022 MMOUI
vBulletin © 2024, Jelsoft Enterprises Ltd