--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Thu May 20 22:46:36 2010 -0700
@@ -0,0 +1,1 @@
+Libs/*

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.pkgmeta	Thu May 20 22:46:36 2010 -0700
@@ -0,0 +1,36 @@
+externals:
+    Libs/LibStub:
+        url: svn://svn.wowace.com/wow/libstub/mainline/trunk
+        tag: latest
+    Libs/CallbackHandler-1.0:
+        url: svn://svn.wowace.com/wow/callbackhandler/mainline/trunk/CallbackHandler-1.0
+        tag: latest
+    Libs/AceAddon-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceAddon-3.0
+        tag: latest
+    Libs/AceBucket-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceBucket-3.0
+        tag: latest
+    Libs/AceConfig-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceConfig-3.0
+        tag: latest
+    Libs/AceConsole-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceConsole-3.0
+        tag: latest
+    Libs/AceDB-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceDB-3.0
+        tag: latest
+    Libs/AceDBOptions-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceDBOptions-3.0
+        tag: latest
+    Libs/AceEvent-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceEvent-3.0
+        tag: latest
+    Libs/AceGUI-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceGUI-3.0
+        tag: latest
+    Libs/AceTimer-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceTimer-3.0
+        tag: latest
+
+

--- a/Libs/AceAddon-3.0/AceAddon-3.0.lua	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,642 +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 895 2009-12-06 16:28:55Z nevcairiel $
-
-local MAJOR, MINOR = "AceAddon-3.0", 5
-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.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
-	
-	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)
-	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
-
-
--- - 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.
-		for name, module in pairs(addon.modules) do
-			self:EnableAddon(module)
-		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.
-		for name, module in pairs(addon.modules) do
-			self:DisableAddon(module)
-		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)
-end

--- a/Libs/AceAddon-3.0/AceAddon-3.0.xml	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -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>
\ No newline at end of file

--- a/Libs/AceBucket-3.0/AceBucket-3.0.lua	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,293 +0,0 @@
---- A bucket to catch events in. **AceBucket-3.0** provides throttling of events that fire in bursts and
--- your addon only needs to know about the full burst.
--- 
--- This Bucket implementation works as follows:\\
---   Initially, no schedule is running, and its waiting for the first event to happen.\\
---   The first event will start the bucket, and get the scheduler running, which will collect all
---   events in the given interval. When that interval is reached, the bucket is pushed to the 
---   callback and a new schedule is started. When a bucket is empty after its interval, the scheduler is 
---   stopped, and the bucket is only listening for the next event to happen, basically back in its initial state.
--- 
--- In addition, the buckets collect information about the "arg1" argument of the events that fire, and pass those as a 
--- table to your callback. This functionality was mostly designed for the UNIT_* events.\\
--- The table will have the different values of "arg1" as keys, and the number of occurances as their value, e.g.\\
---   { ["player"] = 2, ["target"] = 1, ["party1"] = 1 }
---
--- **AceBucket-3.0** can be embeded into your addon, either explicitly by calling AceBucket: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 AceBucket itself.\\
--- It is recommended to embed AceBucket, otherwise you'll have to specify a custom `self` on all calls you
--- make into AceBucket.
--- @usage
--- MyAddon = LibStub("AceAddon-3.0"):NewAddon("BucketExample", "AceBucket-3.0")
--- 
--- function MyAddon:OnEnable()
---   -- Register a bucket that listens to all the HP related events, 
---   -- and fires once per second
---   self:RegisterBucketEvent({"UNIT_HEALTH", "UNIT_MAXHEALTH"}, 1, "UpdateHealth")
--- end
---
--- function MyAddon:UpdateHealth(units)
---   if units.player then
---     print("Your HP changed!")
---   end
--- end
--- @class file
--- @name AceBucket-3.0.lua
--- @release $Id: AceBucket-3.0.lua 895 2009-12-06 16:28:55Z nevcairiel $
-
-local MAJOR, MINOR = "AceBucket-3.0", 3
-local AceBucket, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
-
-if not AceBucket then return end -- No Upgrade needed
-
-AceBucket.buckets = AceBucket.buckets or {}
-AceBucket.embeds = AceBucket.embeds or {}
-
--- the libraries will be lazyly bound later, to avoid errors due to loading order issues
-local AceEvent, AceTimer
-
--- Lua APIs
-local tconcat = table.concat
-local type, next, pairs, select = type, next, pairs, select
-local tonumber, tostring, rawset = tonumber, tostring, rawset
-local assert, loadstring, error = assert, loadstring, error
-
--- 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, geterrorhandler
-
-local bucketCache = setmetatable({}, {__mode='k'})
-
---[[
-	 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, ...)
-	return Dispatchers[select('#', ...)](func, ...)
-end
-
--- FireBucket ( bucket )
---
--- send the bucket to the callback function and schedule the next FireBucket in interval seconds
-local function FireBucket(bucket)
-	local received = bucket.received
-	
-	-- we dont want to fire empty buckets
-	if next(received) then
-		local callback = bucket.callback
-		if type(callback) == "string" then
-			safecall(bucket.object[callback], bucket.object, received)
-		else
-			safecall(callback, received)
-		end
-		
-		for k in pairs(received) do
-			received[k] = nil
-		end
-		
-		-- if the bucket was not empty, schedule another FireBucket in interval seconds
-		bucket.timer = AceTimer.ScheduleTimer(bucket, FireBucket, bucket.interval, bucket)
-	else -- if it was empty, clear the timer and wait for the next event
-		bucket.timer = nil
-	end
-end
-
--- BucketHandler ( event, arg1 )
--- 
--- callback func for AceEvent
--- stores arg1 in the received table, and schedules the bucket if necessary
-local function BucketHandler(self, event, arg1)
-	if arg1 == nil then
-		arg1 = "nil"
-	end
-	
-	self.received[arg1] = (self.received[arg1] or 0) + 1
-	
-	-- if we are not scheduled yet, start a timer on the interval for our bucket to be cleared
-	if not self.timer then
-		self.timer = AceTimer.ScheduleTimer(self, FireBucket, self.interval, self)
-	end
-end
-
--- RegisterBucket( event, interval, callback, isMessage )
---
--- event(string or table) - the event, or a table with the events, that this bucket listens to
--- interval(int) - time between bucket fireings
--- callback(func or string) - function pointer, or method name of the object, that gets called when the bucket is cleared
--- isMessage(boolean) - register AceEvent Messages instead of game events
-local function RegisterBucket(self, event, interval, callback, isMessage)
-	-- try to fetch the librarys
-	if not AceEvent or not AceTimer then 
-		AceEvent = LibStub:GetLibrary("AceEvent-3.0", true)
-		AceTimer = LibStub:GetLibrary("AceTimer-3.0", true)
-		if not AceEvent or not AceTimer then
-			error(MAJOR .. " requires AceEvent-3.0 and AceTimer-3.0", 3)
-		end
-	end
-	
-	if type(event) ~= "string" and type(event) ~= "table" then error("Usage: RegisterBucket(event, interval, callback): 'event' - string or table expected.", 3) end
-	if not callback then
-		if type(event) == "string" then
-			callback = event
-		else
-			error("Usage: RegisterBucket(event, interval, callback): cannot omit callback when event is not a string.", 3)
-		end
-	end
-	if not tonumber(interval) then error("Usage: RegisterBucket(event, interval, callback): 'interval' - number expected.", 3) end
-	if type(callback) ~= "string" and type(callback) ~= "function" then error("Usage: RegisterBucket(event, interval, callback): 'callback' - string or function or nil expected.", 3) end
-	if type(callback) == "string" and type(self[callback]) ~= "function" then error("Usage: RegisterBucket(event, interval, callback): 'callback' - method not found on target object.", 3) end
-	
-	local bucket = next(bucketCache)
-	if bucket then
-		bucketCache[bucket] = nil
-	else
-		bucket = { handler = BucketHandler, received = {} }
-	end
-	bucket.object, bucket.callback, bucket.interval = self, callback, tonumber(interval)
-	
-	local regFunc = isMessage and AceEvent.RegisterMessage or AceEvent.RegisterEvent
-	
-	if type(event) == "table" then
-		for _,e in pairs(event) do
-			regFunc(bucket, e, "handler")
-		end
-	else
-		regFunc(bucket, event, "handler")
-	end
-	
-	local handle = tostring(bucket)
-	AceBucket.buckets[handle] = bucket
-	
-	return handle
-end
-
---- Register a Bucket for an event (or a set of events)
--- @param event The event to listen for, or a table of events.
--- @param interval The Bucket interval (burst interval)
--- @param callback The callback function, either as a function reference, or a string pointing to a method of the addon object.
--- @return The handle of the bucket (for unregistering)
--- @usage
--- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceBucket-3.0")
--- MyAddon:RegisterBucketEvent("BAG_UPDATE", 0.2, "UpdateBags")
--- 
--- function MyAddon:UpdateBags()
---   -- do stuff
--- end
-function AceBucket:RegisterBucketEvent(event, interval, callback)
-	return RegisterBucket(self, event, interval, callback, false)
-end
-
---- Register a Bucket for an AceEvent-3.0 addon message (or a set of messages)
--- @param message The message to listen for, or a table of messages.
--- @param interval The Bucket interval (burst interval)
--- @param callback The callback function, either as a function reference, or a string pointing to a method of the addon object.
--- @return The handle of the bucket (for unregistering)
--- @usage
--- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceBucket-3.0")
--- MyAddon:RegisterBucketEvent("SomeAddon_InformationMessage", 0.2, "ProcessData")
--- 
--- function MyAddon:ProcessData()
---   -- do stuff
--- end
-function AceBucket:RegisterBucketMessage(message, interval, callback)
-	return RegisterBucket(self, message, interval, callback, true)
-end
-
---- Unregister any events and messages from the bucket and clear any remaining data.
--- @param handle The handle of the bucket as returned by RegisterBucket*
-function AceBucket:UnregisterBucket(handle)
-	local bucket = AceBucket.buckets[handle]
-	if bucket then
-		AceEvent.UnregisterAllEvents(bucket)
-		AceEvent.UnregisterAllMessages(bucket)
-		
-		-- clear any remaining data in the bucket
-		for k in pairs(bucket.received) do
-			bucket.received[k] = nil
-		end
-		
-		if bucket.timer then
-			AceTimer.CancelTimer(bucket, bucket.timer)
-			bucket.timer = nil
-		end
-		
-		AceBucket.buckets[handle] = nil
-		-- store our bucket in the cache
-		bucketCache[bucket] = true
-	end
-end
-
---- Unregister all buckets of the current addon object (or custom "self").
-function AceBucket:UnregisterAllBuckets()
-	-- hmm can we do this more efficient? (it is not done often so shouldn't matter much)
-	for handle, bucket in pairs(AceBucket.buckets) do
-		if bucket.object == self then
-			AceBucket.UnregisterBucket(self, handle)
-		end
-	end
-end
-
-
-
--- embedding and embed handling
-local mixins = {
-	"RegisterBucketEvent",
-	"RegisterBucketMessage", 
-	"UnregisterBucket",
-	"UnregisterAllBuckets",
-} 
-
--- Embeds AceBucket into the target object making the functions from the mixins list available on target:..
--- @param target target object to embed AceBucket in
-function AceBucket:Embed( target )
-	for _, v in pairs( mixins ) do
-		target[v] = self[v]
-	end
-	self.embeds[target] = true
-	return target
-end
-
-function AceBucket:OnEmbedDisable( target )
-	target:UnregisterAllBuckets()
-end
-
-for addon in pairs(AceBucket.embeds) do
-	AceBucket:Embed(addon)
-end

--- a/Libs/AceBucket-3.0/AceBucket-3.0.xml	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -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="AceBucket-3.0.lua"/>
-</Ui>
\ No newline at end of file

--- a/Libs/AceConfig-3.0/AceConfig-3.0.lua	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,57 +0,0 @@
---- AceConfig-3.0 wrapper library.
--- Provides an API to register an options table with the config registry,
--- as well as associate it with a slash command.
--- @class file
--- @name AceConfig-3.0
--- @release $Id: AceConfig-3.0.lua 877 2009-11-02 15:56:50Z nevcairiel $
-
---[[
-AceConfig-3.0
-
-Very light wrapper library that combines all the AceConfig subcomponents into one more easily used whole.
-
-]]
-
-local MAJOR, MINOR = "AceConfig-3.0", 2
-local AceConfig = LibStub:NewLibrary(MAJOR, MINOR)
-
-if not AceConfig then return end
-
-local cfgreg = LibStub("AceConfigRegistry-3.0")
-local cfgcmd = LibStub("AceConfigCmd-3.0")
-local cfgdlg = LibStub("AceConfigDialog-3.0")
---TODO: local cfgdrp = LibStub("AceConfigDropdown-3.0")
-
--- Lua APIs
-local pcall, error, type, pairs = pcall, error, type, pairs
-
--- -------------------------------------------------------------------
--- :RegisterOptionsTable(appName, options, slashcmd, persist)
---
--- - appName - (string) application name
--- - options - table or function ref, see AceConfigRegistry
--- - slashcmd - slash command (string) or table with commands, or nil to NOT create a slash command
-
---- Register a option table with the AceConfig registry.
--- You can supply a slash command (or a table of slash commands) to register with AceConfigCmd directly.
--- @paramsig appName, options [, slashcmd]
--- @param appName The application name for the config table.
--- @param options The option table (or a function to generate one on demand)
--- @param slashcmd A slash command to register for the option table, or a table of slash commands.
--- @usage
--- local AceConfig = LibStub("AceConfig-3.0")
--- AceConfig:RegisterOptionsTable("MyAddon", myOptions, {"/myslash", "/my"})
-function AceConfig:RegisterOptionsTable(appName, options, slashcmd)
-	local ok,msg = pcall(cfgreg.RegisterOptionsTable, self, appName, options)
-	if not ok then error(msg, 2) end
-	
-	if slashcmd then
-		if type(slashcmd) == "table" then
-			for _,cmd in pairs(slashcmd) do
-				cfgcmd:CreateChatCommand(cmd, appName)
-			end
-		else
-			cfgcmd:CreateChatCommand(slashcmd, appName)
-		end
-	end
-end

--- a/Libs/AceConfig-3.0/AceConfig-3.0.xml	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,8 +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">
-	<Include file="AceConfigRegistry-3.0\AceConfigRegistry-3.0.xml"/>
-	<Include file="AceConfigCmd-3.0\AceConfigCmd-3.0.xml"/>
-	<Include file="AceConfigDialog-3.0\AceConfigDialog-3.0.xml"/>
-	<!--<Include file="AceConfigDropdown-3.0\AceConfigDropdown-3.0.xml"/>-->
-	<Script file="AceConfig-3.0.lua"/>
-</Ui>
\ No newline at end of file

--- a/Libs/AceConfig-3.0/AceConfigCmd-3.0/AceConfigCmd-3.0.lua	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,787 +0,0 @@
---- AceConfigCmd-3.0 handles access to an options table through the "command line" interface via the ChatFrames.
--- @class file
--- @name AceConfigCmd-3.0
--- @release $Id: AceConfigCmd-3.0.lua 904 2009-12-13 11:56:37Z nevcairiel $
-
---[[
-AceConfigCmd-3.0
-
-Handles commandline optionstable access
-
-REQUIRES: AceConsole-3.0 for command registration (loaded on demand)
-
-]]
-
--- TODO: plugin args
-
-
-local MAJOR, MINOR = "AceConfigCmd-3.0", 12
-local AceConfigCmd = LibStub:NewLibrary(MAJOR, MINOR)
-
-if not AceConfigCmd then return end
-
-AceConfigCmd.commands = AceConfigCmd.commands or {}
-local commands = AceConfigCmd.commands
-
-local cfgreg = LibStub("AceConfigRegistry-3.0")
-local AceConsole -- LoD
-local AceConsoleName = "AceConsole-3.0"
-
--- Lua APIs
-local strsub, strsplit, strlower, strmatch, strtrim = string.sub, string.split, string.lower, string.match, string.trim
-local format, tonumber, tostring = string.format, tonumber, tostring
-local tsort, tinsert = table.sort, table.insert
-local select, pairs, next, type = select, pairs, next, type
-local error, assert = error, assert
-
--- WoW APIs
-local _G = _G
-
--- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
--- List them here for Mikk's FindGlobals script
--- GLOBALS: LibStub, SELECTED_CHAT_FRAME, DEFAULT_CHAT_FRAME
-
-
-local L = setmetatable({}, {	-- TODO: replace with proper locale
-	__index = function(self,k) return k end
-})
-
-
-
-local function print(msg)
-	(SELECTED_CHAT_FRAME or DEFAULT_CHAT_FRAME):AddMessage(msg)
-end
-
--- constants used by getparam() calls below
-
-local handlertypes = {["table"]=true}
-local handlermsg = "expected a table"
-
-local functypes = {["function"]=true, ["string"]=true}
-local funcmsg = "expected function or member name"
-
-
--- pickfirstset() - picks the first non-nil value and returns it
-
-local function pickfirstset(...)	
-	for i=1,select("#",...) do
-		if select(i,...)~=nil then
-			return select(i,...)
-		end
-	end
-end
-
-
--- err() - produce real error() regarding malformed options tables etc
-
-local function err(info,inputpos,msg )
-	local cmdstr=" "..strsub(info.input, 1, inputpos-1)
-	error(MAJOR..": /" ..info[0] ..cmdstr ..": "..(msg or "malformed options table"), 2)
-end
-
-
--- usererr() - produce chatframe message regarding bad slash syntax etc
-
-local function usererr(info,inputpos,msg )
-	local cmdstr=strsub(info.input, 1, inputpos-1);
-	print("/" ..info[0] .. " "..cmdstr ..": "..(msg or "malformed options table"))
-end
-
-
--- callmethod() - call a given named method (e.g. "get", "set") with given arguments
-
-local function callmethod(info, inputpos, tab, methodtype, ...)
-	local method = info[methodtype]
-	if not method then
-		err(info, inputpos, "'"..methodtype.."': not set")
-	end
-
-	info.arg = tab.arg
-	info.option = tab
-	info.type = tab.type
-
-	if type(method)=="function" then
-		return method(info, ...)
-	elseif type(method)=="string" then
-		if type(info.handler[method])~="function" then
-			err(info, inputpos, "'"..methodtype.."': '"..method.."' is not a member function of "..tostring(info.handler))
-		end
-		return info.handler[method](info.handler, info, ...)
-	else
-		assert(false)	-- type should have already been checked on read
-	end
-end
-
--- callfunction() - call a given named function (e.g. "name", "desc") with given arguments
-
-local function callfunction(info, tab, methodtype, ...)
-	local method = tab[methodtype]
-
-	info.arg = tab.arg
-	info.option = tab
-	info.type = tab.type
-	
-	if type(method)=="function" then
-		return method(info, ...)
-	else
-		assert(false) -- type should have already been checked on read
-	end
-end
-
--- do_final() - do the final step (set/execute) along with validation and confirmation
-
-local function do_final(info, inputpos, tab, methodtype, ...)
-	if info.validate then 
-		local res = callmethod(info,inputpos,tab,"validate",...)
-		if type(res)=="string" then
-			usererr(info, inputpos, "'"..strsub(info.input, inputpos).."' - "..res)
-			return
-		end
-	end
-	-- console ignores .confirm
-	
-	callmethod(info,inputpos,tab,methodtype, ...)
-end
-
-
--- getparam() - used by handle() to retreive and store "handler", "get", "set", etc
-
-local function getparam(info, inputpos, tab, depth, paramname, types, errormsg)
-	local old,oldat = info[paramname], info[paramname.."_at"]
-	local val=tab[paramname]
-	if val~=nil then
-		if val==false then
-			val=nil
-		elseif not types[type(val)] then 
-			err(info, inputpos, "'" .. paramname.. "' - "..errormsg) 
-		end
-		info[paramname] = val
-		info[paramname.."_at"] = depth
-	end
-	return old,oldat
-end
-
-
--- iterateargs(tab) - custom iterator that iterates both t.args and t.plugins.*
-local dummytable={}
-
-local function iterateargs(tab)
-	if not tab.plugins then 
-		return pairs(tab.args) 
-	end
-	
-	local argtabkey,argtab=next(tab.plugins)
-	local v
-	
-	return function(_, k)
-		while argtab do
-			k,v = next(argtab, k)
-			if k then return k,v end
-			if argtab==tab.args then
-				argtab=nil
-			else
-				argtabkey,argtab = next(tab.plugins, argtabkey)
-				if not argtabkey then
-					argtab=tab.args
-				end
-			end
-		end
-	end
-end
-
-local function checkhidden(info, inputpos, tab)
-	if tab.cmdHidden~=nil then
-		return tab.cmdHidden
-	end
-	local hidden = tab.hidden
-	if type(hidden) == "function" or type(hidden) == "string" then
-		info.hidden = hidden
-		hidden = callmethod(info, inputpos, tab, 'hidden')
-		info.hidden = nil
-	end
-	return hidden
-end
-
-local function showhelp(info, inputpos, tab, depth, noHead)
-	if not noHead then
-		print("|cff33ff99"..info.appName.."|r: Arguments to |cffffff78/"..info[0].."|r "..strsub(info.input,1,inputpos-1)..":")
-	end
-	
-	local sortTbl = {}	-- [1..n]=name
-	local refTbl = {}   -- [name]=tableref
-	
-	for k,v in iterateargs(tab) do
-		if not refTbl[k] then	-- a plugin overriding something in .args
-			tinsert(sortTbl, k)
-			refTbl[k] = v
-		end
-	end
-	
-	tsort(sortTbl, function(one, two) 
-		local o1 = refTbl[one].order or 100
-		local o2 = refTbl[two].order or 100
-		if type(o1) == "function" or type(o1) == "string" then
-			info.order = o1
-			info[#info+1] = one
-			o1 = callmethod(info, inputpos, refTbl[one], "order")
-			info[#info] = nil
-			info.order = nil
-		end
-		if type(o2) == "function" or type(o1) == "string" then
-			info.order = o2
-			info[#info+1] = two
-			o2 = callmethod(info, inputpos, refTbl[two], "order")
-			info[#info] = nil
-			info.order = nil
-		end
-		if o1<0 and o2<0 then return o1<o2 end
-		if o2<0 then return true end
-		if o1<0 then return false end
-		if o1==o2 then return tostring(one)<tostring(two) end   -- compare names
-		return o1<o2
-	end)
-	
-	for i = 1, #sortTbl do
-		local k = sortTbl[i]
-		local v = refTbl[k]
-		if not checkhidden(info, inputpos, v) then
-			if v.type ~= "description" and v.type ~= "header" then
-				-- recursively show all inline groups
-				local name, desc = v.name, v.desc
-				if type(name) == "function" then
-					name = callfunction(info, v, 'name')
-				end
-				if type(desc) == "function" then
-					desc = callfunction(info, v, 'desc')
-				end
-				if v.type == "group" and pickfirstset(v.cmdInline, v.inline, false) then
-					print("  "..(desc or name)..":")
-					local oldhandler,oldhandler_at = getparam(info, inputpos, v, depth, "handler", handlertypes, handlermsg)
-					showhelp(info, inputpos, v, depth, true)
-					info.handler,info.handler_at = oldhandler,oldhandler_at
-				else
-					local key = k:gsub(" ", "_")
-					print("  |cffffff78"..key.."|r - "..(desc or name or ""))
-				end
-			end
-		end
-	end
-end
-
-
-local function keybindingValidateFunc(text)
-	if text == nil or text == "NONE" then
-		return nil
-	end
-	text = text:upper()
-	local shift, ctrl, alt
-	local modifier
-	while true do
-		if text == "-" then
-			break
-		end
-		modifier, text = strsplit('-', text, 2)
-		if text then
-			if modifier ~= "SHIFT" and modifier ~= "CTRL" and modifier ~= "ALT" then
-				return false
-			end
-			if modifier == "SHIFT" then
-				if shift then
-					return false
-				end
-				shift = true
-			end
-			if modifier == "CTRL" then
-				if ctrl then
-					return false
-				end
-				ctrl = true
-			end
-			if modifier == "ALT" then
-				if alt then
-					return false
-				end
-				alt = true
-			end
-		else
-			text = modifier
-			break
-		end
-	end
-	if text == "" then
-		return false
-	end
-	if not text:find("^F%d+$") and text ~= "CAPSLOCK" and text:len() ~= 1 and (text:byte() < 128 or text:len() > 4) and not _G["KEY_" .. text] then
-		return false
-	end
-	local s = text
-	if shift then
-		s = "SHIFT-" .. s
-	end
-	if ctrl then
-		s = "CTRL-" .. s
-	end
-	if alt then
-		s = "ALT-" .. s
-	end
-	return s
-end
-
--- handle() - selfrecursing function that processes input->optiontable 
--- - depth - starts at 0
--- - retfalse - return false rather than produce error if a match is not found (used by inlined groups)
-
-local function handle(info, inputpos, tab, depth, retfalse)
-
-	if not(type(tab)=="table" and type(tab.type)=="string") then err(info,inputpos) end
-
-	-------------------------------------------------------------------
-	-- Grab hold of handler,set,get,func,etc if set (and remember old ones)
-	-- Note that we do NOT validate if method names are correct at this stage,
-	-- the handler may change before they're actually used!
-
-	local oldhandler,oldhandler_at = getparam(info,inputpos,tab,depth,"handler",handlertypes,handlermsg)
-	local oldset,oldset_at = getparam(info,inputpos,tab,depth,"set",functypes,funcmsg)
-	local oldget,oldget_at = getparam(info,inputpos,tab,depth,"get",functypes,funcmsg)
-	local oldfunc,oldfunc_at = getparam(info,inputpos,tab,depth,"func",functypes,funcmsg)
-	local oldvalidate,oldvalidate_at = getparam(info,inputpos,tab,depth,"validate",functypes,funcmsg)
-	--local oldconfirm,oldconfirm_at = getparam(info,inputpos,tab,depth,"confirm",functypes,funcmsg)
-	
-	-------------------------------------------------------------------
-	-- Act according to .type of this table
-		
-	if tab.type=="group" then
-		------------ group --------------------------------------------
-		
-		if type(tab.args)~="table" then err(info, inputpos) end
-		if tab.plugins and type(tab.plugins)~="table" then err(info,inputpos) end
-		
-		-- grab next arg from input
-		local _,nextpos,arg = (info.input):find(" *([^ ]+) *", inputpos)
-		if not arg then
-			showhelp(info, inputpos, tab, depth)
-			return
-		end
-		nextpos=nextpos+1
-		
-		-- loop .args and try to find a key with a matching name
-		for k,v in iterateargs(tab) do
-			if not(type(k)=="string" and type(v)=="table" and type(v.type)=="string") then err(info,inputpos, "options table child '"..tostring(k).."' is malformed") end
-			
-			-- is this child an inline group? if so, traverse into it
-			if v.type=="group" and pickfirstset(v.cmdInline, v.inline, false) then
-				info[depth+1] = k
-				if handle(info, inputpos, v, depth+1, true)==false then
-					info[depth+1] = nil
-					-- wasn't found in there, but that's ok, we just keep looking down here
-				else
-					return	-- done, name was found in inline group
-				end
-			-- matching name and not a inline group
-			elseif strlower(arg)==strlower(k:gsub(" ", "_")) then
-				info[depth+1] = k
-				return handle(info,nextpos,v,depth+1)
-			end
-		end
-			
-		-- no match 
-		if retfalse then
-			-- restore old infotable members and return false to indicate failure
-			info.handler,info.handler_at = oldhandler,oldhandler_at
-			info.set,info.set_at = oldset,oldset_at
-			info.get,info.get_at = oldget,oldget_at
-			info.func,info.func_at = oldfunc,oldfunc_at
-			info.validate,info.validate_at = oldvalidate,oldvalidate_at
-			--info.confirm,info.confirm_at = oldconfirm,oldconfirm_at
-			return false
-		end
-		
-		-- couldn't find the command, display error
-		usererr(info, inputpos, "'"..arg.."' - " .. L["unknown argument"])
-		return
-	end
-	
-	local str = strsub(info.input,inputpos);
-	
-	if tab.type=="execute" then
-		------------ execute --------------------------------------------
-		do_final(info, inputpos, tab, "func")
-		
-
-	
-	elseif tab.type=="input" then
-		------------ input --------------------------------------------
-		
-		local res = true
-		if tab.pattern then
-			if not(type(tab.pattern)=="string") then err(info, inputpos, "'pattern' - expected a string") end
-			if not strmatch(str, tab.pattern) then
-				usererr(info, inputpos, "'"..str.."' - " .. L["invalid input"])
-				return
-			end
-		end
-		
-		do_final(info, inputpos, tab, "set", str)
-		
-
-	
-	elseif tab.type=="toggle" then
-		------------ toggle --------------------------------------------
-		local b
-		local str = strtrim(strlower(str))
-		if str=="" then
-			b = callmethod(info, inputpos, tab, "get")
-
-			if tab.tristate then
-				--cycle in true, nil, false order
-				if b then
-					b = nil
-				elseif b == nil then
-					b = false
-				else
-					b = true
-				end
-			else
-				b = not b
-			end
-			
-		elseif str==L["on"] then
-			b = true
-		elseif str==L["off"] then
-			b = false
-		elseif tab.tristate and str==L["default"] then
-			b = nil
-		else
-			if tab.tristate then
-				usererr(info, inputpos, format(L["'%s' - expected 'on', 'off' or 'default', or no argument to toggle."], str))
-			else
-				usererr(info, inputpos, format(L["'%s' - expected 'on' or 'off', or no argument to toggle."], str))
-			end
-			return
-		end
-		
-		do_final(info, inputpos, tab, "set", b)
-		
-
-	elseif tab.type=="range" then
-		------------ range --------------------------------------------
-		local val = tonumber(str)
-		if not val then
-			usererr(info, inputpos, "'"..str.."' - "..L["expected number"])
-			return
-		end
-		if type(info.step)=="number" then
-			val = val- (val % info.step)
-		end
-		if type(info.min)=="number" and val<info.min then
-			usererr(info, inputpos, val.." - "..format(L["must be equal to or higher than %s"], tostring(info.min)) )
-			return
-		end
-		if type(info.max)=="number" and val>info.max then
-			usererr(info, inputpos, val.." - "..format(L["must be equal to or lower than %s"], tostring(info.max)) )
-			return
-		end
-		
-		do_final(info, inputpos, tab, "set", val)
-
-	
-	elseif tab.type=="select" then
-		------------ select ------------------------------------
-		local str = strtrim(strlower(str))
-		
-		local values = tab.values
-		if type(values) == "function" or type(values) == "string" then
-			info.values = values
-			values = callmethod(info, inputpos, tab, "values")
-			info.values = nil
-		end
-		
-		if str == "" then
-			local b = callmethod(info, inputpos, tab, "get")
-			local fmt = "|cffffff78- [%s]|r %s"
-			local fmt_sel = "|cffffff78- [%s]|r %s |cffff0000*|r"
-			print(L["Options for |cffffff78"..info[#info].."|r:"])
-			for k, v in pairs(values) do
-				if b == k then
-					print(fmt_sel:format(k, v))
-				else
-					print(fmt:format(k, v))
-				end
-			end
-			return
-		end
-
-		local ok
-		for k,v in pairs(values) do 
-			if strlower(k)==str then
-				str = k	-- overwrite with key (in case of case mismatches)
-				ok = true
-				break
-			end
-		end
-		if not ok then
-			usererr(info, inputpos, "'"..str.."' - "..L["unknown selection"])
-			return
-		end
-		
-		do_final(info, inputpos, tab, "set", str)
-		
-	elseif tab.type=="multiselect" then
-		------------ multiselect -------------------------------------------
-		local str = strtrim(strlower(str))
-		
-		local values = tab.values
-		if type(values) == "function" or type(values) == "string" then
-			info.values = values
-			values = callmethod(info, inputpos, tab, "values")
-			info.values = nil
-		end
-		
-		if str == "" then
-			local fmt = "|cffffff78- [%s]|r %s"
-			local fmt_sel = "|cffffff78- [%s]|r %s |cffff0000*|r"
-			print(L["Options for |cffffff78"..info[#info].."|r (multiple possible):"])
-			for k, v in pairs(values) do
-				if callmethod(info, inputpos, tab, "get", k) then
-					print(fmt_sel:format(k, v))
-				else
-					print(fmt:format(k, v))
-				end
-			end
-			return
-		end
-		
-		--build a table of the selections, checking that they exist
-		--parse for =on =off =default in the process
-		--table will be key = true for options that should toggle, key = [on|off|default] for options to be set
-		local sels = {}
-		for v in str:gmatch("[^ ]+") do
-			--parse option=on etc
-			local opt, val = v:match('(.+)=(.+)')
-			--get option if toggling
-			if not opt then 
-				opt = v 
-			end
-			
-			--check that the opt is valid
-			local ok
-			for k,v in pairs(values) do 
-				if strlower(k)==opt then
-					opt = k	-- overwrite with key (in case of case mismatches)
-					ok = true
-					break
-				end
-			end
-			
-			if not ok then
-				usererr(info, inputpos, "'"..opt.."' - "..L["unknown selection"])
-				return
-			end
-			
-			--check that if val was supplied it is valid
-			if val then
-				if val == L["on"] or val == L["off"] or (tab.tristate and val == L["default"]) then
-					--val is valid insert it
-					sels[opt] = val
-				else
-					if tab.tristate then
-						usererr(info, inputpos, format(L["'%s' '%s' - expected 'on', 'off' or 'default', or no argument to toggle."], v, val))
-					else
-						usererr(info, inputpos, format(L["'%s' '%s' - expected 'on' or 'off', or no argument to toggle."], v, val))
-					end
-					return
-				end
-			else
-				-- no val supplied, toggle
-				sels[opt] = true
-			end
-		end
-		
-		for opt, val in pairs(sels) do
-			local newval
-			
-			if (val == true) then
-				--toggle the option
-				local b = callmethod(info, inputpos, tab, "get", opt)
-				
-				if tab.tristate then
-					--cycle in true, nil, false order
-					if b then
-						b = nil
-					elseif b == nil then
-						b = false
-					else
-						b = true
-					end
-				else
-					b = not b
-				end
-				newval = b
-			else
-				--set the option as specified
-				if val==L["on"] then
-					newval = true
-				elseif val==L["off"] then
-					newval = false
-				elseif val==L["default"] then
-					newval = nil
-				end
-			end
-			
-			do_final(info, inputpos, tab, "set", opt, newval)
-		end
-					
-		
-	elseif tab.type=="color" then
-		------------ color --------------------------------------------
-		local str = strtrim(strlower(str))
-		if str == "" then
-			--TODO: Show current value
-			return
-		end
-		
-		local r, g, b, a
-		
-		if tab.hasAlpha then
-			if str:len() == 8 and str:find("^%x*$")  then
-				--parse a hex string
-				r,g,b,a = tonumber(str:sub(1, 2), 16) / 255, tonumber(str:sub(3, 4), 16) / 255, tonumber(str:sub(5, 6), 16) / 255, tonumber(str:sub(7, 8), 16) / 255
-			else
-				--parse seperate values
-				r,g,b,a = str:match("^([%d%.]+) ([%d%.]+) ([%d%.]+) ([%d%.]+)$")
-				r,g,b,a = tonumber(r), tonumber(g), tonumber(b), tonumber(a)
-			end
-			if not (r and g and b and a) then
-				usererr(info, inputpos, format(L["'%s' - expected 'RRGGBBAA' or 'r g b a'."], str))
-				return
-			end
-			
-			if r >= 0.0 and r <= 1.0 and g >= 0.0 and g <= 1.0 and b >= 0.0 and b <= 1.0 and a >= 0.0 and a <= 1.0 then
-				--values are valid
-			elseif r >= 0 and r <= 255 and g >= 0 and g <= 255 and b >= 0 and b <= 255 and a >= 0 and a <= 255 then
-				--values are valid 0..255, convert to 0..1
-				r = r / 255
-				g = g / 255
-				b = b / 255
-				a = a / 255
-			else
-				--values are invalid
-				usererr(info, inputpos, format(L["'%s' - values must all be either in the range 0..1 or 0..255."], str))
-			end
-		else
-			a = 1.0
-			if str:len() == 6 and str:find("^%x*$") then
-				--parse a hex string
-				r,g,b = tonumber(str:sub(1, 2), 16) / 255, tonumber(str:sub(3, 4), 16) / 255, tonumber(str:sub(5, 6), 16) / 255
-			else
-				--parse seperate values
-				r,g,b = str:match("^([%d%.]+) ([%d%.]+) ([%d%.]+)$")
-				r,g,b = tonumber(r), tonumber(g), tonumber(b)
-			end
-			if not (r and g and b) then
-				usererr(info, inputpos, format(L["'%s' - expected 'RRGGBB' or 'r g b'."], str))
-				return
-			end
-			if r >= 0.0 and r <= 1.0 and g >= 0.0 and g <= 1.0 and b >= 0.0 and b <= 1.0 then
-				--values are valid
-			elseif r >= 0 and r <= 255 and g >= 0 and g <= 255 and b >= 0 and b <= 255 then
-				--values are valid 0..255, convert to 0..1
-				r = r / 255
-				g = g / 255
-				b = b / 255
-			else
-				--values are invalid
-				usererr(info, inputpos, format(L["'%s' - values must all be either in the range 0-1 or 0-255."], str))
-			end
-		end
-		
-		do_final(info, inputpos, tab, "set", r,g,b,a)
-
-	elseif tab.type=="keybinding" then
-		------------ keybinding --------------------------------------------
-		local str = strtrim(strlower(str))
-		if str == "" then
-			--TODO: Show current value
-			return
-		end
-		local value = keybindingValidateFunc(str:upper())
-		if value == false then
-			usererr(info, inputpos, format(L["'%s' - Invalid Keybinding."], str))
-			return
-		end
-
-		do_final(info, inputpos, tab, "set", value)
-
-	elseif tab.type=="description" then
-		------------ description --------------------
-		-- ignore description, GUI config only
-	else
-		err(info, inputpos, "unknown options table item type '"..tostring(tab.type).."'")
-	end
-end
-
---- Handle the chat command.
--- This is usually called from a chat command handler to parse the command input as operations on an aceoptions table.\\
--- AceConfigCmd uses this function internally when a slash command is registered with `:CreateChatCommand`
--- @param slashcmd The slash command WITHOUT leading slash (only used for error output)
--- @param appName The application name as given to `:RegisterOptionsTable()`
--- @param input The commandline input (as given by the WoW handler, i.e. without the command itself)
--- @usage
--- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceConsole-3.0")
--- -- Use AceConsole-3.0 to register a Chat Command
--- MyAddon:RegisterChatCommand("mychat", "ChatCommand")
--- 
--- -- Show the GUI if no input is supplied, otherwise handle the chat input.
--- function MyAddon:ChatCommand(input)
---   -- Assuming "MyOptions" is the appName of a valid options table
---   if not input or input:trim() == "" then
---     LibStub("AceConfigDialog-3.0"):Open("MyOptions")
---   else
---     LibStub("AceConfigCmd-3.0").HandleCommand(MyAddon, "mychat", "MyOptions", input)
---   end
--- end
-function AceConfigCmd:HandleCommand(slashcmd, appName, input)
-
-	local optgetter = cfgreg:GetOptionsTable(appName)
-	if not optgetter then
-		error([[Usage: HandleCommand("slashcmd", "appName", "input"): 'appName' - no options table "]]..tostring(appName)..[[" has been registered]], 2)
-	end
-	local options = assert( optgetter("cmd", MAJOR) )
-	
-	local info = {   -- Don't try to recycle this, it gets handed off to callbacks and whatnot
-		[0] = slashcmd,
-		appName = appName,
-		options = options,
-		input = input,
-		self = self,
-		handler = self,
-		uiType = "cmd",
-		uiName = MAJOR,
-	}
-	
-	handle(info, 1, options, 0)  -- (info, inputpos, table, depth)
-end
-
---- Utility function to create a slash command handler.
--- Also registers tab completion with AceTab
--- @param slashcmd The slash command WITHOUT leading slash (only used for error output)
--- @param appName The application name as given to `:RegisterOptionsTable()`
-function AceConfigCmd:CreateChatCommand(slashcmd, appName)
-	if not AceConsole then
-		AceConsole = LibStub(AceConsoleName)
-	end
-	if AceConsole.RegisterChatCommand(self, slashcmd, function(input)
-				AceConfigCmd.HandleCommand(self, slashcmd, appName, input)	-- upgradable
-		end,
-	true) then -- succesfully registered so lets get the command -> app table in
-		commands[slashcmd] = appName
-	end
-end
-
---- Utility function that returns the options table that belongs to a slashcommand.
--- Designed to be used for the AceTab interface.
--- @param slashcmd The slash command WITHOUT leading slash (only used for error output)
--- @return The options table associated with the slash command (or nil if the slash command was not registered)
-function AceConfigCmd:GetChatCommandOptions(slashcmd)
-	return commands[slashcmd]
-end

--- a/Libs/AceConfig-3.0/AceConfigCmd-3.0/AceConfigCmd-3.0.xml	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -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="AceConfigCmd-3.0.lua"/>
-</Ui>
\ No newline at end of file

--- a/Libs/AceConfig-3.0/AceConfigDialog-3.0/AceConfigDialog-3.0.lua	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1895 +0,0 @@
---- AceConfigDialog-3.0 generates AceGUI-3.0 based windows based on option tables.
--- @class file
--- @name AceConfigDialog-3.0
--- @release $Id: AceConfigDialog-3.0.lua 902 2009-12-12 14:56:14Z nevcairiel $
-
-local LibStub = LibStub
-local MAJOR, MINOR = "AceConfigDialog-3.0", 43
-local AceConfigDialog, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
-
-if not AceConfigDialog then return end
-
-AceConfigDialog.OpenFrames = AceConfigDialog.OpenFrames or {}
-AceConfigDialog.Status = AceConfigDialog.Status or {}
-AceConfigDialog.frame = AceConfigDialog.frame or CreateFrame("Frame")
-
-AceConfigDialog.frame.apps = AceConfigDialog.frame.apps or {}
-AceConfigDialog.frame.closing = AceConfigDialog.frame.closing or {}
-
-local gui = LibStub("AceGUI-3.0")
-local reg = LibStub("AceConfigRegistry-3.0")
-
--- Lua APIs
-local tconcat, tinsert, tsort, tremove = table.concat, table.insert, table.sort, table.remove
-local strmatch, format = string.match, string.format
-local assert, loadstring, error = assert, loadstring, error
-local pairs, next, select, type, unpack = pairs, next, select, type, unpack
-local rawset, tostring = rawset, tostring
-local math_min, math_max, math_floor = math.min, math.max, math.floor
-
--- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
--- List them here for Mikk's FindGlobals script
--- GLOBALS: NORMAL_FONT_COLOR, GameTooltip, StaticPopupDialogs, ACCEPT, CANCEL, StaticPopup_Show
--- GLOBALS: PlaySound, GameFontHighlight, GameFontHighlightSmall, GameFontHighlightLarge
--- GLOBALS: CloseSpecialWindows, InterfaceOptions_AddCategory, geterrorhandler
-
-local emptyTbl = {}
-
---[[
-	 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, ...)
-	return Dispatchers[select('#', ...)](func, ...)
-end
-
-local width_multiplier = 170
-
---[[
-Group Types
-  Tree 	- All Descendant Groups will all become nodes on the tree, direct child options will appear above the tree
-  		- Descendant Groups with inline=true and thier children will not become nodes
-
-  Tab	- Direct Child Groups will become tabs, direct child options will appear above the tab control
-  		- Grandchild groups will default to inline unless specified otherwise
-
-  Select- Same as Tab but with entries in a dropdown rather than tabs
-
-
-  Inline Groups
-  	- Will not become nodes of a select group, they will be effectivly part of thier parent group seperated by a border
-  	- If declared on a direct child of a root node of a select group, they will appear above the group container control
-  	- When a group is displayed inline, all descendants will also be inline members of the group
-
-]]
-
--- Recycling functions
-local new, del, copy
---newcount, delcount,createdcount,cached = 0,0,0
-do
-	local pool = setmetatable({},{__mode='k'})
-	function new()
-		--newcount = newcount + 1
-		local t = next(pool)
-		if t then
-			pool[t] = nil
-			return t
-		else
-			--createdcount = createdcount + 1
-			return {}
-		end
-	end
-	function copy(t)
-		local c = new()
-		for k, v in pairs(t) do
-			c[k] = v
-		end
-		return c
-	end
-	function del(t)
-		--delcount = delcount + 1
-		for k in pairs(t) do
-			t[k] = nil
-		end
-		pool[t] = true
-	end
---	function cached()
---		local n = 0
---		for k in pairs(pool) do
---			n = n + 1
---		end
---		return n
---	end
-end
-
--- picks the first non-nil value and returns it
-local function pickfirstset(...)
-  for i=1,select("#",...) do
-    if select(i,...)~=nil then
-      return select(i,...)
-    end
-  end
-end
-
---gets an option from a given group, checking plugins
-local function GetSubOption(group, key)
-	if group.plugins then
-		for plugin, t in pairs(group.plugins) do
-			if t[key] then
-				return t[key]
-			end
-		end
-	end
-
-	return group.args[key]
-end
-
---Option member type definitions, used to decide how to access it
-
---Is the member Inherited from parent options
-local isInherited = {
-	set = true,
-	get = true,
-	func = true,
-	confirm = true,
-	validate = true,
-	disabled = true,
-	hidden = true
-}
-
---Does a string type mean a literal value, instead of the default of a method of the handler
-local stringIsLiteral = {
-	name = true,
-	desc = true,
-	icon = true,
-	usage = true,
-	width = true,
-	image = true,
-	fontSize = true,
-}
-
---Is Never a function or method
-local allIsLiteral = {
-	type = true,
-	descStyle = true,
-	imageWidth = true,
-	imageHeight = true,
-}
-
---gets the value for a member that could be a function
---function refs are called with an info arg
---every other type is returned
-local function GetOptionsMemberValue(membername, option, options, path, appName, ...)
-	--get definition for the member
-	local inherits = isInherited[membername]
-	
-
-	--get the member of the option, traversing the tree if it can be inherited
-	local member
-	
-	if inherits then
-		local group = options
-		if group[membername] ~= nil then
-			member = group[membername]
-		end
-		for i = 1, #path do
-			group = GetSubOption(group, path[i])
-			if group[membername] ~= nil then
-				member = group[membername]
-			end
-		end
-	else
-		member = option[membername]
-	end
-	
-	--check if we need to call a functon, or if we have a literal value
-	if ( not allIsLiteral[membername] ) and ( type(member) == "function" or ((not stringIsLiteral[membername]) and type(member) == "string") ) then
-		--We have a function to call
-		local info = new()
-		--traverse the options table, picking up the handler and filling the info with the path
-		local handler
-		local group = options
-		handler = group.handler or handler
-		
-		for i = 1, #path do
-			group = GetSubOption(group, path[i])
-			info[i] = path[i]
-			handler = group.handler or handler
-		end
-		
-		info.options = options
-		info.appName = appName
-		info[0] = appName
-		info.arg = option.arg
-		info.handler = handler
-		info.option = option
-		info.type = option.type
-		info.uiType = 'dialog'
-		info.uiName = MAJOR
-	
-		local a, b, c ,d 
-		--using 4 returns for the get of a color type, increase if a type needs more
-		if type(member) == "function" then
-			--Call the function
-			a,b,c,d = member(info, ...)
-		else
-			--Call the method
-			if handler and handler[member] then
-				a,b,c,d = handler[member](handler, info, ...)
-			else
-				error(format("Method %s doesn't exist in handler for type %s", member, membername))
-			end
-		end
-		del(info)
-		return a,b,c,d
-	else
-		--The value isnt a function to call, return it
-		return member	
-	end	
-end
-
---[[calls an options function that could be inherited, method name or function ref
-local function CallOptionsFunction(funcname ,option, options, path, appName, ...)
-	local info = new()
-
-	local func
-	local group = options
-	local handler
-
-	--build the info table containing the path
-	-- pick up functions while traversing the tree
-	if group[funcname] ~= nil then
-		func = group[funcname]
-	end
-	handler = group.handler or handler
-
-	for i, v in ipairs(path) do
-		group = GetSubOption(group, v)
-		info[i] = v
-		if group[funcname] ~= nil then
-			func =  group[funcname]
-		end
-		handler = group.handler or handler
-	end
-
-	info.options = options
-	info[0] = appName
-	info.arg = option.arg
-
-	local a, b, c ,d
-	if type(func) == "string" then
-		if handler and handler[func] then
-			a,b,c,d = handler[func](handler, info, ...)
-		else
-			error(string.format("Method %s doesn't exist in handler for type func", func))
-		end
-	elseif type(func) == "function" then
-		a,b,c,d = func(info, ...)
-	end
-	del(info)
-	return a,b,c,d
-end
---]]
-
---tables to hold orders and names for options being sorted, will be created with new()
---prevents needing to call functions repeatedly while sorting
-local tempOrders
-local tempNames
-
-local function compareOptions(a,b)
-	if not a then
-		return true
-	end
-	if not b then
-		return false
-	end
-	local OrderA, OrderB = tempOrders[a] or 100, tempOrders[b] or 100
-	if OrderA == OrderB then
-		local NameA = (type(tempNames[a] == "string") and tempNames[a]) or ""
-		local NameB = (type(tempNames[b] == "string") and tempNames[b]) or ""
-		return NameA:upper() < NameB:upper()
-	end
-	if OrderA < 0 then
-		if OrderB > 0 then
-			return false
-		end
-	else
-		if OrderB < 0 then
-			return true
-		end
-	end
-	return OrderA < OrderB
-end
-
-
-
---builds 2 tables out of an options group
--- keySort, sorted keys
--- opts, combined options from .plugins and args
-local function BuildSortedOptionsTable(group, keySort, opts, options, path, appName)
-	tempOrders = new()
-	tempNames = new()
-	
-	if group.plugins then
-		for plugin, t in pairs(group.plugins) do
-			for k, v in pairs(t) do
-				if not opts[k] then
-					tinsert(keySort, k)
-					opts[k] = v
-
-					path[#path+1] = k
-					tempOrders[k] = GetOptionsMemberValue("order", v, options, path, appName)
-					tempNames[k] = GetOptionsMemberValue("name", v, options, path, appName)
-					path[#path] = nil
-				end
-			end
-		end
-	end
-	
-	for k, v in pairs(group.args) do
-		if not opts[k] then
-			tinsert(keySort, k)
-			opts[k] = v
-
-			path[#path+1] = k
-			tempOrders[k] = GetOptionsMemberValue("order", v, options, path, appName)
-			tempNames[k] = GetOptionsMemberValue("name", v, options, path, appName)
-			path[#path] = nil
-		end
-	end
-
-	tsort(keySort, compareOptions)
-
-	del(tempOrders)
-	del(tempNames)
-end
-
-local function DelTree(tree)
-	if tree.children then
-		local childs = tree.children
-		for i = 1, #childs do
-			DelTree(childs[i])
-			del(childs[i])
-		end
-		del(childs)
-	end
-end
-
-local function CleanUserData(widget, event)
-	
-	local user = widget:GetUserDataTable()
-
-	if user.path then
-		del(user.path)
-	end
-
-	if widget.type == "TreeGroup" then
-		local tree = user.tree
-		widget:SetTree(nil)
-		if tree then
-			for i = 1, #tree do
-				DelTree(tree[i])
-				del(tree[i])
-			end
-			del(tree)
-		end
-	end
-
-	if widget.type == "TabGroup" then
-		widget:SetTabs(nil)
-		if user.tablist then
-			del(user.tablist)
-		end
-	end
-
-	if widget.type == "DropdownGroup" then
-		widget:SetGroupList(nil)
-		if user.grouplist then
-			del(user.grouplist)
-		end
-	end
-end
-
--- - Gets a status table for the given appname and options path.
--- @param appName The application name as given to `:RegisterOptionsTable()`
--- @param path The path to the options (a table with all group keys)
--- @return 
-function AceConfigDialog:GetStatusTable(appName, path)
-	local status = self.Status
-
-	if not status[appName] then
-		status[appName] = {}
-		status[appName].status = {}
-		status[appName].children = {}
-	end
-
-	status = status[appName]
-
-	if path then
-		for i = 1, #path do
-			local v = path[i]
-			if not status.children[v] then
-				status.children[v] = {}
-				status.children[v].status = {}
-				status.children[v].children = {}
-			end
-			status = status.children[v]
-		end
-	end
-
-	return status.status
-end
-
---- Selects the specified path in the options window.
--- The path specified has to match the keys of the groups in the table.
--- @param appName The application name as given to `:RegisterOptionsTable()`
--- @param ... The path to the key that should be selected
-function AceConfigDialog:SelectGroup(appName, ...)
-	local path = new()
-
-	
-	local app = reg:GetOptionsTable(appName)
-	if not app then
-		error(("%s isn't registed with AceConfigRegistry, unable to open config"):format(appName), 2)
-	end
-	local options = app("dialog", MAJOR)
-	local group = options
-	local status = self:GetStatusTable(appName, path)
-	if not status.groups then
-		status.groups = {}
-	end
-	status = status.groups
-	local treevalue 
-	local treestatus 
-	
-	for n = 1, select('#',...) do
-		local key = select(n, ...)
-
-		if group.childGroups == "tab" or group.childGroups == "select" then
-			--if this is a tab or select group, select the group
-			status.selected = key
-			--children of this group are no longer extra levels of a tree
-			treevalue = nil
-		else
-			--tree group by default
-			if treevalue then
-				--this is an extra level of a tree group, build a uniquevalue for it
-				treevalue = treevalue.."\001"..key
-			else
-				--this is the top level of a tree group, the uniquevalue is the same as the key
-				treevalue = key
-				if not status.groups then
-					status.groups = {}
-				end
-				--save this trees status table for any extra levels or groups
-				treestatus = status
-			end
-			--make sure that the tree entry is open, and select it.
-			--the selected group will be overwritten if a child is the final target but still needs to be open
-			treestatus.selected = treevalue
-			treestatus.groups[treevalue] = true
-			
-		end
-		
-		--move to the next group in the path
-		group = GetSubOption(group, key)
-		if not group then 
-			break
-		end
-		tinsert(path, key)
-		status = self:GetStatusTable(appName, path)
-		if not status.groups then
-			status.groups = {}
-		end
-		status = status.groups
-	end
-	
-	del(path)
-	reg:NotifyChange(appName)
-end	
-
-local function OptionOnMouseOver(widget, event)
-	--show a tooltip/set the status bar to the desc text
-	local user = widget:GetUserDataTable()
-	local opt = user.option
-	local options = user.options
-	local path = user.path
-	local appName = user.appName
-
-	GameTooltip:SetOwner(widget.frame, "ANCHOR_TOPRIGHT")
-	local name = GetOptionsMemberValue("name", opt, options, path, appName)
-	local desc = GetOptionsMemberValue("desc", opt, options, path, appName)
-	local usage = GetOptionsMemberValue("usage", opt, options, path, appName)
-	local descStyle = opt.descStyle
-	
-	if descStyle and descStyle ~= "tooltip" then return end
-	
-	GameTooltip:SetText(name, 1, .82, 0, 1)
-	
-	if opt.type == 'multiselect' then
-		GameTooltip:AddLine(user.text,0.5, 0.5, 0.8, 1)
-	end	
-	if type(desc) == "string" then
-		GameTooltip:AddLine(desc, 1, 1, 1, 1)
-	end
-	if type(usage) == "string" then
-		GameTooltip:AddLine("Usage: "..usage, NORMAL_FONT_COLOR.r, NORMAL_FONT_COLOR.g, NORMAL_FONT_COLOR.b, 1)
-	end
-
-	GameTooltip:Show()
-end
-
-local function OptionOnMouseLeave(widget, event)
-	GameTooltip:Hide()
-end
-
-local function GetFuncName(option)
-	local type = option.type
-	if type == 'execute' then
-		return 'func'
-	else
-		return 'set'
-	end
-end
-local function confirmPopup(appName, rootframe, basepath, info, message, func, ...)
-	if not StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"] then
-		StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"] = {}
-	end
-	local t = StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"]
-	for k in pairs(t) do
-		t[k] = nil
-	end
-	t.text = message
-	t.button1 = ACCEPT
-	t.button2 = CANCEL
-	local dialog, oldstrata
-	t.OnAccept = function()
-		safecall(func, unpack(t))
-		if dialog and oldstrata then
-			dialog:SetFrameStrata(oldstrata)
-		end
-		AceConfigDialog:Open(appName, rootframe, unpack(basepath or emptyTbl))
-		del(info)
-	end
-	t.OnCancel = function()
-		if dialog and oldstrata then
-			dialog:SetFrameStrata(oldstrata)
-		end
-		AceConfigDialog:Open(appName, rootframe, unpack(basepath or emptyTbl))
-		del(info)
-	end
-	for i = 1, select('#', ...) do
-		t[i] = select(i, ...) or false
-	end
-	t.timeout = 0
-	t.whileDead = 1
-	t.hideOnEscape = 1
-
-	dialog = StaticPopup_Show("ACECONFIGDIALOG30_CONFIRM_DIALOG")
-	if dialog then
-		oldstrata = dialog:GetFrameStrata()
-		dialog:SetFrameStrata("TOOLTIP")
-	end
-end
-
-local function ActivateControl(widget, event, ...)
-	--This function will call the set / execute handler for the widget
-	--widget:GetUserDataTable() contains the needed info
-	local user = widget:GetUserDataTable()
-	local option = user.option
-	local options = user.options
-	local path = user.path
-	local info = new()
-
-	local func
-	local group = options
-	local funcname = GetFuncName(option)
-	local handler
-	local confirm
-	local validate
-	--build the info table containing the path
-	-- pick up functions while traversing the tree
-	if group[funcname] ~= nil then
-		func =  group[funcname]
-	end
-	handler = group.handler or handler
-	confirm = group.confirm
-	validate = group.validate
-	for i = 1, #path do
-		local v = path[i]
-		group = GetSubOption(group, v)
-		info[i] = v
-		if group[funcname] ~= nil then
-			func =  group[funcname]
-		end
-		handler = group.handler or handler
-		if group.confirm ~= nil then
-			confirm = group.confirm
-		end
-		if group.validate ~= nil then
-			validate = group.validate
-		end
-	end
-
-	info.options = options
-	info.appName = user.appName
-	info.arg = option.arg
-	info.handler = handler
-	info.option = option
-	info.type = option.type
-	info.uiType = 'dialog'
-	info.uiName = MAJOR
-
-	local name
-	if type(option.name) == "function" then
-		name = option.name(info)
-	elseif type(option.name) == "string" then
-		name = option.name
-	else
-		name = ""
-	end
-	local usage = option.usage
-	local pattern = option.pattern
-
-	local validated = true
-
-	if option.type == "input" then
-		if type(pattern)=="string" then
-			if not strmatch(..., pattern) then
-				validated = false
-			end
-		end
-	end
-	
-	local success
-	if validated and option.type ~= "execute" then
-		if type(validate) == "string" then
-			if handler and handler[validate] then
-				success, validated = safecall(handler[validate], handler, info, ...)
-				if not success then validated = false end
-			else
-				error(format("Method %s doesn't exist in handler for type execute", validate))
-			end
-		elseif type(validate) == "function" then
-			success, validated = safecall(validate, info, ...)
-			if not success then validated = false end
-		end
-	end
-	
-	local rootframe = user.rootframe
-	if type(validated) == "string" then
-		--validate function returned a message to display
-		if rootframe.SetStatusText then
-			rootframe:SetStatusText(validated)
-		else
-			-- TODO: do something else.
-		end
-		PlaySound("igPlayerInviteDecline")
-		del(info)
-		return true
-	elseif not validated then
-		--validate returned false	
-		if rootframe.SetStatusText then
-			if usage then
-				rootframe:SetStatusText(name..": "..usage)
-			else
-				if pattern then
-					rootframe:SetStatusText(name..": Expected "..pattern)
-				else
-					rootframe:SetStatusText(name..": Invalid Value")
-				end
-			end
-		else
-			-- TODO: do something else
-		end
-		PlaySound("igPlayerInviteDecline")
-		del(info)
-		return true
-	else
-		
-		local confirmText = option.confirmText
-		--call confirm func/method
-		if type(confirm) == "string" then
-			if handler and handler[confirm] then
-				success, confirm = safecall(handler[confirm], handler, info, ...)
-				if success and type(confirm) == "string" then
-					confirmText = confirm
-					confirm = true
-				elseif not success then
-					confirm = false
-				end
-			else
-				error(format("Method %s doesn't exist in handler for type confirm", confirm))
-			end
-		elseif type(confirm) == "function" then
-			success, confirm = safecall(confirm, info, ...)
-			if success and type(confirm) == "string" then
-				confirmText = confirm
-				confirm = true
-			elseif not success then
-				confirm = false
-			end
-		end
-
-		--confirm if needed
-		if type(confirm) == "boolean" then
-			if confirm then
-				if not confirmText then
-					local name, desc = option.name, option.desc
-					if type(name) == "function" then
-						name = name(info)
-					end
-					if type(desc) == "function" then
-						desc = desc(info)
-					end
-					confirmText = name
-					if desc then
-						confirmText = confirmText.." - "..desc
-					end
-				end
-				
-				local iscustom = user.rootframe:GetUserData('iscustom')
-				local rootframe
-				
-				if iscustom then
-					rootframe = user.rootframe
-				end
-				local basepath = user.rootframe:GetUserData('basepath')
-				if type(func) == "string" then
-					if handler and handler[func] then
-						confirmPopup(user.appName, rootframe, basepath, info, confirmText, handler[func], handler, info, ...)
-					else
-						error(format("Method %s doesn't exist in handler for type func", func))
-					end
-				elseif type(func) == "function" then
-					confirmPopup(user.appName, rootframe, basepath, info, confirmText, func, info, ...)
-				end
-				--func will be called and info deleted when the confirm dialog is responded to
-				return
-			end
-		end
-
-		--call the function
-		if type(func) == "string" then
-			if handler and handler[func] then
-				safecall(handler[func],handler, info, ...)
-			else
-				error(format("Method %s doesn't exist in handler for type func", func))
-			end
-		elseif type(func) == "function" then
-			safecall(func,info, ...)
-		end
-
-
-
-		local iscustom = user.rootframe:GetUserData('iscustom')
-		local basepath = user.rootframe:GetUserData('basepath') or emptyTbl
-		--full refresh of the frame, some controls dont cause this on all events
-		if option.type == "color" then
-			if event == "OnValueConfirmed" then
-				
-				if iscustom then
-					AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath))
-				else
-					AceConfigDialog:Open(user.appName, unpack(basepath))
-				end
-			end
-		elseif option.type == "range" then
-			if event == "OnMouseUp" then
-				if iscustom then
-					AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath))
-				else
-					AceConfigDialog:Open(user.appName, unpack(basepath))
-				end
-			end
-		--multiselects don't cause a refresh on 'OnValueChanged' only 'OnClosed'
-		elseif option.type == "multiselect" then
-			user.valuechanged = true
-		else
-			if iscustom then
-				AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath))
-			else
-				AceConfigDialog:Open(user.appName, unpack(basepath))
-			end
-		end
-
-	end
-	del(info)
-end
-
-local function ActivateSlider(widget, event, value)
-	local option = widget:GetUserData('option')
-	local min, max, step = option.min or 0, option.max or 100, option.step
-	if step then
-		value = math_floor((value - min) / step + 0.5) * step + min
-	else
-		value = math_max(math_min(value,max),min)
-	end
-	ActivateControl(widget,event,value)
-end
-
---called from a checkbox that is part of an internally created multiselect group
---this type is safe to refresh on activation of one control
-local function ActivateMultiControl(widget, event, ...)
-	ActivateControl(widget, event, widget:GetUserData('value'), ...)
-	local user = widget:GetUserDataTable()
-	local iscustom = user.rootframe:GetUserData('iscustom')
-	local basepath = user.rootframe:GetUserData('basepath') or emptyTbl
-	if iscustom then
-		AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath))
-	else
-		AceConfigDialog:Open(user.appName, unpack(basepath))
-	end
-end
-
-local function MultiControlOnClosed(widget, event, ...)
-	local user = widget:GetUserDataTable()
-	if user.valuechanged then
-		local iscustom = user.rootframe:GetUserData('iscustom')
-		local basepath = user.rootframe:GetUserData('basepath') or emptyTbl
-		if iscustom then
-			AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath))
-		else
-			AceConfigDialog:Open(user.appName, unpack(basepath))
-		end
-	end
-end
-
-local function FrameOnClose(widget, event)
-	local appName = widget:GetUserData('appName')
-	AceConfigDialog.OpenFrames[appName] = nil
-	gui:Release(widget)
-end
-
-local function CheckOptionHidden(option, options, path, appName)
-	--check for a specific boolean option
-	local hidden = pickfirstset(option.dialogHidden,option.guiHidden)
-	if hidden ~= nil then
-		return hidden
-	end
-
-	return GetOptionsMemberValue("hidden", option, options, path, appName)
-end
-
-local function CheckOptionDisabled(option, options, path, appName)
-	--check for a specific boolean option
-	local disabled = pickfirstset(option.dialogDisabled,option.guiDisabled)
-	if disabled ~= nil then
-		return disabled
-	end
-
-	return GetOptionsMemberValue("disabled", option, options, path, appName)
-end
---[[
-local function BuildTabs(group, options, path, appName)
-	local tabs = new()
-	local text = new()
-	local keySort = new()
-	local opts = new()
-
-	BuildSortedOptionsTable(group, keySort, opts, options, path, appName)
-
-	for i = 1, #keySort do
-		local k = keySort[i]
-		local v = opts[k]
-		if v.type == "group" then
-			path[#path+1] = k
-			local inline = pickfirstset(v.dialogInline,v.guiInline,v.inline, false)
-			local hidden = CheckOptionHidden(v, options, path, appName)
-			if not inline and not hidden then
-				tinsert(tabs, k)
-				text[k] = GetOptionsMemberValue("name", v, options, path, appName)
-			end
-			path[#path] = nil
-		end
-	end
-
-	del(keySort)
-	del(opts)
-
-	return tabs, text
-end
-]]
-local function BuildSelect(group, options, path, appName)
-	local groups = new()
-	local keySort = new()
-	local opts = new()
-
-	BuildSortedOptionsTable(group, keySort, opts, options, path, appName)
-
-	for i = 1, #keySort do
-		local k = keySort[i]
-		local v = opts[k]
-		if v.type == "group" then
-			path[#path+1] = k
-			local inline = pickfirstset(v.dialogInline,v.guiInline,v.inline, false)
-			local hidden = CheckOptionHidden(v, options, path, appName)
-			if not inline and not hidden then
-				groups[k] = GetOptionsMemberValue("name", v, options, path, appName)
-			end
-			path[#path] = nil
-		end
-	end
-
-	del(keySort)
-	del(opts)
-
-	return groups
-end
-
-local function BuildSubGroups(group, tree, options, path, appName)
-	local keySort = new()
-	local opts = new()
-
-	BuildSortedOptionsTable(group, keySort, opts, options, path, appName)
-
-	for i = 1, #keySort do
-		local k = keySort[i]
-		local v = opts[k]
-		if v.type == "group" then
-			path[#path+1] = k
-			local inline = pickfirstset(v.dialogInline,v.guiInline,v.inline, false)
-			local hidden = CheckOptionHidden(v, options, path, appName)
-			if not inline and not hidden then
-				local entry = new()
-				entry.value = k
-				entry.text = GetOptionsMemberValue("name", v, options, path, appName)
-				entry.icon = GetOptionsMemberValue("icon", v, options, path, appName)
-				entry.disabled = CheckOptionDisabled(v, options, path, appName)
-				if not tree.children then tree.children = new() end
-				tinsert(tree.children,entry)
-				if (v.childGroups or "tree") == "tree" then
-					BuildSubGroups(v,entry, options, path, appName)
-				end
-			end
-			path[#path] = nil
-		end
-	end
-
-	del(keySort)
-	del(opts)
-end
-
-local function BuildGroups(group, options, path, appName, recurse)
-	local tree = new()
-	local keySort = new()
-	local opts = new()
-
-	BuildSortedOptionsTable(group, keySort, opts, options, path, appName)
-
-	for i = 1, #keySort do
-		local k = keySort[i]
-		local v = opts[k]
-		if v.type == "group" then
-			path[#path+1] = k
-			local inline = pickfirstset(v.dialogInline,v.guiInline,v.inline, false)
-			local hidden = CheckOptionHidden(v, options, path, appName)
-			if not inline and not hidden then
-				local entry = new()
-				entry.value = k
-				entry.text = GetOptionsMemberValue("name", v, options, path, appName)
-				entry.icon = GetOptionsMemberValue("icon", v, options, path, appName)
-				entry.disabled = CheckOptionDisabled(v, options, path, appName)
-				tinsert(tree,entry)
-				if recurse and (v.childGroups or "tree") == "tree" then
-					BuildSubGroups(v,entry, options, path, appName)
-				end
-			end
-			path[#path] = nil
-		end
-	end
-	del(keySort)
-	del(opts)
-	return tree
-end
-
-local function InjectInfo(control, options, option, path, rootframe, appName)
-	local user = control:GetUserDataTable()
-	for i = 1, #path do
-		user[i] = path[i]
-	end
-	user.rootframe = rootframe
-	user.option = option
-	user.options = options
-	user.path = copy(path)
-	user.appName = appName
-	control:SetCallback("OnRelease", CleanUserData)
-	control:SetCallback("OnLeave", OptionOnMouseLeave)
-	control:SetCallback("OnEnter", OptionOnMouseOver)
-end
-
-
---[[
-	options - root of the options table being fed
-	container - widget that controls will be placed in
-	rootframe - Frame object the options are in
-	path - table with the keys to get to the group being fed
---]]
-
-local function FeedOptions(appName, options,container,rootframe,path,group,inline)
-	local keySort = new()
-	local opts = new()
-
-	BuildSortedOptionsTable(group, keySort, opts, options, path, appName)
-
-	for i = 1, #keySort do
-		local k = keySort[i]
-		local v = opts[k]
-		tinsert(path, k)
-		local hidden = CheckOptionHidden(v, options, path, appName)
-		local name = GetOptionsMemberValue("name", v, options, path, appName)
-		if not hidden then
-			if v.type == "group" then
-				if inline or pickfirstset(v.dialogInline,v.guiInline,v.inline, false) then
-					--Inline group
-					local GroupContainer
-					if name and name ~= "" then
-						GroupContainer = gui:Create("InlineGroup")
-						GroupContainer:SetTitle(name or "")
-					else
-						GroupContainer = gui:Create("SimpleGroup")
-					end
-					
-					GroupContainer.width = "fill"
-					GroupContainer:SetLayout("flow")
-					container:AddChild(GroupContainer)
-					FeedOptions(appName,options,GroupContainer,rootframe,path,v,true)
-				end
-			else
-				--Control to feed
-				local control
-				
-				local name = GetOptionsMemberValue("name", v, options, path, appName)
-				
-				if v.type == "execute" then
-					
-					local imageCoords = GetOptionsMemberValue("imageCoords",v, options, path, appName)
-					local image, width, height = GetOptionsMemberValue("image",v, options, path, appName)
-					
-					if type(image) == 'string' then
-						control = gui:Create("Icon")
-						if not width then
-							width = GetOptionsMemberValue("imageWidth",v, options, path, appName)
-						end
-						if not height then
-							height = GetOptionsMemberValue("imageHeight",v, options, path, appName)
-						end
-						if type(imageCoords) == 'table' then
-							control:SetImage(image, unpack(imageCoords))
-						else
-							control:SetImage(image)
-						end
-						if type(width) ~= "number" then
-							width = 32
-						end
-						if type(height) ~= "number" then
-							height = 32
-						end
-						control:SetImageSize(width, height)
-						control:SetLabel(name)
-					else
-						control = gui:Create("Button")
-						control:SetText(name)
-					end
-					control:SetCallback("OnClick",ActivateControl)
-
-				elseif v.type == "input" then
-					local controlType = v.dialogControl or v.control or (v.multiline and "MultiLineEditBox") or "EditBox"
-					control = gui:Create(controlType)
-					if not control then
-						geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(controlType)))
-						control = gui:Create(v.multiline and "MultiLineEditBox" or "EditBox")
-					end
-					
-					if v.multiline then
-						local lines = 4
-						if type(v.multiline) == "number" then
-							lines = v.multiline
-						end
-						control:SetHeight(60 + (14*lines))
-					end
-					control:SetLabel(name)
-					control:SetCallback("OnEnterPressed",ActivateControl)
-					local text = GetOptionsMemberValue("get",v, options, path, appName)
-					if type(text) ~= "string" then
-						text = ""
-					end
-					control:SetText(text)
-
-				elseif v.type == "toggle" then
-					control = gui:Create("CheckBox")
-					control:SetLabel(name)
-					control:SetTriState(v.tristate)
-					local value = GetOptionsMemberValue("get",v, options, path, appName)
-					control:SetValue(value)
-					control:SetCallback("OnValueChanged",ActivateControl)
-					
-					if v.descStyle == "inline" then
-						local desc = GetOptionsMemberValue("desc", v, options, path, appName)
-						control:SetDescription(desc)
-					end
-					
-					local image = GetOptionsMemberValue("image", v, options, path, appName)
-					local imageCoords = GetOptionsMemberValue("imageCoords", v, options, path, appName)
-					
-					if type(image) == 'string' then
-						if type(imageCoords) == 'table' then
-							control:SetImage(image, unpack(imageCoords))
-						else
-							control:SetImage(image)
-						end
-					end
-				elseif v.type == "range" then
-					control = gui:Create("Slider")
-					control:SetLabel(name)
-					control:SetSliderValues(v.min or 0,v.max or 100, v.bigStep or v.step or 0)
-					control:SetIsPercent(v.isPercent)
-					local value = GetOptionsMemberValue("get",v, options, path, appName)
-					if type(value) ~= "number" then
-						value = 0
-					end
-					control:SetValue(value)
-					control:SetCallback("OnValueChanged",ActivateSlider)
-					control:SetCallback("OnMouseUp",ActivateSlider)
-
-				elseif v.type == "select" then
-					local values = GetOptionsMemberValue("values", v, options, path, appName)
-					local controlType = v.dialogControl or v.control or "Dropdown"
-					control = gui:Create(controlType)
-					if not control then
-						geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(controlType)))
-						control = gui:Create("Dropdown")
-					end
-					control:SetLabel(name)
-					control:SetList(values)
-					local value = GetOptionsMemberValue("get",v, options, path, appName)
-					if not values[value] then
-						value = nil
-					end
-					control:SetValue(value)
-					control:SetCallback("OnValueChanged",ActivateControl)
-
-				elseif v.type == "multiselect" then
-					local values = GetOptionsMemberValue("values", v, options, path, appName)
-					local disabled = CheckOptionDisabled(v, options, path, appName)
-					
-					local controlType = v.dialogControl or v.control
-					
-					local valuesort = new()
-					if values then
-						for value, text in pairs(values) do
-							tinsert(valuesort, value)
-						end
-					end
-					tsort(valuesort)
-					
-					if controlType then
-						control = gui:Create(controlType)
-						if not control then
-							geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(controlType)))
-						end
-					end
-					if control then
-						control:SetMultiselect(true)
-						control:SetLabel(name)
-						control:SetList(values)
-						control:SetDisabled(disabled)
-						control:SetCallback("OnValueChanged",ActivateControl)
-						control:SetCallback("OnClosed", MultiControlOnClosed)
-						local width = GetOptionsMemberValue("width",v,options,path,appName)
-						if width == "double" then
-							control:SetWidth(width_multiplier * 2)
-						elseif width == "half" then
-							control:SetWidth(width_multiplier / 2)
-						elseif width == "full" then
-							control.width = "fill"
-						else
-							control:SetWidth(width_multiplier)
-						end
-						--check:SetTriState(v.tristate)
-						for i = 1, #valuesort do
-							local key = valuesort[i]
-							local value = GetOptionsMemberValue("get",v, options, path, appName, key)
-							control:SetItemValue(key,value)
-						end
-					else
-						control = gui:Create("InlineGroup")
-						control:SetLayout("Flow")
-						control:SetTitle(name)
-						control.width = "fill"
-
-						control:PauseLayout()
-						local width = GetOptionsMemberValue("width",v,options,path,appName)
-						for i = 1, #valuesort do
-							local value = valuesort[i]
-							local text = values[value]
-							local check = gui:Create("CheckBox")
-							check:SetLabel(text)
-							check:SetUserData('value', value)
-							check:SetUserData('text', text)
-							check:SetDisabled(disabled)
-							check:SetTriState(v.tristate)
-							check:SetValue(GetOptionsMemberValue("get",v, options, path, appName, value))
-							check:SetCallback("OnValueChanged",ActivateMultiControl)
-							InjectInfo(check, options, v, path, rootframe, appName)
-							control:AddChild(check)
-							if width == "double" then
-								check:SetWidth(width_multiplier * 2)
-							elseif width == "half" then
-								check:SetWidth(width_multiplier / 2)
-							elseif width == "full" then
-								check.width = "fill"
-							else
-								check:SetWidth(width_multiplier)
-							end
-						end
-						control:ResumeLayout()
-						control:DoLayout()
-
-						
-					end
-					
-					del(valuesort)
-
-				elseif v.type == "color" then
-					control = gui:Create("ColorPicker")
-					control:SetLabel(name)
-					control:SetHasAlpha(v.hasAlpha)
-					control:SetColor(GetOptionsMemberValue("get",v, options, path, appName))
-					control:SetCallback("OnValueChanged",ActivateControl)
-					control:SetCallback("OnValueConfirmed",ActivateControl)
-
-				elseif v.type == "keybinding" then
-					control = gui:Create("Keybinding")
-					control:SetLabel(name)
-					control:SetKey(GetOptionsMemberValue("get",v, options, path, appName))
-					control:SetCallback("OnKeyChanged",ActivateControl)
-
-				elseif v.type == "header" then
-					control = gui:Create("Heading")
-					control:SetText(name)
-					control.width = "fill"
-
-				elseif v.type == "description" then
-					control = gui:Create("Label")
-					control:SetText(name)
-					
-					local fontSize = GetOptionsMemberValue("fontSize",v, options, path, appName)
-					if fontSize == "medium" then
-						control:SetFontObject(GameFontHighlight)
-					elseif fontSize == "large" then
-						control:SetFontObject(GameFontHighlightLarge)
-					else -- small or invalid
-						control:SetFontObject(GameFontHighlightSmall)
-					end
-					
-					local imageCoords = GetOptionsMemberValue("imageCoords",v, options, path, appName)
-					local image, width, height = GetOptionsMemberValue("image",v, options, path, appName)
-					
-					if type(image) == 'string' then
-						if not width then
-							width = GetOptionsMemberValue("imageWidth",v, options, path, appName)
-						end
-						if not height then
-							height = GetOptionsMemberValue("imageHeight",v, options, path, appName)
-						end
-						if type(imageCoords) == 'table' then
-							control:SetImage(image, unpack(imageCoords))
-						else
-							control:SetImage(image)
-						end
-						if type(width) ~= "number" then
-							width = 32
-						end
-						if type(height) ~= "number" then
-							height = 32
-						end
-						control:SetImageSize(width, height)
-					end
-					local width = GetOptionsMemberValue("width",v,options,path,appName)
-					control.width = not width and "fill"
-				end
-
-				--Common Init
-				if control then
-					if control.width ~= "fill" then
-						local width = GetOptionsMemberValue("width",v,options,path,appName)
-						if width == "double" then
-							control:SetWidth(width_multiplier * 2)
-						elseif width == "half" then
-							control:SetWidth(width_multiplier / 2)
-						elseif width == "full" then
-							control.width = "fill"
-						else
-							control:SetWidth(width_multiplier)
-						end
-					end
-					if control.SetDisabled then
-						local disabled = CheckOptionDisabled(v, options, path, appName)
-						control:SetDisabled(disabled)
-					end
-
-					InjectInfo(control, options, v, path, rootframe, appName)
-					container:AddChild(control)
-				end
-				
-			end
-		end
-		tremove(path)
-	end
-	container:ResumeLayout()
-	container:DoLayout()
-	del(keySort)
-	del(opts)
-end
-
-local function BuildPath(path, ...)
-	for i = 1, select('#',...)  do
-		tinsert(path, (select(i,...)))
-	end
-end
-
-
-local function TreeOnButtonEnter(widget, event, uniquevalue, button)
-	local user = widget:GetUserDataTable()
-	if not user then return end
-	local options = user.options
-	local option = user.option
-	local path = user.path
-	local appName = user.appName
-	
-	local feedpath = new()
-	for i = 1, #path do
-		feedpath[i] = path[i]
-	end
-
-	BuildPath(feedpath, ("\001"):split(uniquevalue))
-	local group = options
-	for i = 1, #feedpath do
-		if not group then return end
-		group = GetSubOption(group, feedpath[i])
-	end
-
-	local name = GetOptionsMemberValue("name", group, options, feedpath, appName)
-	local desc = GetOptionsMemberValue("desc", group, options, feedpath, appName)
-	
-	GameTooltip:SetOwner(button, "ANCHOR_NONE")
-	if widget.type == "TabGroup" then
-		GameTooltip:SetPoint("BOTTOM",button,"TOP")
-	else
-		GameTooltip:SetPoint("LEFT",button,"RIGHT")
-	end
-
-	GameTooltip:SetText(name, 1, .82, 0, 1)
-	
-	if type(desc) == "string" then
-		GameTooltip:AddLine(desc, 1, 1, 1, 1)
-	end
-	
-	GameTooltip:Show()
-end
-
-local function TreeOnButtonLeave(widget, event, value, button)
-	GameTooltip:Hide()
-end
-
-
-local function GroupExists(appName, options, path, uniquevalue)
-	if not uniquevalue then return false end
-	
-	local feedpath = new()
-	local temppath = new()
-	for i = 1, #path do
-		feedpath[i] = path[i]
-	end
-	
-	BuildPath(feedpath, ("\001"):split(uniquevalue))
-	
-	local group = options
-	for i = 1, #feedpath do
-		local v = feedpath[i]
-		temppath[i] = v
-		group = GetSubOption(group, v)
-		
-		if not group or group.type ~= "group" or CheckOptionHidden(group, options, temppath, appName) then 
-			del(feedpath)
-			del(temppath)
-			return false 
-		end
-	end
-	del(feedpath)
-	del(temppath)
-	return true
-end
-
-local function GroupSelected(widget, event, uniquevalue)
-
-	local user = widget:GetUserDataTable()
-
-	local options = user.options
-	local option = user.option
-	local path = user.path
-	local rootframe = user.rootframe
-
-	local feedpath = new()
-	for i = 1, #path do
-		feedpath[i] = path[i]
-	end
-
-	BuildPath(feedpath, ("\001"):split(uniquevalue))
-	local group = options
-	for i = 1, #feedpath do
-		group = GetSubOption(group, feedpath[i])
-	end
-	widget:ReleaseChildren()
-	AceConfigDialog:FeedGroup(user.appName,options,widget,rootframe,feedpath)
-
-	del(feedpath)
-end
-
-
-
---[[
--- INTERNAL --
-This function will feed one group, and any inline child groups into the given container
-Select Groups will only have the selection control (tree, tabs, dropdown) fed in
-and have a group selected, this event will trigger the feeding of child groups
-
-Rules:
-	If the group is Inline, FeedOptions
-	If the group has no child groups, FeedOptions
-
-	If the group is a tab or select group, FeedOptions then add the Group Control
-	If the group is a tree group FeedOptions then
-		its parent isnt a tree group:  then add the tree control containing this and all child tree groups
-		if its parent is a tree group, its already a node on a tree
---]]
-
-function AceConfigDialog:FeedGroup(appName,options,container,rootframe,path, isRoot)
-	local group = options
-	--follow the path to get to the curent group
-	local inline
-	local grouptype, parenttype = options.childGroups, "none"
-
-
-	--temp path table to pass to callbacks as we traverse the tree
-	local temppath = new()
-	for i = 1, #path do
-		local v = path[i]
-		temppath[i] = v
-		group = GetSubOption(group, v)
-		inline = inline or pickfirstset(v.dialogInline,v.guiInline,v.inline, false)
-		parenttype = grouptype
-		grouptype = group.childGroups
-	end
-	del(temppath)
-
-	if not parenttype then
-		parenttype = "tree"
-	end
-
-	--check if the group has child groups
-	local hasChildGroups
-	for k, v in pairs(group.args) do
-		if v.type == "group" and not pickfirstset(v.dialogInline,v.guiInline,v.inline, false) and not CheckOptionHidden(v, options, path, appName) then
-			hasChildGroups = true
-		end
-	end
-	if group.plugins then
-		for plugin, t in pairs(group.plugins) do
-			for k, v in pairs(t) do
-				if v.type == "group" and not pickfirstset(v.dialogInline,v.guiInline,v.inline, false) and not CheckOptionHidden(v, options, path, appName) then
-					hasChildGroups = true
-				end
-			end
-		end
-	end
-
-	container:SetLayout("flow")
-	local scroll
-
-	--Add a scrollframe if we are not going to add a group control, this is the inverse of the conditions for that later on
-	if (not (hasChildGroups and not inline)) or (grouptype ~= "tab" and grouptype ~= "select" and (parenttype == "tree" and not isRoot)) then
-		if container.type ~= "InlineGroup" and container.type ~= "SimpleGroup" then
-			scroll = gui:Create("ScrollFrame")
-			scroll:SetLayout("flow")
-			scroll.width = "fill"
-			scroll.height = "fill"
-			container:SetLayout("fill")
-			container:AddChild(scroll)
-			container = scroll
-		end
-	end
-
-	FeedOptions(appName,options,container,rootframe,path,group,nil)
-
-	if scroll then
-		container:PerformLayout()
-		local status = self:GetStatusTable(appName, path)
-		if not status.scroll then
-			status.scroll = {}
-		end
-		scroll:SetStatusTable(status.scroll)
-	end
-
-	if hasChildGroups and not inline then
-		local name = GetOptionsMemberValue("name", group, options, path, appName)
-		if grouptype == "tab" then
-
-			local tab = gui:Create("TabGroup")
-			InjectInfo(tab, options, group, path, rootframe, appName)
-			tab:SetCallback("OnGroupSelected", GroupSelected)
-			tab:SetCallback("OnTabEnter", TreeOnButtonEnter)
-			tab:SetCallback("OnTabLeave", TreeOnButtonLeave)
-			
-			local status = AceConfigDialog:GetStatusTable(appName, path)
-			if not status.groups then
-				status.groups = {}
-			end
-			tab:SetStatusTable(status.groups)
-			tab.width = "fill"
-			tab.height = "fill"
-
-			local tabs = BuildGroups(group, options, path, appName)
-			tab:SetTabs(tabs)
-			tab:SetUserData("tablist", tabs)
-
-			for i = 1, #tabs do
-				local entry = tabs[i]
-				if not entry.disabled then
-					tab:SelectTab((GroupExists(appName, options, path,status.groups.selected) and status.groups.selected) or entry.value)
-					break
-				end
-			end
-			
-			container:AddChild(tab)
-
-		elseif grouptype == "select" then
-
-			local select = gui:Create("DropdownGroup")
-			select:SetTitle(name)
-			InjectInfo(select, options, group, path, rootframe, appName)
-			select:SetCallback("OnGroupSelected", GroupSelected)
-			local status = AceConfigDialog:GetStatusTable(appName, path)
-			if not status.groups then
-				status.groups = {}
-			end
-			select:SetStatusTable(status.groups)
-			local grouplist = BuildSelect(group, options, path, appName)
-			select:SetGroupList(grouplist)
-			select:SetUserData("grouplist", grouplist)
-			local firstgroup
-			for k, v in pairs(grouplist) do
-				if not firstgroup or k < firstgroup then
-					firstgroup = k
-				end
-			end
-			
-			if firstgroup then
-				select:SetGroup((GroupExists(appName, options, path,status.groups.selected) and status.groups.selected) or firstgroup)
-			end
-			
-			select.width = "fill"
-			select.height = "fill"
-
-			container:AddChild(select)
-
-		--assume tree group by default
-		--if parenttype is tree then this group is already a node on that tree
-		elseif (parenttype ~= "tree") or isRoot then
-			local tree = gui:Create("TreeGroup")
-			InjectInfo(tree, options, group, path, rootframe, appName)
-			tree:EnableButtonTooltips(false)
-			
-			tree.width = "fill"
-			tree.height = "fill"
-
-			tree:SetCallback("OnGroupSelected", GroupSelected)
-			tree:SetCallback("OnButtonEnter", TreeOnButtonEnter)
-			tree:SetCallback("OnButtonLeave", TreeOnButtonLeave)
-			
-			local status = AceConfigDialog:GetStatusTable(appName, path)
-			if not status.groups then
-				status.groups = {}
-			end
-			local treedefinition = BuildGroups(group, options, path, appName, true)
-			tree:SetStatusTable(status.groups)
-
-			tree:SetTree(treedefinition)
-			tree:SetUserData("tree",treedefinition)
-
-			for i = 1, #treedefinition do
-				local entry = treedefinition[i]
-				if not entry.disabled then
-					tree:SelectByValue((GroupExists(appName, options, path,status.groups.selected) and status.groups.selected) or entry.value)
-					break
-				end
-			end
-
-			container:AddChild(tree)
-		end
-	end
-end
-
-local old_CloseSpecialWindows
-
-
-local function RefreshOnUpdate(this)
-	for appName in pairs(this.closing) do
-		if AceConfigDialog.OpenFrames[appName] then
-			AceConfigDialog.OpenFrames[appName]:Hide()
-		end
-		if AceConfigDialog.BlizOptions and AceConfigDialog.BlizOptions[appName] then
-			for key, widget in pairs(AceConfigDialog.BlizOptions[appName]) do
-				if not widget:IsVisible() then
-					widget:ReleaseChildren()
-				end
-			end
-		end
-		this.closing[appName] = nil
-	end
-	
-	if this.closeAll then
-		for k, v in pairs(AceConfigDialog.OpenFrames) do
-			v:Hide()
-		end
-		this.closeAll = nil
-	end
-	
-	for appName in pairs(this.apps) do
-		if AceConfigDialog.OpenFrames[appName] then
-			local user = AceConfigDialog.OpenFrames[appName]:GetUserDataTable()
-			AceConfigDialog:Open(appName, unpack(user.basepath or emptyTbl))
-		end
-		if AceConfigDialog.BlizOptions and AceConfigDialog.BlizOptions[appName] then
-			for key, widget in pairs(AceConfigDialog.BlizOptions[appName]) do
-				local user = widget:GetUserDataTable()
-				if widget:IsVisible() then
-					AceConfigDialog:Open(widget:GetUserData('appName'), widget, unpack(user.basepath or emptyTbl))
-				end
-			end
-		end
-		this.apps[appName] = nil
-	end
-	this:SetScript("OnUpdate", nil)
-end
-
--- Upgrade the OnUpdate script as well, if needed.
-if AceConfigDialog.frame:GetScript("OnUpdate") then
-	AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate)
-end
-
---- Close all open options windows
-function AceConfigDialog:CloseAll()
-	AceConfigDialog.frame.closeAll = true
-	AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate)
-	if next(self.OpenFrames) then
-		return true
-	end
-end
-
---- Close a specific options window.
--- @param appName The application name as given to `:RegisterOptionsTable()`
-function AceConfigDialog:Close(appName)
-	if self.OpenFrames[appName] then
-		AceConfigDialog.frame.closing[appName] = true
-		AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate)
-		return true
-	end
-end
-
--- Internal -- Called by AceConfigRegistry
-function AceConfigDialog:ConfigTableChanged(event, appName)
-	AceConfigDialog.frame.apps[appName] = true
-	AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate)
-end
-
-reg.RegisterCallback(AceConfigDialog, "ConfigTableChange", "ConfigTableChanged")
-
---- Sets the default size of the options window for a specific application.
--- @param appName The application name as given to `:RegisterOptionsTable()`
--- @param width The default width
--- @param height The default height
-function AceConfigDialog:SetDefaultSize(appName, width, height)
-	local status = AceConfigDialog:GetStatusTable(appName)
-	if type(width) == "number" and type(height) == "number" then
-		status.width = width
-		status.height = height
-	end
-end
-
---- Open an option window at the specified path (if any).
--- This function can optionally feed the group into a pre-created container
--- instead of creating a new container frame.
--- @paramsig appName [, container][, ...]
--- @param appName The application name as given to `:RegisterOptionsTable()`
--- @param container An optional container frame to feed the options into
--- @param ... The path to open after creating the options window (see `:SelectGroup` for details)
-function AceConfigDialog:Open(appName, container, ...)
-	if not old_CloseSpecialWindows then
-		old_CloseSpecialWindows = CloseSpecialWindows
-		CloseSpecialWindows = function()
-			local found = old_CloseSpecialWindows()
-			return self:CloseAll() or found
-		end
-	end
-	local app = reg:GetOptionsTable(appName)
-	if not app then
-		error(("%s isn't registed with AceConfigRegistry, unable to open config"):format(appName), 2)
-	end
-	local options = app("dialog", MAJOR)
-
-	local f
-	
-	local path = new()
-	local name = GetOptionsMemberValue("name", options, options, path, appName)
-	
-	--If an optional path is specified add it to the path table before feeding the options
-	--as container is optional as well it may contain the first element of the path
-	if type(container) == "string" then
-		tinsert(path, container)
-		container = nil
-	end
-	for n = 1, select('#',...) do
-		tinsert(path, (select(n, ...)))
-	end
-	
-	--if a container is given feed into that
-	if container then
-		f = container
-		f:ReleaseChildren()
-		f:SetUserData('appName', appName)
-		f:SetUserData('iscustom', true)
-		if #path > 0 then
-			f:SetUserData('basepath', copy(path))
-		end
-		local status = AceConfigDialog:GetStatusTable(appName)
-		if not status.width then
-			status.width =  700
-		end
-		if not status.height then
-			status.height = 500
-		end
-		if f.SetStatusTable then
-			f:SetStatusTable(status)
-		end
-		if f.SetTitle then
-			f:SetTitle(name or "")
-		end
-	else
-		if not self.OpenFrames[appName] then
-			f = gui:Create("Frame")
-			self.OpenFrames[appName] = f
-		else
-			f = self.OpenFrames[appName]
-		end
-		f:ReleaseChildren()
-		f:SetCallback("OnClose", FrameOnClose)
-		f:SetUserData('appName', appName)
-		if #path > 0 then
-			f:SetUserData('basepath', copy(path))
-		end
-		f:SetTitle(name or "")
-		local status = AceConfigDialog:GetStatusTable(appName)
-		f:SetStatusTable(status)
-	end
-
-	self:FeedGroup(appName,options,f,f,path,true)
-	if f.Show then
-		f:Show()
-	end
-	del(path)
-end
-
--- convert pre-39 BlizOptions structure to the new format
-if oldminor and oldminor < 39 and AceConfigDialog.BlizOptions then
-	local old = AceConfigDialog.BlizOptions
-	local new = {}
-	for key, widget in pairs(old) do
-		local appName = widget:GetUserData('appName')
-		if not new[appName] then new[appName] = {} end
-		new[appName][key] = widget
-	end
-	AceConfigDialog.BlizOptions = new
-else
-	AceConfigDialog.BlizOptions = AceConfigDialog.BlizOptions or {}
-end
-
-local function FeedToBlizPanel(widget, event)
-	local path = widget:GetUserData('path')
-	AceConfigDialog:Open(widget:GetUserData('appName'), widget, unpack(path or emptyTbl))
-end
-
-local function ClearBlizPanel(widget, event)
-	local appName = widget:GetUserData('appName')
-	AceConfigDialog.frame.closing[appName] = true
-	AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate)
-end
-
---- Add an option table into the Blizzard Interface Options panel.
--- You can optionally supply a descriptive name to use and a parent frame to use,
--- as well as a path in the options table.\\
--- If no name is specified, the appName will be used instead.
---
--- If you specify a proper `parent` (by name), the interface options will generate a
--- tree layout. Note that only one level of children is supported, so the parent always
--- has to be a head-level note.
---
--- This function returns a reference to the container frame registered with the Interface
--- Options. You can use this reference to open the options with the API function
--- `InterfaceOptionsFrame_OpenToCategory`.
--- @param appName The application name as given to `:RegisterOptionsTable()`
--- @param name A descriptive name to display in the options tree (defaults to appName)
--- @param parent The parent to use in the interface options tree.
--- @param ... The path in the options table to feed into the interface options panel.
--- @return The reference to the frame registered into the Interface Options. 
-function AceConfigDialog:AddToBlizOptions(appName, name, parent, ...)
-	local BlizOptions = AceConfigDialog.BlizOptions
-	
-	local key = appName
-	for n = 1, select('#', ...) do
-		key = key..'\001'..select(n, ...)
-	end
-	
-	if not BlizOptions[appName] then
-		BlizOptions[appName] = {}
-	end
-	
-	if not BlizOptions[appName][key] then
-		local group = gui:Create("BlizOptionsGroup")
-		BlizOptions[appName][key] = group
-		group:SetName(name or appName, parent)
-
-		group:SetTitle(name or appName)
-		group:SetUserData('appName', appName)
-		if select('#', ...) > 0 then
-			local path = {}
-			for n = 1, select('#',...) do
-				tinsert(path, (select(n, ...)))
-			end
-			group:SetUserData('path', path)
-		end
-		group:SetCallback("OnShow", FeedToBlizPanel)
-		group:SetCallback("OnHide", ClearBlizPanel)
-		InterfaceOptions_AddCategory(group.frame)
-		return group.frame
-	else
-		error(("%s has already been added to the Blizzard Options Window with the given path"):format(appName), 2)
-	end
-end

--- a/Libs/AceConfig-3.0/AceConfigDialog-3.0/AceConfigDialog-3.0.xml	Thu May 20 22:34:37 2010 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -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="AceConfigDialog-3.0.lua"/>
-</Ui>
\ No newline at end of file