/
local S, C, Soop = unpack(select(2, ...)) -- Import: S - function; C - config; Soop - Database |
local LSM = LibStub("LibSharedMedia-3.0") |
-------------------------------------------------------------- |
-- Load Shared Media |
-------------------------------------------------------------- |
-- Fonts |
-------------------------------------------------------------- |
C["media"].font = LSM:Fetch("font", C["media"].font) |
-- Minimap Media |
C["minimap"].border = LSM:Fetch("border", C["minimap"].border) |
-- Item Quality Border |
C['general'].IQBorder = LSM:Fetch("border", C["general"].IQBorder) |
-- Skins |
-------------------------------------------------------------- |
-- -- Chat Media |
-- C["chat"].border = LSM:Fetch("border", C["chat"].border) |
-- C["chat"].background = LSM:Fetch("background", C["chat"].background) |
-- C["chat"].editboxborder = LSM:Fetch("border", C["chat"].editboxborder) |
-- C["chat"].editboxbackground = LSM:Fetch("background", C["chat"].editboxbackground) |
-- C["chat"].sound = LSM:Fetch("sound", C["chat"].sound) |
-- Datatext Media |
C["datatext"].border = LSM:Fetch("border", C["datatext"].border) |
C["datatext"].background = LSM:Fetch("background", C["datatext"].background) |
local LSM = LibStub("LibSharedMedia-3.0") |
if LSM == nil then return end |
-------------------------------------------------------------- |
-- Borders |
-------------------------------------------------------------- |
LSM:Register("background", "Black", [[Interface\Addons\SoopUI\Media\Textures\BLACK8X8.blp]]) |
LSM:Register("border", "Fer07", [[Interface\Addons\SoopUI\Media\Border\Fer07.tga]]) |
LSM:Register("border9", "Fer09", [[Interface\Addons\SoopUI\Media\Border\Fer09.tga]]) |
LSM:Register("border2", "Fer02", [[Interface\Addons\SoopUI\Media\Border\Fer02.tga]]) |
LSM:Register("border3", "Fer03", [[Interface\Addons\SoopUI\Media\Border\Fer03.tga]]) |
LSM:Register("border7", "Fer07", [[Interface\Addons\SoopUI\Media\Border\Fer07.tga]]) |
-------------------------------------------------------------- |
-- Font |
-------------------------------------------------------------- |
LSM:Register("font", "Adventure", [[Interface\Addons\SoopUI\Media\Fonts\Adventure.ttf]]) |
LSM:Register("font", "Bazooka", [[Interface\Addons\SoopUI\Media\Fonts\Bazooka.ttf]]) |
LSM:Register("font", "BigNoodleTitling", [[Interface\Addons\SoopUI\Media\Fonts\BigNoodleTitling.ttf]]) |
LSM:Register("font", "Expressway", [[Interface\Addons\SoopUI\Media\Fonts\Expressway.ttf]]) |
LSM:Register("font", "Enigmatic", [[Interface\Addons\SoopUI\Media\Fonts\Enigma__2.ttf]]) |
LSM:Register("font", "Vera Serif", [[Interface\Addons\SoopUI\Media\Fonts\VeraSe.ttf]]) |
LSM:Register("font", "Yellowjacket", [[Interface\Addons\SoopUI\Media\Fonts\YELLOWJACKET.ttf]]) |
LSM:Register("font", "DorisPP", [[Interface\Addons\SoopUI\Media\Fonts\DORISPP.ttf]]) |
LSM:Register("font", "Fitzgerald", [[Interface\Addons\SoopUI\Media\Fonts\Fitzgerald.ttf]]) |
LSM:Register("font", "Gentium", [[Interface\Addons\SoopUI\Media\Fonts\Gentium.ttf]]) |
LSM:Register("font", "Hooked Up", [[Interface\Addons\SoopUI\Media\Fonts\HookedUp.ttf]]) |
LSM:Register("font", "Liberation Sans", [[Interface\Addons\SoopUI\Media\Fonts\LiberationSans.ttf]]) |
LSM:Register("font", "semplice", [[Interface\Addons\SoopUI\Media\Fonts\semplice.ttf.ttf]]) |
LSM:Register("font", "Covington", [[Interface\Addons\SoopUI\Media\Fonts\SFCovington.ttf]]) |
LSM:Register("font", "Wonder Comic", [[Interface\Addons\SoopUI\Media\Fonts\SFWonderComic.ttf]]) |
LSM:Register("font", "swf!t", [[Interface\Addons\SoopUI\Media\Fonts\swfit.ttf]]) |
-------------------------------------------------------------- |
-- Sound |
-------------------------------------------------------------- |
LSM:Register("sound", "Warning", [[Interface\Addons\SoopUI\Media\Sound\Warning.mp3]]) |
LSM:Register("sound", "Whisper", [[Interface\Addons\SoopUI\Media\Sound\Whisper.mp3]]) |
## Interface: 50400 |
## Author: Soopie |
## Title: SoopUI |
## Version: 3.0.0 Beta 1 |
## RequiredDeps: SoopUI_Config |
## SavedVariables: SoopDB |
## SavedVariablesPerCharacter: SoopDBPerCharacter |
## OptionalDeps: SharedMedia, SharedMediaAdditionalFonts |
-------------------------------------------------------------- |
-- Libs |
-------------------------------------------------------------- |
Libs\Libs.xml |
Media\LSM.lua |
-------------------------------------------------------------- |
-- Core |
-------------------------------------------------------------- |
Core\Driver.lua |
Core\Core.lua |
Core\Defaults.lua |
Core\Config.lua |
-------------------------------------------------------------- |
-- Media |
-------------------------------------------------------------- |
Media\LSMLaunch.lua |
-------------------------------------------------------------- |
-- Modules |
-------------------------------------------------------------- |
------- DataText |
Modules\Datatext\Datapanel.lua |
Modules\Datatext\Positions.lua |
Modules\Datatext\Colors.lua |
Modules\Datatext\Coords.lua |
Modules\Datatext\Professions.lua |
Modules\Datatext\Stat1.lua |
Modules\Datatext\Stat2.lua |
Modules\Datatext\Battleground.lua |
Modules\Datatext\Durability.lua |
Modules\Datatext\System.lua |
Modules\Datatext\Friends.lua |
Modules\Datatext\Guild.lua |
Modules\Datatext\Time.lua |
Modules\Datatext\Spec.lua |
Modules\Datatext\Zone.lua |
Modules\Datatext\Calltoarms.lua |
------- General |
Modules\General\Autogreed.lua |
Modules\General\Merchant.lua |
Modules\General\Store.lua |
Modules\General\Font.lua |
Modules\General\Interrupts.lua |
Modules\General\Quest.lua |
Modules\General\Watchframe.lua |
Modules\General\Tooltip.lua |
------- Map |
Modules\Minimap\sMinimap.lua |
Modules\Tooltip\Tooltip.lua |
---------------------------------------------------------------------------- |
-- This loads new user defaults every time a new user is detected |
---------------------------------------------------------------------------- |
local S, C, Soop = unpack(select(2, ...)) -- Import: S - function C - config Soop - Database |
--Convert default database |
for group,options in pairs(Soop) do |
if not C[group] then C[group] = {} end |
for option, value in pairs(options) do |
C[group][option] = value |
end |
end |
if IsAddOnLoaded("SoopUI_Config") then |
local SoopUIConfig = LibStub("AceAddon-3.0"):GetAddon("SoopUIConfig") |
SoopUIConfig:Load() |
--Load settings from SoopUIConfig database |
for group, options in pairs(SoopUIConfig.db.profile) do |
if C[group] then |
for option, value in pairs(options) do |
C[group][option] = value |
end |
end |
end |
S.SavePath = SoopUIConfig.db.profile |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-- CVars |
local function SetDefaultCVars() |
-- Graphics |
if GetCVar("gxMultisample") ~= "1" then |
SetCVar("gxMultisample", 1) |
RestartGx() |
end |
-- Sound |
SetCVar("Sound_EnableErrorSpeech", 0) |
-- Nameplates |
SetCVar("bloatTest", 0) |
SetCVar("bloatnameplates", 0) |
SetCVar("bloatthreat", 0) |
-- Screenshots |
SetCVar("screenshotFormat", "jpg") -- JPG format |
SetCVar("screenshotQuality", "10") -- Highest quality |
-- Help |
SetCVar("showGameTips", 0) -- Turn off Loading Screen Tips |
SetCVar("showTutorials", 0) -- Turn off Tutorials |
SetCVar("UberTooltips", 1) -- Turn on Enhanced Tooltips |
SetCVar("scriptErrors", 1) -- Turn on Display Lua Errors |
-- Controls |
SetCVar("deselectOnClick", 1) -- Turn off Sticky Targeting (inverted) |
-- Combat |
SetCVar("displaySpellActivationOverlays", 1) -- Turn on Spell Alerts |
SetCVar("spellActivationOverlayOpacity", 0.75) -- Spell Alert Opacity |
-- Display |
SetCVar("emphasizeMySpellEffects", 0) -- Turn off Emphasize My Spell Effects |
SetCVar("SpellTooltip_DisplayAvgValues", 0) -- Turn off Display Points As Average |
-- Social |
SetCVar("chatBubbles", 0) -- Turn off Chat Bubbles |
SetCVar("chatBubblesParty", 0) -- Turn off Party Chat Bubbles |
SetCVar("chatStyle", "classic") -- Chat Style = "Classic" |
SetCVar("conversationMode", "inline") -- Conversation Mode = "In-line" |
-- Quests |
SetCVar("autoQuestWatch", 1) -- Auto Track Quests |
SetCVar("mapQuestDifficulty", 1) -- Color Quests by Difficulty on World Map |
-- Names |
SetCVar("UnitNameNPC", 1) -- Turn on NPC Names |
SetCVar("UnitNamePlayerPVPTitle", 0) -- Turn off PvP Player Titles |
SetCVar("UnitNameEnemyGuardianName", 1) -- Turn on Enemy Pet Names |
SetCVar("UnitNameEnemyTotemName", 1) -- Turn on Enemy Totem Names |
SetCVar("nameplateMotion", 1) -- Stacking Nameplates |
-- Camera |
SetCVar("cameraYawSmoothSpeed", 210) |
SetCVar("cameraView", 1) -- Camera Stlye |
SetCVar("cameraDistanceMax", 50) -- Camera Max Distance |
SetCVar("cameraDistanceMaxFactor", 3) -- Camera Follow Speed |
-- Quality of Life |
SetCVar("guildShowOffline", 0) -- Hide Offline Guild Members |
SetCVar("profanityFilter", 0) -- Turn off Profanity Filter |
end |
-------------------------------------------------------------- |
-- SoopUI Media Options |
-------------------------------------------------------------- |
Soop ["media"] = { |
["font"] = "Express", |
["fontSize"] = 14, |
["fontxSmall"] = 10, |
["fontSmall"] = 12, |
["fontMedium"] = 14, |
["fontLarge"] = 16, |
["fontHuge"] = 20, |
} |
-------------------------------------------------------------- |
-- General Options |
-------------------------------------------------------------- |
Soop ["general"] = { |
["color"] = { r = 1, g = 1, b = 1}, |
["classcolor"] = true, |
["autogreed"] = true, |
["Interrupts"] = true, |
} |
--------------------- |
-- Datatext Options |
--------------------- |
Soop ["datatext"] = { |
["enable"] = true, |
["border"] = "border", |
["background"] = "Blizzard Dialog Background", |
["top"] = false, -- if = true then panel on top of screen, if = false panel below mainmenubar |
["fontsize"] = 11, -- font size for panels. |
["system"] = 5, -- show total memory and others systems info (FPS/MS) on panel. |
["wowtime"] = 3, -- show time on panel. |
["guild"] = 2, -- show number on guildmate connected on panel. |
["dur"] = 8, -- show your equipment durability on panel. |
["friends"] = 1, -- show number of friends connected. |
["spec"] = 6, -- show your current spec on panel. |
["zone"] = 0, -- show your current zone on panel. |
["coords"] = 0, -- show your current coords on panel. |
["pro"] = 0, -- shows your professions and tradeskills |
["stat1"] = 0, -- Stat Based on your Role (Avoidance-Tank, AP-Melee, SP/HP-Caster) |
["stat2"] = 0, -- Stat Based on your Role (Armor-Tank, Crit-Melee, Crit-Caster) |
["calltoarms"] = 0, -- Show Current Call to Arms. |
-- Color Datatext |
["colors"] = { |
["color"] = { r = 0, g = 0, b = 1}, -- datatext color if classcolor = false |
}, |
["battleground"] = true, -- enable 3 stats in battleground only that replace stat1,stat2,stat3. |
-- Clock Settings |
["time24"] = false, -- set time to 24h format. |
["localtime"] = true, -- set time to local time instead of server time. |
-- FPS Settings |
["fps"] = { |
["enable"] = true, -- enable the FPS on the System Tooltip |
-- ONLY ONE OF THESE CAN BE TRUE |
["home"] = false, -- Only Show Home Latency |
["world"] = false, -- Only Show World Latency |
["both"] = true, -- Show both Home and World Latency |
}, |
} |
-------------------------------------------------------------- |
-- Merchant Options |
-- Merchant provides the auto-sell and repair functions |
-------------------------------------------------------------- |
Soop ["merchant"] = { |
["enable"] = true, -- enable merchant module. |
["sellMisc"] = true, -- allows the user to add specific items to sell at merchant (please see the local filter in merchant.lua) |
["autoSellGrey"] = true, -- Allow grey items to be sold |
["autoRepair"] = true, -- Should we auto-repair? |
} |
-------------------------------------------------------------- |
-- Minimap Options |
-------------------------------------------------------------- |
Soop ["minimap"] = { |
["enable"] = true, |
["border"] = "fer09", |
["gameclock"] = true, |
["farm"] = false, |
["farmscale"] = 3, |
["zoneText"] = true, |
["instanceDifficulty"] = false, |
} |
-------------------------------------------------------------- |
-- Quest Options (Autocomplete/Turn in) |
-------------------------------------------------------------- |
Soop["quest"] = { |
["enable"] = true, -- enable quest module. |
["autocomplete"] = false, -- enable the autoaccept quest and autocomplete quest if no reward. |
} |
------------------- |
-- Tooltip Options |
------------------- |
Soop["tooltip"] = { |
["enable"] = true, -- Move the tooltip up so its not overlapping the MainMenubar |
["fontSize"] = 14, |
["fontOutline"] = true, |
["disableFade"] = false, -- Can cause errors or a buggy tooltip! |
["border"] = "Blizzard Tooltip", |
["background"] = "Black", |
["statusbar"] = "Blizzard", |
["reactionBorderColor"] = true, |
["itemqualityBorderColor"] = true, |
["showPlayerTitles"] = true, |
["showPVPIcons"] = false, -- Show pvp icons instead of just a prefix |
["abbrevRealmNames"] = false, |
["showMouseoverTarget"] = true, |
["showOnMouseover"] = false, |
["showUnitRole"] = true, |
["showItemLevel"] = true, |
["showSpecializationIcon"] = false, |
["showItemLevel"] = true, |
["healthbar"] = { |
["showHealthValue"] = true, |
["showOutline"] = false, |
["healthFormat"] = '$cur / $max', -- Possible: $cur, $max, $deficit, $perc, $smartperc, $smartcolorperc, $colorperc |
["healthFullFormat"] = '$cur', -- if the tooltip unit has 100% hp |
["textPos"] = "CENTER", -- Possible "TOP" "BOTTOM" "CENTER" |
["reactionColoring"] = false, |
["customColorapply"] = false, |
["custom"] = { |
["apply"] = false, |
["color"] = { r = 1, g = 1, b = 0}, |
}, |
["fontSize"] = 14, |
}, |
} |
local S, C, Soop = unpack(select(2, ...)) -- Import driver || S = Functions || C = Config || Soop = Database |
local L = setmetatable({}, { __index = function(t,k) |
local v = tostring(k) |
rawset(t, k, v) |
return v |
end }) |
-------------------------------------------------------------- |
-- Constants |
-- m = scaling by resolution |
-------------------------------------------------------------- |
local m = 768/string.match(GetCVar("gxResolution"), "%d+x(%d+)")/min(2, max(.64, 768/string.match(({GetScreenResolutions()})[GetCurrentResolution()], "%d+x(%d+)"))); |
S.scale = function(v) return m * floor(v/m+.5) end; |
S.dummy = function() return end |
S.toc = select(4, GetBuildInfo()) |
S.myname, _ = UnitName("player") |
S.myrealm = GetRealmName() |
_, S.myclass = UnitClass("player") |
S.version = "3.0.0 Alpha 1" |
S.patch = GetBuildInfo() |
S.level = UnitLevel("player") |
S.locale = GetLocale() |
--- Resolution scaling |
S.resolution = GetCurrentResolution() |
S.getscreenresolution = select(S.resolution, GetScreenResolutions()) |
S.getscreenheight = tonumber(string.match(({GetScreenResolutions()})[GetCurrentResolution()], "%d+x(%d+)")) |
S.getscreenwidth = tonumber(string.match(({GetScreenResolutions()})[GetCurrentResolution()], "(%d+)x+%d")) |
-- Class coloring |
S.ccolor = RAID_CLASS_COLORS[select(2, UnitClass("player"))] |
-- Screen areas defined |
S.regions ={['TOPLEFT'] = L['TOPLEFT'], ['TOP'] = L['TOP'], ['TOPRIGHT'] = L['TOPRIGHT'], ['LEFT'] = L['LEFT'], ['CENTER'] = L['CENTER'], ['RIGHT'] = L['RIGHT'], ['BOTTOMLEFT'] = L['BOTTOMLEFT'], ['BOTTOM'] = L['BOTTOM'], ['BOTTOMRIGHT'] = L['BOTTOMRIGHT']} |
S.border = {['Blizzard'] = L['Blizzard'], ['SoopUI'] = L['SoopUI']} |
S.mapshape = {['SQUARE'] = L['SQUARE'], ['ROUND'] = L['ROUND']} |
--[[ Class Role Key |
-- DEATHKNIGHT = [1] = "Tank", [2] = "Melee", [3] = "Melee" |
-- DRUID = [1] = "Caster", [2] = "Melee", [3] = "Tank", [4] = "Caster" |
-- HUNTER = "Melee" |
-- MAGE = "Caster" |
-- MONK = [1] = "Tank", [2] = "Caster", [3] = "Melee" |
-- PALADIN = [1] = "Caster", [2] = "Tank", [3] = "Melee" |
-- PRIEST = "Caster" |
-- ROGUE = "Melee" |
-- SHAMAN = [1] = "Caster", [2] = "Melee", [3] = "Caster" |
-- WARRIOR = [1] = "Melee", [2] = "Melee", [3] = "Tank" |
-- WARLOCK = "Caster" |
--]] |
-------------------------------------------------------------- |
-- Check player roles |
-------------------------------------------------------------- |
local RoleUpdater = CreateFrame("Frame") |
local function CheckRole(self, event, unit) |
local tree = GetSpecialization() |
local resilience |
local resilperc = GetCombatRatingBonus(COMBAT_RATING_RESILIENCE_PLAYER_DAMAGE_TAKEN) |
if resilperc > GetDodgeChance() and resilperc > GetParryChance() then |
resilience = true |
else |
resilience = false |
end |
if ((S.myclass == "PALADIN" and tree == 2) or |
(S.myclass == "WARRIOR" and tree == 3) or |
(S.myclass == "DEATHKNIGHT" and tree == 1) or |
(S.myclass == "MONK" and tree == 1)) and |
resilience == false or |
(S.myclass == "DRUID" and tree == 2 and GetBonusBarOffset() == 3) then |
S.Role = "Tank" |
else |
local playerint = select(2, UnitStat("player", 4)) |
local playeragi = select(2, UnitStat("player", 2)) |
local base, posBuff, negBuff = UnitAttackPower("player"); |
local playerap = base + posBuff + negBuff; |
if (((playerap > playerint) or (playeragi > playerint)) and not (S.myclass == "DRUID" and tree ~= 1 and tree ~= 3 and tree ~= 4) or (S.myclass == "SHAMAN" and tree ~= 1 and tree ~= 3) or (S.myclass == "MONK" and tree ~= 1 and tree ~= 2) or (S.myclass == "PALADIN" and tree ~= 1 and tree ~= 3) or S.myclass == "ROGUE" or S.myclass == "HUNTER") then |
S.Role = "Melee" |
else |
S.Role = "Caster" |
end |
end |
end |
RoleUpdater:RegisterEvent("PLAYER_ENTERING_WORLD") |
RoleUpdater:RegisterEvent("ACTIVE_TALENT_GROUP_CHANGED") |
RoleUpdater:RegisterEvent("PLAYER_TALENT_UPDATE") |
RoleUpdater:RegisterEvent("CHARACTER_POINTS_CHANGED") |
RoleUpdater:RegisterEvent("UNIT_INVENTORY_CHANGED") |
RoleUpdater:RegisterEvent("UPDATE_BONUS_ACTIONBAR") |
RoleUpdater:SetScript("OnEvent", CheckRole) |
CheckRole() |
S.SetFontString = function(parent, fontName, fontHeight, fontStyle) |
local fs = parent:CreateFontString(nil, 'OVERLAY') |
fs:SetFont(fontName, fontHeight, fontStyle) |
fs:SetJustifyH('LEFT') |
fs:SetShadowColor(0, 0, 0) |
fs:SetShadowOffset(1.25, -1.25) |
return fs |
end |
-------------------------------------------------------------- |
-- Message on Login |
-------------------------------------------------------------- |
local EventFrame = CreateFrame("Frame") |
EventFrame:RegisterEvent("PLAYER_LOGIN") |
EventFrame:SetScript("OnEvent", function(self,event,...) |
if type(SoopDBPerCharacter) ~= "number" then -- Saved variable SoopDBPerCharacter = |
SoopDBPerCharacter = 1 |
ChatFrame1:AddMessage("This appears to be the first time you've loaded |cff00B4FFSoopUI|r . You must install before you begin playing. Thanks for choosing |cff00B4FFSoopUI v"..S.version..'|r.') |
else |
if SoopDBPerCharacter == 1 then |
ChatFrame1:AddMessage('Welcome back '.. UnitName("Player")..". You're using |cff00B4FFSoopUI v"..S.version..'|r.') |
else |
ChatFrame1:AddMessage('Welcome back '.. UnitName("Player")..". You're using |cff00B4FFSoopUI v"..S.version..'|r.') |
end |
SoopDBPerCharacter = SoopDBPerCharacter + 1 |
end |
end) |
-------------------------------------------------------------- |
-- RBG to hex conversion |
-------------------------------------------------------------- |
function S.RGBToHex(r, g, b) |
r = r <= 1 and r >= 0 and r or 0 |
g = g <= 1 and g >= 0 and g or 0 |
b = b <= 1 and b >= 0 and b or 0 |
return string.format("|cff%02x%02x%02x", r*255, g*255, b*255) |
end |
-------------------------------------------------------------- |
-- Hex to RBG conversion |
-------------------------------------------------------------- |
function S.HexToRGB(hex) |
local rhex, ghex, bhex = string.sub(hex, 1, 2), string.sub(hex, 3, 4), string.sub(hex, 5, 6) |
return tonumber(rhex, 16), tonumber(ghex, 16), tonumber(bhex, 16) |
end |
function S.ShortValue(v) |
if v >= 1e6 then |
return ("%.1fm"):format(v / 1e6):gsub("%.?0+([km])$", "%1") |
elseif v >= 1e3 or v <= -1e3 then |
return ("%.1fk"):format(v / 1e3):gsub("%.?0+([km])$", "%1") |
else |
return v |
end |
end |
S.SetUpAnimGroup = function(self) |
self.anim = self:CreateAnimationGroup("Pulse") |
self.anim.fadein = self.anim:CreateAnimation("ALPHA", "FadeIn") |
self.anim.fadein:SetChange(1) |
self.anim.fadein:SetOrder(2) |
self.anim.fadeout = self.anim:CreateAnimation("ALPHA", "FadeOut") |
self.anim.fadeout:SetChange(-1) |
self.anim.fadeout:SetOrder(1) |
end |
S.Flash = function(self, duration) |
if not self.anim then |
S.SetUpAnimGroup(self) |
end |
self.anim.fadein:SetDuration(duration) |
self.anim.fadeout:SetDuration(duration) |
self.anim:SetLooping("REPEAT") |
self.anim:Play() |
end |
S.StopFlash = function(self) |
if self.anim then |
self.anim:Finish() |
end |
end |
INTERFACE_ACTION_BLOCKED = '' |
-------------------------------------------------------------- |
-- Slash Command functionality |
-------------------------------------------------------------- |
SlashCmdList['RELOADUI'] = function() |
ReloadUI() |
end |
SLASH_RELOADUI1 = '/rl' |
SLASH_FRAME1 = "/frame" -- Identifies frames for you |
SlashCmdList["FRAME"] = function(arg) |
if arg ~= "" then |
arg = _G[arg] |
else |
arg = GetMouseFocus() |
end |
if arg ~= nil and arg:GetName() ~= nil then |
local point, relativeTo, relativePoint, xOfs, yOfs = arg:GetPoint() |
ChatFrame1:AddMessage("|cffCC0000----------------------------") |
ChatFrame1:AddMessage("Name: |cffFFD100"..arg:GetName()) |
if arg:GetParent() and arg:GetParent():GetName() then |
ChatFrame1:AddMessage("Parent: |cffFFD100"..arg:GetParent():GetName()) |
end |
ChatFrame1:AddMessage("Width: |cffFFD100"..format("%.2f",arg:GetWidth())) |
ChatFrame1:AddMessage("Height: |cffFFD100"..format("%.2f",arg:GetHeight())) |
ChatFrame1:AddMessage("Strata: |cffFFD100"..arg:GetFrameStrata()) |
ChatFrame1:AddMessage("Level: |cffFFD100"..arg:GetFrameLevel()) |
if xOfs then |
ChatFrame1:AddMessage("X: |cffFFD100"..format("%.2f",xOfs)) |
end |
if yOfs then |
ChatFrame1:AddMessage("Y: |cffFFD100"..format("%.2f",yOfs)) |
end |
if relativeTo and relativeTo:GetName() then |
ChatFrame1:AddMessage("Point: |cffFFD100"..point.."|r anchored to "..relativeTo:GetName().."'s |cffFFD100"..relativePoint) |
end |
ChatFrame1:AddMessage("|cffCC0000----------------------------") |
elseif arg == nil then |
ChatFrame1:AddMessage("Invalid frame name") |
else |
ChatFrame1:AddMessage("Could not find frame info") |
end |
end |
-------------------------------------------------------------- |
-- Hides UI Errors |
-------------------------------------------------------------- |
UIErrorsFrame:UnregisterEvent('UI_ERROR_MESSAGE') |
UIErrorsFrame:SetTimeVisible(1) |
UIErrorsFrame:SetFadeDuration(0.75) |
local ignoreList = { |
[ERR_SPELL_COOLDOWN] = true, |
[ERR_ABILITY_COOLDOWN] = true, |
[OUT_OF_ENERGY] = true, |
[SPELL_FAILED_NO_COMBO_POINTS] = true, |
[SPELL_FAILED_MOVING] = true, |
[ERR_NO_ATTACK_TARGET] = true, |
[SPELL_FAILED_SPELL_IN_PROGRESS] = true, |
[ERR_NO_ATTACK_TARGET] = true, |
[ERR_INVALID_ATTACK_TARGET] = true, |
[SPELL_FAILED_BAD_TARGETS] = true, |
} |
local event = CreateFrame('Frame') |
event:SetScript('OnEvent', function(self, event, error) |
if (not ignoreList[error]) then |
UIErrorsFrame:AddMessage(error, 1, .1, .1) |
end |
end) |
event:RegisterEvent('UI_ERROR_MESSAGE') |
---------------------------------- |
-- Communication between all parts of SoopUI |
---------------------------------- |
-- Includes |
local addon, driver = ... |
driver[1] = {} -- S, functions, constants |
driver[2] = {} -- C, config |
driver[3] = {} -- Soop, database, post config load |
SoopUI = driver -- Allow other addons to use Driver |
--[[ |
This should be at the top of every file inside of the SoopUI AddOn: |
local S, C, Soop = unpack(select(2, ...)) |
----------------------------------------------------------------------- |
This is how another addon imports the SoopUI driver: |
local S, C, Soop = unpack(SoopUI) |
]] |
local S, C, Soop = unpack(select(2, ...)) -- Import: S - function; C - Config; Soop - Database |
-------------------------------------------------------------- |
-- Minimap |
-- Inspired by nMinimap |
-------------------------------------------------------------- |
if C['minimap'].enable ~= true then return end |
-- Square Minimap |
Minimap:ClearAllPoints() |
-- Set Minimap to Square |
function GetMinimapShape() |
return 'SQUARE' |
end |
-- Set Minimap Position |
if C['datatext'].top ~= true then |
Minimap:SetPoint('TOPRIGHT', UIParent, -16, -16) |
else |
Minimap:SetPoint('TOPRIGHT', UIParent, -16, -16) |
end |
-------------------------------------------------------------- |
-- Minimap Border Frame Set |
-------------------------------------------------------------- |
local Minimapbg = CreateFrame("Frame", nil, Minimap) |
Minimapbg:SetPoint("TOPLEFT", -4, 4); |
Minimapbg:SetPoint("BOTTOMRIGHT", 4, -4); |
Minimapbg:SetBackdrop({ |
edgeFile = C['minimap'].border, |
tile = true, tileSize = 16, edgeSize = 18, |
}) |
if C['general'].classcolor ~= true then |
Minimapbg:SetBackdropBorderColor(C['general'].color.r,C['general'].color.g,C['general'].color.b) |
else |
Minimapbg:SetBackdropBorderColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
end |
MinimapCluster:RegisterEvent("PLAYER_REGEN_ENABLED") |
MinimapCluster:RegisterEvent("PLAYER_REGEN_DISABLED") |
MinimapCluster:HookScript("OnEvent", function(self, event) |
if event == "PLAYER_REGEN_ENABLED" then |
MinimapCluster:Show() |
elseif event == "PLAYER_REGEN_DISABLED" then |
MinimapCluster:Hide() |
end |
end) |
Minimap:SetMaskTexture('Interface\\ChatFrame\\ChatFrameBackground') |
-------------------------------------------------------------- |
-- Minimap Mail Notify |
-------------------------------------------------------------- |
MiniMapMailFrame:SetSize(14, 14) |
MiniMapMailFrame:ClearAllPoints() |
MiniMapMailFrame:SetPoint('BOTTOMRIGHT', Minimap, -4, 5) |
MiniMapMailBorder:SetTexture(nil) |
MiniMapMailIcon:SetTexture(nil) |
hooksecurefunc(MiniMapMailFrame, 'Show', function() |
MiniMapMailBorder:SetTexture(nil) |
MiniMapMailIcon:SetTexture(nil) |
end) |
MiniMapMailFrame.Text = MiniMapMailFrame:CreateFontString(nil, 'OVERLAY') |
MiniMapMailFrame.Text:SetFont(C['media'].font, C['media'].fontLarge, 'OUTLINE') |
MiniMapMailFrame.Text:SetPoint('BOTTOMRIGHT', MiniMapMailFrame) |
MiniMapMailFrame.Text:SetTextColor(1, 0, 1) |
MiniMapMailFrame.Text:SetText('Mail') |
-------------------------------------------------------------- |
-- Dungeon Finder |
-------------------------------------------------------------- |
QueueStatusMinimapButton:ClearAllPoints() |
QueueStatusMinimapButton:SetPoint('TOPLEFT', Minimap, 6, -6) --- Icon position |
QueueStatusMinimapButton:SetSize(14, 14) |
QueueStatusMinimapButton:SetHighlightTexture(nil) |
QueueStatusMinimapButtonBorder:SetTexture() |
-------------------------------------------------------------- |
-- Minimap Hide Useless Shit |
-------------------------------------------------------------- |
MinimapZoomIn:Hide() |
MinimapZoomIn:UnregisterAllEvents() |
MinimapZoomOut:Hide() |
MinimapZoomOut:UnregisterAllEvents() |
MiniMapWorldMapButton:Hide() |
MiniMapWorldMapButton:UnregisterAllEvents() |
MinimapNorthTag:SetAlpha(0) |
MinimapBorder:Hide() |
MinimapBorderTop:Hide() |
MinimapZoneText:Hide() |
MinimapZoneTextButton:Hide() |
MinimapZoneTextButton:UnregisterAllEvents() |
MiniMapTracking:UnregisterAllEvents() |
MiniMapTracking:Hide() |
DurabilityFrame:Hide() |
DurabilityFrame:UnregisterAllEvents() |
-------------------------------------------------------------- |
-- Minimap Farm Mode |
-------------------------------------------------------------- |
if C['minimap'].farm == true then |
MinimapCluster:SetScale(C['minimap'].farmscale) |
MinimapCluster:EnableMouse(false) |
else |
MinimapCluster:SetScale(.8) |
MinimapCluster:EnableMouse(false) |
end |
-------------------------------------------------------------- |
-- Minimap Zoom on Scroll |
-------------------------------------------------------------- |
Minimap:EnableMouseWheel(true) |
Minimap:SetScript('OnMouseWheel', function(self, delta) |
if (delta > 0) then |
_G.MinimapZoomIn:Click() |
elseif delta < 0 then |
_G.MinimapZoomOut:Click() |
end |
end) |
-------------------------------------------------------------- |
-- Minimap Tracking |
-------------------------------------------------------------- |
Minimap:SetScript('OnMouseUp', function(self, button) |
if (button == 'RightButton') then |
ToggleDropDownMenu(1, nil, MiniMapTrackingDropDown, self, - (Minimap:GetWidth() * 0.7), -3) |
else |
Minimap_OnClick(self) |
end |
end) |
-------------------------------------------------------------- |
-- Minimap Bliz Ticket Frame |
-------------------------------------------------------------- |
TicketStatusFrame:ClearAllPoints() |
TicketStatusFrame:SetPoint('BOTTOMRIGHT', UIParent, -25, -33) |
TicketStatusFrameButton:HookScript('OnShow', function(self) |
self:SetBackdrop({ |
bgFile = C['minimap'].background, |
edgeFile = C['minimap'].border, |
insets = {left = 3, right = 3, top = 3, bottom = 3} |
}) |
end) |
local function GetZoneColor() |
local zoneType = GetZonePVPInfo() |
if (zoneType == 'sanctuary') then |
return 0.4, 0.8, 0.94 |
elseif (zoneType == 'arena') then |
return 1, 0.1, 0.1 |
elseif (zoneType == 'friendly') then |
return 0.1, 1, 0.1 |
elseif (zoneType == 'hostile') then |
return 1, 0.1, 0.1 |
elseif (zoneType == 'contested') then |
return 1, 0.8, 0 |
else |
return 1, 1, 1 |
end |
end |
-------------------------------------------------------------- |
-- Minimap Mouseover Zone Text |
-------------------------------------------------------------- |
if (C['minimap'].zoneText) then |
local MainZone = Minimap:CreateFontString(nil, 'OVERLAY') |
MainZone:SetFont(C['media'].font, C['media'].fontLarge, 'THINOUTLINE') |
MainZone:SetPoint('TOP', Minimap, 0, -22) |
MainZone:SetTextColor(1, 1, 1) |
MainZone:SetAlpha(0) |
MainZone:SetSize(130, 32) |
MainZone:SetJustifyV('BOTTOM') |
local SubZone = Minimap:CreateFontString(nil, 'OVERLAY') |
SubZone:SetFont(C['media'].font, C['media'].fontSmall, 'THINOUTLINE') |
SubZone:SetPoint('TOP', MainZone, 'BOTTOM', 0, -1) |
SubZone:SetTextColor(1, 1, 1) |
SubZone:SetAlpha(0) |
SubZone:SetSize(130, 26) |
SubZone:SetJustifyV('TOP') |
Minimap:HookScript('OnEnter', function() |
if (not IsShiftKeyDown()) then |
SubZone:SetTextColor(GetZoneColor()) |
SubZone:SetText(GetSubZoneText()) |
securecall('UIFrameFadeIn', SubZone, 0.15, SubZone:GetAlpha(), 1) |
MainZone:SetTextColor(GetZoneColor()) |
MainZone:SetText(GetRealZoneText()) |
securecall('UIFrameFadeIn', MainZone, 0.15, MainZone:GetAlpha(), 1) |
end |
end) |
Minimap:HookScript('OnLeave', function() |
securecall('UIFrameFadeOut', SubZone, 0.15, SubZone:GetAlpha(), 0) |
securecall('UIFrameFadeOut', MainZone, 0.15, MainZone:GetAlpha(), 0) |
end) |
end |
-------------------------------------------------------------- |
-- Minimap Mouseover Dungeon Diff |
-------------------------------------------------------------- |
local isGuildGroup = isGuildGroup |
local function HideDifficultyFrame() |
GuildInstanceDifficulty:EnableMouse(false) |
GuildInstanceDifficulty:SetAlpha(0) |
MiniMapInstanceDifficulty:EnableMouse(false) |
MiniMapInstanceDifficulty:SetAlpha(0) |
end |
function GetDifficultyText() |
local inInstance, instancetype = IsInInstance() |
local _, _, difficultyIndex, _, maxPlayers, playerDifficulty, isDynamic = GetInstanceInfo() |
local guildStyle |
local heroStyle = '|cffff00ffH|r' |
if (isGuildGroup or GuildInstanceDifficulty:IsShown()) then |
guildStyle = '|cffffff00G|r' |
else |
guildStyle = '' |
end |
if (inInstance and instancetype == 'raid') then |
if (isDynamic) then |
if (difficultyIndex == 4 or difficultyIndex == 3) then |
if (playerDifficulty == 0) then |
return maxPlayers..guildStyle..heroStyle |
end |
end |
if (difficultyIndex == 2) then |
return maxPlayers..guildStyle |
end |
if (difficultyIndex == 1) then |
if (playerDifficulty == 0) then |
return maxPlayers..guildStyle |
end |
if (playerDifficulty == 1) then |
return maxPlayers..guildStyle..heroStyle |
end |
end |
end |
if (not isDynamic) then |
if (difficultyIndex == 1 or difficultyIndex == 2) then |
return maxPlayers..guildStyle |
end |
if (difficultyIndex == 3 or difficultyIndex == 4) then |
return maxPlayers..guildStyle..heroStyle |
end |
end |
end |
if (inInstance and instancetype == 'party') then |
if (difficultyIndex == 2)then |
return maxPlayers..guildStyle..heroStyle |
elseif (difficultyIndex == 1)then |
return maxPlayers..guildStyle |
end |
end |
if (not inInstance) then |
return '' |
end |
end |
-------------------------------------------------------------- |
-- Minimap frame |
-------------------------------------------------------------- |
local f = Minimap |
f.InstanceText = f:CreateFontString(nil, 'OVERLAY') |
f.InstanceText:SetFont(C['media'].font, C['media'].fontLarge, 'OUTLINE') |
f.InstanceText:SetPoint('TOP', Minimap, 0, -3.5) |
f.InstanceText:SetTextColor(1, 1, 1) |
f.InstanceText:Show() |
hooksecurefunc(GuildInstanceDifficulty, 'Show', function() |
isGuildGroup = true |
HideDifficultyFrame() |
end) |
hooksecurefunc(GuildInstanceDifficulty, 'Hide', function() |
isGuildGroup = false |
end) |
hooksecurefunc(MiniMapInstanceDifficulty, 'Show', function() |
HideDifficultyFrame() |
end) |
GuildInstanceDifficulty:HookScript('OnEvent', function(self) |
if (self:IsShown()) then |
isGuildGroup = true |
else |
isGuildGroup = false |
end |
Minimap.InstanceText:SetText(GetDifficultyText()) |
end) |
MiniMapInstanceDifficulty:HookScript('OnEvent', function(self) |
Minimap.InstanceText:SetText(GetDifficultyText()) |
end) |
if (C['minimap'].instanceDifficulty) then |
Minimap.InstanceText:SetAlpha(0) |
Minimap:HookScript('OnEnter', function(self) |
securecall('UIFrameFadeIn', self.InstanceText, 0.235, 0, 1) |
end) |
Minimap:HookScript('OnLeave', function(self) |
securecall('UIFrameFadeOut', self.InstanceText, 0.235, 1, 0) |
end) |
end |
-------------------------------------------------------------- |
-- Calendar |
-------------------------------------------------------------- |
if (not IsAddOnLoaded('Blizzard_TimeManager')) then |
LoadAddOn('Blizzard_TimeManager') |
end |
for i = 1, select('#', GameTimeFrame:GetRegions()) do |
local texture = select(i, GameTimeFrame:GetRegions()) |
if (texture and texture:GetObjectType() == 'Texture') then |
texture:SetTexture(nil) |
end |
end |
GameTimeFrame:SetSize(14, 14) |
GameTimeFrame:SetHitRectInsets(0, 0, 0, 0) |
GameTimeFrame:ClearAllPoints() |
GameTimeFrame:SetPoint('TOPRIGHT', Minimap, -3.5, -3.5) |
GameTimeFrame:GetFontString():SetFont(C['media'].font, C['media'].fontLarge, 'OUTLINE') |
GameTimeFrame:GetFontString():SetShadowOffset(0, 0) |
GameTimeFrame:GetFontString():SetPoint('TOPRIGHT', GameTimeFrame) |
for _, texture in pairs({ |
GameTimeCalendarEventAlarmTexture, |
GameTimeCalendarInvitesTexture, |
GameTimeCalendarInvitesGlow, |
TimeManagerAlarmFiredTexture, |
}) do |
texture:SetTexture(nil) |
if (texture:IsShown()) then |
GameTimeFrame:GetFontString():SetTextColor(1, 0, 1) |
else |
GameTimeFrame:GetFontString():SetTextColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
end |
hooksecurefunc(texture, 'Show', function() |
GameTimeFrame:GetFontString():SetTextColor(1, 0, 1) |
end) |
hooksecurefunc(texture, 'Hide', function() |
GameTimeFrame:GetFontString():SetTextColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
end) |
end |
-------------------------------------------------------------- |
-- Minimap Clock |
-------------------------------------------------------------- |
TimeManagerClockTicker:SetFont(C['media'].font, C['media'].fontLarge, 'OUTLINE') |
TimeManagerClockTicker:SetShadowOffset(0, 0) |
TimeManagerClockTicker:SetTextColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
TimeManagerClockTicker:SetPoint('TOPRIGHT', TimeManagerClockButton, 0, 0) |
TimeManagerClockButton:GetRegions():Hide() |
TimeManagerClockButton:ClearAllPoints() |
TimeManagerClockButton:SetWidth(40) |
TimeManagerClockButton:SetHeight(18) |
TimeManagerClockButton:SetPoint('BOTTOM', Minimap, 0, 2) |
TimeManagerAlarmFiredTexture:SetTexture(nil) |
hooksecurefunc(TimeManagerAlarmFiredTexture, 'Show', function() |
TimeManagerClockTicker:SetTextColor(1, 0, 1) |
end) |
hooksecurefunc(TimeManagerAlarmFiredTexture, 'Hide', function() |
TimeManagerClockTicker:SetTextColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
end) |
if C['minimap'].gameclock == true then |
TimeManagerClockButton:Show() |
else |
TimeManagerClockButton:Hide() |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import: S - function; C - config; Soop - Database |
if C['tooltip'].enable ~= true then return end |
local _G = _G |
local select = select |
local format = string.format |
local UnitName = UnitName |
local UnitLevel = UnitLevel |
local UnitExists = UnitExists |
local UnitIsDead = UnitIsDead |
local UnitIsGhost = UnitIsGhost |
local UnitFactionGroup = UnitFactionGroup |
local UnitCreatureType = UnitCreatureType |
local GetQuestDifficultyColor = GetQuestDifficultyColor |
local tankIcon = '|TInterface\\LFGFrame\\UI-LFG-ICON-PORTRAITROLES.blp:13:13:0:0:64:64:0:19:22:41|t' |
local healIcon = '|TInterface\\LFGFrame\\UI-LFG-ICON-PORTRAITROLES.blp:13:13:0:0:64:64:20:39:1:20|t' |
local damagerIcon = '|TInterface\\LFGFrame\\UI-LFG-ICON-PORTRAITROLES.blp:13:13:0:0:64:64:20:39:22:41|t' |
local symbiosis = { |
gain = { |
['DEATHKNIGHT'] = { ['DK_BLOOD'] = 113072, ['DK_FROST'] = 113516, ['DK_UNHOLY'] = 113516, }, |
['HUNTER'] = { ['HUNTER_BM'] = 113073, ['HUNTER_MM'] = 113073, ['HUNTER_SV'] = 113073, }, |
['MAGE'] = { ['MAGE_ARCANE'] = 113074, ['MAGE_FIRE'] = 113074, ['MAGE_FROST'] = 113074, }, |
['MONK'] = { ['MONK_BREW'] = 113306, ['MONK_MIST'] = 127361, ['MONK_WIND'] = 113275, }, |
['PALADIN'] = { ['PALADIN_HOLY'] = 113269, ['PALADIN_PROT'] = 122287, ['PALADIN_RET'] = 113075, }, |
['PRIEST'] = { ['PRIEST_DISC'] = 113506, ['PRIEST_HOLY'] = 113506, ['PRIEST_SHADOW'] = 113277, }, |
['ROGUE'] = { ['ROGUE_ASS'] = 113613, ['ROGUE_COMBAT'] = 113613, ['ROGUE_SUB'] = 113613, }, |
['SHAMAN'] = { ['SHAMAN_ELE'] = 113286, ['SHAMAN_ENHANCE'] = 113286, ['SHAMAN_RESTO'] = 113289, }, |
['WARLOCK'] = { ['WARLOCK_AFFLICTION'] = 113295, ['WARLOCK_DEMO'] = 113295, ['WARLOCK_DESTRO'] = 113295, }, |
['WARRIOR'] = { ['WARRIOR_ARMS'] = 122294, ['WARRIOR_FURY'] = 122294, ['WARRIOR_PROT'] = 122286, }, |
}, |
grant = { |
['DEATHKNIGHT'] = { ['DRUID_BALANCE'] = 110570, ['DRUID_FERAL'] = 122282, ['DRUID_GUARDIAN'] = 122285, ['DRUID_RESTO'] = 110575, }, |
['HUNTER'] = { ['DRUID_BALANCE'] = 110588, ['DRUID_FERAL'] = 110597, ['DRUID_GUARDIAN'] = 110600, ['DRUID_RESTO'] = 19263, }, |
['MAGE'] = { ['DRUID_BALANCE'] = 110621, ['DRUID_FERAL'] = 110693, ['DRUID_GUARDIAN'] = 110694, ['DRUID_RESTO'] = 110696, }, |
['MONK'] = { ['DRUID_BALANCE'] = 126458, ['DRUID_FERAL'] = 128844, ['DRUID_GUARDIAN'] = 126453, ['DRUID_RESTO'] = 126456, }, |
['PALADIN'] = { ['DRUID_BALANCE'] = 110698, ['DRUID_FERAL'] = 110700, ['DRUID_GUARDIAN'] = 110701, ['DRUID_RESTO'] = 122288, }, |
['PRIEST'] = { ['DRUID_BALANCE'] = 110707, ['DRUID_FERAL'] = 110715, ['DRUID_GUARDIAN'] = 110717, ['DRUID_RESTO'] = 110718, }, |
['ROGUE'] = { ['DRUID_BALANCE'] = 110788, ['DRUID_FERAL'] = 110730, ['DRUID_GUARDIAN'] = 122289, ['DRUID_RESTO'] = 110791, }, |
['SHAMAN'] = { ['DRUID_BALANCE'] = 110802, ['DRUID_FERAL'] = 110807, ['DRUID_GUARDIAN'] = 110803, ['DRUID_RESTO'] = 110806, }, |
['WARLOCK'] = { ['DRUID_BALANCE'] = 122291, ['DRUID_FERAL'] = 110810, ['DRUID_GUARDIAN'] = 122290, ['DRUID_RESTO'] = 112970, }, |
['WARRIOR'] = { ['DRUID_BALANCE'] = 122292, ['DRUID_FERAL'] = 112997, ['DRUID_GUARDIAN'] = 113002, ['DRUID_RESTO'] = 113004, }, |
} |
} |
CUSTOM_FACTION_BAR_COLORS = { |
[1] = {r = 1, g = 0, b = 0}, |
[2] = {r = 1, g = 0, b = 0}, |
[3] = {r = 1, g = 1, b = 0}, |
[4] = {r = 1, g = 1, b = 0}, |
[5] = {r = 0, g = 1, b = 0}, |
[6] = {r = 0, g = 1, b = 0}, |
[7] = {r = 0, g = 1, b = 0}, |
[8] = {r = 0, g = 1, b = 0}, |
} |
function GameTooltip_UnitColor(unit) |
local r, g, b |
if (UnitIsDead(unit) or UnitIsGhost(unit) or UnitIsTapped(unit) and not UnitIsTappedByPlayer(unit)) then |
r = 0.5 |
g = 0.5 |
b = 0.5 |
elseif (UnitIsPlayer(unit)) then |
if (UnitIsFriend(unit, 'player')) then |
local _, class = UnitClass(unit) |
r = RAID_CLASS_COLORS[class].r |
g = RAID_CLASS_COLORS[class].g |
b = RAID_CLASS_COLORS[class].b |
elseif (not UnitIsFriend(unit, 'player')) then |
r = 1 |
g = 0 |
b = 0 |
end |
elseif (UnitPlayerControlled(unit)) then |
if (UnitCanAttack(unit, 'player')) then |
if (not UnitCanAttack('player', unit)) then |
r = 157/255 |
g = 197/255 |
b = 255/255 |
else |
r = 1 |
g = 0 |
b = 0 |
end |
elseif (UnitCanAttack('player', unit)) then |
r = 1 |
g = 1 |
b = 0 |
elseif (UnitIsPVP(unit)) then |
r = 0 |
g = 1 |
b = 0 |
else |
r = 157/255 |
g = 197/255 |
b = 255/255 |
end |
else |
local reaction = UnitReaction(unit, 'player') |
if (reaction) then |
r = CUSTOM_FACTION_BAR_COLORS[reaction].r |
g = CUSTOM_FACTION_BAR_COLORS[reaction].g |
b = CUSTOM_FACTION_BAR_COLORS[reaction].b |
else |
r = 157/255 |
g = 197/255 |
b = 255/255 |
end |
end |
return r, g, b |
end |
UnitSelectionColor = GameTooltip_UnitColor |
-- Some tooltip changes |
if (C['tooltip'].fontOutline) then |
GameTooltipHeaderText:SetFont(C['media'].font, (C['tooltip'].fontSize + 2), 'THINOUTLINE') |
GameTooltipHeaderText:SetShadowOffset(0, 0) |
GameTooltipText:SetFont(C['media'].font, (C['tooltip'].fontSize), 'THINOUTLINE') |
GameTooltipText:SetShadowOffset(0, 0) |
GameTooltipTextSmall:SetFont(C['media'].font, (C['tooltip'].fontSize), 'THINOUTLINE') |
GameTooltipTextSmall:SetShadowOffset(0, 0) |
else |
GameTooltipHeaderText:SetFont(C['media'].font, (C['tooltip'].fontSize + 2)) |
GameTooltipText:SetFont(C['media'].font, (C['tooltip'].fontSize)) |
GameTooltipTextSmall:SetFont(C['media'].font, (C['tooltip'].fontSize)) |
end |
GameTooltipStatusBar:SetHeight(7) |
GameTooltipStatusBar:SetBackdrop({bgFile = 'Interface\\Buttons\\WHITE8x8'}) |
GameTooltipStatusBar:SetBackdropColor(0, 1, 0, 0.3) |
local function ApplyTooltipStyle(self) |
local bgsize, bsize |
if (self == ConsolidatedBuffsTooltip) then |
bgsize = 1 |
bsize = 8 |
elseif (self == FriendsTooltip) then |
FriendsTooltip:SetScale(1.1) |
bgsize = 1 |
bsize = 9 |
else |
bgsize = 3 |
bsize = 12 |
end |
self:SetBackdrop({ |
bgFile = C["tooltip"].background, -- 'Interface\\Tooltips\\UI-Tooltip-Background', |
edgeFile = C["tooltip"].border, |
tile = true, tileSize = 16, edgeSize = 18, |
insets = { |
left = bgsize, right = bgsize, top = bgsize, bottom = bgsize |
} |
}) |
self:HookScript('OnShow', function(self) |
self:SetBackdropColor(0, 0, 0, 0.7) |
end) |
if (IsAddOnLoaded('!Beautycase')) then |
self:CreateBeautyBorder(bsize) |
end |
end |
for _, tooltip in pairs({ |
GameTooltip, |
ItemRefTooltip, |
ShoppingTooltip1, |
ShoppingTooltip2, |
ShoppingTooltip3, |
WorldMapTooltip, |
ConsolidatedBuffsTooltip, |
ChatMenu, |
EmoteMenu, |
LanguageMenu, |
VoiceMacroMenu, |
FriendsTooltip, |
}) do |
ApplyTooltipStyle(tooltip) |
end |
-- Itemquaility border, we use our beautycase functions |
if (C['tooltip'].itemqualityBorderColor) then |
for _, tooltip in pairs({ |
GameTooltip, |
ItemRefTooltip, |
ShoppingTooltip1, |
ShoppingTooltip2, |
ShoppingTooltip3, |
}) do |
tooltip:HookScript('OnTooltipSetItem', function(self) |
local name, item = self:GetItem() |
if (item) then |
local quality = select(3, GetItemInfo(item)) |
if (quality) then |
local r, g, b = GetItemQualityColor(quality) |
--self:SetBeautyBorderTexture('white') |
self:SetBackdropBorderColor(r, g, b) |
end |
end |
end) |
tooltip:HookScript('OnTooltipCleared', function(self) |
--self:SetBeautyBorderTexture('default') |
self:SetBackdropBorderColor(1, 1, 1) |
end) |
end |
end |
-- Itemlvl (by Gsuz) - http://www.tukui.org/forums/topic.php?id=10151 |
local function GetItemLevel(unit) |
local total, item = 0, 0 |
for i, v in pairs({ |
'Head', |
'Neck', |
'Shoulder', |
'Back', |
'Chest', |
'Wrist', |
'Hands', |
'Waist', |
'Legs', |
'Feet', |
'Finger0', |
'Finger1', |
'Trinket0', |
'Trinket1', |
'MainHand', |
'SecondaryHand', |
}) do |
local slot = GetInventoryItemLink(unit, GetInventorySlotInfo(v..'Slot')) |
if (slot ~= nil) then |
item = item + 1 |
total = total + select(4, GetItemInfo(slot)) |
end |
end |
if (item > 0) then |
return floor(total / item) |
end |
return 0 |
end |
-- Make sure we get a correct unit |
local function GetRealUnit(self) |
if (GetMouseFocus() and not GetMouseFocus():GetAttribute('unit') and GetMouseFocus() ~= WorldFrame) then |
return select(2, self:GetUnit()) |
elseif (GetMouseFocus() and GetMouseFocus():GetAttribute('unit')) then |
return GetMouseFocus():GetAttribute('unit') |
elseif (select(2, self:GetUnit())) then |
return select(2, self:GetUnit()) |
else |
return 'mouseover' |
end |
end |
local function GetFormattedUnitType(unit) |
local creaturetype = UnitCreatureType(unit) |
if (creaturetype) then |
return creaturetype |
else |
return '' |
end |
end |
local function GetFormattedUnitClassification(unit) |
local class = UnitClassification(unit) |
if (class == 'worldboss') then |
return '|cffFF0000'..BOSS..'|r ' |
elseif (class == 'rareelite') then |
return '|cffFF66CCRare|r |cffFFFF00'..ELITE..'|r ' |
elseif (class == 'rare') then |
return '|cffFF66CCRare|r ' |
elseif (class == 'elite') then |
return '|cffFFFF00'..ELITE..'|r ' |
else |
return '' |
end |
end |
local function GetFormattedUnitLevel(unit) |
local diff = GetQuestDifficultyColor(UnitLevel(unit)) |
if (UnitLevel(unit) == -1) then |
return '|cffff0000??|r ' |
elseif (UnitLevel(unit) == 0) then |
return '? ' |
else |
return format('|cff%02x%02x%02x%s|r ', diff.r*255, diff.g*255, diff.b*255, UnitLevel(unit)) |
end |
end |
local function GetFormattedUnitClass(unit) |
local color = RAID_CLASS_COLORS[select(2, UnitClass(unit))] |
if (color) then |
return format(' |cff%02x%02x%02x%s|r', color.r*255, color.g*255, color.b*255, UnitClass(unit)) |
end |
end |
local function GetFormattedUnitString(unit, specIcon) |
if (UnitIsPlayer(unit)) then |
return GetFormattedUnitLevel(unit)..UnitRace(unit)..GetFormattedUnitClass(unit)..(C['tooltip'].showSpecializationIcon and specIcon or '') |
else |
return GetFormattedUnitLevel(unit)..GetFormattedUnitClassification(unit)..GetFormattedUnitType(unit) |
end |
end |
local function GetUnitRoleString(unit) |
local role = UnitGroupRolesAssigned(unit) |
local roleList = nil |
if (role == 'TANK') then |
roleList = ' '..tankIcon..' '..TANK |
elseif (role == 'HEALER') then |
roleList = ' '..healIcon..' '..HEALER |
elseif (role == 'DAMAGER') then |
roleList = ' '..damagerIcon..' '..DAMAGER |
end |
return roleList |
end |
-- Healthbar coloring funtion |
local function SetHealthBarColor(unit) |
local r, g, b |
if (C['tooltip'].healthbar.custom.apply and not C['tooltip'].healthbar.reactionColoring) then |
r, g, b = C['tooltip'].healthbar.custom.color.r, C['tooltip'].healthbar.custom.color.g, C['tooltip'].healthbar.custom.color.b |
elseif (C['tooltip'].healthbar.reactionColoring and unit) then |
r, g, b = UnitSelectionColor(unit) |
else |
r, g, b = 0, 1, 0 |
end |
GameTooltipStatusBar:SetStatusBarColor(r, g, b) |
GameTooltipStatusBar:SetBackdropColor(r, g, b, 0.3) |
end |
local function GetUnitRaidIcon(unit) |
local index = GetRaidTargetIndex(unit) |
if (index) then |
if (UnitIsPVP(unit) and C['tooltip'].showPVPIcons) then |
return ICON_LIST[index]..'11|t' |
else |
return ICON_LIST[index]..'11|t ' |
end |
else |
return '' |
end |
end |
local function GetUnitPVPIcon(unit) |
local factionGroup = UnitFactionGroup(unit) |
if (UnitIsPVPFreeForAll(unit)) then |
if (C['tooltip'].showPVPIcons) then |
return '|TInterface\\AddOns\\nTooltip\\media\\UI-PVP-FFA:12|t' |
else |
return '|cffFF0000# |r' |
end |
elseif (factionGroup and UnitIsPVP(unit)) then |
if (C['tooltip'].showPVPIcons) then |
return '|TInterface\\AddOns\\nTooltip\\media\\UI-PVP-'..factionGroup..':12|t' |
else |
return '|cff00FF00# |r' |
end |
else |
return '' |
end |
end |
local function AddMouseoverTarget(self, unit) |
local unitTargetName = UnitName(unit..'target') |
local unitTargetClassColor = RAID_CLASS_COLORS[select(2, UnitClass(unit..'target'))] or { r = 1, g = 0, b = 1 } |
local unitTargetReactionColor = { |
r = select(1, UnitSelectionColor(unit..'target')), |
g = select(2, UnitSelectionColor(unit..'target')), |
b = select(3, UnitSelectionColor(unit..'target')) |
} |
if (UnitExists(unit..'target')) then |
if (UnitName('player') == unitTargetName) then |
self:AddLine(format('|cffFFFF00Target|r: '..GetUnitRaidIcon(unit..'target')..'|cffff00ff%s|r', string.upper("** YOU **")), 1, 1, 1) |
else |
if (UnitIsPlayer(unit..'target')) then |
self:AddLine(format('|cffFFFF00Target|r: '..GetUnitRaidIcon(unit..'target')..'|cff%02x%02x%02x%s|r', unitTargetClassColor.r*255, unitTargetClassColor.g*255, unitTargetClassColor.b*255, unitTargetName:sub(1, 40)), 1, 1, 1) |
else |
self:AddLine(format('|cffFFFF00Target|r: '..GetUnitRaidIcon(unit..'target')..'|cff%02x%02x%02x%s|r', unitTargetReactionColor.r*255, unitTargetReactionColor.g*255, unitTargetReactionColor.b*255, unitTargetName:sub(1, 40)), 1, 1, 1) |
end |
end |
end |
end |
GameTooltip.inspectCache = {} |
GameTooltip:HookScript('OnTooltipSetUnit', function(self, ...) |
local unit = GetRealUnit(self) |
if (UnitExists(unit) and UnitName(unit) ~= UNKNOWN) then |
local ilvl = 0 |
local specIcon = '' |
local lastUpdate = 30 |
for index, _ in pairs(self.inspectCache) do |
local inspectCache = self.inspectCache[index] |
if (inspectCache.GUID == UnitGUID(unit)) then |
ilvl = inspectCache.itemLevel or 0 |
specIcon = inspectCache.specIcon or '' |
lastUpdate = inspectCache.lastUpdate and math.abs(inspectCache.lastUpdate - math.floor(GetTime())) or 30 |
end |
end |
-- Fetch inspect information (ilvl and spec) |
if (unit and CanInspect(unit)) then |
if (not self.inspectRefresh and lastUpdate >= 30 and not self.blockInspectRequests) then |
if (not self.blockInspectRequests) then |
self.inspectRequestSent = true |
NotifyInspect(unit) |
end |
end |
end |
self.inspectRefresh = false |
local name, realm = UnitName(unit) |
-- Hide player titles |
if (C['tooltip'].showPlayerTitles) then |
if (UnitPVPName(unit)) then |
name = UnitPVPName(unit) |
end |
end |
GameTooltipTextLeft1:SetText(name) |
-- Color guildnames |
if (GetGuildInfo(unit)) then |
if (GetGuildInfo(unit) == GetGuildInfo('player') and IsInGuild('player')) then |
GameTooltipTextLeft2:SetText('|cffFF66CC'..GameTooltipTextLeft2:GetText()..'|r') |
end |
end |
-- Tooltip level text |
for i = 2, GameTooltip:NumLines() do |
if (_G['GameTooltipTextLeft'..i]:GetText():find('^'..TOOLTIP_UNIT_LEVEL:gsub('%%s', '.+'))) then |
_G['GameTooltipTextLeft'..i]:SetText(GetFormattedUnitString(unit, specIcon)) |
end |
end |
-- Role text |
if (C['tooltip'].showUnitRole) then |
self:AddLine(GetUnitRoleString(unit), 1, 1, 1) |
end |
-- Mouse over target with raidicon support |
if (C['tooltip'].showMouseoverTarget) then |
AddMouseoverTarget(self, unit) |
end |
-- Pvp flag prefix |
for i = 3, GameTooltip:NumLines() do |
if (_G['GameTooltipTextLeft'..i]:GetText():find(PVP_ENABLED)) then |
_G['GameTooltipTextLeft'..i]:SetText(nil) |
GameTooltipTextLeft1:SetText(GetUnitPVPIcon(unit)..GameTooltipTextLeft1:GetText()) |
end |
end |
-- Raid icon, want to see the raidicon on the left |
GameTooltipTextLeft1:SetText(GetUnitRaidIcon(unit)..GameTooltipTextLeft1:GetText()) |
-- Afk and dnd prefix |
if (UnitIsAFK(unit)) then |
self:AppendText('|cff00ff00 <AFK>|r') |
elseif (UnitIsDND(unit)) then |
self:AppendText('|cff00ff00 <DND>|r') |
end |
-- Player realm names |
if (realm and realm ~= '') then |
if (C['tooltip'].abbrevRealmNames) then |
self:AppendText(' (*)') |
else |
self:AppendText(' - '..realm) |
end |
end |
-- Move the healthbar inside the tooltip |
self:AddLine(' ') |
GameTooltipStatusBar:ClearAllPoints() |
GameTooltipStatusBar:SetPoint('LEFT', self:GetName()..'TextLeft'..self:NumLines(), 1, -3) |
GameTooltipStatusBar:SetPoint('RIGHT', self, -10, 0) |
-- Border coloring |
if (C['tooltip'].reactionBorderColor) then |
local r, g, b = UnitSelectionColor(unit) |
--self:SetBeautyBorderTexture('white') |
self:SetBackdropBorderColor(r, g, b) |
end |
-- Dead or ghost recoloring |
if (UnitIsDead(unit) or UnitIsGhost(unit)) then |
GameTooltipStatusBar:SetBackdropColor(0.5, 0.5, 0.5, 0.3) |
else |
if (not C['tooltip'].healthbar.custom.apply and not C['tooltip'].healthbar.reactionColoring) then |
GameTooltipStatusBar:SetBackdropColor(27/255, 243/255, 27/255, 0.3) |
else |
SetHealthBarColor(unit) |
end |
end |
-- Custom healthbar coloring |
if (C['tooltip'].healthbar.reactionColoring or C['tooltip'].healthbar.custom.apply) then |
GameTooltipStatusBar:HookScript('OnValueChanged', function() |
SetHealthBarColor(unit) |
end) |
end |
-- Show player item lvl |
if (C['tooltip'].showItemLevel and ilvl > 1) then |
GameTooltip:AddLine(STAT_AVERAGE_ITEM_LEVEL .. ': ' .. '|cffFFFFFF'..ilvl..'|r') |
end |
-- Symbiosis |
if (UnitIsPlayer(unit) and not UnitIsEnemy(unit, 'player')) then |
local hasSymbiosisBuff = false |
for i = 1, 40 do |
if select(11, UnitAura(unit, i, 'HELPFUL')) == 110309 then |
hasSymbiosisBuff = true |
break |
end |
end |
local _, playerClass = UnitClass('player') |
local _, unitClass = UnitClass(unit) |
local spec = SPEC_CORE_ABILITY_TEXT[GetSpecializationInfo(GetSpecialization() or 1)] |
local spellID = (playerClass == 'DRUID' and unitClass ~= 'DRUID') and symbiosis.grant[unitClass][spec] or (playerClass ~= 'DRUID' and unitClass == 'DRUID') and symbiosis.grant[playerClass][spec] |
local name, _, icon = GetSpellInfo(spellID) |
if (hasSymbiosisBuff) then |
GameTooltip:AddLine(' ') |
GameTooltip:AddLine('|cff3eea23'..GetSpellInfo(110309)..' already buffed|r') |
end |
if (icon) then |
GameTooltip:AddLine(' ') |
GameTooltip:AddDoubleLine('|T'..icon..':16:16:0:0:64:64:4:60:4:60|t '..name, '|cff3eea23'..GetSpellInfo(110309)..'|r') |
end |
end |
end |
end) |
GameTooltip:HookScript('OnTooltipCleared', function(self) |
GameTooltipStatusBar:ClearAllPoints() |
GameTooltipStatusBar:SetPoint('BOTTOMLEFT', self, 'TOPLEFT', 0.5, 3) |
GameTooltipStatusBar:SetPoint('BOTTOMRIGHT', self, 'TOPRIGHT', -1, 3) |
GameTooltipStatusBar:SetBackdropColor(0, 1, 0, 0.3) |
if (C['tooltip'].reactionBorderColor and self.beautyBorder) then |
self:SetBeautyBorderTexture('default') |
self:SetBeautyBorderColor(1, 1, 1) |
end |
end) |
GameTooltip:RegisterEvent('INSPECT_READY') |
GameTooltip:SetScript('OnEvent', function(self, event, GUID) |
if (not self:IsShown()) then |
return |
end |
local _, unit = self:GetUnit() |
if (not unit) then |
return |
end |
if (self.blockInspectRequests) then |
self.inspectRequestSent = false |
end |
if (UnitGUID(unit) ~= GUID or not self.inspectRequestSent) then |
if (not self.blockInspectRequests) then |
ClearInspectPlayer() |
end |
return |
end |
local _, _, _, icon = GetSpecializationInfoByID(GetInspectSpecialization(unit)) |
local ilvl = GetItemLevel(unit) |
local now = GetTime() |
local matchFound |
for index, _ in pairs(self.inspectCache) do |
local inspectCache = self.inspectCache[index] |
if (inspectCache.GUID == GUID) then |
inspectCache.itemLevel = ilvl |
inspectCache.specIcon = icon and ' |T'..icon..':0|t' or '' |
inspectCache.lastUpdate = math.floor(now) |
matchFound = true |
end |
end |
if not matchFound then |
local GUIDInfo = { |
['GUID'] = GUID, |
['itemLevel'] = ilvl, |
['specIcon'] = icon and ' |T'..icon..':0|t' or '', |
['lastUpdate'] = math.floor(now) |
} |
table.insert(self.inspectCache, GUIDInfo) |
end |
if (#self.inspectCache > 30) then |
table.remove(self.inspectCache, 1) |
end |
self.inspectRefresh = true |
GameTooltip:SetUnit('mouseover') |
if (not self.blockInspectRequests) then |
ClearInspectPlayer() |
end |
self.inspectRequestSent = false |
end) |
local f = CreateFrame('Frame') |
f:RegisterEvent('ADDON_LOADED') |
f:SetScript('OnEvent', function(self, event) |
if IsAddOnLoaded('Blizzard_InspectUI') then |
hooksecurefunc('InspectFrame_Show', function(unit) |
GameTooltip.blockInspectRequests = true |
end) |
InspectFrame:HookScript('OnHide', function() |
GameTooltip.blockInspectRequests = false |
end) |
self:UnregisterEvent('ADDON_LOADED') |
end |
end) |
GameTooltip:RegisterEvent('INSPECT_READY') |
if (not C['tooltip'].healthbar.showHealthValue) then |
return |
else |
local select = select |
local tonumber = tonumber |
local modf = math.modf |
local gsub = string.gsub |
local format = string.format |
local bar = GameTooltipStatusBar |
bar.Text = bar:CreateFontString(nil, 'OVERLAY') |
bar.Text:SetPoint('CENTER', bar, C['tooltip'].healthbar.textPos, 0, 1) |
if (C['tooltip'].healthbar.showOutline) then |
bar.Text:SetFont(C['media'].font, C['media'].fontSize, 'THINOUTLINE') |
bar.Text:SetShadowOffset(0, 0) |
else |
bar.Text:SetFont(C['media'].font, C['media'].fontSize) |
bar.Text:SetShadowOffset(1, -1) |
end |
local function ColorGradient(perc, ...) |
if (perc >= 1) then |
local r, g, b = select(select('#', ...) - 2, ...) |
return r, g, b |
elseif (perc <= 0) then |
local r, g, b = ... |
return r, g, b |
end |
local num = select('#', ...) / 3 |
local segment, relperc = modf(perc*(num-1)) |
local r1, g1, b1, r2, g2, b2 = select((segment*3)+1, ...) |
return r1 + (r2-r1)*relperc, g1 + (g2-g1)*relperc, b1 + (b2-b1)*relperc |
end |
local function FormatValue(value) |
if (value >= 1e6) then |
return tonumber(format('%.1f', value/1e6))..'m' |
elseif (value >= 1e3) then |
return tonumber(format('%.1f', value/1e3))..'k' |
else |
return value |
end |
end |
local function DeficitValue(value) |
if (value == 0) then |
return '' |
else |
return '-'..FormatValue(value) |
end |
end |
local function GetHealthTag(text, cur, max) |
local perc = format('%d', (cur/max)*100) |
if (max == 1) then |
return perc |
end |
local r, g, b = ColorGradient(cur/max, 1, 0, 0, 1, 1, 0, 0, 1, 0) |
text = gsub(text, '$cur', format('%s', FormatValue(cur))) |
text = gsub(text, '$max', format('%s', FormatValue(max))) |
text = gsub(text, '$deficit', format('%s', DeficitValue(max-cur))) |
text = gsub(text, '$perc', format('%d', perc)..'%%') |
text = gsub(text, '$smartperc', format('%d', perc)) |
text = gsub(text, '$smartcolorperc', format('|cff%02x%02x%02x%d|r', r*255, g*255, b*255, perc)) |
text = gsub(text, '$colorperc', format('|cff%02x%02x%02x%d', r*255, g*255, b*255, perc)..'%%|r') |
return text |
end |
GameTooltipStatusBar:HookScript('OnValueChanged', function(self, value) |
if (self.Text) then |
self.Text:SetText('') |
end |
if (not value) then |
return |
end |
local min, max = self:GetMinMaxValues() |
if ((value < min) or (value > max) or (value == 0) or (value == 1)) then |
return |
end |
if (not self.Text) then |
CreateHealthString(self) |
end |
local fullString = GetHealthTag(C['tooltip'].healthbar.healthFullFormat, value, max) |
local normalString = GetHealthTag(C['tooltip'].healthbar.healthFormat, value, max) |
local perc = (value/max)*100 |
if (perc >= 100 and currentValue ~= 1) then |
self.Text:SetText(fullString) |
elseif (perc < 100 and currentValue ~= 1) then |
self.Text:SetText(normalString) |
else |
self.Text:SetText('') |
end |
end) |
end |
if (not C['tooltip'].disableFade) then |
return |
else |
-- GameTooltip.FadeOut = GameTooltip.Hide |
GameTooltip.UpdateTime = 0 |
GameTooltip:HookScript('OnUpdate', function(self, elapsed) |
self.UpdateTime = self.UpdateTime + elapsed |
if (self.UpdateTime > TOOLTIP_UPDATE_TIME) then |
self.UpdateTime = 0 |
if (GetMouseFocus() == WorldFrame and (not UnitExists('mouseover'))) then |
self:Hide() |
end |
end |
end) |
end |
-- Spell ID in Tooltip |
hooksecurefunc(GameTooltip, 'SetUnitBuff', function(self,...) |
local id = select(11,UnitBuff(...)) |
if (id) then |
self:AddLine('SpellID: '..id, 1, 1, 1) |
self:Show() |
end |
end) |
hooksecurefunc(GameTooltip, 'SetUnitDebuff', function(self,...) |
local id = select(11,UnitDebuff(...)) |
if (id) then |
self:AddLine('SpellID: '..id, 1, 1, 1) |
self:Show() |
end |
end) |
hooksecurefunc(GameTooltip, 'SetUnitAura', function(self,...) |
local id = select(11, UnitAura(...)) |
if (id) then |
self:AddLine('SpellID: '..id, 1, 1, 1) |
self:Show() |
end |
end) |
hooksecurefunc('SetItemRef', function(link, text, button, chatFrame) |
if (string.find(link,'^spell:')) then |
local id = string.sub(link,7) |
ItemRefTooltip:AddLine('SpellID: '..id, 1, 1, 1) |
ItemRefTooltip:Show() |
end |
end) |
GameTooltip:HookScript('OnTooltipSetSpell', function(self) |
local id = select(3,self:GetSpell()) |
if (id) then |
self:AddLine('SpellID: '..id, 1, 1, 1) |
self:Show() |
end |
end) |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Autogreed on Items |
-------------------------------------------------------------- |
if C['general'].autogreed ~= true then return end |
local AddOn = CreateFrame('Frame') |
AddOn:RegisterEvent('START_LOOT_ROLL') |
AddOn:SetScript('OnEvent', function(_, _, RollID) |
local _, Name, _, Quality, BoP, _, _, CanDisenchant = GetLootRollItemInfo(RollID) |
if (Quality == 2 and not BoP) then |
RollOnLoot(RollID, CanDisenchant and 3 or 2) |
end |
end) |
local S, C, Soop = unpack(select(2, ...)) |
if C['general'].interrupts ~= true then return end |
---------------------------------------------------------------------------------------- |
-- Announce your interrupts(by Elv22) |
---------------------------------------------------------------------------------------- |
local frame = CreateFrame("Frame") |
frame:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED") |
frame:SetScript("OnEvent", function(self, _, ...) |
local _, event, _, sourceGUID, _, _, _, _, destName, _, _, _, _, _, spellID = ... |
if not (event == "SPELL_INTERRUPT" and sourceGUID == UnitGUID("player")) then return end |
SendChatMessage(INTERRUPTED.." "..destName..": "..GetSpellLink(spellID), T.CheckChat()) |
end) |
local S, C, Soop = unpack(select(2, ...)) |
-------------------------------------------------------------- |
-- Merchant |
-- Auto vendor and repair functionality |
-- Credit for Merchant goes to Tuks and ballagarba |
-- Modified for SoopUI by Soopie |
-------------------------------------------------------------- |
if C['merchant'].enable ~= true then return end |
local filter = { |
[6289] = true, -- Raw Longjaw Mud Snapper |
[6291] = true, -- Raw Brilliant Smallfish |
[6308] = true, -- Raw Bristle Whisker Catfish |
[6309] = true, -- 17 Pound Catfish |
[6310] = true, -- 19 Pound Catfish |
[41808] = true, -- Bonescale Snapper |
[42336] = true, -- Bloodstone Band |
[42337] = true, -- Sun Rock Ring |
[43244] = true, -- Crystal Citrine Necklace |
[43571] = true, -- Sewer Carp |
[43572] = true, -- Magic Eater |
} |
local f = CreateFrame("Frame") |
f:SetScript("OnEvent", function() |
-- if C['merchant'].autoSellGrey or C['merchant'].sellMisc then |
-- local c = 0 |
-- for bag = 0, 4 do |
-- for slot = 1, GetContainerNumSlots(bag) do |
-- local l,lid = GetContainerItemLink(bag, slot), GetContainerItemID(bag, slot) |
-- if l and lid then |
-- local p = select(11, GetItemInfo(l))*select(2, GetContainerItemInfo(bag, slot)) |
-- if C['merchant'].autoSellGrey and select(3, GetItemInfo(l))==0 then |
-- UseContainerItem(bag, slot) |
-- PickupMerchantItem() |
-- c = c+p |
-- end |
-- if C['merchant'].sellMisc and filter[ lid ] then |
-- UseContainerItem(bag, slot) |
-- PickupMerchantItem() |
-- c = c+p |
-- end |
-- end |
-- end |
-- end |
-- if c>0 then |
-- local g, s, c = math.floor(c/10000) or 0, math.floor((c%10000)/100) or 0, c%100 |
-- DEFAULT_CHAT_FRAME:AddMessage("Your grey item's have been sold for".." |cffffffff"..g.."|cffffd700g|r".." |cffffffff"..s.."|cffc7c7cfs|r".." |cffffffff"..c.."|cffeda55fc|r"..".",255,255,0) |
-- end |
-- end |
-- if not IsShiftKeyDown() then |
if CanMerchantRepair() and C['merchant'].autoRepair then |
local cost = GetRepairAllCost() |
if GetGuildBankWithdrawMoney() >= cost then |
RepairAllItems(1) |
elseif GetMoney() >= cost then |
RepairAllItems() |
end |
end |
end) |
f:RegisterEvent("MERCHANT_SHOW") |
--------- |
--AltBuy |
--------- |
-- just a new color |
local NEW_ITEM_VENDOR_STACK_BUY = ITEM_VENDOR_STACK_BUY |
ITEM_VENDOR_STACK_BUY = '|cffa9ff00'..NEW_ITEM_VENDOR_STACK_BUY..'|r' |
-- alt-click to buy a stack |
local origMerchantItemButton_OnModifiedClick = _G.MerchantItemButton_OnModifiedClick |
local function MerchantItemButton_OnModifiedClickHook(self, ...) |
origMerchantItemButton_OnModifiedClick(self, ...) |
if (IsAltKeyDown()) then |
local maxStack = select(8, GetItemInfo(GetMerchantItemLink(self:GetID()))) |
local _, _, _, quantity = GetMerchantItemInfo(self:GetID()) |
if (maxStack and maxStack > 1) then |
BuyMerchantItem(self:GetID(), floor(maxStack / quantity)) |
end |
end |
end |
MerchantItemButton_OnModifiedClick = MerchantItemButton_OnModifiedClickHook |
-- Google translate ftw...NOT |
local function GetAltClickString() |
if (GetLocale() == 'enUS') then |
return '<Alt-click, to buy an stack>' |
elseif (GetLocale() == 'frFR') then |
return '<Alt-clic, d acheter une pile>' |
elseif (GetLocale() == 'esES') then |
return '<Alt-clic, para comprar una pila>' |
elseif (GetLocale() == 'deDE') then |
return '<Alt-klicken, um einen ganzen Stapel zu kaufen>' |
else |
return '<Alt-click, to buy an stack>' |
end |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver || S = Functions || C = Config || Soop = Database |
-------------------------------------------------------------- |
-- Quest Automation and Improvements |
-- |
-- Original coding by Nightcracker |
-------------------------------------------------------------- |
if C['quest'].enable ~= true then return end |
-------------------------------------------------------------- |
-- Add Quest Level in Log |
-------------------------------------------------------------- |
local function questlevel() |
local buttons = QuestLogScrollFrame.buttons |
local numButtons = #buttons |
local scrollOffset = HybridScrollFrame_GetOffset(QuestLogScrollFrame) |
local numEntries, numQuests = GetNumQuestLogEntries() |
for i = 1, numButtons do |
local questIndex = i + scrollOffset |
local questLogTitle = buttons[i] |
if questIndex <= numEntries then |
local title, level, questTag, suggestedGroup, isHeader, isCollapsed, isComplete, isDaily = GetQuestLogTitle(questIndex) |
if not isHeader then |
questLogTitle:SetText("[" .. level .. "] " .. title) |
QuestLogTitleButton_Resize(questLogTitle) |
end |
end |
end |
end |
hooksecurefunc("QuestLog_Update", questlevel) |
QuestLogScrollFrameScrollBar:HookScript("OnValueChanged", questlevel) |
local QuestFrame = CreateFrame("Frame") |
local function MostValueable() |
local bestp, besti = 0 |
for i=1,GetNumQuestChoices() do |
local link, name, _, qty = GetQuestItemLink("choice", i), GetQuestItemInfo("choice", i) |
local price = link and select(11, GetItemInfo(link)) |
if not price then |
return |
elseif (price * (qty or 1)) > bestp then |
bestp, besti = (price * (qty or 1)), i |
end |
end |
if besti then |
local btn = _G["QuestInfoItem"..besti] |
if (btn.type == "choice") then |
btn:GetScript("OnClick")(btn) |
end |
end |
end |
-------------------------------------------------------------- |
-- Quest Auto Complete |
-------------------------------------------------------------- |
if C['quest'].autocomplete == true then |
QuestFrame:SetScript("OnEvent", function(self, event, ...) |
if (event == "QUEST_DETAIL") then |
AcceptQuest() |
CompleteQuest() |
elseif (event == "QUEST_COMPLETE") then |
if (GetNumQuestChoices() and GetNumQuestChoices() < 1) then |
GetQuestReward() |
else |
MostValueable() |
end |
elseif (event == "QUEST_ACCEPT_CONFIRM") then |
ConfirmAcceptQuest() |
end |
end) |
else |
QuestFrame:SetScript("OnEvent", function(self, event, ...) |
if (event == "QUEST_COMPLETE") then |
if (GetNumQuestChoices() and GetNumQuestChoices() < 1) then |
GetQuestReward() |
else |
MostValueable() |
end |
end |
end) |
end |
QuestFrame:RegisterEvent("QUEST_ACCEPT_CONFIRM") |
QuestFrame:RegisterEvent("QUEST_DETAIL") |
QuestFrame:RegisterEvent("QUEST_COMPLETE") |
local timeout = CreateFrame("Frame") |
timeout:Hide() |
local S, C, Soop = unpack(select(2, ...)) -- Import driver || S = Functions || C = Config || Soop = Database |
-------------------------------------------------------------- |
-- Watchframe Improvements |
-------------------------------------------------------------- |
local watchFrame = _G['WatchFrame'] |
watchFrame:SetHeight(400) |
watchFrame:ClearAllPoints() |
watchFrame.ClearAllPoints = function() end |
watchFrame:SetPoint('TOPRIGHT', UIParent, -100, -250) |
watchFrame:SetClampedToScreen(true) |
watchFrame:SetMovable(true) |
watchFrame:SetUserPlaced(true) |
watchFrame.SetPoint = function() end |
watchFrame:SetScale(1.01) |
local watchHead = _G['WatchFrameHeader'] |
watchHead:EnableMouse(true) |
watchHead:RegisterForDrag('LeftButton') |
watchHead:SetHitRectInsets(-15, 0, -5, -5) |
watchHead:SetScript('OnDragStart', function(self) |
if (IsShiftKeyDown()) then |
self:GetParent():StartMoving() |
end |
end) |
watchHead:SetScript('OnDragStop', function(self) |
self:GetParent():StopMovingOrSizing() |
end) |
watchHead:SetScript('OnEnter', function() |
if InCombatLockdown() then return end |
GameTooltip:SetOwner(watchHead, "ANCHOR_TOPLEFT") |
GameTooltip:ClearLines() |
GameTooltip:AddLine("|cffeda55fShift+Left Click|r to Drag") |
GameTooltip:Show() |
end) |
watchHead:SetScript('OnLeave', function() GameTooltip:Hide() end) |
local watchHeadTitle = _G['WatchFrameTitle'] |
watchHeadTitle:SetFont(C['media'].font, 15) |
if C['general'].classcolor ~= true then |
watchHeadTitle:SetTextColor(C['general'].color.r,C['general'].color.g,C['general'].color.b) |
else |
watchHeadTitle:SetTextColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Font Options Setup |
-------------------------------------------------------------- |
local function SetFont(obj, font, size, style, r, g, b, sr, sg, sb, sox, soy) |
obj:SetFont(font, size, style) |
if sr and sg and sb then obj:SetShadowColor(sr, sg, sb) end |
if sox and soy then obj:SetShadowOffset(sox, soy) end |
if r and g and b then obj:SetTextColor(r, g, b) |
elseif r then obj:SetAlpha(r) end |
end |
local NORMAL = C['media'].font |
local COMBAT = C['media'].font |
local NUMBER = C['media'].font |
local _, editBoxFontSize, _, _, _, _, _, _, _, _ = GetChatWindowInfo(1) |
UIDROPDOWNMENU_DEFAULT_TEXT_HEIGHT = 12 |
CHAT_FONT_HEIGHTS = {12, 13, 14, 15, 16, 17, 18, 19, 20} |
UNIT_NAME_FONT = NORMAL |
NAMEPLATE_FONT = NORMAL |
DAMAGE_TEXT_FONT = COMBAT |
STANDARD_TEXT_FONT = NORMAL |
-- Base fonts |
SetFont(GameTooltipHeader, NORMAL, C['media'].fontSize) |
SetFont(NumberFont_OutlineThick_Mono_Small, NUMBER, C['media'].fontSize, "OUTLINE") |
SetFont(NumberFont_Outline_Huge, NUMBER, 28, "THICKOUTLINE", 28) |
SetFont(NumberFont_Outline_Large, NUMBER, 15, "OUTLINE") |
SetFont(NumberFont_Outline_Med, NUMBER, C['media'].fontSize*1.1, "OUTLINE") |
SetFont(NumberFont_Shadow_Med, NORMAL, C['media'].fontSize) -- Chat editbox uses this |
SetFont(NumberFont_Shadow_Small, NORMAL, C['media'].fontSize) |
SetFont(QuestFont, NORMAL, C['media'].fontSize) |
SetFont(QuestFont_Large, NORMAL, 14) |
SetFont(SystemFont_Large, NORMAL, 15) |
SetFont(SystemFont_Shadow_Huge1, NORMAL, 20, "OUTLINE") -- Raid Warning, Boss emote frame too |
SetFont(SystemFont_Med1, NORMAL, C['media'].fontSize) |
SetFont(SystemFont_Med3, NORMAL, C['media'].fontSize*1.1) |
SetFont(SystemFont_OutlineThick_Huge2, NORMAL, 20, "THICKOUTLINE") |
SetFont(SystemFont_Outline_Small, NUMBER, C['media'].fontSize, "OUTLINE") |
SetFont(SystemFont_Shadow_Large, NORMAL, 15) |
SetFont(SystemFont_Shadow_Med1, NORMAL, C['media'].fontSize) |
SetFont(SystemFont_Shadow_Med3, NORMAL, C['media'].fontSize*1.1) |
SetFont(SystemFont_Shadow_Outline_Huge2, NORMAL, 20, "OUTLINE") |
SetFont(SystemFont_Shadow_Small, NORMAL, C['media'].fontSize*0.9) |
SetFont(SystemFont_Small, NORMAL, C['media'].fontSize) |
SetFont(SystemFont_Tiny, NORMAL, C['media'].fontSize) |
SetFont(Tooltip_Med, NORMAL, C['media'].fontSize) |
SetFont(Tooltip_Small, NORMAL, C['media'].fontSize) |
SetFont(ZoneTextString, NORMAL, 32, "OUTLINE") |
SetFont(SubZoneTextString, NORMAL, 25, "OUTLINE") |
SetFont(PVPInfoTextString, NORMAL, 22, "OUTLINE") |
SetFont(PVPArenaTextString, NORMAL, 22, "OUTLINE") |
SetFont(CombatTextFont, COMBAT, 100, "OUTLINE") -- Increases font quality |
local S, C, Soop = unpack(select(2, ...)) |
-------------------------------------------------------------- |
-- Hide the Blizzard store button |
-------------------------------------------------------------- |
GameMenuButtonStore:ClearAllPoints() |
GameMenuButtonStore:Hide() |
GameMenuButtonStore:HookScript("OnShow", GameMenuButtonStore.Hide) |
GameMenuButtonOptions:ClearAllPoints() |
GameMenuButtonOptions:SetPoint("TOP", GameMenuButtonHelp, "BOTTOM", 0, -16) |
function GameMenuFrame_UpdateVisibleButtons(self) -- Adapted from GameMenuFrame.lua |
local height = 290 |
if IsMacClient() then |
height = height + 20 |
GameMenuButtonMacOptions:Show() |
GameMenuButtonUIOptions:SetPoint("TOP", GameMenuButtonMacOptions, "BOTTOM", 0, -1) |
else |
GameMenuButtonMacOptions:Hide() |
GameMenuButtonUIOptions:SetPoint("TOP", GameMenuButtonOptions, "BOTTOM", 0, -1) |
end |
if GameMenuButtonRatings:IsShown() then |
height = height + 20 |
GameMenuButtonLogout:SetPoint("TOP", GameMenuButtonRatings, "BOTTOM", 0, -16) |
else |
GameMenuButtonLogout:SetPoint("TOP", GameMenuButtonMacros, "BOTTOM", 0, -16) |
end |
self:SetHeight(height) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Stat Data Panel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].stat1 and C['datatext'].stat1 > 0 then |
local Stat = CreateFrame("Frame") |
Stat:RegisterEvent("PLAYER_ENTERING_WORLD") |
Stat:SetFrameStrata("BACKGROUND") |
Stat:SetFrameLevel(3) |
Stat:EnableMouse(true) |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].stat1, Text) |
local format = string.format |
local targetlv, playerlv = UnitLevel("target"), UnitLevel("player") |
local basemisschance, leveldifference, dodge, parry, block |
local chanceString = "%.2f%%" |
local modifierString = string.join("", "%d (+", chanceString, ")") |
local manaRegenString = "%d / %d" |
local displayNumberString = string.join("", "%s", "%d|r") |
local displayFloatString = string.join("", "%s", "%.2f%%|r") |
local spellpwr, avoidance, pwr |
local haste, hasteBonus |
local level = UnitLevel("player") |
local function ShowTooltip(self) |
if InCombatLockdown() then return end |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Statistics") |
GameTooltip:AddLine' ' |
if S.Role == "Tank" then |
if targetlv > 1 then |
GameTooltip:AddDoubleLine("Avoidance Breakdown", string.join("", " (", "lvl", " ", targetlv, ")")) |
elseif targetlv == -1 then |
GameTooltip:AddDoubleLine("Avoidance Breakdown", string.join("", " (", "Boss", ")")) |
else |
GameTooltip:AddDoubleLine("Avoidance Breakdown", string.join("", " (", "lvl", " ", playerlv, ")")) |
end |
GameTooltip:AddLine' ' |
GameTooltip:AddDoubleLine(DODGE_CHANCE, format(chanceString, dodge),1,1,1) |
GameTooltip:AddDoubleLine(PARRY_CHANCE, format(chanceString, parry),1,1,1) |
GameTooltip:AddDoubleLine(BLOCK_CHANCE, format(chanceString, block),1,1,1) |
GameTooltip:AddDoubleLine(MISS_CHANCE, format(chanceString, basemisschance),1,1,1) |
elseif S.Role == "Caster" then |
GameTooltip:AddDoubleLine(STAT_HIT_CHANCE, format(modifierString, GetCombatRating(CR_HIT_SPELL), GetCombatRatingBonus(CR_HIT_SPELL)), 1, 1, 1) |
GameTooltip:AddDoubleLine(STAT_HASTE, format(modifierString, GetCombatRating(CR_HASTE_SPELL), GetCombatRatingBonus(CR_HASTE_SPELL)), 1, 1, 1) |
local base, combat = GetManaRegen() |
GameTooltip:AddDoubleLine(MANA_REGEN, format(manaRegenString, base * 5, combat * 5), 1, 1, 1) |
elseif S.Role == "Melee" then |
local hit = S.myclass == "HUNTER" and GetCombatRating(CR_HIT_RANGED) or GetCombatRating(CR_HIT_MELEE) |
local hitBonus = S.myclass == "HUNTER" and GetCombatRatingBonus(CR_HIT_RANGED) or GetCombatRatingBonus(CR_HIT_MELEE) |
GameTooltip:AddDoubleLine(STAT_HIT_CHANCE, format(modifierString, hit, hitBonus), 1, 1, 1) |
--Hunters don't use expertise |
--[[if S.myclass ~= "HUNTER" then |
local expertisePercent, offhandExpertisePercent = GetExpertisePercent() |
expertisePercent = format("%.2f", expertisePercent) |
offhandExpertisePercent = format("%.2f", offhandExpertisePercent) |
local expertisePercentDisplay |
if IsDualWielding() then |
expertisePercentDisplay = expertisePercent.."% / "..offhandExpertisePercent.."%" |
else |
expertisePercentDisplay = expertisePercent.."%" |
end |
GameTooltip:AddDoubleLine(COMBAT_RATING_NAME24, format('%d (+%s)', GetCombatRating(CR_EXPERTISE), expertisePercentDisplay), 1, 1, 1) |
end]] |
local haste = S.myclass == "HUNTER" and GetCombatRating(CR_HASTE_RANGED) or GetCombatRating(CR_HASTE_MELEE) |
local hasteBonus = S.myclass == "HUNTER" and GetCombatRatingBonus(CR_HASTE_RANGED) or GetCombatRatingBonus(CR_HASTE_MELEE) |
GameTooltip:AddDoubleLine(STAT_HASTE, format(modifierString, haste, hasteBonus), 1, 1, 1) |
end |
local masteryspell |
if GetCombatRating(CR_MASTERY) ~= 0 and GetSpecialization () then |
if S.myclass == "DRUID" then |
if S.Role == "Melee" then |
masteryspell = select(2, GetSpecializationMasterySpells(GetSpecialization ())) |
elseif S.Role == "Tank" then |
masteryspell = select(1, GetSpecializationMasterySpells(GetSpecialization ())) |
else |
masteryspell = GetSpecializationMasterySpells(GetSpecialization ()) |
end |
else |
masteryspell = GetSpecializationMasterySpells(GetSpecialization ()) |
end |
local masteryName, _, _, _, _, _, _, _, _ = GetSpellInfo(masteryspell) |
if masteryName then |
GameTooltip:AddLine' ' |
GameTooltip:AddDoubleLine(masteryName, format(modifierString, GetCombatRating(CR_MASTERY), GetCombatRatingBonus(CR_MASTERY)), 1, 1, 1) |
end |
end |
GameTooltip:Show() |
end |
local function UpdateTank(self) |
-- the 5 is for base miss chance |
if targetlv == -1 then |
basemisschance = (5 - (3*.2)) |
leveldifference = 3 |
elseif targetlv > playerlv then |
basemisschance = (5 - ((targetlv - playerlv)*.2)) |
leveldifference = (targetlv - playerlv) |
elseif targetlv < playerlv and targetlv > 0 then |
basemisschance = (5 + ((playerlv - targetlv)*.2)) |
leveldifference = (targetlv - playerlv) |
else |
basemisschance = 5 |
leveldifference = 0 |
end |
if select(2, UnitRace("player")) == "NightElf" then basemisschance = basemisschance + 2 end |
if leveldifference >= 0 then |
dodge = (GetDodgeChance()-leveldifference*.2) |
parry = (GetParryChance()-leveldifference*.2) |
block = (GetBlockChance()-leveldifference*.2) |
else |
dodge = (GetDodgeChance()+abs(leveldifference*.2)) |
parry = (GetParryChance()+abs(leveldifference*.2)) |
block = (GetBlockChance()+abs(leveldifference*.2)) |
end |
if dodge <= 0 then dodge = 0 end |
if parry <= 0 then parry = 0 end |
if block <= 0 then block = 0 end |
if S.myclass == "DRUID" then |
parry = 0 |
block = 0 |
elseif S.myclass == "DEATHKNIGHT" then |
block = 0 |
end |
avoidance = (dodge+parry+block+basemisschance) |
Text:SetFormattedText(displayFloatString, hexa.."AVD: "..hexb, avoidance) |
--Setup Tooltip |
self:SetAllPoints(Text) |
end |
local function UpdateCaster(self) |
if GetSpellBonusHealing() > GetSpellBonusDamage(7) then |
spellpwr = GetSpellBonusHealing() |
else |
spellpwr = GetSpellBonusDamage(7) |
end |
Text:SetFormattedText(displayNumberString, hexa.."SP: "..hexb, spellpwr) |
--Setup Tooltip |
self:SetAllPoints(Text) |
end |
local function UpdateMelee(self) |
local base, posBuff, negBuff = UnitAttackPower("player"); |
local effective = base + posBuff + negBuff; |
local Rbase, RposBuff, RnegBuff = UnitRangedAttackPower("player"); |
local Reffective = Rbase + RposBuff + RnegBuff; |
if S.myclass == "HUNTER" then |
pwr = Reffective |
else |
pwr = effective |
end |
Text:SetFormattedText(displayNumberString, hexa.."AP: "..hexb, pwr) |
--Setup Tooltip |
self:SetAllPoints(Text) |
end |
-- initial delay for update (let the ui load) |
local int = 5 |
local function Update(self, t) |
int = int - t |
if int > 0 then return end |
if S.Role == "Tank" then |
UpdateTank(self) |
elseif S.Role == "Caster" then |
UpdateCaster(self) |
elseif S.Role == "Melee" then |
UpdateMelee(self) |
end |
int = 2 |
end |
Stat:SetScript("OnEnter", function() ShowTooltip(Stat) end) |
Stat:SetScript("OnLeave", function() GameTooltip:Hide() end) |
Stat:SetScript("OnUpdate", Update) |
Update(Stat, 10) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Stats 2 Data Panel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].stat2 and C['datatext'].stat2 > 0 then |
local Stat = CreateFrame("Frame") |
Stat:RegisterEvent("PLAYER_ENTERING_WORLD") |
Stat:SetFrameStrata("BACKGROUND") |
Stat:SetFrameLevel(3) |
Stat:EnableMouse(true) |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].stat2, Text) |
local _G = getfenv(0) |
local format = string.format |
local chanceString = "%.2f%%" |
local armorString = hexa..ARMOR..hexb..": " |
local modifierString = string.join("", "%d (+", chanceString, ")") |
local baseArmor, effectiveArmor, armor, posBuff, negBuff |
local displayNumberString = string.join("", "%s", "%d|r") |
local displayFloatString = string.join("", "%s", "%.2f%%|r") |
local level = UnitLevel("player") |
local function CalculateMitigation(level, effective) |
local mitigation |
if not effective then |
_, effective, _, _, _ = UnitArmor("player") |
end |
if level < 60 then |
mitigation = (effective/(effective + 400 + (85 * level))); |
else |
mitigation = (effective/(effective + (467.5 * level - 22167.5))); |
end |
if mitigation > .75 then |
mitigation = .75 |
end |
return mitigation |
end |
local function AddTooltipHeader(description) |
GameTooltip:AddLine(description) |
GameTooltip:AddLine(' ') |
end |
local function ShowTooltip(self) |
if InCombatLockdown() then return end |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Statistics") |
GameTooltip:AddLine' ' |
if S.Role == "Tank" then |
AddTooltipHeader("Mitigation By Level: ") |
local lv = level +3 |
for i = 1, 4 do |
GameTooltip:AddDoubleLine(lv,format(chanceString, CalculateMitigation(lv, effectiveArmor) * 100),1,1,1) |
lv = lv - 1 |
end |
lv = UnitLevel("target") |
if lv and lv > 0 and (lv > level + 3 or lv < level) then |
GameTooltip:AddDoubleLine(lv, format(chanceString, CalculateMitigation(lv, effectiveArmor) * 100),1,1,1) |
end |
elseif S.Role == "Caster" or S.Role == "Melee" then |
AddTooltipHeader(MAGIC_RESISTANCES_COLON) |
local baseResistance, effectiveResistance, posResitance, negResistance |
for i = 2, 6 do |
baseResistance, effectiveResistance, posResitance, negResistance = UnitResistance("player", i) |
GameTooltip:AddDoubleLine(_G["DAMAGE_SCHOOL"..(i+1)], format(chanceString, (effectiveResistance / (effectiveResistance + (500 + level + 2.5))) * 100),1,1,1) |
end |
local spellpen = GetSpellPenetration() |
if (S.myclass == "SHAMAN" or S.Role == "Caster") and spellpen > 0 then |
GameTooltip:AddLine' ' |
GameTooltip:AddDoubleLine(ITEM_MOD_SPELL_PENETRATION_SHORT, spellpen,1,1,1) |
end |
end |
GameTooltip:Show() |
end |
local function UpdateTank(self) |
baseArmor, effectiveArmor, armor, posBuff, negBuff = UnitArmor("player"); |
Text:SetFormattedText(displayNumberString, armorString, effectiveArmor) |
--Setup Tooltip |
self:SetAllPoints(Text) |
end |
local function UpdateCaster(self) |
local spellcrit = GetSpellCritChance(1) |
Text:SetFormattedText(displayFloatString, hexa.."Crit: "..hexb, spellcrit) |
--Setup Tooltip |
self:SetAllPoints(Text) |
end |
local function UpdateMelee(self) |
local meleecrit = GetCritChance() |
local rangedcrit = GetRangedCritChance() |
local critChance |
if S.myclass == "HUNTER" then |
critChance = rangedcrit |
else |
critChance = meleecrit |
end |
Text:SetFormattedText(displayFloatString, hexa.."Crit: "..hexb, critChance) |
--Setup Tooltip |
self:SetAllPoints(Text) |
end |
-- initial delay for update (let the ui load) |
local int = 5 |
local function Update(self, t) |
int = int - t |
if int > 0 then return end |
if S.Role == "Tank" then |
UpdateTank(self) |
elseif S.Role == "Caster" then |
UpdateCaster(self) |
elseif S.Role == "Melee" then |
UpdateMelee(self) |
end |
int = 2 |
end |
Stat:SetScript("OnEnter", function() ShowTooltip(Stat) end) |
Stat:SetScript("OnLeave", function() GameTooltip:Hide() end) |
Stat:SetScript("OnUpdate", Update) |
Update(Stat, 10) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import: S - function; C - config; Soop - Database |
--[[ |
All Credit for Time.lua goes to Tuks. |
Tukui = http://www.tukui.org/download.php. |
Edited by Cokedriver. |
]] |
if C['datatext'].enable ~= true then return end |
if C['datatext'].wowtime and C['datatext'].wowtime > 0 then |
local europeDisplayFormat = string.join("", "%02d", ":|r%02d") |
local ukDisplayFormat = string.join("", "", "%d", ":|r%02d", " %s|r") |
local timerLongFormat = "%d:%02d:%02d" |
local timerShortFormat = "%d:%02d" |
local lockoutInfoFormat = "%s |cffaaaaaa(%s%s, %s/%s)" |
local formatBattleGroundInfo = "%s: " |
local lockoutColorExtended, lockoutColorNormal = { r=0.3,g=1,b=0.3 }, { r=1,g=1,b=1 } |
local difficultyInfo = { "N", "N", "H", "H" } |
local curHr, curMin, curAmPm |
local Stat = CreateFrame("Frame") |
Stat:EnableMouse(true) |
Stat:SetFrameStrata("MEDIUM") |
Stat:SetFrameLevel(3) |
local Text = DataPanel:CreateFontString(nil, 'OVERLAY') |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].wowtime, Text) |
local APM = { TIMEMANAGER_PM, TIMEMANAGER_AM } |
local function CalculateTimeValues(tt) |
if tt == nil then tt = false end |
local Hr, Min, AmPm |
if tt == true then |
if C['datatext'].localtime == true then |
Hr, Min = GetGameTime() |
if C['datatext'].time24 == true then |
return Hr, Min, -1 |
else |
if Hr>=12 then |
if Hr>12 then Hr = Hr - 12 end |
AmPm = 1 |
else |
if Hr == 0 then Hr = 12 end |
AmPm = 2 |
end |
return Hr, Min, AmPm |
end |
else |
local Hr24 = tonumber(date("%H")) |
Hr = tonumber(date("%I")) |
Min = tonumber(date("%M")) |
if C['datatext'].time24 == true then |
return Hr24, Min, -1 |
else |
if Hr24>=12 then AmPm = 1 else AmPm = 2 end |
return Hr, Min, AmPm |
end |
end |
else |
if C['datatext'].localtime == true then |
local Hr24 = tonumber(date("%H")) |
Hr = tonumber(date("%I")) |
Min = tonumber(date("%M")) |
if C['datatext'].time24 == true then |
return Hr24, Min, -1 |
else |
if Hr24>=12 then AmPm = 1 else AmPm = 2 end |
return Hr, Min, AmPm |
end |
else |
Hr, Min = GetGameTime() |
if C['datatext'].time24 == true then |
return Hr, Min, -1 |
else |
if Hr>=12 then |
if Hr>12 then Hr = Hr - 12 end |
AmPm = 1 |
else |
if Hr == 0 then Hr = 12 end |
AmPm = 2 |
end |
return Hr, Min, AmPm |
end |
end |
end |
end |
local function CalculateTimeLeft(time) |
local hour = floor(time / 3600) |
local min = floor(time / 60 - (hour*60)) |
local sec = time - (hour * 3600) - (min * 60) |
return hour, min, sec |
end |
local function formatResetTime(sec,table) |
local table = table or {} |
local d,h,m,s = ChatFrame_TimeBreakDown(floor(sec)) |
local string = gsub(gsub(format(" %dd %dh %dm "..((d==0 and h==0) and "%ds" or ""),d,h,m,s)," 0[dhms]"," "),"%s+"," ") |
local string = strtrim(gsub(string, "([dhms])", {d=table.days or "d",h=table.hours or "h",m=table.minutes or "m",s=table.seconds or "s"})," ") |
return strmatch(string,"^%s*$") and "0"..(table.seconds or L"s") or string |
end |
local int = 1 |
local function Update(self, t) |
int = int - t |
if int > 0 then return end |
local Hr, Min, AmPm = CalculateTimeValues() |
if CalendarGetNumPendingInvites() > 0 then |
Text:SetTextColor(1, 0, 0) |
else |
Text:SetTextColor(1, 1, 1) |
end |
-- no update quick exit |
if (Hr == curHr and Min == curMin and AmPm == curAmPm) then |
int = 2 |
return |
end |
curHr = Hr |
curMin = Min |
curAmPm = AmPm |
if AmPm == -1 then |
Text:SetFormattedText(europeDisplayFormat, Hr, Min) |
else |
Text:SetFormattedText(ukDisplayFormat, Hr, Min, hexa..APM[AmPm]..hexb) |
end |
self:SetAllPoints(Text) |
int = 2 |
end |
Stat:SetScript("OnEnter", function(self) |
if InCombatLockdown() then return end |
OnLoad = function(self) RequestRaidInfo() end |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Time") |
GameTooltip:AddLine' ' |
local localizedName, isActive, canQueue, startTime, canEnter |
for i = 1, GetNumWorldPVPAreas() do |
_, localizedName, isActive, canQueue, startTime, canEnter = GetWorldPVPAreaInfo(i) |
if canEnter then |
if isActive then |
startTime = WINTERGRASP_IN_PROGRESS |
elseif startTime == nil then |
startTime = QUEUE_TIME_UNAVAILABLE |
else |
local hour, min, sec = CalculateTimeLeft(startTime) |
if hour > 0 then |
startTime = string.format(timerLongFormat, hour, min, sec) |
else |
startTime = string.format(timerShortFormat, min, sec) |
end |
end |
GameTooltip:AddDoubleLine(format(formatBattleGroundInfo, localizedName), startTime) |
end |
end |
local timeText |
local Hr, Min, AmPm = CalculateTimeValues(true) |
if C['datatext'].localtime == true then |
timeText = "Server Time: " |
else |
timeText = "Local Time: " |
end |
if AmPm == -1 then |
GameTooltip:AddDoubleLine(timeText, string.format(europeDisplayFormat, Hr, Min)) |
else |
GameTooltip:AddDoubleLine(timeText, string.format(ukDisplayFormat, Hr, Min, APM[AmPm])) |
end |
local oneraid, lockoutColor |
for i = 1, GetNumSavedInstances() do |
local name, _, reset, difficulty, locked, extended, _, isRaid, maxPlayers, _, numEncounters, encounterProgress = GetSavedInstanceInfo(i) |
if isRaid and (locked or extended) then |
local tr,tg,tb,diff |
if not oneraid then |
GameTooltip:AddLine(" ") |
GameTooltip:AddLine("Saved Raid(s)") |
oneraid = true |
end |
if extended then lockoutColor = lockoutColorExtended else lockoutColor = lockoutColorNormal end |
GameTooltip:AddDoubleLine(format(name, maxPlayers, difficultyInfo[difficulty],encounterProgress,numEncounters), formatResetTime(reset), 1,1,1, lockoutColor.r,lockoutColor.g,lockoutColor.b) |
end |
end |
GameTooltip:Show() |
end) |
Stat:SetScript("OnLeave", function() GameTooltip:Hide() end) |
Stat:RegisterEvent("CALENDAR_UPDATE_PENDING_INVITES") |
Stat:RegisterEvent("PLAYER_ENTERING_WORLD") |
Stat:SetScript("OnUpdate", Update) |
Stat:RegisterEvent("UPDATE_INSTANCE_INFO") |
Stat:SetScript("OnMouseDown", function(self, btn) |
if btn == 'RightButton' then |
ToggleTimeManager() |
else |
GameTimeFrame:Click() |
end |
end) |
Update(Stat, 10) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- CTA Datapanel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].calltoarms and C['datatext'].calltoarms > 0 then |
local Stat = CreateFrame("Frame") |
Stat:EnableMouse(true) |
Stat:SetFrameStrata("MEDIUM") |
Stat:SetFrameLevel(3) |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].calltoarms, Text) |
local function MakeIconString(tank, healer, damage) |
local str = "" |
if tank then |
str = str..'T' |
end |
if healer then |
str = str..', H' |
end |
if damage then |
str = str..', D' |
end |
return str |
end |
local function MakeString(tank, healer, damage) |
local str = "" |
if tank then |
str = str..'Tank' |
end |
if healer then |
str = str..', Healer' |
end |
if damage then |
str = str..', DPS' |
end |
return str |
end |
local function OnEvent(self, event, ...) |
local tankReward = false |
local healerReward = false |
local dpsReward = false |
local unavailable = true |
for i=1, GetNumRandomDungeons() do |
local id, name = GetLFGRandomDungeonInfo(i) |
for x = 1,LFG_ROLE_NUM_SHORTAGE_TYPES do |
local eligible, forTank, forHealer, forDamage, itemCount = GetLFGRoleShortageRewards(id, x) |
if eligible then unavailable = false end |
if eligible and forTank and itemCount > 0 then tankReward = true end |
if eligible and forHealer and itemCount > 0 then healerReward = true end |
if eligible and forDamage and itemCount > 0 then dpsReward = true end |
end |
end |
if unavailable then |
Text:SetText(QUEUE_TIME_UNAVAILABLE) |
else |
Text:SetText(hexa..'C to A'..hexb.." : "..MakeIconString(tankReward, healerReward, dpsReward).." ") |
end |
self:SetAllPoints(Text) |
end |
local function OnEnter(self) |
if InCombatLockdown() then return end |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Call to Arms") |
GameTooltip:AddLine(' ') |
local allUnavailable = true |
local numCTA = 0 |
for i=1, GetNumRandomDungeons() do |
local id, name = GetLFGRandomDungeonInfo(i) |
local tankReward = false |
local healerReward = false |
local dpsReward = false |
local unavailable = true |
for x=1, LFG_ROLE_NUM_SHORTAGE_TYPES do |
local eligible, forTank, forHealer, forDamage, itemCount = GetLFGRoleShortageRewards(id, x) |
if eligible then unavailable = false end |
if eligible and forTank and itemCount > 0 then tankReward = true end |
if eligible and forHealer and itemCount > 0 then healerReward = true end |
if eligible and forDamage and itemCount > 0 then dpsReward = true end |
end |
if not unavailable then |
allUnavailable = false |
local rolesString = MakeString(tankReward, healerReward, dpsReward) |
if rolesString ~= "" then |
GameTooltip:AddDoubleLine(name.." : ", rolesString..' ', 1, 1, 1) |
end |
if tankReward or healerReward or dpsReward then numCTA = numCTA + 1 end |
end |
end |
if allUnavailable then |
GameTooltip:AddLine("Could not get Call To Arms information.") |
elseif numCTA == 0 then |
GameTooltip:AddLine("Could not get Call To Arms information.") |
end |
GameTooltip:AddLine' ' |
GameTooltip:AddLine("|cffeda55fClick|r to Open Dungeon Finder") |
GameTooltip:Show() |
end |
Stat:RegisterEvent("LFG_UPDATE_RANDOM_INFO") |
Stat:RegisterEvent("PLAYER_LOGIN") |
Stat:SetScript("OnEvent", OnEvent) |
Stat:SetScript("OnMouseDown", function() ToggleFrame(LFDParentFrame) end) |
Stat:SetScript("OnEnter", OnEnter) |
Stat:SetScript("OnLeave", function() GameTooltip:Hide() end) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Colors |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C["general"].classcolor ~= true then |
local r, g, b = C["general"].color.r, C["general"].color.g, C["general"].color.b |
hexa = ("|cff%.2x%.2x%.2x"):format(r * 255, g * 255, b * 255) |
hexb = "|r" |
else |
hexa = ("|cff%.2x%.2x%.2x"):format(S.ccolor.r * 255, S.ccolor.g * 255, S.ccolor.b * 255) |
hexb = "|r" |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Data Panel (originally by Tuks of Tukui.org) |
-------------------------------------------------------------- |
if not C["datatext"].guild or C["datatext"].guild == 0 then return end |
local Stat = CreateFrame("Frame") |
Stat:EnableMouse(true) |
Stat:SetFrameStrata("MEDIUM") |
Stat:SetFrameLevel(3) |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C["media"].font, C["datatext"].fontsize,'THINOUTLINE') |
S.PP(C["datatext"].guild, Text) |
local tthead, ttsubh, ttoff = {r=0.4, g=0.78, b=1}, {r=0.75, g=0.9, b=1}, {r=.3,g=1,b=.3} |
local activezone, inactivezone = {r=0.3, g=1.0, b=0.3}, {r=0.65, g=0.65, b=0.65} |
local displayString = string.join("", hexa.."%s: "..hexb, "|cffffffff", "%d|r") |
local guildInfoString0 = "%s" |
local guildInfoString1 = "%s [%d]" |
local guildInfoString2 = "%s: %d/%d" |
local guildMotDString = "%s |cffaaaaaa- |cffffffff%s" |
local levelNameString = "|cff%02x%02x%02x%d|r |cff%02x%02x%02x%s|r %s" |
local levelNameStatusString = "|cff%02x%02x%02x%d|r %s %s" |
local nameRankString = "%s |cff999999-|cffffffff %s" |
local noteString = " '%s'" |
local officerNoteString = " o: '%s'" |
local guildTable, guildXP, guildMotD = {}, {}, "" |
local totalOnline = 0 |
local function BuildGuildTable() |
totalOnline = 0 |
wipe(guildTable) |
local _, name, rank, level, zone, note, officernote, connected, status, class, isMobile |
for i = 1, GetNumGuildMembers() do |
name, rank, _, level, _, zone, note, officernote, connected, status, class, _, _, isMobile = GetGuildRosterInfo(i) |
if status == 1 then |
status = "|cffff0000["..AFK.."]|r" |
elseif status == 2 then |
status = "|cffff0000["..DND.."]|r" |
else |
status = "" |
end |
guildTable[i] = { name, rank, level, zone, note, officernote, connected, status, class, isMobile } |
if connected then totalOnline = totalOnline + 1 end |
end |
table.sort(guildTable, function(a, b) |
if a and b then |
return a[1] < b[1] |
end |
end) |
end |
local function UpdateGuildXP() |
local currentXP, remainingXP = UnitGetGuildXP("player") |
local nextLevelXP = currentXP + remainingXP |
-- prevent 4.3 division / 0 |
if nextLevelXP == 0 or maxDailyXP == 0 then return end |
local percentTotal = tostring(math.ceil((currentXP / nextLevelXP) * 100)) |
guildXP[0] = { currentXP, nextLevelXP, percentTotal } |
end |
local function UpdateGuildMessage() |
guildMotD = GetGuildRosterMOTD() |
end |
local function Update(self, event, ...) |
if event == "PLAYER_ENTERING_WORLD" then |
self:UnregisterEvent("PLAYER_ENTERING_WORLD") |
if IsInGuild() and not GuildFrame then LoadAddOn("Blizzard_GuildUI") end |
end |
if IsInGuild() then |
totalOnline = 0 |
local name, rank, level, zone, note, officernote, connected, status, class |
for i = 1, GetNumGuildMembers() do |
local connected = select(9, GetGuildRosterInfo(i)) |
if connected then totalOnline = totalOnline + 1 end |
end |
Text:SetFormattedText(displayString, "Guild", totalOnline) |
else |
Text:SetText("No Guild") |
end |
self:SetAllPoints(Text) |
end |
local menuFrame = CreateFrame("Frame", "GuildRightClickMenu", UIParent, "UIDropDownMenuTemplate") |
local menuList = { |
{ text = OPTIONS_MENU, isTitle = true,notCheckable=true}, |
{ text = INVITE, hasArrow = true,notCheckable=true,}, |
{ text = CHAT_MSG_WHISPER_INFORM, hasArrow = true,notCheckable=true,} |
} |
local function inviteClick(self, arg1, arg2, checked) |
menuFrame:Hide() |
InviteUnit(arg1) |
end |
local function whisperClick(self,arg1,arg2,checked) |
menuFrame:Hide() |
SetItemRef( "player:"..arg1, ("|Hplayer:%1$s|h[%1$s]|h"):format(arg1), "LeftButton" ) |
end |
local function ToggleGuildFrame() |
if IsInGuild() then |
if not GuildFrame then LoadAddOn("Blizzard_GuildUI") end |
GuildFrame_Toggle() |
GuildFrame_TabClicked(GuildFrameTab2) |
else |
if not LookingForGuildFrame then LoadAddOn("Blizzard_LookingForGuildUI") end |
LookingForGuildFrame_Toggle() |
end |
end |
Stat:SetScript("OnMouseUp", function(self, btn) |
if btn ~= "RightButton" or not IsInGuild() then return end |
GameTooltip:Hide() |
local classc, levelc, grouped |
local menuCountWhispers = 0 |
local menuCountInvites = 0 |
menuList[2].menuList = {} |
menuList[3].menuList = {} |
for i = 1, #guildTable do |
if (guildTable[i][7] and guildTable[i][1] ~= S.myname) then |
local classc, levelc = (CUSTOM_CLASS_COLORS or RAID_CLASS_COLORS)[guildTable[i][9]], GetQuestDifficultyColor(guildTable[i][3]) |
if UnitInParty(guildTable[i][1]) or UnitInRaid(guildTable[i][1]) then |
grouped = "|cffaaaaaa*|r" |
else |
grouped = "" |
if not guildTable[i][10] then |
menuCountInvites = menuCountInvites + 1 |
menuList[2].menuList[menuCountInvites] = {text = string.format(levelNameString, levelc.r*255,levelc.g*255,levelc.b*255, guildTable[i][3], classc.r*255,classc.g*255,classc.b*255, guildTable[i][1], ""), arg1 = guildTable[i][1],notCheckable=true, func = inviteClick} |
end |
end |
menuCountWhispers = menuCountWhispers + 1 |
menuList[3].menuList[menuCountWhispers] = {text = string.format(levelNameString, levelc.r*255,levelc.g*255,levelc.b*255, guildTable[i][3], classc.r*255,classc.g*255,classc.b*255, guildTable[i][1], grouped), arg1 = guildTable[i][1],notCheckable=true, func = whisperClick} |
end |
end |
EasyMenu(menuList, menuFrame, "cursor", 0, 0, "MENU", 2) |
end) |
Stat:SetScript("OnEnter", function(self) |
if InCombatLockdown() or not IsInGuild() then return end |
GuildRoster() |
UpdateGuildMessage() |
BuildGuildTable() |
local name, rank, level, zone, note, officernote, connected, status, class, isMobile |
local zonec, classc, levelc |
local online = totalOnline |
local guildName, guildRankName, guildRankIndex = GetGuildInfo("player"); |
local GuildInfo = GetGuildInfo('player') |
local GuildLevel = GetGuildLevel() |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Guild") |
if GuildInfo then |
GameTooltip:AddDoubleLine(string.format(guildInfoString0, GuildInfo), string.format(guildInfoString1, "Guild Level:", GuildLevel),tthead.r,tthead.g,tthead.b,tthead.r,tthead.g,tthead.b) |
end |
GameTooltip:AddLine' ' |
if GuildLevel then |
GameTooltip:AddLine( string.format(guildInfoString2, "Member's Online", online, #guildTable),tthead.r,tthead.g,tthead.b) |
end |
if guildMotD ~= "" then GameTooltip:AddLine(' ') |
GameTooltip:AddLine(string.format(guildMotDString, GUILD_MOTD, guildMotD), ttsubh.r, ttsubh.g, ttsubh.b, 1) |
end |
local col = S.RGBToHex(ttsubh.r, ttsubh.g, ttsubh.b) |
GameTooltip:AddLine' ' |
if GuildLevel and GuildLevel ~= 25 then |
--UpdateGuildXP() |
if guildXP[0] then |
local currentXP, nextLevelXP, percentTotal = unpack(guildXP[0]) |
GameTooltip:AddLine(string.format(col..GUILD_EXPERIENCE_CURRENT, "|r |cFFFFFFFF"..S.ShortValue(currentXP), S.ShortValue(nextLevelXP), percentTotal)) |
end |
end |
local _, _, standingID, barMin, barMax, barValue = GetGuildFactionInfo() |
if standingID ~= 8 then -- Not Max Rep |
barMax = barMax - barMin |
barValue = barValue - barMin |
barMin = 0 |
GameTooltip:AddLine(string.format("%s:|r |cFFFFFFFF%s/%s (%s%%)",col..COMBAT_FACTION_CHANGE, S.ShortValue(barValue), S.ShortValue(barMax), math.ceil((barValue / barMax) * 100))) |
end |
if online > 1 then |
GameTooltip:AddLine(' ') |
for i = 1, #guildTable do |
if online <= 1 then |
if online > 1 then GameTooltip:AddLine(format("+ %d More...", online - modules.Guild.maxguild),ttsubh.r,ttsubh.g,ttsubh.b) end |
break |
end |
name, rank, level, zone, note, officernote, connected, status, class, isMobile = unpack(guildTable[i]) |
if connected and name ~= S.myname then |
if GetRealZoneText() == zone then zonec = activezone else zonec = inactivezone end |
classc, levelc = (CUSTOM_CLASS_COLORS or RAID_CLASS_COLORS)[class], GetQuestDifficultyColor(level) |
if isMobile then zone = "" end |
if IsShiftKeyDown() then |
GameTooltip:AddDoubleLine(string.format(nameRankString, name, rank), zone, classc.r, classc.g, classc.b, zonec.r, zonec.g, zonec.b) |
if note ~= "" then GameTooltip:AddLine(string.format(noteString, note), ttsubh.r, ttsubh.g, ttsubh.b, 1) end |
if officernote ~= "" then GameTooltip:AddLine(string.format(officerNoteString, officernote), ttoff.r, ttoff.g, ttoff.b ,1) end |
else |
GameTooltip:AddDoubleLine(string.format(levelNameStatusString, levelc.r*255, levelc.g*255, levelc.b*255, level, name, status), zone, classc.r,classc.g,classc.b, zonec.r,zonec.g,zonec.b) |
end |
end |
end |
end |
GameTooltip:AddLine' ' |
GameTooltip:AddLine("|cffeda55fLeft Click|r to Open Guild Roster") |
GameTooltip:AddLine("|cffeda55fHold Shift & Mouseover|r to See Guild and Officer Note's") |
GameTooltip:AddLine("|cffeda55fRight Click|r to open Options Menu") |
GameTooltip:Show() |
end) |
Stat:SetScript("OnLeave", function() GameTooltip:Hide() end) |
Stat:SetScript("OnMouseDown", function(self, btn) |
if btn ~= "LeftButton" then return end |
ToggleGuildFrame() |
end) |
Stat:RegisterEvent("GUILD_ROSTER_SHOW") |
Stat:RegisterEvent("PLAYER_ENTERING_WORLD") |
Stat:RegisterEvent("GUILD_ROSTER_UPDATE") |
Stat:RegisterEvent("PLAYER_GUILD_UPDATE") |
Stat:SetScript("OnEvent", Update) |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Durability Data Panel |
-------------------------------------------------------------- |
if C["datatext"].enable ~= true then return end |
if C["datatext"].dur and C["datatext"].dur > 0 then |
Slots = { |
[1] = {1, "Head", 1000}, |
[2] = {3, "Shoulder", 1000}, |
[3] = {5, "Chest", 1000}, |
[4] = {6, "Waist", 1000}, |
[5] = {9, "Wrist", 1000}, |
[6] = {10, "Hands", 1000}, |
[7] = {7, "Legs", 1000}, |
[8] = {8, "Feet", 1000}, |
[9] = {16, "Main Hand", 1000}, |
[10] = {17, "Off Hand", 1000}, |
[11] = {18, "Ranged", 1000} |
} |
local Stat = CreateFrame("Frame") |
Stat:EnableMouse(true) |
Stat:SetFrameStrata("MEDIUM") |
Stat:SetFrameLevel(3) |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C["media"].font, C["datatext"].fontsize,'THINOUTLINE') |
S.PP(C["datatext"].dur, Text) |
local function OnEvent(self) |
local Total = 0 |
local current, max |
for i = 1, 11 do |
if GetInventoryItemLink("player", Slots[i][1]) ~= nil then |
current, max = GetInventoryItemDurability(Slots[i][1]) |
if current then |
Slots[i][3] = current/max |
Total = Total + 1 |
end |
end |
end |
table.sort(Slots, function(a, b) return a[3] < b[3] end) |
if Total > 0 then |
Text:SetText(hexa.."Armor: "..hexb..floor(Slots[1][3]*100).."% |r") |
else |
Text:SetText(hexa.."Armor: "..hexb.."100% |r") |
end |
-- Setup Durability Tooltip |
self:SetAllPoints(Text) |
Total = 0 |
end |
Stat:RegisterEvent("UPDATE_INVENTORY_DURABILITY") |
Stat:RegisterEvent("MERCHANT_SHOW") |
Stat:RegisterEvent("PLAYER_ENTERING_WORLD") |
Stat:SetScript("OnMouseDown", function() ToggleCharacter("PaperDollFrame") end) |
Stat:SetScript("OnEvent", OnEvent) |
Stat:SetScript("OnEnter", function(self) |
if not InCombatLockdown() then |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Durability") |
GameTooltip:AddLine' ' |
for i = 1, 11 do |
if Slots[i][3] ~= 1000 then |
local green, red |
green = Slots[i][3]*2 |
red = 1 - green |
GameTooltip:AddDoubleLine(Slots[i][2], floor(Slots[i][3]*100).."%",1 ,1 , 1, red + 1, green, 0) |
end |
end |
GameTooltip:AddLine(" ") |
GameTooltip:AddLine("|cffeda55fClick|r to Show Character Panel") |
GameTooltip:Show() |
end |
end) |
Stat:SetScript("OnLeave", function() GameTooltip:Hide() end) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Professions Datapanel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].pro and C['datatext'].pro > 0 then |
local Stat = CreateFrame('Button') |
Stat:RegisterEvent('PLAYER_ENTERING_WORLD') |
Stat:SetFrameStrata('BACKGROUND') |
Stat:SetFrameLevel(3) |
Stat:EnableMouse(true) |
Stat.tooltip = false |
local Text = DataPanel:CreateFontString(nil, 'OVERLAY') |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].pro, Text) |
local function Update(self) |
for i = 1, select("#", GetProfessions()) do |
local v = select(i, GetProfessions()); |
if v ~= nil then |
local name, texture, rank, maxRank = GetProfessionInfo(v) |
Text:SetFormattedText(hexa.."Professions"..hexb) |
end |
end |
self:SetAllPoints(Text) |
end |
Stat:SetScript('OnEnter', function() |
if InCombatLockdown() then return end |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Professions") |
GameTooltip:AddLine' ' |
for i = 1, select("#", GetProfessions()) do |
local v = select(i, GetProfessions()); |
if v ~= nil then |
local name, texture, rank, maxRank = GetProfessionInfo(v) |
GameTooltip:AddDoubleLine(name, rank..' / '..maxRank,.75,.9,1,.3,1,.3) |
end |
end |
GameTooltip:AddLine' ' |
GameTooltip:AddLine("|cffeda55fLeft Click|r to Open Profession #1") |
GameTooltip:AddLine("|cffeda55fMiddle Click|r to Open Spell Book") |
GameTooltip:AddLine("|cffeda55fRight Click|r to Open Profession #2") |
GameTooltip:Show() |
end) |
Stat:SetScript("OnClick",function(self,btn) |
local prof1, prof2 = GetProfessions() |
if btn == "LeftButton" then |
if prof1 then |
if (GetProfessionInfo(prof1) == (S.locale == "deDE" and "Kr\195\164uterkunde" or'Herbalism')) then |
print('Soop: Herbalism doesnt have any options') |
elseif(GetProfessionInfo(prof1) == (S.locale == "deDE" and "K\195\188rschnerei" or 'Skinning')) then |
print('Soop: Skinning doesnt have any options') |
elseif(GetProfessionInfo(prof1) == (S.locale == "deDE" and "Bergbau" or 'Mining')) then |
if(S.locale == "deDE") then |
CastSpellByName("Verh\195\188ttung") |
else |
CastSpellByName("Smelting") |
end |
else |
CastSpellByName((GetProfessionInfo(prof1))) |
end |
else |
print('Soop: No Profession Found') |
end |
elseif btn == 'MiddleButton' then |
ToggleFrame(SpellBookFrame) |
elseif btn == "RightButton" then |
if prof2 then |
if (GetProfessionInfo(prof2) == (S.locale == "deDE" and "Kräuterkunde" or'Herbalism')) then |
print('Soop: Herbalism doesnt have any options') |
elseif(GetProfessionInfo(prof2) == (S.locale == "deDE" and "K\195\188rschnerei" or 'Skinning')) then |
print('Soop" Skinning doesnt have any options') |
elseif(GetProfessionInfo(prof2) == (S.locale == "deDE" and "Bergbau" or 'Mining')) then |
if(S.locale == "deDE") then |
CastSpellByName("Verh\195\188ttung") |
else |
CastSpellByName("Smelting") |
end |
else |
CastSpellByName((GetProfessionInfo(prof2))) |
end |
else |
print('Soop: No profession found') |
end |
end |
end) |
Stat:RegisterForClicks("AnyUp") |
Stat:SetScript('OnUpdate', Update) |
Stat:SetScript('OnLeave', function() GameTooltip:Hide() end) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Zone Data Panel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].zone and C['datatext'].zone > 0 then |
local Stat = CreateFrame("Frame") |
Stat:EnableMouse(true) |
Stat:SetFrameStrata('BACKGROUND') |
Stat:SetFrameLevel(3) |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].zone, Text) |
local function Update(self) |
if GetMinimapZoneText() == "Putricide's Laboratory of Alchemical Horrors and Fun" then |
Text:SetText("Putricides's Laboratory") |
else |
Text:SetText(hexa..GetMinimapZoneText()..hexb) |
end |
end |
Stat:SetScript("OnUpdate", Update) |
Update(Stat, 10) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- System Data Panel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].system and C['datatext'].system > 0 then |
local Stat = CreateFrame("Frame") |
Stat:RegisterEvent("PLAYER_ENTERING_WORLD") |
Stat:SetFrameStrata("BACKGROUND") |
Stat:SetFrameLevel(3) |
Stat:EnableMouse(true) |
Stat.tooltip = false |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].system, Text) |
local bandwidthString = "%.2f Mbps" |
local percentageString = "%.2f%%" |
local homeLatencyString = "%d ms" |
local worldLatencyString = "%d ms" |
local kiloByteString = "%d kb" |
local megaByteString = "%.2f mb" |
local function formatMem(memory) |
local mult = 10^1 |
if memory > 999 then |
local mem = ((memory/1024) * mult) / mult |
return string.format(megaByteString, mem) |
else |
local mem = (memory * mult) / mult |
return string.format(kiloByteString, mem) |
end |
end |
local memoryTable = {} |
local function RebuildAddonList(self) |
local addOnCount = GetNumAddOns() |
if (addOnCount == #memoryTable) or self.tooltip == true then return end |
-- Number of loaded addons changed, create new memoryTable for all addons |
memoryTable = {} |
for i = 1, addOnCount do |
memoryTable[i] = { i, select(2, GetAddOnInfo(i)), 0, IsAddOnLoaded(i) } |
end |
self:SetAllPoints(Text) |
end |
local function UpdateMemory() |
-- Update the memory usages of the addons |
UpdateAddOnMemoryUsage() |
-- Load memory usage in table |
local addOnMem = 0 |
local totalMemory = 0 |
for i = 1, #memoryTable do |
addOnMem = GetAddOnMemoryUsage(memoryTable[i][1]) |
memoryTable[i][3] = addOnMem |
totalMemory = totalMemory + addOnMem |
end |
-- Sort the table to put the largest addon on top |
table.sort(memoryTable, function(a, b) |
if a and b then |
return a[3] > b[3] |
end |
end) |
return totalMemory |
end |
-- initial delay for update (let the ui load) |
local int, int2 = 6, 5 |
local statusColors = { |
"|cff0CD809", |
"|cffE8DA0F", |
"|cffFF9000", |
"|cffD80909" |
} |
local function Update(self, t) |
int = int - t |
int2 = int2 - t |
if int < 0 then |
RebuildAddonList(self) |
int = 10 |
end |
if int2 < 0 then |
local framerate = floor(GetFramerate()) |
local fpscolor = 4 |
local latency = select(4, GetNetStats()) |
local latencycolor = 4 |
if latency < 150 then |
latencycolor = 1 |
elseif latency >= 150 and latency < 300 then |
latencycolor = 2 |
elseif latency >= 300 and latency < 500 then |
latencycolor = 3 |
end |
if framerate >= 30 then |
fpscolor = 1 |
elseif framerate >= 20 and framerate < 30 then |
fpscolor = 2 |
elseif framerate >= 10 and framerate < 20 then |
fpscolor = 3 |
end |
local displayFormat = string.join("", hexa.."FPS: "..hexb, statusColors[fpscolor], "%d|r", hexa.." MS: "..hexb, statusColors[latencycolor], "%d|r") |
Text:SetFormattedText(displayFormat, framerate, latency) |
int2 = 1 |
end |
end |
Stat:SetScript("OnMouseDown", function () collectgarbage("collect") Update(Stat, 20) end) |
Stat:SetScript("OnEnter", function(self) |
if InCombatLockdown() then return end |
local bandwidth = GetAvailableBandwidth() |
local _, _, latencyHome, latencyWorld = GetNetStats() |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Latency") |
GameTooltip:AddLine' ' |
if C['datatext'].fps.enable == true then |
if C['datatext'].fps.home == true then |
GameTooltip:AddDoubleLine("Home Latency: ", string.format(homeLatencyString, latencyHome), 0.80, 0.31, 0.31,0.84, 0.75, 0.65) |
elseif C['datatext'].fps.world == true then |
GameTooltip:AddDoubleLine("World Latency: ", string.format(worldLatencyString, latencyWorld), 0.80, 0.31, 0.31,0.84, 0.75, 0.65) |
elseif C['datatext'].fps.both == true then |
GameTooltip:AddDoubleLine("Home Latency: ", string.format(homeLatencyString, latencyHome), 0.80, 0.31, 0.31,0.84, 0.75, 0.65) |
GameTooltip:AddDoubleLine("World Latency: ", string.format(worldLatencyString, latencyWorld), 0.80, 0.31, 0.31,0.84, 0.75, 0.65) |
end |
end |
if bandwidth ~= 0 then |
GameTooltip:AddDoubleLine(L.datatext_bandwidth , string.format(bandwidthString, bandwidth),0.69, 0.31, 0.31,0.84, 0.75, 0.65) |
GameTooltip:AddDoubleLine("Download: " , string.format(percentageString, GetDownloadedPercentage() *100),0.69, 0.31, 0.31, 0.84, 0.75, 0.65) |
GameTooltip:AddLine(" ") |
end |
local totalMemory = UpdateMemory() |
GameTooltip:AddDoubleLine("Total Memory Usage:", formatMem(totalMemory), 0.69, 0.31, 0.31,0.84, 0.75, 0.65) |
GameTooltip:AddLine(" ") |
for i = 1, #memoryTable do |
if (memoryTable[i][4]) then |
local red = memoryTable[i][3] / totalMemory |
local green = 1 - red |
GameTooltip:AddDoubleLine(memoryTable[i][2], formatMem(memoryTable[i][3]), 1, 1, 1, red, green + .5, 0) |
end |
end |
GameTooltip:Show() |
end) |
Stat:SetScript("OnLeave", function() GameTooltip:Hide() end) |
Stat:SetScript("OnUpdate", Update) |
Update(Stat, 10) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import: S - function; C - config; Soop - Database |
--[[ |
All Credit for Positions.lua goes to Tuks. |
Tukui = http://www.tukui.org/download.php. |
]] |
if C['datatext'].enable ~= true then return end |
-- Datatext Positions |
S.PP = function(p, obj) |
local left = PanelLeft |
local center = PanelCenter |
local right = PanelRight |
-- Left Panel Data |
if p == 1 then |
obj:SetParent(left) |
obj:SetHeight(left:GetHeight()) |
obj:SetPoint('LEFT', left, 5, 0) |
obj:SetPoint('TOP', left) |
obj:SetPoint('BOTTOM', left) |
elseif p == 2 then |
obj:SetParent(left) |
obj:SetHeight(left:GetHeight()) |
obj:SetPoint('TOP', left) |
obj:SetPoint('BOTTOM', left) |
elseif p == 3 then |
obj:SetParent(left) |
obj:SetHeight(left:GetHeight()) |
obj:SetPoint('RIGHT', left, 0, 0) |
obj:SetPoint('TOP', left) |
obj:SetPoint('BOTTOM', left) |
-- Center Panel Data |
elseif p == 4 then |
obj:SetParent(center) |
obj:SetHeight(center:GetHeight()) |
obj:SetPoint('LEFT', center, 5, 0) |
obj:SetPoint('TOP', center) |
obj:SetPoint('BOTTOM', center) |
elseif p == 5 then |
obj:SetParent(center) |
obj:SetHeight(center:GetHeight()) |
obj:SetPoint('LEFT', center, 60, 0) |
obj:SetPoint('TOP', center) |
obj:SetPoint('BOTTOM', center) |
elseif p == 6 then |
obj:SetParent(center) |
obj:SetHeight(center:GetHeight()) |
obj:SetPoint('RIGHT', center, 45, 0) |
obj:SetPoint('TOP', center) |
obj:SetPoint('BOTTOM', center) |
-- Right Panel Data |
elseif p == 7 then |
obj:SetParent(right) |
obj:SetHeight(right:GetHeight()) |
obj:SetPoint('LEFT', right, 50, 0) |
obj:SetPoint('TOP', right) |
obj:SetPoint('BOTTOM', right) |
elseif p == 8 then |
obj:SetParent(right) |
obj:SetHeight(right:GetHeight()) |
obj:SetPoint('RIGHT', right, 80, 0) |
obj:SetPoint('TOP', right) |
obj:SetPoint('BOTTOM', right) |
elseif p == 9 then |
obj:SetParent(right) |
obj:SetHeight(right:GetHeight()) |
obj:SetPoint('RIGHT', right, -10, 0) |
obj:SetPoint('TOP', right) |
obj:SetPoint('BOTTOM', right) |
end |
end |
S.DataTextTooltipAnchor = function(self) |
local panel = self:GetParent() |
local anchor = 'GameTooltip' |
local xoff = 1 |
local yoff = 3 |
for _, panel in pairs ({ |
PanelLeft, |
PanelCenter, |
PanelRight, |
}) do |
if C['datatext'].top == true then |
anchor = 'ANCHOR_BOTTOM' |
else |
anchor = 'ANCHOR_TOP' |
end |
end |
return anchor, panel, xoff, yoff |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Coords Datapanel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].coords and C['datatext'].coords > 0 then |
local Stat = CreateFrame("Frame") |
Stat:EnableMouse(true) |
Stat:SetFrameStrata('BACKGROUND') |
Stat:SetFrameLevel(3) |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].coords, Text) |
local function Update(self) |
local px,py=GetPlayerMapPosition("player") |
Text:SetText(format("%i , %i",px*100,py*100)) |
end |
Stat:SetScript("OnUpdate", Update) |
Update(Stat, 10) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Data Panel (originally by Tuks of Tukui.org) |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
local DataPanel = CreateFrame('Frame', 'DataPanel', UIParent) |
local PanelLeft = CreateFrame('Frame', 'PanelLeft', UIParent) |
local PanelCenter = CreateFrame('Frame', 'PanelCenter', UIParent) |
local PanelRight = CreateFrame('Frame', 'PanelRight', UIParent) |
local BattleGroundPanel = CreateFrame('Frame', 'BattleGroundPanel', UIParent) |
if C['datatext'].top == true then |
DataPanel:SetPoint('TOP', UIParent, 0, 0) |
DataPanel:SetHeight(30) |
DataPanel:SetWidth(S.getscreenwidth / 6) |
DataPanel:SetFrameStrata('LOW') |
DataPanel:SetFrameLevel(0) |
DataPanel:SetBackdrop({ |
bgFile = C['datatext'].background, |
edgeFile = C['datatext'].border, |
tile = true, tileSize = 16, edgeSize = 14, |
insets = {left = 15, right = 15, top = 2, bottom = 2}, |
}) |
if C['datatext'].border == "fer09" then |
if C['general'].classcolor ~= true then |
DataPanel:SetBackdropBorderColor(C['general'].color.r,C['general'].color.g,C['general'].color.b) |
else |
DataPanel:SetBackdropBorderColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
end |
else |
DataPanel:SetBackdropBorderColor(1, 1, 1) |
end |
-- Left Panel |
PanelLeft:SetPoint('LEFT', DataPanel, 5, 0) |
PanelLeft:SetHeight(30) |
PanelLeft:SetWidth(S.getscreenwidth / 6) |
PanelLeft:SetFrameStrata('LOW') |
PanelLeft:SetFrameLevel(1) |
-- Center Panel |
PanelCenter:SetPoint('CENTER', DataPanel, 0, 0) |
PanelCenter:SetHeight(30) |
PanelCenter:SetWidth(S.getscreenwidth / 6) |
PanelCenter:SetFrameStrata('LOW') |
PanelCenter:SetFrameLevel(1) |
-- Right Panel |
PanelRight:SetPoint('RIGHT', DataPanel, -5, 0) |
PanelRight:SetHeight(30) |
PanelRight:SetWidth(S.getscreenwidth / 6) |
PanelRight:SetFrameStrata('LOW') |
PanelRight:SetFrameLevel(1) |
-- Battleground Panel |
BattleGroundPanel:SetAllPoints(PanelLeft) |
BattleGroundPanel:SetFrameStrata('LOW') |
BattleGroundPanel:SetFrameLevel(1) |
else |
DataPanel:SetPoint('BOTTOM', UIParent, 40, -5) |
DataPanel:SetHeight(30) |
DataPanel:SetWidth(560) |
DataPanel:SetFrameStrata('LOW') |
DataPanel:SetFrameLevel(0) |
DataPanel:SetBackdrop({ |
bgFile = C['datatext'].background, |
edgeFile = C['datatext'].border, |
tile = true, tileSize = 16, edgeSize = 5, |
insets = {left = 3, right = 3, top = 3, bottom = 3} |
}) |
DataPanel:SetBackdropColor(1, 0, 0, 0) |
if C['datatext'].border == "edgeFile" then |
if C['general'].classcolor ~= true then |
DataPanel:SetBackdropBorderColor(C['general'].color.r,C['general'].color.g,C['general'].color.b) |
else |
DataPanel:SetBackdropBorderColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
end |
else |
DataPanel:SetBackdropBorderColor(0, 0, 0, 1) |
DataPanel:SetAlpha(.60) |
end |
-- Left Panel |
PanelLeft:SetPoint('LEFT', DataPanel, 68, 0) |
PanelLeft:SetHeight(30) |
PanelLeft:SetWidth(560 / 3) |
PanelLeft:SetFrameStrata('LOW') |
PanelLeft:SetFrameLevel(1) |
-- -- Center Panel |
PanelCenter:SetPoint('CENTER', DataPanel, 0, 0) |
PanelCenter:SetHeight(30) |
PanelCenter:SetWidth(560 / 3) |
PanelCenter:SetFrameStrata('LOW') |
PanelCenter:SetFrameLevel(1) |
-- Right panel |
PanelRight:SetPoint('RIGHT', DataPanel, -5, 0) |
PanelRight:SetHeight(30) |
PanelRight:SetWidth(560 / 3) |
PanelRight:SetFrameStrata('LOW') |
PanelRight:SetFrameLevel(1) |
-- Battleground Panel |
BattleGroundPanel:SetAllPoints(PanelLeft) |
BattleGroundPanel:SetFrameStrata('LOW') |
BattleGroundPanel:SetFrameLevel(1) |
end |
-- move some frames to make way for the datapanel |
if C['datatext'].top == true then |
local top = function() end |
PlayerFrame:ClearAllPoints() PlayerFrame:SetPoint("TOPLEFT", -19, -20) PlayerFrame.ClearAllPoints = top PlayerFrame.SetPoint = top |
TargetFrame:ClearAllPoints() TargetFrame:SetPoint("TOPLEFT", 250, -20) TargetFrame.ClearAllPoints = top TargetFrame.SetPoint = top |
MinimapCluster:ClearAllPoints() MinimapCluster:SetPoint('TOPRIGHT', 0, -32) MinimapCluster.ClearAllPoints = top MinimapCluster.SetPoint = top |
BuffFrame:ClearAllPoints() BuffFrame:SetPoint('TOP', MinimapCluster, -110, -2) BuffFrame.ClearAllPoints = top BuffFrame.SetPoint = top |
WorldStateAlwaysUpFrame:ClearAllPoints() WorldStateAlwaysUpFrame:SetPoint('TOP', 0, -32) WorldStateAlwaysUpFrame.ClearAllpoints = top WorldStateAlwaysUpFrame.Setpoint = top |
else |
-- Move the Bags above the Actionbar |
CONTAINER_WIDTH = 192; |
CONTAINER_SPACING = 5; |
VISIBLE_CONTAINER_SPACING = 3; |
CONTAINER_OFFSET_Y = 70; |
CONTAINER_OFFSET_X = 0; |
function UpdateContainerFrameAnchors() |
local _, xOffset, yOffset, _, _, _, _; |
local containerScale = 1; |
screenHeight = GetScreenHeight() / containerScale; |
-- Adjust the start anchor for bags depending on the multibars |
xOffset = CONTAINER_OFFSET_X / containerScale; |
yOffset = CONTAINER_OFFSET_Y / containerScale + 25; |
-- freeScreenHeight determines when to start a new column of bags |
freeScreenHeight = screenHeight - yOffset; |
column = 0; |
for index, frameName in ipairs(ContainerFrame1.bags) do |
frame = _G[frameName]; |
frame:SetScale(containerScale); |
if ( index == 1 ) then |
-- First bag |
frame:SetPoint('BOTTOMRIGHT', frame:GetParent(), 'BOTTOMRIGHT', -xOffset, yOffset ); |
elseif ( freeScreenHeight < frame:GetHeight() ) then |
-- Start a new column |
column = column + 1; |
freeScreenHeight = screenHeight - yOffset; |
frame:SetPoint('BOTTOMRIGHT', frame:GetParent(), 'BOTTOMRIGHT', -(column * CONTAINER_WIDTH) - xOffset, yOffset ); |
else |
-- Anchor to the previous bag |
frame:SetPoint('BOTTOMRIGHT', ContainerFrame1.bags[index - 1], 'TOPRIGHT', 0, CONTAINER_SPACING); |
end |
freeScreenHeight = freeScreenHeight - frame:GetHeight() - VISIBLE_CONTAINER_SPACING; |
end |
end |
-- Move some stuff for the panel on bottom. |
local bottom = function() end |
MainMenuBar:ClearAllPoints() MainMenuBar:SetPoint("BOTTOM", DataPanel, "TOP", 0, -3) MainMenuBar.ClearAllPoints = bottom MainMenuBar.SetPoint = bottom |
PetBattleFrame.BottomFrame:ClearAllPoints() PetBattleFrame.BottomFrame:SetPoint("BOTTOM", DataPanel, "TOP", 0, -3) PetBattleFrame.BottomFrame.ClearAllPoints = bottom PetBattleFrame.BottomFrame.SetPoint = bottom |
OverrideActionBar:ClearAllPoints() OverrideActionBar:SetPoint("BOTTOM", DataPanel, "TOP", 0, -3) OverrideActionBar.ClearAllPoints = bottom OverrideActionBar.SetPoint = bottom |
PetActionBarFrame:ClearAllPoints() PetActionBarFrame:SetPoint("BOTTOM", MainMenuBar, "TOP", 40, 47) PetActionBarFrame.ClearAllPoints = bottom PetActionBarFrame.SetPoint = bottom |
WorldStateAlwaysUpFrame:ClearAllPoints() WorldStateAlwaysUpFrame:SetPoint('TOP', -20, -40) WorldStateAlwaysUpFrame.ClearAllpoints = bottom WorldStateAlwaysUpFrame.Setpoint = bottom |
BuffFrame:ClearAllPoints() BuffFrame:SetPoint('TOP', MinimapCluster, -110, -15) BuffFrame.ClearAllPoints = bottom BuffFrame.SetPoint = bottom |
-- Move the tooltip above the Actionbar |
if C["tooltip"].enable == true then |
hooksecurefunc('GameTooltip_SetDefaultAnchor', function(self) |
self:SetPoint('BOTTOMRIGHT', UIParent, -95, 135) |
end) |
end |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- BG Datapanel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].battleground == true then |
--Map IDs |
local WSG = 443 |
local TP = 626 |
local AV = 401 |
local SOTA = 512 |
local IOC = 540 |
local EOTS = 482 |
local TBFG = 736 |
local AB = 461 |
local bgframe = BattleGroundPanel |
bgframe:SetScript('OnEnter', function(self) |
local numScores = GetNumBattlefieldScores() |
for i=1, numScores do |
local name, killingBlows, honorableKills, deaths, honorGained, faction, race, class, classToken, damageDone, healingDone, bgRating, ratingChange = GetBattlefieldScore(i) |
if ( name ) then |
if ( name == UnitName('player') ) then |
GameTooltip:SetOwner(self, 'ANCHOR_TOPLEFT', 0, 4) |
GameTooltip:ClearLines() |
GameTooltip:SetPoint('BOTTOM', self, 'TOP', 0, 1) |
GameTooltip:ClearLines() |
GameTooltip:AddLine("Stats for : "..hexa..name..hexb) |
GameTooltip:AddLine' ' |
GameTooltip:AddDoubleLine("Killing Blows:", killingBlows,1,1,1) |
GameTooltip:AddDoubleLine("Honorable Kills:", honorableKills,1,1,1) |
GameTooltip:AddDoubleLine("Deaths:", deaths,1,1,1) |
GameTooltip:AddDoubleLine("Honor Gained:", format('%d', honorGained),1,1,1) |
GameTooltip:AddDoubleLine("Damage Done:", damageDone,1,1,1) |
GameTooltip:AddDoubleLine("Healing Done:", healingDone,1,1,1) |
--Add extra statistics to watch based on what BG you are in. |
if curmapid == WSG or curmapid == TP then |
GameTooltip:AddDoubleLine("Flags Captured:",GetBattlefieldStatData(i, 1),1,1,1) |
GameTooltip:AddDoubleLine("Flags Returned:",GetBattlefieldStatData(i, 2),1,1,1) |
elseif curmapid == EOTS then |
GameTooltip:AddDoubleLine("Flags Captured:",GetBattlefieldStatData(i, 1),1,1,1) |
elseif curmapid == AV then |
GameTooltip:AddDoubleLine("Graveyards Assaulted:",GetBattlefieldStatData(i, 1),1,1,1) |
GameTooltip:AddDoubleLine("Graveyards Defended:",GetBattlefieldStatData(i, 2),1,1,1) |
GameTooltip:AddDoubleLine("Towers Assaulted:",GetBattlefieldStatData(i, 3),1,1,1) |
GameTooltip:AddDoubleLine("Towers Defended:",GetBattlefieldStatData(i, 4),1,1,1) |
elseif curmapid == SOTA then |
GameTooltip:AddDoubleLine("Demolishers Destroyed:",GetBattlefieldStatData(i, 1),1,1,1) |
GameTooltip:AddDoubleLine("Gates Destroyed:",GetBattlefieldStatData(i, 2),1,1,1) |
elseif curmapid == IOC or curmapid == TBFG or curmapid == AB then |
GameTooltip:AddDoubleLine("Bases Assaulted:",GetBattlefieldStatData(i, 1),1,1,1) |
GameTooltip:AddDoubleLine("Bases Defended:",GetBattlefieldStatData(i, 2),1,1,1) |
end |
GameTooltip:Show() |
end |
end |
end |
end) |
bgframe:SetScript('OnLeave', function(self) GameTooltip:Hide() end) |
local Stat = CreateFrame('Frame') |
Stat:EnableMouse(true) |
local Text1 = BattleGroundPanel:CreateFontString(nil, 'OVERLAY') |
Text1:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
Text1:SetPoint('LEFT', BattleGroundPanel, 30, 0) |
Text1:SetHeight(DataPanel:GetHeight()) |
local Text2 = BattleGroundPanel:CreateFontString(nil, 'OVERLAY') |
Text2:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
Text2:SetPoint('CENTER', BattleGroundPanel, 0, 0) |
Text2:SetHeight(DataPanel:GetHeight()) |
local Text3 = BattleGroundPanel:CreateFontString(nil, 'OVERLAY') |
Text3:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
Text3:SetPoint('RIGHT', BattleGroundPanel, -30, 0) |
Text3:SetHeight(DataPanel:GetHeight()) |
local int = 2 |
local function Update(self, t) |
int = int - t |
if int < 0 then |
local dmgtxt |
RequestBattlefieldScoreData() |
local numScores = GetNumBattlefieldScores() |
for i=1, numScores do |
local name, killingBlows, honorableKills, deaths, honorGained, faction, race, class, classToken, damageDone, healingDone, bgRating, ratingChange = GetBattlefieldScore(i) |
if healingDone > damageDone then |
dmgtxt = ("Healing : "..hexa..healingDone..hexb) |
else |
dmgtxt = ("Damage : "..hexa..damageDone..hexb) |
end |
if ( name ) then |
if ( name == myname ) then |
Text2:SetText("Honor : "..hexa..format('%d', honorGained)..hexb) |
Text1:SetText(dmgtxt) |
Text3:SetText("Killing Blows : "..hexa..killingBlows..hexb) |
end |
end |
end |
int = 0 |
end |
end |
--hide text when not in an bg |
local function OnEvent(self, event) |
if event == 'PLAYER_ENTERING_WORLD' then |
local inInstance, instanceType = IsInInstance() |
if inInstance and (instanceType == 'pvp') then |
bgframe:Show() |
PanelLeft:Hide() |
else |
Text1:SetText('') |
Text2:SetText('') |
Text3:SetText('') |
bgframe:Hide() |
PanelLeft:Show() |
end |
end |
end |
Stat:RegisterEvent('PLAYER_ENTERING_WORLD') |
Stat:SetScript('OnEvent', OnEvent) |
Stat:SetScript('OnUpdate', Update) |
Update(Stat, 10) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Friends Data Panel |
-------------------------------------------------------------- |
if not C["datatext"].friends or C["datatext"].friends == 0 then return end |
-- create a popup |
StaticPopupDialogs["SET_BN_BROADCAST"] = { |
text = BN_BROADCAST_TOOLTIP, |
button1 = ACCEPT, |
button2 = CANCEL, |
hasEditBox = 1, |
editBoxWidth = 350, |
maxLetters = 127, |
OnAccept = function(self) BNSetCustomMessage(self.editBox:GetText()) end, |
OnShow = function(self) self.editBox:SetText(select(3, BNGetInfo()) ) self.editBox:SetFocus() end, |
OnHide = ChatEdit_FocusActiveWindow, |
EditBoxOnEnterPressed = function(self) BNSetCustomMessage(self:GetText()) self:GetParent():Hide() end, |
EditBoxOnEscapePressed = function(self) self:GetParent():Hide() end, |
timeout = 0, |
exclusive = 1, |
whileDead = 1, |
hideOnEscape = 1 |
} |
-- localized references for global functions (about 50% faster) |
local join = string.join |
local find = string.find |
local format = string.format |
local split = string.split |
local sort = table.sort |
local insert = table.insert |
local sizeof = table.getn |
-- for datatext display |
local displayString = join("", hexa.."%s: "..hexb, "|cffffffff", "%d|r") |
local Stat = CreateFrame("Frame") |
Stat:EnableMouse(true) |
Stat:SetFrameStrata("MEDIUM") |
Stat:SetFrameLevel(3) |
local Text = DataPanel:CreateFontString(nil, "OVERLAY") |
Text:SetFont(C["media"].font, C["datatext"].fontsize,'THINOUTLINE') |
S.PP(C["datatext"].friends, Text) |
local menuFrame = CreateFrame("Frame", "FriendRightClickMenu", UIParent, "UIDropDownMenuTemplate") |
local menuList = { |
{ text = OPTIONS_MENU, isTitle = true,notCheckable=true}, |
{ text = INVITE, hasArrow = true,notCheckable=true, }, |
{ text = CHAT_MSG_WHISPER_INFORM, hasArrow = true,notCheckable=true, }, |
{ text = PLAYER_STATUS, hasArrow = true, notCheckable=true, |
menuList = { |
{ text = "|cff2BC226"..AVAILABLE.."|r", notCheckable=true, func = function() if IsChatAFK() then SendChatMessage("", "AFK") elseif IsChatDND() then SendChatMessage("", "DND") end end }, |
{ text = "|cffE7E716"..DND.."|r", notCheckable=true, func = function() if not IsChatDND() then SendChatMessage("", "DND") end end }, |
{ text = "|cffFF0000"..AFK.."|r", notCheckable=true, func = function() if not IsChatAFK() then SendChatMessage("", "AFK") end end }, |
}, |
}, |
{ text = BN_BROADCAST_TOOLTIP, notCheckable=true, func = function() StaticPopup_Show("SET_BN_BROADCAST") end }, |
} |
local function GetTableIndex(table, fieldIndex, value) |
for k,v in ipairs(table) do |
if v[fieldIndex] == value then return k end |
end |
return -1 |
end |
local function inviteClick(self, arg1, arg2, checked) |
menuFrame:Hide() |
if type(arg1) ~= 'number' then |
InviteUnit(arg1) |
else |
BNInviteFriend(arg1); |
end |
end |
local function whisperClick(self,name,bnet) |
menuFrame:Hide() |
if bnet then |
ChatFrame_SendSmartTell(name) |
else |
SetItemRef( "player:"..name, ("|Hplayer:%1$s|h[%1$s]|h"):format(name), "LeftButton" ) |
end |
end |
local levelNameString = "|cff%02x%02x%02x%d|r |cff%02x%02x%02x%s|r" |
local clientLevelNameString = "%s (|cff%02x%02x%02x%d|r |cff%02x%02x%02x%s|r%s) |cff%02x%02x%02x%s|r" |
local levelNameClassString = "|cff%02x%02x%02x%d|r %s%s%s" |
local worldOfWarcraftString = "World of Warcraft" |
local battleNetString = "Battle.NET" |
local wowString = "WoW" |
local totalOnlineString = "Online:" .. "%s/%s" |
local tthead, ttsubh, ttoff = {r=0.4, g=0.78, b=1}, {r=0.75, g=0.9, b=1}, {r=.3,g=1,b=.3} |
local activezone, inactivezone = {r=0.3, g=1.0, b=0.3}, {r=0.65, g=0.65, b=0.65} |
local displayString = string.join("", "%s ", "%d|r") |
local statusTable = { "|cffff0000[AFK]|r", "|cffff0000[DND]|r", "" } |
local groupedTable = { "|cffaaaaaa*|r", "" } |
local friendTable, BNTable = {}, {} |
local totalOnline, BNTotalOnline = 0, 0 |
local function BuildFriendTable(total) |
totalOnline = 0 |
wipe(friendTable) |
local name, level, class, area, connected, status, note |
for i = 1, total do |
name, level, class, area, connected, status, note = GetFriendInfo(i) |
for k,v in pairs(LOCALIZED_CLASS_NAMES_MALE) do if class == v then class = k end end |
if status == "<"..AFK..">" then |
status = "|cffff0000[AFK]|r" |
elseif status == "<"..DND..">" then |
status = "|cffff0000[DND]|r" |
end |
friendTable[i] = { name, level, class, area, connected, status, note } |
if connected then totalOnline = totalOnline + 1 end |
end |
end |
local function UpdateFriendTable(total) |
totalOnline = 0 |
local name, level, class, area, connected, status, note |
for i = 1, #friendTable do |
name, level, class, area, connected, status, note = GetFriendInfo(i) |
for k,v in pairs(LOCALIZED_CLASS_NAMES_MALE) do if class == v then class = k end end |
-- get the correct index in our table |
local index = GetTableIndex(friendTable, 1, name) |
-- we cannot find a friend in our table, so rebuild it |
if index == -1 then |
BuildFriendTable(total) |
break |
end |
-- update on-line status for all members |
friendTable[index][5] = connected |
-- update information only for on-line members |
if connected then |
friendTable[index][2] = level |
friendTable[index][3] = class |
friendTable[index][4] = area |
friendTable[index][6] = status |
friendTable[index][7] = note |
totalOnline = totalOnline + 1 |
end |
end |
end |
local function BuildBNTable(total) |
BNTotalOnline = 0 |
wipe(BNTable) |
for i = 1, total do |
local presenceID, presenceName, battleTag, isBattleTagPresence, toonName, toonID, client, isOnline, lastOnline, isAFK, isDND, messageText, noteText, isRIDFriend, messageTime, canSoR = BNGetFriendInfo(i) |
local hasFocus, _, _, realmName, realmID, faction, race, class, guild, zoneName, level, gameText = BNGetToonInfo(presenceID) |
for k,v in pairs(LOCALIZED_CLASS_NAMES_MALE) do if class == v then class = k end end |
BNTable[i] = { presenceID, presenceName, battleTag, toonName, toonID, client, isOnline, isAFK, isDND, noteText, realmName, faction, race, class, zoneName, level } |
if isOnline then BNTotalOnline = BNTotalOnline + 1 end |
end |
end |
local function UpdateBNTable(total) |
BNTotalOnline = 0 |
for i = 1, #BNTable do |
-- get guild roster information |
local presenceID, presenceName, battleTag, isBattleTagPresence, toonName, toonID, client, isOnline, lastOnline, isAFK, isDND, messageText, noteText, isRIDFriend, messageTime, canSoR = BNGetFriendInfo(i) |
local hasFocus, _, _, realmName, realmID, faction, race, class, guild, zoneName, level, gameText = BNGetToonInfo(presenceID) |
for k,v in pairs(LOCALIZED_CLASS_NAMES_MALE) do if class == v then class = k end end |
-- get the correct index in our table |
local index = GetTableIndex(BNTable, 1, presenceID) |
-- we cannot find a BN member in our table, so rebuild it |
if index == -1 then |
BuildBNTable(total) |
return |
end |
-- update on-line status for all members |
BNTable[index][7] = isOnline |
-- update information only for on-line members |
if isOnline then |
BNTable[index][2] = presenceName |
BNTable[index][3] = battleTag |
BNTable[index][4] = toonName |
BNTable[index][5] = toonID |
BNTable[index][6] = client |
BNTable[index][8] = isAFK |
BNTable[index][9] = isDND |
BNTable[index][10] = noteText |
BNTable[index][11] = realmName |
BNTable[index][12] = faction |
BNTable[index][13] = race |
BNTable[index][14] = class |
BNTable[index][15] = zoneName |
BNTable[index][16] = level |
BNTotalOnline = BNTotalOnline + 1 |
end |
end |
end |
Stat:SetScript("OnMouseUp", function(self, btn) |
if btn ~= "RightButton" then return end |
GameTooltip:Hide() |
local menuCountWhispers = 0 |
local menuCountInvites = 0 |
local classc, levelc |
menuList[2].menuList = {} |
menuList[3].menuList = {} |
if totalOnline > 0 then |
for i = 1, #friendTable do |
if (friendTable[i][5]) then |
menuCountInvites = menuCountInvites + 1 |
menuCountWhispers = menuCountWhispers + 1 |
classc, levelc = (CUSTOM_CLASS_COLORS or RAID_CLASS_COLORS)[friendTable[i][3]], GetQuestDifficultyColor(friendTable[i][2]) |
if classc == nil then classc = GetQuestDifficultyColor(friendTable[i][2]) end |
menuList[2].menuList[menuCountInvites] = {text = format(levelNameString,levelc.r*255,levelc.g*255,levelc.b*255,friendTable[i][2],classc.r*255,classc.g*255,classc.b*255,friendTable[i][1]), arg1 = friendTable[i][1],notCheckable=true, func = inviteClick} |
menuList[3].menuList[menuCountWhispers] = {text = format(levelNameString,levelc.r*255,levelc.g*255,levelc.b*255,friendTable[i][2],classc.r*255,classc.g*255,classc.b*255,friendTable[i][1]), arg1 = friendTable[i][1],notCheckable=true, func = whisperClick} |
end |
end |
end |
if BNTotalOnline > 0 then |
local realID, grouped |
for i = 1, #BNTable do |
if (BNTable[i][7]) then |
realID = BNTable[i][2] |
menuCountWhispers = menuCountWhispers + 1 |
menuList[3].menuList[menuCountWhispers] = {text = realID, arg1 = realID, arg2 = true, notCheckable=true, func = whisperClick} |
if BNTable[i][6] == wowString and UnitFactionGroup("player") == BNTable[i][12] then |
classc, levelc = (CUSTOM_CLASS_COLORS or RAID_CLASS_COLORS)[BNTable[i][14]], GetQuestDifficultyColor(BNTable[i][16]) |
if classc == nil then classc = GetQuestDifficultyColor(BNTable[i][16]) end |
if UnitInParty(BNTable[i][4]) or UnitInRaid(BNTable[i][4]) then grouped = 1 else grouped = 2 end |
menuCountInvites = menuCountInvites + 1 |
menuList[2].menuList[menuCountInvites] = {text = format(levelNameString,levelc.r*255,levelc.g*255,levelc.b*255,BNTable[i][16],classc.r*255,classc.g*255,classc.b*255,BNTable[i][4]), arg1 = BNTable[i][5],notCheckable=true, func = inviteClick} |
end |
end |
end |
end |
EasyMenu(menuList, menuFrame, "cursor", 0, 0, "MENU", 2) |
end) |
local function Update(self, event) |
if event == "BN_FRIEND_INFO_CHANGED" or "BN_FRIEND_ACCOUNT_ONLINE" or "BN_FRIEND_ACCOUNT_OFFLINE" or "BN_TOON_NAME_UPDATED" |
or "BN_FRIEND_TOON_ONLINE" or "BN_FRIEND_TOON_OFFLINE" or "PLAYER_ENTERING_WORLD" then |
local BNTotal = BNGetNumFriends() |
if BNTotal == #BNTable then |
UpdateBNTable(BNTotal) |
else |
BuildBNTable(BNTotal) |
end |
end |
if event == "FRIENDLIST_UPDATE" or "PLAYER_ENTERING_WORLD" then |
local total = GetNumFriends() |
if total == #friendTable then |
UpdateFriendTable(total) |
else |
BuildFriendTable(total) |
end |
end |
Text:SetFormattedText(displayString, hexa.."Friends:"..hexb, totalOnline + BNTotalOnline) |
self:SetAllPoints(Text) |
end |
Stat:SetScript("OnMouseDown", function(self, btn) if btn == "LeftButton" then ToggleFriendsFrame(1) end end) |
Stat:SetScript("OnEnter", function(self) |
if InCombatLockdown() then return end |
local totalonline = totalOnline + BNTotalOnline |
local totalfriends = #friendTable + #BNTable |
local zonec, classc, levelc, realmc, grouped |
if totalonline > 0 then |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Friends") |
GameTooltip:AddLine' ' |
GameTooltip:AddLine( format(totalOnlineString, totalonline, totalfriends),tthead.r,tthead.g,tthead.b) |
if totalOnline > 0 then |
GameTooltip:AddLine(' ') |
GameTooltip:AddLine(worldOfWarcraftString) |
for i = 1, #friendTable do |
if friendTable[i][5] then |
if GetRealZoneText() == friendTable[i][4] then zonec = activezone else zonec = inactivezone end |
classc, levelc = (CUSTOM_CLASS_COLORS or RAID_CLASS_COLORS)[friendTable[i][3]], GetQuestDifficultyColor(friendTable[i][2]) |
if classc == nil then classc = GetQuestDifficultyColor(friendTable[i][2]) end |
if UnitInParty(friendTable[i][1]) or UnitInRaid(friendTable[i][1]) then grouped = 1 else grouped = 2 end |
GameTooltip:AddDoubleLine(format(levelNameClassString,levelc.r*255,levelc.g*255,levelc.b*255,friendTable[i][2],friendTable[i][1],groupedTable[grouped]," "..friendTable[i][6]),friendTable[i][4],classc.r,classc.g,classc.b,zonec.r,zonec.g,zonec.b) |
end |
end |
end |
if BNTotalOnline > 0 then |
GameTooltip:AddLine(' ') |
GameTooltip:AddLine(battleNetString) |
local status = 0 |
for i = 1, #BNTable do |
if BNTable[i][7] then |
if BNTable[i][6] == wowString then |
if (BNTable[i][8] == true) then status = 1 elseif (BNTable[i][9] == true) then status = 2 else status = 3 end |
classc, levelc = (CUSTOM_CLASS_COLORS or RAID_CLASS_COLORS)[BNTable[i][14]], GetQuestDifficultyColor(BNTable[i][16]) |
if classc == nil then classc = GetQuestDifficultyColor(BNTable[i][16]) end |
if UnitInParty(BNTable[i][4]) or UnitInRaid(BNTable[i][4]) then grouped = 1 else grouped = 2 end |
GameTooltip:AddDoubleLine(format(clientLevelNameString, BNTable[i][6],levelc.r*255,levelc.g*255,levelc.b*255,BNTable[i][16],classc.r*255,classc.g*255,classc.b*255,BNTable[i][4],groupedTable[grouped], 255, 0, 0, statusTable[status]),BNTable[i][2],238,238,238,238,238,238) |
if IsShiftKeyDown() then |
if GetRealZoneText() == BNTable[i][15] then zonec = activezone else zonec = inactivezone end |
if GetRealmName() == BNTable[i][11] then realmc = activezone else realmc = inactivezone end |
GameTooltip:AddDoubleLine(" ".."Zone: "..BNTable[i][15], "Realm: "..BNTable[i][11], zonec.r, zonec.g, zonec.b, realmc.r, realmc.g, realmc.b) |
end |
else |
GameTooltip:AddDoubleLine("|cffeeeeee"..BNTable[i][6].." ("..BNTable[i][4]..")|r", "|cffeeeeee"..BNTable[i][2].."|r") |
end |
end |
end |
end |
GameTooltip:AddLine' ' |
GameTooltip:AddLine("|cffeda55fLeft Click|r to Open Friend Panel") |
GameTooltip:AddLine("|cffeda55fHold Shift & Mouseover|r to See Friend's Zone/Realm") |
GameTooltip:AddLine("|cffeda55fRight Click|r to open Options Menu") |
GameTooltip:Show() |
else |
GameTooltip:Hide() |
end |
end) |
Stat:RegisterEvent("BN_FRIEND_ACCOUNT_ONLINE") |
Stat:RegisterEvent("BN_FRIEND_ACCOUNT_OFFLINE") |
Stat:RegisterEvent("BN_FRIEND_INFO_CHANGED") |
Stat:RegisterEvent("BN_FRIEND_TOON_ONLINE") |
Stat:RegisterEvent("BN_FRIEND_TOON_OFFLINE") |
Stat:RegisterEvent("BN_TOON_NAME_UPDATED") |
Stat:RegisterEvent("FRIENDLIST_UPDATE") |
Stat:RegisterEvent("PLAYER_ENTERING_WORLD") |
Stat:SetScript("OnLeave", function() GameTooltip:Hide() end) |
Stat:SetScript("OnEvent", Update) |
local S, C, Soop = unpack(select(2, ...)) -- Import driver S = Functions C = Config Soop = Database |
-------------------------------------------------------------- |
-- Spec Data Panel |
-------------------------------------------------------------- |
if C['datatext'].enable ~= true then return end |
if C['datatext'].spec and C['datatext'].spec > 0 then |
local Stat = CreateFrame('Frame') |
Stat:EnableMouse(true) |
Stat:SetFrameStrata('BACKGROUND') |
Stat:SetFrameLevel(3) |
local Text = DataPanel:CreateFontString(nil, 'OVERLAY') |
Text:SetFont(C['media'].font, C['datatext'].fontsize,'THINOUTLINE') |
S.PP(C['datatext'].spec, Text) |
local talent = {} |
local active |
local talentString = string.join('', '|cffFFFFFF%s|r ') |
local talentStringTip = string.join('', '|cffFFFFFF%s:|r ') |
local activeString = string.join('', '|cff00FF00' , ACTIVE_PETS, '|r') |
local inactiveString = string.join('', '|cffFF0000', FACTION_INACTIVE, '|r') |
local int = 1 |
local function Update(self, t) |
int = int - t |
if int > 0 or not GetSpecialization () then return end |
active = GetActiveSpecGroup(false, false) |
Text:SetFormattedText(talentString, hexa..select(2, GetSpecializationInfo (GetSpecialization (false, false, active)))..hexb) |
int = 1 |
-- disable script |
self:SetScript('OnUpdate', nil) |
end |
Stat:SetScript('OnEnter', function(self) |
if InCombatLockdown() then return end |
local anchor, panel, xoff, yoff = S.DataTextTooltipAnchor(Text) |
GameTooltip:SetOwner(panel, anchor, xoff, yoff) |
GameTooltip:ClearLines() |
GameTooltip:AddLine(hexa..S.myname.."'s"..hexb.." Spec") |
GameTooltip:AddLine' ' |
for i = 1, GetNumSpecGroups () do |
if GetSpecialization (false, false, i) then |
GameTooltip:AddLine(string.join(' ', string.format(talentStringTip, select(2, GetSpecializationInfo (GetSpecialization (false, false, i)))), (i == active and activeString or inactiveString)),1,1,1) |
end |
end |
GameTooltip:AddLine' ' |
GameTooltip:AddLine("|cffeda55fLeft Click|r to Switch Spec's") |
GameTooltip:AddLine("|cffeda55fRight Click|r to Open Talent Tree") |
GameTooltip:Show() |
end) |
Stat:SetScript('OnLeave', function() GameTooltip:Hide() end) |
local function OnEvent(self, event, ...) |
if event == 'PLAYER_ENTERING_WORLD' then |
self:UnregisterEvent('PLAYER_ENTERING_WORLD') |
end |
-- Setup Talents Tooltip |
self:SetAllPoints(Text) |
-- update datatext |
if event ~= 'PLAYER_ENTERING_WORLD' then |
self:SetScript('OnUpdate', Update) |
end |
end |
Stat:RegisterEvent('PLAYER_ENTERING_WORLD'); |
Stat:RegisterEvent('CHARACTER_POINTS_CHANGED'); |
Stat:RegisterEvent('PLAYER_TALENT_UPDATE'); |
Stat:RegisterEvent('ACTIVE_TALENT_GROUP_CHANGED') |
Stat:RegisterEvent("EQUIPMENT_SETS_CHANGED") |
Stat:SetScript('OnEvent', OnEvent) |
Stat:SetScript('OnUpdate', Update) |
Stat:SetScript("OnMouseDown", function(self, button) |
if button == "LeftButton" then |
SetActiveSpecGroup (active == 1 and 2 or 1) |
elseif button == "RightButton" then |
ToggleTalentFrame() |
end |
end) |
end |
local S, C, Soop = unpack(select(2, ...)) -- Import driver || S = Functions || C = Config || Soop = Database |
if C['chat'].enable ~= true then return end |
-------------------------------------------------------------- |
-- Chat Module |
-------------------------------------------------------------- |
FCF_ResetChatWindows() |
FCF_OpenNewWindow("") |
FCF_DockFrame(ChatFrame2) |
FCF_DockFrame(ChatFrame3) |
FCF_SetLocked(ChatFrame1, 1) |
FCF_SetLocked(ChatFrame2, 1) |
FCF_SetLocked(ChatFrame3, 1) |
FCF_SetLocked(ChatFrame4, 1) |
for i = 1, NUM_CHAT_WINDOWS do |
local frame = _G[format("ChatFrame%s", i)] |
local id = frame:GetID() |
-- set default font size |
FCF_SetChatWindowFontSize(nil, frame, 12) |
-- rename windows general and combat log |
if i == 1 then FCF_SetWindowName(frame, "Social") end |
if i == 2 then FCF_SetWindowName(frame, "Combat") end |
if i == 3 then FCF_SetWindowName(frame, "Loot") end |
if i == 4 then FCF_SetWindowName(frame, "Trade.General") end |
end |
ChatFrame_RemoveAllMessageGroups(ChatFrame1) |
ChatFrame_AddMessageGroup(ChatFrame1, "SAY") |
ChatFrame_AddMessageGroup(ChatFrame1, "EMOTE") |
ChatFrame_AddMessageGroup(ChatFrame1, "YELL") |
ChatFrame_AddMessageGroup(ChatFrame1, "GUILD") |
ChatFrame_AddMessageGroup(ChatFrame1, "OFFICER") |
ChatFrame_AddMessageGroup(ChatFrame1, "GUILD_ACHIEVEMENT") |
ChatFrame_AddMessageGroup(ChatFrame1, "WHISPER") |
ChatFrame_AddMessageGroup(ChatFrame1, "BN_WHISPER") |
ChatFrame_AddMessageGroup(ChatFrame1, "BN_CONVERSATION") |
ChatFrame_AddMessageGroup(ChatFrame1, "BN_INLINE_TOAST_ALERT") |
ChatFrame_AddMessageGroup(ChatFrame1, "MONSTER_SAY") |
ChatFrame_AddMessageGroup(ChatFrame1, "MONSTER_EMOTE") |
ChatFrame_AddMessageGroup(ChatFrame1, "MONSTER_YELL") |
ChatFrame_AddMessageGroup(ChatFrame1, "MONSTER_BOSS_EMOTE") |
ChatFrame_AddMessageGroup(ChatFrame1, "PARTY") |
ChatFrame_AddMessageGroup(ChatFrame1, "PARTY_LEADER") |
ChatFrame_AddMessageGroup(ChatFrame1, "RAID") |
ChatFrame_AddMessageGroup(ChatFrame1, "RAID_LEADER") |
ChatFrame_AddMessageGroup(ChatFrame1, "RAID_WARNING") |
ChatFrame_AddMessageGroup(ChatFrame1, "INSTANCE_CHAT") |
ChatFrame_AddMessageGroup(ChatFrame1, "INSTANCE_CHAT_LEADER") |
ChatFrame_AddMessageGroup(ChatFrame1, "BATTLEGROUND") |
ChatFrame_AddMessageGroup(ChatFrame1, "BATTLEGROUND_LEADER") |
ChatFrame_AddMessageGroup(ChatFrame1, "BG_HORDE") |
ChatFrame_AddMessageGroup(ChatFrame1, "BG_ALLIANCE") |
ChatFrame_AddMessageGroup(ChatFrame1, "BG_NEUTRAL") |
ChatFrame_AddMessageGroup(ChatFrame1, "SYSTEM") |
ChatFrame_AddMessageGroup(ChatFrame1, "ERRORS") |
ChatFrame_AddMessageGroup(ChatFrame1, "AFK") |
ChatFrame_AddMessageGroup(ChatFrame1, "DND") |
ChatFrame_AddMessageGroup(ChatFrame1, "IGNORED") |
ChatFrame_AddMessageGroup(ChatFrame1, "ACHIEVEMENT") |
ChatFrame_AddMessageGroup(ChatFrame1, "COMBAT_FACTION_CHANGE") |
ChatFrame_RemoveAllMessageGroups(ChatFrame3) |
ChatFrame_AddMessageGroup(ChatFrame3, "SKILL") |
ChatFrame_AddMessageGroup(ChatFrame3, "LOOT") |
ChatFrame_AddMessageGroup(ChatFrame3, "MONEY") |
ChatFrame_AddMessageGroup(ChatFrame3, "COMBAT_XP_GAIN") |
ChatFrame_AddMessageGroup(ChatFrame3, "COMBAT_HONOR_GAIN") |
ChatFrame_AddMessageGroup(ChatFrame3, "COMBAT_GUILD_XP_GAIN") |
ChatFrame_RemoveAllMessageGroups(ChatFrame5) |
ChatFrame_AddMessageGroup(ChatFrame5, "General") |
ChatFrame_AddMessageGroup(ChatFrame3, "Trade") |
-- enable classcolor automatically on login and on each character without doing /configure each time. |
ToggleChatColorNamesByClassGroup(true, "SAY") |
ToggleChatColorNamesByClassGroup(true, "EMOTE") |
ToggleChatColorNamesByClassGroup(true, "YELL") |
ToggleChatColorNamesByClassGroup(true, "GUILD") |
ToggleChatColorNamesByClassGroup(true, "OFFICER") |
ToggleChatColorNamesByClassGroup(true, "GUILD_ACHIEVEMENT") |
ToggleChatColorNamesByClassGroup(true, "ACHIEVEMENT") |
ToggleChatColorNamesByClassGroup(true, "WHISPER") |
ToggleChatColorNamesByClassGroup(true, "PARTY") |
ToggleChatColorNamesByClassGroup(true, "PARTY_LEADER") |
ToggleChatColorNamesByClassGroup(true, "RAID") |
ToggleChatColorNamesByClassGroup(true, "RAID_LEADER") |
ToggleChatColorNamesByClassGroup(true, "RAID_WARNING") |
ToggleChatColorNamesByClassGroup(true, "BATTLEGROUND") |
ToggleChatColorNamesByClassGroup(true, "BATTLEGROUND_LEADER") |
ToggleChatColorNamesByClassGroup(true, "INSTANCE_CHAT") |
ToggleChatColorNamesByClassGroup(true, "INSTANCE_CHAT_LEADER") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL1") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL2") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL3") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL4") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL5") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL6") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL7") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL8") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL9") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL10") |
ToggleChatColorNamesByClassGroup(true, "CHANNEL11") |
local _G = _G |
local type = type |
local select = select |
local unpack = unpack |
local tostring = tostring |
local concat = table.concat |
local find = string.find |
local gsub = string.gsub |
local format = string.format |
_G.CHAT_FRAME_TAB_SELECTED_MOUSEOVER_ALPHA = 1 |
_G.CHAT_FRAME_TAB_SELECTED_NOMOUSE_ALPHA = 0 |
_G.CHAT_FRAME_TAB_NORMAL_MOUSEOVER_ALPHA = 0.5 |
_G.CHAT_FRAME_TAB_NORMAL_NOMOUSE_ALPHA = 0 |
--_G.CHAT_FRAME_FADE_OUT_TIME = 0 |
--_G.CHAT_FRAME_FADE_TIME = 0 |
_G.CHAT_FONT_HEIGHTS = { |
[1] = 8, |
[2] = 9, |
[3] = 10, |
[4] = 11, |
[5] = 12, |
[6] = 13, |
[7] = 14, |
[8] = 15, |
[9] = 16, |
[10] = 17, |
[11] = 18, |
[12] = 19, |
[13] = 20, |
} |
_G.CHAT_SAY_GET = '%s:\32' |
_G.CHAT_YELL_GET = '%s:\32' |
_G.CHAT_WHISPER_GET = '[from] %s:\32' |
_G.CHAT_WHISPER_INFORM_GET = '[to] %s:\32' |
_G.CHAT_BN_WHISPER_GET = '[from] %s:\32' |
_G.CHAT_BN_WHISPER_GET = '[to] %s:\32' |
_G.CHAT_FLAG_AFK = '[AFK] ' |
_G.CHAT_FLAG_DND = '[DND] ' |
_G.CHAT_FLAG_GM = '[GM] ' |
_G.CHAT_GUILD_GET = '[|Hchannel:Guild|hG|h] %s:\32' |
_G.CHAT_OFFICER_GET = '[|Hchannel:o|hO|h] %s:\32' |
_G.CHAT_PARTY_GET = '[|Hchannel:party|hP|h] %s:\32' |
_G.CHAT_PARTY_LEADER_GET = '[|Hchannel:party|hPL|h] %s:\32' |
_G.CHAT_PARTY_GUIDE_GET = '[|Hchannel:party|hDG|h] %s:\32' |
_G.CHAT_MONSTER_PARTY_GET = '[|Hchannel:raid|hR|h] %s:\32' |
_G.CHAT_RAID_GET = '[|Hchannel:raid|hR|h] %s:\32' |
_G.CHAT_RAID_WARNING_GET = '[RW!] %s:\32' |
_G.CHAT_RAID_LEADER_GET = '[|Hchannel:raid|hL|h] %s:\32' |
_G.CHAT_BATTLEGROUND_GET = '[|Hchannel:Battleground|hBG|h] %s:\32' |
_G.CHAT_BATTLEGROUND_LEADER_GET = '[|Hchannel:Battleground|hBL|h] %s:\32' |
local channelFormat |
do |
local a, b = '.*%[(.*)%].*', '%%[%1%%]' |
channelFormat = { |
[1] = {gsub(CHAT_BATTLEGROUND_GET, a, b), '[BG]'}, |
[2] = {gsub(CHAT_BATTLEGROUND_LEADER_GET, a, b), '[BGL]'}, |
[3] = {gsub(CHAT_GUILD_GET, a, b), '[G]'}, |
[4] = {gsub(CHAT_OFFICER_GET, a, b), '[O]'}, |
[5] = {gsub(CHAT_PARTY_GET, a, b), '[P]'}, |
[6] = {gsub(CHAT_PARTY_LEADER_GET, a, b), '[PL]'}, |
[7] = {gsub(CHAT_PARTY_GUIDE_GET, a, b), '[PL]'}, |
[8] = {gsub(CHAT_RAID_GET, a, b), '[R]'}, |
[9] = {gsub(CHAT_RAID_LEADER_GET, a, b), '[RL]'}, |
[10] = {gsub(CHAT_RAID_WARNING_GET, a, b), '[RW]'}, |
[11] = {gsub(CHAT_FLAG_AFK, a, b), '[AFK] '}, |
[12] = {gsub(CHAT_FLAG_DND, a, b), '[DND] '}, |
[13] = {gsub(CHAT_FLAG_GM, a, b), '[GM] '}, |
} |
end |
local AddMessage = ChatFrame1.AddMessage |
local function FCF_AddMessage(self, text, ...) |
if (type(text) == 'string') then |
text = gsub(text, '(|HBNplayer.-|h)%[(.-)%]|h', '%1%2|h') |
text = gsub(text, '(|Hplayer.-|h)%[(.-)%]|h', '%1%2|h') |
text = gsub(text, '%[(%d0?)%. (.-)%]', '[%1]') |
for i = 1, #channelFormat do |
text = gsub(text, channelFormat[i][1], channelFormat[i][2]) |
end |
end |
return AddMessage(self, text, ...) |
end |
-- Modify the editbox |
for k = 6, 11 do |
select(k, ChatFrame1EditBox:GetRegions()):SetTexture(nil) |
end |
ChatFrame1EditBox:SetAltArrowKeyMode(false) |
ChatFrame1EditBox:ClearAllPoints() |
ChatFrame1EditBox:SetFont(C['media'].font, C['media'].fontMedium) |
ChatFrame1EditBox:SetPoint('BOTTOMLEFT', ChatFrame1, 'TOPLEFT', 2, 33) |
ChatFrame1EditBox:SetPoint('BOTTOMRIGHT', ChatFrame1, 'TOPRIGHT', 0, 33) |
ChatFrame1EditBox:SetBackdrop({ |
bgFile = C['chat'].editboxbackground, |
edgeFile = C['chat'].editboxborder, |
tile = true, tileSize = 16, edgeSize = 18, |
insets = {left = 3, right = 3, top = 2, bottom = 3}, |
}) |
ChatFrame1EditBox:SetBackdropColor(0, 0, 0, 0.5) |
if (C['chat'].enableBorderColoring) then |
hooksecurefunc('ChatEdit_UpdateHeader', function(editBox) |
local type = editBox:GetAttribute('chatType') |
if (not type) then |
return |
end |
local info = ChatTypeInfo[type] |
ChatFrame1EditBox:SetBackdropBorderColor(info.r, info.g, info.b) |
end) |
end |
-- Hide the menu and friend button |
FriendsMicroButton:SetAlpha(0) |
FriendsMicroButton:EnableMouse(false) |
FriendsMicroButton:UnregisterAllEvents() |
ChatFrameMenuButton:SetAlpha(0) |
ChatFrameMenuButton:EnableMouse(false) |
-- Tab text colors for the tabs |
hooksecurefunc('FCFTab_UpdateColors', function(self, selected) |
if (selected) then |
self:GetFontString():SetTextColor(0, 0.75, 1) |
else |
self:GetFontString():SetTextColor(1, 1, 1) |
end |
end) |
-- Tab text fadeout |
local origFCF_FadeOutChatFrame = _G.FCF_FadeOutChatFrame |
local function FCF_FadeOutChatFrameHook(chatFrame) |
origFCF_FadeOutChatFrame(chatFrame) |
local frameName = chatFrame:GetName() |
local chatTab = _G[frameName..'Tab'] |
local tabGlow = _G[frameName..'TabGlow'] |
if (not tabGlow:IsShown()) then |
if (frameName.isDocked) then |
securecall('UIFrameFadeOut', chatTab, CHAT_FRAME_FADE_OUT_TIME, chatTab:GetAlpha(), CHAT_FRAME_TAB_NORMAL_NOMOUSE_ALPHA) |
else |
securecall('UIFrameFadeOut', chatTab, CHAT_FRAME_FADE_OUT_TIME, chatTab:GetAlpha(), CHAT_FRAME_TAB_NORMAL_NOMOUSE_ALPHA) |
end |
end |
end |
FCF_FadeOutChatFrame = FCF_FadeOutChatFrameHook |
-- Improve mousewheel scrolling |
hooksecurefunc('FloatingChatFrame_OnMouseScroll', function(self, direction) |
if (direction > 0) then |
if (IsShiftKeyDown()) then |
self:ScrollToTop() |
else |
self:ScrollUp() |
self:ScrollUp() |
end |
elseif (direction < 0) then |
if (IsShiftKeyDown()) then |
self:ScrollToBottom() |
else |
self:ScrollDown() |
self:ScrollDown() |
end |
end |
if (C['chat'].enableBottomButton) then |
local buttonBottom = _G[self:GetName() .. 'ButtonFrameBottomButton'] |
if (self:AtBottom()) then |
buttonBottom:SetAlpha(0) |
buttonBottom:EnableMouse(false) |
else |
buttonBottom:SetAlpha(0.7) |
buttonBottom:EnableMouse(true) |
end |
end |
end) |
-- Reposit toast frame |
BNToastFrame:HookScript('OnShow', function(self) |
BNToastFrame:ClearAllPoints() |
BNToastFrame:SetPoint('BOTTOMLEFT', ChatFrame1EditBox, 'TOPLEFT', 0, 15) |
end) |
-- Modify the chat tabs |
function SkinTab(self) |
local chat = _G[self] |
local tab = _G[self..'Tab'] |
for i = 1, select('#', tab:GetRegions()) do |
local texture = select(i, tab:GetRegions()) |
if (texture and texture:GetObjectType() == 'Texture') then |
texture:SetTexture(nil) |
end |
end |
local tabText = _G[self..'TabText'] |
tabText:SetJustifyH('CENTER') |
tabText:SetWidth(60) |
if (C['chat'].taS.fontOutline) then |
tabText:SetFont(C['media'].font, C['media'].fontLarge, 'THINOUTLINE') |
tabText:SetShadowOffset(0, 0) |
else |
tabText:SetFont(C['media'].font, C['media'].fontLarge) |
tabText:SetShadowOffset(1, -1) |
end |
local a1, a2, a3, a4, a5 = tabText:GetPoint() |
tabText:SetPoint(a1, a2, a3, a4, 1) |
local s1, s2, s3 = C['chat'].taS.specialColor.r, C['chat'].taS.specialColor.g, C['chat'].taS.specialColor.b |
local e1, e2, e3 = C['chat'].taS.selectedColor.r, C['chat'].taS.selectedColor.g, C['chat'].taS.selectedColor.b |
local n1, n2, n3 = C['chat'].taS.normalColor.r, C['chat'].taS.normalColor.g, C['chat'].taS.normalColor.b |
local tabGlow = _G[self..'TabGlow'] |
hooksecurefunc(tabGlow, 'Show', function() |
tabText:SetTextColor(s1, s2, s3, CHAT_FRAME_TAB_NORMAL_MOUSEOVER_ALPHA) |
end) |
hooksecurefunc(tabGlow, 'Hide', function() |
tabText:SetTextColor(n1, n2, n3) |
end) |
tab:SetScript('OnEnter', function() |
tabText:SetTextColor(s1, s2, s3, tabText:GetAlpha()) |
end) |
tab:SetScript('OnLeave', function() |
local hasNofication = tabGlow:IsShown() |
local r, g, b |
if (_G[self] == SELECTED_CHAT_FRAME and chat.isDocked) then |
r, g, b = e1, e2, e3 |
elseif (hasNofication) then |
r, g, b = s1, s2, s3 |
else |
r, g, b = n1, n2, n3 |
end |
tabText:SetTextColor(r, g, b) |
end) |
hooksecurefunc(tab, 'Show', function() |
if (not taS.wasShown) then |
local hasNofication = tabGlow:IsShown() |
if (chat:IsMouseOver()) then |
tab:SetAlpha(CHAT_FRAME_TAB_NORMAL_MOUSEOVER_ALPHA) |
else |
tab:SetAlpha(CHAT_FRAME_TAB_NORMAL_NOMOUSE_ALPHA) |
end |
local r, g, b |
if (_G[self] == SELECTED_CHAT_FRAME and chat.isDocked) then |
r, g, b = e1, e2, e3 |
elseif (hasNofication) then |
r, g, b = s1, s2, s3 |
else |
r, g, b = n1, n2, n3 |
end |
tabText:SetTextColor(r, g, b) |
taS.wasShown = true |
end |
end) |
end |
local function ModChat(self) |
local chat = _G[self] |
if (not C['chat'].chatOutline) then |
chat:SetShadowOffset(1, -1) |
end |
if (C['chat'].disableFade) then |
chat:SetFading(false) |
end |
SkinTab(self) |
local font, fontsize, fontflags = chat:GetFont() |
chat:SetFont(C["media"].font, fontsize, C['chat'].chatOutline and 'THINOUTLINE' or fontflags) |
chat:SetClampedToScreen(false) |
chat:SetClampRectInsets(0, 0, 0, 0) |
chat:SetMaxResize(UIParent:GetWidth(), UIParent:GetHeight()) |
chat:SetMinResize(150, 25) |
if (self ~= 'ChatFrame2') then |
chat.AddMessage = FCF_AddMessage |
end |
local buttonUp = _G[self..'ButtonFrameUpButton'] |
buttonUp:SetAlpha(0) |
buttonUp:EnableMouse(false) |
local buttonDown = _G[self..'ButtonFrameDownButton'] |
buttonDown:SetAlpha(0) |
buttonDown:EnableMouse(false) |
local buttonBottom = _G[self..'ButtonFrameBottomButton'] |
buttonBottom:SetAlpha(0) |
buttonBottom:EnableMouse(false) |
if (C['chat'].enableBottomButton) then |
buttonBottom:ClearAllPoints() |
buttonBottom:SetPoint('BOTTOMRIGHT', chat, -1, -3) |
buttonBottom:HookScript('OnClick', function(self) |
self:SetAlpha(0) |
self:EnableMouse(false) |
end) |
end |
for _, texture in pairs({ |
'ButtonFrameBackground', |
'ButtonFrameTopLeftTexture', |
'ButtonFrameBottomLeftTexture', |
'ButtonFrameTopRightTexture', |
'ButtonFrameBottomRightTexture', |
'ButtonFrameLeftTexture', |
'ButtonFrameRightTexture', |
'ButtonFrameBottomTexture', |
'ButtonFrameTopTexture', |
}) do |
_G[self..texture]:SetTexture(nil) |
end |
end |
local function SetChatStyle() |
for _, v in pairs(CHAT_FRAMES) do |
local chat = _G[v] |
if (chat and not chat.hasModification) then |
ModChat(chat:GetName()) |
local convButton = _G[chat:GetName()..'ConversationButton'] |
if (convButton) then |
convButton:SetAlpha(0) |
convButton:EnableMouse(false) |
end |
local chatMinimize = _G[chat:GetName()..'ButtonFrameMinimizeButton'] |
if (chatMinimize) then |
chatMinimize:SetAlpha(0) |
chatMinimize:EnableMouse(0) |
end |
chat.hasModification = true |
end |
end |
end |
hooksecurefunc('FCF_OpenTemporaryWindow', SetChatStyle) |
SetChatStyle() |
-- Chat menu, just a middle click on the chatframe 1 tab |
hooksecurefunc('ChatFrameMenu_UpdateAnchorPoint', function() |
if (FCF_GetButtonSide(DEFAULT_CHAT_FRAME) == 'right') then |
ChatMenu:ClearAllPoints() |
ChatMenu:SetPoint('BOTTOMRIGHT', ChatFrame1Tab, 'TOPLEFT') |
else |
ChatMenu:ClearAllPoints() |
ChatMenu:SetPoint('BOTTOMLEFT', ChatFrame1Tab, 'TOPRIGHT') |
end |
end) |
ChatFrame1Tab:RegisterForClicks('AnyUp') |
ChatFrame1Tab:HookScript('OnClick', function(self, button) |
if (button == 'MiddleButton' or button == 'Button4' or button == 'Button5') then |
if (ChatMenu:IsShown()) then |
ChatMenu:Hide() |
else |
ChatMenu:Show() |
end |
else |
ChatMenu:Hide() |
end |
end) |
-- Modify the gm chatframe and add a sound notification on incoming whispers |
local f = CreateFrame('Frame') |
f:RegisterEvent('ADDON_LOADED') |
f:RegisterEvent('CHAT_MSG_WHISPER') |
f:RegisterEvent('CHAT_MSG_BN_WHISPER') |
f:SetScript('OnEvent', function(_, event) |
if (event == 'ADDON_LOADED' and arg1 == 'Blizzard_GMChatUI') then |
GMChatFrame:EnableMouseWheel(true) |
GMChatFrame:SetScript('OnMouseWheel', ChatFrame1:GetScript('OnMouseWheel')) |
GMChatFrame:SetHeight(200) |
GMChatFrameUpButton:SetAlpha(0) |
GMChatFrameUpButton:EnableMouse(false) |
GMChatFrameDownButton:SetAlpha(0) |
GMChatFrameDownButton:EnableMouse(false) |
GMChatFrameBottomButton:SetAlpha(0) |
GMChatFrameBottomButton:EnableMouse(false) |
end |
if (event == 'CHAT_MSG_WHISPER' or event == 'CHAT_MSG_BN_WHISPER') then |
PlaySoundFile(C['chat'].sound) |
end |
end) |
local combatLog = { |
text = 'CombatLog', |
colorCode = '|cffFFD100', |
isNotRadio = true, |
func = function() |
if (not LoggingCombat()) then |
LoggingCombat(true) |
DEFAULT_CHAT_FRAME:AddMessage(COMBATLOGENABLED, 1, 1, 0) |
else |
LoggingCombat(false) |
DEFAULT_CHAT_FRAME:AddMessage(COMBATLOGDISABLED, 1, 1, 0) |
end |
end, |
checked = function() |
if (LoggingCombat()) then |
return true |
else |
return false |
end |
end |
} |
local chatLog = { |
text = 'ChatLog', |
colorCode = '|cffFFD100', |
isNotRadio = true, |
func = function() |
if (not LoggingChat()) then |
LoggingChat(true) |
DEFAULT_CHAT_FRAME:AddMessage(CHATLOGENABLED, 1, 1, 0) |
else |
LoggingChat(false) |
DEFAULT_CHAT_FRAME:AddMessage(CHATLOGDISABLED, 1, 1, 0) |
end |
end, |
checked = function() |
if (LoggingChat()) then |
return true |
else |
return false |
end |
end |
} |
local origFCF_Tab_OnClick = _G.FCF_Tab_OnClick |
local function FCF_Tab_OnClickHook(chatTab, ...) |
origFCF_Tab_OnClick(chatTab, ...) |
combatLog.arg1 = chatTab |
UIDropDownMenu_AddButton(combatLog) |
chatLog.arg1 = chatTab |
UIDropDownMenu_AddButton(chatLog) |
end |
FCF_Tab_OnClick = FCF_Tab_OnClickHook |
-- Chat Copy |
local f = CreateFrame('Frame', nil, UIParent) |
f:SetHeight(220) |
f:SetBackdropColor(0, 0, 0, 1) |
f:SetPoint('BOTTOMLEFT', ChatFrame1EditBox, 'TOPLEFT', 3, 10) |
f:SetPoint('BOTTOMRIGHT', ChatFrame1EditBox, 'TOPRIGHT', -3, 10) |
f:SetFrameStrata('DIALOG') |
f:SetBackdrop({ |
bgFile = C['chat'].background, |
edgeFile = C['chat'].border, |
tile = true, tileSize = 16, edgeSize = 18, |
insets = {left = 3, right = 3, top = 3, bottom = 3 |
}}) |
f:SetBackdropBorderColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
f:Hide() |
f.t = f:CreateFontString(nil, 'OVERLAY') |
f.t:SetFont(C['media'].font, C['media'].fontHuge) |
f.t:SetPoint('TOPLEFT', f, 8, -8) |
f.t:SetTextColor(1, 1, 0) |
f.t:SetShadowOffset(1, -1) |
f.t:SetJustifyH('LEFT') |
f.b = CreateFrame('EditBox', nil, f) |
f.b:SetMultiLine(true) |
f.b:SetMaxLetters(20000) |
f.b:SetSize(450, 270) |
f.b:SetScript('OnEscapePressed', function() |
f:Hide() |
end) |
f.s = CreateFrame('ScrollFrame', '$parentScrollBar', f, 'UIPanelScrollFrameTemplate') |
f.s:SetPoint('TOPLEFT', f, 'TOPLEFT', 8, -30) |
f.s:SetPoint('BOTTOMRIGHT', f, 'BOTTOMRIGHT', -30, 8) |
f.s:SetScrollChild(f.b) |
f.c = CreateFrame('Button', nil, f, 'UIPanelCloseButton') |
f.c:SetPoint('TOPRIGHT', f, 'TOPRIGHT', 0, -1) |
local lines = {} |
local function GetChatLines(...) |
local count = 1 |
for i = select('#', ...), 1, -1 do |
local region = select(i, ...) |
if (region:GetObjectType() == 'FontString') then |
lines[count] = tostring(region:GetText()) |
count = count + 1 |
end |
end |
return count - 1 |
end |
local function copyChat(self) |
local chat = _G[self:GetName()] |
local _, fontSize = chat:GetFont() |
FCF_SetChatWindowFontSize(self, chat, 0.1) |
local lineCount = GetChatLines(chat:GetRegions()) |
FCF_SetChatWindowFontSize(self, chat, fontSize) |
if (lineCount > 0) then |
ToggleFrame(f) |
f.t:SetText(chat:GetName()) |
local f1, f2, f3 = ChatFrame1:GetFont() |
f.b:SetFont(f1, f2, f3) |
local text = concat(lines, '\n', 1, lineCount) |
f.b:SetText(text) |
end |
end |
local function CreateCopyButton(self) |
self.Copy = CreateFrame('Button', nil, _G[self:GetName()]) |
self.Copy:SetSize(20, 20) |
self.Copy:SetPoint('TOPRIGHT', self, -5, -5) |
self.Copy:SetNormalTexture([[Interface\AddOns\SoopUI\Media\Textures\textureCopyNormal]]) |
self.Copy:GetNormalTexture():SetSize(20, 20) |
self.Copy:SetHighlightTexture([[Interface\AddOns\SoopUI\Media\Textures\textureCopyHighlight]]) |
self.Copy:GetHighlightTexture():SetAllPoints(self.Copy:GetNormalTexture()) |
local tab = _G[self:GetName()..'Tab'] |
hooksecurefunc(tab, 'SetAlpha', function() |
self.Copy:SetAlpha(tab:GetAlpha()*0.55) |
end) |
self.Copy:SetScript('OnMouseDown', function(self) |
self:GetNormalTexture():ClearAllPoints() |
self:GetNormalTexture():SetPoint('CENTER', 1, -1) |
end) |
self.Copy:SetScript('OnMouseUp', function() |
self.Copy:GetNormalTexture():ClearAllPoints() |
self.Copy:GetNormalTexture():SetPoint('CENTER') |
if (self.Copy:IsMouseOver()) then |
copyChat(self) |
end |
end) |
end |
local function EnableCopyButton() |
for _, v in pairs(CHAT_FRAMES) do |
local chat = _G[v] |
if (chat and not chat.Copy) then |
CreateCopyButton(chat) |
end |
end |
end |
hooksecurefunc('FCF_OpenTemporaryWindow', EnableCopyButton) |
EnableCopyButton() |
-- Copy URL |
local urlStyle = '|cffff00ff|Hurl:%1|h%1|h|r' |
local urlPatterns = { |
'(http://%S+)', -- http://xxx.com |
'(www%.%S+)', -- www.xxx.com/site/index.php |
'(%d+%.%d+%.%d+%.%d+:?%d*)', -- 192.168.1.1 / 192.168.1.1:1110 |
} |
local messageTypes = { |
'CHAT_MSG_CHANNEL', |
'CHAT_MSG_GUILD', |
'CHAT_MSG_PARTY', |
'CHAT_MSG_RAID', |
'CHAT_MSG_SAY', |
'CHAT_MSG_WHISPER', |
} |
local function urlFilter(self, event, text, ...) |
for _, pattern in ipairs(urlPatterns) do |
local result, matches = gsub(text, pattern, urlStyle) |
if (matches > 0) then |
return false, result, ... |
end |
end |
end |
for _, event in ipairs(messageTypes) do |
ChatFrame_AddMessageEventFilter(event, urlFilter) |
end |
local origSetItemRef = _G.SetItemRef |
local currentLink |
local SetItemRefHook = function(link, text, button) |
if (link:sub(0, 3) == 'url') then |
currentLink = link:sub(5) |
StaticPopup_Show('UrlCopyDialog') |
return |
end |
return origSetItemRef(link, text, button) |
end |
SetItemRef = SetItemRefHook |
StaticPopupDialogs['UrlCopyDialog'] = { |
text = 'URL', |
button2 = CLOSE, |
hasEditBox = 1, |
editBoxWidth = 250, |
OnShow = function(frame) |
local editBox = _G[frame:GetName()..'EditBox'] |
if (editBox) then |
editBox:SetText(currentLink) |
editBox:SetFocus() |
editBox:HighlightText(0) |
end |
local button = _G[frame:GetName()..'Button2'] |
if (button) then |
button:ClearAllPoints() |
button:SetWidth(100) |
button:SetPoint('CENTER', editBox, 'CENTER', 0, -30) |
end |
end, |
EditBoxOnEscapePressed = function(frame) |
frame:GetParent():Hide() |
end, |
timeout = 0, |
whileDead = 1, |
hideOnEscape = 1, |
maxLetters = 1024, |
} |
if C['chat'].enableHyperlinkTooltip ~= true then return end |
--[[ |
All Create for hyperlink.lua goes to Neal, ballagarba, and Tuks. |
Neav UI = http://www.wowinterface.com/downloads/info13981-NeavUI.html. |
Tukui = http://www.tukui.org/download.php. |
Edited by Cokedriver. |
]] |
local _G = getfenv(0) |
local orig1, orig2 = {}, {} |
local GameTooltip = GameTooltip |
local linktypes = { |
item = true, |
enchant = true, |
spell = true, |
quest = true, |
unit = true, |
talent = true, |
achievement = true, |
glyph = true |
} |
local function OnHyperlinkEnter(frame, link, ...) |
local linktype = link:match('^([^:]+)') |
if (linktype and linktypes[linktype]) then |
GameTooltip:SetOwner(ChatFrame1, 'ANCHOR_CURSOR', 0, 20) |
GameTooltip:SetHyperlink(link) |
GameTooltip:Show() |
else |
GameTooltip:Hide() |
end |
if (orig1[frame]) then |
return orig1[frame](frame, link, ...) |
end |
end |
local function OnHyperlinkLeave(frame, ...) |
GameTooltip:Hide() |
if (orig2[frame]) then |
return orig2[frame](frame, ...) |
end |
end |
local function EnableItemLinkTooltip() |
for _, v in pairs(CHAT_FRAMES) do |
local chat = _G[v] |
if (chat and not chat.URLCopy) then |
orig1[chat] = chat:GetScript('OnHyperlinkEnter') |
chat:SetScript('OnHyperlinkEnter', OnHyperlinkEnter) |
orig2[chat] = chat:GetScript('OnHyperlinkLeave') |
chat:SetScript('OnHyperlinkLeave', OnHyperlinkLeave) |
chat.URLCopy = true |
end |
end |
end |
hooksecurefunc('FCF_OpenTemporaryWindow', EnableItemLinkTooltip) |
EnableItemLinkTooltip() |
if C["chat"].windowborder == true then |
for i = 1, NUM_CHAT_WINDOWS do |
local cf = _G['ChatFrame'..i] |
local bg = CreateFrame("Frame", nil, cf); |
bg:SetFrameStrata("BACKGROUND"); |
if i == 2 then |
bg:SetPoint("TOPLEFT", -8, 32); |
else |
bg:SetPoint("TOPLEFT", -8, 8); |
end |
bg:SetPoint("BOTTOMRIGHT", 8, -12); |
bg:SetBackdrop({ |
edgeFile = C['chat'].border, |
tile = true, tileSize = 16, edgeSize = 18, |
}) |
if C['general'].classcolor ~= true then |
bg:SetBackdropBorderColor(C['general'].color.r,C['general'].color.g,C['general'].color.b) |
else |
bg:SetBackdropBorderColor(S.ccolor.r, S.ccolor.g, S.ccolor.b) |
end |
end |
end |
<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> |
--- 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 1066 2012-09-18 14:36:49Z nevcairiel $ |
local ACEDBO_MAJOR, ACEDBO_MINOR = "AceDBOptions-3.0", 14 |
local AceDBOptions, oldminor = 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 |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: NORMAL_FONT_COLOR_CODE, FONT_COLOR_CODE_CLOSE |
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"] = "Current Profile:" |
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 um die SavedVariables Datei 'sauber' zu halten." |
L["delete_sub"] = "Löscht ein Profil aus der Datenbank." |
L["intro"] = "Hier kannst du das aktive Datenbankprofile ä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 das 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"] = "Current Profile:" |
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"] = "Current Profile:" |
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"] = "Current Profile:" |
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"] = "Current Profile:" |
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"] = "Current Profile:" |
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"] = "Current Profile:" |
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 gia' esistenti." |
L["choose_sub"] = "Seleziona uno dei profili 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"] = "Standard" |
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 di default, 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 di default." |
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 |
--- AceEvent-3.0 provides event registration and secure dispatching. |
-- All dispatching is done using **CallbackHandler-1.0**. AceEvent is a simple wrapper around |
-- CallbackHandler, and dispatches all game events or addon message to the registrees. |
-- |
-- **AceEvent-3.0** can be embeded into your addon, either explicitly by calling AceEvent:Embed(MyAddon) or by |
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object |
-- and can be accessed directly, without having to explicitly call AceEvent itself.\\ |
-- It is recommended to embed AceEvent, otherwise you'll have to specify a custom `self` on all calls you |
-- make into AceEvent. |
-- @class file |
-- @name AceEvent-3.0 |
-- @release $Id: AceEvent-3.0.lua 975 2010-10-23 11:26:18Z nevcairiel $ |
local MAJOR, MINOR = "AceEvent-3.0", 3 |
local AceEvent = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceEvent then return end |
-- Lua APIs |
local pairs = pairs |
local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0") |
AceEvent.frame = AceEvent.frame or CreateFrame("Frame", "AceEvent30Frame") -- our event frame |
AceEvent.embeds = AceEvent.embeds or {} -- what objects embed this lib |
-- APIs and registry for blizzard events, using CallbackHandler lib |
if not AceEvent.events then |
AceEvent.events = CallbackHandler:New(AceEvent, |
"RegisterEvent", "UnregisterEvent", "UnregisterAllEvents") |
end |
function AceEvent.events:OnUsed(target, eventname) |
AceEvent.frame:RegisterEvent(eventname) |
end |
function AceEvent.events:OnUnused(target, eventname) |
AceEvent.frame:UnregisterEvent(eventname) |
end |
-- APIs and registry for IPC messages, using CallbackHandler lib |
if not AceEvent.messages then |
AceEvent.messages = CallbackHandler:New(AceEvent, |
"RegisterMessage", "UnregisterMessage", "UnregisterAllMessages" |
) |
AceEvent.SendMessage = AceEvent.messages.Fire |
end |
--- embedding and embed handling |
local mixins = { |
"RegisterEvent", "UnregisterEvent", |
"RegisterMessage", "UnregisterMessage", |
"SendMessage", |
"UnregisterAllEvents", "UnregisterAllMessages", |
} |
--- Register for a Blizzard Event. |
-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied) |
-- Any arguments to the event will be passed on after that. |
-- @name AceEvent:RegisterEvent |
-- @class function |
-- @paramsig event[, callback [, arg]] |
-- @param event The event to register for |
-- @param callback The callback function to call when the event is triggered (funcref or method, defaults to a method with the event name) |
-- @param arg An optional argument to pass to the callback function |
--- Unregister an event. |
-- @name AceEvent:UnregisterEvent |
-- @class function |
-- @paramsig event |
-- @param event The event to unregister |
--- Register for a custom AceEvent-internal message. |
-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied) |
-- Any arguments to the event will be passed on after that. |
-- @name AceEvent:RegisterMessage |
-- @class function |
-- @paramsig message[, callback [, arg]] |
-- @param message The message to register for |
-- @param callback The callback function to call when the message is triggered (funcref or method, defaults to a method with the event name) |
-- @param arg An optional argument to pass to the callback function |
--- Unregister a message |
-- @name AceEvent:UnregisterMessage |
-- @class function |
-- @paramsig message |
-- @param message The message to unregister |
--- Send a message over the AceEvent-3.0 internal message system to other addons registered for this message. |
-- @name AceEvent:SendMessage |
-- @class function |
-- @paramsig message, ... |
-- @param message The message to send |
-- @param ... Any arguments to the message |
-- Embeds AceEvent into the target object making the functions from the mixins list available on target:.. |
-- @param target target object to embed AceEvent in |
function AceEvent:Embed(target) |
for k, v in pairs(mixins) do |
target[v] = self[v] |
end |
self.embeds[target] = true |
return target |
end |
-- AceEvent:OnEmbedDisable( target ) |
-- target (object) - target object that is being disabled |
-- |
-- Unregister all events messages etc when the target disables. |
-- this method should be called by the target manually or by an addon framework |
function AceEvent:OnEmbedDisable(target) |
target:UnregisterAllEvents() |
target:UnregisterAllMessages() |
end |
-- Script to fire blizzard events into the event listeners |
local events = AceEvent.events |
AceEvent.frame:SetScript("OnEvent", function(this, event, ...) |
events:Fire(event, ...) |
end) |
--- Finally: upgrade our old embeds |
for target, v in pairs(AceEvent.embeds) do |
AceEvent:Embed(target) |
end |
<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> |
<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="libs\AceAddon-3.0\AceAddon-3.0.lua"/> |
<Script file="libs\AceDB-3.0\AceDB-3.0.lua"/> |
<Script file="CallbackHandler-1.0\CallbackHandler-1.0.lua"/> |
<Script file="libs\AceDBOptions-3.0\AceDBOptions-3.0.lua"/> |
<Script file="libs\AceConsole-3.0\AceConsole-3.0.lua"/> |
<Script file="libs\AceEvent-3.0\AceEvent-3.0.lua"/> |
<Script file="libs\LibStub\LibStub.lua"/> |
<Include file="LibDataBroker\Load.xml"/> |
<Include file="AceHook-3.0\AceHook-3.0.xml"/> |
<Include file="LibSharedMedia-3.0\LibSharedMedia-3.0.xml"/> |
</Ui> |
<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> |
--- **AceConsole-3.0** provides registration facilities for slash commands. |
-- You can register slash commands to your custom functions and use the `GetArgs` function to parse them |
-- to your addons individual needs. |
-- |
-- **AceConsole-3.0** can be embeded into your addon, either explicitly by calling AceConsole:Embed(MyAddon) or by |
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object |
-- and can be accessed directly, without having to explicitly call AceConsole itself.\\ |
-- It is recommended to embed AceConsole, otherwise you'll have to specify a custom `self` on all calls you |
-- make into AceConsole. |
-- @class file |
-- @name AceConsole-3.0 |
-- @release $Id: AceConsole-3.0.lua 878 2009-11-02 18:51:58Z nevcairiel $ |
local MAJOR,MINOR = "AceConsole-3.0", 7 |
local AceConsole, oldminor = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceConsole then return end -- No upgrade needed |
AceConsole.embeds = AceConsole.embeds or {} -- table containing objects AceConsole is embedded in. |
AceConsole.commands = AceConsole.commands or {} -- table containing commands registered |
AceConsole.weakcommands = AceConsole.weakcommands or {} -- table containing self, command => func references for weak commands that don't persist through enable/disable |
-- Lua APIs |
local tconcat, tostring, select = table.concat, tostring, select |
local type, pairs, error = type, pairs, error |
local format, strfind, strsub = string.format, string.find, string.sub |
local max = math.max |
-- WoW APIs |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: DEFAULT_CHAT_FRAME, SlashCmdList, hash_SlashCmdList |
local tmp={} |
local function Print(self,frame,...) |
local n=0 |
if self ~= AceConsole then |
n=n+1 |
tmp[n] = "|cff33ff99"..tostring( self ).."|r:" |
end |
for i=1, select("#", ...) do |
n=n+1 |
tmp[n] = tostring(select(i, ...)) |
end |
frame:AddMessage( tconcat(tmp," ",1,n) ) |
end |
--- Print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function) |
-- @paramsig [chatframe ,] ... |
-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function) |
-- @param ... List of any values to be printed |
function AceConsole:Print(...) |
local frame = ... |
if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member? |
return Print(self, frame, select(2,...)) |
else |
return Print(self, DEFAULT_CHAT_FRAME, ...) |
end |
end |
--- Formatted (using format()) print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function) |
-- @paramsig [chatframe ,] "format"[, ...] |
-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function) |
-- @param format Format string - same syntax as standard Lua format() |
-- @param ... Arguments to the format string |
function AceConsole:Printf(...) |
local frame = ... |
if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member? |
return Print(self, frame, format(select(2,...))) |
else |
return Print(self, DEFAULT_CHAT_FRAME, format(...)) |
end |
end |
--- Register a simple chat command |
-- @param command Chat command to be registered WITHOUT leading "/" |
-- @param func Function to call when the slash command is being used (funcref or methodname) |
-- @param persist if false, the command will be soft disabled/enabled when aceconsole is used as a mixin (default: true) |
function AceConsole:RegisterChatCommand( command, func, persist ) |
if type(command)~="string" then error([[Usage: AceConsole:RegisterChatCommand( "command", func[, persist ]): 'command' - expected a string]], 2) end |
if persist==nil then persist=true end -- I'd rather have my addon's "/addon enable" around if the author screws up. Having some extra slash regged when it shouldnt be isn't as destructive. True is a better default. /Mikk |
local name = "ACECONSOLE_"..command:upper() |
if type( func ) == "string" then |
SlashCmdList[name] = function(input, editBox) |
self[func](self, input, editBox) |
end |
else |
SlashCmdList[name] = func |
end |
_G["SLASH_"..name.."1"] = "/"..command:lower() |
AceConsole.commands[command] = name |
-- non-persisting commands are registered for enabling disabling |
if not persist then |
if not AceConsole.weakcommands[self] then AceConsole.weakcommands[self] = {} end |
AceConsole.weakcommands[self][command] = func |
end |
return true |
end |
--- Unregister a chatcommand |
-- @param command Chat command to be unregistered WITHOUT leading "/" |
function AceConsole:UnregisterChatCommand( command ) |
local name = AceConsole.commands[command] |
if name then |
SlashCmdList[name] = nil |
_G["SLASH_" .. name .. "1"] = nil |
hash_SlashCmdList["/" .. command:upper()] = nil |
AceConsole.commands[command] = nil |
end |
end |
--- Get an iterator over all Chat Commands registered with AceConsole |
-- @return Iterator (pairs) over all commands |
function AceConsole:IterateChatCommands() return pairs(AceConsole.commands) end |
local function nils(n, ...) |
if n>1 then |
return nil, nils(n-1, ...) |
elseif n==1 then |
return nil, ... |
else |
return ... |
end |
end |
--- Retreive one or more space-separated arguments from a string. |
-- Treats quoted strings and itemlinks as non-spaced. |
-- @param string The raw argument string |
-- @param numargs How many arguments to get (default 1) |
-- @param startpos Where in the string to start scanning (default 1) |
-- @return Returns arg1, arg2, ..., nextposition\\ |
-- Missing arguments will be returned as nils. 'nextposition' is returned as 1e9 at the end of the string. |
function AceConsole:GetArgs(str, numargs, startpos) |
numargs = numargs or 1 |
startpos = max(startpos or 1, 1) |
local pos=startpos |
-- find start of new arg |
pos = strfind(str, "[^ ]", pos) |
if not pos then -- whoops, end of string |
return nils(numargs, 1e9) |
end |
if numargs<1 then |
return pos |
end |
-- quoted or space separated? find out which pattern to use |
local delim_or_pipe |
local ch = strsub(str, pos, pos) |
if ch=='"' then |
pos = pos + 1 |
delim_or_pipe='([|"])' |
elseif ch=="'" then |
pos = pos + 1 |
delim_or_pipe="([|'])" |
else |
delim_or_pipe="([| ])" |
end |
startpos = pos |
while true do |
-- find delimiter or hyperlink |
local ch,_ |
pos,_,ch = strfind(str, delim_or_pipe, pos) |
if not pos then break end |
if ch=="|" then |
-- some kind of escape |
if strsub(str,pos,pos+1)=="|H" then |
-- It's a |H....|hhyper link!|h |
pos=strfind(str, "|h", pos+2) -- first |h |
if not pos then break end |
pos=strfind(str, "|h", pos+2) -- second |h |
if not pos then break end |
elseif strsub(str,pos, pos+1) == "|T" then |
-- It's a |T....|t texture |
pos=strfind(str, "|t", pos+2) |
if not pos then break end |
end |
pos=pos+2 -- skip past this escape (last |h if it was a hyperlink) |
else |
-- found delimiter, done with this arg |
return strsub(str, startpos, pos-1), AceConsole:GetArgs(str, numargs-1, pos+1) |
end |
end |
-- search aborted, we hit end of string. return it all as one argument. (yes, even if it's an unterminated quote or hyperlink) |
return strsub(str, startpos), nils(numargs-1, 1e9) |
end |
--- embedding and embed handling |
local mixins = { |
"Print", |
"Printf", |
"RegisterChatCommand", |
"UnregisterChatCommand", |
"GetArgs", |
} |
-- Embeds AceConsole into the target object making the functions from the mixins list available on target:.. |
-- @param target target object to embed AceBucket in |
function AceConsole:Embed( target ) |
for k, v in pairs( mixins ) do |
target[v] = self[v] |
end |
self.embeds[target] = true |
return target |
end |
function AceConsole:OnEmbedEnable( target ) |
if AceConsole.weakcommands[target] then |
for command, func in pairs( AceConsole.weakcommands[target] ) do |
target:RegisterChatCommand( command, func, false, true ) -- nonpersisting and silent registry |
end |
end |
end |
function AceConsole:OnEmbedDisable( target ) |
if AceConsole.weakcommands[target] then |
for command, func in pairs( AceConsole.weakcommands[target] ) do |
target:UnregisterChatCommand( command ) -- TODO: this could potentially unregister a command from another application in case of command conflicts. Do we care? |
end |
end |
end |
for addon in pairs(AceConsole.embeds) do |
AceConsole:Embed(addon) |
end |
<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> |
--[[ |
Name: LibSharedMedia-3.0 |
Revision: $Revision: 62 $ |
Author: Elkano (elkano@gmx.de) |
Inspired By: SurfaceLib by Haste/Otravi (troeks@gmail.com) |
Website: http://www.wowace.com/projects/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", 100001 -- increase manualy 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 table_insert = _G.table.insert |
local table_sort = _G.table.sort |
local locale = GetLocale() |
local locale_is_western |
local LOCALE_MASK = 0 |
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["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 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["White"] = [[Interface\Buttons\WHITE8X8]] |
lib.MediaTable.background["Black"] = [[Interface\AddOns\SoopUI\Media\Textures\BLACK8X8]] |
-- BORDER |
if not lib.MediaTable.border then lib.MediaTable.border = {} end |
lib.MediaTable.border["None"] = [[Interface\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]] |
-- FONT |
if not lib.MediaTable.font then lib.MediaTable.font = {} end |
local SML_MT_font = lib.MediaTable.font |
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\ZYKai_C.ttf]] |
SML_MT_font["é»è®¤"] = [[Fonts\ZYKai_T.ttf]] |
SML_MT_font["è天"] = [[Fonts\ZYHei.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["Arial Narrow"] = [[Fonts\ARIALN.TTF]] |
SML_MT_font["Friz Quadrata TT"] = [[Fonts\FRIZQT__.TTF]] |
SML_MT_font["Morpheus"] = [[Fonts\MORPHEUS.TTF]] |
SML_MT_font["Nimrod MT"] = [[Fonts\NIM_____.ttf]] |
SML_MT_font["Skurri"] = [[Fonts\SKURRI.TTF]] |
-- |
lib.DefaultMedia.font = "Friz Quadrata TT" |
-- |
else |
LOCALE_MASK = lib.LOCALE_BIT_western |
locale_is_western = true |
-- |
SML_MT_font["Arial Narrow"] = [[Fonts\ARIALN.TTF]] |
SML_MT_font["Friz Quadrata TT"] = [[Fonts\FRIZQT__.TTF]] |
SML_MT_font["Morpheus"] = [[Fonts\MORPHEUS.TTF]] |
SML_MT_font["Skurri"] = [[Fonts\SKURRI.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.DefaultMedia.statusbar = "Blizzard" |
-- SOUND |
if not lib.MediaTable.sound then lib.MediaTable.sound = {} end |
lib.MediaTable.sound["None"] = [[Interface\Quiet.ogg]] -- Relies on the fact that PlaySound[File] doesn't error on non-existing input. |
lib.DefaultMedia.sound = "None" |
local function rebuildMediaList(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 |
local i = 0 |
for k in pairs(mtable) do |
i = i + 1 |
mlist[i] = k |
end |
table_sort(mlist) |
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 return false end |
if not mediaTable[mediatype] then mediaTable[mediatype] = {} end |
local mtable = mediaTable[mediatype] |
if mtable[key] then return false end |
mtable[key] = data |
rebuildMediaList(mediatype) |
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 |
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 |
rebuildMediaList(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 |
<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> |
--- **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 1084 2013-04-27 20:14:11Z nevcairiel $ |
local MAJOR, MINOR = "AceAddon-3.0", 12 |
local AceAddon, oldminor = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceAddon then return end -- No Upgrade needed. |
AceAddon.frame = AceAddon.frame or CreateFrame("Frame", "AceAddon30Frame") -- Our very own frame |
AceAddon.addons = AceAddon.addons or {} -- addons in general |
AceAddon.statuses = AceAddon.statuses or {} -- statuses of addon. |
AceAddon.initializequeue = AceAddon.initializequeue or {} -- addons that are new and not initialized |
AceAddon.enablequeue = AceAddon.enablequeue or {} -- addons that are initialized and waiting to be enabled |
AceAddon.embeds = AceAddon.embeds or setmetatable({}, {__index = function(tbl, key) tbl[key] = {} return tbl[key] end }) -- contains a list of libraries embedded in an addon |
-- Lua APIs |
local tinsert, tconcat, tremove = table.insert, table.concat, table.remove |
local fmt, tostring = string.format, tostring |
local select, pairs, next, type, unpack = select, pairs, next, type, unpack |
local loadstring, assert, error = loadstring, assert, error |
local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: LibStub, IsLoggedIn, geterrorhandler |
--[[ |
xpcall safecall implementation |
]] |
local xpcall = xpcall |
local function errorhandler(err) |
return geterrorhandler()(err) |
end |
local function CreateDispatcher(argCount) |
local code = [[ |
local xpcall, eh = ... |
local method, ARGS |
local function call() return method(ARGS) end |
local function dispatch(func, ...) |
method = func |
if not method then return end |
ARGS = ... |
return xpcall(call, eh) |
end |
return dispatch |
]] |
local ARGS = {} |
for i = 1, argCount do ARGS[i] = "arg"..i end |
code = code:gsub("ARGS", tconcat(ARGS, ", ")) |
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler) |
end |
local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
local dispatcher = CreateDispatcher(argCount) |
rawset(self, argCount, dispatcher) |
return dispatcher |
end}) |
Dispatchers[0] = function(func) |
return xpcall(func, errorhandler) |
end |
local function safecall(func, ...) |
-- we check to see if the func is passed is actually a function here and don't error when it isn't |
-- this safecall is used for optional functions like OnInitialize OnEnable etc. When they are not |
-- present execution should continue without hinderance |
if type(func) == "function" then |
return Dispatchers[select('#', ...)](func, ...) |
end |
end |
-- local functions that will be implemented further down |
local Enable, Disable, EnableModule, DisableModule, Embed, NewModule, GetModule, GetName, SetDefaultModuleState, SetDefaultModuleLibraries, SetEnabledState, SetDefaultModulePrototype |
-- used in the addon metatable |
local function addontostring( self ) return self.name end |
-- 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 |
-- Event Handling |
local function onEvent(this, event, arg1) |
-- 2011-08-17 nevcairiel - ignore the load event of Blizzard_DebugTools, so a potential startup error isn't swallowed up |
if (event == "ADDON_LOADED" and arg1 ~= "Blizzard_DebugTools") 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 |
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
..\FrameXML\UI.xsd"> |
<Script file="AceDB-3.0.lua"/> |
</Ui> |
--- **AceDB-3.0** manages the SavedVariables of your addon. |
-- It offers profile management, smart defaults and namespaces for modules.\\ |
-- Data can be saved in different data-types, depending on its intended usage. |
-- The most common data-type is the `profile` type, which allows the user to choose |
-- the active profile, and manage the profiles of all of his characters.\\ |
-- The following data types are available: |
-- * **char** Character-specific data. Every character has its own database. |
-- * **realm** Realm-specific data. All of the players characters on the same realm share this database. |
-- * **class** Class-specific data. All of the players characters of the same class share this database. |
-- * **race** Race-specific data. All of the players characters of the same race share this database. |
-- * **faction** Faction-specific data. All of the players characters of the same faction share this database. |
-- * **factionrealm** Faction and realm specific data. All of the players characters on the same realm and of the same faction share this database. |
-- * **global** Global Data. All characters on the same account share this database. |
-- * **profile** Profile-specific data. All characters using the same profile share this database. The user can control which profile should be used. |
-- |
-- Creating a new Database using the `:New` function will return a new DBObject. A database will inherit all functions |
-- of the DBObjectLib listed here. \\ |
-- If you create a new namespaced child-database (`:RegisterNamespace`), you'll get a DBObject as well, but note |
-- that the child-databases cannot individually change their profile, and are linked to their parents profile - and because of that, |
-- the profile related APIs are not available. Only `:RegisterDefaults` and `:ResetProfile` are available on child-databases. |
-- |
-- For more details on how to use AceDB-3.0, see the [[AceDB-3.0 Tutorial]]. |
-- |
-- You may also be interested in [[libdualspec-1-0|LibDualSpec-1.0]] to do profile switching automatically when switching specs. |
-- |
-- @usage |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("DBExample") |
-- |
-- -- declare defaults to be used in the DB |
-- local defaults = { |
-- profile = { |
-- setting = true, |
-- } |
-- } |
-- |
-- function MyAddon:OnInitialize() |
-- -- Assuming the .toc says ## SavedVariables: MyAddonDB |
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
-- end |
-- @class file |
-- @name AceDB-3.0.lua |
-- @release $Id: AceDB-3.0.lua 1035 2011-07-09 03:20:13Z kaelten $ |
local ACEDB_MAJOR, ACEDB_MINOR = "AceDB-3.0", 22 |
local AceDB, oldminor = LibStub:NewLibrary(ACEDB_MAJOR, ACEDB_MINOR) |
if not AceDB then return end -- No upgrade needed |
-- Lua APIs |
local type, pairs, next, error = type, pairs, next, error |
local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget |
-- WoW APIs |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: LibStub |
AceDB.db_registry = AceDB.db_registry or {} |
AceDB.frame = AceDB.frame or CreateFrame("Frame") |
local CallbackHandler |
local CallbackDummy = { Fire = function() end } |
local DBObjectLib = {} |
--[[------------------------------------------------------------------------- |
AceDB Utility Functions |
---------------------------------------------------------------------------]] |
-- Simple shallow copy for copying defaults |
local function copyTable(src, dest) |
if type(dest) ~= "table" then dest = {} end |
if type(src) == "table" then |
for k,v in pairs(src) do |
if type(v) == "table" then |
-- try to index the key first so that the metatable creates the defaults, if set, and use that table |
v = copyTable(v, dest[k]) |
end |
dest[k] = v |
end |
end |
return dest |
end |
-- Called to add defaults to a section of the database |
-- |
-- When a ["*"] default section is indexed with a new key, a table is returned |
-- and set in the host table. These tables must be cleaned up by removeDefaults |
-- in order to ensure we don't write empty default tables. |
local function copyDefaults(dest, src) |
-- this happens if some value in the SV overwrites our default value with a non-table |
--if type(dest) ~= "table" then return end |
for k, v in pairs(src) do |
if k == "*" or k == "**" then |
if type(v) == "table" then |
-- This is a metatable used for table defaults |
local mt = { |
-- This handles the lookup and creation of new subtables |
__index = function(t,k) |
if k == nil then return nil end |
local tbl = {} |
copyDefaults(tbl, v) |
rawset(t, k, tbl) |
return tbl |
end, |
} |
setmetatable(dest, mt) |
-- handle already existing tables in the SV |
for dk, dv in pairs(dest) do |
if not rawget(src, dk) and type(dv) == "table" then |
copyDefaults(dv, v) |
end |
end |
else |
-- Values are not tables, so this is just a simple return |
local mt = {__index = function(t,k) return k~=nil and v or nil end} |
setmetatable(dest, mt) |
end |
elseif type(v) == "table" then |
if not rawget(dest, k) then rawset(dest, k, {}) end |
if type(dest[k]) == "table" then |
copyDefaults(dest[k], v) |
if src['**'] then |
copyDefaults(dest[k], src['**']) |
end |
end |
else |
if rawget(dest, k) == nil then |
rawset(dest, k, v) |
end |
end |
end |
end |
-- Called to remove all defaults in the default table from the database |
local function removeDefaults(db, defaults, blocker) |
-- remove all metatables from the db, so we don't accidentally create new sub-tables through them |
setmetatable(db, nil) |
-- loop through the defaults and remove their content |
for k,v in pairs(defaults) do |
if k == "*" or k == "**" then |
if type(v) == "table" then |
-- Loop through all the actual k,v pairs and remove |
for key, value in pairs(db) do |
if type(value) == "table" then |
-- if the key was not explicitly specified in the defaults table, just strip everything from * and ** tables |
if defaults[key] == nil and (not blocker or blocker[key] == nil) then |
removeDefaults(value, v) |
-- if the table is empty afterwards, remove it |
if next(value) == nil then |
db[key] = nil |
end |
-- if it was specified, only strip ** content, but block values which were set in the key table |
elseif k == "**" then |
removeDefaults(value, v, defaults[key]) |
end |
end |
end |
elseif k == "*" then |
-- check for non-table default |
for key, value in pairs(db) do |
if defaults[key] == nil and v == value then |
db[key] = nil |
end |
end |
end |
elseif type(v) == "table" and type(db[k]) == "table" then |
-- if a blocker was set, dive into it, to allow multi-level defaults |
removeDefaults(db[k], v, blocker and blocker[k]) |
if next(db[k]) == nil then |
db[k] = nil |
end |
else |
-- check if the current value matches the default, and that its not blocked by another defaults table |
if db[k] == defaults[k] and (not blocker or blocker[k] == nil) then |
db[k] = nil |
end |
end |
end |
end |
-- This is called when a table section is first accessed, to set up the defaults |
local function initSection(db, section, svstore, key, defaults) |
local sv = rawget(db, "sv") |
local tableCreated |
if not sv[svstore] then sv[svstore] = {} end |
if not sv[svstore][key] then |
sv[svstore][key] = {} |
tableCreated = true |
end |
local tbl = sv[svstore][key] |
if defaults then |
copyDefaults(tbl, defaults) |
end |
rawset(db, section, tbl) |
return tableCreated, tbl |
end |
-- Metatable to handle the dynamic creation of sections and copying of sections. |
local dbmt = { |
__index = function(t, section) |
local keys = rawget(t, "keys") |
local key = keys[section] |
if key then |
local defaultTbl = rawget(t, "defaults") |
local defaults = defaultTbl and defaultTbl[section] |
if section == "profile" then |
local new = initSection(t, section, "profiles", key, defaults) |
if new then |
-- Callback: OnNewProfile, database, newProfileKey |
t.callbacks:Fire("OnNewProfile", t, key) |
end |
elseif section == "profiles" then |
local sv = rawget(t, "sv") |
if not sv.profiles then sv.profiles = {} end |
rawset(t, "profiles", sv.profiles) |
elseif section == "global" then |
local sv = rawget(t, "sv") |
if not sv.global then sv.global = {} end |
if defaults then |
copyDefaults(sv.global, defaults) |
end |
rawset(t, section, sv.global) |
else |
initSection(t, section, section, key, defaults) |
end |
end |
return rawget(t, section) |
end |
} |
local function validateDefaults(defaults, keyTbl, offset) |
if not defaults then return end |
offset = offset or 0 |
for k in pairs(defaults) do |
if not keyTbl[k] or k == "profiles" then |
error(("Usage: AceDBObject:RegisterDefaults(defaults): '%s' is not a valid datatype."):format(k), 3 + offset) |
end |
end |
end |
local preserve_keys = { |
["callbacks"] = true, |
["RegisterCallback"] = true, |
["UnregisterCallback"] = true, |
["UnregisterAllCallbacks"] = true, |
["children"] = true, |
} |
local realmKey = GetRealmName() |
local charKey = UnitName("player") .. " - " .. realmKey |
local _, classKey = UnitClass("player") |
local _, raceKey = UnitRace("player") |
local factionKey = UnitFactionGroup("player") |
local factionrealmKey = factionKey .. " - " .. realmKey |
local factionrealmregionKey = factionrealmKey .. " - " .. string.sub(GetCVar("realmList"), 1, 2):upper() |
local localeKey = GetLocale():lower() |
-- Actual database initialization function |
local function initdb(sv, defaults, defaultProfile, olddb, parent) |
-- Generate the database keys for each section |
-- map "true" to our "Default" profile |
if defaultProfile == true then defaultProfile = "Default" end |
local profileKey |
if not parent then |
-- Make a container for profile keys |
if not sv.profileKeys then sv.profileKeys = {} end |
-- Try to get the profile selected from the char db |
profileKey = sv.profileKeys[charKey] or defaultProfile or charKey |
-- save the selected profile for later |
sv.profileKeys[charKey] = profileKey |
else |
-- Use the profile of the parents DB |
profileKey = parent.keys.profile or defaultProfile or charKey |
-- clear the profileKeys in the DB, namespaces don't need to store them |
sv.profileKeys = nil |
end |
-- This table contains keys that enable the dynamic creation |
-- of each section of the table. The 'global' and 'profiles' |
-- have a key of true, since they are handled in a special case |
local keyTbl= { |
["char"] = charKey, |
["realm"] = realmKey, |
["class"] = classKey, |
["race"] = raceKey, |
["faction"] = factionKey, |
["factionrealm"] = factionrealmKey, |
["factionrealmregion"] = factionrealmregionKey, |
["profile"] = profileKey, |
["locale"] = localeKey, |
["global"] = true, |
["profiles"] = true, |
} |
validateDefaults(defaults, keyTbl, 1) |
-- This allows us to use this function to reset an entire database |
-- Clear out the old database |
if olddb then |
for k,v in pairs(olddb) do if not preserve_keys[k] then olddb[k] = nil end end |
end |
-- Give this database the metatable so it initializes dynamically |
local db = setmetatable(olddb or {}, dbmt) |
if not rawget(db, "callbacks") then |
-- try to load CallbackHandler-1.0 if it loaded after our library |
if not CallbackHandler then CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0", true) end |
db.callbacks = CallbackHandler and CallbackHandler:New(db) or CallbackDummy |
end |
-- Copy methods locally into the database object, to avoid hitting |
-- the metatable when calling methods |
if not parent then |
for name, func in pairs(DBObjectLib) do |
db[name] = func |
end |
else |
-- hack this one in |
db.RegisterDefaults = DBObjectLib.RegisterDefaults |
db.ResetProfile = DBObjectLib.ResetProfile |
end |
-- Set some properties in the database object |
db.profiles = sv.profiles |
db.keys = keyTbl |
db.sv = sv |
--db.sv_name = name |
db.defaults = defaults |
db.parent = parent |
-- store the DB in the registry |
AceDB.db_registry[db] = true |
return db |
end |
-- handle PLAYER_LOGOUT |
-- strip all defaults from all databases |
-- and cleans up empty sections |
local function logoutHandler(frame, event) |
if event == "PLAYER_LOGOUT" then |
for db in pairs(AceDB.db_registry) do |
db.callbacks:Fire("OnDatabaseShutdown", db) |
db:RegisterDefaults(nil) |
-- cleanup sections that are empty without defaults |
local sv = rawget(db, "sv") |
for section in pairs(db.keys) do |
if rawget(sv, section) then |
-- global is special, all other sections have sub-entrys |
-- also don't delete empty profiles on main dbs, only on namespaces |
if section ~= "global" and (section ~= "profiles" or rawget(db, "parent")) then |
for key in pairs(sv[section]) do |
if not next(sv[section][key]) then |
sv[section][key] = nil |
end |
end |
end |
if not next(sv[section]) then |
sv[section] = nil |
end |
end |
end |
end |
end |
end |
AceDB.frame:RegisterEvent("PLAYER_LOGOUT") |
AceDB.frame:SetScript("OnEvent", logoutHandler) |
--[[------------------------------------------------------------------------- |
AceDB Object Method Definitions |
---------------------------------------------------------------------------]] |
--- Sets the defaults table for the given database object by clearing any |
-- that are currently set, and then setting the new defaults. |
-- @param defaults A table of defaults for this database |
function DBObjectLib:RegisterDefaults(defaults) |
if defaults and type(defaults) ~= "table" then |
error("Usage: AceDBObject:RegisterDefaults(defaults): 'defaults' - table or nil expected.", 2) |
end |
validateDefaults(defaults, self.keys) |
-- Remove any currently set defaults |
if self.defaults then |
for section,key in pairs(self.keys) do |
if self.defaults[section] and rawget(self, section) then |
removeDefaults(self[section], self.defaults[section]) |
end |
end |
end |
-- Set the DBObject.defaults table |
self.defaults = defaults |
-- Copy in any defaults, only touching those sections already created |
if defaults then |
for section,key in pairs(self.keys) do |
if defaults[section] and rawget(self, section) then |
copyDefaults(self[section], defaults[section]) |
end |
end |
end |
end |
--- Changes the profile of the database and all of it's namespaces to the |
-- supplied named profile |
-- @param name The name of the profile to set as the current profile |
function DBObjectLib:SetProfile(name) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:SetProfile(name): 'name' - string expected.", 2) |
end |
-- changing to the same profile, dont do anything |
if name == self.keys.profile then return end |
local oldProfile = self.profile |
local defaults = self.defaults and self.defaults.profile |
-- Callback: OnProfileShutdown, database |
self.callbacks:Fire("OnProfileShutdown", self) |
if oldProfile and defaults then |
-- Remove the defaults from the old profile |
removeDefaults(oldProfile, defaults) |
end |
self.profile = nil |
self.keys["profile"] = name |
-- if the storage exists, save the new profile |
-- this won't exist on namespaces. |
if self.sv.profileKeys then |
self.sv.profileKeys[charKey] = name |
end |
-- populate to child namespaces |
if self.children then |
for _, db in pairs(self.children) do |
DBObjectLib.SetProfile(db, name) |
end |
end |
-- Callback: OnProfileChanged, database, newProfileKey |
self.callbacks:Fire("OnProfileChanged", self, name) |
end |
--- Returns a table with the names of the existing profiles in the database. |
-- You can optionally supply a table to re-use for this purpose. |
-- @param tbl A table to store the profile names in (optional) |
function DBObjectLib:GetProfiles(tbl) |
if tbl and type(tbl) ~= "table" then |
error("Usage: AceDBObject:GetProfiles(tbl): 'tbl' - table or nil expected.", 2) |
end |
-- Clear the container table |
if tbl then |
for k,v in pairs(tbl) do tbl[k] = nil end |
else |
tbl = {} |
end |
local curProfile = self.keys.profile |
local i = 0 |
for profileKey in pairs(self.profiles) do |
i = i + 1 |
tbl[i] = profileKey |
if curProfile and profileKey == curProfile then curProfile = nil end |
end |
-- Add the current profile, if it hasn't been created yet |
if curProfile then |
i = i + 1 |
tbl[i] = curProfile |
end |
return tbl, i |
end |
--- Returns the current profile name used by the database |
function DBObjectLib:GetCurrentProfile() |
return self.keys.profile |
end |
--- Deletes a named profile. This profile must not be the active profile. |
-- @param name The name of the profile to be deleted |
-- @param silent If true, do not raise an error when the profile does not exist |
function DBObjectLib:DeleteProfile(name, silent) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:DeleteProfile(name): 'name' - string expected.", 2) |
end |
if self.keys.profile == name then |
error("Cannot delete the active profile in an AceDBObject.", 2) |
end |
if not rawget(self.profiles, name) and not silent then |
error("Cannot delete profile '" .. name .. "'. It does not exist.", 2) |
end |
self.profiles[name] = nil |
-- populate to child namespaces |
if self.children then |
for _, db in pairs(self.children) do |
DBObjectLib.DeleteProfile(db, name, true) |
end |
end |
-- Callback: OnProfileDeleted, database, profileKey |
self.callbacks:Fire("OnProfileDeleted", self, name) |
end |
--- Copies a named profile into the current profile, overwriting any conflicting |
-- settings. |
-- @param name The name of the profile to be copied into the current profile |
-- @param silent If true, do not raise an error when the profile does not exist |
function DBObjectLib:CopyProfile(name, silent) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:CopyProfile(name): 'name' - string expected.", 2) |
end |
if name == self.keys.profile then |
error("Cannot have the same source and destination profiles.", 2) |
end |
if not rawget(self.profiles, name) and not silent then |
error("Cannot copy profile '" .. name .. "'. It does not exist.", 2) |
end |
-- Reset the profile before copying |
DBObjectLib.ResetProfile(self, nil, true) |
local profile = self.profile |
local source = self.profiles[name] |
copyTable(source, profile) |
-- populate to child namespaces |
if self.children then |
for _, db in pairs(self.children) do |
DBObjectLib.CopyProfile(db, name, true) |
end |
end |
-- Callback: OnProfileCopied, database, sourceProfileKey |
self.callbacks:Fire("OnProfileCopied", self, name) |
end |
--- Resets the current profile to the default values (if specified). |
-- @param noChildren if set to true, the reset will not be populated to the child namespaces of this DB object |
-- @param noCallbacks if set to true, won't fire the OnProfileReset callback |
function DBObjectLib:ResetProfile(noChildren, noCallbacks) |
local profile = self.profile |
for k,v in pairs(profile) do |
profile[k] = nil |
end |
local defaults = self.defaults and self.defaults.profile |
if defaults then |
copyDefaults(profile, defaults) |
end |
-- populate to child namespaces |
if self.children and not noChildren then |
for _, db in pairs(self.children) do |
DBObjectLib.ResetProfile(db, nil, noCallbacks) |
end |
end |
-- Callback: OnProfileReset, database |
if not noCallbacks then |
self.callbacks:Fire("OnProfileReset", self) |
end |
end |
--- Resets the entire database, using the string defaultProfile as the new default |
-- profile. |
-- @param defaultProfile The profile name to use as the default |
function DBObjectLib:ResetDB(defaultProfile) |
if defaultProfile and type(defaultProfile) ~= "string" then |
error("Usage: AceDBObject:ResetDB(defaultProfile): 'defaultProfile' - string or nil expected.", 2) |
end |
local sv = self.sv |
for k,v in pairs(sv) do |
sv[k] = nil |
end |
local parent = self.parent |
initdb(sv, self.defaults, defaultProfile, self) |
-- fix the child namespaces |
if self.children then |
if not sv.namespaces then sv.namespaces = {} end |
for name, db in pairs(self.children) do |
if not sv.namespaces[name] then sv.namespaces[name] = {} end |
initdb(sv.namespaces[name], db.defaults, self.keys.profile, db, self) |
end |
end |
-- Callback: OnDatabaseReset, database |
self.callbacks:Fire("OnDatabaseReset", self) |
-- Callback: OnProfileChanged, database, profileKey |
self.callbacks:Fire("OnProfileChanged", self, self.keys["profile"]) |
return self |
end |
--- Creates a new database namespace, directly tied to the database. This |
-- is a full scale database in it's own rights other than the fact that |
-- it cannot control its profile individually |
-- @param name The name of the new namespace |
-- @param defaults A table of values to use as defaults |
function DBObjectLib:RegisterNamespace(name, defaults) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - string expected.", 2) |
end |
if defaults and type(defaults) ~= "table" then |
error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'defaults' - table or nil expected.", 2) |
end |
if self.children and self.children[name] then |
error ("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - a namespace with that name already exists.", 2) |
end |
local sv = self.sv |
if not sv.namespaces then sv.namespaces = {} end |
if not sv.namespaces[name] then |
sv.namespaces[name] = {} |
end |
local newDB = initdb(sv.namespaces[name], defaults, self.keys.profile, nil, self) |
if not self.children then self.children = {} end |
self.children[name] = newDB |
return newDB |
end |
--- Returns an already existing namespace from the database object. |
-- @param name The name of the new namespace |
-- @param silent if true, the addon is optional, silently return nil if its not found |
-- @usage |
-- local namespace = self.db:GetNamespace('namespace') |
-- @return the namespace object if found |
function DBObjectLib:GetNamespace(name, silent) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:GetNamespace(name): 'name' - string expected.", 2) |
end |
if not silent and not (self.children and self.children[name]) then |
error ("Usage: AceDBObject:GetNamespace(name): 'name' - namespace does not exist.", 2) |
end |
if not self.children then self.children = {} end |
return self.children[name] |
end |
--[[------------------------------------------------------------------------- |
AceDB Exposed Methods |
---------------------------------------------------------------------------]] |
--- Creates a new database object that can be used to handle database settings and profiles. |
-- By default, an empty DB is created, using a character specific profile. |
-- |
-- You can override the default profile used by passing any profile name as the third argument, |
-- or by passing //true// as the third argument to use a globally shared profile called "Default". |
-- |
-- Note that there is no token replacement in the default profile name, passing a defaultProfile as "char" |
-- will use a profile named "char", and not a character-specific profile. |
-- @param tbl The name of variable, or table to use for the database |
-- @param defaults A table of database defaults |
-- @param defaultProfile The name of the default profile. If not set, a character specific profile will be used as the default. |
-- You can also pass //true// to use a shared global profile called "Default". |
-- @usage |
-- -- Create an empty DB using a character-specific default profile. |
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB") |
-- @usage |
-- -- Create a DB using defaults and using a shared default profile |
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
function AceDB:New(tbl, defaults, defaultProfile) |
if type(tbl) == "string" then |
local name = tbl |
tbl = _G[name] |
if not tbl then |
tbl = {} |
_G[name] = tbl |
end |
end |
if type(tbl) ~= "table" then |
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'tbl' - table expected.", 2) |
end |
if defaults and type(defaults) ~= "table" then |
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaults' - table expected.", 2) |
end |
if defaultProfile and type(defaultProfile) ~= "string" and defaultProfile ~= true then |
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaultProfile' - string or true expected.", 2) |
end |
return initdb(tbl, defaults, defaultProfile) |
end |
-- upgrade existing databases |
for db in pairs(AceDB.db_registry) do |
if not db.parent then |
for name,func in pairs(DBObjectLib) do |
db[name] = func |
end |
else |
db.RegisterDefaults = DBObjectLib.RegisterDefaults |
db.ResetProfile = DBObjectLib.ResetProfile |
end |
end |
-- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/wiki/LibStub for more info |
-- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke |
local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2 -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS! |
local LibStub = _G[LIBSTUB_MAJOR] |
if not LibStub or LibStub.minor < LIBSTUB_MINOR then |
LibStub = LibStub or {libs = {}, minors = {} } |
_G[LIBSTUB_MAJOR] = LibStub |
LibStub.minor = LIBSTUB_MINOR |
function LibStub:NewLibrary(major, minor) |
assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)") |
minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.") |
local oldminor = self.minors[major] |
if oldminor and oldminor >= minor then return nil end |
self.minors[major], self.libs[major] = minor, self.libs[major] or {} |
return self.libs[major], oldminor |
end |
function LibStub:GetLibrary(major, silent) |
if not self.libs[major] and not silent then |
error(("Cannot find a library instance of %q."):format(tostring(major)), 2) |
end |
return self.libs[major], self.minors[major] |
end |
function LibStub:IterateLibraries() return pairs(self.libs) end |
setmetatable(LibStub, { __call = LibStub.GetLibrary }) |
end |
LibDataBroker is a small WoW addon library designed to provide a "MVC":http://en.wikipedia.org/wiki/Model-view-controller interface for use in various addons. |
LDB's primary goal is to "detach" plugins for TitanPanel and FuBar from the display addon. |
Plugins can provide data into a simple table, and display addons can receive callbacks to refresh their display of this data. |
LDB also provides a place for addons to register "quicklaunch" functions, removing the need for authors to embed many large libraries to create minimap buttons. |
Users who do not wish to be "plagued" by these buttons simply do not install an addon to render them. |
Due to it's simple generic design, LDB can be used for any design where you wish to have an addon notified of changes to a table. |
h2. Links |
* "API documentation":http://github.com/tekkub/libdatabroker-1-1/wikis/api |
* "Data specifications":http://github.com/tekkub/libdatabroker-1-1/wikis/data-specifications |
* "Addons using LDB":http://github.com/tekkub/libdatabroker-1-1/wikis/addons-using-ldb |
assert(LibStub, "LibDataBroker-1.1 requires LibStub") |
assert(LibStub:GetLibrary("CallbackHandler-1.0", true), "LibDataBroker-1.1 requires CallbackHandler-1.0") |
local lib, oldminor = LibStub:NewLibrary("LibDataBroker-1.1", 4) |
if not lib then return end |
oldminor = oldminor or 0 |
lib.callbacks = lib.callbacks or LibStub:GetLibrary("CallbackHandler-1.0"):New(lib) |
lib.attributestorage, lib.namestorage, lib.proxystorage = lib.attributestorage or {}, lib.namestorage or {}, lib.proxystorage or {} |
local attributestorage, namestorage, callbacks = lib.attributestorage, lib.namestorage, lib.callbacks |
if oldminor < 2 then |
lib.domt = { |
__metatable = "access denied", |
__index = function(self, key) return attributestorage[self] and attributestorage[self][key] end, |
} |
end |
if oldminor < 3 then |
lib.domt.__newindex = function(self, key, value) |
if not attributestorage[self] then attributestorage[self] = {} end |
if attributestorage[self][key] == value then return end |
attributestorage[self][key] = value |
local name = namestorage[self] |
if not name then return end |
callbacks:Fire("LibDataBroker_AttributeChanged", name, key, value, self) |
callbacks:Fire("LibDataBroker_AttributeChanged_"..name, name, key, value, self) |
callbacks:Fire("LibDataBroker_AttributeChanged_"..name.."_"..key, name, key, value, self) |
callbacks:Fire("LibDataBroker_AttributeChanged__"..key, name, key, value, self) |
end |
end |
if oldminor < 2 then |
function lib:NewDataObject(name, dataobj) |
if self.proxystorage[name] then return end |
if dataobj then |
assert(type(dataobj) == "table", "Invalid dataobj, must be nil or a table") |
self.attributestorage[dataobj] = {} |
for i,v in pairs(dataobj) do |
self.attributestorage[dataobj][i] = v |
dataobj[i] = nil |
end |
end |
dataobj = setmetatable(dataobj or {}, self.domt) |
self.proxystorage[name], self.namestorage[dataobj] = dataobj, name |
self.callbacks:Fire("LibDataBroker_DataObjectCreated", name, dataobj) |
return dataobj |
end |
end |
if oldminor < 1 then |
function lib:DataObjectIterator() |
return pairs(self.proxystorage) |
end |
function lib:GetDataObjectByName(dataobjectname) |
return self.proxystorage[dataobjectname] |
end |
function lib:GetNameByDataObject(dataobject) |
return self.namestorage[dataobject] |
end |
end |
if oldminor < 4 then |
local next = pairs(attributestorage) |
function lib:pairs(dataobject_or_name) |
local t = type(dataobject_or_name) |
assert(t == "string" or t == "table", "Usage: ldb:pairs('dataobjectname') or ldb:pairs(dataobject)") |
local dataobj = self.proxystorage[dataobject_or_name] or dataobject_or_name |
assert(attributestorage[dataobj], "Data object not found") |
return next, attributestorage[dataobj], nil |
end |
local ipairs_iter = ipairs(attributestorage) |
function lib:ipairs(dataobject_or_name) |
local t = type(dataobject_or_name) |
assert(t == "string" or t == "table", "Usage: ldb:ipairs('dataobjectname') or ldb:ipairs(dataobject)") |
local dataobj = self.proxystorage[dataobject_or_name] or dataobject_or_name |
assert(attributestorage[dataobj], "Data object not found") |
return ipairs_iter, attributestorage[dataobj], 0 |
end |
end |
## Interface: 40300 |
## LoadOnDemand: 1 |
## Title: Lib: LibDataBroker-1.1 |
## Notes: LDB's primary goal is to "detach" plugins for TitanPanel and FuBar from the display addon. |
## Author: Tekkub |
## X-Website: http://github.com/tekkub/libdatabroker-1-1/ |
## X-Category: Library |
## X-License: All Rights Reserved |
Load.xml |
<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> |
--[[ $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. |
<Ui xsi:schemaLocation="http://www.blizzard.com/wow/ui/"> |
<Include file="CallbackHandler\CallbackHandler-1.0.xml"/> |
<Script file="LibDataBroker-1.1\LibDataBroker-1.1.lua"/> |
</Ui> |
<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> |
--[[ $Id: CallbackHandler-1.0.lua 965 2010-08-09 00:47:52Z mikk $ ]] |
local MAJOR, MINOR = "CallbackHandler-1.0", 6 |
local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR) |
if not CallbackHandler then return end -- No upgrade needed |
local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end} |
-- Lua APIs |
local tconcat = table.concat |
local assert, error, loadstring = assert, error, loadstring |
local setmetatable, rawset, rawget = setmetatable, rawset, rawget |
local next, select, pairs, type, tostring = next, select, pairs, type, tostring |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: geterrorhandler |
local xpcall = xpcall |
local function errorhandler(err) |
return geterrorhandler()(err) |
end |
local function CreateDispatcher(argCount) |
local code = [[ |
local next, xpcall, eh = ... |
local method, ARGS |
local function call() method(ARGS) end |
local function dispatch(handlers, ...) |
local index |
index, method = next(handlers) |
if not method then return end |
local OLD_ARGS = ARGS |
ARGS = ... |
repeat |
xpcall(call, eh) |
index, method = next(handlers, index) |
until not method |
ARGS = OLD_ARGS |
end |
return dispatch |
]] |
local ARGS, OLD_ARGS = {}, {} |
for i = 1, argCount do ARGS[i], OLD_ARGS[i] = "arg"..i, "old_arg"..i end |
code = code:gsub("OLD_ARGS", tconcat(OLD_ARGS, ", ")):gsub("ARGS", tconcat(ARGS, ", ")) |
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(next, xpcall, errorhandler) |
end |
local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
local dispatcher = CreateDispatcher(argCount) |
rawset(self, argCount, dispatcher) |
return dispatcher |
end}) |
-------------------------------------------------------------------------- |
-- CallbackHandler:New |
-- |
-- target - target object to embed public APIs in |
-- RegisterName - name of the callback registration API, default "RegisterCallback" |
-- UnregisterName - name of the callback unregistration API, default "UnregisterCallback" |
-- UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API. |
function CallbackHandler:New(target, RegisterName, UnregisterName, UnregisterAllName, OnUsed, OnUnused) |
-- TODO: Remove this after beta has gone out |
assert(not OnUsed and not OnUnused, "ACE-80: OnUsed/OnUnused are deprecated. Callbacks are now done to registry.OnUsed and registry.OnUnused") |
RegisterName = RegisterName or "RegisterCallback" |
UnregisterName = UnregisterName or "UnregisterCallback" |
if UnregisterAllName==nil then -- false is used to indicate "don't want this method" |
UnregisterAllName = "UnregisterAllCallbacks" |
end |
-- we declare all objects and exported APIs inside this closure to quickly gain access |
-- to e.g. function names, the "target" parameter, etc |
-- Create the registry object |
local events = setmetatable({}, meta) |
local registry = { recurse=0, events=events } |
-- registry:Fire() - fires the given event/message into the registry |
function registry:Fire(eventname, ...) |
if not rawget(events, eventname) or not next(events[eventname]) then return end |
local oldrecurse = registry.recurse |
registry.recurse = oldrecurse + 1 |
Dispatchers[select('#', ...) + 1](events[eventname], eventname, ...) |
registry.recurse = oldrecurse |
if registry.insertQueue and oldrecurse==0 then |
-- Something in one of our callbacks wanted to register more callbacks; they got queued |
for eventname,callbacks in pairs(registry.insertQueue) do |
local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten. |
for self,func in pairs(callbacks) do |
events[eventname][self] = func |
-- fire OnUsed callback? |
if first and registry.OnUsed then |
registry.OnUsed(registry, target, eventname) |
first = nil |
end |
end |
end |
registry.insertQueue = nil |
end |
end |
-- Registration of a callback, handles: |
-- self["method"], leads to self["method"](self, ...) |
-- self with function ref, leads to functionref(...) |
-- "addonId" (instead of self) with function ref, leads to functionref(...) |
-- all with an optional arg, which, if present, gets passed as first argument (after self if present) |
target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]]) |
if type(eventname) ~= "string" then |
error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2) |
end |
method = method or eventname |
local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten. |
if type(method) ~= "string" and type(method) ~= "function" then |
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2) |
end |
local regfunc |
if type(method) == "string" then |
-- self["method"] calling style |
if type(self) ~= "table" then |
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2) |
elseif self==target then |
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2) |
elseif type(self[method]) ~= "function" then |
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2) |
end |
if select("#",...)>=1 then -- this is not the same as testing for arg==nil! |
local arg=select(1,...) |
regfunc = function(...) self[method](self,arg,...) end |
else |
regfunc = function(...) self[method](self,...) end |
end |
else |
-- function ref with self=object or self="addonId" or self=thread |
if type(self)~="table" and type(self)~="string" and type(self)~="thread" then |
error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string or thread expected.", 2) |
end |
if select("#",...)>=1 then -- this is not the same as testing for arg==nil! |
local arg=select(1,...) |
regfunc = function(...) method(arg,...) end |
else |
regfunc = method |
end |
end |
if events[eventname][self] or registry.recurse<1 then |
-- if registry.recurse<1 then |
-- we're overwriting an existing entry, or not currently recursing. just set it. |
events[eventname][self] = regfunc |
-- fire OnUsed callback? |
if registry.OnUsed and first then |
registry.OnUsed(registry, target, eventname) |
end |
else |
-- we're currently processing a callback in this registry, so delay the registration of this new entry! |
-- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency |
registry.insertQueue = registry.insertQueue or setmetatable({},meta) |
registry.insertQueue[eventname][self] = regfunc |
end |
end |
-- Unregister a callback |
target[UnregisterName] = function(self, eventname) |
if not self or self==target then |
error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2) |
end |
if type(eventname) ~= "string" then |
error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2) |
end |
if rawget(events, eventname) and events[eventname][self] then |
events[eventname][self] = nil |
-- Fire OnUnused callback? |
if registry.OnUnused and not next(events[eventname]) then |
registry.OnUnused(registry, target, eventname) |
end |
end |
if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then |
registry.insertQueue[eventname][self] = nil |
end |
end |
-- OPTIONAL: Unregister all callbacks for given selfs/addonIds |
if UnregisterAllName then |
target[UnregisterAllName] = function(...) |
if select("#",...)<1 then |
error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2) |
end |
if select("#",...)==1 and ...==target then |
error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2) |
end |
for i=1,select("#",...) do |
local self = select(i,...) |
if registry.insertQueue then |
for eventname, callbacks in pairs(registry.insertQueue) do |
if callbacks[self] then |
callbacks[self] = nil |
end |
end |
end |
for eventname, callbacks in pairs(events) do |
if callbacks[self] then |
callbacks[self] = nil |
-- Fire OnUnused callback? |
if registry.OnUnused and not next(callbacks) then |
registry.OnUnused(registry, target, eventname) |
end |
end |
end |
end |
end |
end |
return registry |
end |
-- CallbackHandler purposefully does NOT do explicit embedding. Nor does it |
-- try to upgrade old implicit embeds since the system is selfcontained and |
-- relies on closures to work. |
--- **AceHook-3.0** offers safe Hooking/Unhooking of functions, methods and frame scripts. |
-- Using AceHook-3.0 is recommended when you need to unhook your hooks again, so the hook chain isn't broken |
-- when you manually restore the original function. |
-- |
-- **AceHook-3.0** can be embeded into your addon, either explicitly by calling AceHook:Embed(MyAddon) or by |
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object |
-- and can be accessed directly, without having to explicitly call AceHook itself.\\ |
-- It is recommended to embed AceHook, otherwise you'll have to specify a custom `self` on all calls you |
-- make into AceHook. |
-- @class file |
-- @name AceHook-3.0 |
-- @release $Id: AceHook-3.0.lua 877 2009-11-02 15:56:50Z nevcairiel $ |
local ACEHOOK_MAJOR, ACEHOOK_MINOR = "AceHook-3.0", 5 |
local AceHook, oldminor = LibStub:NewLibrary(ACEHOOK_MAJOR, ACEHOOK_MINOR) |
if not AceHook then return end -- No upgrade needed |
AceHook.embeded = AceHook.embeded or {} |
AceHook.registry = AceHook.registry or setmetatable({}, {__index = function(tbl, key) tbl[key] = {} return tbl[key] end }) |
AceHook.handlers = AceHook.handlers or {} |
AceHook.actives = AceHook.actives or {} |
AceHook.scripts = AceHook.scripts or {} |
AceHook.onceSecure = AceHook.onceSecure or {} |
AceHook.hooks = AceHook.hooks or {} |
-- local upvalues |
local registry = AceHook.registry |
local handlers = AceHook.handlers |
local actives = AceHook.actives |
local scripts = AceHook.scripts |
local onceSecure = AceHook.onceSecure |
-- Lua APIs |
local pairs, next, type = pairs, next, type |
local format = string.format |
local assert, error = assert, error |
-- WoW APIs |
local issecurevariable, hooksecurefunc = issecurevariable, hooksecurefunc |
local _G = _G |
-- functions for later definition |
local donothing, createHook, hook |
local protectedScripts = { |
OnClick = true, |
} |
-- upgrading of embeded is done at the bottom of the file |
local mixins = { |
"Hook", "SecureHook", |
"HookScript", "SecureHookScript", |
"Unhook", "UnhookAll", |
"IsHooked", |
"RawHook", "RawHookScript" |
} |
-- AceHook:Embed( target ) |
-- target (object) - target object to embed AceHook in |
-- |
-- Embeds AceEevent into the target object making the functions from the mixins list available on target:.. |
function AceHook:Embed( target ) |
for k, v in pairs( mixins ) do |
target[v] = self[v] |
end |
self.embeded[target] = true |
-- inject the hooks table safely |
target.hooks = target.hooks or {} |
return target |
end |
-- AceHook:OnEmbedDisable( target ) |
-- target (object) - target object that is being disabled |
-- |
-- Unhooks all hooks when the target disables. |
-- this method should be called by the target manually or by an addon framework |
function AceHook:OnEmbedDisable( target ) |
target:UnhookAll() |
end |
function createHook(self, handler, orig, secure, failsafe) |
local uid |
local method = type(handler) == "string" |
if failsafe and not secure then |
-- failsafe hook creation |
uid = function(...) |
if actives[uid] then |
if method then |
self[handler](self, ...) |
else |
handler(...) |
end |
end |
return orig(...) |
end |
-- /failsafe hook |
else |
-- all other hooks |
uid = function(...) |
if actives[uid] then |
if method then |
return self[handler](self, ...) |
else |
return handler(...) |
end |
elseif not secure then -- backup on non secure |
return orig(...) |
end |
end |
-- /hook |
end |
return uid |
end |
function donothing() end |
function hook(self, obj, method, handler, script, secure, raw, forceSecure, usage) |
if not handler then handler = method end |
-- These asserts make sure AceHooks's devs play by the rules. |
assert(not script or type(script) == "boolean") |
assert(not secure or type(secure) == "boolean") |
assert(not raw or type(raw) == "boolean") |
assert(not forceSecure or type(forceSecure) == "boolean") |
assert(usage) |
-- Error checking Battery! |
if obj and type(obj) ~= "table" then |
error(format("%s: 'object' - nil or table expected got %s", usage, type(obj)), 3) |
end |
if type(method) ~= "string" then |
error(format("%s: 'method' - string expected got %s", usage, type(method)), 3) |
end |
if type(handler) ~= "string" and type(handler) ~= "function" then |
error(format("%s: 'handler' - nil, string, or function expected got %s", usage, type(handler)), 3) |
end |
if type(handler) == "string" and type(self[handler]) ~= "function" then |
error(format("%s: 'handler' - Handler specified does not exist at self[handler]", usage), 3) |
end |
if script then |
if not secure and obj:IsProtected() and protectedScripts[method] then |
error(format("Cannot hook secure script %q; Use SecureHookScript(obj, method, [handler]) instead.", method), 3) |
end |
if not obj or not obj.GetScript or not obj:HasScript(method) then |
error(format("%s: You can only hook a script on a frame object", usage), 3) |
end |
else |
local issecure |
if obj then |
issecure = onceSecure[obj] and onceSecure[obj][method] or issecurevariable(obj, method) |
else |
issecure = onceSecure[method] or issecurevariable(method) |
end |
if issecure then |
if forceSecure then |
if obj then |
onceSecure[obj] = onceSecure[obj] or {} |
onceSecure[obj][method] = true |
else |
onceSecure[method] = true |
end |
elseif not secure then |
error(format("%s: Attempt to hook secure function %s. Use `SecureHook' or add `true' to the argument list to override.", usage, method), 3) |
end |
end |
end |
local uid |
if obj then |
uid = registry[self][obj] and registry[self][obj][method] |
else |
uid = registry[self][method] |
end |
if uid then |
if actives[uid] then |
-- Only two sane choices exist here. We either a) error 100% of the time or b) always unhook and then hook |
-- choice b would likely lead to odd debuging conditions or other mysteries so we're going with a. |
error(format("Attempting to rehook already active hook %s.", method)) |
end |
if handlers[uid] == handler then -- turn on a decative hook, note enclosures break this ability, small memory leak |
actives[uid] = true |
return |
elseif obj then -- is there any reason not to call unhook instead of doing the following several lines? |
if self.hooks and self.hooks[obj] then |
self.hooks[obj][method] = nil |
end |
registry[self][obj][method] = nil |
else |
if self.hooks then |
self.hooks[method] = nil |
end |
registry[self][method] = nil |
end |
handlers[uid], actives[uid], scripts[uid] = nil, nil, nil |
uid = nil |
end |
local orig |
if script then |
orig = obj:GetScript(method) or donothing |
elseif obj then |
orig = obj[method] |
else |
orig = _G[method] |
end |
if not orig then |
error(format("%s: Attempting to hook a non existing target", usage), 3) |
end |
uid = createHook(self, handler, orig, secure, not (raw or secure)) |
if obj then |
self.hooks[obj] = self.hooks[obj] or {} |
registry[self][obj] = registry[self][obj] or {} |
registry[self][obj][method] = uid |
if not secure then |
self.hooks[obj][method] = orig |
end |
if script then |
-- If the script is empty before, HookScript will not work, so use SetScript instead |
-- This will make the hook insecure, but shouldnt matter, since it was empty before. |
-- It does not taint the full frame. |
if not secure or orig == donothing then |
obj:SetScript(method, uid) |
elseif secure then |
obj:HookScript(method, uid) |
end |
else |
if not secure then |
obj[method] = uid |
else |
hooksecurefunc(obj, method, uid) |
end |
end |
else |
registry[self][method] = uid |
if not secure then |
_G[method] = uid |
self.hooks[method] = orig |
else |
hooksecurefunc(method, uid) |
end |
end |
actives[uid], handlers[uid], scripts[uid] = true, handler, script and true or nil |
end |
--- Hook a function or a method on an object. |
-- The hook created will be a "safe hook", that means that your handler will be called |
-- before the hooked function ("Pre-Hook"), and you don't have to call the original function yourself, |
-- however you cannot stop the execution of the function, or modify any of the arguments/return values.\\ |
-- This type of hook is typically used if you need to know if some function got called, and don't want to modify it. |
-- @paramsig [object], method, [handler], [hookSecure] |
-- @param object The object to hook a method from |
-- @param method If object was specified, the name of the method, or the name of the function to hook. |
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function) |
-- @param hookSecure If true, AceHook will allow hooking of secure functions. |
-- @usage |
-- -- create an addon with AceHook embeded |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0") |
-- |
-- function MyAddon:OnEnable() |
-- -- Hook ActionButton_UpdateHotkeys, overwriting the secure status |
-- self:Hook("ActionButton_UpdateHotkeys", true) |
-- end |
-- |
-- function MyAddon:ActionButton_UpdateHotkeys(button, type) |
-- print(button:GetName() .. " is updating its HotKey") |
-- end |
function AceHook:Hook(object, method, handler, hookSecure) |
if type(object) == "string" then |
method, handler, hookSecure, object = object, method, handler, nil |
end |
if handler == true then |
handler, hookSecure = nil, true |
end |
hook(self, object, method, handler, false, false, false, hookSecure or false, "Usage: Hook([object], method, [handler], [hookSecure])") |
end |
--- RawHook a function or a method on an object. |
-- The hook created will be a "raw hook", that means that your handler will completly replace |
-- the original function, and your handler has to call the original function (or not, depending on your intentions).\\ |
-- The original function will be stored in `self.hooks[object][method]` or `self.hooks[functionName]` respectively.\\ |
-- This type of hook can be used for all purposes, and is usually the most common case when you need to modify arguments |
-- or want to control execution of the original function. |
-- @paramsig [object], method, [handler], [hookSecure] |
-- @param object The object to hook a method from |
-- @param method If object was specified, the name of the method, or the name of the function to hook. |
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function) |
-- @param hookSecure If true, AceHook will allow hooking of secure functions. |
-- @usage |
-- -- create an addon with AceHook embeded |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0") |
-- |
-- function MyAddon:OnEnable() |
-- -- Hook ActionButton_UpdateHotkeys, overwriting the secure status |
-- self:RawHook("ActionButton_UpdateHotkeys", true) |
-- end |
-- |
-- function MyAddon:ActionButton_UpdateHotkeys(button, type) |
-- if button:GetName() == "MyButton" then |
-- -- do stuff here |
-- else |
-- self.hooks.ActionButton_UpdateHotkeys(button, type) |
-- end |
-- end |
function AceHook:RawHook(object, method, handler, hookSecure) |
if type(object) == "string" then |
method, handler, hookSecure, object = object, method, handler, nil |
end |
if handler == true then |
handler, hookSecure = nil, true |
end |
hook(self, object, method, handler, false, false, true, hookSecure or false, "Usage: RawHook([object], method, [handler], [hookSecure])") |
end |
--- SecureHook a function or a method on an object. |
-- This function is a wrapper around the `hooksecurefunc` function in the WoW API. Using AceHook |
-- extends the functionality of secure hooks, and adds the ability to unhook once the hook isn't |
-- required anymore, or the addon is being disabled.\\ |
-- Secure Hooks should be used if the secure-status of the function is vital to its function, |
-- and taint would block execution. Secure Hooks are always called after the original function was called |
-- ("Post Hook"), and you cannot modify the arguments, return values or control the execution. |
-- @paramsig [object], method, [handler] |
-- @param object The object to hook a method from |
-- @param method If object was specified, the name of the method, or the name of the function to hook. |
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked function) |
function AceHook:SecureHook(object, method, handler) |
if type(object) == "string" then |
method, handler, object = object, method, nil |
end |
hook(self, object, method, handler, false, true, false, false, "Usage: SecureHook([object], method, [handler])") |
end |
--- Hook a script handler on a frame. |
-- The hook created will be a "safe hook", that means that your handler will be called |
-- before the hooked script ("Pre-Hook"), and you don't have to call the original function yourself, |
-- however you cannot stop the execution of the function, or modify any of the arguments/return values.\\ |
-- This is the frame script equivalent of the :Hook safe-hook. It would typically be used to be notified |
-- when a certain event happens to a frame. |
-- @paramsig frame, script, [handler] |
-- @param frame The Frame to hook the script on |
-- @param script The script to hook |
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script) |
-- @usage |
-- -- create an addon with AceHook embeded |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0") |
-- |
-- function MyAddon:OnEnable() |
-- -- Hook the OnShow of FriendsFrame |
-- self:HookScript(FriendsFrame, "OnShow", "FriendsFrameOnShow") |
-- end |
-- |
-- function MyAddon:FriendsFrameOnShow(frame) |
-- print("The FriendsFrame was shown!") |
-- end |
function AceHook:HookScript(frame, script, handler) |
hook(self, frame, script, handler, true, false, false, false, "Usage: HookScript(object, method, [handler])") |
end |
--- RawHook a script handler on a frame. |
-- The hook created will be a "raw hook", that means that your handler will completly replace |
-- the original script, and your handler has to call the original script (or not, depending on your intentions).\\ |
-- The original script will be stored in `self.hooks[frame][script]`.\\ |
-- This type of hook can be used for all purposes, and is usually the most common case when you need to modify arguments |
-- or want to control execution of the original script. |
-- @paramsig frame, script, [handler] |
-- @param frame The Frame to hook the script on |
-- @param script The script to hook |
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script) |
-- @usage |
-- -- create an addon with AceHook embeded |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0") |
-- |
-- function MyAddon:OnEnable() |
-- -- Hook the OnShow of FriendsFrame |
-- self:RawHookScript(FriendsFrame, "OnShow", "FriendsFrameOnShow") |
-- end |
-- |
-- function MyAddon:FriendsFrameOnShow(frame) |
-- -- Call the original function |
-- self.hooks[frame].OnShow(frame) |
-- -- Do our processing |
-- -- .. stuff |
-- end |
function AceHook:RawHookScript(frame, script, handler) |
hook(self, frame, script, handler, true, false, true, false, "Usage: RawHookScript(object, method, [handler])") |
end |
--- SecureHook a script handler on a frame. |
-- This function is a wrapper around the `frame:HookScript` function in the WoW API. Using AceHook |
-- extends the functionality of secure hooks, and adds the ability to unhook once the hook isn't |
-- required anymore, or the addon is being disabled.\\ |
-- Secure Hooks should be used if the secure-status of the function is vital to its function, |
-- and taint would block execution. Secure Hooks are always called after the original function was called |
-- ("Post Hook"), and you cannot modify the arguments, return values or control the execution. |
-- @paramsig frame, script, [handler] |
-- @param frame The Frame to hook the script on |
-- @param script The script to hook |
-- @param handler The handler for the hook, a funcref or a method name. (Defaults to the name of the hooked script) |
function AceHook:SecureHookScript(frame, script, handler) |
hook(self, frame, script, handler, true, true, false, false, "Usage: SecureHookScript(object, method, [handler])") |
end |
--- Unhook from the specified function, method or script. |
-- @paramsig [obj], method |
-- @param obj The object or frame to unhook from |
-- @param method The name of the method, function or script to unhook from. |
function AceHook:Unhook(obj, method) |
local usage = "Usage: Unhook([obj], method)" |
if type(obj) == "string" then |
method, obj = obj, nil |
end |
if obj and type(obj) ~= "table" then |
error(format("%s: 'obj' - expecting nil or table got %s", usage, type(obj)), 2) |
end |
if type(method) ~= "string" then |
error(format("%s: 'method' - expeting string got %s", usage, type(method)), 2) |
end |
local uid |
if obj then |
uid = registry[self][obj] and registry[self][obj][method] |
else |
uid = registry[self][method] |
end |
if not uid or not actives[uid] then |
-- Declining to error on an unneeded unhook since the end effect is the same and this would just be annoying. |
return false |
end |
actives[uid], handlers[uid] = nil, nil |
if obj then |
registry[self][obj][method] = nil |
registry[self][obj] = next(registry[self][obj]) and registry[self][obj] or nil |
-- if the hook reference doesnt exist, then its a secure hook, just bail out and dont do any unhooking |
if not self.hooks[obj] or not self.hooks[obj][method] then return true end |
if scripts[uid] and obj:GetScript(method) == uid then -- unhooks scripts |
obj:SetScript(method, self.hooks[obj][method] ~= donothing and self.hooks[obj][method] or nil) |
scripts[uid] = nil |
elseif obj and self.hooks[obj] and self.hooks[obj][method] and obj[method] == uid then -- unhooks methods |
obj[method] = self.hooks[obj][method] |
end |
self.hooks[obj][method] = nil |
self.hooks[obj] = next(self.hooks[obj]) and self.hooks[obj] or nil |
else |
registry[self][method] = nil |
-- if self.hooks[method] doesn't exist, then this is a SecureHook, just bail out |
if not self.hooks[method] then return true end |
if self.hooks[method] and _G[method] == uid then -- unhooks functions |
_G[method] = self.hooks[method] |
end |
self.hooks[method] = nil |
end |
return true |
end |
--- Unhook all existing hooks for this addon. |
function AceHook:UnhookAll() |
for key, value in pairs(registry[self]) do |
if type(key) == "table" then |
for method in pairs(value) do |
self:Unhook(key, method) |
end |
else |
self:Unhook(key) |
end |
end |
end |
--- Check if the specific function, method or script is already hooked. |
-- @paramsig [obj], method |
-- @param obj The object or frame to unhook from |
-- @param method The name of the method, function or script to unhook from. |
function AceHook:IsHooked(obj, method) |
-- we don't check if registry[self] exists, this is done by evil magicks in the metatable |
if type(obj) == "string" then |
if registry[self][obj] and actives[registry[self][obj]] then |
return true, handlers[registry[self][obj]] |
end |
else |
if registry[self][obj] and registry[self][obj][method] and actives[registry[self][obj][method]] then |
return true, handlers[registry[self][obj][method]] |
end |
end |
return false, nil |
end |
--- Upgrade our old embeded |
for target, v in pairs( AceHook.embeded ) do |
AceHook:Embed( target ) |
end |
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
..\FrameXML\UI.xsd"> |
<Script file="AceHook-3.0.lua"/> |
</Ui> |
local SoopUIConfig = LibStub("AceAddon-3.0"):NewAddon("SoopUIConfig", "AceConsole-3.0", "AceEvent-3.0") |
local LSM = LibStub("LibSharedMedia-3.0") |
local db |
local defaults |
SoopUIConfig.panel = CreateFrame("Frame","SoopUIPanel",UIParent); |
InterfaceOptions_AddCategory(SoopUIConfig.panel); |
local L = setmetatable({}, { __index = function(t,k) |
local v = tostring(k) |
rawset(t, k, v) |
return v |
end }) |
function SoopUIConfig:LoadDefaults() |
local S, _, Soop = unpack(SoopUI) |
--Defaults |
defaults = { |
profile = { |
media = Soop["media"], |
general = Soop["general"], |
datatext = Soop["datatext"], |
merchant = Soop["merchant"], |
minimap = Soop["minimap"], |
quest = Soop["quest"], |
tooltip = Soop["tooltip"], |
}, |
} |
end |
function SoopUIConfig:OnInitialize() |
SoopUIConfig:RegisterChatCommand("sui", "ShowConfig") |
SoopUIConfig:RegisterChatCommand("soopui", "ShowConfig") |
SLASH_SOOPUI1 = "/soopui" |
SLASH_SOOPUI2 = "/sui" |
self.OnInitialize = nil |
end |
function SoopUIConfig:ShowConfig(arg) |
InterfaceOptionsFrame_OpenToCategory("SoopUI") |
InterfaceOptionsFrame_OpenToCategory("SoopUI") |
end |
function SoopUIConfig:Load() |
self:LoadDefaults() |
-- Create savedvariables |
self.db = LibStub("AceDB-3.0"):New("SoopUIConfig", defaults) |
self.db.RegisterCallback(self, "OnProfileChanged", "RefreshConfig") |
self.db.RegisterCallback(self, "OnProfileCopied", "RefreshConfig") |
self.db.RegisterCallback(self, "OnProfileReset", "RefreshConfig") |
db = self.db.profile |
self:SetupOptions() |
end |
function SoopUIConfig:RefreshConfig(db, name) |
db = self.db.profile |
self:Print("Profile changed.") |
end |
function SoopUIConfig:SetupOptions() |
LibStub("AceConfigRegistry-3.0"):RegisterOptionsTable("SoopUIConfig", self.GenerateOptions) |
--Create Profiles Table |
self.profileOptions = LibStub("AceDBOptions-3.0"):GetOptionsTable(self.db); |
LibStub("AceConfig-3.0"):RegisterOptionsTable("SoopUIProfiles", self.profileOptions) |
local ACD3 = LibStub("AceConfigDialog-3.0") |
self.optionsFrame = ACD3:AddToBlizOptions("SoopUIConfig", L["SoopUI"], nil, "general") |
self.optionsFrame = ACD3:AddToBlizOptions("SoopUIConfig", L["Media"], "SoopUI", "media") |
self.optionsFrame = ACD3:AddToBlizOptions("SoopUIConfig", L["DataText"], "SoopUI", "datatext") |
self.optionsFrame = ACD3:AddToBlizOptions("SoopUIConfig", L["Merchant"], "SoopUI", "merchant") |
self.optionsFrame = ACD3:AddToBlizOptions("SoopUIConfig", L["Minimap"], "SoopUI", "minimap") |
self.optionsFrame = ACD3:AddToBlizOptions("SoopUIConfig", L["Quest"], "SoopUI", "quest") |
self.optionsFrame = ACD3:AddToBlizOptions("SoopUIConfig", L["Tooltip"], "SoopUI", "tooltip") |
self.optionsFrame = ACD3:AddToBlizOptions("SoopUIProfiles", L["Profiles"], "SoopUI") |
self.SetupOptions = nil |
end |
function SoopUIConfig.GenerateOptions() |
if SoopUIConfig.noconfig then assert(false, SoopUIConfig.noconfig) end |
if not SoopUIConfig.Options then |
SoopUIConfig.GenerateOptionsInternal() |
SoopUIConfig.GenerateOptionsInternal = nil |
end |
return SoopUIConfig.Options |
end |
function SoopUIConfig.GenerateOptionsInternal() |
local S, C, Soop = unpack(SoopUI) |
StaticPopupDialogs["CFG_RELOAD"] = { |
text = L["One or more of the changes you have made require a ReloadUI."], |
button1 = ACCEPT, |
button2 = CANCEL, |
OnAccept = function() ReloadUI() end, |
timeout = 0, |
whileDead = 1, |
} |
----------------------- |
-- Options Order Chart |
----------------------- |
-- toggle = 1 |
-- select = 2 |
-- color = 3 |
-- range = 4 |
-- group = 5 |
SoopUIConfig.Options = { |
type = "group", |
name = "SoopUI", |
handler = SoopUI, |
childGroups = "tree", |
args = { |
Header = { |
type = "header", |
order = 1, |
name = L["Welcome to the SoopUI3 Configuration Menu"], |
width = "full", |
}, |
Text = { |
type = "header", |
order = 2, |
name = L["When changes are made a Reload of the UI is needed."], |
width = "full", |
}, |
sep1 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
Text2 = { |
type = "description", |
order = 4, |
name = L["Currently still in alpha phase"], |
width = "full", |
fontSize = "large", |
}, |
Text3 = { |
type = "description", |
order = 5, |
name = L["There might, be bugs"], |
width = "full", |
fontSize = "large", |
}, |
sep2 = { |
type = "description", |
order = 6, |
name = " ", |
}, |
media = { |
type = "group", |
order = 0, |
name = L["Media"], |
desc = L["Media Module for SoopUI"], |
childGroups = "tree", |
get = function(info) return db.media[ info[#info] ] end, |
set = function(info, value) db.media[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
font = { |
type = 'select', |
order = 2, |
name = L["SoopUI Font"], |
desc = L["The font that the core of the UI will use"], |
dialogControl = 'LSM30_Font', --Select your widget here |
values = AceGUIWidgetLSMlists.font, |
}, |
fontSize = { |
type = "range", |
order = 4, |
name = L["Game Font Size"], |
desc = L["Controls the Size of the Game Font"], |
min = 0, max = 30, step = 1, |
}, |
fontxSmall = { |
type = "range", |
order = 4, |
name = L["Font Extra Small"], |
desc = L["Controls the Size of the Extra Small Font"], |
min = 0, max = 30, step = 1, |
}, |
fontSmall = { |
type = "range", |
order = 4, |
name = L["Font Small"], |
desc = L["Controls the Size of the Small Font"], |
min = 0, max = 30, step = 1, |
}, |
fontMedium = { |
type = "range", |
order = 4, |
name = L["Font Medium"], |
desc = L["Controls the Size of Medium Font"], |
min = 0, max = 30, step = 1, |
}, |
fontLarge = { |
type = "range", |
order = 4, |
name = L["Font Large"], |
desc = L["Controls the Size of the Large Font"], |
min = 0, max = 30, step = 1, |
}, |
fontHuge = { |
type = "range", |
order = 4, |
name = L["Font Huge"], |
desc = L["Controls the Size of the Huge Font"], |
min = 0, max = 30, step = 1, |
}, |
}, |
}, |
-------------------------------------------------------------- |
-- General Options |
-------------------------------------------------------------- |
general = { |
type = "group", |
order = 1, |
name = L["General"], |
desc = L["General Modules for SoopUI"], |
childGroups = "tree", |
get = function(info) return db.general[ info[#info] ] end, |
set = function(info, value) db.general[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
autogreed = { |
type = "toggle", |
order = 1, |
name = L["Autogreed"], |
desc = L["Enables Automatically rolling greed on green items when in a instance."], |
}, |
interrupts = { |
type = "toggle", |
order = 1, |
name = L["interrupts"], |
desc = L["Enables announcing your interrupts"], |
}, |
classcolor = { |
type = "toggle", |
order = 1, |
name = L["Class Color"], |
desc = L["Use your classcolor for border and some text color."], |
}, |
color = { |
type = "color", |
order = 3, |
name = L["UI Border Color"], |
desc = L["Picks the UI Border Color if Class Color is not used."], |
disabled = function() return db.general.classcolor end, |
get = function(info) |
local rc = db.general[ info[#info] ] |
return rc.r, rc.g, rc.b |
end, |
set = function(info, r, g, b) |
db.general[ info[#info] ] = {} |
local rc = db.general[ info[#info] ] |
rc.r, rc.g, rc.b = r, g, b |
StaticPopup_Show("CFG_RELOAD") |
end, |
}, |
}, |
}, |
-------------------------------------------------------------- |
-- Datatext Options |
------------------------------------------------------------------------------ |
datatext = { |
type = "group", |
order = 5, |
name = L["Datatext"], |
desc = L["Datatext Module for SoopUI."], |
childGroups = "tree", |
get = function(info) return db.datatext[ info[#info] ] end, |
set = function(info, value) db.datatext[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
--------------------------- |
--Option Type Separators |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
enable = { |
type = "toggle", |
order = 0, |
name = L["Enable"], |
desc = L["Enables Datatext Module."], |
}, |
time24 = { |
type = "toggle", |
order = 1, |
name = L["24-Hour Time"], |
desc = L["Display time datatext on a 24 hour time scale"], |
disabled = function() return not db.datatext.enable end, |
}, |
battleground = { |
type = "toggle", |
order = 1, |
name = L["Battleground Text"], |
desc = L["Display special datatexts when inside a battleground"], |
disabled = function() return not db.datatext.enable end, |
}, |
top = { |
type = "toggle", |
order = 1, |
name = L["Datapanel Top"], |
desc = L["If checked then panel moves to top of screen, If unchecked panel moves below MainMenuBar"], |
disabled = function() return not db.datatext.enable end, |
}, |
localtime = { |
type = "toggle", |
order = 1, |
name = L["Local Time"], |
desc = L["Display local time instead of server time"], |
disabled = function() return not db.datatext.enable end, |
}, |
fontsize = { |
type = "range", |
order = 4, |
name = L["Font Scale"], |
desc = L["Font size for datatexts"], |
min = 9, max = 25, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
DataGroup = { |
type = "group", |
order = 5, |
name = L["Text Positions"], |
disabled = function() return not db.datatext.enable end, |
args = { |
--------------------------- |
--Option Type Seperators |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
calltoarms = { |
type = "range", |
order = 4, |
name = L["Call to Arms"], |
desc = L["Display the active roles that will recieve a reward for completing a random dungeon"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
coords = { |
type = "range", |
order = 4, |
name = L["Coordinates"], |
desc = L["Display Player's Coordinates"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
dur = { |
type = "range", |
order = 4, |
name = L["Durability"], |
desc = L["Display your current durability"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
friends = { |
type = "range", |
order = 4, |
name = L["Friends"], |
desc = L["Display current online friends"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
guild = { |
type = "range", |
order = 4, |
name = L["Guild"], |
desc = L["Display current online people in guild"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
pro = { |
type = "range", |
order = 4, |
name = L["Professions"], |
desc = L["Display Professions"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
spec = { |
type = "range", |
order = 4, |
name = L["Talent Spec"], |
desc = L["Display current spec"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
stat1 = { |
type = "range", |
order = 4, |
name = L["Stat #1"], |
desc = L["Display stat based on your role (Avoidance-Tank, AP-Melee, SP/HP-Caster)"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
stat2 = { |
type = "range", |
order = 4, |
name = L["Stat #2"], |
desc = L["Display stat based on your role (Armor-Tank, Crit-Melee, Crit-Caster)"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
system = { |
type = "range", |
order = 4, |
name = L["System"], |
desc = L["Display FPS and Latency"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
wowtime = { |
type = "range", |
order = 4, |
name = L["Time"], |
desc = L["Display current time"]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
zone = { |
type = "range", |
order = 4, |
name = L["Zone"], |
desc = L["Display Player's Current Zone."]..L["\n\n0 - Disabled\n1 - POSITION #1\n2 - POSITION #2\n3 - POSITION #3\n4 - POSITION #4\n5 - POSITION #5\n6 - POSITION #6\n7 - POSITION #7\n8 - POSITION #8\n9 - POSITION #9"], |
min = 0, max = 9, step = 1, |
disabled = function() return not db.datatext.enable end, |
}, |
}, |
}, |
}, |
}, |
merchant = { |
type = "group", |
order = 6, |
name = L["Merchant"], |
desc = L["Merchant Module for SoopUI."], |
childGroups = "tree", |
get = function(info) return db.merchant[ info[#info] ] end, |
set = function(info, value) db.merchant[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
--------------------------- |
--Option Type Separators |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
enable = { |
type = "toggle", |
order = 0, |
name = L["Enable"], |
desc = L["Enable Merchant Settings"], |
width = "full", |
}, |
autoRepair = { |
type = "toggle", |
order = 1, |
name = L["Auto Repair"], |
desc = L["Automatically repair when visiting a vendor"], |
disabled = function() return not db.merchant.enable end, |
}, |
autoSellGrey = { |
type = "toggle", |
order = 1, |
name = L["Sell Grays"], |
desc = L["Automatically sell gray items when visiting a vendor"], |
disabled = function() return not db.merchant.enable end, |
}, |
sellMisc = { |
type = "toggle", |
order = 1, |
name = L["Sell Misc Items"], |
desc = L["Automatically sell a user selected item."], |
disabled = function() return not db.merchant.enable end, |
}, |
}, |
}, |
----------------------------------------------------------------------------- |
minimap = { |
type = "group", |
order = 7, |
name = L["Minimap"], |
desc = L["Enables Minimap Modifications."], |
get = function(info) return db.minimap[ info[#info] ] end, |
set = function(info, value) db.minimap[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
--------------------------- |
--Option Type Separators |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
enable = { |
type = "toggle", |
order = 0, |
name = L["Enable"], |
desc = L["Enables Minimap Modifications."], |
width = "full" |
}, |
farm = { |
type = "toggle", |
order = 1, |
name = L["Farming"], |
desc = L["Enlarges the Minimap when Farming."], |
disabled = function() return not db.minimap.enable end, |
}, |
farmscale = { |
type = "range", |
order = 4, |
name = L["Farming Map Scale"], |
desc = L["Controls the Size of the Farming Map"], |
disabled = function() return not db.minimap.enable or not db.minimap.farm end, |
min = 1, max = 5, step = 0.1, |
}, |
gameclock = { |
type = "toggle", |
order = 1, |
name = L["Game Clock"], |
desc = L["Enable the Clock Frame on Minimap."], |
disabled = function() return not db.minimap.enable end, |
}, |
border = { |
type = "select", |
order = 2, |
name = L["Border Style"], |
desc = L["Style of Border for Minimap."], |
disabled = function() return not db.minimap.enable end, |
dialogControl = 'LSM30_Border', --Select your widget here |
values = AceGUIWidgetLSMlists.border, |
}, |
zoneText = { |
type = "toggle", |
order = 1, |
name = L["Zone Text"], |
desc = L["Enable Mouseover Zone Text."], |
disabled = function() return not db.minimap.enable end, |
}, |
instanceDifficulty = { |
type = "toggle", |
order = 1, |
name = L["Instance Difficulty"], |
desc = L["Enable Mouseover Instance Difficulty."], |
disabled = function() return not db.minimap.enable end, |
}, |
}, |
}, |
------------------------------------------------------------------- |
quest = { |
type = "group", |
order = 10, |
name = L["|Quest"], |
desc = L["Quest Module for SoopUI."], |
childGroups = "tree", |
get = function(info) return db.quest[ info[#info] ] end, |
set = function(info, value) db.quest[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
--------------------------- |
--Option Type Separators |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
enable = { |
type = "toggle", |
order = 0, |
name = L["Enable"], |
desc = L["Enables Quest Module"], |
}, |
autocomplete = { |
type = "toggle", |
order = 1, |
name = L["Autocomplete"], |
desc = L["Automatically complete your quest."], |
disabled = function() return not db.quest.enable end, |
}, |
}, |
}, |
----------------------------------------------------------- |
tooltip = { |
type = "group", |
order = 12, |
name = L["Tooltip"], |
desc = L["Tooltip Module for SoopUI"], |
childGroups = "tree", |
get = function(info) return db.tooltip[ info[#info] ] end, |
set = function(info, value) db.tooltip[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
--------------------------- |
--Option Type Separators |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
enable = { |
type = "toggle", |
order = 0, |
name = L["Enable"], |
desc = L["Enables Tooltip Module"], |
}, |
disableFade = { |
type = "toggle", |
order = 1, |
name = L["Disable Fade"], |
desc = L["Disables Tooltip Fade."], |
disabled = function() return not db.tooltip.enable end, |
}, |
border = { |
type = "select", |
order = 2, |
name = L["Border Style"], |
desc = L["Style of Border for Tooltip."], |
disabled = function() return not db.tooltip.enable end, |
dialogControl = 'LSM30_Border', --Select your widget here |
values = AceGUIWidgetLSMlists.border, |
}, |
background = { |
type = "select", |
order = 2, |
name = L["Background Style"], |
desc = L["Style of Background for Tooltip."], |
disabled = function() return not db.tooltip.enable end, |
dialogControl = 'LSM30_Background', --Select your widget here |
values = AceGUIWidgetLSMlists.background, |
}, |
statusbar = { |
type = "select", |
order = 2, |
name = L["Statusbar Style"], |
desc = L["Style of Statusbar for Tooltip."], |
disabled = function() return not db.tooltip.enable end, |
dialogControl = 'LSM30_Statusbar', --Select your widget here |
values = AceGUIWidgetLSMlists.statusbar, |
}, |
reactionBorderColor = { |
type = "toggle", |
order = 1, |
name = L["Reaction Border Color"], |
desc = L["Colors the borders match targets classcolors."], |
disabled = function() return not db.tooltip.enable end, |
}, |
itemqualityBorderColor = { |
type = "toggle", |
order = 1, |
name = L["Item Quality Border Color"], |
desc = L["Colors the border of the tooltip to match the items quality."], |
disabled = function() return not db.tooltip.enable end, |
}, |
showPlayerTitles = { |
type = "toggle", |
order = 1, |
name = L["Player Titles"], |
desc = L["Shows players title in tooltip."], |
disabled = function() return not db.tooltip.enable end, |
}, |
showPVPIcons = { |
type = "toggle", |
order = 1, |
name = L["PVP Icons"], |
desc = L["Shows PvP Icons in tooltip."], |
disabled = function() return not db.tooltip.enable end, |
}, |
abbrevRealmNames = { |
type = "toggle", |
order = 1, |
name = L["Abberviate Realm Names"], |
desc = L["Abberviates Players Realm Name."], |
disabled = function() return not db.tooltip.enable end, |
}, |
showMouseoverTarget = { |
type = "toggle", |
order = 1, |
name = L["Mouseover Target"], |
desc = L["Shows mouseover target."], |
disabled = function() return not db.tooltip.enable end, |
}, |
showItemLevel = { |
type = "toggle", |
order = 1, |
name = L["Item Level"], |
desc = L["Shows targets average item level."], |
disabled = function() return not db.tooltip.enable end, |
}, |
healthbar = { |
type = "group", |
order = 5, |
name = L["Healthbar"], |
desc = L["Players Healthbar Options."], |
guiInline = true, |
disabled = function() return not db.tooltip.enable end, |
get = function(info) return db.tooltip.healthbar[ info[#info] ] end, |
set = function(info, value) db.tooltip.healthbar[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
--------------------------- |
--Option Type Separators |
sep1 = { |
type = "description", |
order = 2, |
name = " ", |
}, |
sep2 = { |
type = "description", |
order = 3, |
name = " ", |
}, |
sep3 = { |
type = "description", |
order = 4, |
name = " ", |
}, |
sep4 = { |
type = "description", |
order = 5, |
name = " ", |
}, |
--------------------------- |
showHealthValue = { |
type = "toggle", |
order = 1, |
name = L["Health Value"], |
desc = L["Shows health value over healthbar."], |
disabled = function() return not db.tooltip.enable end, |
}, |
showOutline = { |
type = "toggle", |
order = 1, |
name = L["Font Outline"], |
desc = L["Adds a font outline to health value."], |
disabled = function() return not db.tooltip.enable end, |
}, |
reactionColoring = { |
type = "toggle", |
order = 1, |
name = L["Reaction Coloring"], |
desc = L["Change healthbar color to targets classcolor. (Overides Custom Color)"], |
disabled = function() return not db.tooltip.enable end, |
}, |
custom = { |
type = "group", |
order = 5, |
name = L["Custom"], |
desc = L["Custom Coloring"], |
guiInline = true, |
disabled = function() return not db.tooltip.enable end, |
get = function(info) return db.tooltip.healthbar.custom[ info[#info] ] end, |
set = function(info, value) db.tooltip.healthbar.custom[ info[#info] ] = value; StaticPopup_Show("CFG_RELOAD") end, |
args = { |
--------------------------- |
--Option Type Seperators |
sep1 = { |
type = "description", |
name = " ", |
order = 2, |
}, |
sep2 = { |
type = "description", |
name = " ", |
order = 3, |
}, |
sep3 = { |
type = "description", |
name = " ", |
order = 4, |
}, |
sep4 = { |
type = "description", |
name = " ", |
order = 5, |
}, |
--------------------------- |
apply = { |
type = "toggle", |
order = 1, |
name = L["Apply Custom Color"], |
desc = L["Use the Custom Color you have chosen."], |
disabled = function() return not db.tooltip.enable end, |
}, |
color = { |
type = "color", |
order = 3, |
name = L["Custom Color"], |
desc = L["Picks a Custom Color for the tooltip border."], |
hasAlpha = false, |
disabled = function() return not db.tooltip.healthbar.custom.apply or not db.tooltip.enable end, |
get = function(info) |
local hb = db.tooltip.healthbar.custom[ info[#info] ] |
return hb.r, hb.g, hb.b |
end, |
set = function(info, r, g, b) |
db.tooltip.healthbar.custom[ info[#info] ] = {} |
local hb = db.tooltip.healthbar.custom[ info[#info] ] |
hb.r, hb.g, hb.b = r, g, b |
end, |
}, |
}, |
}, |
textPos = { |
type = "select", |
order = 2, |
name = L["Text Position"], |
desc = L["Health Value Position."], |
disabled = function() return not db.tooltip.enable end, |
values = S.regions; |
}, |
fontSize= { |
type = "range", |
order = 4, |
name = L["Font Size"], |
desc = L["Controls the healthbar value font size."], |
min = 8, max = 25, step = 1, |
disabled = function() return not db.tooltip.enable end, |
}, |
}, |
}, |
}, |
}, |
}, |
} |
end |
function SoopUIConfig:SetDefaultOptions() |
local S, _, _ = unpack(SoopUI) |
local addon = self.db.profile; |
addon.media = { |
["font"] = "Express", |
['fontSize'] = 14, |
['fontxSmall'] = 10, |
["fontSmall"] = 12, |
['fontMedium'] = 14, |
['fontLarge'] = 16, |
['fontHuge'] = 20, |
} |
addon.general = { |
["color"] = { r = 1, g = 1, b = 1}, |
["classcolor"] = true, |
["interrupts"] = true, |
["autogreed"] = true, |
} |
addon.datatext = { |
["enable"] = true, |
-- Datapanel Media |
['border'] = "Fer09", |
['background'] = "Blizzard Dialog Background", |
["top"] = false, |
["fontsize"] = 11, |
["system"] = 5, |
["wowtime"] = 4, |
["guild"] = 3, |
["dur"] = 8, |
["friends"] = 2, |
["spec"] = 6, |
["zone"] = 0, |
["coords"] = 7, |
["pro"] = 4, |
["stat1"] = 1, |
["stat2"] = 3, |
["calltoarms"] = 6, |
-- Color Datatext |
["colors"] = { |
["classcolor"] = true, |
["color"] = { r = 0, g = 0, b = 1}, |
}, |
["battleground"] = true, |
-- Clock Settings |
["time24"] = false, |
["localtime"] = true, |
-- FPS Settings |
["fps"] = { |
["enable"] = true, |
-- ONLY ONE OF THESE CAN BE TRUE |
["home"] = false, |
["world"] = false, |
["both"] = true, |
}, |
} |
addon.merchant = { |
['enable'] = true, |
['sellMisc'] = true, |
['autoSellGrey'] = true, |
['autoRepair'] = true, |
} |
addon.minimap = { |
['enable'] = true, |
['border'] = "Blizzard Dialog", |
['gameclock'] = true, |
['farm'] = false, |
['farmscale'] = 3, |
['zoneText'] = true, |
['instanceDifficulty'] = false, |
} |
addon.quest = { |
['enable'] = true, |
['autocomplete'] = false, |
} |
addon.tooltip = { |
["enable"] = true, |
["disableFade"] = false, |
['border'] = "Blizzard Dialog", |
['background'] = "Black", |
['statusbar'] = "Blizzard", |
["reactionBorderColor"] = true, |
["itemqualityBorderColor"] = true, |
["showPlayerTitles"] = true, |
["showPVPIcons"] = false, |
["abbrevRealmNames"] = false, |
["showMouseoverTarget"] = true, |
["showItemLevel"] = true, |
["healthbar"] = { |
["showHealthValue"] = true, |
["showOutline"] = false, |
["textPos"] = "CENTER", |
["reactionColoring"] = false, |
["customColorapply"] = false, |
["custom"] = { |
["apply"] = false, |
["color"] = { r = 1, g = 1, b = 0}, |
}, |
["fontSize"] = 14, |
}, |
} |
end |
## Interface: 50400 |
## Author: Soopie |
## Title: SoopUI_Config |
## RequiredDeps: SoopUI |
## SavedVariables: SoopUIConfig |
## OptionalDeps: SharedMedia, SharedMediaAdditionalFonts |
Libs\Libs.xml |
SoopUI_Config.lua |
--[[----------------------------------------------------------------------------- |
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) |
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 |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameFontNormal |
---------------- |
-- Main Frame -- |
---------------- |
--[[ |
Events : |
OnClose |
]] |
do |
local Type = "Window" |
local Version = 4 |
local function frameOnClose(this) |
this.obj:Fire("OnClose") |
end |
local function closeOnClick(this) |
PlaySound("gsTitleOptionExit") |
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("OnHide",frameOnClose) |
frame:SetMinResize(240,240) |
frame:SetToplevel(true) |
local titlebg = frame:CreateTexture(nil, "BACKGROUND") |
titlebg:SetTexture([[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([[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([[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([[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([[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([[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([[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([[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([[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([[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("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("Interface\\Tooltips\\UI-Tooltip-Border") |
local 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 |
--[[----------------------------------------------------------------------------- |
DropdownGroup Container |
Container controlled by a dropdown on the top. |
-------------------------------------------------------------------------------]] |
local Type, Version = "DropdownGroup", 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 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) |
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) |
--[[----------------------------------------------------------------------------- |
ScrollFrame Container |
Plain container that scrolls its content and doesn't grow in height. |
-------------------------------------------------------------------------------]] |
local Type, Version = "ScrollFrame", 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, assert, type = pairs, assert, type |
local min, max, floor, abs = math.min, math.max, math.floor, math.abs |
-- 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:FixScroll() |
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 = 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 |
local curvalue = self.scrollbar:GetValue() |
-- 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") |
self:DoLayout() |
end |
else |
if not self.scrollBarShown then |
self.scrollBarShown = true |
self.scrollbar:Show() |
self.scrollframe:SetPoint("BOTTOMRIGHT", -20, 0) |
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) |
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 |
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:SetTexture(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) |
--[[----------------------------------------------------------------------------- |
TreeGroup Container |
Container that uses a tree control to switch between groups. |
-------------------------------------------------------------------------------]] |
local Type, Version = "TreeGroup", 34 |
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, floor |
local select, tremove, unpack, tconcat = select, table.remove, unpack, table.concat |
-- WoW APIs |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameTooltip, FONT_COLOR_CODE_CLOSE |
-- 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 frame = self.frame |
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 |
local normalTexture = button:GetNormalTexture() |
local line = button.line |
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("Interface\\Buttons\\UI-PlusButton-UP") |
toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN") |
else |
toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP") |
toggle:SetPushedTexture("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() |
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 |
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 |
GameTooltip:SetOwner(frame, "ANCHOR_NONE") |
GameTooltip:SetPoint("LEFT",frame,"RIGHT") |
GameTooltip:SetText(frame.text:GetText() or "", 1, .82, 0, 1) |
GameTooltip:Show() |
end |
end |
local function Button_OnLeave(frame) |
local self = frame.obj |
self:Fire("OnButtonLeave", frame.uniquevalue, frame) |
if self.enabletooltips then |
GameTooltip: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 = value |
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 frame = 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:SetPoint("TOPLEFT", frame, "TOPLEFT",0,0) |
treeframe:SetPoint("BOTTOMLEFT", frame, "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) |
end, |
["OnRelease"] = function(self) |
self.status = 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) |
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 |
local hasChildren = self.hasChildren |
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) |
local buttons = self.buttons |
local lines = self.lines |
for i, v in ipairs(buttons) do |
v:Hide() |
end |
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 |
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 |
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 |
treeframe:SetMaxResize(maxtreewidth, 1600) |
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 = 0, |
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) |
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) |
treeframe:SetMinResize(100, 1) |
treeframe:SetMaxResize(400, 1600) |
treeframe:SetScript("OnUpdate", FirstFrameUpdate) |
treeframe:SetScript("OnSizeChanged", Tree_OnSizeChanged) |
treeframe:SetScript("OnMouseWheel", Tree_OnMouseWheel) |
local dragger = CreateFrame("Frame", nil, treeframe) |
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:SetTexture(0,0,0,0.4) |
local border = CreateFrame("Frame",nil,frame) |
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) |
--[[----------------------------------------------------------------------------- |
Button Widget |
Graphical Button. |
-------------------------------------------------------------------------------]] |
local Type, Version = "Button", 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 _G = _G |
local PlaySound, CreateFrame, UIParent = PlaySound, CreateFrame, UIParent |
local wowMoP |
do |
local _, _, _, interface = GetBuildInfo() |
wowMoP = (interface >= 50000) |
end |
--[[----------------------------------------------------------------------------- |
Scripts |
-------------------------------------------------------------------------------]] |
local function Button_OnClick(frame, ...) |
AceGUI:ClearFocus() |
PlaySound("igMainMenuOption") |
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:SetText() |
end, |
-- ["OnRelease"] = nil, |
["SetText"] = function(self, text) |
self.text:SetText(text) |
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, wowMoP and "UIPanelButtonTemplate" or "UIPanelButtonTemplate2") |
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) |
--[[ $Id: AceGUIWidget-DropDown-Items.lua 996 2010-12-01 18:34:17Z 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 = 1000, |
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("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("OVERLAY") |
check:SetWidth(16) |
check:SetHeight(16) |
check:SetPoint("LEFT",frame,"LEFT",3,-1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:Hide() |
self.check = check |
local sub = frame:CreateTexture("OVERLAY") |
sub:SetWidth(16) |
sub:SetHeight(16) |
sub:SetPoint("RIGHT",frame,"RIGHT",-3,-1) |
sub:SetTexture("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 = 3 |
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("igMainMenuOptionCheckBoxOn") |
else |
PlaySound("igMainMenuOptionCheckBoxOff") |
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 = 1 |
-- 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:SetTexture(.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 |
--[[----------------------------------------------------------------------------- |
ColorPicker Widget |
-------------------------------------------------------------------------------]] |
local Type, Version = "ColorPicker", 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 |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: ShowUIPanel, HideUIPanel, ColorPickerFrame, OpacitySliderFrame |
--[[----------------------------------------------------------------------------- |
Support functions |
-------------------------------------------------------------------------------]] |
local function ColorCallback(self, r, g, b, a, isAlpha) |
if not self.HasAlpha then |
a = 1 |
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) |
HideUIPanel(ColorPickerFrame) |
local self = frame.obj |
if not self.disabled then |
ColorPickerFrame:SetFrameStrata("FULLSCREEN_DIALOG") |
ColorPickerFrame.func = function() |
local r, g, b = ColorPickerFrame:GetColorRGB() |
local a = 1 - OpacitySliderFrame:GetValue() |
ColorCallback(self, r, g, b, a) |
end |
ColorPickerFrame.hasOpacity = self.HasAlpha |
ColorPickerFrame.opacityFunc = function() |
local r, g, b = ColorPickerFrame:GetColorRGB() |
local a = 1 - OpacitySliderFrame:GetValue() |
ColorCallback(self, r, g, b, a, true) |
end |
local r, g, b, a = self.r, self.g, self.b, self.a |
if self.HasAlpha then |
ColorPickerFrame.opacity = 1 - (a or 0) |
end |
ColorPickerFrame:SetColorRGB(r, g, b) |
ColorPickerFrame.cancelFunc = function() |
ColorCallback(self, r, g, b, a, true) |
end |
ShowUIPanel(ColorPickerFrame) |
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("Interface\\ChatFrame\\ChatFrameColorSwatch") |
colorSwatch:SetPoint("LEFT") |
local texture = frame:CreateTexture(nil, "BACKGROUND") |
texture:SetWidth(16) |
texture:SetHeight(16) |
texture:SetTexture(1, 1, 1) |
texture:SetPoint("CENTER", colorSwatch) |
texture:Show() |
local checkers = frame:CreateTexture(nil, "BACKGROUND") |
checkers:SetWidth(14) |
checkers:SetHeight(14) |
checkers:SetTexture("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("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) |
--[[----------------------------------------------------------------------------- |
InteractiveLabel Widget |
-------------------------------------------------------------------------------]] |
local Type, Version = "InteractiveLabel", 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 select, pairs = select, pairs |
-- WoW APIs |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameFontHighlightSmall |
--[[----------------------------------------------------------------------------- |
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) |
--[[----------------------------------------------------------------------------- |
Label Widget |
Displays text and optionally an icon. |
-------------------------------------------------------------------------------]] |
local Type, Version = "Label", 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 max, select, pairs = math.max, select, pairs |
-- WoW APIs |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameFontHighlightSmall |
--[[----------------------------------------------------------------------------- |
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:GetHeight() |
else |
-- image on the left |
image:SetPoint("TOPLEFT") |
if image:GetHeight() > label:GetHeight() 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:GetHeight()) |
end |
else |
-- no image shown |
label:SetPoint("TOPLEFT") |
label:SetWidth(width) |
height = label:GetHeight() |
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() |
-- 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) |
self.label:SetFont(font, height, flags) |
end, |
["SetFontObject"] = function(self, font) |
self:SetFont((font or GameFontHighlightSmall):GetFont()) |
end, |
["SetImageSize"] = function(self, width, height) |
self.image:SetWidth(width) |
self.image:SetHeight(height) |
UpdateImageAnchor(self) |
end, |
} |
--[[----------------------------------------------------------------------------- |
Constructor |
-------------------------------------------------------------------------------]] |
local function Constructor() |
local frame = CreateFrame("Frame", nil, UIParent) |
frame:Hide() |
local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlightSmall") |
label:SetJustifyH("LEFT") |
label:SetJustifyV("TOP") |
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) |
local Type, Version = "MultiLineEditBox", 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 GetCursorInfo, GetSpellInfo, ClearCursor = GetCursorInfo, GetSpellInfo, ClearCursor |
local CreateFrame, UIParent = CreateFrame, UIParent |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: ACCEPT, ChatFontNormal |
local wowMoP |
do |
local _, _, _, interface = GetBuildInfo() |
wowMoP = (interface >= 50000) |
end |
--[[----------------------------------------------------------------------------- |
Support functions |
-------------------------------------------------------------------------------]] |
if not AceGUIMultiLineEditBoxInsertLink then |
-- upgradeable hook |
hooksecurefunc("ChatEdit_InsertLink", function(...) return _G.AceGUIMultiLineEditBoxInsertLink(...) 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 = GetCursorInfo() |
if type == "spell" then |
info = GetSpellInfo(id, info) |
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 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, |
["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, wowMoP and "UIPanelButtonTemplate" or "UIPanelButtonTemplate2") |
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) |
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) |
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) |
--[[----------------------------------------------------------------------------- |
Slider Widget |
Graphical Slider, like, for Range values. |
-------------------------------------------------------------------------------]] |
local Type, Version = "Slider", 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 min, max, floor = math.min, math.max, math.floor |
local tonumber, pairs = tonumber, pairs |
-- WoW APIs |
local PlaySound = PlaySound |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameFontHighlightSmall |
--[[----------------------------------------------------------------------------- |
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, max = (self.min or 0), (self.max or 100) |
if self.ispercent then |
self.lowtext:SetFormattedText("%s%%", (min * 100)) |
self.hightext:SetFormattedText("%s%%", (max * 100)) |
else |
self.lowtext:SetText(min) |
self.hightext:SetText(max) |
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) |
local self = frame.obj |
if not frame.setup then |
local newvalue = frame:GetValue() |
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("igMainMenuOptionCheckBoxOn") |
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, max, step) |
local frame = self.slider |
frame.setup = true |
self.min = min |
self.max = max |
self.step = step |
frame:SetMinMaxValues(min or 0,max 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) |
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) |
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) |
--[[----------------------------------------------------------------------------- |
TabGroup Container |
Container that uses tabs on top to switch between groups. |
-------------------------------------------------------------------------------]] |
local Type, Version = "TabGroup", 35 |
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, wipe |
-- WoW APIs |
local PlaySound = PlaySound |
local CreateFrame, UIParent = CreateFrame, UIParent |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: PanelTemplates_TabResize, PanelTemplates_SetDisabledTabState, PanelTemplates_SelectTab, PanelTemplates_DeselectTab |
-- local upvalue storage used by BuildTabs |
local widths = {} |
local rowwidths = {} |
local rowends = {} |
--[[----------------------------------------------------------------------------- |
Support functions |
-------------------------------------------------------------------------------]] |
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("igCharacterInfoTab") |
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, "OptionsFrameTabButtonTemplate") |
tab.obj = self |
tab.id = id |
tab.text = _G[tabname .. "Text"] |
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 status = self.status or self.localstatus |
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) |
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) |
--[[----------------------------------------------------------------------------- |
Keybinding Widget |
Set Keybindings in the Config UI. |
-------------------------------------------------------------------------------]] |
local Type, Version = "Keybinding", 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 IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown = IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: NOT_BOUND |
local wowMoP |
do |
local _, _, _, interface = GetBuildInfo() |
wowMoP = (interface >= 50000) |
end |
--[[----------------------------------------------------------------------------- |
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) |
self.msgframe:Hide() |
frame:UnlockHighlight() |
self.waitingForKey = nil |
else |
frame:EnableKeyboard(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) |
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 |
--[[----------------------------------------------------------------------------- |
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) |
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, wowMoP and "UIPanelButtonTemplate" or "UIPanelButtonTemplate2") |
button:EnableMouse(true) |
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:SetPoint("BOTTOMLEFT") |
button:SetPoint("BOTTOMRIGHT") |
button:SetHeight(24) |
button:EnableKeyboard(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) |
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) |
--[[----------------------------------------------------------------------------- |
Checkbox Widget |
-------------------------------------------------------------------------------]] |
local Type, Version = "CheckBox", 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 select, pairs = select, pairs |
-- WoW APIs |
local PlaySound = PlaySound |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: SetDesaturation, GameFontHighlight |
--[[----------------------------------------------------------------------------- |
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("igMainMenuOptionCheckBoxOn") |
else -- for both nil and false (tristate) |
PlaySound("igMainMenuOptionCheckBoxOff") |
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:GetHeight()) |
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(self.check, false) |
self.check:Show() |
else |
--Nil is the unknown tristate value |
if self.tristate and value == nil then |
SetDesaturation(self.check, true) |
self.check:Show() |
else |
SetDesaturation(self.check, false) |
self.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("Interface\\Buttons\\UI-RadioButton") |
checkbg:SetTexCoord(0, 0.25, 0, 1) |
check:SetTexture("Interface\\Buttons\\UI-RadioButton") |
check:SetTexCoord(0.25, 0.5, 0, 1) |
check:SetBlendMode("ADD") |
highlight:SetTexture("Interface\\Buttons\\UI-RadioButton") |
highlight:SetTexCoord(0.5, 0.75, 0, 1) |
else |
size = 24 |
checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up") |
checkbg:SetTexCoord(0, 1, 0, 1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:SetTexCoord(0, 1, 0, 1) |
check:SetBlendMode("BLEND") |
highlight:SetTexture("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 desc = self.frame:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall") |
desc:ClearAllPoints() |
desc:SetPoint("TOPLEFT", self.checkbg, "TOPRIGHT", 5, -21) |
desc:SetWidth(self.frame.width - 30) |
desc:SetJustifyH("LEFT") |
desc:SetJustifyV("TOP") |
self.desc = desc |
end |
self.desc:Show() |
--self.text:SetFontObject(GameFontNormal) |
self.desc:SetText(desc) |
self:SetHeight(28 + self.desc:GetHeight()) |
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("Interface\\Buttons\\UI-CheckBox-Up") |
local check = frame:CreateTexture(nil, "OVERLAY") |
check:SetAllPoints(checkbg) |
check:SetTexture("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("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) |
--[[----------------------------------------------------------------------------- |
BlizOptionsGroup Container |
Simple container widget for the integration of AceGUI into the Blizzard Interface Options |
-------------------------------------------------------------------------------]] |
local Type, Version = "BlizOptionsGroup", 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 = 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 defaults(frame) |
frame.obj:Fire("defaults") |
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") |
frame:Hide() |
-- support functions for the Blizzard Interface Options |
frame.okay = okay |
frame.cancel = cancel |
frame.defaults = defaults |
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) |
--[[----------------------------------------------------------------------------- |
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, GetBuildInfo = CreateFrame, UIParent, GetBuildInfo |
--[[----------------------------------------------------------------------------- |
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("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 |
-- SetText is deprecated, but keep it around for a while. (say, to WoW 4.0) |
if (select(4, GetBuildInfo()) < 40000) then |
widget.SetText = widget.SetLabel |
else |
widget.SetText = function(self, ...) print("AceGUI-3.0-Icon: SetText is deprecated! Use SetLabel instead!"); self:SetLabel(...) end |
end |
return AceGUI:RegisterAsWidget(widget) |
end |
AceGUI:RegisterWidgetType(Type, Constructor, Version) |
--[[----------------------------------------------------------------------------- |
Frame Container |
-------------------------------------------------------------------------------]] |
local Type, Version = "Frame", 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, assert, type = pairs, assert, type |
local wipe = table.wipe |
-- WoW APIs |
local PlaySound = PlaySound |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: CLOSE |
--[[----------------------------------------------------------------------------- |
Scripts |
-------------------------------------------------------------------------------]] |
local function Button_OnClick(frame) |
PlaySound("gsTitleOptionExit") |
frame.obj:Hide() |
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: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) |
frame:Hide() |
frame:EnableMouse(true) |
frame:SetMovable(true) |
frame:SetResizable(true) |
frame:SetFrameStrata("FULLSCREEN_DIALOG") |
frame:SetBackdrop(FrameBackdrop) |
frame:SetBackdropColor(0, 0, 0, 1) |
frame:SetMinResize(400, 200) |
frame:SetToplevel(true) |
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) |
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("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("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("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("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("Interface\\Tooltips\\UI-Tooltip-Border") |
local 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) |
--[[----------------------------------------------------------------------------- |
InlineGroup Container |
Simple container widget that creates a visible "box" with an optional title. |
-------------------------------------------------------------------------------]] |
local Type, Version = "InlineGroup", 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, |
["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) |
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) |
--[[ $Id: AceGUIWidget-DropDown.lua 1029 2011-06-10 23:10:58Z nevcairiel $ ]]-- |
local AceGUI = LibStub("AceGUI-3.0") |
-- Lua APIs |
local min, max, floor = math.min, math.max, math.floor |
local select, pairs, ipairs, type = select, pairs, ipairs, type |
local tsort = table.sort |
-- WoW APIs |
local PlaySound = PlaySound |
local UIParent, CreateFrame = UIParent, CreateFrame |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: CLOSE |
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 = 3 |
--[[ 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 |
if i == 1 then |
item:SetPoint("TOP", itemFrame, "TOP", 0, -2) |
else |
item:SetPoint("TOP", items[i-1].frame, "BOTTOM", 0, 1) |
end |
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) |
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) |
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 = 25 |
--[[ Static data ]]-- |
--[[ UI event handler ]]-- |
local function Control_OnEnter(this) |
this.obj:Fire("OnEnter") |
end |
local function Control_OnLeave(this) |
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 |
PlaySound("igMainMenuOptionCheckBoxOn") -- missleading name, but the Blizzard code uses this sound |
if self.open then |
self.open = nil |
self.pullout:Close() |
AceGUI:ClearFocus() |
else |
self.open = true |
self.pullout:SetWidth(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 |
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() |
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.label:SetTextColor(0.5,0.5,0.5) |
else |
self.button: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,-18) |
self:SetHeight(44) |
self.alignoffset = 30 |
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) |
if self.list then |
self:SetText(self.list[value] or "") |
end |
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 SetList(self, list, order, itemType) |
self.list = list |
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) |
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) |
if self.list then |
self.list[value] = text |
AddListItem(self, value, text, itemType) |
end |
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 |
--[[ 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.alignoffset = 30 |
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 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 |
--[[----------------------------------------------------------------------------- |
EditBox Widget |
-------------------------------------------------------------------------------]] |
local Type, Version = "EditBox", 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 tostring, pairs = tostring, pairs |
-- WoW APIs |
local PlaySound = PlaySound |
local GetCursorInfo, ClearCursor, GetSpellInfo = GetCursorInfo, ClearCursor, GetSpellInfo |
local CreateFrame, UIParent = CreateFrame, UIParent |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: AceGUIEditBoxInsertLink, ChatFontNormal, OKAY |
--[[----------------------------------------------------------------------------- |
Support functions |
-------------------------------------------------------------------------------]] |
if not AceGUIEditBoxInsertLink then |
-- upgradeable hook |
hooksecurefunc("ChatEdit_InsertLink", function(...) return _G.AceGUIEditBoxInsertLink(...) 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("igMainMenuOptionCheckBoxOn") |
HideButton(self) |
end |
end |
local function EditBox_OnReceiveDrag(frame) |
local self = frame.obj |
local type, id, info = GetCursorInfo() |
if type == "item" then |
self:SetText(info) |
self:Fire("OnEnterPressed", info) |
ClearCursor() |
elseif type == "spell" then |
local name = GetSpellInfo(id, info) |
self:SetText(name) |
self:Fire("OnEnterPressed", name) |
ClearCursor() |
end |
HideButton(self) |
AceGUI:ClearFocus() |
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 |
} |
--[[----------------------------------------------------------------------------- |
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) |
--[[----------------------------------------------------------------------------- |
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("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("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) |
<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> |
--- **AceGUI-3.0** provides access to numerous widgets which can be used to create GUIs. |
-- AceGUI is used by AceConfigDialog to create the option GUIs, but you can use it by itself |
-- to create any custom GUI. There are more extensive examples in the test suite in the Ace3 |
-- stand-alone distribution. |
-- |
-- **Note**: When using AceGUI-3.0 directly, please do not modify the frames of the widgets directly, |
-- as any "unknown" change to the widgets will cause addons that get your widget out of the widget pool |
-- to misbehave. If you think some part of a widget should be modifiable, please open a ticket, and we"ll |
-- implement a proper API to modify it. |
-- @usage |
-- local AceGUI = LibStub("AceGUI-3.0") |
-- -- Create a container frame |
-- local f = AceGUI:Create("Frame") |
-- f:SetCallback("OnClose",function(widget) AceGUI:Release(widget) end) |
-- f:SetTitle("AceGUI-3.0 Example") |
-- f:SetStatusText("Status Bar") |
-- f:SetLayout("Flow") |
-- -- Create a button |
-- local btn = AceGUI:Create("Button") |
-- btn:SetWidth(170) |
-- btn:SetText("Button !") |
-- btn:SetCallback("OnClick", function() print("Click!") end) |
-- -- Add the button to the container |
-- f:AddChild(btn) |
-- @class file |
-- @name AceGUI-3.0 |
-- @release $Id: AceGUI-3.0.lua 924 2010-05-13 15:12:20Z nevcairiel $ |
local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 33 |
local AceGUI, oldminor = LibStub:NewLibrary(ACEGUI_MAJOR, ACEGUI_MINOR) |
if not AceGUI then return end -- No upgrade needed |
-- Lua APIs |
local tconcat, tremove, tinsert = table.concat, table.remove, table.insert |
local select, pairs, next, type = select, pairs, next, type |
local error, assert, loadstring = error, assert, loadstring |
local setmetatable, rawget, rawset = setmetatable, rawget, rawset |
local math_max = math.max |
-- WoW APIs |
local UIParent = UIParent |
-- 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, LibStub |
--local con = LibStub("AceConsole-3.0",true) |
AceGUI.WidgetRegistry = AceGUI.WidgetRegistry or {} |
AceGUI.LayoutRegistry = AceGUI.LayoutRegistry or {} |
AceGUI.WidgetBase = AceGUI.WidgetBase or {} |
AceGUI.WidgetContainerBase = AceGUI.WidgetContainerBase or {} |
AceGUI.WidgetVersions = AceGUI.WidgetVersions or {} |
-- local upvalues |
local WidgetRegistry = AceGUI.WidgetRegistry |
local LayoutRegistry = AceGUI.LayoutRegistry |
local WidgetVersions = AceGUI.WidgetVersions |
--[[ |
xpcall safecall implementation |
]] |
local xpcall = xpcall |
local function errorhandler(err) |
return geterrorhandler()(err) |
end |
local function CreateDispatcher(argCount) |
local code = [[ |
local xpcall, eh = ... |
local method, ARGS |
local function call() return method(ARGS) end |
local function dispatch(func, ...) |
method = func |
if not method then return end |
ARGS = ... |
return xpcall(call, eh) |
end |
return dispatch |
]] |
local ARGS = {} |
for i = 1, argCount do ARGS[i] = "arg"..i end |
code = code:gsub("ARGS", tconcat(ARGS, ", ")) |
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler) |
end |
local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
local dispatcher = CreateDispatcher(argCount) |
rawset(self, argCount, dispatcher) |
return dispatcher |
end}) |
Dispatchers[0] = function(func) |
return xpcall(func, errorhandler) |
end |
local function safecall(func, ...) |
return Dispatchers[select("#", ...)](func, ...) |
end |
-- Recycling functions |
local newWidget, delWidget |
do |
-- Version Upgrade in Minor 29 |
-- Internal Storage of the objects changed, from an array table |
-- to a hash table, and additionally we introduced versioning on |
-- the widgets which would discard all widgets from a pre-29 version |
-- anyway, so we just clear the storage now, and don't try to |
-- convert the storage tables to the new format. |
-- This should generally not cause *many* widgets to end up in trash, |
-- since once dialogs are opened, all addons should be loaded already |
-- and AceGUI should be on the latest version available on the users |
-- setup. |
-- -- nevcairiel - Nov 2nd, 2009 |
if oldminor and oldminor < 29 and AceGUI.objPools then |
AceGUI.objPools = nil |
end |
AceGUI.objPools = AceGUI.objPools or {} |
local objPools = AceGUI.objPools |
--Returns a new instance, if none are available either returns a new table or calls the given contructor |
function newWidget(type) |
if not WidgetRegistry[type] then |
error("Attempt to instantiate unknown widget type", 2) |
end |
if not objPools[type] then |
objPools[type] = {} |
end |
local newObj = next(objPools[type]) |
if not newObj then |
newObj = WidgetRegistry[type]() |
newObj.AceGUIWidgetVersion = WidgetVersions[type] |
else |
objPools[type][newObj] = nil |
-- if the widget is older then the latest, don't even try to reuse it |
-- just forget about it, and grab a new one. |
if not newObj.AceGUIWidgetVersion or newObj.AceGUIWidgetVersion < WidgetVersions[type] then |
return newWidget(type) |
end |
end |
return newObj |
end |
-- Releases an instance to the Pool |
function delWidget(obj,type) |
if not objPools[type] then |
objPools[type] = {} |
end |
if objPools[type][obj] then |
error("Attempt to Release Widget that is already released", 2) |
end |
objPools[type][obj] = true |
end |
end |
------------------- |
-- API Functions -- |
------------------- |
-- Gets a widget Object |
--- Create a new Widget of the given type. |
-- This function will instantiate a new widget (or use one from the widget pool), and call the |
-- OnAcquire function on it, before returning. |
-- @param type The type of the widget. |
-- @return The newly created widget. |
function AceGUI:Create(type) |
if WidgetRegistry[type] then |
local widget = newWidget(type) |
if rawget(widget, "Acquire") then |
widget.OnAcquire = widget.Acquire |
widget.Acquire = nil |
elseif rawget(widget, "Aquire") then |
widget.OnAcquire = widget.Aquire |
widget.Aquire = nil |
end |
if rawget(widget, "Release") then |
widget.OnRelease = rawget(widget, "Release") |
widget.Release = nil |
end |
if widget.OnAcquire then |
widget:OnAcquire() |
else |
error(("Widget type %s doesn't supply an OnAcquire Function"):format(type)) |
end |
-- Set the default Layout ("List") |
safecall(widget.SetLayout, widget, "List") |
safecall(widget.ResumeLayout, widget) |
return widget |
end |
end |
--- Releases a widget Object. |
-- This function calls OnRelease on the widget and places it back in the widget pool. |
-- Any data on the widget is being erased, and the widget will be hidden.\\ |
-- If this widget is a Container-Widget, all of its Child-Widgets will be releases as well. |
-- @param widget The widget to release |
function AceGUI:Release(widget) |
safecall(widget.PauseLayout, widget) |
widget:Fire("OnRelease") |
safecall(widget.ReleaseChildren, widget) |
if widget.OnRelease then |
widget:OnRelease() |
-- else |
-- error(("Widget type %s doesn't supply an OnRelease Function"):format(widget.type)) |
end |
for k in pairs(widget.userdata) do |
widget.userdata[k] = nil |
end |
for k in pairs(widget.events) do |
widget.events[k] = nil |
end |
widget.width = nil |
widget.relWidth = nil |
widget.height = nil |
widget.relHeight = nil |
widget.noAutoHeight = nil |
widget.frame:ClearAllPoints() |
widget.frame:Hide() |
widget.frame:SetParent(UIParent) |
widget.frame.width = nil |
widget.frame.height = nil |
if widget.content then |
widget.content.width = nil |
widget.content.height = nil |
end |
delWidget(widget, widget.type) |
end |
----------- |
-- Focus -- |
----------- |
--- Called when a widget has taken focus. |
-- e.g. Dropdowns opening, Editboxes gaining kb focus |
-- @param widget The widget that should be focused |
function AceGUI:SetFocus(widget) |
if self.FocusedWidget and self.FocusedWidget ~= widget then |
safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget) |
end |
self.FocusedWidget = widget |
end |
--- Called when something has happened that could cause widgets with focus to drop it |
-- e.g. titlebar of a frame being clicked |
function AceGUI:ClearFocus() |
if self.FocusedWidget then |
safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget) |
self.FocusedWidget = nil |
end |
end |
------------- |
-- Widgets -- |
------------- |
--[[ |
Widgets must provide the following functions |
OnAcquire() - Called when the object is acquired, should set everything to a default hidden state |
And the following members |
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes |
type - the type of the object, same as the name given to :RegisterWidget() |
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet |
It will be cleared automatically when a widget is released |
Placing values directly into a widget object should be avoided |
If the Widget can act as a container for other Widgets the following |
content - frame or derivitive that children will be anchored to |
The Widget can supply the following Optional Members |
:OnRelease() - Called when the object is Released, should remove any additional anchors and clear any data |
:OnWidthSet(width) - Called when the width of the widget is changed |
:OnHeightSet(height) - Called when the height of the widget is changed |
Widgets should not use the OnSizeChanged events of thier frame or content members, use these methods instead |
AceGUI already sets a handler to the event |
:LayoutFinished(width, height) - called after a layout has finished, the width and height will be the width and height of the |
area used for controls. These can be nil if the layout used the existing size to layout the controls. |
]] |
-------------------------- |
-- Widget Base Template -- |
-------------------------- |
do |
local WidgetBase = AceGUI.WidgetBase |
WidgetBase.SetParent = function(self, parent) |
local frame = self.frame |
frame:SetParent(nil) |
frame:SetParent(parent.content) |
self.parent = parent |
end |
WidgetBase.SetCallback = function(self, name, func) |
if type(func) == "function" then |
self.events[name] = func |
end |
end |
WidgetBase.Fire = function(self, name, ...) |
if self.events[name] then |
local success, ret = safecall(self.events[name], self, name, ...) |
if success then |
return ret |
end |
end |
end |
WidgetBase.SetWidth = function(self, width) |
self.frame:SetWidth(width) |
self.frame.width = width |
if self.OnWidthSet then |
self:OnWidthSet(width) |
end |
end |
WidgetBase.SetRelativeWidth = function(self, width) |
if width <= 0 or width > 1 then |
error(":SetRelativeWidth(width): Invalid relative width.", 2) |
end |
self.relWidth = width |
self.width = "relative" |
end |
WidgetBase.SetHeight = function(self, height) |
self.frame:SetHeight(height) |
self.frame.height = height |
if self.OnHeightSet then |
self:OnHeightSet(height) |
end |
end |
--[[ WidgetBase.SetRelativeHeight = function(self, height) |
if height <= 0 or height > 1 then |
error(":SetRelativeHeight(height): Invalid relative height.", 2) |
end |
self.relHeight = height |
self.height = "relative" |
end ]] |
WidgetBase.IsVisible = function(self) |
return self.frame:IsVisible() |
end |
WidgetBase.IsShown= function(self) |
return self.frame:IsShown() |
end |
WidgetBase.Release = function(self) |
AceGUI:Release(self) |
end |
WidgetBase.SetPoint = function(self, ...) |
return self.frame:SetPoint(...) |
end |
WidgetBase.ClearAllPoints = function(self) |
return self.frame:ClearAllPoints() |
end |
WidgetBase.GetNumPoints = function(self) |
return self.frame:GetNumPoints() |
end |
WidgetBase.GetPoint = function(self, ...) |
return self.frame:GetPoint(...) |
end |
WidgetBase.GetUserDataTable = function(self) |
return self.userdata |
end |
WidgetBase.SetUserData = function(self, key, value) |
self.userdata[key] = value |
end |
WidgetBase.GetUserData = function(self, key) |
return self.userdata[key] |
end |
WidgetBase.IsFullHeight = function(self) |
return self.height == "fill" |
end |
WidgetBase.SetFullHeight = function(self, isFull) |
if isFull then |
self.height = "fill" |
else |
self.height = nil |
end |
end |
WidgetBase.IsFullWidth = function(self) |
return self.width == "fill" |
end |
WidgetBase.SetFullWidth = function(self, isFull) |
if isFull then |
self.width = "fill" |
else |
self.width = nil |
end |
end |
-- local function LayoutOnUpdate(this) |
-- this:SetScript("OnUpdate",nil) |
-- this.obj:PerformLayout() |
-- end |
local WidgetContainerBase = AceGUI.WidgetContainerBase |
WidgetContainerBase.PauseLayout = function(self) |
self.LayoutPaused = true |
end |
WidgetContainerBase.ResumeLayout = function(self) |
self.LayoutPaused = nil |
end |
WidgetContainerBase.PerformLayout = function(self) |
if self.LayoutPaused then |
return |
end |
safecall(self.LayoutFunc, self.content, self.children) |
end |
--call this function to layout, makes sure layed out objects get a frame to get sizes etc |
WidgetContainerBase.DoLayout = function(self) |
self:PerformLayout() |
-- if not self.parent then |
-- self.frame:SetScript("OnUpdate", LayoutOnUpdate) |
-- end |
end |
WidgetContainerBase.AddChild = function(self, child, beforeWidget) |
if beforeWidget then |
local siblingIndex = 1 |
for _, widget in pairs(self.children) do |
if widget == beforeWidget then |
break |
end |
siblingIndex = siblingIndex + 1 |
end |
tinsert(self.children, siblingIndex, child) |
else |
tinsert(self.children, child) |
end |
child:SetParent(self) |
child.frame:Show() |
self:DoLayout() |
end |
WidgetContainerBase.AddChildren = function(self, ...) |
for i = 1, select("#", ...) do |
local child = select(i, ...) |
tinsert(self.children, child) |
child:SetParent(self) |
child.frame:Show() |
end |
self:DoLayout() |
end |
WidgetContainerBase.ReleaseChildren = function(self) |
local children = self.children |
for i = 1,#children do |
AceGUI:Release(children[i]) |
children[i] = nil |
end |
end |
WidgetContainerBase.SetLayout = function(self, Layout) |
self.LayoutFunc = AceGUI:GetLayout(Layout) |
end |
WidgetContainerBase.SetAutoAdjustHeight = function(self, adjust) |
if adjust then |
self.noAutoHeight = nil |
else |
self.noAutoHeight = true |
end |
end |
local function FrameResize(this) |
local self = this.obj |
if this:GetWidth() and this:GetHeight() then |
if self.OnWidthSet then |
self:OnWidthSet(this:GetWidth()) |
end |
if self.OnHeightSet then |
self:OnHeightSet(this:GetHeight()) |
end |
end |
end |
local function ContentResize(this) |
if this:GetWidth() and this:GetHeight() then |
this.width = this:GetWidth() |
this.height = this:GetHeight() |
this.obj:DoLayout() |
end |
end |
setmetatable(WidgetContainerBase, {__index=WidgetBase}) |
--One of these function should be called on each Widget Instance as part of its creation process |
--- Register a widget-class as a container for newly created widgets. |
-- @param widget The widget class |
function AceGUI:RegisterAsContainer(widget) |
widget.children = {} |
widget.userdata = {} |
widget.events = {} |
widget.base = WidgetContainerBase |
widget.content.obj = widget |
widget.frame.obj = widget |
widget.content:SetScript("OnSizeChanged", ContentResize) |
widget.frame:SetScript("OnSizeChanged", FrameResize) |
setmetatable(widget, {__index = WidgetContainerBase}) |
widget:SetLayout("List") |
return widget |
end |
--- Register a widget-class as a widget. |
-- @param widget The widget class |
function AceGUI:RegisterAsWidget(widget) |
widget.userdata = {} |
widget.events = {} |
widget.base = WidgetBase |
widget.frame.obj = widget |
widget.frame:SetScript("OnSizeChanged", FrameResize) |
setmetatable(widget, {__index = WidgetBase}) |
return widget |
end |
end |
------------------ |
-- Widget API -- |
------------------ |
--- Registers a widget Constructor, this function returns a new instance of the Widget |
-- @param Name The name of the widget |
-- @param Constructor The widget constructor function |
-- @param Version The version of the widget |
function AceGUI:RegisterWidgetType(Name, Constructor, Version) |
assert(type(Constructor) == "function") |
assert(type(Version) == "number") |
local oldVersion = WidgetVersions[Name] |
if oldVersion and oldVersion >= Version then return end |
WidgetVersions[Name] = Version |
WidgetRegistry[Name] = Constructor |
end |
--- Registers a Layout Function |
-- @param Name The name of the layout |
-- @param LayoutFunc Reference to the layout function |
function AceGUI:RegisterLayout(Name, LayoutFunc) |
assert(type(LayoutFunc) == "function") |
if type(Name) == "string" then |
Name = Name:upper() |
end |
LayoutRegistry[Name] = LayoutFunc |
end |
--- Get a Layout Function from the registry |
-- @param Name The name of the layout |
function AceGUI:GetLayout(Name) |
if type(Name) == "string" then |
Name = Name:upper() |
end |
return LayoutRegistry[Name] |
end |
AceGUI.counts = AceGUI.counts or {} |
--- A type-based counter to count the number of widgets created. |
-- This is used by widgets that require a named frame, e.g. when a Blizzard |
-- Template requires it. |
-- @param type The widget type |
function AceGUI:GetNextWidgetNum(type) |
if not self.counts[type] then |
self.counts[type] = 0 |
end |
self.counts[type] = self.counts[type] + 1 |
return self.counts[type] |
end |
--- Return the number of created widgets for this type. |
-- In contrast to GetNextWidgetNum, the number is not incremented. |
-- @param type The widget type |
function AceGUI:GetWidgetCount(type) |
return self.counts[type] or 0 |
end |
--- Return the version of the currently registered widget type. |
-- @param type The widget type |
function AceGUI:GetWidgetVersion(type) |
return WidgetVersions[type] |
end |
------------- |
-- Layouts -- |
------------- |
--[[ |
A Layout is a func that takes 2 parameters |
content - the frame that widgets will be placed inside |
children - a table containing the widgets to layout |
]] |
-- Very simple Layout, Children are stacked on top of each other down the left side |
AceGUI:RegisterLayout("List", |
function(content, children) |
local height = 0 |
local width = content.width or content:GetWidth() or 0 |
for i = 1, #children do |
local child = children[i] |
local frame = child.frame |
frame:ClearAllPoints() |
frame:Show() |
if i == 1 then |
frame:SetPoint("TOPLEFT", content) |
else |
frame:SetPoint("TOPLEFT", children[i-1].frame, "BOTTOMLEFT") |
end |
if child.width == "fill" then |
child:SetWidth(width) |
frame:SetPoint("RIGHT", content) |
if child.DoLayout then |
child:DoLayout() |
end |
elseif child.width == "relative" then |
child:SetWidth(width * child.relWidth) |
if child.DoLayout then |
child:DoLayout() |
end |
end |
height = height + (frame.height or frame:GetHeight() or 0) |
end |
safecall(content.obj.LayoutFinished, content.obj, nil, height) |
end) |
-- A single control fills the whole content area |
AceGUI:RegisterLayout("Fill", |
function(content, children) |
if children[1] then |
children[1]:SetWidth(content:GetWidth() or 0) |
children[1]:SetHeight(content:GetHeight() or 0) |
children[1].frame:SetAllPoints(content) |
children[1].frame:Show() |
safecall(content.obj.LayoutFinished, content.obj, nil, children[1].frame:GetHeight()) |
end |
end) |
AceGUI:RegisterLayout("Flow", |
function(content, children) |
--used height so far |
local height = 0 |
--width used in the current row |
local usedwidth = 0 |
--height of the current row |
local rowheight = 0 |
local rowoffset = 0 |
local lastrowoffset |
local width = content.width or content:GetWidth() or 0 |
--control at the start of the row |
local rowstart |
local rowstartoffset |
local lastrowstart |
local isfullheight |
local frameoffset |
local lastframeoffset |
local oversize |
for i = 1, #children do |
local child = children[i] |
oversize = nil |
local frame = child.frame |
local frameheight = frame.height or frame:GetHeight() or 0 |
local framewidth = frame.width or frame:GetWidth() or 0 |
lastframeoffset = frameoffset |
-- HACK: Why did we set a frameoffset of (frameheight / 2) ? |
-- That was moving all widgets half the widgets size down, is that intended? |
-- Actually, it seems to be neccessary for many cases, we'll leave it in for now. |
-- If widgets seem to anchor weirdly with this, provide a valid alignoffset for them. |
-- TODO: Investigate moar! |
frameoffset = child.alignoffset or (frameheight / 2) |
if child.width == "relative" then |
framewidth = width * child.relWidth |
end |
frame:Show() |
frame:ClearAllPoints() |
if i == 1 then |
-- anchor the first control to the top left |
frame:SetPoint("TOPLEFT", content) |
rowheight = frameheight |
rowoffset = frameoffset |
rowstart = frame |
rowstartoffset = frameoffset |
usedwidth = framewidth |
if usedwidth > width then |
oversize = true |
end |
else |
-- if there isn't available width for the control start a new row |
-- if a control is "fill" it will be on a row of its own full width |
if usedwidth == 0 or ((framewidth) + usedwidth > width) or child.width == "fill" then |
if isfullheight then |
-- a previous row has already filled the entire height, there's nothing we can usefully do anymore |
-- (maybe error/warn about this?) |
break |
end |
--anchor the previous row, we will now know its height and offset |
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3)) |
height = height + rowheight + 3 |
--save this as the rowstart so we can anchor it after the row is complete and we have the max height and offset of controls in it |
rowstart = frame |
rowstartoffset = frameoffset |
rowheight = frameheight |
rowoffset = frameoffset |
usedwidth = framewidth |
if usedwidth > width then |
oversize = true |
end |
-- put the control on the current row, adding it to the width and checking if the height needs to be increased |
else |
--handles cases where the new height is higher than either control because of the offsets |
--math.max(rowheight-rowoffset+frameoffset, frameheight-frameoffset+rowoffset) |
--offset is always the larger of the two offsets |
rowoffset = math_max(rowoffset, frameoffset) |
rowheight = math_max(rowheight, rowoffset + (frameheight / 2)) |
frame:SetPoint("TOPLEFT", children[i-1].frame, "TOPRIGHT", 0, frameoffset - lastframeoffset) |
usedwidth = framewidth + usedwidth |
end |
end |
if child.width == "fill" then |
child:SetWidth(width) |
frame:SetPoint("RIGHT", content) |
usedwidth = 0 |
rowstart = frame |
rowstartoffset = frameoffset |
if child.DoLayout then |
child:DoLayout() |
end |
rowheight = frame.height or frame:GetHeight() or 0 |
rowoffset = child.alignoffset or (rowheight / 2) |
rowstartoffset = rowoffset |
elseif child.width == "relative" then |
child:SetWidth(width * child.relWidth) |
if child.DoLayout then |
child:DoLayout() |
end |
elseif oversize then |
if width > 1 then |
frame:SetPoint("RIGHT", content) |
end |
end |
if child.height == "fill" then |
frame:SetPoint("BOTTOM", content) |
isfullheight = true |
end |
end |
--anchor the last row, if its full height needs a special case since its height has just been changed by the anchor |
if isfullheight then |
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -height) |
elseif rowstart then |
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3)) |
end |
height = height + rowheight + 3 |
safecall(content.obj.LayoutFinished, content.obj, nil, height) |
end) |
<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> |
--[[ |
Name: LibSharedMedia-3.0 |
Revision: $Revision: 62 $ |
Author: Elkano (elkano@gmx.de) |
Inspired By: SurfaceLib by Haste/Otravi (troeks@gmail.com) |
Website: http://www.wowace.com/projects/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", 100001 -- increase manualy 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 table_insert = _G.table.insert |
local table_sort = _G.table.sort |
local locale = GetLocale() |
local locale_is_western |
local LOCALE_MASK = 0 |
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["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 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["White"] = [[Interface\Buttons\WHITE8X8]] |
lib.MediaTable.background["Black"] = [[Interface\AddOns\BasicUI\Media\Textures\BLACK8X8]] |
-- BORDER |
if not lib.MediaTable.border then lib.MediaTable.border = {} end |
lib.MediaTable.border["None"] = [[Interface\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]] |
-- FONT |
if not lib.MediaTable.font then lib.MediaTable.font = {} end |
local SML_MT_font = lib.MediaTable.font |
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\ZYKai_C.ttf]] |
SML_MT_font["é»è®¤"] = [[Fonts\ZYKai_T.ttf]] |
SML_MT_font["è天"] = [[Fonts\ZYHei.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["Arial Narrow"] = [[Fonts\ARIALN.TTF]] |
SML_MT_font["Friz Quadrata TT"] = [[Fonts\FRIZQT__.TTF]] |
SML_MT_font["Morpheus"] = [[Fonts\MORPHEUS.TTF]] |
SML_MT_font["Nimrod MT"] = [[Fonts\NIM_____.ttf]] |
SML_MT_font["Skurri"] = [[Fonts\SKURRI.TTF]] |
-- |
lib.DefaultMedia.font = "Friz Quadrata TT" |
-- |
else |
LOCALE_MASK = lib.LOCALE_BIT_western |
locale_is_western = true |
-- |
SML_MT_font["Arial Narrow"] = [[Fonts\ARIALN.TTF]] |
SML_MT_font["Friz Quadrata TT"] = [[Fonts\FRIZQT__.TTF]] |
SML_MT_font["Morpheus"] = [[Fonts\MORPHEUS.TTF]] |
SML_MT_font["Skurri"] = [[Fonts\SKURRI.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.DefaultMedia.statusbar = "Blizzard" |
-- SOUND |
if not lib.MediaTable.sound then lib.MediaTable.sound = {} end |
lib.MediaTable.sound["None"] = [[Interface\Quiet.ogg]] -- Relies on the fact that PlaySound[File] doesn't error on non-existing input. |
lib.DefaultMedia.sound = "None" |
local function rebuildMediaList(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 |
local i = 0 |
for k in pairs(mtable) do |
i = i + 1 |
mlist[i] = k |
end |
table_sort(mlist) |
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 return false end |
if not mediaTable[mediatype] then mediaTable[mediatype] = {} end |
local mtable = mediaTable[mediatype] |
if mtable[key] then return false end |
mtable[key] = data |
rebuildMediaList(mediatype) |
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 |
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 |
rebuildMediaList(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 |
<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> |
--- **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 1036 2011-08-16 22:45:05Z nevcairiel $ |
local MAJOR, MINOR = "AceAddon-3.0", 11 |
local AceAddon, oldminor = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceAddon then return end -- No Upgrade needed. |
AceAddon.frame = AceAddon.frame or CreateFrame("Frame", "AceAddon30Frame") -- Our very own frame |
AceAddon.addons = AceAddon.addons or {} -- addons in general |
AceAddon.statuses = AceAddon.statuses or {} -- statuses of addon. |
AceAddon.initializequeue = AceAddon.initializequeue or {} -- addons that are new and not initialized |
AceAddon.enablequeue = AceAddon.enablequeue or {} -- addons that are initialized and waiting to be enabled |
AceAddon.embeds = AceAddon.embeds or setmetatable({}, {__index = function(tbl, key) tbl[key] = {} return tbl[key] end }) -- contains a list of libraries embedded in an addon |
-- Lua APIs |
local tinsert, tconcat, tremove = table.insert, table.concat, table.remove |
local fmt, tostring = string.format, tostring |
local select, pairs, next, type, unpack = select, pairs, next, type, unpack |
local loadstring, assert, error = loadstring, assert, error |
local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: LibStub, IsLoggedIn, geterrorhandler |
--[[ |
xpcall safecall implementation |
]] |
local xpcall = xpcall |
local function errorhandler(err) |
return geterrorhandler()(err) |
end |
local function CreateDispatcher(argCount) |
local code = [[ |
local xpcall, eh = ... |
local method, ARGS |
local function call() return method(ARGS) end |
local function dispatch(func, ...) |
method = func |
if not method then return end |
ARGS = ... |
return xpcall(call, eh) |
end |
return dispatch |
]] |
local ARGS = {} |
for i = 1, argCount do ARGS[i] = "arg"..i end |
code = code:gsub("ARGS", tconcat(ARGS, ", ")) |
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler) |
end |
local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
local dispatcher = CreateDispatcher(argCount) |
rawset(self, argCount, dispatcher) |
return dispatcher |
end}) |
Dispatchers[0] = function(func) |
return xpcall(func, errorhandler) |
end |
local function safecall(func, ...) |
-- we check to see if the func is passed is actually a function here and don't error when it isn't |
-- this safecall is used for optional functions like OnInitialize OnEnable etc. When they are not |
-- present execution should continue without hinderance |
if type(func) == "function" then |
return Dispatchers[select('#', ...)](func, ...) |
end |
end |
-- local functions that will be implemented further down |
local Enable, Disable, EnableModule, DisableModule, Embed, NewModule, GetModule, GetName, SetDefaultModuleState, SetDefaultModuleLibraries, SetEnabledState, SetDefaultModulePrototype |
-- used in the addon metatable |
local function addontostring( self ) return self.name end |
--- Create a new AceAddon-3.0 addon. |
-- Any libraries you specified will be embeded, and the addon will be scheduled for |
-- its OnInitialize and OnEnable callbacks. |
-- The final addon object, with all libraries embeded, will be returned. |
-- @paramsig [object ,]name[, lib, ...] |
-- @param object Table to use as a base for the addon (optional) |
-- @param name Name of the addon object to create |
-- @param lib List of libraries to embed into the addon |
-- @usage |
-- -- Create a simple addon object |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceEvent-3.0") |
-- |
-- -- Create a Addon object based on the table of a frame |
-- local MyFrame = CreateFrame("Frame") |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon(MyFrame, "MyAddon", "AceEvent-3.0") |
function AceAddon:NewAddon(objectorname, ...) |
local object,name |
local i=1 |
if type(objectorname)=="table" then |
object=objectorname |
name=... |
i=2 |
else |
name=objectorname |
end |
if type(name)~="string" then |
error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) |
end |
if self.addons[name] then |
error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - Addon '%s' already exists."):format(name), 2) |
end |
object = object or {} |
object.name = name |
local addonmeta = {} |
local oldmeta = getmetatable(object) |
if oldmeta then |
for k, v in pairs(oldmeta) do addonmeta[k] = v end |
end |
addonmeta.__tostring = addontostring |
setmetatable( object, addonmeta ) |
self.addons[name] = object |
object.modules = {} |
object.orderedModules = {} |
object.defaultModuleLibraries = {} |
Embed( object ) -- embed NewModule, GetModule methods |
self:EmbedLibraries(object, select(i,...)) |
-- add to queue of addons to be initialized upon ADDON_LOADED |
tinsert(self.initializequeue, object) |
return object |
end |
--- Get the addon object by its name from the internal AceAddon registry. |
-- Throws an error if the addon object cannot be found (except if silent is set). |
-- @param name unique name of the addon object |
-- @param silent if true, the addon is optional, silently return nil if its not found |
-- @usage |
-- -- Get the Addon |
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
function AceAddon:GetAddon(name, silent) |
if not silent and not self.addons[name] then |
error(("Usage: GetAddon(name): 'name' - Cannot find an AceAddon '%s'."):format(tostring(name)), 2) |
end |
return self.addons[name] |
end |
-- - Embed a list of libraries into the specified addon. |
-- This function will try to embed all of the listed libraries into the addon |
-- and error if a single one fails. |
-- |
-- **Note:** This function is for internal use by :NewAddon/:NewModule |
-- @paramsig addon, [lib, ...] |
-- @param addon addon object to embed the libs in |
-- @param lib List of libraries to embed into the addon |
function AceAddon:EmbedLibraries(addon, ...) |
for i=1,select("#", ... ) do |
local libname = select(i, ...) |
self:EmbedLibrary(addon, libname, false, 4) |
end |
end |
-- - Embed a library into the addon object. |
-- This function will check if the specified library is registered with LibStub |
-- and if it has a :Embed function to call. It'll error if any of those conditions |
-- fails. |
-- |
-- **Note:** This function is for internal use by :EmbedLibraries |
-- @paramsig addon, libname[, silent[, offset]] |
-- @param addon addon object to embed the library in |
-- @param libname name of the library to embed |
-- @param silent marks an embed to fail silently if the library doesn't exist (optional) |
-- @param offset will push the error messages back to said offset, defaults to 2 (optional) |
function AceAddon:EmbedLibrary(addon, libname, silent, offset) |
local lib = LibStub:GetLibrary(libname, true) |
if not lib and not silent then |
error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Cannot find a library instance of %q."):format(tostring(libname)), offset or 2) |
elseif lib and type(lib.Embed) == "function" then |
lib:Embed(addon) |
tinsert(self.embeds[addon], libname) |
return true |
elseif lib then |
error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Library '%s' is not Embed capable"):format(libname), offset or 2) |
end |
end |
--- Return the specified module from an addon object. |
-- Throws an error if the addon object cannot be found (except if silent is set) |
-- @name //addon//:GetModule |
-- @paramsig name[, silent] |
-- @param name unique name of the module |
-- @param silent if true, the module is optional, silently return nil if its not found (optional) |
-- @usage |
-- -- Get the Addon |
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
-- -- Get the Module |
-- MyModule = MyAddon:GetModule("MyModule") |
function GetModule(self, name, silent) |
if not self.modules[name] and not silent then |
error(("Usage: GetModule(name, silent): 'name' - Cannot find module '%s'."):format(tostring(name)), 2) |
end |
return self.modules[name] |
end |
local function IsModuleTrue(self) return true end |
--- Create a new module for the addon. |
-- The new module can have its own embeded libraries and/or use a module prototype to be mixed into the module.\\ |
-- A module has the same functionality as a real addon, it can have modules of its own, and has the same API as |
-- an addon object. |
-- @name //addon//:NewModule |
-- @paramsig name[, prototype|lib[, lib, ...]] |
-- @param name unique name of the module |
-- @param prototype object to derive this module from, methods and values from this table will be mixed into the module (optional) |
-- @param lib List of libraries to embed into the addon |
-- @usage |
-- -- Create a module with some embeded libraries |
-- MyModule = MyAddon:NewModule("MyModule", "AceEvent-3.0", "AceHook-3.0") |
-- |
-- -- Create a module with a prototype |
-- local prototype = { OnEnable = function(self) print("OnEnable called!") end } |
-- MyModule = MyAddon:NewModule("MyModule", prototype, "AceEvent-3.0", "AceHook-3.0") |
function NewModule(self, name, prototype, ...) |
if type(name) ~= "string" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) end |
if type(prototype) ~= "string" and type(prototype) ~= "table" and type(prototype) ~= "nil" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'prototype' - table (prototype), string (lib) or nil expected got '%s'."):format(type(prototype)), 2) end |
if self.modules[name] then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - Module '%s' already exists."):format(name), 2) end |
-- modules are basically addons. We treat them as such. They will be added to the initializequeue properly as well. |
-- NewModule can only be called after the parent addon is present thus the modules will be initialized after their parent is. |
local module = AceAddon:NewAddon(fmt("%s_%s", self.name or tostring(self), name)) |
module.IsModule = IsModuleTrue |
module:SetEnabledState(self.defaultModuleState) |
module.moduleName = name |
if type(prototype) == "string" then |
AceAddon:EmbedLibraries(module, prototype, ...) |
else |
AceAddon:EmbedLibraries(module, ...) |
end |
AceAddon:EmbedLibraries(module, unpack(self.defaultModuleLibraries)) |
if not prototype or type(prototype) == "string" then |
prototype = self.defaultModulePrototype or nil |
end |
if type(prototype) == "table" then |
local mt = getmetatable(module) |
mt.__index = prototype |
setmetatable(module, mt) -- More of a Base class type feel. |
end |
safecall(self.OnModuleCreated, self, module) -- Was in Ace2 and I think it could be a cool thing to have handy. |
self.modules[name] = module |
tinsert(self.orderedModules, module) |
return module |
end |
--- Returns the real name of the addon or module, without any prefix. |
-- @name //addon//:GetName |
-- @paramsig |
-- @usage |
-- print(MyAddon:GetName()) |
-- -- prints "MyAddon" |
function GetName(self) |
return self.moduleName or self.name |
end |
--- Enables the Addon, if possible, return true or false depending on success. |
-- This internally calls AceAddon:EnableAddon(), thus dispatching a OnEnable callback |
-- and enabling all modules of the addon (unless explicitly disabled).\\ |
-- :Enable() also sets the internal `enableState` variable to true |
-- @name //addon//:Enable |
-- @paramsig |
-- @usage |
-- -- Enable MyModule |
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
-- MyModule = MyAddon:GetModule("MyModule") |
-- MyModule:Enable() |
function Enable(self) |
self:SetEnabledState(true) |
return AceAddon:EnableAddon(self) |
end |
--- Disables the Addon, if possible, return true or false depending on success. |
-- This internally calls AceAddon:DisableAddon(), thus dispatching a OnDisable callback |
-- and disabling all modules of the addon.\\ |
-- :Disable() also sets the internal `enableState` variable to false |
-- @name //addon//:Disable |
-- @paramsig |
-- @usage |
-- -- Disable MyAddon |
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
-- MyAddon:Disable() |
function Disable(self) |
self:SetEnabledState(false) |
return AceAddon:DisableAddon(self) |
end |
--- Enables the Module, if possible, return true or false depending on success. |
-- Short-hand function that retrieves the module via `:GetModule` and calls `:Enable` on the module object. |
-- @name //addon//:EnableModule |
-- @paramsig name |
-- @usage |
-- -- Enable MyModule using :GetModule |
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
-- MyModule = MyAddon:GetModule("MyModule") |
-- MyModule:Enable() |
-- |
-- -- Enable MyModule using the short-hand |
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
-- MyAddon:EnableModule("MyModule") |
function EnableModule(self, name) |
local module = self:GetModule( name ) |
return module:Enable() |
end |
--- Disables the Module, if possible, return true or false depending on success. |
-- Short-hand function that retrieves the module via `:GetModule` and calls `:Disable` on the module object. |
-- @name //addon//:DisableModule |
-- @paramsig name |
-- @usage |
-- -- Disable MyModule using :GetModule |
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
-- MyModule = MyAddon:GetModule("MyModule") |
-- MyModule:Disable() |
-- |
-- -- Disable MyModule using the short-hand |
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
-- MyAddon:DisableModule("MyModule") |
function DisableModule(self, name) |
local module = self:GetModule( name ) |
return module:Disable() |
end |
--- Set the default libraries to be mixed into all modules created by this object. |
-- Note that you can only change the default module libraries before any module is created. |
-- @name //addon//:SetDefaultModuleLibraries |
-- @paramsig lib[, lib, ...] |
-- @param lib List of libraries to embed into the addon |
-- @usage |
-- -- Create the addon object |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon") |
-- -- Configure default libraries for modules (all modules need AceEvent-3.0) |
-- MyAddon:SetDefaultModuleLibraries("AceEvent-3.0") |
-- -- Create a module |
-- MyModule = MyAddon:NewModule("MyModule") |
function SetDefaultModuleLibraries(self, ...) |
if next(self.modules) then |
error("Usage: SetDefaultModuleLibraries(...): cannot change the module defaults after a module has been registered.", 2) |
end |
self.defaultModuleLibraries = {...} |
end |
--- Set the default state in which new modules are being created. |
-- Note that you can only change the default state before any module is created. |
-- @name //addon//:SetDefaultModuleState |
-- @paramsig state |
-- @param state Default state for new modules, true for enabled, false for disabled |
-- @usage |
-- -- Create the addon object |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon") |
-- -- Set the default state to "disabled" |
-- MyAddon:SetDefaultModuleState(false) |
-- -- Create a module and explicilty enable it |
-- MyModule = MyAddon:NewModule("MyModule") |
-- MyModule:Enable() |
function SetDefaultModuleState(self, state) |
if next(self.modules) then |
error("Usage: SetDefaultModuleState(state): cannot change the module defaults after a module has been registered.", 2) |
end |
self.defaultModuleState = state |
end |
--- Set the default prototype to use for new modules on creation. |
-- Note that you can only change the default prototype before any module is created. |
-- @name //addon//:SetDefaultModulePrototype |
-- @paramsig prototype |
-- @param prototype Default prototype for the new modules (table) |
-- @usage |
-- -- Define a prototype |
-- local prototype = { OnEnable = function(self) print("OnEnable called!") end } |
-- -- Set the default prototype |
-- MyAddon:SetDefaultModulePrototype(prototype) |
-- -- Create a module and explicitly Enable it |
-- MyModule = MyAddon:NewModule("MyModule") |
-- MyModule:Enable() |
-- -- should print "OnEnable called!" now |
-- @see NewModule |
function SetDefaultModulePrototype(self, prototype) |
if next(self.modules) then |
error("Usage: SetDefaultModulePrototype(prototype): cannot change the module defaults after a module has been registered.", 2) |
end |
if type(prototype) ~= "table" then |
error(("Usage: SetDefaultModulePrototype(prototype): 'prototype' - table expected got '%s'."):format(type(prototype)), 2) |
end |
self.defaultModulePrototype = prototype |
end |
--- Set the state of an addon or module |
-- This should only be called before any enabling actually happend, e.g. in/before OnInitialize. |
-- @name //addon//:SetEnabledState |
-- @paramsig state |
-- @param state the state of an addon or module (enabled=true, disabled=false) |
function SetEnabledState(self, state) |
self.enabledState = state |
end |
--- Return an iterator of all modules associated to the addon. |
-- @name //addon//:IterateModules |
-- @paramsig |
-- @usage |
-- -- Enable all modules |
-- for name, module in MyAddon:IterateModules() do |
-- module:Enable() |
-- end |
local function IterateModules(self) return pairs(self.modules) end |
-- Returns an iterator of all embeds in the addon |
-- @name //addon//:IterateEmbeds |
-- @paramsig |
local function IterateEmbeds(self) return pairs(AceAddon.embeds[self]) end |
--- Query the enabledState of an addon. |
-- @name //addon//:IsEnabled |
-- @paramsig |
-- @usage |
-- if MyAddon:IsEnabled() then |
-- MyAddon:Disable() |
-- end |
local function IsEnabled(self) return self.enabledState end |
local mixins = { |
NewModule = NewModule, |
GetModule = GetModule, |
Enable = Enable, |
Disable = Disable, |
EnableModule = EnableModule, |
DisableModule = DisableModule, |
IsEnabled = IsEnabled, |
SetDefaultModuleLibraries = SetDefaultModuleLibraries, |
SetDefaultModuleState = SetDefaultModuleState, |
SetDefaultModulePrototype = SetDefaultModulePrototype, |
SetEnabledState = SetEnabledState, |
IterateModules = IterateModules, |
IterateEmbeds = IterateEmbeds, |
GetName = GetName, |
} |
local function IsModule(self) return false end |
local pmixins = { |
defaultModuleState = true, |
enabledState = true, |
IsModule = IsModule, |
} |
-- Embed( target ) |
-- target (object) - target object to embed aceaddon in |
-- |
-- this is a local function specifically since it's meant to be only called internally |
function Embed(target, skipPMixins) |
for k, v in pairs(mixins) do |
target[k] = v |
end |
if not skipPMixins then |
for k, v in pairs(pmixins) do |
target[k] = target[k] or v |
end |
end |
end |
-- - Initialize the addon after creation. |
-- This function is only used internally during the ADDON_LOADED event |
-- It will call the **OnInitialize** function on the addon object (if present), |
-- and the **OnEmbedInitialize** function on all embeded libraries. |
-- |
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing. |
-- @param addon addon object to intialize |
function AceAddon:InitializeAddon(addon) |
safecall(addon.OnInitialize, addon) |
local embeds = self.embeds[addon] |
for i = 1, #embeds do |
local lib = LibStub:GetLibrary(embeds[i], true) |
if lib then safecall(lib.OnEmbedInitialize, lib, addon) end |
end |
-- we don't call InitializeAddon on modules specifically, this is handled |
-- from the event handler and only done _once_ |
end |
-- - Enable the addon after creation. |
-- Note: This function is only used internally during the PLAYER_LOGIN event, or during ADDON_LOADED, |
-- if IsLoggedIn() already returns true at that point, e.g. for LoD Addons. |
-- It will call the **OnEnable** function on the addon object (if present), |
-- and the **OnEmbedEnable** function on all embeded libraries.\\ |
-- This function does not toggle the enable state of the addon itself, and will return early if the addon is disabled. |
-- |
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing. |
-- Use :Enable on the addon itself instead. |
-- @param addon addon object to enable |
function AceAddon:EnableAddon(addon) |
if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end |
if self.statuses[addon.name] or not addon.enabledState then return false end |
-- set the statuses first, before calling the OnEnable. this allows for Disabling of the addon in OnEnable. |
self.statuses[addon.name] = true |
safecall(addon.OnEnable, addon) |
-- make sure we're still enabled before continueing |
if self.statuses[addon.name] then |
local embeds = self.embeds[addon] |
for i = 1, #embeds do |
local lib = LibStub:GetLibrary(embeds[i], true) |
if lib then safecall(lib.OnEmbedEnable, lib, addon) end |
end |
-- enable possible modules. |
local modules = addon.orderedModules |
for i = 1, #modules do |
self:EnableAddon(modules[i]) |
end |
end |
return self.statuses[addon.name] -- return true if we're disabled |
end |
-- - Disable the addon |
-- Note: This function is only used internally. |
-- It will call the **OnDisable** function on the addon object (if present), |
-- and the **OnEmbedDisable** function on all embeded libraries.\\ |
-- This function does not toggle the enable state of the addon itself, and will return early if the addon is still enabled. |
-- |
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing. |
-- Use :Disable on the addon itself instead. |
-- @param addon addon object to enable |
function AceAddon:DisableAddon(addon) |
if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end |
if not self.statuses[addon.name] then return false end |
-- set statuses first before calling OnDisable, this allows for aborting the disable in OnDisable. |
self.statuses[addon.name] = false |
safecall( addon.OnDisable, addon ) |
-- make sure we're still disabling... |
if not self.statuses[addon.name] then |
local embeds = self.embeds[addon] |
for i = 1, #embeds do |
local lib = LibStub:GetLibrary(embeds[i], true) |
if lib then safecall(lib.OnEmbedDisable, lib, addon) end |
end |
-- disable possible modules. |
local modules = addon.orderedModules |
for i = 1, #modules do |
self:DisableAddon(modules[i]) |
end |
end |
return not self.statuses[addon.name] -- return true if we're disabled |
end |
--- Get an iterator over all registered addons. |
-- @usage |
-- -- Print a list of all installed AceAddon's |
-- for name, addon in AceAddon:IterateAddons() do |
-- print("Addon: " .. name) |
-- end |
function AceAddon:IterateAddons() return pairs(self.addons) end |
--- Get an iterator over the internal status registry. |
-- @usage |
-- -- Print a list of all enabled addons |
-- for name, status in AceAddon:IterateAddonStatus() do |
-- if status then |
-- print("EnabledAddon: " .. name) |
-- end |
-- end |
function AceAddon:IterateAddonStatus() return pairs(self.statuses) end |
-- Following Iterators are deprecated, and their addon specific versions should be used |
-- e.g. addon:IterateEmbeds() instead of :IterateEmbedsOnAddon(addon) |
function AceAddon:IterateEmbedsOnAddon(addon) return pairs(self.embeds[addon]) end |
function AceAddon:IterateModulesOfAddon(addon) return pairs(addon.modules) end |
-- Event Handling |
local function onEvent(this, event, arg1) |
-- 2011-08-17 nevcairiel - ignore the load event of Blizzard_DebugTools, so a potential startup error isn't swallowed up |
if (event == "ADDON_LOADED" and arg1 ~= "Blizzard_DebugTools") 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 |
<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> |
--- 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 969 2010-10-07 02:11:48Z shefki $ |
--[[ |
AceConfig-3.0 |
Very light wrapper library that combines all the AceConfig subcomponents into one more easily used whole. |
]] |
local MAJOR, MINOR = "AceConfig-3.0", 2 |
local AceConfig = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceConfig then return end |
local cfgreg = LibStub("AceConfigRegistry-3.0") |
local cfgcmd = LibStub("AceConfigCmd-3.0") |
--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, persist) |
-- |
-- - appName - (string) application name |
-- - options - table or function ref, see AceConfigRegistry |
-- - slashcmd - slash command (string) or table with commands, or nil to NOT create a slash command |
--- Register a option table with the AceConfig registry. |
-- You can supply a slash command (or a table of slash commands) to register with AceConfigCmd directly. |
-- @paramsig appName, options [, slashcmd] |
-- @param appName The application name for the config table. |
-- @param options The option table (or a function to generate one on demand). 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 |
<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> |
--- AceConfigDialog-3.0 generates AceGUI-3.0 based windows based on option tables. |
-- @class file |
-- @name AceConfigDialog-3.0 |
-- @release $Id: AceConfigDialog-3.0.lua 1049 2012-04-02 13:22:10Z mikk $ |
local LibStub = LibStub |
local MAJOR, MINOR = "AceConfigDialog-3.0", 57 |
local AceConfigDialog, oldminor = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceConfigDialog then return end |
AceConfigDialog.OpenFrames = AceConfigDialog.OpenFrames or {} |
AceConfigDialog.Status = AceConfigDialog.Status or {} |
AceConfigDialog.frame = AceConfigDialog.frame or CreateFrame("Frame") |
AceConfigDialog.frame.apps = AceConfigDialog.frame.apps or {} |
AceConfigDialog.frame.closing = AceConfigDialog.frame.closing or {} |
AceConfigDialog.frame.closeAllOverride = AceConfigDialog.frame.closeAllOverride or {} |
local gui = LibStub("AceGUI-3.0") |
local reg = LibStub("AceConfigRegistry-3.0") |
-- Lua APIs |
local tconcat, tinsert, tsort, tremove, tsort = table.concat, table.insert, table.sort, table.remove, table.sort |
local strmatch, format = string.match, string.format |
local assert, loadstring, error = assert, loadstring, error |
local pairs, next, select, type, unpack, wipe, ipairs = pairs, next, select, type, unpack, wipe, ipairs |
local rawset, tostring, tonumber = rawset, tostring, tonumber |
local math_min, math_max, math_floor = math.min, math.max, math.floor |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: NORMAL_FONT_COLOR, GameTooltip, StaticPopupDialogs, ACCEPT, CANCEL, StaticPopup_Show |
-- GLOBALS: PlaySound, GameFontHighlight, GameFontHighlightSmall, GameFontHighlightLarge |
-- GLOBALS: CloseSpecialWindows, InterfaceOptions_AddCategory, geterrorhandler |
local emptyTbl = {} |
--[[ |
xpcall safecall implementation |
]] |
local xpcall = xpcall |
local function errorhandler(err) |
return geterrorhandler()(err) |
end |
local function CreateDispatcher(argCount) |
local code = [[ |
local xpcall, eh = ... |
local method, ARGS |
local function call() return method(ARGS) end |
local function dispatch(func, ...) |
method = func |
if not method then return end |
ARGS = ... |
return xpcall(call, eh) |
end |
return dispatch |
]] |
local ARGS = {} |
for i = 1, argCount do ARGS[i] = "arg"..i end |
code = code:gsub("ARGS", tconcat(ARGS, ", ")) |
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler) |
end |
local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
local dispatcher = CreateDispatcher(argCount) |
rawset(self, argCount, dispatcher) |
return dispatcher |
end}) |
Dispatchers[0] = function(func) |
return xpcall(func, errorhandler) |
end |
local function safecall(func, ...) |
return Dispatchers[select("#", ...)](func, ...) |
end |
local width_multiplier = 170 |
--[[ |
Group Types |
Tree - All Descendant Groups will all become nodes on the tree, direct child options will appear above the tree |
- Descendant Groups with inline=true and thier children will not become nodes |
Tab - Direct Child Groups will become tabs, direct child options will appear above the tab control |
- Grandchild groups will default to inline unless specified otherwise |
Select- Same as Tab but with entries in a dropdown rather than tabs |
Inline Groups |
- Will not become nodes of a select group, they will be effectivly part of thier parent group seperated by a border |
- If declared on a direct child of a root node of a select group, they will appear above the group container control |
- When a group is displayed inline, all descendants will also be inline members of the group |
]] |
-- Recycling functions |
local new, del, copy |
--newcount, delcount,createdcount,cached = 0,0,0 |
do |
local pool = setmetatable({},{__mode="k"}) |
function new() |
--newcount = newcount + 1 |
local t = next(pool) |
if t then |
pool[t] = nil |
return t |
else |
--createdcount = createdcount + 1 |
return {} |
end |
end |
function copy(t) |
local c = new() |
for k, v in pairs(t) do |
c[k] = v |
end |
return c |
end |
function del(t) |
--delcount = delcount + 1 |
wipe(t) |
pool[t] = true |
end |
-- function cached() |
-- local n = 0 |
-- for k in pairs(pool) do |
-- n = n + 1 |
-- end |
-- return n |
-- end |
end |
-- picks the first non-nil value and returns it |
local function pickfirstset(...) |
for i=1,select("#",...) do |
if select(i,...)~=nil then |
return select(i,...) |
end |
end |
end |
--gets an option from a given group, checking plugins |
local function GetSubOption(group, key) |
if group.plugins then |
for plugin, t in pairs(group.plugins) do |
if t[key] then |
return t[key] |
end |
end |
end |
return group.args[key] |
end |
--Option member type definitions, used to decide how to access it |
--Is the member Inherited from parent options |
local isInherited = { |
set = true, |
get = true, |
func = true, |
confirm = true, |
validate = true, |
disabled = true, |
hidden = true |
} |
--Does a string type mean a literal value, instead of the default of a method of the handler |
local stringIsLiteral = { |
name = true, |
desc = true, |
icon = true, |
usage = true, |
width = true, |
image = true, |
fontSize = true, |
} |
--Is Never a function or method |
local allIsLiteral = { |
type = true, |
descStyle = true, |
imageWidth = true, |
imageHeight = true, |
} |
--gets the value for a member that could be a function |
--function refs are called with an info arg |
--every other type is returned |
local function GetOptionsMemberValue(membername, option, options, path, appName, ...) |
--get definition for the member |
local inherits = isInherited[membername] |
--get the member of the option, traversing the tree if it can be inherited |
local member |
if inherits then |
local group = options |
if group[membername] ~= nil then |
member = group[membername] |
end |
for i = 1, #path do |
group = GetSubOption(group, path[i]) |
if group[membername] ~= nil then |
member = group[membername] |
end |
end |
else |
member = option[membername] |
end |
--check if we need to call a functon, or if we have a literal value |
if ( not allIsLiteral[membername] ) and ( type(member) == "function" or ((not stringIsLiteral[membername]) and type(member) == "string") ) then |
--We have a function to call |
local info = new() |
--traverse the options table, picking up the handler and filling the info with the path |
local handler |
local group = options |
handler = group.handler or handler |
for i = 1, #path do |
group = GetSubOption(group, path[i]) |
info[i] = path[i] |
handler = group.handler or handler |
end |
info.options = options |
info.appName = appName |
info[0] = appName |
info.arg = option.arg |
info.handler = handler |
info.option = option |
info.type = option.type |
info.uiType = "dialog" |
info.uiName = MAJOR |
local a, b, c ,d |
--using 4 returns for the get of a color type, increase if a type needs more |
if type(member) == "function" then |
--Call the function |
a,b,c,d = member(info, ...) |
else |
--Call the method |
if handler and handler[member] then |
a,b,c,d = handler[member](handler, info, ...) |
else |
error(format("Method %s doesn't exist in handler for type %s", member, membername)) |
end |
end |
del(info) |
return a,b,c,d |
else |
--The value isnt a function to call, return it |
return member |
end |
end |
--[[calls an options function that could be inherited, method name or function ref |
local function CallOptionsFunction(funcname ,option, options, path, appName, ...) |
local info = new() |
local func |
local group = options |
local handler |
--build the info table containing the path |
-- pick up functions while traversing the tree |
if group[funcname] ~= nil then |
func = group[funcname] |
end |
handler = group.handler or handler |
for i, v in ipairs(path) do |
group = GetSubOption(group, v) |
info[i] = v |
if group[funcname] ~= nil then |
func = group[funcname] |
end |
handler = group.handler or handler |
end |
info.options = options |
info[0] = appName |
info.arg = option.arg |
local a, b, c ,d |
if type(func) == "string" then |
if handler and handler[func] then |
a,b,c,d = handler[func](handler, info, ...) |
else |
error(string.format("Method %s doesn't exist in handler for type func", func)) |
end |
elseif type(func) == "function" then |
a,b,c,d = func(info, ...) |
end |
del(info) |
return a,b,c,d |
end |
--]] |
--tables to hold orders and names for options being sorted, will be created with new() |
--prevents needing to call functions repeatedly while sorting |
local tempOrders |
local tempNames |
local function compareOptions(a,b) |
if not a then |
return true |
end |
if not b then |
return false |
end |
local OrderA, OrderB = tempOrders[a] or 100, tempOrders[b] or 100 |
if OrderA == OrderB then |
local NameA = (type(tempNames[a]) == "string") and tempNames[a] or "" |
local NameB = (type(tempNames[b]) == "string") and tempNames[b] or "" |
return NameA:upper() < NameB:upper() |
end |
if OrderA < 0 then |
if OrderB > 0 then |
return false |
end |
else |
if OrderB < 0 then |
return true |
end |
end |
return OrderA < OrderB |
end |
--builds 2 tables out of an options group |
-- keySort, sorted keys |
-- opts, combined options from .plugins and args |
local function BuildSortedOptionsTable(group, keySort, opts, options, path, appName) |
tempOrders = new() |
tempNames = new() |
if group.plugins then |
for plugin, t in pairs(group.plugins) do |
for k, v in pairs(t) do |
if not opts[k] then |
tinsert(keySort, k) |
opts[k] = v |
path[#path+1] = k |
tempOrders[k] = GetOptionsMemberValue("order", v, options, path, appName) |
tempNames[k] = GetOptionsMemberValue("name", v, options, path, appName) |
path[#path] = nil |
end |
end |
end |
end |
for k, v in pairs(group.args) do |
if not opts[k] then |
tinsert(keySort, k) |
opts[k] = v |
path[#path+1] = k |
tempOrders[k] = GetOptionsMemberValue("order", v, options, path, appName) |
tempNames[k] = GetOptionsMemberValue("name", v, options, path, appName) |
path[#path] = nil |
end |
end |
tsort(keySort, compareOptions) |
del(tempOrders) |
del(tempNames) |
end |
local function DelTree(tree) |
if tree.children then |
local childs = tree.children |
for i = 1, #childs do |
DelTree(childs[i]) |
del(childs[i]) |
end |
del(childs) |
end |
end |
local function CleanUserData(widget, event) |
local user = widget:GetUserDataTable() |
if user.path then |
del(user.path) |
end |
if widget.type == "TreeGroup" then |
local tree = user.tree |
widget:SetTree(nil) |
if tree then |
for i = 1, #tree do |
DelTree(tree[i]) |
del(tree[i]) |
end |
del(tree) |
end |
end |
if widget.type == "TabGroup" then |
widget:SetTabs(nil) |
if user.tablist then |
del(user.tablist) |
end |
end |
if widget.type == "DropdownGroup" then |
widget:SetGroupList(nil) |
if user.grouplist then |
del(user.grouplist) |
end |
if user.orderlist then |
del(user.orderlist) |
end |
end |
end |
-- - Gets a status table for the given appname and options path. |
-- @param appName The application name as given to `:RegisterOptionsTable()` |
-- @param path The path to the options (a table with all group keys) |
-- @return |
function AceConfigDialog:GetStatusTable(appName, path) |
local status = self.Status |
if not status[appName] then |
status[appName] = {} |
status[appName].status = {} |
status[appName].children = {} |
end |
status = status[appName] |
if path then |
for i = 1, #path do |
local v = path[i] |
if not status.children[v] then |
status.children[v] = {} |
status.children[v].status = {} |
status.children[v].children = {} |
end |
status = status.children[v] |
end |
end |
return status.status |
end |
--- Selects the specified path in the options window. |
-- The path specified has to match the keys of the groups in the table. |
-- @param appName The application name as given to `:RegisterOptionsTable()` |
-- @param ... The path to the key that should be selected |
function AceConfigDialog:SelectGroup(appName, ...) |
local path = new() |
local app = reg:GetOptionsTable(appName) |
if not app then |
error(("%s isn't registed with AceConfigRegistry, unable to open config"):format(appName), 2) |
end |
local options = app("dialog", MAJOR) |
local group = options |
local status = self:GetStatusTable(appName, path) |
if not status.groups then |
status.groups = {} |
end |
status = status.groups |
local treevalue |
local treestatus |
for n = 1, select("#",...) do |
local key = select(n, ...) |
if group.childGroups == "tab" or group.childGroups == "select" then |
--if this is a tab or select group, select the group |
status.selected = key |
--children of this group are no longer extra levels of a tree |
treevalue = nil |
else |
--tree group by default |
if treevalue then |
--this is an extra level of a tree group, build a uniquevalue for it |
treevalue = treevalue.."\001"..key |
else |
--this is the top level of a tree group, the uniquevalue is the same as the key |
treevalue = key |
if not status.groups then |
status.groups = {} |
end |
--save this trees status table for any extra levels or groups |
treestatus = status |
end |
--make sure that the tree entry is open, and select it. |
--the selected group will be overwritten if a child is the final target but still needs to be open |
treestatus.selected = treevalue |
treestatus.groups[treevalue] = true |
end |
--move to the next group in the path |
group = GetSubOption(group, key) |
if not group then |
break |
end |
tinsert(path, key) |
status = self:GetStatusTable(appName, path) |
if not status.groups then |
status.groups = {} |
end |
status = status.groups |
end |
del(path) |
reg:NotifyChange(appName) |
end |
local function OptionOnMouseOver(widget, event) |
--show a tooltip/set the status bar to the desc text |
local user = widget:GetUserDataTable() |
local opt = user.option |
local options = user.options |
local path = user.path |
local appName = user.appName |
GameTooltip:SetOwner(widget.frame, "ANCHOR_TOPRIGHT") |
local name = GetOptionsMemberValue("name", opt, options, path, appName) |
local desc = GetOptionsMemberValue("desc", opt, options, path, appName) |
local usage = GetOptionsMemberValue("usage", opt, options, path, appName) |
local descStyle = opt.descStyle |
if descStyle and descStyle ~= "tooltip" then return end |
GameTooltip:SetText(name, 1, .82, 0, 1) |
if opt.type == "multiselect" then |
GameTooltip:AddLine(user.text,0.5, 0.5, 0.8, 1) |
end |
if type(desc) == "string" then |
GameTooltip:AddLine(desc, 1, 1, 1, 1) |
end |
if type(usage) == "string" then |
GameTooltip:AddLine("Usage: "..usage, NORMAL_FONT_COLOR.r, NORMAL_FONT_COLOR.g, NORMAL_FONT_COLOR.b, 1) |
end |
GameTooltip:Show() |
end |
local function OptionOnMouseLeave(widget, event) |
GameTooltip:Hide() |
end |
local function GetFuncName(option) |
local type = option.type |
if type == "execute" then |
return "func" |
else |
return "set" |
end |
end |
local function confirmPopup(appName, rootframe, basepath, info, message, func, ...) |
if not StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"] then |
StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"] = {} |
end |
local t = StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"] |
for k in pairs(t) do |
t[k] = nil |
end |
t.text = message |
t.button1 = ACCEPT |
t.button2 = CANCEL |
t.preferredIndex = 3 |
local dialog, oldstrata |
t.OnAccept = function() |
safecall(func, unpack(t)) |
if dialog and oldstrata then |
dialog:SetFrameStrata(oldstrata) |
end |
AceConfigDialog:Open(appName, rootframe, unpack(basepath or emptyTbl)) |
del(info) |
end |
t.OnCancel = function() |
if dialog and oldstrata then |
dialog:SetFrameStrata(oldstrata) |
end |
AceConfigDialog:Open(appName, rootframe, unpack(basepath or emptyTbl)) |
del(info) |
end |
for i = 1, select("#", ...) do |
t[i] = select(i, ...) or false |
end |
t.timeout = 0 |
t.whileDead = 1 |
t.hideOnEscape = 1 |
dialog = StaticPopup_Show("ACECONFIGDIALOG30_CONFIRM_DIALOG") |
if dialog then |
oldstrata = dialog:GetFrameStrata() |
dialog:SetFrameStrata("TOOLTIP") |
end |
end |
local function ActivateControl(widget, event, ...) |
--This function will call the set / execute handler for the widget |
--widget:GetUserDataTable() contains the needed info |
local user = widget:GetUserDataTable() |
local option = user.option |
local options = user.options |
local path = user.path |
local info = new() |
local func |
local group = options |
local funcname = GetFuncName(option) |
local handler |
local confirm |
local validate |
--build the info table containing the path |
-- pick up functions while traversing the tree |
if group[funcname] ~= nil then |
func = group[funcname] |
end |
handler = group.handler or handler |
confirm = group.confirm |
validate = group.validate |
for i = 1, #path do |
local v = path[i] |
group = GetSubOption(group, v) |
info[i] = v |
if group[funcname] ~= nil then |
func = group[funcname] |
end |
handler = group.handler or handler |
if group.confirm ~= nil then |
confirm = group.confirm |
end |
if group.validate ~= nil then |
validate = group.validate |
end |
end |
info.options = options |
info.appName = user.appName |
info.arg = option.arg |
info.handler = handler |
info.option = option |
info.type = option.type |
info.uiType = "dialog" |
info.uiName = MAJOR |
local name |
if type(option.name) == "function" then |
name = option.name(info) |
elseif type(option.name) == "string" then |
name = option.name |
else |
name = "" |
end |
local usage = option.usage |
local pattern = option.pattern |
local validated = true |
if option.type == "input" then |
if type(pattern)=="string" then |
if not strmatch(..., pattern) then |
validated = false |
end |
end |
end |
local success |
if validated and option.type ~= "execute" then |
if type(validate) == "string" then |
if handler and handler[validate] then |
success, validated = safecall(handler[validate], handler, info, ...) |
if not success then validated = false end |
else |
error(format("Method %s doesn't exist in handler for type execute", validate)) |
end |
elseif type(validate) == "function" then |
success, validated = safecall(validate, info, ...) |
if not success then validated = false end |
end |
end |
local rootframe = user.rootframe |
if type(validated) == "string" then |
--validate function returned a message to display |
if rootframe.SetStatusText then |
rootframe:SetStatusText(validated) |
else |
-- TODO: do something else. |
end |
PlaySound("igPlayerInviteDecline") |
del(info) |
return true |
elseif not validated then |
--validate returned false |
if rootframe.SetStatusText then |
if usage then |
rootframe:SetStatusText(name..": "..usage) |
else |
if pattern then |
rootframe:SetStatusText(name..": Expected "..pattern) |
else |
rootframe:SetStatusText(name..": Invalid Value") |
end |
end |
else |
-- TODO: do something else |
end |
PlaySound("igPlayerInviteDecline") |
del(info) |
return true |
else |
local confirmText = option.confirmText |
--call confirm func/method |
if type(confirm) == "string" then |
if handler and handler[confirm] then |
success, confirm = safecall(handler[confirm], handler, info, ...) |
if success and type(confirm) == "string" then |
confirmText = confirm |
confirm = true |
elseif not success then |
confirm = false |
end |
else |
error(format("Method %s doesn't exist in handler for type confirm", confirm)) |
end |
elseif type(confirm) == "function" then |
success, confirm = safecall(confirm, info, ...) |
if success and type(confirm) == "string" then |
confirmText = confirm |
confirm = true |
elseif not success then |
confirm = false |
end |
end |
--confirm if needed |
if type(confirm) == "boolean" then |
if confirm then |
if not confirmText then |
local name, desc = option.name, option.desc |
if type(name) == "function" then |
name = name(info) |
end |
if type(desc) == "function" then |
desc = desc(info) |
end |
confirmText = name |
if desc then |
confirmText = confirmText.." - "..desc |
end |
end |
local iscustom = user.rootframe:GetUserData("iscustom") |
local rootframe |
if iscustom then |
rootframe = user.rootframe |
end |
local basepath = user.rootframe:GetUserData("basepath") |
if type(func) == "string" then |
if handler and handler[func] then |
confirmPopup(user.appName, rootframe, basepath, info, confirmText, handler[func], handler, info, ...) |
else |
error(format("Method %s doesn't exist in handler for type func", func)) |
end |
elseif type(func) == "function" then |
confirmPopup(user.appName, rootframe, basepath, info, confirmText, func, info, ...) |
end |
--func will be called and info deleted when the confirm dialog is responded to |
return |
end |
end |
--call the function |
if type(func) == "string" then |
if handler and handler[func] then |
safecall(handler[func],handler, info, ...) |
else |
error(format("Method %s doesn't exist in handler for type func", func)) |
end |
elseif type(func) == "function" then |
safecall(func,info, ...) |
end |
local iscustom = user.rootframe:GetUserData("iscustom") |
local basepath = user.rootframe:GetUserData("basepath") or emptyTbl |
--full refresh of the frame, some controls dont cause this on all events |
if option.type == "color" then |
if event == "OnValueConfirmed" then |
if iscustom then |
AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath)) |
else |
AceConfigDialog:Open(user.appName, unpack(basepath)) |
end |
end |
elseif option.type == "range" then |
if event == "OnMouseUp" then |
if iscustom then |
AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath)) |
else |
AceConfigDialog:Open(user.appName, unpack(basepath)) |
end |
end |
--multiselects don't cause a refresh on 'OnValueChanged' only 'OnClosed' |
elseif option.type == "multiselect" then |
user.valuechanged = true |
else |
if iscustom then |
AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath)) |
else |
AceConfigDialog:Open(user.appName, unpack(basepath)) |
end |
end |
end |
del(info) |
end |
local function ActivateSlider(widget, event, value) |
local option = widget:GetUserData("option") |
local min, max, step = option.min or (not option.softMin and 0 or nil), option.max or (not option.softMax and 100 or nil), option.step |
if min then |
if step then |
value = math_floor((value - min) / step + 0.5) * step + min |
end |
value = math_max(value, min) |
end |
if max then |
value = math_min(value, max) |
end |
ActivateControl(widget,event,value) |
end |
--called from a checkbox that is part of an internally created multiselect group |
--this type is safe to refresh on activation of one control |
local function ActivateMultiControl(widget, event, ...) |
ActivateControl(widget, event, widget:GetUserData("value"), ...) |
local user = widget:GetUserDataTable() |
local iscustom = user.rootframe:GetUserData("iscustom") |
local basepath = user.rootframe:GetUserData("basepath") or emptyTbl |
if iscustom then |
AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath)) |
else |
AceConfigDialog:Open(user.appName, unpack(basepath)) |
end |
end |
local function MultiControlOnClosed(widget, event, ...) |
local user = widget:GetUserDataTable() |
if user.valuechanged then |
local iscustom = user.rootframe:GetUserData("iscustom") |
local basepath = user.rootframe:GetUserData("basepath") or emptyTbl |
if iscustom then |
AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath)) |
else |
AceConfigDialog:Open(user.appName, unpack(basepath)) |
end |
end |
end |
local function FrameOnClose(widget, event) |
local appName = widget:GetUserData("appName") |
AceConfigDialog.OpenFrames[appName] = nil |
gui:Release(widget) |
end |
local function CheckOptionHidden(option, options, path, appName) |
--check for a specific boolean option |
local hidden = pickfirstset(option.dialogHidden,option.guiHidden) |
if hidden ~= nil then |
return hidden |
end |
return GetOptionsMemberValue("hidden", option, options, path, appName) |
end |
local function CheckOptionDisabled(option, options, path, appName) |
--check for a specific boolean option |
local disabled = pickfirstset(option.dialogDisabled,option.guiDisabled) |
if disabled ~= nil then |
return disabled |
end |
return GetOptionsMemberValue("disabled", option, options, path, appName) |
end |
--[[ |
local function BuildTabs(group, options, path, appName) |
local tabs = new() |
local text = new() |
local keySort = new() |
local opts = new() |
BuildSortedOptionsTable(group, keySort, opts, options, path, appName) |
for i = 1, #keySort do |
local k = keySort[i] |
local v = opts[k] |
if v.type == "group" then |
path[#path+1] = k |
local inline = pickfirstset(v.dialogInline,v.guiInline,v.inline, false) |
local hidden = CheckOptionHidden(v, options, path, appName) |
if not inline and not hidden then |
tinsert(tabs, k) |
text[k] = GetOptionsMemberValue("name", v, options, path, appName) |
end |
path[#path] = nil |
end |
end |
del(keySort) |
del(opts) |
return tabs, text |
end |
]] |
local function BuildSelect(group, options, path, appName) |
local groups = new() |
local order = new() |
local keySort = new() |
local opts = new() |
BuildSortedOptionsTable(group, keySort, opts, options, path, appName) |
for i = 1, #keySort do |
local k = keySort[i] |
local v = opts[k] |
if v.type == "group" then |
path[#path+1] = k |
local inline = pickfirstset(v.dialogInline,v.guiInline,v.inline, false) |
local hidden = CheckOptionHidden(v, options, path, appName) |
if not inline and not hidden then |
groups[k] = GetOptionsMemberValue("name", v, options, path, appName) |
tinsert(order, k) |
end |
path[#path] = nil |
end |
end |
del(opts) |
del(keySort) |
return groups, order |
end |
local function BuildSubGroups(group, tree, options, path, appName) |
local keySort = new() |
local opts = new() |
BuildSortedOptionsTable(group, keySort, opts, options, path, appName) |
for i = 1, #keySort do |
local k = keySort[i] |
local v = opts[k] |
if v.type == "group" then |
path[#path+1] = k |
local inline = pickfirstset(v.dialogInline,v.guiInline,v.inline, false) |
local hidden = CheckOptionHidden(v, options, path, appName) |
if not inline and not hidden then |
local entry = new() |
entry.value = k |
entry.text = GetOptionsMemberValue("name", v, options, path, appName) |
entry.icon = GetOptionsMemberValue("icon", v, options, path, appName) |
entry.iconCoords = GetOptionsMemberValue("iconCoords", v, options, path, appName) |
entry.disabled = CheckOptionDisabled(v, options, path, appName) |
if not tree.children then tree.children = new() end |
tinsert(tree.children,entry) |
if (v.childGroups or "tree") == "tree" then |
BuildSubGroups(v,entry, options, path, appName) |
end |
end |
path[#path] = nil |
end |
end |
del(keySort) |
del(opts) |
end |
local function BuildGroups(group, options, path, appName, recurse) |
local tree = new() |
local keySort = new() |
local opts = new() |
BuildSortedOptionsTable(group, keySort, opts, options, path, appName) |
for i = 1, #keySort do |
local k = keySort[i] |
local v = opts[k] |
if v.type == "group" then |
path[#path+1] = k |
local inline = pickfirstset(v.dialogInline,v.guiInline,v.inline, false) |
local hidden = CheckOptionHidden(v, options, path, appName) |
if not inline and not hidden then |
local entry = new() |
entry.value = k |
entry.text = GetOptionsMemberValue("name", v, options, path, appName) |
entry.icon = GetOptionsMemberValue("icon", v, options, path, appName) |
entry.disabled = CheckOptionDisabled(v, options, path, appName) |
tinsert(tree,entry) |
if recurse and (v.childGroups or "tree") == "tree" then |
BuildSubGroups(v,entry, options, path, appName) |
end |
end |
path[#path] = nil |
end |
end |
del(keySort) |
del(opts) |
return tree |
end |
local function InjectInfo(control, options, option, path, rootframe, appName) |
local user = control:GetUserDataTable() |
for i = 1, #path do |
user[i] = path[i] |
end |
user.rootframe = rootframe |
user.option = option |
user.options = options |
user.path = copy(path) |
user.appName = appName |
control:SetCallback("OnRelease", CleanUserData) |
control:SetCallback("OnLeave", OptionOnMouseLeave) |
control:SetCallback("OnEnter", OptionOnMouseOver) |
end |
--[[ |
options - root of the options table being fed |
container - widget that controls will be placed in |
rootframe - Frame object the options are in |
path - table with the keys to get to the group being fed |
--]] |
local function FeedOptions(appName, options,container,rootframe,path,group,inline) |
local keySort = new() |
local opts = new() |
BuildSortedOptionsTable(group, keySort, opts, options, path, appName) |
for i = 1, #keySort do |
local k = keySort[i] |
local v = opts[k] |
tinsert(path, k) |
local hidden = CheckOptionHidden(v, options, path, appName) |
local name = GetOptionsMemberValue("name", v, options, path, appName) |
if not hidden then |
if v.type == "group" then |
if inline or pickfirstset(v.dialogInline,v.guiInline,v.inline, false) then |
--Inline group |
local GroupContainer |
if name and name ~= "" then |
GroupContainer = gui:Create("InlineGroup") |
GroupContainer:SetTitle(name or "") |
else |
GroupContainer = gui:Create("SimpleGroup") |
end |
GroupContainer.width = "fill" |
GroupContainer:SetLayout("flow") |
container:AddChild(GroupContainer) |
FeedOptions(appName,options,GroupContainer,rootframe,path,v,true) |
end |
else |
--Control to feed |
local control |
local name = GetOptionsMemberValue("name", v, options, path, appName) |
if v.type == "execute" then |
local imageCoords = GetOptionsMemberValue("imageCoords",v, options, path, appName) |
local image, width, height = GetOptionsMemberValue("image",v, options, path, appName) |
if type(image) == "string" then |
control = gui:Create("Icon") |
if not width then |
width = GetOptionsMemberValue("imageWidth",v, options, path, appName) |
end |
if not height then |
height = GetOptionsMemberValue("imageHeight",v, options, path, appName) |
end |
if type(imageCoords) == "table" then |
control:SetImage(image, unpack(imageCoords)) |
else |
control:SetImage(image) |
end |
if type(width) ~= "number" then |
width = 32 |
end |
if type(height) ~= "number" then |
height = 32 |
end |
control:SetImageSize(width, height) |
control:SetLabel(name) |
else |
control = gui:Create("Button") |
control:SetText(name) |
end |
control:SetCallback("OnClick",ActivateControl) |
elseif v.type == "input" then |
local controlType = v.dialogControl or v.control or (v.multiline and "MultiLineEditBox") or "EditBox" |
control = gui:Create(controlType) |
if not control then |
geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(controlType))) |
control = gui:Create(v.multiline and "MultiLineEditBox" or "EditBox") |
end |
if v.multiline and control.SetNumLines then |
control:SetNumLines(tonumber(v.multiline) or 4) |
end |
control:SetLabel(name) |
control:SetCallback("OnEnterPressed",ActivateControl) |
local text = GetOptionsMemberValue("get",v, options, path, appName) |
if type(text) ~= "string" then |
text = "" |
end |
control:SetText(text) |
elseif v.type == "toggle" then |
control = gui:Create("CheckBox") |
control:SetLabel(name) |
control:SetTriState(v.tristate) |
local value = GetOptionsMemberValue("get",v, options, path, appName) |
control:SetValue(value) |
control:SetCallback("OnValueChanged",ActivateControl) |
if v.descStyle == "inline" then |
local desc = GetOptionsMemberValue("desc", v, options, path, appName) |
control:SetDescription(desc) |
end |
local image = GetOptionsMemberValue("image", v, options, path, appName) |
local imageCoords = GetOptionsMemberValue("imageCoords", v, options, path, appName) |
if type(image) == "string" then |
if type(imageCoords) == "table" then |
control:SetImage(image, unpack(imageCoords)) |
else |
control:SetImage(image) |
end |
end |
elseif v.type == "range" then |
control = gui:Create("Slider") |
control:SetLabel(name) |
control:SetSliderValues(v.softMin or v.min or 0, v.softMax or v.max or 100, v.bigStep or v.step or 0) |
control:SetIsPercent(v.isPercent) |
local value = GetOptionsMemberValue("get",v, options, path, appName) |
if type(value) ~= "number" then |
value = 0 |
end |
control:SetValue(value) |
control:SetCallback("OnValueChanged",ActivateSlider) |
control:SetCallback("OnMouseUp",ActivateSlider) |
elseif v.type == "select" then |
local values = GetOptionsMemberValue("values", v, options, path, appName) |
if v.style == "radio" then |
local disabled = CheckOptionDisabled(v, options, path, appName) |
local width = GetOptionsMemberValue("width",v,options,path,appName) |
control = gui:Create("InlineGroup") |
control:SetLayout("Flow") |
control:SetTitle(name) |
control.width = "fill" |
control:PauseLayout() |
local optionValue = GetOptionsMemberValue("get",v, options, path, appName) |
local t = {} |
for value, text in pairs(values) do |
t[#t+1]=value |
end |
tsort(t) |
for k, value in ipairs(t) do |
local text = values[value] |
local radio = gui:Create("CheckBox") |
radio:SetLabel(text) |
radio:SetUserData("value", value) |
radio:SetUserData("text", text) |
radio:SetDisabled(disabled) |
radio:SetType("radio") |
radio:SetValue(optionValue == value) |
radio:SetCallback("OnValueChanged", ActivateMultiControl) |
InjectInfo(radio, options, v, path, rootframe, appName) |
control:AddChild(radio) |
if width == "double" then |
radio:SetWidth(width_multiplier * 2) |
elseif width == "half" then |
radio:SetWidth(width_multiplier / 2) |
elseif width == "full" then |
radio.width = "fill" |
else |
radio:SetWidth(width_multiplier) |
end |
end |
control:ResumeLayout() |
control:DoLayout() |
else |
local controlType = v.dialogControl or v.control or "Dropdown" |
control = gui:Create(controlType) |
if not control then |
geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(controlType))) |
control = gui:Create("Dropdown") |
end |
local itemType = v.itemControl |
if itemType and not gui:GetWidgetVersion(itemType) then |
geterrorhandler()(("Invalid Custom Item Type - %s"):format(tostring(itemType))) |
itemType = nil |
end |
control:SetLabel(name) |
control:SetList(values, nil, itemType) |
local value = GetOptionsMemberValue("get",v, options, path, appName) |
if not values[value] then |
value = nil |
end |
control:SetValue(value) |
control:SetCallback("OnValueChanged", ActivateControl) |
end |
elseif v.type == "multiselect" then |
local values = GetOptionsMemberValue("values", v, options, path, appName) |
local disabled = CheckOptionDisabled(v, options, path, appName) |
local controlType = v.dialogControl or v.control |
local valuesort = new() |
if values then |
for value, text in pairs(values) do |
tinsert(valuesort, value) |
end |
end |
tsort(valuesort) |
if controlType then |
control = gui:Create(controlType) |
if not control then |
geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(controlType))) |
end |
end |
if control then |
control:SetMultiselect(true) |
control:SetLabel(name) |
control:SetList(values) |
control:SetDisabled(disabled) |
control:SetCallback("OnValueChanged",ActivateControl) |
control:SetCallback("OnClosed", MultiControlOnClosed) |
local width = GetOptionsMemberValue("width",v,options,path,appName) |
if width == "double" then |
control:SetWidth(width_multiplier * 2) |
elseif width == "half" then |
control:SetWidth(width_multiplier / 2) |
elseif width == "full" then |
control.width = "fill" |
else |
control:SetWidth(width_multiplier) |
end |
--check:SetTriState(v.tristate) |
for i = 1, #valuesort do |
local key = valuesort[i] |
local value = GetOptionsMemberValue("get",v, options, path, appName, key) |
control:SetItemValue(key,value) |
end |
else |
control = gui:Create("InlineGroup") |
control:SetLayout("Flow") |
control:SetTitle(name) |
control.width = "fill" |
control:PauseLayout() |
local width = GetOptionsMemberValue("width",v,options,path,appName) |
for i = 1, #valuesort do |
local value = valuesort[i] |
local text = values[value] |
local check = gui:Create("CheckBox") |
check:SetLabel(text) |
check:SetUserData("value", value) |
check:SetUserData("text", text) |
check:SetDisabled(disabled) |
check:SetTriState(v.tristate) |
check:SetValue(GetOptionsMemberValue("get",v, options, path, appName, value)) |
check:SetCallback("OnValueChanged",ActivateMultiControl) |
InjectInfo(check, options, v, path, rootframe, appName) |
control:AddChild(check) |
if width == "double" then |
check:SetWidth(width_multiplier * 2) |
elseif width == "half" then |
check:SetWidth(width_multiplier / 2) |
elseif width == "full" then |
check.width = "fill" |
else |
check:SetWidth(width_multiplier) |
end |
end |
control:ResumeLayout() |
control:DoLayout() |
end |
del(valuesort) |
elseif v.type == "color" then |
control = gui:Create("ColorPicker") |
control:SetLabel(name) |
control:SetHasAlpha(GetOptionsMemberValue("hasAlpha",v, options, path, appName)) |
control:SetColor(GetOptionsMemberValue("get",v, options, path, appName)) |
control:SetCallback("OnValueChanged",ActivateControl) |
control:SetCallback("OnValueConfirmed",ActivateControl) |
elseif v.type == "keybinding" then |
control = gui:Create("Keybinding") |
control:SetLabel(name) |
control:SetKey(GetOptionsMemberValue("get",v, options, path, appName)) |
control:SetCallback("OnKeyChanged",ActivateControl) |
elseif v.type == "header" then |
control = gui:Create("Heading") |
control:SetText(name) |
control.width = "fill" |
elseif v.type == "description" then |
control = gui:Create("Label") |
control:SetText(name) |
local fontSize = GetOptionsMemberValue("fontSize",v, options, path, appName) |
if fontSize == "medium" then |
control:SetFontObject(GameFontHighlight) |
elseif fontSize == "large" then |
control:SetFontObject(GameFontHighlightLarge) |
else -- small or invalid |
control:SetFontObject(GameFontHighlightSmall) |
end |
local imageCoords = GetOptionsMemberValue("imageCoords",v, options, path, appName) |
local image, width, height = GetOptionsMemberValue("image",v, options, path, appName) |
if type(image) == "string" then |
if not width then |
width = GetOptionsMemberValue("imageWidth",v, options, path, appName) |
end |
if not height then |
height = GetOptionsMemberValue("imageHeight",v, options, path, appName) |
end |
if type(imageCoords) == "table" then |
control:SetImage(image, unpack(imageCoords)) |
else |
control:SetImage(image) |
end |
if type(width) ~= "number" then |
width = 32 |
end |
if type(height) ~= "number" then |
height = 32 |
end |
control:SetImageSize(width, height) |
end |
local width = GetOptionsMemberValue("width",v,options,path,appName) |
control.width = not width and "fill" |
end |
--Common Init |
if control then |
if control.width ~= "fill" then |
local width = GetOptionsMemberValue("width",v,options,path,appName) |
if width == "double" then |
control:SetWidth(width_multiplier * 2) |
elseif width == "half" then |
control:SetWidth(width_multiplier / 2) |
elseif width == "full" then |
control.width = "fill" |
else |
control:SetWidth(width_multiplier) |
end |
end |
if control.SetDisabled then |
local disabled = CheckOptionDisabled(v, options, path, appName) |
control:SetDisabled(disabled) |
end |
InjectInfo(control, options, v, path, rootframe, appName) |
container:AddChild(control) |
end |
end |
end |
tremove(path) |
end |
container:ResumeLayout() |
container:DoLayout() |
del(keySort) |
del(opts) |
end |
local function BuildPath(path, ...) |
for i = 1, select("#",...) do |
tinsert(path, (select(i,...))) |
end |
end |
local function TreeOnButtonEnter(widget, event, uniquevalue, button) |
local user = widget:GetUserDataTable() |
if not user then return end |
local options = user.options |
local option = user.option |
local path = user.path |
local appName = user.appName |
local feedpath = new() |
for i = 1, #path do |
feedpath[i] = path[i] |
end |
BuildPath(feedpath, ("\001"):split(uniquevalue)) |
local group = options |
for i = 1, #feedpath do |
if not group then return end |
group = GetSubOption(group, feedpath[i]) |
end |
local name = GetOptionsMemberValue("name", group, options, feedpath, appName) |
local desc = GetOptionsMemberValue("desc", group, options, feedpath, appName) |
GameTooltip:SetOwner(button, "ANCHOR_NONE") |
if widget.type == "TabGroup" then |
GameTooltip:SetPoint("BOTTOM",button,"TOP") |
else |
GameTooltip:SetPoint("LEFT",button,"RIGHT") |
end |
GameTooltip:SetText(name, 1, .82, 0, 1) |
if type(desc) == "string" then |
GameTooltip:AddLine(desc, 1, 1, 1, 1) |
end |
GameTooltip:Show() |
end |
local function TreeOnButtonLeave(widget, event, value, button) |
GameTooltip:Hide() |
end |
local function GroupExists(appName, options, path, uniquevalue) |
if not uniquevalue then return false end |
local feedpath = new() |
local temppath = new() |
for i = 1, #path do |
feedpath[i] = path[i] |
end |
BuildPath(feedpath, ("\001"):split(uniquevalue)) |
local group = options |
for i = 1, #feedpath do |
local v = feedpath[i] |
temppath[i] = v |
group = GetSubOption(group, v) |
if not group or group.type ~= "group" or CheckOptionHidden(group, options, temppath, appName) then |
del(feedpath) |
del(temppath) |
return false |
end |
end |
del(feedpath) |
del(temppath) |
return true |
end |
local function GroupSelected(widget, event, uniquevalue) |
local user = widget:GetUserDataTable() |
local options = user.options |
local option = user.option |
local path = user.path |
local rootframe = user.rootframe |
local feedpath = new() |
for i = 1, #path do |
feedpath[i] = path[i] |
end |
BuildPath(feedpath, ("\001"):split(uniquevalue)) |
local group = options |
for i = 1, #feedpath do |
group = GetSubOption(group, feedpath[i]) |
end |
widget:ReleaseChildren() |
AceConfigDialog:FeedGroup(user.appName,options,widget,rootframe,feedpath) |
del(feedpath) |
end |
--[[ |
-- INTERNAL -- |
This function will feed one group, and any inline child groups into the given container |
Select Groups will only have the selection control (tree, tabs, dropdown) fed in |
and have a group selected, this event will trigger the feeding of child groups |
Rules: |
If the group is Inline, FeedOptions |
If the group has no child groups, FeedOptions |
If the group is a tab or select group, FeedOptions then add the Group Control |
If the group is a tree group FeedOptions then |
its parent isnt a tree group: then add the tree control containing this and all child tree groups |
if its parent is a tree group, its already a node on a tree |
--]] |
function AceConfigDialog:FeedGroup(appName,options,container,rootframe,path, isRoot) |
local group = options |
--follow the path to get to the curent group |
local inline |
local grouptype, parenttype = options.childGroups, "none" |
for i = 1, #path do |
local v = path[i] |
group = GetSubOption(group, v) |
inline = inline or pickfirstset(v.dialogInline,v.guiInline,v.inline, false) |
parenttype = grouptype |
grouptype = group.childGroups |
end |
if not parenttype then |
parenttype = "tree" |
end |
--check if the group has child groups |
local hasChildGroups |
for k, v in pairs(group.args) do |
if v.type == "group" and not pickfirstset(v.dialogInline,v.guiInline,v.inline, false) and not CheckOptionHidden(v, options, path, appName) then |
hasChildGroups = true |
end |
end |
if group.plugins then |
for plugin, t in pairs(group.plugins) do |
for k, v in pairs(t) do |
if v.type == "group" and not pickfirstset(v.dialogInline,v.guiInline,v.inline, false) and not CheckOptionHidden(v, options, path, appName) then |
hasChildGroups = true |
end |
end |
end |
end |
container:SetLayout("flow") |
local scroll |
--Add a scrollframe if we are not going to add a group control, this is the inverse of the conditions for that later on |
if (not (hasChildGroups and not inline)) or (grouptype ~= "tab" and grouptype ~= "select" and (parenttype == "tree" and not isRoot)) then |
if container.type ~= "InlineGroup" and container.type ~= "SimpleGroup" then |
scroll = gui:Create("ScrollFrame") |
scroll:SetLayout("flow") |
scroll.width = "fill" |
scroll.height = "fill" |
container:SetLayout("fill") |
container:AddChild(scroll) |
container = scroll |
end |
end |
FeedOptions(appName,options,container,rootframe,path,group,nil) |
if scroll then |
container:PerformLayout() |
local status = self:GetStatusTable(appName, path) |
if not status.scroll then |
status.scroll = {} |
end |
scroll:SetStatusTable(status.scroll) |
end |
if hasChildGroups and not inline then |
local name = GetOptionsMemberValue("name", group, options, path, appName) |
if grouptype == "tab" then |
local tab = gui:Create("TabGroup") |
InjectInfo(tab, options, group, path, rootframe, appName) |
tab:SetCallback("OnGroupSelected", GroupSelected) |
tab:SetCallback("OnTabEnter", TreeOnButtonEnter) |
tab:SetCallback("OnTabLeave", TreeOnButtonLeave) |
local status = AceConfigDialog:GetStatusTable(appName, path) |
if not status.groups then |
status.groups = {} |
end |
tab:SetStatusTable(status.groups) |
tab.width = "fill" |
tab.height = "fill" |
local tabs = BuildGroups(group, options, path, appName) |
tab:SetTabs(tabs) |
tab:SetUserData("tablist", tabs) |
for i = 1, #tabs do |
local entry = tabs[i] |
if not entry.disabled then |
tab:SelectTab((GroupExists(appName, options, path,status.groups.selected) and status.groups.selected) or entry.value) |
break |
end |
end |
container:AddChild(tab) |
elseif grouptype == "select" then |
local select = gui:Create("DropdownGroup") |
select:SetTitle(name) |
InjectInfo(select, options, group, path, rootframe, appName) |
select:SetCallback("OnGroupSelected", GroupSelected) |
local status = AceConfigDialog:GetStatusTable(appName, path) |
if not status.groups then |
status.groups = {} |
end |
select:SetStatusTable(status.groups) |
local grouplist, orderlist = BuildSelect(group, options, path, appName) |
select:SetGroupList(grouplist, orderlist) |
select:SetUserData("grouplist", grouplist) |
select:SetUserData("orderlist", orderlist) |
local firstgroup = orderlist[1] |
if firstgroup then |
select:SetGroup((GroupExists(appName, options, path,status.groups.selected) and status.groups.selected) or firstgroup) |
end |
select.width = "fill" |
select.height = "fill" |
container:AddChild(select) |
--assume tree group by default |
--if parenttype is tree then this group is already a node on that tree |
elseif (parenttype ~= "tree") or isRoot then |
local tree = gui:Create("TreeGroup") |
InjectInfo(tree, options, group, path, rootframe, appName) |
tree:EnableButtonTooltips(false) |
tree.width = "fill" |
tree.height = "fill" |
tree:SetCallback("OnGroupSelected", GroupSelected) |
tree:SetCallback("OnButtonEnter", TreeOnButtonEnter) |
tree:SetCallback("OnButtonLeave", TreeOnButtonLeave) |
local status = AceConfigDialog:GetStatusTable(appName, path) |
if not status.groups then |
status.groups = {} |
end |
local treedefinition = BuildGroups(group, options, path, appName, true) |
tree:SetStatusTable(status.groups) |
tree:SetTree(treedefinition) |
tree:SetUserData("tree",treedefinition) |
for i = 1, #treedefinition do |
local entry = treedefinition[i] |
if not entry.disabled then |
tree:SelectByValue((GroupExists(appName, options, path,status.groups.selected) and status.groups.selected) or entry.value) |
break |
end |
end |
container:AddChild(tree) |
end |
end |
end |
local old_CloseSpecialWindows |
local function RefreshOnUpdate(this) |
for appName in pairs(this.closing) do |
if AceConfigDialog.OpenFrames[appName] then |
AceConfigDialog.OpenFrames[appName]:Hide() |
end |
if AceConfigDialog.BlizOptions and AceConfigDialog.BlizOptions[appName] then |
for key, widget in pairs(AceConfigDialog.BlizOptions[appName]) do |
if not widget:IsVisible() then |
widget:ReleaseChildren() |
end |
end |
end |
this.closing[appName] = nil |
end |
if this.closeAll then |
for k, v in pairs(AceConfigDialog.OpenFrames) do |
if not this.closeAllOverride[k] then |
v:Hide() |
end |
end |
this.closeAll = nil |
wipe(this.closeAllOverride) |
end |
for appName in pairs(this.apps) do |
if AceConfigDialog.OpenFrames[appName] then |
local user = AceConfigDialog.OpenFrames[appName]:GetUserDataTable() |
AceConfigDialog:Open(appName, unpack(user.basepath or emptyTbl)) |
end |
if AceConfigDialog.BlizOptions and AceConfigDialog.BlizOptions[appName] then |
for key, widget in pairs(AceConfigDialog.BlizOptions[appName]) do |
local user = widget:GetUserDataTable() |
if widget:IsVisible() then |
AceConfigDialog:Open(widget:GetUserData("appName"), widget, unpack(user.basepath or emptyTbl)) |
end |
end |
end |
this.apps[appName] = nil |
end |
this:SetScript("OnUpdate", nil) |
end |
-- Upgrade the OnUpdate script as well, if needed. |
if AceConfigDialog.frame:GetScript("OnUpdate") then |
AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate) |
end |
--- Close all open options windows |
function AceConfigDialog:CloseAll() |
AceConfigDialog.frame.closeAll = true |
AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate) |
if next(self.OpenFrames) then |
return true |
end |
end |
--- Close a specific options window. |
-- @param appName The application name as given to `:RegisterOptionsTable()` |
function AceConfigDialog:Close(appName) |
if self.OpenFrames[appName] then |
AceConfigDialog.frame.closing[appName] = true |
AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate) |
return true |
end |
end |
-- Internal -- Called by AceConfigRegistry |
function AceConfigDialog:ConfigTableChanged(event, appName) |
AceConfigDialog.frame.apps[appName] = true |
AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate) |
end |
reg.RegisterCallback(AceConfigDialog, "ConfigTableChange", "ConfigTableChanged") |
--- Sets the default size of the options window for a specific application. |
-- @param appName The application name as given to `:RegisterOptionsTable()` |
-- @param width The default width |
-- @param height The default height |
function AceConfigDialog:SetDefaultSize(appName, width, height) |
local status = AceConfigDialog:GetStatusTable(appName) |
if type(width) == "number" and type(height) == "number" then |
status.width = width |
status.height = height |
end |
end |
--- Open an option window at the specified path (if any). |
-- This function can optionally feed the group into a pre-created container |
-- instead of creating a new container frame. |
-- @paramsig appName [, container][, ...] |
-- @param appName The application name as given to `:RegisterOptionsTable()` |
-- @param container An optional container frame to feed the options into |
-- @param ... The path to open after creating the options window (see `:SelectGroup` for details) |
function AceConfigDialog:Open(appName, container, ...) |
if not old_CloseSpecialWindows then |
old_CloseSpecialWindows = CloseSpecialWindows |
CloseSpecialWindows = function() |
local found = old_CloseSpecialWindows() |
return self:CloseAll() or found |
end |
end |
local app = reg:GetOptionsTable(appName) |
if not app then |
error(("%s isn't registed with AceConfigRegistry, unable to open config"):format(appName), 2) |
end |
local options = app("dialog", MAJOR) |
local f |
local path = new() |
local name = GetOptionsMemberValue("name", options, options, path, appName) |
--If an optional path is specified add it to the path table before feeding the options |
--as container is optional as well it may contain the first element of the path |
if type(container) == "string" then |
tinsert(path, container) |
container = nil |
end |
for n = 1, select("#",...) do |
tinsert(path, (select(n, ...))) |
end |
--if a container is given feed into that |
if container then |
f = container |
f:ReleaseChildren() |
f:SetUserData("appName", appName) |
f:SetUserData("iscustom", true) |
if #path > 0 then |
f:SetUserData("basepath", copy(path)) |
end |
local status = AceConfigDialog:GetStatusTable(appName) |
if not status.width then |
status.width = 700 |
end |
if not status.height then |
status.height = 500 |
end |
if f.SetStatusTable then |
f:SetStatusTable(status) |
end |
if f.SetTitle then |
f:SetTitle(name or "") |
end |
else |
if not self.OpenFrames[appName] then |
f = gui:Create("Frame") |
self.OpenFrames[appName] = f |
else |
f = self.OpenFrames[appName] |
end |
f:ReleaseChildren() |
f:SetCallback("OnClose", FrameOnClose) |
f:SetUserData("appName", appName) |
if #path > 0 then |
f:SetUserData("basepath", copy(path)) |
end |
f:SetTitle(name or "") |
local status = AceConfigDialog:GetStatusTable(appName) |
f:SetStatusTable(status) |
end |
self:FeedGroup(appName,options,f,f,path,true) |
if f.Show then |
f:Show() |
end |
del(path) |
if AceConfigDialog.frame.closeAll then |
-- close all is set, but thats not good, since we're just opening here, so force it |
AceConfigDialog.frame.closeAllOverride[appName] = true |
end |
end |
-- convert pre-39 BlizOptions structure to the new format |
if oldminor and oldminor < 39 and AceConfigDialog.BlizOptions then |
local old = AceConfigDialog.BlizOptions |
local new = {} |
for key, widget in pairs(old) do |
local appName = widget:GetUserData("appName") |
if not new[appName] then new[appName] = {} end |
new[appName][key] = widget |
end |
AceConfigDialog.BlizOptions = new |
else |
AceConfigDialog.BlizOptions = AceConfigDialog.BlizOptions or {} |
end |
local function FeedToBlizPanel(widget, event) |
local path = widget:GetUserData("path") |
AceConfigDialog:Open(widget:GetUserData("appName"), widget, unpack(path or emptyTbl)) |
end |
local function ClearBlizPanel(widget, event) |
local appName = widget:GetUserData("appName") |
AceConfigDialog.frame.closing[appName] = true |
AceConfigDialog.frame:SetScript("OnUpdate", RefreshOnUpdate) |
end |
--- Add an option table into the Blizzard Interface Options panel. |
-- You can optionally supply a descriptive name to use and a parent frame to use, |
-- as well as a path in the options table.\\ |
-- If no name is specified, the appName will be used instead. |
-- |
-- If you specify a proper `parent` (by name), the interface options will generate a |
-- tree layout. Note that only one level of children is supported, so the parent always |
-- has to be a head-level note. |
-- |
-- This function returns a reference to the container frame registered with the Interface |
-- Options. You can use this reference to open the options with the API function |
-- `InterfaceOptionsFrame_OpenToCategory`. |
-- @param appName The application name as given to `:RegisterOptionsTable()` |
-- @param name A descriptive name to display in the options tree (defaults to appName) |
-- @param parent The parent to use in the interface options tree. |
-- @param ... The path in the options table to feed into the interface options panel. |
-- @return The reference to the frame registered into the Interface Options. |
function AceConfigDialog:AddToBlizOptions(appName, name, parent, ...) |
local BlizOptions = AceConfigDialog.BlizOptions |
local key = appName |
for n = 1, select("#", ...) do |
key = key.."\001"..select(n, ...) |
end |
if not BlizOptions[appName] then |
BlizOptions[appName] = {} |
end |
if not BlizOptions[appName][key] then |
local group = gui:Create("BlizOptionsGroup") |
BlizOptions[appName][key] = group |
group:SetName(name or appName, parent) |
group:SetTitle(name or appName) |
group:SetUserData("appName", appName) |
if select("#", ...) > 0 then |
local path = {} |
for n = 1, select("#",...) do |
tinsert(path, (select(n, ...))) |
end |
group:SetUserData("path", path) |
end |
group:SetCallback("OnShow", FeedToBlizPanel) |
group:SetCallback("OnHide", ClearBlizPanel) |
InterfaceOptions_AddCategory(group.frame) |
return group.frame |
else |
error(("%s has already been added to the Blizzard Options Window with the given path"):format(appName), 2) |
end |
end |
<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> |
--- 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 1045 2011-12-09 17:58:40Z nevcairiel $ |
--[[ |
AceConfigCmd-3.0 |
Handles commandline optionstable access |
REQUIRES: AceConsole-3.0 for command registration (loaded on demand) |
]] |
-- TODO: plugin args |
local MAJOR, MINOR = "AceConfigCmd-3.0", 13 |
local AceConfigCmd = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceConfigCmd then return end |
AceConfigCmd.commands = AceConfigCmd.commands or {} |
local commands = AceConfigCmd.commands |
local cfgreg = LibStub("AceConfigRegistry-3.0") |
local AceConsole -- LoD |
local AceConsoleName = "AceConsole-3.0" |
-- Lua APIs |
local strsub, strsplit, strlower, strmatch, strtrim = string.sub, string.split, string.lower, string.match, string.trim |
local format, tonumber, tostring = string.format, tonumber, tostring |
local tsort, tinsert = table.sort, table.insert |
local select, pairs, next, type = select, pairs, next, type |
local error, assert = error, assert |
-- WoW APIs |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: LibStub, SELECTED_CHAT_FRAME, DEFAULT_CHAT_FRAME |
local L = setmetatable({}, { -- TODO: replace with proper locale |
__index = function(self,k) return k end |
}) |
local function print(msg) |
(SELECTED_CHAT_FRAME or DEFAULT_CHAT_FRAME):AddMessage(msg) |
end |
-- constants used by getparam() calls below |
local handlertypes = {["table"]=true} |
local handlermsg = "expected a table" |
local functypes = {["function"]=true, ["string"]=true} |
local funcmsg = "expected function or member name" |
-- pickfirstset() - picks the first non-nil value and returns it |
local function pickfirstset(...) |
for i=1,select("#",...) do |
if select(i,...)~=nil then |
return select(i,...) |
end |
end |
end |
-- err() - produce real error() regarding malformed options tables etc |
local function err(info,inputpos,msg ) |
local cmdstr=" "..strsub(info.input, 1, inputpos-1) |
error(MAJOR..": /" ..info[0] ..cmdstr ..": "..(msg or "malformed options table"), 2) |
end |
-- usererr() - produce chatframe message regarding bad slash syntax etc |
local function usererr(info,inputpos,msg ) |
local cmdstr=strsub(info.input, 1, inputpos-1); |
print("/" ..info[0] .. " "..cmdstr ..": "..(msg or "malformed options table")) |
end |
-- callmethod() - call a given named method (e.g. "get", "set") with given arguments |
local function callmethod(info, inputpos, tab, methodtype, ...) |
local method = info[methodtype] |
if not method then |
err(info, inputpos, "'"..methodtype.."': not set") |
end |
info.arg = tab.arg |
info.option = tab |
info.type = tab.type |
if type(method)=="function" then |
return method(info, ...) |
elseif type(method)=="string" then |
if type(info.handler[method])~="function" then |
err(info, inputpos, "'"..methodtype.."': '"..method.."' is not a member function of "..tostring(info.handler)) |
end |
return info.handler[method](info.handler, info, ...) |
else |
assert(false) -- type should have already been checked on read |
end |
end |
-- callfunction() - call a given named function (e.g. "name", "desc") with given arguments |
local function callfunction(info, tab, methodtype, ...) |
local method = tab[methodtype] |
info.arg = tab.arg |
info.option = tab |
info.type = tab.type |
if type(method)=="function" then |
return method(info, ...) |
else |
assert(false) -- type should have already been checked on read |
end |
end |
-- do_final() - do the final step (set/execute) along with validation and confirmation |
local function do_final(info, inputpos, tab, methodtype, ...) |
if info.validate then |
local res = callmethod(info,inputpos,tab,"validate",...) |
if type(res)=="string" then |
usererr(info, inputpos, "'"..strsub(info.input, inputpos).."' - "..res) |
return |
end |
end |
-- console ignores .confirm |
callmethod(info,inputpos,tab,methodtype, ...) |
end |
-- getparam() - used by handle() to retreive and store "handler", "get", "set", etc |
local function getparam(info, inputpos, tab, depth, paramname, types, errormsg) |
local old,oldat = info[paramname], info[paramname.."_at"] |
local val=tab[paramname] |
if val~=nil then |
if val==false then |
val=nil |
elseif not types[type(val)] then |
err(info, inputpos, "'" .. paramname.. "' - "..errormsg) |
end |
info[paramname] = val |
info[paramname.."_at"] = depth |
end |
return old,oldat |
end |
-- iterateargs(tab) - custom iterator that iterates both t.args and t.plugins.* |
local dummytable={} |
local function iterateargs(tab) |
if not tab.plugins then |
return pairs(tab.args) |
end |
local argtabkey,argtab=next(tab.plugins) |
local v |
return function(_, k) |
while argtab do |
k,v = next(argtab, k) |
if k then return k,v end |
if argtab==tab.args then |
argtab=nil |
else |
argtabkey,argtab = next(tab.plugins, argtabkey) |
if not argtabkey then |
argtab=tab.args |
end |
end |
end |
end |
end |
local function checkhidden(info, inputpos, tab) |
if tab.cmdHidden~=nil then |
return tab.cmdHidden |
end |
local hidden = tab.hidden |
if type(hidden) == "function" or type(hidden) == "string" then |
info.hidden = hidden |
hidden = callmethod(info, inputpos, tab, 'hidden') |
info.hidden = nil |
end |
return hidden |
end |
local function showhelp(info, inputpos, tab, depth, noHead) |
if not noHead then |
print("|cff33ff99"..info.appName.."|r: Arguments to |cffffff78/"..info[0].."|r "..strsub(info.input,1,inputpos-1)..":") |
end |
local sortTbl = {} -- [1..n]=name |
local refTbl = {} -- [name]=tableref |
for k,v in iterateargs(tab) do |
if not refTbl[k] then -- a plugin overriding something in .args |
tinsert(sortTbl, k) |
refTbl[k] = v |
end |
end |
tsort(sortTbl, function(one, two) |
local o1 = refTbl[one].order or 100 |
local o2 = refTbl[two].order or 100 |
if type(o1) == "function" or type(o1) == "string" then |
info.order = o1 |
info[#info+1] = one |
o1 = callmethod(info, inputpos, refTbl[one], "order") |
info[#info] = nil |
info.order = nil |
end |
if type(o2) == "function" or type(o1) == "string" then |
info.order = o2 |
info[#info+1] = two |
o2 = callmethod(info, inputpos, refTbl[two], "order") |
info[#info] = nil |
info.order = nil |
end |
if o1<0 and o2<0 then return o1<o2 end |
if o2<0 then return true end |
if o1<0 then return false end |
if o1==o2 then return tostring(one)<tostring(two) end -- compare names |
return o1<o2 |
end) |
for i = 1, #sortTbl do |
local k = sortTbl[i] |
local v = refTbl[k] |
if not checkhidden(info, inputpos, v) then |
if v.type ~= "description" and v.type ~= "header" then |
-- recursively show all inline groups |
local name, desc = v.name, v.desc |
if type(name) == "function" then |
name = callfunction(info, v, 'name') |
end |
if type(desc) == "function" then |
desc = callfunction(info, v, 'desc') |
end |
if v.type == "group" and pickfirstset(v.cmdInline, v.inline, false) then |
print(" "..(desc or name)..":") |
local oldhandler,oldhandler_at = getparam(info, inputpos, v, depth, "handler", handlertypes, handlermsg) |
showhelp(info, inputpos, v, depth, true) |
info.handler,info.handler_at = oldhandler,oldhandler_at |
else |
local key = k:gsub(" ", "_") |
print(" |cffffff78"..key.."|r - "..(desc or name or "")) |
end |
end |
end |
end |
end |
local function keybindingValidateFunc(text) |
if text == nil or text == "NONE" then |
return nil |
end |
text = text:upper() |
local shift, ctrl, alt |
local modifier |
while true do |
if text == "-" then |
break |
end |
modifier, text = strsplit('-', text, 2) |
if text then |
if modifier ~= "SHIFT" and modifier ~= "CTRL" and modifier ~= "ALT" then |
return false |
end |
if modifier == "SHIFT" then |
if shift then |
return false |
end |
shift = true |
end |
if modifier == "CTRL" then |
if ctrl then |
return false |
end |
ctrl = true |
end |
if modifier == "ALT" then |
if alt then |
return false |
end |
alt = true |
end |
else |
text = modifier |
break |
end |
end |
if text == "" then |
return false |
end |
if not text:find("^F%d+$") and text ~= "CAPSLOCK" and text:len() ~= 1 and (text:byte() < 128 or text:len() > 4) and not _G["KEY_" .. text] then |
return false |
end |
local s = text |
if shift then |
s = "SHIFT-" .. s |
end |
if ctrl then |
s = "CTRL-" .. s |
end |
if alt then |
s = "ALT-" .. s |
end |
return s |
end |
-- handle() - selfrecursing function that processes input->optiontable |
-- - depth - starts at 0 |
-- - retfalse - return false rather than produce error if a match is not found (used by inlined groups) |
local function handle(info, inputpos, tab, depth, retfalse) |
if not(type(tab)=="table" and type(tab.type)=="string") then err(info,inputpos) end |
------------------------------------------------------------------- |
-- Grab hold of handler,set,get,func,etc if set (and remember old ones) |
-- Note that we do NOT validate if method names are correct at this stage, |
-- the handler may change before they're actually used! |
local oldhandler,oldhandler_at = getparam(info,inputpos,tab,depth,"handler",handlertypes,handlermsg) |
local oldset,oldset_at = getparam(info,inputpos,tab,depth,"set",functypes,funcmsg) |
local oldget,oldget_at = getparam(info,inputpos,tab,depth,"get",functypes,funcmsg) |
local oldfunc,oldfunc_at = getparam(info,inputpos,tab,depth,"func",functypes,funcmsg) |
local oldvalidate,oldvalidate_at = getparam(info,inputpos,tab,depth,"validate",functypes,funcmsg) |
--local oldconfirm,oldconfirm_at = getparam(info,inputpos,tab,depth,"confirm",functypes,funcmsg) |
------------------------------------------------------------------- |
-- Act according to .type of this table |
if tab.type=="group" then |
------------ group -------------------------------------------- |
if type(tab.args)~="table" then err(info, inputpos) end |
if tab.plugins and type(tab.plugins)~="table" then err(info,inputpos) end |
-- grab next arg from input |
local _,nextpos,arg = (info.input):find(" *([^ ]+) *", inputpos) |
if not arg then |
showhelp(info, inputpos, tab, depth) |
return |
end |
nextpos=nextpos+1 |
-- loop .args and try to find a key with a matching name |
for k,v in iterateargs(tab) do |
if not(type(k)=="string" and type(v)=="table" and type(v.type)=="string") then err(info,inputpos, "options table child '"..tostring(k).."' is malformed") end |
-- is this child an inline group? if so, traverse into it |
if v.type=="group" and pickfirstset(v.cmdInline, v.inline, false) then |
info[depth+1] = k |
if handle(info, inputpos, v, depth+1, true)==false then |
info[depth+1] = nil |
-- wasn't found in there, but that's ok, we just keep looking down here |
else |
return -- done, name was found in inline group |
end |
-- matching name and not a inline group |
elseif strlower(arg)==strlower(k:gsub(" ", "_")) then |
info[depth+1] = k |
return handle(info,nextpos,v,depth+1) |
end |
end |
-- no match |
if retfalse then |
-- restore old infotable members and return false to indicate failure |
info.handler,info.handler_at = oldhandler,oldhandler_at |
info.set,info.set_at = oldset,oldset_at |
info.get,info.get_at = oldget,oldget_at |
info.func,info.func_at = oldfunc,oldfunc_at |
info.validate,info.validate_at = oldvalidate,oldvalidate_at |
--info.confirm,info.confirm_at = oldconfirm,oldconfirm_at |
return false |
end |
-- couldn't find the command, display error |
usererr(info, inputpos, "'"..arg.."' - " .. L["unknown argument"]) |
return |
end |
local str = strsub(info.input,inputpos); |
if tab.type=="execute" then |
------------ execute -------------------------------------------- |
do_final(info, inputpos, tab, "func") |
elseif tab.type=="input" then |
------------ input -------------------------------------------- |
local res = true |
if tab.pattern then |
if not(type(tab.pattern)=="string") then err(info, inputpos, "'pattern' - expected a string") end |
if not strmatch(str, tab.pattern) then |
usererr(info, inputpos, "'"..str.."' - " .. L["invalid input"]) |
return |
end |
end |
do_final(info, inputpos, tab, "set", str) |
elseif tab.type=="toggle" then |
------------ toggle -------------------------------------------- |
local b |
local str = strtrim(strlower(str)) |
if str=="" then |
b = callmethod(info, inputpos, tab, "get") |
if tab.tristate then |
--cycle in true, nil, false order |
if b then |
b = nil |
elseif b == nil then |
b = false |
else |
b = true |
end |
else |
b = not b |
end |
elseif str==L["on"] then |
b = true |
elseif str==L["off"] then |
b = false |
elseif tab.tristate and str==L["default"] then |
b = nil |
else |
if tab.tristate then |
usererr(info, inputpos, format(L["'%s' - expected 'on', 'off' or 'default', or no argument to toggle."], str)) |
else |
usererr(info, inputpos, format(L["'%s' - expected 'on' or 'off', or no argument to toggle."], str)) |
end |
return |
end |
do_final(info, inputpos, tab, "set", b) |
elseif tab.type=="range" then |
------------ range -------------------------------------------- |
local val = tonumber(str) |
if not val then |
usererr(info, inputpos, "'"..str.."' - "..L["expected number"]) |
return |
end |
if type(info.step)=="number" then |
val = val- (val % info.step) |
end |
if type(info.min)=="number" and val<info.min then |
usererr(info, inputpos, val.." - "..format(L["must be equal to or higher than %s"], tostring(info.min)) ) |
return |
end |
if type(info.max)=="number" and val>info.max then |
usererr(info, inputpos, val.." - "..format(L["must be equal to or lower than %s"], tostring(info.max)) ) |
return |
end |
do_final(info, inputpos, tab, "set", val) |
elseif tab.type=="select" then |
------------ select ------------------------------------ |
local str = strtrim(strlower(str)) |
local values = tab.values |
if type(values) == "function" or type(values) == "string" then |
info.values = values |
values = callmethod(info, inputpos, tab, "values") |
info.values = nil |
end |
if str == "" then |
local b = callmethod(info, inputpos, tab, "get") |
local fmt = "|cffffff78- [%s]|r %s" |
local fmt_sel = "|cffffff78- [%s]|r %s |cffff0000*|r" |
print(L["Options for |cffffff78"..info[#info].."|r:"]) |
for k, v in pairs(values) do |
if b == k then |
print(fmt_sel:format(k, v)) |
else |
print(fmt:format(k, v)) |
end |
end |
return |
end |
local ok |
for k,v in pairs(values) do |
if strlower(k)==str then |
str = k -- overwrite with key (in case of case mismatches) |
ok = true |
break |
end |
end |
if not ok then |
usererr(info, inputpos, "'"..str.."' - "..L["unknown selection"]) |
return |
end |
do_final(info, inputpos, tab, "set", str) |
elseif tab.type=="multiselect" then |
------------ multiselect ------------------------------------------- |
local str = strtrim(strlower(str)) |
local values = tab.values |
if type(values) == "function" or type(values) == "string" then |
info.values = values |
values = callmethod(info, inputpos, tab, "values") |
info.values = nil |
end |
if str == "" then |
local fmt = "|cffffff78- [%s]|r %s" |
local fmt_sel = "|cffffff78- [%s]|r %s |cffff0000*|r" |
print(L["Options for |cffffff78"..info[#info].."|r (multiple possible):"]) |
for k, v in pairs(values) do |
if callmethod(info, inputpos, tab, "get", k) then |
print(fmt_sel:format(k, v)) |
else |
print(fmt:format(k, v)) |
end |
end |
return |
end |
--build a table of the selections, checking that they exist |
--parse for =on =off =default in the process |
--table will be key = true for options that should toggle, key = [on|off|default] for options to be set |
local sels = {} |
for v in str:gmatch("[^ ]+") do |
--parse option=on etc |
local opt, val = v:match('(.+)=(.+)') |
--get option if toggling |
if not opt then |
opt = v |
end |
--check that the opt is valid |
local ok |
for k,v in pairs(values) do |
if strlower(k)==opt then |
opt = k -- overwrite with key (in case of case mismatches) |
ok = true |
break |
end |
end |
if not ok then |
usererr(info, inputpos, "'"..opt.."' - "..L["unknown selection"]) |
return |
end |
--check that if val was supplied it is valid |
if val then |
if val == L["on"] or val == L["off"] or (tab.tristate and val == L["default"]) then |
--val is valid insert it |
sels[opt] = val |
else |
if tab.tristate then |
usererr(info, inputpos, format(L["'%s' '%s' - expected 'on', 'off' or 'default', or no argument to toggle."], v, val)) |
else |
usererr(info, inputpos, format(L["'%s' '%s' - expected 'on' or 'off', or no argument to toggle."], v, val)) |
end |
return |
end |
else |
-- no val supplied, toggle |
sels[opt] = true |
end |
end |
for opt, val in pairs(sels) do |
local newval |
if (val == true) then |
--toggle the option |
local b = callmethod(info, inputpos, tab, "get", opt) |
if tab.tristate then |
--cycle in true, nil, false order |
if b then |
b = nil |
elseif b == nil then |
b = false |
else |
b = true |
end |
else |
b = not b |
end |
newval = b |
else |
--set the option as specified |
if val==L["on"] then |
newval = true |
elseif val==L["off"] then |
newval = false |
elseif val==L["default"] then |
newval = nil |
end |
end |
do_final(info, inputpos, tab, "set", opt, newval) |
end |
elseif tab.type=="color" then |
------------ color -------------------------------------------- |
local str = strtrim(strlower(str)) |
if str == "" then |
--TODO: Show current value |
return |
end |
local r, g, b, a |
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(str)) |
if str == "" then |
--TODO: Show current value |
return |
end |
local value = keybindingValidateFunc(str:upper()) |
if value == false then |
usererr(info, inputpos, format(L["'%s' - Invalid Keybinding."], str)) |
return |
end |
do_final(info, inputpos, tab, "set", value) |
elseif tab.type=="description" then |
------------ description -------------------- |
-- ignore description, GUI config only |
else |
err(info, inputpos, "unknown options table item type '"..tostring(tab.type).."'") |
end |
end |
--- Handle the chat command. |
-- This is usually called from a chat command handler to parse the command input as operations on an aceoptions table.\\ |
-- AceConfigCmd uses this function internally when a slash command is registered with `:CreateChatCommand` |
-- @param slashcmd The slash command WITHOUT leading slash (only used for error output) |
-- @param appName The application name as given to `:RegisterOptionsTable()` |
-- @param input The commandline input (as given by the WoW handler, i.e. without the command itself) |
-- @usage |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceConsole-3.0") |
-- -- Use AceConsole-3.0 to register a Chat Command |
-- MyAddon:RegisterChatCommand("mychat", "ChatCommand") |
-- |
-- -- Show the GUI if no input is supplied, otherwise handle the chat input. |
-- function MyAddon:ChatCommand(input) |
-- -- Assuming "MyOptions" is the appName of a valid options table |
-- if not input or input:trim() == "" then |
-- LibStub("AceConfigDialog-3.0"):Open("MyOptions") |
-- else |
-- LibStub("AceConfigCmd-3.0").HandleCommand(MyAddon, "mychat", "MyOptions", input) |
-- end |
-- end |
function AceConfigCmd:HandleCommand(slashcmd, appName, input) |
local optgetter = cfgreg:GetOptionsTable(appName) |
if not optgetter then |
error([[Usage: HandleCommand("slashcmd", "appName", "input"): 'appName' - no options table "]]..tostring(appName)..[[" has been registered]], 2) |
end |
local options = assert( optgetter("cmd", MAJOR) ) |
local info = { -- Don't try to recycle this, it gets handed off to callbacks and whatnot |
[0] = slashcmd, |
appName = appName, |
options = options, |
input = input, |
self = self, |
handler = self, |
uiType = "cmd", |
uiName = MAJOR, |
} |
handle(info, 1, options, 0) -- (info, inputpos, table, depth) |
end |
--- Utility function to create a slash command handler. |
-- Also registers tab completion with AceTab |
-- @param slashcmd The slash command WITHOUT leading slash (only used for error output) |
-- @param appName The application name as given to `:RegisterOptionsTable()` |
function AceConfigCmd:CreateChatCommand(slashcmd, appName) |
if not AceConsole then |
AceConsole = LibStub(AceConsoleName) |
end |
if AceConsole.RegisterChatCommand(self, slashcmd, function(input) |
AceConfigCmd.HandleCommand(self, slashcmd, appName, input) -- upgradable |
end, |
true) then -- succesfully registered so lets get the command -> app table in |
commands[slashcmd] = appName |
end |
end |
--- Utility function that returns the options table that belongs to a slashcommand. |
-- Designed to be used for the AceTab interface. |
-- @param slashcmd The slash command WITHOUT leading slash (only used for error output) |
-- @return The options table associated with the slash command (or nil if the slash command was not registered) |
function AceConfigCmd:GetChatCommandOptions(slashcmd) |
return commands[slashcmd] |
end |
<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> |
--- 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 1045 2011-12-09 17:58:40Z nevcairiel $ |
local MAJOR, MINOR = "AceConfigRegistry-3.0", 14 |
local AceConfigRegistry = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceConfigRegistry then return end |
AceConfigRegistry.tables = AceConfigRegistry.tables or {} |
local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0") |
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 optnumber={["nil"]=true,["number"]=true, _="number"} |
local optmethod={["nil"]=true,["string"]=true,["function"]=true, _="methodname or funcref"} |
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 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, |
icon=optstringfunc, |
iconCoords=optmethodtable, |
handler=opttable, |
get=optmethodfalse, |
set=optmethodfalse, |
func=optmethodfalse, |
arg={["*"]=true}, |
width=optstring, |
} |
local typedkeys={ |
header={}, |
description={ |
image=optstringfunc, |
imageCoords=optmethodtable, |
imageHeight=optnumber, |
imageWidth=optnumber, |
fontSize=optstringfunc, |
}, |
group={ |
args=istable, |
plugins=opttable, |
inline=optbool, |
cmdInline=optbool, |
guiInline=optbool, |
dropdownInline=optbool, |
dialogInline=optbool, |
childGroups=optstring, |
}, |
execute={ |
image=optstringfunc, |
imageCoords=optmethodtable, |
imageHeight=optnumber, |
imageWidth=optnumber, |
}, |
input={ |
pattern=optstring, |
usage=optstring, |
control=optstring, |
dialogControl=optstring, |
dropdownControl=optstring, |
multiline=optboolnumber, |
}, |
toggle={ |
tristate=optbool, |
image=optstringfunc, |
imageCoords=optmethodtable, |
}, |
tristate={ |
}, |
range={ |
min=optnumber, |
softMin=optnumber, |
max=optnumber, |
softMax=optnumber, |
step=optnumber, |
bigStep=optnumber, |
isPercent=optbool, |
}, |
select={ |
values=ismethodtable, |
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, |
}, |
keybinding={ |
-- TODO |
}, |
} |
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. |
function AceConfigRegistry:RegisterOptionsTable(appName, options) |
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] 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] 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 |
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
..\FrameXML\UI.xsd"> |
<Script file="AceDB-3.0.lua"/> |
</Ui> |
--- **AceDB-3.0** manages the SavedVariables of your addon. |
-- It offers profile management, smart defaults and namespaces for modules.\\ |
-- Data can be saved in different data-types, depending on its intended usage. |
-- The most common data-type is the `profile` type, which allows the user to choose |
-- the active profile, and manage the profiles of all of his characters.\\ |
-- The following data types are available: |
-- * **char** Character-specific data. Every character has its own database. |
-- * **realm** Realm-specific data. All of the players characters on the same realm share this database. |
-- * **class** Class-specific data. All of the players characters of the same class share this database. |
-- * **race** Race-specific data. All of the players characters of the same race share this database. |
-- * **faction** Faction-specific data. All of the players characters of the same faction share this database. |
-- * **factionrealm** Faction and realm specific data. All of the players characters on the same realm and of the same faction share this database. |
-- * **global** Global Data. All characters on the same account share this database. |
-- * **profile** Profile-specific data. All characters using the same profile share this database. The user can control which profile should be used. |
-- |
-- Creating a new Database using the `:New` function will return a new DBObject. A database will inherit all functions |
-- of the DBObjectLib listed here. \\ |
-- If you create a new namespaced child-database (`:RegisterNamespace`), you'll get a DBObject as well, but note |
-- that the child-databases cannot individually change their profile, and are linked to their parents profile - and because of that, |
-- the profile related APIs are not available. Only `:RegisterDefaults` and `:ResetProfile` are available on child-databases. |
-- |
-- For more details on how to use AceDB-3.0, see the [[AceDB-3.0 Tutorial]]. |
-- |
-- You may also be interested in [[libdualspec-1-0|LibDualSpec-1.0]] to do profile switching automatically when switching specs. |
-- |
-- @usage |
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("DBExample") |
-- |
-- -- declare defaults to be used in the DB |
-- local defaults = { |
-- profile = { |
-- setting = true, |
-- } |
-- } |
-- |
-- function MyAddon:OnInitialize() |
-- -- Assuming the .toc says ## SavedVariables: MyAddonDB |
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
-- end |
-- @class file |
-- @name AceDB-3.0.lua |
-- @release $Id: AceDB-3.0.lua 1035 2011-07-09 03:20:13Z kaelten $ |
local ACEDB_MAJOR, ACEDB_MINOR = "AceDB-3.0", 22 |
local AceDB, oldminor = LibStub:NewLibrary(ACEDB_MAJOR, ACEDB_MINOR) |
if not AceDB then return end -- No upgrade needed |
-- Lua APIs |
local type, pairs, next, error = type, pairs, next, error |
local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget |
-- WoW APIs |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: LibStub |
AceDB.db_registry = AceDB.db_registry or {} |
AceDB.frame = AceDB.frame or CreateFrame("Frame") |
local CallbackHandler |
local CallbackDummy = { Fire = function() end } |
local DBObjectLib = {} |
--[[------------------------------------------------------------------------- |
AceDB Utility Functions |
---------------------------------------------------------------------------]] |
-- Simple shallow copy for copying defaults |
local function copyTable(src, dest) |
if type(dest) ~= "table" then dest = {} end |
if type(src) == "table" then |
for k,v in pairs(src) do |
if type(v) == "table" then |
-- try to index the key first so that the metatable creates the defaults, if set, and use that table |
v = copyTable(v, dest[k]) |
end |
dest[k] = v |
end |
end |
return dest |
end |
-- Called to add defaults to a section of the database |
-- |
-- When a ["*"] default section is indexed with a new key, a table is returned |
-- and set in the host table. These tables must be cleaned up by removeDefaults |
-- in order to ensure we don't write empty default tables. |
local function copyDefaults(dest, src) |
-- this happens if some value in the SV overwrites our default value with a non-table |
--if type(dest) ~= "table" then return end |
for k, v in pairs(src) do |
if k == "*" or k == "**" then |
if type(v) == "table" then |
-- This is a metatable used for table defaults |
local mt = { |
-- This handles the lookup and creation of new subtables |
__index = function(t,k) |
if k == nil then return nil end |
local tbl = {} |
copyDefaults(tbl, v) |
rawset(t, k, tbl) |
return tbl |
end, |
} |
setmetatable(dest, mt) |
-- handle already existing tables in the SV |
for dk, dv in pairs(dest) do |
if not rawget(src, dk) and type(dv) == "table" then |
copyDefaults(dv, v) |
end |
end |
else |
-- Values are not tables, so this is just a simple return |
local mt = {__index = function(t,k) return k~=nil and v or nil end} |
setmetatable(dest, mt) |
end |
elseif type(v) == "table" then |
if not rawget(dest, k) then rawset(dest, k, {}) end |
if type(dest[k]) == "table" then |
copyDefaults(dest[k], v) |
if src['**'] then |
copyDefaults(dest[k], src['**']) |
end |
end |
else |
if rawget(dest, k) == nil then |
rawset(dest, k, v) |
end |
end |
end |
end |
-- Called to remove all defaults in the default table from the database |
local function removeDefaults(db, defaults, blocker) |
-- remove all metatables from the db, so we don't accidentally create new sub-tables through them |
setmetatable(db, nil) |
-- loop through the defaults and remove their content |
for k,v in pairs(defaults) do |
if k == "*" or k == "**" then |
if type(v) == "table" then |
-- Loop through all the actual k,v pairs and remove |
for key, value in pairs(db) do |
if type(value) == "table" then |
-- if the key was not explicitly specified in the defaults table, just strip everything from * and ** tables |
if defaults[key] == nil and (not blocker or blocker[key] == nil) then |
removeDefaults(value, v) |
-- if the table is empty afterwards, remove it |
if next(value) == nil then |
db[key] = nil |
end |
-- if it was specified, only strip ** content, but block values which were set in the key table |
elseif k == "**" then |
removeDefaults(value, v, defaults[key]) |
end |
end |
end |
elseif k == "*" then |
-- check for non-table default |
for key, value in pairs(db) do |
if defaults[key] == nil and v == value then |
db[key] = nil |
end |
end |
end |
elseif type(v) == "table" and type(db[k]) == "table" then |
-- if a blocker was set, dive into it, to allow multi-level defaults |
removeDefaults(db[k], v, blocker and blocker[k]) |
if next(db[k]) == nil then |
db[k] = nil |
end |
else |
-- check if the current value matches the default, and that its not blocked by another defaults table |
if db[k] == defaults[k] and (not blocker or blocker[k] == nil) then |
db[k] = nil |
end |
end |
end |
end |
-- This is called when a table section is first accessed, to set up the defaults |
local function initSection(db, section, svstore, key, defaults) |
local sv = rawget(db, "sv") |
local tableCreated |
if not sv[svstore] then sv[svstore] = {} end |
if not sv[svstore][key] then |
sv[svstore][key] = {} |
tableCreated = true |
end |
local tbl = sv[svstore][key] |
if defaults then |
copyDefaults(tbl, defaults) |
end |
rawset(db, section, tbl) |
return tableCreated, tbl |
end |
-- Metatable to handle the dynamic creation of sections and copying of sections. |
local dbmt = { |
__index = function(t, section) |
local keys = rawget(t, "keys") |
local key = keys[section] |
if key then |
local defaultTbl = rawget(t, "defaults") |
local defaults = defaultTbl and defaultTbl[section] |
if section == "profile" then |
local new = initSection(t, section, "profiles", key, defaults) |
if new then |
-- Callback: OnNewProfile, database, newProfileKey |
t.callbacks:Fire("OnNewProfile", t, key) |
end |
elseif section == "profiles" then |
local sv = rawget(t, "sv") |
if not sv.profiles then sv.profiles = {} end |
rawset(t, "profiles", sv.profiles) |
elseif section == "global" then |
local sv = rawget(t, "sv") |
if not sv.global then sv.global = {} end |
if defaults then |
copyDefaults(sv.global, defaults) |
end |
rawset(t, section, sv.global) |
else |
initSection(t, section, section, key, defaults) |
end |
end |
return rawget(t, section) |
end |
} |
local function validateDefaults(defaults, keyTbl, offset) |
if not defaults then return end |
offset = offset or 0 |
for k in pairs(defaults) do |
if not keyTbl[k] or k == "profiles" then |
error(("Usage: AceDBObject:RegisterDefaults(defaults): '%s' is not a valid datatype."):format(k), 3 + offset) |
end |
end |
end |
local preserve_keys = { |
["callbacks"] = true, |
["RegisterCallback"] = true, |
["UnregisterCallback"] = true, |
["UnregisterAllCallbacks"] = true, |
["children"] = true, |
} |
local realmKey = GetRealmName() |
local charKey = UnitName("player") .. " - " .. realmKey |
local _, classKey = UnitClass("player") |
local _, raceKey = UnitRace("player") |
local factionKey = UnitFactionGroup("player") |
local factionrealmKey = factionKey .. " - " .. realmKey |
local factionrealmregionKey = factionrealmKey .. " - " .. string.sub(GetCVar("realmList"), 1, 2):upper() |
local localeKey = GetLocale():lower() |
-- Actual database initialization function |
local function initdb(sv, defaults, defaultProfile, olddb, parent) |
-- Generate the database keys for each section |
-- map "true" to our "Default" profile |
if defaultProfile == true then defaultProfile = "Default" end |
local profileKey |
if not parent then |
-- Make a container for profile keys |
if not sv.profileKeys then sv.profileKeys = {} end |
-- Try to get the profile selected from the char db |
profileKey = sv.profileKeys[charKey] or defaultProfile or charKey |
-- save the selected profile for later |
sv.profileKeys[charKey] = profileKey |
else |
-- Use the profile of the parents DB |
profileKey = parent.keys.profile or defaultProfile or charKey |
-- clear the profileKeys in the DB, namespaces don't need to store them |
sv.profileKeys = nil |
end |
-- This table contains keys that enable the dynamic creation |
-- of each section of the table. The 'global' and 'profiles' |
-- have a key of true, since they are handled in a special case |
local keyTbl= { |
["char"] = charKey, |
["realm"] = realmKey, |
["class"] = classKey, |
["race"] = raceKey, |
["faction"] = factionKey, |
["factionrealm"] = factionrealmKey, |
["factionrealmregion"] = factionrealmregionKey, |
["profile"] = profileKey, |
["locale"] = localeKey, |
["global"] = true, |
["profiles"] = true, |
} |
validateDefaults(defaults, keyTbl, 1) |
-- This allows us to use this function to reset an entire database |
-- Clear out the old database |
if olddb then |
for k,v in pairs(olddb) do if not preserve_keys[k] then olddb[k] = nil end end |
end |
-- Give this database the metatable so it initializes dynamically |
local db = setmetatable(olddb or {}, dbmt) |
if not rawget(db, "callbacks") then |
-- try to load CallbackHandler-1.0 if it loaded after our library |
if not CallbackHandler then CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0", true) end |
db.callbacks = CallbackHandler and CallbackHandler:New(db) or CallbackDummy |
end |
-- Copy methods locally into the database object, to avoid hitting |
-- the metatable when calling methods |
if not parent then |
for name, func in pairs(DBObjectLib) do |
db[name] = func |
end |
else |
-- hack this one in |
db.RegisterDefaults = DBObjectLib.RegisterDefaults |
db.ResetProfile = DBObjectLib.ResetProfile |
end |
-- Set some properties in the database object |
db.profiles = sv.profiles |
db.keys = keyTbl |
db.sv = sv |
--db.sv_name = name |
db.defaults = defaults |
db.parent = parent |
-- store the DB in the registry |
AceDB.db_registry[db] = true |
return db |
end |
-- handle PLAYER_LOGOUT |
-- strip all defaults from all databases |
-- and cleans up empty sections |
local function logoutHandler(frame, event) |
if event == "PLAYER_LOGOUT" then |
for db in pairs(AceDB.db_registry) do |
db.callbacks:Fire("OnDatabaseShutdown", db) |
db:RegisterDefaults(nil) |
-- cleanup sections that are empty without defaults |
local sv = rawget(db, "sv") |
for section in pairs(db.keys) do |
if rawget(sv, section) then |
-- global is special, all other sections have sub-entrys |
-- also don't delete empty profiles on main dbs, only on namespaces |
if section ~= "global" and (section ~= "profiles" or rawget(db, "parent")) then |
for key in pairs(sv[section]) do |
if not next(sv[section][key]) then |
sv[section][key] = nil |
end |
end |
end |
if not next(sv[section]) then |
sv[section] = nil |
end |
end |
end |
end |
end |
end |
AceDB.frame:RegisterEvent("PLAYER_LOGOUT") |
AceDB.frame:SetScript("OnEvent", logoutHandler) |
--[[------------------------------------------------------------------------- |
AceDB Object Method Definitions |
---------------------------------------------------------------------------]] |
--- Sets the defaults table for the given database object by clearing any |
-- that are currently set, and then setting the new defaults. |
-- @param defaults A table of defaults for this database |
function DBObjectLib:RegisterDefaults(defaults) |
if defaults and type(defaults) ~= "table" then |
error("Usage: AceDBObject:RegisterDefaults(defaults): 'defaults' - table or nil expected.", 2) |
end |
validateDefaults(defaults, self.keys) |
-- Remove any currently set defaults |
if self.defaults then |
for section,key in pairs(self.keys) do |
if self.defaults[section] and rawget(self, section) then |
removeDefaults(self[section], self.defaults[section]) |
end |
end |
end |
-- Set the DBObject.defaults table |
self.defaults = defaults |
-- Copy in any defaults, only touching those sections already created |
if defaults then |
for section,key in pairs(self.keys) do |
if defaults[section] and rawget(self, section) then |
copyDefaults(self[section], defaults[section]) |
end |
end |
end |
end |
--- Changes the profile of the database and all of it's namespaces to the |
-- supplied named profile |
-- @param name The name of the profile to set as the current profile |
function DBObjectLib:SetProfile(name) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:SetProfile(name): 'name' - string expected.", 2) |
end |
-- changing to the same profile, dont do anything |
if name == self.keys.profile then return end |
local oldProfile = self.profile |
local defaults = self.defaults and self.defaults.profile |
-- Callback: OnProfileShutdown, database |
self.callbacks:Fire("OnProfileShutdown", self) |
if oldProfile and defaults then |
-- Remove the defaults from the old profile |
removeDefaults(oldProfile, defaults) |
end |
self.profile = nil |
self.keys["profile"] = name |
-- if the storage exists, save the new profile |
-- this won't exist on namespaces. |
if self.sv.profileKeys then |
self.sv.profileKeys[charKey] = name |
end |
-- populate to child namespaces |
if self.children then |
for _, db in pairs(self.children) do |
DBObjectLib.SetProfile(db, name) |
end |
end |
-- Callback: OnProfileChanged, database, newProfileKey |
self.callbacks:Fire("OnProfileChanged", self, name) |
end |
--- Returns a table with the names of the existing profiles in the database. |
-- You can optionally supply a table to re-use for this purpose. |
-- @param tbl A table to store the profile names in (optional) |
function DBObjectLib:GetProfiles(tbl) |
if tbl and type(tbl) ~= "table" then |
error("Usage: AceDBObject:GetProfiles(tbl): 'tbl' - table or nil expected.", 2) |
end |
-- Clear the container table |
if tbl then |
for k,v in pairs(tbl) do tbl[k] = nil end |
else |
tbl = {} |
end |
local curProfile = self.keys.profile |
local i = 0 |
for profileKey in pairs(self.profiles) do |
i = i + 1 |
tbl[i] = profileKey |
if curProfile and profileKey == curProfile then curProfile = nil end |
end |
-- Add the current profile, if it hasn't been created yet |
if curProfile then |
i = i + 1 |
tbl[i] = curProfile |
end |
return tbl, i |
end |
--- Returns the current profile name used by the database |
function DBObjectLib:GetCurrentProfile() |
return self.keys.profile |
end |
--- Deletes a named profile. This profile must not be the active profile. |
-- @param name The name of the profile to be deleted |
-- @param silent If true, do not raise an error when the profile does not exist |
function DBObjectLib:DeleteProfile(name, silent) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:DeleteProfile(name): 'name' - string expected.", 2) |
end |
if self.keys.profile == name then |
error("Cannot delete the active profile in an AceDBObject.", 2) |
end |
if not rawget(self.profiles, name) and not silent then |
error("Cannot delete profile '" .. name .. "'. It does not exist.", 2) |
end |
self.profiles[name] = nil |
-- populate to child namespaces |
if self.children then |
for _, db in pairs(self.children) do |
DBObjectLib.DeleteProfile(db, name, true) |
end |
end |
-- Callback: OnProfileDeleted, database, profileKey |
self.callbacks:Fire("OnProfileDeleted", self, name) |
end |
--- Copies a named profile into the current profile, overwriting any conflicting |
-- settings. |
-- @param name The name of the profile to be copied into the current profile |
-- @param silent If true, do not raise an error when the profile does not exist |
function DBObjectLib:CopyProfile(name, silent) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:CopyProfile(name): 'name' - string expected.", 2) |
end |
if name == self.keys.profile then |
error("Cannot have the same source and destination profiles.", 2) |
end |
if not rawget(self.profiles, name) and not silent then |
error("Cannot copy profile '" .. name .. "'. It does not exist.", 2) |
end |
-- Reset the profile before copying |
DBObjectLib.ResetProfile(self, nil, true) |
local profile = self.profile |
local source = self.profiles[name] |
copyTable(source, profile) |
-- populate to child namespaces |
if self.children then |
for _, db in pairs(self.children) do |
DBObjectLib.CopyProfile(db, name, true) |
end |
end |
-- Callback: OnProfileCopied, database, sourceProfileKey |
self.callbacks:Fire("OnProfileCopied", self, name) |
end |
--- Resets the current profile to the default values (if specified). |
-- @param noChildren if set to true, the reset will not be populated to the child namespaces of this DB object |
-- @param noCallbacks if set to true, won't fire the OnProfileReset callback |
function DBObjectLib:ResetProfile(noChildren, noCallbacks) |
local profile = self.profile |
for k,v in pairs(profile) do |
profile[k] = nil |
end |
local defaults = self.defaults and self.defaults.profile |
if defaults then |
copyDefaults(profile, defaults) |
end |
-- populate to child namespaces |
if self.children and not noChildren then |
for _, db in pairs(self.children) do |
DBObjectLib.ResetProfile(db, nil, noCallbacks) |
end |
end |
-- Callback: OnProfileReset, database |
if not noCallbacks then |
self.callbacks:Fire("OnProfileReset", self) |
end |
end |
--- Resets the entire database, using the string defaultProfile as the new default |
-- profile. |
-- @param defaultProfile The profile name to use as the default |
function DBObjectLib:ResetDB(defaultProfile) |
if defaultProfile and type(defaultProfile) ~= "string" then |
error("Usage: AceDBObject:ResetDB(defaultProfile): 'defaultProfile' - string or nil expected.", 2) |
end |
local sv = self.sv |
for k,v in pairs(sv) do |
sv[k] = nil |
end |
local parent = self.parent |
initdb(sv, self.defaults, defaultProfile, self) |
-- fix the child namespaces |
if self.children then |
if not sv.namespaces then sv.namespaces = {} end |
for name, db in pairs(self.children) do |
if not sv.namespaces[name] then sv.namespaces[name] = {} end |
initdb(sv.namespaces[name], db.defaults, self.keys.profile, db, self) |
end |
end |
-- Callback: OnDatabaseReset, database |
self.callbacks:Fire("OnDatabaseReset", self) |
-- Callback: OnProfileChanged, database, profileKey |
self.callbacks:Fire("OnProfileChanged", self, self.keys["profile"]) |
return self |
end |
--- Creates a new database namespace, directly tied to the database. This |
-- is a full scale database in it's own rights other than the fact that |
-- it cannot control its profile individually |
-- @param name The name of the new namespace |
-- @param defaults A table of values to use as defaults |
function DBObjectLib:RegisterNamespace(name, defaults) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - string expected.", 2) |
end |
if defaults and type(defaults) ~= "table" then |
error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'defaults' - table or nil expected.", 2) |
end |
if self.children and self.children[name] then |
error ("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - a namespace with that name already exists.", 2) |
end |
local sv = self.sv |
if not sv.namespaces then sv.namespaces = {} end |
if not sv.namespaces[name] then |
sv.namespaces[name] = {} |
end |
local newDB = initdb(sv.namespaces[name], defaults, self.keys.profile, nil, self) |
if not self.children then self.children = {} end |
self.children[name] = newDB |
return newDB |
end |
--- Returns an already existing namespace from the database object. |
-- @param name The name of the new namespace |
-- @param silent if true, the addon is optional, silently return nil if its not found |
-- @usage |
-- local namespace = self.db:GetNamespace('namespace') |
-- @return the namespace object if found |
function DBObjectLib:GetNamespace(name, silent) |
if type(name) ~= "string" then |
error("Usage: AceDBObject:GetNamespace(name): 'name' - string expected.", 2) |
end |
if not silent and not (self.children and self.children[name]) then |
error ("Usage: AceDBObject:GetNamespace(name): 'name' - namespace does not exist.", 2) |
end |
if not self.children then self.children = {} end |
return self.children[name] |
end |
--[[------------------------------------------------------------------------- |
AceDB Exposed Methods |
---------------------------------------------------------------------------]] |
--- Creates a new database object that can be used to handle database settings and profiles. |
-- By default, an empty DB is created, using a character specific profile. |
-- |
-- You can override the default profile used by passing any profile name as the third argument, |
-- or by passing //true// as the third argument to use a globally shared profile called "Default". |
-- |
-- Note that there is no token replacement in the default profile name, passing a defaultProfile as "char" |
-- will use a profile named "char", and not a character-specific profile. |
-- @param tbl The name of variable, or table to use for the database |
-- @param defaults A table of database defaults |
-- @param defaultProfile The name of the default profile. If not set, a character specific profile will be used as the default. |
-- You can also pass //true// to use a shared global profile called "Default". |
-- @usage |
-- -- Create an empty DB using a character-specific default profile. |
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB") |
-- @usage |
-- -- Create a DB using defaults and using a shared default profile |
-- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
function AceDB:New(tbl, defaults, defaultProfile) |
if type(tbl) == "string" then |
local name = tbl |
tbl = _G[name] |
if not tbl then |
tbl = {} |
_G[name] = tbl |
end |
end |
if type(tbl) ~= "table" then |
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'tbl' - table expected.", 2) |
end |
if defaults and type(defaults) ~= "table" then |
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaults' - table expected.", 2) |
end |
if defaultProfile and type(defaultProfile) ~= "string" and defaultProfile ~= true then |
error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaultProfile' - string or true expected.", 2) |
end |
return initdb(tbl, defaults, defaultProfile) |
end |
-- upgrade existing databases |
for db in pairs(AceDB.db_registry) do |
if not db.parent then |
for name,func in pairs(DBObjectLib) do |
db[name] = func |
end |
else |
db.RegisterDefaults = DBObjectLib.RegisterDefaults |
db.ResetProfile = DBObjectLib.ResetProfile |
end |
end |
-- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/wiki/LibStub for more info |
-- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke |
local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2 -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS! |
local LibStub = _G[LIBSTUB_MAJOR] |
if not LibStub or LibStub.minor < LIBSTUB_MINOR then |
LibStub = LibStub or {libs = {}, minors = {} } |
_G[LIBSTUB_MAJOR] = LibStub |
LibStub.minor = LIBSTUB_MINOR |
function LibStub:NewLibrary(major, minor) |
assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)") |
minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.") |
local oldminor = self.minors[major] |
if oldminor and oldminor >= minor then return nil end |
self.minors[major], self.libs[major] = minor, self.libs[major] or {} |
return self.libs[major], oldminor |
end |
function LibStub:GetLibrary(major, silent) |
if not self.libs[major] and not silent then |
error(("Cannot find a library instance of %q."):format(tostring(major)), 2) |
end |
return self.libs[major], self.minors[major] |
end |
function LibStub:IterateLibraries() return pairs(self.libs) end |
setmetatable(LibStub, { __call = LibStub.GetLibrary }) |
end |
<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="prototypes.lua" /> |
<Script file="FontWidget.lua" /> |
<Script file="SoundWidget.lua" /> |
<Script file="StatusbarWidget.lua" /> |
<Script file="BorderWidget.lua" /> |
<Script file="BackgroundWidget.lua" /> |
</Ui> |
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
-- Widget created by Yssaril |
local AceGUI = LibStub("AceGUI-3.0") |
local Media = LibStub("LibSharedMedia-3.0") |
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
do |
local widgetType = "LSM30_Background" |
local widgetVersion = 9 |
local contentFrameCache = {} |
local function ReturnSelf(self) |
self:ClearAllPoints() |
self:Hide() |
self.check:Hide() |
table.insert(contentFrameCache, self) |
end |
local function ContentOnClick(this, button) |
local self = this.obj |
self:Fire("OnValueChanged", this.text:GetText()) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function ContentOnEnter(this, button) |
local self = this.obj |
local text = this.text:GetText() |
local background = self.list[text] ~= text and self.list[text] or Media:Fetch('background',text) |
self.dropdown.bgTex:SetTexture(background) |
end |
local function GetContentLine() |
local frame |
if next(contentFrameCache) then |
frame = table.remove(contentFrameCache) |
else |
frame = CreateFrame("Button", nil, UIParent) |
--frame:SetWidth(200) |
frame:SetHeight(18) |
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
frame:SetScript("OnClick", ContentOnClick) |
frame:SetScript("OnEnter", ContentOnEnter) |
local check = frame:CreateTexture("OVERLAY") |
check:SetWidth(16) |
check:SetHeight(16) |
check:SetPoint("LEFT",frame,"LEFT",1,-1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:Hide() |
frame.check = check |
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
local font, size = text:GetFont() |
text:SetFont(font,size,"OUTLINE") |
text:SetPoint("LEFT", check, "RIGHT", 1, 0) |
text:SetPoint("RIGHT", frame, "RIGHT", -2, 0) |
text:SetJustifyH("LEFT") |
text:SetText("Test Test Test Test Test Test Test") |
frame.text = text |
frame.ReturnSelf = ReturnSelf |
end |
frame:Show() |
return frame |
end |
local function OnAcquire(self) |
self:SetHeight(44) |
self:SetWidth(200) |
end |
local function OnRelease(self) |
self:SetText("") |
self:SetLabel("") |
self:SetDisabled(false) |
self.value = nil |
self.list = nil |
self.open = nil |
self.hasClose = nil |
self.frame:ClearAllPoints() |
self.frame:Hide() |
end |
local function SetValue(self, value) -- Set the value to an item in the List. |
if self.list then |
self:SetText(value or "") |
end |
self.value = value |
end |
local function GetValue(self) |
return self.value |
end |
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
self.list = list or Media:HashTable("background") |
end |
local function SetText(self, text) -- Set the text displayed in the box. |
self.frame.text:SetText(text or "") |
local background = self.list[text] ~= text and self.list[text] or Media:Fetch('background',text) |
self.frame.displayButton:SetBackdrop({bgFile = background, |
edgeFile = "Interface/Tooltips/UI-Tooltip-Border", |
edgeSize = 16, |
insets = { left = 4, right = 4, top = 4, bottom = 4 }}) |
end |
local function SetLabel(self, text) -- Set the text for the label. |
self.frame.label:SetText(text or "") |
end |
local function AddItem(self, key, value) -- Add an item to the list. |
self.list = self.list or {} |
self.list[key] = value |
end |
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
local function SetDisabled(self, disabled) -- Disable the widget. |
self.disabled = disabled |
if disabled then |
self.frame:Disable() |
self.frame.displayButton:SetBackdropColor(.2,.2,.2,1) |
else |
self.frame:Enable() |
self.frame.displayButton:SetBackdropColor(1,1,1,1) |
end |
end |
local function textSort(a,b) |
return string.upper(a) < string.upper(b) |
end |
local sortedlist = {} |
local function ToggleDrop(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
AceGUI:ClearFocus() |
else |
AceGUI:SetFocus(self) |
self.dropdown = AGSMW:GetDropDownFrame() |
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
for k, v in pairs(self.list) do |
sortedlist[#sortedlist+1] = k |
end |
table.sort(sortedlist, textSort) |
for i, k in ipairs(sortedlist) do |
local f = GetContentLine() |
f.text:SetText(k) |
--print(k) |
if k == self.value then |
f.check:Show() |
end |
f.obj = self |
f.dropdown = self.dropdown |
self.dropdown:AddFrame(f) |
end |
wipe(sortedlist) |
end |
end |
local function ClearFocus(self) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function OnHide(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function Drop_OnEnter(this) |
this.obj:Fire("OnEnter") |
end |
local function Drop_OnLeave(this) |
this.obj:Fire("OnLeave") |
end |
local function Constructor() |
local frame = AGSMW:GetBaseFrameWithWindow() |
local self = {} |
self.type = widgetType |
self.frame = frame |
frame.obj = self |
frame.dropButton.obj = self |
frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
frame.dropButton:SetScript("OnClick",ToggleDrop) |
frame:SetScript("OnHide", OnHide) |
self.alignoffset = 31 |
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.ToggleDrop = ToggleDrop |
AceGUI:RegisterAsWidget(self) |
return self |
end |
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
end |
-- Widget created by Yssaril |
--[===[@debug@ |
local DataVersion = 9001 -- dev version always overwrites everything else :) |
--@end-debug@]===] |
--@non-debug@ |
local DataVersion = 37 |
--@end-non-debug@ |
local AGSMW = LibStub:NewLibrary("AceGUISharedMediaWidgets-1.0", DataVersion) |
if not AGSMW then |
return -- already loaded and no upgrade necessary |
end |
LoadAddOn("LibSharedMedia-3.0") |
local AceGUI = LibStub("AceGUI-3.0") |
local Media = LibStub("LibSharedMedia-3.0") |
AGSMW = AGSMW or {} |
AceGUIWidgetLSMlists = { |
['font'] = Media:HashTable("font"), |
['sound'] = Media:HashTable("sound"), |
['statusbar'] = Media:HashTable("statusbar"), |
['border'] = Media:HashTable("border"), |
['background'] = Media:HashTable("background"), |
} |
do |
local function disable(frame) |
frame.label:SetTextColor(.5,.5,.5) |
frame.text:SetTextColor(.5,.5,.5) |
frame.dropButton:Disable() |
if frame.displayButtonFont then |
frame.displayButtonFont:SetTextColor(.5,.5,.5) |
frame.displayButton:Disable() |
end |
end |
local function enable(frame) |
frame.label:SetTextColor(1,.82,0) |
frame.text:SetTextColor(1,1,1) |
frame.dropButton:Enable() |
if frame.displayButtonFont then |
frame.displayButtonFont:SetTextColor(1,1,1) |
frame.displayButton:Enable() |
end |
end |
local displayButtonBackdrop = { |
edgeFile = "Interface/Tooltips/UI-Tooltip-Border", |
tile = true, tileSize = 16, edgeSize = 16, |
insets = { left = 4, right = 4, top = 4, bottom = 4 }, |
} |
-- create or retrieve BaseFrame |
function AGSMW:GetBaseFrame() |
local frame = CreateFrame("Frame", nil, UIParent) |
frame:SetHeight(44) |
frame:SetWidth(200) |
frame:SetPoint("CENTER", UIParent, "CENTER") |
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:SetText("") |
frame.label = label |
local DLeft = frame:CreateTexture(nil, "ARTWORK") |
DLeft:SetWidth(25) |
DLeft:SetHeight(64) |
DLeft:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", -17, -21) |
DLeft:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]]) |
DLeft:SetTexCoord(0, 0.1953125, 0, 1) |
frame.DLeft = DLeft |
local DRight = frame:CreateTexture(nil, "ARTWORK") |
DRight:SetWidth(25) |
DRight:SetHeight(64) |
DRight:SetPoint("TOP", DLeft, "TOP") |
DRight:SetPoint("RIGHT", frame, "RIGHT", 17, 0) |
DRight:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]]) |
DRight:SetTexCoord(0.8046875, 1, 0, 1) |
frame.DRight = DRight |
local DMiddle = frame:CreateTexture(nil, "ARTWORK") |
DMiddle:SetHeight(64) |
DMiddle:SetPoint("TOP", DLeft, "TOP") |
DMiddle:SetPoint("LEFT", DLeft, "RIGHT") |
DMiddle:SetPoint("RIGHT", DRight, "LEFT") |
DMiddle:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]]) |
DMiddle:SetTexCoord(0.1953125, 0.8046875, 0, 1) |
frame.DMiddle = DMiddle |
local text = frame:CreateFontString(nil,"OVERLAY","GameFontHighlightSmall") |
text:SetPoint("RIGHT",DRight,"RIGHT",-43,1) |
text:SetPoint("LEFT",DLeft,"LEFT",26,1) |
text:SetJustifyH("RIGHT") |
text:SetHeight(18) |
text:SetText("") |
frame.text = text |
local dropButton = CreateFrame("Button", nil, frame) |
dropButton:SetWidth(24) |
dropButton:SetHeight(24) |
dropButton:SetPoint("TOPRIGHT", DRight, "TOPRIGHT", -16, -18) |
dropButton:SetNormalTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Up]]) |
dropButton:SetPushedTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Down]]) |
dropButton:SetDisabledTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Disabled]]) |
dropButton:SetHighlightTexture([[Interface\Buttons\UI-Common-MouseHilight]], "ADD") |
frame.dropButton = dropButton |
frame.Disable = disable |
frame.Enable = enable |
return frame |
end |
function AGSMW:GetBaseFrameWithWindow() |
local frame = self:GetBaseFrame() |
local displayButton = CreateFrame("Button", nil, frame) |
displayButton:SetHeight(42) |
displayButton:SetWidth(42) |
displayButton:SetPoint("TOPLEFT", frame, "TOPLEFT", 1, -2) |
displayButton:SetBackdrop(displayButtonBackdrop) |
displayButton:SetBackdropBorderColor(.5, .5, .5) |
frame.displayButton = displayButton |
frame.label:SetPoint("TOPLEFT",displayButton,"TOPRIGHT",1,2) |
frame.DLeft:SetPoint("BOTTOMLEFT", displayButton, "BOTTOMRIGHT", -17, -20) |
return frame |
end |
end |
do |
local sliderBackdrop = { |
["bgFile"] = [[Interface\Buttons\UI-SliderBar-Background]], |
["edgeFile"] = [[Interface\Buttons\UI-SliderBar-Border]], |
["tile"] = true, |
["edgeSize"] = 8, |
["tileSize"] = 8, |
["insets"] = { |
["left"] = 3, |
["right"] = 3, |
["top"] = 3, |
["bottom"] = 3, |
}, |
} |
local frameBackdrop = { |
bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]], |
edgeFile = [[Interface\DialogFrame\UI-DialogBox-Border]], |
tile = true, tileSize = 32, edgeSize = 32, |
insets = { left = 11, right = 12, top = 12, bottom = 9 }, |
} |
local function OnMouseWheel(self, dir) |
self.slider:SetValue(self.slider:GetValue()+(15*dir*-1)) |
end |
local function AddFrame(self, frame) |
frame:SetParent(self.contentframe) |
local strata = self:GetFrameStrata() |
frame:SetFrameStrata(strata) |
local level = self:GetFrameLevel() + 100 |
frame:SetFrameLevel(level) |
if next(self.contentRepo) then |
frame:SetPoint("TOPLEFT", self.contentRepo[#self.contentRepo], "BOTTOMLEFT", 0, 0) |
frame:SetPoint("RIGHT", self.contentframe, "RIGHT", 0, 0) |
self.contentframe:SetHeight(self.contentframe:GetHeight() + frame:GetHeight()) |
self.contentRepo[#self.contentRepo+1] = frame |
else |
self.contentframe:SetHeight(frame:GetHeight()) |
frame:SetPoint("TOPLEFT", self.contentframe, "TOPLEFT", 0, 0) |
frame:SetPoint("RIGHT", self.contentframe, "RIGHT", 0, 0) |
self.contentRepo[1] = frame |
end |
if self.contentframe:GetHeight() > UIParent:GetHeight()*2/5 - 20 then |
self.scrollframe:SetWidth(146) |
self:SetHeight(UIParent:GetHeight()*2/5) |
self.slider:Show() |
self:SetScript("OnMouseWheel", OnMouseWheel) |
self.scrollframe:UpdateScrollChildRect() |
self.slider:SetMinMaxValues(0, self.contentframe:GetHeight()-self.scrollframe:GetHeight()) |
else |
self.scrollframe:SetWidth(160) |
self:SetHeight(self.contentframe:GetHeight()+25) |
self.slider:Hide() |
self:SetScript("OnMouseWheel", nil) |
self.scrollframe:UpdateScrollChildRect() |
self.slider:SetMinMaxValues(0, 0) |
end |
self.contentframe:SetWidth(self.scrollframe:GetWidth()) |
end |
local function ClearFrames(self) |
for i, frame in ipairs(self.contentRepo) do |
frame:ReturnSelf() |
self.contentRepo[i] = nil |
end |
end |
local function slider_OnValueChanged(self, value) |
self.frame.scrollframe:SetVerticalScroll(value) |
end |
local DropDownCache = {} |
function AGSMW:GetDropDownFrame() |
local frame |
if next(DropDownCache) then |
frame = table.remove(DropDownCache) |
else |
frame = CreateFrame("Frame", nil, UIParent) |
frame:SetClampedToScreen(true) |
frame:SetWidth(188) |
frame:SetBackdrop(frameBackdrop) |
frame:SetFrameStrata("TOOLTIP") |
frame:EnableMouseWheel(true) |
local contentframe = CreateFrame("Frame", nil, frame) |
contentframe:SetWidth(160) |
contentframe:SetHeight(0) |
frame.contentframe = contentframe |
local scrollframe = CreateFrame("ScrollFrame", nil, frame) |
scrollframe:SetPoint("TOPLEFT", frame, "TOPLEFT", 14, -13) |
scrollframe:SetPoint("BOTTOM", frame, "BOTTOM", 0, 12) |
scrollframe:SetWidth(160) |
scrollframe:SetScrollChild(contentframe) |
frame.scrollframe = scrollframe |
local bgTex = frame:CreateTexture(nil, "ARTWORK") |
bgTex:SetAllPoints(scrollframe) |
frame.bgTex = bgTex |
frame.AddFrame = AddFrame |
frame.ClearFrames = ClearFrames |
frame.contentRepo = {} -- store all our frames in here so we can get rid of them later |
local slider = CreateFrame("Slider", nil, scrollframe) |
slider:SetOrientation("VERTICAL") |
slider:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -14, -10) |
slider:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -14, 10) |
slider:SetBackdrop(sliderBackdrop) |
slider:SetThumbTexture([[Interface\Buttons\UI-SliderBar-Button-Vertical]]) |
slider:SetMinMaxValues(0, 1) |
--slider:SetValueStep(1) |
slider:SetWidth(12) |
slider.frame = frame |
slider:SetScript("OnValueChanged", slider_OnValueChanged) |
frame.slider = slider |
end |
frame:SetHeight(UIParent:GetHeight()*2/5) |
frame.slider:SetValue(0) |
frame:Show() |
return frame |
end |
function AGSMW:ReturnDropDownFrame(frame) |
ClearFrames(frame) |
frame:ClearAllPoints() |
frame:Hide() |
frame:SetBackdrop(frameBackdrop) |
frame.bgTex:SetTexture(nil) |
table.insert(DropDownCache, frame) |
return nil |
end |
end |
local Type, Version = "MultiLineEditBox", 25 |
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, GetSpellInfo, ClearCursor = GetCursorInfo, GetSpellInfo, ClearCursor |
local CreateFrame, UIParent = CreateFrame, UIParent |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: ACCEPT, ChatFontNormal |
--[[----------------------------------------------------------------------------- |
Support functions |
-------------------------------------------------------------------------------]] |
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) |
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 = GetCursorInfo() |
if type == "spell" then |
info = GetSpellInfo(id, info) |
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 OnShowFocus(frame) |
frame.obj.editBox:SetFocus() |
frame:SetScript("OnShow", nil) |
end |
local function OnFocusGained(frame) |
AceGUI:SetFocus(frame.obj) |
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 |
} |
--[[----------------------------------------------------------------------------- |
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, "UIPanelButtonTemplate2") |
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) |
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) |
local editBox = CreateFrame("EditBox", nil, 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", OnFocusGained) |
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) |
--[[----------------------------------------------------------------------------- |
Slider Widget |
Graphical Slider, like, for Range values. |
-------------------------------------------------------------------------------]] |
local Type, Version = "Slider", 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 min, max, floor = math.min, math.max, math.floor |
local tonumber, pairs = tonumber, pairs |
-- WoW APIs |
local PlaySound = PlaySound |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameFontHighlightSmall |
--[[----------------------------------------------------------------------------- |
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, max = (self.min or 0), (self.max or 100) |
if self.ispercent then |
self.lowtext:SetFormattedText("%s%%", (min * 100)) |
self.hightext:SetFormattedText("%s%%", (max * 100)) |
else |
self.lowtext:SetText(min) |
self.hightext:SetText(max) |
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) |
local self = frame.obj |
if not frame.setup then |
local newvalue = frame:GetValue() |
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("igMainMenuOptionCheckBoxOn") |
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, max, step) |
local frame = self.slider |
frame.setup = true |
self.min = min |
self.max = max |
self.step = step |
frame:SetMinMaxValues(min or 0,max 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) |
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) |
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) |
--[[----------------------------------------------------------------------------- |
TabGroup Container |
Container that uses tabs on top to switch between groups. |
-------------------------------------------------------------------------------]] |
local Type, Version = "TabGroup", 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, ipairs, assert, type, wipe = pairs, ipairs, assert, type, wipe |
-- WoW APIs |
local PlaySound = PlaySound |
local CreateFrame, UIParent = CreateFrame, UIParent |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: PanelTemplates_TabResize, PanelTemplates_SetDisabledTabState, PanelTemplates_SelectTab, PanelTemplates_DeselectTab |
-- local upvalue storage used by BuildTabs |
local widths = {} |
local rowwidths = {} |
local rowends = {} |
--[[----------------------------------------------------------------------------- |
Support functions |
-------------------------------------------------------------------------------]] |
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, width) |
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("igCharacterInfoTab") |
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, "OptionsFrameTabButtonTemplate") |
tab.obj = self |
tab.id = id |
tab.text = _G[tabname .. "Text"] |
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 status = self.status or self.localstatus |
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 |
local padding = 0 |
if not (numrows == 1 and rowwidths[1] < width*0.75) then |
padding = (width - rowwidths[row]) / (endtab - starttab+1) |
end |
for i = starttab, endtab do |
PanelTemplates_TabResize(tabs[i], padding + 4, nil, width) |
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) |
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) |
--[[----------------------------------------------------------------------------- |
Keybinding Widget |
Set Keybindings in the Config UI. |
-------------------------------------------------------------------------------]] |
local Type, Version = "Keybinding", 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 IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown = IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: NOT_BOUND |
--[[----------------------------------------------------------------------------- |
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) |
self.msgframe:Hide() |
frame:UnlockHighlight() |
self.waitingForKey = nil |
else |
frame:EnableKeyboard(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) |
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 |
--[[----------------------------------------------------------------------------- |
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) |
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, "UIPanelButtonTemplate2") |
button:EnableMouse(true) |
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:SetPoint("BOTTOMLEFT") |
button:SetPoint("BOTTOMRIGHT") |
button:SetHeight(24) |
button:EnableKeyboard(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) |
msgframe:SetHeight(30) |
msgframe:SetBackdrop(ControlBackdrop) |
msgframe:SetBackdropColor(0,0,0) |
msgframe:SetFrameStrata("FULLSCREEN_DIALOG") |
msgframe:SetFrameLevel(1000) |
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) |
--[[----------------------------------------------------------------------------- |
Checkbox Widget |
-------------------------------------------------------------------------------]] |
local Type, Version = "CheckBox", 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 |
-- WoW APIs |
local PlaySound = PlaySound |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: SetDesaturation, GameFontHighlight |
--[[----------------------------------------------------------------------------- |
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("igMainMenuOptionCheckBoxOn") |
else -- for both nil and false (tristate) |
PlaySound("igMainMenuOptionCheckBoxOff") |
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:GetHeight()) |
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) |
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 |
end |
end, |
["SetValue"] = function(self,value) |
local check = self.check |
self.checked = value |
if value then |
SetDesaturation(self.check, false) |
self.check:Show() |
else |
--Nil is the unknown tristate value |
if self.tristate and value == nil then |
SetDesaturation(self.check, true) |
self.check:Show() |
else |
SetDesaturation(self.check, false) |
self.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("Interface\\Buttons\\UI-RadioButton") |
checkbg:SetTexCoord(0, 0.25, 0, 1) |
check:SetTexture("Interface\\Buttons\\UI-RadioButton") |
check:SetTexCoord(0.25, 0.5, 0, 1) |
check:SetBlendMode("ADD") |
highlight:SetTexture("Interface\\Buttons\\UI-RadioButton") |
highlight:SetTexCoord(0.5, 0.75, 0, 1) |
else |
size = 24 |
checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up") |
checkbg:SetTexCoord(0, 1, 0, 1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:SetTexCoord(0, 1, 0, 1) |
check:SetBlendMode("BLEND") |
highlight:SetTexture("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 desc = self.frame:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall") |
desc:ClearAllPoints() |
desc:SetPoint("TOPLEFT", self.checkbg, "TOPRIGHT", 5, -21) |
desc:SetWidth(self.frame.width - 30) |
desc:SetJustifyH("LEFT") |
desc:SetJustifyV("TOP") |
self.desc = desc |
end |
self.desc:Show() |
--self.text:SetFontObject(GameFontNormal) |
self.desc:SetText(desc) |
self:SetHeight(28 + self.desc:GetHeight()) |
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("Interface\\Buttons\\UI-CheckBox-Up") |
local check = frame:CreateTexture(nil, "OVERLAY") |
check:SetAllPoints(checkbg) |
check:SetTexture("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("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) |
--[[----------------------------------------------------------------------------- |
BlizOptionsGroup Container |
Simple container widget for the integration of AceGUI into the Blizzard Interface Options |
-------------------------------------------------------------------------------]] |
local Type, Version = "BlizOptionsGroup", 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 = 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 defaults(frame) |
frame.obj:Fire("defaults") |
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") |
frame:Hide() |
-- support functions for the Blizzard Interface Options |
frame.okay = okay |
frame.cancel = cancel |
frame.defaults = defaults |
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) |
--[[----------------------------------------------------------------------------- |
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, GetBuildInfo = CreateFrame, UIParent, GetBuildInfo |
--[[----------------------------------------------------------------------------- |
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("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 |
-- SetText is deprecated, but keep it around for a while. (say, to WoW 4.0) |
if (select(4, GetBuildInfo()) < 40000) then |
widget.SetText = widget.SetLabel |
else |
widget.SetText = function(self, ...) print("AceGUI-3.0-Icon: SetText is deprecated! Use SetLabel instead!"); self:SetLabel(...) end |
end |
return AceGUI:RegisterAsWidget(widget) |
end |
AceGUI:RegisterWidgetType(Type, Constructor, Version) |
--[[----------------------------------------------------------------------------- |
Frame Container |
-------------------------------------------------------------------------------]] |
local Type, Version = "Frame", 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, assert, type = pairs, assert, type |
local wipe = table.wipe |
-- WoW APIs |
local PlaySound = PlaySound |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: CLOSE |
--[[----------------------------------------------------------------------------- |
Scripts |
-------------------------------------------------------------------------------]] |
local function Button_OnClick(frame) |
PlaySound("gsTitleOptionExit") |
frame.obj:Hide() |
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:SetTitle() |
self:SetStatusText() |
self:ApplyStatus() |
self:Show() |
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, |
-- 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) |
frame:Hide() |
frame:EnableMouse(true) |
frame:SetMovable(true) |
frame:SetResizable(true) |
frame:SetFrameStrata("FULLSCREEN_DIALOG") |
frame:SetBackdrop(FrameBackdrop) |
frame:SetBackdropColor(0, 0, 0, 1) |
frame:SetMinResize(400, 200) |
frame:SetToplevel(true) |
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) |
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("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("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("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("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("Interface\\Tooltips\\UI-Tooltip-Border") |
local 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, |
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) |
--[[----------------------------------------------------------------------------- |
InlineGroup Container |
Simple container widget that creates a visible "box" with an optional title. |
-------------------------------------------------------------------------------]] |
local Type, Version = "InlineGroup", 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, |
["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) |
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) |
--[[ $Id: AceGUIWidget-DropDown.lua 991 2010-11-12 16:51:38Z nevcairiel $ ]]-- |
local AceGUI = LibStub("AceGUI-3.0") |
-- Lua APIs |
local min, max, floor = math.min, math.max, math.floor |
local select, pairs, ipairs, type = select, pairs, ipairs, type |
local tsort = table.sort |
-- WoW APIs |
local PlaySound = PlaySound |
local UIParent, CreateFrame = UIParent, CreateFrame |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: CLOSE |
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 = 3 |
--[[ 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 |
if i == 1 then |
item:SetPoint("TOP", itemFrame, "TOP", 0, -2) |
else |
item:SetPoint("TOP", items[i-1].frame, "BOTTOM", 0, 1) |
end |
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) |
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) |
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 = 23 |
--[[ Static data ]]-- |
--[[ UI event handler ]]-- |
local function Control_OnEnter(this) |
this.obj:Fire("OnEnter") |
end |
local function Control_OnLeave(this) |
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 |
PlaySound("igMainMenuOptionCheckBoxOn") -- missleading name, but the Blizzard code uses this sound |
if self.open then |
self.open = nil |
self.pullout:Close() |
AceGUI:ClearFocus() |
else |
self.open = true |
self.pullout:SetWidth(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 |
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) |
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:SetLabel("") |
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.label:SetTextColor(0.5,0.5,0.5) |
else |
self.button: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,-18) |
self.frame:SetHeight(44) |
else |
self.label:SetText("") |
self.label:Hide() |
self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,0) |
self.frame:SetHeight(26) |
end |
end |
-- exported |
local function SetValue(self, value) |
if self.list then |
self:SetText(self.list[value] or "") |
end |
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) |
local item = AceGUI:Create("Dropdown-Item-Toggle") |
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 SetList(self, list,order) |
self.list = list |
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) |
for i, key in ipairs(sortlist) do |
AddListItem(self, key, list[key]) |
sortlist[i] = nil |
end |
else |
for i, key in ipairs(order) do |
AddListItem(self, key, list[key]) |
end |
end |
if self.multiselect then |
ShowMultiText(self) |
AddCloseButton(self) |
end |
end |
-- exported |
local function AddItem(self, value, text) |
if self.list then |
self.list[value] = text |
AddListItem(self, value, text) |
end |
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 |
--[[ 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.alignoffset = 31 |
frame:SetHeight(44) |
frame:SetWidth(200) |
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 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 |
--[[----------------------------------------------------------------------------- |
EditBox Widget |
-------------------------------------------------------------------------------]] |
local Type, Version = "EditBox", 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 tostring, pairs = tostring, pairs |
-- WoW APIs |
local PlaySound = PlaySound |
local GetCursorInfo, ClearCursor, GetSpellInfo = GetCursorInfo, ClearCursor, GetSpellInfo |
local CreateFrame, UIParent = CreateFrame, UIParent |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: AceGUIEditBoxInsertLink, ChatFontNormal, OKAY |
--[[----------------------------------------------------------------------------- |
Support functions |
-------------------------------------------------------------------------------]] |
if not AceGUIEditBoxInsertLink then |
-- upgradeable hook |
hooksecurefunc("ChatEdit_InsertLink", function(...) return _G.AceGUIEditBoxInsertLink(...) 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("igMainMenuOptionCheckBoxOn") |
HideButton(self) |
end |
end |
local function EditBox_OnReceiveDrag(frame) |
local self = frame.obj |
local type, id, info = GetCursorInfo() |
if type == "item" then |
self:SetText(info) |
self:Fire("OnEnterPressed", info) |
ClearCursor() |
elseif type == "spell" then |
local name = GetSpellInfo(id, info) |
self:SetText(name) |
self:Fire("OnEnterPressed", name) |
ClearCursor() |
end |
HideButton(self) |
AceGUI:ClearFocus() |
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 |
} |
--[[----------------------------------------------------------------------------- |
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) |
--[[----------------------------------------------------------------------------- |
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("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("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) |
--[[----------------------------------------------------------------------------- |
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) |
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 |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameFontNormal |
---------------- |
-- Main Frame -- |
---------------- |
--[[ |
Events : |
OnClose |
]] |
do |
local Type = "Window" |
local Version = 4 |
local function frameOnClose(this) |
this.obj:Fire("OnClose") |
end |
local function closeOnClick(this) |
PlaySound("gsTitleOptionExit") |
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("OnHide",frameOnClose) |
frame:SetMinResize(240,240) |
frame:SetToplevel(true) |
local titlebg = frame:CreateTexture(nil, "BACKGROUND") |
titlebg:SetTexture([[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([[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([[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([[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([[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([[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([[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([[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([[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([[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("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("Interface\\Tooltips\\UI-Tooltip-Border") |
local 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 |
--[[----------------------------------------------------------------------------- |
DropdownGroup Container |
Container controlled by a dropdown on the top. |
-------------------------------------------------------------------------------]] |
local Type, Version = "DropdownGroup", 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 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) |
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) |
--[[----------------------------------------------------------------------------- |
ScrollFrame Container |
Plain container that scrolls its content and doesn't grow in height. |
-------------------------------------------------------------------------------]] |
local Type, Version = "ScrollFrame", 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 pairs, assert, type = pairs, assert, type |
local min, max, floor, abs = math.min, math.max, math.floor, math.abs |
-- 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) |
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 = 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 |
local curvalue = self.scrollbar:GetValue() |
-- 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") |
self:DoLayout() |
end |
else |
if not self.scrollBarShown then |
self.scrollBarShown = true |
self.scrollbar:Show() |
self.scrollframe:SetPoint("BOTTOMRIGHT", -20, 0) |
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) |
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 |
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:SetTexture(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) |
--[[----------------------------------------------------------------------------- |
TreeGroup Container |
Container that uses a tree control to switch between groups. |
-------------------------------------------------------------------------------]] |
local Type, Version = "TreeGroup", 32 |
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, floor |
local select, tremove, unpack = select, table.remove, unpack |
-- WoW APIs |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameTooltip, FONT_COLOR_CODE_CLOSE |
-- 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 frame = self.frame |
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 |
local normalTexture = button:GetNormalTexture() |
local line = button.line |
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("Interface\\Buttons\\UI-PlusButton-UP") |
toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN") |
else |
toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP") |
toggle:SetPushedTexture("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() |
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 |
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 |
GameTooltip:SetOwner(frame, "ANCHOR_NONE") |
GameTooltip:SetPoint("LEFT",frame,"RIGHT") |
GameTooltip:SetText(frame.text:GetText() or "", 1, .82, 0, 1) |
GameTooltip:Show() |
end |
end |
local function Button_OnLeave(frame) |
local self = frame.obj |
self:Fire("OnButtonLeave", frame.uniquevalue, frame) |
if self.enabletooltips then |
GameTooltip: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 = value |
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 frame = 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:SetPoint("TOPLEFT", frame, "TOPLEFT",0,0) |
treeframe:SetPoint("BOTTOMLEFT", frame, "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) |
end, |
["OnRelease"] = function(self) |
self.status = 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) |
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 |
local hasChildren = self.hasChildren |
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) |
local buttons = self.buttons |
local lines = self.lines |
for i, v in ipairs(buttons) do |
v:Hide() |
end |
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 |
self:BuildLevel(tree, 1) |
local numlines = #lines |
local maxlines = (floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18)) |
if maxlines <= 0 then return end |
local first, last |
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 |
if self.scrollbar:GetValue() ~= status.scrollvalue then |
self.scrollbar:SetValue(status.scrollvalue) |
end |
self.noupdate = nil |
first, last = status.scrollvalue+1, status.scrollvalue + maxlines |
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 |
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 |
for i = 1, select('#', ...) do |
groups[BuildUniqueValue(select(i, ...))] = true |
end |
status.selected = uniquevalue |
self:RefreshTree() |
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 |
treeframe:SetMaxResize(maxtreewidth, 1600) |
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, |
["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 = 0, |
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) |
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) |
treeframe:SetMinResize(100, 1) |
treeframe:SetMaxResize(400, 1600) |
treeframe:SetScript("OnUpdate", FirstFrameUpdate) |
treeframe:SetScript("OnSizeChanged", Tree_OnSizeChanged) |
treeframe:SetScript("OnMouseWheel", Tree_OnMouseWheel) |
local dragger = CreateFrame("Frame", nil, treeframe) |
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:SetTexture(0,0,0,0.4) |
local border = CreateFrame("Frame",nil,frame) |
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) |
--[[----------------------------------------------------------------------------- |
Button Widget |
Graphical Button. |
-------------------------------------------------------------------------------]] |
local Type, Version = "Button", 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 pairs = pairs |
-- WoW APIs |
local _G = _G |
local PlaySound, CreateFrame, UIParent = PlaySound, CreateFrame, UIParent |
--[[----------------------------------------------------------------------------- |
Scripts |
-------------------------------------------------------------------------------]] |
local function Button_OnClick(frame, ...) |
AceGUI:ClearFocus() |
PlaySound("igMainMenuOption") |
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:SetText() |
end, |
-- ["OnRelease"] = nil, |
["SetText"] = function(self, text) |
self.text:SetText(text) |
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, "UIPanelButtonTemplate2") |
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) |
--[[ $Id: AceGUIWidget-DropDown-Items.lua 916 2010-03-15 12:24:36Z 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 = 1000, |
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("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("OVERLAY") |
check:SetWidth(16) |
check:SetHeight(16) |
check:SetPoint("LEFT",frame,"LEFT",3,-1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:Hide() |
self.check = check |
local sub = frame:CreateTexture("OVERLAY") |
sub:SetWidth(16) |
sub:SetHeight(16) |
sub:SetPoint("RIGHT",frame,"RIGHT",-3,-1) |
sub:SetTexture("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 |
--[[ |
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 = 3 |
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("igMainMenuOptionCheckBoxOn") |
else |
PlaySound("igMainMenuOptionCheckBoxOff") |
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 = 1 |
-- 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:SetTexture(.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 |
--[[----------------------------------------------------------------------------- |
ColorPicker Widget |
-------------------------------------------------------------------------------]] |
local Type, Version = "ColorPicker", 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 |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: ShowUIPanel, HideUIPanel, ColorPickerFrame, OpacitySliderFrame |
--[[----------------------------------------------------------------------------- |
Support functions |
-------------------------------------------------------------------------------]] |
local function ColorCallback(self, r, g, b, a, isAlpha) |
if not self.HasAlpha then |
a = 1 |
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) |
HideUIPanel(ColorPickerFrame) |
local self = frame.obj |
if not self.disabled then |
ColorPickerFrame:SetFrameStrata("FULLSCREEN_DIALOG") |
ColorPickerFrame.func = function() |
local r, g, b = ColorPickerFrame:GetColorRGB() |
local a = 1 - OpacitySliderFrame:GetValue() |
ColorCallback(self, r, g, b, a) |
end |
ColorPickerFrame.hasOpacity = self.HasAlpha |
ColorPickerFrame.opacityFunc = function() |
local r, g, b = ColorPickerFrame:GetColorRGB() |
local a = 1 - OpacitySliderFrame:GetValue() |
ColorCallback(self, r, g, b, a, true) |
end |
local r, g, b, a = self.r, self.g, self.b, self.a |
if self.HasAlpha then |
ColorPickerFrame.opacity = 1 - (a or 0) |
end |
ColorPickerFrame:SetColorRGB(r, g, b) |
ColorPickerFrame.cancelFunc = function() |
ColorCallback(self, r, g, b, a, true) |
end |
ShowUIPanel(ColorPickerFrame) |
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("Interface\\ChatFrame\\ChatFrameColorSwatch") |
colorSwatch:SetPoint("LEFT") |
local texture = frame:CreateTexture(nil, "BACKGROUND") |
texture:SetWidth(16) |
texture:SetHeight(16) |
texture:SetTexture(1, 1, 1) |
texture:SetPoint("CENTER", colorSwatch) |
texture:Show() |
local checkers = frame:CreateTexture(nil, "BACKGROUND") |
checkers:SetWidth(14) |
checkers:SetHeight(14) |
checkers:SetTexture("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("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) |
--[[----------------------------------------------------------------------------- |
InteractiveLabel Widget |
-------------------------------------------------------------------------------]] |
local Type, Version = "InteractiveLabel", 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 select, pairs = select, pairs |
-- WoW APIs |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameFontHighlightSmall |
--[[----------------------------------------------------------------------------- |
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) |
--[[----------------------------------------------------------------------------- |
Label Widget |
Displays text and optionally an icon. |
-------------------------------------------------------------------------------]] |
local Type, Version = "Label", 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 max, select, pairs = math.max, select, pairs |
-- WoW APIs |
local CreateFrame, UIParent = CreateFrame, UIParent |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: GameFontHighlightSmall |
--[[----------------------------------------------------------------------------- |
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:GetHeight() |
else |
-- image on the left |
image:SetPoint("TOPLEFT") |
label:SetPoint("TOPLEFT", image, "TOPRIGHT", 4, 0) |
label:SetWidth(width - imagewidth - 4) |
height = max(image:GetHeight(), label:GetHeight()) |
end |
else |
-- no image shown |
label:SetPoint("TOPLEFT") |
label:SetWidth(width) |
height = label:GetHeight() |
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() |
-- 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) |
self.label:SetFont(font, height, flags) |
end, |
["SetFontObject"] = function(self, font) |
self:SetFont((font or GameFontHighlightSmall):GetFont()) |
end, |
["SetImageSize"] = function(self, width, height) |
self.image:SetWidth(width) |
self.image:SetHeight(height) |
UpdateImageAnchor(self) |
end, |
} |
--[[----------------------------------------------------------------------------- |
Constructor |
-------------------------------------------------------------------------------]] |
local function Constructor() |
local frame = CreateFrame("Frame", nil, UIParent) |
frame:Hide() |
local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlightSmall") |
label:SetJustifyH("LEFT") |
label:SetJustifyV("TOP") |
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) |
<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> |
--- **AceGUI-3.0** provides access to numerous widgets which can be used to create GUIs. |
-- AceGUI is used by AceConfigDialog to create the option GUIs, but you can use it by itself |
-- to create any custom GUI. There are more extensive examples in the test suite in the Ace3 |
-- stand-alone distribution. |
-- |
-- **Note**: When using AceGUI-3.0 directly, please do not modify the frames of the widgets directly, |
-- as any "unknown" change to the widgets will cause addons that get your widget out of the widget pool |
-- to misbehave. If you think some part of a widget should be modifiable, please open a ticket, and we"ll |
-- implement a proper API to modify it. |
-- @usage |
-- local AceGUI = LibStub("AceGUI-3.0") |
-- -- Create a container frame |
-- local f = AceGUI:Create("Frame") |
-- f:SetCallback("OnClose",function(widget) AceGUI:Release(widget) end) |
-- f:SetTitle("AceGUI-3.0 Example") |
-- f:SetStatusText("Status Bar") |
-- f:SetLayout("Flow") |
-- -- Create a button |
-- local btn = AceGUI:Create("Button") |
-- btn:SetWidth(170) |
-- btn:SetText("Button !") |
-- btn:SetCallback("OnClick", function() print("Click!") end) |
-- -- Add the button to the container |
-- f:AddChild(btn) |
-- @class file |
-- @name AceGUI-3.0 |
-- @release $Id: AceGUI-3.0.lua 924 2010-05-13 15:12:20Z nevcairiel $ |
local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 33 |
local AceGUI, oldminor = LibStub:NewLibrary(ACEGUI_MAJOR, ACEGUI_MINOR) |
if not AceGUI then return end -- No upgrade needed |
-- Lua APIs |
local tconcat, tremove, tinsert = table.concat, table.remove, table.insert |
local select, pairs, next, type = select, pairs, next, type |
local error, assert, loadstring = error, assert, loadstring |
local setmetatable, rawget, rawset = setmetatable, rawget, rawset |
local math_max = math.max |
-- WoW APIs |
local UIParent = UIParent |
-- 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, LibStub |
--local con = LibStub("AceConsole-3.0",true) |
AceGUI.WidgetRegistry = AceGUI.WidgetRegistry or {} |
AceGUI.LayoutRegistry = AceGUI.LayoutRegistry or {} |
AceGUI.WidgetBase = AceGUI.WidgetBase or {} |
AceGUI.WidgetContainerBase = AceGUI.WidgetContainerBase or {} |
AceGUI.WidgetVersions = AceGUI.WidgetVersions or {} |
-- local upvalues |
local WidgetRegistry = AceGUI.WidgetRegistry |
local LayoutRegistry = AceGUI.LayoutRegistry |
local WidgetVersions = AceGUI.WidgetVersions |
--[[ |
xpcall safecall implementation |
]] |
local xpcall = xpcall |
local function errorhandler(err) |
return geterrorhandler()(err) |
end |
local function CreateDispatcher(argCount) |
local code = [[ |
local xpcall, eh = ... |
local method, ARGS |
local function call() return method(ARGS) end |
local function dispatch(func, ...) |
method = func |
if not method then return end |
ARGS = ... |
return xpcall(call, eh) |
end |
return dispatch |
]] |
local ARGS = {} |
for i = 1, argCount do ARGS[i] = "arg"..i end |
code = code:gsub("ARGS", tconcat(ARGS, ", ")) |
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler) |
end |
local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
local dispatcher = CreateDispatcher(argCount) |
rawset(self, argCount, dispatcher) |
return dispatcher |
end}) |
Dispatchers[0] = function(func) |
return xpcall(func, errorhandler) |
end |
local function safecall(func, ...) |
return Dispatchers[select("#", ...)](func, ...) |
end |
-- Recycling functions |
local newWidget, delWidget |
do |
-- Version Upgrade in Minor 29 |
-- Internal Storage of the objects changed, from an array table |
-- to a hash table, and additionally we introduced versioning on |
-- the widgets which would discard all widgets from a pre-29 version |
-- anyway, so we just clear the storage now, and don't try to |
-- convert the storage tables to the new format. |
-- This should generally not cause *many* widgets to end up in trash, |
-- since once dialogs are opened, all addons should be loaded already |
-- and AceGUI should be on the latest version available on the users |
-- setup. |
-- -- nevcairiel - Nov 2nd, 2009 |
if oldminor and oldminor < 29 and AceGUI.objPools then |
AceGUI.objPools = nil |
end |
AceGUI.objPools = AceGUI.objPools or {} |
local objPools = AceGUI.objPools |
--Returns a new instance, if none are available either returns a new table or calls the given contructor |
function newWidget(type) |
if not WidgetRegistry[type] then |
error("Attempt to instantiate unknown widget type", 2) |
end |
if not objPools[type] then |
objPools[type] = {} |
end |
local newObj = next(objPools[type]) |
if not newObj then |
newObj = WidgetRegistry[type]() |
newObj.AceGUIWidgetVersion = WidgetVersions[type] |
else |
objPools[type][newObj] = nil |
-- if the widget is older then the latest, don't even try to reuse it |
-- just forget about it, and grab a new one. |
if not newObj.AceGUIWidgetVersion or newObj.AceGUIWidgetVersion < WidgetVersions[type] then |
return newWidget(type) |
end |
end |
return newObj |
end |
-- Releases an instance to the Pool |
function delWidget(obj,type) |
if not objPools[type] then |
objPools[type] = {} |
end |
if objPools[type][obj] then |
error("Attempt to Release Widget that is already released", 2) |
end |
objPools[type][obj] = true |
end |
end |
------------------- |
-- API Functions -- |
------------------- |
-- Gets a widget Object |
--- Create a new Widget of the given type. |
-- This function will instantiate a new widget (or use one from the widget pool), and call the |
-- OnAcquire function on it, before returning. |
-- @param type The type of the widget. |
-- @return The newly created widget. |
function AceGUI:Create(type) |
if WidgetRegistry[type] then |
local widget = newWidget(type) |
if rawget(widget, "Acquire") then |
widget.OnAcquire = widget.Acquire |
widget.Acquire = nil |
elseif rawget(widget, "Aquire") then |
widget.OnAcquire = widget.Aquire |
widget.Aquire = nil |
end |
if rawget(widget, "Release") then |
widget.OnRelease = rawget(widget, "Release") |
widget.Release = nil |
end |
if widget.OnAcquire then |
widget:OnAcquire() |
else |
error(("Widget type %s doesn't supply an OnAcquire Function"):format(type)) |
end |
-- Set the default Layout ("List") |
safecall(widget.SetLayout, widget, "List") |
safecall(widget.ResumeLayout, widget) |
return widget |
end |
end |
--- Releases a widget Object. |
-- This function calls OnRelease on the widget and places it back in the widget pool. |
-- Any data on the widget is being erased, and the widget will be hidden.\\ |
-- If this widget is a Container-Widget, all of its Child-Widgets will be releases as well. |
-- @param widget The widget to release |
function AceGUI:Release(widget) |
safecall(widget.PauseLayout, widget) |
widget:Fire("OnRelease") |
safecall(widget.ReleaseChildren, widget) |
if widget.OnRelease then |
widget:OnRelease() |
-- else |
-- error(("Widget type %s doesn't supply an OnRelease Function"):format(widget.type)) |
end |
for k in pairs(widget.userdata) do |
widget.userdata[k] = nil |
end |
for k in pairs(widget.events) do |
widget.events[k] = nil |
end |
widget.width = nil |
widget.relWidth = nil |
widget.height = nil |
widget.relHeight = nil |
widget.noAutoHeight = nil |
widget.frame:ClearAllPoints() |
widget.frame:Hide() |
widget.frame:SetParent(UIParent) |
widget.frame.width = nil |
widget.frame.height = nil |
if widget.content then |
widget.content.width = nil |
widget.content.height = nil |
end |
delWidget(widget, widget.type) |
end |
----------- |
-- Focus -- |
----------- |
--- Called when a widget has taken focus. |
-- e.g. Dropdowns opening, Editboxes gaining kb focus |
-- @param widget The widget that should be focused |
function AceGUI:SetFocus(widget) |
if self.FocusedWidget and self.FocusedWidget ~= widget then |
safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget) |
end |
self.FocusedWidget = widget |
end |
--- Called when something has happened that could cause widgets with focus to drop it |
-- e.g. titlebar of a frame being clicked |
function AceGUI:ClearFocus() |
if self.FocusedWidget then |
safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget) |
self.FocusedWidget = nil |
end |
end |
------------- |
-- Widgets -- |
------------- |
--[[ |
Widgets must provide the following functions |
OnAcquire() - Called when the object is acquired, should set everything to a default hidden state |
And the following members |
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes |
type - the type of the object, same as the name given to :RegisterWidget() |
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet |
It will be cleared automatically when a widget is released |
Placing values directly into a widget object should be avoided |
If the Widget can act as a container for other Widgets the following |
content - frame or derivitive that children will be anchored to |
The Widget can supply the following Optional Members |
:OnRelease() - Called when the object is Released, should remove any additional anchors and clear any data |
:OnWidthSet(width) - Called when the width of the widget is changed |
:OnHeightSet(height) - Called when the height of the widget is changed |
Widgets should not use the OnSizeChanged events of thier frame or content members, use these methods instead |
AceGUI already sets a handler to the event |
:LayoutFinished(width, height) - called after a layout has finished, the width and height will be the width and height of the |
area used for controls. These can be nil if the layout used the existing size to layout the controls. |
]] |
-------------------------- |
-- Widget Base Template -- |
-------------------------- |
do |
local WidgetBase = AceGUI.WidgetBase |
WidgetBase.SetParent = function(self, parent) |
local frame = self.frame |
frame:SetParent(nil) |
frame:SetParent(parent.content) |
self.parent = parent |
end |
WidgetBase.SetCallback = function(self, name, func) |
if type(func) == "function" then |
self.events[name] = func |
end |
end |
WidgetBase.Fire = function(self, name, ...) |
if self.events[name] then |
local success, ret = safecall(self.events[name], self, name, ...) |
if success then |
return ret |
end |
end |
end |
WidgetBase.SetWidth = function(self, width) |
self.frame:SetWidth(width) |
self.frame.width = width |
if self.OnWidthSet then |
self:OnWidthSet(width) |
end |
end |
WidgetBase.SetRelativeWidth = function(self, width) |
if width <= 0 or width > 1 then |
error(":SetRelativeWidth(width): Invalid relative width.", 2) |
end |
self.relWidth = width |
self.width = "relative" |
end |
WidgetBase.SetHeight = function(self, height) |
self.frame:SetHeight(height) |
self.frame.height = height |
if self.OnHeightSet then |
self:OnHeightSet(height) |
end |
end |
--[[ WidgetBase.SetRelativeHeight = function(self, height) |
if height <= 0 or height > 1 then |
error(":SetRelativeHeight(height): Invalid relative height.", 2) |
end |
self.relHeight = height |
self.height = "relative" |
end ]] |
WidgetBase.IsVisible = function(self) |
return self.frame:IsVisible() |
end |
WidgetBase.IsShown= function(self) |
return self.frame:IsShown() |
end |
WidgetBase.Release = function(self) |
AceGUI:Release(self) |
end |
WidgetBase.SetPoint = function(self, ...) |
return self.frame:SetPoint(...) |
end |
WidgetBase.ClearAllPoints = function(self) |
return self.frame:ClearAllPoints() |
end |
WidgetBase.GetNumPoints = function(self) |
return self.frame:GetNumPoints() |
end |
WidgetBase.GetPoint = function(self, ...) |
return self.frame:GetPoint(...) |
end |
WidgetBase.GetUserDataTable = function(self) |
return self.userdata |
end |
WidgetBase.SetUserData = function(self, key, value) |
self.userdata[key] = value |
end |
WidgetBase.GetUserData = function(self, key) |
return self.userdata[key] |
end |
WidgetBase.IsFullHeight = function(self) |
return self.height == "fill" |
end |
WidgetBase.SetFullHeight = function(self, isFull) |
if isFull then |
self.height = "fill" |
else |
self.height = nil |
end |
end |
WidgetBase.IsFullWidth = function(self) |
return self.width == "fill" |
end |
WidgetBase.SetFullWidth = function(self, isFull) |
if isFull then |
self.width = "fill" |
else |
self.width = nil |
end |
end |
-- local function LayoutOnUpdate(this) |
-- this:SetScript("OnUpdate",nil) |
-- this.obj:PerformLayout() |
-- end |
local WidgetContainerBase = AceGUI.WidgetContainerBase |
WidgetContainerBase.PauseLayout = function(self) |
self.LayoutPaused = true |
end |
WidgetContainerBase.ResumeLayout = function(self) |
self.LayoutPaused = nil |
end |
WidgetContainerBase.PerformLayout = function(self) |
if self.LayoutPaused then |
return |
end |
safecall(self.LayoutFunc, self.content, self.children) |
end |
--call this function to layout, makes sure layed out objects get a frame to get sizes etc |
WidgetContainerBase.DoLayout = function(self) |
self:PerformLayout() |
-- if not self.parent then |
-- self.frame:SetScript("OnUpdate", LayoutOnUpdate) |
-- end |
end |
WidgetContainerBase.AddChild = function(self, child, beforeWidget) |
if beforeWidget then |
local siblingIndex = 1 |
for _, widget in pairs(self.children) do |
if widget == beforeWidget then |
break |
end |
siblingIndex = siblingIndex + 1 |
end |
tinsert(self.children, siblingIndex, child) |
else |
tinsert(self.children, child) |
end |
child:SetParent(self) |
child.frame:Show() |
self:DoLayout() |
end |
WidgetContainerBase.AddChildren = function(self, ...) |
for i = 1, select("#", ...) do |
local child = select(i, ...) |
tinsert(self.children, child) |
child:SetParent(self) |
child.frame:Show() |
end |
self:DoLayout() |
end |
WidgetContainerBase.ReleaseChildren = function(self) |
local children = self.children |
for i = 1,#children do |
AceGUI:Release(children[i]) |
children[i] = nil |
end |
end |
WidgetContainerBase.SetLayout = function(self, Layout) |
self.LayoutFunc = AceGUI:GetLayout(Layout) |
end |
WidgetContainerBase.SetAutoAdjustHeight = function(self, adjust) |
if adjust then |
self.noAutoHeight = nil |
else |
self.noAutoHeight = true |
end |
end |
local function FrameResize(this) |
local self = this.obj |
if this:GetWidth() and this:GetHeight() then |
if self.OnWidthSet then |
self:OnWidthSet(this:GetWidth()) |
end |
if self.OnHeightSet then |
self:OnHeightSet(this:GetHeight()) |
end |
end |
end |
local function ContentResize(this) |
if this:GetWidth() and this:GetHeight() then |
this.width = this:GetWidth() |
this.height = this:GetHeight() |
this.obj:DoLayout() |
end |
end |
setmetatable(WidgetContainerBase, {__index=WidgetBase}) |
--One of these function should be called on each Widget Instance as part of its creation process |
--- Register a widget-class as a container for newly created widgets. |
-- @param widget The widget class |
function AceGUI:RegisterAsContainer(widget) |
widget.children = {} |
widget.userdata = {} |
widget.events = {} |
widget.base = WidgetContainerBase |
widget.content.obj = widget |
widget.frame.obj = widget |
widget.content:SetScript("OnSizeChanged", ContentResize) |
widget.frame:SetScript("OnSizeChanged", FrameResize) |
setmetatable(widget, {__index = WidgetContainerBase}) |
widget:SetLayout("List") |
return widget |
end |
--- Register a widget-class as a widget. |
-- @param widget The widget class |
function AceGUI:RegisterAsWidget(widget) |
widget.userdata = {} |
widget.events = {} |
widget.base = WidgetBase |
widget.frame.obj = widget |
widget.frame:SetScript("OnSizeChanged", FrameResize) |
setmetatable(widget, {__index = WidgetBase}) |
return widget |
end |
end |
------------------ |
-- Widget API -- |
------------------ |
--- Registers a widget Constructor, this function returns a new instance of the Widget |
-- @param Name The name of the widget |
-- @param Constructor The widget constructor function |
-- @param Version The version of the widget |
function AceGUI:RegisterWidgetType(Name, Constructor, Version) |
assert(type(Constructor) == "function") |
assert(type(Version) == "number") |
local oldVersion = WidgetVersions[Name] |
if oldVersion and oldVersion >= Version then return end |
WidgetVersions[Name] = Version |
WidgetRegistry[Name] = Constructor |
end |
--- Registers a Layout Function |
-- @param Name The name of the layout |
-- @param LayoutFunc Reference to the layout function |
function AceGUI:RegisterLayout(Name, LayoutFunc) |
assert(type(LayoutFunc) == "function") |
if type(Name) == "string" then |
Name = Name:upper() |
end |
LayoutRegistry[Name] = LayoutFunc |
end |
--- Get a Layout Function from the registry |
-- @param Name The name of the layout |
function AceGUI:GetLayout(Name) |
if type(Name) == "string" then |
Name = Name:upper() |
end |
return LayoutRegistry[Name] |
end |
AceGUI.counts = AceGUI.counts or {} |
--- A type-based counter to count the number of widgets created. |
-- This is used by widgets that require a named frame, e.g. when a Blizzard |
-- Template requires it. |
-- @param type The widget type |
function AceGUI:GetNextWidgetNum(type) |
if not self.counts[type] then |
self.counts[type] = 0 |
end |
self.counts[type] = self.counts[type] + 1 |
return self.counts[type] |
end |
--- Return the number of created widgets for this type. |
-- In contrast to GetNextWidgetNum, the number is not incremented. |
-- @param type The widget type |
function AceGUI:GetWidgetCount(type) |
return self.counts[type] or 0 |
end |
--- Return the version of the currently registered widget type. |
-- @param type The widget type |
function AceGUI:GetWidgetVersion(type) |
return WidgetVersions[type] |
end |
------------- |
-- Layouts -- |
------------- |
--[[ |
A Layout is a func that takes 2 parameters |
content - the frame that widgets will be placed inside |
children - a table containing the widgets to layout |
]] |
-- Very simple Layout, Children are stacked on top of each other down the left side |
AceGUI:RegisterLayout("List", |
function(content, children) |
local height = 0 |
local width = content.width or content:GetWidth() or 0 |
for i = 1, #children do |
local child = children[i] |
local frame = child.frame |
frame:ClearAllPoints() |
frame:Show() |
if i == 1 then |
frame:SetPoint("TOPLEFT", content) |
else |
frame:SetPoint("TOPLEFT", children[i-1].frame, "BOTTOMLEFT") |
end |
if child.width == "fill" then |
child:SetWidth(width) |
frame:SetPoint("RIGHT", content) |
if child.DoLayout then |
child:DoLayout() |
end |
elseif child.width == "relative" then |
child:SetWidth(width * child.relWidth) |
if child.DoLayout then |
child:DoLayout() |
end |
end |
height = height + (frame.height or frame:GetHeight() or 0) |
end |
safecall(content.obj.LayoutFinished, content.obj, nil, height) |
end) |
-- A single control fills the whole content area |
AceGUI:RegisterLayout("Fill", |
function(content, children) |
if children[1] then |
children[1]:SetWidth(content:GetWidth() or 0) |
children[1]:SetHeight(content:GetHeight() or 0) |
children[1].frame:SetAllPoints(content) |
children[1].frame:Show() |
safecall(content.obj.LayoutFinished, content.obj, nil, children[1].frame:GetHeight()) |
end |
end) |
AceGUI:RegisterLayout("Flow", |
function(content, children) |
--used height so far |
local height = 0 |
--width used in the current row |
local usedwidth = 0 |
--height of the current row |
local rowheight = 0 |
local rowoffset = 0 |
local lastrowoffset |
local width = content.width or content:GetWidth() or 0 |
--control at the start of the row |
local rowstart |
local rowstartoffset |
local lastrowstart |
local isfullheight |
local frameoffset |
local lastframeoffset |
local oversize |
for i = 1, #children do |
local child = children[i] |
oversize = nil |
local frame = child.frame |
local frameheight = frame.height or frame:GetHeight() or 0 |
local framewidth = frame.width or frame:GetWidth() or 0 |
lastframeoffset = frameoffset |
-- HACK: Why did we set a frameoffset of (frameheight / 2) ? |
-- That was moving all widgets half the widgets size down, is that intended? |
-- Actually, it seems to be neccessary for many cases, we'll leave it in for now. |
-- If widgets seem to anchor weirdly with this, provide a valid alignoffset for them. |
-- TODO: Investigate moar! |
frameoffset = child.alignoffset or (frameheight / 2) |
if child.width == "relative" then |
framewidth = width * child.relWidth |
end |
frame:Show() |
frame:ClearAllPoints() |
if i == 1 then |
-- anchor the first control to the top left |
frame:SetPoint("TOPLEFT", content) |
rowheight = frameheight |
rowoffset = frameoffset |
rowstart = frame |
rowstartoffset = frameoffset |
usedwidth = framewidth |
if usedwidth > width then |
oversize = true |
end |
else |
-- if there isn't available width for the control start a new row |
-- if a control is "fill" it will be on a row of its own full width |
if usedwidth == 0 or ((framewidth) + usedwidth > width) or child.width == "fill" then |
if isfullheight then |
-- a previous row has already filled the entire height, there's nothing we can usefully do anymore |
-- (maybe error/warn about this?) |
break |
end |
--anchor the previous row, we will now know its height and offset |
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3)) |
height = height + rowheight + 3 |
--save this as the rowstart so we can anchor it after the row is complete and we have the max height and offset of controls in it |
rowstart = frame |
rowstartoffset = frameoffset |
rowheight = frameheight |
rowoffset = frameoffset |
usedwidth = framewidth |
if usedwidth > width then |
oversize = true |
end |
-- put the control on the current row, adding it to the width and checking if the height needs to be increased |
else |
--handles cases where the new height is higher than either control because of the offsets |
--math.max(rowheight-rowoffset+frameoffset, frameheight-frameoffset+rowoffset) |
--offset is always the larger of the two offsets |
rowoffset = math_max(rowoffset, frameoffset) |
rowheight = math_max(rowheight, rowoffset + (frameheight / 2)) |
frame:SetPoint("TOPLEFT", children[i-1].frame, "TOPRIGHT", 0, frameoffset - lastframeoffset) |
usedwidth = framewidth + usedwidth |
end |
end |
if child.width == "fill" then |
child:SetWidth(width) |
frame:SetPoint("RIGHT", content) |
usedwidth = 0 |
rowstart = frame |
rowstartoffset = frameoffset |
if child.DoLayout then |
child:DoLayout() |
end |
rowheight = frame.height or frame:GetHeight() or 0 |
rowoffset = child.alignoffset or (rowheight / 2) |
rowstartoffset = rowoffset |
elseif child.width == "relative" then |
child:SetWidth(width * child.relWidth) |
if child.DoLayout then |
child:DoLayout() |
end |
elseif oversize then |
if width > 1 then |
frame:SetPoint("RIGHT", content) |
end |
end |
if child.height == "fill" then |
frame:SetPoint("BOTTOM", content) |
isfullheight = true |
end |
end |
--anchor the last row, if its full height needs a special case since its height has just been changed by the anchor |
if isfullheight then |
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -height) |
elseif rowstart then |
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3)) |
end |
height = height + rowheight + 3 |
safecall(content.obj.LayoutFinished, content.obj, nil, height) |
end) |
-- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/wiki/LibStub for more info |
-- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke |
local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2 -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS! |
local LibStub = _G[LIBSTUB_MAJOR] |
if not LibStub or LibStub.minor < LIBSTUB_MINOR then |
LibStub = LibStub or {libs = {}, minors = {} } |
_G[LIBSTUB_MAJOR] = LibStub |
LibStub.minor = LIBSTUB_MINOR |
function LibStub:NewLibrary(major, minor) |
assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)") |
minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.") |
local oldminor = self.minors[major] |
if oldminor and oldminor >= minor then return nil end |
self.minors[major], self.libs[major] = minor, self.libs[major] or {} |
return self.libs[major], oldminor |
end |
function LibStub:GetLibrary(major, silent) |
if not self.libs[major] and not silent then |
error(("Cannot find a library instance of %q."):format(tostring(major)), 2) |
end |
return self.libs[major], self.minors[major] |
end |
function LibStub:IterateLibraries() return pairs(self.libs) end |
setmetatable(LibStub, { __call = LibStub.GetLibrary }) |
end |
## Interface: 20400 |
## Title: Lib: LibStub |
## Notes: Universal Library Stub |
## Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel |
## X-Website: http://jira.wowace.com/browse/LS |
## X-Category: Library |
## X-License: Public Domain |
## X-Curse-Packaged-Version: 1.0 |
## X-Curse-Project-Name: LibStub |
## X-Curse-Project-ID: libstub |
## X-Curse-Repository-ID: wow/libstub/mainline |
LibStub.lua |
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
..\FrameXML\UI.xsd"> |
<Script file="CallbackHandler-1.0.lua"/> |
</Ui> |
--[[ $Id: CallbackHandler-1.0.lua 3 2008-09-29 16:54:20Z nevcairiel $ ]] |
local MAJOR, MINOR = "CallbackHandler-1.0", 3 |
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} |
local type = type |
local pcall = pcall |
local pairs = pairs |
local assert = assert |
local concat = table.concat |
local loadstring = loadstring |
local next = next |
local select = select |
local type = type |
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", concat(OLD_ARGS, ", ")):gsub("ARGS", concat(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" |
if type(self)~="table" and type(self)~="string" then |
error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string 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. |
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
-- Widget created by Yssaril |
local AceGUI = LibStub("AceGUI-3.0") |
local Media = LibStub("LibSharedMedia-3.0") |
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
do |
local widgetType = "LSM30_Font" |
local widgetVersion = 9 |
local contentFrameCache = {} |
local function ReturnSelf(self) |
self:ClearAllPoints() |
self:Hide() |
self.check:Hide() |
table.insert(contentFrameCache, self) |
end |
local function ContentOnClick(this, button) |
local self = this.obj |
self:Fire("OnValueChanged", this.text:GetText()) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function GetContentLine() |
local frame |
if next(contentFrameCache) then |
frame = table.remove(contentFrameCache) |
else |
frame = CreateFrame("Button", nil, UIParent) |
--frame:SetWidth(200) |
frame:SetHeight(18) |
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
frame:SetScript("OnClick", ContentOnClick) |
local check = frame:CreateTexture("OVERLAY") |
check:SetWidth(16) |
check:SetHeight(16) |
check:SetPoint("LEFT",frame,"LEFT",1,-1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:Hide() |
frame.check = check |
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
text:SetPoint("LEFT", check, "RIGHT", 1, 0) |
text:SetPoint("RIGHT", frame, "RIGHT", -2, 0) |
text:SetJustifyH("LEFT") |
text:SetText("Test Test Test Test Test Test Test") |
frame.text = text |
frame.ReturnSelf = ReturnSelf |
end |
frame:Show() |
return frame |
end |
local function OnAcquire(self) |
self:SetHeight(44) |
self:SetWidth(200) |
end |
local function OnRelease(self) |
self:SetText("") |
self:SetLabel("") |
self:SetDisabled(false) |
self.value = nil |
self.list = nil |
self.open = nil |
self.hasClose = nil |
self.frame:ClearAllPoints() |
self.frame:Hide() |
end |
local function SetValue(self, value) -- Set the value to an item in the List. |
if self.list then |
self:SetText(value or "") |
end |
self.value = value |
end |
local function GetValue(self) |
return self.value |
end |
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
self.list = list or Media:HashTable("font") |
end |
local function SetText(self, text) -- Set the text displayed in the box. |
self.frame.text:SetText(text or "") |
local font = self.list[text] ~= text and self.list[text] or Media:Fetch('font',text) |
local _, size, outline= self.frame.text:GetFont() |
self.frame.text:SetFont(font,size,outline) |
end |
local function SetLabel(self, text) -- Set the text for the label. |
self.frame.label:SetText(text or "") |
end |
local function AddItem(self, key, value) -- Add an item to the list. |
self.list = self.list or {} |
self.list[key] = value |
end |
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
local function SetDisabled(self, disabled) -- Disable the widget. |
self.disabled = disabled |
if disabled then |
self.frame:Disable() |
else |
self.frame:Enable() |
end |
end |
local function textSort(a,b) |
return string.upper(a) < string.upper(b) |
end |
local sortedlist = {} |
local function ToggleDrop(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
AceGUI:ClearFocus() |
else |
AceGUI:SetFocus(self) |
self.dropdown = AGSMW:GetDropDownFrame() |
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
for k, v in pairs(self.list) do |
sortedlist[#sortedlist+1] = k |
end |
table.sort(sortedlist, textSort) |
for i, k in ipairs(sortedlist) do |
local f = GetContentLine() |
local _, size, outline= f.text:GetFont() |
local font = self.list[k] ~= k and self.list[k] or Media:Fetch('font',k) |
f.text:SetFont(font,size,outline) |
f.text:SetText(k) |
if k == self.value then |
f.check:Show() |
end |
f.obj = self |
self.dropdown:AddFrame(f) |
end |
wipe(sortedlist) |
end |
end |
local function ClearFocus(self) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function OnHide(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function Drop_OnEnter(this) |
this.obj:Fire("OnEnter") |
end |
local function Drop_OnLeave(this) |
this.obj:Fire("OnLeave") |
end |
local function Constructor() |
local frame = AGSMW:GetBaseFrame() |
local self = {} |
self.type = widgetType |
self.frame = frame |
frame.obj = self |
frame.dropButton.obj = self |
frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
frame.dropButton:SetScript("OnClick",ToggleDrop) |
frame:SetScript("OnHide", OnHide) |
self.alignoffset = 31 |
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.ToggleDrop = ToggleDrop |
AceGUI:RegisterAsWidget(self) |
return self |
end |
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
end |
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
-- Widget created by Yssaril |
local AceGUI = LibStub("AceGUI-3.0") |
local Media = LibStub("LibSharedMedia-3.0") |
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
do |
local widgetType = "LSM30_Sound" |
local widgetVersion = 9 |
local contentFrameCache = {} |
local function ReturnSelf(self) |
self:ClearAllPoints() |
self:Hide() |
self.check:Hide() |
table.insert(contentFrameCache, self) |
end |
local function ContentOnClick(this, button) |
local self = this.obj |
self:Fire("OnValueChanged", this.text:GetText()) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function ContentSpeakerOnClick(this, button) |
local self = this.frame.obj |
local sound = this.frame.text:GetText() |
PlaySoundFile(self.list[sound] ~= sound and self.list[sound] or Media:Fetch('sound',sound)) |
end |
local function GetContentLine() |
local frame |
if next(contentFrameCache) then |
frame = table.remove(contentFrameCache) |
else |
frame = CreateFrame("Button", nil, UIParent) |
--frame:SetWidth(200) |
frame:SetHeight(18) |
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
frame:SetScript("OnClick", ContentOnClick) |
local check = frame:CreateTexture("OVERLAY") |
check:SetWidth(16) |
check:SetHeight(16) |
check:SetPoint("LEFT",frame,"LEFT",1,-1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:Hide() |
frame.check = check |
local soundbutton = CreateFrame("Button", nil, frame) |
soundbutton:SetWidth(16) |
soundbutton:SetHeight(16) |
soundbutton:SetPoint("RIGHT",frame,"RIGHT",-1,0) |
soundbutton.frame = frame |
soundbutton:SetScript("OnClick", ContentSpeakerOnClick) |
frame.soundbutton = soundbutton |
local speaker = soundbutton:CreateTexture(nil, "BACKGROUND") |
speaker:SetTexture("Interface\\Common\\VoiceChat-Speaker") |
speaker:SetAllPoints(soundbutton) |
frame.speaker = speaker |
local speakeron = soundbutton:CreateTexture(nil, "HIGHLIGHT") |
speakeron:SetTexture("Interface\\Common\\VoiceChat-On") |
speakeron:SetAllPoints(soundbutton) |
frame.speakeron = speakeron |
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
text:SetPoint("LEFT", check, "RIGHT", 1, 0) |
text:SetPoint("RIGHT", soundbutton, "LEFT", -2, 0) |
text:SetJustifyH("LEFT") |
text:SetText("Test Test Test Test Test Test Test") |
frame.text = text |
frame.ReturnSelf = ReturnSelf |
end |
frame:Show() |
return frame |
end |
local function OnAcquire(self) |
self:SetHeight(44) |
self:SetWidth(200) |
end |
local function OnRelease(self) |
self:SetText("") |
self:SetLabel("") |
self:SetDisabled(false) |
self.value = nil |
self.list = nil |
self.open = nil |
self.hasClose = nil |
self.frame:ClearAllPoints() |
self.frame:Hide() |
end |
local function SetValue(self, value) -- Set the value to an item in the List. |
if self.list then |
self:SetText(value or "") |
end |
self.value = value |
end |
local function GetValue(self) |
return self.value |
end |
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
self.list = list or Media:HashTable("sound") |
end |
local function SetText(self, text) -- Set the text displayed in the box. |
self.frame.text:SetText(text or "") |
end |
local function SetLabel(self, text) -- Set the text for the label. |
self.frame.label:SetText(text or "") |
end |
local function AddItem(self, key, value) -- Add an item to the list. |
self.list = self.list or {} |
self.list[key] = value |
end |
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
local function SetDisabled(self, disabled) -- Disable the widget. |
self.disabled = disabled |
if disabled then |
self.frame:Disable() |
self.speaker:SetDesaturated(true) |
self.speakeron:SetDesaturated(true) |
else |
self.frame:Enable() |
self.speaker:SetDesaturated(false) |
self.speakeron:SetDesaturated(false) |
end |
end |
local function textSort(a,b) |
return string.upper(a) < string.upper(b) |
end |
local sortedlist = {} |
local function ToggleDrop(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
AceGUI:ClearFocus() |
else |
AceGUI:SetFocus(self) |
self.dropdown = AGSMW:GetDropDownFrame() |
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
for k, v in pairs(self.list) do |
sortedlist[#sortedlist+1] = k |
end |
table.sort(sortedlist, textSort) |
for i, k in ipairs(sortedlist) do |
local f = GetContentLine() |
f.text:SetText(k) |
if k == self.value then |
f.check:Show() |
end |
f.obj = self |
self.dropdown:AddFrame(f) |
end |
wipe(sortedlist) |
end |
end |
local function ClearFocus(self) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function OnHide(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function Drop_OnEnter(this) |
this.obj:Fire("OnEnter") |
end |
local function Drop_OnLeave(this) |
this.obj:Fire("OnLeave") |
end |
local function WidgetPlaySound(this) |
local self = this.obj |
local sound = self.frame.text:GetText() |
PlaySoundFile(self.list[sound] ~= sound and self.list[sound] or Media:Fetch('sound',sound)) |
end |
local function Constructor() |
local frame = AGSMW:GetBaseFrame() |
local self = {} |
self.type = widgetType |
self.frame = frame |
frame.obj = self |
frame.dropButton.obj = self |
frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
frame.dropButton:SetScript("OnClick",ToggleDrop) |
frame:SetScript("OnHide", OnHide) |
local soundbutton = CreateFrame("Button", nil, frame) |
soundbutton:SetWidth(16) |
soundbutton:SetHeight(16) |
soundbutton:SetPoint("LEFT",frame.DLeft,"LEFT",26,1) |
soundbutton:SetScript("OnClick", WidgetPlaySound) |
soundbutton.obj = self |
self.soundbutton = soundbutton |
frame.text:SetPoint("LEFT",soundbutton,"RIGHT",2,0) |
local speaker = soundbutton:CreateTexture(nil, "BACKGROUND") |
speaker:SetTexture("Interface\\Common\\VoiceChat-Speaker") |
speaker:SetAllPoints(soundbutton) |
self.speaker = speaker |
local speakeron = soundbutton:CreateTexture(nil, "HIGHLIGHT") |
speakeron:SetTexture("Interface\\Common\\VoiceChat-On") |
speakeron:SetAllPoints(soundbutton) |
self.speakeron = speakeron |
self.alignoffset = 31 |
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.ToggleDrop = ToggleDrop |
AceGUI:RegisterAsWidget(self) |
return self |
end |
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
end |
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
-- Widget created by Yssaril |
local AceGUI = LibStub("AceGUI-3.0") |
local Media = LibStub("LibSharedMedia-3.0") |
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
do |
local widgetType = "LSM30_Statusbar" |
local widgetVersion = 9 |
local contentFrameCache = {} |
local function ReturnSelf(self) |
self:ClearAllPoints() |
self:Hide() |
self.check:Hide() |
table.insert(contentFrameCache, self) |
end |
local function ContentOnClick(this, button) |
local self = this.obj |
self:Fire("OnValueChanged", this.text:GetText()) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function GetContentLine() |
local frame |
if next(contentFrameCache) then |
frame = table.remove(contentFrameCache) |
else |
frame = CreateFrame("Button", nil, UIParent) |
--frame:SetWidth(200) |
frame:SetHeight(18) |
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
frame:SetScript("OnClick", ContentOnClick) |
local check = frame:CreateTexture("OVERLAY") |
check:SetWidth(16) |
check:SetHeight(16) |
check:SetPoint("LEFT",frame,"LEFT",1,-1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:Hide() |
frame.check = check |
local bar = frame:CreateTexture("ARTWORK") |
bar:SetHeight(16) |
bar:SetPoint("LEFT",check,"RIGHT",1,0) |
bar:SetPoint("RIGHT",frame,"RIGHT",-1,0) |
frame.bar = bar |
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
local font, size = text:GetFont() |
text:SetFont(font,size,"OUTLINE") |
text:SetPoint("LEFT", check, "RIGHT", 3, 0) |
text:SetPoint("RIGHT", frame, "RIGHT", -2, 0) |
text:SetJustifyH("LEFT") |
text:SetText("Test Test Test Test Test Test Test") |
frame.text = text |
frame.ReturnSelf = ReturnSelf |
end |
frame:Show() |
return frame |
end |
local function OnAcquire(self) |
self:SetHeight(44) |
self:SetWidth(200) |
end |
local function OnRelease(self) |
self:SetText("") |
self:SetLabel("") |
self:SetDisabled(false) |
self.value = nil |
self.list = nil |
self.open = nil |
self.hasClose = nil |
self.frame:ClearAllPoints() |
self.frame:Hide() |
end |
local function SetValue(self, value) -- Set the value to an item in the List. |
if self.list then |
self:SetText(value or "") |
end |
self.value = value |
end |
local function GetValue(self) |
return self.value |
end |
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
self.list = list or Media:HashTable("statusbar") |
end |
local function SetText(self, text) -- Set the text displayed in the box. |
self.frame.text:SetText(text or "") |
local statusbar = self.list[text] ~= text and self.list[text] or Media:Fetch('statusbar',text) |
self.bar:SetTexture(statusbar) |
end |
local function SetLabel(self, text) -- Set the text for the label. |
self.frame.label:SetText(text or "") |
end |
local function AddItem(self, key, value) -- Add an item to the list. |
self.list = self.list or {} |
self.list[key] = value |
end |
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
local function SetDisabled(self, disabled) -- Disable the widget. |
self.disabled = disabled |
if disabled then |
self.frame:Disable() |
else |
self.frame:Enable() |
end |
end |
local function textSort(a,b) |
return string.upper(a) < string.upper(b) |
end |
local sortedlist = {} |
local function ToggleDrop(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
AceGUI:ClearFocus() |
else |
AceGUI:SetFocus(self) |
self.dropdown = AGSMW:GetDropDownFrame() |
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
for k, v in pairs(self.list) do |
sortedlist[#sortedlist+1] = k |
end |
table.sort(sortedlist, textSort) |
for i, k in ipairs(sortedlist) do |
local f = GetContentLine() |
f.text:SetText(k) |
--print(k) |
if k == self.value then |
f.check:Show() |
end |
local statusbar = self.list[k] ~= k and self.list[k] or Media:Fetch('statusbar',k) |
f.bar:SetTexture(statusbar) |
f.obj = self |
f.dropdown = self.dropdown |
self.dropdown:AddFrame(f) |
end |
wipe(sortedlist) |
end |
end |
local function ClearFocus(self) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function OnHide(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function Drop_OnEnter(this) |
this.obj:Fire("OnEnter") |
end |
local function Drop_OnLeave(this) |
this.obj:Fire("OnLeave") |
end |
local function Constructor() |
local frame = AGSMW:GetBaseFrame() |
local self = {} |
self.type = widgetType |
self.frame = frame |
frame.obj = self |
frame.dropButton.obj = self |
frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
frame.dropButton:SetScript("OnClick",ToggleDrop) |
frame:SetScript("OnHide", OnHide) |
local bar = frame:CreateTexture(nil, "ARTWORK") |
bar:SetPoint("TOPLEFT", frame,"TOPLEFT",6,-25) |
bar:SetPoint("BOTTOMRIGHT", frame,"BOTTOMRIGHT", -21, 5) |
self.bar = bar |
self.alignoffset = 31 |
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.ToggleDrop = ToggleDrop |
AceGUI:RegisterAsWidget(self) |
return self |
end |
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
end |
-- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
-- Widget created by Yssaril |
local AceGUI = LibStub("AceGUI-3.0") |
local Media = LibStub("LibSharedMedia-3.0") |
local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
do |
local widgetType = "LSM30_Border" |
local widgetVersion = 9 |
local contentFrameCache = {} |
local function ReturnSelf(self) |
self:ClearAllPoints() |
self:Hide() |
self.check:Hide() |
table.insert(contentFrameCache, self) |
end |
local function ContentOnClick(this, button) |
local self = this.obj |
self:Fire("OnValueChanged", this.text:GetText()) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function ContentOnEnter(this, button) |
local self = this.obj |
local text = this.text:GetText() |
local border = self.list[text] ~= text and self.list[text] or Media:Fetch('border',text) |
this.dropdown:SetBackdrop({edgeFile = border, |
bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]], |
tile = true, tileSize = 16, edgeSize = 16, |
insets = { left = 4, right = 4, top = 4, bottom = 4 }}) |
end |
local function GetContentLine() |
local frame |
if next(contentFrameCache) then |
frame = table.remove(contentFrameCache) |
else |
frame = CreateFrame("Button", nil, UIParent) |
--frame:SetWidth(200) |
frame:SetHeight(18) |
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
frame:SetScript("OnClick", ContentOnClick) |
frame:SetScript("OnEnter", ContentOnEnter) |
local check = frame:CreateTexture("OVERLAY") |
check:SetWidth(16) |
check:SetHeight(16) |
check:SetPoint("LEFT",frame,"LEFT",1,-1) |
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
check:Hide() |
frame.check = check |
local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
text:SetPoint("LEFT", check, "RIGHT", 1, 0) |
text:SetPoint("RIGHT", frame, "RIGHT", -2, 0) |
text:SetJustifyH("LEFT") |
text:SetText("Test Test Test Test Test Test Test") |
frame.text = text |
frame.ReturnSelf = ReturnSelf |
end |
frame:Show() |
return frame |
end |
local function OnAcquire(self) |
self:SetHeight(44) |
self:SetWidth(200) |
end |
local function OnRelease(self) |
self:SetText("") |
self:SetLabel("") |
self:SetDisabled(false) |
self.value = nil |
self.list = nil |
self.open = nil |
self.hasClose = nil |
self.frame:ClearAllPoints() |
self.frame:Hide() |
end |
local function SetValue(self, value) -- Set the value to an item in the List. |
if self.list then |
self:SetText(value or "") |
end |
self.value = value |
end |
local function GetValue(self) |
return self.value |
end |
local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
self.list = list or Media:HashTable("border") |
end |
local function SetText(self, text) -- Set the text displayed in the box. |
self.frame.text:SetText(text or "") |
local border = self.list[text] ~= text and self.list[text] or Media:Fetch('border',text) |
self.frame.displayButton:SetBackdrop({edgeFile = border, |
bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]], |
tile = true, tileSize = 16, edgeSize = 16, |
insets = { left = 4, right = 4, top = 4, bottom = 4 }}) |
end |
local function SetLabel(self, text) -- Set the text for the label. |
self.frame.label:SetText(text or "") |
end |
local function AddItem(self, key, value) -- Add an item to the list. |
self.list = self.list or {} |
self.list[key] = value |
end |
local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
local function SetDisabled(self, disabled) -- Disable the widget. |
self.disabled = disabled |
if disabled then |
self.frame:Disable() |
else |
self.frame:Enable() |
end |
end |
local function textSort(a,b) |
return string.upper(a) < string.upper(b) |
end |
local sortedlist = {} |
local function ToggleDrop(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
AceGUI:ClearFocus() |
else |
AceGUI:SetFocus(self) |
self.dropdown = AGSMW:GetDropDownFrame() |
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
for k, v in pairs(self.list) do |
sortedlist[#sortedlist+1] = k |
end |
table.sort(sortedlist, textSort) |
for i, k in ipairs(sortedlist) do |
local f = GetContentLine() |
f.text:SetText(k) |
--print(k) |
if k == self.value then |
f.check:Show() |
end |
f.obj = self |
f.dropdown = self.dropdown |
self.dropdown:AddFrame(f) |
end |
wipe(sortedlist) |
end |
end |
local function ClearFocus(self) |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function OnHide(this) |
local self = this.obj |
if self.dropdown then |
self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
end |
end |
local function Drop_OnEnter(this) |
this.obj:Fire("OnEnter") |
end |
local function Drop_OnLeave(this) |
this.obj:Fire("OnLeave") |
end |
local function Constructor() |
local frame = AGSMW:GetBaseFrameWithWindow() |
local self = {} |
self.type = widgetType |
self.frame = frame |
frame.obj = self |
frame.dropButton.obj = self |
frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
frame.dropButton:SetScript("OnClick",ToggleDrop) |
frame:SetScript("OnHide", OnHide) |
self.alignoffset = 31 |
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.ToggleDrop = ToggleDrop |
AceGUI:RegisterAsWidget(self) |
return self |
end |
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
end |
<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> |
--[[ $Id: CallbackHandler-1.0.lua 965 2010-08-09 00:47:52Z mikk $ ]] |
local MAJOR, MINOR = "CallbackHandler-1.0", 6 |
local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR) |
if not CallbackHandler then return end -- No upgrade needed |
local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end} |
-- Lua APIs |
local tconcat = table.concat |
local assert, error, loadstring = assert, error, loadstring |
local setmetatable, rawset, rawget = setmetatable, rawset, rawget |
local next, select, pairs, type, tostring = next, select, pairs, type, tostring |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: geterrorhandler |
local xpcall = xpcall |
local function errorhandler(err) |
return geterrorhandler()(err) |
end |
local function CreateDispatcher(argCount) |
local code = [[ |
local next, xpcall, eh = ... |
local method, ARGS |
local function call() method(ARGS) end |
local function dispatch(handlers, ...) |
local index |
index, method = next(handlers) |
if not method then return end |
local OLD_ARGS = ARGS |
ARGS = ... |
repeat |
xpcall(call, eh) |
index, method = next(handlers, index) |
until not method |
ARGS = OLD_ARGS |
end |
return dispatch |
]] |
local ARGS, OLD_ARGS = {}, {} |
for i = 1, argCount do ARGS[i], OLD_ARGS[i] = "arg"..i, "old_arg"..i end |
code = code:gsub("OLD_ARGS", tconcat(OLD_ARGS, ", ")):gsub("ARGS", tconcat(ARGS, ", ")) |
return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(next, xpcall, errorhandler) |
end |
local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
local dispatcher = CreateDispatcher(argCount) |
rawset(self, argCount, dispatcher) |
return dispatcher |
end}) |
-------------------------------------------------------------------------- |
-- CallbackHandler:New |
-- |
-- target - target object to embed public APIs in |
-- RegisterName - name of the callback registration API, default "RegisterCallback" |
-- UnregisterName - name of the callback unregistration API, default "UnregisterCallback" |
-- UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API. |
function CallbackHandler:New(target, RegisterName, UnregisterName, UnregisterAllName, OnUsed, OnUnused) |
-- TODO: Remove this after beta has gone out |
assert(not OnUsed and not OnUnused, "ACE-80: OnUsed/OnUnused are deprecated. Callbacks are now done to registry.OnUsed and registry.OnUnused") |
RegisterName = RegisterName or "RegisterCallback" |
UnregisterName = UnregisterName or "UnregisterCallback" |
if UnregisterAllName==nil then -- false is used to indicate "don't want this method" |
UnregisterAllName = "UnregisterAllCallbacks" |
end |
-- we declare all objects and exported APIs inside this closure to quickly gain access |
-- to e.g. function names, the "target" parameter, etc |
-- Create the registry object |
local events = setmetatable({}, meta) |
local registry = { recurse=0, events=events } |
-- registry:Fire() - fires the given event/message into the registry |
function registry:Fire(eventname, ...) |
if not rawget(events, eventname) or not next(events[eventname]) then return end |
local oldrecurse = registry.recurse |
registry.recurse = oldrecurse + 1 |
Dispatchers[select('#', ...) + 1](events[eventname], eventname, ...) |
registry.recurse = oldrecurse |
if registry.insertQueue and oldrecurse==0 then |
-- Something in one of our callbacks wanted to register more callbacks; they got queued |
for eventname,callbacks in pairs(registry.insertQueue) do |
local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten. |
for self,func in pairs(callbacks) do |
events[eventname][self] = func |
-- fire OnUsed callback? |
if first and registry.OnUsed then |
registry.OnUsed(registry, target, eventname) |
first = nil |
end |
end |
end |
registry.insertQueue = nil |
end |
end |
-- Registration of a callback, handles: |
-- self["method"], leads to self["method"](self, ...) |
-- self with function ref, leads to functionref(...) |
-- "addonId" (instead of self) with function ref, leads to functionref(...) |
-- all with an optional arg, which, if present, gets passed as first argument (after self if present) |
target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]]) |
if type(eventname) ~= "string" then |
error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2) |
end |
method = method or eventname |
local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten. |
if type(method) ~= "string" and type(method) ~= "function" then |
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2) |
end |
local regfunc |
if type(method) == "string" then |
-- self["method"] calling style |
if type(self) ~= "table" then |
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2) |
elseif self==target then |
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2) |
elseif type(self[method]) ~= "function" then |
error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2) |
end |
if select("#",...)>=1 then -- this is not the same as testing for arg==nil! |
local arg=select(1,...) |
regfunc = function(...) self[method](self,arg,...) end |
else |
regfunc = function(...) self[method](self,...) end |
end |
else |
-- function ref with self=object or self="addonId" or self=thread |
if type(self)~="table" and type(self)~="string" and type(self)~="thread" then |
error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string or thread expected.", 2) |
end |
if select("#",...)>=1 then -- this is not the same as testing for arg==nil! |
local arg=select(1,...) |
regfunc = function(...) method(arg,...) end |
else |
regfunc = method |
end |
end |
if events[eventname][self] or registry.recurse<1 then |
-- if registry.recurse<1 then |
-- we're overwriting an existing entry, or not currently recursing. just set it. |
events[eventname][self] = regfunc |
-- fire OnUsed callback? |
if registry.OnUsed and first then |
registry.OnUsed(registry, target, eventname) |
end |
else |
-- we're currently processing a callback in this registry, so delay the registration of this new entry! |
-- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency |
registry.insertQueue = registry.insertQueue or setmetatable({},meta) |
registry.insertQueue[eventname][self] = regfunc |
end |
end |
-- Unregister a callback |
target[UnregisterName] = function(self, eventname) |
if not self or self==target then |
error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2) |
end |
if type(eventname) ~= "string" then |
error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2) |
end |
if rawget(events, eventname) and events[eventname][self] then |
events[eventname][self] = nil |
-- Fire OnUnused callback? |
if registry.OnUnused and not next(events[eventname]) then |
registry.OnUnused(registry, target, eventname) |
end |
end |
if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then |
registry.insertQueue[eventname][self] = nil |
end |
end |
-- OPTIONAL: Unregister all callbacks for given selfs/addonIds |
if UnregisterAllName then |
target[UnregisterAllName] = function(...) |
if select("#",...)<1 then |
error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2) |
end |
if select("#",...)==1 and ...==target then |
error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2) |
end |
for i=1,select("#",...) do |
local self = select(i,...) |
if registry.insertQueue then |
for eventname, callbacks in pairs(registry.insertQueue) do |
if callbacks[self] then |
callbacks[self] = nil |
end |
end |
end |
for eventname, callbacks in pairs(events) do |
if callbacks[self] then |
callbacks[self] = nil |
-- Fire OnUnused callback? |
if registry.OnUnused and not next(callbacks) then |
registry.OnUnused(registry, target, eventname) |
end |
end |
end |
end |
end |
end |
return registry |
end |
-- CallbackHandler purposefully does NOT do explicit embedding. Nor does it |
-- try to upgrade old implicit embeds since the system is selfcontained and |
-- relies on closures to work. |
<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> |
--- 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 938 2010-06-13 07:21:38Z nevcairiel $ |
local ACEDBO_MAJOR, ACEDBO_MINOR = "AceDBOptions-3.0", 12 |
local AceDBOptions, oldminor = 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 |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: NORMAL_FONT_COLOR_CODE, FONT_COLOR_CODE_CLOSE |
AceDBOptions.optionTables = AceDBOptions.optionTables or {} |
AceDBOptions.handlers = AceDBOptions.handlers or {} |
--[[ |
Localization of AceDBOptions-3.0 |
]] |
local L = { |
default = "Default", |
intro = "You can change the active database profile, so you can have different settings for every character.", |
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 = "Reset Profile", |
reset_sub = "Reset the current profile to the default", |
choose_desc = "You can either create a new profile by entering a name in the editbox, or choose one of the already existing profiles.", |
new = "New", |
new_sub = "Create a new empty profile.", |
choose = "Existing Profiles", |
choose_sub = "Select one of your currently available profiles.", |
copy_desc = "Copy the settings from one existing profile into the currently active profile.", |
copy = "Copy From", |
delete_desc = "Delete existing and unused profiles from the database to save space, and cleanup the SavedVariables file.", |
delete = "Delete a Profile", |
delete_sub = "Deletes a profile from the database.", |
delete_confirm = "Are you sure you want to delete the selected profile?", |
profiles = "Profiles", |
profiles_sub = "Manage Profiles", |
current = "Current Profile:", |
} |
local LOCALE = GetLocale() |
if LOCALE == "deDE" then |
L["default"] = "Standard" |
L["intro"] = "Hier kannst du das aktive Datenbankprofile \195\164ndern, damit du verschiedene Einstellungen f\195\188r jeden Charakter erstellen kannst, wodurch eine sehr flexible Konfiguration m\195\182glich wird." |
L["reset_desc"] = "Setzt das momentane Profil auf Standardwerte zur\195\188ck, f\195\188r den Fall das mit der Konfiguration etwas schief lief oder weil du einfach neu starten willst." |
L["reset"] = "Profil zur\195\188cksetzen" |
L["reset_sub"] = "Das aktuelle Profil auf Standard zur\195\188cksetzen." |
L["choose_desc"] = "Du kannst ein neues Profil erstellen, indem du einen neuen Namen in der Eingabebox 'Neu' eingibst, oder w\195\164hle eines der vorhandenen Profile aus." |
L["new"] = "Neu" |
L["new_sub"] = "Ein neues Profil erstellen." |
L["choose"] = "Vorhandene Profile" |
L["choose_sub"] = "W\195\164hlt ein bereits vorhandenes Profil aus." |
L["copy_desc"] = "Kopiere die Einstellungen von einem vorhandenen Profil in das aktive Profil." |
L["copy"] = "Kopieren von..." |
L["delete_desc"] = "L\195\182sche vorhandene oder unbenutzte Profile aus der Datenbank um Platz zu sparen und um die SavedVariables Datei 'sauber' zu halten." |
L["delete"] = "Profil l\195\182schen" |
L["delete_sub"] = "L\195\182scht ein Profil aus der Datenbank." |
L["delete_confirm"] = "Willst du das ausgew\195\164hlte Profil wirklich l\195\182schen?" |
L["profiles"] = "Profile" |
L["profiles_sub"] = "Profile verwalten" |
--L["current"] = "Current Profile:" |
elseif LOCALE == "frFR" then |
L["default"] = "D\195\169faut" |
L["intro"] = "Vous pouvez changer le profil actuel afin d'avoir des param\195\168tres diff\195\169rents pour chaque personnage, permettant ainsi d'avoir une configuration tr\195\168s flexible." |
L["reset_desc"] = "R\195\169initialise le profil actuel au cas o\195\185 votre configuration est corrompue ou si vous voulez tout simplement faire table rase." |
L["reset"] = "R\195\169initialiser le profil" |
L["reset_sub"] = "R\195\169initialise le profil actuel avec les param\195\168tres par d\195\169faut." |
L["choose_desc"] = "Vous pouvez cr\195\169er un nouveau profil en entrant un nouveau nom dans la bo\195\174te de saisie, ou en choississant un des profils d\195\169j\195\160 existants." |
L["new"] = "Nouveau" |
L["new_sub"] = "Cr\195\169\195\169e un nouveau profil vierge." |
L["choose"] = "Profils existants" |
L["choose_sub"] = "Permet de choisir un des profils d\195\169j\195\160 disponibles." |
L["copy_desc"] = "Copie les param\195\168tres d'un profil d\195\169j\195\160 existant dans le profil actuellement actif." |
L["copy"] = "Copier \195\160 partir de" |
L["delete_desc"] = "Supprime les profils existants inutilis\195\169s de la base de donn\195\169es afin de gagner de la place et de nettoyer le fichier SavedVariables." |
L["delete"] = "Supprimer un profil" |
L["delete_sub"] = "Supprime un profil de la base de donn\195\169es." |
L["delete_confirm"] = "Etes-vous s\195\187r de vouloir supprimer le profil s\195\169lectionn\195\169 ?" |
L["profiles"] = "Profils" |
L["profiles_sub"] = "Gestion des profils" |
--L["current"] = "Current Profile:" |
elseif LOCALE == "koKR" then |
L["default"] = "기본ê°" |
L["intro"] = "모ë ìºë¦í°ì ë¤ìí ì¤ì ê³¼ ì¬ì©ì¤ì¸ ë°ì´í°ë² ì´ì¤ íë¡í, ì´ëê²ì´ëì§ ë§¤ì° ë¤ë£¨ê¸° ì½ê² ë°ê¿ì ììµëë¤." |
L["reset_desc"] = "ë¨ìí ë¤ì ìë¡ê² 구ì±ì ìíë ê²½ì°, íì¬ íë¡íì 기본ê°ì¼ë¡ ì´ê¸°í í©ëë¤." |
L["reset"] = "íë¡í ì´ê¸°í" |
L["reset_sub"] = "íì¬ì íë¡íì 기본ê°ì¼ë¡ ì´ê¸°í í©ëë¤" |
L["choose_desc"] = "ìë¡ì´ ì´ë¦ì ì ë ¥íê±°ë, ì´ë¯¸ ìë íë¡íì¤ íë를 ì ííì¬ ìë¡ì´ íë¡íì ë§ë¤ ì ììµëë¤." |
L["new"] = "ìë¡ì´ íë¡í" |
L["new_sub"] = "ìë¡ì´ íë¡íì ë§ëëë¤." |
L["choose"] = "íë¡í ì í" |
L["choose_sub"] = "ë¹ì ì´ íì¬ ì´ì©í ì ìë íë¡íì ì íí©ëë¤." |
L["copy_desc"] = "íì¬ ì¬ì©ì¤ì¸ íë¡íì, ì íí íë¡íì ì¤ì ì ë³µì¬í©ëë¤." |
L["copy"] = "ë³µì¬" |
L["delete_desc"] = "ë°ì´í°ë² ì´ì¤ì ì¬ì©ì¤ì´ê±°ë ì ì¥ë íë¡íì¼ ìì ë¡ SavedVariables íì¼ì ì 리ì ê³µê° ì ì½ì´ ë©ëë¤." |
L["delete"] = "íë¡í ìì " |
L["delete_sub"] = "ë°ì´í°ë² ì´ì¤ì íë¡íì ìì í©ëë¤." |
L["delete_confirm"] = "ì ë§ë¡ ì íí íë¡íì ìì 를 ìíìëê¹?" |
L["profiles"] = "íë¡í" |
L["profiles_sub"] = "íë¡í ì¤ì " |
--L["current"] = "Current Profile:" |
elseif LOCALE == "esES" or LOCALE == "esMX" then |
L["default"] = "Por defecto" |
L["intro"] = "Puedes cambiar el perfil activo de tal manera que cada personaje tenga diferentes configuraciones." |
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"] = "Reiniciar Perfil" |
L["reset_sub"] = "Reinicar el perfil actual al de por defecto" |
L["choose_desc"] = "Puedes crear un nuevo perfil introduciendo un nombre en el recuadro o puedes seleccionar un perfil de los ya existentes." |
L["new"] = "Nuevo" |
L["new_sub"] = "Crear un nuevo perfil vacio." |
L["choose"] = "Perfiles existentes" |
L["choose_sub"] = "Selecciona uno de los perfiles disponibles." |
L["copy_desc"] = "Copia los ajustes de un perfil existente al perfil actual." |
L["copy"] = "Copiar de" |
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"] = "Borrar un Perfil" |
L["delete_sub"] = "Borra un perfil de la base de datos." |
L["delete_confirm"] = "¿Estas seguro que quieres borrar el perfil seleccionado?" |
L["profiles"] = "Perfiles" |
L["profiles_sub"] = "Manejar Perfiles" |
--L["current"] = "Current Profile:" |
elseif LOCALE == "zhTW" then |
L["default"] = "é è¨" |
L["intro"] = "ä½ å¯ä»¥é¸æä¸åæ´»åçè³æè¨å®æªï¼éæ¨£ä½ çæ¯åè§è²å°±å¯ä»¥ææä¸åçè¨å®å¼ï¼å¯ä»¥çµ¦ä½ çæ件è¨å®å¸¶ä¾æ¥µå¤§çéæ´»æ§ã" |
L["reset_desc"] = "å°ç¶åçè¨å®æªæ¢å¾©å°å®çé è¨å¼ï¼ç¨æ¼ä½ çè¨å®æªæå£ï¼æè ä½ åªæ¯æ³éä¾çæ æ³ã" |
L["reset"] = "éç½®è¨å®æª" |
L["reset_sub"] = "å°ç¶åçè¨å®æªæ¢å¾©çºé è¨å¼" |
L["choose_desc"] = "ä½ å¯ä»¥ééå¨ææ¬æ¡å §è¼¸å ¥ä¸ååååµç«ä¸åæ°çè¨å®æªï¼ä¹å¯ä»¥é¸æä¸åå·²ç¶åå¨çè¨å®æªã" |
L["new"] = "æ°å»º" |
L["new_sub"] = "æ°å»ºä¸å空çè¨å®æªã" |
L["choose"] = "ç¾æçè¨å®æª" |
L["choose_sub"] = "å¾ç¶åå¯ç¨çè¨å®æªè£é¢é¸æä¸åã" |
L["copy_desc"] = "å¾ç¶åæåå·²ä¿åçè¨å®æªè¤è£½å°ç¶åæ£ä½¿ç¨çè¨å®æªã" |
L["copy"] = "è¤è£½èª" |
L["delete_desc"] = "å¾è³æ庫è£åªé¤ä¸å使ç¨çè¨å®æªï¼ä»¥ç¯ç空éï¼ä¸¦ä¸æ¸ çSavedVariablesæªã" |
L["delete"] = "åªé¤ä¸åè¨å®æª" |
L["delete_sub"] = "å¾è³æ庫è£åªé¤ä¸åè¨å®æªã" |
L["delete_confirm"] = "ä½ ç¢ºå®è¦åªé¤æé¸æçè¨å®æªåï¼" |
L["profiles"] = "è¨å®æª" |
L["profiles_sub"] = "管çè¨å®æª" |
--L["current"] = "Current Profile:" |
elseif LOCALE == "zhCN" then |
L["default"] = "é»è®¤" |
L["intro"] = "ä½ å¯ä»¥éæ©ä¸ä¸ªæ´»å¨çæ°æ®é ç½®æ件ï¼è¿æ ·ä½ çæ¯ä¸ªè§è²å°±å¯ä»¥æ¥æä¸åç设置å¼ï¼å¯ä»¥ç»ä½ çæ件é 置带æ¥æ大ççµæ´»æ§ã" |
L["reset_desc"] = "å°å½åçé ç½®æ件æ¢å¤å°å®çé»è®¤å¼ï¼ç¨äºä½ çé ç½®æ件æåï¼æè ä½ åªæ¯æ³éæ¥çæ åµã" |
L["reset"] = "éç½®é ç½®æ件" |
L["reset_sub"] = "å°å½åçé ç½®æ件æ¢å¤ä¸ºé»è®¤å¼" |
L["choose_desc"] = "ä½ å¯ä»¥éè¿å¨ææ¬æ¡å è¾å ¥ä¸ä¸ªåååç«ä¸ä¸ªæ°çé ç½®æ件ï¼ä¹å¯ä»¥éæ©ä¸ä¸ªå·²ç»åå¨çé ç½®æ件ã" |
L["new"] = "æ°å»º" |
L["new_sub"] = "æ°å»ºä¸ä¸ªç©ºçé ç½®æ件ã" |
L["choose"] = "ç°æçé ç½®æ件" |
L["choose_sub"] = "ä»å½åå¯ç¨çé ç½®æ件éé¢éæ©ä¸ä¸ªã" |
L["copy_desc"] = "ä»å½åæ个已ä¿åçé ç½®æ件å¤å¶å°å½åæ£ä½¿ç¨çé ç½®æ件ã" |
L["copy"] = "å¤å¶èª" |
L["delete_desc"] = "ä»æ°æ®åºéå é¤ä¸å使ç¨çé ç½®æ件ï¼ä»¥èç空é´ï¼å¹¶ä¸æ¸ çSavedVariablesæ件ã" |
L["delete"] = "å é¤ä¸ä¸ªé ç½®æ件" |
L["delete_sub"] = "ä»æ°æ®åºéå é¤ä¸ä¸ªé ç½®æ件ã" |
L["delete_confirm"] = "ä½ ç¡®å®è¦å é¤æéæ©çé ç½®æ件ä¹ï¼" |
L["profiles"] = "é ç½®æ件" |
L["profiles_sub"] = "管çé ç½®æ件" |
--L["current"] = "Current Profile:" |
elseif LOCALE == "ruRU" then |
L["default"] = "Ðо ÑмолÑаниÑ" |
L["intro"] = "ÐзменÑÑ Ð°ÐºÑивнÑй пÑоÑилÑ, Ð²Ñ Ð¼Ð¾Ð¶ÐµÑе задаÑÑ ÑазлиÑнÑе наÑÑÑойки модиÑикаÑий Ð´Ð»Ñ ÐºÐ°Ð¶Ð´Ð¾Ð³Ð¾ пеÑÑонажа." |
L["reset_desc"] = "ÐÑли ваÑа конÑигÑÑаÑии иÑпоÑÑена или еÑли Ð²Ñ Ñ Ð¾ÑиÑе наÑÑÑоиÑÑ Ð²ÑÑ Ð·Ð°Ð½Ð¾Ð²Ð¾ - ÑбÑоÑÑÑе ÑекÑÑий пÑоÑÐ¸Ð»Ñ Ð½Ð° ÑÑандаÑÑнÑе знаÑениÑ." |
L["reset"] = "СбÑÐ¾Ñ Ð¿ÑоÑилÑ" |
L["reset_sub"] = "СбÑÐ¾Ñ ÑекÑÑего пÑоÑÐ¸Ð»Ñ Ð½Ð° ÑÑандаÑÑнÑй" |
L["choose_desc"] = "ÐÑ Ð¼Ð¾Ð¶ÐµÑе ÑоздаÑÑ Ð½Ð¾Ð²Ñй пÑоÑилÑ, Ð²Ð²ÐµÐ´Ñ Ð½Ð°Ð·Ð²Ð°Ð½Ð¸Ðµ в поле ввода, или вÑбÑаÑÑ Ð¾Ð´Ð¸Ð½ из Ñже ÑÑÑеÑÑвÑÑÑÐ¸Ñ Ð¿ÑоÑилей." |
L["new"] = "ÐовÑй" |
L["new_sub"] = "СоздаÑÑ Ð½Ð¾Ð²Ñй ÑиÑÑÑй пÑоÑилÑ" |
L["choose"] = "СÑÑеÑÑвÑÑÑие пÑоÑили" |
L["choose_sub"] = "ÐÑÐ±Ð¾Ñ Ð¾Ð´Ð¸Ð½Ð¾Ð³Ð¾ из Ñже доÑÑÑпнÑÑ Ð¿ÑоÑилей" |
L["copy_desc"] = "СкопиÑоваÑÑ Ð½Ð°ÑÑÑойки из вÑбÑанного пÑоÑÐ¸Ð»Ñ Ð² акÑивнÑй." |
L["copy"] = "СкопиÑоваÑÑ Ð¸Ð·" |
L["delete_desc"] = "УдалиÑÑ ÑÑÑеÑÑвÑÑÑий и неиÑполÑзÑемÑй пÑоÑÐ¸Ð»Ñ Ð¸Ð· ÐÐ Ð´Ð»Ñ ÑÐ¾Ñ ÑÐ°Ð½ÐµÐ½Ð¸Ñ Ð¼ÐµÑÑа, и оÑиÑÑиÑÑ SavedVariables Ñайл." |
L["delete"] = "УдалиÑÑ Ð¿ÑоÑилÑ" |
L["delete_sub"] = "Удаление пÑоÑÐ¸Ð»Ñ Ð¸Ð· ÐÐ" |
L["delete_confirm"] = "ÐÑ ÑвеÑенÑ, ÑÑо Ð²Ñ Ñ Ð¾ÑиÑе ÑдалиÑÑ Ð²ÑбÑаннÑй пÑоÑилÑ?" |
L["profiles"] = "ÐÑоÑили" |
L["profiles_sub"] = "УпÑавление пÑоÑилÑми" |
--L["current"] = "Current Profile:" |
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 |
<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> |
--- AceEvent-3.0 provides event registration and secure dispatching. |
-- All dispatching is done using **CallbackHandler-1.0**. AceEvent is a simple wrapper around |
-- CallbackHandler, and dispatches all game events or addon message to the registrees. |
-- |
-- **AceEvent-3.0** can be embeded into your addon, either explicitly by calling AceEvent:Embed(MyAddon) or by |
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object |
-- and can be accessed directly, without having to explicitly call AceEvent itself.\\ |
-- It is recommended to embed AceEvent, otherwise you'll have to specify a custom `self` on all calls you |
-- make into AceEvent. |
-- @class file |
-- @name AceEvent-3.0 |
-- @release $Id: AceEvent-3.0.lua 975 2010-10-23 11:26:18Z nevcairiel $ |
local MAJOR, MINOR = "AceEvent-3.0", 3 |
local AceEvent = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceEvent then return end |
-- Lua APIs |
local pairs = pairs |
local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0") |
AceEvent.frame = AceEvent.frame or CreateFrame("Frame", "AceEvent30Frame") -- our event frame |
AceEvent.embeds = AceEvent.embeds or {} -- what objects embed this lib |
-- APIs and registry for blizzard events, using CallbackHandler lib |
if not AceEvent.events then |
AceEvent.events = CallbackHandler:New(AceEvent, |
"RegisterEvent", "UnregisterEvent", "UnregisterAllEvents") |
end |
function AceEvent.events:OnUsed(target, eventname) |
AceEvent.frame:RegisterEvent(eventname) |
end |
function AceEvent.events:OnUnused(target, eventname) |
AceEvent.frame:UnregisterEvent(eventname) |
end |
-- APIs and registry for IPC messages, using CallbackHandler lib |
if not AceEvent.messages then |
AceEvent.messages = CallbackHandler:New(AceEvent, |
"RegisterMessage", "UnregisterMessage", "UnregisterAllMessages" |
) |
AceEvent.SendMessage = AceEvent.messages.Fire |
end |
--- embedding and embed handling |
local mixins = { |
"RegisterEvent", "UnregisterEvent", |
"RegisterMessage", "UnregisterMessage", |
"SendMessage", |
"UnregisterAllEvents", "UnregisterAllMessages", |
} |
--- Register for a Blizzard Event. |
-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied) |
-- Any arguments to the event will be passed on after that. |
-- @name AceEvent:RegisterEvent |
-- @class function |
-- @paramsig event[, callback [, arg]] |
-- @param event The event to register for |
-- @param callback The callback function to call when the event is triggered (funcref or method, defaults to a method with the event name) |
-- @param arg An optional argument to pass to the callback function |
--- Unregister an event. |
-- @name AceEvent:UnregisterEvent |
-- @class function |
-- @paramsig event |
-- @param event The event to unregister |
--- Register for a custom AceEvent-internal message. |
-- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied) |
-- Any arguments to the event will be passed on after that. |
-- @name AceEvent:RegisterMessage |
-- @class function |
-- @paramsig message[, callback [, arg]] |
-- @param message The message to register for |
-- @param callback The callback function to call when the message is triggered (funcref or method, defaults to a method with the event name) |
-- @param arg An optional argument to pass to the callback function |
--- Unregister a message |
-- @name AceEvent:UnregisterMessage |
-- @class function |
-- @paramsig message |
-- @param message The message to unregister |
--- Send a message over the AceEvent-3.0 internal message system to other addons registered for this message. |
-- @name AceEvent:SendMessage |
-- @class function |
-- @paramsig message, ... |
-- @param message The message to send |
-- @param ... Any arguments to the message |
-- Embeds AceEvent into the target object making the functions from the mixins list available on target:.. |
-- @param target target object to embed AceEvent in |
function AceEvent:Embed(target) |
for k, v in pairs(mixins) do |
target[v] = self[v] |
end |
self.embeds[target] = true |
return target |
end |
-- AceEvent:OnEmbedDisable( target ) |
-- target (object) - target object that is being disabled |
-- |
-- Unregister all events messages etc when the target disables. |
-- this method should be called by the target manually or by an addon framework |
function AceEvent:OnEmbedDisable(target) |
target:UnregisterAllEvents() |
target:UnregisterAllMessages() |
end |
-- Script to fire blizzard events into the event listeners |
local events = AceEvent.events |
AceEvent.frame:SetScript("OnEvent", function(this, event, ...) |
events:Fire(event, ...) |
end) |
--- Finally: upgrade our old embeds |
for target, v in pairs(AceEvent.embeds) do |
AceEvent:Embed(target) |
end |
<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="LibStub\LibStub.lua"/> + <Script file="CallbackHandler-1.0\CallbackHandler-1.0.lua"/> + <Include file="AceAddon-3.0\AceAddon-3.0.xml"/> + <Include file="AceEvent-3.0\AceEvent-3.0.xml"/> + <Include file="AceGUI-3.0\AceGUI-3.0.xml"/> + <Include file="AceConfig-3.0\AceConfig-3.0.xml"/> + <Include file="AceConsole-3.0\AceConsole-3.0.xml"/> + <Include file="AceDB-3.0\AceDB-3.0.xml"/> + <Include file="AceLocale-3.0\AceLocale-3.0.xml"/> + <Include file="AceDBOptions-3.0\AceDBOptions-3.0.xml"/> + <Include file="LibSharedMedia-3.0\lib.xml"/> + <Include file="AceGUI-3.0-SharedMediaWidgets\widget.xml"/> +</Ui> |
<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> |
--- **AceConsole-3.0** provides registration facilities for slash commands. |
-- You can register slash commands to your custom functions and use the `GetArgs` function to parse them |
-- to your addons individual needs. |
-- |
-- **AceConsole-3.0** can be embeded into your addon, either explicitly by calling AceConsole:Embed(MyAddon) or by |
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object |
-- and can be accessed directly, without having to explicitly call AceConsole itself.\\ |
-- It is recommended to embed AceConsole, otherwise you'll have to specify a custom `self` on all calls you |
-- make into AceConsole. |
-- @class file |
-- @name AceConsole-3.0 |
-- @release $Id: AceConsole-3.0.lua 878 2009-11-02 18:51:58Z nevcairiel $ |
local MAJOR,MINOR = "AceConsole-3.0", 7 |
local AceConsole, oldminor = LibStub:NewLibrary(MAJOR, MINOR) |
if not AceConsole then return end -- No upgrade needed |
AceConsole.embeds = AceConsole.embeds or {} -- table containing objects AceConsole is embedded in. |
AceConsole.commands = AceConsole.commands or {} -- table containing commands registered |
AceConsole.weakcommands = AceConsole.weakcommands or {} -- table containing self, command => func references for weak commands that don't persist through enable/disable |
-- Lua APIs |
local tconcat, tostring, select = table.concat, tostring, select |
local type, pairs, error = type, pairs, error |
local format, strfind, strsub = string.format, string.find, string.sub |
local max = math.max |
-- WoW APIs |
local _G = _G |
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
-- List them here for Mikk's FindGlobals script |
-- GLOBALS: DEFAULT_CHAT_FRAME, SlashCmdList, hash_SlashCmdList |
local tmp={} |
local function Print(self,frame,...) |
local n=0 |
if self ~= AceConsole then |
n=n+1 |
tmp[n] = "|cff33ff99"..tostring( self ).."|r:" |
end |
for i=1, select("#", ...) do |
n=n+1 |
tmp[n] = tostring(select(i, ...)) |
end |
frame:AddMessage( tconcat(tmp," ",1,n) ) |
end |
--- Print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function) |
-- @paramsig [chatframe ,] ... |
-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function) |
-- @param ... List of any values to be printed |
function AceConsole:Print(...) |
local frame = ... |
if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member? |
return Print(self, frame, select(2,...)) |
else |
return Print(self, DEFAULT_CHAT_FRAME, ...) |
end |
end |
--- Formatted (using format()) print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function) |
-- @paramsig [chatframe ,] "format"[, ...] |
-- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function) |
-- @param format Format string - same syntax as standard Lua format() |
-- @param ... Arguments to the format string |
function AceConsole:Printf(...) |
local frame = ... |
if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member? |
return Print(self, frame, format(select(2,...))) |
else |
return Print(self, DEFAULT_CHAT_FRAME, format(...)) |
end |
end |
--- Register a simple chat command |
-- @param command Chat command to be registered WITHOUT leading "/" |
-- @param func Function to call when the slash command is being used (funcref or methodname) |
-- @param persist if false, the command will be soft disabled/enabled when aceconsole is used as a mixin (default: true) |
function AceConsole:RegisterChatCommand( command, func, persist ) |
if type(command)~="string" then error([[Usage: AceConsole:RegisterChatCommand( "command", func[, persist ]): 'command' - expected a string]], 2) end |
if persist==nil then persist=true end -- I'd rather have my addon's "/addon enable" around if the author screws up. Having some extra slash regged when it shouldnt be isn't as destructive. True is a better default. /Mikk |
local name = "ACECONSOLE_"..command:upper() |
if type( func ) == "string" then |
SlashCmdList[name] = function(input, editBox) |
self[func](self, input, editBox) |
end |
else |
SlashCmdList[name] = func |
end |
_G["SLASH_"..name.."1"] = "/"..command:lower() |
AceConsole.commands[command] = name |
-- non-persisting commands are registered for enabling disabling |
if not persist then |
if not AceConsole.weakcommands[self] then AceConsole.weakcommands[self] = {} end |
AceConsole.weakcommands[self][command] = func |
end |
return true |
end |
--- Unregister a chatcommand |
-- @param command Chat command to be unregistered WITHOUT leading "/" |
function AceConsole:UnregisterChatCommand( command ) |
local name = AceConsole.commands[command] |
if name then |
SlashCmdList[name] = nil |
_G["SLASH_" .. name .. "1"] = nil |
hash_SlashCmdList["/" .. command:upper()] = nil |
AceConsole.commands[command] = nil |
end |
end |
--- Get an iterator over all Chat Commands registered with AceConsole |
-- @return Iterator (pairs) over all commands |
function AceConsole:IterateChatCommands() return pairs(AceConsole.commands) end |
local function nils(n, ...) |
if n>1 then |
return nil, nils(n-1, ...) |
elseif n==1 then |
return nil, ... |
else |
return ... |
end |
end |
--- Retreive one or more space-separated arguments from a string. |
-- Treats quoted strings and itemlinks as non-spaced. |
-- @param string The raw argument string |
-- @param numargs How many arguments to get (default 1) |
-- @param startpos Where in the string to start scanning (default 1) |
-- @return Returns arg1, arg2, ..., nextposition\\ |
-- Missing arguments will be returned as nils. 'nextposition' is returned as 1e9 at the end of the string. |
function AceConsole:GetArgs(str, numargs, startpos) |
numargs = numargs or 1 |
startpos = max(startpos or 1, 1) |
local pos=startpos |
-- find start of new arg |
pos = strfind(str, "[^ ]", pos) |
if not pos then -- whoops, end of string |
return nils(numargs, 1e9) |
end |
if numargs<1 then |
return pos |
end |
-- quoted or space separated? find out which pattern to use |
local delim_or_pipe |
local ch = strsub(str, pos, pos) |
if ch=='"' then |
pos = pos + 1 |
delim_or_pipe='([|"])' |
elseif ch=="'" then |
pos = pos + 1 |
delim_or_pipe="([|'])" |
else |
delim_or_pipe="([| ])" |
end |
startpos = pos |
while true do |
-- find delimiter or hyperlink |
local ch,_ |
pos,_,ch = strfind(str, delim_or_pipe, pos) |
if not pos then break end |
if ch=="|" then |
-- some kind of escape |
if strsub(str,pos,pos+1)=="|H" then |
-- It's a |H....|hhyper link!|h |
pos=strfind(str, "|h", pos+2) -- first |h |
if not pos then break end |
pos=strfind(str, "|h", pos+2) -- second |h |
if not pos then break end |
elseif strsub(str,pos, pos+1) == "|T" then |
-- It's a |T....|t texture |
pos=strfind(str, "|t", pos+2) |
if not pos then break end |
end |
pos=pos+2 -- skip past this escape (last |h if it was a hyperlink) |
else |
-- found delimiter, done with this arg |
return strsub(str, startpos, pos-1), AceConsole:GetArgs(str, numargs-1, pos+1) |
end |
end |
-- search aborted, we hit end of string. return it all as one argument. (yes, even if it's an unterminated quote or hyperlink) |
return strsub(str, startpos), nils(numargs-1, 1e9) |
end |
--- embedding and embed handling |
local mixins = { |
"Print", |
"Printf", |
"RegisterChatCommand", |
"UnregisterChatCommand", |
"GetArgs", |
} |
-- Embeds AceConsole into the target object making the functions from the mixins list available on target:.. |
-- @param target target object to embed AceBucket in |
function AceConsole:Embed( target ) |
for k, v in pairs( mixins ) do |
target[v] = self[v] |
end |
self.embeds[target] = true |
return target |
end |
function AceConsole:OnEmbedEnable( target ) |
if AceConsole.weakcommands[target] then |
for command, func in pairs( AceConsole.weakcommands[target] ) do |
target:RegisterChatCommand( command, func, false, true ) -- nonpersisting and silent registry |
end |
end |
end |
function AceConsole:OnEmbedDisable( target ) |
if AceConsole.weakcommands[target] then |
for command, func in pairs( AceConsole.weakcommands[target] ) do |
target:UnregisterChatCommand( command ) -- TODO: this could potentially unregister a command from another application in case of command conflicts. Do we care? |
end |
end |
end |
for addon in pairs(AceConsole.embeds) do |
AceConsole:Embed(addon) |
end |