initial commit

Changelog.lua

@@ -0,0 +1,36 @@
+HMGT_Changelog = {
+    releases = {
+        enUS = {
+            {
+                version = "2.0",
+                entries = {
+                    "The tracker system was rebuilt around individual tracker configs instead of the previous fixed tracker modules.",
+                    "You can now create custom trackers and assign your own spell category combinations to each tracker.",
+                    "Party-attached demo/test previews now only create tracker frames when matching party frames are actually available.",
+                    "Party-frame attachment now aligns tracker content against the visible bar/icon area instead of the outer frame bounds, so the default Y offset lines up cleanly again.",
+                    "Upward bar growth was reworked so bars anchor above the tracker title and grow upward consistently in normal layouts and party-attached layouts.",
+                    "Tracker category selections now persist correctly across /reload and are no longer repopulated from default tracker entries.",
+                    "Removing a tracker now asks for confirmation in the options UI before deleting it.",
+                    "Use Class Colours now correctly keeps progress bars in class color, while the fallback cooldown coloring now follows red, then yellow, then green thresholds.",
+                    "Bar rows now use isolated status bar textures so color changes no longer bleed from one active bar into another.",
+                },
+            },
+        },
+        deDE = {
+            {
+                version = "2.0",
+                entries = {
+                    "Das Tracker-System wurde auf einzelne Tracker-Konfigurationen umgebaut statt auf die bisherigen fest verdrahteten Tracker-Module.",
+                    "Es koennen jetzt eigene Custom-Tracker angelegt und mit frei waehlbaren Zauber-Kategorie-Kombinationen konfiguriert werden.",
+                    "Demo-/Test-Vorschauen mit Party-Attach erzeugen Tracker-Frames jetzt nur noch dann, wenn passende Party-Frames auch wirklich verfuegbar sind.",
+                    "Das Party-Attach richtet den sichtbaren Tracker-Inhalt jetzt am echten Bar-/Icon-Bereich statt an den aeusseren Frame-Grenzen aus, sodass der Standard-Y-Offset wieder sauber passt.",
+                    "Aufwaerts wachsende Bars wurden ueberarbeitet: sie werden jetzt oberhalb des Tracker-Titels verankert und wachsen in normalen Layouts wie auch bei Party-Attach konsistent nach oben.",
+                    "Tracker-Kategorien bleiben nach /reload jetzt korrekt gespeichert und werden nicht mehr aus Default-Tracker-Eintraegen wieder aufgefuellt.",
+                    "Das Entfernen eines Trackers fragt in den Optionen jetzt erst nach einer Bestaetigung.",
+                    "Use Class Colours faerbt Progress-Bars jetzt korrekt in Klassenfarben; ohne diese Option nutzt die Restzeit-Faerbung jetzt rot, dann gelb, dann gruen.",
+                    "Bar-Zeilen verwenden jetzt eigene StatusBar-Texturen, damit Farbwechsel nicht mehr von einer aktiven Bar auf eine andere ueberlaufen.",
+                },
+            },
+        },
+    },
+}

Core/AceWindow.lua

@@ -0,0 +1,176 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = _G[ADDON_NAME]
+if not HMGT then return end
+
+local AceGUI = LibStub("AceGUI-3.0", true)
+if not AceGUI then return end
+
+local WindowPrototype = {}
+
+local function ResolveFrame(target)
+    if not target then
+        return nil
+    end
+    if type(target) == "table" and target.frame then
+        return target.frame
+    end
+    return target
+end
+
+function WindowPrototype:GetContent()
+    return self.content
+end
+
+function WindowPrototype:SetTitle(text)
+    if self.widget and self.widget.SetTitle then
+        self.widget:SetTitle(tostring(text or ""))
+    end
+end
+
+function WindowPrototype:SetStatusText(text)
+    if self.widget and self.widget.SetStatusText then
+        self.widget:SetStatusText(tostring(text or ""))
+    end
+end
+
+function WindowPrototype:Show()
+    if self.widget and self.widget.Show then
+        self.widget:Show()
+    elseif self.frame then
+        self.frame:Show()
+    end
+end
+
+function WindowPrototype:Hide()
+    if self.widget and self.widget.Hide then
+        self.widget:Hide()
+    elseif self.frame then
+        self.frame:Hide()
+    end
+end
+
+function WindowPrototype:Raise()
+    if self.frame and self.frame.Raise then
+        self.frame:Raise()
+    end
+end
+
+function WindowPrototype:IsShown()
+    return self.frame and self.frame:IsShown() or false
+end
+
+function WindowPrototype:RegisterMinimizeTarget(target)
+    self.minimizeTargets = self.minimizeTargets or {}
+    self.minimizeTargets[#self.minimizeTargets + 1] = target
+end
+
+function WindowPrototype:SetMinimized(minimized)
+    minimized = minimized and true or false
+    if not self.minimizable then
+        minimized = false
+    end
+
+    self.statusTable = self.statusTable or {}
+    self.statusTable.minimized = minimized
+    if minimized then
+        self.statusTable.restoreHeight = self.statusTable.height or (self.frame and self.frame:GetHeight()) or self.height or 360
+    end
+
+    local targetHeight = minimized
+        and (self.minimizedHeight or 64)
+        or (self.statusTable.restoreHeight or self.statusTable.height or self.height or 360)
+
+    if self.widget and self.widget.EnableResize then
+        self.widget:EnableResize(not minimized)
+        self.widget:SetHeight(targetHeight)
+    elseif self.frame then
+        self.frame:SetHeight(targetHeight)
+    end
+
+    if self.minimizeButton and self.minimizeButton.SetText then
+        self.minimizeButton:SetText(minimized and "+" or "-")
+    end
+
+    for _, target in ipairs(self.minimizeTargets or {}) do
+        local frame = ResolveFrame(target)
+        if frame and frame.SetShown then
+            frame:SetShown(not minimized)
+        end
+    end
+end
+
+function WindowPrototype:ToggleMinimized()
+    self:SetMinimized(not (self.statusTable and self.statusTable.minimized))
+end
+
+function HMGT:CreateAceWindow(key, options)
+    self._aceWindows = self._aceWindows or {}
+    if self._aceWindows[key] then
+        return self._aceWindows[key]
+    end
+
+    if not AceGUI then
+        return nil
+    end
+
+    options = options or {}
+    local statusTable = options.statusTable or {}
+    local widget = AceGUI:Create("Frame")
+    widget:SetTitle(tostring(options.title or ""))
+    widget:SetStatusText(tostring(options.statusText or ""))
+    widget:SetStatusTable(statusTable)
+    widget:SetWidth(tonumber(options.width) or 800)
+    widget:SetHeight(tonumber(options.height) or 360)
+    widget:EnableResize(options.resizable ~= false)
+    widget.frame:SetClampedToScreen(true)
+    widget.frame:SetToplevel(true)
+    widget.frame:SetFrameStrata(options.strata or "FULLSCREEN_DIALOG")
+    widget:Hide()
+    widget:SetCallback("OnClose", function()
+        widget:Hide()
+    end)
+
+    local window = setmetatable({
+        key = key,
+        widget = widget,
+        frame = widget.frame,
+        content = widget.content,
+        statusTable = statusTable,
+        width = tonumber(options.width) or 800,
+        height = tonumber(options.height) or 360,
+        minimizable = options.minimizable == true,
+        minimizedHeight = tonumber(options.minimizedHeight) or 64,
+        minimizeTargets = {},
+    }, { __index = WindowPrototype })
+
+    if options.backgroundTexture then
+        local texture = window.content:CreateTexture(nil, "BACKGROUND")
+        texture:SetPoint("CENTER", window.content, "CENTER", tonumber(options.backgroundOffsetX) or 0, tonumber(options.backgroundOffsetY) or 0)
+        texture:SetSize(tonumber(options.backgroundWidth) or 220, tonumber(options.backgroundHeight) or 120)
+        texture:SetTexture(tostring(options.backgroundTexture))
+        texture:SetAlpha(tonumber(options.backgroundAlpha) or 0.12)
+        window.backgroundTexture = texture
+    end
+
+    if window.minimizable then
+        local minimizeButton = AceGUI:Create("Button")
+        minimizeButton:SetText((statusTable and statusTable.minimized) and "+" or "-")
+        minimizeButton:SetWidth(24)
+        minimizeButton:SetCallback("OnClick", function()
+            window:ToggleMinimized()
+        end)
+        minimizeButton.frame:SetParent(window.frame)
+        minimizeButton.frame:ClearAllPoints()
+        minimizeButton.frame:SetPoint("TOPRIGHT", window.frame, "TOPRIGHT", -34, -4)
+        minimizeButton.frame:SetHeight(20)
+        minimizeButton.frame:Show()
+        window.minimizeButton = minimizeButton
+    end
+
+    self._aceWindows[key] = window
+    if options.onCreate then
+        options.onCreate(window, window.content, widget)
+    end
+    window:SetMinimized(statusTable and statusTable.minimized)
+    return window
+end

Core/DebugWindow.lua

@@ -0,0 +1,486 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = _G[ADDON_NAME]
+if not HMGT then return end
+
+local L = HMGT.L or LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME)
+local AceGUI = LibStub("AceGUI-3.0", true)
+
+local function GetOrderedDebugLevels()
+    return { "error", "info", "verbose" }
+end
+
+local function GetOrderedDebugScopes()
+    local values = HMGT:GetDebugScopeOptions() or {}
+    local names = { "ALL" }
+    for scope in pairs(values) do
+        if scope ~= "ALL" then
+            names[#names + 1] = scope
+        end
+    end
+    table.sort(names, function(a, b)
+        if a == "ALL" then return true end
+        if b == "ALL" then return false end
+        return tostring(values[a] or a) < tostring(values[b] or b)
+    end)
+    return names, values
+end
+
+local function SetFilterButtonText(buttonWidget, prefix, valueLabel)
+    if not buttonWidget then
+        return
+    end
+    buttonWidget:SetText(string.format("%s: %s", tostring(prefix or ""), tostring(valueLabel or "")))
+end
+
+local function AdvanceDebugLevel(step)
+    local levels = GetOrderedDebugLevels()
+    local current = HMGT:GetConfiguredDebugLevel()
+    local nextIndex = 1
+    for index, value in ipairs(levels) do
+        if value == current then
+            nextIndex = index + (step or 1)
+            break
+        end
+    end
+    if nextIndex < 1 then
+        nextIndex = #levels
+    elseif nextIndex > #levels then
+        nextIndex = 1
+    end
+    HMGT.db.profile.debugLevel = levels[nextIndex]
+    HMGT:RefreshDebugWindow()
+end
+
+local function AdvanceDebugScope(step)
+    local scopes, labels = GetOrderedDebugScopes()
+    local current = (HMGT.db and HMGT.db.profile and HMGT.db.profile.debugScope) or "ALL"
+    local nextIndex = 1
+    for index, value in ipairs(scopes) do
+        if value == current then
+            nextIndex = index + (step or 1)
+            break
+        end
+    end
+    if nextIndex < 1 then
+        nextIndex = #scopes
+    elseif nextIndex > #scopes then
+        nextIndex = 1
+    end
+    HMGT.db.profile.debugScope = scopes[nextIndex]
+    HMGT:RefreshDebugWindow()
+end
+
+function HMGT:SetDebugWindowMinimized(minimized)
+    local frame = self.debugWindow
+    if not frame then
+        return
+    end
+
+    minimized = minimized and true or false
+    self.debugWindowStatus = self.debugWindowStatus or {
+        width = 860,
+        height = 340,
+    }
+    self.debugWindowStatus.minimized = minimized
+
+    local collapsedHeight = 64
+    if minimized then
+        self.debugWindowStatus.restoreHeight = self.debugWindowStatus.height or frame:GetHeight() or 340
+    end
+
+    local targetHeight = minimized
+        and collapsedHeight
+        or (self.debugWindowStatus.restoreHeight or self.debugWindowStatus.height or 340)
+
+    if frame.aceWidget then
+        frame.aceWidget:EnableResize(not minimized)
+        frame.aceWidget:SetHeight(targetHeight)
+    else
+        frame:SetHeight(targetHeight)
+    end
+
+    if frame.minimizeButton then
+        frame.minimizeButton:SetText(minimized and "+" or "-")
+    end
+    if frame.clearButton then
+        local buttonFrame = frame.clearButton.frame or frame.clearButton
+        buttonFrame:SetShown(not minimized)
+    end
+    if frame.selectButton then
+        local buttonFrame = frame.selectButton.frame or frame.selectButton
+        buttonFrame:SetShown(not minimized)
+    end
+    if frame.levelFilter then
+        local filterFrame = frame.levelFilter.frame or frame.levelFilter
+        filterFrame:SetShown(not minimized)
+    end
+    if frame.scopeFilter then
+        local filterFrame = frame.scopeFilter.frame or frame.scopeFilter
+        filterFrame:SetShown(not minimized)
+    end
+    if frame.logWidget then
+        frame.logWidget.frame:SetShown(not minimized)
+    end
+    if frame.scrollBG then
+        frame.scrollBG:SetShown(not minimized)
+    end
+
+    if not minimized then
+        self:RefreshDebugWindow()
+    end
+end
+
+function HMGT:ToggleDebugWindowMinimized()
+    self:SetDebugWindowMinimized(not (self.debugWindowStatus and self.debugWindowStatus.minimized))
+end
+
+function HMGT:EnsureDebugWindow()
+    if self.debugWindow then
+        return self.debugWindow
+    end
+
+    local frameWidget
+    if AceGUI then
+        frameWidget = AceGUI:Create("Frame")
+        self.debugWindowStatus = self.debugWindowStatus or {
+            width = 860,
+            height = 340,
+        }
+        frameWidget:SetTitle(L["DEBUG_WINDOW_TITLE"] or "HMGT Debug Console")
+        frameWidget:SetStatusText(L["DEBUG_WINDOW_HINT"] or "Mouse wheel scrolls, Ctrl+A selects all, Ctrl+C copies selected text")
+        frameWidget:SetStatusTable(self.debugWindowStatus)
+        frameWidget:SetWidth(self.debugWindowStatus.width or 860)
+        frameWidget:SetHeight(self.debugWindowStatus.height or 340)
+        frameWidget:EnableResize(true)
+        frameWidget.frame:SetClampedToScreen(true)
+        frameWidget.frame:SetToplevel(true)
+        frameWidget.frame:SetFrameStrata("FULLSCREEN_DIALOG")
+        frameWidget:Hide()
+    end
+
+    local frame = frameWidget and frameWidget.frame or CreateFrame("Frame", "HMGT_DebugWindow", UIParent, "BackdropTemplate")
+    if not frameWidget then
+        frame:SetSize(860, 340)
+        frame:SetPoint("CENTER", UIParent, "CENTER", 0, 0)
+        frame:SetFrameStrata("DIALOG")
+        frame:SetClampedToScreen(true)
+        frame:SetMovable(true)
+        frame:EnableMouse(true)
+        frame:RegisterForDrag("LeftButton")
+        frame:SetScript("OnDragStart", function(selfFrame) selfFrame:StartMoving() end)
+        frame:SetScript("OnDragStop", function(selfFrame) selfFrame:StopMovingOrSizing() end)
+        frame:SetBackdrop({
+            bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background-Dark",
+            edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
+            edgeSize = 12,
+            insets = { left = 3, right = 3, top = 3, bottom = 3 },
+        })
+        frame:SetBackdropColor(0.05, 0.05, 0.06, 0.95)
+        frame:SetBackdropBorderColor(0.35, 0.55, 0.85, 1)
+        frame:Hide()
+
+        local title = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
+        title:SetPoint("TOPLEFT", frame, "TOPLEFT", 14, -12)
+        title:SetText(L["DEBUG_WINDOW_TITLE"] or "HMGT Debug Console")
+        frame.title = title
+
+        local closeButton = CreateFrame("Button", nil, frame, "UIPanelCloseButton")
+        closeButton:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -5, -5)
+        frame.closeButton = closeButton
+
+        local minimizeButton = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate")
+        minimizeButton:SetSize(22, 20)
+        minimizeButton:SetPoint("TOPRIGHT", closeButton, "TOPLEFT", -2, 0)
+        minimizeButton:SetText((self.debugWindowStatus and self.debugWindowStatus.minimized) and "+" or "-")
+        minimizeButton:SetScript("OnClick", function()
+            HMGT:ToggleDebugWindowMinimized()
+        end)
+        frame.minimizeButton = minimizeButton
+    end
+
+    frame.aceWidget = frameWidget
+
+    if frameWidget and AceGUI then
+        local content = frameWidget.content
+
+        local minimizeButton = AceGUI:Create("Button")
+        minimizeButton:SetText((self.debugWindowStatus and self.debugWindowStatus.minimized) and "+" or "-")
+        minimizeButton:SetWidth(24)
+        minimizeButton:SetCallback("OnClick", function()
+            HMGT:ToggleDebugWindowMinimized()
+        end)
+        minimizeButton.frame:SetParent(frame)
+        minimizeButton.frame:ClearAllPoints()
+        minimizeButton.frame:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -34, -4)
+        minimizeButton.frame:SetHeight(20)
+        minimizeButton.frame:Show()
+        frame.minimizeButton = minimizeButton
+
+        local clearButton = AceGUI:Create("Button")
+        clearButton:SetText(L["OPT_DEBUG_CLEAR"] or "Clear log")
+        clearButton:SetWidth(120)
+        clearButton:SetCallback("OnClick", function()
+            HMGT:ClearDebugLog()
+        end)
+        clearButton.frame:SetParent(content)
+        clearButton.frame:ClearAllPoints()
+        clearButton.frame:SetPoint("TOPRIGHT", content, "TOPRIGHT", 0, -2)
+        clearButton.frame:Show()
+        frame.clearButton = clearButton
+
+        local selectButton = AceGUI:Create("Button")
+        selectButton:SetText(L["OPT_DEBUG_SELECT_ALL"] or "Select all")
+        selectButton:SetWidth(120)
+        selectButton:SetCallback("OnClick", function()
+            if frame.editBox then
+                frame.editBox:SetFocus()
+                frame.editBox:HighlightText(0)
+            end
+        end)
+        selectButton.frame:SetParent(content)
+        selectButton.frame:ClearAllPoints()
+        selectButton.frame:SetPoint("TOPRIGHT", clearButton.frame, "TOPLEFT", -6, 0)
+        selectButton.frame:Show()
+        frame.selectButton = selectButton
+
+        local levelFilter = AceGUI:Create("Button")
+        levelFilter:SetWidth(150)
+        levelFilter:SetCallback("OnClick", function()
+            AdvanceDebugLevel(1)
+        end)
+        levelFilter.frame:SetParent(content)
+        levelFilter.frame:ClearAllPoints()
+        levelFilter.frame:SetPoint("TOPLEFT", content, "TOPLEFT", 0, 0)
+        levelFilter.frame:Show()
+        frame.levelFilter = levelFilter
+
+        local scopeFilter = AceGUI:Create("Button")
+        scopeFilter:SetWidth(180)
+        scopeFilter:SetCallback("OnClick", function()
+            AdvanceDebugScope(1)
+        end)
+        scopeFilter.frame:SetParent(content)
+        scopeFilter.frame:ClearAllPoints()
+        scopeFilter.frame:SetPoint("TOPLEFT", levelFilter.frame, "TOPRIGHT", 8, 0)
+        scopeFilter.frame:Show()
+        frame.scopeFilter = scopeFilter
+
+        local logWidget = AceGUI:Create("MultiLineEditBox")
+        logWidget:SetLabel("")
+        logWidget:DisableButton(true)
+        logWidget:SetNumLines(18)
+        logWidget:SetText("")
+        logWidget.frame:SetParent(content)
+        logWidget.frame:ClearAllPoints()
+        logWidget.frame:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -54)
+        logWidget.frame:SetPoint("BOTTOMRIGHT", content, "BOTTOMRIGHT", 0, 0)
+        logWidget.frame:Show()
+        logWidget:SetCallback("OnTextChanged", function()
+            HMGT:RefreshDebugWindow()
+        end)
+        logWidget.editBox:SetScript("OnKeyDown", function(selfBox, key)
+            if IsControlKeyDown() and (key == "A" or key == "a") then
+                selfBox:HighlightText(0)
+            end
+        end)
+        frame.logWidget = logWidget
+        frame.editBox = logWidget.editBox
+        frame.scrollFrame = logWidget.scrollFrame
+
+        self.debugWindow = frame
+        self:SetDebugWindowMinimized(self.debugWindowStatus and self.debugWindowStatus.minimized)
+        return frame
+    end
+
+    local clearButton = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate")
+    clearButton:SetSize(90, 22)
+    clearButton:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -30, -6)
+    clearButton:SetText(L["OPT_DEBUG_CLEAR"] or "Clear log")
+    clearButton:SetScript("OnClick", function()
+        HMGT:ClearDebugLog()
+    end)
+    frame.clearButton = clearButton
+
+    local selectButton = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate")
+    selectButton:SetSize(90, 22)
+    selectButton:SetPoint("TOPRIGHT", clearButton, "TOPLEFT", -6, 0)
+    selectButton:SetText(L["OPT_DEBUG_SELECT_ALL"] or "Select all")
+    selectButton:SetScript("OnClick", function()
+        if frame.editBox then
+            frame.editBox:SetFocus()
+            frame.editBox:HighlightText(0)
+        end
+    end)
+    frame.selectButton = selectButton
+
+    local scopeFilter = CreateFrame("Frame", nil, frame)
+    scopeFilter:SetSize(170, 22)
+    scopeFilter:SetPoint("TOPLEFT", frame, "TOPLEFT", 16, -8)
+    frame.scopeFilter = scopeFilter
+
+    local scrollBG = CreateFrame("Frame", nil, frame, "BackdropTemplate")
+    scrollBG:SetBackdrop({
+        bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
+        edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
+        edgeSize = 16,
+        insets = { left = 4, right = 3, top = 4, bottom = 3 },
+    })
+    scrollBG:SetBackdropColor(0, 0, 0, 0.95)
+    scrollBG:SetBackdropBorderColor(0.4, 0.4, 0.4, 1)
+    scrollBG:SetPoint("TOPLEFT", frame, "TOPLEFT", 14, -36)
+    scrollBG:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -30, 14)
+    frame.scrollBG = scrollBG
+
+    local scrollFrame = CreateFrame("ScrollFrame", nil, scrollBG, "UIPanelScrollFrameTemplate")
+    scrollFrame:SetPoint("TOPLEFT", scrollBG, "TOPLEFT", 6, -6)
+    scrollFrame:SetPoint("BOTTOMRIGHT", scrollBG, "BOTTOMRIGHT", -27, 4)
+    scrollFrame:EnableMouseWheel(true)
+    scrollFrame:SetScript("OnMouseWheel", function(selfMsg, delta)
+        if delta > 0 then
+            selfMsg:SetVerticalScroll(math.max(0, selfMsg:GetVerticalScroll() - 42))
+        else
+            selfMsg:SetVerticalScroll(selfMsg:GetVerticalScroll() + 42)
+        end
+    end)
+    frame.scrollFrame = scrollFrame
+
+    local editBox = CreateFrame("EditBox", nil, scrollFrame)
+    editBox:SetMultiLine(true)
+    editBox:SetAutoFocus(false)
+    editBox:SetFontObject(ChatFontNormal)
+    editBox:SetWidth(780)
+    editBox:SetTextInsets(6, 6, 6, 6)
+    editBox:EnableMouse(true)
+    editBox:SetScript("OnEscapePressed", function(selfBox)
+        selfBox:ClearFocus()
+    end)
+    editBox:SetScript("OnKeyDown", function(selfBox, key)
+        if IsControlKeyDown() and (key == "A" or key == "a") then
+            selfBox:HighlightText(0)
+        end
+    end)
+    editBox:SetScript("OnTextChanged", function(selfBox, userInput)
+        if userInput then
+            HMGT:RefreshDebugWindow()
+        else
+            selfBox:SetCursorPosition(selfBox:GetNumLetters())
+            selfBox:SetHeight(math.max(scrollFrame:GetHeight(), HMGT:GetDebugWindowTextHeight(frame, selfBox:GetText()) + 16))
+            scrollFrame:UpdateScrollChildRect()
+        end
+    end)
+    editBox:SetScript("OnMouseUp", function(selfBox)
+        selfBox:SetFocus()
+    end)
+    scrollFrame:SetScrollChild(editBox)
+    frame.editBox = editBox
+
+    local measureText = frame:CreateFontString(nil, "ARTWORK", "ChatFontNormal")
+    measureText:SetJustifyH("LEFT")
+    measureText:SetJustifyV("TOP")
+    if measureText.SetSpacing then
+        measureText:SetSpacing(2)
+    end
+    measureText:SetWidth(768)
+    frame.measureText = measureText
+
+    self.debugWindow = frame
+    self:SetDebugWindowMinimized(self.debugWindowStatus and self.debugWindowStatus.minimized)
+    return frame
+end
+
+function HMGT:GetDebugWindowTextHeight(frame, text)
+    if not frame or not frame.measureText then
+        return 0
+    end
+
+    local width = 768
+    if frame.editBox then
+        width = math.max(1, (frame.editBox:GetWidth() or width) - 12)
+    end
+    frame.measureText:SetWidth(width)
+    frame.measureText:SetText(text or "")
+    return frame.measureText:GetStringHeight()
+end
+
+function HMGT:RefreshDebugWindow()
+    local frame = self:EnsureDebugWindow()
+    if not frame then
+        return
+    end
+
+    local filtered = self:GetFilteredDebugBuffer() or self.debugBuffer or {}
+    local text = table.concat(filtered, "\n")
+    if frame.logWidget and frame.editBox then
+        if frame.levelFilter then
+            local levelOptions = self:GetDebugLevelOptions()
+            SetFilterButtonText(frame.levelFilter, L["OPT_DEBUG_LEVEL"] or "Level", levelOptions[self:GetConfiguredDebugLevel()])
+        end
+        if frame.scopeFilter then
+            local scopeOptions = self:GetDebugScopeOptions()
+            local currentScope = (self.db and self.db.profile and self.db.profile.debugScope) or "ALL"
+            SetFilterButtonText(frame.scopeFilter, L["OPT_DEBUG_SCOPE"] or "Module", scopeOptions[currentScope] or currentScope)
+        end
+        frame.logWidget:SetText(text)
+        frame.editBox:SetCursorPosition(frame.editBox:GetNumLetters())
+        return
+    end
+
+    if not frame.editBox then
+        return
+    end
+
+    frame.editBox:SetText(text)
+    frame.editBox:SetCursorPosition(#text)
+    frame.editBox:SetHeight(math.max(frame.scrollFrame:GetHeight(), self:GetDebugWindowTextHeight(frame, text) + 16))
+    frame.scrollFrame:SetVerticalScroll(math.max(0, frame.editBox:GetHeight() - frame.scrollFrame:GetHeight()))
+end
+
+function HMGT:UpdateDebugWindowVisibility()
+    if self.db and self.db.profile then
+        self.db.profile.debug = false
+    end
+    local frame = self.debugWindow
+    if not frame then
+        return
+    end
+    local widget = frame.aceWidget
+    if widget then
+        widget:Hide()
+    else
+        frame:Hide()
+    end
+end
+
+function HMGT:ClearDebugLog()
+    wipe(self.debugBuffer)
+    if self.debugWindow and self.debugWindow.logWidget then
+        self.debugWindow.logWidget:SetText("")
+        self.debugWindow.editBox:SetCursorPosition(0)
+        self.debugWindow.scrollFrame:SetVerticalScroll(0)
+        return
+    end
+    if self.debugWindow and self.debugWindow.editBox then
+        self.debugWindow.editBox:SetText("")
+        self.debugWindow.scrollFrame:SetVerticalScroll(0)
+    end
+end
+
+function HMGT:ToggleDebugWindowShortcut()
+    if self.db and self.db.profile then
+        self.db.profile.debug = false
+    end
+    local frame = self.debugWindow
+    if not frame then
+        return
+    end
+    local widget = frame.aceWidget
+    if widget then
+        widget:Hide()
+    else
+        frame:Hide()
+    end
+end
+
+function HMGT:DumpDebugLog(maxLines)
+    return
+end

Core/DevTools.lua

@@ -0,0 +1,227 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = _G[ADDON_NAME]
+if not HMGT then return end
+
+local L = HMGT.L or LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME)
+
+HMGT.devToolsBuffer = HMGT.devToolsBuffer or {}
+HMGT.devToolsBufferMax = HMGT.devToolsBufferMax or 300
+
+local DEVTOOLS_SCOPE_ALL = "ALL"
+local DEVTOOLS_SCOPE_LABELS = {
+    System = "System",
+    Version = "Version",
+    Options = "Options",
+    Comm = "Communication",
+    Tracker = "Tracker",
+    RaidTimeline = "Raid Timeline",
+    Notes = "Notes",
+}
+
+local DEVTOOLS_LEVELS = {
+    error = 1,
+    trace = 2,
+}
+
+local function TrimText(value)
+    return tostring(value or ""):gsub("^%s+", ""):gsub("%s+$", "")
+end
+
+local function SortKeys(tbl)
+    local keys = {}
+    for key in pairs(tbl or {}) do
+        keys[#keys + 1] = key
+    end
+    table.sort(keys, function(a, b)
+        return tostring(a) < tostring(b)
+    end)
+    return keys
+end
+
+local function EncodePayloadValue(value, depth)
+    depth = tonumber(depth) or 0
+    local valueType = type(value)
+    if valueType == "nil" then
+        return "nil"
+    end
+    if valueType == "string" then
+        return value
+    end
+    if valueType == "number" or valueType == "boolean" then
+        return tostring(value)
+    end
+    if valueType == "table" then
+        if depth >= 1 then
+            return "{...}"
+        end
+        local parts = {}
+        for _, key in ipairs(SortKeys(value)) do
+            parts[#parts + 1] = string.format("%s=%s", tostring(key), EncodePayloadValue(value[key], depth + 1))
+        end
+        return table.concat(parts, ", ")
+    end
+    return tostring(value)
+end
+
+function HMGT:GetDevToolsSettings()
+    local profile = self.db and self.db.profile
+    if not profile then
+        return {
+            enabled = false,
+            level = "error",
+            scope = DEVTOOLS_SCOPE_ALL,
+            window = { width = 920, height = 420, minimized = false },
+        }
+    end
+    profile.devTools = type(profile.devTools) == "table" and profile.devTools or {}
+    local settings = profile.devTools
+    settings.enabled = settings.enabled == true
+    if settings.level ~= "error" and settings.level ~= "trace" then
+        settings.level = "error"
+    end
+    if type(settings.scope) ~= "string" or settings.scope == "" then
+        settings.scope = DEVTOOLS_SCOPE_ALL
+    end
+    settings.window = type(settings.window) == "table" and settings.window or {}
+    settings.window.width = math.max(720, tonumber(settings.window.width) or 920)
+    settings.window.height = math.max(260, tonumber(settings.window.height) or 420)
+    settings.window.minimized = settings.window.minimized == true
+    return settings
+end
+
+function HMGT:IsDevToolsEnabled()
+    return self:GetDevToolsSettings().enabled == true
+end
+
+function HMGT:GetDevToolsLevelOptions()
+    return {
+        error = L["OPT_DEVTOOLS_LEVEL_ERROR"] or "Errors",
+        trace = L["OPT_DEVTOOLS_LEVEL_TRACE"] or "Trace",
+    }
+end
+
+function HMGT:GetConfiguredDevToolsLevel()
+    return self:GetDevToolsSettings().level or "error"
+end
+
+function HMGT:ShouldIncludeDevToolsLevel(level)
+    local configured = self:GetConfiguredDevToolsLevel()
+    return (DEVTOOLS_LEVELS[tostring(level or "error")] or DEVTOOLS_LEVELS.error)
+        <= (DEVTOOLS_LEVELS[configured] or DEVTOOLS_LEVELS.error)
+end
+
+function HMGT:GetDevToolsScopeOptions()
+    local values = {
+        [DEVTOOLS_SCOPE_ALL] = L["OPT_DEVTOOLS_SCOPE_ALL"] or "All scopes",
+    }
+    for scope, label in pairs(DEVTOOLS_SCOPE_LABELS) do
+        values[scope] = label
+    end
+    for _, entry in ipairs(self.devToolsBuffer or {}) do
+        local scope = TrimText(entry and entry.scope or "")
+        if scope ~= "" and scope ~= DEVTOOLS_SCOPE_ALL then
+            values[scope] = values[scope] or scope
+        end
+    end
+    return values
+end
+
+function HMGT:FormatDevToolsEntry(entry)
+    local stamp = tostring(entry and entry.stamp or date("%H:%M:%S"))
+    local level = string.upper(tostring(entry and entry.level or "error"))
+    local scope = tostring(entry and entry.scope or "System")
+    local eventName = tostring(entry and entry.event or "")
+    local payload = TrimText(entry and entry.payload or "")
+    if payload ~= "" then
+        return string.format("%s [%s][%s] %s | %s", stamp, level, scope, eventName, payload)
+    end
+    return string.format("%s [%s][%s] %s", stamp, level, scope, eventName)
+end
+
+function HMGT:GetFilteredDevToolsEntries()
+    local filtered = {}
+    local settings = self:GetDevToolsSettings()
+    for _, entry in ipairs(self.devToolsBuffer or {}) do
+        local scopeMatches = settings.scope == DEVTOOLS_SCOPE_ALL or settings.scope == tostring(entry.scope or "")
+        if scopeMatches and self:ShouldIncludeDevToolsLevel(entry.level) then
+            filtered[#filtered + 1] = entry
+        end
+    end
+    return filtered
+end
+
+function HMGT:GetFilteredDevToolsLines()
+    local lines = {}
+    for _, entry in ipairs(self:GetFilteredDevToolsEntries()) do
+        lines[#lines + 1] = self:FormatDevToolsEntry(entry)
+    end
+    return lines
+end
+
+function HMGT:RecordDevEvent(level, scope, eventName, payload)
+    if not self:IsDevToolsEnabled() then
+        return
+    end
+
+    local normalizedLevel = tostring(level or "error")
+    if normalizedLevel ~= "error" and normalizedLevel ~= "trace" then
+        normalizedLevel = "trace"
+    end
+    if not self:ShouldIncludeDevToolsLevel(normalizedLevel) then
+        return
+    end
+
+    local normalizedScope = TrimText(scope or "System")
+    if normalizedScope == "" then
+        normalizedScope = "System"
+    end
+
+    local entry = {
+        stamp = date("%H:%M:%S"),
+        level = normalizedLevel,
+        scope = normalizedScope,
+        event = TrimText(eventName or "event"),
+        payload = EncodePayloadValue(payload, 0),
+    }
+
+    table.insert(self.devToolsBuffer, entry)
+    if #self.devToolsBuffer > (tonumber(self.devToolsBufferMax) or 300) then
+        table.remove(self.devToolsBuffer, 1)
+    end
+
+    if self.devToolsWindow and self.devToolsWindow:IsShown() and self.RefreshDevToolsWindow then
+        self:RefreshDevToolsWindow()
+    end
+end
+
+function HMGT:DevError(scope, eventName, payload)
+    self:RecordDevEvent("error", scope, eventName, payload)
+end
+
+function HMGT:DevTrace(scope, eventName, payload)
+    self:RecordDevEvent("trace", scope, eventName, payload)
+end
+
+function HMGT:ClearDevToolsLog()
+    wipe(self.devToolsBuffer)
+    if self.devToolsWindow and self.devToolsWindow.editBox then
+        self.devToolsWindow.editBox:SetText("")
+        self.devToolsWindow.editBox:SetCursorPosition(0)
+    end
+end
+
+function HMGT:DumpDevToolsLog(maxLines)
+    if self:IsDevToolsEnabled() and self.OpenDevToolsWindow then
+        self:OpenDevToolsWindow()
+        return
+    end
+
+    local lines = tonumber(maxLines) or 40
+    if lines < 1 then
+        lines = 1
+    end
+    local startIndex = math.max(1, #self.devToolsBuffer - lines + 1)
+    for i = startIndex, #self.devToolsBuffer do
+        self:Print(self:FormatDevToolsEntry(self.devToolsBuffer[i]))
+    end
+end

Core/DevToolsWindow.lua

@@ -0,0 +1,254 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = _G[ADDON_NAME]
+if not HMGT then return end
+
+local L = HMGT.L or LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME)
+local AceGUI = LibStub("AceGUI-3.0", true)
+if not AceGUI then return end
+
+local function GetOrderedLevels()
+    return { "error", "trace" }
+end
+
+local function GetOrderedScopes()
+    local values = HMGT:GetDevToolsScopeOptions() or {}
+    local scopes = { "ALL" }
+    for scope in pairs(values) do
+        if scope ~= "ALL" then
+            scopes[#scopes + 1] = scope
+        end
+    end
+    table.sort(scopes, function(a, b)
+        if a == "ALL" then return true end
+        if b == "ALL" then return false end
+        return tostring(values[a] or a) < tostring(values[b] or b)
+    end)
+    return scopes, values
+end
+
+local function SetFilterButtonText(buttonWidget, prefix, valueLabel)
+    if not buttonWidget then
+        return
+    end
+    buttonWidget:SetText(string.format("%s: %s", tostring(prefix or ""), tostring(valueLabel or "")))
+end
+
+local function AdvanceLevel(step)
+    local levels = GetOrderedLevels()
+    local current = HMGT:GetConfiguredDevToolsLevel()
+    local nextIndex = 1
+    for index, value in ipairs(levels) do
+        if value == current then
+            nextIndex = index + (step or 1)
+            break
+        end
+    end
+    if nextIndex < 1 then
+        nextIndex = #levels
+    elseif nextIndex > #levels then
+        nextIndex = 1
+    end
+    HMGT:GetDevToolsSettings().level = levels[nextIndex]
+    HMGT:RefreshDevToolsWindow()
+end
+
+local function AdvanceScope(step)
+    local scopes = GetOrderedScopes()
+    local current = HMGT:GetDevToolsSettings().scope or "ALL"
+    local nextIndex = 1
+    for index, value in ipairs(scopes) do
+        if value == current then
+            nextIndex = index + (step or 1)
+            break
+        end
+    end
+    if nextIndex < 1 then
+        nextIndex = #scopes
+    elseif nextIndex > #scopes then
+        nextIndex = 1
+    end
+    HMGT:GetDevToolsSettings().scope = scopes[nextIndex]
+    HMGT:RefreshDevToolsWindow()
+end
+
+function HMGT:EnsureDevToolsWindow()
+    if self.devToolsWindow then
+        return self.devToolsWindow
+    end
+
+    local settings = self:GetDevToolsSettings()
+    local window = self:CreateAceWindow("devTools", {
+        title = L["DEVTOOLS_WINDOW_TITLE"] or "HMGT Developer Tools",
+        statusText = L["DEVTOOLS_WINDOW_HINT"] or "Structured developer events for the current session",
+        statusTable = settings.window,
+        width = settings.window.width or 920,
+        height = settings.window.height or 420,
+        minimizable = true,
+        minimizedHeight = 64,
+    })
+    if not window then
+        return nil
+    end
+
+    local content = window:GetContent()
+
+    local clearButton = AceGUI:Create("Button")
+    clearButton:SetText(L["OPT_DEVTOOLS_CLEAR"] or "Clear developer log")
+    clearButton:SetWidth(140)
+    clearButton:SetCallback("OnClick", function()
+        HMGT:ClearDevToolsLog()
+    end)
+    clearButton.frame:SetParent(content)
+    clearButton.frame:ClearAllPoints()
+    clearButton.frame:SetPoint("TOPRIGHT", content, "TOPRIGHT", 0, -2)
+    clearButton.frame:Show()
+    window.clearButton = clearButton
+    window:RegisterMinimizeTarget(clearButton)
+
+    local selectButton = AceGUI:Create("Button")
+    selectButton:SetText(L["OPT_DEVTOOLS_SELECT_ALL"] or "Select all")
+    selectButton:SetWidth(120)
+    selectButton:SetCallback("OnClick", function()
+        if window.editBox then
+            window.editBox:SetFocus()
+            window.editBox:HighlightText(0)
+        end
+    end)
+    selectButton.frame:SetParent(content)
+    selectButton.frame:ClearAllPoints()
+    selectButton.frame:SetPoint("TOPRIGHT", clearButton.frame, "TOPLEFT", -6, 0)
+    selectButton.frame:Show()
+    window.selectButton = selectButton
+    window:RegisterMinimizeTarget(selectButton)
+
+    local levelFilter = AceGUI:Create("Button")
+    levelFilter:SetWidth(150)
+    levelFilter:SetCallback("OnClick", function()
+        AdvanceLevel(1)
+    end)
+    levelFilter.frame:SetParent(content)
+    levelFilter.frame:ClearAllPoints()
+    levelFilter.frame:SetPoint("TOPLEFT", content, "TOPLEFT", 0, 0)
+    levelFilter.frame:Show()
+    window.levelFilter = levelFilter
+    window:RegisterMinimizeTarget(levelFilter)
+
+    local scopeFilter = AceGUI:Create("Button")
+    scopeFilter:SetWidth(200)
+    scopeFilter:SetCallback("OnClick", function()
+        AdvanceScope(1)
+    end)
+    scopeFilter.frame:SetParent(content)
+    scopeFilter.frame:ClearAllPoints()
+    scopeFilter.frame:SetPoint("TOPLEFT", levelFilter.frame, "TOPRIGHT", 8, 0)
+    scopeFilter.frame:Show()
+    window.scopeFilter = scopeFilter
+    window:RegisterMinimizeTarget(scopeFilter)
+
+    local logWidget = AceGUI:Create("MultiLineEditBox")
+    logWidget:SetLabel("")
+    logWidget:DisableButton(true)
+    logWidget:SetNumLines(20)
+    logWidget:SetText("")
+    logWidget.frame:SetParent(content)
+    logWidget.frame:ClearAllPoints()
+    logWidget.frame:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -54)
+    logWidget.frame:SetPoint("BOTTOMRIGHT", content, "BOTTOMRIGHT", 0, 0)
+    logWidget.frame:Show()
+    logWidget.editBox:SetScript("OnKeyDown", function(selfBox, key)
+        if IsControlKeyDown() and (key == "A" or key == "a") then
+            selfBox:HighlightText(0)
+        end
+    end)
+    window.logWidget = logWidget
+    window.editBox = logWidget.editBox
+    window:RegisterMinimizeTarget(logWidget)
+
+    self.devToolsWindow = window
+    window:SetMinimized(settings.window.minimized)
+    return window
+end
+
+function HMGT:RefreshDevToolsWindow()
+    local window = self:EnsureDevToolsWindow()
+    if not window or not window.editBox or not window.logWidget then
+        return
+    end
+
+    local levelOptions = self:GetDevToolsLevelOptions()
+    SetFilterButtonText(window.levelFilter, L["OPT_DEVTOOLS_LEVEL"] or "Capture level", levelOptions[self:GetConfiguredDevToolsLevel()])
+
+    local scopeValues = self:GetDevToolsScopeOptions()
+    local currentScope = self:GetDevToolsSettings().scope or "ALL"
+    SetFilterButtonText(window.scopeFilter, L["OPT_DEVTOOLS_SCOPE"] or "Scope", scopeValues[currentScope] or currentScope)
+
+    local text = table.concat(self:GetFilteredDevToolsLines(), "\n")
+    window.logWidget:SetText(text)
+    window.editBox:SetCursorPosition(window.editBox:GetNumLetters())
+end
+
+function HMGT:OpenDevToolsWindow()
+    if not self:IsDevToolsEnabled() then
+        self:Print(L["OPT_DEVTOOLS_DISABLED"] or "HMGT: developer tools are not enabled.")
+        return
+    end
+    local window = self:EnsureDevToolsWindow()
+    if not window then
+        return
+    end
+    window:Show()
+    window:Raise()
+    self:RefreshDevToolsWindow()
+end
+
+function HMGT:ToggleDevToolsWindow()
+    if not self:IsDevToolsEnabled() then
+        self:Print(L["OPT_DEVTOOLS_DISABLED"] or "HMGT: developer tools are not enabled.")
+        return
+    end
+    local window = self:EnsureDevToolsWindow()
+    if not window then
+        return
+    end
+    if window:IsShown() then
+        window:Hide()
+        return
+    end
+    window:Show()
+    window:Raise()
+    self:RefreshDevToolsWindow()
+end
+
+function HMGT:UpdateDevToolsWindowVisibility()
+    local window = self.devToolsWindow
+    if not window then
+        return
+    end
+    if not self:IsDevToolsEnabled() then
+        window:Hide()
+        return
+    end
+    if window:IsShown() then
+        self:RefreshDevToolsWindow()
+    end
+end
+
+function HMGT:RefreshDebugWindow()
+    self:RefreshDevToolsWindow()
+end
+
+function HMGT:UpdateDebugWindowVisibility()
+    self:UpdateDevToolsWindowVisibility()
+end
+
+function HMGT:ClearDebugLog()
+    self:ClearDevToolsLog()
+end
+
+function HMGT:ToggleDebugWindowShortcut()
+    self:ToggleDevToolsWindow()
+end
+
+function HMGT:DumpDebugLog(maxLines)
+    self:DumpDevToolsLog(maxLines)
+end

Core/VersionNoticeWindow.lua

@@ -0,0 +1,103 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = _G[ADDON_NAME]
+if not HMGT then return end
+
+local L = HMGT.L or LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME)
+
+function HMGT:EnsureVersionNoticeWindow()
+    if self.versionNoticeWindow then
+        return self.versionNoticeWindow
+    end
+
+    self.versionNoticeWindowStatus = self.versionNoticeWindowStatus or {
+        width = 560,
+        height = 240,
+    }
+
+    local window = self:CreateAceWindow("versionNotice", {
+        title = L["VERSION_WINDOW_TITLE"] or "HMGT Version Check",
+        statusText = "",
+        statusTable = self.versionNoticeWindowStatus,
+        width = self.versionNoticeWindowStatus.width or 560,
+        height = self.versionNoticeWindowStatus.height or 240,
+        backgroundTexture = "Interface\\AddOns\\HailMaryGuildTools\\Media\\HailMaryLogo.png",
+        backgroundWidth = 220,
+        backgroundHeight = 120,
+        backgroundOffsetY = -8,
+        backgroundAlpha = 0.12,
+        strata = "FULLSCREEN_DIALOG",
+    })
+    if not window then
+        return nil
+    end
+
+    local content = window:GetContent()
+    local messageText = content:CreateFontString(nil, "OVERLAY", "GameFontHighlightLarge")
+    messageText:SetPoint("TOPLEFT", content, "TOPLEFT", 28, -28)
+    messageText:SetPoint("TOPRIGHT", content, "TOPRIGHT", -28, -28)
+    messageText:SetJustifyH("CENTER")
+    messageText:SetJustifyV("MIDDLE")
+    messageText:SetTextColor(1, 0.82, 0.1, 1)
+    messageText:SetText(L["VERSION_WINDOW_MESSAGE"] or "A new version of Hail Mary Guild Tools is available.")
+    window.messageText = messageText
+
+    local detailText = content:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
+    detailText:SetPoint("TOPLEFT", messageText, "BOTTOMLEFT", 0, -18)
+    detailText:SetPoint("TOPRIGHT", messageText, "BOTTOMRIGHT", 0, -18)
+    detailText:SetJustifyH("CENTER")
+    detailText:SetJustifyV("TOP")
+    if detailText.SetSpacing then
+        detailText:SetSpacing(2)
+    end
+    detailText:SetTextColor(0.9, 0.9, 0.9, 1)
+    window.detailText = detailText
+
+    self.versionNoticeWindow = window
+    return window
+end
+
+function HMGT:ShowVersionMismatchPopup(playerName, detail, sourceTag, opts)
+    opts = opts or {}
+
+    if playerName or detail or sourceTag then
+        self.latestVersionMismatch = {
+            playerName = playerName,
+            detail = detail,
+            sourceTag = sourceTag,
+        }
+    end
+
+    local info = self.latestVersionMismatch or {}
+    local window = self:EnsureVersionNoticeWindow()
+    if not window then
+        return
+    end
+    local hasMismatch = info.playerName or info.detail
+
+    window:SetTitle(L["VERSION_WINDOW_TITLE"] or "HMGT Version Check")
+
+    if hasMismatch then
+        window.messageText:SetText(L["VERSION_WINDOW_MESSAGE"] or "A new version of Hail Mary Guild Tools is available.")
+        window.detailText:SetText(string.format(
+            L["VERSION_WINDOW_DETAIL"] or "Detected via %s from %s.\n%s",
+            tostring(info.sourceTag or "?"),
+            tostring(info.playerName or UNKNOWN),
+            tostring(info.detail or "")
+        ))
+    else
+        window.messageText:SetText(L["VERSION_WINDOW_NO_MISMATCH"] or "No newer HMGT version has been detected in your current group.")
+        window.detailText:SetText(string.format(
+            L["VERSION_WINDOW_CURRENT"] or "Current version: %s | Protocol: %s",
+            tostring(HMGT.ADDON_VERSION or "dev"),
+            tostring(HMGT.PROTOCOL_VERSION or "?")
+        ))
+    end
+
+    self:DevTrace("Version", hasMismatch and "window_show_mismatch" or "window_show_current", {
+        player = info.playerName,
+        source = info.sourceTag,
+        detail = info.detail,
+    })
+    window:Show()
+    window:Raise()
+end

Embeds.xml

@@ -0,0 +1,44 @@
+<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">
+
+    <!-- LibStub -->
+    <Script file="Libs\LibStub\LibStub.lua"/>
+
+    <!-- CallbackHandler -->
+    <Include file="Libs\CallbackHandler-1.0\CallbackHandler-1.0.xml"/>
+
+    <!-- AceAddon -->
+    <Include file="Libs\AceAddon-3.0\AceAddon-3.0.xml"/>
+
+    <!-- AceEvent -->
+    <Include file="Libs\AceEvent-3.0\AceEvent-3.0.xml"/>
+    
+    <!-- AceTimer -->
+    <Include file="Libs\AceTimer-3.0\AceTimer-3.0.xml"/>  
+    
+    <!-- AceComm -->
+    <Include file="Libs\AceComm-3.0\AceComm-3.0.xml"/>
+
+    <!-- AceDB -->
+    <Include file="Libs\AceDB-3.0\AceDB-3.0.xml"/>
+
+    <!-- AceDBOptions -->
+    <Include file="Libs\AceDBOptions-3.0\AceDBOptions-3.0.xml"/>
+
+    <!-- AceGUI -->
+    <Include file="Libs\AceGUI-3.0\AceGUI-3.0.xml"/>
+
+    <!-- AceConfig (depends on AceGUI via AceConfigDialog) -->
+    <Include file="Libs\AceConfig-3.0\AceConfig-3.0.xml"/>
+
+    <!-- AceConsole -->
+    <Include file="Libs\AceConsole-3.0\AceConsole-3.0.xml"/>
+
+    <!-- AceLocale -->
+    <Include file="Libs\AceLocale-3.0\AceLocale-3.0.xml"/>
+
+    <!-- LibSharedMedia -->
+    <Include file="Libs\LibSharedMedia-3.0\lib.xml"/>
+
+</Ui>

HailMaryGuildTools.toc

@@ -0,0 +1,59 @@
+## Interface: 120000,120001
+## IconTexture: Interface\Addons\HailMaryGuildTools\Media\HailMaryIcon.png
+## Author: Torsten Brendgen
+## Title: Hail Mary Guild Tools
+## Notes: Guild Tools for World of Warcraft
+## Version: 1.3
+## X-Stable-Version: 1.3
+## X-Build-Version: 2.0-beta
+## X-Release-Channel: beta
+## SavedVariables: HailMaryGuildToolsDB
+## OptionalDeps: Ace3, LibSharedMedia-3.0, LibDataBroker-1.1, LibDBIcon-1.0
+
+# ── Libraries ────────────────────────────────────────────────────────
+Embeds.xml
+
+# ── Locales ──────────────────────────────────────────────────────────
+Locales\Locales.xml
+
+# ── Changelog ────────────────────────────────────────────────────────
+Changelog.lua
+
+# ── Core ─────────────────────────────────────────────────────────────
+HailMaryGuildTools.lua
+Core\AceWindow.lua
+Core\DevTools.lua
+Core\DevToolsWindow.lua
+Core\VersionNoticeWindow.lua
+HailMaryGuildToolsOptions.lua
+
+# ── Modules ──────────────────────────────────────────────────────────
+# ────── Tracker ──────────────────────────────────────────────────────
+Modules\Tracker\Frame.lua
+Modules\Tracker\SpellDatabase.lua
+Modules\Tracker\SingleFrameTrackerBase.lua
+
+Modules\Tracker\InterruptTracker\InterruptSpellDatabase.lua
+Modules\Tracker\RaidcooldownTracker\RaidCooldownSpellDatabase.lua
+Modules\Tracker\GroupCooldownTracker\GroupCooldownSpellDatabase.lua
+Modules\Tracker\TrackerManager.lua
+Modules\Tracker\NormalTrackerFrames.lua
+Modules\Tracker\GroupTrackerFrames.lua
+Modules\Tracker\TrackerOptions.lua
+
+# ────── BuffEndingAnnouncer ──────────────────────────────────────────
+Modules\BuffEndingAnnouncer\BuffEndingAnnouncer.lua
+Modules\BuffEndingAnnouncer\BuffEndingAnnouncerOptions.lua
+
+# ────── MapOverlay ───────────────────────────────────────────────────
+Modules\MapOverlay\MapOverlayIconConfig.lua
+Modules\MapOverlay\MapOverlay.lua
+Modules\MapOverlay\MapOverlayOptions.lua
+Modules\MapOverlay\MapOverlay.xml
+
+# ────── RaidTimeline ─────────────────────────────────────────────────
+Modules\RaidTimeline\RaidTimelineBossAbilityData.lua
+Modules\RaidTimeline\RaidTimeline.lua
+Modules\RaidTimeline\RaidTimelineBigWigs.lua
+Modules\RaidTimeline\RaidTimelineDBM.lua
+Modules\RaidTimeline\RaidTimelineOptions.lua

Libs/AceAddon-3.0/AceAddon-3.0.lua

@@ -0,0 +1,649 @@
+--- **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 1284 2022-09-25 09:15:30Z nevcairiel $
+
+local MAJOR, MINOR = "AceAddon-3.0", 13
+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
+
+--[[
+	 xpcall safecall implementation
+]]
+local xpcall = xpcall
+
+local function errorhandler(err)
+	return geterrorhandler()(err)
+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 xpcall(func, errorhandler, ...)
+	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
+
+-- Check if the addon is queued for initialization
+local function queuedForInitialization(addon)
+	for i = 1, #AceAddon.initializequeue do
+		if AceAddon.initializequeue[i] == addon then
+			return true
+		end
+	end
+	return false
+end
+
+--- Create a new AceAddon-3.0 addon.
+-- Any libraries you specified will be embeded, and the addon will be scheduled for
+-- its OnInitialize and OnEnable callbacks.
+-- The final addon object, with all libraries embeded, will be returned.
+-- @paramsig [object ,]name[, lib, ...]
+-- @param object Table to use as a base for the addon (optional)
+-- @param name Name of the addon object to create
+-- @param lib List of libraries to embed into the addon
+-- @usage
+-- -- Create a simple addon object
+-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceEvent-3.0")
+--
+-- -- Create a Addon object based on the table of a frame
+-- local MyFrame = CreateFrame("Frame")
+-- MyAddon = LibStub("AceAddon-3.0"):NewAddon(MyFrame, "MyAddon", "AceEvent-3.0")
+function AceAddon:NewAddon(objectorname, ...)
+	local object,name
+	local i=1
+	if type(objectorname)=="table" then
+		object=objectorname
+		name=...
+		i=2
+	else
+		name=objectorname
+	end
+	if type(name)~="string" then
+		error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2)
+	end
+	if self.addons[name] then
+		error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - Addon '%s' already exists."):format(name), 2)
+	end
+
+	object = object or {}
+	object.name = name
+
+	local addonmeta = {}
+	local oldmeta = getmetatable(object)
+	if oldmeta then
+		for k, v in pairs(oldmeta) do addonmeta[k] = v end
+	end
+	addonmeta.__tostring = addontostring
+
+	setmetatable( object, addonmeta )
+	self.addons[name] = object
+	object.modules = {}
+	object.orderedModules = {}
+	object.defaultModuleLibraries = {}
+	Embed( object ) -- embed NewModule, GetModule methods
+	self:EmbedLibraries(object, select(i,...))
+
+	-- add to queue of addons to be initialized upon ADDON_LOADED
+	tinsert(self.initializequeue, object)
+	return object
+end
+
+
+--- Get the addon object by its name from the internal AceAddon registry.
+-- Throws an error if the addon object cannot be found (except if silent is set).
+-- @param name unique name of the addon object
+-- @param silent if true, the addon is optional, silently return nil if its not found
+-- @usage
+-- -- Get the Addon
+-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
+function AceAddon:GetAddon(name, silent)
+	if not silent and not self.addons[name] then
+		error(("Usage: GetAddon(name): 'name' - Cannot find an AceAddon '%s'."):format(tostring(name)), 2)
+	end
+	return self.addons[name]
+end
+
+-- - Embed a list of libraries into the specified addon.
+-- This function will try to embed all of the listed libraries into the addon
+-- and error if a single one fails.
+--
+-- **Note:** This function is for internal use by :NewAddon/:NewModule
+-- @paramsig addon, [lib, ...]
+-- @param addon addon object to embed the libs in
+-- @param lib List of libraries to embed into the addon
+function AceAddon:EmbedLibraries(addon, ...)
+	for i=1,select("#", ... ) do
+		local libname = select(i, ...)
+		self:EmbedLibrary(addon, libname, false, 4)
+	end
+end
+
+-- - Embed a library into the addon object.
+-- This function will check if the specified library is registered with LibStub
+-- and if it has a :Embed function to call. It'll error if any of those conditions
+-- fails.
+--
+-- **Note:** This function is for internal use by :EmbedLibraries
+-- @paramsig addon, libname[, silent[, offset]]
+-- @param addon addon object to embed the library in
+-- @param libname name of the library to embed
+-- @param silent marks an embed to fail silently if the library doesn't exist (optional)
+-- @param offset will push the error messages back to said offset, defaults to 2 (optional)
+function AceAddon:EmbedLibrary(addon, libname, silent, offset)
+	local lib = LibStub:GetLibrary(libname, true)
+	if not lib and not silent then
+		error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Cannot find a library instance of %q."):format(tostring(libname)), offset or 2)
+	elseif lib and type(lib.Embed) == "function" then
+		lib:Embed(addon)
+		tinsert(self.embeds[addon], libname)
+		return true
+	elseif lib then
+		error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Library '%s' is not Embed capable"):format(libname), offset or 2)
+	end
+end
+
+--- Return the specified module from an addon object.
+-- Throws an error if the addon object cannot be found (except if silent is set)
+-- @name //addon//:GetModule
+-- @paramsig name[, silent]
+-- @param name unique name of the module
+-- @param silent if true, the module is optional, silently return nil if its not found (optional)
+-- @usage
+-- -- Get the Addon
+-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
+-- -- Get the Module
+-- MyModule = MyAddon:GetModule("MyModule")
+function GetModule(self, name, silent)
+	if not self.modules[name] and not silent then
+		error(("Usage: GetModule(name, silent): 'name' - Cannot find module '%s'."):format(tostring(name)), 2)
+	end
+	return self.modules[name]
+end
+
+local function IsModuleTrue(self) return true end
+
+--- Create a new module for the addon.
+-- The new module can have its own embeded libraries and/or use a module prototype to be mixed into the module.\\
+-- A module has the same functionality as a real addon, it can have modules of its own, and has the same API as
+-- an addon object.
+-- @name //addon//:NewModule
+-- @paramsig name[, prototype|lib[, lib, ...]]
+-- @param name unique name of the module
+-- @param prototype object to derive this module from, methods and values from this table will be mixed into the module (optional)
+-- @param lib List of libraries to embed into the addon
+-- @usage
+-- -- Create a module with some embeded libraries
+-- MyModule = MyAddon:NewModule("MyModule", "AceEvent-3.0", "AceHook-3.0")
+--
+-- -- Create a module with a prototype
+-- local prototype = { OnEnable = function(self) print("OnEnable called!") end }
+-- MyModule = MyAddon:NewModule("MyModule", prototype, "AceEvent-3.0", "AceHook-3.0")
+function NewModule(self, name, prototype, ...)
+	if type(name) ~= "string" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) end
+	if type(prototype) ~= "string" and type(prototype) ~= "table" and type(prototype) ~= "nil" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'prototype' - table (prototype), string (lib) or nil expected got '%s'."):format(type(prototype)), 2) end
+
+	if self.modules[name] then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - Module '%s' already exists."):format(name), 2) end
+
+	-- modules are basically addons. We treat them as such. They will be added to the initializequeue properly as well.
+	-- NewModule can only be called after the parent addon is present thus the modules will be initialized after their parent is.
+	local module = AceAddon:NewAddon(fmt("%s_%s", self.name or tostring(self), name))
+
+	module.IsModule = IsModuleTrue
+	module:SetEnabledState(self.defaultModuleState)
+	module.moduleName = name
+
+	if type(prototype) == "string" then
+		AceAddon:EmbedLibraries(module, prototype, ...)
+	else
+		AceAddon:EmbedLibraries(module, ...)
+	end
+	AceAddon:EmbedLibraries(module, unpack(self.defaultModuleLibraries))
+
+	if not prototype or type(prototype) == "string" then
+		prototype = self.defaultModulePrototype or nil
+	end
+
+	if type(prototype) == "table" then
+		local mt = getmetatable(module)
+		mt.__index = prototype
+		setmetatable(module, mt)  -- More of a Base class type feel.
+	end
+
+	safecall(self.OnModuleCreated, self, module) -- Was in Ace2 and I think it could be a cool thing to have handy.
+	self.modules[name] = module
+	tinsert(self.orderedModules, module)
+
+	return module
+end
+
+--- Returns the real name of the addon or module, without any prefix.
+-- @name //addon//:GetName
+-- @paramsig
+-- @usage
+-- print(MyAddon:GetName())
+-- -- prints "MyAddon"
+function GetName(self)
+	return self.moduleName or self.name
+end
+
+--- Enables the Addon, if possible, return true or false depending on success.
+-- This internally calls AceAddon:EnableAddon(), thus dispatching a OnEnable callback
+-- and enabling all modules of the addon (unless explicitly disabled).\\
+-- :Enable() also sets the internal `enableState` variable to true
+-- @name //addon//:Enable
+-- @paramsig
+-- @usage
+-- -- Enable MyModule
+-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
+-- MyModule = MyAddon:GetModule("MyModule")
+-- MyModule:Enable()
+function Enable(self)
+	self:SetEnabledState(true)
+
+	-- nevcairiel 2013-04-27: don't enable an addon/module if its queued for init still
+	-- it'll be enabled after the init process
+	if not queuedForInitialization(self) then
+		return AceAddon:EnableAddon(self)
+	end
+end
+
+--- Disables the Addon, if possible, return true or false depending on success.
+-- This internally calls AceAddon:DisableAddon(), thus dispatching a OnDisable callback
+-- and disabling all modules of the addon.\\
+-- :Disable() also sets the internal `enableState` variable to false
+-- @name //addon//:Disable
+-- @paramsig
+-- @usage
+-- -- Disable MyAddon
+-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
+-- MyAddon:Disable()
+function Disable(self)
+	self:SetEnabledState(false)
+	return AceAddon:DisableAddon(self)
+end
+
+--- Enables the Module, if possible, return true or false depending on success.
+-- Short-hand function that retrieves the module via `:GetModule` and calls `:Enable` on the module object.
+-- @name //addon//:EnableModule
+-- @paramsig name
+-- @usage
+-- -- Enable MyModule using :GetModule
+-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
+-- MyModule = MyAddon:GetModule("MyModule")
+-- MyModule:Enable()
+--
+-- -- Enable MyModule using the short-hand
+-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
+-- MyAddon:EnableModule("MyModule")
+function EnableModule(self, name)
+	local module = self:GetModule( name )
+	return module:Enable()
+end
+
+--- Disables the Module, if possible, return true or false depending on success.
+-- Short-hand function that retrieves the module via `:GetModule` and calls `:Disable` on the module object.
+-- @name //addon//:DisableModule
+-- @paramsig name
+-- @usage
+-- -- Disable MyModule using :GetModule
+-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
+-- MyModule = MyAddon:GetModule("MyModule")
+-- MyModule:Disable()
+--
+-- -- Disable MyModule using the short-hand
+-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
+-- MyAddon:DisableModule("MyModule")
+function DisableModule(self, name)
+	local module = self:GetModule( name )
+	return module:Disable()
+end
+
+--- Set the default libraries to be mixed into all modules created by this object.
+-- Note that you can only change the default module libraries before any module is created.
+-- @name //addon//:SetDefaultModuleLibraries
+-- @paramsig lib[, lib, ...]
+-- @param lib List of libraries to embed into the addon
+-- @usage
+-- -- Create the addon object
+-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
+-- -- Configure default libraries for modules (all modules need AceEvent-3.0)
+-- MyAddon:SetDefaultModuleLibraries("AceEvent-3.0")
+-- -- Create a module
+-- MyModule = MyAddon:NewModule("MyModule")
+function SetDefaultModuleLibraries(self, ...)
+	if next(self.modules) then
+		error("Usage: SetDefaultModuleLibraries(...): cannot change the module defaults after a module has been registered.", 2)
+	end
+	self.defaultModuleLibraries = {...}
+end
+
+--- Set the default state in which new modules are being created.
+-- Note that you can only change the default state before any module is created.
+-- @name //addon//:SetDefaultModuleState
+-- @paramsig state
+-- @param state Default state for new modules, true for enabled, false for disabled
+-- @usage
+-- -- Create the addon object
+-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
+-- -- Set the default state to "disabled"
+-- MyAddon:SetDefaultModuleState(false)
+-- -- Create a module and explicilty enable it
+-- MyModule = MyAddon:NewModule("MyModule")
+-- MyModule:Enable()
+function SetDefaultModuleState(self, state)
+	if next(self.modules) then
+		error("Usage: SetDefaultModuleState(state): cannot change the module defaults after a module has been registered.", 2)
+	end
+	self.defaultModuleState = state
+end
+
+--- Set the default prototype to use for new modules on creation.
+-- Note that you can only change the default prototype before any module is created.
+-- @name //addon//:SetDefaultModulePrototype
+-- @paramsig prototype
+-- @param prototype Default prototype for the new modules (table)
+-- @usage
+-- -- Define a prototype
+-- local prototype = { OnEnable = function(self) print("OnEnable called!") end }
+-- -- Set the default prototype
+-- MyAddon:SetDefaultModulePrototype(prototype)
+-- -- Create a module and explicitly Enable it
+-- MyModule = MyAddon:NewModule("MyModule")
+-- MyModule:Enable()
+-- -- should print "OnEnable called!" now
+-- @see NewModule
+function SetDefaultModulePrototype(self, prototype)
+	if next(self.modules) then
+		error("Usage: SetDefaultModulePrototype(prototype): cannot change the module defaults after a module has been registered.", 2)
+	end
+	if type(prototype) ~= "table" then
+		error(("Usage: SetDefaultModulePrototype(prototype): 'prototype' - table expected got '%s'."):format(type(prototype)), 2)
+	end
+	self.defaultModulePrototype = prototype
+end
+
+--- Set the state of an addon or module
+-- This should only be called before any enabling actually happend, e.g. in/before OnInitialize.
+-- @name //addon//:SetEnabledState
+-- @paramsig state
+-- @param state the state of an addon or module  (enabled=true, disabled=false)
+function SetEnabledState(self, state)
+	self.enabledState = state
+end
+
+
+--- Return an iterator of all modules associated to the addon.
+-- @name //addon//:IterateModules
+-- @paramsig
+-- @usage
+-- -- Enable all modules
+-- for name, module in MyAddon:IterateModules() do
+--    module:Enable()
+-- end
+local function IterateModules(self) return pairs(self.modules) end
+
+-- Returns an iterator of all embeds in the addon
+-- @name //addon//:IterateEmbeds
+-- @paramsig
+local function IterateEmbeds(self) return pairs(AceAddon.embeds[self]) end
+
+--- Query the enabledState of an addon.
+-- @name //addon//:IsEnabled
+-- @paramsig
+-- @usage
+-- if MyAddon:IsEnabled() then
+--     MyAddon:Disable()
+-- end
+local function IsEnabled(self) return self.enabledState end
+local mixins = {
+	NewModule = NewModule,
+	GetModule = GetModule,
+	Enable = Enable,
+	Disable = Disable,
+	EnableModule = EnableModule,
+	DisableModule = DisableModule,
+	IsEnabled = IsEnabled,
+	SetDefaultModuleLibraries = SetDefaultModuleLibraries,
+	SetDefaultModuleState = SetDefaultModuleState,
+	SetDefaultModulePrototype = SetDefaultModulePrototype,
+	SetEnabledState = SetEnabledState,
+	IterateModules = IterateModules,
+	IterateEmbeds = IterateEmbeds,
+	GetName = GetName,
+}
+local function IsModule(self) return false end
+local pmixins = {
+	defaultModuleState = true,
+	enabledState = true,
+	IsModule = IsModule,
+}
+-- Embed( target )
+-- target (object) - target object to embed aceaddon in
+--
+-- this is a local function specifically since it's meant to be only called internally
+function Embed(target, skipPMixins)
+	for k, v in pairs(mixins) do
+		target[k] = v
+	end
+	if not skipPMixins then
+		for k, v in pairs(pmixins) do
+			target[k] = target[k] or v
+		end
+	end
+end
+
+
+-- - Initialize the addon after creation.
+-- This function is only used internally during the ADDON_LOADED event
+-- It will call the **OnInitialize** function on the addon object (if present),
+-- and the **OnEmbedInitialize** function on all embeded libraries.
+--
+-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
+-- @param addon addon object to intialize
+function AceAddon:InitializeAddon(addon)
+	safecall(addon.OnInitialize, addon)
+
+	local embeds = self.embeds[addon]
+	for i = 1, #embeds do
+		local lib = LibStub:GetLibrary(embeds[i], true)
+		if lib then safecall(lib.OnEmbedInitialize, lib, addon) end
+	end
+
+	-- we don't call InitializeAddon on modules specifically, this is handled
+	-- from the event handler and only done _once_
+end
+
+-- - Enable the addon after creation.
+-- Note: This function is only used internally during the PLAYER_LOGIN event, or during ADDON_LOADED,
+-- if IsLoggedIn() already returns true at that point, e.g. for LoD Addons.
+-- It will call the **OnEnable** function on the addon object (if present),
+-- and the **OnEmbedEnable** function on all embeded libraries.\\
+-- This function does not toggle the enable state of the addon itself, and will return early if the addon is disabled.
+--
+-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
+-- Use :Enable on the addon itself instead.
+-- @param addon addon object to enable
+function AceAddon:EnableAddon(addon)
+	if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
+	if self.statuses[addon.name] or not addon.enabledState then return false end
+
+	-- set the statuses first, before calling the OnEnable. this allows for Disabling of the addon in OnEnable.
+	self.statuses[addon.name] = true
+
+	safecall(addon.OnEnable, addon)
+
+	-- make sure we're still enabled before continueing
+	if self.statuses[addon.name] then
+		local embeds = self.embeds[addon]
+		for i = 1, #embeds do
+			local lib = LibStub:GetLibrary(embeds[i], true)
+			if lib then safecall(lib.OnEmbedEnable, lib, addon) end
+		end
+
+		-- enable possible modules.
+		local modules = addon.orderedModules
+		for i = 1, #modules do
+			self:EnableAddon(modules[i])
+		end
+	end
+	return self.statuses[addon.name] -- return true if we're disabled
+end
+
+-- - Disable the addon
+-- Note: This function is only used internally.
+-- It will call the **OnDisable** function on the addon object (if present),
+-- and the **OnEmbedDisable** function on all embeded libraries.\\
+-- This function does not toggle the enable state of the addon itself, and will return early if the addon is still enabled.
+--
+-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
+-- Use :Disable on the addon itself instead.
+-- @param addon addon object to enable
+function AceAddon:DisableAddon(addon)
+	if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
+	if not self.statuses[addon.name] then return false end
+
+	-- set statuses first before calling OnDisable, this allows for aborting the disable in OnDisable.
+	self.statuses[addon.name] = false
+
+	safecall( addon.OnDisable, addon )
+
+	-- make sure we're still disabling...
+	if not self.statuses[addon.name] then
+		local embeds = self.embeds[addon]
+		for i = 1, #embeds do
+			local lib = LibStub:GetLibrary(embeds[i], true)
+			if lib then safecall(lib.OnEmbedDisable, lib, addon) end
+		end
+		-- disable possible modules.
+		local modules = addon.orderedModules
+		for i = 1, #modules do
+			self:DisableAddon(modules[i])
+		end
+	end
+
+	return not self.statuses[addon.name] -- return true if we're disabled
+end
+
+--- Get an iterator over all registered addons.
+-- @usage
+-- -- Print a list of all installed AceAddon's
+-- for name, addon in AceAddon:IterateAddons() do
+--   print("Addon: " .. name)
+-- end
+function AceAddon:IterateAddons() return pairs(self.addons) end
+
+--- Get an iterator over the internal status registry.
+-- @usage
+-- -- Print a list of all enabled addons
+-- for name, status in AceAddon:IterateAddonStatus() do
+--   if status then
+--     print("EnabledAddon: " .. name)
+--   end
+-- end
+function AceAddon:IterateAddonStatus() return pairs(self.statuses) end
+
+-- Following Iterators are deprecated, and their addon specific versions should be used
+-- e.g. addon:IterateEmbeds() instead of :IterateEmbedsOnAddon(addon)
+function AceAddon:IterateEmbedsOnAddon(addon) return pairs(self.embeds[addon]) end
+function AceAddon:IterateModulesOfAddon(addon) return pairs(addon.modules) end
+
+-- Blizzard AddOns which can load very early in the loading process and mess with Ace3 addon loading
+local BlizzardEarlyLoadAddons = {
+	Blizzard_DebugTools = true,
+	Blizzard_TimeManager = true,
+	Blizzard_BattlefieldMap = true,
+	Blizzard_MapCanvas = true,
+	Blizzard_SharedMapDataProviders = true,
+	Blizzard_CombatLog = true,
+}
+
+-- Event Handling
+local function onEvent(this, event, arg1)
+	-- 2020-08-28 nevcairiel - ignore the load event of Blizzard addons which occur early in the loading process
+	if (event == "ADDON_LOADED"  and (arg1 == nil or not BlizzardEarlyLoadAddons[arg1])) or event == "PLAYER_LOGIN" then
+		-- if a addon loads another addon, recursion could happen here, so we need to validate the table on every iteration
+		while(#AceAddon.initializequeue > 0) do
+			local addon = tremove(AceAddon.initializequeue, 1)
+			-- this might be an issue with recursion - TODO: validate
+			if event == "ADDON_LOADED" then addon.baseName = arg1 end
+			AceAddon:InitializeAddon(addon)
+			tinsert(AceAddon.enablequeue, addon)
+		end
+
+		if IsLoggedIn() then
+			while(#AceAddon.enablequeue > 0) do
+				local addon = tremove(AceAddon.enablequeue, 1)
+				AceAddon:EnableAddon(addon)
+			end
+		end
+	end
+end
+
+AceAddon.frame:RegisterEvent("ADDON_LOADED")
+AceAddon.frame:RegisterEvent("PLAYER_LOGIN")
+AceAddon.frame:SetScript("OnEvent", onEvent)
+
+-- upgrade embeded
+for name, addon in pairs(AceAddon.addons) do
+	Embed(addon, true)
+end
+
+-- 2010-10-27 nevcairiel - add new "orderedModules" table
+if oldminor and oldminor < 10 then
+	for name, addon in pairs(AceAddon.addons) do
+		addon.orderedModules = {}
+		for module_name, module in pairs(addon.modules) do
+			tinsert(addon.orderedModules, module)
+		end
+	end
+end

Libs/AceAddon-3.0/AceAddon-3.0.xml

@@ -0,0 +1,4 @@
+<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>

Libs/AceComm-3.0/AceComm-3.0.lua

@@ -0,0 +1,301 @@
+--- **AceComm-3.0** allows you to send messages of unlimited length over the addon comm channels.
+-- It'll automatically split the messages into multiple parts and rebuild them on the receiving end.\\
+-- **ChatThrottleLib** is of course being used to avoid being disconnected by the server.
+--
+-- **AceComm-3.0** can be embeded into your addon, either explicitly by calling AceComm: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 AceComm itself.\\
+-- It is recommended to embed AceComm, otherwise you'll have to specify a custom `self` on all calls you
+-- make into AceComm.
+-- @class file
+-- @name AceComm-3.0
+-- @release $Id: AceComm-3.0.lua 1333 2024-05-05 16:24:39Z nevcairiel $
+
+--[[ AceComm-3.0
+
+TODO: Time out old data rotting around from dead senders? Not a HUGE deal since the number of possible sender names is somewhat limited.
+
+]]
+
+local CallbackHandler = LibStub("CallbackHandler-1.0")
+local CTL = assert(ChatThrottleLib, "AceComm-3.0 requires ChatThrottleLib")
+
+local MAJOR, MINOR = "AceComm-3.0", 14
+local AceComm,oldminor = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceComm then return end
+
+-- Lua APIs
+local type, next, pairs, tostring = type, next, pairs, tostring
+local strsub, strfind = string.sub, string.find
+local match = string.match
+local tinsert, tconcat = table.insert, table.concat
+local error, assert = error, assert
+
+-- WoW APIs
+local Ambiguate = Ambiguate
+
+AceComm.embeds = AceComm.embeds or {}
+
+-- for my sanity and yours, let's give the message type bytes some names
+local MSG_MULTI_FIRST = "\001"
+local MSG_MULTI_NEXT  = "\002"
+local MSG_MULTI_LAST  = "\003"
+local MSG_ESCAPE = "\004"
+
+-- remove old structures (pre WoW 4.0)
+AceComm.multipart_origprefixes = nil
+AceComm.multipart_reassemblers = nil
+
+-- the multipart message spool: indexed by a combination of sender+distribution+
+AceComm.multipart_spool = AceComm.multipart_spool or {}
+
+--- Register for Addon Traffic on a specified prefix
+-- @param prefix A printable character (\032-\255) classification of the message (typically AddonName or AddonNameEvent), max 16 characters
+-- @param method Callback to call on message reception: Function reference, or method name (string) to call on self. Defaults to "OnCommReceived"
+function AceComm:RegisterComm(prefix, method)
+	if method == nil then
+		method = "OnCommReceived"
+	end
+
+	if #prefix > 16 then -- TODO: 15?
+		error("AceComm:RegisterComm(prefix,method): prefix length is limited to 16 characters")
+	end
+	if C_ChatInfo then
+		C_ChatInfo.RegisterAddonMessagePrefix(prefix)
+	else
+		RegisterAddonMessagePrefix(prefix)
+	end
+
+	return AceComm._RegisterComm(self, prefix, method)	-- created by CallbackHandler
+end
+
+local warnedPrefix=false
+
+--- Send a message over the Addon Channel
+-- @param prefix A printable character (\032-\255) classification of the message (typically AddonName or AddonNameEvent)
+-- @param text Data to send, nils (\000) not allowed. Any length.
+-- @param distribution Addon channel, e.g. "RAID", "GUILD", etc; see SendAddonMessage API
+-- @param target Destination for some distributions; see SendAddonMessage API
+-- @param prio OPTIONAL: ChatThrottleLib priority, "BULK", "NORMAL" or "ALERT". Defaults to "NORMAL".
+-- @param callbackFn OPTIONAL: callback function to be called as each chunk is sent. receives 3 args: the user supplied arg (see next), the number of bytes sent so far, and the number of bytes total to send.
+-- @param callbackArg: OPTIONAL: first arg to the callback function. nil will be passed if not specified.
+function AceComm:SendCommMessage(prefix, text, distribution, target, prio, callbackFn, callbackArg)
+	prio = prio or "NORMAL"	-- pasta's reference implementation had different prio for singlepart and multipart, but that's a very bad idea since that can easily lead to out-of-sequence delivery!
+	if not( type(prefix)=="string" and
+			type(text)=="string" and
+			type(distribution)=="string" and
+			(target==nil or type(target)=="string" or type(target)=="number") and
+			(prio=="BULK" or prio=="NORMAL" or prio=="ALERT")
+		) then
+		error('Usage: SendCommMessage(addon, "prefix", "text", "distribution"[, "target"[, "prio"[, callbackFn, callbackarg]]])', 2)
+	end
+
+	local textlen = #text
+	local maxtextlen = 255  -- Yes, the max is 255 even if the dev post said 256. I tested. Char 256+ get silently truncated. /Mikk, 20110327
+	local queueName = prefix
+
+	local ctlCallback = nil
+	if callbackFn then
+		ctlCallback = function(sent, sendResult)
+			return callbackFn(callbackArg, sent, textlen, sendResult)
+		end
+	end
+
+	local forceMultipart
+	if match(text, "^[\001-\009]") then -- 4.1+: see if the first character is a control character
+		-- we need to escape the first character with a \004
+		if textlen+1 > maxtextlen then	-- would we go over the size limit?
+			forceMultipart = true	-- just make it multipart, no escape problems then
+		else
+			text = "\004" .. text
+		end
+	end
+
+	if not forceMultipart and textlen <= maxtextlen then
+		-- fits all in one message
+		CTL:SendAddonMessage(prio, prefix, text, distribution, target, queueName, ctlCallback, textlen)
+	else
+		maxtextlen = maxtextlen - 1	-- 1 extra byte for part indicator in prefix(4.0)/start of message(4.1)
+
+		-- first part
+		local chunk = strsub(text, 1, maxtextlen)
+		CTL:SendAddonMessage(prio, prefix, MSG_MULTI_FIRST..chunk, distribution, target, queueName, ctlCallback, maxtextlen)
+
+		-- continuation
+		local pos = 1+maxtextlen
+
+		while pos+maxtextlen <= textlen do
+			chunk = strsub(text, pos, pos+maxtextlen-1)
+			CTL:SendAddonMessage(prio, prefix, MSG_MULTI_NEXT..chunk, distribution, target, queueName, ctlCallback, pos+maxtextlen-1)
+			pos = pos + maxtextlen
+		end
+
+		-- final part
+		chunk = strsub(text, pos)
+		CTL:SendAddonMessage(prio, prefix, MSG_MULTI_LAST..chunk, distribution, target, queueName, ctlCallback, textlen)
+	end
+end
+
+
+----------------------------------------
+-- Message receiving
+----------------------------------------
+
+do
+	local compost = setmetatable({}, {__mode = "k"})
+	local function new()
+		local t = next(compost)
+		if t then
+			compost[t]=nil
+			for i=#t,3,-1 do	-- faster than pairs loop. don't even nil out 1/2 since they'll be overwritten
+				t[i]=nil
+			end
+			return t
+		end
+
+		return {}
+	end
+
+	local function lostdatawarning(prefix,sender,where)
+		DEFAULT_CHAT_FRAME:AddMessage(MAJOR..": Warning: lost network data regarding '"..tostring(prefix).."' from '"..tostring(sender).."' (in "..where..")")
+	end
+
+	function AceComm:OnReceiveMultipartFirst(prefix, message, distribution, sender)
+		local key = prefix.."\t"..distribution.."\t"..sender	-- a unique stream is defined by the prefix + distribution + sender
+		local spool = AceComm.multipart_spool
+
+		--[[
+		if spool[key] then
+			lostdatawarning(prefix,sender,"First")
+			-- continue and overwrite
+		end
+		--]]
+
+		spool[key] = message  -- plain string for now
+	end
+
+	function AceComm:OnReceiveMultipartNext(prefix, message, distribution, sender)
+		local key = prefix.."\t"..distribution.."\t"..sender	-- a unique stream is defined by the prefix + distribution + sender
+		local spool = AceComm.multipart_spool
+		local olddata = spool[key]
+
+		if not olddata then
+			--lostdatawarning(prefix,sender,"Next")
+			return
+		end
+
+		if type(olddata)~="table" then
+			-- ... but what we have is not a table. So make it one. (Pull a composted one if available)
+			local t = new()
+			t[1] = olddata    -- add old data as first string
+			t[2] = message    -- and new message as second string
+			spool[key] = t    -- and put the table in the spool instead of the old string
+		else
+			tinsert(olddata, message)
+		end
+	end
+
+	function AceComm:OnReceiveMultipartLast(prefix, message, distribution, sender)
+		local key = prefix.."\t"..distribution.."\t"..sender	-- a unique stream is defined by the prefix + distribution + sender
+		local spool = AceComm.multipart_spool
+		local olddata = spool[key]
+
+		if not olddata then
+			--lostdatawarning(prefix,sender,"End")
+			return
+		end
+
+		spool[key] = nil
+
+		if type(olddata) == "table" then
+			-- if we've received a "next", the spooled data will be a table for rapid & garbage-free tconcat
+			tinsert(olddata, message)
+			AceComm.callbacks:Fire(prefix, tconcat(olddata, ""), distribution, sender)
+			compost[olddata] = true
+		else
+			-- if we've only received a "first", the spooled data will still only be a string
+			AceComm.callbacks:Fire(prefix, olddata..message, distribution, sender)
+		end
+	end
+end
+
+
+
+
+
+
+----------------------------------------
+-- Embed CallbackHandler
+----------------------------------------
+
+if not AceComm.callbacks then
+	AceComm.callbacks = CallbackHandler:New(AceComm,
+						"_RegisterComm",
+						"UnregisterComm",
+						"UnregisterAllComm")
+end
+
+AceComm.callbacks.OnUsed = nil
+AceComm.callbacks.OnUnused = nil
+
+local function OnEvent(self, event, prefix, message, distribution, sender)
+	if event == "CHAT_MSG_ADDON" then
+		sender = Ambiguate(sender, "none")
+		local control, rest = match(message, "^([\001-\009])(.*)")
+		if control then
+			if control==MSG_MULTI_FIRST then
+				AceComm:OnReceiveMultipartFirst(prefix, rest, distribution, sender)
+			elseif control==MSG_MULTI_NEXT then
+				AceComm:OnReceiveMultipartNext(prefix, rest, distribution, sender)
+			elseif control==MSG_MULTI_LAST then
+				AceComm:OnReceiveMultipartLast(prefix, rest, distribution, sender)
+			elseif control==MSG_ESCAPE then
+				AceComm.callbacks:Fire(prefix, rest, distribution, sender)
+			else
+				-- unknown control character, ignore SILENTLY (dont warn unnecessarily about future extensions!)
+			end
+		else
+			-- single part: fire it off immediately and let CallbackHandler decide if it's registered or not
+			AceComm.callbacks:Fire(prefix, message, distribution, sender)
+		end
+	else
+		assert(false, "Received "..tostring(event).." event?!")
+	end
+end
+
+AceComm.frame = AceComm.frame or CreateFrame("Frame", "AceComm30Frame")
+AceComm.frame:SetScript("OnEvent", OnEvent)
+AceComm.frame:UnregisterAllEvents()
+AceComm.frame:RegisterEvent("CHAT_MSG_ADDON")
+
+
+----------------------------------------
+-- Base library stuff
+----------------------------------------
+
+local mixins = {
+	"RegisterComm",
+	"UnregisterComm",
+	"UnregisterAllComm",
+	"SendCommMessage",
+}
+
+-- Embeds AceComm-3.0 into the target object making the functions from the mixins list available on target:..
+-- @param target target object to embed AceComm-3.0 in
+function AceComm:Embed(target)
+	for k, v in pairs(mixins) do
+		target[v] = self[v]
+	end
+	self.embeds[target] = true
+	return target
+end
+
+function AceComm:OnEmbedDisable(target)
+	target:UnregisterAllComm()
+end
+
+-- Update embeds
+for target, v in pairs(AceComm.embeds) do
+	AceComm:Embed(target)
+end

Libs/AceComm-3.0/AceComm-3.0.xml

@@ -0,0 +1,5 @@
+<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="ChatThrottleLib.lua"/>
+	<Script file="AceComm-3.0.lua"/>
+</Ui>

Libs/AceComm-3.0/ChatThrottleLib.lua

@@ -0,0 +1,701 @@
+--
+-- ChatThrottleLib by Mikk
+--
+-- Manages AddOn chat output to keep player from getting kicked off.
+--
+-- ChatThrottleLib:SendChatMessage/:SendAddonMessage functions that accept
+-- a Priority ("BULK", "NORMAL", "ALERT") as well as prefix for SendChatMessage.
+--
+-- Priorities get an equal share of available bandwidth when fully loaded.
+-- Communication channels are separated on extension+chattype+destination and
+-- get round-robinned. (Destination only matters for whispers and channels,
+-- obviously)
+--
+-- Will install hooks for SendChatMessage and SendAddonMessage to measure
+-- bandwidth bypassing the library and use less bandwidth itself.
+--
+--
+-- Fully embeddable library. Just copy this file into your addon directory,
+-- add it to the .toc, and it's done.
+--
+-- Can run as a standalone addon also, but, really, just embed it! :-)
+--
+-- LICENSE: ChatThrottleLib is released into the Public Domain
+--
+
+local CTL_VERSION = 31
+
+local _G = _G
+
+if _G.ChatThrottleLib then
+	if _G.ChatThrottleLib.version >= CTL_VERSION then
+		-- There's already a newer (or same) version loaded. Buh-bye.
+		return
+	elseif not _G.ChatThrottleLib.securelyHooked then
+		print("ChatThrottleLib: Warning: There's an ANCIENT ChatThrottleLib.lua (pre-wow 2.0, <v16) in an addon somewhere. Get the addon updated or copy in a newer ChatThrottleLib.lua (>=v16) in it!")
+		-- ATTEMPT to unhook; this'll behave badly if someone else has hooked...
+		-- ... and if someone has securehooked, they can kiss that goodbye too... >.<
+		_G.SendChatMessage = _G.ChatThrottleLib.ORIG_SendChatMessage
+		if _G.ChatThrottleLib.ORIG_SendAddonMessage then
+			_G.SendAddonMessage = _G.ChatThrottleLib.ORIG_SendAddonMessage
+		end
+	end
+	_G.ChatThrottleLib.ORIG_SendChatMessage = nil
+	_G.ChatThrottleLib.ORIG_SendAddonMessage = nil
+end
+
+if not _G.ChatThrottleLib then
+	_G.ChatThrottleLib = {}
+end
+
+ChatThrottleLib = _G.ChatThrottleLib  -- in case some addon does "local ChatThrottleLib" above us and we're copypasted (AceComm-2, sigh)
+local ChatThrottleLib = _G.ChatThrottleLib
+
+ChatThrottleLib.version = CTL_VERSION
+
+
+
+------------------ TWEAKABLES -----------------
+
+ChatThrottleLib.MAX_CPS = 800			  -- 2000 seems to be safe if NOTHING ELSE is happening. let's call it 800.
+ChatThrottleLib.MSG_OVERHEAD = 40		-- Guesstimate overhead for sending a message; source+dest+chattype+protocolstuff
+
+ChatThrottleLib.BURST = 4000				-- WoW's server buffer seems to be about 32KB. 8KB should be safe, but seen disconnects on _some_ servers. Using 4KB now.
+
+ChatThrottleLib.MIN_FPS = 20				-- Reduce output CPS to half (and don't burst) if FPS drops below this value
+
+
+local setmetatable = setmetatable
+local table_remove = table.remove
+local tostring = tostring
+local GetTime = GetTime
+local math_min = math.min
+local math_max = math.max
+local next = next
+local strlen = string.len
+local GetFramerate = GetFramerate
+local unpack,type,pairs,wipe = unpack,type,pairs,table.wipe
+
+
+-----------------------------------------------------------------------
+-- Double-linked ring implementation
+
+local Ring = {}
+local RingMeta = { __index = Ring }
+
+function Ring:New()
+	local ret = {}
+	setmetatable(ret, RingMeta)
+	return ret
+end
+
+function Ring:Add(obj)	-- Append at the "far end" of the ring (aka just before the current position)
+	if self.pos then
+		obj.prev = self.pos.prev
+		obj.prev.next = obj
+		obj.next = self.pos
+		obj.next.prev = obj
+	else
+		obj.next = obj
+		obj.prev = obj
+		self.pos = obj
+	end
+end
+
+function Ring:Remove(obj)
+	obj.next.prev = obj.prev
+	obj.prev.next = obj.next
+	if self.pos == obj then
+		self.pos = obj.next
+		if self.pos == obj then
+			self.pos = nil
+		end
+	end
+end
+
+-- Note that this is local because there's no upgrade logic for existing ring
+-- metatables, and this isn't present on rings created in versions older than
+-- v25.
+local function Ring_Link(self, other)  -- Move and append all contents of another ring to this ring
+	if not self.pos then
+		-- This ring is empty, so just transfer ownership.
+		self.pos = other.pos
+		other.pos = nil
+	elseif other.pos then
+		-- Our tail should point to their head, and their tail to our head.
+		self.pos.prev.next, other.pos.prev.next = other.pos, self.pos
+		-- Our head should point to their tail, and their head to our tail.
+		self.pos.prev, other.pos.prev = other.pos.prev, self.pos.prev
+		other.pos = nil
+	end
+end
+
+
+
+-----------------------------------------------------------------------
+-- Recycling bin for pipes
+-- A pipe is a plain integer-indexed queue of messages
+-- Pipes normally live in Rings of pipes  (3 rings total, one per priority)
+
+ChatThrottleLib.PipeBin = nil -- pre-v19, drastically different
+local PipeBin = setmetatable({}, {__mode="k"})
+
+local function DelPipe(pipe)
+	PipeBin[pipe] = true
+end
+
+local function NewPipe()
+	local pipe = next(PipeBin)
+	if pipe then
+		wipe(pipe)
+		PipeBin[pipe] = nil
+		return pipe
+	end
+	return {}
+end
+
+
+
+
+-----------------------------------------------------------------------
+-- Recycling bin for messages
+
+ChatThrottleLib.MsgBin = nil -- pre-v19, drastically different
+local MsgBin = setmetatable({}, {__mode="k"})
+
+local function DelMsg(msg)
+	msg[1] = nil
+	-- there's more parameters, but they're very repetetive so the string pool doesn't suffer really, and it's faster to just not delete them.
+	MsgBin[msg] = true
+end
+
+local function NewMsg()
+	local msg = next(MsgBin)
+	if msg then
+		MsgBin[msg] = nil
+		return msg
+	end
+	return {}
+end
+
+
+-----------------------------------------------------------------------
+-- ChatThrottleLib:Init
+-- Initialize queues, set up frame for OnUpdate, etc
+
+
+function ChatThrottleLib:Init()
+
+	-- Set up queues
+	if not self.Prio then
+		self.Prio = {}
+		self.Prio["ALERT"] = { ByName = {}, Ring = Ring:New(), avail = 0 }
+		self.Prio["NORMAL"] = { ByName = {}, Ring = Ring:New(), avail = 0 }
+		self.Prio["BULK"] = { ByName = {}, Ring = Ring:New(), avail = 0 }
+	end
+
+	if not self.BlockedQueuesDelay then
+		-- v25: Add blocked queues to rings to handle new client throttles.
+		for _, Prio in pairs(self.Prio) do
+			Prio.Blocked = Ring:New()
+		end
+	end
+
+	-- v4: total send counters per priority
+	for _, Prio in pairs(self.Prio) do
+		Prio.nTotalSent = Prio.nTotalSent or 0
+	end
+
+	if not self.avail then
+		self.avail = 0 -- v5
+	end
+	if not self.nTotalSent then
+		self.nTotalSent = 0 -- v5
+	end
+
+
+	-- Set up a frame to get OnUpdate events
+	if not self.Frame then
+		self.Frame = CreateFrame("Frame")
+		self.Frame:Hide()
+	end
+	self.Frame:SetScript("OnUpdate", self.OnUpdate)
+	self.Frame:SetScript("OnEvent", self.OnEvent)	-- v11: Monitor P_E_W so we can throttle hard for a few seconds
+	self.Frame:RegisterEvent("PLAYER_ENTERING_WORLD")
+	self.OnUpdateDelay = 0
+	self.BlockedQueuesDelay = 0
+	self.LastAvailUpdate = GetTime()
+	self.HardThrottlingBeginTime = GetTime()	-- v11: Throttle hard for a few seconds after startup
+
+	-- Hook SendChatMessage and SendAddonMessage so we can measure unpiped traffic and avoid overloads (v7)
+	if not self.securelyHooked then
+		-- Use secure hooks as of v16. Old regular hook support yanked out in v21.
+		self.securelyHooked = true
+		--SendChatMessage
+		if _G.C_ChatInfo and _G.C_ChatInfo.SendChatMessage then
+			hooksecurefunc(_G.C_ChatInfo, "SendChatMessage", function(...)
+				return ChatThrottleLib.Hook_SendChatMessage(...)
+			end)
+		else
+			hooksecurefunc("SendChatMessage", function(...)
+				return ChatThrottleLib.Hook_SendChatMessage(...)
+			end)
+		end
+		--SendAddonMessage
+		hooksecurefunc(_G.C_ChatInfo, "SendAddonMessage", function(...)
+			return ChatThrottleLib.Hook_SendAddonMessage(...)
+		end)
+	end
+
+	-- v26: Hook SendAddonMessageLogged for traffic logging
+	if not self.securelyHookedLogged then
+		self.securelyHookedLogged = true
+		hooksecurefunc(_G.C_ChatInfo, "SendAddonMessageLogged", function(...)
+			return ChatThrottleLib.Hook_SendAddonMessageLogged(...)
+		end)
+	end
+
+	-- v29: Hook BNSendGameData for traffic logging
+	if not self.securelyHookedBNGameData then
+		self.securelyHookedBNGameData = true
+		if _G.C_BattleNet and _G.C_BattleNet.SendGameData then
+			hooksecurefunc(_G.C_BattleNet, "SendGameData", function(...)
+				return ChatThrottleLib.Hook_BNSendGameData(...)
+			end)
+		else
+			hooksecurefunc("BNSendGameData", function(...)
+				return ChatThrottleLib.Hook_BNSendGameData(...)
+			end)
+		end
+	end
+
+	self.nBypass = 0
+end
+
+
+-----------------------------------------------------------------------
+-- ChatThrottleLib.Hook_SendChatMessage / .Hook_SendAddonMessage
+
+local bMyTraffic = false
+
+function ChatThrottleLib.Hook_SendChatMessage(text, chattype, language, destination, ...)
+	if bMyTraffic then
+		return
+	end
+	local self = ChatThrottleLib
+	local size = strlen(tostring(text or "")) + strlen(tostring(destination or "")) + self.MSG_OVERHEAD
+	self.avail = self.avail - size
+	self.nBypass = self.nBypass + size	-- just a statistic
+end
+function ChatThrottleLib.Hook_SendAddonMessage(prefix, text, chattype, destination, ...)
+	if bMyTraffic then
+		return
+	end
+	local self = ChatThrottleLib
+	local size = tostring(text or ""):len() + tostring(prefix or ""):len();
+	size = size + tostring(destination or ""):len() + self.MSG_OVERHEAD
+	self.avail = self.avail - size
+	self.nBypass = self.nBypass + size	-- just a statistic
+end
+function ChatThrottleLib.Hook_SendAddonMessageLogged(prefix, text, chattype, destination, ...)
+	ChatThrottleLib.Hook_SendAddonMessage(prefix, text, chattype, destination, ...)
+end
+function ChatThrottleLib.Hook_BNSendGameData(destination, prefix, text)
+	ChatThrottleLib.Hook_SendAddonMessage(prefix, text, "WHISPER", destination)
+end
+
+
+
+-----------------------------------------------------------------------
+-- ChatThrottleLib:UpdateAvail
+-- Update self.avail with how much bandwidth is currently available
+
+function ChatThrottleLib:UpdateAvail()
+	local now = GetTime()
+	local MAX_CPS = self.MAX_CPS;
+	local newavail = MAX_CPS * (now - self.LastAvailUpdate)
+	local avail = self.avail
+
+	if now - self.HardThrottlingBeginTime < 5 then
+		-- First 5 seconds after startup/zoning: VERY hard clamping to avoid irritating the server rate limiter, it seems very cranky then
+		avail = math_min(avail + (newavail*0.1), MAX_CPS*0.5)
+		self.bChoking = true
+	elseif GetFramerate() < self.MIN_FPS then		-- GetFrameRate call takes ~0.002 secs
+		avail = math_min(MAX_CPS, avail + newavail*0.5)
+		self.bChoking = true		-- just a statistic
+	else
+		avail = math_min(self.BURST, avail + newavail)
+		self.bChoking = false
+	end
+
+	avail = math_max(avail, 0-(MAX_CPS*2))	-- Can go negative when someone is eating bandwidth past the lib. but we refuse to stay silent for more than 2 seconds; if they can do it, we can.
+
+	self.avail = avail
+	self.LastAvailUpdate = now
+
+	return avail
+end
+
+
+-----------------------------------------------------------------------
+-- Despooling logic
+-- Reminder:
+-- - We have 3 Priorities, each containing a "Ring" construct ...
+-- - ... made up of N "Pipe"s (1 for each destination/pipename)
+-- - and each pipe contains messages
+
+local SendAddonMessageResult = Enum.SendAddonMessageResult or {
+	Success = 0,
+	AddonMessageThrottle = 3,
+	NotInGroup = 5,
+	ChannelThrottle = 8,
+	GeneralError = 9,
+}
+
+local function MapToSendResult(ok, ...)
+	local result
+
+	if not ok then
+		-- The send function itself errored; don't look at anything else.
+		result = SendAddonMessageResult.GeneralError
+	else
+		-- Grab the last return value from the send function and remap
+		-- it from a boolean to an enum code. If there are no results,
+		-- assume success (true).
+
+		result = select(-1, true, ...)
+
+		if result == true then
+			result = SendAddonMessageResult.Success
+		elseif result == false then
+			result = SendAddonMessageResult.GeneralError
+		end
+	end
+
+	return result
+end
+
+local function IsThrottledSendResult(result)
+	return result == SendAddonMessageResult.AddonMessageThrottle
+end
+
+-- A copy of this function exists in FrameXML, but for clarity it's here too.
+local function CallErrorHandler(...)
+	return geterrorhandler()(...)
+end
+
+local function PerformSend(sendFunction, ...)
+	bMyTraffic = true
+	local sendResult = MapToSendResult(xpcall(sendFunction, CallErrorHandler, ...))
+	bMyTraffic = false
+	return sendResult
+end
+
+function ChatThrottleLib:Despool(Prio)
+	local ring = Prio.Ring
+	while ring.pos and Prio.avail > ring.pos[1].nSize do
+		local pipe = ring.pos
+		local msg = pipe[1]
+		local sendResult = PerformSend(msg.f, unpack(msg, 1, msg.n))
+
+		if IsThrottledSendResult(sendResult) then
+			-- Message was throttled; move the pipe into the blocked ring.
+			Prio.Ring:Remove(pipe)
+			Prio.Blocked:Add(pipe)
+		else
+			-- Dequeue message after submission.
+			table_remove(pipe, 1)
+			DelMsg(msg)
+
+			if not pipe[1] then  -- did we remove last msg in this pipe?
+				Prio.Ring:Remove(pipe)
+				Prio.ByName[pipe.name] = nil
+				DelPipe(pipe)
+			else
+				ring.pos = ring.pos.next
+			end
+
+			-- Update bandwidth counters on successful sends.
+			local didSend = (sendResult == SendAddonMessageResult.Success)
+			if didSend then
+				Prio.avail = Prio.avail - msg.nSize
+				Prio.nTotalSent = Prio.nTotalSent + msg.nSize
+			end
+
+			-- Notify caller of message submission.
+			if msg.callbackFn then
+				securecallfunction(msg.callbackFn, msg.callbackArg, didSend, sendResult)
+			end
+		end
+	end
+end
+
+
+function ChatThrottleLib.OnEvent(this,event)
+	-- v11: We know that the rate limiter is touchy after login. Assume that it's touchy after zoning, too.
+	local self = ChatThrottleLib
+	if event == "PLAYER_ENTERING_WORLD" then
+		self.HardThrottlingBeginTime = GetTime()	-- Throttle hard for a few seconds after zoning
+		self.avail = 0
+	end
+end
+
+
+function ChatThrottleLib.OnUpdate(this,delay)
+	local self = ChatThrottleLib
+
+	self.OnUpdateDelay = self.OnUpdateDelay + delay
+	self.BlockedQueuesDelay = self.BlockedQueuesDelay + delay
+	if self.OnUpdateDelay < 0.08 then
+		return
+	end
+	self.OnUpdateDelay = 0
+
+	self:UpdateAvail()
+
+	if self.avail < 0  then
+		return -- argh. some bastard is spewing stuff past the lib. just bail early to save cpu.
+	end
+
+	-- Integrate blocked queues back into their rings periodically.
+	if self.BlockedQueuesDelay >= 0.35 then
+		for _, Prio in pairs(self.Prio) do
+			Ring_Link(Prio.Ring, Prio.Blocked)
+		end
+
+		self.BlockedQueuesDelay = 0
+	end
+
+	-- See how many of our priorities have queued messages. This is split
+	-- into two counters because priorities that consist only of blocked
+	-- queues must keep our OnUpdate alive, but shouldn't count toward
+	-- bandwidth distribution.
+	local nSendablePrios = 0
+	local nBlockedPrios = 0
+
+	for prioname, Prio in pairs(self.Prio) do
+		if Prio.Ring.pos then
+			nSendablePrios = nSendablePrios + 1
+		elseif Prio.Blocked.pos then
+			nBlockedPrios = nBlockedPrios + 1
+		end
+
+		-- Collect unused bandwidth from priorities with nothing to send.
+		if not Prio.Ring.pos then
+			self.avail = self.avail + Prio.avail
+			Prio.avail = 0
+		end
+	end
+
+	-- Bandwidth reclamation may take us back over the burst cap.
+	self.avail = math_min(self.avail, self.BURST)
+
+	-- If we can't currently send on any priorities, stop processing early.
+	if nSendablePrios == 0 then
+		-- If we're completely out of data to send, disable queue processing.
+		if nBlockedPrios == 0 then
+			self.bQueueing = false
+			self.Frame:Hide()
+		end
+
+		return
+	end
+
+	-- There's stuff queued. Hand out available bandwidth to priorities as needed and despool their queues
+	local avail = self.avail / nSendablePrios
+	self.avail = 0
+
+	for prioname, Prio in pairs(self.Prio) do
+		if Prio.Ring.pos then
+			Prio.avail = Prio.avail + avail
+			self:Despool(Prio)
+		end
+	end
+end
+
+
+
+
+-----------------------------------------------------------------------
+-- Spooling logic
+
+function ChatThrottleLib:Enqueue(prioname, pipename, msg)
+	local Prio = self.Prio[prioname]
+	local pipe = Prio.ByName[pipename]
+	if not pipe then
+		self.Frame:Show()
+		pipe = NewPipe()
+		pipe.name = pipename
+		Prio.ByName[pipename] = pipe
+		Prio.Ring:Add(pipe)
+	end
+
+	pipe[#pipe + 1] = msg
+
+	self.bQueueing = true
+end
+
+function ChatThrottleLib:SendChatMessage(prio, prefix,   text, chattype, language, destination, queueName, callbackFn, callbackArg)
+	if not self or not prio or not prefix or not text or not self.Prio[prio] then
+		error('Usage: ChatThrottleLib:SendChatMessage("{BULK||NORMAL||ALERT}", "prefix", "text"[, "chattype"[, "language"[, "destination"]]]', 2)
+	end
+	if callbackFn and type(callbackFn)~="function" then
+		error('ChatThrottleLib:ChatMessage(): callbackFn: expected function, got '..type(callbackFn), 2)
+	end
+
+	local nSize = text:len()
+
+	if nSize>255 then
+		error("ChatThrottleLib:SendChatMessage(): message length cannot exceed 255 bytes", 2)
+	end
+
+	nSize = nSize + self.MSG_OVERHEAD
+
+	-- Check if there's room in the global available bandwidth gauge to send directly
+	if not self.bQueueing and nSize < self:UpdateAvail() then
+		local sendResult = PerformSend(_G.C_ChatInfo.SendChatMessage or _G.SendChatMessage, text, chattype, language, destination)
+
+		if not IsThrottledSendResult(sendResult) then
+			local didSend = (sendResult == SendAddonMessageResult.Success)
+
+			if didSend then
+				self.avail = self.avail - nSize
+				self.Prio[prio].nTotalSent = self.Prio[prio].nTotalSent + nSize
+			end
+
+			if callbackFn then
+				securecallfunction(callbackFn, callbackArg, didSend, sendResult)
+			end
+
+			return
+		end
+	end
+
+	-- Message needs to be queued
+	local msg = NewMsg()
+	msg.f = _G.C_ChatInfo.SendChatMessage or _G.SendChatMessage
+	msg[1] = text
+	msg[2] = chattype or "SAY"
+	msg[3] = language
+	msg[4] = destination
+	msg.n = 4
+	msg.nSize = nSize
+	msg.callbackFn = callbackFn
+	msg.callbackArg = callbackArg
+
+	self:Enqueue(prio, queueName or prefix, msg)
+end
+
+
+local function SendAddonMessageInternal(self, sendFunction, prio, prefix, text, chattype, target, queueName, callbackFn, callbackArg)
+	local nSize = #text + self.MSG_OVERHEAD
+
+	-- Check if there's room in the global available bandwidth gauge to send directly
+	if not self.bQueueing and nSize < self:UpdateAvail() then
+		local sendResult = PerformSend(sendFunction, prefix, text, chattype, target)
+
+		if not IsThrottledSendResult(sendResult) then
+			local didSend = (sendResult == SendAddonMessageResult.Success)
+
+			if didSend then
+				self.avail = self.avail - nSize
+				self.Prio[prio].nTotalSent = self.Prio[prio].nTotalSent + nSize
+			end
+
+			if callbackFn then
+				securecallfunction(callbackFn, callbackArg, didSend, sendResult)
+			end
+
+			return
+		end
+	end
+
+	-- Message needs to be queued
+	local msg = NewMsg()
+	msg.f = sendFunction
+	msg[1] = prefix
+	msg[2] = text
+	msg[3] = chattype
+	msg[4] = target
+	msg.n = (target~=nil) and 4 or 3;
+	msg.nSize = nSize
+	msg.callbackFn = callbackFn
+	msg.callbackArg = callbackArg
+
+	self:Enqueue(prio, queueName or prefix, msg)
+end
+
+
+function ChatThrottleLib:SendAddonMessage(prio, prefix, text, chattype, target, queueName, callbackFn, callbackArg)
+	if not self or not prio or not prefix or not text or not chattype or not self.Prio[prio] then
+		error('Usage: ChatThrottleLib:SendAddonMessage("{BULK||NORMAL||ALERT}", "prefix", "text", "chattype"[, "target"])', 2)
+	elseif callbackFn and type(callbackFn)~="function" then
+		error('ChatThrottleLib:SendAddonMessage(): callbackFn: expected function, got '..type(callbackFn), 2)
+	elseif #text>255 then
+		error("ChatThrottleLib:SendAddonMessage(): message length cannot exceed 255 bytes", 2)
+	end
+
+	local sendFunction = _G.C_ChatInfo.SendAddonMessage
+	SendAddonMessageInternal(self, sendFunction, prio, prefix, text, chattype, target, queueName, callbackFn, callbackArg)
+end
+
+
+function ChatThrottleLib:SendAddonMessageLogged(prio, prefix, text, chattype, target, queueName, callbackFn, callbackArg)
+	if not self or not prio or not prefix or not text or not chattype or not self.Prio[prio] then
+		error('Usage: ChatThrottleLib:SendAddonMessageLogged("{BULK||NORMAL||ALERT}", "prefix", "text", "chattype"[, "target"])', 2)
+	elseif callbackFn and type(callbackFn)~="function" then
+		error('ChatThrottleLib:SendAddonMessageLogged(): callbackFn: expected function, got '..type(callbackFn), 2)
+	elseif #text>255 then
+		error("ChatThrottleLib:SendAddonMessageLogged(): message length cannot exceed 255 bytes", 2)
+	end
+
+	local sendFunction = _G.C_ChatInfo.SendAddonMessageLogged
+	SendAddonMessageInternal(self, sendFunction, prio, prefix, text, chattype, target, queueName, callbackFn, callbackArg)
+end
+
+local function BNSendGameDataReordered(prefix, text, _, gameAccountID)
+	local bnSendFunc = _G.C_BattleNet and _G.C_BattleNet.SendGameData or _G.BNSendGameData
+	return bnSendFunc(gameAccountID, prefix, text)
+end
+
+function ChatThrottleLib:BNSendGameData(prio, prefix, text, chattype, gameAccountID, queueName, callbackFn, callbackArg)
+	-- Note that this API is intentionally limited to 255 bytes of data
+	-- for reasons of traffic fairness, which is less than the 4078 bytes
+	-- BNSendGameData natively supports. Additionally, a chat type is required
+	-- but must always be set to 'WHISPER' to match what is exposed by the
+	-- receipt event.
+	--
+	-- If splitting messages, callers must also be aware that message
+	-- delivery over BNSendGameData is unordered.
+
+	if not self or not prio or not prefix or not text or not gameAccountID or not chattype or not self.Prio[prio] then
+		error('Usage: ChatThrottleLib:BNSendGameData("{BULK||NORMAL||ALERT}", "prefix", "text", "chattype", gameAccountID)', 2)
+	elseif callbackFn and type(callbackFn)~="function" then
+		error('ChatThrottleLib:BNSendGameData(): callbackFn: expected function, got '..type(callbackFn), 2)
+	elseif #text>255 then
+		error("ChatThrottleLib:BNSendGameData(): message length cannot exceed 255 bytes", 2)
+	elseif chattype ~= "WHISPER" then
+		error("ChatThrottleLib:BNSendGameData(): chat type must be 'WHISPER'", 2)
+	end
+
+	local sendFunction = BNSendGameDataReordered
+	SendAddonMessageInternal(self, sendFunction, prio, prefix, text, chattype, gameAccountID, queueName, callbackFn, callbackArg)
+end
+
+
+-----------------------------------------------------------------------
+-- Get the ball rolling!
+
+ChatThrottleLib:Init()
+
+--[[ WoWBench debugging snippet
+if(WOWB_VER) then
+	local function SayTimer()
+		print("SAY: "..GetTime().." "..arg1)
+	end
+	ChatThrottleLib.Frame:SetScript("OnEvent", SayTimer)
+	ChatThrottleLib.Frame:RegisterEvent("CHAT_MSG_SAY")
+end
+]]
+
+

Libs/AceConfig-3.0/AceConfig-3.0.lua

@@ -0,0 +1,58 @@
+--- 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 1335 2024-05-05 19:35:16Z nevcairiel $
+
+--[[
+AceConfig-3.0
+
+Very light wrapper library that combines all the AceConfig subcomponents into one more easily used whole.
+
+]]
+
+local cfgreg = LibStub("AceConfigRegistry-3.0")
+local cfgcmd = LibStub("AceConfigCmd-3.0")
+
+local MAJOR, MINOR = "AceConfig-3.0", 3
+local AceConfig = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceConfig then return end
+
+--TODO: local cfgdlg = LibStub("AceConfigDialog-3.0", true)
+--TODO: local cfgdrp = LibStub("AceConfigDropdown-3.0", true)
+
+-- Lua APIs
+local pcall, error, type, pairs = pcall, error, type, pairs
+
+-- -------------------------------------------------------------------
+-- :RegisterOptionsTable(appName, options, slashcmd)
+--
+-- - 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).  http://www.wowace.com/addons/ace3/pages/ace-config-3-0-options-tables/
+-- @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

Libs/AceConfig-3.0/AceConfig-3.0.xml

@@ -0,0 +1,8 @@
+<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>

Libs/AceConfig-3.0/AceConfigCmd-3.0/AceConfigCmd-3.0.lua

@@ -0,0 +1,787 @@
+--- 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 1284 2022-09-25 09:15:30Z nevcairiel $
+
+--[[
+AceConfigCmd-3.0
+
+Handles commandline optionstable access
+
+REQUIRES: AceConsole-3.0 for command registration (loaded on demand)
+
+]]
+
+-- TODO: plugin args
+
+local cfgreg = LibStub("AceConfigRegistry-3.0")
+
+local MAJOR, MINOR = "AceConfigCmd-3.0", 14
+local AceConfigCmd = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceConfigCmd then return end
+
+AceConfigCmd.commands = AceConfigCmd.commands or {}
+local commands = AceConfigCmd.commands
+
+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
+
+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 strInput = 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 type(tab.pattern)~="string" then err(info, inputpos, "'pattern' - expected a string") end
+			if not strmatch(strInput, tab.pattern) then
+				usererr(info, inputpos, "'"..strInput.."' - " .. L["invalid input"])
+				return
+			end
+		end
+
+		do_final(info, inputpos, tab, "set", strInput)
+
+
+
+	elseif tab.type=="toggle" then
+		------------ toggle --------------------------------------------
+		local b
+		local str = strtrim(strlower(strInput))
+		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(strInput)
+		if not val then
+			usererr(info, inputpos, "'"..strInput.."' - "..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(strInput))
+
+		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(strInput))
+
+		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 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(strInput))
+		if str == "" then
+			--TODO: Show current value
+			return
+		end
+
+		local r, g, b, a
+
+		local hasAlpha = tab.hasAlpha
+		if type(hasAlpha) == "function" or type(hasAlpha) == "string" then
+			info.hasAlpha = hasAlpha
+			hasAlpha = callmethod(info, inputpos, tab, 'hasAlpha')
+			info.hasAlpha = nil
+		end
+
+		if 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(strInput))
+		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

Libs/AceConfig-3.0/AceConfigCmd-3.0/AceConfigCmd-3.0.xml

@@ -0,0 +1,4 @@
+<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>

Libs/AceConfig-3.0/AceConfigDialog-3.0/AceConfigDialog-3.0.xml

@@ -0,0 +1,4 @@
+<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>

Libs/AceConfig-3.0/AceConfigRegistry-3.0/AceConfigRegistry-3.0.lua

@@ -0,0 +1,373 @@
+--- AceConfigRegistry-3.0 handles central registration of options tables in use by addons and modules.\\
+-- Options tables can be registered as raw tables, OR as function refs that return a table.\\
+-- Such functions receive three arguments: "uiType", "uiName", "appName". \\
+-- * Valid **uiTypes**: "cmd", "dropdown", "dialog". This is verified by the library at call time. \\
+-- * The **uiName** field is expected to contain the full name of the calling addon, including version, e.g. "FooBar-1.0". This is verified by the library at call time.\\
+-- * The **appName** field is the options table name as given at registration time \\
+--
+-- :IterateOptionsTables() (and :GetOptionsTable() if only given one argument) return a function reference that the requesting config handling addon must call with valid "uiType", "uiName".
+-- @class file
+-- @name AceConfigRegistry-3.0
+-- @release $Id: AceConfigRegistry-3.0.lua 1385 2025-12-06 11:26:20Z nevcairiel $
+local CallbackHandler = LibStub("CallbackHandler-1.0")
+
+local MAJOR, MINOR = "AceConfigRegistry-3.0", 22
+local AceConfigRegistry = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceConfigRegistry then return end
+
+AceConfigRegistry.tables = AceConfigRegistry.tables or {}
+
+if not AceConfigRegistry.callbacks then
+	AceConfigRegistry.callbacks = CallbackHandler:New(AceConfigRegistry)
+end
+
+-- Lua APIs
+local tinsert, tconcat = table.insert, table.concat
+local strfind, strmatch = string.find, string.match
+local type, tostring, select, pairs = type, tostring, select, pairs
+local error, assert = error, assert
+
+-----------------------------------------------------------------------
+-- Validating options table consistency:
+
+
+AceConfigRegistry.validated = {
+	-- list of options table names ran through :ValidateOptionsTable automatically.
+	-- CLEARED ON PURPOSE, since newer versions may have newer validators
+	cmd = {},
+	dropdown = {},
+	dialog = {},
+}
+
+
+
+local function err(msg, errlvl, ...)
+	local t = {}
+	for i=select("#",...),1,-1 do
+		tinsert(t, (select(i, ...)))
+	end
+	error(MAJOR..":ValidateOptionsTable(): "..tconcat(t,".")..msg, errlvl+2)
+end
+
+
+local isstring={["string"]=true, _="string"}
+local isstringfunc={["string"]=true,["function"]=true, _="string or funcref"}
+local istable={["table"]=true,   _="table"}
+local ismethodtable={["table"]=true,["string"]=true,["function"]=true,   _="methodname, funcref or table"}
+local optstring={["nil"]=true,["string"]=true, _="string"}
+local optstringfunc={["nil"]=true,["string"]=true,["function"]=true, _="string or funcref"}
+local optstringnumberfunc={["nil"]=true,["string"]=true,["number"]=true,["function"]=true, _="string, number or funcref"}
+local optnumber={["nil"]=true,["number"]=true, _="number"}
+local optmethodfalse={["nil"]=true,["string"]=true,["function"]=true,["boolean"]={[false]=true},  _="methodname, funcref or false"}
+local optmethodnumber={["nil"]=true,["string"]=true,["function"]=true,["number"]=true,  _="methodname, funcref or number"}
+local optmethodtable={["nil"]=true,["string"]=true,["function"]=true,["table"]=true,  _="methodname, funcref or table"}
+local optmethodbool={["nil"]=true,["string"]=true,["function"]=true,["boolean"]=true,  _="methodname, funcref or boolean"}
+local opttable={["nil"]=true,["table"]=true,  _="table"}
+local optbool={["nil"]=true,["boolean"]=true,  _="boolean"}
+local optboolnumber={["nil"]=true,["boolean"]=true,["number"]=true,  _="boolean or number"}
+local optstringnumber={["nil"]=true,["string"]=true,["number"]=true, _="string or number"}
+
+local basekeys={
+	type=isstring,
+	name=isstringfunc,
+	desc=optstringfunc,
+	descStyle=optstring,
+	order=optmethodnumber,
+	validate=optmethodfalse,
+	confirm=optmethodbool,
+	confirmText=optstring,
+	disabled=optmethodbool,
+	hidden=optmethodbool,
+		guiHidden=optmethodbool,
+		dialogHidden=optmethodbool,
+		dropdownHidden=optmethodbool,
+	cmdHidden=optmethodbool,
+	tooltipHyperlink=optstringfunc,
+	icon=optstringnumberfunc,
+	iconCoords=optmethodtable,
+	handler=opttable,
+	get=optmethodfalse,
+	set=optmethodfalse,
+	func=optmethodfalse,
+	arg={["*"]=true},
+	width=optstringnumber,
+	relWidth=optnumber,
+}
+
+local typedkeys={
+	header={
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+	},
+	description={
+		image=optstringnumberfunc,
+		imageCoords=optmethodtable,
+		imageHeight=optnumber,
+		imageWidth=optnumber,
+		fontSize=optstringfunc,
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+	},
+	group={
+		args=istable,
+		plugins=opttable,
+		inline=optbool,
+			cmdInline=optbool,
+			guiInline=optbool,
+			dropdownInline=optbool,
+			dialogInline=optbool,
+		childGroups=optstring,
+	},
+	execute={
+		image=optstringnumberfunc,
+		imageCoords=optmethodtable,
+		imageHeight=optnumber,
+		imageWidth=optnumber,
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+	},
+	input={
+		pattern=optstring,
+		usage=optstring,
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+		multiline=optboolnumber,
+	},
+	toggle={
+		tristate=optbool,
+		image=optstringnumberfunc,
+		imageCoords=optmethodtable,
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+	},
+	tristate={
+	},
+	range={
+		min=optnumber,
+		softMin=optnumber,
+		max=optnumber,
+		softMax=optnumber,
+		step=optnumber,
+		bigStep=optnumber,
+		isPercent=optbool,
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+	},
+	select={
+		values=ismethodtable,
+		sorting=optmethodtable,
+		style={
+			["nil"]=true,
+			["string"]={dropdown=true,radio=true},
+			_="string: 'dropdown' or 'radio'"
+		},
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+		itemControl=optstring,
+	},
+	multiselect={
+		values=ismethodtable,
+		style=optstring,
+		tristate=optbool,
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+	},
+	color={
+		hasAlpha=optmethodbool,
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+	},
+	keybinding={
+		control=optstring,
+		dialogControl=optstring,
+		dropdownControl=optstring,
+	},
+}
+
+local function validateKey(k,errlvl,...)
+	errlvl=(errlvl or 0)+1
+	if type(k)~="string" then
+		err("["..tostring(k).."] - key is not a string", errlvl,...)
+	end
+	if strfind(k, "[%c\127]") then
+		err("["..tostring(k).."] - key name contained control characters", errlvl,...)
+	end
+end
+
+local function validateVal(v, oktypes, errlvl,...)
+	errlvl=(errlvl or 0)+1
+	local isok=oktypes[type(v)] or oktypes["*"]
+
+	if not isok then
+		err(": expected a "..oktypes._..", got '"..tostring(v).."'", errlvl,...)
+	end
+	if type(isok)=="table" then		-- isok was a table containing specific values to be tested for!
+		if not isok[v] then
+			err(": did not expect "..type(v).." value '"..tostring(v).."'", errlvl,...)
+		end
+	end
+end
+
+local function validate(options,errlvl,...)
+	errlvl=(errlvl or 0)+1
+	-- basic consistency
+	if type(options)~="table" then
+		err(": expected a table, got a "..type(options), errlvl,...)
+	end
+	if type(options.type)~="string" then
+		err(".type: expected a string, got a "..type(options.type), errlvl,...)
+	end
+
+	-- get type and 'typedkeys' member
+	local tk = typedkeys[options.type]
+	if not tk then
+		err(".type: unknown type '"..options.type.."'", errlvl,...)
+	end
+
+	-- make sure that all options[] are known parameters
+	for k,v in pairs(options) do
+		if not (tk[k] or basekeys[k]) then
+			err(": unknown parameter", errlvl,tostring(k),...)
+		end
+	end
+
+	-- verify that required params are there, and that everything is the right type
+	for k,oktypes in pairs(basekeys) do
+		validateVal(options[k], oktypes, errlvl,k,...)
+	end
+	for k,oktypes in pairs(tk) do
+		validateVal(options[k], oktypes, errlvl,k,...)
+	end
+
+	-- extra logic for groups
+	if options.type=="group" then
+		for k,v in pairs(options.args) do
+			validateKey(k,errlvl,"args",...)
+			validate(v, errlvl,k,"args",...)
+		end
+		if options.plugins then
+			for plugname,plugin in pairs(options.plugins) do
+				if type(plugin)~="table" then
+					err(": expected a table, got '"..tostring(plugin).."'", errlvl,tostring(plugname),"plugins",...)
+				end
+				for k,v in pairs(plugin) do
+					validateKey(k,errlvl,tostring(plugname),"plugins",...)
+					validate(v, errlvl,k,tostring(plugname),"plugins",...)
+				end
+			end
+		end
+	end
+end
+
+
+--- Validates basic structure and integrity of an options table \\
+-- Does NOT verify that get/set etc actually exist, since they can be defined at any depth
+-- @param options The table to be validated
+-- @param name The name of the table to be validated (shown in any error message)
+-- @param errlvl (optional number) error level offset, default 0 (=errors point to the function calling :ValidateOptionsTable)
+function AceConfigRegistry:ValidateOptionsTable(options,name,errlvl)
+	errlvl=(errlvl or 0)+1
+	name = name or "Optionstable"
+	if not options.name then
+		options.name=name	-- bit of a hack, the root level doesn't really need a .name :-/
+	end
+	validate(options,errlvl,name)
+end
+
+--- Fires a "ConfigTableChange" callback for those listening in on it, allowing config GUIs to refresh.
+-- You should call this function if your options table changed from any outside event, like a game event
+-- or a timer.
+-- @param appName The application name as given to `:RegisterOptionsTable()`
+function AceConfigRegistry:NotifyChange(appName)
+	if not AceConfigRegistry.tables[appName] then return end
+	AceConfigRegistry.callbacks:Fire("ConfigTableChange", appName)
+end
+
+-- -------------------------------------------------------------------
+-- Registering and retreiving options tables:
+
+
+-- validateGetterArgs: helper function for :GetOptionsTable (or, rather, the getter functions returned by it)
+
+local function validateGetterArgs(uiType, uiName, errlvl)
+	errlvl=(errlvl or 0)+2
+	if uiType~="cmd" and uiType~="dropdown" and uiType~="dialog" then
+		error(MAJOR..": Requesting options table: 'uiType' - invalid configuration UI type, expected 'cmd', 'dropdown' or 'dialog'", errlvl)
+	end
+	if not strmatch(uiName, "[A-Za-z]%-[0-9]") then	-- Expecting e.g. "MyLib-1.2"
+		error(MAJOR..": Requesting options table: 'uiName' - badly formatted or missing version number. Expected e.g. 'MyLib-1.2'", errlvl)
+	end
+end
+
+--- Register an options table with the config registry.
+-- @param appName The application name as given to `:RegisterOptionsTable()`
+-- @param options The options table, OR a function reference that generates it on demand. \\
+-- See the top of the page for info on arguments passed to such functions.
+-- @param skipValidation Skip options table validation (primarily useful for extremely huge options, with a noticeable slowdown)
+function AceConfigRegistry:RegisterOptionsTable(appName, options, skipValidation)
+	if type(options)=="table" then
+		if options.type~="group" then	-- quick sanity checker
+			error(MAJOR..": RegisterOptionsTable(appName, options): 'options' - missing type='group' member in root group", 2)
+		end
+		AceConfigRegistry.tables[appName] = function(uiType, uiName, errlvl)
+			errlvl=(errlvl or 0)+1
+			validateGetterArgs(uiType, uiName, errlvl)
+			if not AceConfigRegistry.validated[uiType][appName] and not skipValidation then
+				AceConfigRegistry:ValidateOptionsTable(options, appName, errlvl)	-- upgradable
+				AceConfigRegistry.validated[uiType][appName] = true
+			end
+			return options
+		end
+	elseif type(options)=="function" then
+		AceConfigRegistry.tables[appName] = function(uiType, uiName, errlvl)
+			errlvl=(errlvl or 0)+1
+			validateGetterArgs(uiType, uiName, errlvl)
+			local tab = assert(options(uiType, uiName, appName))
+			if not AceConfigRegistry.validated[uiType][appName] and not skipValidation then
+				AceConfigRegistry:ValidateOptionsTable(tab, appName, errlvl)	-- upgradable
+				AceConfigRegistry.validated[uiType][appName] = true
+			end
+			return tab
+		end
+	else
+		error(MAJOR..": RegisterOptionsTable(appName, options): 'options' - expected table or function reference", 2)
+	end
+end
+
+--- Returns an iterator of ["appName"]=funcref pairs
+function AceConfigRegistry:IterateOptionsTables()
+	return pairs(AceConfigRegistry.tables)
+end
+
+
+
+
+--- Query the registry for a specific options table.
+-- If only appName is given, a function is returned which you
+-- can call with (uiType,uiName) to get the table.\\
+-- If uiType&uiName are given, the table is returned.
+-- @param appName The application name as given to `:RegisterOptionsTable()`
+-- @param uiType The type of UI to get the table for, one of "cmd", "dropdown", "dialog"
+-- @param uiName The name of the library/addon querying for the table, e.g. "MyLib-1.0"
+function AceConfigRegistry:GetOptionsTable(appName, uiType, uiName)
+	local f = AceConfigRegistry.tables[appName]
+	if not f then
+		return nil
+	end
+
+	if uiType then
+		return f(uiType,uiName,1)	-- get the table for us
+	else
+		return f	-- return the function
+	end
+end

Libs/AceConfig-3.0/AceConfigRegistry-3.0/AceConfigRegistry-3.0.xml

@@ -0,0 +1,4 @@
+<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="AceConfigRegistry-3.0.lua"/>
+</Ui>

Libs/AceConsole-3.0/AceConsole-3.0.lua

@@ -0,0 +1,246 @@
+--- **AceConsole-3.0** provides registration facilities for slash commands.
+-- You can register slash commands to your custom functions and use the `GetArgs` function to parse them
+-- to your addons individual needs.
+--
+-- **AceConsole-3.0** can be embeded into your addon, either explicitly by calling AceConsole:Embed(MyAddon) or by
+-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
+-- and can be accessed directly, without having to explicitly call AceConsole itself.\\
+-- It is recommended to embed AceConsole, otherwise you'll have to specify a custom `self` on all calls you
+-- make into AceConsole.
+-- @class file
+-- @name AceConsole-3.0
+-- @release $Id: AceConsole-3.0.lua 1284 2022-09-25 09:15:30Z nevcairiel $
+local MAJOR,MINOR = "AceConsole-3.0", 7
+
+local AceConsole, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceConsole then return end -- No upgrade needed
+
+AceConsole.embeds = AceConsole.embeds or {} -- table containing objects AceConsole is embedded in.
+AceConsole.commands = AceConsole.commands or {} -- table containing commands registered
+AceConsole.weakcommands = AceConsole.weakcommands or {} -- table containing self, command => func references for weak commands that don't persist through enable/disable
+
+-- Lua APIs
+local tconcat, tostring, select = table.concat, tostring, select
+local type, pairs, error = type, pairs, error
+local format, strfind, strsub = string.format, string.find, string.sub
+local max = math.max
+
+-- WoW APIs
+local _G = _G
+
+local tmp={}
+local function Print(self,frame,...)
+	local n=0
+	if self ~= AceConsole then
+		n=n+1
+		tmp[n] = "|cff33ff99"..tostring( self ).."|r:"
+	end
+	for i=1, select("#", ...) do
+		n=n+1
+		tmp[n] = tostring(select(i, ...))
+	end
+	frame:AddMessage( tconcat(tmp," ",1,n) )
+end
+
+--- Print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function)
+-- @paramsig [chatframe ,] ...
+-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function)
+-- @param ... List of any values to be printed
+function AceConsole:Print(...)
+	local frame = ...
+	if type(frame) == "table" and frame.AddMessage then	-- Is first argument something with an .AddMessage member?
+		return Print(self, frame, select(2,...))
+	else
+		return Print(self, DEFAULT_CHAT_FRAME, ...)
+	end
+end
+
+
+--- Formatted (using format()) print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function)
+-- @paramsig [chatframe ,] "format"[, ...]
+-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function)
+-- @param format Format string - same syntax as standard Lua format()
+-- @param ... Arguments to the format string
+function AceConsole:Printf(...)
+	local frame = ...
+	if type(frame) == "table" and frame.AddMessage then	-- Is first argument something with an .AddMessage member?
+		return Print(self, frame, format(select(2,...)))
+	else
+		return Print(self, DEFAULT_CHAT_FRAME, format(...))
+	end
+end
+
+
+
+
+--- Register a simple chat command
+-- @param command Chat command to be registered WITHOUT leading "/"
+-- @param func Function to call when the slash command is being used (funcref or methodname)
+-- @param persist if false, the command will be soft disabled/enabled when aceconsole is used as a mixin (default: true)
+function AceConsole:RegisterChatCommand( command, func, persist )
+	if type(command)~="string" then error([[Usage: AceConsole:RegisterChatCommand( "command", func[, persist ]): 'command' - expected a string]], 2) end
+
+	if persist==nil then persist=true end	-- I'd rather have my addon's "/addon enable" around if the author screws up. Having some extra slash regged when it shouldnt be isn't as destructive. True is a better default. /Mikk
+
+	local name = "ACECONSOLE_"..command:upper()
+
+	if type( func ) == "string" then
+		SlashCmdList[name] = function(input, editBox)
+			self[func](self, input, editBox)
+		end
+	else
+		SlashCmdList[name] = func
+	end
+	_G["SLASH_"..name.."1"] = "/"..command:lower()
+	AceConsole.commands[command] = name
+	-- non-persisting commands are registered for enabling disabling
+	if not persist then
+		if not AceConsole.weakcommands[self] then AceConsole.weakcommands[self] = {} end
+		AceConsole.weakcommands[self][command] = func
+	end
+	return true
+end
+
+--- Unregister a chatcommand
+-- @param command Chat command to be unregistered WITHOUT leading "/"
+function AceConsole:UnregisterChatCommand( command )
+	local name = AceConsole.commands[command]
+	if name then
+		SlashCmdList[name] = nil
+		_G["SLASH_" .. name .. "1"] = nil
+		hash_SlashCmdList["/" .. command:upper()] = nil
+		AceConsole.commands[command] = nil
+	end
+end
+
+--- Get an iterator over all Chat Commands registered with AceConsole
+-- @return Iterator (pairs) over all commands
+function AceConsole:IterateChatCommands() return pairs(AceConsole.commands) end
+
+
+local function nils(n, ...)
+	if n>1 then
+		return nil, nils(n-1, ...)
+	elseif n==1 then
+		return nil, ...
+	else
+		return ...
+	end
+end
+
+
+--- Retreive one or more space-separated arguments from a string.
+-- Treats quoted strings and itemlinks as non-spaced.
+-- @param str The raw argument string
+-- @param numargs How many arguments to get (default 1)
+-- @param startpos Where in the string to start scanning (default  1)
+-- @return Returns arg1, arg2, ..., nextposition\\
+-- Missing arguments will be returned as nils. 'nextposition' is returned as 1e9 at the end of the string.
+function AceConsole:GetArgs(str, numargs, startpos)
+	numargs = numargs or 1
+	startpos = max(startpos or 1, 1)
+
+	local pos=startpos
+
+	-- find start of new arg
+	pos = strfind(str, "[^ ]", pos)
+	if not pos then	-- whoops, end of string
+		return nils(numargs, 1e9)
+	end
+
+	if numargs<1 then
+		return pos
+	end
+
+	-- quoted or space separated? find out which pattern to use
+	local delim_or_pipe
+	local ch = strsub(str, pos, pos)
+	if ch=='"' then
+		pos = pos + 1
+		delim_or_pipe='([|"])'
+	elseif ch=="'" then
+		pos = pos + 1
+		delim_or_pipe="([|'])"
+	else
+		delim_or_pipe="([| ])"
+	end
+
+	startpos = pos
+
+	while true do
+		-- find delimiter or hyperlink
+		local _
+		pos,_,ch = strfind(str, delim_or_pipe, pos)
+
+		if not pos then break end
+
+		if ch=="|" then
+			-- some kind of escape
+
+			if strsub(str,pos,pos+1)=="|H" then
+				-- It's a |H....|hhyper link!|h
+				pos=strfind(str, "|h", pos+2)	-- first |h
+				if not pos then break end
+
+				pos=strfind(str, "|h", pos+2)	-- second |h
+				if not pos then break end
+			elseif strsub(str,pos, pos+1) == "|T" then
+				-- It's a |T....|t  texture
+				pos=strfind(str, "|t", pos+2)
+				if not pos then break end
+			end
+
+			pos=pos+2 -- skip past this escape (last |h if it was a hyperlink)
+
+		else
+			-- found delimiter, done with this arg
+			return strsub(str, startpos, pos-1), AceConsole:GetArgs(str, numargs-1, pos+1)
+		end
+
+	end
+
+	-- search aborted, we hit end of string. return it all as one argument. (yes, even if it's an unterminated quote or hyperlink)
+	return strsub(str, startpos), nils(numargs-1, 1e9)
+end
+
+
+--- embedding and embed handling
+
+local mixins = {
+	"Print",
+	"Printf",
+	"RegisterChatCommand",
+	"UnregisterChatCommand",
+	"GetArgs",
+}
+
+-- Embeds AceConsole into the target object making the functions from the mixins list available on target:..
+-- @param target target object to embed AceBucket in
+function AceConsole:Embed( target )
+	for k, v in pairs( mixins ) do
+		target[v] = self[v]
+	end
+	self.embeds[target] = true
+	return target
+end
+
+function AceConsole:OnEmbedEnable( target )
+	if AceConsole.weakcommands[target] then
+		for command, func in pairs( AceConsole.weakcommands[target] ) do
+			target:RegisterChatCommand( command, func, false, true ) -- nonpersisting and silent registry
+		end
+	end
+end
+
+function AceConsole:OnEmbedDisable( target )
+	if AceConsole.weakcommands[target] then
+		for command, func in pairs( AceConsole.weakcommands[target] ) do
+			target:UnregisterChatCommand( command ) -- TODO: this could potentially unregister a command from another application in case of command conflicts. Do we care?
+		end
+	end
+end
+
+for addon in pairs(AceConsole.embeds) do
+	AceConsole:Embed(addon)
+end

Libs/AceConsole-3.0/AceConsole-3.0.xml

@@ -0,0 +1,4 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+..\FrameXML\UI.xsd">
+	<Script file="AceConsole-3.0.lua"/>
+</Ui>

Libs/AceDB-3.0/AceDB-3.0.lua

@@ -0,0 +1,797 @@
+--- **AceDB-3.0** manages the SavedVariables of your addon.
+-- It offers profile management, smart defaults and namespaces for modules.\\
+-- Data can be saved in different data-types, depending on its intended usage.
+-- The most common data-type is the `profile` type, which allows the user to choose
+-- the active profile, and manage the profiles of all of his characters.\\
+-- The following data types are available:
+-- * **char** Character-specific data. Every character has its own database.
+-- * **realm** Realm-specific data. All of the players characters on the same realm share this database.
+-- * **class** Class-specific data. All of the players characters of the same class share this database.
+-- * **race** Race-specific data. All of the players characters of the same race share this database.
+-- * **faction** Faction-specific data. All of the players characters of the same faction share this database.
+-- * **factionrealm** Faction and realm specific data. All of the players characters on the same realm and of the same faction share this database.
+-- * **locale** Locale specific data, based on the locale of the players game client.
+-- * **global** Global Data. All characters on the same account share this database.
+-- * **profile** Profile-specific data. All characters using the same profile share this database. The user can control which profile should be used.
+--
+-- Creating a new Database using the `:New` function will return a new DBObject. A database will inherit all functions
+-- of the DBObjectLib listed here. \\
+-- If you create a new namespaced child-database (`:RegisterNamespace`), you'll get a DBObject as well, but note
+-- that the child-databases cannot individually change their profile, and are linked to their parents profile - and because of that,
+-- the profile related APIs are not available. Only `:RegisterDefaults` and `:ResetProfile` are available on child-databases.
+--
+-- For more details on how to use AceDB-3.0, see the [[AceDB-3.0 Tutorial]].
+--
+-- You may also be interested in [[libdualspec-1-0|LibDualSpec-1.0]] to do profile switching automatically when switching specs.
+--
+-- @usage
+-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("DBExample")
+--
+-- -- declare defaults to be used in the DB
+-- local defaults = {
+--   profile = {
+--     setting = true,
+--   }
+-- }
+--
+-- function MyAddon:OnInitialize()
+--   -- Assuming the .toc says ## SavedVariables: MyAddonDB
+--   self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true)
+-- end
+-- @class file
+-- @name AceDB-3.0.lua
+-- @release $Id: AceDB-3.0.lua 1364 2025-07-05 16:01:08Z nevcairiel $
+local ACEDB_MAJOR, ACEDB_MINOR = "AceDB-3.0", 33
+local AceDB = LibStub:NewLibrary(ACEDB_MAJOR, ACEDB_MINOR)
+
+if not AceDB then return end -- No upgrade needed
+
+-- Lua APIs
+local type, pairs, next, error = type, pairs, next, error
+local setmetatable, rawset, rawget = setmetatable, rawset, rawget
+
+-- WoW APIs
+local _G = _G
+
+AceDB.db_registry = AceDB.db_registry or {}
+AceDB.frame = AceDB.frame or CreateFrame("Frame")
+
+local CallbackHandler
+local CallbackDummy = { Fire = function() end }
+
+local DBObjectLib = {}
+
+--[[-------------------------------------------------------------------------
+	AceDB Utility Functions
+---------------------------------------------------------------------------]]
+
+-- Simple shallow copy for copying defaults
+local function copyTable(src, dest)
+	if type(dest) ~= "table" then dest = {} end
+	if type(src) == "table" then
+		for k,v in pairs(src) do
+			if type(v) == "table" then
+				-- try to index the key first so that the metatable creates the defaults, if set, and use that table
+				v = copyTable(v, dest[k])
+			end
+			dest[k] = v
+		end
+	end
+	return dest
+end
+
+-- Called to add defaults to a section of the database
+--
+-- When a ["*"] default section is indexed with a new key, a table is returned
+-- and set in the host table.  These tables must be cleaned up by removeDefaults
+-- in order to ensure we don't write empty default tables.
+local function copyDefaults(dest, src)
+	-- this happens if some value in the SV overwrites our default value with a non-table
+	--if type(dest) ~= "table" then return end
+	for k, v in pairs(src) do
+		if k == "*" or k == "**" then
+			if type(v) == "table" then
+				-- This is a metatable used for table defaults
+				local mt = {
+					-- This handles the lookup and creation of new subtables
+					__index = function(t,k2)
+							if k2 == nil then return nil end
+							local tbl = {}
+							copyDefaults(tbl, v)
+							rawset(t, k2, tbl)
+							return tbl
+						end,
+				}
+				setmetatable(dest, mt)
+				-- handle already existing tables in the SV
+				for dk, dv in pairs(dest) do
+					if not rawget(src, dk) and type(dv) == "table" then
+						copyDefaults(dv, v)
+					end
+				end
+			else
+				-- Values are not tables, so this is just a simple return
+				local mt = {__index = function(t,k2) return k2~=nil and v or nil end}
+				setmetatable(dest, mt)
+			end
+		elseif type(v) == "table" then
+			if not rawget(dest, k) then rawset(dest, k, {}) end
+			if type(dest[k]) == "table" then
+				copyDefaults(dest[k], v)
+				if src['**'] then
+					copyDefaults(dest[k], src['**'])
+				end
+			end
+		else
+			if rawget(dest, k) == nil then
+				rawset(dest, k, v)
+			end
+		end
+	end
+end
+
+-- Called to remove all defaults in the default table from the database
+local function removeDefaults(db, defaults, blocker)
+	-- remove all metatables from the db, so we don't accidentally create new sub-tables through them
+	setmetatable(db, nil)
+	-- loop through the defaults and remove their content
+	for k,v in pairs(defaults) do
+		if k == "*" or k == "**" then
+			if type(v) == "table" then
+				-- Loop through all the actual k,v pairs and remove
+				for key, value in pairs(db) do
+					if type(value) == "table" then
+						-- if the key was not explicitly specified in the defaults table, just strip everything from * and ** tables
+						if defaults[key] == nil and (not blocker or blocker[key] == nil) then
+							removeDefaults(value, v)
+							-- if the table is empty afterwards, remove it
+							if next(value) == nil then
+								db[key] = nil
+							end
+						-- if it was specified, only strip ** content, but block values which were set in the key table
+						elseif k == "**" then
+							removeDefaults(value, v, defaults[key])
+						end
+					end
+				end
+			elseif k == "*" then
+				-- check for non-table default
+				for key, value in pairs(db) do
+					if defaults[key] == nil and v == value then
+						db[key] = nil
+					end
+				end
+			end
+		elseif type(v) == "table" and type(db[k]) == "table" then
+			-- if a blocker was set, dive into it, to allow multi-level defaults
+			removeDefaults(db[k], v, blocker and blocker[k])
+			if next(db[k]) == nil then
+				db[k] = nil
+			end
+		else
+			-- check if the current value matches the default, and that its not blocked by another defaults table
+			if db[k] == defaults[k] and (not blocker or blocker[k] == nil) then
+				db[k] = nil
+			end
+		end
+	end
+end
+
+-- This is called when a table section is first accessed, to set up the defaults
+local function initSection(db, section, svstore, key, defaults)
+	local sv = rawget(db, "sv")
+
+	local tableCreated
+	if not sv[svstore] then sv[svstore] = {} end
+	if not sv[svstore][key] then
+		sv[svstore][key] = {}
+		tableCreated = true
+	end
+
+	local tbl = sv[svstore][key]
+
+	if defaults then
+		copyDefaults(tbl, defaults)
+	end
+	rawset(db, section, tbl)
+
+	return tableCreated, tbl
+end
+
+-- Metatable to handle the dynamic creation of sections and copying of sections.
+local dbmt = {
+	__index = function(t, section)
+			local keys = rawget(t, "keys")
+			local key = keys[section]
+			if key then
+				local defaultTbl = rawget(t, "defaults")
+				local defaults = defaultTbl and defaultTbl[section]
+
+				if section == "profile" then
+					local new = initSection(t, section, "profiles", key, defaults)
+					if new then
+						-- Callback: OnNewProfile, database, newProfileKey
+						t.callbacks:Fire("OnNewProfile", t, key)
+					end
+				elseif section == "profiles" then
+					local sv = rawget(t, "sv")
+					if not sv.profiles then sv.profiles = {} end
+					rawset(t, "profiles", sv.profiles)
+				elseif section == "global" then
+					local sv = rawget(t, "sv")
+					if not sv.global then sv.global = {} end
+					if defaults then
+						copyDefaults(sv.global, defaults)
+					end
+					rawset(t, section, sv.global)
+				else
+					initSection(t, section, section, key, defaults)
+				end
+			end
+
+			return rawget(t, section)
+		end
+}
+
+local function validateDefaults(defaults, keyTbl, offset)
+	if not defaults then return end
+	offset = offset or 0
+	for k in pairs(defaults) do
+		if not keyTbl[k] or k == "profiles" then
+			error(("Usage: AceDBObject:RegisterDefaults(defaults): '%s' is not a valid datatype."):format(k), 3 + offset)
+		end
+	end
+end
+
+local preserve_keys = {
+	["callbacks"] = true,
+	["RegisterCallback"] = true,
+	["UnregisterCallback"] = true,
+	["UnregisterAllCallbacks"] = true,
+	["children"] = true,
+}
+
+local realmKey = GetRealmName()
+local charKey = UnitName("player") .. " - " .. realmKey
+local _, classKey = UnitClass("player")
+local _, raceKey = UnitRace("player")
+local factionKey = UnitFactionGroup("player")
+local factionrealmKey = factionKey .. " - " .. realmKey
+local localeKey = GetLocale():lower()
+
+local regionTable = { "US", "KR", "EU", "TW", "CN" }
+local regionKey = regionTable[GetCurrentRegion()] or GetCurrentRegionName() or "TR"
+local factionrealmregionKey = factionrealmKey .. " - " .. regionKey
+
+-- Actual database initialization function
+local function initdb(sv, defaults, defaultProfile, olddb, parent)
+	-- Generate the database keys for each section
+
+	-- map "true" to our "Default" profile
+	if defaultProfile == true then defaultProfile = "Default" end
+
+	local profileKey
+	if not parent then
+		-- Make a container for profile keys
+		if not sv.profileKeys then sv.profileKeys = {} end
+
+		-- Try to get the profile selected from the char db
+		profileKey = sv.profileKeys[charKey] or defaultProfile or charKey
+
+		-- save the selected profile for later
+		sv.profileKeys[charKey] = profileKey
+	else
+		-- Use the profile of the parents DB
+		profileKey = parent.keys.profile or defaultProfile or charKey
+
+		-- clear the profileKeys in the DB, namespaces don't need to store them
+		sv.profileKeys = nil
+	end
+
+	-- This table contains keys that enable the dynamic creation
+	-- of each section of the table.  The 'global' and 'profiles'
+	-- have a key of true, since they are handled in a special case
+	local keyTbl= {
+		["char"] = charKey,
+		["realm"] = realmKey,
+		["class"] = classKey,
+		["race"] = raceKey,
+		["faction"] = factionKey,
+		["factionrealm"] = factionrealmKey,
+		["factionrealmregion"] = factionrealmregionKey,
+		["profile"] = profileKey,
+		["locale"] = localeKey,
+		["global"] = true,
+		["profiles"] = true,
+	}
+
+	validateDefaults(defaults, keyTbl, 1)
+
+	-- This allows us to use this function to reset an entire database
+	-- Clear out the old database
+	if olddb then
+		for k,v in pairs(olddb) do if not preserve_keys[k] then olddb[k] = nil end end
+	end
+
+	-- Give this database the metatable so it initializes dynamically
+	local db = setmetatable(olddb or {}, dbmt)
+
+	if not rawget(db, "callbacks") then
+		-- try to load CallbackHandler-1.0 if it loaded after our library
+		if not CallbackHandler then CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0", true) end
+		db.callbacks = CallbackHandler and CallbackHandler:New(db) or CallbackDummy
+	end
+
+	-- Copy methods locally into the database object, to avoid hitting
+	-- the metatable when calling methods
+
+	if not parent then
+		for name, func in pairs(DBObjectLib) do
+			db[name] = func
+		end
+	else
+		-- hack this one in
+		db.RegisterDefaults = DBObjectLib.RegisterDefaults
+		db.ResetProfile = DBObjectLib.ResetProfile
+	end
+
+	-- Set some properties in the database object
+	db.profiles = sv.profiles
+	db.keys = keyTbl
+	db.sv = sv
+	--db.sv_name = name
+	db.defaults = defaults
+	db.parent = parent
+
+	-- store the DB in the registry
+	AceDB.db_registry[db] = true
+
+	return db
+end
+
+-- handle PLAYER_LOGOUT
+-- strip all defaults from all databases
+-- and cleans up empty sections
+local function logoutHandler(frame, event)
+	if event == "PLAYER_LOGOUT" then
+		for db in pairs(AceDB.db_registry) do
+			db.callbacks:Fire("OnDatabaseShutdown", db)
+			db:RegisterDefaults(nil)
+
+			-- cleanup sections that are empty without defaults
+			local sv = rawget(db, "sv")
+			for section in pairs(rawget(db, "keys")) do
+				if rawget(sv, section) then
+					-- global is special, all other sections have sub-entrys
+					-- also don't delete empty profiles on main dbs, only on namespaces
+					if section ~= "global" and (section ~= "profiles" or rawget(db, "parent")) then
+						for key in pairs(sv[section]) do
+							if not next(sv[section][key]) then
+								sv[section][key] = nil
+							end
+						end
+					end
+					if not next(sv[section]) then
+						sv[section] = nil
+					end
+				end
+			end
+		end
+
+		-- second pass after everything else is cleaned up to remove empty namespaces
+		-- can't be run in-loop above since there is no guaranteed order
+		for db in pairs(AceDB.db_registry) do
+			local sv = rawget(db, "sv")
+			local namespaces = rawget(sv, "namespaces")
+			if namespaces then
+				for name in pairs(namespaces) do
+					-- cleanout empty profiles table, if still present
+					if namespaces[name].profiles and not next(namespaces[name].profiles) then
+						namespaces[name].profiles = nil
+					end
+
+					-- remove entire namespace, if needed
+					if not next(namespaces[name]) then
+						namespaces[name] = nil
+					end
+				end
+			end
+		end
+	end
+end
+
+AceDB.frame:RegisterEvent("PLAYER_LOGOUT")
+AceDB.frame:SetScript("OnEvent", logoutHandler)
+
+
+--[[-------------------------------------------------------------------------
+	AceDB Object Method Definitions
+---------------------------------------------------------------------------]]
+
+--- Sets the defaults table for the given database object by clearing any
+-- that are currently set, and then setting the new defaults.
+-- @param defaults A table of defaults for this database
+function DBObjectLib:RegisterDefaults(defaults)
+	if defaults and type(defaults) ~= "table" then
+		error(("Usage: AceDBObject:RegisterDefaults(defaults): 'defaults' - table or nil expected, got %q."):format(type(defaults)), 2)
+	end
+
+	validateDefaults(defaults, self.keys)
+
+	-- Remove any currently set defaults
+	if self.defaults then
+		for section,key in pairs(self.keys) do
+			if self.defaults[section] and rawget(self, section) then
+				removeDefaults(self[section], self.defaults[section])
+			end
+		end
+	end
+
+	-- Set the DBObject.defaults table
+	self.defaults = defaults
+
+	-- Copy in any defaults, only touching those sections already created
+	if defaults then
+		for section,key in pairs(self.keys) do
+			if defaults[section] and rawget(self, section) then
+				copyDefaults(self[section], defaults[section])
+			end
+		end
+	end
+end
+
+--- Changes the profile of the database and all of it's namespaces to the
+-- supplied named profile
+-- @param name The name of the profile to set as the current profile
+function DBObjectLib:SetProfile(name)
+	if type(name) ~= "string" then
+		error(("Usage: AceDBObject:SetProfile(name): 'name' - string expected, got %q."):format(type(name)), 2)
+	end
+
+	-- changing to the same profile, dont do anything
+	if name == self.keys.profile then return end
+
+	local oldProfile = self.profile
+	local defaults = self.defaults and self.defaults.profile
+
+	-- Callback: OnProfileShutdown, database
+	self.callbacks:Fire("OnProfileShutdown", self)
+
+	if oldProfile and defaults then
+		-- Remove the defaults from the old profile
+		removeDefaults(oldProfile, defaults)
+	end
+
+	self.profile = nil
+	self.keys["profile"] = name
+
+	-- if the storage exists, save the new profile
+	-- this won't exist on namespaces.
+	if self.sv.profileKeys then
+		self.sv.profileKeys[charKey] = name
+	end
+
+	-- populate to child namespaces
+	if self.children then
+		for _, db in pairs(self.children) do
+			DBObjectLib.SetProfile(db, name)
+		end
+	end
+
+	-- Callback: OnProfileChanged, database, newProfileKey
+	self.callbacks:Fire("OnProfileChanged", self, name)
+end
+
+--- Returns a table with the names of the existing profiles in the database.
+-- You can optionally supply a table to re-use for this purpose.
+-- @param tbl A table to store the profile names in (optional)
+function DBObjectLib:GetProfiles(tbl)
+	if tbl and type(tbl) ~= "table" then
+		error(("Usage: AceDBObject:GetProfiles(tbl): 'tbl' - table or nil expected, got %q."):format(type(tbl)), 2)
+	end
+
+	-- Clear the container table
+	if tbl then
+		for k,v in pairs(tbl) do tbl[k] = nil end
+	else
+		tbl = {}
+	end
+
+	local curProfile = self.keys.profile
+
+	local i = 0
+	for profileKey in pairs(self.profiles) do
+		i = i + 1
+		tbl[i] = profileKey
+		if curProfile and profileKey == curProfile then curProfile = nil end
+	end
+
+	-- Add the current profile, if it hasn't been created yet
+	if curProfile then
+		i = i + 1
+		tbl[i] = curProfile
+	end
+
+	return tbl, i
+end
+
+--- Returns the current profile name used by the database
+function DBObjectLib:GetCurrentProfile()
+	return self.keys.profile
+end
+
+--- Deletes a named profile.  This profile must not be the active profile.
+-- @param name The name of the profile to be deleted
+-- @param silent If true, do not raise an error when the profile does not exist
+function DBObjectLib:DeleteProfile(name, silent)
+	if type(name) ~= "string" then
+		error(("Usage: AceDBObject:DeleteProfile(name): 'name' - string expected, got %q."):format(type(name)), 2)
+	end
+
+	if self.keys.profile == name then
+		error(("Cannot delete the active profile (%q) in an AceDBObject."):format(name), 2)
+	end
+
+	if not rawget(self.profiles, name) and not silent then
+		error(("Cannot delete profile %q as it does not exist."):format(name), 2)
+	end
+
+	self.profiles[name] = nil
+
+	-- populate to child namespaces
+	if self.children then
+		for _, db in pairs(self.children) do
+			DBObjectLib.DeleteProfile(db, name, true)
+		end
+	end
+
+	-- remove from unloaded namespaces
+	if self.sv.namespaces then
+		for nsname, data in pairs(self.sv.namespaces) do
+			if self.children and self.children[nsname] then
+				-- already a mapped namespace
+			elseif data.profiles then
+				data.profiles[name] = nil
+			end
+		end
+	end
+
+	-- switch all characters that use this profile back to the default
+	if self.sv.profileKeys then
+		for key, profile in pairs(self.sv.profileKeys) do
+			if profile == name then
+				self.sv.profileKeys[key] = nil
+			end
+		end
+	end
+
+	-- Callback: OnProfileDeleted, database, profileKey
+	self.callbacks:Fire("OnProfileDeleted", self, name)
+end
+
+--- Copies a named profile into the current profile, overwriting any conflicting
+-- settings.
+-- @param name The name of the profile to be copied into the current profile
+-- @param silent If true, do not raise an error when the profile does not exist
+function DBObjectLib:CopyProfile(name, silent)
+	if type(name) ~= "string" then
+		error(("Usage: AceDBObject:CopyProfile(name): 'name' - string expected, got %q."):format(type(name)), 2)
+	end
+
+	if name == self.keys.profile then
+		error(("Cannot have the same source and destination profiles (%q)."):format(name), 2)
+	end
+
+	if not rawget(self.profiles, name) and not silent then
+		error(("Cannot copy profile %q as it does not exist."):format(name), 2)
+	end
+
+	-- Reset the profile before copying
+	DBObjectLib.ResetProfile(self, nil, true)
+
+	local profile = self.profile
+	local source = self.profiles[name]
+
+	copyTable(source, profile)
+
+	-- populate to child namespaces
+	if self.children then
+		for _, db in pairs(self.children) do
+			DBObjectLib.CopyProfile(db, name, true)
+		end
+	end
+
+	-- copy unloaded namespaces
+	if self.sv.namespaces then
+		for nsname, data in pairs(self.sv.namespaces) do
+			if self.children and self.children[nsname] then
+				-- already a mapped namespace
+			elseif data.profiles then
+				-- reset the current profile
+				data.profiles[self.keys.profile] = {}
+				-- copy data
+				copyTable(data.profiles[name], data.profiles[self.keys.profile])
+			end
+		end
+	end
+
+	-- Callback: OnProfileCopied, database, sourceProfileKey
+	self.callbacks:Fire("OnProfileCopied", self, name)
+end
+
+--- Resets the current profile to the default values (if specified).
+-- @param noChildren if set to true, the reset will not be populated to the child namespaces of this DB object
+-- @param noCallbacks if set to true, won't fire the OnProfileReset callback
+function DBObjectLib:ResetProfile(noChildren, noCallbacks)
+	local profile = self.profile
+
+	for k,v in pairs(profile) do
+		profile[k] = nil
+	end
+
+	local defaults = self.defaults and self.defaults.profile
+	if defaults then
+		copyDefaults(profile, defaults)
+	end
+
+	-- populate to child namespaces
+	if self.children and not noChildren then
+		for _, db in pairs(self.children) do
+			DBObjectLib.ResetProfile(db, nil, noCallbacks)
+		end
+	end
+
+	-- reset unloaded namespaces
+	if self.sv.namespaces and not noChildren then
+		for nsname, data in pairs(self.sv.namespaces) do
+			if self.children and self.children[nsname] then
+				-- already a mapped namespace
+			elseif data.profiles then
+				-- reset the current profile
+				data.profiles[self.keys.profile] = nil
+			end
+		end
+	end
+
+	-- Callback: OnProfileReset, database
+	if not noCallbacks then
+		self.callbacks:Fire("OnProfileReset", self)
+	end
+end
+
+--- Resets the entire database, using the string defaultProfile as the new default
+-- profile.
+-- @param defaultProfile The profile name to use as the default
+function DBObjectLib:ResetDB(defaultProfile)
+	if defaultProfile and type(defaultProfile) ~= "string" and defaultProfile ~= true then
+		error(("Usage: AceDBObject:ResetDB(defaultProfile): 'defaultProfile' - string or true expected, got %q."):format(type(defaultProfile)), 2)
+	end
+
+	local sv = self.sv
+	for k,v in pairs(sv) do
+		sv[k] = nil
+	end
+
+	initdb(sv, self.defaults, defaultProfile, self)
+
+	-- fix the child namespaces
+	if self.children then
+		if not sv.namespaces then sv.namespaces = {} end
+		for name, db in pairs(self.children) do
+			if not sv.namespaces[name] then sv.namespaces[name] = {} end
+			initdb(sv.namespaces[name], db.defaults, self.keys.profile, db, self)
+		end
+	end
+
+	-- Callback: OnDatabaseReset, database
+	self.callbacks:Fire("OnDatabaseReset", self)
+	-- Callback: OnProfileChanged, database, profileKey
+	self.callbacks:Fire("OnProfileChanged", self, self.keys["profile"])
+
+	return self
+end
+
+--- Creates a new database namespace, directly tied to the database.  This
+-- is a full scale database in it's own rights other than the fact that
+-- it cannot control its profile individually
+-- @param name The name of the new namespace
+-- @param defaults A table of values to use as defaults
+function DBObjectLib:RegisterNamespace(name, defaults)
+	if type(name) ~= "string" then
+		error(("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - string expected, got %q."):format(type(name)), 2)
+	end
+	if defaults and type(defaults) ~= "table" then
+		error(("Usage: AceDBObject:RegisterNamespace(name, defaults): 'defaults' - table or nil expected, got %q."):format(type(defaults)), 2)
+	end
+	if self.children and self.children[name] then
+		error(("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - a namespace called %q already exists."):format(name), 2)
+	end
+
+	local sv = self.sv
+	if not sv.namespaces then sv.namespaces = {} end
+	if not sv.namespaces[name] then
+		sv.namespaces[name] = {}
+	end
+
+	local newDB = initdb(sv.namespaces[name], defaults, self.keys.profile, nil, self)
+
+	if not self.children then self.children = {} end
+	self.children[name] = newDB
+	return newDB
+end
+
+--- Returns an already existing namespace from the database object.
+-- @param name The name of the new namespace
+-- @param silent if true, the addon is optional, silently return nil if its not found
+-- @usage
+-- local namespace = self.db:GetNamespace('namespace')
+-- @return the namespace object if found
+function DBObjectLib:GetNamespace(name, silent)
+	if type(name) ~= "string" then
+		error(("Usage: AceDBObject:GetNamespace(name): 'name' - string expected, got %q."):format(type(name)), 2)
+	end
+	if not silent and not (self.children and self.children[name]) then
+		error(("Usage: AceDBObject:GetNamespace(name): 'name' - namespace %q does not exist."):format(name), 2)
+	end
+	if not self.children then self.children = {} end
+	return self.children[name]
+end
+
+--[[-------------------------------------------------------------------------
+	AceDB Exposed Methods
+---------------------------------------------------------------------------]]
+
+--- Creates a new database object that can be used to handle database settings and profiles.
+-- By default, an empty DB is created, using a character specific profile.
+--
+-- You can override the default profile used by passing any profile name as the third argument,
+-- or by passing //true// as the third argument to use a globally shared profile called "Default".
+--
+-- Note that there is no token replacement in the default profile name, passing a defaultProfile as "char"
+-- will use a profile named "char", and not a character-specific profile.
+-- @param tbl The name of variable, or table to use for the database
+-- @param defaults A table of database defaults
+-- @param defaultProfile The name of the default profile. If not set, a character specific profile will be used as the default.
+-- You can also pass //true// to use a shared global profile called "Default".
+-- @usage
+-- -- Create an empty DB using a character-specific default profile.
+-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB")
+-- @usage
+-- -- Create a DB using defaults and using a shared default profile
+-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true)
+function AceDB:New(tbl, defaults, defaultProfile)
+	if type(tbl) == "string" then
+		local name = tbl
+		tbl = _G[name]
+		if not tbl then
+			tbl = {}
+			_G[name] = tbl
+		end
+	end
+
+	if type(tbl) ~= "table" then
+		error(("Usage: AceDB:New(tbl, defaults, defaultProfile): 'tbl' - table expected, got %q."):format(type(tbl)), 2)
+	end
+
+	if defaults and type(defaults) ~= "table" then
+		error(("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaults' - table expected, got %q."):format(type(defaults)), 2)
+	end
+
+	if defaultProfile and type(defaultProfile) ~= "string" and defaultProfile ~= true then
+		error(("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaultProfile' - string or true expected, got %q."):format(type(defaultProfile)), 2)
+	end
+
+	return initdb(tbl, defaults, defaultProfile)
+end
+
+-- upgrade existing databases
+for db in pairs(AceDB.db_registry) do
+	if not db.parent then
+		for name,func in pairs(DBObjectLib) do
+			db[name] = func
+		end
+	else
+		db.RegisterDefaults = DBObjectLib.RegisterDefaults
+		db.ResetProfile = DBObjectLib.ResetProfile
+	end
+end

Libs/AceDB-3.0/AceDB-3.0.xml

@@ -0,0 +1,4 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+..\FrameXML\UI.xsd">
+	<Script file="AceDB-3.0.lua"/>
+</Ui>

Libs/AceDBOptions-3.0/AceDBOptions-3.0.lua

@@ -0,0 +1,456 @@
+--- AceDBOptions-3.0 provides a universal AceConfig options screen for managing AceDB-3.0 profiles.
+-- @class file
+-- @name AceDBOptions-3.0
+-- @release $Id: AceDBOptions-3.0.lua 1304 2023-05-19 19:50:10Z nevcairiel $
+local ACEDBO_MAJOR, ACEDBO_MINOR = "AceDBOptions-3.0", 15
+local AceDBOptions = LibStub:NewLibrary(ACEDBO_MAJOR, ACEDBO_MINOR)
+
+if not AceDBOptions then return end -- No upgrade needed
+
+-- Lua APIs
+local pairs, next = pairs, next
+
+-- WoW APIs
+local UnitClass = UnitClass
+
+AceDBOptions.optionTables = AceDBOptions.optionTables or {}
+AceDBOptions.handlers = AceDBOptions.handlers or {}
+
+--[[
+	Localization of AceDBOptions-3.0
+]]
+
+local L = {
+	choose = "Existing Profiles",
+	choose_desc = "You can either create a new profile by entering a name in the editbox, or choose one of the already existing profiles.",
+	choose_sub = "Select one of your currently available profiles.",
+	copy = "Copy From",
+	copy_desc = "Copy the settings from one existing profile into the currently active profile.",
+	current = "Current Profile:",
+	default = "Default",
+	delete = "Delete a Profile",
+	delete_confirm = "Are you sure you want to delete the selected profile?",
+	delete_desc = "Delete existing and unused profiles from the database to save space, and cleanup the SavedVariables file.",
+	delete_sub = "Deletes a profile from the database.",
+	intro = "You can change the active database profile, so you can have different settings for every character.",
+	new = "New",
+	new_sub = "Create a new empty profile.",
+	profiles = "Profiles",
+	profiles_sub = "Manage Profiles",
+	reset = "Reset Profile",
+	reset_desc = "Reset the current profile back to its default values, in case your configuration is broken, or you simply want to start over.",
+	reset_sub = "Reset the current profile to the default",
+}
+
+local LOCALE = GetLocale()
+if LOCALE == "deDE" then
+	L["choose"] = "Vorhandene Profile"
+	L["choose_desc"] = "Du kannst ein neues Profil erstellen, indem du einen neuen Namen in der Eingabebox 'Neu' eingibst, oder wähle eines der vorhandenen Profile aus."
+	L["choose_sub"] = "Wählt ein bereits vorhandenes Profil aus."
+	L["copy"] = "Kopieren von..."
+	L["copy_desc"] = "Kopiere die Einstellungen von einem vorhandenen Profil in das aktive Profil."
+	L["current"] = "Aktuelles Profil:"
+	L["default"] = "Standard"
+	L["delete"] = "Profil löschen"
+	L["delete_confirm"] = "Willst du das ausgewählte Profil wirklich löschen?"
+	L["delete_desc"] = "Lösche vorhandene oder unbenutzte Profile aus der Datenbank, um Platz zu sparen und die SavedVariables-Datei 'sauber' zu halten."
+	L["delete_sub"] = "Löscht ein Profil aus der Datenbank."
+	L["intro"] = "Hier kannst du das aktive Datenbankprofil ändern, damit du verschiedene Einstellungen für jeden Charakter erstellen kannst, wodurch eine sehr flexible Konfiguration möglich wird."
+	L["new"] = "Neu"
+	L["new_sub"] = "Ein neues Profil erstellen."
+	L["profiles"] = "Profile"
+	L["profiles_sub"] = "Profile verwalten"
+	L["reset"] = "Profil zurücksetzen"
+	L["reset_desc"] = "Setzt das momentane Profil auf Standardwerte zurück, für den Fall, dass mit der Konfiguration etwas schief lief oder weil du einfach neu starten willst."
+	L["reset_sub"] = "Das aktuelle Profil auf Standard zurücksetzen."
+elseif LOCALE == "frFR" then
+	L["choose"] = "Profils existants"
+	L["choose_desc"] = "Vous pouvez créer un nouveau profil en entrant un nouveau nom dans la boîte de saisie, ou en choississant un des profils déjà existants."
+	L["choose_sub"] = "Permet de choisir un des profils déjà disponibles."
+	L["copy"] = "Copier à partir de"
+	L["copy_desc"] = "Copie les paramètres d'un profil déjà existant dans le profil actuellement actif."
+	L["current"] = "Profil actuel :"
+	L["default"] = "Défaut"
+	L["delete"] = "Supprimer un profil"
+	L["delete_confirm"] = "Etes-vous sûr de vouloir supprimer le profil sélectionné ?"
+	L["delete_desc"] = "Supprime les profils existants inutilisés de la base de données afin de gagner de la place et de nettoyer le fichier SavedVariables."
+	L["delete_sub"] = "Supprime un profil de la base de données."
+	L["intro"] = "Vous pouvez changer le profil actuel afin d'avoir des paramètres différents pour chaque personnage, permettant ainsi d'avoir une configuration très flexible."
+	L["new"] = "Nouveau"
+	L["new_sub"] = "Créée un nouveau profil vierge."
+	L["profiles"] = "Profils"
+	L["profiles_sub"] = "Gestion des profils"
+	L["reset"] = "Réinitialiser le profil"
+	L["reset_desc"] = "Réinitialise le profil actuel au cas où votre configuration est corrompue ou si vous voulez tout simplement faire table rase."
+	L["reset_sub"] = "Réinitialise le profil actuel avec les paramètres par défaut."
+elseif LOCALE == "koKR" then
+	L["choose"] = "기존 프로필"
+	L["choose_desc"] = "편집 상자에 이름을 입력하여 새로운 프로필을 만들거나 이미 존재하는 프로필 중 하나를 선택할 수 있습니다."
+	L["choose_sub"] = "현재 이용할 수 있는 프로필 중 하나를 선택합니다."
+	L["copy"] = "복사해 올 프로필"
+	L["copy_desc"] = "기존 프로필의 설정을 현재 활성화된 프로필로 복사합니다."
+	L["current"] = "현재 프로필:"
+	L["default"] = "기본값"
+	L["delete"] = "프로필 삭제"
+	L["delete_confirm"] = "선택한 프로필을 삭제하시겠습니까?"
+	L["delete_desc"] = "데이터베이스에서 기존 프로필과 사용하지 않는 프로필을 삭제하여 공간을 절약하고 SavedVariables 파일을 정리합니다."
+	L["delete_sub"] = "데이터베이스에서 프로필을 삭제합니다."
+	L["intro"] = "활성 데이터베이스 프로필을 변경할 수 있으며, 모든 캐릭터마다 서로 다른 설정을 지정할 수 있습니다."
+	L["new"] = "새로운 프로필"
+	L["new_sub"] = "비어 있는 프로필을 새로 만듭니다."
+	L["profiles"] = "프로필"
+	L["profiles_sub"] = "프로필 관리"
+	L["reset"] = "프로필 재설정"
+	L["reset_desc"] = "구성이 손상되었거나 처음부터 다시 시작하고 싶은 경우 현재 프로필을 기본값으로 재설정하세요."
+	L["reset_sub"] = "현재 프로필을 기본값으로 재설정합니다"
+elseif LOCALE == "esES" or LOCALE == "esMX" then
+	L["choose"] = "Perfiles existentes"
+	L["choose_desc"] = "Puedes crear un nuevo perfil introduciendo un nombre en el recuadro o puedes seleccionar un perfil de los ya existentes."
+	L["choose_sub"] = "Selecciona uno de los perfiles disponibles."
+	L["copy"] = "Copiar de"
+	L["copy_desc"] = "Copia los ajustes de un perfil existente al perfil actual."
+	L["current"] = "Perfil actual:"
+	L["default"] = "Por defecto"
+	L["delete"] = "Borrar un Perfil"
+	L["delete_confirm"] = "¿Estas seguro que quieres borrar el perfil seleccionado?"
+	L["delete_desc"] = "Borra los perfiles existentes y sin uso de la base de datos para ganar espacio y limpiar el archivo SavedVariables."
+	L["delete_sub"] = "Borra un perfil de la base de datos."
+	L["intro"] = "Puedes cambiar el perfil activo de tal manera que cada personaje tenga diferentes configuraciones."
+	L["new"] = "Nuevo"
+	L["new_sub"] = "Crear un nuevo perfil vacio."
+	L["profiles"] = "Perfiles"
+	L["profiles_sub"] = "Manejar Perfiles"
+	L["reset"] = "Reiniciar Perfil"
+	L["reset_desc"] = "Reinicia el perfil actual a los valores por defectos, en caso de que se haya estropeado la configuración o quieras volver a empezar de nuevo."
+	L["reset_sub"] = "Reinicar el perfil actual al de por defecto"
+elseif LOCALE == "zhTW" then
+	L["choose"] = "現有的設定檔"
+	L["choose_desc"] = "您可以在文字方塊內輸入名字以建立新的設定檔，或是選擇一個現有的設定檔使用。"
+	L["choose_sub"] = "從當前可用的設定檔裡面選擇一個。"
+	L["copy"] = "複製自"
+	L["copy_desc"] = "從一個現有的設定檔，將設定複製到現在使用中的設定檔。"
+	L["current"] = "目前設定檔："
+	L["default"] = "預設"
+	L["delete"] = "刪除一個設定檔"
+	L["delete_confirm"] = "確定要刪除所選擇的設定檔嗎？"
+	L["delete_desc"] = "從資料庫裡刪除不再使用的設定檔，以節省空間，並且清理 SavedVariables 檔案。"
+	L["delete_sub"] = "從資料庫裡刪除一個設定檔。"
+	L["intro"] = "您可以從資料庫中選擇一個設定檔來使用，如此就可以讓每個角色使用不同的設定。"
+	L["new"] = "新建"
+	L["new_sub"] = "新建一個空的設定檔。"
+	L["profiles"] = "設定檔"
+	L["profiles_sub"] = "管理設定檔"
+	L["reset"] = "重置設定檔"
+	L["reset_desc"] = "將現用的設定檔重置為預設值；用於設定檔損壞，或者單純想要重來的情況。"
+	L["reset_sub"] = "將目前的設定檔重置為預設值"
+elseif LOCALE == "zhCN" then
+	L["choose"] = "现有的配置文件"
+	L["choose_desc"] = "你可以通过在文本框内输入一个名字创立一个新的配置文件，也可以选择一个已经存在的配置文件。"
+	L["choose_sub"] = "从当前可用的配置文件里面选择一个。"
+	L["copy"] = "复制自"
+	L["copy_desc"] = "从当前某个已保存的配置文件复制到当前正使用的配置文件。"
+	L["current"] = "当前配置文件："
+	L["default"] = "默认"
+	L["delete"] = "删除一个配置文件"
+	L["delete_confirm"] = "你确定要删除所选择的配置文件么？"
+	L["delete_desc"] = "从数据库里删除不再使用的配置文件，以节省空间，并且清理SavedVariables文件。"
+	L["delete_sub"] = "从数据库里删除一个配置文件。"
+	L["intro"] = "你可以选择一个活动的数据配置文件，这样你的每个角色就可以拥有不同的设置值，可以给你的插件配置带来极大的灵活性。"
+	L["new"] = "新建"
+	L["new_sub"] = "新建一个空的配置文件。"
+	L["profiles"] = "配置文件"
+	L["profiles_sub"] = "管理配置文件"
+	L["reset"] = "重置配置文件"
+	L["reset_desc"] = "将当前的配置文件恢复到它的默认值，用于你的配置文件损坏，或者你只是想重来的情况。"
+	L["reset_sub"] = "将当前的配置文件恢复为默认值"
+elseif LOCALE == "ruRU" then
+	L["choose"] = "Существующие профили"
+	L["choose_desc"] = "Вы можете создать новый профиль, введя название в поле ввода, или выбрать один из уже существующих профилей."
+	L["choose_sub"] = "Выбор одного из уже доступных профилей."
+	L["copy"] = "Скопировать из"
+	L["copy_desc"] = "Копирование настроек из выбранного профиля в активный."
+	L["current"] = "Текущий профиль:"
+	L["default"] = "По умолчанию"
+	L["delete"] = "Удалить профиль"
+	L["delete_confirm"] = "Вы уверены, что хотите удалить выбранный профиль?"
+	L["delete_desc"] = "Удаление существующего и неиспользуемого профиля из базы данных для сохранения места, и очистка файла SavedVariables."
+	L["delete_sub"] = "Удаление профиля из базы данных."
+	L["intro"] = "Изменяя активный профиль, Вы можете задать разные настройки для каждого персонажа."
+	L["new"] = "Новый"
+	L["new_sub"] = "Создание нового чистого профиля."
+	L["profiles"] = "Профили"
+	L["profiles_sub"] = "Управление профилями"
+	L["reset"] = "Сбросить профиль"
+	L["reset_desc"] = "Сброс текущего профиля к стандартным настройкам, если Ваша конфигурация испорчена или Вы хотите настроить все заново."
+	L["reset_sub"] = "Сброс текущего профиля на стандартный"
+elseif LOCALE == "itIT" then
+	L["choose"] = "Profili Esistenti"
+	L["choose_desc"] = "Puoi creare un nuovo profilo digitando il nome della casella di testo, oppure scegliendone uno tra i profili già esistenti."
+	L["choose_sub"] = "Seleziona uno dei profili attualmente disponibili."
+	L["copy"] = "Copia Da"
+	L["copy_desc"] = "Copia le impostazioni da un profilo esistente nel profilo attivo in questo momento."
+	L["current"] = "Profilo Attivo:"
+	L["default"] = "Predefinito"
+	L["delete"] = "Cancella un Profilo"
+	L["delete_confirm"] = "Sei sicuro di voler cancellare il profilo selezionato?"
+	L["delete_desc"] = "Cancella i profili non utilizzati dal database per risparmiare spazio e mantenere puliti i file di configurazione SavedVariables."
+	L["delete_sub"] = "Cancella un profilo dal Database."
+	L["intro"] = "Puoi cambiare il profilo attivo, in modo da usare impostazioni diverse per ogni personaggio."
+	L["new"] = "Nuovo"
+	L["new_sub"] = "Crea un nuovo profilo vuoto."
+	L["profiles"] = "Profili"
+	L["profiles_sub"] = "Gestisci Profili"
+	L["reset"] = "Reimposta Profilo"
+	L["reset_desc"] = "Riporta il tuo profilo attivo alle sue impostazioni predefinite, nel caso in cui la tua configurazione si sia corrotta, o semplicemente tu voglia re-inizializzarla."
+	L["reset_sub"] = "Reimposta il profilo ai suoi valori predefiniti."
+elseif LOCALE == "ptBR" then
+	L["choose"] = "Perfis Existentes"
+	L["choose_desc"] = "Você pode tanto criar um perfil novo tanto digitando um nome na caixa de texto, quanto escolher um dos perfis já existentes."
+	L["choose_sub"] = "Selecione um de seus perfis atualmente disponíveis."
+	L["copy"] = "Copiar De"
+	L["copy_desc"] = "Copia as definições de um perfil existente no perfil atualmente ativo."
+	L["current"] = "Perfil Autal:"
+	L["default"] = "Padrão"
+	L["delete"] = "Remover um Perfil"
+	L["delete_confirm"] = "Tem certeza que deseja remover o perfil selecionado?"
+	L["delete_desc"] = "Remove perfis existentes e inutilizados do banco de dados para economizar espaço, e limpar o arquivo SavedVariables."
+	L["delete_sub"] = "Remove um perfil do banco de dados."
+	L["intro"] = "Você pode alterar o perfil do banco de dados ativo, para que possa ter definições diferentes para cada personagem."
+	L["new"] = "Novo"
+	L["new_sub"] = "Cria um novo perfil vazio."
+	L["profiles"] = "Perfis"
+	L["profiles_sub"] = "Gerenciar Perfis"
+	L["reset"] = "Resetar Perfil"
+	L["reset_desc"] = "Reseta o perfil atual para os valores padrões, no caso de sua configuração estar quebrada, ou simplesmente se deseja começar novamente."
+	L["reset_sub"] = "Resetar o perfil atual ao padrão"
+end
+
+local defaultProfiles
+local tmpprofiles = {}
+
+-- Get a list of available profiles for the specified database.
+-- You can specify which profiles to include/exclude in the list using the two boolean parameters listed below.
+-- @param db The db object to retrieve the profiles from
+-- @param common If true, getProfileList will add the default profiles to the return list, even if they have not been created yet
+-- @param nocurrent If true, then getProfileList will not display the current profile in the list
+-- @return Hashtable of all profiles with the internal name as keys and the display name as value.
+local function getProfileList(db, common, nocurrent)
+	local profiles = {}
+
+	-- copy existing profiles into the table
+	local currentProfile = db:GetCurrentProfile()
+	for i,v in pairs(db:GetProfiles(tmpprofiles)) do
+		if not (nocurrent and v == currentProfile) then
+			profiles[v] = v
+		end
+	end
+
+	-- add our default profiles to choose from ( or rename existing profiles)
+	for k,v in pairs(defaultProfiles) do
+		if (common or profiles[k]) and not (nocurrent and k == currentProfile) then
+			profiles[k] = v
+		end
+	end
+
+	return profiles
+end
+
+--[[
+	OptionsHandlerPrototype
+	prototype class for handling the options in a sane way
+]]
+local OptionsHandlerPrototype = {}
+
+--[[ Reset the profile ]]
+function OptionsHandlerPrototype:Reset()
+	self.db:ResetProfile()
+end
+
+--[[ Set the profile to value ]]
+function OptionsHandlerPrototype:SetProfile(info, value)
+	self.db:SetProfile(value)
+end
+
+--[[ returns the currently active profile ]]
+function OptionsHandlerPrototype:GetCurrentProfile()
+	return self.db:GetCurrentProfile()
+end
+
+--[[
+	List all active profiles
+	you can control the output with the .arg variable
+	currently four modes are supported
+
+	(empty) - return all available profiles
+	"nocurrent" - returns all available profiles except the currently active profile
+	"common" - returns all avaialble profiles + some commonly used profiles ("char - realm", "realm", "class", "Default")
+	"both" - common except the active profile
+]]
+function OptionsHandlerPrototype:ListProfiles(info)
+	local arg = info.arg
+	local profiles
+	if arg == "common" and not self.noDefaultProfiles then
+		profiles = getProfileList(self.db, true, nil)
+	elseif arg == "nocurrent" then
+		profiles = getProfileList(self.db, nil, true)
+	elseif arg == "both" then -- currently not used
+		profiles = getProfileList(self.db, (not self.noDefaultProfiles) and true, true)
+	else
+		profiles = getProfileList(self.db)
+	end
+
+	return profiles
+end
+
+function OptionsHandlerPrototype:HasNoProfiles(info)
+	local profiles = self:ListProfiles(info)
+	return ((not next(profiles)) and true or false)
+end
+
+--[[ Copy a profile ]]
+function OptionsHandlerPrototype:CopyProfile(info, value)
+	self.db:CopyProfile(value)
+end
+
+--[[ Delete a profile from the db ]]
+function OptionsHandlerPrototype:DeleteProfile(info, value)
+	self.db:DeleteProfile(value)
+end
+
+--[[ fill defaultProfiles with some generic values ]]
+local function generateDefaultProfiles(db)
+	defaultProfiles = {
+		["Default"] = L["default"],
+		[db.keys.char] = db.keys.char,
+		[db.keys.realm] = db.keys.realm,
+		[db.keys.class] = UnitClass("player")
+	}
+end
+
+--[[ create and return a handler object for the db, or upgrade it if it already existed ]]
+local function getOptionsHandler(db, noDefaultProfiles)
+	if not defaultProfiles then
+		generateDefaultProfiles(db)
+	end
+
+	local handler = AceDBOptions.handlers[db] or { db = db, noDefaultProfiles = noDefaultProfiles }
+
+	for k,v in pairs(OptionsHandlerPrototype) do
+		handler[k] = v
+	end
+
+	AceDBOptions.handlers[db] = handler
+	return handler
+end
+
+--[[
+	the real options table
+]]
+local optionsTable = {
+	desc = {
+		order = 1,
+		type = "description",
+		name = L["intro"] .. "\n",
+	},
+	descreset = {
+		order = 9,
+		type = "description",
+		name = L["reset_desc"],
+	},
+	reset = {
+		order = 10,
+		type = "execute",
+		name = L["reset"],
+		desc = L["reset_sub"],
+		func = "Reset",
+	},
+	current = {
+		order = 11,
+		type = "description",
+		name = function(info) return L["current"] .. " " .. NORMAL_FONT_COLOR_CODE .. info.handler:GetCurrentProfile() .. FONT_COLOR_CODE_CLOSE end,
+		width = "default",
+	},
+	choosedesc = {
+		order = 20,
+		type = "description",
+		name = "\n" .. L["choose_desc"],
+	},
+	new = {
+		name = L["new"],
+		desc = L["new_sub"],
+		type = "input",
+		order = 30,
+		get = false,
+		set = "SetProfile",
+	},
+	choose = {
+		name = L["choose"],
+		desc = L["choose_sub"],
+		type = "select",
+		order = 40,
+		get = "GetCurrentProfile",
+		set = "SetProfile",
+		values = "ListProfiles",
+		arg = "common",
+	},
+	copydesc = {
+		order = 50,
+		type = "description",
+		name = "\n" .. L["copy_desc"],
+	},
+	copyfrom = {
+		order = 60,
+		type = "select",
+		name = L["copy"],
+		desc = L["copy_desc"],
+		get = false,
+		set = "CopyProfile",
+		values = "ListProfiles",
+		disabled = "HasNoProfiles",
+		arg = "nocurrent",
+	},
+	deldesc = {
+		order = 70,
+		type = "description",
+		name = "\n" .. L["delete_desc"],
+	},
+	delete = {
+		order = 80,
+		type = "select",
+		name = L["delete"],
+		desc = L["delete_sub"],
+		get = false,
+		set = "DeleteProfile",
+		values = "ListProfiles",
+		disabled = "HasNoProfiles",
+		arg = "nocurrent",
+		confirm = true,
+		confirmText = L["delete_confirm"],
+	},
+}
+
+--- Get/Create a option table that you can use in your addon to control the profiles of AceDB-3.0.
+-- @param db The database object to create the options table for.
+-- @return The options table to be used in AceConfig-3.0
+-- @usage
+-- -- Assuming `options` is your top-level options table and `self.db` is your database:
+-- options.args.profiles = LibStub("AceDBOptions-3.0"):GetOptionsTable(self.db)
+function AceDBOptions:GetOptionsTable(db, noDefaultProfiles)
+	local tbl = AceDBOptions.optionTables[db] or {
+			type = "group",
+			name = L["profiles"],
+			desc = L["profiles_sub"],
+		}
+
+	tbl.handler = getOptionsHandler(db, noDefaultProfiles)
+	tbl.args = optionsTable
+
+	AceDBOptions.optionTables[db] = tbl
+	return tbl
+end
+
+-- upgrade existing tables
+for db,tbl in pairs(AceDBOptions.optionTables) do
+	tbl.handler = getOptionsHandler(db)
+	tbl.args = optionsTable
+end

Libs/AceDBOptions-3.0/AceDBOptions-3.0.xml

@@ -0,0 +1,4 @@
+<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="AceDBOptions-3.0.lua"/>
+</Ui>

Libs/AceEvent-3.0/AceEvent-3.0.lua

@@ -0,0 +1,126 @@
+--- AceEvent-3.0 provides event registration and secure dispatching.
+-- All dispatching is done using **CallbackHandler-1.0**. AceEvent is a simple wrapper around
+-- CallbackHandler, and dispatches all game events or addon message to the registrees.
+--
+-- **AceEvent-3.0** can be embeded into your addon, either explicitly by calling AceEvent:Embed(MyAddon) or by
+-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
+-- and can be accessed directly, without having to explicitly call AceEvent itself.\\
+-- It is recommended to embed AceEvent, otherwise you'll have to specify a custom `self` on all calls you
+-- make into AceEvent.
+-- @class file
+-- @name AceEvent-3.0
+-- @release $Id: AceEvent-3.0.lua 1202 2019-05-15 23:11:22Z nevcairiel $
+local CallbackHandler = LibStub("CallbackHandler-1.0")
+
+local MAJOR, MINOR = "AceEvent-3.0", 4
+local AceEvent = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceEvent then return end
+
+-- Lua APIs
+local pairs = pairs
+
+AceEvent.frame = AceEvent.frame or CreateFrame("Frame", "AceEvent30Frame") -- our event frame
+AceEvent.embeds = AceEvent.embeds or {} -- what objects embed this lib
+
+-- APIs and registry for blizzard events, using CallbackHandler lib
+if not AceEvent.events then
+	AceEvent.events = CallbackHandler:New(AceEvent,
+		"RegisterEvent", "UnregisterEvent", "UnregisterAllEvents")
+end
+
+function AceEvent.events:OnUsed(target, eventname)
+	AceEvent.frame:RegisterEvent(eventname)
+end
+
+function AceEvent.events:OnUnused(target, eventname)
+	AceEvent.frame:UnregisterEvent(eventname)
+end
+
+
+-- APIs and registry for IPC messages, using CallbackHandler lib
+if not AceEvent.messages then
+	AceEvent.messages = CallbackHandler:New(AceEvent,
+		"RegisterMessage", "UnregisterMessage", "UnregisterAllMessages"
+	)
+	AceEvent.SendMessage = AceEvent.messages.Fire
+end
+
+--- embedding and embed handling
+local mixins = {
+	"RegisterEvent", "UnregisterEvent",
+	"RegisterMessage", "UnregisterMessage",
+	"SendMessage",
+	"UnregisterAllEvents", "UnregisterAllMessages",
+}
+
+--- Register for a Blizzard Event.
+-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied)
+-- Any arguments to the event will be passed on after that.
+-- @name AceEvent:RegisterEvent
+-- @class function
+-- @paramsig event[, callback [, arg]]
+-- @param event The event to register for
+-- @param callback The callback function to call when the event is triggered (funcref or method, defaults to a method with the event name)
+-- @param arg An optional argument to pass to the callback function
+
+--- Unregister an event.
+-- @name AceEvent:UnregisterEvent
+-- @class function
+-- @paramsig event
+-- @param event The event to unregister
+
+--- Register for a custom AceEvent-internal message.
+-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied)
+-- Any arguments to the event will be passed on after that.
+-- @name AceEvent:RegisterMessage
+-- @class function
+-- @paramsig message[, callback [, arg]]
+-- @param message The message to register for
+-- @param callback The callback function to call when the message is triggered (funcref or method, defaults to a method with the event name)
+-- @param arg An optional argument to pass to the callback function
+
+--- Unregister a message
+-- @name AceEvent:UnregisterMessage
+-- @class function
+-- @paramsig message
+-- @param message The message to unregister
+
+--- Send a message over the AceEvent-3.0 internal message system to other addons registered for this message.
+-- @name AceEvent:SendMessage
+-- @class function
+-- @paramsig message, ...
+-- @param message The message to send
+-- @param ... Any arguments to the message
+
+
+-- Embeds AceEvent into the target object making the functions from the mixins list available on target:..
+-- @param target target object to embed AceEvent in
+function AceEvent:Embed(target)
+	for k, v in pairs(mixins) do
+		target[v] = self[v]
+	end
+	self.embeds[target] = true
+	return target
+end
+
+-- AceEvent:OnEmbedDisable( target )
+-- target (object) - target object that is being disabled
+--
+-- Unregister all events messages etc when the target disables.
+-- this method should be called by the target manually or by an addon framework
+function AceEvent:OnEmbedDisable(target)
+	target:UnregisterAllEvents()
+	target:UnregisterAllMessages()
+end
+
+-- Script to fire blizzard events into the event listeners
+local events = AceEvent.events
+AceEvent.frame:SetScript("OnEvent", function(this, event, ...)
+	events:Fire(event, ...)
+end)
+
+--- Finally: upgrade our old embeds
+for target, v in pairs(AceEvent.embeds) do
+	AceEvent:Embed(target)
+end

Libs/AceEvent-3.0/AceEvent-3.0.xml

@@ -0,0 +1,4 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+..\FrameXML\UI.xsd">
+	<Script file="AceEvent-3.0.lua"/>
+</Ui>

Libs/AceGUI-3.0/AceGUI-3.0.xml

@@ -0,0 +1,28 @@
+<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="AceGUI-3.0.lua"/>
+	<!-- Container -->
+	<Script file="widgets\AceGUIContainer-BlizOptionsGroup.lua"/>
+	<Script file="widgets\AceGUIContainer-DropDownGroup.lua"/>
+	<Script file="widgets\AceGUIContainer-Frame.lua"/>
+	<Script file="widgets\AceGUIContainer-InlineGroup.lua"/>
+	<Script file="widgets\AceGUIContainer-ScrollFrame.lua"/>
+	<Script file="widgets\AceGUIContainer-SimpleGroup.lua"/>
+	<Script file="widgets\AceGUIContainer-TabGroup.lua"/>
+	<Script file="widgets\AceGUIContainer-TreeGroup.lua"/>
+	<Script file="widgets\AceGUIContainer-Window.lua"/>
+	<!-- Widgets -->
+	<Script file="widgets\AceGUIWidget-Button.lua"/>
+	<Script file="widgets\AceGUIWidget-CheckBox.lua"/>
+	<Script file="widgets\AceGUIWidget-ColorPicker.lua"/>
+	<Script file="widgets\AceGUIWidget-DropDown.lua"/>
+	<Script file="widgets\AceGUIWidget-DropDown-Items.lua"/>
+	<Script file="widgets\AceGUIWidget-EditBox.lua"/>
+	<Script file="widgets\AceGUIWidget-Heading.lua"/>
+	<Script file="widgets\AceGUIWidget-Icon.lua"/>
+	<Script file="widgets\AceGUIWidget-InteractiveLabel.lua"/>
+	<Script file="widgets\AceGUIWidget-Keybinding.lua"/>
+	<Script file="widgets\AceGUIWidget-Label.lua"/>
+	<Script file="widgets\AceGUIWidget-MultiLineEditBox.lua"/>
+	<Script file="widgets\AceGUIWidget-Slider.lua"/>
+</Ui>

Libs/AceGUI-3.0/widgets/AceGUIContainer-BlizOptionsGroup.lua

@@ -0,0 +1,143 @@
+--[[-----------------------------------------------------------------------------
+BlizOptionsGroup Container
+Simple container widget for the integration of AceGUI into the Blizzard Interface Options
+-------------------------------------------------------------------------------]]
+local Type, Version = "BlizOptionsGroup", 26
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs = pairs
+
+-- WoW APIs
+local CreateFrame = CreateFrame
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+
+local function OnShow(frame)
+	frame.obj:Fire("OnShow")
+end
+
+local function OnHide(frame)
+	frame.obj:Fire("OnHide")
+end
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+
+local function okay(frame)
+	frame.obj:Fire("okay")
+end
+
+local function cancel(frame)
+	frame.obj:Fire("cancel")
+end
+
+local function default(frame)
+	frame.obj:Fire("default")
+end
+
+local function refresh(frame)
+	frame.obj:Fire("refresh")
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetName()
+		self:SetTitle()
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["OnWidthSet"] = function(self, width)
+		local content = self.content
+		local contentwidth = width - 63
+		if contentwidth < 0 then
+			contentwidth = 0
+		end
+		content:SetWidth(contentwidth)
+		content.width = contentwidth
+	end,
+
+	["OnHeightSet"] = function(self, height)
+		local content = self.content
+		local contentheight = height - 26
+		if contentheight < 0 then
+			contentheight = 0
+		end
+		content:SetHeight(contentheight)
+		content.height = contentheight
+	end,
+
+	["SetName"] = function(self, name, parent)
+		self.frame.name = name
+		self.frame.parent = parent
+	end,
+
+	["SetTitle"] = function(self, title)
+		local content = self.content
+		content:ClearAllPoints()
+		if not title or title == "" then
+			content:SetPoint("TOPLEFT", 10, -10)
+			self.label:SetText("")
+		else
+			content:SetPoint("TOPLEFT", 10, -40)
+			self.label:SetText(title)
+		end
+		content:SetPoint("BOTTOMRIGHT", -10, 10)
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, InterfaceOptionsFramePanelContainer)
+	frame:Hide()
+
+	-- support functions for the Blizzard Interface Options
+	frame.okay = okay
+	frame.cancel = cancel
+	frame.default = default
+	frame.refresh = refresh
+
+	-- 10.0 support function aliases (cancel has been removed)
+	frame.OnCommit = okay
+	frame.OnDefault = default
+	frame.OnRefresh = refresh
+
+	frame:SetScript("OnHide", OnHide)
+	frame:SetScript("OnShow", OnShow)
+
+	local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge")
+	label:SetPoint("TOPLEFT", 10, -15)
+	label:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", 10, -45)
+	label:SetJustifyH("LEFT")
+	label:SetJustifyV("TOP")
+
+	--Container Support
+	local content = CreateFrame("Frame", nil, frame)
+	content:SetPoint("TOPLEFT", 10, -10)
+	content:SetPoint("BOTTOMRIGHT", -10, 10)
+
+	local widget = {
+		label   = label,
+		frame   = frame,
+		content = content,
+		type    = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsContainer(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIContainer-DropDownGroup.lua

@@ -0,0 +1,157 @@
+--[[-----------------------------------------------------------------------------
+DropdownGroup Container
+Container controlled by a dropdown on the top.
+-------------------------------------------------------------------------------]]
+local Type, Version = "DropdownGroup", 22
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local assert, pairs, type = assert, pairs, type
+
+-- WoW APIs
+local CreateFrame = CreateFrame
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function SelectedGroup(self, event, value)
+	local group = self.parentgroup
+	local status = group.status or group.localstatus
+	status.selected = value
+	self.parentgroup:Fire("OnGroupSelected", value)
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self.dropdown:SetText("")
+		self:SetDropdownWidth(200)
+		self:SetTitle("")
+	end,
+
+	["OnRelease"] = function(self)
+		self.dropdown.list = nil
+		self.status = nil
+		for k in pairs(self.localstatus) do
+			self.localstatus[k] = nil
+		end
+	end,
+
+	["SetTitle"] = function(self, title)
+		self.titletext:SetText(title)
+		self.dropdown.frame:ClearAllPoints()
+		if title and title ~= "" then
+			self.dropdown.frame:SetPoint("TOPRIGHT", -2, 0)
+		else
+			self.dropdown.frame:SetPoint("TOPLEFT", -1, 0)
+		end
+	end,
+
+	["SetGroupList"] = function(self,list,order)
+		self.dropdown:SetList(list,order)
+	end,
+
+	["SetStatusTable"] = function(self, status)
+		assert(type(status) == "table")
+		self.status = status
+	end,
+
+	["SetGroup"] = function(self,group)
+		self.dropdown:SetValue(group)
+		local status = self.status or self.localstatus
+		status.selected = group
+		self:Fire("OnGroupSelected", group)
+	end,
+
+	["OnWidthSet"] = function(self, width)
+		local content = self.content
+		local contentwidth = width - 26
+		if contentwidth < 0 then
+			contentwidth = 0
+		end
+		content:SetWidth(contentwidth)
+		content.width = contentwidth
+	end,
+
+	["OnHeightSet"] = function(self, height)
+		local content = self.content
+		local contentheight = height - 63
+		if contentheight < 0 then
+			contentheight = 0
+		end
+		content:SetHeight(contentheight)
+		content.height = contentheight
+	end,
+
+	["LayoutFinished"] = function(self, width, height)
+		self:SetHeight((height or 0) + 63)
+	end,
+
+	["SetDropdownWidth"] = function(self, width)
+		self.dropdown:SetWidth(width)
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local PaneBackdrop  = {
+	bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
+	edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
+	tile = true, tileSize = 16, edgeSize = 16,
+	insets = { left = 3, right = 3, top = 5, bottom = 3 }
+}
+
+local function Constructor()
+	local frame = CreateFrame("Frame")
+	frame:SetHeight(100)
+	frame:SetWidth(100)
+	frame:SetFrameStrata("FULLSCREEN_DIALOG")
+
+	local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+	titletext:SetPoint("TOPLEFT", 4, -5)
+	titletext:SetPoint("TOPRIGHT", -4, -5)
+	titletext:SetJustifyH("LEFT")
+	titletext:SetHeight(18)
+
+	local dropdown = AceGUI:Create("Dropdown")
+	dropdown.frame:SetParent(frame)
+	dropdown.frame:SetFrameLevel(dropdown.frame:GetFrameLevel() + 2)
+	dropdown:SetCallback("OnValueChanged", SelectedGroup)
+	dropdown.frame:SetPoint("TOPLEFT", -1, 0)
+	dropdown.frame:Show()
+	dropdown:SetLabel("")
+
+	local border = CreateFrame("Frame", nil, frame, "BackdropTemplate")
+	border:SetPoint("TOPLEFT", 0, -26)
+	border:SetPoint("BOTTOMRIGHT", 0, 3)
+	border:SetBackdrop(PaneBackdrop)
+	border:SetBackdropColor(0.1,0.1,0.1,0.5)
+	border:SetBackdropBorderColor(0.4,0.4,0.4)
+
+	--Container Support
+	local content = CreateFrame("Frame", nil, border)
+	content:SetPoint("TOPLEFT", 10, -10)
+	content:SetPoint("BOTTOMRIGHT", -10, 10)
+
+	local widget = {
+		frame       = frame,
+		localstatus = {},
+		titletext   = titletext,
+		dropdown    = dropdown,
+		border      = border,
+		content     = content,
+		type        = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+	dropdown.parentgroup = widget
+
+	return AceGUI:RegisterAsContainer(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIContainer-Frame.lua

@@ -0,0 +1,318 @@
+--[[-----------------------------------------------------------------------------
+Frame Container
+-------------------------------------------------------------------------------]]
+local Type, Version = "Frame", 30
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs, assert, type = pairs, assert, type
+local wipe = table.wipe
+
+-- WoW APIs
+local PlaySound = PlaySound
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Button_OnClick(frame)
+	PlaySound(799) -- SOUNDKIT.GS_TITLE_OPTION_EXIT
+	frame.obj:Hide()
+end
+
+local function Frame_OnShow(frame)
+	frame.obj:Fire("OnShow")
+end
+
+local function Frame_OnClose(frame)
+	frame.obj:Fire("OnClose")
+end
+
+local function Frame_OnMouseDown(frame)
+	AceGUI:ClearFocus()
+end
+
+local function Title_OnMouseDown(frame)
+	frame:GetParent():StartMoving()
+	AceGUI:ClearFocus()
+end
+
+local function MoverSizer_OnMouseUp(mover)
+	local frame = mover:GetParent()
+	frame:StopMovingOrSizing()
+	local self = frame.obj
+	local status = self.status or self.localstatus
+	status.width = frame:GetWidth()
+	status.height = frame:GetHeight()
+	status.top = frame:GetTop()
+	status.left = frame:GetLeft()
+end
+
+local function SizerSE_OnMouseDown(frame)
+	frame:GetParent():StartSizing("BOTTOMRIGHT")
+	AceGUI:ClearFocus()
+end
+
+local function SizerS_OnMouseDown(frame)
+	frame:GetParent():StartSizing("BOTTOM")
+	AceGUI:ClearFocus()
+end
+
+local function SizerE_OnMouseDown(frame)
+	frame:GetParent():StartSizing("RIGHT")
+	AceGUI:ClearFocus()
+end
+
+local function StatusBar_OnEnter(frame)
+	frame.obj:Fire("OnEnterStatusBar")
+end
+
+local function StatusBar_OnLeave(frame)
+	frame.obj:Fire("OnLeaveStatusBar")
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self.frame:SetParent(UIParent)
+		self.frame:SetFrameStrata("FULLSCREEN_DIALOG")
+		self.frame:SetFrameLevel(100) -- Lots of room to draw under it
+		self:SetTitle()
+		self:SetStatusText()
+		self:ApplyStatus()
+		self:Show()
+        self:EnableResize(true)
+	end,
+
+	["OnRelease"] = function(self)
+		self.status = nil
+		wipe(self.localstatus)
+	end,
+
+	["OnWidthSet"] = function(self, width)
+		local content = self.content
+		local contentwidth = width - 34
+		if contentwidth < 0 then
+			contentwidth = 0
+		end
+		content:SetWidth(contentwidth)
+		content.width = contentwidth
+	end,
+
+	["OnHeightSet"] = function(self, height)
+		local content = self.content
+		local contentheight = height - 57
+		if contentheight < 0 then
+			contentheight = 0
+		end
+		content:SetHeight(contentheight)
+		content.height = contentheight
+	end,
+
+	["SetTitle"] = function(self, title)
+		self.titletext:SetText(title)
+		self.titlebg:SetWidth((self.titletext:GetWidth() or 0) + 10)
+	end,
+
+	["SetStatusText"] = function(self, text)
+		self.statustext:SetText(text)
+	end,
+
+	["Hide"] = function(self)
+		self.frame:Hide()
+	end,
+
+	["Show"] = function(self)
+		self.frame:Show()
+	end,
+
+	["EnableResize"] = function(self, state)
+		local func = state and "Show" or "Hide"
+		self.sizer_se[func](self.sizer_se)
+		self.sizer_s[func](self.sizer_s)
+		self.sizer_e[func](self.sizer_e)
+	end,
+
+	-- called to set an external table to store status in
+	["SetStatusTable"] = function(self, status)
+		assert(type(status) == "table")
+		self.status = status
+		self:ApplyStatus()
+	end,
+
+	["ApplyStatus"] = function(self)
+		local status = self.status or self.localstatus
+		local frame = self.frame
+		self:SetWidth(status.width or 700)
+		self:SetHeight(status.height or 500)
+		frame:ClearAllPoints()
+		if status.top and status.left then
+			frame:SetPoint("TOP", UIParent, "BOTTOM", 0, status.top)
+			frame:SetPoint("LEFT", UIParent, "LEFT", status.left, 0)
+		else
+			frame:SetPoint("CENTER")
+		end
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local FrameBackdrop = {
+	bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background",
+	edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
+	tile = true, tileSize = 32, edgeSize = 32,
+	insets = { left = 8, right = 8, top = 8, bottom = 8 }
+}
+
+local PaneBackdrop  = {
+	bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
+	edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
+	tile = true, tileSize = 16, edgeSize = 16,
+	insets = { left = 3, right = 3, top = 5, bottom = 3 }
+}
+
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, UIParent, "BackdropTemplate")
+	frame:Hide()
+
+	frame:EnableMouse(true)
+	frame:SetMovable(true)
+	frame:SetResizable(true)
+	frame:SetFrameStrata("FULLSCREEN_DIALOG")
+	frame:SetFrameLevel(100) -- Lots of room to draw under it
+	frame:SetBackdrop(FrameBackdrop)
+	frame:SetBackdropColor(0, 0, 0, 1)
+	if frame.SetResizeBounds then -- WoW 10.0
+		frame:SetResizeBounds(400, 200)
+	else
+		frame:SetMinResize(400, 200)
+	end
+	frame:SetToplevel(true)
+	frame:SetScript("OnShow", Frame_OnShow)
+	frame:SetScript("OnHide", Frame_OnClose)
+	frame:SetScript("OnMouseDown", Frame_OnMouseDown)
+
+	local closebutton = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate")
+	closebutton:SetScript("OnClick", Button_OnClick)
+	closebutton:SetPoint("BOTTOMRIGHT", -27, 17)
+	closebutton:SetHeight(20)
+	closebutton:SetWidth(100)
+	closebutton:SetText(CLOSE)
+
+	local statusbg = CreateFrame("Button", nil, frame, "BackdropTemplate")
+	statusbg:SetPoint("BOTTOMLEFT", 15, 15)
+	statusbg:SetPoint("BOTTOMRIGHT", -132, 15)
+	statusbg:SetHeight(24)
+	statusbg:SetBackdrop(PaneBackdrop)
+	statusbg:SetBackdropColor(0.1,0.1,0.1)
+	statusbg:SetBackdropBorderColor(0.4,0.4,0.4)
+	statusbg:SetScript("OnEnter", StatusBar_OnEnter)
+	statusbg:SetScript("OnLeave", StatusBar_OnLeave)
+
+	local statustext = statusbg:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+	statustext:SetPoint("TOPLEFT", 7, -2)
+	statustext:SetPoint("BOTTOMRIGHT", -7, 2)
+	statustext:SetHeight(20)
+	statustext:SetJustifyH("LEFT")
+	statustext:SetText("")
+
+	local titlebg = frame:CreateTexture(nil, "OVERLAY")
+	titlebg:SetTexture(131080) -- Interface\\DialogFrame\\UI-DialogBox-Header
+	titlebg:SetTexCoord(0.31, 0.67, 0, 0.63)
+	titlebg:SetPoint("TOP", 0, 12)
+	titlebg:SetWidth(100)
+	titlebg:SetHeight(40)
+
+	local title = CreateFrame("Frame", nil, frame)
+	title:EnableMouse(true)
+	title:SetScript("OnMouseDown", Title_OnMouseDown)
+	title:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
+	title:SetAllPoints(titlebg)
+
+	local titletext = title:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+	titletext:SetPoint("TOP", titlebg, "TOP", 0, -14)
+
+	local titlebg_l = frame:CreateTexture(nil, "OVERLAY")
+	titlebg_l:SetTexture(131080) -- Interface\\DialogFrame\\UI-DialogBox-Header
+	titlebg_l:SetTexCoord(0.21, 0.31, 0, 0.63)
+	titlebg_l:SetPoint("RIGHT", titlebg, "LEFT")
+	titlebg_l:SetWidth(30)
+	titlebg_l:SetHeight(40)
+
+	local titlebg_r = frame:CreateTexture(nil, "OVERLAY")
+	titlebg_r:SetTexture(131080) -- Interface\\DialogFrame\\UI-DialogBox-Header
+	titlebg_r:SetTexCoord(0.67, 0.77, 0, 0.63)
+	titlebg_r:SetPoint("LEFT", titlebg, "RIGHT")
+	titlebg_r:SetWidth(30)
+	titlebg_r:SetHeight(40)
+
+	local sizer_se = CreateFrame("Frame", nil, frame)
+	sizer_se:SetPoint("BOTTOMRIGHT")
+	sizer_se:SetWidth(25)
+	sizer_se:SetHeight(25)
+	sizer_se:EnableMouse()
+	sizer_se:SetScript("OnMouseDown",SizerSE_OnMouseDown)
+	sizer_se:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
+
+	local line1 = sizer_se:CreateTexture(nil, "BACKGROUND")
+	line1:SetWidth(14)
+	line1:SetHeight(14)
+	line1:SetPoint("BOTTOMRIGHT", -8, 8)
+	line1:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
+	local x = 0.1 * 14/17
+	line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
+
+	local line2 = sizer_se:CreateTexture(nil, "BACKGROUND")
+	line2:SetWidth(8)
+	line2:SetHeight(8)
+	line2:SetPoint("BOTTOMRIGHT", -8, 8)
+	line2:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
+	x = 0.1 * 8/17
+	line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
+
+	local sizer_s = CreateFrame("Frame", nil, frame)
+	sizer_s:SetPoint("BOTTOMRIGHT", -25, 0)
+	sizer_s:SetPoint("BOTTOMLEFT")
+	sizer_s:SetHeight(25)
+	sizer_s:EnableMouse(true)
+	sizer_s:SetScript("OnMouseDown", SizerS_OnMouseDown)
+	sizer_s:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
+
+	local sizer_e = CreateFrame("Frame", nil, frame)
+	sizer_e:SetPoint("BOTTOMRIGHT", 0, 25)
+	sizer_e:SetPoint("TOPRIGHT")
+	sizer_e:SetWidth(25)
+	sizer_e:EnableMouse(true)
+	sizer_e:SetScript("OnMouseDown", SizerE_OnMouseDown)
+	sizer_e:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
+
+	--Container Support
+	local content = CreateFrame("Frame", nil, frame)
+	content:SetPoint("TOPLEFT", 17, -27)
+	content:SetPoint("BOTTOMRIGHT", -17, 40)
+
+	local widget = {
+		localstatus = {},
+		titletext   = titletext,
+		statustext  = statustext,
+		titlebg     = titlebg,
+		sizer_se    = sizer_se,
+		sizer_s     = sizer_s,
+		sizer_e     = sizer_e,
+		content     = content,
+		frame       = frame,
+		type        = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+	closebutton.obj, statusbg.obj = widget, widget
+
+	return AceGUI:RegisterAsContainer(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIContainer-InlineGroup.lua

@@ -0,0 +1,103 @@
+--[[-----------------------------------------------------------------------------
+InlineGroup Container
+Simple container widget that creates a visible "box" with an optional title.
+-------------------------------------------------------------------------------]]
+local Type, Version = "InlineGroup", 22
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs = pairs
+
+-- WoW APIs
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetWidth(300)
+		self:SetHeight(100)
+		self:SetTitle("")
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["SetTitle"] = function(self,title)
+		self.titletext:SetText(title)
+	end,
+
+
+	["LayoutFinished"] = function(self, width, height)
+		if self.noAutoHeight then return end
+		self:SetHeight((height or 0) + 40)
+	end,
+
+	["OnWidthSet"] = function(self, width)
+		local content = self.content
+		local contentwidth = width - 20
+		if contentwidth < 0 then
+			contentwidth = 0
+		end
+		content:SetWidth(contentwidth)
+		content.width = contentwidth
+	end,
+
+	["OnHeightSet"] = function(self, height)
+		local content = self.content
+		local contentheight = height - 20
+		if contentheight < 0 then
+			contentheight = 0
+		end
+		content:SetHeight(contentheight)
+		content.height = contentheight
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local PaneBackdrop  = {
+	bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
+	edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
+	tile = true, tileSize = 16, edgeSize = 16,
+	insets = { left = 3, right = 3, top = 5, bottom = 3 }
+}
+
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, UIParent)
+	frame:SetFrameStrata("FULLSCREEN_DIALOG")
+
+	local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+	titletext:SetPoint("TOPLEFT", 14, 0)
+	titletext:SetPoint("TOPRIGHT", -14, 0)
+	titletext:SetJustifyH("LEFT")
+	titletext:SetHeight(18)
+
+	local border = CreateFrame("Frame", nil, frame, "BackdropTemplate")
+	border:SetPoint("TOPLEFT", 0, -17)
+	border:SetPoint("BOTTOMRIGHT", -1, 3)
+	border:SetBackdrop(PaneBackdrop)
+	border:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
+	border:SetBackdropBorderColor(0.4, 0.4, 0.4)
+
+	--Container Support
+	local content = CreateFrame("Frame", nil, border)
+	content:SetPoint("TOPLEFT", 10, -10)
+	content:SetPoint("BOTTOMRIGHT", -10, 10)
+
+	local widget = {
+		frame     = frame,
+		content   = content,
+		titletext = titletext,
+		type      = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsContainer(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIContainer-ScrollFrame.lua

@@ -0,0 +1,215 @@
+--[[-----------------------------------------------------------------------------
+ScrollFrame Container
+Plain container that scrolls its content and doesn't grow in height.
+-------------------------------------------------------------------------------]]
+local Type, Version = "ScrollFrame", 26
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs, assert, type = pairs, assert, type
+local min, max, floor = math.min, math.max, math.floor
+
+-- WoW APIs
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+local function FixScrollOnUpdate(frame)
+	frame:SetScript("OnUpdate", nil)
+	frame.obj:FixScroll()
+end
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function ScrollFrame_OnMouseWheel(frame, value)
+	frame.obj:MoveScroll(value)
+end
+
+local function ScrollFrame_OnSizeChanged(frame)
+	frame:SetScript("OnUpdate", FixScrollOnUpdate)
+end
+
+local function ScrollBar_OnScrollValueChanged(frame, value)
+	frame.obj:SetScroll(value)
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetScroll(0)
+		self.scrollframe:SetScript("OnUpdate", FixScrollOnUpdate)
+	end,
+
+	["OnRelease"] = function(self)
+		self.status = nil
+		for k in pairs(self.localstatus) do
+			self.localstatus[k] = nil
+		end
+		self.scrollframe:SetPoint("BOTTOMRIGHT")
+		self.scrollbar:Hide()
+		self.scrollBarShown = nil
+		self.content.height, self.content.width, self.content.original_width = nil, nil, nil
+	end,
+
+	["SetScroll"] = function(self, value)
+		local status = self.status or self.localstatus
+		local viewheight = self.scrollframe:GetHeight()
+		local height = self.content:GetHeight()
+		local offset
+
+		if viewheight > height then
+			offset = 0
+		else
+			offset = floor((height - viewheight) / 1000.0 * value)
+		end
+		self.content:ClearAllPoints()
+		self.content:SetPoint("TOPLEFT", 0, offset)
+		self.content:SetPoint("TOPRIGHT", 0, offset)
+		status.offset = offset
+		status.scrollvalue = value
+	end,
+
+	["MoveScroll"] = function(self, value)
+		local status = self.status or self.localstatus
+		local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight()
+
+		if self.scrollBarShown then
+			local diff = height - viewheight
+			local delta = 1
+			if value < 0 then
+				delta = -1
+			end
+			self.scrollbar:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000))
+		end
+	end,
+
+	["FixScroll"] = function(self)
+		if self.updateLock then return end
+		self.updateLock = true
+		local status = self.status or self.localstatus
+		local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight()
+		local offset = status.offset or 0
+		-- Give us a margin of error of 2 pixels to stop some conditions that i would blame on floating point inaccuracys
+		-- No-one is going to miss 2 pixels at the bottom of the frame, anyhow!
+		if viewheight < height + 2 then
+			if self.scrollBarShown then
+				self.scrollBarShown = nil
+				self.scrollbar:Hide()
+				self.scrollbar:SetValue(0)
+				self.scrollframe:SetPoint("BOTTOMRIGHT")
+				if self.content.original_width then
+					self.content.width = self.content.original_width
+				end
+				self:DoLayout()
+			end
+		else
+			if not self.scrollBarShown then
+				self.scrollBarShown = true
+				self.scrollbar:Show()
+				self.scrollframe:SetPoint("BOTTOMRIGHT", -20, 0)
+				if self.content.original_width then
+					self.content.width = self.content.original_width - 20
+				end
+				self:DoLayout()
+			end
+			local value = (offset / (viewheight - height) * 1000)
+			if value > 1000 then value = 1000 end
+			self.scrollbar:SetValue(value)
+			self:SetScroll(value)
+			if value < 1000 then
+				self.content:ClearAllPoints()
+				self.content:SetPoint("TOPLEFT", 0, offset)
+				self.content:SetPoint("TOPRIGHT", 0, offset)
+				status.offset = offset
+			end
+		end
+		self.updateLock = nil
+	end,
+
+	["LayoutFinished"] = function(self, width, height)
+		self.content:SetHeight(height or 0 + 20)
+
+		-- update the scrollframe
+		self:FixScroll()
+
+		-- schedule another update when everything has "settled"
+		self.scrollframe:SetScript("OnUpdate", FixScrollOnUpdate)
+	end,
+
+	["SetStatusTable"] = function(self, status)
+		assert(type(status) == "table")
+		self.status = status
+		if not status.scrollvalue then
+			status.scrollvalue = 0
+		end
+	end,
+
+	["OnWidthSet"] = function(self, width)
+		local content = self.content
+		content.width = width - (self.scrollBarShown and 20 or 0)
+		content.original_width = width
+	end,
+
+	["OnHeightSet"] = function(self, height)
+		local content = self.content
+		content.height = height
+	end
+}
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, UIParent)
+	local num = AceGUI:GetNextWidgetNum(Type)
+
+	local scrollframe = CreateFrame("ScrollFrame", nil, frame)
+	scrollframe:SetPoint("TOPLEFT")
+	scrollframe:SetPoint("BOTTOMRIGHT")
+	scrollframe:EnableMouseWheel(true)
+	scrollframe:SetScript("OnMouseWheel", ScrollFrame_OnMouseWheel)
+	scrollframe:SetScript("OnSizeChanged", ScrollFrame_OnSizeChanged)
+
+	local scrollbar = CreateFrame("Slider", ("AceConfigDialogScrollFrame%dScrollBar"):format(num), scrollframe, "UIPanelScrollBarTemplate")
+	scrollbar:SetPoint("TOPLEFT", scrollframe, "TOPRIGHT", 4, -16)
+	scrollbar:SetPoint("BOTTOMLEFT", scrollframe, "BOTTOMRIGHT", 4, 16)
+	scrollbar:SetMinMaxValues(0, 1000)
+	scrollbar:SetValueStep(1)
+	scrollbar:SetValue(0)
+	scrollbar:SetWidth(16)
+	scrollbar:Hide()
+	-- set the script as the last step, so it doesn't fire yet
+	scrollbar:SetScript("OnValueChanged", ScrollBar_OnScrollValueChanged)
+
+	local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND")
+	scrollbg:SetAllPoints(scrollbar)
+	scrollbg:SetColorTexture(0, 0, 0, 0.4)
+
+	--Container Support
+	local content = CreateFrame("Frame", nil, scrollframe)
+	content:SetPoint("TOPLEFT")
+	content:SetPoint("TOPRIGHT")
+	content:SetHeight(400)
+	scrollframe:SetScrollChild(content)
+
+	local widget = {
+		localstatus = { scrollvalue = 0 },
+		scrollframe = scrollframe,
+		scrollbar   = scrollbar,
+		content     = content,
+		frame       = frame,
+		type        = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+	scrollframe.obj, scrollbar.obj = widget, widget
+
+	return AceGUI:RegisterAsContainer(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIContainer-SimpleGroup.lua

@@ -0,0 +1,69 @@
+--[[-----------------------------------------------------------------------------
+SimpleGroup Container
+Simple container widget that just groups widgets.
+-------------------------------------------------------------------------------]]
+local Type, Version = "SimpleGroup", 20
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs = pairs
+
+-- WoW APIs
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetWidth(300)
+		self:SetHeight(100)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["LayoutFinished"] = function(self, width, height)
+		if self.noAutoHeight then return end
+		self:SetHeight(height or 0)
+	end,
+
+	["OnWidthSet"] = function(self, width)
+		local content = self.content
+		content:SetWidth(width)
+		content.width = width
+	end,
+
+	["OnHeightSet"] = function(self, height)
+		local content = self.content
+		content:SetHeight(height)
+		content.height = height
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, UIParent)
+	frame:SetFrameStrata("FULLSCREEN_DIALOG")
+
+	--Container Support
+	local content = CreateFrame("Frame", nil, frame)
+	content:SetPoint("TOPLEFT")
+	content:SetPoint("BOTTOMRIGHT")
+
+	local widget = {
+		frame     = frame,
+		content   = content,
+		type      = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsContainer(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIContainer-TabGroup.lua

@@ -0,0 +1,535 @@
+--[[-----------------------------------------------------------------------------
+TabGroup Container
+Container that uses tabs on top to switch between groups.
+-------------------------------------------------------------------------------]]
+local Type, Version = "TabGroup", 38
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs, ipairs, assert, type, wipe = pairs, ipairs, assert, type, table.wipe
+
+-- WoW APIs
+local PlaySound = PlaySound
+local CreateFrame, UIParent = CreateFrame, UIParent
+local _G = _G
+
+-- local upvalue storage used by BuildTabs
+local widths = {}
+local rowwidths = {}
+local rowends = {}
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+
+local function PanelTemplates_TabResize(tab, padding, absoluteSize, minWidth, maxWidth, absoluteTextSize)
+	local tabName = tab:GetName();
+
+	local buttonMiddle = tab.Middle or tab.middleTexture or _G[tabName.."Middle"];
+	local buttonMiddleDisabled = tab.MiddleDisabled or (tabName and _G[tabName.."MiddleDisabled"]);
+	local left = tab.Left or tab.leftTexture or _G[tabName.."Left"];
+	local sideWidths = 2 * left:GetWidth();
+	local tabText = tab.Text or _G[tab:GetName().."Text"];
+	local highlightTexture = tab.HighlightTexture or (tabName and _G[tabName.."HighlightTexture"]);
+
+	local width, tabWidth;
+	local textWidth;
+	if ( absoluteTextSize ) then
+		textWidth = absoluteTextSize;
+	else
+		tabText:SetWidth(0);
+		textWidth = tabText:GetWidth();
+	end
+	-- If there's an absolute size specified then use it
+	if ( absoluteSize ) then
+		if ( absoluteSize < sideWidths) then
+			width = 1;
+			tabWidth = sideWidths
+		else
+			width = absoluteSize - sideWidths;
+			tabWidth = absoluteSize
+		end
+		tabText:SetWidth(width);
+	else
+		-- Otherwise try to use padding
+		if ( padding ) then
+			width = textWidth + padding;
+		else
+			width = textWidth + 24;
+		end
+		-- If greater than the maxWidth then cap it
+		if ( maxWidth and width > maxWidth ) then
+			if ( padding ) then
+				width = maxWidth + padding;
+			else
+				width = maxWidth + 24;
+			end
+			tabText:SetWidth(width);
+		else
+			tabText:SetWidth(0);
+		end
+		if (minWidth and width < minWidth) then
+			width = minWidth;
+		end
+		tabWidth = width + sideWidths;
+	end
+
+	if ( buttonMiddle ) then
+		buttonMiddle:SetWidth(width);
+	end
+	if ( buttonMiddleDisabled ) then
+		buttonMiddleDisabled:SetWidth(width);
+	end
+
+	tab:SetWidth(tabWidth);
+
+	if ( highlightTexture ) then
+		highlightTexture:SetWidth(tabWidth);
+	end
+end
+
+local function PanelTemplates_DeselectTab(tab)
+	local name = tab:GetName();
+
+	local left = tab.Left or _G[name.."Left"];
+	local middle = tab.Middle or _G[name.."Middle"];
+	local right = tab.Right or _G[name.."Right"];
+	left:Show();
+	middle:Show();
+	right:Show();
+	--tab:UnlockHighlight();
+	tab:Enable();
+	local text = tab.Text or _G[name.."Text"];
+	text:SetPoint("CENTER", tab, "CENTER", (tab.deselectedTextX or 0), (tab.deselectedTextY or 2));
+
+	local leftDisabled = tab.LeftDisabled or _G[name.."LeftDisabled"];
+	local middleDisabled = tab.MiddleDisabled or _G[name.."MiddleDisabled"];
+	local rightDisabled = tab.RightDisabled or _G[name.."RightDisabled"];
+	leftDisabled:Hide();
+	middleDisabled:Hide();
+	rightDisabled:Hide();
+end
+
+local function PanelTemplates_SelectTab(tab)
+	local name = tab:GetName();
+
+	local left = tab.Left or _G[name.."Left"];
+	local middle = tab.Middle or _G[name.."Middle"];
+	local right = tab.Right or _G[name.."Right"];
+	left:Hide();
+	middle:Hide();
+	right:Hide();
+	--tab:LockHighlight();
+	tab:Disable();
+	tab:SetDisabledFontObject(GameFontHighlightSmall);
+	local text = tab.Text or _G[name.."Text"];
+	text:SetPoint("CENTER", tab, "CENTER", (tab.selectedTextX or 0), (tab.selectedTextY or -3));
+
+	local leftDisabled = tab.LeftDisabled or _G[name.."LeftDisabled"];
+	local middleDisabled = tab.MiddleDisabled or _G[name.."MiddleDisabled"];
+	local rightDisabled = tab.RightDisabled or _G[name.."RightDisabled"];
+	leftDisabled:Show();
+	middleDisabled:Show();
+	rightDisabled:Show();
+
+	if GameTooltip:IsOwned(tab) then
+		GameTooltip:Hide();
+	end
+end
+
+local function PanelTemplates_SetDisabledTabState(tab)
+	local name = tab:GetName();
+	local left = tab.Left or _G[name.."Left"];
+	local middle = tab.Middle or _G[name.."Middle"];
+	local right = tab.Right or _G[name.."Right"];
+	left:Show();
+	middle:Show();
+	right:Show();
+	--tab:UnlockHighlight();
+	tab:Disable();
+	tab.text = tab:GetText();
+	-- Gray out text
+	tab:SetDisabledFontObject(GameFontDisableSmall);
+	local leftDisabled = tab.LeftDisabled or _G[name.."LeftDisabled"];
+	local middleDisabled = tab.MiddleDisabled or _G[name.."MiddleDisabled"];
+	local rightDisabled = tab.RightDisabled or _G[name.."RightDisabled"];
+	leftDisabled:Hide();
+	middleDisabled:Hide();
+	rightDisabled:Hide();
+end
+
+local function UpdateTabLook(frame)
+	if frame.disabled then
+		PanelTemplates_SetDisabledTabState(frame)
+	elseif frame.selected then
+		PanelTemplates_SelectTab(frame)
+	else
+		PanelTemplates_DeselectTab(frame)
+	end
+end
+
+local function Tab_SetText(frame, text)
+	frame:_SetText(text)
+	local width = frame.obj.frame.width or frame.obj.frame:GetWidth() or 0
+	PanelTemplates_TabResize(frame, 0, nil, nil, width, frame:GetFontString():GetStringWidth())
+end
+
+local function Tab_SetSelected(frame, selected)
+	frame.selected = selected
+	UpdateTabLook(frame)
+end
+
+local function Tab_SetDisabled(frame, disabled)
+	frame.disabled = disabled
+	UpdateTabLook(frame)
+end
+
+local function BuildTabsOnUpdate(frame)
+	local self = frame.obj
+	self:BuildTabs()
+	frame:SetScript("OnUpdate", nil)
+end
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Tab_OnClick(frame)
+	if not (frame.selected or frame.disabled) then
+		PlaySound(841) -- SOUNDKIT.IG_CHARACTER_INFO_TAB
+		frame.obj:SelectTab(frame.value)
+	end
+end
+
+local function Tab_OnEnter(frame)
+	local self = frame.obj
+	self:Fire("OnTabEnter", self.tabs[frame.id].value, frame)
+end
+
+local function Tab_OnLeave(frame)
+	local self = frame.obj
+	self:Fire("OnTabLeave", self.tabs[frame.id].value, frame)
+end
+
+local function Tab_OnShow(frame)
+	_G[frame:GetName().."HighlightTexture"]:SetWidth(frame:GetTextWidth() + 30)
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetTitle()
+	end,
+
+	["OnRelease"] = function(self)
+		self.status = nil
+		for k in pairs(self.localstatus) do
+			self.localstatus[k] = nil
+		end
+		self.tablist = nil
+		for _, tab in pairs(self.tabs) do
+			tab:Hide()
+		end
+	end,
+
+	["CreateTab"] = function(self, id)
+		local tabname = ("AceGUITabGroup%dTab%d"):format(self.num, id)
+		local tab = CreateFrame("Button", tabname, self.border)
+		tab:SetSize(115, 24)
+		tab.deselectedTextY = -3
+		tab.selectedTextY = -2
+
+		tab.LeftDisabled = tab:CreateTexture(tabname .. "LeftDisabled", "BORDER")
+		tab.LeftDisabled:SetTexture("Interface\\OptionsFrame\\UI-OptionsFrame-ActiveTab")
+		tab.LeftDisabled:SetSize(20, 24)
+		tab.LeftDisabled:SetPoint("BOTTOMLEFT", 0, -3)
+		tab.LeftDisabled:SetTexCoord(0, 0.15625, 0, 1.0)
+
+		tab.MiddleDisabled = tab:CreateTexture(tabname .. "MiddleDisabled", "BORDER")
+		tab.MiddleDisabled:SetTexture("Interface\\OptionsFrame\\UI-OptionsFrame-ActiveTab")
+		tab.MiddleDisabled:SetSize(88, 24)
+		tab.MiddleDisabled:SetPoint("LEFT", tab.LeftDisabled, "RIGHT")
+		tab.MiddleDisabled:SetTexCoord(0.15625, 0.84375, 0, 1.0)
+
+		tab.RightDisabled = tab:CreateTexture(tabname .. "RightDisabled", "BORDER")
+		tab.RightDisabled:SetTexture("Interface\\OptionsFrame\\UI-OptionsFrame-ActiveTab")
+		tab.RightDisabled:SetSize(20, 24)
+		tab.RightDisabled:SetPoint("LEFT", tab.MiddleDisabled, "RIGHT")
+		tab.RightDisabled:SetTexCoord(0.84375, 1.0, 0, 1.0)
+
+		tab.Left = tab:CreateTexture(tabname .. "Left", "BORDER")
+		tab.Left:SetTexture("Interface\\OptionsFrame\\UI-OptionsFrame-InActiveTab")
+		tab.Left:SetSize(20, 24)
+		tab.Left:SetPoint("TOPLEFT")
+		tab.Left:SetTexCoord(0, 0.15625, 0, 1.0)
+
+		tab.Middle = tab:CreateTexture(tabname .. "Middle", "BORDER")
+		tab.Middle:SetTexture("Interface\\OptionsFrame\\UI-OptionsFrame-InActiveTab")
+		tab.Middle:SetSize(88, 24)
+		tab.Middle:SetPoint("LEFT", tab.Left, "RIGHT")
+		tab.Middle:SetTexCoord(0.15625, 0.84375, 0, 1.0)
+
+		tab.Right = tab:CreateTexture(tabname .. "Right", "BORDER")
+		tab.Right:SetTexture("Interface\\OptionsFrame\\UI-OptionsFrame-InActiveTab")
+		tab.Right:SetSize(20, 24)
+		tab.Right:SetPoint("LEFT", tab.Middle, "RIGHT")
+		tab.Right:SetTexCoord(0.84375, 1.0, 0, 1.0)
+
+		tab.Text = tab:CreateFontString(tabname .. "Text")
+		tab:SetFontString(tab.Text)
+
+		tab:SetNormalFontObject(GameFontNormalSmall)
+		tab:SetHighlightFontObject(GameFontHighlightSmall)
+		tab:SetDisabledFontObject(GameFontHighlightSmall)
+		tab:SetHighlightTexture("Interface\\PaperDollInfoFrame\\UI-Character-Tab-Highlight", "ADD")
+		tab.HighlightTexture = tab:GetHighlightTexture()
+		tab.HighlightTexture:ClearAllPoints()
+		tab.HighlightTexture:SetPoint("LEFT", tab, "LEFT", 10, -4)
+		tab.HighlightTexture:SetPoint("RIGHT", tab, "RIGHT", -10, -4)
+		_G[tabname .. "HighlightTexture"] = tab.HighlightTexture
+
+		tab.obj = self
+		tab.id = id
+
+		tab.text = tab.Text -- compat
+		tab.text:ClearAllPoints()
+		tab.text:SetPoint("LEFT", 14, -3)
+		tab.text:SetPoint("RIGHT", -12, -3)
+
+		tab:SetScript("OnClick", Tab_OnClick)
+		tab:SetScript("OnEnter", Tab_OnEnter)
+		tab:SetScript("OnLeave", Tab_OnLeave)
+		tab:SetScript("OnShow", Tab_OnShow)
+
+		tab._SetText = tab.SetText
+		tab.SetText = Tab_SetText
+		tab.SetSelected = Tab_SetSelected
+		tab.SetDisabled = Tab_SetDisabled
+
+		return tab
+	end,
+
+	["SetTitle"] = function(self, text)
+		self.titletext:SetText(text or "")
+		if text and text ~= "" then
+			self.alignoffset = 25
+		else
+			self.alignoffset = 18
+		end
+		self:BuildTabs()
+	end,
+
+	["SetStatusTable"] = function(self, status)
+		assert(type(status) == "table")
+		self.status = status
+	end,
+
+	["SelectTab"] = function(self, value)
+		local status = self.status or self.localstatus
+		local found
+		for i, v in ipairs(self.tabs) do
+			if v.value == value then
+				v:SetSelected(true)
+				found = true
+			else
+				v:SetSelected(false)
+			end
+		end
+		status.selected = value
+		if found then
+			self:Fire("OnGroupSelected",value)
+		end
+	end,
+
+	["SetTabs"] = function(self, tabs)
+		self.tablist = tabs
+		self:BuildTabs()
+	end,
+
+
+	["BuildTabs"] = function(self)
+		local hastitle = (self.titletext:GetText() and self.titletext:GetText() ~= "")
+		local tablist = self.tablist
+		local tabs = self.tabs
+
+		if not tablist then return end
+
+		local width = self.frame.width or self.frame:GetWidth() or 0
+
+		wipe(widths)
+		wipe(rowwidths)
+		wipe(rowends)
+
+		--Place Text into tabs and get thier initial width
+		for i, v in ipairs(tablist) do
+			local tab = tabs[i]
+			if not tab then
+				tab = self:CreateTab(i)
+				tabs[i] = tab
+			end
+
+			tab:Show()
+			tab:SetText(v.text)
+			tab:SetDisabled(v.disabled)
+			tab.value = v.value
+
+			widths[i] = tab:GetWidth() - 6 --tabs are anchored 10 pixels from the right side of the previous one to reduce spacing, but add a fixed 4px padding for the text
+		end
+
+		for i = (#tablist)+1, #tabs, 1 do
+			tabs[i]:Hide()
+		end
+
+		--First pass, find the minimum number of rows needed to hold all tabs and the initial tab layout
+		local numtabs = #tablist
+		local numrows = 1
+		local usedwidth = 0
+
+		for i = 1, #tablist do
+			--If this is not the first tab of a row and there isn't room for it
+			if usedwidth ~= 0 and (width - usedwidth - widths[i]) < 0 then
+				rowwidths[numrows] = usedwidth + 10 --first tab in each row takes up an extra 10px
+				rowends[numrows] = i - 1
+				numrows = numrows + 1
+				usedwidth = 0
+			end
+			usedwidth = usedwidth + widths[i]
+		end
+		rowwidths[numrows] = usedwidth + 10 --first tab in each row takes up an extra 10px
+		rowends[numrows] = #tablist
+
+		--Fix for single tabs being left on the last row, move a tab from the row above if applicable
+		if numrows > 1 then
+			--if the last row has only one tab
+			if rowends[numrows-1] == numtabs-1 then
+				--if there are more than 2 tabs in the 2nd last row
+				if (numrows == 2 and rowends[numrows-1] > 2) or (rowends[numrows] - rowends[numrows-1] > 2) then
+					--move 1 tab from the second last row to the last, if there is enough space
+					if (rowwidths[numrows] + widths[numtabs-1]) <= width then
+						rowends[numrows-1] = rowends[numrows-1] - 1
+						rowwidths[numrows] = rowwidths[numrows] + widths[numtabs-1]
+						rowwidths[numrows-1] = rowwidths[numrows-1] - widths[numtabs-1]
+					end
+				end
+			end
+		end
+
+		--anchor the rows as defined and resize tabs to fill thier row
+		local starttab = 1
+		for row, endtab in ipairs(rowends) do
+			local first = true
+			for tabno = starttab, endtab do
+				local tab = tabs[tabno]
+				tab:ClearAllPoints()
+				if first then
+					tab:SetPoint("TOPLEFT", self.frame, "TOPLEFT", 0, -(hastitle and 14 or 7)-(row-1)*20 )
+					first = false
+				else
+					tab:SetPoint("LEFT", tabs[tabno-1], "RIGHT", -10, 0)
+				end
+			end
+
+			-- equal padding for each tab to fill the available width,
+			-- if the used space is above 75% already
+			-- the 18 pixel is the typical width of a scrollbar, so we can have a tab group inside a scrolling frame,
+			-- and not have the tabs jump around funny when switching between tabs that need scrolling and those that don't
+			local padding = 0
+			if not (numrows == 1 and rowwidths[1] < width*0.75 - 18) then
+				padding = (width - rowwidths[row]) / (endtab - starttab+1)
+			end
+
+			for i = starttab, endtab do
+				PanelTemplates_TabResize(tabs[i], padding + 4, nil, nil, width, tabs[i]:GetFontString():GetStringWidth())
+			end
+			starttab = endtab + 1
+		end
+
+		self.borderoffset = (hastitle and 17 or 10)+((numrows)*20)
+		self.border:SetPoint("TOPLEFT", 1, -self.borderoffset)
+	end,
+
+	["OnWidthSet"] = function(self, width)
+		local content = self.content
+		local contentwidth = width - 60
+		if contentwidth < 0 then
+			contentwidth = 0
+		end
+		content:SetWidth(contentwidth)
+		content.width = contentwidth
+		self:BuildTabs(self)
+		self.frame:SetScript("OnUpdate", BuildTabsOnUpdate)
+	end,
+
+	["OnHeightSet"] = function(self, height)
+		local content = self.content
+		local contentheight = height - (self.borderoffset + 23)
+		if contentheight < 0 then
+			contentheight = 0
+		end
+		content:SetHeight(contentheight)
+		content.height = contentheight
+	end,
+
+	["LayoutFinished"] = function(self, width, height)
+		if self.noAutoHeight then return end
+		self:SetHeight((height or 0) + (self.borderoffset + 23))
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local PaneBackdrop  = {
+	bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
+	edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
+	tile = true, tileSize = 16, edgeSize = 16,
+	insets = { left = 3, right = 3, top = 5, bottom = 3 }
+}
+
+local function Constructor()
+	local num = AceGUI:GetNextWidgetNum(Type)
+	local frame = CreateFrame("Frame",nil,UIParent)
+	frame:SetHeight(100)
+	frame:SetWidth(100)
+	frame:SetFrameStrata("FULLSCREEN_DIALOG")
+
+	local titletext = frame:CreateFontString(nil,"OVERLAY","GameFontNormal")
+	titletext:SetPoint("TOPLEFT", 14, 0)
+	titletext:SetPoint("TOPRIGHT", -14, 0)
+	titletext:SetJustifyH("LEFT")
+	titletext:SetHeight(18)
+	titletext:SetText("")
+
+	local border = CreateFrame("Frame", nil, frame, "BackdropTemplate")
+	border:SetPoint("TOPLEFT", 1, -27)
+	border:SetPoint("BOTTOMRIGHT", -1, 3)
+	border:SetBackdrop(PaneBackdrop)
+	border:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
+	border:SetBackdropBorderColor(0.4, 0.4, 0.4)
+
+	local content = CreateFrame("Frame", nil, border)
+	content:SetPoint("TOPLEFT", 10, -7)
+	content:SetPoint("BOTTOMRIGHT", -10, 7)
+
+	local widget = {
+		num          = num,
+		frame        = frame,
+		localstatus  = {},
+		alignoffset  = 18,
+		titletext    = titletext,
+		border       = border,
+		borderoffset = 27,
+		tabs         = {},
+		content      = content,
+		type         = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsContainer(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIContainer-TreeGroup.lua

@@ -0,0 +1,719 @@
+--[[-----------------------------------------------------------------------------
+TreeGroup Container
+Container that uses a tree control to switch between groups.
+-------------------------------------------------------------------------------]]
+local Type, Version = "TreeGroup", 49
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local next, pairs, ipairs, assert, type = next, pairs, ipairs, assert, type
+local math_min, math_max, floor = math.min, math.max, math.floor
+local select, tremove, unpack, tconcat = select, table.remove, unpack, table.concat
+
+-- WoW APIs
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+-- Recycling functions
+local new, del
+do
+	local pool = setmetatable({},{__mode='k'})
+	function new()
+		local t = next(pool)
+		if t then
+			pool[t] = nil
+			return t
+		else
+			return {}
+		end
+	end
+	function del(t)
+		for k in pairs(t) do
+			t[k] = nil
+		end
+		pool[t] = true
+	end
+end
+
+local DEFAULT_TREE_WIDTH = 175
+local DEFAULT_TREE_SIZABLE = true
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+local function GetButtonUniqueValue(line)
+	local parent = line.parent
+	if parent and parent.value then
+		return GetButtonUniqueValue(parent).."\001"..line.value
+	else
+		return line.value
+	end
+end
+
+local function UpdateButton(button, treeline, selected, canExpand, isExpanded)
+	local self = button.obj
+	local toggle = button.toggle
+	local text = treeline.text or ""
+	local icon = treeline.icon
+	local iconCoords = treeline.iconCoords
+	local level = treeline.level
+	local value = treeline.value
+	local uniquevalue = treeline.uniquevalue
+	local disabled = treeline.disabled
+
+	button.treeline = treeline
+	button.value = value
+	button.uniquevalue = uniquevalue
+	if selected then
+		button:LockHighlight()
+		button.selected = true
+	else
+		button:UnlockHighlight()
+		button.selected = false
+	end
+	button.level = level
+	if ( level == 1 ) then
+		button:SetNormalFontObject("GameFontNormal")
+		button:SetHighlightFontObject("GameFontHighlight")
+		button.text:SetPoint("LEFT", (icon and 16 or 0) + 8, 2)
+	else
+		button:SetNormalFontObject("GameFontHighlightSmall")
+		button:SetHighlightFontObject("GameFontHighlightSmall")
+		button.text:SetPoint("LEFT", (icon and 16 or 0) + 8 * level, 2)
+	end
+
+	if disabled then
+		button:EnableMouse(false)
+		button.text:SetText("|cff808080"..text..FONT_COLOR_CODE_CLOSE)
+	else
+		button.text:SetText(text)
+		button:EnableMouse(true)
+	end
+
+	if icon then
+		button.icon:SetTexture(icon)
+		button.icon:SetPoint("LEFT", 8 * level, (level == 1) and 0 or 1)
+	else
+		button.icon:SetTexture(nil)
+	end
+
+	if iconCoords then
+		button.icon:SetTexCoord(unpack(iconCoords))
+	else
+		button.icon:SetTexCoord(0, 1, 0, 1)
+	end
+
+	if canExpand then
+		if not isExpanded then
+			toggle:SetNormalTexture(130838) -- Interface\\Buttons\\UI-PlusButton-UP
+			toggle:SetPushedTexture(130836) -- Interface\\Buttons\\UI-PlusButton-DOWN
+		else
+			toggle:SetNormalTexture(130821) -- Interface\\Buttons\\UI-MinusButton-UP
+			toggle:SetPushedTexture(130820) -- Interface\\Buttons\\UI-MinusButton-DOWN
+		end
+		toggle:Show()
+	else
+		toggle:Hide()
+	end
+end
+
+local function ShouldDisplayLevel(tree)
+	local result = false
+	for k, v in ipairs(tree) do
+		if v.children == nil and v.visible ~= false then
+			result = true
+		elseif v.children then
+			result = result or ShouldDisplayLevel(v.children)
+		end
+		if result then return result end
+	end
+	return false
+end
+
+local function addLine(self, v, tree, level, parent)
+	local line = new()
+	line.value = v.value
+	line.text = v.text
+	line.icon = v.icon
+	line.iconCoords = v.iconCoords
+	line.disabled = v.disabled
+	line.tree = tree
+	line.level = level
+	line.parent = parent
+	line.visible = v.visible
+	line.uniquevalue = GetButtonUniqueValue(line)
+	if v.children then
+		line.hasChildren = true
+	else
+		line.hasChildren = nil
+	end
+	self.lines[#self.lines+1] = line
+	return line
+end
+
+--fire an update after one frame to catch the treeframes height
+local function FirstFrameUpdate(frame)
+	local self = frame.obj
+	frame:SetScript("OnUpdate", nil)
+	self:RefreshTree(nil, true)
+end
+
+local function BuildUniqueValue(...)
+	local n = select('#', ...)
+	if n == 1 then
+		return ...
+	else
+		return (...).."\001"..BuildUniqueValue(select(2,...))
+	end
+end
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Expand_OnClick(frame)
+	local button = frame.button
+	local self = button.obj
+	local status = (self.status or self.localstatus).groups
+	status[button.uniquevalue] = not status[button.uniquevalue]
+	self:RefreshTree()
+end
+
+local function Button_OnClick(frame)
+	local self = frame.obj
+	self:Fire("OnClick", frame.uniquevalue, frame.selected)
+	if not frame.selected then
+		self:SetSelected(frame.uniquevalue)
+		frame.selected = true
+		frame:LockHighlight()
+		self:RefreshTree()
+	end
+	AceGUI:ClearFocus()
+end
+
+local function Button_OnDoubleClick(button)
+	local self = button.obj
+	local status = (self.status or self.localstatus).groups
+	status[button.uniquevalue] = not status[button.uniquevalue]
+	self:RefreshTree()
+end
+
+local function Button_OnEnter(frame)
+	local self = frame.obj
+	self:Fire("OnButtonEnter", frame.uniquevalue, frame)
+
+	if self.enabletooltips then
+		local tooltip = AceGUI.tooltip
+		tooltip:SetOwner(frame, "ANCHOR_NONE")
+		tooltip:ClearAllPoints()
+		tooltip:SetPoint("LEFT",frame,"RIGHT")
+		tooltip:SetText(frame.text:GetText() or "", 1, .82, 0, 1, true)
+
+		tooltip:Show()
+	end
+end
+
+local function Button_OnLeave(frame)
+	local self = frame.obj
+	self:Fire("OnButtonLeave", frame.uniquevalue, frame)
+
+	if self.enabletooltips then
+		AceGUI.tooltip:Hide()
+	end
+end
+
+local function OnScrollValueChanged(frame, value)
+	if frame.obj.noupdate then return end
+	local self = frame.obj
+	local status = self.status or self.localstatus
+	status.scrollvalue = floor(value + 0.5)
+	self:RefreshTree()
+	AceGUI:ClearFocus()
+end
+
+local function Tree_OnSizeChanged(frame)
+	frame.obj:RefreshTree()
+end
+
+local function Tree_OnMouseWheel(frame, delta)
+	local self = frame.obj
+	if self.showscroll then
+		local scrollbar = self.scrollbar
+		local min, max = scrollbar:GetMinMaxValues()
+		local value = scrollbar:GetValue()
+		local newvalue = math_min(max,math_max(min,value - delta))
+		if value ~= newvalue then
+			scrollbar:SetValue(newvalue)
+		end
+	end
+end
+
+local function Dragger_OnLeave(frame)
+	frame:SetBackdropColor(1, 1, 1, 0)
+end
+
+local function Dragger_OnEnter(frame)
+	frame:SetBackdropColor(1, 1, 1, 0.8)
+end
+
+local function Dragger_OnMouseDown(frame)
+	local treeframe = frame:GetParent()
+	treeframe:StartSizing("RIGHT")
+end
+
+local function Dragger_OnMouseUp(frame)
+	local treeframe = frame:GetParent()
+	local self = treeframe.obj
+	local treeframeParent = treeframe:GetParent()
+	treeframe:StopMovingOrSizing()
+	--treeframe:SetScript("OnUpdate", nil)
+	treeframe:SetUserPlaced(false)
+	--Without this :GetHeight will get stuck on the current height, causing the tree contents to not resize
+	treeframe:SetHeight(0)
+	treeframe:ClearAllPoints()
+	treeframe:SetPoint("TOPLEFT", treeframeParent, "TOPLEFT",0,0)
+	treeframe:SetPoint("BOTTOMLEFT", treeframeParent, "BOTTOMLEFT",0,0)
+
+	local status = self.status or self.localstatus
+	status.treewidth = treeframe:GetWidth()
+
+	treeframe.obj:Fire("OnTreeResize",treeframe:GetWidth())
+	-- recalculate the content width
+	treeframe.obj:OnWidthSet(status.fullwidth)
+	-- update the layout of the content
+	treeframe.obj:DoLayout()
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetTreeWidth(DEFAULT_TREE_WIDTH, DEFAULT_TREE_SIZABLE)
+		self:EnableButtonTooltips(true)
+		self.frame:SetScript("OnUpdate", FirstFrameUpdate)
+	end,
+
+	["OnRelease"] = function(self)
+		self.status = nil
+		self.tree = nil
+		self.frame:SetScript("OnUpdate", nil)
+		for k, v in pairs(self.localstatus) do
+			if k == "groups" then
+				for k2 in pairs(v) do
+					v[k2] = nil
+				end
+			else
+				self.localstatus[k] = nil
+			end
+		end
+		self.localstatus.scrollvalue = 0
+		self.localstatus.treewidth = DEFAULT_TREE_WIDTH
+		self.localstatus.treesizable = DEFAULT_TREE_SIZABLE
+	end,
+
+	["EnableButtonTooltips"] = function(self, enable)
+		self.enabletooltips = enable
+	end,
+
+	["CreateButton"] = function(self)
+		local num = AceGUI:GetNextWidgetNum("TreeGroupButton")
+		local button = CreateFrame("Button", ("AceGUI30TreeButton%d"):format(num), self.treeframe, "OptionsListButtonTemplate")
+		button.obj = self
+
+		local icon = button:CreateTexture(nil, "OVERLAY")
+		icon:SetWidth(14)
+		icon:SetHeight(14)
+		button.icon = icon
+
+		button:SetScript("OnClick",Button_OnClick)
+		button:SetScript("OnDoubleClick", Button_OnDoubleClick)
+		button:SetScript("OnEnter",Button_OnEnter)
+		button:SetScript("OnLeave",Button_OnLeave)
+
+		button.toggle.button = button
+		button.toggle:SetScript("OnClick",Expand_OnClick)
+
+		button.text:SetHeight(14) -- Prevents text wrapping
+
+		return button
+	end,
+
+	["SetStatusTable"] = function(self, status)
+		assert(type(status) == "table")
+		self.status = status
+		if not status.groups then
+			status.groups = {}
+		end
+		if not status.scrollvalue then
+			status.scrollvalue = 0
+		end
+		if not status.treewidth then
+			status.treewidth = DEFAULT_TREE_WIDTH
+		end
+		if status.treesizable == nil then
+			status.treesizable = DEFAULT_TREE_SIZABLE
+		end
+		self:SetTreeWidth(status.treewidth,status.treesizable)
+		self:RefreshTree()
+	end,
+
+	--sets the tree to be displayed
+	["SetTree"] = function(self, tree, filter)
+		self.filter = filter
+		if tree then
+			assert(type(tree) == "table")
+		end
+		self.tree = tree
+		self:RefreshTree()
+	end,
+
+	["BuildLevel"] = function(self, tree, level, parent)
+		local groups = (self.status or self.localstatus).groups
+
+		for i, v in ipairs(tree) do
+			if v.children then
+				if not self.filter or ShouldDisplayLevel(v.children) then
+					local line = addLine(self, v, tree, level, parent)
+					if groups[line.uniquevalue] then
+						self:BuildLevel(v.children, level+1, line)
+					end
+				end
+			elseif v.visible ~= false or not self.filter then
+				addLine(self, v, tree, level, parent)
+			end
+		end
+	end,
+
+	["RefreshTree"] = function(self,scrollToSelection,fromOnUpdate)
+		local buttons = self.buttons
+		local lines = self.lines
+		while lines[1] do
+			local t = tremove(lines)
+			for k in pairs(t) do
+				t[k] = nil
+			end
+			del(t)
+		end
+
+		if not self.tree then return end
+		--Build the list of visible entries from the tree and status tables
+		local status = self.status or self.localstatus
+		local groupstatus = status.groups
+		local tree = self.tree
+
+		local treeframe = self.treeframe
+
+		status.scrollToSelection = status.scrollToSelection or scrollToSelection	-- needs to be cached in case the control hasn't been drawn yet (code bails out below)
+
+		self:BuildLevel(tree, 1)
+
+		local numlines = #lines
+
+		local maxlines = (floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18))
+		if maxlines <= 0 then return end
+
+		if self.frame:GetParent() == UIParent and not fromOnUpdate then
+			self.frame:SetScript("OnUpdate", FirstFrameUpdate)
+			return
+		end
+
+		local first, last
+
+		scrollToSelection = status.scrollToSelection
+		status.scrollToSelection = nil
+
+		if numlines <= maxlines then
+			--the whole tree fits in the frame
+			status.scrollvalue = 0
+			self:ShowScroll(false)
+			first, last = 1, numlines
+		else
+			self:ShowScroll(true)
+			--scrolling will be needed
+			self.noupdate = true
+			self.scrollbar:SetMinMaxValues(0, numlines - maxlines)
+			--check if we are scrolled down too far
+			if numlines - status.scrollvalue < maxlines then
+				status.scrollvalue = numlines - maxlines
+			end
+			self.noupdate = nil
+			first, last = status.scrollvalue+1, status.scrollvalue + maxlines
+			--show selection?
+			if scrollToSelection and status.selected then
+				local show
+				for i,line in ipairs(lines) do	-- find the line number
+					if line.uniquevalue==status.selected then
+						show=i
+					end
+				end
+				if not show then
+					-- selection was deleted or something?
+				elseif show>=first and show<=last then
+					-- all good
+				else
+					-- scrolling needed!
+					if show<first then
+						status.scrollvalue = show-1
+					else
+						status.scrollvalue = show-maxlines
+					end
+					first, last = status.scrollvalue+1, status.scrollvalue + maxlines
+				end
+			end
+			if self.scrollbar:GetValue() ~= status.scrollvalue then
+				self.scrollbar:SetValue(status.scrollvalue)
+			end
+		end
+
+		local buttonnum = 1
+		for i = first, last do
+			local line = lines[i]
+			local button = buttons[buttonnum]
+			if not button then
+				button = self:CreateButton()
+
+				buttons[buttonnum] = button
+				button:SetParent(treeframe)
+				button:SetFrameLevel(treeframe:GetFrameLevel()+1)
+				button:ClearAllPoints()
+				if buttonnum == 1 then
+					if self.showscroll then
+						button:SetPoint("TOPRIGHT", -22, -10)
+						button:SetPoint("TOPLEFT", 0, -10)
+					else
+						button:SetPoint("TOPRIGHT", 0, -10)
+						button:SetPoint("TOPLEFT", 0, -10)
+					end
+				else
+					button:SetPoint("TOPRIGHT", buttons[buttonnum-1], "BOTTOMRIGHT",0,0)
+					button:SetPoint("TOPLEFT", buttons[buttonnum-1], "BOTTOMLEFT",0,0)
+				end
+			end
+
+			UpdateButton(button, line, status.selected == line.uniquevalue, line.hasChildren, groupstatus[line.uniquevalue] )
+			button:Show()
+			buttonnum = buttonnum + 1
+		end
+
+		-- We hide the remaining buttons after updating others to avoid a blizzard bug that keeps them interactable even if hidden when hidden before updating the buttons.
+		for i = buttonnum, #buttons do
+			buttons[i]:Hide()
+		end
+	end,
+
+	["SetSelected"] = function(self, value)
+		local status = self.status or self.localstatus
+		if status.selected ~= value then
+			status.selected = value
+			self:Fire("OnGroupSelected", value)
+		end
+	end,
+
+	["Select"] = function(self, uniquevalue, ...)
+		self.filter = false
+		local status = self.status or self.localstatus
+		local groups = status.groups
+		local path = {...}
+		for i = 1, #path do
+			groups[tconcat(path, "\001", 1, i)] = true
+		end
+		status.selected = uniquevalue
+		self:RefreshTree(true)
+		self:Fire("OnGroupSelected", uniquevalue)
+	end,
+
+	["SelectByPath"] = function(self, ...)
+		self:Select(BuildUniqueValue(...), ...)
+	end,
+
+	["SelectByValue"] = function(self, uniquevalue)
+		self:Select(uniquevalue, ("\001"):split(uniquevalue))
+	end,
+
+	["ShowScroll"] = function(self, show)
+		self.showscroll = show
+		if show then
+			self.scrollbar:Show()
+			if self.buttons[1] then
+				self.buttons[1]:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",-22,-10)
+			end
+		else
+			self.scrollbar:Hide()
+			if self.buttons[1] then
+				self.buttons[1]:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",0,-10)
+			end
+		end
+	end,
+
+	["OnWidthSet"] = function(self, width)
+		local content = self.content
+		local treeframe = self.treeframe
+		local status = self.status or self.localstatus
+		status.fullwidth = width
+
+		local contentwidth = width - status.treewidth - 20
+		if contentwidth < 0 then
+			contentwidth = 0
+		end
+		content:SetWidth(contentwidth)
+		content.width = contentwidth
+
+		local maxtreewidth = math_min(400, width - 50)
+
+		if maxtreewidth > 100 and status.treewidth > maxtreewidth then
+			self:SetTreeWidth(maxtreewidth, status.treesizable)
+		end
+		if treeframe.SetResizeBounds then
+			treeframe:SetResizeBounds(100, 1, maxtreewidth, 1600)
+		else
+			treeframe:SetMaxResize(maxtreewidth, 1600)
+		end
+	end,
+
+	["OnHeightSet"] = function(self, height)
+		local content = self.content
+		local contentheight = height - 20
+		if contentheight < 0 then
+			contentheight = 0
+		end
+		content:SetHeight(contentheight)
+		content.height = contentheight
+	end,
+
+	["SetTreeWidth"] = function(self, treewidth, resizable)
+		if not resizable then
+			if type(treewidth) == 'number' then
+				resizable = false
+			elseif type(treewidth) == 'boolean' then
+				resizable = treewidth
+				treewidth = DEFAULT_TREE_WIDTH
+			else
+				resizable = false
+				treewidth = DEFAULT_TREE_WIDTH
+			end
+		end
+		self.treeframe:SetWidth(treewidth)
+		self.dragger:EnableMouse(resizable)
+
+		local status = self.status or self.localstatus
+		status.treewidth = treewidth
+		status.treesizable = resizable
+
+		-- recalculate the content width
+		if status.fullwidth then
+			self:OnWidthSet(status.fullwidth)
+		end
+	end,
+
+	["GetTreeWidth"] = function(self)
+		local status = self.status or self.localstatus
+		return status.treewidth or DEFAULT_TREE_WIDTH
+	end,
+
+	["LayoutFinished"] = function(self, width, height)
+		if self.noAutoHeight then return end
+		self:SetHeight((height or 0) + 20)
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local PaneBackdrop  = {
+	bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
+	edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
+	tile = true, tileSize = 16, edgeSize = 16,
+	insets = { left = 3, right = 3, top = 5, bottom = 3 }
+}
+
+local DraggerBackdrop  = {
+	bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
+	edgeFile = nil,
+	tile = true, tileSize = 16, edgeSize = 1,
+	insets = { left = 3, right = 3, top = 7, bottom = 7 }
+}
+
+local function Constructor()
+	local num = AceGUI:GetNextWidgetNum(Type)
+	local frame = CreateFrame("Frame", nil, UIParent)
+
+	local treeframe = CreateFrame("Frame", nil, frame, "BackdropTemplate")
+	treeframe:SetPoint("TOPLEFT")
+	treeframe:SetPoint("BOTTOMLEFT")
+	treeframe:SetWidth(DEFAULT_TREE_WIDTH)
+	treeframe:EnableMouseWheel(true)
+	treeframe:SetBackdrop(PaneBackdrop)
+	treeframe:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
+	treeframe:SetBackdropBorderColor(0.4, 0.4, 0.4)
+	treeframe:SetResizable(true)
+	if treeframe.SetResizeBounds then -- WoW 10.0
+		treeframe:SetResizeBounds(100, 1, 400, 1600)
+	else
+		treeframe:SetMinResize(100, 1)
+		treeframe:SetMaxResize(400, 1600)
+	end
+	treeframe:SetScript("OnUpdate", FirstFrameUpdate)
+	treeframe:SetScript("OnSizeChanged", Tree_OnSizeChanged)
+	treeframe:SetScript("OnMouseWheel", Tree_OnMouseWheel)
+
+	local dragger = CreateFrame("Frame", nil, treeframe, "BackdropTemplate")
+	dragger:SetWidth(8)
+	dragger:SetPoint("TOP", treeframe, "TOPRIGHT")
+	dragger:SetPoint("BOTTOM", treeframe, "BOTTOMRIGHT")
+	dragger:SetBackdrop(DraggerBackdrop)
+	dragger:SetBackdropColor(1, 1, 1, 0)
+	dragger:SetScript("OnEnter", Dragger_OnEnter)
+	dragger:SetScript("OnLeave", Dragger_OnLeave)
+	dragger:SetScript("OnMouseDown", Dragger_OnMouseDown)
+	dragger:SetScript("OnMouseUp", Dragger_OnMouseUp)
+
+	local scrollbar = CreateFrame("Slider", ("AceConfigDialogTreeGroup%dScrollBar"):format(num), treeframe, "UIPanelScrollBarTemplate")
+	scrollbar:SetScript("OnValueChanged", nil)
+	scrollbar:SetPoint("TOPRIGHT", -10, -26)
+	scrollbar:SetPoint("BOTTOMRIGHT", -10, 26)
+	scrollbar:SetMinMaxValues(0,0)
+	scrollbar:SetValueStep(1)
+	scrollbar:SetValue(0)
+	scrollbar:SetWidth(16)
+	scrollbar:SetScript("OnValueChanged", OnScrollValueChanged)
+
+	local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND")
+	scrollbg:SetAllPoints(scrollbar)
+	scrollbg:SetColorTexture(0,0,0,0.4)
+
+	local border = CreateFrame("Frame", nil, frame, "BackdropTemplate")
+	border:SetPoint("TOPLEFT", treeframe, "TOPRIGHT")
+	border:SetPoint("BOTTOMRIGHT")
+	border:SetBackdrop(PaneBackdrop)
+	border:SetBackdropColor(0.1, 0.1, 0.1, 0.5)
+	border:SetBackdropBorderColor(0.4, 0.4, 0.4)
+
+	--Container Support
+	local content = CreateFrame("Frame", nil, border)
+	content:SetPoint("TOPLEFT", 10, -10)
+	content:SetPoint("BOTTOMRIGHT", -10, 10)
+
+	local widget = {
+		frame        = frame,
+		lines        = {},
+		levels       = {},
+		buttons      = {},
+		hasChildren  = {},
+		localstatus  = { groups = {}, scrollvalue = 0 },
+		filter       = false,
+		treeframe    = treeframe,
+		dragger      = dragger,
+		scrollbar    = scrollbar,
+		border       = border,
+		content      = content,
+		type         = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+	treeframe.obj, dragger.obj, scrollbar.obj = widget, widget, widget
+
+	return AceGUI:RegisterAsContainer(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIContainer-Window.lua

@@ -0,0 +1,336 @@
+local AceGUI = LibStub("AceGUI-3.0")
+
+-- Lua APIs
+local pairs, assert, type = pairs, assert, type
+
+-- WoW APIs
+local PlaySound = PlaySound
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+----------------
+-- Main Frame --
+----------------
+--[[
+	Events :
+		OnClose
+
+]]
+do
+	local Type = "Window"
+	local Version = 8
+
+	local function frameOnShow(this)
+		this.obj:Fire("OnShow")
+	end
+
+	local function frameOnClose(this)
+		this.obj:Fire("OnClose")
+	end
+
+	local function closeOnClick(this)
+		PlaySound(799) -- SOUNDKIT.GS_TITLE_OPTION_EXIT
+		this.obj:Hide()
+	end
+
+	local function frameOnMouseDown(this)
+		AceGUI:ClearFocus()
+	end
+
+	local function titleOnMouseDown(this)
+		this:GetParent():StartMoving()
+		AceGUI:ClearFocus()
+	end
+
+	local function frameOnMouseUp(this)
+		local frame = this:GetParent()
+		frame:StopMovingOrSizing()
+		local self = frame.obj
+		local status = self.status or self.localstatus
+		status.width = frame:GetWidth()
+		status.height = frame:GetHeight()
+		status.top = frame:GetTop()
+		status.left = frame:GetLeft()
+	end
+
+	local function sizerseOnMouseDown(this)
+		this:GetParent():StartSizing("BOTTOMRIGHT")
+		AceGUI:ClearFocus()
+	end
+
+	local function sizersOnMouseDown(this)
+		this:GetParent():StartSizing("BOTTOM")
+		AceGUI:ClearFocus()
+	end
+
+	local function sizereOnMouseDown(this)
+		this:GetParent():StartSizing("RIGHT")
+		AceGUI:ClearFocus()
+	end
+
+	local function sizerOnMouseUp(this)
+		this:GetParent():StopMovingOrSizing()
+	end
+
+	local function SetTitle(self,title)
+		self.titletext:SetText(title)
+	end
+
+	local function SetStatusText(self,text)
+		-- self.statustext:SetText(text)
+	end
+
+	local function Hide(self)
+		self.frame:Hide()
+	end
+
+	local function Show(self)
+		self.frame:Show()
+	end
+
+	local function OnAcquire(self)
+		self.frame:SetParent(UIParent)
+		self.frame:SetFrameStrata("FULLSCREEN_DIALOG")
+		self:ApplyStatus()
+		self:EnableResize(true)
+		self:Show()
+	end
+
+	local function OnRelease(self)
+		self.status = nil
+		for k in pairs(self.localstatus) do
+			self.localstatus[k] = nil
+		end
+	end
+
+	-- called to set an external table to store status in
+	local function SetStatusTable(self, status)
+		assert(type(status) == "table")
+		self.status = status
+		self:ApplyStatus()
+	end
+
+	local function ApplyStatus(self)
+		local status = self.status or self.localstatus
+		local frame = self.frame
+		self:SetWidth(status.width or 700)
+		self:SetHeight(status.height or 500)
+		if status.top and status.left then
+			frame:SetPoint("TOP",UIParent,"BOTTOM",0,status.top)
+			frame:SetPoint("LEFT",UIParent,"LEFT",status.left,0)
+		else
+			frame:SetPoint("CENTER",UIParent,"CENTER")
+		end
+	end
+
+	local function OnWidthSet(self, width)
+		local content = self.content
+		local contentwidth = width - 34
+		if contentwidth < 0 then
+			contentwidth = 0
+		end
+		content:SetWidth(contentwidth)
+		content.width = contentwidth
+	end
+
+
+	local function OnHeightSet(self, height)
+		local content = self.content
+		local contentheight = height - 57
+		if contentheight < 0 then
+			contentheight = 0
+		end
+		content:SetHeight(contentheight)
+		content.height = contentheight
+	end
+
+	local function EnableResize(self, state)
+		local func = state and "Show" or "Hide"
+		self.sizer_se[func](self.sizer_se)
+		self.sizer_s[func](self.sizer_s)
+		self.sizer_e[func](self.sizer_e)
+	end
+
+	local function Constructor()
+		local frame = CreateFrame("Frame",nil,UIParent)
+		local self = {}
+		self.type = "Window"
+
+		self.Hide = Hide
+		self.Show = Show
+		self.SetTitle =  SetTitle
+		self.OnRelease = OnRelease
+		self.OnAcquire = OnAcquire
+		self.SetStatusText = SetStatusText
+		self.SetStatusTable = SetStatusTable
+		self.ApplyStatus = ApplyStatus
+		self.OnWidthSet = OnWidthSet
+		self.OnHeightSet = OnHeightSet
+		self.EnableResize = EnableResize
+
+		self.localstatus = {}
+
+		self.frame = frame
+		frame.obj = self
+		frame:SetWidth(700)
+		frame:SetHeight(500)
+		frame:SetPoint("CENTER",UIParent,"CENTER",0,0)
+		frame:EnableMouse()
+		frame:SetMovable(true)
+		frame:SetResizable(true)
+		frame:SetFrameStrata("FULLSCREEN_DIALOG")
+		frame:SetScript("OnMouseDown", frameOnMouseDown)
+
+		frame:SetScript("OnShow",frameOnShow)
+		frame:SetScript("OnHide",frameOnClose)
+		if frame.SetResizeBounds then -- WoW 10.0
+			frame:SetResizeBounds(240,240)
+		else
+			frame:SetMinResize(240,240)
+		end
+		frame:SetToplevel(true)
+
+		local titlebg = frame:CreateTexture(nil, "BACKGROUND")
+		titlebg:SetTexture(251966) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Title-Background
+		titlebg:SetPoint("TOPLEFT", 9, -6)
+		titlebg:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", -28, -24)
+
+		local dialogbg = frame:CreateTexture(nil, "BACKGROUND")
+		dialogbg:SetTexture(137056) -- Interface\\Tooltips\\UI-Tooltip-Background
+		dialogbg:SetPoint("TOPLEFT", 8, -24)
+		dialogbg:SetPoint("BOTTOMRIGHT", -6, 8)
+		dialogbg:SetVertexColor(0, 0, 0, .75)
+
+		local topleft = frame:CreateTexture(nil, "BORDER")
+		topleft:SetTexture(251963) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Border
+		topleft:SetWidth(64)
+		topleft:SetHeight(64)
+		topleft:SetPoint("TOPLEFT")
+		topleft:SetTexCoord(0.501953125, 0.625, 0, 1)
+
+		local topright = frame:CreateTexture(nil, "BORDER")
+		topright:SetTexture(251963) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Border
+		topright:SetWidth(64)
+		topright:SetHeight(64)
+		topright:SetPoint("TOPRIGHT")
+		topright:SetTexCoord(0.625, 0.75, 0, 1)
+
+		local top = frame:CreateTexture(nil, "BORDER")
+		top:SetTexture(251963) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Border
+		top:SetHeight(64)
+		top:SetPoint("TOPLEFT", topleft, "TOPRIGHT")
+		top:SetPoint("TOPRIGHT", topright, "TOPLEFT")
+		top:SetTexCoord(0.25, 0.369140625, 0, 1)
+
+		local bottomleft = frame:CreateTexture(nil, "BORDER")
+		bottomleft:SetTexture(251963) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Border
+		bottomleft:SetWidth(64)
+		bottomleft:SetHeight(64)
+		bottomleft:SetPoint("BOTTOMLEFT")
+		bottomleft:SetTexCoord(0.751953125, 0.875, 0, 1)
+
+		local bottomright = frame:CreateTexture(nil, "BORDER")
+		bottomright:SetTexture(251963) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Border
+		bottomright:SetWidth(64)
+		bottomright:SetHeight(64)
+		bottomright:SetPoint("BOTTOMRIGHT")
+		bottomright:SetTexCoord(0.875, 1, 0, 1)
+
+		local bottom = frame:CreateTexture(nil, "BORDER")
+		bottom:SetTexture(251963) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Border
+		bottom:SetHeight(64)
+		bottom:SetPoint("BOTTOMLEFT", bottomleft, "BOTTOMRIGHT")
+		bottom:SetPoint("BOTTOMRIGHT", bottomright, "BOTTOMLEFT")
+		bottom:SetTexCoord(0.376953125, 0.498046875, 0, 1)
+
+		local left = frame:CreateTexture(nil, "BORDER")
+		left:SetTexture(251963) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Border
+		left:SetWidth(64)
+		left:SetPoint("TOPLEFT", topleft, "BOTTOMLEFT")
+		left:SetPoint("BOTTOMLEFT", bottomleft, "TOPLEFT")
+		left:SetTexCoord(0.001953125, 0.125, 0, 1)
+
+		local right = frame:CreateTexture(nil, "BORDER")
+		right:SetTexture(251963) -- Interface\\PaperDollInfoFrame\\UI-GearManager-Border
+		right:SetWidth(64)
+		right:SetPoint("TOPRIGHT", topright, "BOTTOMRIGHT")
+		right:SetPoint("BOTTOMRIGHT", bottomright, "TOPRIGHT")
+		right:SetTexCoord(0.1171875, 0.2421875, 0, 1)
+
+		local close = CreateFrame("Button", nil, frame, "UIPanelCloseButton")
+		close:SetPoint("TOPRIGHT", 2, 1)
+		close:SetScript("OnClick", closeOnClick)
+		self.closebutton = close
+		close.obj = self
+
+		local titletext = frame:CreateFontString(nil, "ARTWORK")
+		titletext:SetFontObject(GameFontNormal)
+		titletext:SetPoint("TOPLEFT", 12, -8)
+		titletext:SetPoint("TOPRIGHT", -32, -8)
+		self.titletext = titletext
+
+		local title = CreateFrame("Button", nil, frame)
+		title:SetPoint("TOPLEFT", titlebg)
+		title:SetPoint("BOTTOMRIGHT", titlebg)
+		title:EnableMouse()
+		title:SetScript("OnMouseDown",titleOnMouseDown)
+		title:SetScript("OnMouseUp", frameOnMouseUp)
+		self.title = title
+
+		local sizer_se = CreateFrame("Frame",nil,frame)
+		sizer_se:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,0)
+		sizer_se:SetWidth(25)
+		sizer_se:SetHeight(25)
+		sizer_se:EnableMouse()
+		sizer_se:SetScript("OnMouseDown",sizerseOnMouseDown)
+		sizer_se:SetScript("OnMouseUp", sizerOnMouseUp)
+		self.sizer_se = sizer_se
+
+		local line1 = sizer_se:CreateTexture(nil, "BACKGROUND")
+		self.line1 = line1
+		line1:SetWidth(14)
+		line1:SetHeight(14)
+		line1:SetPoint("BOTTOMRIGHT", -8, 8)
+		line1:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
+		local x = 0.1 * 14/17
+		line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
+
+		local line2 = sizer_se:CreateTexture(nil, "BACKGROUND")
+		self.line2 = line2
+		line2:SetWidth(8)
+		line2:SetHeight(8)
+		line2:SetPoint("BOTTOMRIGHT", -8, 8)
+		line2:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
+		x = 0.1 * 8/17
+		line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
+
+		local sizer_s = CreateFrame("Frame",nil,frame)
+		sizer_s:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-25,0)
+		sizer_s:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",0,0)
+		sizer_s:SetHeight(25)
+		sizer_s:EnableMouse()
+		sizer_s:SetScript("OnMouseDown",sizersOnMouseDown)
+		sizer_s:SetScript("OnMouseUp", sizerOnMouseUp)
+		self.sizer_s = sizer_s
+
+		local sizer_e = CreateFrame("Frame",nil,frame)
+		sizer_e:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,25)
+		sizer_e:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0)
+		sizer_e:SetWidth(25)
+		sizer_e:EnableMouse()
+		sizer_e:SetScript("OnMouseDown",sizereOnMouseDown)
+		sizer_e:SetScript("OnMouseUp", sizerOnMouseUp)
+		self.sizer_e = sizer_e
+
+		--Container Support
+		local content = CreateFrame("Frame",nil,frame)
+		self.content = content
+		content.obj = self
+		content:SetPoint("TOPLEFT",frame,"TOPLEFT",12,-32)
+		content:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-12,13)
+
+		AceGUI:RegisterAsContainer(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(Type,Constructor,Version)
+end

Libs/AceGUI-3.0/widgets/AceGUIWidget-Button.lua

@@ -0,0 +1,103 @@
+--[[-----------------------------------------------------------------------------
+Button Widget
+Graphical Button.
+-------------------------------------------------------------------------------]]
+local Type, Version = "Button", 24
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs = pairs
+
+-- WoW APIs
+local _G = _G
+local PlaySound, CreateFrame, UIParent = PlaySound, CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Button_OnClick(frame, ...)
+	AceGUI:ClearFocus()
+	PlaySound(852) -- SOUNDKIT.IG_MAINMENU_OPTION
+	frame.obj:Fire("OnClick", ...)
+end
+
+local function Control_OnEnter(frame)
+	frame.obj:Fire("OnEnter")
+end
+
+local function Control_OnLeave(frame)
+	frame.obj:Fire("OnLeave")
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		-- restore default values
+		self:SetHeight(24)
+		self:SetWidth(200)
+		self:SetDisabled(false)
+		self:SetAutoWidth(false)
+		self:SetText()
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["SetText"] = function(self, text)
+		self.text:SetText(text)
+		if self.autoWidth then
+			self:SetWidth(self.text:GetStringWidth() + 30)
+		end
+	end,
+
+	["SetAutoWidth"] = function(self, autoWidth)
+		self.autoWidth = autoWidth
+		if self.autoWidth then
+			self:SetWidth(self.text:GetStringWidth() + 30)
+		end
+	end,
+
+	["SetDisabled"] = function(self, disabled)
+		self.disabled = disabled
+		if disabled then
+			self.frame:Disable()
+		else
+			self.frame:Enable()
+		end
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local name = "AceGUI30Button" .. AceGUI:GetNextWidgetNum(Type)
+	local frame = CreateFrame("Button", name, UIParent, "UIPanelButtonTemplate")
+	frame:Hide()
+
+	frame:EnableMouse(true)
+	frame:SetScript("OnClick", Button_OnClick)
+	frame:SetScript("OnEnter", Control_OnEnter)
+	frame:SetScript("OnLeave", Control_OnLeave)
+
+	local text = frame:GetFontString()
+	text:ClearAllPoints()
+	text:SetPoint("TOPLEFT", 15, -1)
+	text:SetPoint("BOTTOMRIGHT", -15, 1)
+	text:SetJustifyV("MIDDLE")
+
+	local widget = {
+		text  = text,
+		frame = frame,
+		type  = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-CheckBox.lua

@@ -0,0 +1,292 @@
+--[[-----------------------------------------------------------------------------
+Checkbox Widget
+-------------------------------------------------------------------------------]]
+local Type, Version = "CheckBox", 26
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local select, pairs = select, pairs
+
+-- WoW APIs
+local PlaySound = PlaySound
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+local function AlignImage(self)
+	local img = self.image:GetTexture()
+	self.text:ClearAllPoints()
+	if not img then
+		self.text:SetPoint("LEFT", self.checkbg, "RIGHT")
+		self.text:SetPoint("RIGHT")
+	else
+		self.text:SetPoint("LEFT", self.image, "RIGHT", 1, 0)
+		self.text:SetPoint("RIGHT")
+	end
+end
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Control_OnEnter(frame)
+	frame.obj:Fire("OnEnter")
+end
+
+local function Control_OnLeave(frame)
+	frame.obj:Fire("OnLeave")
+end
+
+local function CheckBox_OnMouseDown(frame)
+	local self = frame.obj
+	if not self.disabled then
+		if self.image:GetTexture() then
+			self.text:SetPoint("LEFT", self.image,"RIGHT", 2, -1)
+		else
+			self.text:SetPoint("LEFT", self.checkbg, "RIGHT", 1, -1)
+		end
+	end
+	AceGUI:ClearFocus()
+end
+
+local function CheckBox_OnMouseUp(frame)
+	local self = frame.obj
+	if not self.disabled then
+		self:ToggleChecked()
+
+		if self.checked then
+			PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
+		else -- for both nil and false (tristate)
+			PlaySound(857) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF
+		end
+
+		self:Fire("OnValueChanged", self.checked)
+		AlignImage(self)
+	end
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetType()
+		self:SetValue(false)
+		self:SetTriState(nil)
+		-- height is calculated from the width and required space for the description
+		self:SetWidth(200)
+		self:SetImage()
+		self:SetDisabled(nil)
+		self:SetDescription(nil)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["OnWidthSet"] = function(self, width)
+		if self.desc then
+			self.desc:SetWidth(width - 30)
+			if self.desc:GetText() and self.desc:GetText() ~= "" then
+				self:SetHeight(28 + self.desc:GetStringHeight())
+			end
+		end
+	end,
+
+	["SetDisabled"] = function(self, disabled)
+		self.disabled = disabled
+		if disabled then
+			self.frame:Disable()
+			self.text:SetTextColor(0.5, 0.5, 0.5)
+			SetDesaturation(self.check, true)
+			if self.desc then
+				self.desc:SetTextColor(0.5, 0.5, 0.5)
+			end
+		else
+			self.frame:Enable()
+			self.text:SetTextColor(1, 1, 1)
+			if self.tristate and self.checked == nil then
+				SetDesaturation(self.check, true)
+			else
+				SetDesaturation(self.check, false)
+			end
+			if self.desc then
+				self.desc:SetTextColor(1, 1, 1)
+			end
+		end
+	end,
+
+	["SetValue"] = function(self, value)
+		local check = self.check
+		self.checked = value
+		if value then
+			SetDesaturation(check, false)
+			check:Show()
+		else
+			--Nil is the unknown tristate value
+			if self.tristate and value == nil then
+				SetDesaturation(check, true)
+				check:Show()
+			else
+				SetDesaturation(check, false)
+				check:Hide()
+			end
+		end
+		self:SetDisabled(self.disabled)
+	end,
+
+	["GetValue"] = function(self)
+		return self.checked
+	end,
+
+	["SetTriState"] = function(self, enabled)
+		self.tristate = enabled
+		self:SetValue(self:GetValue())
+	end,
+
+	["SetType"] = function(self, type)
+		local checkbg = self.checkbg
+		local check = self.check
+		local highlight = self.highlight
+
+		local size
+		if type == "radio" then
+			size = 16
+			checkbg:SetTexture(130843) -- Interface\\Buttons\\UI-RadioButton
+			checkbg:SetTexCoord(0, 0.25, 0, 1)
+			check:SetTexture(130843) -- Interface\\Buttons\\UI-RadioButton
+			check:SetTexCoord(0.25, 0.5, 0, 1)
+			check:SetBlendMode("ADD")
+			highlight:SetTexture(130843) -- Interface\\Buttons\\UI-RadioButton
+			highlight:SetTexCoord(0.5, 0.75, 0, 1)
+		else
+			size = 24
+			checkbg:SetTexture(130755) -- Interface\\Buttons\\UI-CheckBox-Up
+			checkbg:SetTexCoord(0, 1, 0, 1)
+			check:SetTexture(130751) -- Interface\\Buttons\\UI-CheckBox-Check
+			check:SetTexCoord(0, 1, 0, 1)
+			check:SetBlendMode("BLEND")
+			highlight:SetTexture(130753) -- Interface\\Buttons\\UI-CheckBox-Highlight
+			highlight:SetTexCoord(0, 1, 0, 1)
+		end
+		checkbg:SetHeight(size)
+		checkbg:SetWidth(size)
+	end,
+
+	["ToggleChecked"] = function(self)
+		local value = self:GetValue()
+		if self.tristate then
+			--cycle in true, nil, false order
+			if value then
+				self:SetValue(nil)
+			elseif value == nil then
+				self:SetValue(false)
+			else
+				self:SetValue(true)
+			end
+		else
+			self:SetValue(not self:GetValue())
+		end
+	end,
+
+	["SetLabel"] = function(self, label)
+		self.text:SetText(label)
+	end,
+
+	["SetDescription"] = function(self, desc)
+		if desc then
+			if not self.desc then
+				local f = self.frame:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall")
+				f:ClearAllPoints()
+				f:SetPoint("TOPLEFT", self.checkbg, "TOPRIGHT", 5, -21)
+				f:SetWidth(self.frame.width - 30)
+				f:SetPoint("RIGHT", self.frame, "RIGHT", -30, 0)
+				f:SetJustifyH("LEFT")
+				f:SetJustifyV("TOP")
+				self.desc = f
+			end
+			self.desc:Show()
+			--self.text:SetFontObject(GameFontNormal)
+			self.desc:SetText(desc)
+			self:SetHeight(28 + self.desc:GetStringHeight())
+		else
+			if self.desc then
+				self.desc:SetText("")
+				self.desc:Hide()
+			end
+			--self.text:SetFontObject(GameFontHighlight)
+			self:SetHeight(24)
+		end
+	end,
+
+	["SetImage"] = function(self, path, ...)
+		local image = self.image
+		image:SetTexture(path)
+
+		if image:GetTexture() then
+			local n = select("#", ...)
+			if n == 4 or n == 8 then
+				image:SetTexCoord(...)
+			else
+				image:SetTexCoord(0, 1, 0, 1)
+			end
+		end
+		AlignImage(self)
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local frame = CreateFrame("Button", nil, UIParent)
+	frame:Hide()
+
+	frame:EnableMouse(true)
+	frame:SetScript("OnEnter", Control_OnEnter)
+	frame:SetScript("OnLeave", Control_OnLeave)
+	frame:SetScript("OnMouseDown", CheckBox_OnMouseDown)
+	frame:SetScript("OnMouseUp", CheckBox_OnMouseUp)
+
+	local checkbg = frame:CreateTexture(nil, "ARTWORK")
+	checkbg:SetWidth(24)
+	checkbg:SetHeight(24)
+	checkbg:SetPoint("TOPLEFT")
+	checkbg:SetTexture(130755) -- Interface\\Buttons\\UI-CheckBox-Up
+
+	local check = frame:CreateTexture(nil, "OVERLAY")
+	check:SetAllPoints(checkbg)
+	check:SetTexture(130751) -- Interface\\Buttons\\UI-CheckBox-Check
+
+	local text = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
+	text:SetJustifyH("LEFT")
+	text:SetHeight(18)
+	text:SetPoint("LEFT", checkbg, "RIGHT")
+	text:SetPoint("RIGHT")
+
+	local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
+	highlight:SetTexture(130753) -- Interface\\Buttons\\UI-CheckBox-Highlight
+	highlight:SetBlendMode("ADD")
+	highlight:SetAllPoints(checkbg)
+
+	local image = frame:CreateTexture(nil, "OVERLAY")
+	image:SetHeight(16)
+	image:SetWidth(16)
+	image:SetPoint("LEFT", checkbg, "RIGHT", 1, 0)
+
+	local widget = {
+		checkbg   = checkbg,
+		check     = check,
+		text      = text,
+		highlight = highlight,
+		image     = image,
+		frame     = frame,
+		type      = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-ColorPicker.lua

@@ -0,0 +1,230 @@
+--[[-----------------------------------------------------------------------------
+ColorPicker Widget
+-------------------------------------------------------------------------------]]
+local Type, Version = "ColorPicker", 28
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs = pairs
+
+-- WoW APIs
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+-- Unfortunately we have no way to realistically detect if a client uses inverted alpha
+-- as no API will tell you. Wrath uses the old colorpicker, era uses the new one, both are inverted
+local INVERTED_ALPHA = (WOW_PROJECT_ID ~= WOW_PROJECT_MAINLINE)
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+local function ColorCallback(self, r, g, b, a, isAlpha)
+	if INVERTED_ALPHA and a then
+		a = 1 - a
+	end
+	if not self.HasAlpha then
+		a = 1
+	end
+	-- no change, skip update
+	if r == self.r and g == self.g and b == self.b and a == self.a then
+		return
+	end
+	self:SetColor(r, g, b, a)
+	if ColorPickerFrame:IsVisible() then
+		--colorpicker is still open
+		self:Fire("OnValueChanged", r, g, b, a)
+	else
+		--colorpicker is closed, color callback is first, ignore it,
+		--alpha callback is the final call after it closes so confirm now
+		if isAlpha then
+			self:Fire("OnValueConfirmed", r, g, b, a)
+		end
+	end
+end
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Control_OnEnter(frame)
+	frame.obj:Fire("OnEnter")
+end
+
+local function Control_OnLeave(frame)
+	frame.obj:Fire("OnLeave")
+end
+
+local function ColorSwatch_OnClick(frame)
+	ColorPickerFrame:Hide()
+	local self = frame.obj
+	if not self.disabled then
+		ColorPickerFrame:SetFrameStrata("FULLSCREEN_DIALOG")
+		ColorPickerFrame:SetFrameLevel(frame:GetFrameLevel() + 10)
+		ColorPickerFrame:SetClampedToScreen(true)
+
+		if ColorPickerFrame.SetupColorPickerAndShow then -- 10.2.5 color picker overhaul
+			local r2, g2, b2, a2 = self.r, self.g, self.b, (self.a or 1)
+			if INVERTED_ALPHA then
+				a2 = 1 - a2
+			end
+
+			local info = {
+				swatchFunc = function()
+					local r, g, b = ColorPickerFrame:GetColorRGB()
+					local a = ColorPickerFrame:GetColorAlpha()
+					ColorCallback(self, r, g, b, a)
+				end,
+
+				hasOpacity = self.HasAlpha,
+				opacityFunc = function()
+					local r, g, b = ColorPickerFrame:GetColorRGB()
+					local a = ColorPickerFrame:GetColorAlpha()
+					ColorCallback(self, r, g, b, a, true)
+				end,
+				opacity = a2,
+
+				cancelFunc = function()
+					ColorCallback(self, r2, g2, b2, a2, true)
+				end,
+
+				r = r2,
+				g = g2,
+				b = b2,
+			}
+
+			ColorPickerFrame:SetupColorPickerAndShow(info)
+		else
+			ColorPickerFrame.func = function()
+				local r, g, b = ColorPickerFrame:GetColorRGB()
+				local a = OpacitySliderFrame:GetValue()
+				ColorCallback(self, r, g, b, a)
+			end
+
+			ColorPickerFrame.hasOpacity = self.HasAlpha
+			ColorPickerFrame.opacityFunc = function()
+				local r, g, b = ColorPickerFrame:GetColorRGB()
+				local a = OpacitySliderFrame:GetValue()
+				ColorCallback(self, r, g, b, a, true)
+			end
+
+			local r, g, b, a = self.r, self.g, self.b, 1 - (self.a or 1)
+			if self.HasAlpha then
+				ColorPickerFrame.opacity = a
+			end
+			ColorPickerFrame:SetColorRGB(r, g, b)
+
+			ColorPickerFrame.cancelFunc = function()
+				ColorCallback(self, r, g, b, a, true)
+			end
+
+			ColorPickerFrame:Show()
+		end
+	end
+	AceGUI:ClearFocus()
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetHeight(24)
+		self:SetWidth(200)
+		self:SetHasAlpha(false)
+		self:SetColor(0, 0, 0, 1)
+		self:SetDisabled(nil)
+		self:SetLabel(nil)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["SetLabel"] = function(self, text)
+		self.text:SetText(text)
+	end,
+
+	["SetColor"] = function(self, r, g, b, a)
+		self.r = r
+		self.g = g
+		self.b = b
+		self.a = a or 1
+		self.colorSwatch:SetVertexColor(r, g, b, a)
+	end,
+
+	["SetHasAlpha"] = function(self, HasAlpha)
+		self.HasAlpha = HasAlpha
+	end,
+
+	["SetDisabled"] = function(self, disabled)
+		self.disabled = disabled
+		if self.disabled then
+			self.frame:Disable()
+			self.text:SetTextColor(0.5, 0.5, 0.5)
+		else
+			self.frame:Enable()
+			self.text:SetTextColor(1, 1, 1)
+		end
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local frame = CreateFrame("Button", nil, UIParent)
+	frame:Hide()
+
+	frame:EnableMouse(true)
+	frame:SetScript("OnEnter", Control_OnEnter)
+	frame:SetScript("OnLeave", Control_OnLeave)
+	frame:SetScript("OnClick", ColorSwatch_OnClick)
+
+	local colorSwatch = frame:CreateTexture(nil, "OVERLAY")
+	colorSwatch:SetWidth(19)
+	colorSwatch:SetHeight(19)
+	colorSwatch:SetTexture(130939) -- Interface\\ChatFrame\\ChatFrameColorSwatch
+	colorSwatch:SetPoint("LEFT")
+
+	local texture = frame:CreateTexture(nil, "BACKGROUND")
+	colorSwatch.background = texture
+	texture:SetWidth(16)
+	texture:SetHeight(16)
+	texture:SetColorTexture(1, 1, 1)
+	texture:SetPoint("CENTER", colorSwatch)
+	texture:Show()
+
+	local checkers = frame:CreateTexture(nil, "BACKGROUND")
+	colorSwatch.checkers = checkers
+	checkers:SetWidth(14)
+	checkers:SetHeight(14)
+	checkers:SetTexture(188523) -- Tileset\\Generic\\Checkers
+	checkers:SetTexCoord(.25, 0, 0.5, .25)
+	checkers:SetDesaturated(true)
+	checkers:SetVertexColor(1, 1, 1, 0.75)
+	checkers:SetPoint("CENTER", colorSwatch)
+	checkers:Show()
+
+	local text = frame:CreateFontString(nil,"OVERLAY","GameFontHighlight")
+	text:SetHeight(24)
+	text:SetJustifyH("LEFT")
+	text:SetTextColor(1, 1, 1)
+	text:SetPoint("LEFT", colorSwatch, "RIGHT", 2, 0)
+	text:SetPoint("RIGHT")
+
+	--local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
+	--highlight:SetTexture(136810) -- Interface\\QuestFrame\\UI-QuestTitleHighlight
+	--highlight:SetBlendMode("ADD")
+	--highlight:SetAllPoints(frame)
+
+	local widget = {
+		colorSwatch = colorSwatch,
+		text        = text,
+		frame       = frame,
+		type        = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown-Items.lua

@@ -0,0 +1,471 @@
+--[[ $Id: AceGUIWidget-DropDown-Items.lua 1272 2022-08-29 15:56:35Z nevcairiel $ ]]--
+
+local AceGUI = LibStub("AceGUI-3.0")
+
+-- Lua APIs
+local select, assert = select, assert
+
+-- WoW APIs
+local PlaySound = PlaySound
+local CreateFrame = CreateFrame
+
+local function fixlevels(parent,...)
+	local i = 1
+	local child = select(i, ...)
+	while child do
+		child:SetFrameLevel(parent:GetFrameLevel()+1)
+		fixlevels(child, child:GetChildren())
+		i = i + 1
+		child = select(i, ...)
+	end
+end
+
+local function fixstrata(strata, parent, ...)
+	local i = 1
+	local child = select(i, ...)
+	parent:SetFrameStrata(strata)
+	while child do
+		fixstrata(strata, child, child:GetChildren())
+		i = i + 1
+		child = select(i, ...)
+	end
+end
+
+-- ItemBase is the base "class" for all dropdown items.
+-- Each item has to use ItemBase.Create(widgetType) to
+-- create an initial 'self' value.
+-- ItemBase will add common functions and ui event handlers.
+-- Be sure to keep basic usage when you override functions.
+
+local ItemBase = {
+	-- NOTE: The ItemBase version is added to each item's version number
+	--       to ensure proper updates on ItemBase changes.
+	--       Use at least 1000er steps.
+	version = 2000,
+	counter = 0,
+}
+
+function ItemBase.Frame_OnEnter(this)
+	local self = this.obj
+
+	if self.useHighlight then
+		self.highlight:Show()
+	end
+	self:Fire("OnEnter")
+
+	if self.specialOnEnter then
+		self.specialOnEnter(self)
+	end
+end
+
+function ItemBase.Frame_OnLeave(this)
+	local self = this.obj
+
+	self.highlight:Hide()
+	self:Fire("OnLeave")
+
+	if self.specialOnLeave then
+		self.specialOnLeave(self)
+	end
+end
+
+-- exported, AceGUI callback
+function ItemBase.OnAcquire(self)
+	self.frame:SetToplevel(true)
+	self.frame:SetFrameStrata("FULLSCREEN_DIALOG")
+end
+
+-- exported, AceGUI callback
+function ItemBase.OnRelease(self)
+	self:SetDisabled(false)
+	self.pullout = nil
+	self.frame:SetParent(nil)
+	self.frame:ClearAllPoints()
+	self.frame:Hide()
+end
+
+-- exported
+-- NOTE: this is called by a Dropdown-Pullout.
+--       Do not call this method directly
+function ItemBase.SetPullout(self, pullout)
+	self.pullout = pullout
+
+	self.frame:SetParent(nil)
+	self.frame:SetParent(pullout.itemFrame)
+	self.parent = pullout.itemFrame
+	fixlevels(pullout.itemFrame, pullout.itemFrame:GetChildren())
+end
+
+-- exported
+function ItemBase.SetText(self, text)
+	self.text:SetText(text or "")
+end
+
+-- exported
+function ItemBase.GetText(self)
+	return self.text:GetText()
+end
+
+-- exported
+function ItemBase.SetPoint(self, ...)
+	self.frame:SetPoint(...)
+end
+
+-- exported
+function ItemBase.Show(self)
+	self.frame:Show()
+end
+
+-- exported
+function ItemBase.Hide(self)
+	self.frame:Hide()
+end
+
+-- exported
+function ItemBase.SetDisabled(self, disabled)
+	self.disabled = disabled
+	if disabled then
+		self.useHighlight = false
+		self.text:SetTextColor(.5, .5, .5)
+	else
+		self.useHighlight = true
+		self.text:SetTextColor(1, 1, 1)
+	end
+end
+
+-- exported
+-- NOTE: this is called by a Dropdown-Pullout.
+--       Do not call this method directly
+function ItemBase.SetOnLeave(self, func)
+	self.specialOnLeave = func
+end
+
+-- exported
+-- NOTE: this is called by a Dropdown-Pullout.
+--       Do not call this method directly
+function ItemBase.SetOnEnter(self, func)
+	self.specialOnEnter = func
+end
+
+function ItemBase.Create(type)
+	-- NOTE: Most of the following code is copied from AceGUI-3.0/Dropdown widget
+	local count = AceGUI:GetNextWidgetNum(type)
+	local frame = CreateFrame("Button", "AceGUI30DropDownItem"..count)
+	local self = {}
+	self.frame = frame
+	frame.obj = self
+	self.type = type
+
+	self.useHighlight = true
+
+	frame:SetHeight(17)
+	frame:SetFrameStrata("FULLSCREEN_DIALOG")
+
+	local text = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall")
+	text:SetTextColor(1,1,1)
+	text:SetJustifyH("LEFT")
+	text:SetPoint("TOPLEFT",frame,"TOPLEFT",18,0)
+	text:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-8,0)
+	self.text = text
+
+	local highlight = frame:CreateTexture(nil, "OVERLAY")
+	highlight:SetTexture(136810) -- Interface\\QuestFrame\\UI-QuestTitleHighlight
+	highlight:SetBlendMode("ADD")
+	highlight:SetHeight(14)
+	highlight:ClearAllPoints()
+	highlight:SetPoint("RIGHT",frame,"RIGHT",-3,0)
+	highlight:SetPoint("LEFT",frame,"LEFT",5,0)
+	highlight:Hide()
+	self.highlight = highlight
+
+	local check = frame:CreateTexture(nil, "OVERLAY")
+	check:SetWidth(16)
+	check:SetHeight(16)
+	check:SetPoint("LEFT",frame,"LEFT",3,-1)
+	check:SetTexture(130751) -- Interface\\Buttons\\UI-CheckBox-Check
+	check:Hide()
+	self.check = check
+
+	local sub = frame:CreateTexture(nil, "OVERLAY")
+	sub:SetWidth(16)
+	sub:SetHeight(16)
+	sub:SetPoint("RIGHT",frame,"RIGHT",-3,-1)
+	sub:SetTexture(130940) -- Interface\\ChatFrame\\ChatFrameExpandArrow
+	sub:Hide()
+	self.sub = sub
+
+	frame:SetScript("OnEnter", ItemBase.Frame_OnEnter)
+	frame:SetScript("OnLeave", ItemBase.Frame_OnLeave)
+
+	self.OnAcquire = ItemBase.OnAcquire
+	self.OnRelease = ItemBase.OnRelease
+
+	self.SetPullout = ItemBase.SetPullout
+	self.GetText    = ItemBase.GetText
+	self.SetText    = ItemBase.SetText
+	self.SetDisabled = ItemBase.SetDisabled
+
+	self.SetPoint   = ItemBase.SetPoint
+	self.Show       = ItemBase.Show
+	self.Hide       = ItemBase.Hide
+
+	self.SetOnLeave = ItemBase.SetOnLeave
+	self.SetOnEnter = ItemBase.SetOnEnter
+
+	return self
+end
+
+-- Register a dummy LibStub library to retrieve the ItemBase, so other addons can use it.
+local IBLib = LibStub:NewLibrary("AceGUI-3.0-DropDown-ItemBase", ItemBase.version)
+if IBLib then
+	IBLib.GetItemBase = function() return ItemBase end
+end
+
+--[[
+	Template for items:
+
+-- Item:
+--
+do
+	local widgetType = "Dropdown-Item-"
+	local widgetVersion = 1
+
+	local function Constructor()
+		local self = ItemBase.Create(widgetType)
+
+		AceGUI:RegisterAsWidget(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
+end
+--]]
+
+-- Item: Header
+-- A single text entry.
+-- Special: Different text color and no highlight
+do
+	local widgetType = "Dropdown-Item-Header"
+	local widgetVersion = 1
+
+	local function OnEnter(this)
+		local self = this.obj
+		self:Fire("OnEnter")
+
+		if self.specialOnEnter then
+			self.specialOnEnter(self)
+		end
+	end
+
+	local function OnLeave(this)
+		local self = this.obj
+		self:Fire("OnLeave")
+
+		if self.specialOnLeave then
+			self.specialOnLeave(self)
+		end
+	end
+
+	-- exported, override
+	local function SetDisabled(self, disabled)
+		ItemBase.SetDisabled(self, disabled)
+		if not disabled then
+			self.text:SetTextColor(1, 1, 0)
+		end
+	end
+
+	local function Constructor()
+		local self = ItemBase.Create(widgetType)
+
+		self.SetDisabled = SetDisabled
+
+		self.frame:SetScript("OnEnter", OnEnter)
+		self.frame:SetScript("OnLeave", OnLeave)
+
+		self.text:SetTextColor(1, 1, 0)
+
+		AceGUI:RegisterAsWidget(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
+end
+
+-- Item: Execute
+-- A simple button
+do
+	local widgetType = "Dropdown-Item-Execute"
+	local widgetVersion = 1
+
+	local function Frame_OnClick(this, button)
+		local self = this.obj
+		if self.disabled then return end
+		self:Fire("OnClick")
+		if self.pullout then
+			self.pullout:Close()
+		end
+	end
+
+	local function Constructor()
+		local self = ItemBase.Create(widgetType)
+
+		self.frame:SetScript("OnClick", Frame_OnClick)
+
+		AceGUI:RegisterAsWidget(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
+end
+
+-- Item: Toggle
+-- Some sort of checkbox for dropdown menus.
+-- Does not close the pullout on click.
+do
+	local widgetType = "Dropdown-Item-Toggle"
+	local widgetVersion = 4
+
+	local function UpdateToggle(self)
+		if self.value then
+			self.check:Show()
+		else
+			self.check:Hide()
+		end
+	end
+
+	local function OnRelease(self)
+		ItemBase.OnRelease(self)
+		self:SetValue(nil)
+	end
+
+	local function Frame_OnClick(this, button)
+		local self = this.obj
+		if self.disabled then return end
+		self.value = not self.value
+		if self.value then
+			PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
+		else
+			PlaySound(857) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF
+		end
+		UpdateToggle(self)
+		self:Fire("OnValueChanged", self.value)
+	end
+
+	-- exported
+	local function SetValue(self, value)
+		self.value = value
+		UpdateToggle(self)
+	end
+
+	-- exported
+	local function GetValue(self)
+		return self.value
+	end
+
+	local function Constructor()
+		local self = ItemBase.Create(widgetType)
+
+		self.frame:SetScript("OnClick", Frame_OnClick)
+
+		self.SetValue = SetValue
+		self.GetValue = GetValue
+		self.OnRelease = OnRelease
+
+		AceGUI:RegisterAsWidget(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
+end
+
+-- Item: Menu
+-- Shows a submenu on mouse over
+-- Does not close the pullout on click
+do
+	local widgetType = "Dropdown-Item-Menu"
+	local widgetVersion = 2
+
+	local function OnEnter(this)
+		local self = this.obj
+		self:Fire("OnEnter")
+
+		if self.specialOnEnter then
+			self.specialOnEnter(self)
+		end
+
+		self.highlight:Show()
+
+		if not self.disabled and self.submenu then
+			self.submenu:Open("TOPLEFT", self.frame, "TOPRIGHT", self.pullout:GetRightBorderWidth(), 0, self.frame:GetFrameLevel() + 100)
+		end
+	end
+
+	local function OnHide(this)
+		local self = this.obj
+		if self.submenu then
+			self.submenu:Close()
+		end
+	end
+
+	-- exported
+	local function SetMenu(self, menu)
+		assert(menu.type == "Dropdown-Pullout")
+		self.submenu = menu
+	end
+
+	-- exported
+	local function CloseMenu(self)
+		self.submenu:Close()
+	end
+
+	local function Constructor()
+		local self = ItemBase.Create(widgetType)
+
+		self.sub:Show()
+
+		self.frame:SetScript("OnEnter", OnEnter)
+		self.frame:SetScript("OnHide", OnHide)
+
+		self.SetMenu   = SetMenu
+		self.CloseMenu = CloseMenu
+
+		AceGUI:RegisterAsWidget(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
+end
+
+-- Item: Separator
+-- A single line to separate items
+do
+	local widgetType = "Dropdown-Item-Separator"
+	local widgetVersion = 2
+
+	-- exported, override
+	local function SetDisabled(self, disabled)
+		ItemBase.SetDisabled(self, disabled)
+		self.useHighlight = false
+	end
+
+	local function Constructor()
+		local self = ItemBase.Create(widgetType)
+
+		self.SetDisabled = SetDisabled
+
+		local line = self.frame:CreateTexture(nil, "OVERLAY")
+		line:SetHeight(1)
+		line:SetColorTexture(.5, .5, .5)
+		line:SetPoint("LEFT", self.frame, "LEFT", 10, 0)
+		line:SetPoint("RIGHT", self.frame, "RIGHT", -10, 0)
+
+		self.text:Hide()
+
+		self.useHighlight = false
+
+		AceGUI:RegisterAsWidget(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
+end

Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown.lua

@@ -0,0 +1,732 @@
+--[[ $Id: AceGUIWidget-DropDown.lua 1284 2022-09-25 09:15:30Z nevcairiel $ ]]--
+local AceGUI = LibStub("AceGUI-3.0")
+
+-- Lua APIs
+local min, max, floor = math.min, math.max, math.floor
+local select, pairs, ipairs, type, tostring = select, pairs, ipairs, type, tostring
+local tsort = table.sort
+
+-- WoW APIs
+local PlaySound = PlaySound
+local UIParent, CreateFrame = UIParent, CreateFrame
+local _G = _G
+
+local function fixlevels(parent,...)
+	local i = 1
+	local child = select(i, ...)
+	while child do
+		child:SetFrameLevel(parent:GetFrameLevel()+1)
+		fixlevels(child, child:GetChildren())
+		i = i + 1
+		child = select(i, ...)
+	end
+end
+
+local function fixstrata(strata, parent, ...)
+	local i = 1
+	local child = select(i, ...)
+	parent:SetFrameStrata(strata)
+	while child do
+		fixstrata(strata, child, child:GetChildren())
+		i = i + 1
+		child = select(i, ...)
+	end
+end
+
+do
+	local widgetType = "Dropdown-Pullout"
+	local widgetVersion = 5
+
+	--[[ Static data ]]--
+
+	local backdrop = {
+		bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
+		edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
+		edgeSize = 32,
+		tileSize = 32,
+		tile = true,
+		insets = { left = 11, right = 12, top = 12, bottom = 11 },
+	}
+	local sliderBackdrop  = {
+		bgFile = "Interface\\Buttons\\UI-SliderBar-Background",
+		edgeFile = "Interface\\Buttons\\UI-SliderBar-Border",
+		tile = true, tileSize = 8, edgeSize = 8,
+		insets = { left = 3, right = 3, top = 3, bottom = 3 }
+	}
+
+	local defaultWidth = 200
+	local defaultMaxHeight = 600
+
+	--[[ UI Event Handlers ]]--
+
+	-- HACK: This should be no part of the pullout, but there
+	--       is no other 'clean' way to response to any item-OnEnter
+	--       Used to close Submenus when an other item is entered
+	local function OnEnter(item)
+		local self = item.pullout
+		for k, v in ipairs(self.items) do
+			if v.CloseMenu and v ~= item then
+				v:CloseMenu()
+			end
+		end
+	end
+
+	-- See the note in Constructor() for each scroll related function
+	local function OnMouseWheel(this, value)
+		this.obj:MoveScroll(value)
+	end
+
+	local function OnScrollValueChanged(this, value)
+		this.obj:SetScroll(value)
+	end
+
+	local function OnSizeChanged(this)
+		this.obj:FixScroll()
+	end
+
+	--[[ Exported methods ]]--
+
+	-- exported
+	local function SetScroll(self, value)
+		local status = self.scrollStatus
+		local frame, child = self.scrollFrame, self.itemFrame
+		local height, viewheight = frame:GetHeight(), child:GetHeight()
+
+		local offset
+		if height > viewheight then
+			offset = 0
+		else
+			offset = floor((viewheight - height) / 1000 * value)
+		end
+		child:ClearAllPoints()
+		child:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, offset)
+		child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", self.slider:IsShown() and -12 or 0, offset)
+		status.offset = offset
+		status.scrollvalue = value
+	end
+
+	-- exported
+	local function MoveScroll(self, value)
+		local status = self.scrollStatus
+		local frame, child = self.scrollFrame, self.itemFrame
+		local height, viewheight = frame:GetHeight(), child:GetHeight()
+
+		if height > viewheight then
+			self.slider:Hide()
+		else
+			self.slider:Show()
+			local diff = height - viewheight
+			local delta = 1
+			if value < 0 then
+				delta = -1
+			end
+			self.slider:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000))
+		end
+	end
+
+	-- exported
+	local function FixScroll(self)
+		local status = self.scrollStatus
+		local frame, child = self.scrollFrame, self.itemFrame
+		local height, viewheight = frame:GetHeight(), child:GetHeight()
+		local offset = status.offset or 0
+
+		if viewheight < height then
+			self.slider:Hide()
+			child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, offset)
+			self.slider:SetValue(0)
+		else
+			self.slider:Show()
+			local value = (offset / (viewheight - height) * 1000)
+			if value > 1000 then value = 1000 end
+			self.slider:SetValue(value)
+			self:SetScroll(value)
+			if value < 1000 then
+				child:ClearAllPoints()
+				child:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, offset)
+				child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -12, offset)
+				status.offset = offset
+			end
+		end
+	end
+
+	-- exported, AceGUI callback
+	local function OnAcquire(self)
+		self.frame:SetParent(UIParent)
+		--self.itemFrame:SetToplevel(true)
+	end
+
+	-- exported, AceGUI callback
+	local function OnRelease(self)
+		self:Clear()
+		self.frame:ClearAllPoints()
+		self.frame:Hide()
+	end
+
+	-- exported
+	local function AddItem(self, item)
+		self.items[#self.items + 1] = item
+
+		local h = #self.items * 16
+		self.itemFrame:SetHeight(h)
+		self.frame:SetHeight(min(h + 34, self.maxHeight)) -- +34: 20 for scrollFrame placement (10 offset) and +14 for item placement
+
+		item.frame:SetPoint("LEFT", self.itemFrame, "LEFT")
+		item.frame:SetPoint("RIGHT", self.itemFrame, "RIGHT")
+
+		item:SetPullout(self)
+		item:SetOnEnter(OnEnter)
+	end
+
+	-- exported
+	local function Open(self, point, relFrame, relPoint, x, y)
+		local items = self.items
+		local frame = self.frame
+		local itemFrame = self.itemFrame
+
+		frame:SetPoint(point, relFrame, relPoint, x, y)
+
+
+		local height = 8
+		for i, item in pairs(items) do
+			item:SetPoint("TOP", itemFrame, "TOP", 0, -2 + (i - 1) * -16)
+			item:Show()
+
+			height = height + 16
+		end
+		itemFrame:SetHeight(height)
+		fixstrata("TOOLTIP", frame, frame:GetChildren())
+		frame:Show()
+		self:Fire("OnOpen")
+	end
+
+	-- exported
+	local function Close(self)
+		self.frame:Hide()
+		self:Fire("OnClose")
+	end
+
+	-- exported
+	local function Clear(self)
+		local items = self.items
+		for i, item in pairs(items) do
+			AceGUI:Release(item)
+			items[i] = nil
+		end
+	end
+
+	-- exported
+	local function IterateItems(self)
+		return ipairs(self.items)
+	end
+
+	-- exported
+	local function SetHideOnLeave(self, val)
+		self.hideOnLeave = val
+	end
+
+	-- exported
+	local function SetMaxHeight(self, height)
+		self.maxHeight = height or defaultMaxHeight
+		if self.frame:GetHeight() > height then
+			self.frame:SetHeight(height)
+		elseif (self.itemFrame:GetHeight() + 34) < height then
+			self.frame:SetHeight(self.itemFrame:GetHeight() + 34) -- see :AddItem
+		end
+	end
+
+	-- exported
+	local function GetRightBorderWidth(self)
+		return 6 + (self.slider:IsShown() and 12 or 0)
+	end
+
+	-- exported
+	local function GetLeftBorderWidth(self)
+		return 6
+	end
+
+	--[[ Constructor ]]--
+
+	local function Constructor()
+		local count = AceGUI:GetNextWidgetNum(widgetType)
+		local frame = CreateFrame("Frame", "AceGUI30Pullout"..count, UIParent, "BackdropTemplate")
+		local self = {}
+		self.count = count
+		self.type = widgetType
+		self.frame = frame
+		frame.obj = self
+
+		self.OnAcquire = OnAcquire
+		self.OnRelease = OnRelease
+
+		self.AddItem = AddItem
+		self.Open    = Open
+		self.Close   = Close
+		self.Clear   = Clear
+		self.IterateItems = IterateItems
+		self.SetHideOnLeave = SetHideOnLeave
+
+		self.SetScroll  = SetScroll
+		self.MoveScroll = MoveScroll
+		self.FixScroll  = FixScroll
+
+		self.SetMaxHeight = SetMaxHeight
+		self.GetRightBorderWidth = GetRightBorderWidth
+		self.GetLeftBorderWidth = GetLeftBorderWidth
+
+		self.items = {}
+
+		self.scrollStatus = {
+			scrollvalue = 0,
+		}
+
+		self.maxHeight = defaultMaxHeight
+
+		frame:SetBackdrop(backdrop)
+		frame:SetBackdropColor(0, 0, 0)
+		frame:SetFrameStrata("FULLSCREEN_DIALOG")
+		frame:SetClampedToScreen(true)
+		frame:SetWidth(defaultWidth)
+		frame:SetHeight(self.maxHeight)
+		--frame:SetToplevel(true)
+
+		-- NOTE: The whole scroll frame code is copied from the AceGUI-3.0 widget ScrollFrame
+		local scrollFrame = CreateFrame("ScrollFrame", nil, frame)
+		local itemFrame = CreateFrame("Frame", nil, scrollFrame)
+
+		self.scrollFrame = scrollFrame
+		self.itemFrame = itemFrame
+
+		scrollFrame.obj = self
+		itemFrame.obj = self
+
+		local slider = CreateFrame("Slider", "AceGUI30PulloutScrollbar"..count, scrollFrame, "BackdropTemplate")
+		slider:SetOrientation("VERTICAL")
+		slider:SetHitRectInsets(0, 0, -10, 0)
+		slider:SetBackdrop(sliderBackdrop)
+		slider:SetWidth(8)
+		slider:SetThumbTexture("Interface\\Buttons\\UI-SliderBar-Button-Vertical")
+		slider:SetFrameStrata("FULLSCREEN_DIALOG")
+		self.slider = slider
+		slider.obj = self
+
+		scrollFrame:SetScrollChild(itemFrame)
+		scrollFrame:SetPoint("TOPLEFT", frame, "TOPLEFT", 6, -12)
+		scrollFrame:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -6, 12)
+		scrollFrame:EnableMouseWheel(true)
+		scrollFrame:SetScript("OnMouseWheel", OnMouseWheel)
+		scrollFrame:SetScript("OnSizeChanged", OnSizeChanged)
+		scrollFrame:SetToplevel(true)
+		scrollFrame:SetFrameStrata("FULLSCREEN_DIALOG")
+
+		itemFrame:SetPoint("TOPLEFT", scrollFrame, "TOPLEFT", 0, 0)
+		itemFrame:SetPoint("TOPRIGHT", scrollFrame, "TOPRIGHT", -12, 0)
+		itemFrame:SetHeight(400)
+		itemFrame:SetToplevel(true)
+		itemFrame:SetFrameStrata("FULLSCREEN_DIALOG")
+
+		slider:SetPoint("TOPLEFT", scrollFrame, "TOPRIGHT", -16, 0)
+		slider:SetPoint("BOTTOMLEFT", scrollFrame, "BOTTOMRIGHT", -16, 0)
+		slider:SetScript("OnValueChanged", OnScrollValueChanged)
+		slider:SetMinMaxValues(0, 1000)
+		slider:SetValueStep(1)
+		slider:SetValue(0)
+
+		scrollFrame:Show()
+		itemFrame:Show()
+		slider:Hide()
+
+		self:FixScroll()
+
+		AceGUI:RegisterAsWidget(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
+end
+
+do
+	local widgetType = "Dropdown"
+	local widgetVersion = 36
+
+	--[[ Static data ]]--
+
+	--[[ UI event handler ]]--
+
+	local function Control_OnEnter(this)
+		this.obj.button:LockHighlight()
+		this.obj:Fire("OnEnter")
+	end
+
+	local function Control_OnLeave(this)
+		this.obj.button:UnlockHighlight()
+		this.obj:Fire("OnLeave")
+	end
+
+	local function Dropdown_OnHide(this)
+		local self = this.obj
+		if self.open then
+			self.pullout:Close()
+		end
+	end
+
+	local function Dropdown_TogglePullout(this)
+		local self = this.obj
+		if self.open then
+			self.open = nil
+			self.pullout:Close()
+			AceGUI:ClearFocus()
+		else
+			self.open = true
+			self.pullout:SetWidth(self.pulloutWidth or self.frame:GetWidth())
+			self.pullout:Open("TOPLEFT", self.frame, "BOTTOMLEFT", 0, self.label:IsShown() and -2 or 0)
+			AceGUI:SetFocus(self)
+		end
+	end
+
+	local function OnPulloutOpen(this)
+		local self = this.userdata.obj
+		local value = self.value
+
+		if not self.multiselect then
+			for i, item in this:IterateItems() do
+				item:SetValue(item.userdata.value == value)
+			end
+		end
+
+		self.open = true
+		self:Fire("OnOpened")
+	end
+
+	local function OnPulloutClose(this)
+		local self = this.userdata.obj
+		self.open = nil
+		self:Fire("OnClosed")
+	end
+
+	local function ShowMultiText(self)
+		local text
+		for i, widget in self.pullout:IterateItems() do
+			if widget.type == "Dropdown-Item-Toggle" then
+				if widget:GetValue() then
+					if text then
+						text = text..", "..widget:GetText()
+					else
+						text = widget:GetText()
+					end
+				end
+			end
+		end
+		self:SetText(text)
+	end
+
+	local function OnItemValueChanged(this, event, checked)
+		local self = this.userdata.obj
+
+		if self.multiselect then
+			self:Fire("OnValueChanged", this.userdata.value, checked)
+			ShowMultiText(self)
+		else
+			if checked then
+				self:SetValue(this.userdata.value)
+				self:Fire("OnValueChanged", this.userdata.value)
+			else
+				this:SetValue(true)
+			end
+			if self.open then
+				self.pullout:Close()
+			end
+		end
+	end
+
+	--[[ Exported methods ]]--
+
+	-- exported, AceGUI callback
+	local function OnAcquire(self)
+		local pullout = AceGUI:Create("Dropdown-Pullout")
+		self.pullout = pullout
+		pullout.userdata.obj = self
+		pullout:SetCallback("OnClose", OnPulloutClose)
+		pullout:SetCallback("OnOpen", OnPulloutOpen)
+		self.pullout.frame:SetFrameLevel(self.frame:GetFrameLevel() + 1)
+		fixlevels(self.pullout.frame, self.pullout.frame:GetChildren())
+
+		self:SetHeight(44)
+		self:SetWidth(200)
+		self:SetLabel()
+		self:SetPulloutWidth(nil)
+		self.list = {}
+	end
+
+	-- exported, AceGUI callback
+	local function OnRelease(self)
+		if self.open then
+			self.pullout:Close()
+		end
+		AceGUI:Release(self.pullout)
+		self.pullout = nil
+
+		self:SetText("")
+		self:SetDisabled(false)
+		self:SetMultiselect(false)
+
+		self.value = nil
+		self.list = nil
+		self.open = nil
+		self.hasClose = nil
+
+		self.frame:ClearAllPoints()
+		self.frame:Hide()
+	end
+
+	-- exported
+	local function SetDisabled(self, disabled)
+		self.disabled = disabled
+		if disabled then
+			self.text:SetTextColor(0.5,0.5,0.5)
+			self.button:Disable()
+			self.button_cover:Disable()
+			self.label:SetTextColor(0.5,0.5,0.5)
+		else
+			self.button:Enable()
+			self.button_cover:Enable()
+			self.label:SetTextColor(1,.82,0)
+			self.text:SetTextColor(1,1,1)
+		end
+	end
+
+	-- exported
+	local function ClearFocus(self)
+		if self.open then
+			self.pullout:Close()
+		end
+	end
+
+	-- exported
+	local function SetText(self, text)
+		self.text:SetText(text or "")
+	end
+
+	-- exported
+	local function SetLabel(self, text)
+		if text and text ~= "" then
+			self.label:SetText(text)
+			self.label:Show()
+			self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,-14)
+			self:SetHeight(40)
+			self.alignoffset = 26
+		else
+			self.label:SetText("")
+			self.label:Hide()
+			self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,0)
+			self:SetHeight(26)
+			self.alignoffset = 12
+		end
+	end
+
+	-- exported
+	local function SetValue(self, value)
+		self:SetText(self.list[value] or "")
+		self.value = value
+	end
+
+	-- exported
+	local function GetValue(self)
+		return self.value
+	end
+
+	-- exported
+	local function SetItemValue(self, item, value)
+		if not self.multiselect then return end
+		for i, widget in self.pullout:IterateItems() do
+			if widget.userdata.value == item then
+				if widget.SetValue then
+					widget:SetValue(value)
+				end
+			end
+		end
+		ShowMultiText(self)
+	end
+
+	-- exported
+	local function SetItemDisabled(self, item, disabled)
+		for i, widget in self.pullout:IterateItems() do
+			if widget.userdata.value == item then
+				widget:SetDisabled(disabled)
+			end
+		end
+	end
+
+	local function AddListItem(self, value, text, itemType)
+		if not itemType then itemType = "Dropdown-Item-Toggle" end
+		local exists = AceGUI:GetWidgetVersion(itemType)
+		if not exists then error(("The given item type, %q, does not exist within AceGUI-3.0"):format(tostring(itemType)), 2) end
+
+		local item = AceGUI:Create(itemType)
+		item:SetText(text)
+		item.userdata.obj = self
+		item.userdata.value = value
+		item:SetCallback("OnValueChanged", OnItemValueChanged)
+		self.pullout:AddItem(item)
+	end
+
+	local function AddCloseButton(self)
+		if not self.hasClose then
+			local close = AceGUI:Create("Dropdown-Item-Execute")
+			close:SetText(CLOSE)
+			self.pullout:AddItem(close)
+			self.hasClose = true
+		end
+	end
+
+	-- exported
+	local sortlist = {}
+	local function sortTbl(x,y)
+		local num1, num2 = tonumber(x), tonumber(y)
+		if num1 and num2 then -- numeric comparison, either two numbers or numeric strings
+			return num1 < num2
+		else -- compare everything else tostring'ed
+			return tostring(x) < tostring(y)
+		end
+	end
+	local function SetList(self, list, order, itemType)
+		self.list = list or {}
+		self.pullout:Clear()
+		self.hasClose = nil
+		if not list then return end
+
+		if type(order) ~= "table" then
+			for v in pairs(list) do
+				sortlist[#sortlist + 1] = v
+			end
+			tsort(sortlist, sortTbl)
+
+			for i, key in ipairs(sortlist) do
+				AddListItem(self, key, list[key], itemType)
+				sortlist[i] = nil
+			end
+		else
+			for i, key in ipairs(order) do
+				AddListItem(self, key, list[key], itemType)
+			end
+		end
+		if self.multiselect then
+			ShowMultiText(self)
+			AddCloseButton(self)
+		end
+	end
+
+	-- exported
+	local function AddItem(self, value, text, itemType)
+		self.list[value] = text
+		AddListItem(self, value, text, itemType)
+	end
+
+	-- exported
+	local function SetMultiselect(self, multi)
+		self.multiselect = multi
+		if multi then
+			ShowMultiText(self)
+			AddCloseButton(self)
+		end
+	end
+
+	-- exported
+	local function GetMultiselect(self)
+		return self.multiselect
+	end
+
+	local function SetPulloutWidth(self, width)
+		self.pulloutWidth = width
+	end
+
+	--[[ Constructor ]]--
+
+	local function Constructor()
+		local count = AceGUI:GetNextWidgetNum(widgetType)
+		local frame = CreateFrame("Frame", nil, UIParent)
+		local dropdown = CreateFrame("Frame", "AceGUI30DropDown"..count, frame, "UIDropDownMenuTemplate")
+
+		local self = {}
+		self.type = widgetType
+		self.frame = frame
+		self.dropdown = dropdown
+		self.count = count
+		frame.obj = self
+		dropdown.obj = self
+
+		self.OnRelease   = OnRelease
+		self.OnAcquire   = OnAcquire
+
+		self.ClearFocus  = ClearFocus
+
+		self.SetText     = SetText
+		self.SetValue    = SetValue
+		self.GetValue    = GetValue
+		self.SetList     = SetList
+		self.SetLabel    = SetLabel
+		self.SetDisabled = SetDisabled
+		self.AddItem     = AddItem
+		self.SetMultiselect = SetMultiselect
+		self.GetMultiselect = GetMultiselect
+		self.SetItemValue = SetItemValue
+		self.SetItemDisabled = SetItemDisabled
+		self.SetPulloutWidth = SetPulloutWidth
+
+		self.alignoffset = 26
+
+		frame:SetScript("OnHide",Dropdown_OnHide)
+
+		dropdown:ClearAllPoints()
+		dropdown:SetPoint("TOPLEFT",frame,"TOPLEFT",-15,0)
+		dropdown:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",17,0)
+		dropdown:SetScript("OnHide", nil)
+
+		local left = _G[dropdown:GetName() .. "Left"]
+		local middle = _G[dropdown:GetName() .. "Middle"]
+		local right = _G[dropdown:GetName() .. "Right"]
+
+		middle:ClearAllPoints()
+		right:ClearAllPoints()
+
+		middle:SetPoint("LEFT", left, "RIGHT", 0, 0)
+		middle:SetPoint("RIGHT", right, "LEFT", 0, 0)
+		right:SetPoint("TOPRIGHT", dropdown, "TOPRIGHT", 0, 17)
+
+		local button = _G[dropdown:GetName() .. "Button"]
+		self.button = button
+		button.obj = self
+		button:SetScript("OnEnter",Control_OnEnter)
+		button:SetScript("OnLeave",Control_OnLeave)
+		button:SetScript("OnClick",Dropdown_TogglePullout)
+
+		local button_cover = CreateFrame("BUTTON",nil,self.frame)
+		self.button_cover = button_cover
+		button_cover.obj = self
+		button_cover:SetPoint("TOPLEFT",self.frame,"BOTTOMLEFT",0,25)
+		button_cover:SetPoint("BOTTOMRIGHT",self.frame,"BOTTOMRIGHT")
+		button_cover:SetScript("OnEnter",Control_OnEnter)
+		button_cover:SetScript("OnLeave",Control_OnLeave)
+		button_cover:SetScript("OnClick",Dropdown_TogglePullout)
+
+		local text = _G[dropdown:GetName() .. "Text"]
+		self.text = text
+		text.obj = self
+		text:ClearAllPoints()
+		text:SetPoint("RIGHT", right, "RIGHT" ,-43, 2)
+		text:SetPoint("LEFT", left, "LEFT", 25, 2)
+
+		local label = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall")
+		label:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0)
+		label:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0)
+		label:SetJustifyH("LEFT")
+		label:SetHeight(18)
+		label:Hide()
+		self.label = label
+
+		AceGUI:RegisterAsWidget(self)
+		return self
+	end
+
+	AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
+end

Libs/AceGUI-3.0/widgets/AceGUIWidget-EditBox.lua

@@ -0,0 +1,267 @@
+--[[-----------------------------------------------------------------------------
+EditBox Widget
+-------------------------------------------------------------------------------]]
+local Type, Version = "EditBox", 29
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local tostring, pairs = tostring, pairs
+
+-- WoW APIs
+local PlaySound = PlaySound
+local GetCursorInfo, ClearCursor = GetCursorInfo, ClearCursor
+local CreateFrame, UIParent = CreateFrame, UIParent
+local _G = _G
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+if not AceGUIEditBoxInsertLink then
+	-- upgradeable hook
+	if ChatFrameUtil and ChatFrameUtil.InsertLink then
+		hooksecurefunc(ChatFrameUtil, "InsertLink", function(...) return _G.AceGUIEditBoxInsertLink(...) end)
+	elseif ChatEdit_InsertLink then
+		hooksecurefunc("ChatEdit_InsertLink", function(...) return _G.AceGUIEditBoxInsertLink(...) end)
+	end
+end
+
+function _G.AceGUIEditBoxInsertLink(text)
+	for i = 1, AceGUI:GetWidgetCount(Type) do
+		local editbox = _G["AceGUI-3.0EditBox"..i]
+		if editbox and editbox:IsVisible() and editbox:HasFocus() then
+			editbox:Insert(text)
+			return true
+		end
+	end
+end
+
+local function ShowButton(self)
+	if not self.disablebutton then
+		self.button:Show()
+		self.editbox:SetTextInsets(0, 20, 3, 3)
+	end
+end
+
+local function HideButton(self)
+	self.button:Hide()
+	self.editbox:SetTextInsets(0, 0, 3, 3)
+end
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Control_OnEnter(frame)
+	frame.obj:Fire("OnEnter")
+end
+
+local function Control_OnLeave(frame)
+	frame.obj:Fire("OnLeave")
+end
+
+local function Frame_OnShowFocus(frame)
+	frame.obj.editbox:SetFocus()
+	frame:SetScript("OnShow", nil)
+end
+
+local function EditBox_OnEscapePressed(frame)
+	AceGUI:ClearFocus()
+end
+
+local function EditBox_OnEnterPressed(frame)
+	local self = frame.obj
+	local value = frame:GetText()
+	local cancel = self:Fire("OnEnterPressed", value)
+	if not cancel then
+		PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
+		HideButton(self)
+	end
+end
+
+local function EditBox_OnReceiveDrag(frame)
+	local self = frame.obj
+	local type, id, info, extra = GetCursorInfo()
+	local name
+	if type == "item" then
+		name = info
+	elseif type == "spell" then
+		if C_Spell and C_Spell.GetSpellName then
+			name = C_Spell.GetSpellName(extra)
+		else
+			name = GetSpellInfo(id, info)
+		end
+	elseif type == "macro" then
+		name = GetMacroInfo(id)
+	end
+	if name then
+		self:SetText(name)
+		self:Fire("OnEnterPressed", name)
+		ClearCursor()
+		HideButton(self)
+		AceGUI:ClearFocus()
+	end
+end
+
+local function EditBox_OnTextChanged(frame)
+	local self = frame.obj
+	local value = frame:GetText()
+	if tostring(value) ~= tostring(self.lasttext) then
+		self:Fire("OnTextChanged", value)
+		self.lasttext = value
+		ShowButton(self)
+	end
+end
+
+local function EditBox_OnFocusGained(frame)
+	AceGUI:SetFocus(frame.obj)
+end
+
+local function Button_OnClick(frame)
+	local editbox = frame.obj.editbox
+	editbox:ClearFocus()
+	EditBox_OnEnterPressed(editbox)
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		-- height is controlled by SetLabel
+		self:SetWidth(200)
+		self:SetDisabled(false)
+		self:SetLabel()
+		self:SetText()
+		self:DisableButton(false)
+		self:SetMaxLetters(0)
+	end,
+
+	["OnRelease"] = function(self)
+		self:ClearFocus()
+	end,
+
+	["SetDisabled"] = function(self, disabled)
+		self.disabled = disabled
+		if disabled then
+			self.editbox:EnableMouse(false)
+			self.editbox:ClearFocus()
+			self.editbox:SetTextColor(0.5,0.5,0.5)
+			self.label:SetTextColor(0.5,0.5,0.5)
+		else
+			self.editbox:EnableMouse(true)
+			self.editbox:SetTextColor(1,1,1)
+			self.label:SetTextColor(1,.82,0)
+		end
+	end,
+
+	["SetText"] = function(self, text)
+		self.lasttext = text or ""
+		self.editbox:SetText(text or "")
+		self.editbox:SetCursorPosition(0)
+		HideButton(self)
+	end,
+
+	["GetText"] = function(self, text)
+		return self.editbox:GetText()
+	end,
+
+	["SetLabel"] = function(self, text)
+		if text and text ~= "" then
+			self.label:SetText(text)
+			self.label:Show()
+			self.editbox:SetPoint("TOPLEFT",self.frame,"TOPLEFT",7,-18)
+			self:SetHeight(44)
+			self.alignoffset = 30
+		else
+			self.label:SetText("")
+			self.label:Hide()
+			self.editbox:SetPoint("TOPLEFT",self.frame,"TOPLEFT",7,0)
+			self:SetHeight(26)
+			self.alignoffset = 12
+		end
+	end,
+
+	["DisableButton"] = function(self, disabled)
+		self.disablebutton = disabled
+		if disabled then
+			HideButton(self)
+		end
+	end,
+
+	["SetMaxLetters"] = function (self, num)
+		self.editbox:SetMaxLetters(num or 0)
+	end,
+
+	["ClearFocus"] = function(self)
+		self.editbox:ClearFocus()
+		self.frame:SetScript("OnShow", nil)
+	end,
+
+	["SetFocus"] = function(self)
+		self.editbox:SetFocus()
+		if not self.frame:IsShown() then
+			self.frame:SetScript("OnShow", Frame_OnShowFocus)
+		end
+	end,
+
+	["HighlightText"] = function(self, from, to)
+		self.editbox:HighlightText(from, to)
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local num  = AceGUI:GetNextWidgetNum(Type)
+	local frame = CreateFrame("Frame", nil, UIParent)
+	frame:Hide()
+
+	local editbox = CreateFrame("EditBox", "AceGUI-3.0EditBox"..num, frame, "InputBoxTemplate")
+	editbox:SetAutoFocus(false)
+	editbox:SetFontObject(ChatFontNormal)
+	editbox:SetScript("OnEnter", Control_OnEnter)
+	editbox:SetScript("OnLeave", Control_OnLeave)
+	editbox:SetScript("OnEscapePressed", EditBox_OnEscapePressed)
+	editbox:SetScript("OnEnterPressed", EditBox_OnEnterPressed)
+	editbox:SetScript("OnTextChanged", EditBox_OnTextChanged)
+	editbox:SetScript("OnReceiveDrag", EditBox_OnReceiveDrag)
+	editbox:SetScript("OnMouseDown", EditBox_OnReceiveDrag)
+	editbox:SetScript("OnEditFocusGained", EditBox_OnFocusGained)
+	editbox:SetTextInsets(0, 0, 3, 3)
+	editbox:SetMaxLetters(256)
+	editbox:SetPoint("BOTTOMLEFT", 6, 0)
+	editbox:SetPoint("BOTTOMRIGHT")
+	editbox:SetHeight(19)
+
+	local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
+	label:SetPoint("TOPLEFT", 0, -2)
+	label:SetPoint("TOPRIGHT", 0, -2)
+	label:SetJustifyH("LEFT")
+	label:SetHeight(18)
+
+	local button = CreateFrame("Button", nil, editbox, "UIPanelButtonTemplate")
+	button:SetWidth(40)
+	button:SetHeight(20)
+	button:SetPoint("RIGHT", -2, 0)
+	button:SetText(OKAY)
+	button:SetScript("OnClick", Button_OnClick)
+	button:Hide()
+
+	local widget = {
+		alignoffset = 30,
+		editbox     = editbox,
+		label       = label,
+		button      = button,
+		frame       = frame,
+		type        = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+	editbox.obj, button.obj = widget, widget
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-Heading.lua

@@ -0,0 +1,78 @@
+--[[-----------------------------------------------------------------------------
+Heading Widget
+-------------------------------------------------------------------------------]]
+local Type, Version = "Heading", 20
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs = pairs
+
+-- WoW APIs
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetText()
+		self:SetFullWidth()
+		self:SetHeight(18)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["SetText"] = function(self, text)
+		self.label:SetText(text or "")
+		if text and text ~= "" then
+			self.left:SetPoint("RIGHT", self.label, "LEFT", -5, 0)
+			self.right:Show()
+		else
+			self.left:SetPoint("RIGHT", -3, 0)
+			self.right:Hide()
+		end
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, UIParent)
+	frame:Hide()
+
+	local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontNormal")
+	label:SetPoint("TOP")
+	label:SetPoint("BOTTOM")
+	label:SetJustifyH("CENTER")
+
+	local left = frame:CreateTexture(nil, "BACKGROUND")
+	left:SetHeight(8)
+	left:SetPoint("LEFT", 3, 0)
+	left:SetPoint("RIGHT", label, "LEFT", -5, 0)
+	left:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
+	left:SetTexCoord(0.81, 0.94, 0.5, 1)
+
+	local right = frame:CreateTexture(nil, "BACKGROUND")
+	right:SetHeight(8)
+	right:SetPoint("RIGHT", -3, 0)
+	right:SetPoint("LEFT", label, "RIGHT", 5, 0)
+	right:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
+	right:SetTexCoord(0.81, 0.94, 0.5, 1)
+
+	local widget = {
+		label = label,
+		left  = left,
+		right = right,
+		frame = frame,
+		type  = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-Icon.lua

@@ -0,0 +1,140 @@
+--[[-----------------------------------------------------------------------------
+Icon Widget
+-------------------------------------------------------------------------------]]
+local Type, Version = "Icon", 21
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local select, pairs, print = select, pairs, print
+
+-- WoW APIs
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Control_OnEnter(frame)
+	frame.obj:Fire("OnEnter")
+end
+
+local function Control_OnLeave(frame)
+	frame.obj:Fire("OnLeave")
+end
+
+local function Button_OnClick(frame, button)
+	frame.obj:Fire("OnClick", button)
+	AceGUI:ClearFocus()
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetHeight(110)
+		self:SetWidth(110)
+		self:SetLabel()
+		self:SetImage(nil)
+		self:SetImageSize(64, 64)
+		self:SetDisabled(false)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["SetLabel"] = function(self, text)
+		if text and text ~= "" then
+			self.label:Show()
+			self.label:SetText(text)
+			self:SetHeight(self.image:GetHeight() + 25)
+		else
+			self.label:Hide()
+			self:SetHeight(self.image:GetHeight() + 10)
+		end
+	end,
+
+	["SetImage"] = function(self, path, ...)
+		local image = self.image
+		image:SetTexture(path)
+
+		if image:GetTexture() then
+			local n = select("#", ...)
+			if n == 4 or n == 8 then
+				image:SetTexCoord(...)
+			else
+				image:SetTexCoord(0, 1, 0, 1)
+			end
+		end
+	end,
+
+	["SetImageSize"] = function(self, width, height)
+		self.image:SetWidth(width)
+		self.image:SetHeight(height)
+		--self.frame:SetWidth(width + 30)
+		if self.label:IsShown() then
+			self:SetHeight(height + 25)
+		else
+			self:SetHeight(height + 10)
+		end
+	end,
+
+	["SetDisabled"] = function(self, disabled)
+		self.disabled = disabled
+		if disabled then
+			self.frame:Disable()
+			self.label:SetTextColor(0.5, 0.5, 0.5)
+			self.image:SetVertexColor(0.5, 0.5, 0.5, 0.5)
+		else
+			self.frame:Enable()
+			self.label:SetTextColor(1, 1, 1)
+			self.image:SetVertexColor(1, 1, 1, 1)
+		end
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local frame = CreateFrame("Button", nil, UIParent)
+	frame:Hide()
+
+	frame:EnableMouse(true)
+	frame:SetScript("OnEnter", Control_OnEnter)
+	frame:SetScript("OnLeave", Control_OnLeave)
+	frame:SetScript("OnClick", Button_OnClick)
+
+	local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlight")
+	label:SetPoint("BOTTOMLEFT")
+	label:SetPoint("BOTTOMRIGHT")
+	label:SetJustifyH("CENTER")
+	label:SetJustifyV("TOP")
+	label:SetHeight(18)
+
+	local image = frame:CreateTexture(nil, "BACKGROUND")
+	image:SetWidth(64)
+	image:SetHeight(64)
+	image:SetPoint("TOP", 0, -5)
+
+	local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
+	highlight:SetAllPoints(image)
+	highlight:SetTexture(136580) -- Interface\\PaperDollInfoFrame\\UI-Character-Tab-Highlight
+	highlight:SetTexCoord(0, 1, 0.23, 0.77)
+	highlight:SetBlendMode("ADD")
+
+	local widget = {
+		label = label,
+		image = image,
+		frame = frame,
+		type  = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	widget.SetText = function(self, ...) print("AceGUI-3.0-Icon: SetText is deprecated! Use SetLabel instead!"); self:SetLabel(...) end
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-InteractiveLabel.lua

@@ -0,0 +1,94 @@
+--[[-----------------------------------------------------------------------------
+InteractiveLabel Widget
+-------------------------------------------------------------------------------]]
+local Type, Version = "InteractiveLabel", 21
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local select, pairs = select, pairs
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Control_OnEnter(frame)
+	frame.obj:Fire("OnEnter")
+end
+
+local function Control_OnLeave(frame)
+	frame.obj:Fire("OnLeave")
+end
+
+local function Label_OnClick(frame, button)
+	frame.obj:Fire("OnClick", button)
+	AceGUI:ClearFocus()
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:LabelOnAcquire()
+		self:SetHighlight()
+		self:SetHighlightTexCoord()
+		self:SetDisabled(false)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["SetHighlight"] = function(self, ...)
+		self.highlight:SetTexture(...)
+	end,
+
+	["SetHighlightTexCoord"] = function(self, ...)
+		local c = select("#", ...)
+		if c == 4 or c == 8 then
+			self.highlight:SetTexCoord(...)
+		else
+			self.highlight:SetTexCoord(0, 1, 0, 1)
+		end
+	end,
+
+	["SetDisabled"] = function(self,disabled)
+		self.disabled = disabled
+		if disabled then
+			self.frame:EnableMouse(false)
+			self.label:SetTextColor(0.5, 0.5, 0.5)
+		else
+			self.frame:EnableMouse(true)
+			self.label:SetTextColor(1, 1, 1)
+		end
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	-- create a Label type that we will hijack
+	local label = AceGUI:Create("Label")
+
+	local frame = label.frame
+	frame:EnableMouse(true)
+	frame:SetScript("OnEnter", Control_OnEnter)
+	frame:SetScript("OnLeave", Control_OnLeave)
+	frame:SetScript("OnMouseDown", Label_OnClick)
+
+	local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
+	highlight:SetTexture(nil)
+	highlight:SetAllPoints()
+	highlight:SetBlendMode("ADD")
+
+	label.highlight = highlight
+	label.type = Type
+	label.LabelOnAcquire = label.OnAcquire
+	for method, func in pairs(methods) do
+		label[method] = func
+	end
+
+	return label
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)
+

Libs/AceGUI-3.0/widgets/AceGUIWidget-Keybinding.lua

@@ -0,0 +1,251 @@
+--[[-----------------------------------------------------------------------------
+Keybinding Widget
+Set Keybindings in the Config UI.
+-------------------------------------------------------------------------------]]
+local Type, Version = "Keybinding", 27
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs = pairs
+
+-- WoW APIs
+local IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown = IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+
+local function Control_OnEnter(frame)
+	frame.obj:Fire("OnEnter")
+end
+
+local function Control_OnLeave(frame)
+	frame.obj:Fire("OnLeave")
+end
+
+local function Keybinding_OnClick(frame, button)
+	if button == "LeftButton" or button == "RightButton" then
+		local self = frame.obj
+		if self.waitingForKey then
+			frame:EnableKeyboard(false)
+			frame:EnableMouseWheel(false)
+			frame:EnableGamePadButton(false)
+			self.msgframe:Hide()
+			frame:UnlockHighlight()
+			self.waitingForKey = nil
+		else
+			frame:EnableKeyboard(true)
+			frame:EnableMouseWheel(true)
+			frame:EnableGamePadButton(true)
+			self.msgframe:Show()
+			frame:LockHighlight()
+			self.waitingForKey = true
+		end
+	end
+	AceGUI:ClearFocus()
+end
+
+local ignoreKeys = {
+	["BUTTON1"] = true, ["BUTTON2"] = true,
+	["UNKNOWN"] = true,
+	["LSHIFT"] = true, ["LCTRL"] = true, ["LALT"] = true,
+	["RSHIFT"] = true, ["RCTRL"] = true, ["RALT"] = true,
+}
+local function Keybinding_OnKeyDown(frame, key)
+	local self = frame.obj
+	if self.waitingForKey then
+		local keyPressed = key
+		if keyPressed == "ESCAPE" then
+			keyPressed = ""
+		else
+			if ignoreKeys[keyPressed] then return end
+			if IsShiftKeyDown() then
+				keyPressed = "SHIFT-"..keyPressed
+			end
+			if IsControlKeyDown() then
+				keyPressed = "CTRL-"..keyPressed
+			end
+			if IsAltKeyDown() then
+				keyPressed = "ALT-"..keyPressed
+			end
+		end
+
+		frame:EnableKeyboard(false)
+		frame:EnableMouseWheel(false)
+		frame:EnableGamePadButton(false)
+		self.msgframe:Hide()
+		frame:UnlockHighlight()
+		self.waitingForKey = nil
+
+		if not self.disabled then
+			self:SetKey(keyPressed)
+			self:Fire("OnKeyChanged", keyPressed)
+		end
+	end
+end
+
+local function Keybinding_OnMouseDown(frame, button)
+	if button == "LeftButton" or button == "RightButton" then
+		return
+	elseif button == "MiddleButton" then
+		button = "BUTTON3"
+	elseif button == "Button4" then
+		button = "BUTTON4"
+	elseif button == "Button5" then
+		button = "BUTTON5"
+	end
+	Keybinding_OnKeyDown(frame, button)
+end
+
+local function Keybinding_OnMouseWheel(frame, direction)
+	local button
+	if direction >= 0 then
+		button = "MOUSEWHEELUP"
+	else
+		button = "MOUSEWHEELDOWN"
+	end
+	Keybinding_OnKeyDown(frame, button)
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetWidth(200)
+		self:SetLabel("")
+		self:SetKey("")
+		self.waitingForKey = nil
+		self.msgframe:Hide()
+		self:SetDisabled(false)
+		self.button:EnableKeyboard(false)
+		self.button:EnableMouseWheel(false)
+		self.button:EnableGamePadButton(false)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["SetDisabled"] = function(self, disabled)
+		self.disabled = disabled
+		if disabled then
+			self.button:Disable()
+			self.label:SetTextColor(0.5,0.5,0.5)
+		else
+			self.button:Enable()
+			self.label:SetTextColor(1,1,1)
+		end
+	end,
+
+	["SetKey"] = function(self, key)
+		if (key or "") == "" then
+			self.button:SetText(NOT_BOUND)
+			self.button:SetNormalFontObject("GameFontNormal")
+		else
+			self.button:SetText(key)
+			self.button:SetNormalFontObject("GameFontHighlight")
+		end
+	end,
+
+	["GetKey"] = function(self)
+		local key = self.button:GetText()
+		if key == NOT_BOUND then
+			key = nil
+		end
+		return key
+	end,
+
+	["SetLabel"] = function(self, label)
+		self.label:SetText(label or "")
+		if (label or "") == "" then
+			self.alignoffset = nil
+			self:SetHeight(24)
+		else
+			self.alignoffset = 30
+			self:SetHeight(44)
+		end
+	end,
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+
+local ControlBackdrop  = {
+	bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
+	edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
+	tile = true, tileSize = 16, edgeSize = 16,
+	insets = { left = 3, right = 3, top = 3, bottom = 3 }
+}
+
+local function keybindingMsgFixWidth(frame)
+	frame:SetWidth(frame.msg:GetWidth() + 10)
+	frame:SetScript("OnUpdate", nil)
+end
+
+local function Constructor()
+	local name = "AceGUI30KeybindingButton" .. AceGUI:GetNextWidgetNum(Type)
+
+	local frame = CreateFrame("Frame", nil, UIParent)
+	local button = CreateFrame("Button", name, frame, "UIPanelButtonTemplate")
+
+	button:EnableMouse(true)
+	button:EnableMouseWheel(false)
+	button:RegisterForClicks("AnyDown")
+	button:SetScript("OnEnter", Control_OnEnter)
+	button:SetScript("OnLeave", Control_OnLeave)
+	button:SetScript("OnClick", Keybinding_OnClick)
+	button:SetScript("OnKeyDown", Keybinding_OnKeyDown)
+	button:SetScript("OnMouseDown", Keybinding_OnMouseDown)
+	button:SetScript("OnMouseWheel", Keybinding_OnMouseWheel)
+	button:SetScript("OnGamePadButtonDown", Keybinding_OnKeyDown)
+	button:SetPoint("BOTTOMLEFT")
+	button:SetPoint("BOTTOMRIGHT")
+	button:SetHeight(24)
+	button:EnableKeyboard(false)
+	button:EnableGamePadButton(false)
+
+	local text = button:GetFontString()
+	text:SetPoint("LEFT", 7, 0)
+	text:SetPoint("RIGHT", -7, 0)
+
+	local label = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
+	label:SetPoint("TOPLEFT")
+	label:SetPoint("TOPRIGHT")
+	label:SetJustifyH("CENTER")
+	label:SetHeight(18)
+
+	local msgframe = CreateFrame("Frame", nil, UIParent, "BackdropTemplate")
+	msgframe:SetHeight(30)
+	msgframe:SetBackdrop(ControlBackdrop)
+	msgframe:SetBackdropColor(0,0,0)
+	msgframe:SetFrameStrata("FULLSCREEN_DIALOG")
+	msgframe:SetFrameLevel(1000)
+	msgframe:SetToplevel(true)
+
+	local msg = msgframe:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+	msg:SetText("Press a key to bind, ESC to clear the binding or click the button again to cancel.")
+	msgframe.msg = msg
+	msg:SetPoint("TOPLEFT", 5, -5)
+	msgframe:SetScript("OnUpdate", keybindingMsgFixWidth)
+	msgframe:SetPoint("BOTTOM", button, "TOP")
+	msgframe:Hide()
+
+	local widget = {
+		button      = button,
+		label       = label,
+		msgframe    = msgframe,
+		frame       = frame,
+		alignoffset = 30,
+		type        = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+	button.obj = widget
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-Label.lua

@@ -0,0 +1,179 @@
+--[[-----------------------------------------------------------------------------
+Label Widget
+Displays text and optionally an icon.
+-------------------------------------------------------------------------------]]
+local Type, Version = "Label", 28
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local max, select, pairs = math.max, select, pairs
+
+-- WoW APIs
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+
+local function UpdateImageAnchor(self)
+	if self.resizing then return end
+	local frame = self.frame
+	local width = frame.width or frame:GetWidth() or 0
+	local image = self.image
+	local label = self.label
+	local height
+
+	label:ClearAllPoints()
+	image:ClearAllPoints()
+
+	if self.imageshown then
+		local imagewidth = image:GetWidth()
+		if (width - imagewidth) < 200 or (label:GetText() or "") == "" then
+			-- image goes on top centered when less than 200 width for the text, or if there is no text
+			image:SetPoint("TOP")
+			label:SetPoint("TOP", image, "BOTTOM")
+			label:SetPoint("LEFT")
+			label:SetWidth(width)
+			height = image:GetHeight() + label:GetStringHeight()
+		else
+			-- image on the left
+			image:SetPoint("TOPLEFT")
+			if image:GetHeight() > label:GetStringHeight() then
+				label:SetPoint("LEFT", image, "RIGHT", 4, 0)
+			else
+				label:SetPoint("TOPLEFT", image, "TOPRIGHT", 4, 0)
+			end
+			label:SetWidth(width - imagewidth - 4)
+			height = max(image:GetHeight(), label:GetStringHeight())
+		end
+	else
+		-- no image shown
+		label:SetPoint("TOPLEFT")
+		label:SetWidth(width)
+		height = label:GetStringHeight()
+	end
+
+	-- avoid zero-height labels, since they can used as spacers
+	if not height or height == 0 then
+		height = 1
+	end
+
+	self.resizing = true
+	frame:SetHeight(height)
+	frame.height = height
+	self.resizing = nil
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		-- set the flag to stop constant size updates
+		self.resizing = true
+		-- height is set dynamically by the text and image size
+		self:SetWidth(200)
+		self:SetText()
+		self:SetImage(nil)
+		self:SetImageSize(16, 16)
+		self:SetColor()
+		self:SetFontObject()
+		self:SetJustifyH("LEFT")
+		self:SetJustifyV("TOP")
+
+		-- reset the flag
+		self.resizing = nil
+		-- run the update explicitly
+		UpdateImageAnchor(self)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["OnWidthSet"] = function(self, width)
+		UpdateImageAnchor(self)
+	end,
+
+	["SetText"] = function(self, text)
+		self.label:SetText(text)
+		UpdateImageAnchor(self)
+	end,
+
+	["SetColor"] = function(self, r, g, b)
+		if not (r and g and b) then
+			r, g, b = 1, 1, 1
+		end
+		self.label:SetVertexColor(r, g, b)
+	end,
+
+	["SetImage"] = function(self, path, ...)
+		local image = self.image
+		image:SetTexture(path)
+
+		if image:GetTexture() then
+			self.imageshown = true
+			local n = select("#", ...)
+			if n == 4 or n == 8 then
+				image:SetTexCoord(...)
+			else
+				image:SetTexCoord(0, 1, 0, 1)
+			end
+		else
+			self.imageshown = nil
+		end
+		UpdateImageAnchor(self)
+	end,
+
+	["SetFont"] = function(self, font, height, flags)
+		if not self.fontObject then
+			self.fontObject = CreateFont("AceGUI30LabelFont" .. AceGUI:GetNextWidgetNum(Type))
+		end
+		self.fontObject:SetFont(font, height, flags)
+		self:SetFontObject(self.fontObject)
+	end,
+
+	["SetFontObject"] = function(self, font)
+		self.label:SetFontObject(font or GameFontHighlightSmall)
+		UpdateImageAnchor(self)
+	end,
+
+	["SetImageSize"] = function(self, width, height)
+		self.image:SetWidth(width)
+		self.image:SetHeight(height)
+		UpdateImageAnchor(self)
+	end,
+
+	["SetJustifyH"] = function(self, justifyH)
+		self.label:SetJustifyH(justifyH)
+	end,
+
+	["SetJustifyV"] = function(self, justifyV)
+		self.label:SetJustifyV(justifyV)
+	end,
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, UIParent)
+	frame:Hide()
+
+	local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlightSmall")
+	local image = frame:CreateTexture(nil, "BACKGROUND")
+
+	-- create widget
+	local widget = {
+		label = label,
+		image = image,
+		frame = frame,
+		type  = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-MultiLineEditBox.lua

@@ -0,0 +1,377 @@
+local Type, Version = "MultiLineEditBox", 33
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local pairs = pairs
+
+-- WoW APIs
+local GetCursorInfo, ClearCursor = GetCursorInfo, ClearCursor
+local CreateFrame, UIParent = CreateFrame, UIParent
+local _G = _G
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+
+if not AceGUIMultiLineEditBoxInsertLink then
+	-- upgradeable hook
+	if ChatFrameUtil and ChatFrameUtil.InsertLink then
+		hooksecurefunc(ChatFrameUtil, "InsertLink", function(...) return _G.AceGUIMultiLineEditBoxInsertLink(...) end)
+	elseif ChatEdit_InsertLink then
+		hooksecurefunc("ChatEdit_InsertLink", function(...) return _G.AceGUIMultiLineEditBoxInsertLink(...) end)
+	end
+end
+
+function _G.AceGUIMultiLineEditBoxInsertLink(text)
+	for i = 1, AceGUI:GetWidgetCount(Type) do
+		local editbox = _G[("MultiLineEditBox%uEdit"):format(i)]
+		if editbox and editbox:IsVisible() and editbox:HasFocus() then
+			editbox:Insert(text)
+			return true
+		end
+	end
+end
+
+
+local function Layout(self)
+	self:SetHeight(self.numlines * 14 + (self.disablebutton and 19 or 41) + self.labelHeight)
+
+	if self.labelHeight == 0 then
+		self.scrollBar:SetPoint("TOP", self.frame, "TOP", 0, -23)
+	else
+		self.scrollBar:SetPoint("TOP", self.label, "BOTTOM", 0, -19)
+	end
+
+	if self.disablebutton then
+		self.scrollBar:SetPoint("BOTTOM", self.frame, "BOTTOM", 0, 21)
+		self.scrollBG:SetPoint("BOTTOMLEFT", 0, 4)
+	else
+		self.scrollBar:SetPoint("BOTTOM", self.button, "TOP", 0, 18)
+		self.scrollBG:SetPoint("BOTTOMLEFT", self.button, "TOPLEFT")
+	end
+end
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function OnClick(self)                                                     -- Button
+	self = self.obj
+	self.editBox:ClearFocus()
+	if not self:Fire("OnEnterPressed", self.editBox:GetText()) then
+		self.button:Disable()
+	end
+end
+
+local function OnCursorChanged(self, _, y, _, cursorHeight)                      -- EditBox
+	self, y = self.obj.scrollFrame, -y
+	local offset = self:GetVerticalScroll()
+	if y < offset then
+		self:SetVerticalScroll(y)
+	else
+		y = y + cursorHeight - self:GetHeight()
+		if y > offset then
+			self:SetVerticalScroll(y)
+		end
+	end
+end
+
+local function OnEditFocusLost(self)                                             -- EditBox
+	self:HighlightText(0, 0)
+	self.obj:Fire("OnEditFocusLost")
+end
+
+local function OnEnter(self)                                                     -- EditBox / ScrollFrame
+	self = self.obj
+	if not self.entered then
+		self.entered = true
+		self:Fire("OnEnter")
+	end
+end
+
+local function OnLeave(self)                                                     -- EditBox / ScrollFrame
+	self = self.obj
+	if self.entered then
+		self.entered = nil
+		self:Fire("OnLeave")
+	end
+end
+
+local function OnMouseUp(self)                                                   -- ScrollFrame
+	self = self.obj.editBox
+	self:SetFocus()
+	self:SetCursorPosition(self:GetNumLetters())
+end
+
+local function OnReceiveDrag(self)                                               -- EditBox / ScrollFrame
+	local type, id, info, extra = GetCursorInfo()
+	if type == "spell" then
+		if C_Spell and C_Spell.GetSpellName then
+			info = C_Spell.GetSpellName(extra)
+		else
+			info = GetSpellInfo(id, info)
+		end
+	elseif type ~= "item" then
+		return
+	end
+	ClearCursor()
+	self = self.obj
+	local editBox = self.editBox
+	if not editBox:HasFocus() then
+		editBox:SetFocus()
+		editBox:SetCursorPosition(editBox:GetNumLetters())
+	end
+	editBox:Insert(info)
+	self.button:Enable()
+end
+
+local function OnSizeChanged(self, width, height)                                -- ScrollFrame
+	self.obj.editBox:SetWidth(width)
+end
+
+local function OnTextChanged(self, userInput)                                    -- EditBox
+	if userInput then
+		self = self.obj
+		self:Fire("OnTextChanged", self.editBox:GetText())
+		self.button:Enable()
+	end
+end
+
+local function OnTextSet(self)                                                   -- EditBox
+	self:HighlightText(0, 0)
+	self:SetCursorPosition(self:GetNumLetters())
+	self:SetCursorPosition(0)
+	self.obj.button:Disable()
+end
+
+local function OnVerticalScroll(self, offset)                                    -- ScrollFrame
+	local editBox = self.obj.editBox
+	editBox:SetHitRectInsets(0, 0, offset, editBox:GetHeight() - offset - self:GetHeight())
+end
+
+local function OnScrollRangeChanged(self, xrange, yrange)
+	if yrange == 0 then
+		self.obj.editBox:SetHitRectInsets(0, 0, 0, 0)
+	else
+		OnVerticalScroll(self, self:GetVerticalScroll())
+	end
+end
+
+local function OnShowFocus(frame)
+	frame.obj.editBox:SetFocus()
+	frame:SetScript("OnShow", nil)
+end
+
+local function OnEditFocusGained(frame)
+	AceGUI:SetFocus(frame.obj)
+	frame.obj:Fire("OnEditFocusGained")
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self.editBox:SetText("")
+		self:SetDisabled(false)
+		self:SetWidth(200)
+		self:DisableButton(false)
+		self:SetNumLines()
+		self.entered = nil
+		self:SetMaxLetters(0)
+	end,
+
+	["OnRelease"] = function(self)
+		self:ClearFocus()
+	end,
+
+	["SetDisabled"] = function(self, disabled)
+		local editBox = self.editBox
+		if disabled then
+			editBox:ClearFocus()
+			editBox:EnableMouse(false)
+			editBox:SetTextColor(0.5, 0.5, 0.5)
+			self.label:SetTextColor(0.5, 0.5, 0.5)
+			self.scrollFrame:EnableMouse(false)
+			self.button:Disable()
+		else
+			editBox:EnableMouse(true)
+			editBox:SetTextColor(1, 1, 1)
+			self.label:SetTextColor(1, 0.82, 0)
+			self.scrollFrame:EnableMouse(true)
+		end
+	end,
+
+	["SetLabel"] = function(self, text)
+		if text and text ~= "" then
+			self.label:SetText(text)
+			if self.labelHeight ~= 10 then
+				self.labelHeight = 10
+				self.label:Show()
+			end
+		elseif self.labelHeight ~= 0 then
+			self.labelHeight = 0
+			self.label:Hide()
+		end
+		Layout(self)
+	end,
+
+	["SetNumLines"] = function(self, value)
+		if not value or value < 4 then
+			value = 4
+		end
+		self.numlines = value
+		Layout(self)
+	end,
+
+	["SetText"] = function(self, text)
+		self.editBox:SetText(text)
+	end,
+
+	["GetText"] = function(self)
+		return self.editBox:GetText()
+	end,
+
+	["SetMaxLetters"] = function (self, num)
+		self.editBox:SetMaxLetters(num or 0)
+	end,
+
+	["DisableButton"] = function(self, disabled)
+		self.disablebutton = disabled
+		if disabled then
+			self.button:Hide()
+		else
+			self.button:Show()
+		end
+		Layout(self)
+	end,
+
+	["ClearFocus"] = function(self)
+		self.editBox:ClearFocus()
+		self.frame:SetScript("OnShow", nil)
+	end,
+
+	["SetFocus"] = function(self)
+		self.editBox:SetFocus()
+		if not self.frame:IsShown() then
+			self.frame:SetScript("OnShow", OnShowFocus)
+		end
+	end,
+
+	["HighlightText"] = function(self, from, to)
+		self.editBox:HighlightText(from, to)
+	end,
+
+	["GetCursorPosition"] = function(self)
+		return self.editBox:GetCursorPosition()
+	end,
+
+	["SetCursorPosition"] = function(self, ...)
+		return self.editBox:SetCursorPosition(...)
+	end,
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local backdrop = {
+	bgFile = [[Interface\Tooltips\UI-Tooltip-Background]],
+	edgeFile = [[Interface\Tooltips\UI-Tooltip-Border]], edgeSize = 16,
+	insets = { left = 4, right = 3, top = 4, bottom = 3 }
+}
+
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, UIParent)
+	frame:Hide()
+
+	local widgetNum = AceGUI:GetNextWidgetNum(Type)
+
+	local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
+	label:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, -4)
+	label:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, -4)
+	label:SetJustifyH("LEFT")
+	label:SetText(ACCEPT)
+	label:SetHeight(10)
+
+	local button = CreateFrame("Button", ("%s%dButton"):format(Type, widgetNum), frame, "UIPanelButtonTemplate")
+	button:SetPoint("BOTTOMLEFT", 0, 4)
+	button:SetHeight(22)
+	button:SetWidth(label:GetStringWidth() + 24)
+	button:SetText(ACCEPT)
+	button:SetScript("OnClick", OnClick)
+	button:Disable()
+
+	local text = button:GetFontString()
+	text:ClearAllPoints()
+	text:SetPoint("TOPLEFT", button, "TOPLEFT", 5, -5)
+	text:SetPoint("BOTTOMRIGHT", button, "BOTTOMRIGHT", -5, 1)
+	text:SetJustifyV("MIDDLE")
+
+	local scrollBG = CreateFrame("Frame", nil, frame, "BackdropTemplate")
+	scrollBG:SetBackdrop(backdrop)
+	scrollBG:SetBackdropColor(0, 0, 0)
+	scrollBG:SetBackdropBorderColor(0.4, 0.4, 0.4)
+
+	local scrollFrame = CreateFrame("ScrollFrame", ("%s%dScrollFrame"):format(Type, widgetNum), frame, "UIPanelScrollFrameTemplate")
+
+	local scrollBar = _G[scrollFrame:GetName() .. "ScrollBar"]
+	scrollBar:ClearAllPoints()
+	scrollBar:SetPoint("TOP", label, "BOTTOM", 0, -19)
+	scrollBar:SetPoint("BOTTOM", button, "TOP", 0, 18)
+	scrollBar:SetPoint("RIGHT", frame, "RIGHT")
+
+	scrollBG:SetPoint("TOPRIGHT", scrollBar, "TOPLEFT", 0, 19)
+	scrollBG:SetPoint("BOTTOMLEFT", button, "TOPLEFT")
+
+	scrollFrame:SetPoint("TOPLEFT", scrollBG, "TOPLEFT", 5, -6)
+	scrollFrame:SetPoint("BOTTOMRIGHT", scrollBG, "BOTTOMRIGHT", -4, 4)
+	scrollFrame:SetScript("OnEnter", OnEnter)
+	scrollFrame:SetScript("OnLeave", OnLeave)
+	scrollFrame:SetScript("OnMouseUp", OnMouseUp)
+	scrollFrame:SetScript("OnReceiveDrag", OnReceiveDrag)
+	scrollFrame:SetScript("OnSizeChanged", OnSizeChanged)
+	scrollFrame:HookScript("OnVerticalScroll", OnVerticalScroll)
+	scrollFrame:HookScript("OnScrollRangeChanged", OnScrollRangeChanged)
+
+	local editBox = CreateFrame("EditBox", ("%s%dEdit"):format(Type, widgetNum), scrollFrame)
+	editBox:SetAllPoints()
+	editBox:SetFontObject(ChatFontNormal)
+	editBox:SetMultiLine(true)
+	editBox:EnableMouse(true)
+	editBox:SetAutoFocus(false)
+	editBox:SetCountInvisibleLetters(false)
+	editBox:SetScript("OnCursorChanged", OnCursorChanged)
+	editBox:SetScript("OnEditFocusLost", OnEditFocusLost)
+	editBox:SetScript("OnEnter", OnEnter)
+	editBox:SetScript("OnEscapePressed", editBox.ClearFocus)
+	editBox:SetScript("OnLeave", OnLeave)
+	editBox:SetScript("OnMouseDown", OnReceiveDrag)
+	editBox:SetScript("OnReceiveDrag", OnReceiveDrag)
+	editBox:SetScript("OnTextChanged", OnTextChanged)
+	editBox:SetScript("OnTextSet", OnTextSet)
+	editBox:SetScript("OnEditFocusGained", OnEditFocusGained)
+
+
+	scrollFrame:SetScrollChild(editBox)
+
+	local widget = {
+		button      = button,
+		editBox     = editBox,
+		frame       = frame,
+		label       = label,
+		labelHeight = 10,
+		numlines    = 4,
+		scrollBar   = scrollBar,
+		scrollBG    = scrollBG,
+		scrollFrame = scrollFrame,
+		type        = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+	button.obj, editBox.obj, scrollFrame.obj = widget, widget, widget
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type, Constructor, Version)

Libs/AceGUI-3.0/widgets/AceGUIWidget-Slider.lua

@@ -0,0 +1,280 @@
+--[[-----------------------------------------------------------------------------
+Slider Widget
+Graphical Slider, like, for Range values.
+-------------------------------------------------------------------------------]]
+local Type, Version = "Slider", 23
+local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
+if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
+
+-- Lua APIs
+local min, max, floor = math.min, math.max, math.floor
+local tonumber, pairs = tonumber, pairs
+
+-- WoW APIs
+local PlaySound = PlaySound
+local CreateFrame, UIParent = CreateFrame, UIParent
+
+--[[-----------------------------------------------------------------------------
+Support functions
+-------------------------------------------------------------------------------]]
+local function UpdateText(self)
+	local value = self.value or 0
+	if self.ispercent then
+		self.editbox:SetText(("%s%%"):format(floor(value * 1000 + 0.5) / 10))
+	else
+		self.editbox:SetText(floor(value * 100 + 0.5) / 100)
+	end
+end
+
+local function UpdateLabels(self)
+	local min_value, max_value = (self.min or 0), (self.max or 100)
+	if self.ispercent then
+		self.lowtext:SetFormattedText("%s%%", (min_value * 100))
+		self.hightext:SetFormattedText("%s%%", (max_value * 100))
+	else
+		self.lowtext:SetText(min_value)
+		self.hightext:SetText(max_value)
+	end
+end
+
+--[[-----------------------------------------------------------------------------
+Scripts
+-------------------------------------------------------------------------------]]
+local function Control_OnEnter(frame)
+	frame.obj:Fire("OnEnter")
+end
+
+local function Control_OnLeave(frame)
+	frame.obj:Fire("OnLeave")
+end
+
+local function Frame_OnMouseDown(frame)
+	frame.obj.slider:EnableMouseWheel(true)
+	AceGUI:ClearFocus()
+end
+
+local function Slider_OnValueChanged(frame, newvalue)
+	local self = frame.obj
+	if not frame.setup then
+		if self.step and self.step > 0 then
+			local min_value = self.min or 0
+			newvalue = floor((newvalue - min_value) / self.step + 0.5) * self.step + min_value
+		end
+		if newvalue ~= self.value and not self.disabled then
+			self.value = newvalue
+			self:Fire("OnValueChanged", newvalue)
+		end
+		if self.value then
+			UpdateText(self)
+		end
+	end
+end
+
+local function Slider_OnMouseUp(frame)
+	local self = frame.obj
+	self:Fire("OnMouseUp", self.value)
+end
+
+local function Slider_OnMouseWheel(frame, v)
+	local self = frame.obj
+	if not self.disabled then
+		local value = self.value
+		if v > 0 then
+			value = min(value + (self.step or 1), self.max)
+		else
+			value = max(value - (self.step or 1), self.min)
+		end
+		self.slider:SetValue(value)
+	end
+end
+
+local function EditBox_OnEscapePressed(frame)
+	frame:ClearFocus()
+end
+
+local function EditBox_OnEnterPressed(frame)
+	local self = frame.obj
+	local value = frame:GetText()
+	if self.ispercent then
+		value = value:gsub('%%', '')
+		value = tonumber(value) / 100
+	else
+		value = tonumber(value)
+	end
+
+	if value then
+		PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
+		self.slider:SetValue(value)
+		self:Fire("OnMouseUp", value)
+	end
+end
+
+local function EditBox_OnEnter(frame)
+	frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
+end
+
+local function EditBox_OnLeave(frame)
+	frame:SetBackdropBorderColor(0.3, 0.3, 0.3, 0.8)
+end
+
+--[[-----------------------------------------------------------------------------
+Methods
+-------------------------------------------------------------------------------]]
+local methods = {
+	["OnAcquire"] = function(self)
+		self:SetWidth(200)
+		self:SetHeight(44)
+		self:SetDisabled(false)
+		self:SetIsPercent(nil)
+		self:SetSliderValues(0,100,1)
+		self:SetValue(0)
+		self.slider:EnableMouseWheel(false)
+	end,
+
+	-- ["OnRelease"] = nil,
+
+	["SetDisabled"] = function(self, disabled)
+		self.disabled = disabled
+		if disabled then
+			self.slider:EnableMouse(false)
+			self.label:SetTextColor(.5, .5, .5)
+			self.hightext:SetTextColor(.5, .5, .5)
+			self.lowtext:SetTextColor(.5, .5, .5)
+			--self.valuetext:SetTextColor(.5, .5, .5)
+			self.editbox:SetTextColor(.5, .5, .5)
+			self.editbox:EnableMouse(false)
+			self.editbox:ClearFocus()
+		else
+			self.slider:EnableMouse(true)
+			self.label:SetTextColor(1, .82, 0)
+			self.hightext:SetTextColor(1, 1, 1)
+			self.lowtext:SetTextColor(1, 1, 1)
+			--self.valuetext:SetTextColor(1, 1, 1)
+			self.editbox:SetTextColor(1, 1, 1)
+			self.editbox:EnableMouse(true)
+		end
+	end,
+
+	["SetValue"] = function(self, value)
+		self.slider.setup = true
+		self.slider:SetValue(value)
+		self.value = value
+		UpdateText(self)
+		self.slider.setup = nil
+	end,
+
+	["GetValue"] = function(self)
+		return self.value
+	end,
+
+	["SetLabel"] = function(self, text)
+		self.label:SetText(text)
+	end,
+
+	["SetSliderValues"] = function(self, min_value, max_value, step)
+		local frame = self.slider
+		frame.setup = true
+		self.min = min_value
+		self.max = max_value
+		self.step = step
+		frame:SetMinMaxValues(min_value or 0,max_value or 100)
+		UpdateLabels(self)
+		frame:SetValueStep(step or 1)
+		if self.value then
+			frame:SetValue(self.value)
+		end
+		frame.setup = nil
+	end,
+
+	["SetIsPercent"] = function(self, value)
+		self.ispercent = value
+		UpdateLabels(self)
+		UpdateText(self)
+	end
+}
+
+--[[-----------------------------------------------------------------------------
+Constructor
+-------------------------------------------------------------------------------]]
+local SliderBackdrop  = {
+	bgFile = "Interface\\Buttons\\UI-SliderBar-Background",
+	edgeFile = "Interface\\Buttons\\UI-SliderBar-Border",
+	tile = true, tileSize = 8, edgeSize = 8,
+	insets = { left = 3, right = 3, top = 6, bottom = 6 }
+}
+
+local ManualBackdrop = {
+	bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
+	edgeFile = "Interface\\ChatFrame\\ChatFrameBackground",
+	tile = true, edgeSize = 1, tileSize = 5,
+}
+
+local function Constructor()
+	local frame = CreateFrame("Frame", nil, UIParent)
+
+	frame:EnableMouse(true)
+	frame:SetScript("OnMouseDown", Frame_OnMouseDown)
+
+	local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
+	label:SetPoint("TOPLEFT")
+	label:SetPoint("TOPRIGHT")
+	label:SetJustifyH("CENTER")
+	label:SetHeight(15)
+
+	local slider = CreateFrame("Slider", nil, frame, "BackdropTemplate")
+	slider:SetOrientation("HORIZONTAL")
+	slider:SetHeight(15)
+	slider:SetHitRectInsets(0, 0, -10, 0)
+	slider:SetBackdrop(SliderBackdrop)
+	slider:SetThumbTexture("Interface\\Buttons\\UI-SliderBar-Button-Horizontal")
+	slider:SetPoint("TOP", label, "BOTTOM")
+	slider:SetPoint("LEFT", 3, 0)
+	slider:SetPoint("RIGHT", -3, 0)
+	slider:SetValue(0)
+	slider:SetScript("OnValueChanged",Slider_OnValueChanged)
+	slider:SetScript("OnEnter", Control_OnEnter)
+	slider:SetScript("OnLeave", Control_OnLeave)
+	slider:SetScript("OnMouseUp", Slider_OnMouseUp)
+	slider:SetScript("OnMouseWheel", Slider_OnMouseWheel)
+
+	local lowtext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
+	lowtext:SetPoint("TOPLEFT", slider, "BOTTOMLEFT", 2, 3)
+
+	local hightext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
+	hightext:SetPoint("TOPRIGHT", slider, "BOTTOMRIGHT", -2, 3)
+
+	local editbox = CreateFrame("EditBox", nil, frame, "BackdropTemplate")
+	editbox:SetAutoFocus(false)
+	editbox:SetFontObject(GameFontHighlightSmall)
+	editbox:SetPoint("TOP", slider, "BOTTOM")
+	editbox:SetHeight(14)
+	editbox:SetWidth(70)
+	editbox:SetJustifyH("CENTER")
+	editbox:EnableMouse(true)
+	editbox:SetBackdrop(ManualBackdrop)
+	editbox:SetBackdropColor(0, 0, 0, 0.5)
+	editbox:SetBackdropBorderColor(0.3, 0.3, 0.30, 0.80)
+	editbox:SetScript("OnEnter", EditBox_OnEnter)
+	editbox:SetScript("OnLeave", EditBox_OnLeave)
+	editbox:SetScript("OnEnterPressed", EditBox_OnEnterPressed)
+	editbox:SetScript("OnEscapePressed", EditBox_OnEscapePressed)
+
+	local widget = {
+		label       = label,
+		slider      = slider,
+		lowtext     = lowtext,
+		hightext    = hightext,
+		editbox     = editbox,
+		alignoffset = 25,
+		frame       = frame,
+		type        = Type
+	}
+	for method, func in pairs(methods) do
+		widget[method] = func
+	end
+	slider.obj, editbox.obj = widget, widget
+
+	return AceGUI:RegisterAsWidget(widget)
+end
+
+AceGUI:RegisterWidgetType(Type,Constructor,Version)

Libs/AceLocale-3.0/AceLocale-3.0.lua

@@ -0,0 +1,133 @@
+--- **AceLocale-3.0** manages localization in addons, allowing for multiple locale to be registered with fallback to the base locale for untranslated strings.
+-- @class file
+-- @name AceLocale-3.0
+-- @release $Id: AceLocale-3.0.lua 1284 2022-09-25 09:15:30Z nevcairiel $
+local MAJOR,MINOR = "AceLocale-3.0", 6
+
+local AceLocale, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceLocale then return end -- no upgrade needed
+
+-- Lua APIs
+local assert, tostring, error = assert, tostring, error
+local getmetatable, setmetatable, rawset, rawget = getmetatable, setmetatable, rawset, rawget
+
+local gameLocale = GetLocale()
+if gameLocale == "enGB" then
+	gameLocale = "enUS"
+end
+
+AceLocale.apps = AceLocale.apps or {}          -- array of ["AppName"]=localetableref
+AceLocale.appnames = AceLocale.appnames or {}  -- array of [localetableref]="AppName"
+
+-- This metatable is used on all tables returned from GetLocale
+local readmeta = {
+	__index = function(self, key) -- requesting totally unknown entries: fire off a nonbreaking error and return key
+		rawset(self, key, key)      -- only need to see the warning once, really
+		geterrorhandler()(MAJOR..": "..tostring(AceLocale.appnames[self])..": Missing entry for '"..tostring(key).."'")
+		return key
+	end
+}
+
+-- This metatable is used on all tables returned from GetLocale if the silent flag is true, it does not issue a warning on unknown keys
+local readmetasilent = {
+	__index = function(self, key) -- requesting totally unknown entries: return key
+		rawset(self, key, key)      -- only need to invoke this function once
+		return key
+	end
+}
+
+-- Remember the locale table being registered right now (it gets set by :NewLocale())
+-- NOTE: Do never try to register 2 locale tables at once and mix their definition.
+local registering
+
+-- local assert false function
+local assertfalse = function() assert(false) end
+
+-- This metatable proxy is used when registering nondefault locales
+local writeproxy = setmetatable({}, {
+	__newindex = function(self, key, value)
+		rawset(registering, key, value == true and key or value) -- assigning values: replace 'true' with key string
+	end,
+	__index = assertfalse
+})
+
+-- This metatable proxy is used when registering the default locale.
+-- It refuses to overwrite existing values
+-- Reason 1: Allows loading locales in any order
+-- Reason 2: If 2 modules have the same string, but only the first one to be
+--           loaded has a translation for the current locale, the translation
+--           doesn't get overwritten.
+--
+local writedefaultproxy = setmetatable({}, {
+	__newindex = function(self, key, value)
+		if not rawget(registering, key) then
+			rawset(registering, key, value == true and key or value)
+		end
+	end,
+	__index = assertfalse
+})
+
+--- Register a new locale (or extend an existing one) for the specified application.
+-- :NewLocale will return a table you can fill your locale into, or nil if the locale isn't needed for the players
+-- game locale.
+-- @paramsig application, locale[, isDefault[, silent]]
+-- @param application Unique name of addon / module
+-- @param locale Name of the locale to register, e.g. "enUS", "deDE", etc.
+-- @param isDefault If this is the default locale being registered (your addon is written in this language, generally enUS)
+-- @param silent If true, the locale will not issue warnings for missing keys. Must be set on the first locale registered. If set to "raw", nils will be returned for unknown keys (no metatable used).
+-- @usage
+-- -- enUS.lua
+-- local L = LibStub("AceLocale-3.0"):NewLocale("TestLocale", "enUS", true)
+-- L["string1"] = true
+--
+-- -- deDE.lua
+-- local L = LibStub("AceLocale-3.0"):NewLocale("TestLocale", "deDE")
+-- if not L then return end
+-- L["string1"] = "Zeichenkette1"
+-- @return Locale Table to add localizations to, or nil if the current locale is not required.
+function AceLocale:NewLocale(application, locale, isDefault, silent)
+
+	-- GAME_LOCALE allows translators to test translations of addons without having that wow client installed
+	local activeGameLocale = GAME_LOCALE or gameLocale
+
+	local app = AceLocale.apps[application]
+
+	if silent and app and getmetatable(app) ~= readmetasilent then
+		geterrorhandler()("Usage: NewLocale(application, locale[, isDefault[, silent]]): 'silent' must be specified for the first locale registered")
+	end
+
+	if not app then
+		if silent=="raw" then
+			app = {}
+		else
+			app = setmetatable({}, silent and readmetasilent or readmeta)
+		end
+		AceLocale.apps[application] = app
+		AceLocale.appnames[app] = application
+	end
+
+	if locale ~= activeGameLocale and not isDefault then
+		return -- nop, we don't need these translations
+	end
+
+	registering = app -- remember globally for writeproxy and writedefaultproxy
+
+	if isDefault then
+		return writedefaultproxy
+	end
+
+	return writeproxy
+end
+
+--- Returns localizations for the current locale (or default locale if translations are missing).
+-- Errors if nothing is registered (spank developer, not just a missing translation)
+-- @param application Unique name of addon / module
+-- @param silent If true, the locale is optional, silently return nil if it's not found (defaults to false, optional)
+-- @return The locale table for the current language.
+function AceLocale:GetLocale(application, silent)
+	if not silent and not AceLocale.apps[application] then
+		error("Usage: GetLocale(application[, silent]): 'application' - No locales registered for '"..tostring(application).."'", 2)
+	end
+	return AceLocale.apps[application]
+end

Libs/AceLocale-3.0/AceLocale-3.0.xml

@@ -0,0 +1,4 @@
+<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="AceLocale-3.0.lua"/>
+</Ui>

Libs/AceSerializer-3.0/AceSerializer-3.0.lua

@@ -0,0 +1,287 @@
+--- **AceSerializer-3.0** can serialize any variable (except functions or userdata) into a string format,
+-- that can be send over the addon comm channel. AceSerializer was designed to keep all data intact, especially
+-- very large numbers or floating point numbers, and table structures. The only caveat currently is, that multiple
+-- references to the same table will be send individually.
+--
+-- **AceSerializer-3.0** can be embeded into your addon, either explicitly by calling AceSerializer: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 AceSerializer itself.\\
+-- It is recommended to embed AceSerializer, otherwise you'll have to specify a custom `self` on all calls you
+-- make into AceSerializer.
+-- @class file
+-- @name AceSerializer-3.0
+-- @release $Id: AceSerializer-3.0.lua 1284 2022-09-25 09:15:30Z nevcairiel $
+local MAJOR,MINOR = "AceSerializer-3.0", 5
+local AceSerializer, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceSerializer then return end
+
+-- Lua APIs
+local strbyte, strchar, gsub, gmatch, format = string.byte, string.char, string.gsub, string.gmatch, string.format
+local assert, error, pcall = assert, error, pcall
+local type, tostring, tonumber = type, tostring, tonumber
+local pairs, select, frexp = pairs, select, math.frexp
+local tconcat = table.concat
+
+-- quick copies of string representations of wonky numbers
+local inf = math.huge
+
+local serNaN  -- can't do this in 4.3, see ace3 ticket 268
+local serInf, serInfMac = "1.#INF", "inf"
+local serNegInf, serNegInfMac = "-1.#INF", "-inf"
+
+
+-- Serialization functions
+
+local function SerializeStringHelper(ch)	-- Used by SerializeValue for strings
+	-- We use \126 ("~") as an escape character for all nonprints plus a few more
+	local n = strbyte(ch)
+	if n==30 then           -- v3 / ticket 115: catch a nonprint that ends up being "~^" when encoded... DOH
+		return "\126\122"
+	elseif n<=32 then 			-- nonprint + space
+		return "\126"..strchar(n+64)
+	elseif n==94 then		-- value separator
+		return "\126\125"
+	elseif n==126 then		-- our own escape character
+		return "\126\124"
+	elseif n==127 then		-- nonprint (DEL)
+		return "\126\123"
+	else
+		assert(false)	-- can't be reached if caller uses a sane regex
+	end
+end
+
+local function SerializeValue(v, res, nres)
+	-- We use "^" as a value separator, followed by one byte for type indicator
+	local t=type(v)
+
+	if t=="string" then		-- ^S = string (escaped to remove nonprints, "^"s, etc)
+		res[nres+1] = "^S"
+		res[nres+2] = gsub(v,"[%c \94\126\127]", SerializeStringHelper)
+		nres=nres+2
+
+	elseif t=="number" then	-- ^N = number (just tostring()ed) or ^F (float components)
+		local str = tostring(v)
+		if tonumber(str)==v  --[[not in 4.3 or str==serNaN]] then
+			-- translates just fine, transmit as-is
+			res[nres+1] = "^N"
+			res[nres+2] = str
+			nres=nres+2
+		elseif v == inf or v == -inf then
+			res[nres+1] = "^N"
+			res[nres+2] = v == inf and serInf or serNegInf
+			nres=nres+2
+		else
+			local m,e = frexp(v)
+			res[nres+1] = "^F"
+			res[nres+2] = format("%.0f",m*2^53)	-- force mantissa to become integer (it's originally 0.5--0.9999)
+			res[nres+3] = "^f"
+			res[nres+4] = tostring(e-53)	-- adjust exponent to counteract mantissa manipulation
+			nres=nres+4
+		end
+
+	elseif t=="table" then	-- ^T...^t = table (list of key,value pairs)
+		nres=nres+1
+		res[nres] = "^T"
+		for key,value in pairs(v) do
+			nres = SerializeValue(key, res, nres)
+			nres = SerializeValue(value, res, nres)
+		end
+		nres=nres+1
+		res[nres] = "^t"
+
+	elseif t=="boolean" then	-- ^B = true, ^b = false
+		nres=nres+1
+		if v then
+			res[nres] = "^B"	-- true
+		else
+			res[nres] = "^b"	-- false
+		end
+
+	elseif t=="nil" then		-- ^Z = nil (zero, "N" was taken :P)
+		nres=nres+1
+		res[nres] = "^Z"
+
+	else
+		error(MAJOR..": Cannot serialize a value of type '"..t.."'")	-- can't produce error on right level, this is wildly recursive
+	end
+
+	return nres
+end
+
+
+
+local serializeTbl = { "^1" }	-- "^1" = Hi, I'm data serialized by AceSerializer protocol rev 1
+
+--- Serialize the data passed into the function.
+-- Takes a list of values (strings, numbers, booleans, nils, tables)
+-- and returns it in serialized form (a string).\\
+-- May throw errors on invalid data types.
+-- @param ... List of values to serialize
+-- @return The data in its serialized form (string)
+function AceSerializer:Serialize(...)
+	local nres = 1
+
+	for i=1,select("#", ...) do
+		local v = select(i, ...)
+		nres = SerializeValue(v, serializeTbl, nres)
+	end
+
+	serializeTbl[nres+1] = "^^"	-- "^^" = End of serialized data
+
+	return tconcat(serializeTbl, "", 1, nres+1)
+end
+
+-- Deserialization functions
+local function DeserializeStringHelper(escape)
+	if escape<"~\122" then
+		return strchar(strbyte(escape,2,2)-64)
+	elseif escape=="~\122" then	-- v3 / ticket 115: special case encode since 30+64=94 ("^") - OOPS.
+		return "\030"
+	elseif escape=="~\123" then
+		return "\127"
+	elseif escape=="~\124" then
+		return "\126"
+	elseif escape=="~\125" then
+		return "\94"
+	end
+	error("DeserializeStringHelper got called for '"..escape.."'?!?")  -- can't be reached unless regex is screwed up
+end
+
+local function DeserializeNumberHelper(number)
+	--[[ not in 4.3 if number == serNaN then
+		return 0/0
+	else]]if number == serNegInf or number == serNegInfMac then
+		return -inf
+	elseif number == serInf or number == serInfMac then
+		return inf
+	else
+		return tonumber(number)
+	end
+end
+
+-- DeserializeValue: worker function for :Deserialize()
+-- It works in two modes:
+--   Main (top-level) mode: Deserialize a list of values and return them all
+--   Recursive (table) mode: Deserialize only a single value (_may_ of course be another table with lots of subvalues in it)
+--
+-- The function _always_ works recursively due to having to build a list of values to return
+--
+-- Callers are expected to pcall(DeserializeValue) to trap errors
+
+local function DeserializeValue(iter,single,ctl,data)
+
+	if not single then
+		ctl,data = iter()
+	end
+
+	if not ctl then
+		error("Supplied data misses AceSerializer terminator ('^^')")
+	end
+
+	if ctl=="^^" then
+		-- ignore extraneous data
+		return
+	end
+
+	local res
+
+	if ctl=="^S" then
+		res = gsub(data, "~.", DeserializeStringHelper)
+	elseif ctl=="^N" then
+		res = DeserializeNumberHelper(data)
+		if not res then
+			error("Invalid serialized number: '"..tostring(data).."'")
+		end
+	elseif ctl=="^F" then     -- ^F<mantissa>^f<exponent>
+		local ctl2,e = iter()
+		if ctl2~="^f" then
+			error("Invalid serialized floating-point number, expected '^f', not '"..tostring(ctl2).."'")
+		end
+		local m=tonumber(data)
+		e=tonumber(e)
+		if not (m and e) then
+			error("Invalid serialized floating-point number, expected mantissa and exponent, got '"..tostring(m).."' and '"..tostring(e).."'")
+		end
+		res = m*(2^e)
+	elseif ctl=="^B" then	-- yeah yeah ignore data portion
+		res = true
+	elseif ctl=="^b" then   -- yeah yeah ignore data portion
+		res = false
+	elseif ctl=="^Z" then	-- yeah yeah ignore data portion
+		res = nil
+	elseif ctl=="^T" then
+		-- ignore ^T's data, future extensibility?
+		res = {}
+		local k,v
+		while true do
+			ctl,data = iter()
+			if ctl=="^t" then break end	-- ignore ^t's data
+			k = DeserializeValue(iter,true,ctl,data)
+			if k==nil then
+				error("Invalid AceSerializer table format (no table end marker)")
+			end
+			ctl,data = iter()
+			v = DeserializeValue(iter,true,ctl,data)
+			if v==nil then
+				error("Invalid AceSerializer table format (no table end marker)")
+			end
+			res[k]=v
+		end
+	else
+		error("Invalid AceSerializer control code '"..ctl.."'")
+	end
+
+	if not single then
+		return res,DeserializeValue(iter)
+	else
+		return res
+	end
+end
+
+--- Deserializes the data into its original values.
+-- Accepts serialized data, ignoring all control characters and whitespace.
+-- @param str The serialized data (from :Serialize)
+-- @return true followed by a list of values, OR false followed by an error message
+function AceSerializer:Deserialize(str)
+	str = gsub(str, "[%c ]", "")	-- ignore all control characters; nice for embedding in email and stuff
+
+	local iter = gmatch(str, "(^.)([^^]*)")	-- Any ^x followed by string of non-^
+	local ctl,data = iter()
+	if not ctl or ctl~="^1" then
+		-- we purposefully ignore the data portion of the start code, it can be used as an extension mechanism
+		return false, "Supplied data is not AceSerializer data (rev 1)"
+	end
+
+	return pcall(DeserializeValue, iter)
+end
+
+
+----------------------------------------
+-- Base library stuff
+----------------------------------------
+
+AceSerializer.internals = {	-- for test scripts
+	SerializeValue = SerializeValue,
+	SerializeStringHelper = SerializeStringHelper,
+}
+
+local mixins = {
+	"Serialize",
+	"Deserialize",
+}
+
+AceSerializer.embeds = AceSerializer.embeds or {}
+
+function AceSerializer:Embed(target)
+	for k, v in pairs(mixins) do
+		target[v] = self[v]
+	end
+	self.embeds[target] = true
+	return target
+end
+
+-- Update embeds
+for target, v in pairs(AceSerializer.embeds) do
+	AceSerializer:Embed(target)
+end

Libs/AceSerializer-3.0/AceSerializer-3.0.xml

@@ -0,0 +1,4 @@
+<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="AceSerializer-3.0.lua"/>
+</Ui>

Libs/AceTimer-3.0/AceTimer-3.0.lua

@@ -0,0 +1,278 @@
+--- **AceTimer-3.0** provides a central facility for registering timers.
+-- AceTimer supports one-shot timers and repeating timers. All timers are stored in an efficient
+-- data structure that allows easy dispatching and fast rescheduling. Timers can be registered
+-- or canceled at any time, even from within a running timer, without conflict or large overhead.\\
+-- AceTimer is currently limited to firing timers at a frequency of 0.01s as this is what the WoW timer API
+-- restricts us to.
+--
+-- All `:Schedule` functions will return a handle to the current timer, which you will need to store if you
+-- need to cancel the timer you just registered.
+--
+-- **AceTimer-3.0** can be embeded into your addon, either explicitly by calling AceTimer: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 AceTimer itself.\\
+-- It is recommended to embed AceTimer, otherwise you'll have to specify a custom `self` on all calls you
+-- make into AceTimer.
+-- @class file
+-- @name AceTimer-3.0
+-- @release $Id: AceTimer-3.0.lua 1342 2024-05-26 11:49:35Z nevcairiel $
+
+local MAJOR, MINOR = "AceTimer-3.0", 17 -- Bump minor on changes
+local AceTimer, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not AceTimer then return end -- No upgrade needed
+AceTimer.activeTimers = AceTimer.activeTimers or {} -- Active timer list
+local activeTimers = AceTimer.activeTimers -- Upvalue our private data
+
+-- Lua APIs
+local type, unpack, next, error, select = type, unpack, next, error, select
+-- WoW APIs
+local GetTime, C_TimerAfter = GetTime, C_Timer.After
+
+local function new(self, loop, func, delay, ...)
+	if delay < 0.01 then
+		delay = 0.01 -- Restrict to the lowest time that the C_Timer API allows us
+	end
+
+	local timer = {
+		object = self,
+		func = func,
+		looping = loop,
+		argsCount = select("#", ...),
+		delay = delay,
+		ends = GetTime() + delay,
+		...
+	}
+
+	activeTimers[timer] = timer
+
+	-- Create new timer closure to wrap the "timer" object
+	timer.callback = function()
+		if not timer.cancelled then
+			if type(timer.func) == "string" then
+				-- We manually set the unpack count to prevent issues with an arg set that contains nil and ends with nil
+				-- e.g. local t = {1, 2, nil, 3, nil} print(#t) will result in 2, instead of 5. This fixes said issue.
+				timer.object[timer.func](timer.object, unpack(timer, 1, timer.argsCount))
+			else
+				timer.func(unpack(timer, 1, timer.argsCount))
+			end
+
+			if timer.looping and not timer.cancelled then
+				-- Compensate delay to get a perfect average delay, even if individual times don't match up perfectly
+				-- due to fps differences
+				local time = GetTime()
+				local ndelay = timer.delay - (time - timer.ends)
+				-- Ensure the delay doesn't go below the threshold
+				if ndelay < 0.01 then ndelay = 0.01 end
+				C_TimerAfter(ndelay, timer.callback)
+				timer.ends = time + ndelay
+			else
+				activeTimers[timer.handle or timer] = nil
+			end
+		end
+	end
+
+	C_TimerAfter(delay, timer.callback)
+	return timer
+end
+
+--- Schedule a new one-shot timer.
+-- The timer will fire once in `delay` seconds, unless canceled before.
+-- @param func Callback function for the timer pulse (funcref or method name).
+-- @param delay Delay for the timer, in seconds.
+-- @param ... An optional, unlimited amount of arguments to pass to the callback function.
+-- @usage
+-- MyAddOn = LibStub("AceAddon-3.0"):NewAddon("MyAddOn", "AceTimer-3.0")
+--
+-- function MyAddOn:OnEnable()
+--   self:ScheduleTimer("TimerFeedback", 5)
+-- end
+--
+-- function MyAddOn:TimerFeedback()
+--   print("5 seconds passed")
+-- end
+function AceTimer:ScheduleTimer(func, delay, ...)
+	if not func or not delay then
+		error(MAJOR..": ScheduleTimer(callback, delay, args...): 'callback' and 'delay' must have set values.", 2)
+	end
+	if type(func) == "string" then
+		if type(self) ~= "table" then
+			error(MAJOR..": ScheduleTimer(callback, delay, args...): 'self' - must be a table.", 2)
+		elseif not self[func] then
+			error(MAJOR..": ScheduleTimer(callback, delay, args...): Tried to register '"..func.."' as the callback, but it doesn't exist in the module.", 2)
+		end
+	end
+	return new(self, nil, func, delay, ...)
+end
+
+--- Schedule a repeating timer.
+-- The timer will fire every `delay` seconds, until canceled.
+-- @param func Callback function for the timer pulse (funcref or method name).
+-- @param delay Delay for the timer, in seconds.
+-- @param ... An optional, unlimited amount of arguments to pass to the callback function.
+-- @usage
+-- MyAddOn = LibStub("AceAddon-3.0"):NewAddon("MyAddOn", "AceTimer-3.0")
+--
+-- function MyAddOn:OnEnable()
+--   self.timerCount = 0
+--   self.testTimer = self:ScheduleRepeatingTimer("TimerFeedback", 5)
+-- end
+--
+-- function MyAddOn:TimerFeedback()
+--   self.timerCount = self.timerCount + 1
+--   print(("%d seconds passed"):format(5 * self.timerCount))
+--   -- run 30 seconds in total
+--   if self.timerCount == 6 then
+--     self:CancelTimer(self.testTimer)
+--   end
+-- end
+function AceTimer:ScheduleRepeatingTimer(func, delay, ...)
+	if not func or not delay then
+		error(MAJOR..": ScheduleRepeatingTimer(callback, delay, args...): 'callback' and 'delay' must have set values.", 2)
+	end
+	if type(func) == "string" then
+		if type(self) ~= "table" then
+			error(MAJOR..": ScheduleRepeatingTimer(callback, delay, args...): 'self' - must be a table.", 2)
+		elseif not self[func] then
+			error(MAJOR..": ScheduleRepeatingTimer(callback, delay, args...): Tried to register '"..func.."' as the callback, but it doesn't exist in the module.", 2)
+		end
+	end
+	return new(self, true, func, delay, ...)
+end
+
+--- Cancels a timer with the given id, registered by the same addon object as used for `:ScheduleTimer`
+-- Both one-shot and repeating timers can be canceled with this function, as long as the `id` is valid
+-- and the timer has not fired yet or was canceled before.
+-- @param id The id of the timer, as returned by `:ScheduleTimer` or `:ScheduleRepeatingTimer`
+function AceTimer:CancelTimer(id)
+	local timer = activeTimers[id]
+
+	if not timer then
+		return false
+	else
+		timer.cancelled = true
+		activeTimers[id] = nil
+		return true
+	end
+end
+
+--- Cancels all timers registered to the current addon object ('self')
+function AceTimer:CancelAllTimers()
+	for k,v in next, activeTimers do
+		if v.object == self then
+			AceTimer.CancelTimer(self, k)
+		end
+	end
+end
+
+--- Returns the time left for a timer with the given id, registered by the current addon object ('self').
+-- This function will return 0 when the id is invalid.
+-- @param id The id of the timer, as returned by `:ScheduleTimer` or `:ScheduleRepeatingTimer`
+-- @return The time left on the timer.
+function AceTimer:TimeLeft(id)
+	local timer = activeTimers[id]
+	if not timer then
+		return 0
+	else
+		return timer.ends - GetTime()
+	end
+end
+
+
+-- ---------------------------------------------------------------------
+-- Upgrading
+
+-- Upgrade from old hash-bucket based timers to C_Timer.After timers.
+if oldminor and oldminor < 10 then
+	-- disable old timer logic
+	AceTimer.frame:SetScript("OnUpdate", nil)
+	AceTimer.frame:SetScript("OnEvent", nil)
+	AceTimer.frame:UnregisterAllEvents()
+	-- convert timers
+	for object,timers in next, AceTimer.selfs do
+		for handle,timer in next, timers do
+			if type(timer) == "table" and timer.callback then
+				local newTimer
+				if timer.delay then
+					newTimer = AceTimer.ScheduleRepeatingTimer(timer.object, timer.callback, timer.delay, timer.arg)
+				else
+					newTimer = AceTimer.ScheduleTimer(timer.object, timer.callback, timer.when - GetTime(), timer.arg)
+				end
+				-- Use the old handle for old timers
+				activeTimers[newTimer] = nil
+				activeTimers[handle] = newTimer
+				newTimer.handle = handle
+			end
+		end
+	end
+	AceTimer.selfs = nil
+	AceTimer.hash = nil
+	AceTimer.debug = nil
+elseif oldminor and oldminor < 17 then
+	-- Upgrade from old animation based timers to C_Timer.After timers.
+	AceTimer.inactiveTimers = nil
+	AceTimer.frame = nil
+	local oldTimers = AceTimer.activeTimers
+	-- Clear old timer table and update upvalue
+	AceTimer.activeTimers = {}
+	activeTimers = AceTimer.activeTimers
+	for handle, timer in next, oldTimers do
+		local newTimer
+		-- Stop the old timer animation
+		local duration, elapsed = timer:GetDuration(), timer:GetElapsed()
+		timer:GetParent():Stop()
+		if timer.looping then
+			newTimer = AceTimer.ScheduleRepeatingTimer(timer.object, timer.func, duration, unpack(timer.args, 1, timer.argsCount))
+		else
+			newTimer = AceTimer.ScheduleTimer(timer.object, timer.func, duration - elapsed, unpack(timer.args, 1, timer.argsCount))
+		end
+		-- Use the old handle for old timers
+		activeTimers[newTimer] = nil
+		activeTimers[handle] = newTimer
+		newTimer.handle = handle
+	end
+
+	-- Migrate transitional handles
+	if oldminor < 13 and AceTimer.hashCompatTable then
+		for handle, id in next, AceTimer.hashCompatTable do
+			local t = activeTimers[id]
+			if t then
+				activeTimers[id] = nil
+				activeTimers[handle] = t
+				t.handle = handle
+			end
+		end
+		AceTimer.hashCompatTable = nil
+	end
+end
+
+-- ---------------------------------------------------------------------
+-- Embed handling
+
+AceTimer.embeds = AceTimer.embeds or {}
+
+local mixins = {
+	"ScheduleTimer", "ScheduleRepeatingTimer",
+	"CancelTimer", "CancelAllTimers",
+	"TimeLeft"
+}
+
+function AceTimer:Embed(target)
+	AceTimer.embeds[target] = true
+	for _,v in next, mixins do
+		target[v] = AceTimer[v]
+	end
+	return target
+end
+
+-- AceTimer:OnEmbedDisable(target)
+-- target (object) - target object that AceTimer is embedded in.
+--
+-- cancel all timers registered for the object
+function AceTimer:OnEmbedDisable(target)
+	target:CancelAllTimers()
+end
+
+for addon in next, AceTimer.embeds do
+	AceTimer:Embed(addon)
+end

Libs/AceTimer-3.0/AceTimer-3.0.xml

@@ -0,0 +1,4 @@
+<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="AceTimer-3.0.lua"/>
+</Ui>

Libs/CallbackHandler-1.0/CallbackHandler-1.0.lua

@@ -0,0 +1,202 @@
+--[[ $Id: CallbackHandler-1.0.lua 1298 2022-12-12 15:10:10Z nevcairiel $ ]]
+local MAJOR, MINOR = "CallbackHandler-1.0", 8
+local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not CallbackHandler then return end -- No upgrade needed
+
+local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end}
+
+-- Lua APIs
+local securecallfunction, error = securecallfunction, error
+local setmetatable, rawget = setmetatable, rawget
+local next, select, pairs, type, tostring = next, select, pairs, type, tostring
+
+
+local function Dispatch(handlers, ...)
+	local index, method = next(handlers)
+	if not method then return end
+	repeat
+		securecallfunction(method, ...)
+		index, method = next(handlers, index)
+	until not method
+end
+
+--------------------------------------------------------------------------
+-- CallbackHandler:New
+--
+--   target            - target object to embed public APIs in
+--   RegisterName      - name of the callback registration API, default "RegisterCallback"
+--   UnregisterName    - name of the callback unregistration API, default "UnregisterCallback"
+--   UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API.
+
+function CallbackHandler.New(_self, target, RegisterName, UnregisterName, UnregisterAllName)
+
+	RegisterName = RegisterName or "RegisterCallback"
+	UnregisterName = UnregisterName or "UnregisterCallback"
+	if UnregisterAllName==nil then	-- false is used to indicate "don't want this method"
+		UnregisterAllName = "UnregisterAllCallbacks"
+	end
+
+	-- we declare all objects and exported APIs inside this closure to quickly gain access
+	-- to e.g. function names, the "target" parameter, etc
+
+
+	-- Create the registry object
+	local events = setmetatable({}, meta)
+	local registry = { recurse=0, events=events }
+
+	-- registry:Fire() - fires the given event/message into the registry
+	function registry:Fire(eventname, ...)
+		if not rawget(events, eventname) or not next(events[eventname]) then return end
+		local oldrecurse = registry.recurse
+		registry.recurse = oldrecurse + 1
+
+		Dispatch(events[eventname], eventname, ...)
+
+		registry.recurse = oldrecurse
+
+		if registry.insertQueue and oldrecurse==0 then
+			-- Something in one of our callbacks wanted to register more callbacks; they got queued
+			for event,callbacks in pairs(registry.insertQueue) do
+				local first = not rawget(events, event) or not next(events[event])	-- test for empty before. not test for one member after. that one member may have been overwritten.
+				for object,func in pairs(callbacks) do
+					events[event][object] = func
+					-- fire OnUsed callback?
+					if first and registry.OnUsed then
+						registry.OnUsed(registry, target, event)
+						first = nil
+					end
+				end
+			end
+			registry.insertQueue = nil
+		end
+	end
+
+	-- Registration of a callback, handles:
+	--   self["method"], leads to self["method"](self, ...)
+	--   self with function ref, leads to functionref(...)
+	--   "addonId" (instead of self) with function ref, leads to functionref(...)
+	-- all with an optional arg, which, if present, gets passed as first argument (after self if present)
+	target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]])
+		if type(eventname) ~= "string" then
+			error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2)
+		end
+
+		method = method or eventname
+
+		local first = not rawget(events, eventname) or not next(events[eventname])	-- test for empty before. not test for one member after. that one member may have been overwritten.
+
+		if type(method) ~= "string" and type(method) ~= "function" then
+			error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2)
+		end
+
+		local regfunc
+
+		if type(method) == "string" then
+			-- self["method"] calling style
+			if type(self) ~= "table" then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2)
+			elseif self==target then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2)
+			elseif type(self[method]) ~= "function" then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2)
+			end
+
+			if select("#",...)>=1 then	-- this is not the same as testing for arg==nil!
+				local arg=select(1,...)
+				regfunc = function(...) self[method](self,arg,...) end
+			else
+				regfunc = function(...) self[method](self,...) end
+			end
+		else
+			-- function ref with self=object or self="addonId" or self=thread
+			if type(self)~="table" and type(self)~="string" and type(self)~="thread" then
+				error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string or thread expected.", 2)
+			end
+
+			if select("#",...)>=1 then	-- this is not the same as testing for arg==nil!
+				local arg=select(1,...)
+				regfunc = function(...) method(arg,...) end
+			else
+				regfunc = method
+			end
+		end
+
+
+		if events[eventname][self] or registry.recurse<1 then
+		-- if registry.recurse<1 then
+			-- we're overwriting an existing entry, or not currently recursing. just set it.
+			events[eventname][self] = regfunc
+			-- fire OnUsed callback?
+			if registry.OnUsed and first then
+				registry.OnUsed(registry, target, eventname)
+			end
+		else
+			-- we're currently processing a callback in this registry, so delay the registration of this new entry!
+			-- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency
+			registry.insertQueue = registry.insertQueue or setmetatable({},meta)
+			registry.insertQueue[eventname][self] = regfunc
+		end
+	end
+
+	-- Unregister a callback
+	target[UnregisterName] = function(self, eventname)
+		if not self or self==target then
+			error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2)
+		end
+		if type(eventname) ~= "string" then
+			error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2)
+		end
+		if rawget(events, eventname) and events[eventname][self] then
+			events[eventname][self] = nil
+			-- Fire OnUnused callback?
+			if registry.OnUnused and not next(events[eventname]) then
+				registry.OnUnused(registry, target, eventname)
+			end
+		end
+		if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then
+			registry.insertQueue[eventname][self] = nil
+		end
+	end
+
+	-- OPTIONAL: Unregister all callbacks for given selfs/addonIds
+	if UnregisterAllName then
+		target[UnregisterAllName] = function(...)
+			if select("#",...)<1 then
+				error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2)
+			end
+			if select("#",...)==1 and ...==target then
+				error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2)
+			end
+
+
+			for i=1,select("#",...) do
+				local self = select(i,...)
+				if registry.insertQueue then
+					for eventname, callbacks in pairs(registry.insertQueue) do
+						if callbacks[self] then
+							callbacks[self] = nil
+						end
+					end
+				end
+				for eventname, callbacks in pairs(events) do
+					if callbacks[self] then
+						callbacks[self] = nil
+						-- Fire OnUnused callback?
+						if registry.OnUnused and not next(callbacks) then
+							registry.OnUnused(registry, target, eventname)
+						end
+					end
+				end
+			end
+		end
+	end
+
+	return registry
+end
+
+
+-- CallbackHandler purposefully does NOT do explicit embedding. Nor does it
+-- try to upgrade old implicit embeds since the system is selfcontained and
+-- relies on closures to work.
+

Libs/CallbackHandler-1.0/CallbackHandler-1.0.xml

@@ -0,0 +1,4 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
+..\FrameXML\UI.xsd">
+	<Script file="CallbackHandler-1.0.lua"/>
+</Ui>

Libs/LibGroupInSpecT-1.1/CHANGES.txt

@@ -0,0 +1,23 @@
+------------------------------------------------------------------------
+r106 | nebula169 | 2024-08-23 12:53:29 +0000 (Fri, 23 Aug 2024) | 1 line
+Changed paths:
+   M /trunk/LibGroupInSpecT-1.1.lua
+
+Update talent string decoding for v2
+------------------------------------------------------------------------
+r105 | nebula169 | 2024-08-20 06:44:07 +0000 (Tue, 20 Aug 2024) | 2 lines
+Changed paths:
+   M /trunk/LibGroupInSpecT-1.1.lua
+
+- Handle heroic talents
+- Remove tier/column
+------------------------------------------------------------------------
+r104 | nebula169 | 2024-07-25 01:08:28 +0000 (Thu, 25 Jul 2024) | 1 line
+Changed paths:
+   M /trunk/LibGroupInSpecT-1.1.lua
+   M /trunk/LibGroupInSpecT-1.1.toc
+   D /trunk/embeds.xml
+
+Update TOC for 11.0
+------------------------------------------------------------------------
+

Libs/LibGroupInSpecT-1.1/CallbackHandler-1.0/CallbackHandler-1.0.lua

@@ -0,0 +1,240 @@
+--[[ $Id: CallbackHandler-1.0.lua 14 2010-08-09 00:43:38Z mikk $ ]]
+local MAJOR, MINOR = "CallbackHandler-1.0", 6
+local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not CallbackHandler then return end -- No upgrade needed
+
+local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end}
+
+-- Lua APIs
+local tconcat = table.concat
+local assert, error, loadstring = assert, error, loadstring
+local setmetatable, rawset, rawget = setmetatable, rawset, rawget
+local next, select, pairs, type, tostring = next, select, pairs, type, tostring
+
+-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
+-- List them here for Mikk's FindGlobals script
+-- GLOBALS: geterrorhandler
+
+local xpcall = xpcall
+
+local function errorhandler(err)
+	return geterrorhandler()(err)
+end
+
+local function CreateDispatcher(argCount)
+	local code = [[
+	local next, xpcall, eh = ...
+
+	local method, ARGS
+	local function call() method(ARGS) end
+
+	local function dispatch(handlers, ...)
+		local index
+		index, method = next(handlers)
+		if not method then return end
+		local OLD_ARGS = ARGS
+		ARGS = ...
+		repeat
+			xpcall(call, eh)
+			index, method = next(handlers, index)
+		until not method
+		ARGS = OLD_ARGS
+	end
+
+	return dispatch
+	]]
+
+	local ARGS, OLD_ARGS = {}, {}
+	for i = 1, argCount do ARGS[i], OLD_ARGS[i] = "arg"..i, "old_arg"..i end
+	code = code:gsub("OLD_ARGS", tconcat(OLD_ARGS, ", ")):gsub("ARGS", tconcat(ARGS, ", "))
+	return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(next, xpcall, errorhandler)
+end
+
+local Dispatchers = setmetatable({}, {__index=function(self, argCount)
+	local dispatcher = CreateDispatcher(argCount)
+	rawset(self, argCount, dispatcher)
+	return dispatcher
+end})
+
+--------------------------------------------------------------------------
+-- CallbackHandler:New
+--
+--   target            - target object to embed public APIs in
+--   RegisterName      - name of the callback registration API, default "RegisterCallback"
+--   UnregisterName    - name of the callback unregistration API, default "UnregisterCallback"
+--   UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API.
+
+function CallbackHandler:New(target, RegisterName, UnregisterName, UnregisterAllName, OnUsed, OnUnused)
+	-- TODO: Remove this after beta has gone out
+	assert(not OnUsed and not OnUnused, "ACE-80: OnUsed/OnUnused are deprecated. Callbacks are now done to registry.OnUsed and registry.OnUnused")
+
+	RegisterName = RegisterName or "RegisterCallback"
+	UnregisterName = UnregisterName or "UnregisterCallback"
+	if UnregisterAllName==nil then	-- false is used to indicate "don't want this method"
+		UnregisterAllName = "UnregisterAllCallbacks"
+	end
+
+	-- we declare all objects and exported APIs inside this closure to quickly gain access
+	-- to e.g. function names, the "target" parameter, etc
+
+
+	-- Create the registry object
+	local events = setmetatable({}, meta)
+	local registry = { recurse=0, events=events }
+
+	-- registry:Fire() - fires the given event/message into the registry
+	function registry:Fire(eventname, ...)
+		if not rawget(events, eventname) or not next(events[eventname]) then return end
+		local oldrecurse = registry.recurse
+		registry.recurse = oldrecurse + 1
+
+		Dispatchers[select('#', ...) + 1](events[eventname], eventname, ...)
+
+		registry.recurse = oldrecurse
+
+		if registry.insertQueue and oldrecurse==0 then
+			-- Something in one of our callbacks wanted to register more callbacks; they got queued
+			for eventname,callbacks in pairs(registry.insertQueue) do
+				local first = not rawget(events, eventname) or not next(events[eventname])	-- test for empty before. not test for one member after. that one member may have been overwritten.
+				for self,func in pairs(callbacks) do
+					events[eventname][self] = func
+					-- fire OnUsed callback?
+					if first and registry.OnUsed then
+						registry.OnUsed(registry, target, eventname)
+						first = nil
+					end
+				end
+			end
+			registry.insertQueue = nil
+		end
+	end
+
+	-- Registration of a callback, handles:
+	--   self["method"], leads to self["method"](self, ...)
+	--   self with function ref, leads to functionref(...)
+	--   "addonId" (instead of self) with function ref, leads to functionref(...)
+	-- all with an optional arg, which, if present, gets passed as first argument (after self if present)
+	target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]])
+		if type(eventname) ~= "string" then
+			error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2)
+		end
+
+		method = method or eventname
+
+		local first = not rawget(events, eventname) or not next(events[eventname])	-- test for empty before. not test for one member after. that one member may have been overwritten.
+
+		if type(method) ~= "string" and type(method) ~= "function" then
+			error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2)
+		end
+
+		local regfunc
+
+		if type(method) == "string" then
+			-- self["method"] calling style
+			if type(self) ~= "table" then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2)
+			elseif self==target then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2)
+			elseif type(self[method]) ~= "function" then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2)
+			end
+
+			if select("#",...)>=1 then	-- this is not the same as testing for arg==nil!
+				local arg=select(1,...)
+				regfunc = function(...) self[method](self,arg,...) end
+			else
+				regfunc = function(...) self[method](self,...) end
+			end
+		else
+			-- function ref with self=object or self="addonId" or self=thread
+			if type(self)~="table" and type(self)~="string" and type(self)~="thread" then
+				error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string or thread expected.", 2)
+			end
+
+			if select("#",...)>=1 then	-- this is not the same as testing for arg==nil!
+				local arg=select(1,...)
+				regfunc = function(...) method(arg,...) end
+			else
+				regfunc = method
+			end
+		end
+
+
+		if events[eventname][self] or registry.recurse<1 then
+		-- if registry.recurse<1 then
+			-- we're overwriting an existing entry, or not currently recursing. just set it.
+			events[eventname][self] = regfunc
+			-- fire OnUsed callback?
+			if registry.OnUsed and first then
+				registry.OnUsed(registry, target, eventname)
+			end
+		else
+			-- we're currently processing a callback in this registry, so delay the registration of this new entry!
+			-- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency
+			registry.insertQueue = registry.insertQueue or setmetatable({},meta)
+			registry.insertQueue[eventname][self] = regfunc
+		end
+	end
+
+	-- Unregister a callback
+	target[UnregisterName] = function(self, eventname)
+		if not self or self==target then
+			error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2)
+		end
+		if type(eventname) ~= "string" then
+			error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2)
+		end
+		if rawget(events, eventname) and events[eventname][self] then
+			events[eventname][self] = nil
+			-- Fire OnUnused callback?
+			if registry.OnUnused and not next(events[eventname]) then
+				registry.OnUnused(registry, target, eventname)
+			end
+		end
+		if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then
+			registry.insertQueue[eventname][self] = nil
+		end
+	end
+
+	-- OPTIONAL: Unregister all callbacks for given selfs/addonIds
+	if UnregisterAllName then
+		target[UnregisterAllName] = function(...)
+			if select("#",...)<1 then
+				error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2)
+			end
+			if select("#",...)==1 and ...==target then
+				error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2)
+			end
+
+
+			for i=1,select("#",...) do
+				local self = select(i,...)
+				if registry.insertQueue then
+					for eventname, callbacks in pairs(registry.insertQueue) do
+						if callbacks[self] then
+							callbacks[self] = nil
+						end
+					end
+				end
+				for eventname, callbacks in pairs(events) do
+					if callbacks[self] then
+						callbacks[self] = nil
+						-- Fire OnUnused callback?
+						if registry.OnUnused and not next(callbacks) then
+							registry.OnUnused(registry, target, eventname)
+						end
+					end
+				end
+			end
+		end
+	end
+
+	return registry
+end
+
+
+-- CallbackHandler purposefully does NOT do explicit embedding. Nor does it
+-- try to upgrade old implicit embeds since the system is selfcontained and
+-- relies on closures to work.
+

Libs/LibGroupInSpecT-1.1/LibGroupInSpecT-1.1.toc

@@ -0,0 +1,10 @@
+## Interface: 110000, 110002
+## Title: Lib: GroupInSpecT-1.1
+## Notes: Keeps track of group members and keeps an up-to-date cache of their specialization and talents.
+## Version: 1.5.1
+## Author: Anyia of HordeYakka (Jubei'Thos)
+## X-Category: Library
+
+LibStub\LibStub.lua
+CallbackHandler-1.0\CallbackHandler-1.0.lua
+lib.xml

Libs/LibGroupInSpecT-1.1/LibStub/LibStub.lua

@@ -0,0 +1,51 @@
+-- $Id: LibStub.lua 76 2007-09-03 01:50:17Z mikk $
+-- LibStub is a simple versioning stub meant for use in Libraries.  http://www.wowace.com/wiki/LibStub for more info
+-- LibStub is hereby placed in the Public Domain
+-- Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke
+local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2  -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS!
+local LibStub = _G[LIBSTUB_MAJOR]
+
+-- Check to see is this version of the stub is obsolete
+if not LibStub or LibStub.minor < LIBSTUB_MINOR then
+	LibStub = LibStub or {libs = {}, minors = {} }
+	_G[LIBSTUB_MAJOR] = LibStub
+	LibStub.minor = LIBSTUB_MINOR
+	
+	-- LibStub:NewLibrary(major, minor)
+	-- major (string) - the major version of the library
+	-- minor (string or number ) - the minor version of the library
+	-- 
+	-- returns nil if a newer or same version of the lib is already present
+	-- returns empty library object or old library object if upgrade is needed
+	function LibStub:NewLibrary(major, minor)
+		assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)")
+		minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.")
+		
+		local oldminor = self.minors[major]
+		if oldminor and oldminor >= minor then return nil end
+		self.minors[major], self.libs[major] = minor, self.libs[major] or {}
+		return self.libs[major], oldminor
+	end
+	
+	-- LibStub:GetLibrary(major, [silent])
+	-- major (string) - the major version of the library
+	-- silent (boolean) - if true, library is optional, silently return nil if its not found
+	--
+	-- throws an error if the library can not be found (except silent is set)
+	-- returns the library object if found
+	function LibStub:GetLibrary(major, silent)
+		if not self.libs[major] and not silent then
+			error(("Cannot find a library instance of %q."):format(tostring(major)), 2)
+		end
+		return self.libs[major], self.minors[major]
+	end
+	
+	-- LibStub:IterateLibraries()
+	-- 
+	-- Returns an iterator for the currently registered libraries
+	function LibStub:IterateLibraries() 
+		return pairs(self.libs) 
+	end
+	
+	setmetatable(LibStub, { __call = LibStub.GetLibrary })
+end

Libs/LibGroupInSpecT-1.1/lib.xml

@@ -0,0 +1,6 @@
+<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="LibGroupInSpecT-1.1.lua"/>
+
+</Ui>

Libs/LibSharedMedia-3.0/CHANGES.txt

@@ -0,0 +1,16 @@
+------------------------------------------------------------------------
+r165 | funkehdude | 2026-01-19 18:55:34 +0000 (Mon, 19 Jan 2026) | 1 line
+Changed paths:
+   M /trunk/LibSharedMedia-3.0.toc
+
+Bump toc
+------------------------------------------------------------------------
+r164 | elkano | 2026-01-13 18:05:26 +0000 (Tue, 13 Jan 2026) | 2 lines
+Changed paths:
+   M /trunk/LibSharedMedia-3.0/LibSharedMedia-3.0.lua
+   M /trunk/LibSharedMedia-3.0.toc
+
+- bump TOCs
+- improved algorithmic complexity when registering new media files
+------------------------------------------------------------------------
+

Libs/LibSharedMedia-3.0/CallbackHandler-1.0/CallbackHandler-1.0.lua

@@ -0,0 +1,202 @@
+--[[ $Id: CallbackHandler-1.0.lua 26 2022-12-12 15:09:39Z nevcairiel $ ]]
+local MAJOR, MINOR = "CallbackHandler-1.0", 8
+local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not CallbackHandler then return end -- No upgrade needed
+
+local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end}
+
+-- Lua APIs
+local securecallfunction, error = securecallfunction, error
+local setmetatable, rawget = setmetatable, rawget
+local next, select, pairs, type, tostring = next, select, pairs, type, tostring
+
+
+local function Dispatch(handlers, ...)
+	local index, method = next(handlers)
+	if not method then return end
+	repeat
+		securecallfunction(method, ...)
+		index, method = next(handlers, index)
+	until not method
+end
+
+--------------------------------------------------------------------------
+-- CallbackHandler:New
+--
+--   target            - target object to embed public APIs in
+--   RegisterName      - name of the callback registration API, default "RegisterCallback"
+--   UnregisterName    - name of the callback unregistration API, default "UnregisterCallback"
+--   UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API.
+
+function CallbackHandler.New(_self, target, RegisterName, UnregisterName, UnregisterAllName)
+
+	RegisterName = RegisterName or "RegisterCallback"
+	UnregisterName = UnregisterName or "UnregisterCallback"
+	if UnregisterAllName==nil then	-- false is used to indicate "don't want this method"
+		UnregisterAllName = "UnregisterAllCallbacks"
+	end
+
+	-- we declare all objects and exported APIs inside this closure to quickly gain access
+	-- to e.g. function names, the "target" parameter, etc
+
+
+	-- Create the registry object
+	local events = setmetatable({}, meta)
+	local registry = { recurse=0, events=events }
+
+	-- registry:Fire() - fires the given event/message into the registry
+	function registry:Fire(eventname, ...)
+		if not rawget(events, eventname) or not next(events[eventname]) then return end
+		local oldrecurse = registry.recurse
+		registry.recurse = oldrecurse + 1
+
+		Dispatch(events[eventname], eventname, ...)
+
+		registry.recurse = oldrecurse
+
+		if registry.insertQueue and oldrecurse==0 then
+			-- Something in one of our callbacks wanted to register more callbacks; they got queued
+			for event,callbacks in pairs(registry.insertQueue) do
+				local first = not rawget(events, event) or not next(events[event])	-- test for empty before. not test for one member after. that one member may have been overwritten.
+				for object,func in pairs(callbacks) do
+					events[event][object] = func
+					-- fire OnUsed callback?
+					if first and registry.OnUsed then
+						registry.OnUsed(registry, target, event)
+						first = nil
+					end
+				end
+			end
+			registry.insertQueue = nil
+		end
+	end
+
+	-- Registration of a callback, handles:
+	--   self["method"], leads to self["method"](self, ...)
+	--   self with function ref, leads to functionref(...)
+	--   "addonId" (instead of self) with function ref, leads to functionref(...)
+	-- all with an optional arg, which, if present, gets passed as first argument (after self if present)
+	target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]])
+		if type(eventname) ~= "string" then
+			error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2)
+		end
+
+		method = method or eventname
+
+		local first = not rawget(events, eventname) or not next(events[eventname])	-- test for empty before. not test for one member after. that one member may have been overwritten.
+
+		if type(method) ~= "string" and type(method) ~= "function" then
+			error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2)
+		end
+
+		local regfunc
+
+		if type(method) == "string" then
+			-- self["method"] calling style
+			if type(self) ~= "table" then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2)
+			elseif self==target then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2)
+			elseif type(self[method]) ~= "function" then
+				error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2)
+			end
+
+			if select("#",...)>=1 then	-- this is not the same as testing for arg==nil!
+				local arg=select(1,...)
+				regfunc = function(...) self[method](self,arg,...) end
+			else
+				regfunc = function(...) self[method](self,...) end
+			end
+		else
+			-- function ref with self=object or self="addonId" or self=thread
+			if type(self)~="table" and type(self)~="string" and type(self)~="thread" then
+				error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string or thread expected.", 2)
+			end
+
+			if select("#",...)>=1 then	-- this is not the same as testing for arg==nil!
+				local arg=select(1,...)
+				regfunc = function(...) method(arg,...) end
+			else
+				regfunc = method
+			end
+		end
+
+
+		if events[eventname][self] or registry.recurse<1 then
+		-- if registry.recurse<1 then
+			-- we're overwriting an existing entry, or not currently recursing. just set it.
+			events[eventname][self] = regfunc
+			-- fire OnUsed callback?
+			if registry.OnUsed and first then
+				registry.OnUsed(registry, target, eventname)
+			end
+		else
+			-- we're currently processing a callback in this registry, so delay the registration of this new entry!
+			-- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency
+			registry.insertQueue = registry.insertQueue or setmetatable({},meta)
+			registry.insertQueue[eventname][self] = regfunc
+		end
+	end
+
+	-- Unregister a callback
+	target[UnregisterName] = function(self, eventname)
+		if not self or self==target then
+			error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2)
+		end
+		if type(eventname) ~= "string" then
+			error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2)
+		end
+		if rawget(events, eventname) and events[eventname][self] then
+			events[eventname][self] = nil
+			-- Fire OnUnused callback?
+			if registry.OnUnused and not next(events[eventname]) then
+				registry.OnUnused(registry, target, eventname)
+			end
+		end
+		if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then
+			registry.insertQueue[eventname][self] = nil
+		end
+	end
+
+	-- OPTIONAL: Unregister all callbacks for given selfs/addonIds
+	if UnregisterAllName then
+		target[UnregisterAllName] = function(...)
+			if select("#",...)<1 then
+				error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2)
+			end
+			if select("#",...)==1 and ...==target then
+				error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2)
+			end
+
+
+			for i=1,select("#",...) do
+				local self = select(i,...)
+				if registry.insertQueue then
+					for eventname, callbacks in pairs(registry.insertQueue) do
+						if callbacks[self] then
+							callbacks[self] = nil
+						end
+					end
+				end
+				for eventname, callbacks in pairs(events) do
+					if callbacks[self] then
+						callbacks[self] = nil
+						-- Fire OnUnused callback?
+						if registry.OnUnused and not next(callbacks) then
+							registry.OnUnused(registry, target, eventname)
+						end
+					end
+				end
+			end
+		end
+	end
+
+	return registry
+end
+
+
+-- CallbackHandler purposefully does NOT do explicit embedding. Nor does it
+-- try to upgrade old implicit embeds since the system is selfcontained and
+-- relies on closures to work.
+

Libs/LibSharedMedia-3.0/LibSharedMedia-3.0.toc

@@ -0,0 +1,17 @@
+## Interface: 11508, 11507, 20505, 30405, 38000, 40402, 50503, 50502, 120001, 110207, 120000
+## LoadOnDemand: 1
+
+## Title: Lib: SharedMedia-3.0
+## Notes: Shared handling of media data (fonts, sounds, textures, ...) between addons.
+## Author: Elkano
+## Version: 3.0-165
+## X-Website: https://www.curseforge.com/wow/addons/libsharedmedia-3-0
+## X-Category: Library
+
+## X-Revision: 165
+## X-Date: 2026-01-19T18:55:34Z
+
+LibStub\LibStub.lua
+CallbackHandler-1.0\CallbackHandler-1.0.lua
+
+LibSharedMedia-3.0\lib.xml

Libs/LibSharedMedia-3.0/LibSharedMedia-3.0/LibSharedMedia-3.0.lua

@@ -0,0 +1,324 @@
+--@curseforge-project-slug: libsharedmedia-3-0@
+--[[
+Name: LibSharedMedia-3.0
+Revision: $Revision: 164 $
+Author: Elkano (elkano@gmx.de)
+Inspired By: SurfaceLib by Haste/Otravi (troeks@gmail.com)
+Website: https://www.curseforge.com/wow/addons/libsharedmedia-3-0
+Description: Shared handling of media data (fonts, sounds, textures, ...) between addons.
+Dependencies: LibStub, CallbackHandler-1.0
+License: LGPL v2.1
+]]
+
+local MAJOR, MINOR = "LibSharedMedia-3.0", 12000001 -- 12.0.0 v1 / increase manually on changes
+local lib = LibStub:NewLibrary(MAJOR, MINOR)
+
+if not lib then return end
+
+local _G = getfenv(0)
+
+local pairs         = _G.pairs
+local type          = _G.type
+
+local band          = _G.bit.band
+local math_floor    = _G.math.floor
+local table_insert  = _G.table.insert
+local table_sort    = _G.table.sort
+
+local locale = GetLocale()
+local locale_is_western
+local LOCALE_MASK
+lib.LOCALE_BIT_koKR     = 1
+lib.LOCALE_BIT_ruRU     = 2
+lib.LOCALE_BIT_zhCN     = 4
+lib.LOCALE_BIT_zhTW     = 8
+lib.LOCALE_BIT_western  = 128
+
+local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0")
+
+lib.callbacks       = lib.callbacks     or CallbackHandler:New(lib)
+
+lib.DefaultMedia    = lib.DefaultMedia  or {}
+lib.MediaList       = lib.MediaList     or {}
+lib.MediaTable      = lib.MediaTable    or {}
+lib.MediaType       = lib.MediaType     or {}
+lib.OverrideMedia   = lib.OverrideMedia or {}
+
+local defaultMedia = lib.DefaultMedia
+local mediaList = lib.MediaList
+local mediaTable = lib.MediaTable
+local overrideMedia = lib.OverrideMedia
+
+
+-- create mediatype constants
+lib.MediaType.BACKGROUND    = "background"  -- background textures
+lib.MediaType.BORDER        = "border"      -- border textures
+lib.MediaType.FONT          = "font"        -- fonts
+lib.MediaType.STATUSBAR     = "statusbar"   -- statusbar textures
+lib.MediaType.SOUND         = "sound"       -- sound files
+
+-- populate lib with default Blizzard data
+-- BACKGROUND
+if not lib.MediaTable.background then lib.MediaTable.background = {} end
+lib.MediaTable.background["None"]                               = [[]]
+lib.MediaTable.background["Blizzard Collections Background"]    = [[Interface\Collections\CollectionsBackgroundTile]]
+lib.MediaTable.background["Blizzard Dialog Background"]         = [[Interface\DialogFrame\UI-DialogBox-Background]]
+lib.MediaTable.background["Blizzard Dialog Background Dark"]    = [[Interface\DialogFrame\UI-DialogBox-Background-Dark]]
+lib.MediaTable.background["Blizzard Dialog Background Gold"]    = [[Interface\DialogFrame\UI-DialogBox-Gold-Background]]
+lib.MediaTable.background["Blizzard Garrison Background"]       = [[Interface\Garrison\GarrisonUIBackground]]
+lib.MediaTable.background["Blizzard Garrison Background 2"]     = [[Interface\Garrison\GarrisonUIBackground2]]
+lib.MediaTable.background["Blizzard Garrison Background 3"]     = [[Interface\Garrison\GarrisonMissionUIInfoBoxBackgroundTile]]
+lib.MediaTable.background["Blizzard Low Health"]                = [[Interface\FullScreenTextures\LowHealth]]
+lib.MediaTable.background["Blizzard Marble"]                    = [[Interface\FrameGeneral\UI-Background-Marble]]
+lib.MediaTable.background["Blizzard Out of Control"]            = [[Interface\FullScreenTextures\OutOfControl]]
+lib.MediaTable.background["Blizzard Parchment"]                 = [[Interface\AchievementFrame\UI-Achievement-Parchment-Horizontal]]
+lib.MediaTable.background["Blizzard Parchment 2"]               = [[Interface\AchievementFrame\UI-GuildAchievement-Parchment-Horizontal]]
+lib.MediaTable.background["Blizzard Rock"]                      = [[Interface\FrameGeneral\UI-Background-Rock]]
+lib.MediaTable.background["Blizzard Tabard Background"]         = [[Interface\TabardFrame\TabardFrameBackground]]
+lib.MediaTable.background["Blizzard Tooltip"]                   = [[Interface\Tooltips\UI-Tooltip-Background]]
+lib.MediaTable.background["Solid"]                              = [[Interface\Buttons\WHITE8X8]]
+lib.DefaultMedia.background = "None"
+
+-- BORDER
+if not lib.MediaTable.border then lib.MediaTable.border = {} end
+lib.MediaTable.border["None"]                       = [[]]
+lib.MediaTable.border["Blizzard Achievement Wood"]  = [[Interface\AchievementFrame\UI-Achievement-WoodBorder]]
+lib.MediaTable.border["Blizzard Chat Bubble"]       = [[Interface\Tooltips\ChatBubble-Backdrop]]
+lib.MediaTable.border["Blizzard Dialog"]            = [[Interface\DialogFrame\UI-DialogBox-Border]]
+lib.MediaTable.border["Blizzard Dialog Gold"]       = [[Interface\DialogFrame\UI-DialogBox-Gold-Border]]
+lib.MediaTable.border["Blizzard Party"]             = [[Interface\CHARACTERFRAME\UI-Party-Border]]
+lib.MediaTable.border["Blizzard Tooltip"]           = [[Interface\Tooltips\UI-Tooltip-Border]]
+lib.DefaultMedia.border = "None"
+
+-- FONT
+if not lib.MediaTable.font then lib.MediaTable.font = {} end
+local SML_MT_font = lib.MediaTable.font
+--[[
+All font files are currently in all clients, the following table depicts which font supports which charset as of 5.0.4
+Fonts were checked using langcover.pl from DejaVu fonts (http://sourceforge.net/projects/dejavu/) and FontForge (http://fontforge.org/)
+latin means check for: de, en, es, fr, it, pt
+
+file                name                            latin   koKR    ruRU    zhCN    zhTW
+2002.ttf            2002                            X       X       X       -       -
+2002B.ttf           2002 Bold                       X       X       X       -       -
+ARHei.ttf           AR CrystalzcuheiGBK Demibold    X       -       X       X       X
+ARIALN.TTF          Arial Narrow                    X       -       X       -       -
+ARKai_C.ttf         AR ZhongkaiGBK Medium (Combat)  X       -       X       X       X
+ARKai_T.ttf         AR ZhongkaiGBK Medium           X       -       X       X       X
+bHEI00M.ttf         AR Heiti2 Medium B5             -       -       -       -       X
+bHEI01B.ttf         AR Heiti2 Bold B5               -       -       -       -       X
+bKAI00M.ttf         AR Kaiti Medium B5              -       -       -       -       X
+bLEI00D.ttf         AR Leisu Demi B5                -       -       -       -       X
+FRIZQT__.TTF        Friz Quadrata TT                X       -       -       -       -
+FRIZQT___CYR.TTF    FrizQuadrataCTT                 x       -       X       -       -
+K_Damage.TTF        YDIWingsM                       -       X       X       -       -
+K_Pagetext.TTF      MoK                             X       X       X       -       -
+MORPHEUS.TTF        Morpheus                        X       -       -       -       -
+MORPHEUS_CYR.TTF    Morpheus                        X       -       X       -       -
+NIM_____.ttf        Nimrod MT                       X       -       X       -       -
+SKURRI.TTF          Skurri                          X       -       -       -       -
+SKURRI_CYR.TTF      Skurri                          X       -       X       -       -
+
+WARNING: Although FRIZQT___CYR is available on western clients, it doesn't support special European characters e.g. é, ï, ö
+Due to this, we cannot use it as a replacement for FRIZQT__.TTF
+]]
+
+if locale == "koKR" then
+    LOCALE_MASK = lib.LOCALE_BIT_koKR
+--
+    SML_MT_font["굵은 글꼴"]    = [[Fonts\2002B.TTF]]
+    SML_MT_font["기본 글꼴"]    = [[Fonts\2002.TTF]]
+    SML_MT_font["데미지 글꼴"]  = [[Fonts\K_Damage.TTF]]
+    SML_MT_font["퀘스트 글꼴"]  = [[Fonts\K_Pagetext.TTF]]
+--
+    lib.DefaultMedia["font"] = "기본 글꼴" -- someone from koKR please adjust if needed
+--
+elseif locale == "zhCN" then
+    LOCALE_MASK = lib.LOCALE_BIT_zhCN
+--
+    SML_MT_font["伤害数字"] = [[Fonts\ARKai_C.ttf]]
+    SML_MT_font["默认"]     = [[Fonts\ARKai_T.ttf]]
+    SML_MT_font["聊天"]     = [[Fonts\ARHei.ttf]]
+--
+    lib.DefaultMedia["font"] = "默认" -- someone from zhCN please adjust if needed
+--
+elseif locale == "zhTW" then
+    LOCALE_MASK = lib.LOCALE_BIT_zhTW
+--
+    SML_MT_font["提示訊息"] = [[Fonts\bHEI00M.ttf]]
+    SML_MT_font["聊天"]     = [[Fonts\bHEI01B.ttf]]
+    SML_MT_font["傷害數字"] = [[Fonts\bKAI00M.ttf]]
+    SML_MT_font["預設"]     = [[Fonts\bLEI00D.ttf]]
+--
+    lib.DefaultMedia["font"] = "預設" -- someone from zhTW please adjust if needed
+
+elseif locale == "ruRU" then
+    LOCALE_MASK = lib.LOCALE_BIT_ruRU
+--
+    SML_MT_font["2002"]                             = [[Fonts\2002.TTF]]
+    SML_MT_font["2002 Bold"]                        = [[Fonts\2002B.TTF]]
+    SML_MT_font["AR CrystalzcuheiGBK Demibold"]     = [[Fonts\ARHei.TTF]]
+    SML_MT_font["AR ZhongkaiGBK Medium (Combat)"]   = [[Fonts\ARKai_C.TTF]]
+    SML_MT_font["AR ZhongkaiGBK Medium"]            = [[Fonts\ARKai_T.TTF]]
+    SML_MT_font["Arial Narrow"]                     = [[Fonts\ARIALN.TTF]]
+    SML_MT_font["Friz Quadrata TT"]                 = [[Fonts\FRIZQT___CYR.TTF]]
+    SML_MT_font["MoK"]                              = [[Fonts\K_Pagetext.TTF]]
+    SML_MT_font["Morpheus"]                         = [[Fonts\MORPHEUS_CYR.TTF]]
+    SML_MT_font["Nimrod MT"]                        = [[Fonts\NIM_____.ttf]]
+    SML_MT_font["Skurri"]                           = [[Fonts\SKURRI_CYR.TTF]]
+--
+    lib.DefaultMedia.font = "Friz Quadrata TT"
+--
+else
+    LOCALE_MASK = lib.LOCALE_BIT_western
+    locale_is_western = true
+--
+    SML_MT_font["2002"]                             = [[Fonts\2002.TTF]]
+    SML_MT_font["2002 Bold"]                        = [[Fonts\2002B.TTF]]
+    SML_MT_font["AR CrystalzcuheiGBK Demibold"]     = [[Fonts\ARHei.TTF]]
+    SML_MT_font["AR ZhongkaiGBK Medium (Combat)"]   = [[Fonts\ARKai_C.TTF]]
+    SML_MT_font["AR ZhongkaiGBK Medium"]            = [[Fonts\ARKai_T.TTF]]
+    SML_MT_font["Arial Narrow"]                     = [[Fonts\ARIALN.TTF]]
+    SML_MT_font["Friz Quadrata TT"]                 = [[Fonts\FRIZQT__.TTF]]
+    SML_MT_font["MoK"]                              = [[Fonts\K_Pagetext.TTF]]
+    SML_MT_font["Morpheus"]                         = [[Fonts\MORPHEUS_CYR.TTF]]
+    SML_MT_font["Nimrod MT"]                        = [[Fonts\NIM_____.ttf]]
+    SML_MT_font["Skurri"]                           = [[Fonts\SKURRI_CYR.TTF]]
+--
+    lib.DefaultMedia.font = "Friz Quadrata TT"
+--
+end
+
+-- STATUSBAR
+if not lib.MediaTable.statusbar then lib.MediaTable.statusbar = {} end
+lib.MediaTable.statusbar["Blizzard"]                        = [[Interface\TargetingFrame\UI-StatusBar]]
+lib.MediaTable.statusbar["Blizzard Character Skills Bar"]   = [[Interface\PaperDollInfoFrame\UI-Character-Skills-Bar]]
+lib.MediaTable.statusbar["Blizzard Raid Bar"]               = [[Interface\RaidFrame\Raid-Bar-Hp-Fill]]
+lib.MediaTable.statusbar["Solid"]                           = [[Interface\Buttons\WHITE8X8]]
+lib.DefaultMedia.statusbar = "Blizzard"
+
+-- SOUND
+if not lib.MediaTable.sound then lib.MediaTable.sound = {} end
+lib.MediaTable.sound["None"] = 1 -- Relies on the fact that PlaySoundFile doesn't error on this value
+lib.DefaultMedia.sound = "None"
+
+local function buildMediaList(mediatype)
+    local mtable = mediaTable[mediatype]
+    if not mtable then return end
+    if not mediaList[mediatype] then mediaList[mediatype] = {} end
+    local mlist = mediaList[mediatype]
+    -- list can only get larger, so simply overwrite it (should be empty anyways)
+    local i = 0
+    for k in pairs(mtable) do
+        i = i + 1
+        mlist[i] = k
+    end
+    table_sort(mlist)
+end
+
+local function updateMediaList(mediatype, value)
+    if not mediaList[mediatype] then
+        -- nothing to update, yet
+        return
+    end
+
+    local mlist = mediaList[mediatype]
+    -- invariant: list is sorted, entries are unique, value not yet in list
+    local s, e, m = 1, #mlist
+    while s <= e do
+        m = math_floor((s + e) / 2)
+        if mlist[m] > value then
+            e = m - 1
+        else
+            s = m + 1
+        end
+    end
+    table_insert(mlist, s, value)
+end
+
+function lib:Register(mediatype, key, data, langmask)
+    if type(mediatype) ~= "string" then
+        error(MAJOR..":Register(mediatype, key, data, langmask) - mediatype must be string, got "..type(mediatype))
+    end
+    if type(key) ~= "string" then
+        error(MAJOR..":Register(mediatype, key, data, langmask) - key must be string, got "..type(key))
+    end
+    mediatype = mediatype:lower()
+    if mediatype == lib.MediaType.FONT and ((langmask and band(langmask, LOCALE_MASK) == 0) or not (langmask or locale_is_western)) then
+        -- ignore fonts that aren't flagged as supporting local glyphs on non-western clients
+        return false
+    end
+    if type(data) == "string" and (mediatype == lib.MediaType.BACKGROUND or mediatype == lib.MediaType.BORDER or mediatype == lib.MediaType.STATUSBAR or mediatype == lib.MediaType.SOUND) then
+        local path = data:lower()
+        if not path:find("^interface") then
+            -- files accessed via path only allowed from interface folder
+            return false
+        end
+        if mediatype == lib.MediaType.SOUND and not (path:find(".ogg", nil, true) or path:find(".mp3", nil, true)) then
+            -- only ogg and mp3 are valid sounds
+            return false
+        end
+    end
+    if not mediaTable[mediatype] then mediaTable[mediatype] = {} end
+    local mtable = mediaTable[mediatype]
+    if mtable[key] then
+        -- key already registered
+        return false
+    end
+
+    mtable[key] = data
+    updateMediaList(mediatype, key)
+    self.callbacks:Fire("LibSharedMedia_Registered", mediatype, key)
+    return true
+end
+
+function lib:Fetch(mediatype, key, noDefault)
+    local mtt = mediaTable[mediatype]
+    local overridekey = overrideMedia[mediatype]
+    local result = mtt and ((overridekey and mtt[overridekey] or mtt[key]) or (not noDefault and defaultMedia[mediatype] and mtt[defaultMedia[mediatype]])) or nil
+    return result ~= "" and result or nil
+end
+
+function lib:IsValid(mediatype, key)
+    return mediaTable[mediatype] and (not key or mediaTable[mediatype][key]) and true or false
+end
+
+function lib:HashTable(mediatype)
+    return mediaTable[mediatype]
+end
+
+function lib:List(mediatype)
+    if not mediaTable[mediatype] then
+        return nil
+    end
+    if not mediaList[mediatype] then
+        buildMediaList(mediatype)
+    end
+    return mediaList[mediatype]
+end
+
+function lib:GetGlobal(mediatype)
+    return overrideMedia[mediatype]
+end
+
+function lib:SetGlobal(mediatype, key)
+    if not mediaTable[mediatype] then
+        return false
+    end
+    overrideMedia[mediatype] = (key and mediaTable[mediatype][key]) and key or nil
+    self.callbacks:Fire("LibSharedMedia_SetGlobal", mediatype, overrideMedia[mediatype])
+    return true
+end
+
+function lib:GetDefault(mediatype)
+    return defaultMedia[mediatype]
+end
+
+function lib:SetDefault(mediatype, key)
+    if mediaTable[mediatype] and mediaTable[mediatype][key] and not defaultMedia[mediatype] then
+        defaultMedia[mediatype] = key
+        return true
+    else
+        return false
+    end
+end

Libs/LibSharedMedia-3.0/LibSharedMedia-3.0/lib.xml

@@ -0,0 +1,4 @@
+<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="LibSharedMedia-3.0.lua" />
+</Ui>

Libs/LibSharedMedia-3.0/LibStub/LibStub.lua

@@ -0,0 +1,51 @@
+-- $Id: LibStub.lua 76 2007-09-03 01:50:17Z mikk $
+-- LibStub is a simple versioning stub meant for use in Libraries.  http://www.wowace.com/wiki/LibStub for more info
+-- LibStub is hereby placed in the Public Domain
+-- Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke
+local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2  -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS!
+local LibStub = _G[LIBSTUB_MAJOR]
+
+-- Check to see is this version of the stub is obsolete
+if not LibStub or LibStub.minor < LIBSTUB_MINOR then
+	LibStub = LibStub or {libs = {}, minors = {} }
+	_G[LIBSTUB_MAJOR] = LibStub
+	LibStub.minor = LIBSTUB_MINOR
+	
+	-- LibStub:NewLibrary(major, minor)
+	-- major (string) - the major version of the library
+	-- minor (string or number ) - the minor version of the library
+	-- 
+	-- returns nil if a newer or same version of the lib is already present
+	-- returns empty library object or old library object if upgrade is needed
+	function LibStub:NewLibrary(major, minor)
+		assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)")
+		minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.")
+		
+		local oldminor = self.minors[major]
+		if oldminor and oldminor >= minor then return nil end
+		self.minors[major], self.libs[major] = minor, self.libs[major] or {}
+		return self.libs[major], oldminor
+	end
+	
+	-- LibStub:GetLibrary(major, [silent])
+	-- major (string) - the major version of the library
+	-- silent (boolean) - if true, library is optional, silently return nil if its not found
+	--
+	-- throws an error if the library can not be found (except silent is set)
+	-- returns the library object if found
+	function LibStub:GetLibrary(major, silent)
+		if not self.libs[major] and not silent then
+			error(("Cannot find a library instance of %q."):format(tostring(major)), 2)
+		end
+		return self.libs[major], self.minors[major]
+	end
+	
+	-- LibStub:IterateLibraries()
+	-- 
+	-- Returns an iterator for the currently registered libraries
+	function LibStub:IterateLibraries() 
+		return pairs(self.libs) 
+	end
+	
+	setmetatable(LibStub, { __call = LibStub.GetLibrary })
+end

Libs/LibSharedMedia-3.0/lib.xml

@@ -0,0 +1,5 @@
+<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="LibSharedMedia-3.0\lib.xml"/>
+</Ui>
+

Libs/LibStub/LibStub.lua

@@ -0,0 +1,30 @@
+-- LibStub is a simple versioning stub meant for use in Libraries.  http://www.wowace.com/wiki/LibStub for more info
+-- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke
+local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2  -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS!
+local LibStub = _G[LIBSTUB_MAJOR]
+
+if not LibStub or LibStub.minor < LIBSTUB_MINOR then
+	LibStub = LibStub or {libs = {}, minors = {} }
+	_G[LIBSTUB_MAJOR] = LibStub
+	LibStub.minor = LIBSTUB_MINOR
+
+	function LibStub:NewLibrary(major, minor)
+		assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)")
+		minor = assert(tonumber(string.match(minor, "%d+")), "Minor version must either be a number or contain a number.")
+
+		local oldminor = self.minors[major]
+		if oldminor and oldminor >= minor then return nil end
+		self.minors[major], self.libs[major] = minor, self.libs[major] or {}
+		return self.libs[major], oldminor
+	end
+
+	function LibStub:GetLibrary(major, silent)
+		if not self.libs[major] and not silent then
+			error(("Cannot find a library instance of %q."):format(tostring(major)), 2)
+		end
+		return self.libs[major], self.minors[major]
+	end
+
+	function LibStub:IterateLibraries() return pairs(self.libs) end
+	setmetatable(LibStub, { __call = LibStub.GetLibrary })
+end

Locales/Locales.xml

@@ -0,0 +1,4 @@
+<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="enUS.lua"/>
+    <Script file="deDE.lua"/>
+</Ui>

Locales/deDE.lua

@@ -0,0 +1,483 @@
+-- Locales/deDE.lua
+-- Deutsch
+
+local L = LibStub("AceLocale-3.0"):NewLocale("HailMaryGuildTools", "deDE")
+if not L then return end   -- Nur laden wenn Client-Sprache deDE ist
+
+-- ── Addon general ────────────────────────────────────────────
+L["ADDON_TITLE"]       = "Hail Mary Guild Tools"
+L["ADDON_SUBTITLE"]    = "Interrupt & Raid-Cooldown-Tracker v1.0"
+L["ADDON_LOADED"]      = "|cff00aaffHail Mary Guild Tools|r geladen. /hmgt für Optionen."
+L["FRAMES_LOCKED"]     = "Frames gesperrt."
+L["FRAMES_UNLOCKED"]   = "Frames entsperrt."
+L["DEMO_MODE_ACTIVE"]  = "Demo-Modus aktiv."
+L["TEST_MODE_ACTIVE"]  = "Testmodus aktiv."
+
+-- ── Slash commands ───────────────────────────────────────────
+L["SLASH_HINT"]        = "/hmgt – Optionen  |  /hmgt lock/unlock  |  /hmgt demo  |  /hmgt test  |  /hmgt version  |  /hmgt debugdump [Zeilen]"
+L["VERSION_MISMATCH_CHAT"] = "Versionskonflikt mit %s: %s"
+L["VERSION_MISMATCH_POPUP"] = "HailMaryGuildTools Konflikt mit %s.\n%s\nQuelle: %s"
+L["VERSION_WINDOW_TITLE"] = "HMGT Versionscheck"
+L["VERSION_WINDOW_MESSAGE"] = "Es gibt eine neue Version von Hail Mary Guild Tools."
+L["VERSION_WINDOW_DETAIL"] = "Erkannt ueber %s von %s.\n%s"
+L["VERSION_WINDOW_NO_MISMATCH"] = "In deiner aktuellen Gruppe wurde keine neuere HMGT-Version erkannt."
+L["VERSION_WINDOW_CURRENT"] = "Aktuelle Version: %s | Protokoll: %s"
+L["VERSION_WINDOW_DEBUG_ONLY"] = "HMGT: /hmgt version ist nur bei aktiviertem Debugmodus verfuegbar."
+L["VERSION_WINDOW_DEVTOOLS_ONLY"] = "HMGT: /hmgt version ist nur bei aktivierten Entwicklerwerkzeugen verfuegbar."
+
+-- ── Options: general ─────────────────────────────────────────
+L["OPT_GENERAL"]          = "Allgemein"
+L["OPT_DESC"]             = "Interrupt & Raid-Cooldown-Tracker für Gruppen und Raids.\n\n" ..
+                             "|cffffff00/hmgt|r – Optionen öffnen\n" ..
+                             "|cffffff00/hmgt lock|r – Alle Frames sperren\n" ..
+                             "|cffffff00/hmgt unlock|r – Alle Frames entsperren\n" ..
+                             "|cffffff00/hmgt demo|r – Demo-Modus (Dummy-Daten)\n" ..
+                             "|cffffff00/hmgt test|r – Testmodus (eigene Spells)\n\n" ..
+                             "Kommunikation über AceComm (Addon-Nachrichten). Alle Gruppenmitglieder benötigen das Addon."
+L["OPT_LOCK_ALL"]         = "Alle Frames sperren"
+L["OPT_UNLOCK_ALL"]       = "Alle Frames entsperren"
+L["OPT_DEMO_MODE"]        = "Demo-Modus"
+L["OPT_DEMO_MODE_DESC"]   = "Zeigt Demo-Daten in den Trackern an"
+L["OPT_TEST_MODE"]        = "Testmodus"
+L["OPT_TEST_MODE_DESC"]   = "Zeigt deine eigenen Spells in allen Trackern an"
+L["OPT_DEBUG_MODE"]       = "Debugmodus"
+L["OPT_DEBUG_MODE_DESC"]  = "Zeigt Debug-Informationen zu wichtigen Addon-Aktionen in einer separaten Debug-Konsole an"
+L["OPT_DEBUG_LEVEL"]      = "Debug-Stufe"
+L["OPT_DEBUG_LEVEL_ERROR"]= "Nur Fehler"
+L["OPT_DEBUG_LEVEL_INFO"] = "Info (Tracker-CDs)"
+L["OPT_DEBUG_LEVEL_VERBOSE"] = "Ausführlich (+ Ressourcen)"
+L["OPT_DEBUG_SCOPE"] = "Modulfilter"
+L["OPT_DEBUG_SCOPE_ALL"] = "Alle Module"
+L["OPT_DEBUG_OPEN"]       = "Debug-Konsole oeffnen"
+L["OPT_DEBUG_CLEAR"]      = "Debug-Log leeren"
+L["OPT_DEBUG_SELECT_ALL"] = "Alles markieren"
+L["DEBUG_WINDOW_TITLE"]   = "HMGT Debug-Konsole"
+L["DEBUG_WINDOW_HINT"]    = "Mit dem Mausrad scrollen, Strg+A markiert alles, Strg+C kopiert markierten Text"
+L["OPT_DEVTOOLS_MODE"] = "Entwicklerwerkzeuge"
+L["OPT_DEVTOOLS_MODE_DESC"] = "Aktiviert die strukturierte Entwickler-Konsole."
+L["OPT_DEVTOOLS_LEVEL"] = "Erfassungsstufe"
+L["OPT_DEVTOOLS_LEVEL_ERROR"] = "Fehler"
+L["OPT_DEVTOOLS_LEVEL_TRACE"] = "Trace"
+L["OPT_DEVTOOLS_SCOPE"] = "Scope-Filter"
+L["OPT_DEVTOOLS_SCOPE_ALL"] = "Alle Scopes"
+L["OPT_DEVTOOLS_OPEN"] = "Entwickler-Konsole oeffnen"
+L["OPT_DEVTOOLS_CLEAR"] = "Entwickler-Log leeren"
+L["OPT_DEVTOOLS_SELECT_ALL"] = "Alles markieren"
+L["OPT_DEVTOOLS_DISABLED"] = "HMGT: Entwicklerwerkzeuge sind nicht aktiviert."
+L["DEVTOOLS_WINDOW_TITLE"] = "HMGT Entwicklerwerkzeuge"
+L["DEVTOOLS_WINDOW_HINT"] = "Strukturierte Entwickler-Ereignisse fuer die aktuelle Sitzung"
+L["OPT_SYNC_REMOTE_CHARGES"] = "Remote-Aufladungen synchronisieren"
+L["OPT_SYNC_REMOTE_CHARGES_DESC"] = "Überträgt Aufladungsdaten von Cooldowns an Gruppenmitglieder"
+L["OPT_CHANGELOG"]        = "Changelog"
+L["OPT_CHANGELOG_DESC"]   = "Letzte Addon-Aenderungen"
+L["OPT_CHANGELOG_VERSION"]= "Version"
+L["OPT_CHANGELOG_EMPTY"]  = "Keine Changelog-Eintraege verfuegbar."
+L["OPT_PROFILES"]         = "Profile"
+L["OPT_TRACKER"]          = "Tracker"
+L["OPT_TRACKERS"]         = "Tracker-Bars"
+L["OPT_TRACKERS_DESC"]    = "Erstelle Tracker-Bars und binde sie an eine oder mehrere Zauber-Kategorien."
+L["OPT_TRACKER_ACTIONS"]  = "Tracker-Aktionen"
+L["OPT_TRACKER_ACTIONS_DESC"] = "Globale Aktionen fuer alle Tracker-Frames."
+L["OPT_TRACKER_NAME"]     = "Tracker-Name"
+L["OPT_TRACKER_CATEGORIES"] = "Kategorien"
+L["OPT_TRACKER_CATEGORIES_DESC"] = "Waehle aus, welche Zauber-Kategorien dieser Tracker anzeigen soll."
+L["OPT_TRACKER_TYPE"] = "Tracker-Typ"
+L["OPT_TRACKER_TYPE_DESC"] = "Waehle, ob dieser Tracker einen gemeinsamen Frame oder separate Frames pro Gruppenmitglied verwendet."
+L["OPT_TRACKER_TYPE_NORMAL"] = "Normaler Tracker"
+L["OPT_TRACKER_TYPE_GROUP"] = "Gruppenbasierter Tracker"
+L["OPT_TRACKER_PER_MEMBER"] = "Einen Frame pro Gruppenmitglied erstellen"
+L["OPT_TRACKER_PER_MEMBER_DESC"] = "Verwendet separate Tracker-Frames pro Party-Mitglied statt eines einzelnen gemeinsamen Tracker-Frames."
+L["OPT_INCLUDE_SELF_FRAME"] = "Auch fuer den eigenen Spieler einen Frame erstellen"
+L["OPT_INCLUDE_SELF_FRAME_DESC"] = "Provisioniert bei gruppenbasierten Trackern auch fuer den eigenen Spieler einen eigenen Frame."
+L["OPT_ADD_TRACKER"]      = "Tracker hinzufuegen"
+L["OPT_REMOVE_TRACKER"]   = "Tracker entfernen"
+L["OPT_REMOVE_TRACKER_CONFIRM"] = 'Tracker "%s" wirklich entfernen?'
+L["OPT_TRACKERS_EMPTY"]   = "Es sind noch keine Tracker-Bars konfiguriert."
+L["OPT_TRACKED_SPELLS_DESC"] = "Aenderungen hier gelten fuer alle Tracker-Bars, die die Kategorien dieses Zaubers verwenden."
+L["OPT_TRACKED_SPELLS_EMPTY"] = "Derzeit werden keine Zauber von deinen Tracker-Bars verwendet."
+L["OPT_TRACKED_SPELLS_NO_MATCH"] = "Keine Zauber passen zu den aktuellen Filtern."
+L["OPT_MAP"]              = "Karte"
+L["OPT_MAP_PLACEHOLDER"]  = "Optionen fuer das Karten-Modul werden hier verfuegbar sein."
+L["OPT_MAP_ENABLED"]      = "Karten-Overlay aktivieren"
+L["OPT_MAP_ICON_SIZE"]    = "Icon-Groesse"
+L["OPT_MAP_ALPHA"]        = "Icon-Alpha"
+L["OPT_MAP_SHOW_LABELS"]  = "Labels anzeigen"
+L["OPT_MAP_POI_SECTION"]  = "Eigene POIs"
+L["OPT_MAP_POI_MAPID"]    = "Map-ID"
+L["OPT_MAP_POI_X"]        = "X (0-100)"
+L["OPT_MAP_POI_Y"]        = "Y (0-100)"
+L["OPT_MAP_POI_LABEL"]    = "Bezeichnung"
+L["OPT_MAP_POI_CATEGORY"] = "Icon"
+L["OPT_MAP_POI_USE_CURRENT"] = "Aktuelle Position uebernehmen"
+L["OPT_MAP_POI_USE_CURRENT_DESC"] = "Setzt Map-ID, X und Y auf deine aktuelle Spielerposition"
+L["OPT_MAP_POI_ADD"]      = "POI hinzufuegen"
+L["OPT_MAP_POI_UPDATE"]   = "POI aktualisieren"
+L["OPT_MAP_POI_REMOVE_INDEX"] = "Index entfernen"
+L["OPT_MAP_POI_REMOVE"]   = "POI entfernen"
+L["OPT_MAP_POI_LIST"]     = "Aktuelle POIs"
+L["OPT_MAP_POI_EMPTY"]    = "Keine POIs konfiguriert."
+L["OPT_MAP_POI_CURRENT_SET"] = "HMGT: aktuelle Position uebernommen"
+L["OPT_MAP_POI_CURRENT_FAILED"] = "HMGT: aktuelle Position konnte nicht ermittelt werden"
+L["OPT_MAP_POI_ADDED"]    = "HMGT: POI hinzugefuegt"
+L["OPT_MAP_POI_ADD_FAILED"] = "HMGT: POI konnte nicht hinzugefuegt werden"
+L["OPT_MAP_POI_UPDATED"]  = "HMGT: POI aktualisiert"
+L["OPT_MAP_POI_UPDATE_FAILED"] = "HMGT: POI konnte nicht aktualisiert werden"
+L["OPT_MAP_POI_REMOVED"]  = "HMGT: POI entfernt"
+L["OPT_MAP_POI_REMOVE_FAILED"] = "HMGT: POI konnte nicht entfernt werden"
+L["OPT_GENERAL_SETTINGS"] = "General Settings"
+L["OPT_SHOW_MINIMAP_ICON"] = "Minimap-Icon anzeigen"
+L["OPT_COMMANDS"] = "Commands"
+L["OPT_MODULES"] = "Modules"
+L["OPT_MODULE_TRACKER"] = "Tracker"
+L["OPT_MODULE_BUFF_ENDING"] = "Buff Ending"
+L["OPT_MODULE_MAP_OVERLAY"] = "Map Overlay"
+
+-- ── Options: tracker shared ───────────────────────────────────
+L["OPT_SECTION_GENERAL"]  = "Allgemeine Einstellungen"
+L["OPT_ENABLED"]          = "Aktiviert"
+L["OPT_ENABLED_DESC"]     = "Diesen Tracker aktivieren oder deaktivieren"
+L["OPT_DISPLAY_MODE"]     = "Anzeigemodus"
+L["OPT_DISPLAY_MODE_DESC"]= "Als Progressbar oder Icons anzeigen"
+L["OPT_DISPLAY_BAR"]      = "Progressbars"
+L["OPT_DISPLAY_ICON"]     = "Icons"
+L["OPT_SHOW_SPELL_TOOLTIP"] = "Blizzard-Tooltip auf Bars"
+L["OPT_SHOW_SPELL_TOOLTIP_DESC"] = "Zeigt beim Mouseover ueber eine Progressbar den Blizzard-Spell-Tooltip an"
+L["OPT_SHOW_READY_TEXT"]  = "Bereit-Text anzeigen"
+L["OPT_SHOW_CHARGES_ON_ICON"] = "Aufladungen auf dem Icon anzeigen"
+L["OPT_SHOW_REMAINING_ON_ICON"] = "Restzeit auf dem Icon anzeigen"
+L["OPT_LOCKED"]           = "Frame gesperrt"
+L["OPT_LOCKED_DESC"]      = "Verhindert das Verschieben des Frames"
+L["OPT_SHOW_NAME"]        = "Spielernamen anzeigen"
+L["OPT_CLASS_COLOR"]      = "Klassenfarben verwenden"
+L["OPT_GROW_DIR"]         = "Wachstumsrichtung"
+L["OPT_GROW_DOWN"]        = "Nach unten"
+L["OPT_GROW_UP"]          = "Nach oben"
+L["OPT_SECTION_ANCHOR"]   = "Anker"
+L["OPT_ANCHOR_TO"]        = "Anheften an"
+L["OPT_ANCHOR_TO_DESC"]   = "Diesen Frame an einen anderen Frame oder den Bildschirm heften"
+L["OPT_ANCHOR_TARGET_UI"] = "Bildschirm (UIParent)"
+L["OPT_ANCHOR_TARGET_CUSTOM"] = "Eigener Frame-Name"
+L["OPT_ANCHOR_CUSTOM_NAME"] = "Eigener Frame"
+L["OPT_ANCHOR_CUSTOM_NAME_DESC"] = "Globaler Frame-Name, z.B. ElvUF_Player"
+L["OPT_ATTACH_PARTY_FRAME"] = "An Party-Frame anhängen"
+L["OPT_ATTACH_PARTY_FRAME_DESC"] = "Verankert jeden Gruppen-Cooldown-Frame am zugehörigen Party-Unit-Frame"
+L["OPT_ATTACH_PARTY_SIDE"] = "Anheft-Seite"
+L["OPT_ATTACH_PARTY_OFFSET_X"] = "Anheft-X-Offset"
+L["OPT_ATTACH_PARTY_OFFSET_Y"] = "Anheft-Y-Offset"
+L["OPT_ATTACH_LEFT"] = "Links"
+L["OPT_ATTACH_RIGHT"] = "Rechts"
+L["OPT_ANCHOR_POINT"]     = "Ankerpunkt"
+L["OPT_ANCHOR_POINT_DESC"]= "Punkt dieses Frames, der verankert wird"
+L["OPT_ANCHOR_REL_POINT"] = "Relativer Punkt"
+L["OPT_ANCHOR_REL_POINT_DESC"] = "Punkt am Ziel-Frame, an den angeheftet wird"
+L["OPT_ANCHOR_X"]         = "X-Offset"
+L["OPT_ANCHOR_Y"]         = "Y-Offset"
+L["OPT_SHOW_ONLY_ACTIVE"] = "Nur aktive Cooldowns anzeigen"
+L["OPT_SHOW_ONLY_ACTIVE_DESC"] = "Einträge ausblenden, die aktuell bereit sind"
+L["OPT_SHOW_ONLY_READY"] = "Nur Cooldowns ohne CD anzeigen"
+L["OPT_SHOW_ONLY_READY_DESC"] = "Zeigt nur Einträge an, die aktuell bereit sind"
+L["OPT_READY_SOON_SEC"] = "Bald bereit Schwelle (Sek.)"
+L["OPT_READY_SOON_SEC_DESC"] = "Nur Cooldowns anzeigen, die bereit sind oder unter dieser Restzeit liegen (0 = aus)"
+L["OPT_PREPROVISION_UNKNOWN"] = "Unbekannte Spieler vorprovisionieren"
+L["OPT_PREPROVISION_UNKNOWN_DESC"] = "Zeigt vorausgefüllte Zauber für Gruppenmitglieder, auch bevor Hello/Sync empfangen wurde"
+L["OPT_ROLE_FILTER"] = "Rollenfilter"
+L["OPT_ROLE_FILTER_ALL"] = "Alle"
+L["OPT_ROLE_FILTER_TANK"] = "Tank"
+L["OPT_ROLE_FILTER_HEALER"] = "Heiler"
+L["OPT_ROLE_FILTER_DAMAGER"] = "Schaden"
+L["OPT_RANGE_CHECK"] = "Reichweitenprüfung"
+L["OPT_HIDE_OOR"] = "Außer Reichweite ausblenden"
+L["OPT_OOR_ALPHA"] = "Alpha außer Reichweite"
+
+L["OPT_SECTION_SIZE"]     = "Größe & Breite"
+L["OPT_WIDTH"]            = "Breite (Bars)"
+L["OPT_BAR_HEIGHT"]       = "Bar-Höhe"
+L["OPT_ICON_SIZE"]        = "Icon-Größe"
+L["OPT_ICON_COLS"]        = "Icons pro Zeile"
+
+L["OPT_SECTION_FONT"]     = "Schrift"
+L["OPT_FONT"]             = "Schriftart"
+L["OPT_FONT_SIZE"]        = "Schriftgröße"
+L["OPT_FONT_OUTLINE"]     = "Schrift-Umrandung"
+L["OPT_OUTLINE_NONE"]     = "Keine"
+L["OPT_OUTLINE_NORMAL"]   = "Outline"
+L["OPT_OUTLINE_THICK"]    = "Thick Outline"
+L["OPT_OUTLINE_MONO"]     = "Monochrome"
+
+L["OPT_SECTION_SPELLS"]   = "Angezeigte Zauber"
+L["OPT_SECTION_CUSTOM_SPELLS"] = "Eigene Zauber"
+L["OPT_CUSTOM_SPELLS_INFO"] = "Eigene Zauber für diesen Tracker hinzufügen oder entfernen."
+L["OPT_CUSTOM_SPELLS_ID"] = "Zauber-ID"
+L["OPT_CUSTOM_SPELLS_CD"] = "Cooldown (Sek.)"
+L["OPT_CUSTOM_SPELLS_CLASS"] = "Klasse"
+L["OPT_CUSTOM_SPELLS_SPECS"] = "Spezialisierungen (optional, z.B. 1,3)"
+L["OPT_CUSTOM_SPELLS_CATEGORY"] = "Kategorie"
+L["OPT_CUSTOM_SPELLS_ADD"] = "Zauber hinzufügen"
+L["OPT_CUSTOM_SPELLS_REMOVE"] = "Zauber-ID entfernen"
+L["OPT_CUSTOM_SPELLS_CURRENT"] = "Aktuelle eigene Zauber"
+L["OPT_CUSTOM_SPELLS_EMPTY"] = "Keine eigenen Zauber für diesen Tracker."
+L["OPT_CUSTOM_SPELLS_MSG_ADDED"] = "HMGT: eigener Zauber hinzugefügt"
+L["OPT_CUSTOM_SPELLS_MSG_INVALID"] = "HMGT: ungültige Eingabe für eigenen Zauber"
+L["OPT_CUSTOM_SPELLS_MSG_REMOVED"] = "HMGT: eigener Zauber entfernt"
+L["OPT_CUSTOM_SPELLS_MSG_NOT_FOUND"] = "HMGT: Zauber nicht gefunden"
+L["OPT_SPELLS_DESC"]      = "Aktiviere oder deaktiviere einzelne Zauber:\n"
+L["OPT_SPELL_SELECT"]     = "Zauber auswählen"
+
+-- ── Tracker titles ────────────────────────────────────────────
+L["OPT_DISABLED"]         = "Deaktiviert"
+L["OPT_VISIBILITY_NONE"]  = "Ueberall verborgen"
+L["OPT_STATUS_MODE"]      = "Modus"
+L["OPT_STATUS_DISPLAY"]   = "Anzeige"
+L["OPT_STATUS_VISIBILITY"]= "Sichtbarkeit"
+L["OPT_STATUS_GROWTH"]    = "Wachstum"
+L["OPT_STATUS_ATTACH"]    = "Anheftung"
+L["OPT_UI_GROUP_MODE"]    = "Modus"
+L["OPT_UI_GROUP_PLACEMENT"] = "Positionierung"
+L["OPT_UI_GROUP_VISIBILITY"] = "Sichtbarkeit"
+L["OPT_UI_GROUP_LAYOUT"]  = "Layout"
+L["OPT_UI_GROUP_APPEARANCE"] = "Darstellung"
+L["OPT_SPELL_BROWSER"]    = "Zauber-Browser"
+L["OPT_SPELL_BROWSER_DESC"] = "Filtere verfolgte Zauber nach Name oder Spell-ID und wende Schnellaktionen auf die sichtbaren Ergebnisse an."
+L["OPT_SELECTION"]       = "Auswahl"
+L["OPT_RT_NAME"] = "Raid Timeline"
+L["OPT_RT_ENABLED"] = "Raid Timeline aktivieren"
+L["OPT_RT_LEAD_TIME"] = "Vorlaufzeit der Warnung"
+L["OPT_RT_ASSIGNMENT_LEAD_TIME"] = "Vorlaufzeit fuer Zuweisung"
+L["OPT_RT_ASSIGNMENT_LEAD_TIME_DESC"] = "Wie viele Sekunden vor dem geplanten Einsatz der zugewiesene Spieler ausgewaehlt werden soll."
+L["OPT_RT_ALERT_HEADER"] = "Hinweisfenster"
+L["OPT_RT_UNLOCK"] = "Hinweisfenster entsperren"
+L["OPT_RT_PREVIEW"] = "Vorschau anzeigen"
+L["OPT_RT_ALERT_COLOR"] = "Textfarbe"
+L["OPT_RT_ALERT_PREVIEW"] = "Gelassenheit in 5"
+L["OPT_RT_DESC"] = "Lege hier Encounter-Timelines an und oeffne fuer die visuelle Planung den interaktiven Ace3-Timeline-Editor."
+L["OPT_RT_ALERT_UNLOCKED_HINT"] = "Raid Timeline Hinweis\nZum Verschieben ziehen"
+L["OPT_RT_ALERT_TEMPLATE"] = "%s in %d"
+L["OPT_RT_ENCOUNTERS_HEADER"] = "Encounter-Timelines"
+L["OPT_RT_SECTION_GENERAL"] = "Allgemein"
+L["OPT_RT_SECTION_MANAGE"] = "Encounter verwalten"
+L["OPT_RT_ADD_ENCOUNTER_ID"] = "Encounter-ID"
+L["OPT_RT_ADD_ENCOUNTER_NAME"] = "Encounter-Name"
+L["OPT_RT_ADD_RAID"] = "Raid"
+L["OPT_RT_ADD_ENCOUNTER"] = "Encounter hinzufuegen"
+L["OPT_RT_INVALID_ENCOUNTER"] = "HMGT: ungueltige Encounter-ID"
+L["OPT_RT_EMPTY"] = "Es sind noch keine Encounter-Timelines konfiguriert."
+L["OPT_RT_ENCOUNTER"] = "Encounter"
+L["OPT_RT_ENCOUNTER_NAME"] = "Name"
+L["OPT_RT_RAID_NAME"] = "Raid"
+L["OPT_RT_RAID_ID"] = "Raid-ID"
+L["OPT_RT_RAID_DEFAULT"] = "Encounter"
+L["OPT_RT_DELETE_ENCOUNTER_CONFIRM"] = "Raid-Timeline fuer Encounter %d loeschen?"
+L["OPT_RT_DIFFICULTY_HEADER"] = "Schwierigkeitsgrade"
+L["OPT_RT_DIFF_LFR"] = "LFR"
+L["OPT_RT_DIFF_NORMAL"] = "Normal"
+L["OPT_RT_DIFF_HEROIC"] = "HC"
+L["OPT_RT_DIFF_MYTHIC"] = "Mythic"
+L["OPT_RT_ADD_TIME"] = "Zeit (MM:SS)"
+L["OPT_RT_ADD_SPELL"] = "Spell"
+L["OPT_RT_ADD_PLAYER"] = "Target"
+L["OPT_RT_ADD_PLAYER_DESC"] = "Optional. Kommagetrennte Spielernamen oder Variablen wie Group1, Group8, GroupEven, GroupOdd. Wenn leer, wird an alle gesendet."
+L["OPT_RT_ADD_ENTRY"] = "Eintrag hinzufuegen"
+L["OPT_RT_ADD_ENTRY_INVALID"] = "HMGT: ungueltiger Raid-Timeline-Eintrag"
+L["OPT_RT_ENTRY_TIME"] = "Zeit"
+L["OPT_NOTES_NAME"] = "Notizen"
+L["OPT_NOTES_ENABLED"] = "Notizen aktivieren"
+L["OPT_NOTES_DESC"] = "Stellt ein MRT-aehnliches Notizfenster mit Hauptnotiz, persoenlicher Notiz und Encounter-Entwuerfen bereit."
+L["OPT_NOTES_OPEN_WINDOW"] = "Notizfenster oeffnen"
+L["OPT_NOTES_OPEN_SETTINGS"] = "Optionen oeffnen"
+L["OPT_NOTES_WINDOW_TITLE"] = "HMGT Notizen"
+L["OPT_NOTES_LIST"] = "Notizen"
+L["OPT_NOTES_EDITOR"] = "Editor"
+L["OPT_NOTES_MAIN"] = "Hauptnotiz"
+L["OPT_NOTES_PERSONAL"] = "Persoenliche Notiz"
+L["OPT_NOTES_DRAFT"] = "Entwurf"
+L["OPT_NOTES_NEW_DRAFT"] = "Neuer Entwurf"
+L["OPT_NOTES_DUPLICATE"] = "Duplizieren"
+L["OPT_NOTES_TITLE"] = "Titel"
+L["OPT_NOTES_ENCOUNTER"] = "Encounter"
+L["OPT_NOTES_TEXT"] = "Text"
+L["OPT_NOTES_NO_ENCOUNTER"] = "Kein Encounter"
+L["OPT_NOTES_SEND_CHAT"] = "In Chat senden"
+L["OPT_NOTES_SUMMARY"] = "Hauptnotiz, persoenliche Notiz und %d Entwuerfe verfuegbar."
+L["OPT_RT_ENTRY_SPELL"] = "Spell"
+L["OPT_RT_ENTRY_PLAYER"] = "Target"
+L["OPT_RT_TRIGGER"] = "Ausloeser"
+L["OPT_RT_TRIGGER_TIME"] = "Zeit"
+L["OPT_RT_TRIGGER_BOSS_ABILITY"] = "Bossfaehigkeit"
+L["OPT_RT_ACTION"] = "Aktion"
+L["OPT_RT_ACTION_TEXT"] = "Text"
+L["OPT_RT_ACTION_RAID_COOLDOWN"] = "Raid Cooldown"
+L["OPT_RT_INVALID_TIME"] = "HMGT: ungueltige Zeit"
+L["OPT_RT_INVALID_SPELL"] = "HMGT: ungueltige Spell-ID"
+L["OPT_RT_TIMELINE_VIEWPORT"] = "Timeline-Fenster"
+L["OPT_RT_TIMELINE_EMPTY_WINDOW"] = "Im aktuellen Zeitfenster sind keine Cooldowns."
+L["OPT_RT_TIMELINE_EDITOR"] = "Interaktive Timeline"
+L["OPT_RT_OPEN_EDITOR"] = "Timeline oeffnen"
+L["OPT_RT_START_TEST"] = "Timeline-Test starten"
+L["OPT_RT_STOP_TEST"] = "Test stoppen"
+L["OPT_RT_TEST_HINT"] = "Laesst die Encounter-Timeline ausserhalb des Kampfes ablaufen, damit du Zuweisungen, Whisper und Debug-Ausgaben pruefen kannst."
+L["OPT_RT_TIMELINE_SCROLL"] = "Timeline scrollen"
+L["OPT_RT_TIMELINE_ZOOM"] = "Zoom"
+L["OPT_RT_TIMELINE_HINT"] = "Klicke auf die Leiste, um einen Cooldown anzulegen. Ziehe Marker nach links oder rechts, um die Zeit zu aendern. Mausrad scrollt, Strg+Mausrad zoomt."
+L["OPT_RT_ASSIGNMENT_EDITOR"] = "Zuweisung"
+L["OPT_RT_ASSIGNMENT_NONE"] = "Kein Cooldown ausgewaehlt"
+L["OPT_SPELLS_VISIBLE"]   = "Sichtbare Zauber"
+L["OPT_SPELLS_ENABLED_COUNT"] = "Aktiv"
+L["OPT_FILTER_SEARCH"]    = "Suche"
+L["OPT_FILTER_SEARCH_DESC"] = "Suche nach Zaubername oder Spell-ID"
+L["OPT_FILTER_ENABLED_ONLY"] = "Nur aktive"
+L["OPT_FILTER_RESET"]     = "Filter zuruecksetzen"
+L["OPT_SELECT_VISIBLE"]   = "Sichtbare aktivieren"
+L["OPT_DESELECT_VISIBLE"] = "Sichtbare deaktivieren"
+L["OPT_ALL_SPECS"]        = "Alle Spezialisierungen"
+L["OPT_CUSTOM_SPELLS_EDITOR"] = "Zauber-Editor"
+L["OPT_CUSTOM_SPELLS_PREVIEW"] = "Vorschau"
+L["OPT_CUSTOM_SPELLS_PREVIEW_EMPTY"] = "Gib eine Spell-ID ein, um die Vorschau zu sehen."
+L["OPT_CUSTOM_SPELLS_LOAD"] = "In Editor laden"
+L["IT_TITLE"]  = "|cff00aaffInterrupts|r"
+L["RCD_TITLE"] = "|cffff8800Raid Cooldowns|r"
+L["GCD_TITLE"] = "|cff77dd77Gruppen-Cooldowns|r"
+
+-- ── Options: tracker names ────────────────────────────────────
+L["IT_NAME"]   = "Interrupt Tracker"
+L["RCD_NAME"]  = "Raid Cooldown Tracker"
+L["GCD_NAME"]  = "Gruppen-Cooldown-Tracker"
+L["BEA_NAME"]  = "Buff-Ende-Ansager"
+L["AEM_NAME"]  = "Auto-Gegner-Markierung"
+
+L["OPT_BEA_ENABLED"] = "Buff-Ende-Ansager aktivieren"
+L["OPT_BEA_ENABLED_DESC"] = "Sagt Countdown fuer verfolgte Buffs in /say an"
+L["OPT_BEA_ANNOUNCE_AT"] = "Ansage ab (Sek.)"
+L["OPT_BEA_ANNOUNCE_AT_DESC"] = "Startet die Countdown-Ansage, sobald die Restdauer darunter liegt"
+L["OPT_BEA_DEFAULT_THRESHOLD"] = "Standard-Threshold (Sek.)"
+L["OPT_BEA_DEFAULT_THRESHOLD_DESC"] = "Wird verwendet, wenn du einen neuen Buff hinzufuegst"
+L["OPT_BEA_SECTION_GENERAL"] = "Allgemein"
+L["OPT_BEA_SECTION_BUFFS"] = "Verfolgte Buffs"
+L["OPT_BEA_ADD_ID"] = "Spell-ID hinzufuegen"
+L["OPT_BEA_ADD_THRESHOLD"] = "Threshold"
+L["OPT_BEA_ADD_THRESHOLD_DESC"] = "Countdown-Beginn in Sekunden fuer diesen Buff"
+L["OPT_BEA_ADD"] = "Buff hinzufuegen"
+L["OPT_BEA_REMOVE_ID"] = "Spell-ID entfernen"
+L["OPT_BEA_REMOVE"] = "Buff entfernen"
+L["OPT_BEA_CURRENT"] = "Aktuell verfolgte Buffs"
+L["OPT_BEA_COL_ICON"] = "Icon"
+L["OPT_BEA_COL_SPELL"] = "Spellname"
+L["OPT_BEA_COL_THRESHOLD"] = "Threshold"
+L["OPT_BEA_COL_ACTION"] = "Aktion"
+L["OPT_BEA_EMPTY"] = "Keine Buffs konfiguriert."
+L["OPT_BEA_MSG_ADDED"] = "HMGT: Buff hinzugefuegt: %s"
+L["OPT_BEA_MSG_REMOVED"] = "HMGT: Buff entfernt: %s"
+L["OPT_BEA_MSG_INVALID"] = "HMGT: ungueltige Buff-Spell-ID"
+L["OPT_BEA_MSG_NOT_FOUND"] = "HMGT: Buff nicht gefunden"
+L["OPT_BEA_MSG_THRESHOLD_INVALID"] = "HMGT: ungueltiger Threshold"
+L["BEA_MSG_TEMPLATE"] = "%s endet in %d"
+
+L["OPT_AEM_ENABLED"] = "Automatische Gegner-Markierung aktivieren"
+L["OPT_AEM_ENABLED_DESC"] = "Markiert konfigurierte gegnerische Unit-IDs bei Mouseover mit rotierenden Schlachtzugsmarkierungen (außerhalb von Kaempfen)"
+L["OPT_AEM_RESET_SESSION"] = "Marker-Zyklus zuruecksetzen"
+L["OPT_AEM_SECTION_UNITS"] = "Verfolgte Unit-IDs"
+L["OPT_AEM_ADD_ID"] = "Unit-ID hinzufuegen"
+L["OPT_AEM_ADD"] = "Unit hinzufuegen"
+L["OPT_AEM_REMOVE_ID"] = "Unit-ID entfernen"
+L["OPT_AEM_REMOVE"] = "Unit entfernen"
+L["OPT_AEM_CURRENT"] = "Aktuelle Unit-IDs"
+L["OPT_AEM_EMPTY"] = "Keine Unit-IDs konfiguriert."
+L["OPT_AEM_MSG_ADDED"] = "HMGT: Unit-ID hinzugefuegt: %s"
+L["OPT_AEM_MSG_REMOVED"] = "HMGT: Unit-ID entfernt: %s"
+L["OPT_AEM_MSG_INVALID"] = "HMGT: ungueltige Unit-ID"
+L["OPT_AEM_MSG_NOT_FOUND"] = "HMGT: Unit-ID nicht gefunden"
+L["AEM_MSG_COMBAT_BLOCKED"] = "HMGT Auto-Gegner-Markierung: automatisches Markieren ist im Kampf durch Blizzard-Sicherheitsregeln blockiert."
+L["AEM_MSG_API_BLOCKED"] = "HMGT Auto-Gegner-Markierung: Raid-Marker-API-Aufruf ist in dieser Umgebung blockiert."
+
+-- ── Tooltip ───────────────────────────────────────────────────
+L["TT_DRAG"]        = "|cff00aaffHMGT|r\nZiehen zum Verschieben\n|cffffff00/hmgt lock|r zum Sperren"
+L["TT_REMAINING"]   = "Verbleibend: "
+L["TT_READY"]       = "Bereit!"
+L["TT_UNKNOWN"]     = "Unbekannt"
+
+-- ── Spell toggle label format ─────────────────────────────────
+L["SPELL_LABEL"]    = "[%s] %s"
+L["SPELL_DESC"]     = "SpellID: %d | Cooldown: %ds"
+
+-- ── Spell categories ─────────────────────────────────────────
+L["CAT_lust"]       = "Bloodlust / Lust"
+L["CAT_offensive"]  = "Offensive Cooldowns"
+L["CAT_defensive"]  = "Defensive Cooldowns"
+L["CAT_tank"]       = "Tank Cooldowns"
+L["CAT_healing"]    = "Heal-Cooldowns"
+L["CAT_utility"]    = "Utility"
+L["CAT_cc"]         = "Crowd Control"
+L["CAT_interrupt"]  = "Interrupts"
+L["CAT_raid"]       = "Raid-Cooldowns"
+
+-- ── Config spell list ─────────────────────────────────────────
+L["OPT_CD_LABEL"]     = "%s  (%ds)"
+L["OPT_SELECT_ALL"]   = "Alle auswählen"
+L["OPT_DESELECT_ALL"] = "Alle abwählen"
+
+-- ── Bar-Mode options ─────────────────────────────────────────
+L["OPT_BAR_TEXTURE"]        = "Textur"
+L["OPT_BAR_TEXTURE_DESC"]   = "Textur der Leiste"
+L["OPT_BAR_SPACING"]        = "Bar-Abstand"
+
+-- ── Icon-Mode options ─────────────────────────────────────────
+L["OPT_GROW_LEFT"]          = "Nach links"
+L["OPT_GROW_RIGHT"]         = "Nach rechts"
+L["OPT_ICON_COLS_DESC"]     = "Icons pro Zeile (DOWN/UP) oder pro Spalte (LEFT/RIGHT)"
+L["OPT_ICON_OVERLAY"]       = "Cooldown-Anzeige"
+L["OPT_ICON_OVERLAY_DESC"]  = "Wie der verbleibende Cooldown auf Icons angezeigt wird"
+L["OPT_ICON_OVERLAY_SWEEP"] = "Abklingkreis (Sweep)"
+L["OPT_ICON_OVERLAY_TIMER"] = "Text-Timer (MM:SS)"
+L["OPT_ICON_SPACING"]       = "Icon-Abstand"
+
+-- ── Visibility options ────────────────────────────────────────
+L["OPT_SECTION_VISIBILITY"] = "Sichtbarkeit"
+L["OPT_SHOW_SOLO"]          = "Solo anzeigen"
+L["OPT_SHOW_SOLO_DESC"]     = "Tracker anzeigen wenn kein Gruppe aktiv"
+L["OPT_SHOW_GROUP"]         = "In Gruppe anzeigen"
+L["OPT_SHOW_GROUP_DESC"]    = "Tracker in einer Gruppe anzeigen"
+L["OPT_SHOW_RAID"]          = "Im Raid anzeigen"
+L["OPT_SHOW_RAID_DESC"]     = "Tracker im Raid anzeigen"
+
+-- ── Border options ──────────────────────────────────────────────
+L["OPT_BORDER_ENABLED"]      = "Rahmen anzeigen"
+L["OPT_BORDER_ENABLED_DESC"] = "Zeigt einen 1px-Rahmen um Progressbars und Icons"
+L["OPT_BORDER_COLOR"]        = "Rahmenfarbe"
+L["OPT_BORDER_COLOR_DESC"]   = "Farbe des 1px-Rahmens"
+
+-- ── Text anchor (icon mode) ───────────────────────────────────
+L["OPT_TEXT_ANCHOR"]        = "Text-Position"
+L["OPT_TEXT_ANCHOR_DESC"]   = "Wo Name und Timer relativ zum Icon angezeigt werden"
+L["OPT_ANCHOR_ON_ICON"]     = "Auf dem Icon (Overlay)"
+L["OPT_ANCHOR_ABOVE"]       = "Über dem Icon"
+L["OPT_ANCHOR_BELOW"]       = "Unter dem Icon"
+L["OPT_ANCHOR_LEFT"]        = "Links vom Icon"
+L["OPT_ANCHOR_RIGHT"]       = "Rechts vom Icon"
+
+-- ── Talent mod types ──────────────────────────────────────────
+L["TALENTMOD_SET"]          = "Talent setzt CD auf %ds"
+L["TALENTMOD_MULTIPLY"]     = "Talent multipliziert CD mit %.2f"
+L["TALENTMOD_REDUCE"]       = "Talent reduziert CD um %d%%"
+
+
+
+L["OPT_RT_ADD_TEXT"] = "Freitext"
+L["OPT_RT_ENTRY_TEXT"] = "Freitext"
+L["OPT_RT_NO_SPELL"] = "Kein Spell"
+L["OPT_RT_ADD_TYPE"] = "Typ"
+L["OPT_RT_ENTRY_TYPE"] = "Typ"
+L["OPT_RT_TYPE_SPELL"] = "Spell"
+L["OPT_RT_TYPE_TEXT"] = "Text"
+L["OPT_RT_TYPE_BOSS_ABILITY"] = "Bossfaehigkeit"
+L["OPT_RT_BOSSMOD"] = "Bossmod"
+L["OPT_RT_BOSS_ABILITY"] = "Bossfaehigkeit"
+L["OPT_RT_BOSS_BAR_NAME"] = "Bossmod-Barname"
+L["OPT_RT_NO_BOSS_ABILITY"] = "Keine Bossfaehigkeit"
+L["OPT_RT_CAST_COUNT"] = "Cast-Nummer"
+L["OPT_RT_CAST_COUNT_DESC"] = "Verwende eine Zahl, All, Odd oder Even."
+L["OPT_RT_CAST"] = "Cast"
+L["OPT_RT_CAST_ALL"] = "All"
+L["OPT_RT_CAST_ODD"] = "Odd"
+L["OPT_RT_CAST_EVEN"] = "Even"
+L["OPT_RT_ADD_TARGETS"] = "Ziele"
+L["OPT_RT_ENTRY_TARGETS"] = "Ziele"
+L["OPT_RT_TARGETS_DESC"] = "Verwende All, Odd, Even, Raid-Gruppen wie 1,2, 1-3 oder Spielernamen per Komma getrennt."

Locales/enUS.lua

@@ -0,0 +1,483 @@
+-- Locales/enUS.lua
+-- English (base locale – all keys must be defined here)
+
+local L = LibStub("AceLocale-3.0"):NewLocale("HailMaryGuildTools", "enUS", true)
+-- true = this is the default locale; missing keys in other locales fall back here
+
+-- ── Addon general ────────────────────────────────────────────
+L["ADDON_TITLE"]       = "Hail Mary Guild Tools"
+L["ADDON_SUBTITLE"]    = "Interrupt & Raid Cooldown Tracker v1.0"
+L["ADDON_LOADED"]      = "|cff00aaffHail Mary Guild Tools|r loaded. /hmgt for options."
+L["FRAMES_LOCKED"]     = "Frames locked."
+L["FRAMES_UNLOCKED"]   = "Frames unlocked."
+L["DEMO_MODE_ACTIVE"]  = "Demo mode active."
+L["TEST_MODE_ACTIVE"]  = "Test mode active."
+
+-- ── Slash commands ───────────────────────────────────────────
+L["SLASH_HINT"]        = "/hmgt – options  |  /hmgt lock/unlock  |  /hmgt demo  |  /hmgt test  |  /hmgt version  |  /hmgt debugdump [lines]"
+L["VERSION_MISMATCH_CHAT"] = "Version mismatch with %s: %s"
+L["VERSION_MISMATCH_POPUP"] = "HailMaryGuildTools mismatch with %s.\n%s\nSource: %s"
+L["VERSION_WINDOW_TITLE"] = "HMGT Version Check"
+L["VERSION_WINDOW_MESSAGE"] = "A new version of Hail Mary Guild Tools is available."
+L["VERSION_WINDOW_DETAIL"] = "Detected via %s from %s.\n%s"
+L["VERSION_WINDOW_NO_MISMATCH"] = "No newer HMGT version has been detected in your current group."
+L["VERSION_WINDOW_CURRENT"] = "Current version: %s | Protocol: %s"
+L["VERSION_WINDOW_DEBUG_ONLY"] = "HMGT: /hmgt version is only available while debug mode is enabled."
+L["VERSION_WINDOW_DEVTOOLS_ONLY"] = "HMGT: /hmgt version is only available while developer tools are enabled."
+
+-- ── Options: general ─────────────────────────────────────────
+L["OPT_GENERAL"]          = "General"
+L["OPT_DESC"]             = "Interrupt & Raid Cooldown Tracker for groups and raids.\n\n" ..
+                             "|cffffff00/hmgt|r – open options\n" ..
+                             "|cffffff00/hmgt lock|r – lock all frames\n" ..
+                             "|cffffff00/hmgt unlock|r – unlock all frames\n" ..
+                             "|cffffff00/hmgt demo|r – demo mode (dummy data)\n" ..
+                             "|cffffff00/hmgt test|r – test mode (your own spells)\n\n" ..
+                             "Communication uses AceComm (addon messages). All group members need the addon."
+L["OPT_LOCK_ALL"]         = "Lock all frames"
+L["OPT_UNLOCK_ALL"]       = "Unlock all frames"
+L["OPT_DEMO_MODE"]        = "Demo mode"
+L["OPT_DEMO_MODE_DESC"]   = "Show demo data in the trackers"
+L["OPT_TEST_MODE"]        = "Test mode"
+L["OPT_TEST_MODE_DESC"]   = "Show your own spells in all trackers"
+L["OPT_DEBUG_MODE"]       = "Debug mode"
+L["OPT_DEBUG_MODE_DESC"]  = "Show debug information for important addon actions in a separate debug console"
+L["OPT_DEBUG_LEVEL"]      = "Debug level"
+L["OPT_DEBUG_LEVEL_ERROR"]= "Errors only"
+L["OPT_DEBUG_LEVEL_INFO"] = "Info (tracked CDs)"
+L["OPT_DEBUG_LEVEL_VERBOSE"] = "Verbose (+ power spend)"
+L["OPT_DEBUG_SCOPE"] = "Module filter"
+L["OPT_DEBUG_SCOPE_ALL"] = "All modules"
+L["OPT_DEBUG_OPEN"]       = "Open debug console"
+L["OPT_DEBUG_CLEAR"]      = "Clear debug log"
+L["OPT_DEBUG_SELECT_ALL"] = "Select all"
+L["DEBUG_WINDOW_TITLE"]   = "HMGT Debug Console"
+L["DEBUG_WINDOW_HINT"]    = "Mouse wheel scrolls, Ctrl+A selects all, Ctrl+C copies selected text"
+L["OPT_DEVTOOLS_MODE"] = "Developer tools"
+L["OPT_DEVTOOLS_MODE_DESC"] = "Enable the structured developer event console."
+L["OPT_DEVTOOLS_LEVEL"] = "Capture level"
+L["OPT_DEVTOOLS_LEVEL_ERROR"] = "Errors"
+L["OPT_DEVTOOLS_LEVEL_TRACE"] = "Trace"
+L["OPT_DEVTOOLS_SCOPE"] = "Scope filter"
+L["OPT_DEVTOOLS_SCOPE_ALL"] = "All scopes"
+L["OPT_DEVTOOLS_OPEN"] = "Open developer console"
+L["OPT_DEVTOOLS_CLEAR"] = "Clear developer log"
+L["OPT_DEVTOOLS_SELECT_ALL"] = "Select all"
+L["OPT_DEVTOOLS_DISABLED"] = "HMGT: developer tools are not enabled."
+L["DEVTOOLS_WINDOW_TITLE"] = "HMGT Developer Tools"
+L["DEVTOOLS_WINDOW_HINT"] = "Structured developer events for the current session"
+L["OPT_SYNC_REMOTE_CHARGES"] = "Sync remote charges"
+L["OPT_SYNC_REMOTE_CHARGES_DESC"] = "Transmit charge information for cooldowns to group members"
+L["OPT_CHANGELOG"]        = "Changelog"
+L["OPT_CHANGELOG_DESC"]   = "Recent addon changes"
+L["OPT_CHANGELOG_VERSION"]= "Version"
+L["OPT_CHANGELOG_EMPTY"]  = "No changelog entries available."
+L["OPT_PROFILES"]         = "Profiles"
+L["OPT_TRACKER"]          = "Tracker"
+L["OPT_TRACKERS"]         = "Tracker Bars"
+L["OPT_TRACKERS_DESC"]    = "Create tracker bars and bind them to one or more spell categories."
+L["OPT_TRACKER_ACTIONS"]  = "Tracker actions"
+L["OPT_TRACKER_ACTIONS_DESC"] = "Global actions for all tracker frames."
+L["OPT_TRACKER_NAME"]     = "Tracker name"
+L["OPT_TRACKER_CATEGORIES"] = "Categories"
+L["OPT_TRACKER_CATEGORIES_DESC"] = "Select which spell categories this tracker should display."
+L["OPT_TRACKER_TYPE"] = "Tracker type"
+L["OPT_TRACKER_TYPE_DESC"] = "Choose whether this tracker uses one shared frame or separate frames per group member."
+L["OPT_TRACKER_TYPE_NORMAL"] = "Normal tracker"
+L["OPT_TRACKER_TYPE_GROUP"] = "Group-based tracker"
+L["OPT_TRACKER_PER_MEMBER"] = "Create one frame per group member"
+L["OPT_TRACKER_PER_MEMBER_DESC"] = "Use separate tracker frames for each party member instead of a single shared tracker frame."
+L["OPT_INCLUDE_SELF_FRAME"] = "Create a frame for your own player too"
+L["OPT_INCLUDE_SELF_FRAME_DESC"] = "Also provision a dedicated frame for your own player on group-based trackers."
+L["OPT_ADD_TRACKER"]      = "Add tracker"
+L["OPT_REMOVE_TRACKER"]   = "Remove tracker"
+L["OPT_REMOVE_TRACKER_CONFIRM"] = 'Really remove tracker "%s"?'
+L["OPT_TRACKERS_EMPTY"]   = "No tracker bars configured yet."
+L["OPT_TRACKED_SPELLS_DESC"] = "Changes here apply to all tracker bars that use the spell's categories."
+L["OPT_TRACKED_SPELLS_EMPTY"] = "No spells are currently tracked by your tracker bars."
+L["OPT_TRACKED_SPELLS_NO_MATCH"] = "No spells match the current filters."
+L["OPT_MAP"]              = "Map"
+L["OPT_MAP_PLACEHOLDER"]  = "Map module options will be available here."
+L["OPT_MAP_ENABLED"]      = "Enable map overlay"
+L["OPT_MAP_ICON_SIZE"]    = "Icon size"
+L["OPT_MAP_ALPHA"]        = "Icon alpha"
+L["OPT_MAP_SHOW_LABELS"]  = "Show labels"
+L["OPT_MAP_POI_SECTION"]  = "Custom POIs"
+L["OPT_MAP_POI_MAPID"]    = "Map ID"
+L["OPT_MAP_POI_X"]        = "X (0-100)"
+L["OPT_MAP_POI_Y"]        = "Y (0-100)"
+L["OPT_MAP_POI_LABEL"]    = "Label"
+L["OPT_MAP_POI_CATEGORY"] = "Icon"
+L["OPT_MAP_POI_USE_CURRENT"] = "Use current position"
+L["OPT_MAP_POI_USE_CURRENT_DESC"] = "Fill map ID, X and Y from your current player position"
+L["OPT_MAP_POI_ADD"]      = "Add POI"
+L["OPT_MAP_POI_UPDATE"]   = "Update POI"
+L["OPT_MAP_POI_REMOVE_INDEX"] = "Remove index"
+L["OPT_MAP_POI_REMOVE"]   = "Remove POI"
+L["OPT_MAP_POI_LIST"]     = "Current POIs"
+L["OPT_MAP_POI_EMPTY"]    = "No POIs configured."
+L["OPT_MAP_POI_CURRENT_SET"] = "HMGT: current position copied"
+L["OPT_MAP_POI_CURRENT_FAILED"] = "HMGT: could not determine current position"
+L["OPT_MAP_POI_ADDED"]    = "HMGT: POI added"
+L["OPT_MAP_POI_ADD_FAILED"] = "HMGT: could not add POI"
+L["OPT_MAP_POI_UPDATED"]  = "HMGT: POI updated"
+L["OPT_MAP_POI_UPDATE_FAILED"] = "HMGT: could not update POI"
+L["OPT_MAP_POI_REMOVED"]  = "HMGT: POI removed"
+L["OPT_MAP_POI_REMOVE_FAILED"] = "HMGT: could not remove POI"
+L["OPT_GENERAL_SETTINGS"] = "General Settings"
+L["OPT_SHOW_MINIMAP_ICON"] = "Show Minimap Icon"
+L["OPT_COMMANDS"] = "Commands"
+L["OPT_MODULES"] = "Modules"
+L["OPT_MODULE_TRACKER"] = "Tracker"
+L["OPT_MODULE_BUFF_ENDING"] = "Buff Ending"
+L["OPT_MODULE_MAP_OVERLAY"] = "Map Overlay"
+
+-- ── Options: tracker shared ───────────────────────────────────
+L["OPT_SECTION_GENERAL"]  = "General Settings"
+L["OPT_ENABLED"]          = "Enabled"
+L["OPT_ENABLED_DESC"]     = "Enable or disable this tracker"
+L["OPT_DISPLAY_MODE"]     = "Display mode"
+L["OPT_DISPLAY_MODE_DESC"]= "Show as progress bars or icons"
+L["OPT_DISPLAY_BAR"]      = "Progress bars"
+L["OPT_DISPLAY_ICON"]     = "Icons"
+L["OPT_SHOW_SPELL_TOOLTIP"] = "Blizzard tooltip on bars"
+L["OPT_SHOW_SPELL_TOOLTIP_DESC"] = "Show the Blizzard spell tooltip when mousing over a progress bar"
+L["OPT_SHOW_READY_TEXT"]  = "Show ready text"
+L["OPT_SHOW_CHARGES_ON_ICON"] = "Show charges on icon"
+L["OPT_SHOW_REMAINING_ON_ICON"] = "Show remaining time on icon"
+L["OPT_LOCKED"]           = "Lock frame"
+L["OPT_LOCKED_DESC"]      = "Prevent the frame from being moved"
+L["OPT_SHOW_NAME"]        = "Show player names"
+L["OPT_CLASS_COLOR"]      = "Use class colours"
+L["OPT_GROW_DIR"]         = "Grow direction"
+L["OPT_GROW_DOWN"]        = "Downward"
+L["OPT_GROW_UP"]          = "Upward"
+L["OPT_SECTION_ANCHOR"]   = "Anchor"
+L["OPT_ANCHOR_TO"]        = "Anchor to"
+L["OPT_ANCHOR_TO_DESC"]   = "Attach this frame to another frame or to the screen"
+L["OPT_ANCHOR_TARGET_UI"] = "Screen (UIParent)"
+L["OPT_ANCHOR_TARGET_CUSTOM"] = "Custom frame name"
+L["OPT_ANCHOR_CUSTOM_NAME"] = "Custom frame"
+L["OPT_ANCHOR_CUSTOM_NAME_DESC"] = "Global frame name, e.g. ElvUF_Player"
+L["OPT_ATTACH_PARTY_FRAME"] = "Attach to Party Frame"
+L["OPT_ATTACH_PARTY_FRAME_DESC"] = "Anchor each group cooldown frame to its corresponding party unit frame"
+L["OPT_ATTACH_PARTY_SIDE"] = "Attach side"
+L["OPT_ATTACH_PARTY_OFFSET_X"] = "Attach X offset"
+L["OPT_ATTACH_PARTY_OFFSET_Y"] = "Attach Y offset"
+L["OPT_ATTACH_LEFT"] = "Left"
+L["OPT_ATTACH_RIGHT"] = "Right"
+L["OPT_ANCHOR_POINT"]     = "Anchor point"
+L["OPT_ANCHOR_POINT_DESC"]= "Point on this frame to use for anchoring"
+L["OPT_ANCHOR_REL_POINT"] = "Relative point"
+L["OPT_ANCHOR_REL_POINT_DESC"] = "Point on the target frame to anchor to"
+L["OPT_ANCHOR_X"]         = "X offset"
+L["OPT_ANCHOR_Y"]         = "Y offset"
+L["OPT_SHOW_ONLY_ACTIVE"] = "Show only active cooldowns"
+L["OPT_SHOW_ONLY_ACTIVE_DESC"] = "Hide entries that are currently ready"
+L["OPT_SHOW_ONLY_READY"] = "Show only ready cooldowns"
+L["OPT_SHOW_ONLY_READY_DESC"] = "Only show entries that are currently ready"
+L["OPT_READY_SOON_SEC"] = "Ready soon threshold (sec)"
+L["OPT_READY_SOON_SEC_DESC"] = "Show only cooldowns that are ready or below this remaining time (0 = disabled)"
+L["OPT_PREPROVISION_UNKNOWN"] = "Pre-provision unknown players"
+L["OPT_PREPROVISION_UNKNOWN_DESC"] = "Show prefilled spells for group members even before addon hello/sync was received"
+L["OPT_ROLE_FILTER"] = "Role filter"
+L["OPT_ROLE_FILTER_ALL"] = "All"
+L["OPT_ROLE_FILTER_TANK"] = "Tank"
+L["OPT_ROLE_FILTER_HEALER"] = "Healer"
+L["OPT_ROLE_FILTER_DAMAGER"] = "Damage"
+L["OPT_RANGE_CHECK"] = "Range check"
+L["OPT_HIDE_OOR"] = "Hide out of range"
+L["OPT_OOR_ALPHA"] = "Out of range alpha"
+
+L["OPT_SECTION_SIZE"]     = "Size & Width"
+L["OPT_WIDTH"]            = "Width (bars)"
+L["OPT_BAR_HEIGHT"]       = "Bar height"
+L["OPT_ICON_SIZE"]        = "Icon size"
+L["OPT_ICON_COLS"]        = "Icons per row"
+
+L["OPT_SECTION_FONT"]     = "Font"
+L["OPT_FONT"]             = "Typeface"
+L["OPT_FONT_SIZE"]        = "Font size"
+L["OPT_FONT_OUTLINE"]     = "Font outline"
+L["OPT_OUTLINE_NONE"]     = "None"
+L["OPT_OUTLINE_NORMAL"]   = "Outline"
+L["OPT_OUTLINE_THICK"]    = "Thick Outline"
+L["OPT_OUTLINE_MONO"]     = "Monochrome"
+
+L["OPT_SECTION_SPELLS"]   = "Tracked Spells"
+L["OPT_SECTION_CUSTOM_SPELLS"] = "Custom Spells"
+L["OPT_CUSTOM_SPELLS_INFO"] = "Add/remove custom spells for this tracker."
+L["OPT_CUSTOM_SPELLS_ID"] = "Spell ID"
+L["OPT_CUSTOM_SPELLS_CD"] = "Cooldown (sec)"
+L["OPT_CUSTOM_SPELLS_CLASS"] = "Class"
+L["OPT_CUSTOM_SPELLS_SPECS"] = "Specs (optional, e.g. 1,3)"
+L["OPT_CUSTOM_SPELLS_CATEGORY"] = "Category"
+L["OPT_CUSTOM_SPELLS_ADD"] = "Add Spell"
+L["OPT_CUSTOM_SPELLS_REMOVE"] = "Remove SpellID"
+L["OPT_CUSTOM_SPELLS_CURRENT"] = "Current custom spells"
+L["OPT_CUSTOM_SPELLS_EMPTY"] = "No custom spells for this tracker."
+L["OPT_CUSTOM_SPELLS_MSG_ADDED"] = "HMGT: custom spell added"
+L["OPT_CUSTOM_SPELLS_MSG_INVALID"] = "HMGT: invalid custom spell input"
+L["OPT_CUSTOM_SPELLS_MSG_REMOVED"] = "HMGT: custom spell removed"
+L["OPT_CUSTOM_SPELLS_MSG_NOT_FOUND"] = "HMGT: spell not found"
+L["OPT_SPELLS_DESC"]      = "Enable or disable individual spells:\n"
+L["OPT_SPELL_SELECT"]     = "Select spells"
+L["OPT_DISABLED"]         = "Disabled"
+L["OPT_VISIBILITY_NONE"]  = "Hidden everywhere"
+L["OPT_STATUS_MODE"]      = "Mode"
+L["OPT_STATUS_DISPLAY"]   = "Display"
+L["OPT_STATUS_VISIBILITY"]= "Visibility"
+L["OPT_STATUS_GROWTH"]    = "Growth"
+L["OPT_STATUS_ATTACH"]    = "Attach"
+L["OPT_UI_GROUP_MODE"]    = "Mode"
+L["OPT_UI_GROUP_PLACEMENT"] = "Placement"
+L["OPT_UI_GROUP_VISIBILITY"] = "Visibility"
+L["OPT_UI_GROUP_LAYOUT"]  = "Layout"
+L["OPT_UI_GROUP_APPEARANCE"] = "Appearance"
+L["OPT_SPELL_BROWSER"]    = "Spell Browser"
+L["OPT_SPELL_BROWSER_DESC"] = "Filter tracked spells by name or Spell ID and apply quick actions to the visible results."
+L["OPT_SELECTION"]       = "Selection"
+L["OPT_RT_NAME"] = "Raid Timeline"
+L["OPT_RT_ENABLED"] = "Enable Raid Timeline"
+L["OPT_RT_LEAD_TIME"] = "Warning lead time"
+L["OPT_RT_ASSIGNMENT_LEAD_TIME"] = "Assignment lead time"
+L["OPT_RT_ASSIGNMENT_LEAD_TIME_DESC"] = "How many seconds before the planned use the assigned player should be selected."
+L["OPT_RT_ALERT_HEADER"] = "Alert frame"
+L["OPT_RT_UNLOCK"] = "Unlock alert frame"
+L["OPT_RT_PREVIEW"] = "Preview alert"
+L["OPT_RT_ALERT_COLOR"] = "Text colour"
+L["OPT_RT_ALERT_PREVIEW"] = "Tranquility in 5"
+L["OPT_RT_DESC"] = "Create encounter timelines here and open the interactive Ace3 timeline editor for visual planning."
+L["OPT_RT_ALERT_UNLOCKED_HINT"] = "Raid Timeline Alert\nDrag to move"
+L["OPT_RT_ALERT_TEMPLATE"] = "%s in %d"
+L["OPT_RT_ENCOUNTERS_HEADER"] = "Encounter timelines"
+L["OPT_RT_SECTION_GENERAL"] = "General"
+L["OPT_RT_SECTION_MANAGE"] = "Manage encounters"
+L["OPT_RT_ADD_ENCOUNTER_ID"] = "Encounter ID"
+L["OPT_RT_ADD_ENCOUNTER_NAME"] = "Encounter name"
+L["OPT_RT_ADD_RAID"] = "Raid"
+L["OPT_RT_ADD_ENCOUNTER"] = "Add encounter"
+L["OPT_RT_INVALID_ENCOUNTER"] = "HMGT: invalid encounter ID"
+L["OPT_RT_EMPTY"] = "No encounter timelines configured yet."
+L["OPT_RT_ENCOUNTER"] = "Encounter"
+L["OPT_RT_ENCOUNTER_NAME"] = "Name"
+L["OPT_RT_RAID_NAME"] = "Raid"
+L["OPT_RT_RAID_ID"] = "Raid ID"
+L["OPT_RT_RAID_DEFAULT"] = "Encounter"
+L["OPT_RT_DELETE_ENCOUNTER_CONFIRM"] = "Delete raid timeline for encounter %d?"
+L["OPT_RT_DIFFICULTY_HEADER"] = "Difficulties"
+L["OPT_RT_DIFF_LFR"] = "LFR"
+L["OPT_RT_DIFF_NORMAL"] = "Normal"
+L["OPT_RT_DIFF_HEROIC"] = "HC"
+L["OPT_RT_DIFF_MYTHIC"] = "Mythic"
+L["OPT_RT_ADD_TIME"] = "Time (MM:SS)"
+L["OPT_RT_ADD_SPELL"] = "Spell"
+L["OPT_RT_ADD_PLAYER"] = "Target"
+L["OPT_RT_ADD_PLAYER_DESC"] = "Optional. Comma-separated player names or variables like Group1, Group8, GroupEven, GroupOdd. If empty, sends to everyone."
+L["OPT_RT_ADD_ENTRY"] = "Add entry"
+L["OPT_RT_ADD_ENTRY_INVALID"] = "HMGT: invalid raid timeline entry"
+L["OPT_RT_ENTRY_TIME"] = "Time"
+L["OPT_RT_ENTRY_SPELL"] = "Spell"
+L["OPT_RT_ENTRY_PLAYER"] = "Target"
+L["OPT_NOTES_NAME"] = "Notes"
+L["OPT_NOTES_ENABLED"] = "Enable notes"
+L["OPT_NOTES_DESC"] = "Provides an MRT-style notes window with a main note, a personal note and encounter drafts."
+L["OPT_NOTES_OPEN_WINDOW"] = "Open notes window"
+L["OPT_NOTES_OPEN_SETTINGS"] = "Open settings"
+L["OPT_NOTES_WINDOW_TITLE"] = "HMGT Notes"
+L["OPT_NOTES_LIST"] = "Notes"
+L["OPT_NOTES_EDITOR"] = "Editor"
+L["OPT_NOTES_MAIN"] = "Main note"
+L["OPT_NOTES_PERSONAL"] = "Personal note"
+L["OPT_NOTES_DRAFT"] = "Draft"
+L["OPT_NOTES_NEW_DRAFT"] = "New draft"
+L["OPT_NOTES_DUPLICATE"] = "Duplicate"
+L["OPT_NOTES_TITLE"] = "Title"
+L["OPT_NOTES_ENCOUNTER"] = "Encounter"
+L["OPT_NOTES_TEXT"] = "Text"
+L["OPT_NOTES_NO_ENCOUNTER"] = "No encounter"
+L["OPT_NOTES_SEND_CHAT"] = "Send to chat"
+L["OPT_NOTES_SUMMARY"] = "Main note, personal note and %d drafts available."
+L["OPT_RT_TRIGGER"] = "Trigger"
+L["OPT_RT_TRIGGER_TIME"] = "Time"
+L["OPT_RT_TRIGGER_BOSS_ABILITY"] = "Boss ability"
+L["OPT_RT_ACTION"] = "Action"
+L["OPT_RT_ACTION_TEXT"] = "Text"
+L["OPT_RT_ACTION_RAID_COOLDOWN"] = "Raid Cooldown"
+L["OPT_RT_INVALID_TIME"] = "HMGT: invalid time"
+L["OPT_RT_INVALID_SPELL"] = "HMGT: invalid spell ID"
+L["OPT_RT_TIMELINE_VIEWPORT"] = "Timeline window"
+L["OPT_RT_TIMELINE_EMPTY_WINDOW"] = "No cooldowns in the current window."
+L["OPT_RT_TIMELINE_EDITOR"] = "Interactive Timeline"
+L["OPT_RT_OPEN_EDITOR"] = "Open timeline"
+L["OPT_RT_START_TEST"] = "Start timeline test"
+L["OPT_RT_STOP_TEST"] = "Stop test"
+L["OPT_RT_TEST_HINT"] = "Runs the encounter timeline outside of combat so you can verify assignments, whispers and debug output."
+L["OPT_RT_TIMELINE_SCROLL"] = "Scroll timeline"
+L["OPT_RT_TIMELINE_ZOOM"] = "Zoom"
+L["OPT_RT_TIMELINE_HINT"] = "Click the bar to add a cooldown. Drag markers horizontally to change the time. Mousewheel scrolls, Ctrl+Mousewheel zooms."
+L["OPT_RT_ASSIGNMENT_EDITOR"] = "Assignment"
+L["OPT_RT_ASSIGNMENT_NONE"] = "No cooldown selected"
+L["OPT_SPELLS_VISIBLE"]   = "Visible spells"
+L["OPT_SPELLS_ENABLED_COUNT"] = "Enabled"
+L["OPT_FILTER_SEARCH"]    = "Search"
+L["OPT_FILTER_SEARCH_DESC"] = "Search by spell name or Spell ID"
+L["OPT_FILTER_ENABLED_ONLY"] = "Enabled only"
+L["OPT_FILTER_RESET"]     = "Reset filters"
+L["OPT_SELECT_VISIBLE"]   = "Select visible"
+L["OPT_DESELECT_VISIBLE"] = "Deselect visible"
+L["OPT_ALL_SPECS"]        = "All specs"
+L["OPT_CUSTOM_SPELLS_EDITOR"] = "Spell Editor"
+L["OPT_CUSTOM_SPELLS_PREVIEW"] = "Preview"
+L["OPT_CUSTOM_SPELLS_PREVIEW_EMPTY"] = "Enter a spell ID to preview the custom spell."
+L["OPT_CUSTOM_SPELLS_LOAD"] = "Load into editor"
+
+-- ── Tracker titles ────────────────────────────────────────────
+L["IT_TITLE"]  = "|cff00aaffInterrupts|r"
+L["RCD_TITLE"] = "|cffff8800Raid Cooldowns|r"
+L["GCD_TITLE"] = "|cff77dd77Group Cooldowns|r"
+
+-- ── Options: tracker names ────────────────────────────────────
+L["IT_NAME"]   = "Interrupt Tracker"
+L["RCD_NAME"]  = "Raid Cooldown Tracker"
+L["GCD_NAME"]  = "Group Cooldown Tracker"
+L["BEA_NAME"]  = "Buff Ending Announcer"
+L["AEM_NAME"]  = "Auto Enemy Marker"
+
+L["OPT_BEA_ENABLED"] = "Enable buff ending announcer"
+L["OPT_BEA_ENABLED_DESC"] = "Announce tracked buff countdowns in /say"
+L["OPT_BEA_ANNOUNCE_AT"] = "Announce from (sec)"
+L["OPT_BEA_ANNOUNCE_AT_DESC"] = "Start countdown announcements when remaining buff duration is at or below this value"
+L["OPT_BEA_DEFAULT_THRESHOLD"] = "Default threshold (sec)"
+L["OPT_BEA_DEFAULT_THRESHOLD_DESC"] = "Used when you add a new tracked buff"
+L["OPT_BEA_SECTION_GENERAL"] = "General"
+L["OPT_BEA_SECTION_BUFFS"] = "Tracked buffs"
+L["OPT_BEA_ADD_ID"] = "Add Spell ID"
+L["OPT_BEA_ADD_THRESHOLD"] = "Threshold"
+L["OPT_BEA_ADD_THRESHOLD_DESC"] = "Countdown start in seconds for this buff"
+L["OPT_BEA_ADD"] = "Add buff"
+L["OPT_BEA_REMOVE_ID"] = "Remove Spell ID"
+L["OPT_BEA_REMOVE"] = "Remove buff"
+L["OPT_BEA_CURRENT"] = "Current tracked buffs"
+L["OPT_BEA_COL_ICON"] = "Icon"
+L["OPT_BEA_COL_SPELL"] = "Spellname"
+L["OPT_BEA_COL_THRESHOLD"] = "Threshold"
+L["OPT_BEA_COL_ACTION"] = "Action"
+L["OPT_BEA_EMPTY"] = "No buffs configured."
+L["OPT_BEA_MSG_ADDED"] = "HMGT: buff added: %s"
+L["OPT_BEA_MSG_REMOVED"] = "HMGT: buff removed: %s"
+L["OPT_BEA_MSG_INVALID"] = "HMGT: invalid buff spell ID"
+L["OPT_BEA_MSG_NOT_FOUND"] = "HMGT: buff not found"
+L["OPT_BEA_MSG_THRESHOLD_INVALID"] = "HMGT: invalid threshold"
+L["BEA_MSG_TEMPLATE"] = "%s ending in %d"
+
+L["OPT_AEM_ENABLED"] = "Enable auto enemy marking"
+L["OPT_AEM_ENABLED_DESC"] = "Marks configured enemy unit IDs on mouseover with rotating raid markers (out of combat)"
+L["OPT_AEM_RESET_SESSION"] = "Reset marker cycle"
+L["OPT_AEM_SECTION_UNITS"] = "Tracked unit IDs"
+L["OPT_AEM_ADD_ID"] = "Add Unit ID"
+L["OPT_AEM_ADD"] = "Add unit"
+L["OPT_AEM_REMOVE_ID"] = "Remove Unit ID"
+L["OPT_AEM_REMOVE"] = "Remove unit"
+L["OPT_AEM_CURRENT"] = "Current unit IDs"
+L["OPT_AEM_EMPTY"] = "No unit IDs configured."
+L["OPT_AEM_MSG_ADDED"] = "HMGT: unit ID added: %s"
+L["OPT_AEM_MSG_REMOVED"] = "HMGT: unit ID removed: %s"
+L["OPT_AEM_MSG_INVALID"] = "HMGT: invalid unit ID"
+L["OPT_AEM_MSG_NOT_FOUND"] = "HMGT: unit ID not found"
+L["AEM_MSG_COMBAT_BLOCKED"] = "HMGT Auto Enemy Marker: automatic marking is blocked in combat by Blizzard secure restrictions."
+L["AEM_MSG_API_BLOCKED"] = "HMGT Auto Enemy Marker: raid marker API call is blocked in this environment."
+
+-- ── Tooltip ───────────────────────────────────────────────────
+L["TT_DRAG"]        = "|cff00aaffHMGT|r\nDrag to move\n|cffffff00/hmgt lock|r to lock"
+L["TT_REMAINING"]   = "Remaining: "
+L["TT_READY"]       = "Ready!"
+L["TT_UNKNOWN"]     = "Unknown"
+
+-- ── Spell spell-toggle label format ──────────────────────────
+-- used as: string.format(L["SPELL_LABEL"], classStr, name)
+L["SPELL_LABEL"]    = "[%s] %s"
+-- used as: string.format(L["SPELL_DESC"], spellId, cooldown)
+L["SPELL_DESC"]     = "SpellID: %d | Cooldown: %ds"
+
+-- ── Spell categories ─────────────────────────────────────────
+L["CAT_lust"]       = "Bloodlust / Lust"
+L["CAT_offensive"]  = "Offensive Cooldowns"
+L["CAT_defensive"]  = "Defensive Cooldowns"
+L["CAT_tank"]       = "Tank Cooldowns"
+L["CAT_healing"]    = "Healing Cooldowns"
+L["CAT_utility"]    = "Utility"
+L["CAT_cc"]         = "Crowd Control"
+L["CAT_interrupt"]  = "Interrupts"
+L["CAT_raid"]       = "Raid Cooldowns"
+
+-- ── Config spell list ─────────────────────────────────────────
+L["OPT_CD_LABEL"]   = "%s  (%ds)"    -- icon+name, cooldown
+L["OPT_SELECT_ALL"]   = "Select all"
+L["OPT_DESELECT_ALL"] = "Deselect all"
+
+-- ── Bar-Mode options ─────────────────────────────────────────
+L["OPT_BAR_TEXTURE"]        = "Texture"
+L["OPT_BAR_TEXTURE_DESC"]   = "Texture of the progress bar"
+L["OPT_BAR_SPACING"]        = "Bar spacing"
+
+-- ── Icon-Mode options ─────────────────────────────────────────
+L["OPT_GROW_LEFT"]          = "Leftward"
+L["OPT_GROW_RIGHT"]         = "Rightward"
+L["OPT_ICON_COLS_DESC"]     = "Number of icons per row (DOWN/UP) or per column (LEFT/RIGHT)"
+L["OPT_ICON_OVERLAY"]       = "Cooldown display"
+L["OPT_ICON_OVERLAY_DESC"]  = "How to show remaining cooldown on icons"
+L["OPT_ICON_OVERLAY_SWEEP"] = "Cooldown sweep"
+L["OPT_ICON_OVERLAY_TIMER"] = "Text timer (MM:SS)"
+L["OPT_ICON_SPACING"]       = "Icon spacing"
+
+-- ── Visibility options ────────────────────────────────────────
+L["OPT_SECTION_VISIBILITY"] = "Visibility"
+L["OPT_SHOW_SOLO"]          = "Show when solo"
+L["OPT_SHOW_SOLO_DESC"]     = "Show this tracker when not in a group"
+L["OPT_SHOW_GROUP"]         = "Show in group"
+L["OPT_SHOW_GROUP_DESC"]    = "Show this tracker in a party"
+L["OPT_SHOW_RAID"]          = "Show in raid"
+L["OPT_SHOW_RAID_DESC"]     = "Show this tracker in a raid group"
+
+-- ── Border options ──────────────────────────────────────────────
+L["OPT_BORDER_ENABLED"]      = "Show border"
+L["OPT_BORDER_ENABLED_DESC"] = "Show a 1px border around progress bars and icons"
+L["OPT_BORDER_COLOR"]        = "Border color"
+L["OPT_BORDER_COLOR_DESC"]   = "Color of the 1px border"
+
+-- ── Text anchor (icon mode) ───────────────────────────────────
+L["OPT_TEXT_ANCHOR"]        = "Text position"
+L["OPT_TEXT_ANCHOR_DESC"]   = "Where to show name and timer relative to the icon"
+L["OPT_ANCHOR_ON_ICON"]     = "On icon (overlay)"
+L["OPT_ANCHOR_ABOVE"]       = "Above icon"
+L["OPT_ANCHOR_BELOW"]       = "Below icon"
+L["OPT_ANCHOR_LEFT"]        = "Left of icon"
+L["OPT_ANCHOR_RIGHT"]       = "Right of icon"
+
+-- ── Talent mod types (tooltip / desc) ─────────────────────────
+L["TALENTMOD_SET"]          = "Talent sets CD to %ds"
+L["TALENTMOD_MULTIPLY"]     = "Talent multiplies CD by %.2f"
+L["TALENTMOD_REDUCE"]       = "Talent reduces CD by %d%%"
+
+L["OPT_RT_ADD_TEXT"] = "Custom text"
+L["OPT_RT_ENTRY_TEXT"] = "Custom text"
+L["OPT_RT_NO_SPELL"] = "No spell"
+L["OPT_RT_ADD_TYPE"] = "Type"
+L["OPT_RT_ENTRY_TYPE"] = "Type"
+L["OPT_RT_TYPE_SPELL"] = "Spell"
+L["OPT_RT_TYPE_TEXT"] = "Text"
+L["OPT_RT_TYPE_BOSS_ABILITY"] = "Boss ability"
+L["OPT_RT_BOSSMOD"] = "Boss mod"
+L["OPT_RT_BOSS_ABILITY"] = "Boss ability"
+L["OPT_RT_BOSS_BAR_NAME"] = "Bossmod bar name"
+L["OPT_RT_NO_BOSS_ABILITY"] = "No boss ability"
+L["OPT_RT_CAST_COUNT"] = "Cast count"
+L["OPT_RT_CAST_COUNT_DESC"] = "Use a number, All, Odd, or Even."
+L["OPT_RT_CAST"] = "Cast"
+L["OPT_RT_CAST_ALL"] = "All"
+L["OPT_RT_CAST_ODD"] = "Odd"
+L["OPT_RT_CAST_EVEN"] = "Even"
+L["OPT_RT_ADD_TARGETS"] = "Targets"
+L["OPT_RT_ENTRY_TARGETS"] = "Targets"
+L["OPT_RT_TARGETS_DESC"] = "Use All, Odd, Even, raid groups like 1,2, 1-3 or player names separated by commas."

Modules/BuffEndingAnnouncer/BuffEndingAnnouncer.lua

@@ -0,0 +1,472 @@
+-- Modules/BuffEndingAnnouncer/BuffEndingAnnouncer.lua
+-- Announces tracked buffs in SAY shortly before they expire.
+
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+
+local L = LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME, true) or {}
+
+local BEA = HMGT:NewModule("BuffEndingAnnouncer")
+HMGT.BuffEndingAnnouncer = BEA
+
+BEA.runtimeEnabled = false
+BEA.eventFrame = nil
+BEA.ticker = nil
+BEA.lastAnnouncedSecond = {}
+BEA.recentOwnCastAt = {}
+
+local function NormalizeThreshold(value, fallback)
+    local threshold = tonumber(value)
+    if not threshold then
+        threshold = tonumber(fallback) or 5
+    end
+    threshold = math.floor(threshold + 0.5)
+    if threshold < 1 then threshold = 1 end
+    if threshold > 30 then threshold = 30 end
+    return threshold
+end
+
+local function GetSpellName(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then return nil end
+    if C_Spell and type(C_Spell.GetSpellName) == "function" then
+        local name = C_Spell.GetSpellName(sid)
+        if type(name) == "string" and name ~= "" then
+            return name
+        end
+    end
+    if type(GetSpellInfo) == "function" then
+        local name = GetSpellInfo(sid)
+        if type(name) == "string" and name ~= "" then
+            return name
+        end
+    end
+    return nil
+end
+
+local function IsAuraSourcePlayer(sourceUnit)
+    if not sourceUnit then return nil end
+    if sourceUnit == "player" then return true end
+    if type(UnitIsUnit) == "function" and type(UnitExists) == "function" and UnitExists(sourceUnit) then
+        return UnitIsUnit(sourceUnit, "player") and true or false
+    end
+    return false
+end
+
+local function GetPlayerBuffExpiration(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then return nil, nil, nil, nil end
+
+    if C_UnitAuras and type(C_UnitAuras.GetPlayerAuraBySpellID) == "function" then
+        local aura = C_UnitAuras.GetPlayerAuraBySpellID(sid)
+        if aura then
+            local exp = tonumber(aura.expirationTime) or 0
+            if exp > 0 then
+                local isOwnCaster = IsAuraSourcePlayer(aura.sourceUnit)
+                if isOwnCaster == nil and aura.isFromPlayerOrPlayerPet ~= nil then
+                    isOwnCaster = aura.isFromPlayerOrPlayerPet and true or false
+                end
+                return exp, tonumber(aura.duration) or 0, aura.name, isOwnCaster
+            end
+        end
+    end
+
+    if AuraUtil and type(AuraUtil.FindAuraBySpellID) == "function" then
+        local name, _, _, _, duration, expirationTime, sourceUnit, _, _, _, _, _, castByPlayer =
+            AuraUtil.FindAuraBySpellID(sid, "player", "HELPFUL")
+        local exp = tonumber(expirationTime) or 0
+        if name and exp > 0 then
+            local isOwnCaster = IsAuraSourcePlayer(sourceUnit)
+            if isOwnCaster == nil and castByPlayer ~= nil then
+                isOwnCaster = castByPlayer and true or false
+            end
+            return exp, tonumber(duration) or 0, name, isOwnCaster
+        end
+    end
+
+    return nil, nil, nil, nil
+end
+
+local function GetPlayerChannelExpiration(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then return nil, nil, nil, nil end
+
+    if type(UnitChannelInfo) ~= "function" then
+        return nil, nil, nil, nil
+    end
+
+    local name, _, _, startTimeMS, endTimeMS, _, _, channelSpellId = UnitChannelInfo("player")
+    local activeSpellId = tonumber(channelSpellId)
+    if activeSpellId ~= sid then
+        return nil, nil, nil, nil
+    end
+
+    local startTime = tonumber(startTimeMS) or 0
+    local endTime = tonumber(endTimeMS) or 0
+    if endTime <= 0 or endTime <= startTime then
+        return nil, nil, nil, nil
+    end
+
+    return endTime / 1000, (endTime - startTime) / 1000, name, true
+end
+
+local function GetTrackedSpellExpiration(spellId)
+    local expirationTime, duration, name, isOwnCaster = GetPlayerBuffExpiration(spellId)
+    if expirationTime and expirationTime > 0 then
+        return expirationTime, duration, name, isOwnCaster, "aura"
+    end
+
+    expirationTime, duration, name, isOwnCaster = GetPlayerChannelExpiration(spellId)
+    if expirationTime and expirationTime > 0 then
+        return expirationTime, duration, name, isOwnCaster, "channel"
+    end
+
+    return nil, nil, nil, nil, nil
+end
+
+function BEA:GetSettings()
+    local p = HMGT.db and HMGT.db.profile
+    if not p then return nil end
+    p.buffEndingAnnouncer = p.buffEndingAnnouncer or {}
+    p.buffEndingAnnouncer.announceAtSec = NormalizeThreshold(p.buffEndingAnnouncer.announceAtSec, 5)
+    p.buffEndingAnnouncer.trackedBuffs = p.buffEndingAnnouncer.trackedBuffs or {}
+    return p.buffEndingAnnouncer
+end
+
+function BEA:GetDefaultThreshold()
+    local s = self:GetSettings()
+    return NormalizeThreshold(s and s.announceAtSec, 5)
+end
+
+function BEA:GetTrackedBuffThreshold(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then return nil end
+
+    local settings = self:GetSettings()
+    local tracked = settings and settings.trackedBuffs
+    local value = tracked and tracked[sid]
+    if value == nil then
+        return nil
+    end
+
+    if type(value) == "table" then
+        value = value.threshold
+    end
+    if value == true then
+        value = self:GetDefaultThreshold()
+    end
+
+    return NormalizeThreshold(value, self:GetDefaultThreshold())
+end
+
+function BEA:SetTrackedBuffThreshold(spellId, threshold)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then
+        return false
+    end
+
+    local s = self:GetSettings()
+    s.trackedBuffs[sid] = NormalizeThreshold(threshold, self:GetDefaultThreshold())
+    self.lastAnnouncedSecond[sid] = nil
+    self:Refresh()
+    return true
+end
+
+function BEA:GetTrackedBuffEntries()
+    local entries = {}
+    for _, sid in ipairs(self:GetTrackedBuffSpellIds()) do
+        entries[#entries + 1] = {
+            spellId = sid,
+            name = GetSpellName(sid) or ("Spell " .. tostring(sid)),
+            threshold = self:GetTrackedBuffThreshold(sid) or self:GetDefaultThreshold(),
+        }
+    end
+    return entries
+end
+
+function BEA:GetTrackedBuffSpellIds()
+    local ids = {}
+    local settings = self:GetSettings()
+    local tracked = (settings and settings.trackedBuffs) or {}
+    for sid, value in pairs(tracked) do
+        local id = tonumber(sid)
+        if id and id > 0 and value ~= nil and value ~= false then
+            ids[#ids + 1] = id
+        end
+    end
+    table.sort(ids, function(a, b)
+        local nameA = tostring(GetSpellName(a) or a):lower()
+        local nameB = tostring(GetSpellName(b) or b):lower()
+        if nameA == nameB then
+            return a < b
+        end
+        return nameA < nameB
+    end)
+    return ids
+end
+
+function BEA:ResetAnnouncements()
+    for sid in pairs(self.lastAnnouncedSecond) do
+        self.lastAnnouncedSecond[sid] = nil
+    end
+end
+
+function BEA:ResetRecentOwnCasts()
+    for sid in pairs(self.recentOwnCastAt) do
+        self.recentOwnCastAt[sid] = nil
+    end
+end
+
+function BEA:StopTicker()
+    if self.ticker then
+        self.ticker:Cancel()
+        self.ticker = nil
+    end
+end
+
+function BEA:HasTrackedBuffsConfigured()
+    return #self:GetTrackedBuffSpellIds() > 0
+end
+
+function BEA:UpdateRuntimeEventRegistrations()
+    if not self.eventFrame then
+        return
+    end
+
+    self.eventFrame:UnregisterEvent("UNIT_AURA")
+    self.eventFrame:UnregisterEvent("UNIT_SPELLCAST_SUCCEEDED")
+    self.eventFrame:UnregisterEvent("UNIT_SPELLCAST_CHANNEL_START")
+    self.eventFrame:UnregisterEvent("UNIT_SPELLCAST_CHANNEL_UPDATE")
+    self.eventFrame:UnregisterEvent("UNIT_SPELLCAST_CHANNEL_STOP")
+
+    if not self.runtimeEnabled or not self:HasTrackedBuffsConfigured() then
+        return
+    end
+
+    self.eventFrame:RegisterUnitEvent("UNIT_AURA", "player")
+    self.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", "player")
+    self.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_START", "player")
+    self.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_UPDATE", "player")
+    self.eventFrame:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_STOP", "player")
+end
+
+function BEA:EnsureTicker()
+    if self.ticker then return end
+    self.ticker = C_Timer.NewTicker(0.1, function()
+        self:OnTicker()
+    end)
+end
+
+function BEA:IsProfileEnabled()
+    local s = self:GetSettings()
+    return s and s.enabled == true
+end
+
+function BEA:BuildAnnouncement(spellName, secondsLeft)
+    local template = L["BEA_MSG_TEMPLATE"] or "%s ending in %d"
+    return string.format(template, tostring(spellName or "?"), tonumber(secondsLeft) or 0)
+end
+
+function BEA:IsOwnBuffCaster(spellId, isOwnCaster, duration, now)
+    if isOwnCaster == true then
+        return true
+    end
+    if isOwnCaster == false then
+        return false
+    end
+
+    -- Fallback when aura source information is missing:
+    -- only trust a very recent own cast of the tracked spell.
+    local castAt = self.recentOwnCastAt[tonumber(spellId)]
+    if not castAt then
+        return false
+    end
+
+    local maxAge = tonumber(duration) or 0
+    if maxAge < 3 then maxAge = 3 end
+    if maxAge > 12 then maxAge = 12 end
+    return (tonumber(now) or GetTime()) - castAt <= maxAge
+end
+
+function BEA:EvaluateTrackedBuffs()
+    if not self:IsProfileEnabled() then
+        self:ResetAnnouncements()
+        return false
+    end
+
+    local ids = self:GetTrackedBuffSpellIds()
+    if #ids == 0 then
+        self:ResetAnnouncements()
+        return false
+    end
+
+    local now = GetTime()
+    local hasAnyTrackedBuff = false
+
+    for _, sid in ipairs(ids) do
+        local threshold = self:GetTrackedBuffThreshold(sid)
+        local expirationTime, duration, auraName, isOwnCaster, stateKind = GetTrackedSpellExpiration(sid)
+        if expirationTime and expirationTime > now then
+            local isOwnSource = (stateKind == "channel") or self:IsOwnBuffCaster(sid, isOwnCaster, duration, now)
+            if isOwnSource then
+                hasAnyTrackedBuff = true
+                local remaining = expirationTime - now
+                if threshold and remaining > 0 and remaining <= threshold then
+                    local second = math.ceil(remaining - 0.0001)
+                    if second < 1 then second = 1 end
+                    if self.lastAnnouncedSecond[sid] ~= second then
+                        local msg = self:BuildAnnouncement(auraName or GetSpellName(sid) or ("Spell " .. tostring(sid)), second)
+                        SendChatMessage(msg, "SAY")
+                        self.lastAnnouncedSecond[sid] = second
+                    end
+                else
+                    self.lastAnnouncedSecond[sid] = nil
+                end
+            else
+                self.lastAnnouncedSecond[sid] = nil
+            end
+        else
+            self.lastAnnouncedSecond[sid] = nil
+        end
+
+        local castAt = self.recentOwnCastAt[sid]
+        if castAt and (now - castAt) > 30 then
+            self.recentOwnCastAt[sid] = nil
+        end
+    end
+
+    return hasAnyTrackedBuff
+end
+
+function BEA:Refresh()
+    if not self.runtimeEnabled then return end
+    self:UpdateRuntimeEventRegistrations()
+    local active = self:EvaluateTrackedBuffs()
+    if active then
+        self:EnsureTicker()
+    else
+        self:StopTicker()
+    end
+end
+
+function BEA:OnTicker()
+    if not self.runtimeEnabled then
+        self:StopTicker()
+        return
+    end
+    local active = self:EvaluateTrackedBuffs()
+    if not active then
+        self:StopTicker()
+    end
+end
+
+function BEA:OnEvent(event, ...)
+    if event == "UNIT_AURA" then
+        local unit = ...
+        if unit ~= "player" then
+            return
+        end
+    elseif event == "UNIT_SPELLCAST_SUCCEEDED" then
+        local unit, _, spellId = ...
+        if unit == "player" then
+            local sid = tonumber(spellId)
+            if sid and sid > 0 then
+                local s = self:GetSettings()
+                if s and s.trackedBuffs and s.trackedBuffs[sid] then
+                    self.recentOwnCastAt[sid] = GetTime()
+                end
+            end
+        end
+    elseif event == "UNIT_SPELLCAST_CHANNEL_START" or event == "UNIT_SPELLCAST_CHANNEL_UPDATE" or event == "UNIT_SPELLCAST_CHANNEL_STOP" then
+        local unit = ...
+        if unit ~= "player" then
+            return
+        end
+    elseif event == "PLAYER_ENTERING_WORLD" or event == "PLAYER_DEAD" then
+        self:ResetAnnouncements()
+        self:ResetRecentOwnCasts()
+    end
+    self:Refresh()
+end
+
+function BEA:StartRuntime()
+    if not self:IsProfileEnabled() then return end
+    if self.runtimeEnabled then
+        self:Refresh()
+        return
+    end
+
+    self.runtimeEnabled = true
+    if not self.eventFrame then
+        self.eventFrame = CreateFrame("Frame")
+        self.eventFrame:SetScript("OnEvent", function(_, event, ...)
+            self:OnEvent(event, ...)
+        end)
+    end
+    self.eventFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
+    self.eventFrame:RegisterEvent("PLAYER_DEAD")
+    self:Refresh()
+end
+
+function BEA:StopRuntime()
+    if self.eventFrame then
+        self.eventFrame:UnregisterEvent("UNIT_AURA")
+        self.eventFrame:UnregisterEvent("UNIT_SPELLCAST_SUCCEEDED")
+        self.eventFrame:UnregisterEvent("UNIT_SPELLCAST_CHANNEL_START")
+        self.eventFrame:UnregisterEvent("UNIT_SPELLCAST_CHANNEL_UPDATE")
+        self.eventFrame:UnregisterEvent("UNIT_SPELLCAST_CHANNEL_STOP")
+        self.eventFrame:UnregisterEvent("PLAYER_ENTERING_WORLD")
+        self.eventFrame:UnregisterEvent("PLAYER_DEAD")
+    end
+    self.runtimeEnabled = false
+    self:StopTicker()
+    self:ResetAnnouncements()
+    self:ResetRecentOwnCasts()
+end
+
+function BEA:OnInitialize()
+    HMGT.BuffEndingAnnouncer = self
+end
+
+function BEA:OnEnable()
+    self:StartRuntime()
+end
+
+function BEA:OnDisable()
+    self:StopRuntime()
+end
+
+function BEA:AddTrackedBuff(spellId, threshold)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then
+        return false, "invalid"
+    end
+    local name = GetSpellName(sid)
+    if not name then
+        return false, "invalid"
+    end
+
+    local s = self:GetSettings()
+    s.trackedBuffs[sid] = NormalizeThreshold(threshold, self:GetDefaultThreshold())
+    self.lastAnnouncedSecond[sid] = nil
+    self:Refresh()
+    return true, name
+end
+
+function BEA:RemoveTrackedBuff(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then
+        return false, "invalid"
+    end
+
+    local s = self:GetSettings()
+    if not s.trackedBuffs[sid] then
+        return false, "missing"
+    end
+
+    s.trackedBuffs[sid] = nil
+    self.lastAnnouncedSecond[sid] = nil
+    self:Refresh()
+    return true, GetSpellName(sid) or tostring(sid)
+end

Modules/BuffEndingAnnouncer/BuffEndingAnnouncerOptions.lua

@@ -0,0 +1,409 @@
+-- Modules/BuffEndingAnnouncer/BuffEndingAnnouncerOptions.lua
+
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+local BEA = HMGT.BuffEndingAnnouncer
+if not BEA then return end
+if not HMGT_Config or not HMGT_Config.RegisterOptionsProvider then return end
+
+local L = LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME, true) or {}
+local AceConfigRegistry = LibStub("AceConfigRegistry-3.0")
+local beaOptionsGroup
+
+local function GetSpellName(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then return nil end
+    if C_Spell and type(C_Spell.GetSpellName) == "function" then
+        local name = C_Spell.GetSpellName(sid)
+        if type(name) == "string" and name ~= "" then
+            return name
+        end
+    end
+    if type(GetSpellInfo) == "function" then
+        local name = GetSpellInfo(sid)
+        if type(name) == "string" and name ~= "" then
+            return name
+        end
+    end
+    return nil
+end
+
+local function GetSpellIcon(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then return nil end
+    if HMGT_SpellData and type(HMGT_SpellData.GetSpellIcon) == "function" then
+        return HMGT_SpellData.GetSpellIcon(sid)
+    end
+    if C_Spell and type(C_Spell.GetSpellTexture) == "function" then
+        return C_Spell.GetSpellTexture(sid)
+    end
+    local _, _, icon = GetSpellInfo(sid)
+    return icon
+end
+
+local function RefreshTrackedGroup()
+    if not beaOptionsGroup or type(beaOptionsGroup.args) ~= "table" then
+        return
+    end
+
+    local fresh = BEA:BuildOptionsGroup()
+    local currentTracked = beaOptionsGroup.args.tracked
+    local freshTracked = fresh and fresh.args and fresh.args.tracked
+    if type(currentTracked) == "table" and type(freshTracked) == "table" then
+        currentTracked.name = freshTracked.name
+        currentTracked.order = freshTracked.order
+        currentTracked.inline = freshTracked.inline
+        currentTracked.childGroups = freshTracked.childGroups
+        currentTracked.args = freshTracked.args
+    end
+end
+
+local function NotifyOptionsChanged(rebuild)
+    if rebuild ~= false then
+        RefreshTrackedGroup()
+    end
+    AceConfigRegistry:NotifyChange(ADDON_NAME)
+end
+
+local function GetFilterState()
+    HMGT._beaSpellFilter = HMGT._beaSpellFilter or {
+        search = "",
+    }
+    return HMGT._beaSpellFilter
+end
+
+local function NormalizeSearchText(value)
+    local text = tostring(value or ""):lower()
+    text = text:gsub("^%s+", "")
+    text = text:gsub("%s+$", "")
+    return text
+end
+
+local function GetDraft()
+    HMGT._beaDraft = HMGT._beaDraft or {}
+    return HMGT._beaDraft
+end
+
+local function GetTrackedBuffLabel(entry)
+    local spellId = tonumber(entry and entry.spellId) or 0
+    local spellName = tostring(entry and entry.name or GetSpellName(spellId) or ("Spell " .. spellId))
+    local icon = GetSpellIcon(spellId)
+    local threshold = tonumber(entry and entry.threshold) or tonumber(BEA:GetDefaultThreshold()) or 0
+    if icon and icon ~= "" then
+        return string.format("|T%s:16:16:0:0|t %s (%ss)", tostring(icon), spellName, threshold)
+    end
+    return string.format("%s (%ss)", spellName, threshold)
+end
+
+local function BuildTrackedBuffLeaf(entry)
+    local spellId = tonumber(entry and entry.spellId) or 0
+    return {
+        type = "group",
+        name = GetTrackedBuffLabel(entry),
+        args = {
+            header = {
+                type = "header",
+                order = 1,
+                name = GetTrackedBuffLabel(entry),
+            },
+            spellInfo = {
+                type = "description",
+                order = 2,
+                width = "full",
+                name = string.format(
+                    "|cffffd100Spell ID|r: %d\n|cffffd100%s|r: %s",
+                    spellId,
+                    L["OPT_BEA_COL_SPELL"] or "Spellname",
+                    tostring(entry and entry.name or GetSpellName(spellId) or ("Spell " .. spellId))
+                ),
+            },
+            threshold = {
+                type = "range",
+                order = 3,
+                min = 1,
+                max = 60,
+                step = 1,
+                width = "full",
+                name = L["OPT_BEA_COL_THRESHOLD"] or "Threshold",
+                get = function()
+                    local current = BEA:GetTrackedBuffEntries()
+                    for _, candidate in ipairs(current) do
+                        if tonumber(candidate.spellId) == spellId then
+                            return tonumber(candidate.threshold) or BEA:GetDefaultThreshold()
+                        end
+                    end
+                    return tonumber(BEA:GetDefaultThreshold()) or 5
+                end,
+                set = function(_, val)
+                    BEA:SetTrackedBuffThreshold(spellId, val)
+                    NotifyOptionsChanged()
+                end,
+            },
+            remove = {
+                type = "execute",
+                order = 4,
+                width = "full",
+                name = REMOVE or (L["OPT_BEA_REMOVE"] or "Remove buff"),
+                confirm = function()
+                    return string.format("%s?", tostring(entry and entry.name or GetSpellName(spellId) or ("Spell " .. spellId)))
+                end,
+                func = function()
+                    local ok, info = BEA:RemoveTrackedBuff(spellId)
+                    if ok then
+                        HMGT:Print(string.format(L["OPT_BEA_MSG_REMOVED"] or "HMGT: buff removed: %s", tostring(info or spellId)))
+                    else
+                        HMGT:Print(L["OPT_BEA_MSG_NOT_FOUND"] or "HMGT: buff not found")
+                    end
+                    NotifyOptionsChanged()
+                end,
+            },
+        },
+    }
+end
+
+local function IsTrackedBuffVisible(entry)
+    local spellId = tonumber(entry and entry.spellId) or 0
+    if spellId <= 0 then
+        return false
+    end
+
+    local search = NormalizeSearchText(GetFilterState().search)
+    if search == "" then
+        return true
+    end
+
+    local haystack = table.concat({
+        tostring(entry and entry.name or GetSpellName(spellId) or ""),
+        tostring(spellId),
+    }, " "):lower()
+
+    return haystack:find(search, 1, true) ~= nil
+end
+
+local function CountVisibleEntries(entries)
+    local count = 0
+    for _, entry in ipairs(entries or {}) do
+        if IsTrackedBuffVisible(entry) then
+            count = count + 1
+        end
+    end
+    return count
+end
+
+function BEA:BuildOptionsGroup()
+    local draft = GetDraft()
+    local entries = self:GetTrackedBuffEntries()
+
+    local group = {
+        type = "group",
+        name = L["BEA_NAME"] or "Buff Ending Announcer",
+        order = 3,
+        childGroups = "tree",
+        args = {
+            general = {
+                type = "group",
+                order = 1,
+                name = L["OPT_BEA_SECTION_GENERAL"] or "General",
+                args = {
+                    enabled = {
+                        type = "toggle",
+                        order = 1,
+                        width = "full",
+                        name = L["OPT_BEA_ENABLED"] or "Enable buff ending announcer",
+                        desc = L["OPT_BEA_ENABLED_DESC"] or "Announce tracked buff countdowns in /say",
+                        get = function()
+                            return self:GetSettings().enabled == true
+                        end,
+                        set = function(_, val)
+                            self:GetSettings().enabled = val and true or false
+                            if val then
+                                self:Enable()
+                            else
+                                self:Disable()
+                            end
+                        end,
+                    },
+                    defaultThreshold = {
+                        type = "range",
+                        order = 2,
+                        min = 1,
+                        max = 60,
+                        step = 1,
+                        width = "full",
+                        name = L["OPT_BEA_DEFAULT_THRESHOLD"] or "Default threshold (sec)",
+                        desc = L["OPT_BEA_DEFAULT_THRESHOLD_DESC"] or "Used when you add a new tracked buff",
+                        get = function()
+                            return tonumber(self:GetDefaultThreshold()) or 5
+                        end,
+                        set = function(_, val)
+                            self:GetSettings().announceAtSec = math.floor((tonumber(val) or 5) + 0.5)
+                            self:Refresh()
+                        end,
+                    },
+                },
+            },
+            tracked = {
+                type = "group",
+                order = 2,
+                name = string.format(
+                    "%s (%d)",
+                    L["OPT_BEA_SECTION_BUFFS"] or "Tracked buffs",
+                    #entries
+                ),
+                args = {
+                    header = {
+                        type = "header",
+                        order = 1,
+                        name = L["OPT_SPELL_BROWSER"] or "Spell Browser",
+                    },
+                    summary = {
+                        type = "description",
+                        order = 2,
+                        width = "full",
+                        name = function()
+                            local currentEntries = BEA:GetTrackedBuffEntries()
+                            return string.format(
+                                "%s\n\n|cffffd100%s|r: %d\n|cffffd100%s|r: %d",
+                                L["OPT_SPELL_BROWSER_DESC"] or "Filter tracked spells by name or Spell ID and apply quick actions to the visible results.",
+                                L["OPT_SPELLS_VISIBLE"] or "Visible spells",
+                                CountVisibleEntries(currentEntries),
+                                L["OPT_BEA_SECTION_BUFFS"] or "Tracked buffs",
+                                #currentEntries
+                            )
+                        end,
+                    },
+                    search = {
+                        type = "input",
+                        order = 3,
+                        width = "full",
+                        name = L["OPT_FILTER_SEARCH"] or "Search",
+                        desc = L["OPT_FILTER_SEARCH_DESC"] or "Search by spell name or Spell ID",
+                        get = function()
+                            return GetFilterState().search or ""
+                        end,
+                        set = function(_, val)
+                            GetFilterState().search = val or ""
+                            NotifyOptionsChanged(false)
+                        end,
+                    },
+                    resetFilters = {
+                        type = "execute",
+                        order = 4,
+                        width = "full",
+                        name = L["OPT_FILTER_RESET"] or "Reset filters",
+                        func = function()
+                            GetFilterState().search = ""
+                            NotifyOptionsChanged(false)
+                        end,
+                    },
+                    addGroup = {
+                        type = "group",
+                        order = 5,
+                        inline = true,
+                        name = L["OPT_BEA_CURRENT"] or "Current tracked buffs",
+                        args = {
+                            addSpellId = {
+                                type = "input",
+                                order = 1,
+                                width = 0.9,
+                                name = L["OPT_BEA_ADD_ID"] or "Add Spell ID",
+                                get = function()
+                                    return tostring(draft.addSpellId or "")
+                                end,
+                                set = function(_, val)
+                                    draft.addSpellId = val
+                                end,
+                            },
+                            addThreshold = {
+                                type = "range",
+                                order = 2,
+                                min = 1,
+                                max = 60,
+                                step = 1,
+                                width = 1.1,
+                                name = L["OPT_BEA_ADD_THRESHOLD"] or "Threshold",
+                                desc = L["OPT_BEA_ADD_THRESHOLD_DESC"] or "Countdown start in seconds for this buff",
+                                get = function()
+                                    return tonumber(draft.addThreshold) or tonumber(self:GetDefaultThreshold()) or 5
+                                end,
+                                set = function(_, val)
+                                    draft.addThreshold = tonumber(val) or self:GetDefaultThreshold()
+                                end,
+                            },
+                            addSpell = {
+                                type = "execute",
+                                order = 3,
+                                width = "full",
+                                name = L["OPT_BEA_ADD"] or "Add buff",
+                                func = function()
+                                    local sid = tonumber(draft.addSpellId)
+                                    local threshold = tonumber(draft.addThreshold) or self:GetDefaultThreshold()
+                                    local ok, info = self:AddTrackedBuff(sid, threshold)
+                                    if ok then
+                                        draft.addSpellId = ""
+                                        draft.addThreshold = tonumber(self:GetDefaultThreshold()) or 5
+                                        HMGT:Print(string.format(L["OPT_BEA_MSG_ADDED"] or "HMGT: buff added: %s", tostring(info or sid)))
+                                    else
+                                        HMGT:Print(L["OPT_BEA_MSG_INVALID"] or "HMGT: invalid buff spell ID")
+                                    end
+                                    NotifyOptionsChanged()
+                                end,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    }
+
+    if #entries == 0 then
+        group.args.tracked.args.empty = {
+            type = "description",
+            order = 10,
+            width = "full",
+            name = L["OPT_BEA_EMPTY"] or "No buffs configured.",
+        }
+    else
+        for index, entry in ipairs(entries) do
+            local key = "buff_" .. tostring(tonumber(entry.spellId) or index)
+            local leaf = BuildTrackedBuffLeaf(entry)
+            leaf.order = 10 + index
+            leaf.inline = true
+            leaf.name = " "
+            leaf.hidden = function()
+                return not IsTrackedBuffVisible(entry)
+            end
+            group.args.tracked.args[key] = leaf
+        end
+
+        group.args.tracked.args.noVisible = {
+            type = "description",
+            order = 1000,
+            width = "full",
+            hidden = function()
+                return CountVisibleEntries(BEA:GetTrackedBuffEntries()) > 0
+            end,
+            name = L["OPT_BEA_EMPTY"] or "No buffs configured.",
+        }
+    end
+
+    return group
+end
+
+function BEA:GetOptionsGroup()
+    if not beaOptionsGroup then
+        beaOptionsGroup = self:BuildOptionsGroup()
+    else
+        RefreshTrackedGroup()
+    end
+    return beaOptionsGroup
+end
+
+HMGT_Config:RegisterOptionsProvider("announcer.buffEndingAnnouncer", function()
+    return {
+        path = "announcer",
+        order = 3,
+        group = BEA:GetOptionsGroup(),
+    }
+end)

Modules/MapOverlay/MapOverlay.xml

@@ -0,0 +1,11 @@
+<Ui xmlns="http://www.blizzard.com/wow/ui/">
+    <Button name="HMGTMapOverlayPinTemplate" mixin="HMGTMapOverlayPinMixin" virtual="true">
+        <Size x="16" y="16" />
+        <Scripts>
+            <OnLoad method="OnLoad" />
+            <OnEnter method="OnMouseEnter" />
+            <OnLeave method="OnMouseLeave" />
+            <OnClick method="OnClick" />
+        </Scripts>
+    </Button>
+</Ui>

Modules/MapOverlay/MapOverlayIconConfig.lua

@@ -0,0 +1,37 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+
+local MEDIA_PATH = "Interface\\AddOns\\HailMaryGuildTools\\Modules\\MapOverlay\\Media\\"
+local BLIP_TEXTURE = "Interface\\Minimap\\ObjectIconsAtlas"
+
+-- Curated list of allowed Map Overlay icons.
+-- Add, remove, or reorder entries here without touching the runtime module.
+-- Supported fields per icon:
+-- key, label, texture
+-- atlasIndex + atlasSize = "32x32" (optionally textureWidth, textureHeight, atlasColumns)
+-- or exact iconCoords = { left, right, top, bottom }
+-- or exact cell = { col, row } for fixed 32x32 sheets
+-- Note: 32x32 ObjectIconsAtlas minimap blips are rendered through Blizzard's
+-- legacy ObjectIcons coordinate path internally, so the visible crop stays exact.
+HMGT.MapOverlayIconConfig = {
+    defaultKey = "default",
+    icons = {
+        { key = "default", label = "Default", texture = MEDIA_PATH .. "DefaultIcon.png" },
+        { key = "auctionhouse", label = "Auction House", texture = BLIP_TEXTURE, atlasIndex = 16, atlasSize = "32x32", aliases = { "auction_house" } },
+        { key = "bank", label = "Bank", texture = BLIP_TEXTURE, atlasIndex = 17, atlasSize = "32x32" },
+        { key = "battlemaster", label = "Battlemaster", texture = BLIP_TEXTURE, atlasIndex = 18, atlasSize = "32x32" },
+        { key = "classtrainer", label = "Class Trainer", texture = BLIP_TEXTURE, atlasIndex = 19, atlasSize = "32x32", aliases = { "class_trainer" } },
+        { key = "fooddrink", label = "Food & Drink", texture = BLIP_TEXTURE, atlasIndex = 21, atlasSize = "32x32", aliases = { "food_drink" } },
+        { key = "innkeeper", label = "Innkeeper", texture = BLIP_TEXTURE, atlasIndex = 22, atlasSize = "32x32" },
+        { key = "poisons", label = "Poisons", texture = BLIP_TEXTURE, atlasIndex = 24, atlasSize = "32x32" },
+        { key = "professiontrainer", label = "Profession Trainer", texture = BLIP_TEXTURE, atlasIndex = 25, atlasSize = "32x32", aliases = { "profession_trainer" } },
+        { key = "reagents", label = "Reagents", texture = BLIP_TEXTURE, atlasIndex = 26, atlasSize = "32x32" },
+        { key = "repairs", label = "Repairs", texture = BLIP_TEXTURE, atlasIndex = 27, atlasSize = "32x32" },      
+        { key = "blueblip", label = "Blue Blip", texture = BLIP_TEXTURE, atlasIndex = 0, atlasSize = "32x32", aliases = { "blip_blue" } },
+        { key = "lightblueblip", label = "Light Blue Blip", texture = BLIP_TEXTURE, atlasIndex = 1, atlasSize = "32x32", aliases = { "blip_lightblue" } },
+        { key = "redblip", label = "Red Blip", texture = BLIP_TEXTURE, atlasIndex = 2, atlasSize = "32x32", aliases = { "blip_red" } },
+        { key = "yellowblip", label = "Yellow Blip", texture = BLIP_TEXTURE, atlasIndex = 3, atlasSize = "32x32", aliases = { "blip_yellow" } },
+        { key = "greenblip", label = "Green Blip", texture = BLIP_TEXTURE, atlasIndex = 4, atlasSize = "32x32", aliases = { "blip_green" } },
+    },
+}

Modules/MapOverlay/MapOverlayOptions.lua

@@ -0,0 +1,554 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+
+local MapOverlay = HMGT.MapOverlay
+if not MapOverlay then return end
+if not HMGT_Config or not HMGT_Config.RegisterOptionsProvider then return end
+
+local L = LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME, true) or {}
+local AceConfigRegistry = LibStub("AceConfigRegistry-3.0", true)
+
+local MAX_POI_EDITOR_ROWS = 40
+
+local function NotifyOptionsChanged()
+    if AceConfigRegistry and type(AceConfigRegistry.NotifyChange) == "function" then
+        AceConfigRegistry:NotifyChange(ADDON_NAME)
+    end
+end
+
+local function MapCategoryValues()
+    if HMGT.GetMapPOICategoryValues then
+        return HMGT:GetMapPOICategoryValues()
+    end
+    return { default = "Default" }
+end
+
+local function GetMapPOIs()
+    local profile = HMGT.db and HMGT.db.profile
+    if not profile then
+        return {}
+    end
+    profile.mapOverlay = profile.mapOverlay or {}
+    profile.mapOverlay.pois = profile.mapOverlay.pois or {}
+    return profile.mapOverlay.pois
+end
+
+local function HasPOIAt(index)
+    return GetMapPOIs()[index] ~= nil
+end
+
+local function HasAnyPOIs()
+    return GetMapPOIs()[1] ~= nil
+end
+
+local function GetPoiCount()
+    local count = 0
+    for _ in ipairs(GetMapPOIs()) do
+        count = count + 1
+    end
+    return count
+end
+
+local function EnsurePoiDraft(index)
+    local poi = GetMapPOIs()[index]
+    if not poi then
+        return nil
+    end
+
+    HMGT._mapPoiDrafts = HMGT._mapPoiDrafts or {}
+    local draft = HMGT._mapPoiDrafts[index]
+    if not draft then
+        draft = {
+            mapID = tostring(tonumber(poi.mapID) or ""),
+            x = string.format("%.2f", tonumber(poi.x) or 0),
+            y = string.format("%.2f", tonumber(poi.y) or 0),
+            label = tostring(poi.label or ""),
+            category = tostring(poi.category or "default"),
+        }
+        HMGT._mapPoiDrafts[index] = draft
+    end
+
+    return draft
+end
+
+local function BuildPoiEditorGroupArgs()
+    local function GetPoiTitle(index)
+        local poi = GetMapPOIs()[index]
+        if not poi then
+            return string.format("POI #%d", index)
+        end
+        return tostring(poi.label or ("POI " .. index))
+    end
+
+    local args = {
+    }
+
+    for index = 1, MAX_POI_EDITOR_ROWS do
+        local row = index
+        args["poi_" .. index] = {
+            type = "group",
+            name = function()
+                return GetPoiTitle(row)
+            end,
+            icon = function()
+                local poi = GetMapPOIs()[row]
+                if not poi or not MapOverlay.GetCategoryVisual then
+                    return poi and poi.icon or nil
+                end
+                local texture = MapOverlay:GetCategoryVisual(poi.category)
+                return texture or poi.icon or nil
+            end,
+            iconCoords = function()
+                local poi = GetMapPOIs()[row]
+                if not poi or not MapOverlay.GetCategoryVisual then
+                    return poi and poi.iconCoords or nil
+                end
+                local _, iconCoords = MapOverlay:GetCategoryVisual(poi.category)
+                return iconCoords or poi.iconCoords or nil
+            end,
+            order = 20 + index,
+            hidden = function()
+                return not HasPOIAt(row)
+            end,
+            args = {
+                details = {
+                    type = "description",
+                    order = 0.5,
+                    width = "full",
+                    name = function()
+                        local poi = GetMapPOIs()[row]
+                        if not poi then
+                            return "POI not found."
+                        end
+
+                        local categoryValues = MapCategoryValues()
+                        local category = tostring(poi.category or "default")
+                        local categoryLabel = categoryValues[category] or category
+                        return string.format(
+                            "Map-ID: %d\nX: %.2f\nY: %.2f\nIcon: %s",
+                            tonumber(poi.mapID) or 0,
+                            tonumber(poi.x) or 0,
+                            tonumber(poi.y) or 0,
+                            tostring(categoryLabel)
+                        )
+                    end,
+                },
+                mapID = {
+                    type = "input",
+                    order = 1,
+                    width = 0.7,
+                    name = L["OPT_MAP_POI_MAPID"] or "Map ID",
+                    get = function()
+                        local draft = EnsurePoiDraft(row)
+                        return (draft and draft.mapID) or ""
+                    end,
+                    set = function(_, value)
+                        local draft = EnsurePoiDraft(row)
+                        if draft then
+                            draft.mapID = value
+                        end
+                    end,
+                },
+                x = {
+                    type = "input",
+                    order = 2,
+                    width = 0.7,
+                    name = L["OPT_MAP_POI_X"] or "X (0-100)",
+                    get = function()
+                        local draft = EnsurePoiDraft(row)
+                        return (draft and draft.x) or ""
+                    end,
+                    set = function(_, value)
+                        local draft = EnsurePoiDraft(row)
+                        if draft then
+                            draft.x = value
+                        end
+                    end,
+                },
+                y = {
+                    type = "input",
+                    order = 3,
+                    width = 0.7,
+                    name = L["OPT_MAP_POI_Y"] or "Y (0-100)",
+                    get = function()
+                        local draft = EnsurePoiDraft(row)
+                        return (draft and draft.y) or ""
+                    end,
+                    set = function(_, value)
+                        local draft = EnsurePoiDraft(row)
+                        if draft then
+                            draft.y = value
+                        end
+                    end,
+                },
+                label = {
+                    type = "input",
+                    order = 4,
+                    width = "full",
+                    name = L["OPT_MAP_POI_LABEL"] or "Label",
+                    get = function()
+                        local draft = EnsurePoiDraft(row)
+                        return (draft and draft.label) or ""
+                    end,
+                    set = function(_, value)
+                        local draft = EnsurePoiDraft(row)
+                        if draft then
+                            draft.label = value
+                        end
+                    end,
+                },
+                category = {
+                    type = "select",
+                    order = 5,
+                    width = "full",
+                    name = L["OPT_MAP_POI_CATEGORY"] or "Category",
+                    values = function()
+                        return MapCategoryValues()
+                    end,
+                    get = function()
+                        local draft = EnsurePoiDraft(row)
+                        return (draft and draft.category) or "default"
+                    end,
+                    set = function(_, value)
+                        local draft = EnsurePoiDraft(row)
+                        if draft then
+                            draft.category = value
+                        end
+                    end,
+                },
+                waypoint = {
+                    type = "execute",
+                    order = 6,
+                    width = "half",
+                    name = "Waypoint",
+                    func = function()
+                        local poi = GetMapPOIs()[row]
+                        if poi and MapOverlay.ToggleWaypointForPOI then
+                            MapOverlay:ToggleWaypointForPOI(poi)
+                        end
+                    end,
+                },
+                update = {
+                    type = "execute",
+                    order = 7,
+                    width = "half",
+                    name = L["OPT_MAP_POI_UPDATE"] or "Update POI",
+                    func = function()
+                        local draft = EnsurePoiDraft(row)
+                        if not draft then
+                            return
+                        end
+                        local ok = HMGT.UpdateMapPOI and HMGT:UpdateMapPOI(row, draft.mapID, draft.x, draft.y, draft.label, nil, draft.category)
+                        if ok then
+                            if HMGT._mapPoiDrafts then
+                                HMGT._mapPoiDrafts[row] = nil
+                            end
+                            HMGT:Print(L["OPT_MAP_POI_UPDATED"] or "HMGT: POI updated")
+                        else
+                            HMGT:Print(L["OPT_MAP_POI_UPDATE_FAILED"] or "HMGT: could not update POI")
+                        end
+                        NotifyOptionsChanged()
+                    end,
+                },
+                delete = {
+                    type = "execute",
+                    order = 8,
+                    width = "half",
+                    name = L["OPT_MAP_POI_REMOVE"] or "Remove POI",
+                    func = function()
+                        local ok = HMGT.RemoveMapPOI and HMGT:RemoveMapPOI(row)
+                        if ok then
+                            HMGT._mapPoiDrafts = nil
+                            HMGT:Print(L["OPT_MAP_POI_REMOVED"] or "HMGT: POI removed")
+                        else
+                            HMGT:Print(L["OPT_MAP_POI_REMOVE_FAILED"] or "HMGT: could not remove POI")
+                        end
+                        NotifyOptionsChanged()
+                    end,
+                },
+            },
+        }
+    end
+
+    return args
+end
+
+function MapOverlay:GetOptionsGroup()
+    local group = {
+        type = "group",
+        name = L["OPT_MODULE_MAP_OVERLAY"] or "Map Overlay",
+        order = 30,
+        childGroups = "tree",
+        args = {
+            general = {
+                type = "group",
+                order = 1,
+                name = GENERAL or "General",
+                args = {
+                    enabled = {
+                        type = "toggle",
+                        order = 1,
+                        width = "full",
+                        name = L["OPT_MAP_ENABLED"] or "Enable map overlay",
+                        get = function()
+                            local profile = HMGT.db and HMGT.db.profile
+                            if not profile then
+                                return true
+                            end
+                            profile.mapOverlay = profile.mapOverlay or {}
+                            return profile.mapOverlay.enabled ~= false
+                        end,
+                        set = function(_, value)
+                            local profile = HMGT.db and HMGT.db.profile
+                            if not profile then
+                                return
+                            end
+                            profile.mapOverlay = profile.mapOverlay or {}
+                            profile.mapOverlay.enabled = value
+                            if MapOverlay.Refresh then
+                                MapOverlay:Refresh()
+                            end
+                        end,
+                    },
+                    iconSize = {
+                        type = "range",
+                        order = 2,
+                        min = 8,
+                        max = 48,
+                        step = 1,
+                        name = L["OPT_MAP_ICON_SIZE"] or "Icon size",
+                        get = function()
+                            local profile = HMGT.db and HMGT.db.profile
+                            if not profile then
+                                return 16
+                            end
+                            profile.mapOverlay = profile.mapOverlay or {}
+                            return profile.mapOverlay.iconSize or 16
+                        end,
+                        set = function(_, value)
+                            local profile = HMGT.db and HMGT.db.profile
+                            if not profile then
+                                return
+                            end
+                            profile.mapOverlay = profile.mapOverlay or {}
+                            profile.mapOverlay.iconSize = value
+                            if MapOverlay.Refresh then
+                                MapOverlay:Refresh()
+                            end
+                        end,
+                    },
+                    alpha = {
+                        type = "range",
+                        order = 3,
+                        min = 0.1,
+                        max = 1,
+                        step = 0.05,
+                        name = L["OPT_MAP_ALPHA"] or "Icon alpha",
+                        get = function()
+                            local profile = HMGT.db and HMGT.db.profile
+                            if not profile then
+                                return 1
+                            end
+                            profile.mapOverlay = profile.mapOverlay or {}
+                            return profile.mapOverlay.alpha or 1
+                        end,
+                        set = function(_, value)
+                            local profile = HMGT.db and HMGT.db.profile
+                            if not profile then
+                                return
+                            end
+                            profile.mapOverlay = profile.mapOverlay or {}
+                            profile.mapOverlay.alpha = value
+                            if MapOverlay.Refresh then
+                                MapOverlay:Refresh()
+                            end
+                        end,
+                    },
+                    showLabels = {
+                        type = "toggle",
+                        order = 4,
+                        width = "full",
+                        name = L["OPT_MAP_SHOW_LABELS"] or "Show labels",
+                        get = function()
+                            local profile = HMGT.db and HMGT.db.profile
+                            if not profile then
+                                return true
+                            end
+                            profile.mapOverlay = profile.mapOverlay or {}
+                            return profile.mapOverlay.showLabels ~= false
+                        end,
+                        set = function(_, value)
+                            local profile = HMGT.db and HMGT.db.profile
+                            if not profile then
+                                return
+                            end
+                            profile.mapOverlay = profile.mapOverlay or {}
+                            profile.mapOverlay.showLabels = value
+                            if MapOverlay.Refresh then
+                                MapOverlay:Refresh()
+                            end
+                        end,
+                    },
+                    poiSection = {
+                        type = "header",
+                        order = 10,
+                        name = L["OPT_MAP_POI_SECTION"] or "Custom POIs",
+                    },
+                    poiSummary = {
+                        type = "description",
+                        order = 10.1,
+                        width = "full",
+                        name = function()
+                            local count = GetPoiCount()
+                            if count <= 0 then
+                                return L["OPT_MAP_POI_EMPTY"] or "No POIs configured."
+                            end
+                            return string.format(
+                                "%s: %d\n%s",
+                                L["OPT_MAP_POI_LIST"] or "Current POIs",
+                                count,
+                                L["OPT_MAP_POI_SELECT_HINT"] or "Select a POI in the tree on the left to edit it."
+                            )
+                        end,
+                    },
+                    draftMapID = {
+                        type = "input",
+                        order = 11,
+                        width = 0.8,
+                        name = L["OPT_MAP_POI_MAPID"] or "Map ID",
+                        get = function()
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            if not HMGT._mapDraft.mapID and MapOverlay.GetActiveMapID then
+                                local activeMap = MapOverlay:GetActiveMapID()
+                                if activeMap then
+                                    HMGT._mapDraft.mapID = tostring(activeMap)
+                                end
+                            end
+                            return HMGT._mapDraft.mapID or ""
+                        end,
+                        set = function(_, value)
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            HMGT._mapDraft.mapID = value
+                        end,
+                    },
+                    useCurrentPosition = {
+                        type = "execute",
+                        order = 11.1,
+                        width = "half",
+                        name = L["OPT_MAP_POI_USE_CURRENT"] or "Use current position",
+                        desc = L["OPT_MAP_POI_USE_CURRENT_DESC"] or "Fill map ID, X and Y from your current player position",
+                        func = function()
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            local mapID, x, y = nil, nil, nil
+                            if HMGT.GetCurrentMapPOIData then
+                                mapID, x, y = HMGT:GetCurrentMapPOIData()
+                            end
+
+                            if mapID and x and y then
+                                HMGT._mapDraft.mapID = tostring(mapID)
+                                HMGT._mapDraft.x = string.format("%.2f", x)
+                                HMGT._mapDraft.y = string.format("%.2f", y)
+                                HMGT:Print(L["OPT_MAP_POI_CURRENT_SET"] or "HMGT: current position copied")
+                            else
+                                HMGT:Print(L["OPT_MAP_POI_CURRENT_FAILED"] or "HMGT: could not determine current position")
+                            end
+                            NotifyOptionsChanged()
+                        end,
+                    },
+                    draftX = {
+                        type = "input",
+                        order = 12,
+                        width = 0.8,
+                        name = L["OPT_MAP_POI_X"] or "X (0-100)",
+                        get = function()
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            return HMGT._mapDraft.x or ""
+                        end,
+                        set = function(_, value)
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            HMGT._mapDraft.x = value
+                        end,
+                    },
+                    draftY = {
+                        type = "input",
+                        order = 13,
+                        width = 0.8,
+                        name = L["OPT_MAP_POI_Y"] or "Y (0-100)",
+                        get = function()
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            return HMGT._mapDraft.y or ""
+                        end,
+                        set = function(_, value)
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            HMGT._mapDraft.y = value
+                        end,
+                    },
+                    draftLabel = {
+                        type = "input",
+                        order = 14,
+                        width = "full",
+                        name = L["OPT_MAP_POI_LABEL"] or "Label",
+                        get = function()
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            return HMGT._mapDraft.label or ""
+                        end,
+                        set = function(_, value)
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            HMGT._mapDraft.label = value
+                        end,
+                    },
+                    draftCategory = {
+                        type = "select",
+                        order = 14.1,
+                        width = "full",
+                        name = L["OPT_MAP_POI_CATEGORY"] or "Category",
+                        values = function()
+                            return MapCategoryValues()
+                        end,
+                        get = function()
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            return HMGT._mapDraft.category or "default"
+                        end,
+                        set = function(_, value)
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            HMGT._mapDraft.category = value
+                        end,
+                    },
+                    addPoi = {
+                        type = "execute",
+                        order = 15,
+                        width = "half",
+                        name = L["OPT_MAP_POI_ADD"] or "Add POI",
+                        func = function()
+                            HMGT._mapDraft = HMGT._mapDraft or {}
+                            local draft = HMGT._mapDraft
+                            local ok = HMGT.AddMapPOI and HMGT:AddMapPOI(draft.mapID, draft.x, draft.y, draft.label, nil, draft.category or "default")
+                            if ok then
+                                HMGT._mapPoiDrafts = nil
+                                HMGT:Print(L["OPT_MAP_POI_ADDED"] or "HMGT: POI added")
+                            else
+                                HMGT:Print(L["OPT_MAP_POI_ADD_FAILED"] or "HMGT: could not add POI")
+                            end
+                            NotifyOptionsChanged()
+                        end,
+                    },
+                },
+            },
+        },
+    }
+
+    for key, value in pairs(BuildPoiEditorGroupArgs()) do
+        group.args[key] = value
+    end
+
+    return group
+end
+
+HMGT_Config:RegisterOptionsProvider("map.overlay", function()
+    return {
+        path = "map.overlay",
+        order = 30,
+        group = MapOverlay:GetOptionsGroup(),
+    }
+end)

Modules/RaidTimeline/RaidTimelineBigWigs.lua

@@ -0,0 +1,202 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+
+local RT = HMGT.RaidTimeline
+if not RT then return end
+
+local function TrimText(value)
+    local text = tostring(value or "")
+    text = string.gsub(text, "^%s+", "")
+    text = string.gsub(text, "%s+$", "")
+    return text
+end
+
+local function StripBarDisplayText(value)
+    local text = tostring(value or "")
+    text = string.gsub(text, "|T.-|t", "")
+    text = string.gsub(text, "|c%x%x%x%x%x%x%x%x", "")
+    text = string.gsub(text, "|r", "")
+    return TrimText(text)
+end
+
+local function NormalizeBossAbilityBarName(value)
+    local text = TrimText(value)
+    if text == "" then
+        return ""
+    end
+    text = string.gsub(text, "%s*%(%d+%)%s*$", "")
+    text = string.gsub(text, "%s*%([Cc]ount%)%s*$", "")
+    text = string.gsub(text, "^%s*%[([A-Za-z])%]%s*", "%1 ")
+    text = string.gsub(text, "%s*%[([A-Za-z])%]%s*$", " (%1)")
+    text = string.gsub(text, "%s*%(([A-Za-z])%)%s*$", " (%1)")
+    text = string.lower(text)
+    return TrimText(text)
+end
+
+local function EnsureBigWigsBridge()
+    if RT._bigWigsBridgeRegistered == true then
+        return true
+    end
+    if type(BigWigsLoader) ~= "table" or type(BigWigsLoader.RegisterMessage) ~= "function" then
+        return false
+    end
+
+    RT._bigWigsObservedBars = RT._bigWigsObservedBars or setmetatable({}, { __mode = "k" })
+    RT._bigWigsReceiver = RT._bigWigsReceiver or {}
+
+    function RT._bigWigsReceiver:OnBigWigsBarCreated(_, plugin, bar, module, key, text, time)
+        RT._bigWigsObservedBars[bar] = {
+            plugin = plugin,
+            module = module,
+            key = key,
+            createdText = tostring(text or ""),
+            duration = tonumber(time) or 0,
+        }
+    end
+
+    function RT._bigWigsReceiver:OnBigWigsStopBar(_, plugin, module, text)
+        local targetText = StripBarDisplayText(text)
+        for bar, info in pairs(RT._bigWigsObservedBars) do
+            local currentText = ""
+            if type(bar) == "table" and type(bar.GetText) == "function" then
+                currentText = StripBarDisplayText(bar:GetText())
+            end
+            if (info and info.plugin == plugin or not info or not info.plugin)
+                and (currentText == targetText or StripBarDisplayText(info and info.createdText) == targetText) then
+                RT._bigWigsObservedBars[bar] = nil
+            end
+        end
+    end
+
+    BigWigsLoader.RegisterMessage(RT._bigWigsReceiver, "BigWigs_BarCreated", "OnBigWigsBarCreated")
+    BigWigsLoader.RegisterMessage(RT._bigWigsReceiver, "BigWigs_StopBar", "OnBigWigsStopBar")
+    RT._bigWigsBridgeRegistered = true
+    return true
+end
+
+function RT:GetObservedBigWigsBars()
+    local observed = {}
+    if not EnsureBigWigsBridge() then
+        return observed
+    end
+
+    for bar, info in pairs(self._bigWigsObservedBars or {}) do
+        local rawText = nil
+        if type(bar) == "table" and type(bar.GetText) == "function" then
+            rawText = bar:GetText()
+        end
+        rawText = StripBarDisplayText(rawText or (info and info.createdText) or "")
+        local remaining = math.max(0, tonumber(bar and bar.remaining) or 0)
+        if rawText ~= "" and remaining > 0 then
+            observed[#observed + 1] = {
+                rawText = rawText,
+                normalizedName = NormalizeBossAbilityBarName(rawText),
+                count = tonumber(string.match(rawText, "%((%d+)%)%s*$")) or 1,
+                seconds = remaining,
+                key = info and info.key or nil,
+            }
+        else
+            self._bigWigsObservedBars[bar] = nil
+        end
+    end
+
+    return observed
+end
+
+function RT:ProbeBossAbilityEntry(entryIndex, entry)
+    if not self:IsLocalEditor() or not self.activeEncounterId or self:GetTriggerType(entry) ~= "bossAbility" then
+        return
+    end
+
+    local desiredRawName = TrimText(entry and entry.bossAbilityBarName or "")
+    local desiredName = NormalizeBossAbilityBarName(desiredRawName)
+    local desiredSelector = self:NormalizeCastCountSelector(entry and entry.castCount)
+    local desiredSelectorText = self:FormatCastCountSelector(desiredSelector)
+    if desiredName == "" then
+        self:LogBossAbilityProbe(
+            entryIndex,
+            entry,
+            "missing-bar-name",
+            "RaidTimeline BigWigs probe encounter=%s slot=%s skipped=missing-bar-name",
+            tostring(self.activeEncounterId),
+            tostring(entryIndex)
+        )
+        return
+    end
+
+    local bars = self:GetObservedBigWigsBars()
+    if #bars == 0 then
+        self:LogBossAbilityProbe(
+            entryIndex,
+            entry,
+            "no-bars",
+            "RaidTimeline BigWigs probe encounter=%s slot=%s target=%s normalized=%s selector=%s foundBar=false bars=0",
+            tostring(self.activeEncounterId),
+            tostring(entryIndex),
+            tostring(desiredRawName),
+            tostring(desiredName),
+            tostring(desiredSelectorText)
+        )
+        return
+    end
+
+    local seenNames = {}
+    local foundName = false
+    for _, observed in ipairs(bars) do
+        seenNames[#seenNames + 1] = string.format("%s{key=%s}[%d]=%.1fs", tostring(observed.rawText), tostring(observed.key), tonumber(observed.count) or 1, tonumber(observed.seconds) or 0)
+        if observed.normalizedName == desiredName then
+            foundName = true
+            if self:DoesCastCountSelectorMatch(desiredSelector, observed.count) then
+                self:LogBossAbilityProbe(
+                    entryIndex,
+                    entry,
+                    string.format("match:%s:%s:%d", desiredName, tostring(desiredSelector), tonumber(observed.count) or 1),
+                    "RaidTimeline BigWigs probe encounter=%s slot=%s target=%s normalized=%s selector=%s foundBar=true countMatch=true observed=%s key=%s observedCount=%d remaining=%.1f",
+                    tostring(self.activeEncounterId),
+                    tostring(entryIndex),
+                    tostring(desiredRawName),
+                    tostring(desiredName),
+                    tostring(desiredSelectorText),
+                    tostring(observed.rawText),
+                    tostring(observed.key),
+                    tonumber(observed.count) or 1,
+                    tonumber(observed.seconds) or 0
+                )
+                self:TryDispatchBossAbilityEntry(entryIndex, entry, observed.count, observed.seconds)
+                return
+            end
+
+            self:LogBossAbilityProbe(
+                entryIndex,
+                entry,
+                string.format("count-mismatch:%s:%d", desiredName, observed.count),
+                "RaidTimeline BigWigs probe encounter=%s slot=%s target=%s normalized=%s selector=%s foundBar=true countMatch=false observed=%s key=%s observedCount=%d remaining=%.1f",
+                tostring(self.activeEncounterId),
+                tostring(entryIndex),
+                tostring(desiredRawName),
+                tostring(desiredName),
+                tostring(desiredSelectorText),
+                tostring(observed.rawText),
+                tostring(observed.key),
+                tonumber(observed.count) or 1,
+                tonumber(observed.seconds) or 0
+            )
+        end
+    end
+
+    if not foundName then
+        self:LogBossAbilityProbe(
+            entryIndex,
+            entry,
+            string.format("name-miss:%s", desiredName),
+            "RaidTimeline BigWigs probe encounter=%s slot=%s target=%s normalized=%s selector=%s foundBar=false bars=%s",
+            tostring(self.activeEncounterId),
+            tostring(entryIndex),
+            tostring(desiredRawName),
+            tostring(desiredName),
+            tostring(desiredSelectorText),
+            table.concat(seenNames, ", ")
+        )
+    end
+end

Modules/RaidTimeline/RaidTimelineBossAbilityData.lua

@@ -0,0 +1,52 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+
+HMGT.RaidTimelineBossAbilityData = HMGT.RaidTimelineBossAbilityData or {
+    raids = {
+        --[[
+        {
+            name = "Void Spire",
+            journalInstanceId = 1307,
+            bosses = {
+                [3176] = {
+                    name = "Imperator Averzian",
+                    abilities = {
+                        {
+                            key = "gloom",
+                            name = "Gloom",
+                            spellId = 123456,
+                            icon = 1234567,
+                            difficulties = {
+                                lfr = false,
+                                normal = true,
+                                heroic = true,
+                                mythic = true,
+                            },
+                            triggers = {
+                                bigwigs = { 123456, "gloom" },
+                                dbm = { 123456 },
+                            },
+                        },
+                        {
+                            key = "mythic_gloom",
+                            name = "Mythic Gloom",
+                            spellId = 123457,
+                            difficulties = {
+                                lfr = false,
+                                normal = false,
+                                heroic = false,
+                                mythic = true,
+                            },
+                            triggers = {
+                                bigwigs = { 123457 },
+                                dbm = { 123457 },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        ]]
+    },
+}

Modules/RaidTimeline/RaidTimelineDBM.lua

@@ -0,0 +1,8 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+
+local RT = HMGT.RaidTimeline
+if not RT then return end
+
+-- Placeholder for later DBM-specific raid timeline integration.

Modules/RaidTimeline/RaidTimelineOptions.lua

@@ -0,0 +1,799 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+
+local RT = HMGT.RaidTimeline
+if not RT then return end
+if not HMGT_Config or not HMGT_Config.RegisterOptionsProvider then return end
+
+local L = LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME, true) or {}
+local AceConfigRegistry = LibStub("AceConfigRegistry-3.0")
+local LSM = LibStub("LibSharedMedia-3.0", true)
+
+local FONT_OUTLINE_VALUES = {
+    NONE = NONE or "None",
+    OUTLINE = "Outline",
+    THICKOUTLINE = "Thick Outline",
+    MONOCHROME = "Monochrome",
+    ["OUTLINE,MONOCHROME"] = "Outline Monochrome",
+}
+
+local DIFFICULTY_KEYS = { "lfr", "normal", "heroic", "mythic" }
+local MAX_ENTRY_ROWS = 24
+local raidTimelineOptionsGroup
+local raidCooldownSpellValuesCache
+local bossAbilityValuesCache = {}
+
+local function ClearOptionCaches()
+    raidCooldownSpellValuesCache = nil
+    bossAbilityValuesCache = {}
+end
+
+local function Notify(rebuild)
+    if rebuild then
+        ClearOptionCaches()
+    end
+    if rebuild and raidTimelineOptionsGroup then
+        local fresh = RT:GetOptionsGroup()
+        raidTimelineOptionsGroup.name = fresh.name
+        raidTimelineOptionsGroup.order = fresh.order
+        raidTimelineOptionsGroup.childGroups = fresh.childGroups
+        raidTimelineOptionsGroup.args = fresh.args
+    end
+    AceConfigRegistry:NotifyChange(ADDON_NAME)
+end
+
+local function GetDrafts()
+    HMGT._raidTimelineDraft = HMGT._raidTimelineDraft or {
+        addEncounterId = "",
+        addEncounterName = "",
+        entries = {},
+    }
+    HMGT._raidTimelineDraft.entries = HMGT._raidTimelineDraft.entries or {}
+    return HMGT._raidTimelineDraft
+end
+
+local function TrimText(value)
+    return tostring(value or ""):gsub("^%s+", ""):gsub("%s+$", "")
+end
+
+local function GetEncounterDraft(encounterId)
+    local drafts = GetDrafts()
+    local key = tostring(tonumber(encounterId) or encounterId or "")
+    drafts.entries[key] = drafts.entries[key] or {
+        time = "",
+        spellId = 0,
+        alertText = "",
+        playerName = "",
+        entryType = "spell",
+        triggerType = "time",
+        actionType = "raidCooldown",
+        targetSpec = "",
+        bossAbilityId = "",
+        bossAbilityBarName = "",
+        castCount = "1",
+    }
+    return drafts.entries[key]
+end
+
+local function GetTriggerTypeValues()
+    return (RT.GetTriggerTypeValues and RT:GetTriggerTypeValues()) or {
+        time = L["OPT_RT_TRIGGER_TIME"] or "Time",
+        bossAbility = L["OPT_RT_TRIGGER_BOSS_ABILITY"] or "Boss ability",
+    }
+end
+
+local function GetActionTypeValues()
+    return (RT.GetActionTypeValues and RT:GetActionTypeValues()) or {
+        text = L["OPT_RT_ACTION_TEXT"] or "Text",
+        raidCooldown = L["OPT_RT_ACTION_RAID_COOLDOWN"] or "Raid Cooldown",
+    }
+end
+
+local function GetEncounterEntry(encounterId, row)
+    local encounter = encounterId and RT:GetEncounter(encounterId)
+    return encounter and encounter.entries and encounter.entries[row] or nil
+end
+
+local function GetTargetFieldLabel(kind, isAddRow)
+    return (isAddRow and (L["OPT_RT_ADD_PLAYER"] or "Target")) or (L["OPT_RT_ENTRY_PLAYER"] or "Target")
+end
+
+local function GetTargetFieldDesc(kind)
+    return L["OPT_RT_ADD_PLAYER_DESC"] or "Optional. Comma-separated player names or variables like Group1, Group8, GroupEven, GroupOdd."
+end
+
+local function FormatEntryTime(value)
+    return RT.FormatTimelineClock and RT:FormatTimelineClock(value) or tostring(value or "")
+end
+
+local function GetBossAbilityValues(encounterId)
+    local encounterKey = tostring(tonumber(encounterId) or encounterId or 0)
+    if bossAbilityValuesCache[encounterKey] then
+        return bossAbilityValuesCache[encounterKey]
+    end
+    local values = RT.GetBossAbilityValues and RT:GetBossAbilityValues(encounterId) or { [""] = L["OPT_RT_NO_BOSS_ABILITY"] or "No boss ability" }
+    bossAbilityValuesCache[encounterKey] = values
+    return values
+end
+
+local function GetDraftTriggerType(encounterId)
+    local draft = GetEncounterDraft(encounterId)
+    draft.triggerType = tostring(draft.triggerType or "time")
+    return draft.triggerType == "bossAbility" and "bossAbility" or "time"
+end
+
+local function GetDraftActionType(encounterId)
+    local draft = GetEncounterDraft(encounterId)
+    draft.actionType = tostring(draft.actionType or "raidCooldown")
+    return draft.actionType == "text" and "text" or "raidCooldown"
+end
+
+local function GetSpellName(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then return nil end
+    if C_Spell and type(C_Spell.GetSpellName) == "function" then
+        local name = C_Spell.GetSpellName(sid)
+        if type(name) == "string" and name ~= "" then
+            return name
+        end
+    end
+    if type(GetSpellInfo) == "function" then
+        local name = GetSpellInfo(sid)
+        if type(name) == "string" and name ~= "" then
+            return name
+        end
+    end
+    return nil
+end
+
+local function GetSpellIcon(spellId)
+    local sid = tonumber(spellId)
+    if not sid or sid <= 0 then return nil end
+    if HMGT_SpellData and type(HMGT_SpellData.GetSpellIcon) == "function" then
+        local icon = HMGT_SpellData.GetSpellIcon(sid)
+        if icon and icon ~= "" then
+            return icon
+        end
+    end
+    if C_Spell and type(C_Spell.GetSpellTexture) == "function" then
+        local icon = C_Spell.GetSpellTexture(sid)
+        if icon and icon ~= "" then
+            return icon
+        end
+    end
+    local _, _, icon = GetSpellInfo(sid)
+    return icon
+end
+
+local function GetRaidCooldownSpellValues()
+    if raidCooldownSpellValuesCache then
+        return raidCooldownSpellValuesCache
+    end
+    local values = { [0] = L["OPT_RT_NO_SPELL"] or "No spell" }
+    local seen = { [0] = true }
+    for _, entry in ipairs(HMGT_SpellData and HMGT_SpellData.RaidCooldowns or {}) do
+        local spellId = tonumber(entry and entry.spellId)
+        if spellId and spellId > 0 and not seen[spellId] then
+            seen[spellId] = true
+            local spellName = GetSpellName(spellId) or tostring(entry.name or ("Spell " .. spellId))
+            local icon = GetSpellIcon(spellId)
+            values[spellId] = icon and icon ~= ""
+                and string.format("|T%s:16:16:0:0|t %s (%d)", tostring(icon), spellName, spellId)
+                or string.format("%s (%d)", spellName, spellId)
+        end
+    end
+    raidCooldownSpellValuesCache = values
+    return values
+end
+
+local function GetDifficultyLabel(key)
+    if key == "lfr" then return L["OPT_RT_DIFF_LFR"] or "LFR" end
+    if key == "heroic" then return L["OPT_RT_DIFF_HEROIC"] or "HC" end
+    if key == "mythic" then return L["OPT_RT_DIFF_MYTHIC"] or "Mythic" end
+    return L["OPT_RT_DIFF_NORMAL"] or "Normal"
+end
+
+local function GetEncounterLabel(encounterId)
+    local encounter = RT:GetEncounter(encounterId)
+    local name = TrimText(encounter and encounter.name or "")
+    if name == "" then
+        name = L["OPT_RT_ENCOUNTER"] or "Encounter"
+    end
+    return string.format("%s (%d)", name, tonumber(encounterId) or 0)
+end
+
+local function GetBossTreeLabel(encounterId)
+    local encounter = RT:GetEncounter(encounterId)
+    local name = TrimText(encounter and encounter.name or "")
+    if name == "" then
+        name = L["OPT_RT_ENCOUNTER"] or "Encounter"
+    end
+    return string.format("%s (%d)", name, #(encounter and encounter.entries or {}))
+end
+
+	local function GetRaidBuckets()
+	    local buckets, raidNames = {}, {}
+	    for _, encounterId in ipairs(RT:GetEncounterIds()) do
+	        local encounter = RT:GetEncounter(encounterId)
+	        if encounter then
+	            local journalInstanceId, instanceName = RT:GetEncounterInstanceInfo(encounterId)
+	            local raidName = tostring(encounter.instanceName or instanceName or (L["OPT_RT_RAID_DEFAULT"] or "Encounter"))
+	            if not buckets[raidName] then
+	                buckets[raidName] = {
+	                    key = tostring(journalInstanceId or raidName),
+	                    ids = {},
+	                    difficulties = { lfr = {}, normal = {}, heroic = {}, mythic = {} },
+	                }
+                table.insert(raidNames, raidName)
+            end
+            table.insert(buckets[raidName].ids, encounterId)
+            for _, difficultyKey in ipairs(DIFFICULTY_KEYS) do
+                if encounter.difficulties and encounter.difficulties[difficultyKey] == true then
+                    table.insert(buckets[raidName].difficulties[difficultyKey], encounterId)
+                end
+            end
+        end
+    end
+    table.sort(raidNames)
+    for _, raidName in ipairs(raidNames) do
+        table.sort(buckets[raidName].ids)
+        for _, difficultyKey in ipairs(DIFFICULTY_KEYS) do
+            table.sort(buckets[raidName].difficulties[difficultyKey])
+        end
+    end
+    return raidNames, buckets
+end
+
+local function BuildEntryEditorArgs(encounterId)
+    local args = {
+        entriesHeader = {
+            type = "header",
+            order = 20,
+            name = L["OPT_RT_ENCOUNTERS_HEADER"] or "Encounter timelines",
+        },
+        addTime = {
+            type = "input", order = 21, width = 0.7, name = L["OPT_RT_ADD_TIME"] or "Time (MM:SS)",
+            disabled = function() return not RT:IsLocalEditor() end,
+            get = function() return tostring(GetEncounterDraft(encounterId).time or "") end,
+            set = function(_, val) GetEncounterDraft(encounterId).time = val end,
+            hidden = function() return GetDraftTriggerType(encounterId) == "bossAbility" end,
+        },
+        addTriggerType = {
+            type = "select", order = 22, width = 0.8, name = L["OPT_RT_TRIGGER"] or "Trigger",
+            disabled = function() return not RT:IsLocalEditor() end,
+            values = GetTriggerTypeValues,
+            get = function() return GetDraftTriggerType(encounterId) end,
+            set = function(_, val)
+                local draft = GetEncounterDraft(encounterId)
+                draft.triggerType = (tostring(val or "") == "bossAbility") and "bossAbility" or "time"
+                if draft.triggerType == "time" then
+                    draft.bossAbilityId = ""
+                    draft.bossAbilityBarName = ""
+                    draft.castCount = "1"
+                end
+                Notify(false)
+            end,
+        },
+        addActionType = {
+            type = "select", order = 22.1, width = 1.0, name = L["OPT_RT_ACTION"] or "Action",
+            disabled = function() return not RT:IsLocalEditor() end,
+            values = GetActionTypeValues,
+            get = function() return GetDraftActionType(encounterId) end,
+            set = function(_, val)
+                local draft = GetEncounterDraft(encounterId)
+                draft.actionType = (tostring(val or "") == "text") and "text" or "raidCooldown"
+                if draft.actionType == "text" then
+                    draft.spellId = 0
+                end
+                Notify(false)
+            end,
+        },
+        addSpellId = {
+            type = "select", order = 23, width = 1.2, name = L["OPT_RT_ADD_SPELL"] or "Spell",
+            disabled = function() return not RT:IsLocalEditor() end,
+            values = GetRaidCooldownSpellValues,
+            get = function() return math.max(0, tonumber(GetEncounterDraft(encounterId).spellId) or 0) end,
+            set = function(_, val) GetEncounterDraft(encounterId).spellId = math.max(0, tonumber(val) or 0) end,
+            hidden = function() return GetDraftActionType(encounterId) ~= "raidCooldown" end,
+        },
+        addCastCount = {
+            type = "input", order = 23.1, width = 0.7, name = L["OPT_RT_CAST_COUNT"] or "Cast count",
+            disabled = function() return not RT:IsLocalEditor() end,
+            desc = L["OPT_RT_CAST_COUNT_DESC"] or "Use a number, All, Odd, or Even.",
+            get = function() return RT:FormatCastCountSelector(GetEncounterDraft(encounterId).castCount or "1") end,
+            set = function(_, val) GetEncounterDraft(encounterId).castCount = RT:NormalizeCastCountSelector(val) end,
+            hidden = function() return GetDraftTriggerType(encounterId) ~= "bossAbility" end,
+        },
+        addBossAbilityBarName = {
+            type = "input", order = 23.2, width = 1.2, name = L["OPT_RT_BOSS_BAR_NAME"] or "Bossmod bar name",
+            disabled = function() return not RT:IsLocalEditor() end,
+            get = function() return tostring(GetEncounterDraft(encounterId).bossAbilityBarName or "") end,
+            set = function(_, val) GetEncounterDraft(encounterId).bossAbilityBarName = tostring(val or "") end,
+            hidden = function() return GetDraftTriggerType(encounterId) ~= "bossAbility" end,
+        },
+        addAlertText = {
+            type = "input", order = 24, width = 1.2, name = L["OPT_RT_ADD_TEXT"] or "Custom text",
+            disabled = function() return not RT:IsLocalEditor() end,
+            get = function() return tostring(GetEncounterDraft(encounterId).alertText or "") end,
+            set = function(_, val) GetEncounterDraft(encounterId).alertText = tostring(val or "") end,
+            hidden = function()
+                return GetDraftActionType(encounterId) ~= "text"
+            end,
+        },
+        addPlayerName = {
+            type = "input", order = 25, width = 1.2,
+            name = function() return GetTargetFieldLabel(GetDraftActionType(encounterId), true) end,
+            desc = function() return GetTargetFieldDesc(GetDraftActionType(encounterId)) end,
+            disabled = function() return not RT:IsLocalEditor() end,
+            get = function()
+                local draft = GetEncounterDraft(encounterId)
+                return tostring(draft.playerName or draft.targetSpec or "")
+            end,
+            set = function(_, val)
+                local draft = GetEncounterDraft(encounterId)
+                draft.playerName = tostring(val or "")
+                draft.targetSpec = tostring(val or "")
+            end,
+        },
+        addEntry = {
+            type = "execute", order = 26, width = "full", name = L["OPT_RT_ADD_ENTRY"] or "Add entry",
+            disabled = function() return not RT:IsLocalEditor() end,
+            func = function()
+                local draft = GetEncounterDraft(encounterId)
+                local ok = RT:AddDetailedEntry(encounterId, draft)
+                if ok then
+                    draft.time, draft.spellId, draft.alertText, draft.playerName, draft.entryType, draft.triggerType, draft.actionType, draft.targetSpec, draft.bossAbilityId, draft.bossAbilityBarName, draft.castCount = "", 0, "", "", "spell", "time", "raidCooldown", "", "", "", "1"
+                    Notify(true)
+                else
+                    HMGT:Print(L["OPT_RT_ADD_ENTRY_INVALID"] or "HMGT: invalid raid timeline entry")
+                end
+            end,
+        },
+        addBreak = { type = "description", order = 27, width = "full", name = " " },
+    }
+
+    for entryRow = 1, MAX_ENTRY_ROWS do
+        local order = 40 + (entryRow * 10)
+        args["entryTime_" .. entryRow] = {
+            type = "input", order = order, width = 0.7,
+            disabled = function() return not RT:IsLocalEditor() end,
+            name = function() return entryRow == 1 and (L["OPT_RT_ENTRY_TIME"] or "Time") or "" end,
+            get = function() local entry = GetEncounterEntry(encounterId, entryRow); return entry and FormatEntryTime(entry.time or 0) or "" end,
+            set = function(_, val)
+                if not RT:SetEntryField(encounterId, entryRow, "time", val) then
+                    HMGT:Print(L["OPT_RT_INVALID_TIME"] or "HMGT: invalid time")
+                end
+                Notify(false)
+            end,
+            hidden = function()
+                local entry = GetEncounterEntry(encounterId, entryRow)
+                return not entry or RT:GetTriggerType(entry) == "bossAbility"
+            end,
+        }
+        args["entryTriggerType_" .. entryRow] = {
+            type = "select", order = order + 1, width = 0.8,
+            disabled = function() return not RT:IsLocalEditor() end,
+            name = function() return entryRow == 1 and (L["OPT_RT_TRIGGER"] or "Trigger") or "" end,
+            values = GetTriggerTypeValues,
+            get = function() local entry = GetEncounterEntry(encounterId, entryRow); return entry and RT:GetTriggerType(entry) or "time" end,
+            set = function(_, val) RT:SetEntryField(encounterId, entryRow, "triggerType", val); Notify(false) end,
+            hidden = function() return GetEncounterEntry(encounterId, entryRow) == nil end,
+        }
+        args["entryActionType_" .. entryRow] = {
+            type = "select", order = order + 1.1, width = 1.0,
+            disabled = function() return not RT:IsLocalEditor() end,
+            name = function() return entryRow == 1 and (L["OPT_RT_ACTION"] or "Action") or "" end,
+            values = GetActionTypeValues,
+            get = function() local entry = GetEncounterEntry(encounterId, entryRow); return entry and RT:GetActionType(entry) or "raidCooldown" end,
+            set = function(_, val) RT:SetEntryField(encounterId, entryRow, "actionType", val); Notify(false) end,
+            hidden = function() return GetEncounterEntry(encounterId, entryRow) == nil end,
+        }
+        args["entrySpell_" .. entryRow] = {
+            type = "select", order = order + 2, width = 1.2,
+            disabled = function() return not RT:IsLocalEditor() end,
+            name = function() return entryRow == 1 and (L["OPT_RT_ENTRY_SPELL"] or "Spell") or "" end,
+            values = GetRaidCooldownSpellValues,
+            get = function() local entry = GetEncounterEntry(encounterId, entryRow); return entry and math.max(0, tonumber(entry.spellId) or 0) or 0 end,
+            set = function(_, val)
+                if not RT:SetEntryField(encounterId, entryRow, "spellId", math.max(0, tonumber(val) or 0)) then
+                    HMGT:Print(L["OPT_RT_INVALID_SPELL"] or "HMGT: invalid spell ID")
+                end
+                Notify(false)
+            end,
+            hidden = function() local entry = GetEncounterEntry(encounterId, entryRow); return not entry or RT:GetActionType(entry) ~= "raidCooldown" end,
+        }
+        args["entryCastCount_" .. entryRow] = {
+            type = "input", order = order + 2.1, width = 0.7,
+            disabled = function() return not RT:IsLocalEditor() end,
+            name = function() return entryRow == 1 and (L["OPT_RT_CAST_COUNT"] or "Cast count") or "" end,
+            desc = L["OPT_RT_CAST_COUNT_DESC"] or "Use a number, All, Odd, or Even.",
+            get = function() local entry = GetEncounterEntry(encounterId, entryRow); return entry and RT:FormatCastCountSelector(entry.castCount) or "1" end,
+            set = function(_, val) RT:SetEntryField(encounterId, entryRow, "castCount", val); Notify(false) end,
+            hidden = function() local entry = GetEncounterEntry(encounterId, entryRow); return not entry or RT:GetTriggerType(entry) ~= "bossAbility" end,
+        }
+        args["entryBossAbilityBarName_" .. entryRow] = {
+            type = "input", order = order + 2.2, width = 1.2,
+            disabled = function() return not RT:IsLocalEditor() end,
+            name = function() return entryRow == 1 and (L["OPT_RT_BOSS_BAR_NAME"] or "Bossmod bar name") or "" end,
+            get = function() local entry = GetEncounterEntry(encounterId, entryRow); return entry and tostring(entry.bossAbilityBarName or "") or "" end,
+            set = function(_, val) RT:SetEntryField(encounterId, entryRow, "bossAbilityBarName", val); Notify(false) end,
+            hidden = function() local entry = GetEncounterEntry(encounterId, entryRow); return not entry or RT:GetTriggerType(entry) ~= "bossAbility" end,
+        }
+        args["entryText_" .. entryRow] = {
+            type = "input", order = order + 3, width = 1.2,
+            disabled = function() return not RT:IsLocalEditor() end,
+            name = function() return entryRow == 1 and (L["OPT_RT_ENTRY_TEXT"] or "Custom text") or "" end,
+            get = function() local entry = GetEncounterEntry(encounterId, entryRow); return entry and tostring(entry.alertText or "") or "" end,
+            set = function(_, val) RT:SetEntryField(encounterId, entryRow, "alertText", val); Notify(false) end,
+            hidden = function()
+                local entry = GetEncounterEntry(encounterId, entryRow)
+                if not entry then
+                    return true
+                end
+                return RT:GetActionType(entry) ~= "text"
+            end,
+        }
+        args["entryPlayer_" .. entryRow] = {
+            type = "input", order = order + 4, width = 1.1,
+            disabled = function() return not RT:IsLocalEditor() end,
+            name = function()
+                local entry = GetEncounterEntry(encounterId, entryRow)
+                return entryRow == 1 and GetTargetFieldLabel(entry and RT:GetActionType(entry) or "raidCooldown", false) or ""
+            end,
+            desc = function()
+                local entry = GetEncounterEntry(encounterId, entryRow)
+                return GetTargetFieldDesc(entry and RT:GetActionType(entry) or "raidCooldown")
+            end,
+            get = function()
+                local entry = GetEncounterEntry(encounterId, entryRow)
+                if not entry then return "" end
+                return tostring(entry.playerName or entry.targetSpec or "")
+            end,
+            set = function(_, val)
+                local entry = GetEncounterEntry(encounterId, entryRow)
+                if entry then
+                    RT:SetEntryField(encounterId, entryRow, "playerName", val)
+                    RT:SetEntryField(encounterId, entryRow, "targetSpec", val)
+                    Notify(false)
+                end
+            end,
+            hidden = function() return GetEncounterEntry(encounterId, entryRow) == nil end,
+        }
+        args["entryDelete_" .. entryRow] = {
+            type = "execute", order = order + 5, width = 0.6, name = REMOVE or "Remove",
+            disabled = function() return not RT:IsLocalEditor() end,
+            func = function() RT:RemoveEntry(encounterId, entryRow); Notify(true) end,
+            hidden = function() return GetEncounterEntry(encounterId, entryRow) == nil end,
+        }
+        args["entryBreak_" .. entryRow] = {
+            type = "description", order = order + 6, width = "full", name = " ",
+            hidden = function() return GetEncounterEntry(encounterId, entryRow) == nil end,
+        }
+    end
+    return args
+end
+
+local function BuildEncounterDetailGroup(encounterId)
+    local encounter = RT:GetEncounter(encounterId)
+    if not encounter then return nil end
+
+	    local args = {
+	        header = { type = "header", order = 1, name = GetEncounterLabel(encounterId) },
+	        encounterId = {
+	            type = "description", order = 2, width = "full",
+	            name = string.format("|cffffd100%s|r: %d", L["OPT_RT_ADD_ENCOUNTER_ID"] or "Encounter ID", tonumber(encounterId) or 0),
+	        },
+	        raidName = {
+	            type = "description", order = 3, width = "full",
+	            name = function()
+	                local _, instanceName = RT:GetEncounterInstanceInfo(encounterId)
+	                local current = RT:GetEncounter(encounterId)
+	                return string.format("|cffffd100%s|r: %s", L["OPT_RT_RAID_NAME"] or "Raid", tostring((current and current.instanceName) or instanceName or (L["OPT_RT_RAID_DEFAULT"] or "Encounter")))
+	            end,
+	        },
+	        encounterName = {
+            type = "input", order = 4, width = "full", name = L["OPT_RT_ENCOUNTER_NAME"] or "Name",
+            disabled = function() return not RT:IsLocalEditor() end,
+            get = function() local current = RT:GetEncounter(encounterId); return current and tostring(current.name or "") or "" end,
+            set = function(_, val) local current = RT:GetEncounter(encounterId); if current then current.name = tostring(val or ""); Notify(true) end end,
+        },
+        difficultyHeader = { type = "header", order = 5, name = L["OPT_RT_DIFFICULTY_HEADER"] or "Difficulties" },
+    }
+
+    local diffOrder = 6
+    for _, difficultyKey in ipairs(DIFFICULTY_KEYS) do
+        args["difficulty_" .. difficultyKey] = {
+            type = "toggle", order = diffOrder, width = 0.75, name = GetDifficultyLabel(difficultyKey),
+            disabled = function() return not RT:IsLocalEditor() end,
+            get = function()
+                local current = RT:GetEncounter(encounterId)
+                local difficulties = current and current.difficulties or nil
+                return difficulties and difficulties[difficultyKey] ~= false or false
+            end,
+            set = function(_, val)
+                local current = RT:GetEncounter(encounterId)
+                if current then
+                    current.difficulties = current.difficulties or {}
+                    current.difficulties[difficultyKey] = val and true or false
+                    Notify(true)
+                end
+            end,
+        }
+        diffOrder = diffOrder + 0.01
+    end
+
+    args.openTimelineEditor = {
+        type = "execute", order = 7, width = "full", name = L["OPT_RT_OPEN_EDITOR"] or "Open timeline",
+        func = function() if RT.OpenTimelineEditor then RT:OpenTimelineEditor(encounterId) end end,
+    }
+    args.runTest = {
+        type = "execute",
+        order = 7.5,
+        width = "full",
+        name = function()
+            if RT:IsTestRunning(encounterId) then
+                return L["OPT_RT_STOP_TEST"] or "Stop test"
+            end
+            return L["OPT_RT_START_TEST"] or "Start timeline test"
+        end,
+        disabled = function() return not RT:IsLocalEditor() end,
+        func = function()
+            if RT:IsTestRunning(encounterId) then
+                RT:StopEncounterTest()
+            else
+                RT:StartEncounterTest(encounterId)
+            end
+            Notify()
+        end,
+    }
+    args.testHint = {
+        type = "description",
+        order = 7.6,
+        width = "full",
+        name = L["OPT_RT_TEST_HINT"] or "Runs the encounter timeline outside of combat so you can verify assignments, whispers and debug output.",
+    }
+    args.editorHint = {
+        type = "description", order = 8, width = "full",
+        name = L["OPT_RT_TIMELINE_HINT"] or "Click the bar to add a cooldown. Drag markers horizontally to change the time. Mousewheel scrolls, Ctrl+Mousewheel zooms.",
+    }
+    args.encounterDelete = {
+        type = "execute", order = 9, width = "full", name = DELETE or "Delete",
+        disabled = function() return not RT:IsLocalEditor() end,
+        confirm = function() return string.format(L["OPT_RT_DELETE_ENCOUNTER_CONFIRM"] or "Delete raid timeline for encounter %d?", tonumber(encounterId) or 0) end,
+            func = function() RT:RemoveEncounter(encounterId); Notify(true) end,
+    }
+    args.entryBreak = { type = "description", order = 10, width = "full", name = " " }
+
+    for key, value in pairs(BuildEntryEditorArgs(encounterId)) do
+        args[key] = value
+    end
+
+    return { type = "group", name = GetBossTreeLabel(encounterId), args = args }
+end
+
+local function BuildRaidTreeArgs()
+    local args = {}
+    local raidNames, buckets = GetRaidBuckets()
+
+	    for raidIndex, raidName in ipairs(raidNames) do
+	        local raidKey = tostring(buckets[raidName].key or raidIndex)
+	        args["raid_" .. raidKey] = {
+            type = "group",
+            order = 100 + raidIndex,
+            name = raidName,
+            childGroups = "tree",
+            args = {
+                description = {
+                    type = "description",
+                    order = 1,
+                    width = "full",
+                    name = string.format("|cffffd100%s|r: %s", L["OPT_RT_RAID_NAME"] or "Raid", raidName),
+                },
+                raidId = {
+                    type = "description",
+                    order = 2,
+                    width = "full",
+                    name = string.format("|cffffd100%s|r: %s", L["OPT_RT_RAID_ID"] or "Raid ID", tostring(buckets[raidName].key or raidIndex)),
+                },
+            },
+        }
+
+        local addedEncounterIds = {}
+        local bossOrder = 10
+        for _, difficultyKey in ipairs(DIFFICULTY_KEYS) do
+            local encounterIds = buckets[raidName].difficulties[difficultyKey] or {}
+            for _, encounterId in ipairs(encounterIds) do
+                if not addedEncounterIds[encounterId] then
+                    local encounterGroup = BuildEncounterDetailGroup(encounterId)
+                    if encounterGroup then
+                        encounterGroup.order = bossOrder
+                        args["raid_" .. raidKey].args["boss_" .. tostring(encounterId)] = encounterGroup
+                        bossOrder = bossOrder + 1
+                        addedEncounterIds[encounterId] = true
+                    end
+                end
+            end
+        end
+    end
+
+    return args, #raidNames
+end
+
+function RT:GetOptionsGroup()
+    local drafts = GetDrafts()
+    local raidTreeArgs, raidCount = BuildRaidTreeArgs()
+
+    local group = {
+        type = "group",
+        name = L["OPT_RT_NAME"] or "Raid Timeline",
+        order = 4,
+        childGroups = "tree",
+        args = {
+            general = {
+                type = "group",
+                order = 1,
+                name = L["OPT_RT_SECTION_GENERAL"] or "General",
+                args = {
+                    enabled = {
+                        type = "toggle",
+                        order = 1,
+                        width = "full",
+                        name = L["OPT_RT_ENABLED"] or "Enable Raid Timeline",
+                        get = function() return RT:GetSettings().enabled == true end,
+                        set = function(_, val)
+                            RT:GetSettings().enabled = val and true or false
+                            if val then RT:Enable() else RT:Disable() end
+                        end,
+                    },
+                    leadTime = {
+                        type = "range",
+                        order = 2,
+                        min = 1,
+                        max = 15,
+                        step = 1,
+                        name = L["OPT_RT_LEAD_TIME"] or "Warning lead time",
+                        get = function() return tonumber(RT:GetSettings().leadTime) or 5 end,
+                        set = function(_, val) RT:GetSettings().leadTime = math.floor((tonumber(val) or 5) + 0.5) end,
+                    },
+                    assignmentLeadTime = {
+                        type = "range",
+                        order = 2.1,
+                        min = 0,
+                        max = 60,
+                        step = 1,
+                        name = L["OPT_RT_ASSIGNMENT_LEAD_TIME"] or "Assignment lead time",
+                        desc = L["OPT_RT_ASSIGNMENT_LEAD_TIME_DESC"] or "How many seconds before the planned use the assigned player should be selected.",
+                        get = function()
+                            local settings = RT:GetSettings()
+                            return tonumber(settings.assignmentLeadTime) or tonumber(settings.leadTime) or 5
+                        end,
+                        set = function(_, val)
+                            RT:GetSettings().assignmentLeadTime = math.floor((tonumber(val) or 5) + 0.5)
+                        end,
+                    },
+                    header = { type = "header", order = 3, name = L["OPT_RT_ALERT_HEADER"] or "Alert frame" },
+                    unlocked = {
+                        type = "toggle", order = 4, width = "double", name = L["OPT_RT_UNLOCK"] or "Unlock alert frame",
+                        get = function() return RT:GetSettings().unlocked == true end,
+                        set = function(_, val)
+                            RT:GetSettings().unlocked = val and true or false
+                            RT:ApplyAlertStyle()
+                            if val then RT:ShowPreview() end
+                        end,
+                    },
+                    preview = {
+                        type = "toggle", order = 5, width = "double", name = L["OPT_RT_PREVIEW"] or "Preview alert",
+                        get = function() return RT.previewAlertActive == true end,
+                        set = function(_, val) if val then RT:ShowPreview() else RT:HideAlert() end end,
+                    },
+                    alertFont = {
+                        type = "select", order = 6, width = 1.4, name = L["OPT_FONT"] or "Typeface",
+                        dialogControl = "LSM30_Font",
+                        values = AceGUIWidgetLSMlists and AceGUIWidgetLSMlists.font or (LSM and LSM:HashTable("font")) or {},
+                        get = function() return RT:GetSettings().alertFont or "Friz Quadrata TT" end,
+                        set = function(_, val) RT:GetSettings().alertFont = val; RT:ApplyAlertStyle() end,
+                    },
+                    alertFontSize = {
+                        type = "range", order = 7, min = 10, max = 72, step = 1, width = 1.0, name = L["OPT_FONT_SIZE"] or "Font size",
+                        get = function() return tonumber(RT:GetSettings().alertFontSize) or 30 end,
+                        set = function(_, val) RT:GetSettings().alertFontSize = math.floor((tonumber(val) or 30) + 0.5); RT:ApplyAlertStyle() end,
+                    },
+                    alertFontOutline = {
+                        type = "select", order = 8, width = 1.0, name = L["OPT_FONT_OUTLINE"] or "Font outline",
+                        values = FONT_OUTLINE_VALUES,
+                        get = function() return RT:GetSettings().alertFontOutline or "OUTLINE" end,
+                        set = function(_, val) RT:GetSettings().alertFontOutline = val; RT:ApplyAlertStyle() end,
+                    },
+                    alertColor = {
+                        type = "color", order = 9, width = 0.8, name = L["OPT_RT_ALERT_COLOR"] or "Text colour", hasAlpha = true,
+                        get = function()
+                            local color = RT:GetSettings().alertColor or {}
+                            return color.r or 1, color.g or 0.82, color.b or 0.15, color.a or 1
+                        end,
+                        set = function(_, r, g, b, a)
+                            local color = RT:GetSettings().alertColor
+                            color.r, color.g, color.b, color.a = r, g, b, a
+                            RT:ApplyAlertStyle()
+                        end,
+                    },
+                    desc = {
+                        type = "description", order = 10, width = "full",
+                        name = L["OPT_RT_DESC"] or "Create encounter timelines here and open the interactive Ace3 timeline editor for visual planning.",
+                    },
+                },
+            },
+            manage = {
+                type = "group",
+                order = 2,
+                name = L["OPT_RT_SECTION_MANAGE"] or "Manage encounters",
+                args = {
+                    header = { type = "header", order = 1, name = L["OPT_RT_ENCOUNTERS_HEADER"] or "Encounter timelines" },
+                    addEncounterId = {
+                        type = "input", order = 2, width = 0.8, name = L["OPT_RT_ADD_ENCOUNTER_ID"] or "Encounter ID",
+                        disabled = function() return not RT:IsLocalEditor() end,
+                        get = function() return tostring(drafts.addEncounterId or "") end,
+                        set = function(_, val) drafts.addEncounterId = val end,
+                    },
+	                    addEncounterName = {
+	                        type = "input", order = 3, width = 1.2, name = L["OPT_RT_ADD_ENCOUNTER_NAME"] or "Encounter name",
+	                        disabled = function() return not RT:IsLocalEditor() end,
+	                        get = function() return tostring(drafts.addEncounterName or "") end,
+	                        set = function(_, val) drafts.addEncounterName = val end,
+	                    },
+	                    addEncounter = {
+	                        type = "execute", order = 5, width = "full", name = L["OPT_RT_ADD_ENCOUNTER"] or "Add encounter",
+	                        disabled = function() return not RT:IsLocalEditor() end,
+	                        func = function()
+	                            if RT:AddEncounter(drafts.addEncounterId, drafts.addEncounterName) then
+	                                drafts.addEncounterId, drafts.addEncounterName = "", ""
+                                Notify(true)
+	                            else
+	                                HMGT:Print(L["OPT_RT_INVALID_ENCOUNTER"] or "HMGT: invalid encounter ID")
+	                            end
+                        end,
+                    },
+                    summary = {
+                        type = "description", order = 6, width = "full",
+                        name = function()
+                            if raidCount == 0 then return L["OPT_RT_EMPTY"] or "No encounter timelines configured yet." end
+                            return string.format("|cffffd100%s|r: %d", L["OPT_RT_ENCOUNTERS_HEADER"] or "Encounter timelines", #RT:GetEncounterIds())
+                        end,
+                    },
+                },
+            },
+        },
+    }
+
+    if raidCount == 0 then
+        group.args.empty = {
+            type = "group",
+            order = 50,
+            name = L["OPT_RT_EMPTY"] or "No encounter timelines configured yet.",
+            args = {
+                description = { type = "description", order = 1, width = "full", name = L["OPT_RT_EMPTY"] or "No encounter timelines configured yet." },
+            },
+        }
+    else
+        for key, value in pairs(raidTreeArgs) do
+            group.args[key] = value
+        end
+    end
+
+    return group
+end
+
+HMGT_Config:RegisterOptionsProvider("raidTimeline", function()
+    raidTimelineOptionsGroup = raidTimelineOptionsGroup or RT:GetOptionsGroup()
+    ClearOptionCaches()
+    local fresh = RT:GetOptionsGroup()
+    raidTimelineOptionsGroup.name = fresh.name
+    raidTimelineOptionsGroup.order = fresh.order
+    raidTimelineOptionsGroup.childGroups = fresh.childGroups
+    raidTimelineOptionsGroup.args = fresh.args
+    return {
+        path = "raidTimeline",
+        order = 4,
+        group = raidTimelineOptionsGroup,
+    }
+end)

Modules/Tracker/GroupCooldownTracker/GroupCooldownSpellDatabase.lua

@@ -0,0 +1,391 @@
+-- Core/GroupCooldownSpellDatabase.lua
+-- Group cooldown database.
+
+HMGT_SpellData = HMGT_SpellData or {}
+local Spell = HMGT_SpellData.Spell
+local Relation = HMGT_SpellData.Relation
+if not Spell then return end
+
+HMGT_SpellData.GroupCooldowns = {
+    -- WARRIOR
+    -- Arms Spec
+    Spell(118038, "Die by the Sword", {
+        classes = {"WARRIOR"},
+        specs = {1},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+    Spell(167105, "Colossus Smash", {
+        classes = {"WARRIOR"},
+        specs = {1},
+        category = "offensive",
+        state = { kind = "cooldown", cooldown = 45 },
+    }),
+
+    -- Fury Spec
+    Spell(184364, "Enraged Regeneration", {
+        classes = {"WARRIOR"},
+        specs = {2},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+    Spell(1719, "Recklessness", {
+        classes = {"WARRIOR"},
+        specs = {2},
+        category = "offensive",
+        state = { kind = "cooldown", cooldown = 90 },
+    }),
+
+    -- Protection Spec
+    Spell(871, "Shield Wall", {
+        classes = {"WARRIOR"},
+        specs = {3},
+        category = "tank",
+        state = { kind = "cooldown", cooldown = 108, charges = 1 },
+        mods = {
+            { talentSpellId = 391271, value = 10, op = "reduceByPercent", target = "cooldown" }, -- Honed Reflexes
+            { talentSpellId = 397103, value = 2, op = "set", target = "charges" },
+        },
+    }),
+    Spell(385952, "Shield Charge", {
+        classes = {"WARRIOR"},
+        specs = {3},
+        category = "cc",
+        state = { kind = "cooldown", cooldown = 45 },
+    }),
+    Spell(46968, "Shockwave", {
+        classes = {"WARRIOR"},
+        specs = {3},
+        category = "cc",
+        state = { kind = "cooldown", cooldown = 40 },
+    }),
+    Spell(3411, "Intervene", {
+        classes = {"WARRIOR"},
+        specs = {3},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 27 },
+    }),
+
+    -- All Specs
+    Spell(107574, "Avatar", {
+        classes = {"WARRIOR"},
+        category = "offensive",
+        state = { kind = "cooldown", cooldown = 90 },
+    }),
+    Spell(107570, "Storm Bolt", {
+        classes = {"WARRIOR"},
+        category = "cc",
+        state = { kind = "cooldown", cooldown = 36 },
+    }),
+
+    -- PALADIN
+    Spell(498, "Divine Protection", {
+        classes = {"PALADIN"},
+        specs = {1, 2},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 60 },
+    }),
+    Spell(642, "Divine Shield", {
+        classes = {"PALADIN"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 300 },
+    }),
+    Spell(31884, "Avenging Wrath", {
+        classes = {"PALADIN"},
+        specs = {1, 3},
+        category = "offensive",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+    Spell(86659, "Guardian of Ancient Kings", {
+        classes = {"PALADIN"},
+        specs = {2},
+        category = "tank",
+        state = { kind = "cooldown", cooldown = 300 },
+    }),
+
+    -- HUNTER
+    Spell(264735, "Survival of the Fittest", {
+        classes = {"HUNTER"},
+        specs = {1},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+    Spell(109304, "Exhilaration", {
+        classes = {"HUNTER"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+
+    -- ROGUE
+    Spell(31224, "Cloak of Shadows", {
+        classes = {"ROGUE"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 60 },
+    }),
+    Spell(5277, "Evasion", {
+        classes = {"ROGUE"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+    Spell(2094, "Blind", {
+        classes = {"ROGUE"},
+        category = "cc",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+    Spell(1856, "Vanish", {
+        classes = {"ROGUE"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+
+    -- DEATH KNIGHT
+    Spell(55233, "Vampiric Blood", {
+        classes = {"DEATHKNIGHT"},
+        specs = {1},
+        category = "tank",
+        state = { kind = "cooldown", cooldown = 180 },
+        mods = {
+            { talentSpellId = 374200, value = 150, op = "set", target = "cooldown" },
+        },
+    }),
+    Spell(49028, "Dancing Rune Weapon", {
+        classes = {"DEATHKNIGHT"},
+        specs = {1},
+        category = "tank",
+        state = { kind = "cooldown", cooldown = 120 },
+        mods = {
+            { talentSpellId = 377584, value = 60, op = "set", target = "cooldown" },
+        },
+    }),
+    Spell(48707, "Anti-Magic Shell", {
+        classes = {"DEATHKNIGHT"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 60 },
+    }),
+    Spell(48792, "Icebound Fortitude", {
+        classes = {"DEATHKNIGHT"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+    Spell(42650, "Army of the Dead", {
+        classes = {"DEATHKNIGHT"},
+        category = "offensive",
+        state = { kind = "cooldown", cooldown = 480 },
+    }),
+    Spell(49206, "Summon Gargoyle", {
+        classes = {"DEATHKNIGHT"},
+        specs = {3},
+        category = "offensive",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+
+    -- SHAMAN
+    Spell(204336, "Grounding Totem", {
+        classes = {"SHAMAN"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 30 },
+    }),
+    Spell(51490, "Thunderstorm", {
+        classes = {"SHAMAN"},
+        specs = {1},
+        category = "cc",
+        state = { kind = "cooldown", cooldown = 45 },
+    }),
+
+    -- MAGE
+    Spell(45438, "Ice Block", {
+        classes = {"MAGE"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 240 },
+    }),
+    Spell(110959, "Greater Invisibility", {
+        classes = {"MAGE"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+    Spell(235450, "Prismatic Barrier", {
+        classes = {"MAGE"},
+        specs = {3},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 25 },
+    }),
+
+    -- WARLOCK
+    Spell(104773, "Unending Resolve", {
+        classes = {"WARLOCK"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+    Spell(6229, "Twilight Ward", {
+        classes = {"WARLOCK"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 0 },
+    }),
+    Spell(212295, "Nether Ward", {
+        classes = {"WARLOCK"},
+        specs = {3},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 45 },
+    }),
+
+    -- MONK
+    Spell(122783, "Diffuse Magic", {
+        classes = {"MONK"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 90 },
+    }),
+    Spell(122278, "Dampen Harm", {
+        classes = {"MONK"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+    Spell(120954, "Fortifying Brew", {
+        classes = {"MONK"},
+        specs = {1},
+        category = "tank",
+        state = { kind = "cooldown", cooldown = 420 },
+    }),
+    Spell(115176, "Zen Meditation", {
+        classes = {"MONK"},
+        specs = {2},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 300 },
+    }),
+    Spell(322118, "Invoke Niuzao", {
+        classes = {"MONK"},
+        specs = {1},
+        category = "tank",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+
+    -- DRUID
+    Spell(22812, "Barkskin", {
+        classes = {"DRUID"},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 60 },
+    }),
+    Spell(61336, "Survival Instincts", {
+        classes = {"DRUID"},
+        specs = {2, 3},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+
+    -- DEMON HUNTER
+    Spell(187827, "Metamorphosis", {
+        classes = {"DEMONHUNTER"},
+        specs = {1},
+        category = "offensive",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+    Spell(162264, "Metamorphosis", {
+        classes = {"DEMONHUNTER"},
+        specs = {2},
+        category = "tank",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+    Spell(1217605, "Metamorphosis", {
+        classes = {"DEMONHUNTER"},
+        specs = {3},
+        category = "offensive",
+        state = {
+            kind = "availability",
+            required = 50,
+            source = {
+                type = "auraStacks",
+                auraSpellId = 1225789,
+                fallbackSpellCountId = 1217605,
+            },
+        },
+    }),
+    Spell(203819, "Demon Spikes", {
+        classes = {"DEMONHUNTER"},
+        specs = {2},
+        category = "tank",
+        state = { kind = "cooldown", cooldown = 20 },
+    }),
+    Spell(212800, "Blur", {
+        classes = {"DEMONHUNTER"},
+        specs = {1},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 60 },
+    }),
+    Spell(196555, "Netherwalk", {
+        classes = {"DEMONHUNTER"},
+        specs = {1},
+        category = "defensive",
+        state = { kind = "cooldown", cooldown = 180 },
+    }),
+
+    -- EVOKER
+    Spell(357214, "Time Stop", {
+        classes = {"EVOKER"},
+        specs = {2},
+        category = "cc",
+        state = { kind = "cooldown", cooldown = 120 },
+    }),
+    Spell(375087, "Tempest", {
+        classes = {"EVOKER"},
+        specs = {3},
+        category = "offensive",
+        state = { kind = "cooldown", cooldown = 30 },
+    }),
+}
+
+HMGT_SpellData.Relations = HMGT_SpellData.Relations or {}
+local hasShieldSlamShieldWallRelation = false
+local hasAngerManagementRelation = false
+for _, relation in ipairs(HMGT_SpellData.Relations) do
+    local firstEffect = relation.effects and relation.effects[1]
+    if tonumber(relation.triggerSpellId) == 23922 and tonumber(firstEffect and firstEffect.targetSpellId) == 871 then
+        hasShieldSlamShieldWallRelation = true
+    end
+    if tostring(relation.when) == "powerSpent"
+        and tonumber(relation.talentRequired) == 152278
+        and tostring(relation.powerType) == "RAGE"
+    then
+        hasAngerManagementRelation = true
+    end
+end
+if not hasShieldSlamShieldWallRelation and Relation then
+    HMGT_SpellData.Relations[#HMGT_SpellData.Relations + 1] = Relation({
+        triggerSpellId = 23922, -- Shield Slam
+        classes = {"WARRIOR"},
+        specs = {3}, -- Protection
+        when = "cast",
+        talentRequired = 384072, -- Impenetrable Wall
+        effects = {
+            {
+                type = "reduceCooldown",
+                targetSpellId = 871, -- Shield Wall
+                amount = 6,
+            },
+        },
+    })
+end
+if not hasAngerManagementRelation and Relation then
+    HMGT_SpellData.Relations[#HMGT_SpellData.Relations + 1] = Relation({
+        classes = {"WARRIOR"},
+        specs = {3}, -- Protection
+        when = "powerSpent",
+        powerType = "RAGE",
+        amountPerTrigger = 20,
+        talentRequired = 152278, -- Anger Management
+        effects = {
+            {
+                type = "reduceCooldown",
+                targetSpellId = 107574, -- Avatar
+                amount = 1,
+            },
+            {
+                type = "reduceCooldown",
+                targetSpellId = 871, -- Shield Wall
+                amount = 1,
+            },
+        },
+    })
+end
+
+if HMGT_SpellData.RebuildLookups then
+    HMGT_SpellData.RebuildLookups()
+end

Modules/Tracker/GroupCooldownTracker/GroupCooldownTracker.lua

@@ -0,0 +1,692 @@
+-- Modules/GroupCooldownTracker.lua
+-- Group-Cooldown-Tracker Modul (ein Frame pro Spieler in der Gruppe)
+
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT then return end
+local L    = LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME)
+
+local GCT = HMGT:NewModule("GroupCooldownTracker")
+HMGT.GroupCooldownTracker = GCT
+
+GCT.frame = nil
+GCT.frames = {}
+
+local function SanitizeFrameToken(name)
+    if not name or name == "" then return "Unknown" end
+    return name:gsub("[^%w_]", "_")
+end
+
+local function ShortName(name)
+    if not name then return "" end
+    local short = name:match("^[^-]+")
+    return short or name
+end
+
+local function IsUsableAnchorFrame(frame)
+    return frame
+        and frame.IsObjectType
+        and (frame:IsObjectType("Frame") or frame:IsObjectType("Button"))
+end
+
+local function GetFrameUnit(frame)
+    if not frame then return nil end
+    local unit = frame.unit
+    if not unit and frame.GetAttribute then
+        unit = frame:GetAttribute("unit")
+    end
+    return unit
+end
+
+local function FrameMatchesUnit(frame, unitId)
+    if not IsUsableAnchorFrame(frame) then return false end
+    if not unitId then return true end
+    local unit = GetFrameUnit(frame)
+    return unit == unitId
+end
+
+local PLAYER_FRAME_CANDIDATES = {
+    "PlayerFrame",
+    "ElvUF_Player",
+    "NephUI_PlayerFrame",
+    "NephUIPlayerFrame",
+    "oUF_NephUI_Player",
+    "SUFUnitplayer",
+}
+
+local PARTY_FRAME_PATTERNS = {
+    "PartyMemberFrame%d",               -- Blizzard alt
+    "CompactPartyFrameMember%d",        -- Blizzard modern
+    "ElvUF_PartyGroup1UnitButton%d",    -- ElvUI
+    "ElvUF_PartyUnitButton%d",          -- ElvUI variant
+    "NephUI_PartyUnitButton%d",         -- NephUI (common naming variants)
+    "NephUI_PartyFrame%d",
+    "NephUIPartyFrame%d",
+    "oUF_NephUI_PartyUnitButton%d",
+    "SUFUnitparty%d",                   -- Shadowed Unit Frames
+}
+
+local unitFrameCache = {}
+
+local function EntryNeedsVisualTicker(entry)
+    if type(entry) ~= "table" then
+        return false
+    end
+
+    local remaining = tonumber(entry.remaining) or 0
+    if remaining > 0 then
+        return true
+    end
+
+    local maxCharges = tonumber(entry.maxCharges) or 0
+    local currentCharges = tonumber(entry.currentCharges)
+    if maxCharges > 0 and currentCharges ~= nil and currentCharges < maxCharges then
+        return true
+    end
+
+    return false
+end
+
+local function BuildAnchorLayoutSignature(settings, ordered, unitByPlayer)
+    local parts = {
+        settings.attachToPartyFrame == true and "attach" or "stack",
+        tostring(settings.partyAttachSide or "RIGHT"),
+        tostring(tonumber(settings.partyAttachOffsetX) or 8),
+        tostring(tonumber(settings.partyAttachOffsetY) or 0),
+        tostring(settings.showBar and "bar" or "icon"),
+        tostring(settings.growDirection or "DOWN"),
+        tostring(settings.width or 250),
+        tostring(settings.barHeight or 20),
+        tostring(settings.iconSize or 32),
+        tostring(settings.iconCols or 6),
+        tostring(settings.barSpacing or 2),
+        tostring(settings.locked),
+        tostring(settings.anchorTo or "UIParent"),
+        tostring(settings.anchorPoint or "TOPLEFT"),
+        tostring(settings.anchorRelPoint or "TOPLEFT"),
+        tostring(settings.anchorX or settings.posX or 0),
+        tostring(settings.anchorY or settings.posY or 0),
+    }
+
+    for _, playerName in ipairs(ordered or {}) do
+        parts[#parts + 1] = tostring(playerName)
+        parts[#parts + 1] = tostring(unitByPlayer and unitByPlayer[playerName] or "")
+    end
+
+    return table.concat(parts, "|")
+end
+
+local function ResolveNamedUnitFrame(unitId)
+    if unitId == "player" then
+        for _, frameName in ipairs(PLAYER_FRAME_CANDIDATES) do
+            local frame = _G[frameName]
+            if FrameMatchesUnit(frame, unitId) or (frameName == "PlayerFrame" and IsUsableAnchorFrame(frame)) then
+                return frame
+            end
+        end
+        return nil
+    end
+
+    local idx = type(unitId) == "string" and unitId:match("^party(%d+)$")
+    if not idx then
+        return nil
+    end
+
+    idx = tonumber(idx)
+    for _, pattern in ipairs(PARTY_FRAME_PATTERNS) do
+        local frame = _G[pattern:format(idx)]
+        if FrameMatchesUnit(frame, unitId) then
+            return frame
+        end
+    end
+    return nil
+end
+
+local function ScanUnitFrame(unitId)
+    local frame = EnumerateFrames()
+    local scanned = 0
+    while frame and scanned < 8000 do
+        if IsUsableAnchorFrame(frame) then
+            local unit = GetFrameUnit(frame)
+            if unit == unitId then
+                HMGT:DebugScoped("verbose", HMGT:GetTrackerDebugScope("Group Cooldowns"), "GroupAttach scan unit=%s scanned=%d found=true", tostring(unitId), scanned)
+                return frame
+            end
+        end
+        scanned = scanned + 1
+        frame = EnumerateFrames(frame)
+    end
+    HMGT:DebugScoped("verbose", HMGT:GetTrackerDebugScope("Group Cooldowns"), "GroupAttach scan unit=%s scanned=%d found=false", tostring(unitId), scanned)
+    return nil
+end
+
+local function ResolveUnitAnchorFrame(unitId)
+    if not unitId then return nil end
+
+    local now = GetTime()
+    local cached = unitFrameCache[unitId]
+    if cached and now < (cached.expires or 0) then
+        if cached.frame and cached.frame:IsShown() then
+            return cached.frame
+        end
+        return nil
+    end
+
+    local frame = ResolveNamedUnitFrame(unitId)
+    if not frame then
+        frame = ScanUnitFrame(unitId)
+    end
+
+    local expiresIn = 1.0
+    if frame and frame:IsShown() then
+        expiresIn = 10.0
+    end
+    unitFrameCache[unitId] = {
+        frame = frame,
+        expires = now + expiresIn,
+    }
+
+    if frame and frame:IsShown() then
+        return frame
+    end
+    return nil
+end
+
+function GCT:GetFrameIdForPlayer(playerName)
+    return "GroupCooldownTracker_" .. SanitizeFrameToken(playerName)
+end
+
+function GCT:GetPlayerFrame(playerName)
+    if not playerName then return nil end
+    return self.frames[playerName]
+end
+
+function GCT:GetAnchorableFrames()
+    return self.frames
+end
+
+function GCT:EnsurePlayerFrame(playerName)
+    local frame = self.frames[playerName]
+    local s = HMGT.db.profile.groupCooldownTracker
+    if frame then
+        return frame
+    end
+
+    frame = HMGT.TrackerFrame:CreateTrackerFrame(self:GetFrameIdForPlayer(playerName), s)
+    frame._hmgtPlayerName = playerName
+    self.frames[playerName] = frame
+    return frame
+end
+
+function GCT:HideAllFrames()
+    for _, frame in pairs(self.frames) do
+        frame:Hide()
+    end
+    self.activeOrder = nil
+    self.unitByPlayer = nil
+    self.frame = nil
+    self._lastAnchorLayoutSignature = nil
+    self._nextAnchorRetryAt = nil
+end
+
+function GCT:SetLockedAll(locked)
+    for _, frame in pairs(self.frames) do
+        HMGT.TrackerFrame:SetLocked(frame, locked)
+    end
+end
+
+function GCT:EnsureUpdateTicker()
+    if self.updateTicker then
+        return
+    end
+    self.updateTicker = C_Timer.NewTicker(0.1, function()
+        self:UpdateDisplay()
+    end)
+end
+
+function GCT:StopUpdateTicker()
+    if self.updateTicker then
+        self.updateTicker:Cancel()
+        self.updateTicker = nil
+    end
+end
+
+function GCT:SetUpdateTickerEnabled(enabled)
+    if enabled then
+        self:EnsureUpdateTicker()
+    else
+        self:StopUpdateTicker()
+    end
+end
+
+function GCT:InvalidateAnchorLayout()
+    self._lastAnchorLayoutSignature = nil
+    self._nextAnchorRetryAt = nil
+end
+
+function GCT:RefreshAnchors(force)
+    local s = HMGT.db.profile.groupCooldownTracker
+    if not s then return end
+
+    local ordered = {}
+    for _, playerName in ipairs(self.activeOrder or {}) do
+        local frame = self.frames[playerName]
+        if frame and frame:IsShown() then
+            table.insert(ordered, playerName)
+        end
+    end
+
+    if #ordered == 0 then
+        self.frame = nil
+        self._lastAnchorLayoutSignature = nil
+        self._nextAnchorRetryAt = nil
+        return
+    end
+
+    local now = GetTime()
+    local signature = BuildAnchorLayoutSignature(s, ordered, self.unitByPlayer)
+    if not force and self._lastAnchorLayoutSignature == signature then
+        local retryAt = tonumber(self._nextAnchorRetryAt) or 0
+        if retryAt <= 0 or now < retryAt then
+            return
+        end
+    end
+
+    -- Do not force anchor updates while user is dragging a tracker frame.
+    for _, playerName in ipairs(ordered) do
+        local frame = self.frames[playerName]
+        if frame and frame._hmgtDragging then
+            return
+        end
+    end
+
+    local primaryName = ordered[1]
+    local primary = self.frames[primaryName]
+    self.frame = primary
+
+    if s.attachToPartyFrame == true then
+        local side = s.partyAttachSide or "RIGHT"
+        local extraX = tonumber(s.partyAttachOffsetX) or 8
+        local extraY = tonumber(s.partyAttachOffsetY) or 0
+        local growsUp = s.showBar == true and s.growDirection == "UP"
+        local barHeight = tonumber(s.barHeight) or 20
+        local growUpAttachOffset = barHeight + 20
+        local prevPlaced = nil
+        local missingTargets = 0
+
+        for i = 1, #ordered do
+            local playerName = ordered[i]
+            local frame = self.frames[playerName]
+            local unitId = self.unitByPlayer and self.unitByPlayer[playerName]
+            local target = ResolveUnitAnchorFrame(unitId)
+            local contentTopInset = HMGT.TrackerFrame.GetContentTopInset and HMGT.TrackerFrame:GetContentTopInset(frame) or 0
+
+            frame:ClearAllPoints()
+            if target then
+                if side == "LEFT" then
+                    if growsUp then
+                        frame:SetPoint("BOTTOMRIGHT", target, "TOPLEFT", -extraX, extraY - growUpAttachOffset)
+                    else
+                        frame:SetPoint("TOPRIGHT", target, "TOPLEFT", -extraX, extraY + contentTopInset)
+                    end
+                else
+                    if growsUp then
+                        frame:SetPoint("BOTTOMLEFT", target, "TOPRIGHT", extraX, extraY - growUpAttachOffset)
+                    else
+                        frame:SetPoint("TOPLEFT", target, "TOPRIGHT", extraX, extraY + contentTopInset)
+                    end
+                end
+            elseif prevPlaced then
+                missingTargets = missingTargets + 1
+                HMGT:DebugScoped("verbose", HMGT:GetTrackerDebugScope("Group Cooldowns"), "GroupAttach fallback-stack player=%s unit=%s", tostring(playerName), tostring(unitId))
+                if growsUp then
+                    frame:SetPoint("BOTTOMLEFT", prevPlaced, "TOPLEFT", 0, (s.barSpacing or 2) + 10)
+                else
+                    frame:SetPoint("TOPLEFT", prevPlaced, "BOTTOMLEFT", 0, -((s.barSpacing or 2) + 10))
+                end
+            else
+                missingTargets = missingTargets + 1
+                HMGT:DebugScoped("info", HMGT:GetTrackerDebugScope("Group Cooldowns"), "GroupAttach fallback-anchor player=%s unit=%s (no party frame found)", tostring(playerName), tostring(unitId))
+                HMGT.TrackerFrame:ApplyAnchor(frame)
+            end
+
+            frame:EnableMouse(false)
+            prevPlaced = frame
+        end
+        if missingTargets > 0 then
+            self._lastAnchorLayoutSignature = nil
+            self._nextAnchorRetryAt = now + 1.0
+        else
+            self._lastAnchorLayoutSignature = signature
+            self._nextAnchorRetryAt = nil
+        end
+        return
+    end
+
+    HMGT.TrackerFrame:ApplyAnchor(primary)
+    primary:EnableMouse(not s.locked)
+
+    local gap = (s.barSpacing or 2) + 10
+    local growsUp = s.showBar == true and s.growDirection == "UP"
+    for i = 2, #ordered do
+        local prev = self.frames[ordered[i - 1]]
+        local frame = self.frames[ordered[i]]
+        frame:ClearAllPoints()
+        if growsUp then
+            frame:SetPoint("BOTTOMLEFT", prev, "TOPLEFT", 0, gap)
+        else
+            frame:SetPoint("TOPLEFT", prev, "BOTTOMLEFT", 0, -gap)
+        end
+        frame:EnableMouse(false)
+    end
+    self._lastAnchorLayoutSignature = signature
+    self._nextAnchorRetryAt = nil
+end
+
+-- ============================================================
+-- ENABLE / DISABLE
+-- ============================================================
+
+function GCT:Enable()
+    local s = HMGT.db.profile.groupCooldownTracker
+    if not s.enabled and not s.demoMode and not s.testMode then return end
+
+    self:UpdateDisplay()
+end
+
+function GCT:Disable()
+    self:StopUpdateTicker()
+    self:HideAllFrames()
+end
+
+-- ============================================================
+-- DISPLAY UPDATE
+-- ============================================================
+
+function GCT:UpdateDisplay()
+    local s = HMGT.db.profile.groupCooldownTracker
+    if not s then return end
+
+    if s.testMode then
+        local entries, playerName = HMGT:GetOwnTestEntries(HMGT_SpellData.GroupCooldowns, s, {
+            deferChargeCooldownUntilEmpty = false,
+        })
+        local byPlayer = { [playerName] = {} }
+        for _, entry in ipairs(entries) do
+            entry.playerName = playerName
+            table.insert(byPlayer[playerName], entry)
+        end
+
+        self.activeOrder = { playerName }
+        self.unitByPlayer = { [playerName] = "player" }
+        self.lastEntryCount = 0
+        local active = {}
+        local shownOrder = {}
+        local shouldTick = false
+        for _, pName in ipairs(self.activeOrder) do
+            local frame = self:EnsurePlayerFrame(pName)
+            HMGT.TrackerFrame:SetLocked(frame, s.locked)
+            HMGT.TrackerFrame:SetTitle(frame, string.format("%s - %s", L["GCD_TITLE"], ShortName(pName)))
+            local displayEntries = byPlayer[pName]
+            if HMGT.FilterDisplayEntries then
+                displayEntries = HMGT:FilterDisplayEntries(s, displayEntries) or displayEntries
+            end
+            if HMGT.SortDisplayEntries then
+                HMGT:SortDisplayEntries(displayEntries, "groupCooldownTracker")
+            end
+            if #displayEntries > 0 then
+                HMGT.TrackerFrame:UpdateFrame(frame, displayEntries, true)
+                self.lastEntryCount = self.lastEntryCount + #displayEntries
+                frame:Show()
+                active[pName] = true
+                shownOrder[#shownOrder + 1] = pName
+                for _, entry in ipairs(displayEntries) do
+                    if EntryNeedsVisualTicker(entry) then
+                        shouldTick = true
+                        break
+                    end
+                end
+            else
+                frame:Hide()
+            end
+        end
+        self.activeOrder = shownOrder
+
+        for pn, frame in pairs(self.frames) do
+            if not active[pn] then
+                frame:Hide()
+            end
+        end
+
+        self:RefreshAnchors()
+        self:SetUpdateTickerEnabled(shouldTick)
+        return
+    end
+
+    if s.demoMode then
+        local entries = HMGT:GetDemoEntries("groupCooldownTracker", HMGT_SpellData.GroupCooldowns, s)
+        local playerName = HMGT:NormalizePlayerName(UnitName("player")) or "DemoPlayer"
+        local byPlayer = { [playerName] = {} }
+        for _, entry in ipairs(entries) do
+            entry.playerName = playerName
+            table.insert(byPlayer[playerName], entry)
+        end
+
+        self.activeOrder = { playerName }
+        self.unitByPlayer = { [playerName] = "player" }
+        self.lastEntryCount = 0
+        local active = {}
+        local shownOrder = {}
+        local shouldTick = false
+        for _, playerName in ipairs(self.activeOrder) do
+            local frame = self:EnsurePlayerFrame(playerName)
+            HMGT.TrackerFrame:SetLocked(frame, s.locked)
+            HMGT.TrackerFrame:SetTitle(frame, string.format("%s - %s", L["GCD_TITLE"], ShortName(playerName)))
+            local displayEntries = byPlayer[playerName]
+            if HMGT.FilterDisplayEntries then
+                displayEntries = HMGT:FilterDisplayEntries(s, displayEntries) or displayEntries
+            end
+            if HMGT.SortDisplayEntries then
+                HMGT:SortDisplayEntries(displayEntries, "groupCooldownTracker")
+            end
+            if #displayEntries > 0 then
+                HMGT.TrackerFrame:UpdateFrame(frame, displayEntries, true)
+                self.lastEntryCount = self.lastEntryCount + #displayEntries
+                frame:Show()
+                active[playerName] = true
+                shownOrder[#shownOrder + 1] = playerName
+                shouldTick = true
+            else
+                frame:Hide()
+            end
+        end
+        self.activeOrder = shownOrder
+
+        for pn, frame in pairs(self.frames) do
+            if not active[pn] then
+                frame:Hide()
+            end
+        end
+
+        self:RefreshAnchors()
+        self:SetUpdateTickerEnabled(shouldTick)
+        return
+    end
+
+    if IsInRaid() or not IsInGroup() then
+        self.lastEntryCount = 0
+        self:StopUpdateTicker()
+        self:HideAllFrames()
+        return
+    end
+    if not s.enabled then
+        self.lastEntryCount = 0
+        self:StopUpdateTicker()
+        self:HideAllFrames()
+        return
+    end
+    if not HMGT:IsVisibleForCurrentGroup(s) then
+        self.lastEntryCount = 0
+        self:StopUpdateTicker()
+        self:HideAllFrames()
+        return
+    end
+
+    local entriesByPlayer, order, unitByPlayer = self:CollectEntriesByPlayer()
+    self.activeOrder = order
+    self.unitByPlayer = unitByPlayer
+    self.lastEntryCount = 0
+    local active = {}
+    local shownOrder = {}
+    local shouldTick = false
+
+    for _, playerName in ipairs(order) do
+        local frame = self:EnsurePlayerFrame(playerName)
+        HMGT.TrackerFrame:SetLocked(frame, s.locked)
+        HMGT.TrackerFrame:SetTitle(frame, string.format("%s - %s", L["GCD_TITLE"], ShortName(playerName)))
+
+        local entries = entriesByPlayer[playerName] or {}
+        if HMGT.FilterDisplayEntries then
+            entries = HMGT:FilterDisplayEntries(s, entries) or entries
+        end
+        if HMGT.SortDisplayEntries then
+            HMGT:SortDisplayEntries(entries, "groupCooldownTracker")
+        end
+        if #entries > 0 then
+            HMGT.TrackerFrame:UpdateFrame(frame, entries, true)
+            self.lastEntryCount = self.lastEntryCount + #entries
+            frame:Show()
+            active[playerName] = true
+            shownOrder[#shownOrder + 1] = playerName
+            for _, entry in ipairs(entries) do
+                if EntryNeedsVisualTicker(entry) then
+                    shouldTick = true
+                    break
+                end
+            end
+        else
+            frame:Hide()
+        end
+    end
+    self.activeOrder = shownOrder
+
+    for pn, frame in pairs(self.frames) do
+        if not active[pn] then
+            frame:Hide()
+        end
+    end
+
+    self:RefreshAnchors()
+    self:SetUpdateTickerEnabled(shouldTick)
+end
+
+function GCT:CollectEntriesByPlayer()
+    local s = HMGT.db.profile.groupCooldownTracker
+    local byPlayer = {}
+    local playerOrder = {}
+    local unitByPlayer = {}
+    local players = self:GetGroupPlayers()
+
+    for _, playerInfo in ipairs(players) do
+        repeat
+            local name = playerInfo.name
+            if not name then break end
+
+            local pData = HMGT.playerData[name]
+            local class = pData and pData.class or playerInfo.class
+            local specIdx
+            if playerInfo.isOwn then
+                specIdx = GetSpecialization()
+                if not specIdx or specIdx == 0 then break end
+            else
+                specIdx = pData and pData.specIndex or nil
+                if not specIdx or tonumber(specIdx) <= 0 then break end
+            end
+            local talents = pData and pData.talents or {}
+            if not class then break end
+
+            local knownCDs = HMGT_SpellData.GetSpellsForSpec(class, specIdx, HMGT_SpellData.GroupCooldowns)
+            local entries = {}
+            for _, spellEntry in ipairs(knownCDs) do
+                if s.enabledSpells[spellEntry.spellId] ~= false then
+                    local remaining, total, curCharges, maxCharges = HMGT:GetCooldownInfo(name, spellEntry.spellId, {
+                        deferChargeCooldownUntilEmpty = false,
+                    })
+                    local isAvailabilitySpell = HMGT.IsAvailabilitySpell and HMGT:IsAvailabilitySpell(spellEntry)
+                    local effectiveCd = HMGT_SpellData.GetEffectiveCooldown(spellEntry, talents)
+                    local hasChargeSpell = (tonumber(maxCharges) or 0) > 1
+                    local hasPartialCharges = (tonumber(maxCharges) or 0) > 0 and (tonumber(curCharges) or tonumber(maxCharges) or 0) < (tonumber(maxCharges) or 0)
+                    local include = HMGT:ShouldDisplayEntry(s, remaining, curCharges, maxCharges, spellEntry)
+                    local spellKnown = HMGT:IsTrackedSpellKnownForPlayer(name, spellEntry.spellId)
+                    local hasActiveCd = ((remaining or 0) > 0) or hasPartialCharges
+                    if not spellKnown and not hasActiveCd then
+                        include = false
+                    end
+                    if isAvailabilitySpell and not spellKnown then
+                        include = false
+                    end
+                    if not playerInfo.isOwn then
+                        if isAvailabilitySpell and not HMGT:HasAvailabilityState(name, spellEntry.spellId) then
+                            include = false
+                        end
+                    end
+                    if include then
+                        table.insert(entries, {
+                            playerName = name,
+                            class      = class,
+                            spellEntry = spellEntry,
+                            remaining  = remaining,
+                            total      = total > 0 and total or effectiveCd,
+                            currentCharges = curCharges,
+                            maxCharges     = maxCharges,
+                        })
+                    end
+                end
+            end
+
+            if #entries > 0 then
+                byPlayer[name] = entries
+                table.insert(playerOrder, name)
+                unitByPlayer[name] = playerInfo.unitId
+            end
+        until true
+    end
+
+    table.sort(playerOrder, function(a, b)
+        local own = HMGT:NormalizePlayerName(UnitName("player"))
+        if a == own and b ~= own then return true end
+        if b == own and a ~= own then return false end
+        return a < b
+    end)
+
+    return byPlayer, playerOrder, unitByPlayer
+end
+
+function GCT:GetGroupPlayers()
+    local players = {}
+    local ownName = HMGT:NormalizePlayerName(UnitName("player"))
+    local settings = HMGT.db and HMGT.db.profile and HMGT.db.profile.groupCooldownTracker
+
+    if settings and settings.includeSelfFrame == true and ownName then
+        table.insert(players, {
+            name = ownName,
+            class = select(2, UnitClass("player")),
+            unitId = "player",
+            isOwn = true,
+        })
+    end
+
+    if IsInGroup() and not IsInRaid() then
+        for i = 1, GetNumGroupMembers() - 1 do
+            local unitId = "party" .. i
+            local name = HMGT:NormalizePlayerName(UnitName(unitId))
+            local class = select(2, UnitClass(unitId))
+            if name and name ~= ownName then
+                table.insert(players, {name = name, class = class, unitId = unitId})
+            end
+        end
+    end
+
+    return players
+end
+

Modules/Tracker/GroupTrackerFrames.lua

@@ -0,0 +1,247 @@
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+if not HMGT or not HMGT.TrackerManager then return end
+
+local Manager = HMGT.TrackerManager
+local S = Manager._shared or {}
+
+function Manager:EnsurePlayerFrame(tracker, playerName)
+    local frameKey = S.GetTrackerFrameKey(tracker.id)
+    self.perPlayerFrames[frameKey] = self.perPlayerFrames[frameKey] or {}
+    local frame = self.perPlayerFrames[frameKey][playerName]
+    if not frame then
+        frame = HMGT.TrackerFrame:CreateTrackerFrame(S.GetTrackerPlayerFrameName(tracker.id, playerName), tracker)
+        frame._hmgtTrackerId = tonumber(tracker.id) or 0
+        frame._hmgtPlayerName = playerName
+        self.perPlayerFrames[frameKey][playerName] = frame
+    end
+    frame._settings = tracker
+    HMGT.TrackerFrame:SetTitle(frame, string.format("%s - %s", S.GetTrackerLabel(tracker), S.ShortName(playerName)))
+    HMGT.TrackerFrame:SetLocked(frame, tracker.locked)
+    return frame
+end
+
+function Manager:HidePlayerFrames(frameKey)
+    local frames = self.perPlayerFrames[frameKey]
+    if type(frames) ~= "table" then
+        self.activeOrders[frameKey] = nil
+        self.unitByPlayer[frameKey] = nil
+        self.anchorLayoutSignatures[frameKey] = nil
+        self.nextAnchorRetryAt[frameKey] = nil
+        self._displaySignatures[frameKey] = "0"
+        return
+    end
+    for _, frame in pairs(frames) do
+        frame:Hide()
+    end
+    self.activeOrders[frameKey] = nil
+    self.unitByPlayer[frameKey] = nil
+    self.anchorLayoutSignatures[frameKey] = nil
+    self.nextAnchorRetryAt[frameKey] = nil
+    self._displaySignatures[frameKey] = "0"
+end
+
+function Manager:BuildEntriesByPlayerForTracker(tracker)
+    local frameKey = S.GetTrackerFrameKey(tracker.id)
+    local ownName = HMGT:NormalizePlayerName(UnitName("player")) or "Player"
+    if tracker.testMode then
+        local entries = self:CollectTestEntries(tracker)
+        if S.IsGroupTracker(tracker) and tracker.attachToPartyFrame == true then
+            return S.BuildPartyPreviewEntries(entries)
+        end
+        local byPlayer, order, unitByPlayer = {}, {}, {}
+        if #entries > 0 then
+            byPlayer[ownName] = entries
+            order[1] = ownName
+            unitByPlayer[ownName] = "player"
+        end
+        return byPlayer, order, unitByPlayer, true
+    end
+    if tracker.demoMode then
+        local entries = HMGT:GetDemoEntries(frameKey, S.GetTrackerSpellPool(tracker.categories), tracker)
+        if S.IsGroupTracker(tracker) and tracker.attachToPartyFrame == true then
+            return S.BuildPartyPreviewEntries(entries)
+        end
+        for _, entry in ipairs(entries) do
+            entry.playerName = ownName
+        end
+        local byPlayer, order, unitByPlayer = {}, {}, {}
+        if #entries > 0 then
+            byPlayer[ownName] = entries
+            order[1] = ownName
+            unitByPlayer[ownName] = "player"
+        end
+        return byPlayer, order, unitByPlayer, true
+    end
+    if not tracker.enabled or not HMGT:IsVisibleForCurrentGroup(tracker) then
+        return {}, {}, {}, false
+    end
+    if IsInRaid() or not IsInGroup() then
+        return {}, {}, {}, false
+    end
+    local byPlayer, order, unitByPlayer = {}, {}, {}
+    for _, playerInfo in ipairs(S.GetGroupPlayers(tracker)) do
+        local entries = S.CollectEntriesForPlayer(tracker, playerInfo)
+        if #entries > 0 then
+            local playerName = playerInfo.name
+            byPlayer[playerName] = entries
+            order[#order + 1] = playerName
+            unitByPlayer[playerName] = playerInfo.unitId
+        end
+    end
+    return byPlayer, order, unitByPlayer, true
+end
+
+function Manager:RefreshPerGroupAnchors(tracker, force)
+    local frameKey = S.GetTrackerFrameKey(tracker.id)
+    local frames = self.perPlayerFrames[frameKey] or {}
+    local ordered = {}
+    for _, playerName in ipairs(self.activeOrders[frameKey] or {}) do
+        local frame = frames[playerName]
+        if frame and frame:IsShown() then
+            ordered[#ordered + 1] = playerName
+        end
+    end
+    if #ordered == 0 then
+        self.anchorLayoutSignatures[frameKey] = nil
+        self.nextAnchorRetryAt[frameKey] = nil
+        return
+    end
+    local now = GetTime()
+    local signature = S.BuildAnchorLayoutSignature(tracker, ordered, self.unitByPlayer[frameKey])
+    if not force and self.anchorLayoutSignatures[frameKey] == signature then
+        local retryAt = tonumber(self.nextAnchorRetryAt[frameKey]) or 0
+        if retryAt <= 0 or now < retryAt then
+            return
+        end
+    end
+    for _, playerName in ipairs(ordered) do
+        local frame = frames[playerName]
+        if frame and frame._hmgtDragging then
+            return
+        end
+    end
+    if tracker.attachToPartyFrame == true then
+        local side = tracker.partyAttachSide or "RIGHT"
+        local extraX = tonumber(tracker.partyAttachOffsetX) or 8
+        local extraY = tonumber(tracker.partyAttachOffsetY) or 0
+        local growsUp = tracker.showBar == true and tracker.growDirection == "UP"
+        local barHeight = tonumber(tracker.barHeight) or 20
+        local growUpAttachOffset = barHeight + 20
+        local prevPlaced = nil
+        local missingTargets = 0
+        for _, playerName in ipairs(ordered) do
+            local frame = frames[playerName]
+            local unitId = self.unitByPlayer[frameKey] and self.unitByPlayer[frameKey][playerName]
+            local target = S.ResolveUnitAnchorFrame(unitId)
+            local contentTopInset = HMGT.TrackerFrame.GetContentTopInset and HMGT.TrackerFrame:GetContentTopInset(frame) or 0
+            frame:ClearAllPoints()
+            if target then
+                if side == "LEFT" then
+                    if growsUp then
+                        frame:SetPoint("BOTTOMRIGHT", target, "TOPLEFT", -extraX, extraY - growUpAttachOffset)
+                    else
+                        frame:SetPoint("TOPRIGHT", target, "TOPLEFT", -extraX, extraY + contentTopInset)
+                    end
+                else
+                    if growsUp then
+                        frame:SetPoint("BOTTOMLEFT", target, "TOPRIGHT", extraX, extraY - growUpAttachOffset)
+                    else
+                        frame:SetPoint("TOPLEFT", target, "TOPRIGHT", extraX, extraY + contentTopInset)
+                    end
+                end
+            elseif prevPlaced then
+                missingTargets = missingTargets + 1
+                HMGT:DebugScoped("verbose", HMGT:GetTrackerDebugScope(tracker), "TrackerAttach fallback-stack tracker=%s player=%s unit=%s", tostring(tracker.id), tostring(playerName), tostring(unitId))
+                if growsUp then
+                    frame:SetPoint("BOTTOMLEFT", prevPlaced, "TOPLEFT", 0, (tracker.barSpacing or 2) + 10)
+                else
+                    frame:SetPoint("TOPLEFT", prevPlaced, "BOTTOMLEFT", 0, -((tracker.barSpacing or 2) + 10))
+                end
+            else
+                missingTargets = missingTargets + 1
+                HMGT:DebugScoped("info", HMGT:GetTrackerDebugScope(tracker), "TrackerAttach fallback-anchor tracker=%s player=%s unit=%s", tostring(tracker.id), tostring(playerName), tostring(unitId))
+                HMGT.TrackerFrame:ApplyAnchor(frame)
+            end
+            frame:EnableMouse(false)
+            prevPlaced = frame
+        end
+        if missingTargets > 0 then
+            self.anchorLayoutSignatures[frameKey] = nil
+            self.nextAnchorRetryAt[frameKey] = now + 1.0
+        else
+            self.anchorLayoutSignatures[frameKey] = signature
+            self.nextAnchorRetryAt[frameKey] = nil
+        end
+        return
+    end
+    local primary = frames[ordered[1]]
+    HMGT.TrackerFrame:ApplyAnchor(primary)
+    primary:EnableMouse(not tracker.locked)
+    local gap = (tracker.barSpacing or 2) + 10
+    local growsUp = tracker.showBar == true and tracker.growDirection == "UP"
+    for index = 2, #ordered do
+        local prev = frames[ordered[index - 1]]
+        local frame = frames[ordered[index]]
+        frame:ClearAllPoints()
+        if growsUp then
+            frame:SetPoint("BOTTOMLEFT", prev, "TOPLEFT", 0, gap)
+        else
+            frame:SetPoint("TOPLEFT", prev, "BOTTOMLEFT", 0, -gap)
+        end
+        frame:EnableMouse(false)
+    end
+    self.anchorLayoutSignatures[frameKey] = signature
+    self.nextAnchorRetryAt[frameKey] = nil
+end
+
+function Manager:UpdatePerGroupMemberTracker(tracker)
+    local frameKey = S.GetTrackerFrameKey(tracker.id)
+    local byPlayer, order, unitByPlayer, shouldShow = self:BuildEntriesByPlayerForTracker(tracker)
+    self.activeOrders[frameKey] = order
+    self.unitByPlayer[frameKey] = unitByPlayer
+    local active, shownOrder = {}, {}
+    local shownByPlayer = {}
+    local entryCount, shouldTick = 0, false
+    for _, playerName in ipairs(order) do
+        local frame = self:EnsurePlayerFrame(tracker, playerName)
+        local entries = byPlayer[playerName] or {}
+        if HMGT.FilterDisplayEntries then
+            entries = HMGT:FilterDisplayEntries(tracker, entries) or entries
+        end
+        if HMGT.SortDisplayEntries then
+            HMGT:SortDisplayEntries(entries)
+        end
+        if #entries > 0 then
+            HMGT.TrackerFrame:UpdateFrame(frame, entries, true)
+            frame:Show()
+            active[playerName] = true
+            shownOrder[#shownOrder + 1] = playerName
+            shownByPlayer[playerName] = entries
+            entryCount = entryCount + #entries
+            for _, entry in ipairs(entries) do
+                if S.EntryNeedsVisualTicker(entry) then
+                    shouldTick = true
+                    break
+                end
+            end
+        else
+            frame:Hide()
+        end
+    end
+    for playerName, frame in pairs(self.perPlayerFrames[frameKey] or {}) do
+        if not active[playerName] then
+            frame:Hide()
+        end
+    end
+    self.activeOrders[frameKey] = shownOrder
+    self.unitByPlayer[frameKey] = unitByPlayer
+    self._displaySignatures[frameKey] = S.BuildGroupDisplaySignature and S.BuildGroupDisplaySignature(shownOrder, shownByPlayer) or nil
+    if shouldShow and #shownOrder > 0 then
+        self:RefreshPerGroupAnchors(tracker, false)
+        return true, entryCount, shouldTick
+    end
+    self:HidePlayerFrames(frameKey)
+    self._displaySignatures[frameKey] = "0"
+    return false, 0, false
+end

Modules/Tracker/InterruptTracker/InterruptSpellDatabase.lua

@@ -0,0 +1,154 @@
+-- Core/InterruptSpellDatabase.lua
+
+HMGT_SpellData = HMGT_SpellData or {}
+local Spell = HMGT_SpellData.Spell
+if not Spell then return end
+
+HMGT_SpellData.Interrupts = {
+    -- WARRIOR
+    Spell(6552, "Pummel", {
+        classes = {"WARRIOR"},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 15 },
+        mods = {
+            { talentSpellId = 391271, value = 10, op = "reduceByPercent", target = "cooldown" },
+        },
+    }),
+    Spell(23920, "Spell Reflection", {
+        classes = {"WARRIOR"},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 20 },
+        mods = {
+            { talentSpellId = 391271, value = 10, op = "reduceByPercent", target = "cooldown" },
+        },
+    }),
+
+    -- PALADIN
+    Spell(96231, "Rebuke", {
+        classes = {"PALADIN"},
+        specs = {3},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 15 },
+    }),
+
+    -- HUNTER
+    Spell(147362, "Counter Shot", {
+        classes = {"HUNTER"},
+        specs = {1, 2},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 24 },
+    }),
+    Spell(187707, "Muzzle", {
+        classes = {"HUNTER"},
+        specs = {3},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 15 },
+    }),
+
+    -- ROGUE
+    Spell(1766, "Kick", {
+        classes = {"ROGUE"},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 15 },
+    }),
+
+    -- PRIEST
+    Spell(15487, "Silence", {
+        classes = {"PRIEST"},
+        specs = {3},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 45 },
+    }),
+
+    -- DEATH KNIGHT
+    Spell(47528, "Mind Freeze", {
+        classes = {"DEATHKNIGHT"},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 15 },
+        relations = {
+            {
+                when = "interruptSuccess",
+                effects = {
+                    {
+                        type = "reduceCooldown",
+                        targetSpellId = 47528,
+                        amount = 3,
+                        talentSpellId = 378848,
+                    },
+                },
+            },
+        },
+    }),
+
+    -- SHAMAN
+    Spell(57994, "Wind Shear", {
+        classes = {"SHAMAN"},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 12 },
+    }),
+
+    -- MAGE
+    Spell(2139, "Counterspell", {
+        classes = {"MAGE"},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 24 },
+    }),
+
+    -- WARLOCK
+    Spell(19647, "Spell Lock", {
+        classes = {"WARLOCK"},
+        specs = {2},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 24 },
+    }),
+    Spell(132409, "Spell Lock (Grimoire)", {
+        classes = {"WARLOCK"},
+        specs = {1, 3},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 24 },
+    }),
+
+    -- MONK
+    Spell(116705, "Spear Hand Strike", {
+        classes = {"MONK"},
+        specs = {1, 3},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 15 },
+    }),
+
+    -- DEMON HUNTER
+    Spell(183752, "Disrupt", {
+        classes = {"DEMONHUNTER"},
+        specs = {nil},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 15 },
+    }),
+
+    -- DRUID
+    Spell(78675, "Solar Beam", {
+        classes = {"DRUID"},
+        specs = {1},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 60 },
+    }),
+    Spell(106839, "Skull Bash", {
+        classes = {"DRUID"},
+        specs = {2, 3},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 15 },
+    }),
+
+    -- EVOKER
+    Spell(351338, "Quell", {
+        classes = {"EVOKER"},
+        category = "interrupt",
+        state = { kind = "cooldown", cooldown = 40 },
+        mods = {
+            { talentSpellId = 396371, value = 20, op = "set", target = "cooldown" },
+        },
+    }),
+}
+
+if HMGT_SpellData.RebuildLookups then
+    HMGT_SpellData.RebuildLookups()
+end

Modules/Tracker/InterruptTracker/InterruptTracker.lua

@@ -0,0 +1,21 @@
+-- Modules/InterruptTracker.lua
+-- Interrupt tracker based on the shared single-frame tracker base.
+
+local ADDON_NAME = "HailMaryGuildTools"
+local HMGT = LibStub("AceAddon-3.0"):GetAddon(ADDON_NAME)
+local L = LibStub("AceLocale-3.0"):GetLocale(ADDON_NAME)
+
+local Base = HMGT.SingleFrameTrackerBase
+if not Base then return end
+
+Base:CreateModule("InterruptTracker", {
+    profileKey = "interruptTracker",
+    frameName = "InterruptTracker",
+    title = function()
+        return L["IT_TITLE"]
+    end,
+    demoKey = "interruptTracker",
+    database = function()
+        return HMGT_SpellData.Interrupts
+    end,
+})