--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lib/AceAddon-3.0/AceAddon-3.0.lua	Mon Mar 17 18:24:53 2008 +0000
@@ -0,0 +1,412 @@
+--[[ $Id: AceAddon-3.0.lua 63220 2008-02-29 11:29:58Z nevcairiel $ ]]
+local MAJOR, MINOR = "AceAddon-3.0", 3
+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
+
+local tinsert, tconcat = table.insert, table.concat
+local fmt = string.format
+local pairs, next, type = pairs, next, type
+
+--[[
+	 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 
+
+-- AceAddon:NewAddon( name, [lib, lib, lib, ...] )
+-- name (string) - unique addon object name
+-- [lib] (string) - optional libs to embed in the addon object
+--
+-- returns the addon object when succesful
+function AceAddon:NewAddon(name, ...)
+	if type(name) ~= "string" then error(("Usage: NewAddon(name, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) end
+	
+	if self.addons[name] then error(("Usage: NewAddon(name, [lib, lib, lib, ...]): 'name' - Addon '%s' already exists."):format(name), 2) end
+	
+	local addon = setmetatable( {name = name}, { __tostring = addontostring } )
+	self.addons[name] = addon
+	addon.modules = {}
+	addon.defaultModuleLibraries = {}
+	Embed( addon ) -- embed NewModule, GetModule methods
+	self:EmbedLibraries(addon, ...)
+	
+	-- add to queue of addons to be initialized upon ADDON_LOADED
+	tinsert(self.initializequeue, addon)
+	return addon
+end
+
+-- AceAddon:GetAddon( name, [silent])
+-- name (string) - unique addon object name
+-- silent (boolean) - if true, addon is optional, silently return nil if its not found
+--
+-- throws an error if the addon object can not be found (except silent is set)
+-- returns the addon object if found
+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
+
+-- AceAddon:EmbedLibraries( addon, [lib, lib, lib, ...] )
+-- addon (object) - addon to embed the libs in
+-- [lib] (string) - optional libs to embed
+function AceAddon:EmbedLibraries(addon, ...)
+	for i=1,select("#", ... ) do
+		local libname = select(i, ...)
+		self:EmbedLibrary(addon, libname, false, 4)
+	end
+end
+
+-- AceAddon:EmbedLibrary( addon, libname, silent, offset )
+-- addon (object) - addon to embed the libs in
+-- libname (string) - lib to embed
+-- [silent] (boolean) - optional, marks an embed to fail silently if the library doesn't exist.
+-- [offset] (number) - will push the error messages back to said offset defaults to 2
+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
+
+-- addon:GetModule( name, [silent])
+-- name (string) - unique module object name
+-- silent (boolean) - if true, module is optional, silently return nil if its not found
+--
+-- throws an error if the addon object can not be found (except silent is set)
+-- returns the module object if found
+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
+
+-- addon:NewModule( name, [prototype, [lib, lib, lib, ...] )
+-- name (string) - unique module object name for this addon
+-- prototype (object) - object to derive this module from, methods and values from this table will be mixed into the module, if a string is passed a lib is assumed
+-- [lib] (string) - optional libs to embed in the addon object
+--
+-- returns the addon object when succesful
+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
+	
+	return module
+end
+
+--addon:GetName()
+-- Returns the real name of the addon or module, without any prefix
+function GetName(self)
+	return self.moduleName or self.name
+end
+
+--addon:Enable()
+-- Enables the Addon if possible, return true or false depending on success
+function Enable(self)
+	self:SetEnabledState(true)
+	return AceAddon:EnableAddon(self)
+end
+
+--addon:Disable()
+-- Disables the Addon if possible, return true or false depending on success
+function Disable(self)
+	self:SetEnabledState(false)
+	return AceAddon:DisableAddon(self)
+end
+
+-- addon:EnableModule( name )
+-- name (string) - unique module object name
+--
+-- Enables the Module if possible, return true or false depending on success
+function EnableModule(self, name)
+	local module = self:GetModule( name )
+	return module:Enable()
+end
+
+-- addon:DisableModule( name )
+-- name (string) - unique module object name
+--
+-- Disables the Module if possible, return true or false depending on success
+function DisableModule(self, name)
+	local module = self:GetModule( name )
+	return module:Disable()
+end
+
+-- addon:SetDefaultModuleLibraries( [lib, lib, lib, ...]  )
+-- [lib] (string) - libs to embed in every module
+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
+
+-- addon:SetDefaultModuleState( state )
+-- state (boolean) - default state for new modules (enabled=true, disabled=false)
+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
+
+-- addon:SetDefaultModulePrototype( prototype )
+-- prototype (string or table) - the default prototype to use if none is specified on module creation
+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
+
+-- addon:SetEnabledState ( state )
+-- state ( boolean ) - set the state of an addon or module  (enabled=true, disabled=false)
+--
+-- should only be called before any Enabling actually happend, aka in OnInitialize
+function SetEnabledState(self, state)
+	self.enabledState = state
+end
+
+
+local function IterateModules(self) return pairs(self.modules) end
+local function IterateEmbeds(self) return pairs(AceAddon.embeds[self]) 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)
+	for k, v in pairs(mixins) do
+		target[k] = v
+	end
+	for k, v in pairs(pmixins) do
+		target[k] = target[k] or v
+	end
+end
+
+
+-- AceAddon:IntializeAddon( addon )
+-- addon (object) - addon to intialize
+--
+-- calls OnInitialize on the addon object if available
+-- calls OnEmbedInitialize on embedded libs in the addon object if available
+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
+
+-- AceAddon:EnableAddon( addon )
+-- addon (object) - addon to enable
+--
+-- calls OnEnable on the addon object if available
+-- calls OnEmbedEnable on embedded libs in the addon object if available
+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
+	-- TODO: handle 'first'? Or let addons do it on their own?
+	safecall(addon.OnEnable, addon)
+	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
+	self.statuses[addon.name] = addon.enabledState
+	
+	-- enable possible modules.
+	for name, module in pairs(addon.modules) do
+		self:EnableAddon(module)
+	end
+	
+	return true
+end
+
+-- AceAddon:DisableAddon( addon )
+-- addon (object|string) - addon to disable
+--
+-- calls OnDisable on the addon object if available
+-- calls OnEmbedDisable on embedded libs in the addon object if available
+function AceAddon:DisableAddon(addon)
+	if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
+	if not self.statuses[addon.name] then return false end
+	safecall( addon.OnDisable, addon )
+	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
+	self.statuses[addon.name] = addon.enabledState
+	
+	-- disable possible modules.
+	for name, module in pairs(addon.modules) do
+		self:DisableAddon(module)
+	end
+	
+	return true
+end
+
+--The next few funcs are just because no one should be reaching into the internal registries
+--Thoughts?
+function AceAddon:IterateAddons() return pairs(self.addons) end
+function AceAddon:IterateEmbedsOnAddon(addon) return pairs(self.embeds[addon]) end
+function AceAddon:IterateAddonStatus() return pairs(self.statuses) 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)
+end