Removing wowace libraries
This commit is contained in:
parent
8e22be74f8
commit
72496c4d34
16 changed files with 0 additions and 1995 deletions
|
|
@ -1,658 +0,0 @@
|
||||||
--- **AceAddon-3.0** provides a template for creating addon objects.
|
|
||||||
-- It'll provide you with a set of callback functions that allow you to simplify the loading
|
|
||||||
-- process of your addon.\\
|
|
||||||
-- Callbacks provided are:\\
|
|
||||||
-- * **OnInitialize**, which is called directly after the addon is fully loaded.
|
|
||||||
-- * **OnEnable** which gets called during the PLAYER_LOGIN event, when most of the data provided by the game is already present.
|
|
||||||
-- * **OnDisable**, which is only called when your addon is manually being disabled.
|
|
||||||
-- @usage
|
|
||||||
-- -- A small (but complete) addon, that doesn't do anything,
|
|
||||||
-- -- but shows usage of the callbacks.
|
|
||||||
-- local MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
|
|
||||||
--
|
|
||||||
-- function MyAddon:OnInitialize()
|
|
||||||
-- -- do init tasks here, like loading the Saved Variables,
|
|
||||||
-- -- or setting up slash commands.
|
|
||||||
-- end
|
|
||||||
--
|
|
||||||
-- function MyAddon:OnEnable()
|
|
||||||
-- -- Do more initialization here, that really enables the use of your addon.
|
|
||||||
-- -- Register Events, Hook functions, Create Frames, Get information from
|
|
||||||
-- -- the game that wasn't available in OnInitialize
|
|
||||||
-- end
|
|
||||||
--
|
|
||||||
-- function MyAddon:OnDisable()
|
|
||||||
-- -- Unhook, Unregister Events, Hide frames that you created.
|
|
||||||
-- -- You would probably only use an OnDisable if you want to
|
|
||||||
-- -- build a "standby" mode, or be able to toggle modules on/off.
|
|
||||||
-- end
|
|
||||||
-- @class file
|
|
||||||
-- @name AceAddon-3.0.lua
|
|
||||||
-- @release $Id: AceAddon-3.0.lua 980 2010-10-27 14:20:11Z nevcairiel $
|
|
||||||
|
|
||||||
local MAJOR, MINOR = "AceAddon-3.0", 10
|
|
||||||
local AceAddon, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
|
|
||||||
|
|
||||||
if not AceAddon then return end -- No Upgrade needed.
|
|
||||||
|
|
||||||
AceAddon.frame = AceAddon.frame or CreateFrame("Frame", "AceAddon30Frame") -- Our very own frame
|
|
||||||
AceAddon.addons = AceAddon.addons or {} -- addons in general
|
|
||||||
AceAddon.statuses = AceAddon.statuses or {} -- statuses of addon.
|
|
||||||
AceAddon.initializequeue = AceAddon.initializequeue or {} -- addons that are new and not initialized
|
|
||||||
AceAddon.enablequeue = AceAddon.enablequeue or {} -- addons that are initialized and waiting to be enabled
|
|
||||||
AceAddon.embeds = AceAddon.embeds or setmetatable({}, {__index = function(tbl, key) tbl[key] = {} return tbl[key] end }) -- contains a list of libraries embedded in an addon
|
|
||||||
|
|
||||||
-- Lua APIs
|
|
||||||
local tinsert, tconcat, tremove = table.insert, table.concat, table.remove
|
|
||||||
local fmt, tostring = string.format, tostring
|
|
||||||
local select, pairs, next, type, unpack = select, pairs, next, type, unpack
|
|
||||||
local loadstring, assert, error = loadstring, assert, error
|
|
||||||
local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget
|
|
||||||
|
|
||||||
-- 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, IsLoggedIn, geterrorhandler
|
|
||||||
|
|
||||||
--[[
|
|
||||||
xpcall safecall implementation
|
|
||||||
]]
|
|
||||||
local xpcall = xpcall
|
|
||||||
|
|
||||||
local function errorhandler(err)
|
|
||||||
return geterrorhandler()(err)
|
|
||||||
end
|
|
||||||
|
|
||||||
local function CreateDispatcher(argCount)
|
|
||||||
local code = [[
|
|
||||||
local xpcall, eh = ...
|
|
||||||
local method, ARGS
|
|
||||||
local function call() return method(ARGS) end
|
|
||||||
|
|
||||||
local function dispatch(func, ...)
|
|
||||||
method = func
|
|
||||||
if not method then return end
|
|
||||||
ARGS = ...
|
|
||||||
return xpcall(call, eh)
|
|
||||||
end
|
|
||||||
|
|
||||||
return dispatch
|
|
||||||
]]
|
|
||||||
|
|
||||||
local ARGS = {}
|
|
||||||
for i = 1, argCount do ARGS[i] = "arg"..i end
|
|
||||||
code = code:gsub("ARGS", tconcat(ARGS, ", "))
|
|
||||||
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler)
|
|
||||||
end
|
|
||||||
|
|
||||||
local Dispatchers = setmetatable({}, {__index=function(self, argCount)
|
|
||||||
local dispatcher = CreateDispatcher(argCount)
|
|
||||||
rawset(self, argCount, dispatcher)
|
|
||||||
return dispatcher
|
|
||||||
end})
|
|
||||||
Dispatchers[0] = function(func)
|
|
||||||
return xpcall(func, errorhandler)
|
|
||||||
end
|
|
||||||
|
|
||||||
local function safecall(func, ...)
|
|
||||||
-- we check to see if the func is passed is actually a function here and don't error when it isn't
|
|
||||||
-- this safecall is used for optional functions like OnInitialize OnEnable etc. When they are not
|
|
||||||
-- present execution should continue without hinderance
|
|
||||||
if type(func) == "function" then
|
|
||||||
return Dispatchers[select('#', ...)](func, ...)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- local functions that will be implemented further down
|
|
||||||
local Enable, Disable, EnableModule, DisableModule, Embed, NewModule, GetModule, GetName, SetDefaultModuleState, SetDefaultModuleLibraries, SetEnabledState, SetDefaultModulePrototype
|
|
||||||
|
|
||||||
-- used in the addon metatable
|
|
||||||
local function addontostring( self ) return self.name end
|
|
||||||
|
|
||||||
--- Create a new AceAddon-3.0 addon.
|
|
||||||
-- Any libraries you specified will be embeded, and the addon will be scheduled for
|
|
||||||
-- its OnInitialize and OnEnable callbacks.
|
|
||||||
-- The final addon object, with all libraries embeded, will be returned.
|
|
||||||
-- @paramsig [object ,]name[, lib, ...]
|
|
||||||
-- @param object Table to use as a base for the addon (optional)
|
|
||||||
-- @param name Name of the addon object to create
|
|
||||||
-- @param lib List of libraries to embed into the addon
|
|
||||||
-- @usage
|
|
||||||
-- -- Create a simple addon object
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceEvent-3.0")
|
|
||||||
--
|
|
||||||
-- -- Create a Addon object based on the table of a frame
|
|
||||||
-- local MyFrame = CreateFrame("Frame")
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon(MyFrame, "MyAddon", "AceEvent-3.0")
|
|
||||||
function AceAddon:NewAddon(objectorname, ...)
|
|
||||||
local object,name
|
|
||||||
local i=1
|
|
||||||
if type(objectorname)=="table" then
|
|
||||||
object=objectorname
|
|
||||||
name=...
|
|
||||||
i=2
|
|
||||||
else
|
|
||||||
name=objectorname
|
|
||||||
end
|
|
||||||
if type(name)~="string" then
|
|
||||||
error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2)
|
|
||||||
end
|
|
||||||
if self.addons[name] then
|
|
||||||
error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - Addon '%s' already exists."):format(name), 2)
|
|
||||||
end
|
|
||||||
|
|
||||||
object = object or {}
|
|
||||||
object.name = name
|
|
||||||
|
|
||||||
local addonmeta = {}
|
|
||||||
local oldmeta = getmetatable(object)
|
|
||||||
if oldmeta then
|
|
||||||
for k, v in pairs(oldmeta) do addonmeta[k] = v end
|
|
||||||
end
|
|
||||||
addonmeta.__tostring = addontostring
|
|
||||||
|
|
||||||
setmetatable( object, addonmeta )
|
|
||||||
self.addons[name] = object
|
|
||||||
object.modules = {}
|
|
||||||
object.orderedModules = {}
|
|
||||||
object.defaultModuleLibraries = {}
|
|
||||||
Embed( object ) -- embed NewModule, GetModule methods
|
|
||||||
self:EmbedLibraries(object, select(i,...))
|
|
||||||
|
|
||||||
-- add to queue of addons to be initialized upon ADDON_LOADED
|
|
||||||
tinsert(self.initializequeue, object)
|
|
||||||
return object
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--- Get the addon object by its name from the internal AceAddon registry.
|
|
||||||
-- Throws an error if the addon object cannot be found (except if silent is set).
|
|
||||||
-- @param name unique name of the addon object
|
|
||||||
-- @param silent if true, the addon is optional, silently return nil if its not found
|
|
||||||
-- @usage
|
|
||||||
-- -- Get the Addon
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
|
|
||||||
function AceAddon:GetAddon(name, silent)
|
|
||||||
if not silent and not self.addons[name] then
|
|
||||||
error(("Usage: GetAddon(name): 'name' - Cannot find an AceAddon '%s'."):format(tostring(name)), 2)
|
|
||||||
end
|
|
||||||
return self.addons[name]
|
|
||||||
end
|
|
||||||
|
|
||||||
-- - Embed a list of libraries into the specified addon.
|
|
||||||
-- This function will try to embed all of the listed libraries into the addon
|
|
||||||
-- and error if a single one fails.
|
|
||||||
--
|
|
||||||
-- **Note:** This function is for internal use by :NewAddon/:NewModule
|
|
||||||
-- @paramsig addon, [lib, ...]
|
|
||||||
-- @param addon addon object to embed the libs in
|
|
||||||
-- @param lib List of libraries to embed into the addon
|
|
||||||
function AceAddon:EmbedLibraries(addon, ...)
|
|
||||||
for i=1,select("#", ... ) do
|
|
||||||
local libname = select(i, ...)
|
|
||||||
self:EmbedLibrary(addon, libname, false, 4)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- - Embed a library into the addon object.
|
|
||||||
-- This function will check if the specified library is registered with LibStub
|
|
||||||
-- and if it has a :Embed function to call. It'll error if any of those conditions
|
|
||||||
-- fails.
|
|
||||||
--
|
|
||||||
-- **Note:** This function is for internal use by :EmbedLibraries
|
|
||||||
-- @paramsig addon, libname[, silent[, offset]]
|
|
||||||
-- @param addon addon object to embed the library in
|
|
||||||
-- @param libname name of the library to embed
|
|
||||||
-- @param silent marks an embed to fail silently if the library doesn't exist (optional)
|
|
||||||
-- @param offset will push the error messages back to said offset, defaults to 2 (optional)
|
|
||||||
function AceAddon:EmbedLibrary(addon, libname, silent, offset)
|
|
||||||
local lib = LibStub:GetLibrary(libname, true)
|
|
||||||
if not lib and not silent then
|
|
||||||
error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Cannot find a library instance of %q."):format(tostring(libname)), offset or 2)
|
|
||||||
elseif lib and type(lib.Embed) == "function" then
|
|
||||||
lib:Embed(addon)
|
|
||||||
tinsert(self.embeds[addon], libname)
|
|
||||||
return true
|
|
||||||
elseif lib then
|
|
||||||
error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Library '%s' is not Embed capable"):format(libname), offset or 2)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Return the specified module from an addon object.
|
|
||||||
-- Throws an error if the addon object cannot be found (except if silent is set)
|
|
||||||
-- @name //addon//:GetModule
|
|
||||||
-- @paramsig name[, silent]
|
|
||||||
-- @param name unique name of the module
|
|
||||||
-- @param silent if true, the module is optional, silently return nil if its not found (optional)
|
|
||||||
-- @usage
|
|
||||||
-- -- Get the Addon
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
|
|
||||||
-- -- Get the Module
|
|
||||||
-- MyModule = MyAddon:GetModule("MyModule")
|
|
||||||
function GetModule(self, name, silent)
|
|
||||||
if not self.modules[name] and not silent then
|
|
||||||
error(("Usage: GetModule(name, silent): 'name' - Cannot find module '%s'."):format(tostring(name)), 2)
|
|
||||||
end
|
|
||||||
return self.modules[name]
|
|
||||||
end
|
|
||||||
|
|
||||||
local function IsModuleTrue(self) return true end
|
|
||||||
|
|
||||||
--- Create a new module for the addon.
|
|
||||||
-- The new module can have its own embeded libraries and/or use a module prototype to be mixed into the module.\\
|
|
||||||
-- A module has the same functionality as a real addon, it can have modules of its own, and has the same API as
|
|
||||||
-- an addon object.
|
|
||||||
-- @name //addon//:NewModule
|
|
||||||
-- @paramsig name[, prototype|lib[, lib, ...]]
|
|
||||||
-- @param name unique name of the module
|
|
||||||
-- @param prototype object to derive this module from, methods and values from this table will be mixed into the module (optional)
|
|
||||||
-- @param lib List of libraries to embed into the addon
|
|
||||||
-- @usage
|
|
||||||
-- -- Create a module with some embeded libraries
|
|
||||||
-- MyModule = MyAddon:NewModule("MyModule", "AceEvent-3.0", "AceHook-3.0")
|
|
||||||
--
|
|
||||||
-- -- Create a module with a prototype
|
|
||||||
-- local prototype = { OnEnable = function(self) print("OnEnable called!") end }
|
|
||||||
-- MyModule = MyAddon:NewModule("MyModule", prototype, "AceEvent-3.0", "AceHook-3.0")
|
|
||||||
function NewModule(self, name, prototype, ...)
|
|
||||||
if type(name) ~= "string" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) end
|
|
||||||
if type(prototype) ~= "string" and type(prototype) ~= "table" and type(prototype) ~= "nil" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'prototype' - table (prototype), string (lib) or nil expected got '%s'."):format(type(prototype)), 2) end
|
|
||||||
|
|
||||||
if self.modules[name] then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - Module '%s' already exists."):format(name), 2) end
|
|
||||||
|
|
||||||
-- modules are basically addons. We treat them as such. They will be added to the initializequeue properly as well.
|
|
||||||
-- NewModule can only be called after the parent addon is present thus the modules will be initialized after their parent is.
|
|
||||||
local module = AceAddon:NewAddon(fmt("%s_%s", self.name or tostring(self), name))
|
|
||||||
|
|
||||||
module.IsModule = IsModuleTrue
|
|
||||||
module:SetEnabledState(self.defaultModuleState)
|
|
||||||
module.moduleName = name
|
|
||||||
|
|
||||||
if type(prototype) == "string" then
|
|
||||||
AceAddon:EmbedLibraries(module, prototype, ...)
|
|
||||||
else
|
|
||||||
AceAddon:EmbedLibraries(module, ...)
|
|
||||||
end
|
|
||||||
AceAddon:EmbedLibraries(module, unpack(self.defaultModuleLibraries))
|
|
||||||
|
|
||||||
if not prototype or type(prototype) == "string" then
|
|
||||||
prototype = self.defaultModulePrototype or nil
|
|
||||||
end
|
|
||||||
|
|
||||||
if type(prototype) == "table" then
|
|
||||||
local mt = getmetatable(module)
|
|
||||||
mt.__index = prototype
|
|
||||||
setmetatable(module, mt) -- More of a Base class type feel.
|
|
||||||
end
|
|
||||||
|
|
||||||
safecall(self.OnModuleCreated, self, module) -- Was in Ace2 and I think it could be a cool thing to have handy.
|
|
||||||
self.modules[name] = module
|
|
||||||
tinsert(self.orderedModules, module)
|
|
||||||
|
|
||||||
return module
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Returns the real name of the addon or module, without any prefix.
|
|
||||||
-- @name //addon//:GetName
|
|
||||||
-- @paramsig
|
|
||||||
-- @usage
|
|
||||||
-- print(MyAddon:GetName())
|
|
||||||
-- -- prints "MyAddon"
|
|
||||||
function GetName(self)
|
|
||||||
return self.moduleName or self.name
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Enables the Addon, if possible, return true or false depending on success.
|
|
||||||
-- This internally calls AceAddon:EnableAddon(), thus dispatching a OnEnable callback
|
|
||||||
-- and enabling all modules of the addon (unless explicitly disabled).\\
|
|
||||||
-- :Enable() also sets the internal `enableState` variable to true
|
|
||||||
-- @name //addon//:Enable
|
|
||||||
-- @paramsig
|
|
||||||
-- @usage
|
|
||||||
-- -- Enable MyModule
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
|
|
||||||
-- MyModule = MyAddon:GetModule("MyModule")
|
|
||||||
-- MyModule:Enable()
|
|
||||||
function Enable(self)
|
|
||||||
self:SetEnabledState(true)
|
|
||||||
return AceAddon:EnableAddon(self)
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Disables the Addon, if possible, return true or false depending on success.
|
|
||||||
-- This internally calls AceAddon:DisableAddon(), thus dispatching a OnDisable callback
|
|
||||||
-- and disabling all modules of the addon.\\
|
|
||||||
-- :Disable() also sets the internal `enableState` variable to false
|
|
||||||
-- @name //addon//:Disable
|
|
||||||
-- @paramsig
|
|
||||||
-- @usage
|
|
||||||
-- -- Disable MyAddon
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
|
|
||||||
-- MyAddon:Disable()
|
|
||||||
function Disable(self)
|
|
||||||
self:SetEnabledState(false)
|
|
||||||
return AceAddon:DisableAddon(self)
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Enables the Module, if possible, return true or false depending on success.
|
|
||||||
-- Short-hand function that retrieves the module via `:GetModule` and calls `:Enable` on the module object.
|
|
||||||
-- @name //addon//:EnableModule
|
|
||||||
-- @paramsig name
|
|
||||||
-- @usage
|
|
||||||
-- -- Enable MyModule using :GetModule
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
|
|
||||||
-- MyModule = MyAddon:GetModule("MyModule")
|
|
||||||
-- MyModule:Enable()
|
|
||||||
--
|
|
||||||
-- -- Enable MyModule using the short-hand
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
|
|
||||||
-- MyAddon:EnableModule("MyModule")
|
|
||||||
function EnableModule(self, name)
|
|
||||||
local module = self:GetModule( name )
|
|
||||||
return module:Enable()
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Disables the Module, if possible, return true or false depending on success.
|
|
||||||
-- Short-hand function that retrieves the module via `:GetModule` and calls `:Disable` on the module object.
|
|
||||||
-- @name //addon//:DisableModule
|
|
||||||
-- @paramsig name
|
|
||||||
-- @usage
|
|
||||||
-- -- Disable MyModule using :GetModule
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
|
|
||||||
-- MyModule = MyAddon:GetModule("MyModule")
|
|
||||||
-- MyModule:Disable()
|
|
||||||
--
|
|
||||||
-- -- Disable MyModule using the short-hand
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
|
|
||||||
-- MyAddon:DisableModule("MyModule")
|
|
||||||
function DisableModule(self, name)
|
|
||||||
local module = self:GetModule( name )
|
|
||||||
return module:Disable()
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Set the default libraries to be mixed into all modules created by this object.
|
|
||||||
-- Note that you can only change the default module libraries before any module is created.
|
|
||||||
-- @name //addon//:SetDefaultModuleLibraries
|
|
||||||
-- @paramsig lib[, lib, ...]
|
|
||||||
-- @param lib List of libraries to embed into the addon
|
|
||||||
-- @usage
|
|
||||||
-- -- Create the addon object
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
|
|
||||||
-- -- Configure default libraries for modules (all modules need AceEvent-3.0)
|
|
||||||
-- MyAddon:SetDefaultModuleLibraries("AceEvent-3.0")
|
|
||||||
-- -- Create a module
|
|
||||||
-- MyModule = MyAddon:NewModule("MyModule")
|
|
||||||
function SetDefaultModuleLibraries(self, ...)
|
|
||||||
if next(self.modules) then
|
|
||||||
error("Usage: SetDefaultModuleLibraries(...): cannot change the module defaults after a module has been registered.", 2)
|
|
||||||
end
|
|
||||||
self.defaultModuleLibraries = {...}
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Set the default state in which new modules are being created.
|
|
||||||
-- Note that you can only change the default state before any module is created.
|
|
||||||
-- @name //addon//:SetDefaultModuleState
|
|
||||||
-- @paramsig state
|
|
||||||
-- @param state Default state for new modules, true for enabled, false for disabled
|
|
||||||
-- @usage
|
|
||||||
-- -- Create the addon object
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
|
|
||||||
-- -- Set the default state to "disabled"
|
|
||||||
-- MyAddon:SetDefaultModuleState(false)
|
|
||||||
-- -- Create a module and explicilty enable it
|
|
||||||
-- MyModule = MyAddon:NewModule("MyModule")
|
|
||||||
-- MyModule:Enable()
|
|
||||||
function SetDefaultModuleState(self, state)
|
|
||||||
if next(self.modules) then
|
|
||||||
error("Usage: SetDefaultModuleState(state): cannot change the module defaults after a module has been registered.", 2)
|
|
||||||
end
|
|
||||||
self.defaultModuleState = state
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Set the default prototype to use for new modules on creation.
|
|
||||||
-- Note that you can only change the default prototype before any module is created.
|
|
||||||
-- @name //addon//:SetDefaultModulePrototype
|
|
||||||
-- @paramsig prototype
|
|
||||||
-- @param prototype Default prototype for the new modules (table)
|
|
||||||
-- @usage
|
|
||||||
-- -- Define a prototype
|
|
||||||
-- local prototype = { OnEnable = function(self) print("OnEnable called!") end }
|
|
||||||
-- -- Set the default prototype
|
|
||||||
-- MyAddon:SetDefaultModulePrototype(prototype)
|
|
||||||
-- -- Create a module and explicitly Enable it
|
|
||||||
-- MyModule = MyAddon:NewModule("MyModule")
|
|
||||||
-- MyModule:Enable()
|
|
||||||
-- -- should print "OnEnable called!" now
|
|
||||||
-- @see NewModule
|
|
||||||
function SetDefaultModulePrototype(self, prototype)
|
|
||||||
if next(self.modules) then
|
|
||||||
error("Usage: SetDefaultModulePrototype(prototype): cannot change the module defaults after a module has been registered.", 2)
|
|
||||||
end
|
|
||||||
if type(prototype) ~= "table" then
|
|
||||||
error(("Usage: SetDefaultModulePrototype(prototype): 'prototype' - table expected got '%s'."):format(type(prototype)), 2)
|
|
||||||
end
|
|
||||||
self.defaultModulePrototype = prototype
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Set the state of an addon or module
|
|
||||||
-- This should only be called before any enabling actually happend, e.g. in/before OnInitialize.
|
|
||||||
-- @name //addon//:SetEnabledState
|
|
||||||
-- @paramsig state
|
|
||||||
-- @param state the state of an addon or module (enabled=true, disabled=false)
|
|
||||||
function SetEnabledState(self, state)
|
|
||||||
self.enabledState = state
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--- Return an iterator of all modules associated to the addon.
|
|
||||||
-- @name //addon//:IterateModules
|
|
||||||
-- @paramsig
|
|
||||||
-- @usage
|
|
||||||
-- -- Enable all modules
|
|
||||||
-- for name, module in MyAddon:IterateModules() do
|
|
||||||
-- module:Enable()
|
|
||||||
-- end
|
|
||||||
local function IterateModules(self) return pairs(self.modules) end
|
|
||||||
|
|
||||||
-- Returns an iterator of all embeds in the addon
|
|
||||||
-- @name //addon//:IterateEmbeds
|
|
||||||
-- @paramsig
|
|
||||||
local function IterateEmbeds(self) return pairs(AceAddon.embeds[self]) end
|
|
||||||
|
|
||||||
--- Query the enabledState of an addon.
|
|
||||||
-- @name //addon//:IsEnabled
|
|
||||||
-- @paramsig
|
|
||||||
-- @usage
|
|
||||||
-- if MyAddon:IsEnabled() then
|
|
||||||
-- MyAddon:Disable()
|
|
||||||
-- end
|
|
||||||
local function IsEnabled(self) return self.enabledState end
|
|
||||||
local mixins = {
|
|
||||||
NewModule = NewModule,
|
|
||||||
GetModule = GetModule,
|
|
||||||
Enable = Enable,
|
|
||||||
Disable = Disable,
|
|
||||||
EnableModule = EnableModule,
|
|
||||||
DisableModule = DisableModule,
|
|
||||||
IsEnabled = IsEnabled,
|
|
||||||
SetDefaultModuleLibraries = SetDefaultModuleLibraries,
|
|
||||||
SetDefaultModuleState = SetDefaultModuleState,
|
|
||||||
SetDefaultModulePrototype = SetDefaultModulePrototype,
|
|
||||||
SetEnabledState = SetEnabledState,
|
|
||||||
IterateModules = IterateModules,
|
|
||||||
IterateEmbeds = IterateEmbeds,
|
|
||||||
GetName = GetName,
|
|
||||||
}
|
|
||||||
local function IsModule(self) return false end
|
|
||||||
local pmixins = {
|
|
||||||
defaultModuleState = true,
|
|
||||||
enabledState = true,
|
|
||||||
IsModule = IsModule,
|
|
||||||
}
|
|
||||||
-- Embed( target )
|
|
||||||
-- target (object) - target object to embed aceaddon in
|
|
||||||
--
|
|
||||||
-- this is a local function specifically since it's meant to be only called internally
|
|
||||||
function Embed(target, skipPMixins)
|
|
||||||
for k, v in pairs(mixins) do
|
|
||||||
target[k] = v
|
|
||||||
end
|
|
||||||
if not skipPMixins then
|
|
||||||
for k, v in pairs(pmixins) do
|
|
||||||
target[k] = target[k] or v
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- - Initialize the addon after creation.
|
|
||||||
-- This function is only used internally during the ADDON_LOADED event
|
|
||||||
-- It will call the **OnInitialize** function on the addon object (if present),
|
|
||||||
-- and the **OnEmbedInitialize** function on all embeded libraries.
|
|
||||||
--
|
|
||||||
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
|
|
||||||
-- @param addon addon object to intialize
|
|
||||||
function AceAddon:InitializeAddon(addon)
|
|
||||||
safecall(addon.OnInitialize, addon)
|
|
||||||
|
|
||||||
local embeds = self.embeds[addon]
|
|
||||||
for i = 1, #embeds do
|
|
||||||
local lib = LibStub:GetLibrary(embeds[i], true)
|
|
||||||
if lib then safecall(lib.OnEmbedInitialize, lib, addon) end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- we don't call InitializeAddon on modules specifically, this is handled
|
|
||||||
-- from the event handler and only done _once_
|
|
||||||
end
|
|
||||||
|
|
||||||
-- - Enable the addon after creation.
|
|
||||||
-- Note: This function is only used internally during the PLAYER_LOGIN event, or during ADDON_LOADED,
|
|
||||||
-- if IsLoggedIn() already returns true at that point, e.g. for LoD Addons.
|
|
||||||
-- It will call the **OnEnable** function on the addon object (if present),
|
|
||||||
-- and the **OnEmbedEnable** function on all embeded libraries.\\
|
|
||||||
-- This function does not toggle the enable state of the addon itself, and will return early if the addon is disabled.
|
|
||||||
--
|
|
||||||
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
|
|
||||||
-- Use :Enable on the addon itself instead.
|
|
||||||
-- @param addon addon object to enable
|
|
||||||
function AceAddon:EnableAddon(addon)
|
|
||||||
if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
|
|
||||||
if self.statuses[addon.name] or not addon.enabledState then return false end
|
|
||||||
|
|
||||||
-- set the statuses first, before calling the OnEnable. this allows for Disabling of the addon in OnEnable.
|
|
||||||
self.statuses[addon.name] = true
|
|
||||||
|
|
||||||
safecall(addon.OnEnable, addon)
|
|
||||||
|
|
||||||
-- make sure we're still enabled before continueing
|
|
||||||
if self.statuses[addon.name] then
|
|
||||||
local embeds = self.embeds[addon]
|
|
||||||
for i = 1, #embeds do
|
|
||||||
local lib = LibStub:GetLibrary(embeds[i], true)
|
|
||||||
if lib then safecall(lib.OnEmbedEnable, lib, addon) end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- enable possible modules.
|
|
||||||
local modules = addon.orderedModules
|
|
||||||
for i = 1, #modules do
|
|
||||||
self:EnableAddon(modules[i])
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return self.statuses[addon.name] -- return true if we're disabled
|
|
||||||
end
|
|
||||||
|
|
||||||
-- - Disable the addon
|
|
||||||
-- Note: This function is only used internally.
|
|
||||||
-- It will call the **OnDisable** function on the addon object (if present),
|
|
||||||
-- and the **OnEmbedDisable** function on all embeded libraries.\\
|
|
||||||
-- This function does not toggle the enable state of the addon itself, and will return early if the addon is still enabled.
|
|
||||||
--
|
|
||||||
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
|
|
||||||
-- Use :Disable on the addon itself instead.
|
|
||||||
-- @param addon addon object to enable
|
|
||||||
function AceAddon:DisableAddon(addon)
|
|
||||||
if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
|
|
||||||
if not self.statuses[addon.name] then return false end
|
|
||||||
|
|
||||||
-- set statuses first before calling OnDisable, this allows for aborting the disable in OnDisable.
|
|
||||||
self.statuses[addon.name] = false
|
|
||||||
|
|
||||||
safecall( addon.OnDisable, addon )
|
|
||||||
|
|
||||||
-- make sure we're still disabling...
|
|
||||||
if not self.statuses[addon.name] then
|
|
||||||
local embeds = self.embeds[addon]
|
|
||||||
for i = 1, #embeds do
|
|
||||||
local lib = LibStub:GetLibrary(embeds[i], true)
|
|
||||||
if lib then safecall(lib.OnEmbedDisable, lib, addon) end
|
|
||||||
end
|
|
||||||
-- disable possible modules.
|
|
||||||
local modules = addon.orderedModules
|
|
||||||
for i = 1, #modules do
|
|
||||||
self:DisableAddon(modules[i])
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return not self.statuses[addon.name] -- return true if we're disabled
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Get an iterator over all registered addons.
|
|
||||||
-- @usage
|
|
||||||
-- -- Print a list of all installed AceAddon's
|
|
||||||
-- for name, addon in AceAddon:IterateAddons() do
|
|
||||||
-- print("Addon: " .. name)
|
|
||||||
-- end
|
|
||||||
function AceAddon:IterateAddons() return pairs(self.addons) end
|
|
||||||
|
|
||||||
--- Get an iterator over the internal status registry.
|
|
||||||
-- @usage
|
|
||||||
-- -- Print a list of all enabled addons
|
|
||||||
-- for name, status in AceAddon:IterateAddonStatus() do
|
|
||||||
-- if status then
|
|
||||||
-- print("EnabledAddon: " .. name)
|
|
||||||
-- end
|
|
||||||
-- end
|
|
||||||
function AceAddon:IterateAddonStatus() return pairs(self.statuses) end
|
|
||||||
|
|
||||||
-- Following Iterators are deprecated, and their addon specific versions should be used
|
|
||||||
-- e.g. addon:IterateEmbeds() instead of :IterateEmbedsOnAddon(addon)
|
|
||||||
function AceAddon:IterateEmbedsOnAddon(addon) return pairs(self.embeds[addon]) end
|
|
||||||
function AceAddon:IterateModulesOfAddon(addon) return pairs(addon.modules) end
|
|
||||||
|
|
||||||
-- Event Handling
|
|
||||||
local function onEvent(this, event, arg1)
|
|
||||||
if event == "ADDON_LOADED" or event == "PLAYER_LOGIN" then
|
|
||||||
-- if a addon loads another addon, recursion could happen here, so we need to validate the table on every iteration
|
|
||||||
while(#AceAddon.initializequeue > 0) do
|
|
||||||
local addon = tremove(AceAddon.initializequeue, 1)
|
|
||||||
-- this might be an issue with recursion - TODO: validate
|
|
||||||
if event == "ADDON_LOADED" then addon.baseName = arg1 end
|
|
||||||
AceAddon:InitializeAddon(addon)
|
|
||||||
tinsert(AceAddon.enablequeue, addon)
|
|
||||||
end
|
|
||||||
|
|
||||||
if IsLoggedIn() then
|
|
||||||
while(#AceAddon.enablequeue > 0) do
|
|
||||||
local addon = tremove(AceAddon.enablequeue, 1)
|
|
||||||
AceAddon:EnableAddon(addon)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
AceAddon.frame:RegisterEvent("ADDON_LOADED")
|
|
||||||
AceAddon.frame:RegisterEvent("PLAYER_LOGIN")
|
|
||||||
AceAddon.frame:SetScript("OnEvent", onEvent)
|
|
||||||
|
|
||||||
-- upgrade embeded
|
|
||||||
for name, addon in pairs(AceAddon.addons) do
|
|
||||||
Embed(addon, true)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- 2010-10-27 nevcairiel - add new "orderedModules" table
|
|
||||||
if oldminor and oldminor < 10 then
|
|
||||||
for name, addon in pairs(AceAddon.addons) do
|
|
||||||
addon.orderedModules = {}
|
|
||||||
for module_name, module in pairs(addon.modules) do
|
|
||||||
tinsert(addon.orderedModules, module)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
@ -1,4 +0,0 @@
|
||||||
<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="AceAddon-3.0.lua"/>
|
|
||||||
</Ui>
|
|
||||||
|
|
@ -1,250 +0,0 @@
|
||||||
--- **AceConsole-3.0** provides registration facilities for slash commands.
|
|
||||||
-- You can register slash commands to your custom functions and use the `GetArgs` function to parse them
|
|
||||||
-- to your addons individual needs.
|
|
||||||
--
|
|
||||||
-- **AceConsole-3.0** can be embeded into your addon, either explicitly by calling AceConsole:Embed(MyAddon) or by
|
|
||||||
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
|
|
||||||
-- and can be accessed directly, without having to explicitly call AceConsole itself.\\
|
|
||||||
-- It is recommended to embed AceConsole, otherwise you'll have to specify a custom `self` on all calls you
|
|
||||||
-- make into AceConsole.
|
|
||||||
-- @class file
|
|
||||||
-- @name AceConsole-3.0
|
|
||||||
-- @release $Id: AceConsole-3.0.lua 878 2009-11-02 18:51:58Z nevcairiel $
|
|
||||||
local MAJOR,MINOR = "AceConsole-3.0", 7
|
|
||||||
|
|
||||||
local AceConsole, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
|
|
||||||
|
|
||||||
if not AceConsole then return end -- No upgrade needed
|
|
||||||
|
|
||||||
AceConsole.embeds = AceConsole.embeds or {} -- table containing objects AceConsole is embedded in.
|
|
||||||
AceConsole.commands = AceConsole.commands or {} -- table containing commands registered
|
|
||||||
AceConsole.weakcommands = AceConsole.weakcommands or {} -- table containing self, command => func references for weak commands that don't persist through enable/disable
|
|
||||||
|
|
||||||
-- Lua APIs
|
|
||||||
local tconcat, tostring, select = table.concat, tostring, select
|
|
||||||
local type, pairs, error = type, pairs, error
|
|
||||||
local format, strfind, strsub = string.format, string.find, string.sub
|
|
||||||
local max = math.max
|
|
||||||
|
|
||||||
-- 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: DEFAULT_CHAT_FRAME, SlashCmdList, hash_SlashCmdList
|
|
||||||
|
|
||||||
local tmp={}
|
|
||||||
local function Print(self,frame,...)
|
|
||||||
local n=0
|
|
||||||
if self ~= AceConsole then
|
|
||||||
n=n+1
|
|
||||||
tmp[n] = "|cff33ff99"..tostring( self ).."|r:"
|
|
||||||
end
|
|
||||||
for i=1, select("#", ...) do
|
|
||||||
n=n+1
|
|
||||||
tmp[n] = tostring(select(i, ...))
|
|
||||||
end
|
|
||||||
frame:AddMessage( tconcat(tmp," ",1,n) )
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function)
|
|
||||||
-- @paramsig [chatframe ,] ...
|
|
||||||
-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function)
|
|
||||||
-- @param ... List of any values to be printed
|
|
||||||
function AceConsole:Print(...)
|
|
||||||
local frame = ...
|
|
||||||
if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member?
|
|
||||||
return Print(self, frame, select(2,...))
|
|
||||||
else
|
|
||||||
return Print(self, DEFAULT_CHAT_FRAME, ...)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--- Formatted (using format()) print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function)
|
|
||||||
-- @paramsig [chatframe ,] "format"[, ...]
|
|
||||||
-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function)
|
|
||||||
-- @param format Format string - same syntax as standard Lua format()
|
|
||||||
-- @param ... Arguments to the format string
|
|
||||||
function AceConsole:Printf(...)
|
|
||||||
local frame = ...
|
|
||||||
if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member?
|
|
||||||
return Print(self, frame, format(select(2,...)))
|
|
||||||
else
|
|
||||||
return Print(self, DEFAULT_CHAT_FRAME, format(...))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
--- Register a simple chat command
|
|
||||||
-- @param command Chat command to be registered WITHOUT leading "/"
|
|
||||||
-- @param func Function to call when the slash command is being used (funcref or methodname)
|
|
||||||
-- @param persist if false, the command will be soft disabled/enabled when aceconsole is used as a mixin (default: true)
|
|
||||||
function AceConsole:RegisterChatCommand( command, func, persist )
|
|
||||||
if type(command)~="string" then error([[Usage: AceConsole:RegisterChatCommand( "command", func[, persist ]): 'command' - expected a string]], 2) end
|
|
||||||
|
|
||||||
if persist==nil then persist=true end -- I'd rather have my addon's "/addon enable" around if the author screws up. Having some extra slash regged when it shouldnt be isn't as destructive. True is a better default. /Mikk
|
|
||||||
|
|
||||||
local name = "ACECONSOLE_"..command:upper()
|
|
||||||
|
|
||||||
if type( func ) == "string" then
|
|
||||||
SlashCmdList[name] = function(input, editBox)
|
|
||||||
self[func](self, input, editBox)
|
|
||||||
end
|
|
||||||
else
|
|
||||||
SlashCmdList[name] = func
|
|
||||||
end
|
|
||||||
_G["SLASH_"..name.."1"] = "/"..command:lower()
|
|
||||||
AceConsole.commands[command] = name
|
|
||||||
-- non-persisting commands are registered for enabling disabling
|
|
||||||
if not persist then
|
|
||||||
if not AceConsole.weakcommands[self] then AceConsole.weakcommands[self] = {} end
|
|
||||||
AceConsole.weakcommands[self][command] = func
|
|
||||||
end
|
|
||||||
return true
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Unregister a chatcommand
|
|
||||||
-- @param command Chat command to be unregistered WITHOUT leading "/"
|
|
||||||
function AceConsole:UnregisterChatCommand( command )
|
|
||||||
local name = AceConsole.commands[command]
|
|
||||||
if name then
|
|
||||||
SlashCmdList[name] = nil
|
|
||||||
_G["SLASH_" .. name .. "1"] = nil
|
|
||||||
hash_SlashCmdList["/" .. command:upper()] = nil
|
|
||||||
AceConsole.commands[command] = nil
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Get an iterator over all Chat Commands registered with AceConsole
|
|
||||||
-- @return Iterator (pairs) over all commands
|
|
||||||
function AceConsole:IterateChatCommands() return pairs(AceConsole.commands) end
|
|
||||||
|
|
||||||
|
|
||||||
local function nils(n, ...)
|
|
||||||
if n>1 then
|
|
||||||
return nil, nils(n-1, ...)
|
|
||||||
elseif n==1 then
|
|
||||||
return nil, ...
|
|
||||||
else
|
|
||||||
return ...
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--- Retreive one or more space-separated arguments from a string.
|
|
||||||
-- Treats quoted strings and itemlinks as non-spaced.
|
|
||||||
-- @param string The raw argument string
|
|
||||||
-- @param numargs How many arguments to get (default 1)
|
|
||||||
-- @param startpos Where in the string to start scanning (default 1)
|
|
||||||
-- @return Returns arg1, arg2, ..., nextposition\\
|
|
||||||
-- Missing arguments will be returned as nils. 'nextposition' is returned as 1e9 at the end of the string.
|
|
||||||
function AceConsole:GetArgs(str, numargs, startpos)
|
|
||||||
numargs = numargs or 1
|
|
||||||
startpos = max(startpos or 1, 1)
|
|
||||||
|
|
||||||
local pos=startpos
|
|
||||||
|
|
||||||
-- find start of new arg
|
|
||||||
pos = strfind(str, "[^ ]", pos)
|
|
||||||
if not pos then -- whoops, end of string
|
|
||||||
return nils(numargs, 1e9)
|
|
||||||
end
|
|
||||||
|
|
||||||
if numargs<1 then
|
|
||||||
return pos
|
|
||||||
end
|
|
||||||
|
|
||||||
-- quoted or space separated? find out which pattern to use
|
|
||||||
local delim_or_pipe
|
|
||||||
local ch = strsub(str, pos, pos)
|
|
||||||
if ch=='"' then
|
|
||||||
pos = pos + 1
|
|
||||||
delim_or_pipe='([|"])'
|
|
||||||
elseif ch=="'" then
|
|
||||||
pos = pos + 1
|
|
||||||
delim_or_pipe="([|'])"
|
|
||||||
else
|
|
||||||
delim_or_pipe="([| ])"
|
|
||||||
end
|
|
||||||
|
|
||||||
startpos = pos
|
|
||||||
|
|
||||||
while true do
|
|
||||||
-- find delimiter or hyperlink
|
|
||||||
local ch,_
|
|
||||||
pos,_,ch = strfind(str, delim_or_pipe, pos)
|
|
||||||
|
|
||||||
if not pos then break end
|
|
||||||
|
|
||||||
if ch=="|" then
|
|
||||||
-- some kind of escape
|
|
||||||
|
|
||||||
if strsub(str,pos,pos+1)=="|H" then
|
|
||||||
-- It's a |H....|hhyper link!|h
|
|
||||||
pos=strfind(str, "|h", pos+2) -- first |h
|
|
||||||
if not pos then break end
|
|
||||||
|
|
||||||
pos=strfind(str, "|h", pos+2) -- second |h
|
|
||||||
if not pos then break end
|
|
||||||
elseif strsub(str,pos, pos+1) == "|T" then
|
|
||||||
-- It's a |T....|t texture
|
|
||||||
pos=strfind(str, "|t", pos+2)
|
|
||||||
if not pos then break end
|
|
||||||
end
|
|
||||||
|
|
||||||
pos=pos+2 -- skip past this escape (last |h if it was a hyperlink)
|
|
||||||
|
|
||||||
else
|
|
||||||
-- found delimiter, done with this arg
|
|
||||||
return strsub(str, startpos, pos-1), AceConsole:GetArgs(str, numargs-1, pos+1)
|
|
||||||
end
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
-- search aborted, we hit end of string. return it all as one argument. (yes, even if it's an unterminated quote or hyperlink)
|
|
||||||
return strsub(str, startpos), nils(numargs-1, 1e9)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--- embedding and embed handling
|
|
||||||
|
|
||||||
local mixins = {
|
|
||||||
"Print",
|
|
||||||
"Printf",
|
|
||||||
"RegisterChatCommand",
|
|
||||||
"UnregisterChatCommand",
|
|
||||||
"GetArgs",
|
|
||||||
}
|
|
||||||
|
|
||||||
-- Embeds AceConsole into the target object making the functions from the mixins list available on target:..
|
|
||||||
-- @param target target object to embed AceBucket in
|
|
||||||
function AceConsole:Embed( target )
|
|
||||||
for k, v in pairs( mixins ) do
|
|
||||||
target[v] = self[v]
|
|
||||||
end
|
|
||||||
self.embeds[target] = true
|
|
||||||
return target
|
|
||||||
end
|
|
||||||
|
|
||||||
function AceConsole:OnEmbedEnable( target )
|
|
||||||
if AceConsole.weakcommands[target] then
|
|
||||||
for command, func in pairs( AceConsole.weakcommands[target] ) do
|
|
||||||
target:RegisterChatCommand( command, func, false, true ) -- nonpersisting and silent registry
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
function AceConsole:OnEmbedDisable( target )
|
|
||||||
if AceConsole.weakcommands[target] then
|
|
||||||
for command, func in pairs( AceConsole.weakcommands[target] ) do
|
|
||||||
target:UnregisterChatCommand( command ) -- TODO: this could potentially unregister a command from another application in case of command conflicts. Do we care?
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
for addon in pairs(AceConsole.embeds) do
|
|
||||||
AceConsole:Embed(addon)
|
|
||||||
end
|
|
||||||
|
|
@ -1,4 +0,0 @@
|
||||||
<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="AceConsole-3.0.lua"/>
|
|
||||||
</Ui>
|
|
||||||
|
|
@ -1,126 +0,0 @@
|
||||||
--- AceEvent-3.0 provides event registration and secure dispatching.
|
|
||||||
-- All dispatching is done using **CallbackHandler-1.0**. AceEvent is a simple wrapper around
|
|
||||||
-- CallbackHandler, and dispatches all game events or addon message to the registrees.
|
|
||||||
--
|
|
||||||
-- **AceEvent-3.0** can be embeded into your addon, either explicitly by calling AceEvent:Embed(MyAddon) or by
|
|
||||||
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
|
|
||||||
-- and can be accessed directly, without having to explicitly call AceEvent itself.\\
|
|
||||||
-- It is recommended to embed AceEvent, otherwise you'll have to specify a custom `self` on all calls you
|
|
||||||
-- make into AceEvent.
|
|
||||||
-- @class file
|
|
||||||
-- @name AceEvent-3.0
|
|
||||||
-- @release $Id: AceEvent-3.0.lua 975 2010-10-23 11:26:18Z nevcairiel $
|
|
||||||
local MAJOR, MINOR = "AceEvent-3.0", 3
|
|
||||||
local AceEvent = LibStub:NewLibrary(MAJOR, MINOR)
|
|
||||||
|
|
||||||
if not AceEvent then return end
|
|
||||||
|
|
||||||
-- Lua APIs
|
|
||||||
local pairs = pairs
|
|
||||||
|
|
||||||
local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0")
|
|
||||||
|
|
||||||
AceEvent.frame = AceEvent.frame or CreateFrame("Frame", "AceEvent30Frame") -- our event frame
|
|
||||||
AceEvent.embeds = AceEvent.embeds or {} -- what objects embed this lib
|
|
||||||
|
|
||||||
-- APIs and registry for blizzard events, using CallbackHandler lib
|
|
||||||
if not AceEvent.events then
|
|
||||||
AceEvent.events = CallbackHandler:New(AceEvent,
|
|
||||||
"RegisterEvent", "UnregisterEvent", "UnregisterAllEvents")
|
|
||||||
end
|
|
||||||
|
|
||||||
function AceEvent.events:OnUsed(target, eventname)
|
|
||||||
AceEvent.frame:RegisterEvent(eventname)
|
|
||||||
end
|
|
||||||
|
|
||||||
function AceEvent.events:OnUnused(target, eventname)
|
|
||||||
AceEvent.frame:UnregisterEvent(eventname)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- APIs and registry for IPC messages, using CallbackHandler lib
|
|
||||||
if not AceEvent.messages then
|
|
||||||
AceEvent.messages = CallbackHandler:New(AceEvent,
|
|
||||||
"RegisterMessage", "UnregisterMessage", "UnregisterAllMessages"
|
|
||||||
)
|
|
||||||
AceEvent.SendMessage = AceEvent.messages.Fire
|
|
||||||
end
|
|
||||||
|
|
||||||
--- embedding and embed handling
|
|
||||||
local mixins = {
|
|
||||||
"RegisterEvent", "UnregisterEvent",
|
|
||||||
"RegisterMessage", "UnregisterMessage",
|
|
||||||
"SendMessage",
|
|
||||||
"UnregisterAllEvents", "UnregisterAllMessages",
|
|
||||||
}
|
|
||||||
|
|
||||||
--- Register for a Blizzard Event.
|
|
||||||
-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied)
|
|
||||||
-- Any arguments to the event will be passed on after that.
|
|
||||||
-- @name AceEvent:RegisterEvent
|
|
||||||
-- @class function
|
|
||||||
-- @paramsig event[, callback [, arg]]
|
|
||||||
-- @param event The event to register for
|
|
||||||
-- @param callback The callback function to call when the event is triggered (funcref or method, defaults to a method with the event name)
|
|
||||||
-- @param arg An optional argument to pass to the callback function
|
|
||||||
|
|
||||||
--- Unregister an event.
|
|
||||||
-- @name AceEvent:UnregisterEvent
|
|
||||||
-- @class function
|
|
||||||
-- @paramsig event
|
|
||||||
-- @param event The event to unregister
|
|
||||||
|
|
||||||
--- Register for a custom AceEvent-internal message.
|
|
||||||
-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied)
|
|
||||||
-- Any arguments to the event will be passed on after that.
|
|
||||||
-- @name AceEvent:RegisterMessage
|
|
||||||
-- @class function
|
|
||||||
-- @paramsig message[, callback [, arg]]
|
|
||||||
-- @param message The message to register for
|
|
||||||
-- @param callback The callback function to call when the message is triggered (funcref or method, defaults to a method with the event name)
|
|
||||||
-- @param arg An optional argument to pass to the callback function
|
|
||||||
|
|
||||||
--- Unregister a message
|
|
||||||
-- @name AceEvent:UnregisterMessage
|
|
||||||
-- @class function
|
|
||||||
-- @paramsig message
|
|
||||||
-- @param message The message to unregister
|
|
||||||
|
|
||||||
--- Send a message over the AceEvent-3.0 internal message system to other addons registered for this message.
|
|
||||||
-- @name AceEvent:SendMessage
|
|
||||||
-- @class function
|
|
||||||
-- @paramsig message, ...
|
|
||||||
-- @param message The message to send
|
|
||||||
-- @param ... Any arguments to the message
|
|
||||||
|
|
||||||
|
|
||||||
-- Embeds AceEvent into the target object making the functions from the mixins list available on target:..
|
|
||||||
-- @param target target object to embed AceEvent in
|
|
||||||
function AceEvent:Embed(target)
|
|
||||||
for k, v in pairs(mixins) do
|
|
||||||
target[v] = self[v]
|
|
||||||
end
|
|
||||||
self.embeds[target] = true
|
|
||||||
return target
|
|
||||||
end
|
|
||||||
|
|
||||||
-- AceEvent:OnEmbedDisable( target )
|
|
||||||
-- target (object) - target object that is being disabled
|
|
||||||
--
|
|
||||||
-- Unregister all events messages etc when the target disables.
|
|
||||||
-- this method should be called by the target manually or by an addon framework
|
|
||||||
function AceEvent:OnEmbedDisable(target)
|
|
||||||
target:UnregisterAllEvents()
|
|
||||||
target:UnregisterAllMessages()
|
|
||||||
end
|
|
||||||
|
|
||||||
-- Script to fire blizzard events into the event listeners
|
|
||||||
local events = AceEvent.events
|
|
||||||
AceEvent.frame:SetScript("OnEvent", function(this, event, ...)
|
|
||||||
events:Fire(event, ...)
|
|
||||||
end)
|
|
||||||
|
|
||||||
--- Finally: upgrade our old embeds
|
|
||||||
for target, v in pairs(AceEvent.embeds) do
|
|
||||||
AceEvent:Embed(target)
|
|
||||||
end
|
|
||||||
|
|
@ -1,4 +0,0 @@
|
||||||
<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="AceEvent-3.0.lua"/>
|
|
||||||
</Ui>
|
|
||||||
|
|
@ -1,514 +0,0 @@
|
||||||
--- **AceHook-3.0** offers safe Hooking/Unhooking of functions, methods and frame scripts.
|
|
||||||
-- Using AceHook-3.0 is recommended when you need to unhook your hooks again, so the hook chain isn't broken
|
|
||||||
-- when you manually restore the original function.
|
|
||||||
--
|
|
||||||
-- **AceHook-3.0** can be embeded into your addon, either explicitly by calling AceHook:Embed(MyAddon) or by
|
|
||||||
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
|
|
||||||
-- and can be accessed directly, without having to explicitly call AceHook itself.\\
|
|
||||||
-- It is recommended to embed AceHook, otherwise you'll have to specify a custom `self` on all calls you
|
|
||||||
-- make into AceHook.
|
|
||||||
-- @class file
|
|
||||||
-- @name AceHook-3.0
|
|
||||||
-- @release $Id: AceHook-3.0.lua 877 2009-11-02 15:56:50Z nevcairiel $
|
|
||||||
local ACEHOOK_MAJOR, ACEHOOK_MINOR = "AceHook-3.0", 5
|
|
||||||
local AceHook, oldminor = LibStub:NewLibrary(ACEHOOK_MAJOR, ACEHOOK_MINOR)
|
|
||||||
|
|
||||||
if not AceHook then return end -- No upgrade needed
|
|
||||||
|
|
||||||
AceHook.embeded = AceHook.embeded or {}
|
|
||||||
AceHook.registry = AceHook.registry or setmetatable({}, {__index = function(tbl, key) tbl[key] = {} return tbl[key] end })
|
|
||||||
AceHook.handlers = AceHook.handlers or {}
|
|
||||||
AceHook.actives = AceHook.actives or {}
|
|
||||||
AceHook.scripts = AceHook.scripts or {}
|
|
||||||
AceHook.onceSecure = AceHook.onceSecure or {}
|
|
||||||
AceHook.hooks = AceHook.hooks or {}
|
|
||||||
|
|
||||||
-- local upvalues
|
|
||||||
local registry = AceHook.registry
|
|
||||||
local handlers = AceHook.handlers
|
|
||||||
local actives = AceHook.actives
|
|
||||||
local scripts = AceHook.scripts
|
|
||||||
local onceSecure = AceHook.onceSecure
|
|
||||||
|
|
||||||
-- Lua APIs
|
|
||||||
local pairs, next, type = pairs, next, type
|
|
||||||
local format = string.format
|
|
||||||
local assert, error = assert, error
|
|
||||||
|
|
||||||
-- WoW APIs
|
|
||||||
local issecurevariable, hooksecurefunc = issecurevariable, hooksecurefunc
|
|
||||||
local _G = _G
|
|
||||||
|
|
||||||
-- functions for later definition
|
|
||||||
local donothing, createHook, hook
|
|
||||||
|
|
||||||
local protectedScripts = {
|
|
||||||
OnClick = true,
|
|
||||||
}
|
|
||||||
|
|
||||||
-- upgrading of embeded is done at the bottom of the file
|
|
||||||
|
|
||||||
local mixins = {
|
|
||||||
"Hook", "SecureHook",
|
|
||||||
"HookScript", "SecureHookScript",
|
|
||||||
"Unhook", "UnhookAll",
|
|
||||||
"IsHooked",
|
|
||||||
"RawHook", "RawHookScript"
|
|
||||||
}
|
|
||||||
|
|
||||||
-- AceHook:Embed( target )
|
|
||||||
-- target (object) - target object to embed AceHook in
|
|
||||||
--
|
|
||||||
-- Embeds AceEevent into the target object making the functions from the mixins list available on target:..
|
|
||||||
function AceHook:Embed( target )
|
|
||||||
for k, v in pairs( mixins ) do
|
|
||||||
target[v] = self[v]
|
|
||||||
end
|
|
||||||
self.embeded[target] = true
|
|
||||||
-- inject the hooks table safely
|
|
||||||
target.hooks = target.hooks or {}
|
|
||||||
return target
|
|
||||||
end
|
|
||||||
|
|
||||||
-- AceHook:OnEmbedDisable( target )
|
|
||||||
-- target (object) - target object that is being disabled
|
|
||||||
--
|
|
||||||
-- Unhooks all hooks when the target disables.
|
|
||||||
-- this method should be called by the target manually or by an addon framework
|
|
||||||
function AceHook:OnEmbedDisable( target )
|
|
||||||
target:UnhookAll()
|
|
||||||
end
|
|
||||||
|
|
||||||
function createHook(self, handler, orig, secure, failsafe)
|
|
||||||
local uid
|
|
||||||
local method = type(handler) == "string"
|
|
||||||
if failsafe and not secure then
|
|
||||||
-- failsafe hook creation
|
|
||||||
uid = function(...)
|
|
||||||
if actives[uid] then
|
|
||||||
if method then
|
|
||||||
self[handler](self, ...)
|
|
||||||
else
|
|
||||||
handler(...)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return orig(...)
|
|
||||||
end
|
|
||||||
-- /failsafe hook
|
|
||||||
else
|
|
||||||
-- all other hooks
|
|
||||||
uid = function(...)
|
|
||||||
if actives[uid] then
|
|
||||||
if method then
|
|
||||||
return self[handler](self, ...)
|
|
||||||
else
|
|
||||||
return handler(...)
|
|
||||||
end
|
|
||||||
elseif not secure then -- backup on non secure
|
|
||||||
return orig(...)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
-- /hook
|
|
||||||
end
|
|
||||||
return uid
|
|
||||||
end
|
|
||||||
|
|
||||||
function donothing() end
|
|
||||||
|
|
||||||
function hook(self, obj, method, handler, script, secure, raw, forceSecure, usage)
|
|
||||||
if not handler then handler = method end
|
|
||||||
|
|
||||||
-- These asserts make sure AceHooks's devs play by the rules.
|
|
||||||
assert(not script or type(script) == "boolean")
|
|
||||||
assert(not secure or type(secure) == "boolean")
|
|
||||||
assert(not raw or type(raw) == "boolean")
|
|
||||||
assert(not forceSecure or type(forceSecure) == "boolean")
|
|
||||||
assert(usage)
|
|
||||||
|
|
||||||
-- Error checking Battery!
|
|
||||||
if obj and type(obj) ~= "table" then
|
|
||||||
error(format("%s: 'object' - nil or table expected got %s", usage, type(obj)), 3)
|
|
||||||
end
|
|
||||||
if type(method) ~= "string" then
|
|
||||||
error(format("%s: 'method' - string expected got %s", usage, type(method)), 3)
|
|
||||||
end
|
|
||||||
if type(handler) ~= "string" and type(handler) ~= "function" then
|
|
||||||
error(format("%s: 'handler' - nil, string, or function expected got %s", usage, type(handler)), 3)
|
|
||||||
end
|
|
||||||
if type(handler) == "string" and type(self[handler]) ~= "function" then
|
|
||||||
error(format("%s: 'handler' - Handler specified does not exist at self[handler]", usage), 3)
|
|
||||||
end
|
|
||||||
if script then
|
|
||||||
if not secure and obj:IsProtected() and protectedScripts[method] then
|
|
||||||
error(format("Cannot hook secure script %q; Use SecureHookScript(obj, method, [handler]) instead.", method), 3)
|
|
||||||
end
|
|
||||||
if not obj or not obj.GetScript or not obj:HasScript(method) then
|
|
||||||
error(format("%s: You can only hook a script on a frame object", usage), 3)
|
|
||||||
end
|
|
||||||
else
|
|
||||||
local issecure
|
|
||||||
if obj then
|
|
||||||
issecure = onceSecure[obj] and onceSecure[obj][method] or issecurevariable(obj, method)
|
|
||||||
else
|
|
||||||
issecure = onceSecure[method] or issecurevariable(method)
|
|
||||||
end
|
|
||||||
if issecure then
|
|
||||||
if forceSecure then
|
|
||||||
if obj then
|
|
||||||
onceSecure[obj] = onceSecure[obj] or {}
|
|
||||||
onceSecure[obj][method] = true
|
|
||||||
else
|
|
||||||
onceSecure[method] = true
|
|
||||||
end
|
|
||||||
elseif not secure then
|
|
||||||
error(format("%s: Attempt to hook secure function %s. Use `SecureHook' or add `true' to the argument list to override.", usage, method), 3)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local uid
|
|
||||||
if obj then
|
|
||||||
uid = registry[self][obj] and registry[self][obj][method]
|
|
||||||
else
|
|
||||||
uid = registry[self][method]
|
|
||||||
end
|
|
||||||
|
|
||||||
if uid then
|
|
||||||
if actives[uid] then
|
|
||||||
-- Only two sane choices exist here. We either a) error 100% of the time or b) always unhook and then hook
|
|
||||||
-- choice b would likely lead to odd debuging conditions or other mysteries so we're going with a.
|
|
||||||
error(format("Attempting to rehook already active hook %s.", method))
|
|
||||||
end
|
|
||||||
|
|
||||||
if handlers[uid] == handler then -- turn on a decative hook, note enclosures break this ability, small memory leak
|
|
||||||
actives[uid] = true
|
|
||||||
return
|
|
||||||
elseif obj then -- is there any reason not to call unhook instead of doing the following several lines?
|
|
||||||
if self.hooks and self.hooks[obj] then
|
|
||||||
self.hooks[obj][method] = nil
|
|
||||||
end
|
|
||||||
registry[self][obj][method] = nil
|
|
||||||
else
|
|
||||||
if self.hooks then
|
|
||||||
self.hooks[method] = nil
|
|
||||||
end
|
|
||||||
registry[self][method] = nil
|
|
||||||
end
|
|
||||||
handlers[uid], actives[uid], scripts[uid] = nil, nil, nil
|
|
||||||
uid = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
local orig
|
|
||||||
if script then
|
|
||||||
orig = obj:GetScript(method) or donothing
|
|
||||||
elseif obj then
|
|
||||||
orig = obj[method]
|
|
||||||
else
|
|
||||||
orig = _G[method]
|
|
||||||
end
|
|
||||||
|
|
||||||
if not orig then
|
|
||||||
error(format("%s: Attempting to hook a non existing target", usage), 3)
|
|
||||||
end
|
|
||||||
|
|
||||||
uid = createHook(self, handler, orig, secure, not (raw or secure))
|
|
||||||
|
|
||||||
if obj then
|
|
||||||
self.hooks[obj] = self.hooks[obj] or {}
|
|
||||||
registry[self][obj] = registry[self][obj] or {}
|
|
||||||
registry[self][obj][method] = uid
|
|
||||||
|
|
||||||
if not secure then
|
|
||||||
self.hooks[obj][method] = orig
|
|
||||||
end
|
|
||||||
|
|
||||||
if script then
|
|
||||||
-- If the script is empty before, HookScript will not work, so use SetScript instead
|
|
||||||
-- This will make the hook insecure, but shouldnt matter, since it was empty before.
|
|
||||||
-- It does not taint the full frame.
|
|
||||||
if not secure or orig == donothing then
|
|
||||||
obj:SetScript(method, uid)
|
|
||||||
elseif secure then
|
|
||||||
obj:HookScript(method, uid)
|
|
||||||
end
|
|
||||||
else
|
|
||||||
if not secure then
|
|
||||||
obj[method] = uid
|
|
||||||
else
|
|
||||||
hooksecurefunc(obj, method, uid)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
else
|
|
||||||
registry[self][method] = uid
|
|
||||||
|
|
||||||
if not secure then
|
|
||||||
_G[method] = uid
|
|
||||||
self.hooks[method] = orig
|
|
||||||
else
|
|
||||||
hooksecurefunc(method, uid)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
actives[uid], handlers[uid], scripts[uid] = true, handler, script and true or nil
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Hook a function or a method on an object.
|
|
||||||
-- The hook created will be a "safe hook", that means that your handler will be called
|
|
||||||
-- before the hooked function ("Pre-Hook"), and you don't have to call the original function yourself,
|
|
||||||
-- however you cannot stop the execution of the function, or modify any of the arguments/return values.\\
|
|
||||||
-- This type of hook is typically used if you need to know if some function got called, and don't want to modify it.
|
|
||||||
-- @paramsig [object], method, [handler], [hookSecure]
|
|
||||||
-- @param object The object to hook a method from
|
|
||||||
-- @param method If object was specified, the name of the method, or the name of the function to hook.
|
|
||||||
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function)
|
|
||||||
-- @param hookSecure If true, AceHook will allow hooking of secure functions.
|
|
||||||
-- @usage
|
|
||||||
-- -- create an addon with AceHook embeded
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
|
|
||||||
--
|
|
||||||
-- function MyAddon:OnEnable()
|
|
||||||
-- -- Hook ActionButton_UpdateHotkeys, overwriting the secure status
|
|
||||||
-- self:Hook("ActionButton_UpdateHotkeys", true)
|
|
||||||
-- end
|
|
||||||
--
|
|
||||||
-- function MyAddon:ActionButton_UpdateHotkeys(button, type)
|
|
||||||
-- print(button:GetName() .. " is updating its HotKey")
|
|
||||||
-- end
|
|
||||||
function AceHook:Hook(object, method, handler, hookSecure)
|
|
||||||
if type(object) == "string" then
|
|
||||||
method, handler, hookSecure, object = object, method, handler, nil
|
|
||||||
end
|
|
||||||
|
|
||||||
if handler == true then
|
|
||||||
handler, hookSecure = nil, true
|
|
||||||
end
|
|
||||||
|
|
||||||
hook(self, object, method, handler, false, false, false, hookSecure or false, "Usage: Hook([object], method, [handler], [hookSecure])")
|
|
||||||
end
|
|
||||||
|
|
||||||
--- RawHook a function or a method on an object.
|
|
||||||
-- The hook created will be a "raw hook", that means that your handler will completly replace
|
|
||||||
-- the original function, and your handler has to call the original function (or not, depending on your intentions).\\
|
|
||||||
-- The original function will be stored in `self.hooks[object][method]` or `self.hooks[functionName]` respectively.\\
|
|
||||||
-- This type of hook can be used for all purposes, and is usually the most common case when you need to modify arguments
|
|
||||||
-- or want to control execution of the original function.
|
|
||||||
-- @paramsig [object], method, [handler], [hookSecure]
|
|
||||||
-- @param object The object to hook a method from
|
|
||||||
-- @param method If object was specified, the name of the method, or the name of the function to hook.
|
|
||||||
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function)
|
|
||||||
-- @param hookSecure If true, AceHook will allow hooking of secure functions.
|
|
||||||
-- @usage
|
|
||||||
-- -- create an addon with AceHook embeded
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
|
|
||||||
--
|
|
||||||
-- function MyAddon:OnEnable()
|
|
||||||
-- -- Hook ActionButton_UpdateHotkeys, overwriting the secure status
|
|
||||||
-- self:RawHook("ActionButton_UpdateHotkeys", true)
|
|
||||||
-- end
|
|
||||||
--
|
|
||||||
-- function MyAddon:ActionButton_UpdateHotkeys(button, type)
|
|
||||||
-- if button:GetName() == "MyButton" then
|
|
||||||
-- -- do stuff here
|
|
||||||
-- else
|
|
||||||
-- self.hooks.ActionButton_UpdateHotkeys(button, type)
|
|
||||||
-- end
|
|
||||||
-- end
|
|
||||||
function AceHook:RawHook(object, method, handler, hookSecure)
|
|
||||||
if type(object) == "string" then
|
|
||||||
method, handler, hookSecure, object = object, method, handler, nil
|
|
||||||
end
|
|
||||||
|
|
||||||
if handler == true then
|
|
||||||
handler, hookSecure = nil, true
|
|
||||||
end
|
|
||||||
|
|
||||||
hook(self, object, method, handler, false, false, true, hookSecure or false, "Usage: RawHook([object], method, [handler], [hookSecure])")
|
|
||||||
end
|
|
||||||
|
|
||||||
--- SecureHook a function or a method on an object.
|
|
||||||
-- This function is a wrapper around the `hooksecurefunc` function in the WoW API. Using AceHook
|
|
||||||
-- extends the functionality of secure hooks, and adds the ability to unhook once the hook isn't
|
|
||||||
-- required anymore, or the addon is being disabled.\\
|
|
||||||
-- Secure Hooks should be used if the secure-status of the function is vital to its function,
|
|
||||||
-- and taint would block execution. Secure Hooks are always called after the original function was called
|
|
||||||
-- ("Post Hook"), and you cannot modify the arguments, return values or control the execution.
|
|
||||||
-- @paramsig [object], method, [handler]
|
|
||||||
-- @param object The object to hook a method from
|
|
||||||
-- @param method If object was specified, the name of the method, or the name of the function to hook.
|
|
||||||
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function)
|
|
||||||
function AceHook:SecureHook(object, method, handler)
|
|
||||||
if type(object) == "string" then
|
|
||||||
method, handler, object = object, method, nil
|
|
||||||
end
|
|
||||||
|
|
||||||
hook(self, object, method, handler, false, true, false, false, "Usage: SecureHook([object], method, [handler])")
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Hook a script handler on a frame.
|
|
||||||
-- The hook created will be a "safe hook", that means that your handler will be called
|
|
||||||
-- before the hooked script ("Pre-Hook"), and you don't have to call the original function yourself,
|
|
||||||
-- however you cannot stop the execution of the function, or modify any of the arguments/return values.\\
|
|
||||||
-- This is the frame script equivalent of the :Hook safe-hook. It would typically be used to be notified
|
|
||||||
-- when a certain event happens to a frame.
|
|
||||||
-- @paramsig frame, script, [handler]
|
|
||||||
-- @param frame The Frame to hook the script on
|
|
||||||
-- @param script The script to hook
|
|
||||||
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script)
|
|
||||||
-- @usage
|
|
||||||
-- -- create an addon with AceHook embeded
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
|
|
||||||
--
|
|
||||||
-- function MyAddon:OnEnable()
|
|
||||||
-- -- Hook the OnShow of FriendsFrame
|
|
||||||
-- self:HookScript(FriendsFrame, "OnShow", "FriendsFrameOnShow")
|
|
||||||
-- end
|
|
||||||
--
|
|
||||||
-- function MyAddon:FriendsFrameOnShow(frame)
|
|
||||||
-- print("The FriendsFrame was shown!")
|
|
||||||
-- end
|
|
||||||
function AceHook:HookScript(frame, script, handler)
|
|
||||||
hook(self, frame, script, handler, true, false, false, false, "Usage: HookScript(object, method, [handler])")
|
|
||||||
end
|
|
||||||
|
|
||||||
--- RawHook a script handler on a frame.
|
|
||||||
-- The hook created will be a "raw hook", that means that your handler will completly replace
|
|
||||||
-- the original script, and your handler has to call the original script (or not, depending on your intentions).\\
|
|
||||||
-- The original script will be stored in `self.hooks[frame][script]`.\\
|
|
||||||
-- This type of hook can be used for all purposes, and is usually the most common case when you need to modify arguments
|
|
||||||
-- or want to control execution of the original script.
|
|
||||||
-- @paramsig frame, script, [handler]
|
|
||||||
-- @param frame The Frame to hook the script on
|
|
||||||
-- @param script The script to hook
|
|
||||||
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script)
|
|
||||||
-- @usage
|
|
||||||
-- -- create an addon with AceHook embeded
|
|
||||||
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
|
|
||||||
--
|
|
||||||
-- function MyAddon:OnEnable()
|
|
||||||
-- -- Hook the OnShow of FriendsFrame
|
|
||||||
-- self:RawHookScript(FriendsFrame, "OnShow", "FriendsFrameOnShow")
|
|
||||||
-- end
|
|
||||||
--
|
|
||||||
-- function MyAddon:FriendsFrameOnShow(frame)
|
|
||||||
-- -- Call the original function
|
|
||||||
-- self.hooks[frame].OnShow(frame)
|
|
||||||
-- -- Do our processing
|
|
||||||
-- -- .. stuff
|
|
||||||
-- end
|
|
||||||
function AceHook:RawHookScript(frame, script, handler)
|
|
||||||
hook(self, frame, script, handler, true, false, true, false, "Usage: RawHookScript(object, method, [handler])")
|
|
||||||
end
|
|
||||||
|
|
||||||
--- SecureHook a script handler on a frame.
|
|
||||||
-- This function is a wrapper around the `frame:HookScript` function in the WoW API. Using AceHook
|
|
||||||
-- extends the functionality of secure hooks, and adds the ability to unhook once the hook isn't
|
|
||||||
-- required anymore, or the addon is being disabled.\\
|
|
||||||
-- Secure Hooks should be used if the secure-status of the function is vital to its function,
|
|
||||||
-- and taint would block execution. Secure Hooks are always called after the original function was called
|
|
||||||
-- ("Post Hook"), and you cannot modify the arguments, return values or control the execution.
|
|
||||||
-- @paramsig frame, script, [handler]
|
|
||||||
-- @param frame The Frame to hook the script on
|
|
||||||
-- @param script The script to hook
|
|
||||||
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script)
|
|
||||||
function AceHook:SecureHookScript(frame, script, handler)
|
|
||||||
hook(self, frame, script, handler, true, true, false, false, "Usage: SecureHookScript(object, method, [handler])")
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Unhook from the specified function, method or script.
|
|
||||||
-- @paramsig [obj], method
|
|
||||||
-- @param obj The object or frame to unhook from
|
|
||||||
-- @param method The name of the method, function or script to unhook from.
|
|
||||||
function AceHook:Unhook(obj, method)
|
|
||||||
local usage = "Usage: Unhook([obj], method)"
|
|
||||||
if type(obj) == "string" then
|
|
||||||
method, obj = obj, nil
|
|
||||||
end
|
|
||||||
|
|
||||||
if obj and type(obj) ~= "table" then
|
|
||||||
error(format("%s: 'obj' - expecting nil or table got %s", usage, type(obj)), 2)
|
|
||||||
end
|
|
||||||
if type(method) ~= "string" then
|
|
||||||
error(format("%s: 'method' - expeting string got %s", usage, type(method)), 2)
|
|
||||||
end
|
|
||||||
|
|
||||||
local uid
|
|
||||||
if obj then
|
|
||||||
uid = registry[self][obj] and registry[self][obj][method]
|
|
||||||
else
|
|
||||||
uid = registry[self][method]
|
|
||||||
end
|
|
||||||
|
|
||||||
if not uid or not actives[uid] then
|
|
||||||
-- Declining to error on an unneeded unhook since the end effect is the same and this would just be annoying.
|
|
||||||
return false
|
|
||||||
end
|
|
||||||
|
|
||||||
actives[uid], handlers[uid] = nil, nil
|
|
||||||
|
|
||||||
if obj then
|
|
||||||
registry[self][obj][method] = nil
|
|
||||||
registry[self][obj] = next(registry[self][obj]) and registry[self][obj] or nil
|
|
||||||
|
|
||||||
-- if the hook reference doesnt exist, then its a secure hook, just bail out and dont do any unhooking
|
|
||||||
if not self.hooks[obj] or not self.hooks[obj][method] then return true end
|
|
||||||
|
|
||||||
if scripts[uid] and obj:GetScript(method) == uid then -- unhooks scripts
|
|
||||||
obj:SetScript(method, self.hooks[obj][method] ~= donothing and self.hooks[obj][method] or nil)
|
|
||||||
scripts[uid] = nil
|
|
||||||
elseif obj and self.hooks[obj] and self.hooks[obj][method] and obj[method] == uid then -- unhooks methods
|
|
||||||
obj[method] = self.hooks[obj][method]
|
|
||||||
end
|
|
||||||
|
|
||||||
self.hooks[obj][method] = nil
|
|
||||||
self.hooks[obj] = next(self.hooks[obj]) and self.hooks[obj] or nil
|
|
||||||
else
|
|
||||||
registry[self][method] = nil
|
|
||||||
|
|
||||||
-- if self.hooks[method] doesn't exist, then this is a SecureHook, just bail out
|
|
||||||
if not self.hooks[method] then return true end
|
|
||||||
|
|
||||||
if self.hooks[method] and _G[method] == uid then -- unhooks functions
|
|
||||||
_G[method] = self.hooks[method]
|
|
||||||
end
|
|
||||||
|
|
||||||
self.hooks[method] = nil
|
|
||||||
end
|
|
||||||
return true
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Unhook all existing hooks for this addon.
|
|
||||||
function AceHook:UnhookAll()
|
|
||||||
for key, value in pairs(registry[self]) do
|
|
||||||
if type(key) == "table" then
|
|
||||||
for method in pairs(value) do
|
|
||||||
self:Unhook(key, method)
|
|
||||||
end
|
|
||||||
else
|
|
||||||
self:Unhook(key)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Check if the specific function, method or script is already hooked.
|
|
||||||
-- @paramsig [obj], method
|
|
||||||
-- @param obj The object or frame to unhook from
|
|
||||||
-- @param method The name of the method, function or script to unhook from.
|
|
||||||
function AceHook:IsHooked(obj, method)
|
|
||||||
-- we don't check if registry[self] exists, this is done by evil magicks in the metatable
|
|
||||||
if type(obj) == "string" then
|
|
||||||
if registry[self][obj] and actives[registry[self][obj]] then
|
|
||||||
return true, handlers[registry[self][obj]]
|
|
||||||
end
|
|
||||||
else
|
|
||||||
if registry[self][obj] and registry[self][obj][method] and actives[registry[self][obj][method]] then
|
|
||||||
return true, handlers[registry[self][obj][method]]
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return false, nil
|
|
||||||
end
|
|
||||||
|
|
||||||
--- Upgrade our old embeded
|
|
||||||
for target, v in pairs( AceHook.embeded ) do
|
|
||||||
AceHook:Embed( target )
|
|
||||||
end
|
|
||||||
|
|
@ -1,4 +0,0 @@
|
||||||
<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="AceHook-3.0.lua"/>
|
|
||||||
</Ui>
|
|
||||||
|
|
@ -1,240 +0,0 @@
|
||||||
--[[ $Id: CallbackHandler-1.0.lua 14 2010-08-09 00:43:38Z 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.
|
|
||||||
|
|
||||||
|
|
@ -1,4 +0,0 @@
|
||||||
<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>
|
|
||||||
|
|
@ -1,51 +0,0 @@
|
||||||
-- $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
|
|
||||||
|
|
@ -1,13 +0,0 @@
|
||||||
## Interface: 20400
|
|
||||||
## Title: Lib: LibStub
|
|
||||||
## Notes: Universal Library Stub
|
|
||||||
## Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel
|
|
||||||
## X-Website: http://jira.wowace.com/browse/LS
|
|
||||||
## X-Category: Library
|
|
||||||
## X-License: Public Domain
|
|
||||||
## X-Curse-Packaged-Version: r92
|
|
||||||
## X-Curse-Project-Name: LibStub
|
|
||||||
## X-Curse-Project-ID: libstub
|
|
||||||
## X-Curse-Repository-ID: wow/libstub/mainline
|
|
||||||
|
|
||||||
LibStub.lua
|
|
||||||
|
|
@ -1,41 +0,0 @@
|
||||||
debugstack = debug.traceback
|
|
||||||
strmatch = string.match
|
|
||||||
|
|
||||||
loadfile("../LibStub.lua")()
|
|
||||||
|
|
||||||
local lib, oldMinor = LibStub:NewLibrary("Pants", 1) -- make a new thingy
|
|
||||||
assert(lib) -- should return the library table
|
|
||||||
assert(not oldMinor) -- should not return the old minor, since it didn't exist
|
|
||||||
|
|
||||||
-- the following is to create data and then be able to check if the same data exists after the fact
|
|
||||||
function lib:MyMethod()
|
|
||||||
end
|
|
||||||
local MyMethod = lib.MyMethod
|
|
||||||
lib.MyTable = {}
|
|
||||||
local MyTable = lib.MyTable
|
|
||||||
|
|
||||||
local newLib, newOldMinor = LibStub:NewLibrary("Pants", 1) -- try to register a library with the same version, should silently fail
|
|
||||||
assert(not newLib) -- should not return since out of date
|
|
||||||
|
|
||||||
local newLib, newOldMinor = LibStub:NewLibrary("Pants", 0) -- try to register a library with a previous, should silently fail
|
|
||||||
assert(not newLib) -- should not return since out of date
|
|
||||||
|
|
||||||
local newLib, newOldMinor = LibStub:NewLibrary("Pants", 2) -- register a new version
|
|
||||||
assert(newLib) -- library table
|
|
||||||
assert(rawequal(newLib, lib)) -- should be the same reference as the previous
|
|
||||||
assert(newOldMinor == 1) -- should return the minor version of the previous version
|
|
||||||
|
|
||||||
assert(rawequal(lib.MyMethod, MyMethod)) -- verify that values were saved
|
|
||||||
assert(rawequal(lib.MyTable, MyTable)) -- verify that values were saved
|
|
||||||
|
|
||||||
local newLib, newOldMinor = LibStub:NewLibrary("Pants", "Blah 3 Blah") -- register a new version with a string minor version (instead of a number)
|
|
||||||
assert(newLib) -- library table
|
|
||||||
assert(newOldMinor == 2) -- previous version was 2
|
|
||||||
|
|
||||||
local newLib, newOldMinor = LibStub:NewLibrary("Pants", "Blah 4 and please ignore 15 Blah") -- register a new version with a string minor version (instead of a number)
|
|
||||||
assert(newLib)
|
|
||||||
assert(newOldMinor == 3) -- previous version was 3 (even though it gave a string)
|
|
||||||
|
|
||||||
local newLib, newOldMinor = LibStub:NewLibrary("Pants", 5) -- register a new library, using a normal number instead of a string
|
|
||||||
assert(newLib)
|
|
||||||
assert(newOldMinor == 4) -- previous version was 4 (even though it gave a string)
|
|
||||||
|
|
@ -1,27 +0,0 @@
|
||||||
debugstack = debug.traceback
|
|
||||||
strmatch = string.match
|
|
||||||
|
|
||||||
loadfile("../LibStub.lua")()
|
|
||||||
|
|
||||||
for major, library in LibStub:IterateLibraries() do
|
|
||||||
-- check that MyLib doesn't exist yet, by iterating through all the libraries
|
|
||||||
assert(major ~= "MyLib")
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(not LibStub:GetLibrary("MyLib", true)) -- check that MyLib doesn't exist yet by direct checking
|
|
||||||
assert(not pcall(LibStub.GetLibrary, LibStub, "MyLib")) -- don't silently fail, thus it should raise an error.
|
|
||||||
local lib = LibStub:NewLibrary("MyLib", 1) -- create the lib
|
|
||||||
assert(lib) -- check it exists
|
|
||||||
assert(rawequal(LibStub:GetLibrary("MyLib"), lib)) -- verify that :GetLibrary("MyLib") properly equals the lib reference
|
|
||||||
|
|
||||||
assert(LibStub:NewLibrary("MyLib", 2)) -- create a new version
|
|
||||||
|
|
||||||
local count=0
|
|
||||||
for major, library in LibStub:IterateLibraries() do
|
|
||||||
-- check that MyLib exists somewhere in the libraries, by iterating through all the libraries
|
|
||||||
if major == "MyLib" then -- we found it!
|
|
||||||
count = count +1
|
|
||||||
assert(rawequal(library, lib)) -- verify that the references are equal
|
|
||||||
end
|
|
||||||
end
|
|
||||||
assert(count == 1) -- verify that we actually found it, and only once
|
|
||||||
|
|
@ -1,14 +0,0 @@
|
||||||
debugstack = debug.traceback
|
|
||||||
strmatch = string.match
|
|
||||||
|
|
||||||
loadfile("../LibStub.lua")()
|
|
||||||
|
|
||||||
local proxy = newproxy() -- non-string
|
|
||||||
|
|
||||||
assert(not pcall(LibStub.NewLibrary, LibStub, proxy, 1)) -- should error, proxy is not a string, it's userdata
|
|
||||||
local success, ret = pcall(LibStub.GetLibrary, proxy, true)
|
|
||||||
assert(not success or not ret) -- either error because proxy is not a string or because it's not actually registered.
|
|
||||||
|
|
||||||
assert(not pcall(LibStub.NewLibrary, LibStub, "Something", "No number in here")) -- should error, minor has no string in it.
|
|
||||||
|
|
||||||
assert(not LibStub:GetLibrary("Something", true)) -- shouldn't've created it from the above statement
|
|
||||||
|
|
@ -1,41 +0,0 @@
|
||||||
debugstack = debug.traceback
|
|
||||||
strmatch = string.match
|
|
||||||
|
|
||||||
loadfile("../LibStub.lua")()
|
|
||||||
|
|
||||||
|
|
||||||
-- Pretend like loaded libstub is old and doesn't have :IterateLibraries
|
|
||||||
assert(LibStub.minor)
|
|
||||||
LibStub.minor = LibStub.minor - 0.0001
|
|
||||||
LibStub.IterateLibraries = nil
|
|
||||||
|
|
||||||
loadfile("../LibStub.lua")()
|
|
||||||
|
|
||||||
assert(type(LibStub.IterateLibraries)=="function")
|
|
||||||
|
|
||||||
|
|
||||||
-- Now pretend that we're the same version -- :IterateLibraries should NOT be re-created
|
|
||||||
LibStub.IterateLibraries = 123
|
|
||||||
|
|
||||||
loadfile("../LibStub.lua")()
|
|
||||||
|
|
||||||
assert(LibStub.IterateLibraries == 123)
|
|
||||||
|
|
||||||
|
|
||||||
-- Now pretend that a newer version is loaded -- :IterateLibraries should NOT be re-created
|
|
||||||
LibStub.minor = LibStub.minor + 0.0001
|
|
||||||
|
|
||||||
loadfile("../LibStub.lua")()
|
|
||||||
|
|
||||||
assert(LibStub.IterateLibraries == 123)
|
|
||||||
|
|
||||||
|
|
||||||
-- Again with a huge number
|
|
||||||
LibStub.minor = LibStub.minor + 1234567890
|
|
||||||
|
|
||||||
loadfile("../LibStub.lua")()
|
|
||||||
|
|
||||||
assert(LibStub.IterateLibraries == 123)
|
|
||||||
|
|
||||||
|
|
||||||
print("OK")
|
|
||||||
Loading…
Reference in a new issue