mikx
/
ElvUI_OptionsUI
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

initial commit

This commit is contained in:
Gitea 2020-11-13 14:29:13 -05:00
commit 02d25b5ac1
74 changed files with 49574 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

478
ActionBars.lua Normal file
View File

@ -0,0 +1,478 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local AB = E:GetModule('ActionBars')
local ACH = E.Libs.ACH
local _G = _G
local pairs = pairs
local format = format
local SetCVar = SetCVar
local GameTooltip = _G.GameTooltip
-- GLOBALS: NUM_ACTIONBAR_BUTTONS, NUM_PET_ACTION_SLOTS, LOCK_ACTIONBAR, MICRO_BUTTONS, AceGUIWidgetLSMlists
local SharedBarOptions = {
enabled = ACH:Toggle(L["Enable"], nil, 0),
restorePosition = ACH:Execute(L["Restore Bar"], L["Restore the actionbars default settings"], 1),
generalOptions = ACH:MultiSelect('', nil, 3, { backdrop = L["Backdrop"], mouseover = L["Mouse Over"], clickThrough = L["Click Through"], inheritGlobalFade = L["Inherit Global Fade"] }),
barGroup = ACH:Group(L["Bar Settings"], nil, 4),
buttonGroup = ACH:Group(L["Button Settings"], nil, 5),
backdropGroup = ACH:Group(L["Backdrop Settings"], nil, 6),
visibility = ACH:Input(L["Visibility State"], L["This works like a macro, you can run different situations to get the actionbar to show/hide differently.\n Example: '[combat] show;hide'"], 8, 4, 'full')
}
SharedBarOptions.barGroup.inline = true
SharedBarOptions.barGroup.args.point = ACH:Select(L["Anchor Point"], L["The first button anchors itself to this point on the bar."], 1, { TOPLEFT = 'TOPLEFT', TOPRIGHT = 'TOPRIGHT', BOTTOMLEFT = 'BOTTOMLEFT', BOTTOMRIGHT = 'BOTTOMRIGHT' })
SharedBarOptions.barGroup.args.alpha = ACH:Range(L["Alpha"], nil, 3, { min = 0, max = 1, step = 0.01, isPercent = true })
SharedBarOptions.barGroup.args.spacer1 = ACH:Spacer(19, 'full')
SharedBarOptions.barGroup.args.countFont = ACH:SharedMediaFont(L["Font"], nil, 21)
SharedBarOptions.barGroup.args.countFontOutline = ACH:FontFlags(L["Font Outline"], nil, 21)
SharedBarOptions.barGroup.args.countFontSize = ACH:Range(L["Font Size"], nil, 21, C.Values.FontSize)
SharedBarOptions.barGroup.args.countTextPosition = ACH:Select(L["Text Anchor"], nil, 21, { TOPLEFT = 'TOPLEFT', TOPRIGHT = 'TOPRIGHT', BOTTOMLEFT = 'BOTTOMLEFT', BOTTOMRIGHT = 'BOTTOMRIGHT' })
SharedBarOptions.barGroup.args.countTextXOffset = ACH:Range(L["X-Offset"], nil, 21, { min = -10, max = 10, step = 1 })
SharedBarOptions.barGroup.args.countTextYOffset = ACH:Range(L["Y-Offset"], nil, 21, { min = -10, max = 10, step = 1 })
SharedBarOptions.barGroup.args.customCountFont = ACH:Toggle(L["Custom Count Font"], nil, 20)
SharedBarOptions.barGroup.args.spacer2 = ACH:Spacer(22, 'full')
SharedBarOptions.barGroup.args.customHotkeyFont = ACH:Toggle(L["Custom Keybind Font"], nil, 23)
SharedBarOptions.barGroup.args.hotkeyFont = ACH:SharedMediaFont(L["Font"], nil, 24)
SharedBarOptions.barGroup.args.hotkeyFontOutline = ACH:FontFlags(L["Font Outline"], nil, 24)
SharedBarOptions.barGroup.args.hotkeyFontSize = ACH:Range(L["Font Size"], nil, 24, C.Values.FontSize)
SharedBarOptions.barGroup.args.hotkeyTextPosition = ACH:Select(L["Text Anchor"], nil, 24, { TOPLEFT = 'TOPLEFT', TOPRIGHT = 'TOPRIGHT', BOTTOMLEFT = 'BOTTOMLEFT', BOTTOMRIGHT = 'BOTTOMRIGHT' })
SharedBarOptions.barGroup.args.hotkeyTextXOffset = ACH:Range(L["X-Offset"], nil, 24, { min = -10, max = 10, step = 1 })
SharedBarOptions.barGroup.args.hotkeyTextYOffset = ACH:Range(L["Y-Offset"], nil, 24, { min = -10, max = 10, step = 1 })
SharedBarOptions.buttonGroup.inline = true
SharedBarOptions.buttonGroup.args.buttons = ACH:Range(L["Buttons"], L["The amount of buttons to display."], 1, { min = 1, max = NUM_ACTIONBAR_BUTTONS, step = 1 })
SharedBarOptions.buttonGroup.args.buttonsPerRow = ACH:Range(L["Buttons Per Row"], L["The amount of buttons to display per row."], 2, { min = 1, max = NUM_ACTIONBAR_BUTTONS, step = 1 })
SharedBarOptions.buttonGroup.args.buttonspacing = ACH:Range(L["Button Spacing"], L["The spacing between buttons."], 3, { min = -3, max = 20, step = 1 })
SharedBarOptions.buttonGroup.args.buttonsize = ACH:Range('', nil, 4, { softMin = 14, softMax = 64, min = 12, max = 128, step = 1 })
SharedBarOptions.buttonGroup.args.buttonHeight = ACH:Range(L["Button Height"], L["The height of the action buttons."], 5, { softMin = 14, softMax = 64, min = 12, max = 128, step = 1 })
SharedBarOptions.backdropGroup.inline = true
SharedBarOptions.backdropGroup.args.backdropSpacing = ACH:Range(L["Backdrop Spacing"], L["The spacing between the backdrop and the buttons."], 1, { min = 0, max = 10, step = 1 })
SharedBarOptions.backdropGroup.args.heightMult = ACH:Range(L["Height Multiplier"], L["Multiply the backdrops height or width by this value. This is usefull if you wish to have more than one bar behind a backdrop."], 2, { min = 1, max = 5, step = 1 })
SharedBarOptions.backdropGroup.args.widthMult = ACH:Range(L["Width Multiplier"], L["Multiply the backdrops height or width by this value. This is usefull if you wish to have more than one bar behind a backdrop."], 2, { min = 1, max = 5, step = 1 })
-- Start ActionBar Config
E.Options.args.actionbar = ACH:Group(L["ActionBars"], nil, 2, 'tab', function(info) return E.db.actionbar[info[#info]] end, function(info, value) E.db.actionbar[info[#info]] = value; AB:UpdateButtonSettings() end)
E.Options.args.actionbar.args.intro = ACH:Description(L["ACTIONBARS_DESC"], 0)
E.Options.args.actionbar.args.enable = ACH:Toggle(L["Enable"], nil, 1, nil, nil, nil, function(info) return E.private.actionbar[info[#info]] end, function(info, value) E.private.actionbar[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL') end)
E.Options.args.actionbar.args.general = {
order = 3,
type = 'group',
name = L["General"],
disabled = function() return not E.ActionBars.Initialized; end,
args = {
toggleKeybind = {
order = 0,
type = 'execute',
name = L["Keybind Mode"],
func = function() AB:ActivateBindMode(); E:ToggleOptionsUI(); GameTooltip:Hide(); end,
},
movementModifier = {
order = 1,
type = 'select',
name = L["PICKUP_ACTION_KEY_TEXT"],
desc = L["The button you must hold down in order to drag an ability to another action button."],
hidden = function() return not E.db.actionbar.lockActionBars end,
values = {
NONE = L["NONE"],
SHIFT = L["SHIFT_KEY_TEXT"],
ALT = L["ALT_KEY_TEXT"],
CTRL = L["CTRL_KEY_TEXT"],
},
},
flyoutSize = {
order = 2,
type = 'range',
name = L["Flyout Button Size"],
min = 15, max = 60, step = 1,
},
globalFadeAlpha = {
order = 3,
type = 'range',
name = L["Global Fade Transparency"],
desc = L["Transparency level when not in combat, no target exists, full health, not casting, and no focus target exists."],
min = 0, max = 1, step = 0.01,
isPercent = true,
set = function(info, value) E.db.actionbar[info[#info]] = value; AB.fadeParent:SetAlpha(1-value) end,
},
generalGroup = {
order = 20,
type = 'group',
name = L["General"],
inline = true,
get = function(info) return E.db.actionbar[info[#info]] end,
set = function(info, value) E.db.actionbar[info[#info]] = value; AB:UpdateButtonSettings() end,
args = {
keyDown = {
order = 13,
type = 'toggle',
name = L["Key Down"],
desc = L["OPTION_TOOLTIP_ACTION_BUTTON_USE_KEY_DOWN"],
},
lockActionBars = {
order = 14,
type = 'toggle',
name = L["LOCK_ACTIONBAR_TEXT"],
desc = L["If you unlock actionbars then trying to move a spell might instantly cast it if you cast spells on key press instead of key release."],
set = function(info, value)
E.db.actionbar[info[#info]] = value;
AB:UpdateButtonSettings()
--Make it work for PetBar too
SetCVar('lockActionBars', (value == true and 1 or 0))
LOCK_ACTIONBAR = (value == true and '1' or '0')
end,
},
hideCooldownBling = {
order = 15,
type = 'toggle',
name = L["Hide Cooldown Bling"],
desc = L["Hides the bling animation on buttons at the end of the global cooldown."],
get = function() return E.db.actionbar.hideCooldownBling end,
set = function(_, value) E.db.actionbar.hideCooldownBling = value;
for _, bar in pairs(AB.handledBars) do
AB:UpdateButtonConfig(bar, bar.bindButtons)
end
AB:UpdatePetCooldownSettings()
end,
},
addNewSpells = {
order = 16,
type = 'toggle',
name = L["Auto Add New Spells"],
desc = L["Allow newly learned spells to be automatically placed on an empty actionbar slot."],
set = function(_, value) E.db.actionbar.addNewSpells = value; AB:IconIntroTracker_Toggle() end,
},
rightClickSelfCast = {
order = 17,
type = 'toggle',
name = L["RightClick Self-Cast"],
set = function(_, value)
E.db.actionbar.rightClickSelfCast = value;
for _, bar in pairs(AB.handledBars) do
AB:UpdateButtonConfig(bar, bar.bindButtons)
end
end,
},
useDrawSwipeOnCharges = {
order = 18,
type = 'toggle',
name = L["Charge Draw Swipe"],
desc = L["Shows a swipe animation when a spell is recharging but still has charges left."],
get = function() return E.db.actionbar.useDrawSwipeOnCharges end,
set = function(_, value)
E.db.actionbar.useDrawSwipeOnCharges = value;
for _, bar in pairs(AB.handledBars) do
AB:UpdateButtonConfig(bar, bar.bindButtons)
end
end,
},
chargeCooldown = {
order = 19,
type = 'toggle',
name = L["Charge Cooldown Text"],
set = function(_, value)
E.db.actionbar.chargeCooldown = value;
AB:ToggleCooldownOptions()
end,
},
desaturateOnCooldown = {
order = 20,
type = 'toggle',
name = L["Desaturate Cooldowns"],
set = function(_, value)
E.db.actionbar.desaturateOnCooldown = value;
AB:ToggleCooldownOptions()
end,
},
transparent = {
order = 21,
type = 'toggle',
name = L["Transparent"],
set = function(_, value)
E.db.actionbar.transparent = value
E:StaticPopup_Show('PRIVATE_RL')
end,
},
flashAnimation = {
order = 22,
type = 'toggle',
name = L["Button Flash"],
desc = L["Use a more visible flash animation for Auto Attacks."],
set = function(_, value)
E.db.actionbar.flashAnimation = value
E:StaticPopup_Show('PRIVATE_RL')
end,
},
equippedItem = {
order = 23,
type = 'toggle',
name = L["Equipped Item"],
},
macrotext = {
order = 24,
type = 'toggle',
name = L["Macro Text"],
desc = L["Display macro names on action buttons."],
},
hotkeytext = {
order = 25,
type = 'toggle',
name = L["Keybind Text"],
desc = L["Display bind names on action buttons."],
},
useRangeColorText = {
order = 26,
type = 'toggle',
name = L["Color Keybind Text"],
desc = L["Color Keybind Text when Out of Range, instead of the button."],
},
handleOverlay = {
order = 27,
type = 'toggle',
name = L["Action Button Glow"],
},
}
},
textGroup = {
type = 'group',
order = 50,
name = L["Text Position"],
disabled = function() return (E.Masque and E.private.actionbar.masque.actionbars) end,
inline = true,
args = {
countTextPosition = {
type = 'select',
order = 1,
name = L["Stack Text Position"],
values = {
BOTTOMRIGHT = 'BOTTOMRIGHT',
BOTTOMLEFT = 'BOTTOMLEFT',
TOPRIGHT = 'TOPRIGHT',
TOPLEFT = 'TOPLEFT',
BOTTOM = 'BOTTOM',
TOP = 'TOP',
},
},
countTextXOffset = {
type = 'range',
order = 2,
name = L["Stack Text X-Offset"],
min = -10, max = 10, step = 1,
},
countTextYOffset = {
type = 'range',
order = 3,
name = L["Stack Text Y-Offset"],
min = -10, max = 10, step = 1,
},
hotkeyTextPosition = {
type = 'select',
order = 4,
name = L["Keybind Text Position"],
values = {
BOTTOMRIGHT = 'BOTTOMRIGHT',
BOTTOMLEFT = 'BOTTOMLEFT',
TOPRIGHT = 'TOPRIGHT',
TOPLEFT = 'TOPLEFT',
BOTTOM = 'BOTTOM',
TOP = 'TOP',
},
},
hotkeyTextXOffset = {
type = 'range',
order = 5,
name = L["Keybind Text X-Offset"],
min = -10, max = 10, step = 1,
},
hotkeyTextYOffset = {
type = 'range',
order = 6,
name = L["Keybind Text Y-Offset"],
min = -10, max = 10, step = 1,
},
},
},
},
}
E.Options.args.actionbar.args.general.args.colorGroup = ACH:Group(L["COLORS"], nil, 30, nil, function(info) local t = E.db.actionbar[info[#info]] local d = P.actionbar[info[#info]] return t.r, t.g, t.b, t.a, d.r, d.g, d.b, d.a end, function(info, r, g, b, a) local t = E.db.actionbar[info[#info]] t.r, t.g, t.b, t.a = r, g, b, a AB:UpdateButtonSettings() end, function() return (E.Masque and E.private.actionbar.masque.actionbars) end)
E.Options.args.actionbar.args.general.args.colorGroup.inline = true
E.Options.args.actionbar.args.general.args.colorGroup.args.fontColor = ACH:Color(L["Text"], nil, 0)
E.Options.args.actionbar.args.general.args.colorGroup.args.noRangeColor = ACH:Color(L["Out of Range"], L["Color of the actionbutton when out of range."], 1)
E.Options.args.actionbar.args.general.args.colorGroup.args.noPowerColor = ACH:Color(L["Out of Power"], L["Color of the actionbutton when out of power (Mana, Rage, Focus, Holy Power)."], 2)
E.Options.args.actionbar.args.general.args.colorGroup.args.usableColor = ACH:Color(L["Usable"], L["Color of the actionbutton when usable."], 3)
E.Options.args.actionbar.args.general.args.colorGroup.args.notUsableColor = ACH:Color(L["Not Usable"], L["Color of the actionbutton when not usable."], 4)
E.Options.args.actionbar.args.general.args.colorGroup.args.colorSwipeNormal = ACH:Color(L["Swipe: Normal"], nil, 5, true)
E.Options.args.actionbar.args.general.args.colorGroup.args.colorSwipeLOC = ACH:Color(L["Swipe: Loss of Control"], nil, 6, true)
E.Options.args.actionbar.args.general.args.colorGroup.args.equippedItemColor = ACH:Color(L["Equipped Item Color"], nil, 7)
E.Options.args.actionbar.args.general.args.fontGroup = ACH:Group(L["Fonts"], nil, 40)
E.Options.args.actionbar.args.general.args.fontGroup.inline = true
E.Options.args.actionbar.args.general.args.fontGroup.args.font = ACH:SharedMediaFont(L["Font"], nil, 1)
E.Options.args.actionbar.args.general.args.fontGroup.args.fontSize = ACH:Range(L["Font Size"], nil, 2, C.Values.FontSize)
E.Options.args.actionbar.args.general.args.fontGroup.args.fontOutline = ACH:FontFlags(L["Font Outline"], nil, 3)
E.Options.args.actionbar.args.general.args.masqueGroup = ACH:Group(L["Masque Support"], nil, -1, nil, function(info) return E.private.actionbar.masque[info[#info]] end, function(info, value) E.private.actionbar.masque[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL') end, function() return not E.Masque end)
E.Options.args.actionbar.args.general.args.masqueGroup.inline = true
E.Options.args.actionbar.args.general.args.masqueGroup.args.actionbars = ACH:Toggle(L["ActionBars"], nil, 1)
E.Options.args.actionbar.args.general.args.masqueGroup.args.petBar = ACH:Toggle(L["Pet Bar"], nil, 2)
E.Options.args.actionbar.args.general.args.masqueGroup.args.stanceBar = ACH:Toggle(L["Stance Bar"], nil, 3)
E.Options.args.actionbar.args.barPet = ACH:Group(L["Pet Bar"], nil, 14, nil, function(info) return E.db.actionbar.barPet[info[#info]] end, function(info, value) E.db.actionbar.barPet[info[#info]] = value; AB:PositionAndSizeBarPet() end, function() return not E.ActionBars.Initialized end)
E.Options.args.actionbar.args.barPet.args = CopyTable(SharedBarOptions)
E.Options.args.actionbar.args.barPet.args.restorePosition.func = function() E:CopyTable(E.db.actionbar.barPet, P.actionbar.barPet); E:ResetMovers('Pet Bar'); AB:PositionAndSizeBarPet() end
E.Options.args.actionbar.args.barPet.args.generalOptions = ACH:MultiSelect('', nil, 3, { backdrop = L["Backdrop"], mouseover = L["Mouse Over"], clickThrough = L["Click Through"], inheritGlobalFade = L["Inherit Global Fade"], keepSizeRatio = L["Keep Size Ratio"] }, nil, nil, function(_, key) return E.db.actionbar.barPet[key] end, function(_, key, value) E.db.actionbar.barPet[key] = value; AB:PositionAndSizeBarPet() end)
E.Options.args.actionbar.args.barPet.args.buttonGroup.args.buttonsize.name = function() return E.db.actionbar.barPet.keepSizeRatio and L["Button Size"] or L["Button Width"] end
E.Options.args.actionbar.args.barPet.args.buttonGroup.args.buttonsize.desc = function() return E.db.actionbar.barPet.keepSizeRatio and L["The size of the action buttons."] or L["The width of the action buttons."] end
E.Options.args.actionbar.args.barPet.args.buttonGroup.args.buttonHeight.hidden = function() return E.db.actionbar.barPet.keepSizeRatio end
E.Options.args.actionbar.args.barPet.args.buttonGroup.args.buttonsPerRow.max = NUM_PET_ACTION_SLOTS
E.Options.args.actionbar.args.barPet.args.buttonGroup.args.buttons.max = NUM_PET_ACTION_SLOTS
E.Options.args.actionbar.args.barPet.args.visibility.set = function(_, value) if value and value:match('[\n\r]') then value = value:gsub('[\n\r]','') end E.db.actionbar.barPet.visibility = value; AB:UpdateButtonSettings() end
E.Options.args.actionbar.args.barPet.args.barGroup.args.countFont.hidden = function() return not E.db.actionbar.barPet.customCountFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.countFontOutline.hidden = function() return not E.db.actionbar.barPet.customCountFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.countFontSize.hidden = function() return not E.db.actionbar.barPet.customCountFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.countTextPosition.hidden = function() return not E.db.actionbar.barPet.customCountFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.countTextXOffset.hidden = function() return not E.db.actionbar.barPet.customCountFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.countTextYOffset.hidden = function() return not E.db.actionbar.barPet.customCountFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.hotkeyFont.hidden = function() return not E.db.actionbar.barPet.customHotkeyFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.hotkeyFontOutline.hidden = function() return not E.db.actionbar.barPet.customHotkeyFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.hotkeyFontSize.hidden = function() return not E.db.actionbar.barPet.customHotkeyFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.hotkeyTextPosition.hidden = function() return not E.db.actionbar.barPet.customHotkeyFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.hotkeyTextXOffset.hidden = function() return not E.db.actionbar.barPet.customHotkeyFont end
E.Options.args.actionbar.args.barPet.args.barGroup.args.hotkeyTextYOffset.hidden = function() return not E.db.actionbar.barPet.customHotkeyFont end
E.Options.args.actionbar.args.stanceBar = ACH:Group(L["Stance Bar"], nil, 15, nil, function(info) return E.db.actionbar.stanceBar[info[#info]] end, function(info, value) E.db.actionbar.stanceBar[info[#info]] = value; AB:PositionAndSizeBarShapeShift() end, function() return not E.ActionBars.Initialized end)
E.Options.args.actionbar.args.stanceBar.args = CopyTable(SharedBarOptions)
E.Options.args.actionbar.args.stanceBar.args.restorePosition.func = function() E:CopyTable(E.db.actionbar.stanceBar, P.actionbar.stanceBar); E:ResetMovers('Stance Bar'); AB:PositionAndSizeBarShapeShift() end
E.Options.args.actionbar.args.stanceBar.args.generalOptions = ACH:MultiSelect('', nil, 3, { backdrop = L["Backdrop"], mouseover = L["Mouse Over"], clickThrough = L["Click Through"], inheritGlobalFade = L["Inherit Global Fade"], keepSizeRatio = L["Keep Size Ratio"] }, nil, nil, function(_, key) return E.db.actionbar.stanceBar[key] end, function(_, key, value) E.db.actionbar.stanceBar[key] = value; AB:PositionAndSizeBarShapeShift() end)
E.Options.args.actionbar.args.stanceBar.args.buttonGroup.args.buttonsize.name = function() return E.db.actionbar.stanceBar.keepSizeRatio and L["Button Size"] or L["Button Width"] end
E.Options.args.actionbar.args.stanceBar.args.buttonGroup.args.buttonsize.desc = function() return E.db.actionbar.stanceBar.keepSizeRatio and L["The size of the action buttons."] or L["The width of the action buttons."] end
E.Options.args.actionbar.args.stanceBar.args.buttonGroup.args.buttonHeight.hidden = function() return E.db.actionbar.stanceBar.keepSizeRatio end
E.Options.args.actionbar.args.stanceBar.args.buttonGroup.args.buttonsPerRow.max = NUM_STANCE_SLOTS
E.Options.args.actionbar.args.stanceBar.args.buttonGroup.args.buttons.max = NUM_STANCE_SLOTS
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.style = ACH:Select(L["Style"], L["This setting will be updated upon changing stances."], 12, { darkenInactive = L["Darken Inactive"], classic = L["Classic"] })
E.Options.args.actionbar.args.stanceBar.args.visibility.set = function(_, value) if value and value:match('[\n\r]') then value = value:gsub('[\n\r]','') end E.db.actionbar.stanceBar.visibility = value; AB:UpdateButtonSettings() end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.countFont.hidden = function() return not E.db.actionbar.stanceBar.customCountFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.countFontOutline.hidden = function() return not E.db.actionbar.stanceBar.customCountFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.countFontSize.hidden = function() return not E.db.actionbar.stanceBar.customCountFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.countTextPosition.hidden = function() return not E.db.actionbar.stanceBar.customCountFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.countTextXOffset.hidden = function() return not E.db.actionbar.stanceBar.customCountFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.countTextYOffset.hidden = function() return not E.db.actionbar.stanceBar.customCountFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.hotkeyFont.hidden = function() return not E.db.actionbar.stanceBar.customHotkeyFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.hotkeyFontOutline.hidden = function() return not E.db.actionbar.stanceBar.customHotkeyFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.hotkeyFontSize.hidden = function() return not E.db.actionbar.stanceBar.customHotkeyFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.hotkeyTextPosition.hidden = function() return not E.db.actionbar.stanceBar.customHotkeyFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.hotkeyTextXOffset.hidden = function() return not E.db.actionbar.stanceBar.customHotkeyFont end
E.Options.args.actionbar.args.stanceBar.args.barGroup.args.hotkeyTextYOffset.hidden = function() return not E.db.actionbar.stanceBar.customHotkeyFont end
E.Options.args.actionbar.args.microbar = ACH:Group(L["Micro Bar"], nil, 16, nil, function(info) return E.db.actionbar.microbar[info[#info]] end, function(info, value) E.db.actionbar.microbar[info[#info]] = value; AB:UpdateMicroPositionDimensions() end, function() return not E.ActionBars.Initialized end)
E.Options.args.actionbar.args.microbar.args = CopyTable(SharedBarOptions)
E.Options.args.actionbar.args.microbar.args.restorePosition.func = function() E:CopyTable(E.db.actionbar.microbar, P.actionbar.microbar); E:ResetMovers('Micro Bar'); AB:UpdateMicroPositionDimensions() end
E.Options.args.actionbar.args.microbar.args.generalOptions = ACH:MultiSelect('', nil, 3, { backdrop = L["Backdrop"], mouseover = L["Mouse Over"], keepSizeRatio = L["Keep Size Ratio"] }, nil, nil, function(_, key) return E.db.actionbar.microbar[key] end, function(_, key, value) E.db.actionbar.microbar[key] = value; AB:UpdateMicroPositionDimensions() end)
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttons = nil
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonSize = CopyTable(E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonsize)
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonsize = nil
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonSpacing = CopyTable(E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonspacing)
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonspacing = nil
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonsPerRow.max = #MICRO_BUTTONS-1
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonSize.name = function() return E.db.actionbar.microbar.keepSizeRatio and L["Button Size"] or L["Button Width"] end
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonSize.desc = function() return E.db.actionbar.microbar.keepSizeRatio and L["The size of the action buttons."] or L["The width of the action buttons."] end
E.Options.args.actionbar.args.microbar.args.buttonGroup.args.buttonHeight.hidden = function() return E.db.actionbar.microbar.keepSizeRatio end
E.Options.args.actionbar.args.microbar.args.visibility.set = function(_, value) if value and value:match('[\n\r]') then value = value:gsub('[\n\r]','') end E.db.actionbar.microbar.visibility = value; AB:UpdateMicroPositionDimensions() end
--Remove these as the microbar doesnt show either texts
E.Options.args.actionbar.args.microbar.args.barGroup.args.countFont = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.countFontOutline = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.countFontSize = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.countTextXOffset = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.countTextYOffset = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.countTextPosition = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.customCountFont = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.customHotkeyFont = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.hotkeyFont = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.hotkeyFontOutline = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.hotkeyFontSize = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.hotkeyTextPosition = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.hotkeyTextXOffset = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.hotkeyTextYOffset = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.spacer1 = nil
E.Options.args.actionbar.args.microbar.args.barGroup.args.spacer2 = nil
local SharedButtonOptions = {
alpha = ACH:Range(L["Alpha"], L["Change the alpha level of the frame."], 1, { min = 0, max = 1, step = 0.01, isPercent = true }),
scale = ACH:Range(L["Scale"], nil, 2, { min = 0.2, max = 2, step = 0.01, isPercent = true }),
inheritGlobalFade = ACH:Toggle(L["Inherit Global Fade"], nil, 3),
clean = ACH:Toggle(L["Clean Button"], nil, 4),
}
E.Options.args.actionbar.args.extraButtons = ACH:Group(L["Extra Buttons"], nil, 18, nil, nil, nil, function() return not E.ActionBars.Initialized end)
E.Options.args.actionbar.args.extraButtons.args.extraActionButton = ACH:Group(L["Boss Button"], nil, 1, nil, function(info) return E.db.actionbar.extraActionButton[info[#info]] end, function(info, value) local key = info[#info] E.db.actionbar.extraActionButton[key] = value; if key == 'inheritGlobalFade' then AB:ExtraButtons_GlobalFade() elseif key == 'scale' then AB:ExtraButtons_UpdateScale() else AB:ExtraButtons_UpdateAlpha() end end)
E.Options.args.actionbar.args.extraButtons.args.extraActionButton.inline = true
E.Options.args.actionbar.args.extraButtons.args.extraActionButton.args = CopyTable(SharedButtonOptions)
E.Options.args.actionbar.args.extraButtons.args.zoneButton = ACH:Group(L["Zone Button"], nil, 2, nil, function(info) return E.db.actionbar.zoneActionButton[info[#info]] end, function(info, value) local key = info[#info] E.db.actionbar.zoneActionButton[key] = value; if key == 'inheritGlobalFade' then AB:ExtraButtons_GlobalFade() elseif key == 'scale' then AB:ExtraButtons_UpdateScale() else AB:ExtraButtons_UpdateAlpha() end end)
E.Options.args.actionbar.args.extraButtons.args.zoneButton.inline = true
E.Options.args.actionbar.args.extraButtons.args.zoneButton.args = CopyTable(SharedButtonOptions)
E.Options.args.actionbar.args.extraButtons.args.vehicleExitButton = ACH:Group(L["Vehicle Exit"], nil, 3, nil, function(info) return E.db.actionbar.vehicleExitButton[info[#info]] end, function(info, value) E.db.actionbar.vehicleExitButton[info[#info]] = value; AB:UpdateVehicleLeave() end)
E.Options.args.actionbar.args.extraButtons.args.vehicleExitButton.inline = true
E.Options.args.actionbar.args.extraButtons.args.vehicleExitButton.args.enable = ACH:Toggle(L["Enable"], nil, 1, nil, nil, nil, nil, function(info, value) E.db.actionbar.vehicleExitButton[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL') end)
E.Options.args.actionbar.args.extraButtons.args.vehicleExitButton.args.size = ACH:Range(L["Size"], nil, 2, { min = 16, max = 50, step = 1 })
E.Options.args.actionbar.args.extraButtons.args.vehicleExitButton.args.strata = ACH:Select(L["Frame Strata"], nil, 3, { BACKGROUND = 'BACKGROUND', LOW = 'LOW', MEDIUM = 'MEDIUM', HIGH = 'HIGH' })
E.Options.args.actionbar.args.extraButtons.args.vehicleExitButton.args.level = ACH:Range(L["Frame Level"], nil, 4, { min = 1, max = 128, step = 1 })
E.Options.args.actionbar.args.playerBars = ACH:Group(L["Player Bars"], nil, 4, 'tree', nil, nil, function() return not E.ActionBars.Initialized end)
for i = 1, 10 do
local bar = ACH:Group(L["Bar "]..i, nil, i, 'group', function(info) return E.db.actionbar['bar'..i][info[#info]] end, function(info, value) E.db.actionbar['bar'..i][info[#info]] = value; AB:PositionAndSizeBar('bar'..i) end)
E.Options.args.actionbar.args.playerBars.args['bar'..i] = bar
bar.args = CopyTable(SharedBarOptions)
bar.args.enabled.set = function(info, value) E.db.actionbar['bar'..i][info[#info]] = value AB:PositionAndSizeBar('bar'..i) end
bar.args.restorePosition.set = function() E:CopyTable(E.db.actionbar['bar'..i], P.actionbar['bar'..i]) E:ResetMovers('Bar '..i) AB:PositionAndSizeBar('bar'..i) end
bar.args.generalOptions.get = function(_, key) return E.db.actionbar['bar'..i][key] end
bar.args.generalOptions.set = function(_, key, value) E.db.actionbar['bar'..i][key] = value AB:PositionAndSizeBar('bar'..i) AB:UpdateButtonSettingsForBar('bar'..i) end
bar.args.generalOptions.values.showGrid = L["Show Empty Buttons"]
bar.args.generalOptions.values.keepSizeRatio = L["Keep Size Ratio"]
bar.args.barGroup.args.flyoutDirection = ACH:Select(L["Flyout Direction"], nil, 2, { UP = L["Up"], DOWN = L["Down"], LEFT = L["Left"], RIGHT = L["Right"], AUTOMATIC = L["Automatic"] }, nil, nil, nil, function(info, value) E.db.actionbar['bar'..i][info[#info]] = value AB:PositionAndSizeBar('bar'..i) AB:UpdateButtonSettingsForBar('bar'..i) end)
bar.args.buttonGroup.args.buttonsize.name = function() return E.db.actionbar['bar'..i].keepSizeRatio and L["Button Size"] or L["Button Width"] end
bar.args.buttonGroup.args.buttonsize.desc = function() return E.db.actionbar['bar'..i].keepSizeRatio and L["The size of the action buttons."] or L["The width of the action buttons."] end
bar.args.buttonGroup.args.buttonHeight.hidden = function() return E.db.actionbar['bar'..i].keepSizeRatio end
bar.args.backdropGroup.hidden = function() return not E.db.actionbar['bar'..i].backdrop end
bar.args.paging = ACH:Input(L["Action Paging"], L["This works like a macro, you can run different situations to get the actionbar to page differently.\n Example: '[combat] 2;'"], 7, 4, 'full', function() return E.db.actionbar['bar'..i].paging[E.myclass] end, function(_, value) if value and value:match('[\n\r]') then value = value:gsub('[\n\r]','') end E.db.actionbar['bar'..i].paging[E.myclass] = value AB:UpdateButtonSettings() end)
bar.args.visibility.set = function(_, value) if value and value:match('[\n\r]') then value = value:gsub('[\n\r]','') end E.db.actionbar['bar'..i].visibility = value AB:UpdateButtonSettings() end
bar.args.barGroup.args.countFont.hidden = function() return not E.db.actionbar['bar'..i].customCountFont end
bar.args.barGroup.args.countFontOutline.hidden = function() return not E.db.actionbar['bar'..i].customCountFont end
bar.args.barGroup.args.countFontSize.hidden = function() return not E.db.actionbar['bar'..i].customCountFont end
bar.args.barGroup.args.countTextXOffset.hidden = function() return not E.db.actionbar['bar'..i].customCountFont end
bar.args.barGroup.args.countTextYOffset.hidden = function() return not E.db.actionbar['bar'..i].customCountFont end
bar.args.barGroup.args.countTextPosition.hidden = function() return not E.db.actionbar['bar'..i].customCountFont end
bar.args.barGroup.args.hotkeyFont.hidden = function() return not E.db.actionbar['bar'..i].customHotkeyFont end
bar.args.barGroup.args.hotkeyFontOutline.hidden = function() return not E.db.actionbar['bar'..i].customHotkeyFont end
bar.args.barGroup.args.hotkeyFontSize.hidden = function() return not E.db.actionbar['bar'..i].customHotkeyFont end
bar.args.barGroup.args.hotkeyTextPosition.hidden = function() return not E.db.actionbar['bar'..i].customHotkeyFont end
bar.args.barGroup.args.hotkeyTextXOffset.hidden = function() return not E.db.actionbar['bar'..i].customHotkeyFont end
bar.args.barGroup.args.hotkeyTextYOffset.hidden = function() return not E.db.actionbar['bar'..i].customHotkeyFont end
if (E.myclass == 'DRUID' and i >= 7 or E.myclass == 'ROGUE' and i == 7) then
bar.args.enabled.confirm = function() return format(L["Bar %s is used for stance or forms.|N You will have to adjust paging to use this bar.|N Are you sure?"], i) end
end
end
E.Options.args.actionbar.args.playerBars.args.bar1.args.pagingReset = ACH:Execute(L["Reset Action Paging"], nil, 2, function() E.db.actionbar.bar1.paging[E.myclass] = P.actionbar.bar1.paging[E.myclass] AB:UpdateButtonSettings() end, nil, L["You are about to reset paging. Are you sure?"])
E.Options.args.actionbar.args.playerBars.args.bar6.args.enabled.set = function(_, value) E.db.actionbar.bar6.enabled = value; AB:PositionAndSizeBar('bar6') AB:UpdateBar1Paging() AB:PositionAndSizeBar('bar1') end

76
Auras.lua Normal file
View File

@ -0,0 +1,76 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local A = E:GetModule('Auras')
local ACH = E.Libs.ACH
E.Options.args.auras = ACH:Group(L["BUFFOPTIONS_LABEL"], nil, 2, 'tab', function(info) return E.private.auras[info[#info]] end, function(info, value) E.private.auras[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL') end)
E.Options.args.auras.args.intro = ACH:Description(L["AURAS_DESC"], 0)
E.Options.args.auras.args.enable = ACH:Toggle(L["Enable"], nil, 1)
E.Options.args.auras.args.disableBlizzard = ACH:Toggle(L["Disabled Blizzard"], nil, 2)
E.Options.args.auras.args.buffsHeader = ACH:Toggle(L["Buffs"], nil, 3)
E.Options.args.auras.args.debuffsHeader = ACH:Toggle(L["Debuffs"], nil, 4)
E.Options.args.auras.args.masque = ACH:MultiSelect(L["Masque Support"], nil, 10, { buffs = L["Buffs"], debuffs = L["Debuffs"] }, nil, nil, function(_, key) return E.private.auras.masque[key] end, function(_, key, value) E.private.auras.masque[key] = value; E:StaticPopup_Show('PRIVATE_RL') end, function() return not E.Masque or not E.private.auras.enable end)
local SharedOptions = {
general = ACH:Group(L["General"], nil, 1, nil),
size = ACH:Range(L["Size"], L["Set the size of the individual auras."], 2, { min = 16, max = 60, step = 2 }),
growthDirection = ACH:Select(L["Growth Direction"], L["The direction the auras will grow and then the direction they will grow after they reach the wrap after limit."], 4, C.Values.GrowthDirection),
wrapAfter = ACH:Range(L["Wrap After"], L["Begin a new row or column after this many auras."], 5, { min = 1, max = 32, step = 1 }),
maxWraps = ACH:Range(L["Max Wraps"], L["Limit the number of rows or columns."], 6, { min = 1, max = 32, step = 1 }),
horizontalSpacing = ACH:Range(L["Horizontal Spacing"], nil, 7, { min = 0, max = 50, step = 1 }),
verticalSpacing = ACH:Range(L["Vertical Spacing"], nil, 8, { min = 0, max = 50, step = 1 }),
sortMethod = ACH:Select(L["Sort Method"], L["Defines how the group is sorted."], 9, { INDEX = L["Index"], TIME = L["Time"], NAME = L["Name"] }),
sortDir = ACH:Select(L["Sort Direction"], L["Defines the sort order of the selected sort method."], 10, { ['+'] = L["Ascending"], ['-'] = L["Descending"] }),
seperateOwn = ACH:Select(L["Seperate"], L["Indicate whether buffs you cast yourself should be separated before or after."], 11, { [-1] = L["Other's First"], [0] = L["No Sorting"], [1] = L["Your Auras First"] }),
statusBar = ACH:Group(L["Statusbar"], nil, -3),
timeGroup = ACH:Group(L['Time'], nil, -2),
countGroup = ACH:Group(L['Count'], nil, -1),
}
SharedOptions.general.inline = true
SharedOptions.general.args.fadeThreshold = ACH:Range(L["Fade Threshold"], L["Threshold before the icon will fade out and back in. Set to -1 to disable."], 1, { min = -1, max = 30, step = 1 })
SharedOptions.general.args.showDuration = ACH:Toggle(L["Duration Enable"], nil, 3)
SharedOptions.timeGroup.inline = true
SharedOptions.timeGroup.args.timeFont = ACH:SharedMediaFont(L["Font"], nil, 1)
SharedOptions.timeGroup.args.timeFontOutline = ACH:FontFlags(L["Font Outline"], L["Set the font outline."], 2)
SharedOptions.timeGroup.args.timeFontSize = ACH:Range(L["Font Size"], nil, 3, C.Values.FontSize)
SharedOptions.timeGroup.args.timeXOffset = ACH:Range(L["X-Offset"], nil, 4, { min = -60, max = 60, step = 1 })
SharedOptions.timeGroup.args.timeYOffset = ACH:Range(L["Y-Offset"], nil, 5, { min = -60, max = 60, step = 1 })
SharedOptions.countGroup.inline = true
SharedOptions.countGroup.args.countFont = ACH:SharedMediaFont(L["Font"], nil, 1)
SharedOptions.countGroup.args.countFontOutline = ACH:FontFlags(L["Font Outline"], L["Set the font outline."], 2)
SharedOptions.countGroup.args.countFontSize = ACH:Range(L["Font Size"], nil, 3, C.Values.FontSize)
SharedOptions.countGroup.args.countXOffset = ACH:Range(L["X-Offset"], nil, 4, { min = -60, max = 60, step = 1 })
SharedOptions.countGroup.args.countYOffset = ACH:Range(L["Y-Offset"], nil, 5, { min = -60, max = 60, step = 1 })
SharedOptions.statusBar.inline = true
SharedOptions.statusBar.args.barShow = ACH:Toggle(L["Enable"], nil, 1, nil, nil, nil, nil, nil, false)
SharedOptions.statusBar.args.barNoDuration = ACH:Toggle(L["No Duration"], nil, 2)
SharedOptions.statusBar.args.barTexture = ACH:SharedMediaStatusbar(L["Texture"], nil, 3)
SharedOptions.statusBar.args.barColor = ACH:Color(L.COLOR, nil, 4, true)
SharedOptions.statusBar.args.barColorGradient = ACH:Toggle(L["Color by Value"], nil, 5)
SharedOptions.statusBar.args.barPosition = ACH:Select(L["Position"], nil, 6, { TOP = L["Top"], BOTTOM = L["Bottom"], LEFT = L["Left"], RIGHT = L["Right"] })
SharedOptions.statusBar.args.barSize = ACH:Range(L["Size"], nil, 7, { min = 1, max = 10, step = 1 })
SharedOptions.statusBar.args.barSpacing = ACH:Range(L["Spacing"], nil, 8, { min = -10, max = 10, step = 1 })
E.Options.args.auras.args.buffs = ACH:Group(L["Buffs"], nil, 2, nil, function(info) return E.db.auras.buffs[info[#info]] end, function(info, value) E.db.auras.buffs[info[#info]] = value; A:UpdateHeader(A.BuffFrame) end, function() return not E.private.auras.buffsHeader end)
E.Options.args.auras.args.buffs.args = CopyTable(SharedOptions)
E.Options.args.auras.args.buffs.args.general.get = function(info) return E.db.auras.buffs[info[#info]] end
E.Options.args.auras.args.buffs.args.general.set = function(info, value) E.db.auras.buffs[info[#info]] = value; A:UpdateHeader(A.BuffFrame) end
E.Options.args.auras.args.buffs.args.statusBar.disabled = function() return not E.db.auras.buffs.barShow end
E.Options.args.auras.args.buffs.args.statusBar.args.barColor.get = function() local t = E.db.auras.buffs.barColor local d = P.auras.buffs.barColor return t.r, t.g, t.b, t.a, d.r, d.g, d.b, d.a end
E.Options.args.auras.args.buffs.args.statusBar.args.barColor.set = function(_, r, g, b) local t = E.db.auras.buffs.barColor t.r, t.g, t.b = r, g, b end
E.Options.args.auras.args.buffs.args.statusBar.args.barColor.disabled = function() return not E.db.auras.buffs.barShow or (E.db.auras.buffs.barColorGradient or not E.db.auras.buffs.barShow) end
E.Options.args.auras.args.debuffs = ACH:Group(L["Debuffs"], nil, 3, nil, function(info) return E.db.auras.debuffs[info[#info]] end, function(info, value) E.db.auras.debuffs[info[#info]] = value; A:UpdateHeader(A.DebuffFrame) end, function() return not E.private.auras.debuffsHeader end)
E.Options.args.auras.args.debuffs.args = CopyTable(SharedOptions)
E.Options.args.auras.args.debuffs.args.general.get = function(info) return E.db.auras.debuffs[info[#info]] end
E.Options.args.auras.args.debuffs.args.general.set = function(info, value) E.db.auras.debuffs[info[#info]] = value; A:UpdateHeader(A.DebuffFrame) end
E.Options.args.auras.args.debuffs.args.statusBar.disabled = function() return not E.db.auras.debuffs.barShow end
E.Options.args.auras.args.debuffs.args.statusBar.args.barColor.get = function() local t = E.db.auras.debuffs.barColor local d = P.auras.debuffs.barColor return t.r, t.g, t.b, t.a, d.r, d.g, d.b, d.a end
E.Options.args.auras.args.debuffs.args.statusBar.args.barColor.set = function(_, r, g, b) local t = E.db.auras.debuffs.barColor t.r, t.g, t.b = r, g, b end
E.Options.args.auras.args.debuffs.args.statusBar.args.barColor.disabled = function() return not E.db.auras.debuffs.barShow or (E.db.auras.debuffs.barColorGradient or not E.db.auras.debuffs.barShow) end

777
Bags.lua Normal file
View File

@ -0,0 +1,777 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local B = E:GetModule('Bags')
local ACH = E.Libs.ACH
local _G = _G
local gsub = gsub
local strmatch = strmatch
local SetInsertItemsLeftToRight = SetInsertItemsLeftToRight
local GameTooltip = _G.GameTooltip
E.Options.args.bags = {
type = 'group',
name = L["BAGSLOT"],
childGroups = 'tab',
order = 2,
get = function(info) return E.db.bags[info[#info]] end,
set = function(info, value) E.db.bags[info[#info]] = value end,
args = {
intro = ACH:Description(L["BAGS_DESC"], 1),
enable = {
order = 2,
type = 'toggle',
name = L["Enable"],
desc = L["Enable/Disable the all-in-one bag."],
get = function() return E.private.bags.enable end,
set = function(_, value) E.private.bags.enable = value; E:StaticPopup_Show('PRIVATE_RL') end
},
general = {
order = 3,
type = 'group',
name = L["General"],
disabled = function() return not E.Bags.Initialized end,
args = {
currencyFormat = {
order = 1,
type = 'select',
name = L["Currency Format"],
desc = L["The display format of the currency icons that get displayed below the main bag. (You have to be watching a currency for this to display)"],
values = {
ICON = L["Icons Only"],
ICON_TEXT = L["Icons and Text"],
ICON_TEXT_ABBR = L["Icons and Text (Short)"],
},
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateTokens(); end,
},
moneyFormat = {
order = 2,
type = 'select',
name = L["Money Format"],
desc = L["The display format of the money text that is shown at the top of the main bag."],
values = {
SMART = L["Smart"],
FULL = L["Full"],
SHORT = L["SHORT"],
SHORTINT = L["Short (Whole Numbers)"],
CONDENSED = L["Condensed"],
BLIZZARD = L["Blizzard Style"],
BLIZZARD2 = L["Blizzard Style"]..' 2',
},
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateGoldText(); end,
},
strata = {
order = 3,
type = 'select',
name = L["Frame Strata"],
set = function(info, value) E.db.bags[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL') end,
values = {
BACKGROUND = 'BACKGROUND',
LOW = 'LOW',
MEDIUM = 'MEDIUM',
HIGH = 'HIGH',
},
},
spacer = ACH:Spacer(4, 'full'),
moneyCoins = {
order = 10,
type = 'toggle',
name = L["Show Coins"],
desc = L["Use coin icons instead of colored text."],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateGoldText(); end,
},
transparent = {
order = 11,
type = 'toggle',
name = L["Transparent Buttons"],
set = function(info, value) E.db.bags[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL'); end,
},
junkIcon = {
order = 12,
type = 'toggle',
name = L["Show Junk Icon"],
desc = L["Display the junk icon on all grey items that can be vendored."],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
junkDesaturate = {
order = 13,
type = 'toggle',
name = L["Desaturate Junk Items"],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
upgradeIcon = {
order = 14,
type = 'toggle',
name = L["Show Upgrade Icon"],
desc = L["Display the upgrade icon on items that WoW considers an upgrade for your character."],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
scrapIcon = {
order = 15,
type = 'toggle',
name = L["Show Scrap Icon"],
desc = L["Display the scrap icon on items that can be scrapped."],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
newItemGlow = {
order = 16,
type = 'toggle',
name = L["Show New Item Glow"],
desc = L["Display the New Item Glow"],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
showAssignedColor = {
order = 17,
type = 'toggle',
name = L["Show Assigned Color"],
desc = L["Colors the border according to the type of items assigned to the bag."],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
showAssignedIcon = {
order = 18,
type = 'toggle',
name = L["Show Assigned Icon"],
set = function(info, value) E.db.bags[info[#info]] = value; B:Layout(); B:SizeAndPositionBagBar() end,
},
qualityColors = {
order = 19,
type = 'toggle',
name = L["Show Quality Color"],
desc = L["Colors the border according to the Quality of the Item."],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
specialtyColors = {
order = 20,
type = 'toggle',
name = L["Show Special Bags Color"],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
showBindType = {
order = 21,
type = 'toggle',
name = L["Show Bind on Equip/Use Text"],
set = function(info, value) E.db.bags[info[#info]] = value; B:UpdateAllBagSlots(); end,
},
clearSearchOnClose = {
order = 22,
type = 'toggle',
name = L["Clear Search On Close"],
set = function(info, value) E.db.bags[info[#info]] = value; end
},
reverseLoot = {
order = 23,
type = 'toggle',
name = L["REVERSE_NEW_LOOT_TEXT"],
set = function(info, value)
E.db.bags.reverseLoot = value;
SetInsertItemsLeftToRight(value)
end,
},
reverseSlots = {
order = 24,
type = 'toggle',
name = L["Reverse Bag Slots"],
set = function(info, value) E.db.bags[info[#info]] = value B:UpdateAll() end,
},
disableBagSort = {
order = 25,
type = 'toggle',
name = L["Disable Bag Sort"],
set = function(info, value) E.db.bags[info[#info]] = value; B:ToggleSortButtonState(false); end
},
disableBankSort = {
order = 26,
type = 'toggle',
name = L["Disable Bank Sort"],
set = function(info, value) E.db.bags[info[#info]] = value; B:ToggleSortButtonState(true); end
},
useBlizzardCleanup = {
order = 27,
type = 'toggle',
name = L["Use Blizzard Cleanup"],
desc = L["Use Blizzards method of cleaning up bags instead of the ElvUI sorting."],
set = function(info, value) E.db.bags[info[#info]] = value; end
},
auctionToggle = {
order = 28,
type = 'toggle',
name = L["Auction Toggle"],
desc = L["This will toggle your bags while visiting the Auction House."],
set = function(info, value) E.db.bags[info[#info]] = value; end
},
countGroup = {
order = 50,
type = 'group',
name = L["Item Count Font"],
inline = true,
args = {
countFont = {
order = 1,
type = 'select',
dialogControl = 'LSM30_Font',
name = L["Font"],
values = AceGUIWidgetLSMlists.font,
set = function(info, value) E.db.bags.countFont = value; B:UpdateCountDisplay() end,
},
countFontColor = {
order = 2,
type = 'color',
name = L["COLOR"],
get = function(info)
local t = E.db.bags[info[#info]]
local d = P.bags[info[#info]]
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(info, r, g, b)
local t = E.db.bags[info[#info]]
t.r, t.g, t.b = r, g, b
B:UpdateCountDisplay()
end,
},
countFontSize = {
order = 3,
type = 'range',
name = L["FONT_SIZE"],
min = 6, max = 64, step = 1,
set = function(info, value) E.db.bags.countFontSize = value; B:UpdateCountDisplay() end,
},
countFontOutline = {
order = 4,
type = 'select',
name = L["Font Outline"],
set = function(info, value) E.db.bags.countFontOutline = value; B:UpdateCountDisplay() end,
values = C.Values.FontFlags,
},
},
},
itemLevelGroup = {
order = 55,
type = 'group',
name = L["Item Level"],
inline = true,
args = {
itemLevel = {
order = 1,
type = 'toggle',
name = L["Display Item Level"],
desc = L["Displays item level on equippable items."],
set = function(info, value) E.db.bags.itemLevel = value; B:UpdateItemLevelDisplay() end,
},
itemLevelCustomColorEnable = {
order = 2,
type = 'toggle',
name = L["Enable Custom Color"],
set = function(info, value) E.db.bags.itemLevelCustomColorEnable = value; B:UpdateItemLevelDisplay() end,
},
itemLevelCustomColor = {
order = 3,
type = 'color',
name = L["Custom Color"],
disabled = function() return not E.db.bags.itemLevelCustomColorEnable end,
get = function(info)
local t = E.db.bags.itemLevelCustomColor
local d = P.bags.itemLevelCustomColor
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(info, r, g, b)
local t = E.db.bags.itemLevelCustomColor
t.r, t.g, t.b = r, g, b
B:UpdateItemLevelDisplay()
end,
},
itemLevelThreshold = {
order = 4,
name = L["Item Level Threshold"],
desc = L["The minimum item level required for it to be shown."],
type = 'range',
min = 1, max = 1000, step = 1,
disabled = function() return not E.db.bags.itemLevel end,
set = function(info, value) E.db.bags.itemLevelThreshold = value; B:UpdateItemLevelDisplay() end,
},
itemLevelFont = {
order = 5,
type = 'select',
dialogControl = 'LSM30_Font',
name = L["Font"],
values = AceGUIWidgetLSMlists.font,
disabled = function() return not E.db.bags.itemLevel end,
set = function(info, value) E.db.bags.itemLevelFont = value; B:UpdateItemLevelDisplay() end,
},
itemLevelFontSize = {
order = 6,
type = 'range',
name = L["FONT_SIZE"],
min = 6, max = 64, step = 1,
disabled = function() return not E.db.bags.itemLevel end,
set = function(info, value) E.db.bags.itemLevelFontSize = value; B:UpdateItemLevelDisplay() end,
},
itemLevelFontOutline = {
order = 7,
type = 'select',
name = L["Font Outline"],
disabled = function() return not E.db.bags.itemLevel end,
set = function(info, value) E.db.bags.itemLevelFontOutline = value; B:UpdateItemLevelDisplay() end,
values = C.Values.FontFlags,
},
},
},
},
},
sizeGroup = {
order = 4,
type = 'group',
name = L["Size"],
disabled = function() return not E.Bags.Initialized end,
args = {
bagSize = {
order = 2,
type = 'range',
name = L["Button Size (Bag)"],
desc = L["The size of the individual buttons on the bag frame."],
min = 15, max = 45, step = 1,
set = function(info, value) E.db.bags[info[#info]] = value; B:Layout(); end,
},
bankSize = {
order = 3,
type = 'range',
name = L["Button Size (Bank)"],
desc = L["The size of the individual buttons on the bank frame."],
min = 15, max = 45, step = 1,
set = function(info, value) E.db.bags[info[#info]] = value; B:Layout(true) end,
},
bagWidth = {
order = 4,
type = 'range',
name = L["Panel Width (Bags)"],
desc = L["Adjust the width of the bag frame."],
min = 150, max = 1400, step = 1,
set = function(info, value) E.db.bags[info[#info]] = value; B:Layout();end,
},
bankWidth = {
order = 5,
type = 'range',
name = L["Panel Width (Bank)"],
desc = L["Adjust the width of the bank frame."],
min = 150, max = 1400, step = 1,
set = function(info, value) E.db.bags[info[#info]] = value; B:Layout(true) end,
},
},
},
colorGroup = {
order = 5,
type = 'group',
name = L["COLORS"],
disabled = function() return not E.Bags.Initialized end,
args = {
bags = {
order = 2,
type = 'group',
name = L["Bags"],
inline = true,
args = {
profession = {
order = 1,
type = 'group',
name = L["Profession Bags"],
inline = true,
get = function(info)
local t = E.db.bags.colors.profession[info[#info]]
local d = P.bags.colors.profession[info[#info]]
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(info, r, g, b)
local t = E.db.bags.colors.profession[info[#info]]
t.r, t.g, t.b = r, g, b
B:UpdateBagColors('ProfessionColors', info[#info], r, g, b)
B:UpdateAllBagSlots()
end,
args = {
leatherworking = {
order = 1,
type = 'color',
name = L["Leatherworking"],
},
inscription = {
order = 2,
type = 'color',
name = L["INSCRIPTION"],
},
herbs = {
order = 3,
type = 'color',
name = L["Herbalism"],
},
enchanting = {
order = 4,
type = 'color',
name = L["Enchanting"],
},
engineering = {
order = 5,
type = 'color',
name = L["Engineering"],
},
gems = {
order = 6,
type = 'color',
name = L["Gems"],
},
mining = {
order = 7,
type = 'color',
name = L["Mining"],
},
fishing = {
order = 8,
type = 'color',
name = L["PROFESSIONS_FISHING"],
},
cooking = {
order = 9,
type = 'color',
name = L["PROFESSIONS_COOKING"],
},
},
},
assignment = {
order = 2,
type = 'group',
name = L["Bag Assignment"],
inline = true,
get = function(info)
local t = E.db.bags.colors.assignment[info[#info]]
local d = P.bags.colors.assignment[info[#info]]
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(info, r, g, b)
local t = E.db.bags.colors.assignment[info[#info]]
t.r, t.g, t.b = r, g, b
B:UpdateBagColors('AssignmentColors', info[#info], r, g, b)
B:UpdateAllBagSlots()
end,
args = {
equipment = {
order = 1,
type = 'color',
name = L["BAG_FILTER_EQUIPMENT"],
},
consumables = {
order = 2,
type = 'color',
name = L["BAG_FILTER_CONSUMABLES"],
},
tradegoods = {
order = 3,
type = 'color',
name = L["BAG_FILTER_TRADE_GOODS"],
},
},
},
},
},
items = {
order = 3,
type = 'group',
name = L["ITEMS"],
inline = true,
get = function(info)
local t = E.db.bags.colors.items[info[#info]]
local d = P.bags.colors.items[info[#info]]
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(info, r, g, b)
local t = E.db.bags.colors.items[info[#info]]
t.r, t.g, t.b = r, g, b
B:UpdateQuestColors('QuestColors', info[#info], r, g, b)
B:UpdateAllBagSlots()
end,
args = {
questStarter = {
order = 1,
type = 'color',
name = L["Quest Starter"]
},
questItem = {
order = 2,
type = 'color',
name = L["ITEM_BIND_QUEST"],
}
}
}
}
},
bagBar = {
order = 6,
type = 'group',
name = L["Bag-Bar"],
get = function(info) return E.db.bags.bagBar[info[#info]] end,
set = function(info, value) E.db.bags.bagBar[info[#info]] = value; B:SizeAndPositionBagBar() end,
args = {
enable = {
order = 1,
type = 'toggle',
name = L["Enable"],
desc = L["Enable/Disable the Bag-Bar."],
get = function() return E.private.bags.bagBar end,
set = function(_, value) E.private.bags.bagBar = value; E:StaticPopup_Show('PRIVATE_RL') end
},
showBackdrop = {
order = 2,
type = 'toggle',
name = L["Backdrop"],
},
mouseover = {
order = 3,
name = L["Mouse Over"],
desc = L["The frame is not shown unless you mouse over the frame."],
type = 'toggle',
},
size = {
order = 4,
type = 'range',
name = L["Button Size"],
desc = L["Set the size of your bag buttons."],
min = 24, max = 60, step = 1,
},
spacing = {
order = 5,
type = 'range',
name = L["Button Spacing"],
desc = L["The spacing between buttons."],
min = -1, max = 10, step = 1,
},
backdropSpacing = {
order = 6,
type = 'range',
name = L["Backdrop Spacing"],
desc = L["The spacing between the backdrop and the buttons."],
min = 0, max = 10, step = 1,
disabled = function() return not E.private.actionbar.enable end,
},
sortDirection = {
order = 7,
type = 'select',
name = L["Sort Direction"],
desc = L["The direction that the bag frames will grow from the anchor."],
values = {
ASCENDING = L["Ascending"],
DESCENDING = L["Descending"],
},
},
growthDirection = {
order = 7,
type = 'select',
name = L["Bar Direction"],
desc = L["The direction that the bag frames be (Horizontal or Vertical)."],
values = {
VERTICAL = L["Vertical"],
HORIZONTAL = L["Horizontal"],
},
},
visibility = {
type = 'input',
order = 8,
name = L["Visibility State"],
desc = L["This works like a macro, you can run different situations to get the actionbar to show/hide differently.\n Example: '[combat] show;hide'"],
width = 'full',
multiline = true,
set = function(_, value)
if value and value:match('[\n\r]') then
value = value:gsub('[\n\r]','')
end
E.db.bags.bagBar.visibility = value;
B:SizeAndPositionBagBar()
end,
},
},
},
split = {
order = 7,
type = 'group',
name = L["Split"],
get = function(info) return E.db.bags.split[info[#info]] end,
set = function(info, value) E.db.bags.split[info[#info]] = value B:UpdateAll() end,
disabled = function() return not E.Bags.Initialized end,
args = {
bagSpacing = {
order = 1,
type = 'range',
name = L["Bag Spacing"],
min = 0, max = 20, step = 1,
},
player = {
order = 2,
type = 'toggle',
set = function(info, value) E.db.bags.split[info[#info]] = value B:Layout() end,
name = L["Bag"],
},
bank = {
order = 3,
type = 'toggle',
set = function(info, value) E.db.bags.split[info[#info]] = value B:Layout(true) end,
name = L["Bank"],
},
splitbags = {
order = 4,
type = 'multiselect',
name = L["Player"],
get = function(_, key) return E.db.bags.split[key] end,
set = function(_, key, value) E.db.bags.split[key] = value B:Layout() end,
values = {
bag1 = L["Bag 1"],
bag2 = L["Bag 2"],
bag3 = L["Bag 3"],
bag4 = L["Bag 4"],
},
disabled = function() return not E.db.bags.split.player end,
},
splitbank = {
order = 5,
type = 'multiselect',
name = L["Bank"],
get = function(_, key) return E.db.bags.split[key] end,
set = function(_, key, value) E.db.bags.split[key] = value B:Layout(true) end,
sortByValue = true,
values = {
bag5 = L["Bank 1"],
bag6 = L["Bank 2"],
bag7 = L["Bank 3"],
bag8 = L["Bank 4"],
bag9 = L["Bank 5"],
bag10 = L["Bank 6"],
bag11 = L["Bank 7"],
},
disabled = function() return not E.db.bags.split.bank end,
},
},
},
vendorGrays = {
order = 8,
type = 'group',
name = L["Vendor Grays"],
get = function(info) return E.db.bags.vendorGrays[info[#info]] end,
set = function(info, value) E.db.bags.vendorGrays[info[#info]] = value; B:UpdateSellFrameSettings() end,
args = {
enable = {
order = 1,
type = 'toggle',
name = L["Enable"],
desc = L["Automatically vendor gray items when visiting a vendor."],
},
interval = {
order = 2,
type = 'range',
name = L["Sell Interval"],
desc = L["Will attempt to sell another item in set interval after previous one was sold."],
min = 0.1, max = 1, step = 0.1,
},
details = {
order = 3,
name = L["Vendor Gray Detailed Report"],
desc = L["Displays a detailed report of every item sold when enabled."],
type = 'toggle',
},
progressBar = {
order = 4,
name = L["Progress Bar"],
type = 'toggle',
},
},
},
bagSortingGroup = {
order = 9,
type = 'group',
name = L["Bag Sorting"],
disabled = function() return (not E.Bags.Initialized) or E.db.bags.useBlizzardCleanup end,
args = {
sortInverted = {
order = 1,
type = 'toggle',
name = L["Sort Inverted"],
desc = L["Direction the bag sorting will use to allocate the items."],
},
description = ACH:Description(L["Here you can add items or search terms that you want to be excluded from sorting. To remove an item just click on its name in the list."], 3),
addEntryGroup = {
order = 4,
type = 'group',
name = L["Add Item or Search Syntax"],
inline = true,
args = {
addEntryProfile = {
order = 1,
name = L["Profile"],
desc = L["Add an item or search syntax to the ignored list. Items matching the search syntax will be ignored."],
type = 'input',
get = function() return '' end,
set = function(_, value)
if value == '' or gsub(value, '%s+', '') == '' then return; end --Don't allow empty entries
--Store by itemID if possible
local itemID = strmatch(value, 'item:(%d+)')
E.db.bags.ignoredItems[(itemID or value)] = value
end,
},
addEntryGlobal = {
order = 3,
name = L["Global"],
desc = L["Add an item or search syntax to the ignored list. Items matching the search syntax will be ignored."],
type = 'input',
get = function() return '' end,
set = function(_, value)
if value == '' or gsub(value, '%s+', '') == '' then return; end --Don't allow empty entries
--Store by itemID if possible
local itemID = strmatch(value, 'item:(%d+)')
E.global.bags.ignoredItems[(itemID or value)] = value
--Remove from profile list if we just added the same item to global list
if E.db.bags.ignoredItems[(itemID or value)] then
E.db.bags.ignoredItems[(itemID or value)] = nil
end
end,
},
},
},
ignoredEntriesProfile = {
order = 5,
type = 'multiselect',
name = L["Ignored Items and Search Syntax (Profile)"],
values = function() return E.db.bags.ignoredItems end,
get = function(_, value) return E.db.bags.ignoredItems[value] end,
set = function(_, value)
E.db.bags.ignoredItems[value] = nil
GameTooltip:Hide()--Make sure tooltip is properly hidden
end,
},
ignoredEntriesGlobal = {
order = 6,
type = 'multiselect',
name = L["Ignored Items and Search Syntax (Global)"],
values = function() return E.global.bags.ignoredItems end,
get = function(_, value) return E.global.bags.ignoredItems[value] end,
set = function(_, value)
E.global.bags.ignoredItems[value] = nil
GameTooltip:Hide()--Make sure tooltip is properly hidden
end,
},
},
},
search_syntax = {
order = 10,
type = 'group',
name = L["Search Syntax"],
disabled = function() return not E.Bags.Initialized end,
args = {
text = {
order = 1,
type = 'input',
multiline = 26,
width = 'full',
name = '',
get = function() return L["SEARCH_SYNTAX_DESC"]; end,
set = E.noop,
},
},
},
},
}

857
Chat.lua Normal file
View File

@ -0,0 +1,857 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local CH = E:GetModule('Chat')
local Bags = E:GetModule('Bags')
local Layout = E:GetModule('Layout')
local ACH = E.Libs.ACH
local _G = _G
local gsub = gsub
local wipe = wipe
local pairs = pairs
local format = format
local strlower = strlower
local GameTooltip = _G.GameTooltip
local tabSelectorTable = {}
E.Options.args.chat = {
type = 'group',
name = L["Chat"],
childGroups = 'tab',
order = 2,
get = function(info) return E.db.chat[info[#info]] end,
set = function(info, value) E.db.chat[info[#info]] = value end,
args = {
intro = ACH:Description(L["CHAT_DESC"], 1),
enable = {
order = 2,
type = 'toggle',
name = L["Enable"],
get = function() return E.private.chat.enable end,
set = function(_, value) E.private.chat.enable = value; E:StaticPopup_Show('PRIVATE_RL') end
},
general = {
order = 3,
type = 'group',
name = L["General"],
disabled = function() return not E.Chat.Initialized end,
args = {
url = {
order = 1,
type = 'toggle',
name = L["URL Links"],
desc = L["Attempt to create URL links inside the chat."],
},
shortChannels = {
order = 2,
type = 'toggle',
name = L["Short Channels"],
desc = L["Shorten the channel names in chat."],
},
hyperlinkHover = {
order = 3,
type = 'toggle',
name = L["Hyperlink Hover"],
desc = L["Display the hyperlink tooltip while hovering over a hyperlink."],
set = function(info, value)
E.db.chat[info[#info]] = value
CH:ToggleHyperlink(value)
end,
},
sticky = {
order = 3,
type = 'toggle',
name = L["Sticky Chat"],
desc = L["When opening the Chat Editbox to type a message having this option set means it will retain the last channel you spoke in. If this option is turned off opening the Chat Editbox should always default to the SAY channel."],
},
emotionIcons = {
order = 5,
type = 'toggle',
name = L["Emotion Icons"],
desc = L["Display emotion icons in chat."],
},
lfgIcons = {
order = 6,
type = 'toggle',
name = L["Role Icon"],
desc = L["Display LFG Icons in group chat."],
set = function(self, value)
E.db.chat.lfgIcons = value;
CH:CheckLFGRoles()
end,
},
useAltKey = {
order = 12,
type = 'toggle',
name = L["Use Alt Key"],
desc = L["Require holding the Alt key down to move cursor or cycle through messages in the editbox."],
set = function(self, value)
E.db.chat.useAltKey = value;
CH:UpdateSettings()
end,
},
autoClosePetBattleLog = {
order = 13,
type = 'toggle',
name = L["Auto-Close Pet Battle Log"],
},
useBTagName = {
order = 14,
type = 'toggle',
name = L["Use Real ID BattleTag"],
desc = L["Use BattleTag instead of Real ID names in chat. Chat History will always use BattleTag."],
},
socialQueueMessages = {
order = 15,
type = 'toggle',
name = L["Quick Join Messages"],
desc = L["Show clickable Quick Join messages inside of the chat."],
},
copyChatLines = {
order = 16,
type = 'toggle',
name = L["Copy Chat Lines"],
desc = L["Adds an arrow infront of the chat lines to copy the entire line."],
},
hideCopyButton = {
order = 17,
type = 'toggle',
name = L["Hide Copy Button"],
set = function(self, value)
E.db.chat.hideCopyButton = value
CH:ToggleCopyChatButtons()
end,
},
spacer = ACH:Spacer(18, 'full'),
numAllowedCombatRepeat = {
order = 19,
type = 'range',
name = L["Allowed Combat Repeat"],
desc = L["Number of repeat characters while in combat before the chat editbox is automatically closed."],
min = 2, max = 10, step = 1,
},
throttleInterval = {
order = 20,
type = 'range',
name = L["Spam Interval"],
desc = L["Prevent the same messages from displaying in chat more than once within this set amount of seconds, set to zero to disable."],
min = 0, max = 120, step = 1,
set = function(info, value)
E.db.chat[info[#info]] = value
if value == 0 then
CH:DisableChatThrottle()
end
end,
},
scrollDownInterval = {
order = 21,
type = 'range',
name = L["Scroll Interval"],
desc = L["Number of time in seconds to scroll down to the bottom of the chat window if you are not scrolled down completely."],
min = 0, max = 120, step = 5,
},
numScrollMessages = {
order = 22,
type = 'range',
name = L["Scroll Messages"],
desc = L["Number of messages you scroll for each step."],
min = 1, max = 10, step = 1,
},
maxLines = {
order = 23,
type = 'range',
name = L["Max Lines"],
min = 10, max = 5000, step = 1,
set = function(info, value) E.db.chat[info[#info]] = value; CH:SetupChat() end,
},
editboxHistorySize = {
order = 24,
type = 'range',
name = L["Editbox History"],
min = 5, max = 50, step = 1,
},
resetHistory = {
order = 25,
type = 'execute',
name = L["Reset Editbox History"],
func = function() CH:ResetEditboxHistory() end
},
editBoxPosition = {
order = 26,
type = 'select',
name = L["Chat EditBox Position"],
desc = L["Position of the Chat EditBox, if datatexts are disabled this will be forced to be above chat."],
values = {
BELOW_CHAT = L["Below Chat"],
ABOVE_CHAT = L["Above Chat"],
},
set = function(info, value)
E.db.chat[info[#info]] = value;
CH:UpdateEditboxAnchors()
end,
},
tabSelection = {
order = 65,
type = 'group',
name = L["Tab Selector"],
set = function(info, value)
E.db.chat[info[#info]] = value;
CH:UpdateChatTabColors();
end,
args = {
tabSelectedTextEnabled = {
order = 1,
type = 'toggle',
name = L["Colorize Selected Text"],
},
tabSelectedTextColor = {
order = 2,
type = 'color',
hasAlpha = false,
name = L["Selected Text Color"],
disabled = function() return not E.db.chat.tabSelectedTextEnabled end,
get = function()
local t = E.db.chat.tabSelectedTextColor
local d = P.chat.tabSelectedTextColor
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(_, r, g, b)
local t = E.db.chat.tabSelectedTextColor
t.r, t.g, t.b = r, g, b
CH:UpdateChatTabColors();
end,
},
tabSelector = {
order = 3,
type = 'select',
name = L["Selector Style"],
values = function()
wipe(tabSelectorTable)
for key, value in pairs(CH.TabStyles) do
if key == 'NONE' then
tabSelectorTable[key] = 'None'
else
local color = CH.db.tabSelectorColor
local hexColor = E:RGBToHex(color.r, color.g, color.b)
local selectedColor = E.media.hexvaluecolor
if CH.db.tabSelectedTextEnabled then
color = E.db.chat.tabSelectedTextColor
selectedColor = E:RGBToHex(color.r, color.g, color.b)
end
tabSelectorTable[key] = format(value, hexColor, format('%sName|r', selectedColor), hexColor)
end
end
return tabSelectorTable
end,
},
tabSelectorColor = {
order = 4,
type = 'color',
hasAlpha = false,
name = L["Selector Color"],
disabled = function() return E.db.chat.tabSelector == 'NONE' end,
get = function()
local t = E.db.chat.tabSelectorColor
local d = P.chat.tabSelectorColor
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(_, r, g, b)
local t = E.db.chat.tabSelectorColor
t.r, t.g, t.b = r, g, b
E:UpdateMedia();
end,
},
}
},
historyGroup = {
order = 70,
type = 'group',
name = L["History"],
set = function(info, value) E.db.chat[info[#info]] = value end,
args = {
chatHistory = {
order = 1,
type = 'toggle',
name = L["Enable"],
desc = L["Log the main chat frames history. So when you reloadui or log in and out you see the history from your last session."],
},
resetHistory = {
order = 2,
type = 'execute',
name = L["Reset History"],
func = function() CH:ResetHistory() end
},
historySize = {
order = 3,
type = 'range',
name = L["History Size"],
min = 10, max = 500, step = 1,
disabled = function() return not E.db.chat.chatHistory end,
},
historyTypes = {
order = 4,
type = 'multiselect',
name = L["Display Types"],
get = function(info, key) return
E.db.chat.showHistory[key]
end,
set = function(info, key, value)
E.db.chat.showHistory[key] = value
end,
disabled = function() return not E.db.chat.chatHistory end,
values = {
WHISPER = L["Whisper"],
GUILD = L["Guild"],
OFFICER = L["Officer"],
PARTY = L["Party"],
RAID = L["Raid"],
INSTANCE = L["Instance"],
CHANNEL = L["Channel"],
SAY = L["Say"],
YELL = L["Yell"],
EMOTE = L["Emote"]
},
}
}
},
fadingGroup = {
order = 75,
type = 'group',
name = L["Text Fade"],
disabled = function() return not E.Chat.Initialized end,
set = function(info, value) E.db.chat[info[#info]] = value; CH:UpdateFading() end,
args = {
fade = {
order = 1,
type = 'toggle',
name = L["Enable"],
desc = L["Fade the chat text when there is no activity."],
},
inactivityTimer = {
order = 2,
type = 'range',
name = L["Inactivity Timer"],
desc = L["Controls how many seconds of inactivity has to pass before chat is faded."],
disabled = function() return not CH.db.fade end,
min = 5, softMax = 120, step = 1,
},
},
},
fontGroup = {
order = 80,
type = 'group',
name = L["Fonts"],
disabled = function() return not E.Chat.Initialized end,
set = function(info, value) E.db.chat[info[#info]] = value; CH:SetupChat() end,
args = {
font = {
type = 'select', dialogControl = 'LSM30_Font',
order = 1,
name = L["Font"],
values = AceGUIWidgetLSMlists.font,
},
fontOutline = {
order = 2,
name = L["Font Outline"],
desc = L["Set the font outline."],
type = 'select',
values = C.Values.FontFlags,
},
tabFont = {
type = 'select', dialogControl = 'LSM30_Font',
order = 4,
name = L["Tab Font"],
values = AceGUIWidgetLSMlists.font,
},
tabFontOutline = {
order = 5,
name = L["Tab Font Outline"],
desc = L["Set the font outline."],
type = 'select',
values = C.Values.FontFlags,
},
tabFontSize = {
order = 6,
name = L["Tab Font Size"],
type = 'range',
min = 4, max = 60, step = 1,
},
},
},
alerts = {
order = 85,
type = 'group',
name = L["Alerts"],
disabled = function() return not E.Chat.Initialized end,
args = {
noAlertInCombat = {
order = 1,
type = 'toggle',
name = L["No Alert In Combat"],
},
keywordAlerts = {
order = 2,
type = 'group',
name = L["Keyword Alerts"],
inline = true,
args = {
keywordSound = {
order = 1,
type = 'select', dialogControl = 'LSM30_Sound',
name = L["Keyword Alert"],
width = 'double',
values = AceGUIWidgetLSMlists.sound,
},
keywords = {
order = 2,
name = L["Keywords"],
desc = L["List of words to color in chat if found in a message. If you wish to add multiple words you must seperate the word with a comma. To search for your current name you can use %MYNAME%.\n\nExample:\n%MYNAME%, ElvUI, RBGs, Tank"],
type = 'input',
width = 'full',
set = function(info, value) E.db.chat[info[#info]] = value; CH:UpdateChatKeywords() end,
},
},
},
channelAlerts = {
order = 3,
type = 'group',
name = L["Channel Alerts"],
inline = true,
get = function(info) return E.db.chat.channelAlerts[info[#info]] end,
set = function(info, value) E.db.chat.channelAlerts[info[#info]] = value end,
args = {
GUILD = {
type = 'select', dialogControl = 'LSM30_Sound',
name = L["Guild"],
width = 'double',
values = AceGUIWidgetLSMlists.sound,
},
OFFICER = {
type = 'select', dialogControl = 'LSM30_Sound',
name = L["Officer"],
width = 'double',
values = AceGUIWidgetLSMlists.sound,
},
INSTANCE = {
type = 'select', dialogControl = 'LSM30_Sound',
name = L["Instance"],
width = 'double',
values = AceGUIWidgetLSMlists.sound,
},
PARTY = {
type = 'select', dialogControl = 'LSM30_Sound',
name = L["Party"],
width = 'double',
values = AceGUIWidgetLSMlists.sound,
},
RAID = {
type = 'select', dialogControl = 'LSM30_Sound',
name = L["Raid"],
width = 'double',
values = AceGUIWidgetLSMlists.sound,
},
WHISPER = {
type = 'select', dialogControl = 'LSM30_Sound',
name = L["Whisper"],
width = 'double',
values = AceGUIWidgetLSMlists.sound,
},
},
},
},
},
voicechatGroup = {
order = 90,
type = 'group',
name = L["BINDING_HEADER_VOICE_CHAT"],
args = {
hideVoiceButtons = {
order = 1,
type = 'toggle',
name = L["Hide Voice Buttons"],
desc = L["Completely hide the voice buttons."],
set = function(info, value)
E.db.chat[info[#info]] = value
E:StaticPopup_Show('CONFIG_RL')
end,
},
pinVoiceButtons = {
order = 2,
type = 'toggle',
name = L["Pin Voice Buttons"],
desc = L["This will pin the voice buttons to the chat's tab panel. Unchecking it will create a voice button panel with a mover."],
disabled = function() return E.db.chat.hideVoiceButtons end,
set = function(info, value)
E.db.chat[info[#info]] = value
E:StaticPopup_Show('CONFIG_RL')
end,
},
desaturateVoiceIcons = {
order = 3,
type = 'toggle',
name = L["Desaturate Voice Icons"],
disabled = function() return E.db.chat.hideVoiceButtons end,
set = function(info, value)
E.db.chat[info[#info]] = value
CH:UpdateVoiceChatIcons()
end,
},
},
},
timestampGroup = {
order = 95,
type = 'group',
name = L["TIMESTAMPS_LABEL"],
args = {
useCustomTimeColor = {
order = 1,
type = 'toggle',
name = L["Custom Timestamp Color"],
disabled = function() return not E.db.chat.timeStampFormat == 'NONE' end,
},
customTimeColor = {
order = 2,
type = 'color',
hasAlpha = false,
name = L["Timestamp Color"],
disabled = function() return (not E.db.chat.timeStampFormat == 'NONE' or not E.db.chat.useCustomTimeColor) end,
get = function(info)
local t = E.db.chat.customTimeColor
local d = P.chat.customTimeColor
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(info, r, g, b)
local t = E.db.chat.customTimeColor
t.r, t.g, t.b = r, g, b
end,
},
timeStampLocalTime = {
order = 3,
type = 'toggle',
name = L["Local Time"],
desc = L["If not set to true then the server time will be displayed instead."],
},
timeStampFormat = {
order = 4,
type = 'select',
name = L["TIMESTAMPS_LABEL"],
desc = L["OPTION_TOOLTIP_TIMESTAMPS"],
values = {
['NONE'] = L["NONE"],
['%I:%M '] = '03:27',
['%I:%M:%S '] = '03:27:32',
['%I:%M %p '] = '03:27 PM',
['%I:%M:%S %p '] = '03:27:32 PM',
['%H:%M '] = '15:27',
['%H:%M:%S '] = '15:27:32'
},
},
},
},
classColorMentionGroup = {
order = 100,
type = 'group',
name = L["Class Color Mentions"],
disabled = function() return not E.Chat.Initialized end,
args = {
classColorMentionsChat = {
order = 1,
type = 'toggle',
name = L["Chat"],
desc = L["Use class color for the names of players when they are mentioned."],
get = function(info) return E.db.chat.classColorMentionsChat end,
set = function(info, value) E.db.chat.classColorMentionsChat = value end,
disabled = function() return not E.private.chat.enable end,
},
classColorMentionsSpeech = {
order = 2,
type = 'toggle',
name = L["Chat Bubbles"],
desc = L["Use class color for the names of players when they are mentioned."],
get = function(info) return E.private.general.classColorMentionsSpeech end,
set = function(info, value) E.private.general.classColorMentionsSpeech = value; E:StaticPopup_Show('PRIVATE_RL') end,
disabled = function() return (E.private.general.chatBubbles == 'disabled' or not E.private.chat.enable) end,
},
classColorMentionExcludeName = {
order = 21,
name = L["Exclude Name"],
desc = L["Excluded names will not be class colored."],
type = 'input',
get = function(info) return '' end,
set = function(info, value)
if value == '' or gsub(value, '%s+', '') == '' then return; end --Don't allow empty entries
E.global.chat.classColorMentionExcludedNames[strlower(value)] = value
end,
},
classColorMentionExcludedNames = {
order = 22,
type = 'multiselect',
name = L["Excluded Names"],
values = function() return E.global.chat.classColorMentionExcludedNames end,
get = function(info, value) return E.global.chat.classColorMentionExcludedNames[value] end,
set = function(info, value)
E.global.chat.classColorMentionExcludedNames[value] = nil
GameTooltip:Hide()--Make sure tooltip is properly hidden
end,
},
},
},
},
},
panels = {
order = 5,
type = 'group',
name = L["Panels"],
args = {
fadeUndockedTabs = {
order = 1,
type = 'toggle',
name = L["Fade Undocked Tabs"],
desc = L["Fades the text on chat tabs that are not docked at the left or right chat panel."],
hidden = function() return not E.Chat.Initialized end,
set = function(self, value)
E.db.chat.fadeUndockedTabs = value;
CH:UpdateChatTabs()
end,
},
fadeTabsNoBackdrop = {
order = 2,
type = 'toggle',
name = L["Fade Tabs No Backdrop"],
desc = L["Fades the text on chat tabs that are docked in a panel where the backdrop is disabled."],
hidden = function() return not E.Chat.Initialized end,
set = function(self, value)
E.db.chat.fadeTabsNoBackdrop = value;
CH:UpdateChatTabs()
end,
},
hideChatToggles = {
order = 3,
type = 'toggle',
name = L["Hide Chat Toggles"],
set = function(self, value)
E.db.chat.hideChatToggles = value;
CH:RefreshToggleButtons()
Layout:RepositionChatDataPanels()
end,
},
fadeChatToggles = {
order = 4,
type = 'toggle',
name = L["Fade Chat Toggles"],
desc = L["Fades the buttons that toggle chat windows when that window has been toggled off."],
disabled = function() return E.db.chat.hideChatToggles end,
set = function(self, value)
E.db.chat.fadeChatToggles = value;
CH:RefreshToggleButtons()
end,
},
tabGroup = {
order = 10,
type = 'group',
inline = true,
name = L["Tab Panels"],
hidden = function() return not E.Chat.Initialized end,
args = {
panelTabTransparency = {
order = 1,
type = 'toggle',
name = L["Tab Panel Transparency"],
customWidth = 250,
disabled = function() return not E.db.chat.panelTabBackdrop end,
set = function(info, value) E.db.chat.panelTabTransparency = value; Layout:SetChatTabStyle(); end,
},
panelTabBackdrop = {
order = 2,
type = 'toggle',
name = L["Tab Panel"],
desc = L["Toggle the chat tab panel backdrop."],
set = function(info, value)
E.db.chat.panelTabBackdrop = value
Layout:ToggleChatPanels()
if E.db.chat.pinVoiceButtons and not E.db.chat.hideVoiceButtons then
CH:ReparentVoiceChatIcon()
end
end,
},
}
},
datatextGroup = {
order = 15,
type = 'group',
inline = true,
name = L["DataText Panels"],
args = {
LeftChatDataPanelAnchor = {
order = 1,
type = 'select',
name = L["Left Position"],
values = {
BELOW_CHAT = L["Below Chat"],
ABOVE_CHAT = L["Above Chat"],
},
set = function(info, value) E.db.chat[info[#info]] = value; Layout:RepositionChatDataPanels() end,
},
RightChatDataPanelAnchor = {
order = 2,
type = 'select',
name = L["Right Position"],
values = {
BELOW_CHAT = L["Below Chat"],
ABOVE_CHAT = L["Above Chat"],
},
set = function(info, value) E.db.chat[info[#info]] = value; Layout:RepositionChatDataPanels() end,
}
}
},
panels = {
order = 20,
type = 'group',
inline = true,
name = L["Chat Panels"],
args = {
panelColor = {
order = 1,
type = 'color',
name = L["Backdrop Color"],
hasAlpha = true,
get = function(info)
local t = E.db.chat.panelColor
local d = P.chat.panelColor
return t.r, t.g, t.b, t.a, d.r, d.g, d.b, d.a
end,
set = function(info, r, g, b, a)
local t = E.db.chat.panelColor
t.r, t.g, t.b, t.a = r, g, b, a
CH:Panels_ColorUpdate()
end,
},
separateSizes = {
order = 2,
type = 'toggle',
name = L["Separate Panel Sizes"],
desc = L["Enable the use of separate size options for the right chat panel."],
set = function(info, value)
E.db.chat.separateSizes = value
CH:PositionChats()
Bags:Layout()
end,
},
panelHeight = {
order = 3,
type = 'range',
name = L["Panel Height"],
desc = L["PANEL_DESC"],
min = 60, max = 600, step = 1,
set = function(info, value)
E.db.chat.panelHeight = value
CH:PositionChats()
end,
},
panelWidth = {
order = 4,
type = 'range',
name = L["Panel Width"],
desc = L["PANEL_DESC"],
set = function(info, value)
E.db.chat.panelWidth = value
CH:PositionChats()
if not E.db.chat.separateSizes then
Bags:Layout()
end
Bags:Layout(true)
end,
min = 50, max = 1000, step = 1,
},
panelBackdrop = {
order = 5,
type = 'select',
name = L["Panel Backdrop"],
desc = L["Toggle showing of the left and right chat panels."],
values = {
HIDEBOTH = L["Hide Both"],
SHOWBOTH = L["Show Both"],
LEFT = L["Left Only"],
RIGHT = L["Right Only"],
},
set = function(info, value)
E.db.chat.panelBackdrop = value
Layout:ToggleChatPanels()
CH:PositionChats()
CH:UpdateEditboxAnchors()
end,
},
panelSnapping = {
order = 6,
type = 'toggle',
name = L["Panel Snapping"],
desc = L["When disabled the Chat Background color has to be set via Blizzards Chat Tabs Background setting."],
hidden = function() return not E.Chat.Initialized end,
set = function(info, value)
E.db.chat.panelSnapping = value
CH:PositionChats()
end
},
panelHeightRight = {
order = 6,
type = 'range',
name = L["Right Panel Height"],
desc = L["Adjust the height of your right chat panel."],
min = 60, max = 600, step = 1,
disabled = function() return not E.db.chat.separateSizes end,
hidden = function() return not E.db.chat.separateSizes end,
set = function(info, value)
E.db.chat.panelHeightRight = value
CH:PositionChats()
end,
},
panelWidthRight = {
order = 7,
type = 'range',
name = L["Right Panel Width"],
desc = L["Adjust the width of your right chat panel."],
disabled = function() return not E.db.chat.separateSizes end,
hidden = function() return not E.db.chat.separateSizes end,
set = function(info, value)
E.db.chat.panelWidthRight = value
CH:PositionChats()
Bags:Layout()
end,
min = 50, max = 1000, step = 1,
},
panelBackdropNameLeft = {
order = 8,
type = 'input',
width = 'full',
name = L["Panel Texture (Left)"],
desc = L["Specify a filename located inside the World of Warcraft directory. Textures folder that you wish to have set as a panel background.\n\nPlease Note:\n-The image size recommended is 256x128\n-You must do a complete game restart after adding a file to the folder.\n-The file type must be tga format.\n\nExample: Interface\\AddOns\\ElvUI\\Media\\Textures\\Copy\n\nOr for most users it would be easier to simply put a tga file into your WoW folder, then type the name of the file here."],
set = function(info, value)
E.db.chat[info[#info]] = value
E:UpdateMedia()
end,
},
panelBackdropNameRight = {
order = 9,
type = 'input',
width = 'full',
name = L["Panel Texture (Right)"],
desc = L["Specify a filename located inside the World of Warcraft directory. Textures folder that you wish to have set as a panel background.\n\nPlease Note:\n-The image size recommended is 256x128\n-You must do a complete game restart after adding a file to the folder.\n-The file type must be tga format.\n\nExample: Interface\\AddOns\\ElvUI\\Media\\Textures\\Copy\n\nOr for most users it would be easier to simply put a tga file into your WoW folder, then type the name of the file here."],
set = function(info, value)
E.db.chat[info[#info]] = value
E:UpdateMedia()
end,
},
}
},
},
},
},
}

90
Cooldown.lua Normal file
View File

@ -0,0 +1,90 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local ACH = E.Libs.ACH
-- GLOBALS: AceGUIWidgetLSMlists
local function profile(db)
return (db == 'global' and E.db.cooldown) or E.db[db].cooldown
end
local function private(db)
return (db == 'global' and P.cooldown) or P[db].cooldown
end
local function group(order, db, label)
local main = ACH:Group(label, nil, order, nil, function(info) local t = (profile(db))[info[#info]] local d = (private(db))[info[#info]] return t.r, t.g, t.b, t.a, d.r, d.g, d.b; end, function(info, r, g, b) local t = (profile(db))[info[#info]] t.r, t.g, t.b = r, g, b; E:UpdateCooldownSettings(db); end)
E.Options.args.cooldown.args[db] = main
local mainArgs = main.args
mainArgs.reverse = ACH:Toggle(L["Reverse Toggle"], L["Reverse Toggle will enable Cooldown Text on this module when the global setting is disabled and disable them when the global setting is enabled."], 1, nil, nil, nil, function(info) return (profile(db))[info[#info]] end, function(info, value) (profile(db))[info[#info]] = value; E:UpdateCooldownSettings(db); end)
mainArgs.hideBlizzard = ACH:Toggle(L["Force Hide Blizzard Text"], L["This option will force hide Blizzard's cooldown text if it is enabled at [Interface > ActionBars > Show Numbers on Cooldown]."], 2, nil, nil, nil, function(info) return (profile(db))[info[#info]] end, function(info, value) (profile(db))[info[#info]] = value; E:UpdateCooldownSettings(db); end, nil, function() if db == 'global' then return E.db.cooldown.enable else return (E.db.cooldown.enable and not profile(db).reverse) or (not E.db.cooldown.enable and profile(db).reverse) end end)
local seconds = ACH:Group(L["Text Threshold"], nil, 3, nil, function(info) return (profile(db))[info[#info]] end, function(info, value) (profile(db))[info[#info]] = value; E:UpdateCooldownSettings(db); end, function() return not (profile(db)).checkSeconds end)
seconds.inline = true
seconds.args.checkSeconds = ACH:Toggle(L["Enable"], L["This will override the global cooldown settings."], 1, nil, nil, nil, nil, nil, false)
seconds.args.mmssThreshold = ACH:Range(L["MM:SS Threshold"], L["Threshold (in seconds) before text is shown in the MM:SS format. Set to -1 to never change to this format."], 2, { min = -1, max = 10800, step = 1 })
seconds.args.hhmmThreshold = ACH:Range(L["HH:MM Threshold"], L["Threshold (in minutes) before text is shown in the HH:MM format. Set to -1 to never change to this format."], 3, { min = -1, max = 1440, step = 1 })
mainArgs.secondsGroup = seconds
local fonts = ACH:Group(L["Fonts"], nil, 4, nil, function(info) return (profile(db)).fonts[info[#info]] end, function(info, value) (profile(db)).fonts[info[#info]] = value; E:UpdateCooldownSettings(db); end, function() return not (profile(db)).fonts.enable end)
fonts.inline = true
fonts.args.enable = ACH:Toggle(L["Enable"], L["This will override the global cooldown settings."], 1, nil, nil, nil, nil, nil, false)
fonts.args.font = ACH:SharedMediaFont(L["Font"], nil, 2)
fonts.args.fontSize = ACH:Range(L["Font Size"], nil, 3, { min = 10, max = 50, step = 1 })
fonts.args.fontOutline = ACH:Select(L["Font Outline"], nil, 4, C.Values.FontFlags)
mainArgs.fontGroup = fonts
local colors = ACH:Group(L["Color Override"], nil, 5, nil, nil, nil, function() return not (profile(db)).override end)
colors.inline = true
colors.args.override = ACH:Toggle(L["Enable"], L["This will override the global cooldown settings."], 1, nil, nil, nil, function(info) return (profile(db))[info[#info]] end, function(info, value) (profile(db))[info[#info]] = value; E:UpdateCooldownSettings(db); end, false)
colors.args.threshold = ACH:Range(L["Low Threshold"], L["Threshold before text turns red and is in decimal form. Set to -1 for it to never turn red"], 2, { min = -1, max = 20, step = 1 }, nil, function(info) return (profile(db))[info[#info]] end, function(info, value) (profile(db))[info[#info]] = value; E:UpdateCooldownSettings(db); end)
mainArgs.colorGroup = colors
local tColors = ACH:Group(L["Threshold Colors"], nil, 3)
tColors.args.expiringColor = ACH:Color(L["Expiring"], L["Color when the text is about to expire"], 1)
tColors.args.secondsColor = ACH:Color(L["Seconds"], L["Color when the text is in the seconds format."], 2)
tColors.args.minutesColor = ACH:Color(L["Minutes"], L["Color when the text is in the minutes format."], 3)
tColors.args.hoursColor = ACH:Color(L["Hours"], L["Color when the text is in the hours format."], 4)
tColors.args.daysColor = ACH:Color(L["Days"], L["Color when the text is in the days format."], 5)
tColors.args.mmssColor = ACH:Color(L["MM:SS"], nil, 6)
tColors.args.hhmmColor = ACH:Color(L["HH:MM"], nil, 7)
mainArgs.colorGroup.args.timeColors = tColors
local iColors = ACH:Group(L["Time Indicator Colors"], nil, 4, nil, nil, nil, function() return not (profile(db)).useIndicatorColor end)
iColors.args.useIndicatorColor = ACH:Toggle(L["Use Indicator Color"], nil, 0, nil, nil, nil, function(info) return (profile(db))[info[#info]] end, function(info, value) (profile(db))[info[#info]] = value; E:UpdateCooldownSettings(db); end, false)
iColors.args.expireIndicator = ACH:Color(L["Expiring"], L["Color when the text is about to expire"], 1)
iColors.args.secondsIndicator = ACH:Color(L["Seconds"], L["Color when the text is in the seconds format."], 2)
iColors.args.minutesIndicator = ACH:Color(L["Minutes"], L["Color when the text is in the minutes format."], 3)
iColors.args.hoursIndicator = ACH:Color(L["Hours"], L["Color when the text is in the hours format."], 4)
iColors.args.daysIndicator = ACH:Color(L["Days"], L["Color when the text is in the days format."], 5)
iColors.args.hhmmColorIndicator = ACH:Color(L["MM:SS"], nil, 6)
iColors.args.mmssColorIndicator = ACH:Color(L["HH:MM"], nil, 7)
mainArgs.colorGroup.args.indicatorColors = iColors
if db == 'global' then
mainArgs.reverse = nil
mainArgs.colorGroup.args.override = nil
mainArgs.colorGroup.disabled = nil
mainArgs.colorGroup.name = L["COLORS"]
-- keep these two in this order
E.Options.args.cooldown.args.hideBlizzard = mainArgs.hideBlizzard
mainArgs.hideBlizzard = nil
elseif db == 'auras' then
mainArgs.reverse = nil
mainArgs.hideBlizzard = nil
mainArgs.fontGroup = nil
end
end
E.Options.args.cooldown = ACH:Group(L["Cooldown Text"], nil, 2, 'tab', function(info) return E.db.cooldown[info[#info]] end, function(info, value) E.db.cooldown[info[#info]] = value; E:UpdateCooldownSettings('global'); end)
E.Options.args.cooldown.args.intro = ACH:Description(L["COOLDOWN_DESC"], 0)
E.Options.args.cooldown.args.enable = ACH:Toggle(L["Enable"], L["Display cooldown text on anything with the cooldown spiral."], 1)
group(5, 'global', L["Global"])
group(6, 'auras', L["BUFFOPTIONS_LABEL"])
group(7, 'actionbar', L["ActionBars"])
group(8, 'bags', L["Bags"])
group(9, 'nameplates', L["NamePlates"])
group(10, 'unitframe', L["UnitFrames"])

442
Core.lua Normal file
View File

@ -0,0 +1,442 @@
local E = unpack(ElvUI) --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local D = E:GetModule('Distributor')
local Engine = select(2, ...)
Engine[1] = {}
Engine[2] = E.Libs.ACL:GetLocale('ElvUI', E.global.general.locale)
local C, L = Engine[1], Engine[2]
local _G, format, sort, tinsert, strmatch = _G, format, sort, tinsert, strmatch
C.Values = {
FontFlags = {
NONE = L["NONE"],
OUTLINE = 'Outline',
THICKOUTLINE = 'Thick',
MONOCHROME = '|cffaaaaaaMono|r',
MONOCHROMEOUTLINE = '|cffaaaaaaMono|r Outline',
MONOCHROMETHICKOUTLINE = '|cffaaaaaaMono|r Thick',
},
FontSize = { min = 8, max = 64, step = 1 },
Strata = { BACKGROUND = 'BACKGROUND', LOW = 'LOW', MEDIUM = 'MEDIUM', HIGH = 'HIGH', DIALOG = 'DIALOG', TOOLTIP = 'TOOLTIP' },
GrowthDirection = {
DOWN_RIGHT = format(L["%s and then %s"], L["Down"], L["Right"]),
DOWN_LEFT = format(L["%s and then %s"], L["Down"], L["Left"]),
UP_RIGHT = format(L["%s and then %s"], L["Up"], L["Right"]),
UP_LEFT = format(L["%s and then %s"], L["Up"], L["Left"]),
RIGHT_DOWN = format(L["%s and then %s"], L["Right"], L["Down"]),
RIGHT_UP = format(L["%s and then %s"], L["Right"], L["Up"]),
LEFT_DOWN = format(L["%s and then %s"], L["Left"], L["Down"]),
LEFT_UP = format(L["%s and then %s"], L["Left"], L["Up"]),
}
}
C.StateSwitchGetText = function(_, TEXT)
local friend, enemy = strmatch(TEXT, '^Friendly:([^,]*)'), strmatch(TEXT, '^Enemy:([^,]*)')
local text, blockB, blockS, blockT = friend or enemy or TEXT
local SF, localized = E.global.unitframe.specialFilters[text], L[text]
if SF and localized and text:match('^block') then blockB, blockS, blockT = localized:match('^%[(.-)](%s?)(.+)') end
local filterText = (blockB and format('|cFF999999%s|r%s%s', blockB, blockS, blockT)) or localized or text
return (friend and format('|cFF33FF33%s|r %s', _G.FRIEND, filterText)) or (enemy and format('|cFFFF3333%s|r %s', _G.ENEMY, filterText)) or filterText
end
E:AddLib('AceGUI', 'AceGUI-3.0')
E:AddLib('AceConfig', 'AceConfig-3.0-ElvUI')
E:AddLib('AceConfigDialog', 'AceConfigDialog-3.0-ElvUI')
E:AddLib('AceConfigRegistry', 'AceConfigRegistry-3.0-ElvUI')
E:AddLib('AceDBOptions', 'AceDBOptions-3.0')
E:AddLib('ACH', 'LibAceConfigHelper')
local UnitName = UnitName
local UnitExists = UnitExists
local UnitIsUnit = UnitIsUnit
local UnitIsFriend = UnitIsFriend
local UnitIsPlayer = UnitIsPlayer
local GameTooltip_Hide = GameTooltip_Hide
local GameFontHighlightSmall = _G.GameFontHighlightSmall
local ACH = E.Libs.ACH
--Function we can call on profile change to update GUI
function E:RefreshGUI()
E:RefreshCustomTextsConfigs()
E.Libs.AceConfigRegistry:NotifyChange('ElvUI')
end
E.Libs.AceConfig:RegisterOptionsTable('ElvUI', E.Options)
E.Libs.AceConfigDialog:SetDefaultSize('ElvUI', E:Config_GetDefaultSize())
E.Options.name = format('%s: |cff99ff33%s|r', L["Version"], E.version)
local DONATORS = {
'Dandruff',
'Tobur/Tarilya',
'Netu',
'Alluren',
'Thorgnir',
'Emalal',
'Bendmeova',
'Curl',
'Zarac',
'Emmo',
'Oz',
'Hawké',
'Aynya',
'Tahira',
'Karsten Lumbye Thomsen',
'Thomas B. aka Pitschiqüü',
'Sea Garnet',
'Paul Storry',
'Azagar',
'Archury',
'Donhorn',
'Woodson Harmon',
'Phoenyx',
'Feat',
'Konungr',
'Leyrin',
'Dragonsys',
'Tkalec',
'Paavi',
'Giorgio',
'Bearscantank',
'Eidolic',
'Cosmo',
'Adorno',
'Domoaligato',
'Smorg',
'Pyrokee',
'Portable',
'Ithilyn'
}
local DEVELOPERS = {
'Tukz',
'Haste',
'Nightcracker',
'Omega1970',
'Hydrazine',
'Blazeflack',
'|cff0070DEAzilroka|r',
'|cff9482c9Darth Predator|r',
'|T134297:15:15:0:0:64:64:5:59:5:59|t |cffff7d0aMerathilis|r',
'|TInterface/AddOns/ElvUI/Media/ChatLogos/FoxWarlock:15:15:0:0:64:64:5:59:5:59|t |cffff2020NihilisticPandemonium|r',
E:TextGradient('Simpy but my name needs to be longer.', 0.63,0.40,0.80, 0.63,0.40,0.80, 0.53,0.87,0.19, 0.53,0.87,0.19, 0.20,0.74,0.74, 0.20,0.74,0.74, 0.53,0.87,0.19, 0.53,0.87,0.19, 0.63,0.40,0.80, 0.63,0.40,0.80)
}
local TESTERS = {
'Tukui Community',
'Affinity',
'Modarch',
'Tirain',
'Phima',
'Veiled',
'Repooc',
'Alex',
'Nidra',
'Kurhyus',
'Shrom',
'BuG',
'Kringel',
'Botanica',
'Yachanay',
'Catok',
'|cff00c0faBenik|r',
'|T136012:15:15:0:0:64:64:5:59:5:59|t |cff006fdcRubgrsch|r |T656558:15:15:0:0:64:64:5:59:5:59|t',
'|TInterface/AddOns/ElvUI/Media/ChatLogos/Clover:15:15:0:0:64:64:5:59:5:59|t Luckyone',
'AcidWeb |TInterface/AddOns/ElvUI/Media/ChatLogos/Gem:15:15:-1:2:64:64:6:60:8:60|t',
'|T135167:15:15:0:0:64:64:5:59:5:59|t Loon - For being right',
'|T134297:15:15:0:0:64:64:5:59:5:59|t |cffFF7D0ABladesdruid|r - AKA SUPERBEAR',
}
local function SortList(a, b)
return E:StripString(a) < E:StripString(b)
end
sort(DONATORS, SortList)
sort(DEVELOPERS, SortList)
sort(TESTERS, SortList)
for _, name in pairs(DONATORS) do
tinsert(E.CreditsList, name)
end
local DONATOR_STRING = table.concat(DONATORS, '|n')
for _, name in pairs(DEVELOPERS) do
tinsert(E.CreditsList, name)
end
local DEVELOPER_STRING = table.concat(DEVELOPERS, '|n')
for _, name in pairs(TESTERS) do
tinsert(E.CreditsList, name)
end
local TESTER_STRING = table.concat(TESTERS, '|n')
E.Options.args.info = ACH:Group(L["Information"], nil, 4)
E.Options.args.info.args.header = ACH:Description(L["ELVUI_DESC"], 1, 'medium')
E.Options.args.info.args.spacer = ACH:Spacer(2)
E.Options.args.info.args.support = ACH:Group(L["Support & Download"], nil, 3)
E.Options.args.info.args.support.inline = true
E.Options.args.info.args.support.args.homepage = ACH:Execute(L["Support Forum"], nil, 1, function() E:StaticPopup_Show('ELVUI_EDITBOX', nil, nil, 'https://www.tukui.org/forum/viewforum.php?f=4') end)
E.Options.args.info.args.support.args.homepage.customWidth = 140
E.Options.args.info.args.support.args.git = ACH:Execute(L["Ticket Tracker"], nil, 2, function() E:StaticPopup_Show('ELVUI_EDITBOX', nil, nil, 'https://git.tukui.org/elvui/elvui/issues') end)
E.Options.args.info.args.support.args.git.customWidth = 140
E.Options.args.info.args.support.args.discord = ACH:Execute(L["Discord"], nil, 3, function() E:StaticPopup_Show('ELVUI_EDITBOX', nil, nil, 'https://discordapp.com/invite/xFWcfgE') end)
E.Options.args.info.args.support.args.discord.customWidth = 140
E.Options.args.info.args.support.args.changelog = ACH:Execute(L["Changelog"], nil, 4, function() E:StaticPopup_Show('ELVUI_EDITBOX', nil, nil, 'https://www.tukui.org/download.php?ui=elvui#changelog') end)
E.Options.args.info.args.support.args.changelog.customWidth = 140
E.Options.args.info.args.support.args.development = ACH:Execute(L["Development Version"], L["Link to the latest development version."], 5, function() E:StaticPopup_Show('ELVUI_EDITBOX', nil, nil, 'https://git.tukui.org/elvui/elvui/-/archive/development/elvui-development.zip') end)
E.Options.args.info.args.support.args.development.customWidth = 140
E.Options.args.info.args.credits = ACH:Group(L["Credits"], nil, 4)
E.Options.args.info.args.credits.inline = true
E.Options.args.info.args.credits.args.string = ACH:Description(L["ELVUI_CREDITS"], 1, 'medium')
E.Options.args.info.args.coding = ACH:Group(L["Coding:"], nil, 5)
E.Options.args.info.args.coding.inline = true
E.Options.args.info.args.coding.args.string = ACH:Description(DEVELOPER_STRING, 1, 'medium')
E.Options.args.info.args.testers = ACH:Group(L["Testing:"], nil, 6)
E.Options.args.info.args.testers.inline = true
E.Options.args.info.args.testers.args.string = ACH:Description(TESTER_STRING, 1, 'medium')
E.Options.args.info.args.donators = ACH:Group(L["Donations:"], nil, 7)
E.Options.args.info.args.donators.inline = true
E.Options.args.info.args.donators.args.string = ACH:Description(DONATOR_STRING, 1, 'medium')
local profileTypeItems = { profile = L["Profile"], private = L["Private (Character Settings)"], global = L["Global (Account Settings)"], filters = L["Aura Filters"], styleFilters = L["NamePlate Style Filters"] }
local profileTypeListOrder = { 'profile', 'private', 'global', 'filters', 'styleFilters' }
local exportTypeItems = { text = L["Text"], luaTable = L["Table"], luaPlugin = L["Plugin"] }
local exportTypeListOrder = { 'text', 'luaTable', 'luaPlugin' }
local exportString = ''
local function ExportImport_Open(mode)
local Frame = E.Libs.AceGUI:Create('Frame')
Frame:SetTitle('')
Frame:EnableResize(false)
Frame:SetWidth(800)
Frame:SetHeight(600)
Frame.frame:SetFrameStrata('FULLSCREEN_DIALOG')
Frame:SetLayout('flow')
local Box = E.Libs.AceGUI:Create('MultiLineEditBox-ElvUI')
Box:SetNumLines(30)
Box:DisableButton(true)
Box:SetWidth(800)
Box:SetLabel('')
Frame:AddChild(Box)
--Save original script so we can restore it later
Box.editBox.OnTextChangedOrig = Box.editBox:GetScript('OnTextChanged')
Box.editBox.OnCursorChangedOrig = Box.editBox:GetScript('OnCursorChanged')
--Remove OnCursorChanged script as it causes weird behaviour with long text
Box.editBox:SetScript('OnCursorChanged', nil)
Box.scrollFrame:UpdateScrollChildRect()
local Label1 = E.Libs.AceGUI:Create('Label')
local font = GameFontHighlightSmall:GetFont()
Label1:SetFont(font, 14)
Label1:SetText('.') --Set temporary text so height is set correctly
Label1:SetWidth(800)
Frame:AddChild(Label1)
local Label2 = E.Libs.AceGUI:Create('Label')
font = GameFontHighlightSmall:GetFont()
Label2:SetFont(font, 14)
Label2:SetText('.|n.')
Label2:SetWidth(800)
Frame:AddChild(Label2)
if mode == 'export' then
Frame:SetTitle(L["Export Profile"])
local ProfileTypeDropdown = E.Libs.AceGUI:Create('Dropdown')
ProfileTypeDropdown:SetMultiselect(false)
ProfileTypeDropdown:SetLabel(L["Choose What To Export"])
ProfileTypeDropdown:SetList(profileTypeItems, profileTypeListOrder)
ProfileTypeDropdown:SetValue('profile') --Default export
Frame:AddChild(ProfileTypeDropdown)
local ExportFormatDropdown = E.Libs.AceGUI:Create('Dropdown')
ExportFormatDropdown:SetMultiselect(false)
ExportFormatDropdown:SetLabel(L["Choose Export Format"])
ExportFormatDropdown:SetList(exportTypeItems, exportTypeListOrder)
ExportFormatDropdown:SetValue('text') --Default format
ExportFormatDropdown:SetWidth(150)
Frame:AddChild(ExportFormatDropdown)
local exportButton = E.Libs.AceGUI:Create('Button-ElvUI')
exportButton:SetText(L["Export Now"])
exportButton:SetAutoWidth(true)
exportButton:SetCallback('OnClick', function()
Label1:SetText('')
Label2:SetText('')
local profileType, exportFormat = ProfileTypeDropdown:GetValue(), ExportFormatDropdown:GetValue()
local profileKey, profileExport = D:ExportProfile(profileType, exportFormat)
if not profileKey or not profileExport then
Label1:SetText(L["Error exporting profile!"])
else
Label1:SetText(format('%s: %s%s|r', L["Exported"], E.media.hexvaluecolor, profileTypeItems[profileType]))
if profileType == 'profile' then
Label2:SetText(format('%s: %s%s|r', L["Profile Name"], E.media.hexvaluecolor, profileKey))
end
end
Box:SetText(profileExport)
Box.editBox:HighlightText()
Box:SetFocus()
exportString = profileExport
end)
Frame:AddChild(exportButton)
--Set scripts
Box.editBox:SetScript('OnChar', function()
Box:SetText(exportString)
Box.editBox:HighlightText()
end)
Box.editBox:SetScript('OnTextChanged', function(_, userInput)
if userInput then
--Prevent user from changing export string
Box:SetText(exportString)
Box.editBox:HighlightText()
else
--Scroll frame doesn't scroll to the bottom by itself, so let's do that now
Box.scrollFrame:SetVerticalScroll(Box.scrollFrame:GetVerticalScrollRange())
end
end)
elseif mode == 'import' then
Frame:SetTitle(L["Import Profile"])
local importButton = E.Libs.AceGUI:Create('Button-ElvUI') --This version changes text color on SetDisabled
importButton:SetDisabled(true)
importButton:SetText(L["Import Now"])
importButton:SetAutoWidth(true)
importButton:SetCallback('OnClick', function()
Label1:SetText('')
Label2:SetText('')
local success = D:ImportProfile(Box:GetText())
Label1:SetText((success and L["Profile imported successfully!"]) or L["Error decoding data. Import string may be corrupted!"])
end)
Frame:AddChild(importButton)
local decodeButton = E.Libs.AceGUI:Create('Button-ElvUI')
decodeButton:SetDisabled(true)
decodeButton:SetText(L["Decode Text"])
decodeButton:SetAutoWidth(true)
decodeButton:SetCallback('OnClick', function()
Label1:SetText('')
Label2:SetText('')
local profileType, profileKey, profileData = D:Decode(Box:GetText())
local decodedText = (profileData and E:TableToLuaString(profileData)) or nil
local importText = D:CreateProfileExport(decodedText, profileType, profileKey)
Box:SetText(importText)
end)
Frame:AddChild(decodeButton)
local oldText = ''
local function OnTextChanged()
local text = Box:GetText()
if text == '' then
Label1:SetText('')
Label2:SetText('')
importButton:SetDisabled(true)
decodeButton:SetDisabled(true)
elseif oldText ~= text then
local stringType = D:GetImportStringType(text)
if stringType == 'Base64' then
decodeButton:SetDisabled(false)
else
decodeButton:SetDisabled(true)
end
local profileType, profileKey = D:Decode(text)
if not profileType or (profileType and profileType == 'profile' and not profileKey) then
Label1:SetText(L["Error decoding data. Import string may be corrupted!"])
Label2:SetText('')
importButton:SetDisabled(true)
decodeButton:SetDisabled(true)
else
Label1:SetText(format('%s: %s%s|r', L["Importing"], E.media.hexvaluecolor, profileTypeItems[profileType] or ''))
if profileType == 'profile' then
Label2:SetText(format('%s: %s%s|r', L["Profile Name"], E.media.hexvaluecolor, profileKey))
end
--Scroll frame doesn't scroll to the bottom by itself, so let's do that now
Box.scrollFrame:UpdateScrollChildRect()
Box.scrollFrame:SetVerticalScroll(Box.scrollFrame:GetVerticalScrollRange())
importButton:SetDisabled(false)
end
oldText = text
end
end
Box.editBox:SetFocus()
Box.editBox:SetScript('OnChar', nil)
Box.editBox:SetScript('OnTextChanged', OnTextChanged)
end
Frame:SetCallback('OnClose', function(widget)
--Restore changed scripts
Box.editBox:SetScript('OnChar', nil)
Box.editBox:SetScript('OnTextChanged', Box.editBox.OnTextChangedOrig)
Box.editBox:SetScript('OnCursorChanged', Box.editBox.OnCursorChangedOrig)
Box.editBox.OnTextChangedOrig = nil
Box.editBox.OnCursorChangedOrig = nil
--Clear stored export string
exportString = ''
E.Libs.AceGUI:Release(widget)
E:Config_OpenWindow()
end)
--Clear default text
Label1:SetText('')
Label2:SetText('')
--Close ElvUI OptionsUI
E.Libs.AceConfigDialog:Close('ElvUI')
GameTooltip_Hide() --The tooltip from the Export/Import button stays on screen, so hide it
end
--Create Profiles Table
E.Options.args.profiles = ACH:Group(L["Profiles"], nil, 5, 'tab')
E.Options.args.profiles.args.desc = ACH:Description(L["This feature will allow you to transfer settings to other characters."], 0)
E.Options.args.profiles.args.distributeProfile = ACH:Execute(L["Share Current Profile"], L["Sends your current profile to your target."], 1, function() if not UnitExists('target') or not UnitIsPlayer('target') or not UnitIsFriend('player', 'target') or UnitIsUnit('player', 'target') then E:Print(L["You must be targeting a player."]) return end local name, server = UnitName('target') if name and (not server or server == '') then D:Distribute(name) elseif server then D:Distribute(name, true) end end, nil, nil, nil, nil, nil, function() return not E.global.general.allowDistributor end)
E.Options.args.profiles.args.distributeGlobal = ACH:Execute(L["Share Filters"], L["Sends your filter settings to your target."], 1, function() if not UnitExists('target') or not UnitIsPlayer('target') or not UnitIsFriend('player', 'target') or UnitIsUnit('player', 'target') then E:Print(L["You must be targeting a player."]) return end local name, server = UnitName('target') if name and (not server or server == '') then D:Distribute(name, false, true) elseif server then D:Distribute(name, true, true) end end, nil, nil, nil, nil, nil, function() return not E.global.general.allowDistributor end)
E.Options.args.profiles.args.exportProfile = ACH:Execute(L["Export Profile"], nil, 4, function() ExportImport_Open('export') end)
E.Options.args.profiles.args.importProfile = ACH:Execute(L["Import Profile"], nil, 5, function() ExportImport_Open('import') end)
E.Options.args.profiles.args.allowDistributor = ACH:Toggle(L["Allow Sharing"], L["Both users will need this option enabled."], 6, nil, nil, nil, function() return E.global.general.allowDistributor end, function(_, value) E.global.general.allowDistributor = value; D:UpdateSettings() end)
E.Options.args.profiles.args.spacer = ACH:Spacer(6)
E.Options.args.profiles.args.profile = E.Libs.AceDBOptions:GetOptionsTable(E.data)
E.Options.args.profiles.args.private = E.Libs.AceDBOptions:GetOptionsTable(E.charSettings)
E.Options.args.profiles.args.profile.name = L["Profile"]
E.Options.args.profiles.args.profile.order = 1
E.Options.args.profiles.args.private.name = L["Private"]
E.Options.args.profiles.args.private.order = 2
E.Libs.AceConfig:RegisterOptionsTable('ElvProfiles', E.Options.args.profiles.args.profile)
E.Libs.DualSpec:EnhanceOptions(E.Options.args.profiles.args.profile, E.data)
E.Libs.AceConfig:RegisterOptionsTable('ElvPrivates', E.Options.args.profiles.args.private)
E.Options.args.profiles.args.private.args.choose.confirm = function(info, value)
if info[#info-1] == 'private' then
return format(L["Choosing Settings %s. This will reload the UI.\n\n Are you sure?"], value)
else
return false
end
end
E.Options.args.profiles.args.private.args.copyfrom.confirm = function(info, value)
return format(L["Copy Settings from %s. This will overwrite %s profile.\n\n Are you sure?"], value, info.handler:GetCurrentProfile())
end
if GetAddOnEnableState(nil, 'ElvUI_Config') ~= 0 then
E:StaticPopup_Show('ELVUI_CONFIG_FOUND')
end

112
DataBars.lua Normal file
View File

@ -0,0 +1,112 @@
local E, _, V, P, G = unpack(ElvUI) --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local DB = E:GetModule('DataBars')
local ACH = E.Libs.ACH
local tonumber = tonumber
local SharedOptions = {
enable = ACH:Toggle(L["Enable"], nil, 1),
textFormat = ACH:Select(L["Text Format"], nil, 2, { NONE = L["NONE"], CUR = L["Current"], REM = L["Remaining"], PERCENT = L["Percent"], CURMAX = L["Current - Max"], CURPERC = L["Current - Percent"], CURREM = L["Current - Remaining"], CURPERCREM = L["Current - Percent (Remaining)"] }),
mouseover = ACH:Toggle(L["Mouseover"], nil, 3),
clickThrough = ACH:Toggle(L["Click Through"], nil, 4),
showBubbles = ACH:Toggle(L["Show Bubbles"], nil, 5),
sizeGroup = ACH:Group(L["Size"], nil, -3),
conditionGroup = ACH:MultiSelect(L["Conditions"], nil, -2),
fontGroup = ACH:Group(L["Fonts"], nil, -1),
}
SharedOptions.sizeGroup.inline = true
SharedOptions.sizeGroup.args.width = ACH:Range(L["Width"], nil, 1, { min = 5, max = ceil(GetScreenWidth() or 800), step = 1 })
SharedOptions.sizeGroup.args.height = ACH:Range(L["Height"], nil, 2, { min = 5, max = ceil(GetScreenWidth() or 800), step = 1 })
SharedOptions.sizeGroup.args.orientation = ACH:Select(L["Statusbar Fill Orientation"], L["Direction the bar moves on gains/losses"], 3, { AUTOMATIC = L["Automatic"], HORIZONTAL = L["Horizontal"], VERTICAL = L["Vertical"] })
SharedOptions.sizeGroup.args.reverseFill = ACH:Toggle(L["Reverse Fill Direction"], nil, 4)
SharedOptions.fontGroup.inline = true
SharedOptions.fontGroup.args.font = ACH:SharedMediaFont(L["Font"], nil, 1)
SharedOptions.fontGroup.args.fontSize = ACH:Range(L["Font Size"], nil, 2, C.Values.FontSize)
SharedOptions.fontGroup.args.fontOutline = ACH:Select(L["Font Outline"], nil, 3, C.Values.FontFlags)
E.Options.args.databars = ACH:Group(L["DataBars"], nil, 2, 'tab', function(info) return E.db.databars[info[#info]] end, function(info, value) E.db.databars[info[#info]] = value DB:UpdateAll() end)
E.Options.args.databars.args.intro = ACH:Description(L["Setup on-screen display of information bars."], 1)
E.Options.args.databars.args.spacer = ACH:Spacer(2)
E.Options.args.databars.args.general = ACH:Group(L["General"], nil, 3, nil, function(info) return E.db.databars[info[#info]] end, function(info, value) E.db.databars[info[#info]] = value DB:UpdateAll() end)
E.Options.args.databars.args.general.inline = true
E.Options.args.databars.args.general.args.transparent = ACH:Toggle(L["Transparent"], nil, 1)
E.Options.args.databars.args.general.args.customTexture = ACH:Toggle(L["Custom StatusBar"], nil, 2)
E.Options.args.databars.args.general.args.statusbar = ACH:SharedMediaStatusbar(L["StatusBar Texture"], nil, 3, nil, nil, nil, function() return not E.db.databars.customTexture end)
E.Options.args.databars.args.colorGroup = ACH:Group(L["COLORS"], nil, 4, nil, function(info) local t = E.db.databars.colors[info[#info]] local d = P.databars.colors[info[#info]] return t.r, t.g, t.b, t.a, d.r, d.g, d.b, d.a end)
E.Options.args.databars.args.colorGroup.inline = true
E.Options.args.databars.args.colorGroup.args.experience = ACH:Color(L["Experience"], nil, 1, true, nil, nil, function(info, r, g, b, a) local t = E.db.databars.colors[info[#info]] t.r, t.g, t.b, t.a = r, g, b, a DB:ExperienceBar_Update() end)
E.Options.args.databars.args.colorGroup.args.rested = ACH:Color(L["Rested Experience"], nil, 2, true, nil, nil, function(info, r, g, b, a) local t = E.db.databars.colors[info[#info]] t.r, t.g, t.b, t.a = r, g, b, a DB:ExperienceBar_Update() end)
E.Options.args.databars.args.colorGroup.args.quest = ACH:Color(L["Quest Experience"], nil, 3, true, nil, nil, function(info, r, g, b, a) local t = E.db.databars.colors[info[#info]] t.r, t.g, t.b, t.a = r, g, b, a DB:ExperienceBar_QuestXP() end)
E.Options.args.databars.args.colorGroup.args.honor = ACH:Color(L["Honor"], nil, 4, true, nil, nil, function(info, r, g, b, a) local t = E.db.databars.colors[info[#info]] t.r, t.g, t.b, t.a = r, g, b, a DB:HonorBar_Update() end)
E.Options.args.databars.args.colorGroup.args.azerite = ACH:Color(L["Azerite"], nil, 5, true, nil, nil, function(info, r, g, b, a) local t = E.db.databars.colors[info[#info]] t.r, t.g, t.b, t.a = r, g, b, a DB:AzeriteBar_Update() end)
E.Options.args.databars.args.colorGroup.args.useCustomFactionColors = ACH:Toggle(L["Custom Faction Colors"], L["Reputation"], 6, nil, nil, nil, function() return E.db.databars.colors.useCustomFactionColors end, function(_, value) E.db.databars.colors.useCustomFactionColors = value end)
E.Options.args.databars.args.colorGroup.args.factionColors = ACH:Group(' ', nil, nil, nil, function(info) local v = tonumber(info[#info]) local t = E.db.databars.colors.factionColors[v] local d = P.databars.colors.factionColors[v] return t.r, t.g, t.b, t.a, d.r, d.g, d.b end, function(info, r, g, b) local v = tonumber(info[#info]); local t = E.db.databars.colors.factionColors[v]; t.r, t.g, t.b = r, g, b end, nil, function() return not E.db.databars.colors.useCustomFactionColors end)
E.Options.args.databars.args.colorGroup.args.factionColors.inline = true
for i = 1, 8 do
E.Options.args.databars.args.colorGroup.args.factionColors.args[""..i] = ACH:Color(L["FACTION_STANDING_LABEL"..i], nil, i, true)
end
E.Options.args.databars.args.experience = ACH:Group(L["Experience"], nil, 1, nil, function(info) return DB.db.experience[info[#info]] end, function(info, value) DB.db.experience[info[#info]] = value DB:ExperienceBar_Update() DB:ExperienceBar_QuestXP() DB:UpdateAll() end)
E.Options.args.databars.args.experience.args = CopyTable(SharedOptions)
E.Options.args.databars.args.experience.args.showLevel = ACH:Toggle(L["Level"], nil, 6)
E.Options.args.databars.args.experience.args.enable.set = function(info, value) DB.db.experience[info[#info]] = value DB:ExperienceBar_Toggle() DB:UpdateAll() end
E.Options.args.databars.args.experience.args.textFormat.set = function(info, value) DB.db.experience[info[#info]] = value DB:ExperienceBar_Update() end
E.Options.args.databars.args.experience.args.conditionGroup.get = function(_, key) return DB.db.experience[key] end
E.Options.args.databars.args.experience.args.conditionGroup.set = function(_, key, value) DB.db.experience[key] = value DB:ExperienceBar_Update() DB:ExperienceBar_QuestXP() DB:UpdateAll() end
E.Options.args.databars.args.experience.args.conditionGroup.values = {
questCurrentZoneOnly = L["Quests in Current Zone Only"],
questCompletedOnly = L["Completed Quests Only"],
hideAtMaxLevel = L["Hide At Max Level"],
hideInVehicle = L["Hide In Vehicle"],
hideInCombat = L["Hide In Combat"],
}
E.Options.args.databars.args.reputation = ACH:Group(L["Reputation"], nil, 2, nil, function(info) return DB.db.reputation[info[#info]] end, function(info, value) DB.db.reputation[info[#info]] = value DB:ReputationBar_Update() DB:UpdateAll() end)
E.Options.args.databars.args.reputation.args = CopyTable(SharedOptions)
E.Options.args.databars.args.reputation.args.enable.set = function(info, value) DB.db.reputation[info[#info]] = value DB:ReputationBar_Toggle() DB:UpdateAll() end
E.Options.args.databars.args.reputation.args.textFormat.set = function(info, value) DB.db.reputation[info[#info]] = value DB:ReputationBar_Update() end
E.Options.args.databars.args.reputation.args.conditionGroup.get = function(_, key) return DB.db.reputation[key] end
E.Options.args.databars.args.reputation.args.conditionGroup.set = function(_, key, value) DB.db.reputation[key] = value DB:ReputationBar_Update() DB:UpdateAll() end
E.Options.args.databars.args.reputation.args.conditionGroup.values = {
hideInVehicle = L["Hide In Vehicle"],
hideInCombat = L["Hide In Combat"],
}
E.Options.args.databars.args.honor = ACH:Group(L["Honor"], nil, 3, nil, function(info) return DB.db.honor[info[#info]] end, function(info, value) DB.db.honor[info[#info]] = value DB:HonorBar_Update() DB:UpdateAll() end)
E.Options.args.databars.args.honor.args = CopyTable(SharedOptions)
E.Options.args.databars.args.honor.args.enable.set = function(info, value) DB.db.honor[info[#info]] = value DB:HonorBar_Toggle() DB:UpdateAll() end
E.Options.args.databars.args.honor.args.textFormat.set = function(info, value) DB.db.honor[info[#info]] = value DB:HonorBar_Update() end
E.Options.args.databars.args.honor.args.conditionGroup.get = function(_, key) return DB.db.honor[key] end
E.Options.args.databars.args.honor.args.conditionGroup.set = function(_, key, value) DB.db.honor[key] = value DB:HonorBar_Update() DB:UpdateAll() end
E.Options.args.databars.args.honor.args.conditionGroup.values = {
hideInVehicle = L["Hide In Vehicle"],
hideInCombat = L["Hide In Combat"],
hideOutsidePvP = L["Hide Outside PvP"],
hideBelowMaxLevel = L["Hide Below Max Level"],
}
E.Options.args.databars.args.threat = ACH:Group(L["Threat"], nil, 4, nil, function(info) return DB.db.threat[info[#info]] end, function(info, value) DB.db.threat[info[#info]] = value DB:ThreatBar_Update() DB:UpdateAll() end)
E.Options.args.databars.args.threat.args = CopyTable(SharedOptions)
E.Options.args.databars.args.threat.args.enable.set = function(info, value) DB.db.threat[info[#info]] = value DB:ThreatBar_Toggle() DB:UpdateAll() end
E.Options.args.databars.args.threat.args.textFormat = nil
E.Options.args.databars.args.threat.args.conditionGroup = nil
E.Options.args.databars.args.threat.args.showBubbles = nil
E.Options.args.databars.args.azerite = ACH:Group(L["Azerite"], nil, 5, nil, function(info) return DB.db.azerite[info[#info]] end, function(info, value) DB.db.azerite[info[#info]] = value DB:AzeriteBar_Update() DB:UpdateAll() end)
E.Options.args.databars.args.azerite.args = CopyTable(SharedOptions)
E.Options.args.databars.args.azerite.args.enable.set = function(info, value) DB.db.azerite[info[#info]] = value DB:AzeriteBar_Toggle() DB:UpdateAll() end
E.Options.args.databars.args.azerite.args.textFormat.set = function(info, value) DB.db.azerite[info[#info]] = value DB:AzeriteBar_Update() end
E.Options.args.databars.args.azerite.args.conditionGroup.get = function(_, key) return DB.db.azerite[key] end
E.Options.args.databars.args.azerite.args.conditionGroup.set = function(_, key, value) DB.db.azerite[key] = value DB:AzeriteBar_Update() DB:UpdateAll() end
E.Options.args.databars.args.azerite.args.conditionGroup.values = {
hideInVehicle = L["Hide In Vehicle"],
hideInCombat = L["Hide In Combat"],
hideAtMaxLevel = L["Hide At Max Level"],
}

923
DataTexts.lua Normal file
View File

@ -0,0 +1,923 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local DT = E:GetModule('DataTexts')
local Layout = E:GetModule('Layout')
local Chat = E:GetModule('Chat')
local Minimap = E:GetModule('Minimap')
local ACH = E.Libs.ACH
local _G = _G
local type, pairs, ipairs = type, pairs, ipairs
local gsub, next, wipe = gsub, next, wipe
local tonumber = tonumber
local tostring = tostring
local format = format
-- GLOBALS: AceGUIWidgetLSMlists
local currencyList = {}
local DTPanelOptions = {
numPoints = {
order = 2,
type = 'range',
name = L["Number of DataTexts"],
min = 1, max = 20, step = 1,
},
growth = {
order = 3,
type = 'select',
name = L["Growth"],
values = {
HORIZONTAL = 'HORIZONTAL',
VERTICAL = 'VERTICAL'
},
},
width = {
order = 4,
type = 'range',
name = L["Width"],
min = 24, max = E.screenwidth, step = 1,
},
height = {
order = 5,
type = 'range',
name = L["Height"],
min = 12, max = E.screenheight, step = 1,
},
textJustify = {
order = 6,
type = 'select',
name = L["Text Justify"],
desc = L["Sets the font instance's horizontal text alignment style."],
values = {
CENTER = L["Center"],
LEFT = L["Left"],
RIGHT = L["Right"],
},
},
templateGroup = {
order = 10,
type = 'multiselect',
name = L["Template"],
sortByValue = true,
values = {
backdrop = L["Backdrop"],
panelTransparency = L["Backdrop Transparency"],
mouseover = L["Mouse Over"],
border = L["Show Border"],
},
},
strataAndLevel = {
order = 15,
type = 'group',
name = L["Strata and Level"],
inline = true,
args = {
frameStrata = {
order = 2,
type = 'select',
name = L["Frame Strata"],
values = C.Values.Strata,
},
frameLevel = {
order = 5,
type = 'range',
name = L["Frame Level"],
min = 1, max = 128, step = 1,
},
},
},
tooltip = {
order = 20,
type = 'group',
name = L["Tooltip"],
inline = true,
args = {
tooltipXOffset = {
order = 1,
type = 'range',
name = L["X-Offset"],
min = -30, max = 30, step = 1,
},
tooltipYOffset = {
order = 2,
type = 'range',
name = L["Y-Offset"],
min = -30, max = 30, step = 1,
},
tooltipAnchor = {
order = 3,
type = 'select',
name = L["Anchor"],
values = {
ANCHOR_TOP = L["TOP"],
ANCHOR_RIGHT = L["RIGHT"],
ANCHOR_BOTTOM = L["BOTTOM"],
ANCHOR_LEFT = L["LEFT"],
ANCHOR_TOPRIGHT = L["TOPRIGHT"],
ANCHOR_BOTTOMRIGHT = L["BOTTOMRIGHT"],
ANCHOR_TOPLEFT = L["TOPLEFT"],
ANCHOR_BOTTOMLEFT = L["BOTTOMLEFT"],
ANCHOR_CURSOR = L["CURSOR"],
ANCHOR_CURSOR_LEFT = L["CURSOR_LEFT"],
ANCHOR_CURSOR_RIGHT = L["CURSOR_RIGHT"],
},
},
},
},
visibility = {
type = 'input',
order = 25,
name = L["Visibility State"],
desc = L["This works like a macro, you can run different situations to get the actionbar to show/hide differently.\n Example: '[combat] show;hide'"],
width = 'full',
},
}
local function ColorizeName(name, color)
return format('|cFF%s%s|r', color or 'ffd100', name)
end
local function PanelGroup_Delete(panel)
E.Options.args.datatexts.args.panels.args[panel] = nil
end
local function PanelGroup_Create(panel)
local opts = {
type = 'group',
name = ColorizeName(panel),
get = function(info) return E.db.datatexts.panels[panel][info[#info]] end,
set = function(info, value)
E.db.datatexts.panels[panel][info[#info]] = value
DT:UpdatePanelAttributes(panel, E.global.datatexts.customPanels[panel])
end,
args = {
enable = {
order = 0,
type = 'toggle',
name = L["Enable"],
},
panelOptions = {
order = -1,
name = L["Panel Options"],
type = 'group',
inline = true,
get = function(info) return E.global.datatexts.customPanels[panel][info[#info]] end,
set = function(info, value)
E.global.datatexts.customPanels[panel][info[#info]] = value
DT:UpdatePanelAttributes(panel, E.global.datatexts.customPanels[panel])
DT:PanelLayoutOptions()
end,
args = {
delete = {
order = -1,
type = 'execute',
name = L["Delete"],
width = 'full',
confirm = true,
func = function(info)
E.db.datatexts.panels[panel] = nil
E.global.datatexts.customPanels[panel] = nil
DT:ReleasePanel(panel)
PanelGroup_Delete(panel)
DT:PanelLayoutOptions()
E.Libs.AceConfigDialog:SelectGroup('ElvUI', 'datatexts', 'panels', 'newPanel')
end,
},
fonts = {
order = 10,
type = 'group',
name = L["Fonts"],
inline = true,
get = function(info)
local settings = E.global.datatexts.customPanels[panel]
if not settings.fonts then settings.fonts = E:CopyTable({}, G.datatexts.newPanelInfo.fonts) end
return settings.fonts[info[#info]]
end,
set = function(info, value)
E.global.datatexts.customPanels[panel].fonts[info[#info]] = value
DT:UpdatePanelAttributes(panel, E.global.datatexts.customPanels[panel])
end,
args = {
enable = {
type = 'toggle',
order = 1,
name = L["Enable"],
desc = L["This will override the global cooldown settings."],
disabled = E.noop,
},
fontSize = {
order = 3,
type = 'range',
name = L["Text Font Size"],
min = 10, max = 50, step = 1,
},
font = {
order = 4,
type = 'select',
name = L["Font"],
dialogControl = 'LSM30_Font',
values = AceGUIWidgetLSMlists.font,
},
fontOutline = {
order = 5,
type = 'select',
name = L["Font Outline"],
values = C.Values.FontFlags,
},
}
},
},
}
},
}
local panelOpts = E:CopyTable(opts.args.panelOptions.args, DTPanelOptions)
panelOpts.tooltip.args.tooltipYOffset.disabled = function() return E.global.datatexts.customPanels[panel].tooltipAnchor == 'ANCHOR_CURSOR' end
panelOpts.tooltip.args.tooltipXOffset.disabled = function() return E.global.datatexts.customPanels[panel].tooltipAnchor == 'ANCHOR_CURSOR' end
panelOpts.templateGroup.get = function(_, key) return E.global.datatexts.customPanels[panel][key] end
panelOpts.templateGroup.set = function(_, key, value) E.global.datatexts.customPanels[panel][key] = value; DT:UpdatePanelAttributes(panel, E.global.datatexts.customPanels[panel]) end
E.Options.args.datatexts.args.panels.args[panel] = opts
end
local dts = {[''] = L["NONE"]}
function DT:PanelLayoutOptions()
for name, data in pairs(DT.RegisteredDataTexts) do
dts[name] = data.localizedName or L[name]
end
local options = E.Options.args.datatexts.args.panels.args
-- Custom Panels
for panel in pairs(E.global.datatexts.customPanels) do
PanelGroup_Create(panel)
end
-- This will mixin the options for the Custom Panels.
for name, tab in pairs(DT.db.panels) do
if type(tab) == 'table' then
if not options[name] then
options[name] = {
type = 'group',
name = ColorizeName(name, 'ffffff'),
args = {},
get = function(info) return E.db.datatexts.panels[name][info[#info]] end,
set = function(info, value)
E.db.datatexts.panels[name][info[#info]] = value
DT:UpdatePanelInfo(name)
end,
}
end
if not P.datatexts.panels[name] and not E.global.datatexts.customPanels[name] then
options[name].args.delete = {
order = -1,
type = 'execute',
name = L["Delete"],
func = function()
E.db.datatexts.panels[name] = nil
options[name] = nil
DT:PanelLayoutOptions()
end,
}
end
for option in pairs(tab) do
if type(option) == 'number' then
if E.global.datatexts.customPanels[name] and option > E.global.datatexts.customPanels[name].numPoints then
tab[option] = nil
else
options[name].args[tostring(option)] = {
type = 'select',
order = option,
name = L[format('Position %d', option)],
values = dts,
get = function(info) return E.db.datatexts.panels[name][tonumber(info[#info])] end,
set = function(info, value)
E.db.datatexts.panels[name][tonumber(info[#info])] = value
DT:UpdatePanelInfo(name)
end,
}
end
end
end
end
end
end
local function CreateCustomCurrencyOptions(currencyID)
local currency = E.global.datatexts.customCurrencies[currencyID]
if currency then
E.Options.args.datatexts.args.customCurrency.args[currency.NAME] = {
order = 1,
type = 'group',
name = currency.NAME,
inline = false,
args = {
displayStyle = {
order = 1,
type = 'select',
name = L["Display Style"],
get = function(info) return E.global.datatexts.customCurrencies[currencyID].DISPLAY_STYLE end,
set = function(info, value)
E.global.datatexts.customCurrencies[currencyID].DISPLAY_STYLE = value
DT:UpdateCustomCurrencySettings(currency.NAME, 'DISPLAY_STYLE', value)
DT:LoadDataTexts()
end,
values = {
ICON = L["Icons Only"],
ICON_TEXT = L["Icons and Text"],
ICON_TEXT_ABBR = L["Icons and Text (Short)"],
},
},
showMax = {
order = 2,
type = 'toggle',
name = L["Current / Max"],
get = function(info) return E.global.datatexts.customCurrencies[currencyID].SHOW_MAX end,
set = function(info, value)
E.global.datatexts.customCurrencies[currencyID].SHOW_MAX = value
DT:UpdateCustomCurrencySettings(currency.NAME, 'SHOW_MAX', value)
DT:LoadDataTexts()
end,
},
useTooltip = {
order = 3,
type = 'toggle',
name = L["Use Tooltip"],
get = function(info) return E.global.datatexts.customCurrencies[currencyID].USE_TOOLTIP end,
set = function(info, value)
E.global.datatexts.customCurrencies[currencyID].USE_TOOLTIP = value
DT:UpdateCustomCurrencySettings(currency.NAME, 'USE_TOOLTIP', value)
end,
},
},
}
end
end
local function SetupCustomCurrencies()
for currencyID in pairs(E.global.datatexts.customCurrencies) do
CreateCustomCurrencyOptions(currencyID)
end
end
local function CreateDTOptions(name, data)
local settings = E.global.datatexts.settings[name]
if not settings then return end
local optionTable = {
order = 1,
type = "group",
name = data.localizedName or name,
inline = false,
get = function(info) return settings[info[#info]] end,
set = function(info, value) settings[info[#info]] = value DT:ForceUpdate_DataText(name) end,
args = {},
}
E.Options.args.datatexts.args.settings.args[name] = optionTable
for key in pairs(settings) do
if key == 'decimalLength' then
optionTable.args.decimalLength = {
type = 'range',
name = L["Decimal Length"],
min = 0, max = 5, step = 1,
}
elseif key == 'goldFormat' then
optionTable.args.goldFormat = {
type = 'select',
name = L["Gold Format"],
desc = L["The display format of the money text that is shown in the gold datatext and its tooltip."],
values = { SMART = L["Smart"], FULL = L["Full"], SHORT = L["SHORT"], SHORTINT = L["Short (Whole Numbers)"], CONDENSED = L["Condensed"], BLIZZARD = L["Blizzard Style"], BLIZZARD2 = L["Blizzard Style"].." 2" },
}
elseif key == 'goldCoins' then
optionTable.args.goldCoins = {
type = 'toggle',
name = L["Show Coins"],
desc = L["Use coin icons instead of colored text."],
}
elseif key == 'Label' then
optionTable.args.Label = {
order = 0,
type = 'input',
name = L["Label"],
get = function(info) return settings[info[#info]] and gsub(settings[info[#info]], '\124', '\124\124') end,
set = function(info, value) settings[info[#info]] = gsub(value, '\124\124+', '\124') DT:ForceUpdate_DataText(name) end,
}
elseif key == 'NoLabel' then
optionTable.args.NoLabel = {
type = 'toggle',
name = L["No Label"],
}
elseif key == 'ShowOthers' then
optionTable.args.ShowOthers = {
type = 'toggle',
name = L["Other AddOns"],
}
elseif key == 'textFormat' then
optionTable.args.textFormat = {
type = 'select',
name = L["Text Format"],
width = "double",
get = function(info) return settings[info[#info]] end,
set = function(info, value) settings[info[#info]] = value; DT:ForceUpdate_DataText(name) end,
values = {},
}
end
end
if name == 'Combat' then
optionTable.args.TimeFull = ACH:Toggle('Full Time')
elseif name == 'Currencies' then
optionTable.args.displayedCurrency = {
type = "select",
name = L["Displayed Currency"],
values = function() return DT.CurrencyList end,
sortByValue = true,
}
optionTable.args.displayStyle = {
type = "select",
name = L["Currency Format"],
hidden = function() return (settings.displayedCurrency == "GOLD") or (settings.displayedCurrency == "BACKPACK") end,
values = {
ICON = L["Icons Only"],
ICON_TEXT = L["Icons and Text"],
ICON_TEXT_ABBR = L["Icons and Text (Short)"],
},
}
optionTable.args.goldFormat.hidden = function() return (settings.displayedCurrency ~= "GOLD") end
optionTable.args.goldCoins.hidden = function() return (settings.displayedCurrency ~= "GOLD") end
optionTable.args.tooltipLines = {
order = -1,
type = 'group',
inline = true,
name = L["Tooltip Lines"],
args = {}
}
for i, info in ipairs(G.datatexts.settings.Currencies.tooltipData) do
if not info[2] then
optionTable.args.tooltipLines.args[tostring(i)] = {
order = i,
type = 'group',
inline = true,
name = info[1],
args = {
header = {
order = i,
type = 'toggle',
name = "Header",
get = function() return settings.tooltipData[i][4] end,
set = function(_, value) settings.tooltipData[i][4] = value end,
},
},
}
elseif info[3] then
optionTable.args.tooltipLines.args[tostring(info[3])].args[tostring(i)] = {
order = i,
type = 'toggle',
name = info[1],
get = function() return settings.tooltipData[i][4] end,
set = function(_, value) settings.tooltipData[i][4] = value end,
}
end
end
elseif name == 'Time' then
optionTable.args.time24 = {
type = 'toggle',
name = L["24-Hour Time"],
desc = L["Toggle 24-hour mode for the time datatext."],
}
optionTable.args.localTime = {
type = 'toggle',
name = L["Local Time"],
desc = L["If not set to true then the server time will be displayed instead."],
}
elseif name == 'Durability' then
optionTable.args.percThreshold = {
type = "range",
name = L["Flash Threshold"],
desc = L["The durability percent that the datatext will start flashing. Set to -1 to disable"],
min = -1, max = 99, step = 1,
get = function(info) return settings[info[#info]] end,
set = function(info, value) settings[info[#info]] = value; DT:ForceUpdate_DataText(name) end,
}
elseif name == 'Friends' then
optionTable.args.description = {
order = 1,
type = "description",
name = L["Hide specific sections in the datatext tooltip."],
}
optionTable.args.hideGroup1 = {
order = 2,
type = "multiselect",
name = L["Hide by Status"],
get = function(_, key) return settings[key] end,
set = function(_, key, value) settings[key] = value; DT:ForceUpdate_DataText(name) end,
values = {
hideAFK = L["AFK"],
hideDND = L["DND"],
},
}
optionTable.args.hideGroup2 = {
order = 2,
type = "multiselect",
name = L["Hide by Application"],
get = function(_, key) return settings['hide'..key] end,
set = function(_, key, value) settings['hide'..key] = value; DT:ForceUpdate_DataText(name) end,
sortByValue = true,
values = {
WoW = "World of Warcraft",
App = "App",
BSAp = L["Mobile"],
D3 = "Diablo 3",
WTCG = "Hearthstone",
Hero = "Heroes of the Storm",
Pro = "Overwatch",
S1 = "Starcraft",
S2 = "Starcraft 2",
VIPR = "COD: Black Ops 4",
ODIN = "COD: Modern Warfare",
LAZR = "COD: Modern Warfare 2",
ZEUS = "COD: Cold War"
},
}
elseif name == 'Reputation' or name == 'Experience' then
optionTable.args.textFormat.values = {
PERCENT = L["Percent"],
CUR = L["Current"],
REM = L["Remaining"],
CURMAX = L["Current - Max"],
CURPERC = L["Current - Percent"],
CURREM = L["Current - Remaining"],
CURPERCREM = L["Current - Percent (Remaining)"],
}
elseif name == 'Bags' then
optionTable.args.textFormat.values = {
["FREE"] = L["Only Free Slots"],
["USED"] = L["Only Used Slots"],
["FREE_TOTAL"] = L["Free/Total"],
["USED_TOTAL"] = L["Used/Total"],
}
end
end
local function SetupDTCustomization()
local currencyTable = {}
for name, data in pairs(DT.RegisteredDataTexts) do
currencyTable[name] = data
end
for _, info in pairs(E.global.datatexts.customCurrencies) do
local name = info.NAME
if currencyTable[name] then
currencyTable[name] = nil
end
end
for name, data in pairs(currencyTable) do
if not data.isLibDataBroker then
CreateDTOptions(name, data)
end
end
end
E.Options.args.datatexts = {
type = 'group',
name = L["DataTexts"],
childGroups = 'tab',
order = 2,
get = function(info) return E.db.datatexts[info[#info]] end,
set = function(info, value) E.db.datatexts[info[#info]] = value; DT:LoadDataTexts() end,
args = {
intro = ACH:Description(L["DATATEXT_DESC"], 1),
spacer = ACH:Spacer(2),
general = {
order = 3,
type = 'group',
name = L["General"],
args = {
generalGroup = {
order = 2,
type = 'group',
inline = true,
name = L["General"],
args = {
battleground = {
order = 3,
type = 'toggle',
name = L["Battleground Texts"],
desc = L["When inside a battleground display personal scoreboard information on the main datatext bars."],
},
noCombatClick = {
order = 6,
type = 'toggle',
name = L["Block Combat Click"],
desc = L["Blocks all click events while in combat."],
},
noCombatHover = {
order = 7,
type = 'toggle',
name = L["Block Combat Hover"],
desc = L["Blocks datatext tooltip from showing in combat."],
},
},
},
fontGroup = {
order = 3,
type = 'group',
inline = true,
name = L["Fonts"],
args = {
font = {
type = 'select', dialogControl = 'LSM30_Font',
order = 1,
name = L["Font"],
values = AceGUIWidgetLSMlists.font,
},
fontSize = {
order = 2,
name = L["FONT_SIZE"],
type = 'range',
min = 6, max = 64, step = 1,
},
fontOutline = {
order = 3,
name = L["Font Outline"],
desc = L["Set the font outline."],
type = 'select',
values = C.Values.FontFlags,
},
wordWrap = {
order = 4,
type = 'toggle',
name = L["Word Wrap"],
},
},
},
},
},
panels = {
type = 'group',
name = L["Panels"],
order = 4,
args = {
newPanel = {
order = 0,
type = 'group',
name = ColorizeName(L["New Panel"], '33ff33'),
get = function(info) return E.global.datatexts.newPanelInfo[info[#info]] end,
set = function(info, value) E.global.datatexts.newPanelInfo[info[#info]] = value end,
args = {
name = {
order = 0,
type = 'input',
width = 'full',
name = L["Name"],
validate = function(_, value)
return E.global.datatexts.customPanels[value] and L["Name Taken"] or true
end,
},
add = {
order = 1,
type = 'execute',
name = L["Add"],
width = 'full',
hidden = function()
local name = E.global.datatexts.newPanelInfo.name
return not name or name == ''
end,
func = function()
local name = E.global.datatexts.newPanelInfo.name
E.global.datatexts.customPanels[name] = E:CopyTable({}, E.global.datatexts.newPanelInfo)
E.db.datatexts.panels[name] = { enable = true }
for i = 1, E.global.datatexts.newPanelInfo.numPoints do
E.db.datatexts.panels[name][i] = ''
end
PanelGroup_Create(name)
DT:BuildPanelFrame(name, E.global.datatexts.customPanels[name])
DT:PanelLayoutOptions()
E.Libs.AceConfigDialog:SelectGroup('ElvUI', 'datatexts', 'panels', name)
E.global.datatexts.newPanelInfo = E:CopyTable({}, G.datatexts.newPanelInfo)
end,
},
},
},
LeftChatDataPanel = {
type = 'group',
name = ColorizeName(L["Datatext Panel (Left)"], 'cccccc'),
desc = L["Display data panels below the chat, used for datatexts."],
order = 2,
get = function(info) return E.db.datatexts.panels.LeftChatDataPanel[info[#info]] end,
set = function(info, value) E.db.datatexts.panels.LeftChatDataPanel[info[#info]] = value DT:UpdatePanelInfo('LeftChatDataPanel') Layout:SetDataPanelStyle() end,
args = {
enable = {
order = 0,
name = L["Enable"],
type = 'toggle',
set = function(info, value)
E.db.datatexts.panels[info[#info - 1]][info[#info]] = value
if E.db.LeftChatPanelFaded then
E.db.LeftChatPanelFaded = true;
_G.HideLeftChat()
end
if E.private.chat.enable then
Chat:UpdateEditboxAnchors()
end
Layout:ToggleChatPanels()
Layout:SetDataPanelStyle()
DT:UpdatePanelInfo('LeftChatDataPanel')
end,
},
backdrop = {
order = 5,
name = L["Backdrop"],
type = 'toggle',
},
border = {
order = 6,
name = L["Border"],
type = 'toggle',
disabled = function() return not E.db.datatexts.panels.LeftChatDataPanel.backdrop end,
},
panelTransparency = {
order = 7,
type = 'toggle',
name = L["Panel Transparency"],
disabled = function() return not E.db.datatexts.panels.LeftChatDataPanel.backdrop end,
},
},
},
RightChatDataPanel = {
type = 'group',
name = ColorizeName(L["Datatext Panel (Right)"], 'cccccc'),
desc = L["Display data panels below the chat, used for datatexts."],
order = 3,
get = function(info) return E.db.datatexts.panels.RightChatDataPanel[info[#info]] end,
set = function(info, value) E.db.datatexts.panels.RightChatDataPanel[info[#info]] = value DT:UpdatePanelInfo('RightChatDataPanel') Layout:SetDataPanelStyle() end,
args = {
enable = {
order = 0,
name = L["Enable"],
type = 'toggle',
set = function(info, value)
E.db.datatexts.panels[info[#info - 1]][info[#info]] = value
if E.db.RightChatPanelFaded then
E.db.RightChatPanelFaded = true;
_G.HideRightChat()
end
if E.private.chat.enable then
Chat:UpdateEditboxAnchors()
end
Layout:ToggleChatPanels()
Layout:SetDataPanelStyle()
DT:UpdatePanelInfo('RightChatDataPanel')
end,
},
backdrop = {
order = 5,
name = L["Backdrop"],
type = 'toggle',
},
border = {
order = 6,
name = L["Border"],
type = 'toggle',
disabled = function() return not E.db.datatexts.panels.RightChatDataPanel.backdrop end,
},
panelTransparency = {
order = 7,
type = 'toggle',
name = L["Panel Transparency"],
disabled = function() return not E.db.datatexts.panels.RightChatDataPanel.backdrop end,
},
},
},
MinimapPanel = {
type = 'group',
name = ColorizeName(L["Minimap Panels"], 'cccccc'),
desc = L["Display minimap panels below the minimap, used for datatexts."],
get = function(info) return E.db.datatexts.panels.MinimapPanel[info[#info]] end,
set = function(info, value) E.db.datatexts.panels.MinimapPanel[info[#info]] = value DT:UpdatePanelInfo('MinimapPanel') end,
hidden = function() return not E.private.general.minimap.enable end,
order = 4,
args = {
enable = {
order = 0,
name = L["Enable"],
type = 'toggle',
set = function(info, value)
E.db.datatexts.panels[info[#info - 1]][info[#info]] = value
DT:UpdatePanelInfo('MinimapPanel')
if E.private.general.minimap.enable then
Minimap:UpdateSettings()
end
end,
},
numPoints = {
order = 5,
type = 'range',
name = L["Number of DataTexts"],
min = 1, max = 2, step = 1,
},
backdrop = {
order = 6,
name = L["Backdrop"],
type = 'toggle',
},
border = {
order = 7,
name = L["Border"],
type = 'toggle',
disabled = function() return not E.db.datatexts.panels.MinimapPanel.backdrop end,
},
panelTransparency = {
order = 8,
type = 'toggle',
name = L["Panel Transparency"],
disabled = function() return not E.db.datatexts.panels.MinimapPanel.backdrop end,
},
},
},
},
},
customCurrency = {
order = 6,
type = 'group',
name = L["Custom Currency"],
args = {
description = ACH:Description(L["This allows you to create a new datatext which will track the currency with the supplied currency ID. The datatext can be added to a panel immediately after creation."], 0),
add = {
order = 1,
type = 'select',
name = L["Add Currency"],
width = 'double',
set = function(info, value)
local currencyID = tonumber(value)
if not currencyID then return; end
DT:RegisterCustomCurrencyDT(currencyID)
CreateCustomCurrencyOptions(currencyID)
DT:PanelLayoutOptions()
DT:LoadDataTexts()
end,
values = function()
local list = E:CopyTable({}, DT.CurrencyList)
list.GOLD = nil
list.BACKPACK = nil
return list
end,
},
delete = {
order = 2,
type = 'select',
width = 'double',
name = L["DELETE"],
set = function(info, value)
local currencyName = E.global.datatexts.customCurrencies[value].NAME
DT:RemoveCustomCurrency(currencyName)
E.Options.args.datatexts.args.customCurrency.args[currencyName] = nil
DT.RegisteredDataTexts[currencyName] = nil
E.global.datatexts.customCurrencies[value] = nil
dts[currencyName] = nil
DT:PanelLayoutOptions()
DT:LoadDataTexts()
end,
disabled = function() return not next(E.global.datatexts.customCurrencies) end,
values = function()
wipe(currencyList)
for currencyID, table in pairs(E.global.datatexts.customCurrencies) do
currencyList[currencyID] = table.NAME
end
return currencyList
end
},
},
},
settings = {
order = 7,
type = "group",
name = L["DataText Customization"],
args = {},
}
},
}
E:CopyTable(E.Options.args.datatexts.args.panels.args.newPanel.args, DTPanelOptions)
E.Options.args.datatexts.args.panels.args.newPanel.args.templateGroup.get = function(_, key) return E.global.datatexts.newPanelInfo[key] end
E.Options.args.datatexts.args.panels.args.newPanel.args.templateGroup.set = function(_, key, value) E.global.datatexts.newPanelInfo[key] = value end
DT:PanelLayoutOptions()
SetupCustomCurrencies()
SetupDTCustomization()

27
ElvUI_OptionsUI.toc Normal file
View File

@ -0,0 +1,27 @@
## Interface: 90001
## Author: Elv
## Version: 1.07
## Title: |cff1784d1ElvUI|r |cfd9b9b9bOptionsUI|r
## Notes: Options for ElvUI.
## RequiredDeps: ElvUI
## LoadOnDemand: 1
Libraries\Load_Libraries.xml
Locales\Load_Locales.xml
Core.lua
General.lua
ActionBars.lua
Auras.lua
Bags.lua
Chat.lua
Cooldown.lua
DataTexts.lua
DataBars.lua
Filters.lua
Skins.lua
Tooltip.lua
UnitFrames.lua
Nameplates.lua
Maps.lua
ModuleControl.lua
Tags.lua

745
Filters.lua Normal file
View File

@ -0,0 +1,745 @@
local E, _, V, P, G = unpack(ElvUI) --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local _, L = unpack(select(2, ...))
local UF = E:GetModule('UnitFrames')
local ACH = E.Libs.ACH
local gsub = gsub
local wipe = wipe
local next = next
local pairs = pairs
local format = format
local strmatch = strmatch
local tonumber = tonumber
local tostring = tostring
local GetSpellInfo = GetSpellInfo
-- GLOBALS: MAX_PLAYER_LEVEL
local quickSearchText, selectedSpell, selectedFilter, filterList, spellList = '', nil, nil, {}, {}
local defaultFilterList = { ['Aura Indicator (Global)'] = 'Aura Indicator (Global)', ['Aura Indicator (Class)'] = 'Aura Indicator (Class)', ['Aura Indicator (Pet)'] = 'Aura Indicator (Pet)', ['Aura Indicator (Profile)'] = 'Aura Indicator (Profile)', ['AuraBar Colors'] = 'AuraBar Colors', ['Aura Highlight'] = 'Aura Highlight' }
local auraBarDefaults = { enable = true, color = { r = 1, g = 1, b = 1 } }
local function GetSelectedFilters()
local class = selectedFilter == 'Aura Indicator (Class)'
local pet = selectedFilter == 'Aura Indicator (Pet)'
local profile = selectedFilter == 'Aura Indicator (Profile)'
local selected = (profile and E.db.unitframe.filters.aurawatch) or (pet and (E.global.unitframe.aurawatch.PET or {})) or class and (E.global.unitframe.aurawatch[E.myclass] or {}) or E.global.unitframe.aurawatch.GLOBAL
local default = (profile and P.unitframe.filters.aurawatch) or (pet and G.unitframe.aurawatch.PET) or class and G.unitframe.aurawatch[E.myclass] or G.unitframe.aurawatch.GLOBAL
return selected, default
end
local function GetSelectedSpell()
if selectedSpell and selectedSpell ~= '' then
local spell = strmatch(selectedSpell, ' %((%d+)%)$') or selectedSpell
if spell then
return tonumber(spell) or spell
end
end
end
local function filterMatch(s,v)
local m1, m2, m3, m4 = '^'..v..'$', '^'..v..',', ','..v..'$', ','..v..','
return (strmatch(s, m1) and m1) or (strmatch(s, m2) and m2) or (strmatch(s, m3) and m3) or (strmatch(s, m4) and v..',')
end
local function removePriority(value)
if not value then return end
local x,y,z=E.db.unitframe.units,E.db.nameplates.units;
for n, t in pairs(x) do
if t and t.buffs and t.buffs.priority and t.buffs.priority ~= '' then
z = filterMatch(t.buffs.priority, E:EscapeString(value))
if z then E.db.unitframe.units[n].buffs.priority = gsub(t.buffs.priority, z, '') end
end
if t and t.debuffs and t.debuffs.priority and t.debuffs.priority ~= '' then
z = filterMatch(t.debuffs.priority, E:EscapeString(value))
if z then E.db.unitframe.units[n].debuffs.priority = gsub(t.debuffs.priority, z, '') end
end
if t and t.aurabar and t.aurabar.priority and t.aurabar.priority ~= '' then
z = filterMatch(t.aurabar.priority, E:EscapeString(value))
if z then E.db.unitframe.units[n].aurabar.priority = gsub(t.aurabar.priority, z, '') end
end
end
for n, t in pairs(y) do
if t and t.buffs and t.buffs.priority and t.buffs.priority ~= '' then
z = filterMatch(t.buffs.priority, E:EscapeString(value))
if z then E.db.nameplates.units[n].buffs.priority = gsub(t.buffs.priority, z, '') end
end
if t and t.debuffs and t.debuffs.priority and t.debuffs.priority ~= '' then
z = filterMatch(t.debuffs.priority, E:EscapeString(value))
if z then E.db.nameplates.units[n].debuffs.priority = gsub(t.debuffs.priority, z, '') end
end
end
end
local function SetFilterList()
wipe(filterList)
E:CopyTable(filterList, defaultFilterList)
local list = E.global.unitframe.aurafilters
if list then
for filter in pairs(list) do
filterList[filter] = filter
end
end
return filterList
end
local function ResetFilterList()
wipe(filterList)
E:CopyTable(filterList, defaultFilterList)
local list = G.unitframe.aurafilters
if list then
for filter in pairs(list) do
filterList[filter] = filter
end
end
return filterList
end
local function DeleteFilterList()
wipe(filterList)
local list = E.global.unitframe.aurafilters
local defaultList = G.unitframe.aurafilters
if list then
for filter in pairs(list) do
if not defaultList[filter] then
filterList[filter] = filter
end
end
end
return filterList
end
local function DeleteFilterListDisable()
wipe(filterList)
local list = E.global.unitframe.aurafilters
local defaultList = G.unitframe.aurafilters
if list then
for filter in pairs(list) do
if not defaultList[filter] then
return false
end
end
end
return true
end
local function SetSpellList()
local list
if selectedFilter == 'Aura Highlight' then
list = E.global.unitframe.AuraHighlightColors
elseif selectedFilter == 'AuraBar Colors' then
list = E.global.unitframe.AuraBarColors
elseif selectedFilter == 'Aura Indicator (Pet)' or selectedFilter == 'Aura Indicator (Profile)' or selectedFilter == 'Aura Indicator (Class)' or selectedFilter == 'Aura Indicator (Global)' then
list = GetSelectedFilters()
else
list = E.global.unitframe.aurafilters[selectedFilter].spells
end
if not list then return end
wipe(spellList)
local searchText = quickSearchText:lower()
for filter, spell in pairs(list) do
if spell.id and (selectedFilter == 'Aura Indicator (Pet)' or selectedFilter == 'Aura Indicator (Profile)' or selectedFilter == 'Aura Indicator (Class)' or selectedFilter == 'Aura Indicator (Global)') then
filter = spell.id
end
local spellName = tonumber(filter) and GetSpellInfo(filter)
local name = (spellName and format('%s |cFF888888(%s)|r', spellName, filter)) or tostring(filter)
if name:lower():find(searchText) then
spellList[filter] = name
end
end
if not next(spellList) then
spellList[''] = L["NONE"]
end
return spellList
end
E.Options.args.filters = {
type = 'group',
name = L["FILTERS"],
order = 3,
childGroups = 'tab',
args = {
mainOptions = {
type = 'group',
name = 'Main Options',
order = 1,
args = {
createFilter = {
order = 1,
name = L["Create Filter"],
desc = L["Create a filter, once created a filter can be set inside the buffs/debuffs section of each unit."],
type = 'input',
get = function(info) return '' end,
set = function(info, value)
if strmatch(value, '^[%s%p]-$') then
return
end
if strmatch(value, ',') then
E:Print(L["Filters are not allowed to have commas in their name. Stripping commas from filter name."])
value = gsub(value, ',', '')
end
if strmatch(value, '^Friendly:') or strmatch(value, '^Enemy:') then
return --dont allow people to create Friendly: or Enemy: filters
end
if G.unitframe.specialFilters[value] or E.global.unitframe.aurafilters[value] then
E:Print(L["Filter already exists!"])
return
end
E.global.unitframe.aurafilters[value] = { spells = {} }
selectedFilter = value
end,
},
selectFilter = {
order = 2,
type = 'select',
name = L["Select Filter"],
get = function(info) return selectedFilter end,
set = function(info, value)
selectedFilter, selectedSpell, quickSearchText = nil, nil, ''
if value ~= '' then
selectedFilter = value
end
end,
values = SetFilterList,
},
deleteFilter = {
type = 'select',
order = 3,
name = L["Delete Filter"],
desc = L["Delete a created filter, you cannot delete pre-existing filters, only custom ones."],
confirm = function(info, value)
return 'Remove Filter - '..value
end,
set = function(info, value)
E.global.unitframe.aurafilters[value] = nil
selectedFilter, selectedSpell, quickSearchText = nil, nil, ''
removePriority(value) --This will wipe a filter from the new aura system profile settings.
end,
disabled = DeleteFilterListDisable,
values = DeleteFilterList,
},
resetGroup = {
type = 'select',
name = L["Reset Filter"],
order = 4,
desc = L["This will reset the contents of this filter back to default. Any spell you have added to this filter will be removed."],
confirm = function(info, value)
return 'Reset Filter - '..value
end,
set = function(info, value)
if value == 'Aura Highlight' then
E.global.unitframe.AuraHighlightColors = E:CopyTable({}, G.unitframe.DebuffHighlightColors)
elseif value == 'AuraBar Colors' then
E.global.unitframe.AuraBarColors = E:CopyTable({}, G.unitframe.AuraBarColors)
elseif value == 'Aura Indicator (Pet)' or value == 'Aura Indicator (Profile)' or value == 'Aura Indicator (Class)' or value == 'Aura Indicator (Global)' then
local selectedTable, defaultTable = GetSelectedFilters()
wipe(selectedTable)
E:CopyTable(selectedTable, defaultTable)
else
E.global.unitframe.aurafilters[value].spells = E:CopyTable({}, G.unitframe.aurafilters[value].spells)
end
selectedFilter, selectedSpell, quickSearchText = nil, nil, ''
UF:Update_AllFrames()
end,
values = ResetFilterList,
},
filterGroup = {
type = 'group',
name = function() return selectedFilter end,
hidden = function() return not selectedFilter end,
inline = true,
order = 10,
args = {
selectSpellheader = ACH:Description(L["|cffFF0000Warning:|r Click the arrow on the dropdown box to see a list of spells."], 0, 'medium'),
selectSpell = {
name = L["Select Spell"],
type = 'select',
order = 1,
customWidth = 350,
get = function(info) return selectedSpell or '' end,
set = function(info, value)
selectedSpell = (value ~= '' and value) or nil
end,
values = SetSpellList,
},
quickSearch = {
order = 2,
name = L["Filter Search"],
desc = L["Search for a spell name inside of a filter."],
type = 'input',
customWidth = 200,
get = function() return quickSearchText end,
set = function(info,value) quickSearchText = value end,
},
filterType = {
order = 3,
name = L["Filter Type"],
desc = L["Set the filter type. Blacklist will hide any auras in the list and show all others. Whitelist will show any auras in the filter and hide all others."],
type = 'select',
values = {
Whitelist = L["Whitelist"],
Blacklist = L["Blacklist"],
},
get = function() return E.global.unitframe.aurafilters[selectedFilter].type end,
set = function(info, value) E.global.unitframe.aurafilters[selectedFilter].type = value; UF:Update_AllFrames(); end,
hidden = function() return (selectedFilter == 'Aura Highlight' or selectedFilter == 'AuraBar Colors' or selectedFilter == 'Aura Indicator (Pet)' or selectedFilter == 'Aura Indicator (Profile)' or selectedFilter == 'Aura Indicator (Class)' or selectedFilter == 'Aura Indicator (Global)' or selectedFilter == 'Whitelist' or selectedFilter == 'Blacklist') end,
},
removeSpell = {
order = 4,
name = L["Remove Spell"],
desc = L["Remove a spell from the filter. Use the spell ID if you see the ID as part of the spell name in the filter."],
type = 'select',
confirm = function(info, value)
local spellName = tonumber(value) and GetSpellInfo(value)
local name = (spellName and format('%s |cFF888888(%s)|r', spellName, value)) or tostring(value)
return 'Remove Spell - '..name
end,
customWidth = 350,
get = function(info) return '' end,
set = function(info, value)
if not value then return end
selectedSpell = nil
if selectedFilter == 'Aura Highlight' then
E.global.unitframe.AuraHighlightColors[value] = nil;
elseif selectedFilter == 'AuraBar Colors' then
if G.unitframe.AuraBarColors[value] then
E.global.unitframe.AuraBarColors[value].enable = false;
else
E.global.unitframe.AuraBarColors[value] = nil;
end
elseif selectedFilter == 'Aura Indicator (Pet)' or selectedFilter == 'Aura Indicator (Profile)' or selectedFilter == 'Aura Indicator (Class)' or selectedFilter == 'Aura Indicator (Global)' then
local selectedTable, defaultTable = GetSelectedFilters()
if defaultTable[value] then
selectedTable[value].enabled = false
else
selectedTable[value] = nil
end
elseif G.unitframe.aurafilters[selectedFilter] and G.unitframe.aurafilters[selectedFilter].spells[value] then
E.global.unitframe.aurafilters[selectedFilter].spells[value].enable = false;
else
E.global.unitframe.aurafilters[selectedFilter].spells[value] = nil;
end
UF:Update_AllFrames();
end,
values = SetSpellList,
},
addSpell = {
order = 5,
name = L["Add SpellID"],
desc = L["Add a spell to the filter."],
type = 'input',
customWidth = 200,
get = function(info) return '' end,
set = function(info, value)
value = tonumber(value)
if not value then return end
local spellName = GetSpellInfo(value)
selectedSpell = (spellName and value) or nil
if not selectedSpell then return end
if selectedFilter == 'Aura Highlight' then
if not E.global.unitframe.AuraHighlightColors[value] then
E.global.unitframe.AuraHighlightColors[value] = { enable = true, style = 'GLOW', color = {r = 0.8, g = 0, b = 0, a = 0.85} }
end
elseif selectedFilter == 'AuraBar Colors' then
if not E.global.unitframe.AuraBarColors[value] then
E.global.unitframe.AuraBarColors[value] = E:CopyTable({}, auraBarDefaults)
end
elseif selectedFilter == 'Aura Indicator (Pet)' or selectedFilter == 'Aura Indicator (Profile)' or selectedFilter == 'Aura Indicator (Class)' or selectedFilter == 'Aura Indicator (Global)' then
local selectedTable = GetSelectedFilters()
if not selectedTable[value] then
selectedTable[value] = UF:AuraWatch_AddSpell(value, 'TOPRIGHT')
end
elseif not E.global.unitframe.aurafilters[selectedFilter].spells[value] then
E.global.unitframe.aurafilters[selectedFilter].spells[value] = { enable = true, priority = 0, stackThreshold = 0 }
end
UF:Update_AllFrames()
end,
},
},
},
buffIndicator = {
type = 'group',
name = function()
local spell = GetSelectedSpell()
local spellName = spell and GetSpellInfo(spell)
return (spellName and spellName..' |cFF888888('..spell..')|r') or spell or ' '
end,
hidden = function() return not selectedSpell or (selectedFilter ~= 'Aura Indicator (Pet)' and selectedFilter ~= 'Aura Indicator (Profile)' and selectedFilter ~= 'Aura Indicator (Class)' and selectedFilter ~= 'Aura Indicator (Global)') end,
get = function(info)
local spell = GetSelectedSpell()
if not spell then return end
local selectedTable = GetSelectedFilters()
return selectedTable[spell][info[#info]]
end,
set = function(info, value)
local spell = GetSelectedSpell()
if not spell then return end
local selectedTable = GetSelectedFilters()
selectedTable[spell][info[#info]] = value;
UF:Update_AllFrames()
end,
order = -10,
inline = true,
args = {
enabled = {
name = L["Enable"],
order = 1,
type = 'toggle',
},
point = {
name = L["Anchor Point"],
order = 2,
type = 'select',
values = {
TOPLEFT = 'TOPLEFT',
LEFT = 'LEFT',
BOTTOMLEFT = 'BOTTOMLEFT',
RIGHT = 'RIGHT',
TOPRIGHT = 'TOPRIGHT',
BOTTOMRIGHT = 'BOTTOMRIGHT',
CENTER = 'CENTER',
TOP = 'TOP',
BOTTOM = 'BOTTOM',
}
},
style = {
name = L["Style"],
order = 3,
type = 'select',
values = {
timerOnly = L["Timer Only"],
coloredIcon = L["Colored Icon"],
texturedIcon = L["Textured Icon"],
},
},
color = {
name = L["COLOR"],
type = 'color',
order = 4,
get = function(info)
local spell = GetSelectedSpell()
if not spell then return end
local selectedTable = GetSelectedFilters()
local t = selectedTable[spell][info[#info]]
return t.r, t.g, t.b, t.a
end,
set = function(info, r, g, b)
local spell = GetSelectedSpell()
if not spell then return end
local selectedTable = GetSelectedFilters()
local t = selectedTable[spell][info[#info]]
t.r, t.g, t.b = r, g, b
UF:Update_AllFrames()
end,
disabled = function()
local spell = GetSelectedSpell()
if not spell then return end
local selectedTable = GetSelectedFilters()
return selectedTable[spell].style == 'texturedIcon'
end,
},
sizeOffset = {
order = 5,
type = 'range',
name = L["Size Offset"],
desc = L["This changes the size of the Aura Icon by this value."],
min = -25, max = 25, step = 1,
},
xOffset = {
order = 6,
type = 'range',
name = L["X-Offset"],
min = -75, max = 75, step = 1,
},
yOffset = {
order = 7,
type = 'range',
name = L["Y-Offset"],
min = -75, max = 75, step = 1,
},
textThreshold = {
name = L["Text Threshold"],
desc = L["At what point should the text be displayed. Set to -1 to disable."],
type = 'range',
order = 8,
min = -1, max = 60, step = 1,
},
anyUnit = {
name = L["Show Aura From Other Players"],
order = 9,
customWidth = 205,
type = 'toggle',
},
onlyShowMissing = {
name = L["Show When Not Active"],
order = 10,
type = 'toggle',
},
displayText = {
name = L["Display Text"],
type = 'toggle',
order = 11,
get = function(info)
local spell = GetSelectedSpell()
if not spell then return end
local selectedTable = GetSelectedFilters()
return (selectedTable[spell].style == 'timerOnly') or selectedTable[spell][info[#info]]
end,
disabled = function()
local spell = GetSelectedSpell()
if not spell then return end
local selectedTable = GetSelectedFilters()
return selectedTable[spell].style == 'timerOnly'
end
},
},
},
spellGroup = {
type = 'group',
name = function()
local spell = GetSelectedSpell()
local spellName = spell and GetSpellInfo(spell)
return (spellName and spellName..' |cFF888888('..spell..')|r') or spell or ' '
end,
hidden = function() return not selectedSpell or (selectedFilter == 'Aura Indicator (Pet)' or selectedFilter == 'Aura Indicator (Profile)' or selectedFilter == 'Aura Indicator (Class)' or selectedFilter == 'Aura Indicator (Global)') end,
order = -15,
inline = true,
args = {
enabled = {
name = L["Enable"],
order = 0,
type = 'toggle',
hidden = function() return (selectedFilter == 'Aura Indicator (Pet)' or selectedFilter == 'Aura Indicator (Profile)' or selectedFilter == 'Aura Indicator (Class)' or selectedFilter == 'Aura Indicator (Global)') end,
get = function(info)
local spell = GetSelectedSpell()
if not spell then return end
if selectedFilter == 'Aura Highlight' then
return E.global.unitframe.AuraHighlightColors[spell].enable
elseif selectedFilter == 'AuraBar Colors' then
return E.global.unitframe.AuraBarColors[spell].enable
else
return E.global.unitframe.aurafilters[selectedFilter].spells[spell].enable
end
end,
set = function(info, value)
local spell = GetSelectedSpell()
if not spell then return end
if selectedFilter == 'Aura Highlight' then
E.global.unitframe.AuraHighlightColors[spell].enable = value
elseif selectedFilter == 'AuraBar Colors' then
E.global.unitframe.AuraBarColors[spell].enable = value
else
E.global.unitframe.aurafilters[selectedFilter].spells[spell].enable = value
end
UF:Update_AllFrames();
end,
},
style = {
name = L["Style"],
type = 'select',
order = 1,
values = { GLOW = L["Glow"], FILL = L["Fill"] },
hidden = function() return selectedFilter ~= 'Aura Highlight' end,
get = function(info)
local spell = GetSelectedSpell()
if not spell then return end
return E.global.unitframe.AuraHighlightColors[spell].style
end,
set = function(info, value)
local spell = GetSelectedSpell()
if not spell then return end
E.global.unitframe.AuraHighlightColors[spell].style = value
UF:Update_AllFrames()
end,
},
color = {
name = L["COLOR"],
type = 'color',
order = 2,
hasAlpha = function() return selectedFilter ~= 'AuraBar Colors' end,
hidden = function() return (selectedFilter ~= 'Aura Highlight' and selectedFilter ~= 'AuraBar Colors' and selectedFilter ~= 'Aura Indicator (Pet)' and selectedFilter ~= 'Aura Indicator (Profile)' and selectedFilter ~= 'Aura Indicator (Class)' and selectedFilter ~= 'Aura Indicator (Global)') end,
get = function(info)
local spell = GetSelectedSpell()
if not spell then return end
local t
if selectedFilter == 'Aura Highlight' then
t = E.global.unitframe.AuraHighlightColors[spell].color
elseif selectedFilter == 'AuraBar Colors' then
t = E.global.unitframe.AuraBarColors[spell].color
end
if t then
return t.r, t.g, t.b, t.a
end
end,
set = function(info, r, g, b, a)
local spell = GetSelectedSpell()
if not spell then return end
local t
if selectedFilter == 'Aura Highlight' then
t = E.global.unitframe.AuraHighlightColors[spell].color
elseif selectedFilter == 'AuraBar Colors' then
t = E.global.unitframe.AuraBarColors[spell].color
end
if t then
t.r, t.g, t.b, t.a = r, g, b, a
UF:Update_AllFrames()
end
end,
},
removeColor = {
type = 'execute',
order = 3,
name = L["Restore Defaults"],
hidden = function() return selectedFilter ~= 'AuraBar Colors' end,
func = function(info)
local spell = GetSelectedSpell()
if not spell then return end
if G.unitframe.AuraBarColors[spell] then
E.global.unitframe.AuraBarColors[spell] = E:CopyTable({}, G.unitframe.AuraBarColors[spell])
else
E.global.unitframe.AuraBarColors[spell] = E:CopyTable({}, auraBarDefaults)
end
UF:Update_AllFrames();
end,
},
forDebuffIndicator = {
order = 4,
type = 'group',
name = L["Used as RaidDebuff Indicator"],
inline = true,
hidden = function() return (selectedFilter == 'Aura Highlight' or selectedFilter == 'AuraBar Colors' or selectedFilter == 'Aura Indicator (Pet)' or selectedFilter == 'Aura Indicator (Profile)' or selectedFilter == 'Aura Indicator (Class)' or selectedFilter == 'Aura Indicator (Global)') end,
args = {
priority = {
order = 1,
type = 'range',
name = L["Priority"],
desc = L["Set the priority order of the spell, please note that prioritys are only used for the raid debuff module, not the standard buff/debuff module. If you want to disable set to zero."],
min = 0, max = 99, step = 1,
get = function()
local spell = GetSelectedSpell()
if not spell then
return 0
else
return E.global.unitframe.aurafilters[selectedFilter].spells[spell].priority
end
end,
set = function(info, value)
local spell = GetSelectedSpell()
if not spell then return end
E.global.unitframe.aurafilters[selectedFilter].spells[spell].priority = value;
UF:Update_AllFrames();
end,
},
stackThreshold = {
order = 2,
type = 'range',
name = L["Stack Threshold"],
desc = L["The debuff needs to reach this amount of stacks before it is shown. Set to 0 to always show the debuff."],
min = 0, max = 99, step = 1,
get = function()
local spell = GetSelectedSpell()
if not spell then
return 0
else
return E.global.unitframe.aurafilters[selectedFilter].spells[spell].stackThreshold
end
end,
set = function(info, value)
local spell = GetSelectedSpell()
if not spell then return end
E.global.unitframe.aurafilters[selectedFilter].spells[spell].stackThreshold = value
UF:Update_AllFrames()
end,
},
},
},
},
}
},
},
}
}
E.Options.args.filters.args.help = ACH:Group('Help', nil, 2)
local COLOR = E:ClassColor(E.myclass, true)
local COLOR1 = format('|c%s', COLOR.colorStr)
local COLOR2 = '|cFFFFFFFF'
local FilterHelp = {
'*Whitelists:|r ^Personal, nonPersonal, Boss, CastByUnit, notCastByUnit, Dispellable (includes steal-able), CastByNPC, CastByPlayers|r',
'*Blacklists:|r ^blockNonPersonal, blockNoDuration, blockCastByPlayers | A blacklist filter is only effective against filters that come after it in the priority list. It will not block anything from the filters before it.|r',
'^A blacklist filter is only effective against filters that come after it in the priority list. It will not block anything from the filters before it.',
' ',
'*Boss:|r ^Auras (debuffs only?) cast by a boss unit.|r',
'*Personal:|r ^Auras cast by yourself.|r',
'*nonPersonal:|r ^Auras cast by anyone other than yourself.|r',
'*CastByUnit:|r ^Auras cast by the unit of the unitframe or nameplate (so on target frame it only shows auras cast by the target unit).|r',
'*notCastByUnit:|r ^Auras cast by anyone other than the unit of the unitframe or nameplate.|r',
'*Dispellable:|r ^Auras you can either dispel or spellsteal.|r',
'*CastByNPC:|r ^Auras cast by any NPC.|r',
'*CastByPlayers:|r ^Auras cast by any player-controlled unit (so no NPCs).|r',
'*blockCastByPlayers:|r ^Blocks any aura that is cast by player-controlled units (so will only show auras cast by NPCs).|r',
'*blockNoDuration:|r ^Blocks any aura without a duration.|r',
'*blockNonPersonal:|r ^Blocks any aura that is not cast by yourself.|r',
' ',
'*Show Everything:|r ^Set "Max Duration" to 0 & Leave Priority List Empty or (1) Personal | (2) nonPersonal',
'*Block Blacklisted Auras, Show Everything Else:|r ^(1) Blacklist| (2) Personal | (3) nonPersonal',
'*Block Auras Without Duration, Show Everything Else:|r ^(1) blockNoDuration | (2) Personal | (3) nonPersonal',
'*Block Auras Without Duration, Block Blacklisted Auras, Show Everything Else:|r ^(1) blockNoDuration | (2) Blacklist | (3) Personal | (4) nonPersonal',
'*Block Everything, Except Your Own Auras:|r ^(1) Personal',
'*Block Everything, Except Whitelisted Auras:|r ^(1) Whitelist',
'*Block Everything, Except Whitelisted Auras That Are Cast By Yourself:|r ^(1) blockNonPersonal | (2) Whitelist'
}
for i, text in ipairs(FilterHelp) do
E.Options.args.filters.args.help.args['help'..i] = ACH:Description(text:gsub('*', COLOR1):gsub('%^', COLOR2), i, 'medium')
end
function E:SetToFilterConfig(filter)
selectedSpell = nil
quickSearchText = ''
selectedFilter = filter or ''
E.Libs.AceConfigDialog:SelectGroup('ElvUI', 'filters')
end

971
General.lua Normal file
View File

@ -0,0 +1,971 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local Misc = E:GetModule('Misc')
local Layout = E:GetModule('Layout')
local Totems = E:GetModule('Totems')
local Blizzard = E:GetModule('Blizzard')
local NP = E:GetModule('NamePlates')
local UF = E:GetModule('UnitFrames')
local AFK = E:GetModule('AFK')
local ACH = E.Libs.ACH
local _G = _G
local IsAddOnLoaded = IsAddOnLoaded
local IsMouseButtonDown = IsMouseButtonDown
local FCF_GetNumActiveChatFrames = FCF_GetNumActiveChatFrames
local function GetChatWindowInfo()
local ChatTabInfo = {}
for i = 1, FCF_GetNumActiveChatFrames() do
ChatTabInfo['ChatFrame'..i] = _G['ChatFrame'..i..'Tab']:GetText()
end
return ChatTabInfo
end
E.Options.args.general = {
type = 'group',
name = L["General"],
order = 1,
childGroups = 'tab',
get = function(info) return E.db.general[info[#info]] end,
set = function(info, value) E.db.general[info[#info]] = value end,
args = {
general = {
order = 5,
type = 'group',
name = L["General"],
args = {
loginmessage = {
order = 4,
type = 'toggle',
name = L["Login Message"],
},
taintLog = {
order = 5,
type = 'toggle',
name = L["Log Taints"],
desc = L["Send ADDON_ACTION_BLOCKED errors to the Lua Error frame. These errors are less important in most cases and will not effect your game performance. Also a lot of these errors cannot be fixed. Please only report these errors if you notice a Defect in gameplay."],
},
bottomPanel = {
order = 6,
type = 'toggle',
name = L["Bottom Panel"],
desc = L["Display a panel across the bottom of the screen. This is for cosmetic only."],
set = function(info, value) E.db.general.bottomPanel = value; Layout:BottomPanelVisibility() end
},
topPanel = {
order = 7,
type = 'toggle',
name = L["Top Panel"],
desc = L["Display a panel across the top of the screen. This is for cosmetic only."],
set = function(info, value) E.db.general.topPanel = value; Layout:TopPanelVisibility() end
},
afk = {
order = 8,
type = 'toggle',
name = L["AFK Mode"],
desc = L["When you go AFK display the AFK screen."],
set = function(info, value) E.db.general.afk = value; AFK:Toggle() end
},
eyefinity = {
order = 9,
name = L["Multi-Monitor Support"],
desc = L["Attempt to support eyefinity/nvidia surround."],
type = 'toggle',
get = function(info) return E.global.general.eyefinity end,
set = function(info, value) E.global.general.eyefinity = value; E:StaticPopup_Show('GLOBAL_RL') end,
},
ultrawide = {
order = 10,
name = L["Ultrawide Support"],
desc = L["Attempts to center UI elements in a 16:9 format for ultrawide monitors"],
type = 'toggle',
get = function(info) return E.global.general.ultrawide end,
set = function(info, value) E.global.general.ultrawide = value; E:StaticPopup_Show('GLOBAL_RL') end,
},
autoAcceptInvite = {
order = 11,
name = L["Accept Invites"],
desc = L["Automatically accept invites from guild/friends."],
type = 'toggle',
},
autoRoll = {
order = 12,
name = L["Auto Greed/DE"],
desc = L["Automatically select greed or disenchant (when available) on green quality items. This will only work if you are the max level."],
type = 'toggle',
disabled = function() return not E.private.general.lootRoll end
},
autoTrackReputation = {
order = 13,
name = L["Auto Track Reputation"],
type = 'toggle',
},
spacer1 = ACH:Spacer(15, 'full'),
locale = {
order = 16,
type = 'select',
name = L["LANGUAGE"],
get = function(info) return E.global.general.locale end,
set = function(info, value)
E.global.general.locale = value
E:StaticPopup_Show('CONFIG_RL')
end,
values = {
deDE = 'Deutsch',
enUS = 'English',
esMX = 'Español',
frFR = 'Français',
ptBR = 'Português',
ruRU = 'Русский',
zhCN = '简体中文',
zhTW = '正體中文',
koKR = '한국어',
itIT = 'Italiano',
},
},
messageRedirect = {
order = 17,
name = L["Chat Output"],
desc = L["This selects the Chat Frame to use as the output of ElvUI messages."],
type = 'select',
values = GetChatWindowInfo()
},
numberPrefixStyle = {
order = 18,
type = 'select',
name = L["Unit Prefix Style"],
desc = L["The unit prefixes you want to use when values are shortened in ElvUI. This is mostly used on UnitFrames."],
set = function(info, value)
E.db.general.numberPrefixStyle = value
E:BuildPrefixValues()
E:StaticPopup_Show('CONFIG_RL')
end,
values = {
TCHINESE = '萬, 億',
CHINESE = '万, 亿',
ENGLISH = 'K, M, B',
GERMAN = 'Tsd, Mio, Mrd',
KOREAN = '천, 만, 억',
METRIC = 'k, M, G'
},
},
interruptAnnounce = {
order = 19,
name = L["Announce Interrupts"],
desc = L["Announce when you interrupt a spell to the specified chat channel."],
type = 'select',
values = {
NONE = L["NONE"],
SAY = L["SAY"],
YELL = L["YELL"],
PARTY = L["Party Only"],
RAID = L["Party / Raid"],
RAID_ONLY = L["Raid Only"],
EMOTE = L["CHAT_MSG_EMOTE"],
},
set = function(info, value)
E.db.general[info[#info]] = value
if value == 'NONE' then
Misc:UnregisterEvent('COMBAT_LOG_EVENT_UNFILTERED')
else
Misc:RegisterEvent('COMBAT_LOG_EVENT_UNFILTERED')
end
end,
},
autoRepair = {
order = 20,
name = L["Auto Repair"],
desc = L["Automatically repair using the following method when visiting a merchant."],
type = 'select',
values = {
NONE = L["NONE"],
GUILD = L["GUILD"],
PLAYER = L["PLAYER"],
},
},
spacer2 = ACH:Spacer(25, 'full'),
decimalLength = {
order = 26,
type = 'range',
name = L["Decimal Length"],
desc = L["Controls the amount of decimals used in values displayed on elements like NamePlates and UnitFrames."],
min = 0, max = 4, step = 1,
set = function(info, value)
E.db.general.decimalLength = value
E:BuildPrefixValues()
E:StaticPopup_Show('CONFIG_RL')
end,
},
smoothingAmount = {
order = 27,
type = 'range',
isPercent = true,
name = L["Smoothing Amount"],
desc = L["Controls the speed at which smoothed bars will be updated."],
min = 0.2, max = 0.8, softMax = 0.75, softMin = 0.25, step = 0.01,
set = function(info, value)
E.db.general.smoothingAmount = value
E:SetSmoothingAmount(value)
end,
},
UIScale = {
order = 28,
type = 'range',
name = L["UI_SCALE"],
min = 0.1, max = 1.25, step = 0.000000000000001,
softMin = 0.40, softMax = 1.15, bigStep = 0.01,
get = function(info) return E.global.general.UIScale end,
set = function(info, value)
E.global.general.UIScale = value
if not IsMouseButtonDown() then
E:PixelScaleChanged()
end
end
},
AutoScale = {
order = 29,
type = 'execute',
name = L["Auto Scale"],
func = function()
E.global.general.UIScale = E:PixelBestSize()
E:PixelScaleChanged()
end,
},
totems = {
order = 55,
type = 'group',
inline = true,
name = L["Class Totems"],
get = function(info) return E.db.general.totems[info[#info]] end,
set = function(info, value) E.db.general.totems[info[#info]] = value; Totems:PositionAndSize() end,
args = {
enable = {
order = 2,
type = 'toggle',
name = L["Enable"],
get = function() return E.private.general.totemBar end,
set = function(_, value) E.private.general.totemBar = value; E:StaticPopup_Show('PRIVATE_RL') end,
},
size = {
order = 3,
type = 'range',
name = L["Button Size"],
min = 24, max = 60, step = 1,
disabled = function() return not E.private.general.totemBar end,
},
spacing = {
order = 4,
type = 'range',
name = L["Button Spacing"],
min = 1, max = 10, step = 1,
disabled = function() return not E.private.general.totemBar end,
},
sortDirection = {
order = 5,
type = 'select',
name = L["Sort Direction"],
disabled = function() return not E.private.general.totemBar end,
values = {
ASCENDING = L["Ascending"],
DESCENDING = L["Descending"],
},
},
growthDirection = {
order = 6,
type = 'select',
name = L["Bar Direction"],
disabled = function() return not E.private.general.totemBar end,
values = {
VERTICAL = L["Vertical"],
HORIZONTAL = L["Horizontal"],
},
},
},
},
},
},
media = {
order = 10,
type = 'group',
name = L["Media"],
get = function(info) return E.db.general[info[#info]] end,
set = function(info, value) E.db.general[info[#info]] = value end,
args = {
fontGroup = {
order = 50,
name = L["Font"],
type = 'group',
inline = true,
args = {
main = {
order = 1,
type = 'group',
name = ' ',
args = {
font = {
type = 'select', dialogControl = 'LSM30_Font',
order = 1,
name = L["Default Font"],
desc = L["The font that the core of the UI will use."],
values = AceGUIWidgetLSMlists.font,
set = function(info, value) E.db.general[info[#info]] = value; E:UpdateMedia(); E:UpdateFontTemplates(); end,
},
fontSize = {
order = 2,
name = L["FONT_SIZE"],
desc = L["Set the font size for everything in UI. Note: This doesn't effect somethings that have their own seperate options (UnitFrame Font, Datatext Font, ect..)"],
type = 'range',
min = 6, max = 64, step = 1,
softMin = 8, softMax = 32,
set = function(info, value) E.db.general[info[#info]] = value; E:UpdateMedia(); E:UpdateFontTemplates(); end,
},
fontStyle = {
type = 'select',
order = 3,
name = L["Font Outline"],
values = C.Values.FontFlags,
set = function(info, value) E.db.general[info[#info]] = value; E:UpdateMedia(); E:UpdateFontTemplates(); end,
},
applyFontToAll = {
order = 4,
type = 'execute',
name = L["Apply Font To All"],
desc = L["Applies the font and font size settings throughout the entire user interface. Note: Some font size settings will be skipped due to them having a smaller font size by default."],
func = function() E:StaticPopup_Show('APPLY_FONT_WARNING'); end,
},
replaceBlizzFonts = {
order = 5,
type = 'toggle',
name = L["Replace Blizzard Fonts"],
desc = L["Replaces the default Blizzard fonts on various panels and frames with the fonts chosen in the Media section of the ElvUI Options. NOTE: Any font that inherits from the fonts ElvUI usually replaces will be affected as well if you disable this. Enabled by default."],
get = function(info) return E.private.general[info[#info]] end,
set = function(info, value) E.private.general[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL'); end,
},
unifiedBlizzFonts = {
order = 6,
type = 'toggle',
name = L["Unified Font Sizes"],
desc = L["This setting mimics the older style of Replace Blizzard Fonts, with a more static unified font sizing."],
get = function(info) return E.private.general[info[#info]] end,
set = function(info, value) E.private.general[info[#info]] = value; E:UpdateBlizzardFonts() end,
},
},
},
replaceCombatFont = {
order = 6,
type = 'toggle',
name = L["Replace Combat Font"],
get = function(info) return E.private.general[info[#info]] end,
set = function(info, value) E.private.general[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL'); end,
},
dmgfont = {
type = 'select', dialogControl = 'LSM30_Font',
order = 7,
name = L["CombatText Font"],
desc = L["The font that combat text will use. |cffFF0000WARNING: This requires a game restart or re-log for this change to take effect.|r"],
disabled = function() return not E.private.general.replaceCombatFont end,
values = AceGUIWidgetLSMlists.font,
get = function(info) return E.private.general[info[#info]] end,
set = function(info, value) E.private.general[info[#info]] = value; E:UpdateMedia(); E:UpdateFontTemplates(); E:StaticPopup_Show('PRIVATE_RL'); end,
},
replaceNameFont = {
order = 8,
type = 'toggle',
name = L["Replace Name Font"],
get = function(info) return E.private.general[info[#info]] end,
set = function(info, value) E.private.general[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL'); end,
},
namefont = {
type = 'select', dialogControl = 'LSM30_Font',
order = 9,
name = L["Name Font"],
desc = L["The font that appears on the text above players heads. |cffFF0000WARNING: This requires a game restart or re-log for this change to take effect.|r"],
disabled = function() return not E.private.general.replaceNameFont end,
values = AceGUIWidgetLSMlists.font,
get = function(info) return E.private.general[info[#info]] end,
set = function(info, value) E.private.general[info[#info]] = value; E:UpdateMedia(); E:UpdateFontTemplates(); E:StaticPopup_Show('PRIVATE_RL'); end,
},
},
},
textureGroup = {
order = 51,
name = L["Textures"],
type = 'group',
inline = true,
get = function(info) return E.private.general[info[#info]] end,
args = {
normTex = {
type = 'select', dialogControl = 'LSM30_Statusbar',
order = 1,
name = L["Primary Texture"],
desc = L["The texture that will be used mainly for statusbars."],
values = AceGUIWidgetLSMlists.statusbar,
set = function(info, value)
E.private.general[info[#info]] = value;
E:UpdateMedia()
E:UpdateStatusBars()
end
},
glossTex = {
type = 'select', dialogControl = 'LSM30_Statusbar',
order = 2,
name = L["Secondary Texture"],
desc = L["This texture will get used on objects like chat windows and dropdown menus."],
values = AceGUIWidgetLSMlists.statusbar,
set = function(info, value)
E.private.general[info[#info]] = value;
E:UpdateMedia()
E:UpdateFrameTemplates()
end
},
applyTextureToAll = {
order = 3,
type = 'execute',
name = L["Copy Primary Texture"],
desc = L["Replaces the StatusBar texture setting on Unitframes and Nameplates with the primary texture."],
func = function()
E.db.unitframe.statusbar = E.private.general.normTex
UF:Update_StatusBars()
E.db.nameplates.statusbar = E.private.general.normTex
NP:ConfigureAll()
end,
},
},
},
bordersGroup = {
order = 52,
name = L["Borders"],
type = 'group',
inline = true,
args = {
uiThinBorders = {
order = 1,
name = L["Thin Borders"],
desc = L["The Thin Border Theme option will change the overall apperance of your UI. Using Thin Border Theme is a slight performance increase over the traditional layout."],
type = 'toggle',
get = function(info) return E.private.general.pixelPerfect end,
set = function(info, value)
E.private.general.pixelPerfect = value
E:StaticPopup_Show('PRIVATE_RL')
end
},
ufThinBorders = {
order = 2,
name = L["Unitframe Thin Borders"],
desc = L["Use thin borders on certain unitframe elements."],
type = 'toggle',
get = function(info) return E.db.unitframe.thinBorders end,
set = function(info, value)
E.db.unitframe.thinBorders = value
E:StaticPopup_Show('CONFIG_RL')
end,
},
npThinBorders = {
order = 2,
name = L["Nameplate Thin Borders"],
desc = L["Use thin borders on certain nameplate elements."],
type = 'toggle',
get = function(info) return E.db.nameplates.thinBorders end,
set = function(info, value)
E.db.nameplates.thinBorders = value
E:StaticPopup_Show('CONFIG_RL')
end,
},
cropIcon = {
order = 3,
type = 'toggle',
tristate = true,
name = L["Crop Icons"],
desc = L["This is for Customized Icons in your Interface/Icons folder."],
get = function(info)
local value = E.db.general[info[#info]]
if value == 2 then return true
elseif value == 1 then return nil
else return false end
end,
set = function(info, value)
E.db.general[info[#info]] = (value and 2) or (value == nil and 1) or 0
E:StaticPopup_Show('PRIVATE_RL')
end,
},
}
},
colorsGroup = {
order = 52,
name = L["Colors"],
type = 'group',
inline = true,
get = function(info)
local t = E.db.general[info[#info]]
local d = P.general[info[#info]]
return t.r, t.g, t.b, t.a, d.r, d.g, d.b, d.a
end,
set = function(info, r, g, b, a)
local setting = info[#info]
local t = E.db.general[setting]
t.r, t.g, t.b, t.a = r, g, b, a
E:UpdateMedia()
if setting == 'bordercolor' then
E:UpdateBorderColors()
elseif setting == 'backdropcolor' or setting == 'backdropfadecolor' then
E:UpdateBackdropColors()
end
end,
args = {
backdropcolor = {
type = 'color',
order = 1,
name = L["Backdrop Color"],
desc = L["Main backdrop color of the UI."],
hasAlpha = false,
},
backdropfadecolor = {
type = 'color',
order = 2,
name = L["Backdrop Faded Color"],
desc = L["Backdrop color of transparent frames"],
hasAlpha = true,
},
valuecolor = {
type = 'color',
order = 3,
name = L["Value Color"],
desc = L["Color some texts use."],
hasAlpha = false,
},
spacer1 = ACH:Spacer(9, 'full'),
uiBorderColors = {
type = 'color',
order = 10,
name = L["Border Color"],
desc = L["Main border color of the UI."],
get = function(info)
local t = E.db.general.bordercolor
local d = P.general.bordercolor
return t.r, t.g, t.b, t.a, d.r, d.g, d.b, d.a
end,
set = function(info, r, g, b, a)
local t = E.db.general.bordercolor
t.r, t.g, t.b, t.a = r, g, b, a
E:UpdateMedia()
E:UpdateBorderColors()
end,
},
ufBorderColors = {
order = 11,
type = 'color',
name = L["Unitframes Border Color"],
get = function(info)
local t = E.db.unitframe.colors.borderColor
local d = P.unitframe.colors.borderColor
return t.r, t.g, t.b, t.a, d.r, d.g, d.b, d.a
end,
set = function(info, r, g, b, a)
local t = E.db.unitframe.colors.borderColor
t.r, t.g, t.b, t.a = r, g, b, a
E:UpdateMedia()
E:UpdateBorderColors()
end,
},
},
},
}
},
alternativePowerGroup = {
order = 15,
type = 'group',
name = L["Alternative Power"],
get = function(info) return E.db.general.altPowerBar[info[#info]] end,
set = function(info, value)
E.db.general.altPowerBar[info[#info]] = value;
Blizzard:UpdateAltPowerBarSettings();
end,
args = {
enable = {
order = 2,
type = 'toggle',
name = L["Enable"],
desc = L["Replace Blizzard's Alternative Power Bar"],
width = 'full',
set = function(info, value)
E.db.general.altPowerBar[info[#info]] = value;
E:StaticPopup_Show('PRIVATE_RL');
end,
},
width = {
order = 3,
type = 'range',
name = L["Width"],
min = 50, max = 1000, step = 1,
},
height = {
order = 4,
type = 'range',
name = L["Height"],
min = 5, max = 100, step = 1,
},
statusBarGroup = {
order = 5,
name = L["Status Bar"],
type = 'group',
inline = true,
set = function(info, value)
E.db.general.altPowerBar[info[#info]] = value;
Blizzard:UpdateAltPowerBarColors();
end,
get = function(info)
return E.db.general.altPowerBar[info[#info]]
end,
args = {
smoothbars = {
type = 'toggle',
order = 1,
name = L["Smooth Bars"],
desc = L["Bars will transition smoothly."],
},
statusBar = {
order = 2,
type = 'select', dialogControl = 'LSM30_Statusbar',
name = L["StatusBar Texture"],
values = AceGUIWidgetLSMlists.statusbar,
},
statusBarColorGradient = {
order = 3,
name = L["Color Gradient"],
type = 'toggle',
},
statusBarColor = {
type = 'color',
order = 4,
name = L["COLOR"],
disabled = function()
return E.db.general.altPowerBar.statusBarColorGradient
end,
get = function(info)
local t = E.db.general.altPowerBar[info[#info]]
local d = P.general.altPowerBar[info[#info]]
return t.r, t.g, t.b, t.a, d.r, d.g, d.b
end,
set = function(info, r, g, b)
local t = E.db.general.altPowerBar[info[#info]]
t.r, t.g, t.b = r, g, b
Blizzard:UpdateAltPowerBarColors()
end,
},
},
},
textGroup = {
order = 6,
name = L["Text"],
type = 'group',
inline = true,
set = function(info, value)
E.db.general.altPowerBar[info[#info]] = value;
Blizzard:UpdateAltPowerBarSettings()
end,
get = function(info)
return E.db.general.altPowerBar[info[#info]]
end,
args = {
font = {
type = 'select', dialogControl = 'LSM30_Font',
order = 1,
name = L["Font"],
values = AceGUIWidgetLSMlists.font,
},
fontSize = {
order = 2,
name = L["FONT_SIZE"],
type = 'range',
min = 6, max = 24, step = 1,
},
fontOutline = {
order = 3,
type = 'select',
name = L["Font Outline"],
values = C.Values.FontFlags,
},
textFormat = {
order = 4,
type = 'select',
name = L["Text Format"],
sortByValue = true,
values = {
NONE = L["NONE"],
NAME = L["NAME"],
NAMEPERC = L["Name: Percent"],
NAMECURMAX = L["Name: Current / Max"],
NAMECURMAXPERC = L["Name: Current / Max - Percent"],
PERCENT = L["Percent"],
CURMAX = L["Current / Max"],
CURMAXPERC = L["Current / Max - Percent"],
},
},
},
},
},
},
blizzUIImprovements = {
order = 20,
type = 'group',
name = L["BlizzUI Improvements"],
args = {
loot = {
order = 1,
type = 'toggle',
name = L["Loot"],
desc = L["Enable/Disable the loot frame."],
get = function(info) return E.private.general.loot end,
set = function(info, value) E.private.general.loot = value; E:StaticPopup_Show('PRIVATE_RL') end
},
lootRoll = {
order = 2,
type = 'toggle',
name = L["Loot Roll"],
desc = L["Enable/Disable the loot roll frame."],
get = function(info) return E.private.general.lootRoll end,
set = function(info, value) E.private.general.lootRoll = value; E:StaticPopup_Show('PRIVATE_RL') end
},
hideErrorFrame = {
order = 3,
name = L["Hide Error Text"],
desc = L["Hides the red error text at the top of the screen while in combat."],
type = 'toggle'
},
enhancedPvpMessages = {
order = 4,
type = 'toggle',
name = L["Enhanced PVP Messages"],
desc = L["Display battleground messages in the middle of the screen."],
},
showMissingTalentAlert = {
order = 5,
type = 'toggle',
name = L["Missing Talent Alert"],
desc = L["Show an alert frame if you have unspend talent points."],
get = function(info) return E.global.general.showMissingTalentAlert end,
set = function(info, value) E.global.general.showMissingTalentAlert = value; E:StaticPopup_Show('GLOBAL_RL') end,
},
raidUtility = {
order = 6,
type = 'toggle',
name = L["RAID_CONTROL"],
desc = L["Enables the ElvUI Raid Control panel."],
get = function(info) return E.private.general.raidUtility end,
set = function(info, value) E.private.general.raidUtility = value; E:StaticPopup_Show('PRIVATE_RL') end
},
voiceOverlay = {
order = 7,
type = 'toggle',
name = L["Voice Overlay"],
desc = L["Replace Blizzard's Voice Overlay."],
get = function(info) return E.private.general.voiceOverlay end,
set = function(info, value) E.private.general.voiceOverlay = value; E:StaticPopup_Show('PRIVATE_RL') end
},
disableTutorialButtons = {
order = 8,
type = 'toggle',
name = L["Disable Tutorial Buttons"],
desc = L["Disables the tutorial button found on some frames."],
get = function(info) return E.global.general.disableTutorialButtons end,
set = function(info, value) E.global.general.disableTutorialButtons = value; E:StaticPopup_Show('GLOBAL_RL') end,
},
resurrectSound = {
order = 9,
type = 'toggle',
name = L["Resurrect Sound"],
desc = L["Enable to hear sound if you receive a resurrect."],
},
vehicleSeatIndicatorSize = {
order = 10,
type = 'range',
name = L["Vehicle Seat Indicator Size"],
min = 64, max = 128, step = 4,
get = function(info) return E.db.general.vehicleSeatIndicatorSize end,
set = function(info, value) E.db.general.vehicleSeatIndicatorSize = value; Blizzard:UpdateVehicleFrame() end,
},
durabilityScale = {
order = 11,
type = 'range',
name = L["Durability Scale"],
min = 0.5, max = 8, step = 0.5,
get = function(info) return E.db.general.durabilityScale end,
set = function(info, value) E.db.general.durabilityScale = value; Blizzard:UpdateDurabilityScale() end,
},
commandBarSetting = {
order = 12,
type = 'select',
name = L["Order Hall Command Bar"],
get = function(info) return E.global.general.commandBarSetting end,
set = function(info, value) E.global.general.commandBarSetting = value; E:StaticPopup_Show('GLOBAL_RL') end,
width = 'normal',
values = {
DISABLED = L["Disable"],
ENABLED = L["Enable"],
ENABLED_RESIZEPARENT = L["Enable + Adjust Movers"],
},
},
questRewardMostValueIcon = {
order = 13,
type = 'toggle',
name = L["Mark Quest Reward"],
desc = L["Marks the most valuable quest reward with a gold coin."],
},
itemLevelInfo = {
order = 14,
name = L["Item Level"],
type = 'group',
inline = true,
get = function(info) return E.db.general.itemLevel[info[#info]] end,
args = {
displayCharacterInfo = {
order = 1,
type = 'toggle',
name = L["Display Character Info"],
desc = L["Shows item level of each item, enchants, and gems on the character page."],
set = function(info, value)
E.db.general.itemLevel.displayCharacterInfo = value;
Misc:ToggleItemLevelInfo()
end
},
displayInspectInfo = {
order = 2,
type = 'toggle',
name = L["Display Inspect Info"],
desc = L["Shows item level of each item, enchants, and gems when inspecting another player."],
set = function(info, value)
E.db.general.itemLevel.displayInspectInfo = value;
Misc:ToggleItemLevelInfo()
end
},
fontGroup = {
order = 3,
type = 'group',
name = L["Fonts"],
disabled = function() return not E.db.general.itemLevel.displayCharacterInfo and not E.db.general.itemLevel.displayInspectInfo end,
get = function(info) return E.db.general.itemLevel[info[#info]] end,
set = function(info, value)
E.db.general.itemLevel[info[#info]] = value
Misc:UpdateInspectPageFonts('Character')
Misc:UpdateInspectPageFonts('Inspect')
end,
args = {
itemLevelFont = {
order = 1,
type = 'select',
name = L["Font"],
dialogControl = 'LSM30_Font',
values = AceGUIWidgetLSMlists.font,
},
itemLevelFontSize = {
order = 2,
type = 'range',
name = L["FONT_SIZE"],
min = 4, max = 42, step = 1,
},
itemLevelFontOutline = {
order = 3,
type = 'select',
name = L["Font Outline"],
values = C.Values.FontFlags,
},
},
},
},
},
objectiveFrameGroup = {
order = 15,
type = 'group',
inline = true,
name = L["Objective Frame"],
get = function(info) return E.db.general[info[#info]] end,
args = {
objectiveFrameAutoHide = {
order = 31,
type = 'toggle',
name = L["Auto Hide"],
desc = L["Automatically hide the objective frame during boss or arena fights."],
disabled = function() return IsAddOnLoaded('!KalielsTracker') end,
set = function(info, value) E.db.general.objectiveFrameAutoHide = value; Blizzard:SetObjectiveFrameAutoHide(); end,
},
objectiveFrameAutoHideInKeystone = {
order = 32,
type = 'toggle',
name = L["Hide In Keystone"],
hidden = function() return not E.db.general.objectiveFrameAutoHide end,
set = function(info, value) E.db.general.objectiveFrameAutoHideInKeystone = value end,
},
objectiveFrameHeight = {
order = 33,
type = 'range',
name = L["Objective Frame Height"],
desc = L["Height of the objective tracker. Increase size to be able to see more objectives."],
min = 400, max = E.screenheight, step = 1,
set = function(info, value) E.db.general.objectiveFrameHeight = value; Blizzard:SetObjectiveFrameHeight(); end,
},
bonusObjectivePosition = {
order = 34,
type = 'select',
name = L["Bonus Reward Position"],
desc = L["Position of bonus quest reward frame relative to the objective tracker."],
values = {
RIGHT = L["Right"],
LEFT = L["Left"],
AUTO = L["Automatic"],
},
},
},
},
chatBubblesGroup = {
order = 16,
type = 'group',
inline = true,
name = L["Chat Bubbles"],
get = function(info) return E.private.general[info[#info]] end,
set = function(info, value) E.private.general[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL') end,
args = {
chatBubbles = {
order = 2,
type = 'select',
name = L["Chat Bubbles Style"],
desc = L["Skin the blizzard chat bubbles."],
values = {
backdrop = L["Skin Backdrop"],
nobackdrop = L["Remove Backdrop"],
backdrop_noborder = L["Skin Backdrop (No Borders)"],
disabled = L["DISABLE"],
}
},
chatBubbleFont = {
order = 3,
type = 'select',
name = L["Font"],
dialogControl = 'LSM30_Font',
values = AceGUIWidgetLSMlists.font,
},
chatBubbleFontSize = {
order = 4,
type = 'range',
name = L["FONT_SIZE"],
min = 6, max = 64, step = 1,
},
chatBubbleFontOutline = {
order = 5,
type = 'select',
name = L["Font Outline"],
values = C.Values.FontFlags,
},
chatBubbleName = {
order = 6,
type = 'toggle',
name = L["Chat Bubble Names"],
desc = L["Display the name of the unit on the chat bubble. This will not work if backdrop is disabled or when you are in an instance."],
},
},
},
},
},
},
}

58
Libraries/Ace3/AceConfig-3.0/AceConfig-3.0.lua Normal file
View File

@ -0,0 +1,58 @@
--- AceConfig-3.0 wrapper library.
-- Provides an API to register an options table with the config registry,
-- as well as associate it with a slash command.
-- @class file
-- @name AceConfig-3.0
-- @release $Id$
--[[
AceConfig-3.0
Very light wrapper library that combines all the AceConfig subcomponents into one more easily used whole.
]]
local cfgreg = LibStub("AceConfigRegistry-3.0-ElvUI")
local cfgcmd = LibStub("AceConfigCmd-3.0-ElvUI")
local MAJOR, MINOR = "AceConfig-3.0-ElvUI", 3
local AceConfig = LibStub:NewLibrary(MAJOR, MINOR)
if not AceConfig then return end
--TODO: local cfgdlg = LibStub("AceConfigDialog-3.0", true)
--TODO: local cfgdrp = LibStub("AceConfigDropdown-3.0", true)
-- Lua APIs
local pcall, error, type, pairs = pcall, error, type, pairs
-- -------------------------------------------------------------------
-- :RegisterOptionsTable(appName, options, slashcmd, 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

8
Libraries/Ace3/AceConfig-3.0/AceConfig-3.0.xml Normal file
View File

@ -0,0 +1,8 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Include file="AceConfigRegistry-3.0\AceConfigRegistry-3.0.xml"/>
<Include file="AceConfigCmd-3.0\AceConfigCmd-3.0.xml"/>
<Include file="AceConfigDialog-3.0\AceConfigDialog-3.0.xml"/>
<!--<Include file="AceConfigDropdown-3.0\AceConfigDropdown-3.0.xml"/>-->
<Script file="AceConfig-3.0.lua"/>
</Ui>

794
Libraries/Ace3/AceConfig-3.0/AceConfigCmd-3.0/AceConfigCmd-3.0.lua Normal file
View File

@ -0,0 +1,794 @@
--- 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
Handles commandline optionstable access
REQUIRES: AceConsole-3.0 for command registration (loaded on demand)
]]
-- TODO: plugin args
local cfgreg = LibStub("AceConfigRegistry-3.0-ElvUI")
local MAJOR, MINOR = "AceConfigCmd-3.0-ElvUI", 14
local AceConfigCmd = LibStub:NewLibrary(MAJOR, MINOR)
if not AceConfigCmd then return end
AceConfigCmd.commands = AceConfigCmd.commands or {}
local commands = AceConfigCmd.commands
local AceConsole -- LoD
local AceConsoleName = "AceConsole-3.0"
-- Lua APIs
local strsub, strsplit, strlower, strmatch, strtrim = string.sub, string.split, string.lower, string.match, string.trim
local format, tonumber, tostring = string.format, tonumber, tostring
local tsort, tinsert = table.sort, table.insert
local select, pairs, next, type = select, pairs, next, type
local error, assert = error, assert
-- WoW APIs
local _G = _G
-- 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

4
Libraries/Ace3/AceConfig-3.0/AceConfigCmd-3.0/AceConfigCmd-3.0.xml Normal file
View File

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

2117
Libraries/Ace3/AceConfig-3.0/AceConfigDialog-3.0/AceConfigDialog-3.0.lua Normal file
View File

File diff suppressed because it is too large Load Diff

4
Libraries/Ace3/AceConfig-3.0/AceConfigDialog-3.0/AceConfigDialog-3.0.xml Normal file
View File

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

386
Libraries/Ace3/AceConfig-3.0/AceConfigRegistry-3.0/AceConfigRegistry-3.0.lua Normal file
View File

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

4
Libraries/Ace3/AceConfig-3.0/AceConfigRegistry-3.0/AceConfigRegistry-3.0.xml Normal file
View File

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

460
Libraries/Ace3/AceDBOptions-3.0/AceDBOptions-3.0.lua Normal file
View File

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

4
Libraries/Ace3/AceDBOptions-3.0/AceDBOptions-3.0.xml Normal file
View File

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

1026
Libraries/Ace3/AceGUI-3.0/AceGUI-3.0.lua Normal file
View File

File diff suppressed because it is too large Load Diff

28
Libraries/Ace3/AceGUI-3.0/AceGUI-3.0.xml Normal file
View File

@ -0,0 +1,28 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="AceGUI-3.0.lua"/>
<!-- Container -->
<Script file="widgets\AceGUIContainer-BlizOptionsGroup.lua"/>
<Script file="widgets\AceGUIContainer-DropDownGroup.lua"/>
<Script file="widgets\AceGUIContainer-Frame.lua"/>
<Script file="widgets\AceGUIContainer-InlineGroup.lua"/>
<Script file="widgets\AceGUIContainer-ScrollFrame.lua"/>
<Script file="widgets\AceGUIContainer-SimpleGroup.lua"/>
<Script file="widgets\AceGUIContainer-TabGroup.lua"/>
<Script file="widgets\AceGUIContainer-TreeGroup.lua"/>
<Script file="widgets\AceGUIContainer-Window.lua"/>
<!-- Widgets -->
<Script file="widgets\AceGUIWidget-Button-ElvUI.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-ElvUI.lua"/>
<Script file="widgets\AceGUIWidget-Slider-ElvUI.lua"/>
</Ui>

138
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-BlizOptionsGroup.lua Normal file
View File

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

157
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-DropDownGroup.lua Normal file
View File

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

316
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-Frame.lua Normal file
View File

@ -0,0 +1,316 @@
--[[-----------------------------------------------------------------------------
Frame Container
-------------------------------------------------------------------------------]]
local Type, Version = "Frame", 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, 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(799) -- SOUNDKIT.GS_TITLE_OPTION_EXIT
frame.obj:Hide()
end
local function Frame_OnShow(frame)
frame.obj:Fire("OnShow")
end
local function Frame_OnClose(frame)
frame.obj:Fire("OnClose")
end
local function Frame_OnMouseDown(frame)
AceGUI:ClearFocus()
end
local function Title_OnMouseDown(frame)
frame:GetParent():StartMoving()
AceGUI:ClearFocus()
end
local function MoverSizer_OnMouseUp(mover)
local frame = mover:GetParent()
frame:StopMovingOrSizing()
local self = frame.obj
local status = self.status or self.localstatus
status.width = frame:GetWidth()
status.height = frame:GetHeight()
status.top = frame:GetTop()
status.left = frame:GetLeft()
end
local function SizerSE_OnMouseDown(frame)
frame:GetParent():StartSizing("BOTTOMRIGHT")
AceGUI:ClearFocus()
end
local function SizerS_OnMouseDown(frame)
frame:GetParent():StartSizing("BOTTOM")
AceGUI:ClearFocus()
end
local function SizerE_OnMouseDown(frame)
frame:GetParent():StartSizing("RIGHT")
AceGUI:ClearFocus()
end
local function StatusBar_OnEnter(frame)
frame.obj:Fire("OnEnterStatusBar")
end
local function StatusBar_OnLeave(frame)
frame.obj:Fire("OnLeaveStatusBar")
end
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self.frame:SetParent(UIParent)
self.frame:SetFrameStrata("FULLSCREEN_DIALOG")
self: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, BackdropTemplateMixin and "BackdropTemplate" or nil)
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("OnShow", Frame_OnShow)
frame:SetScript("OnHide", Frame_OnClose)
frame:SetScript("OnMouseDown", Frame_OnMouseDown)
local closebutton = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate")
closebutton:SetScript("OnClick", Button_OnClick)
closebutton:SetPoint("BOTTOMRIGHT", -27, 17)
closebutton:SetHeight(20)
closebutton:SetWidth(100)
closebutton:SetText(CLOSE)
local statusbg = CreateFrame("Button", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
statusbg:SetPoint("BOTTOMLEFT", 15, 15)
statusbg:SetPoint("BOTTOMRIGHT", -132, 15)
statusbg:SetHeight(24)
statusbg:SetBackdrop(PaneBackdrop)
statusbg:SetBackdropColor(0.1,0.1,0.1)
statusbg:SetBackdropBorderColor(0.4,0.4,0.4)
statusbg:SetScript("OnEnter", StatusBar_OnEnter)
statusbg:SetScript("OnLeave", StatusBar_OnLeave)
local statustext = statusbg:CreateFontString(nil, "OVERLAY", "GameFontNormal")
statustext:SetPoint("TOPLEFT", 7, -2)
statustext:SetPoint("BOTTOMRIGHT", -7, 2)
statustext:SetHeight(20)
statustext:SetJustifyH("LEFT")
statustext:SetText("")
local titlebg = frame:CreateTexture(nil, "OVERLAY")
titlebg:SetTexture(131080) -- Interface\\DialogFrame\\UI-DialogBox-Header
titlebg:SetTexCoord(0.31, 0.67, 0, 0.63)
titlebg:SetPoint("TOP", 0, 12)
titlebg:SetWidth(100)
titlebg:SetHeight(40)
local title = CreateFrame("Frame", nil, frame)
title:EnableMouse(true)
title:SetScript("OnMouseDown", Title_OnMouseDown)
title:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
title:SetAllPoints(titlebg)
local titletext = title:CreateFontString(nil, "OVERLAY", "GameFontNormal")
titletext:SetPoint("TOP", titlebg, "TOP", 0, -14)
local titlebg_l = frame:CreateTexture(nil, "OVERLAY")
titlebg_l:SetTexture(131080) -- Interface\\DialogFrame\\UI-DialogBox-Header
titlebg_l:SetTexCoord(0.21, 0.31, 0, 0.63)
titlebg_l:SetPoint("RIGHT", titlebg, "LEFT")
titlebg_l:SetWidth(30)
titlebg_l:SetHeight(40)
local titlebg_r = frame:CreateTexture(nil, "OVERLAY")
titlebg_r:SetTexture(131080) -- Interface\\DialogFrame\\UI-DialogBox-Header
titlebg_r:SetTexCoord(0.67, 0.77, 0, 0.63)
titlebg_r:SetPoint("LEFT", titlebg, "RIGHT")
titlebg_r:SetWidth(30)
titlebg_r:SetHeight(40)
local sizer_se = CreateFrame("Frame", nil, frame)
sizer_se:SetPoint("BOTTOMRIGHT")
sizer_se:SetWidth(25)
sizer_se:SetHeight(25)
sizer_se:EnableMouse()
sizer_se:SetScript("OnMouseDown",SizerSE_OnMouseDown)
sizer_se:SetScript("OnMouseUp", MoverSizer_OnMouseUp)
local line1 = sizer_se:CreateTexture(nil, "BACKGROUND")
line1:SetWidth(14)
line1:SetHeight(14)
line1:SetPoint("BOTTOMRIGHT", -8, 8)
line1:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
local x = 0.1 * 14/17
line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
local line2 = sizer_se:CreateTexture(nil, "BACKGROUND")
line2:SetWidth(8)
line2:SetHeight(8)
line2:SetPoint("BOTTOMRIGHT", -8, 8)
line2:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
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)

103
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-InlineGroup.lua Normal file
View File

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

215
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-ScrollFrame.lua Normal file
View File

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

69
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-SimpleGroup.lua Normal file
View File

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

349
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-TabGroup.lua Normal file
View File

@ -0,0 +1,349 @@
--[[-----------------------------------------------------------------------------
TabGroup Container
Container that uses tabs on top to switch between groups.
-------------------------------------------------------------------------------]]
local Type, Version = "TabGroup", 37
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(841) -- SOUNDKIT.IG_CHARACTER_INFO_TAB
frame.obj:SelectTab(frame.value)
end
end
local function Tab_OnEnter(frame)
local self = frame.obj
self:Fire("OnTabEnter", self.tabs[frame.id].value, frame)
end
local function Tab_OnLeave(frame)
local self = frame.obj
self:Fire("OnTabLeave", self.tabs[frame.id].value, frame)
end
local function Tab_OnShow(frame)
_G[frame:GetName().."HighlightTexture"]:SetWidth(frame:GetTextWidth() + 30)
end
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetTitle()
end,
["OnRelease"] = function(self)
self.status = nil
for k in pairs(self.localstatus) do
self.localstatus[k] = nil
end
self.tablist = nil
for _, tab in pairs(self.tabs) do
tab:Hide()
end
end,
["CreateTab"] = function(self, id)
local tabname = ("AceGUITabGroup%dTab%d"):format(self.num, id)
local tab = CreateFrame("Button", tabname, self.border, "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 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, BackdropTemplateMixin and "BackdropTemplate" or nil)
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)

717
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-TreeGroup.lua Normal file
View File

@ -0,0 +1,717 @@
--[[-----------------------------------------------------------------------------
TreeGroup Container
Container that uses a tree control to switch between groups.
-------------------------------------------------------------------------------]]
local Type, Version = "TreeGroup", 45
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: 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 text = treeline.text or ""
local icon = treeline.icon
local iconCoords = treeline.iconCoords
local level = treeline.level
local value = treeline.value
local uniquevalue = treeline.uniquevalue
local disabled = treeline.disabled
button.treeline = treeline
button.value = value
button.uniquevalue = uniquevalue
if selected then
button:LockHighlight()
button.selected = true
else
button:UnlockHighlight()
button.selected = false
end
button.level = level
if ( level == 1 ) then
button:SetNormalFontObject("GameFontNormal")
button:SetHighlightFontObject("GameFontHighlight")
button.text:SetPoint("LEFT", (icon and 16 or 0) + 8, 2)
else
button:SetNormalFontObject("GameFontHighlightSmall")
button:SetHighlightFontObject("GameFontHighlightSmall")
button.text:SetPoint("LEFT", (icon and 16 or 0) + 8 * level, 2)
end
if disabled then
button:EnableMouse(false)
button.text:SetText("|cff808080"..text..FONT_COLOR_CODE_CLOSE)
else
button.text:SetText(text)
button:EnableMouse(true)
end
if icon then
button.icon:SetTexture(icon)
button.icon:SetPoint("LEFT", 8 * level, (level == 1) and 0 or 1)
else
button.icon:SetTexture(nil)
end
if iconCoords then
button.icon:SetTexCoord(unpack(iconCoords))
else
button.icon:SetTexCoord(0, 1, 0, 1)
end
if canExpand then
if not isExpanded then
toggle:SetNormalTexture(130838) -- Interface\\Buttons\\UI-PlusButton-UP
toggle:SetPushedTexture(130836) -- Interface\\Buttons\\UI-PlusButton-DOWN
else
toggle:SetNormalTexture(130821) -- Interface\\Buttons\\UI-MinusButton-UP
toggle:SetPushedTexture(130820) -- Interface\\Buttons\\UI-MinusButton-DOWN
end
toggle:Show()
else
toggle:Hide()
end
end
local function ShouldDisplayLevel(tree)
local result = false
for k, v in ipairs(tree) do
if v.children == nil and v.visible ~= false then
result = true
elseif v.children then
result = result or ShouldDisplayLevel(v.children)
end
if result then return result end
end
return false
end
local function addLine(self, v, tree, level, parent)
local line = new()
line.value = v.value
line.text = v.text
line.icon = v.icon
line.iconCoords = v.iconCoords
line.disabled = v.disabled
line.tree = tree
line.level = level
line.parent = parent
line.visible = v.visible
line.uniquevalue = GetButtonUniqueValue(line)
if v.children then
line.hasChildren = true
else
line.hasChildren = nil
end
self.lines[#self.lines+1] = line
return line
end
--fire an update after one frame to catch the treeframes height
local function FirstFrameUpdate(frame)
local self = frame.obj
frame:SetScript("OnUpdate", nil)
self:RefreshTree(nil, true)
end
local function BuildUniqueValue(...)
local n = select('#', ...)
if n == 1 then
return ...
else
return (...).."\001"..BuildUniqueValue(select(2,...))
end
end
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local function Expand_OnClick(frame)
local button = frame.button
local self = button.obj
local status = (self.status or self.localstatus).groups
status[button.uniquevalue] = not status[button.uniquevalue]
self:RefreshTree()
end
local function Button_OnClick(frame)
local self = frame.obj
self:Fire("OnClick", frame.uniquevalue, frame.selected)
if not frame.selected then
self:SetSelected(frame.uniquevalue)
frame.selected = true
frame:LockHighlight()
self:RefreshTree()
end
AceGUI:ClearFocus()
end
local function Button_OnDoubleClick(button)
local self = button.obj
local status = (self.status or self.localstatus).groups
status[button.uniquevalue] = not status[button.uniquevalue]
self:RefreshTree()
end
local function Button_OnEnter(frame)
local self = frame.obj
self:Fire("OnButtonEnter", frame.uniquevalue, frame)
if self.enabletooltips then
local tooltip = AceGUI.tooltip
tooltip:SetOwner(frame, "ANCHOR_NONE")
tooltip:ClearAllPoints()
tooltip:SetPoint("LEFT",frame,"RIGHT")
tooltip:SetText(frame.text:GetText() or "", 1, .82, 0, true)
tooltip:Show()
end
end
local function Button_OnLeave(frame)
local self = frame.obj
self:Fire("OnButtonLeave", frame.uniquevalue, frame)
if self.enabletooltips then
AceGUI.tooltip:Hide()
end
end
local function OnScrollValueChanged(frame, value)
if frame.obj.noupdate then return end
local self = frame.obj
local status = self.status or self.localstatus
status.scrollvalue = floor(value + 0.5)
self:RefreshTree()
AceGUI:ClearFocus()
end
local function Tree_OnSizeChanged(frame)
frame.obj:RefreshTree()
end
local function Tree_OnMouseWheel(frame, delta)
local self = frame.obj
if self.showscroll then
local scrollbar = self.scrollbar
local min, max = scrollbar:GetMinMaxValues()
local value = scrollbar:GetValue()
local newvalue = math_min(max,math_max(min,value - delta))
if value ~= newvalue then
scrollbar:SetValue(newvalue)
end
end
end
local function Dragger_OnLeave(frame)
frame:SetBackdropColor(1, 1, 1, 0)
end
local function Dragger_OnEnter(frame)
frame:SetBackdropColor(1, 1, 1, 0.8)
end
local function Dragger_OnMouseDown(frame)
local treeframe = frame:GetParent()
treeframe:StartSizing("RIGHT")
end
local function Dragger_OnMouseUp(frame)
local treeframe = frame:GetParent()
local self = treeframe.obj
local treeframeParent = treeframe:GetParent()
treeframe:StopMovingOrSizing()
--treeframe:SetScript("OnUpdate", nil)
treeframe:SetUserPlaced(false)
--Without this :GetHeight will get stuck on the current height, causing the tree contents to not resize
treeframe:SetHeight(0)
treeframe:ClearAllPoints()
treeframe:SetPoint("TOPLEFT", treeframeParent, "TOPLEFT",0,0)
treeframe:SetPoint("BOTTOMLEFT", treeframeParent, "BOTTOMLEFT",0,0)
local status = self.status or self.localstatus
status.treewidth = treeframe:GetWidth()
treeframe.obj:Fire("OnTreeResize",treeframe:GetWidth())
-- recalculate the content width
treeframe.obj:OnWidthSet(status.fullwidth)
-- update the layout of the content
treeframe.obj:DoLayout()
end
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetTreeWidth(DEFAULT_TREE_WIDTH, DEFAULT_TREE_SIZABLE)
self:EnableButtonTooltips(true)
self.frame:SetScript("OnUpdate", FirstFrameUpdate)
end,
["OnRelease"] = function(self)
self.status = nil
self.tree = nil
self.frame:SetScript("OnUpdate", nil)
for k, v in pairs(self.localstatus) do
if k == "groups" then
for k2 in pairs(v) do
v[k2] = nil
end
else
self.localstatus[k] = nil
end
end
self.localstatus.scrollvalue = 0
self.localstatus.treewidth = DEFAULT_TREE_WIDTH
self.localstatus.treesizable = DEFAULT_TREE_SIZABLE
end,
["EnableButtonTooltips"] = function(self, enable)
self.enabletooltips = enable
end,
["CreateButton"] = function(self)
local num = AceGUI:GetNextWidgetNum("TreeGroupButton")
local name = ("AceGUI30TreeButton%d"):format(num)
local button = CreateFrame("Button", name, self.treeframe, "OptionsListButtonTemplate")
button.obj = self
button.text = _G[name.."Text"] -- tell nev for this
local icon = button:CreateTexture(nil, "OVERLAY")
icon:SetWidth(14)
icon:SetHeight(14)
button.icon = icon
button:SetScript("OnClick",Button_OnClick)
button:SetScript("OnDoubleClick", Button_OnDoubleClick)
button:SetScript("OnEnter",Button_OnEnter)
button:SetScript("OnLeave",Button_OnLeave)
button.toggle.button = button
button.toggle:SetScript("OnClick",Expand_OnClick)
button.text:SetHeight(14) -- Prevents text wrapping
return button
end,
["SetStatusTable"] = function(self, status)
assert(type(status) == "table")
self.status = status
if not status.groups then
status.groups = {}
end
if not status.scrollvalue then
status.scrollvalue = 0
end
if not status.treewidth then
status.treewidth = DEFAULT_TREE_WIDTH
end
if status.treesizable == nil then
status.treesizable = DEFAULT_TREE_SIZABLE
end
self:SetTreeWidth(status.treewidth,status.treesizable)
self:RefreshTree()
end,
--sets the tree to be displayed
["SetTree"] = function(self, tree, filter)
self.filter = filter
if tree then
assert(type(tree) == "table")
end
self.tree = tree
self:RefreshTree()
end,
["BuildLevel"] = function(self, tree, level, parent)
local groups = (self.status or self.localstatus).groups
for i, v in ipairs(tree) do
if v.children then
if not self.filter or ShouldDisplayLevel(v.children) then
local line = addLine(self, v, tree, level, parent)
if groups[line.uniquevalue] then
self:BuildLevel(v.children, level+1, line)
end
end
elseif v.visible ~= false or not self.filter then
addLine(self, v, tree, level, parent)
end
end
end,
["RefreshTree"] = function(self,scrollToSelection,fromOnUpdate)
local buttons = self.buttons
local lines = self.lines
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
if self.frame:GetParent() == UIParent and not fromOnUpdate then
self.frame:SetScript("OnUpdate", FirstFrameUpdate)
return
end
local first, last
scrollToSelection = status.scrollToSelection
status.scrollToSelection = nil
if numlines <= maxlines then
--the whole tree fits in the frame
status.scrollvalue = 0
self:ShowScroll(false)
first, last = 1, numlines
else
self:ShowScroll(true)
--scrolling will be needed
self.noupdate = true
self.scrollbar:SetMinMaxValues(0, numlines - maxlines)
--check if we are scrolled down too far
if numlines - status.scrollvalue < maxlines then
status.scrollvalue = numlines - maxlines
end
self.noupdate = nil
first, last = status.scrollvalue+1, status.scrollvalue + maxlines
--show selection?
if scrollToSelection and status.selected then
local show
for i,line in ipairs(lines) do -- find the line number
if line.uniquevalue==status.selected then
show=i
end
end
if not show then
-- selection was deleted or something?
elseif show>=first and show<=last then
-- all good
else
-- scrolling needed!
if show<first then
status.scrollvalue = show-1
else
status.scrollvalue = show-maxlines
end
first, last = status.scrollvalue+1, status.scrollvalue + maxlines
end
end
if self.scrollbar:GetValue() ~= status.scrollvalue then
self.scrollbar:SetValue(status.scrollvalue)
end
end
local buttonnum = 1
for i = first, last do
local line = lines[i]
local button = buttons[buttonnum]
if not button then
button = self:CreateButton()
buttons[buttonnum] = button
button:SetParent(treeframe)
button:SetFrameLevel(treeframe:GetFrameLevel()+1)
button:ClearAllPoints()
if buttonnum == 1 then
if self.showscroll then
button:SetPoint("TOPRIGHT", -22, -10)
button:SetPoint("TOPLEFT", 0, -10)
else
button:SetPoint("TOPRIGHT", 0, -10)
button:SetPoint("TOPLEFT", 0, -10)
end
else
button:SetPoint("TOPRIGHT", buttons[buttonnum-1], "BOTTOMRIGHT",0,0)
button:SetPoint("TOPLEFT", buttons[buttonnum-1], "BOTTOMLEFT",0,0)
end
end
UpdateButton(button, line, status.selected == line.uniquevalue, line.hasChildren, groupstatus[line.uniquevalue] )
button:Show()
buttonnum = buttonnum + 1
end
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 = 1,
insets = { left = 3, right = 3, top = 7, bottom = 7 }
}
local function Constructor()
local num = AceGUI:GetNextWidgetNum(Type)
local frame = CreateFrame("Frame", nil, UIParent)
local treeframe = CreateFrame("Frame", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
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, BackdropTemplateMixin and "BackdropTemplate" or nil)
dragger:SetWidth(8)
dragger:SetPoint("TOP", treeframe, "TOPRIGHT")
dragger:SetPoint("BOTTOM", treeframe, "BOTTOMRIGHT")
dragger:SetBackdrop(DraggerBackdrop)
dragger:SetBackdropColor(1, 1, 1, 0)
dragger:SetScript("OnEnter", Dragger_OnEnter)
dragger:SetScript("OnLeave", Dragger_OnLeave)
dragger:SetScript("OnMouseDown", Dragger_OnMouseDown)
dragger:SetScript("OnMouseUp", Dragger_OnMouseUp)
local scrollbar = CreateFrame("Slider", ("AceConfigDialogTreeGroup%dScrollBar"):format(num), treeframe, "UIPanelScrollBarTemplate")
scrollbar:SetScript("OnValueChanged", nil)
scrollbar:SetPoint("TOPRIGHT", -10, -26)
scrollbar:SetPoint("BOTTOMRIGHT", -10, 26)
scrollbar:SetMinMaxValues(0,0)
scrollbar:SetValueStep(1)
scrollbar:SetValue(0)
scrollbar:SetWidth(16)
scrollbar:SetScript("OnValueChanged", OnScrollValueChanged)
local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND")
scrollbg:SetAllPoints(scrollbar)
scrollbg:SetColorTexture(0,0,0,0.4)
local border = CreateFrame("Frame", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
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)

336
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIContainer-Window.lua Normal file
View File

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

192
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-Button-ElvUI.lua Normal file
View File

@ -0,0 +1,192 @@
--[[-----------------------------------------------------------------------------
Button Widget (Modified to change text color on SetDisabled method and add Drag and Drop support for Filter lists)
Graphical Button.
-------------------------------------------------------------------------------]]
local Type, Version = "Button-ElvUI", 4
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
local pairs = pairs
local CreateFrame = CreateFrame
local IsShiftKeyDown = IsShiftKeyDown
local PlaySound = PlaySound
local UIParent = UIParent
local DragTooltip = CreateFrame("GameTooltip", "ElvUIAceGUIWidgetDragTooltip", UIParent, "GameTooltipTemplate")
-- GLOBALS: ElvUI
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
local dragdropButton
local function lockTooltip()
_G.ElvUIAceConfigDialogTooltip:Hide()
DragTooltip:ClearAllPoints()
DragTooltip:SetOwner(UIParent, "ANCHOR_CURSOR")
DragTooltip:SetText(" ")
DragTooltip:Show()
end
local function dragdrop_OnMouseDown(frame, ...)
if frame.obj.dragOnMouseDown then
dragdropButton.mouseDownFrame = frame
dragdropButton:SetText(frame.obj.value or "Unknown")
dragdropButton:SetSize(frame:GetSize())
frame.obj.dragOnMouseDown(frame, ...)
end
end
local function dragdrop_OnMouseUp(frame, ...)
if frame.obj.dragOnMouseUp then
frame:SetAlpha(1)
if dragdropButton.enteredFrame and dragdropButton.enteredFrame ~= frame and dragdropButton.enteredFrame:IsMouseOver() then
frame.obj.dragOnMouseUp(frame, ...)
frame.obj.ActivateMultiControl(frame.obj, ...)
end
DragTooltip:Hide()
dragdropButton:Hide()
dragdropButton.enteredFrame = nil
dragdropButton.mouseDownFrame = nil
end
end
local function dragdrop_OnLeave(frame, ...)
if frame.obj.dragOnLeave then
if dragdropButton.mouseDownFrame then
lockTooltip()
end
if frame == dragdropButton.mouseDownFrame then
frame:SetAlpha(0)
dragdropButton:Show()
frame.obj.dragOnLeave(frame, ...)
end
end
end
local function dragdrop_OnEnter(frame, ...)
if frame.obj.dragOnEnter and dragdropButton:IsShown() then
dragdropButton.enteredFrame = frame
lockTooltip()
frame.obj.dragOnEnter(frame, ...)
end
end
local function dragdrop_OnClick(frame, ...)
local button = ...
if frame.obj.dragOnClick and button == "RightButton" then
frame.obj.dragOnClick(frame, ...)
frame.obj.ActivateMultiControl(frame.obj, ...)
elseif frame.obj.stateSwitchOnClick and (button == "LeftButton") and IsShiftKeyDown() then
frame.obj.stateSwitchOnClick(frame, ...)
frame.obj.ActivateMultiControl(frame.obj, ...)
end
end
local function Button_OnClick(frame, ...)
AceGUI:ClearFocus()
PlaySound(852) -- SOUNDKIT.IG_MAINMENU_OPTION
frame.obj:Fire("OnClick", ...)
end
local function Control_OnEnter(frame)
frame.obj:Fire("OnEnter")
end
local function Control_OnLeave(frame)
frame.obj:Fire("OnLeave")
end
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
-- restore default values
self:SetHeight(24)
self:SetWidth(200)
self:SetDisabled(false)
self:SetAutoWidth(false)
self:SetText()
end,
-- ["OnRelease"] = nil,
["SetText"] = function(self, text)
self.text:SetText(text)
if self.autoWidth then
self:SetWidth(self.text:GetStringWidth() + 30)
end
end,
["SetAutoWidth"] = function(self, autoWidth)
self.autoWidth = autoWidth
if self.autoWidth then
self:SetWidth(self.text:GetStringWidth() + 30)
end
end,
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.frame:Disable()
self.text:SetTextColor(0.4, 0.4, 0.4)
else
self.frame:Enable()
self.text:SetTextColor(1, 0.82, 0)
end
end
}
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local S -- ref for Skins module in ElvUI
local function Constructor()
local name = "AceGUI30Button" .. AceGUI:GetNextWidgetNum(Type)
local frame = CreateFrame("Button", name, UIParent, "UIPanelButtonTemplate")
frame:Hide()
frame:EnableMouse(true)
frame:RegisterForClicks("AnyUp")
frame:SetScript("OnClick", Button_OnClick)
frame:SetScript("OnEnter", Control_OnEnter)
frame:SetScript("OnLeave", Control_OnLeave)
-- dragdrop
if not dragdropButton then
dragdropButton = CreateFrame("Button", "ElvUIAceGUI30DragDropButton", UIParent, "UIPanelButtonTemplate")
dragdropButton:SetFrameStrata("TOOLTIP")
dragdropButton:SetFrameLevel(5)
dragdropButton:SetPoint('BOTTOM', DragTooltip, "BOTTOM", 0, 10)
dragdropButton:Hide()
if not S then
S = ElvUI[1]:GetModule("Skins")
-- skin this once :)
DragTooltip:SetTemplate("Transparent", nil, true)
end
S:HandleButton(dragdropButton)
end
frame:HookScript("OnClick", dragdrop_OnClick)
frame:HookScript("OnEnter", dragdrop_OnEnter)
frame:HookScript("OnLeave", dragdrop_OnLeave)
frame:HookScript("OnMouseUp", dragdrop_OnMouseUp)
frame:HookScript("OnMouseDown", dragdrop_OnMouseDown)
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)

296
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-CheckBox.lua Normal file
View File

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

205
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-ColorPicker.lua Normal file
View File

@ -0,0 +1,205 @@
--[[-----------------------------------------------------------------------------
ColorPicker Widget
-------------------------------------------------------------------------------]]
local Type, Version = "ColorPicker-ElvUI", 26
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
-- Lua APIs
local pairs = pairs
-- WoW APIs
local CreateFrame, 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: ColorPickerFrame, OpacitySliderFrame, ColorPPDefault
--[[-----------------------------------------------------------------------------
Support functions
-------------------------------------------------------------------------------]]
local function ColorCallback(self, r, g, b, a, isAlpha)
-- this will block an infinite loop from `E.GrabColorPickerValues`
-- which is caused when we set values into the color picker again on `OnValueChanged`
if ColorPickerFrame.noColorCallback then return end
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)
ColorPickerFrame:Hide()
local self = frame.obj
if not self.disabled then
ColorPickerFrame:SetFrameStrata("FULLSCREEN_DIALOG")
ColorPickerFrame:SetFrameLevel(frame:GetFrameLevel() + 10)
ColorPickerFrame:SetClampedToScreen(true)
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)
if ColorPPDefault and self.dR and self.dG and self.dB then
local alpha = 1
if self.dA then alpha = 1 - self.dA end
if not ColorPPDefault.colors then ColorPPDefault.colors = {} end
ColorPPDefault.colors.r, ColorPPDefault.colors.g, ColorPPDefault.colors.b, ColorPPDefault.colors.a = self.dR, self.dG, self.dB, alpha
end
ColorPickerFrame.cancelFunc = function()
ColorCallback(self, r, g, b, a, true)
end
ColorPickerFrame:Show()
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, defaultR, defaultG, defaultB, defaultA)
self.r = r
self.g = g
self.b = b
self.a = a or 1
self.dR = defaultR or self.dR
self.dG = defaultG or self.dG
self.dB = defaultB or self.dB
self.dA = defaultA or self.dA
self.colorSwatch:SetVertexColor(r, g, b, a)
end,
["SetHasAlpha"] = function(self, HasAlpha)
self.HasAlpha = HasAlpha
end,
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if self.disabled then
self.frame:Disable()
self.text:SetTextColor(0.5, 0.5, 0.5)
else
self.frame:Enable()
self.text:SetTextColor(1, 1, 1)
end
end
}
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local function Constructor()
local frame = CreateFrame("Button", nil, UIParent)
frame:Hide()
frame:EnableMouse(true)
frame:SetScript("OnEnter", Control_OnEnter)
frame:SetScript("OnLeave", Control_OnLeave)
frame:SetScript("OnClick", ColorSwatch_OnClick)
local colorSwatch = frame:CreateTexture(nil, "OVERLAY")
colorSwatch:SetWidth(19)
colorSwatch:SetHeight(19)
colorSwatch:SetTexture(130939) -- Interface\\ChatFrame\\ChatFrameColorSwatch
colorSwatch:SetPoint("LEFT")
local texture = frame:CreateTexture(nil, "BACKGROUND")
colorSwatch.background = texture
texture:SetWidth(16)
texture:SetHeight(16)
texture:SetColorTexture(1, 1, 1)
texture:SetPoint("CENTER", colorSwatch)
texture:Show()
local checkers = frame:CreateTexture(nil, "BACKGROUND")
colorSwatch.checkers = checkers
checkers:SetWidth(14)
checkers:SetHeight(14)
checkers:SetTexture(188523) -- Tileset\\Generic\\Checkers
checkers:SetTexCoord(.25, 0, 0.5, .25)
checkers:SetDesaturated(true)
checkers:SetVertexColor(1, 1, 1, 0.75)
checkers:SetPoint("CENTER", colorSwatch)
checkers:Show()
local text = frame:CreateFontString(nil,"OVERLAY","GameFontHighlight")
text:SetHeight(24)
text:SetJustifyH("LEFT")
text:SetTextColor(1, 1, 1)
text:SetPoint("LEFT", colorSwatch, "RIGHT", 2, 0)
text:SetPoint("RIGHT")
--local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
--highlight:SetTexture(136810) -- Interface\\QuestFrame\\UI-QuestTitleHighlight
--highlight:SetBlendMode("ADD")
--highlight:SetAllPoints(frame)
local widget = {
colorSwatch = colorSwatch,
text = text,
frame = frame,
type = Type
}
for method, func in pairs(methods) do
widget[method] = func
end
return AceGUI:RegisterAsWidget(widget)
end
AceGUI:RegisterWidgetType(Type, Constructor, Version)

471
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-DropDown-Items.lua Normal file
View File

@ -0,0 +1,471 @@
--[[ $Id$ ]]--
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(136810) -- Interface\\QuestFrame\\UI-QuestTitleHighlight
highlight:SetBlendMode("ADD")
highlight:SetHeight(14)
highlight:ClearAllPoints()
highlight:SetPoint("RIGHT",frame,"RIGHT",-3,0)
highlight:SetPoint("LEFT",frame,"LEFT",5,0)
highlight:Hide()
self.highlight = highlight
local check = frame:CreateTexture("OVERLAY")
check:SetWidth(16)
check:SetHeight(16)
check:SetPoint("LEFT",frame,"LEFT",3,-1)
check:SetTexture(130751) -- Interface\\Buttons\\UI-CheckBox-Check
check:Hide()
self.check = check
local sub = frame:CreateTexture("OVERLAY")
sub:SetWidth(16)
sub:SetHeight(16)
sub:SetPoint("RIGHT",frame,"RIGHT",-3,-1)
sub:SetTexture(130940) -- Interface\\ChatFrame\\ChatFrameExpandArrow
sub:Hide()
self.sub = sub
frame:SetScript("OnEnter", ItemBase.Frame_OnEnter)
frame:SetScript("OnLeave", ItemBase.Frame_OnLeave)
self.OnAcquire = ItemBase.OnAcquire
self.OnRelease = ItemBase.OnRelease
self.SetPullout = ItemBase.SetPullout
self.GetText = ItemBase.GetText
self.SetText = ItemBase.SetText
self.SetDisabled = ItemBase.SetDisabled
self.SetPoint = ItemBase.SetPoint
self.Show = ItemBase.Show
self.Hide = ItemBase.Hide
self.SetOnLeave = ItemBase.SetOnLeave
self.SetOnEnter = ItemBase.SetOnEnter
return self
end
-- Register a dummy LibStub library to retrieve the ItemBase, so other addons can use it.
local IBLib = LibStub:NewLibrary("AceGUI-3.0-DropDown-ItemBase", ItemBase.version)
if IBLib then
IBLib.GetItemBase = function() return ItemBase end
end
--[[
Template for items:
-- Item:
--
do
local widgetType = "Dropdown-Item-"
local widgetVersion = 1
local function Constructor()
local self = ItemBase.Create(widgetType)
AceGUI:RegisterAsWidget(self)
return self
end
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
--]]
-- Item: Header
-- A single text entry.
-- Special: Different text color and no highlight
do
local widgetType = "Dropdown-Item-Header"
local widgetVersion = 1
local function OnEnter(this)
local self = this.obj
self:Fire("OnEnter")
if self.specialOnEnter then
self.specialOnEnter(self)
end
end
local function OnLeave(this)
local self = this.obj
self:Fire("OnLeave")
if self.specialOnLeave then
self.specialOnLeave(self)
end
end
-- exported, override
local function SetDisabled(self, disabled)
ItemBase.SetDisabled(self, disabled)
if not disabled then
self.text:SetTextColor(1, 1, 0)
end
end
local function Constructor()
local self = ItemBase.Create(widgetType)
self.SetDisabled = SetDisabled
self.frame:SetScript("OnEnter", OnEnter)
self.frame:SetScript("OnLeave", OnLeave)
self.text:SetTextColor(1, 1, 0)
AceGUI:RegisterAsWidget(self)
return self
end
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
-- Item: Execute
-- A simple button
do
local widgetType = "Dropdown-Item-Execute"
local widgetVersion = 1
local function Frame_OnClick(this, button)
local self = this.obj
if self.disabled then return end
self:Fire("OnClick")
if self.pullout then
self.pullout:Close()
end
end
local function Constructor()
local self = ItemBase.Create(widgetType)
self.frame:SetScript("OnClick", Frame_OnClick)
AceGUI:RegisterAsWidget(self)
return self
end
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
-- Item: Toggle
-- Some sort of checkbox for dropdown menus.
-- Does not close the pullout on click.
do
local widgetType = "Dropdown-Item-Toggle"
local widgetVersion = 4
local function UpdateToggle(self)
if self.value then
self.check:Show()
else
self.check:Hide()
end
end
local function OnRelease(self)
ItemBase.OnRelease(self)
self:SetValue(nil)
end
local function Frame_OnClick(this, button)
local self = this.obj
if self.disabled then return end
self.value = not self.value
if self.value then
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
else
PlaySound(857) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF
end
UpdateToggle(self)
self:Fire("OnValueChanged", self.value)
end
-- exported
local function SetValue(self, value)
self.value = value
UpdateToggle(self)
end
-- exported
local function GetValue(self)
return self.value
end
local function Constructor()
local self = ItemBase.Create(widgetType)
self.frame:SetScript("OnClick", Frame_OnClick)
self.SetValue = SetValue
self.GetValue = GetValue
self.OnRelease = OnRelease
AceGUI:RegisterAsWidget(self)
return self
end
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
-- Item: Menu
-- Shows a submenu on mouse over
-- Does not close the pullout on click
do
local widgetType = "Dropdown-Item-Menu"
local widgetVersion = 2
local function OnEnter(this)
local self = this.obj
self:Fire("OnEnter")
if self.specialOnEnter then
self.specialOnEnter(self)
end
self.highlight:Show()
if not self.disabled and self.submenu then
self.submenu:Open("TOPLEFT", self.frame, "TOPRIGHT", self.pullout:GetRightBorderWidth(), 0, self.frame:GetFrameLevel() + 100)
end
end
local function OnHide(this)
local self = this.obj
if self.submenu then
self.submenu:Close()
end
end
-- exported
local function SetMenu(self, menu)
assert(menu.type == "Dropdown-Pullout")
self.submenu = menu
end
-- exported
local function CloseMenu(self)
self.submenu:Close()
end
local function Constructor()
local self = ItemBase.Create(widgetType)
self.sub:Show()
self.frame:SetScript("OnEnter", OnEnter)
self.frame:SetScript("OnHide", OnHide)
self.SetMenu = SetMenu
self.CloseMenu = CloseMenu
AceGUI:RegisterAsWidget(self)
return self
end
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end
-- Item: Separator
-- A single line to separate items
do
local widgetType = "Dropdown-Item-Separator"
local widgetVersion = 2
-- exported, override
local function SetDisabled(self, disabled)
ItemBase.SetDisabled(self, disabled)
self.useHighlight = false
end
local function Constructor()
local self = ItemBase.Create(widgetType)
self.SetDisabled = SetDisabled
local line = self.frame:CreateTexture(nil, "OVERLAY")
line:SetHeight(1)
line:SetColorTexture(.5, .5, .5)
line:SetPoint("LEFT", self.frame, "LEFT", 10, 0)
line:SetPoint("RIGHT", self.frame, "RIGHT", -10, 0)
self.text:Hide()
self.useHighlight = false
AceGUI:RegisterAsWidget(self)
return self
end
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version)
end

763
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-DropDown.lua Normal file
View File

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

263
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-EditBox.lua Normal file
View File

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

78
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-Heading.lua Normal file
View File

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

140
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-Icon.lua Normal file
View File

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

94
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-InteractiveLabel.lua Normal file
View File

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

249
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-Keybinding.lua Normal file
View File

@ -0,0 +1,249 @@
--[[-----------------------------------------------------------------------------
Keybinding Widget
Set Keybindings in the Config UI.
-------------------------------------------------------------------------------]]
local Type, Version = "Keybinding", 26
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
-- Lua APIs
local pairs = pairs
-- WoW APIs
local 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)
frame:EnableMouseWheel(false)
self.msgframe:Hide()
frame:UnlockHighlight()
self.waitingForKey = nil
else
frame:EnableKeyboard(true)
frame:EnableMouseWheel(true)
self.msgframe:Show()
frame:LockHighlight()
self.waitingForKey = true
end
end
AceGUI:ClearFocus()
end
local ignoreKeys = {
["BUTTON1"] = true, ["BUTTON2"] = true,
["UNKNOWN"] = true,
["LSHIFT"] = true, ["LCTRL"] = true, ["LALT"] = true,
["RSHIFT"] = true, ["RCTRL"] = true, ["RALT"] = true,
}
local function Keybinding_OnKeyDown(frame, key)
local self = frame.obj
if self.waitingForKey then
local keyPressed = key
if keyPressed == "ESCAPE" then
keyPressed = ""
else
if ignoreKeys[keyPressed] then return end
if IsShiftKeyDown() then
keyPressed = "SHIFT-"..keyPressed
end
if IsControlKeyDown() then
keyPressed = "CTRL-"..keyPressed
end
if IsAltKeyDown() then
keyPressed = "ALT-"..keyPressed
end
end
frame:EnableKeyboard(false)
frame:EnableMouseWheel(false)
self.msgframe:Hide()
frame:UnlockHighlight()
self.waitingForKey = nil
if not self.disabled then
self:SetKey(keyPressed)
self:Fire("OnKeyChanged", keyPressed)
end
end
end
local function Keybinding_OnMouseDown(frame, button)
if button == "LeftButton" or button == "RightButton" then
return
elseif button == "MiddleButton" then
button = "BUTTON3"
elseif button == "Button4" then
button = "BUTTON4"
elseif button == "Button5" then
button = "BUTTON5"
end
Keybinding_OnKeyDown(frame, button)
end
local function Keybinding_OnMouseWheel(frame, direction)
local button
if direction >= 0 then
button = "MOUSEWHEELUP"
else
button = "MOUSEWHEELDOWN"
end
Keybinding_OnKeyDown(frame, button)
end
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetWidth(200)
self:SetLabel("")
self:SetKey("")
self.waitingForKey = nil
self.msgframe:Hide()
self:SetDisabled(false)
self.button:EnableKeyboard(false)
self.button:EnableMouseWheel(false)
end,
-- ["OnRelease"] = nil,
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.button:Disable()
self.label:SetTextColor(0.5,0.5,0.5)
else
self.button:Enable()
self.label:SetTextColor(1,1,1)
end
end,
["SetKey"] = function(self, key)
if (key or "") == "" then
self.button:SetText(NOT_BOUND)
self.button:SetNormalFontObject("GameFontNormal")
else
self.button:SetText(key)
self.button:SetNormalFontObject("GameFontHighlight")
end
end,
["GetKey"] = function(self)
local key = self.button:GetText()
if key == NOT_BOUND then
key = nil
end
return key
end,
["SetLabel"] = function(self, label)
self.label:SetText(label or "")
if (label or "") == "" then
self.alignoffset = nil
self:SetHeight(24)
else
self.alignoffset = 30
self:SetHeight(44)
end
end,
}
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local ControlBackdrop = {
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 3, bottom = 3 }
}
local function keybindingMsgFixWidth(frame)
frame:SetWidth(frame.msg:GetWidth() + 10)
frame:SetScript("OnUpdate", nil)
end
local function Constructor()
local name = "AceGUI30KeybindingButton" .. AceGUI:GetNextWidgetNum(Type)
local frame = CreateFrame("Frame", nil, UIParent)
local button = CreateFrame("Button", name, frame, "UIPanelButtonTemplate")
button:EnableMouse(true)
button:EnableMouseWheel(false)
button:RegisterForClicks("AnyDown")
button:SetScript("OnEnter", Control_OnEnter)
button:SetScript("OnLeave", Control_OnLeave)
button:SetScript("OnClick", Keybinding_OnClick)
button:SetScript("OnKeyDown", Keybinding_OnKeyDown)
button:SetScript("OnMouseDown", Keybinding_OnMouseDown)
button:SetScript("OnMouseWheel", Keybinding_OnMouseWheel)
button: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, BackdropTemplateMixin and "BackdropTemplate" or nil)
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)

179
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-Label.lua Normal file
View File

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

372
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-MultiLineEditBox-ElvUI.lua Normal file
View File

@ -0,0 +1,372 @@
--[[-----------------------------------------------------------------------------
MultiLineEditBox Widget (Modified to add Syntax highlighting from FAIAP)
-------------------------------------------------------------------------------]]
local Type, Version = "MultiLineEditBox-ElvUI", 29
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
local _G, pairs = _G, pairs
local GetCursorInfo, GetSpellInfo, ClearCursor = GetCursorInfo, GetSpellInfo, ClearCursor
local CreateFrame, UIParent = CreateFrame, UIParent
-- GLOBALS: ACCEPT, ChatFontNormal, BackdropTemplateMixin
local indent = _G.ElvUI[1].Libs.indent -- ElvUI
--[[-----------------------------------------------------------------------------
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(true)) then -- ElvUI changed
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,
["HighlightText"] = function(self, from, to)
self.editBox:HighlightText(from, to)
end,
["GetCursorPosition"] = function(self)
return self.editBox:GetCursorPosition()
end,
["SetCursorPosition"] = function(self, ...)
return self.editBox:SetCursorPosition(...)
end,
-- ElvUI block
["SetSyntaxHighlightingEnabled"] = function(self, enabled)
if enabled then
indent.enable(self.editBox, nil, 4)
else
indent.disable(self.editBox)
end
end
-- End ElvUI block
}
--[[-----------------------------------------------------------------------------
Constructor
-------------------------------------------------------------------------------]]
local backdrop = {
bgFile = [[Interface\Tooltips\UI-Tooltip-Background]],
edgeFile = [[Interface\Tooltips\UI-Tooltip-Border]], edgeSize = 16,
insets = { left = 4, right = 3, top = 4, bottom = 3 }
}
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:Hide()
local widgetNum = AceGUI:GetNextWidgetNum(Type)
local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
label:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, -4)
label:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, -4)
label:SetJustifyH("LEFT")
label:SetText(ACCEPT)
label:SetHeight(10)
local button = CreateFrame("Button", ("%s%dButton"):format(Type, widgetNum), frame, "UIPanelButtonTemplate")
button:SetPoint("BOTTOMLEFT", 0, 4)
button:SetHeight(22)
button:SetWidth(label:GetStringWidth() + 24)
button:SetText(ACCEPT)
button:SetScript("OnClick", OnClick)
button:Disable()
local text = button:GetFontString()
text:ClearAllPoints()
text:SetPoint("TOPLEFT", button, "TOPLEFT", 5, -5)
text:SetPoint("BOTTOMRIGHT", button, "BOTTOMRIGHT", -5, 1)
text:SetJustifyV("MIDDLE")
local scrollBG = CreateFrame("Frame", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
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)

287
Libraries/Ace3/AceGUI-3.0/widgets/AceGUIWidget-Slider-ElvUI.lua Normal file
View File

@ -0,0 +1,287 @@
--[[-----------------------------------------------------------------------------
Slider Widget (Modified to support min and max fuctions on SetSliderValues)
Graphical Slider, like, for Range values.
-------------------------------------------------------------------------------]]
local Type, Version = "Slider-ElvUI", 2
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, newvalue)
local self = frame.obj
if not frame.setup then
if self.step and self.step > 0 then
local min_value = self.min or 0
newvalue = floor((newvalue - min_value) / self.step + 0.5) * self.step + min_value
end
if newvalue ~= self.value and not self.disabled then
self.value = newvalue
self:Fire("OnValueChanged", newvalue)
end
if self.value then
UpdateText(self)
end
end
end
local function Slider_OnMouseUp(frame)
local self = frame.obj
self:Fire("OnMouseUp", self.value)
end
local function Slider_OnMouseWheel(frame, v)
local self = frame.obj
if not self.disabled then
local value = self.value
if v > 0 then
value = min(value + (self.step or 1), self.max)
else
value = max(value - (self.step or 1), self.min)
end
self.slider:SetValue(value)
end
end
local function EditBox_OnEscapePressed(frame)
frame:ClearFocus()
end
local function EditBox_OnEnterPressed(frame)
local self = frame.obj
local value = frame:GetText()
if self.ispercent then
value = value:gsub('%%', '')
value = tonumber(value) / 100
else
value = tonumber(value)
end
if value then
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
self.slider:SetValue(value)
self:Fire("OnMouseUp", value)
end
end
local function EditBox_OnEnter(frame)
frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1)
end
local function EditBox_OnLeave(frame)
frame:SetBackdropBorderColor(0.3, 0.3, 0.3, 0.8)
end
--[[-----------------------------------------------------------------------------
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
self:SetWidth(200)
self:SetHeight(44)
self:SetDisabled(false)
self:SetIsPercent(nil)
self:SetSliderValues(0,100,1)
self:SetValue(0)
self.slider:EnableMouseWheel(false)
end,
-- ["OnRelease"] = nil,
["SetDisabled"] = function(self, disabled)
self.disabled = disabled
if disabled then
self.slider:EnableMouse(false)
self.label:SetTextColor(.5, .5, .5)
self.hightext:SetTextColor(.5, .5, .5)
self.lowtext:SetTextColor(.5, .5, .5)
--self.valuetext:SetTextColor(.5, .5, .5)
self.editbox:SetTextColor(.5, .5, .5)
self.editbox:EnableMouse(false)
self.editbox:ClearFocus()
else
self.slider:EnableMouse(true)
self.label:SetTextColor(1, .82, 0)
self.hightext:SetTextColor(1, 1, 1)
self.lowtext:SetTextColor(1, 1, 1)
--self.valuetext:SetTextColor(1, 1, 1)
self.editbox:SetTextColor(1, 1, 1)
self.editbox:EnableMouse(true)
end
end,
["SetValue"] = function(self, value)
self.slider.setup = true
self.slider:SetValue(value)
self.value = value
UpdateText(self)
self.slider.setup = nil
end,
["GetValue"] = function(self)
return self.value
end,
["SetLabel"] = function(self, text)
self.label:SetText(text)
end,
["SetSliderValues"] = function(self, min, max, step)
if type(min) == 'function' then min = min() end
if type(max) == 'function' then max = max() end
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, BackdropTemplateMixin and "BackdropTemplate" or nil)
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, BackdropTemplateMixin and "BackdropTemplate" or nil)
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)

29
Libraries/Ace3/LICENSE.txt Normal file
View File

@ -0,0 +1,29 @@
Copyright (c) 2007, Ace3 Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Redistribution of a stand alone version is strictly prohibited without
prior written authorization from the Lead of the Ace3 Development Team.
* Neither the name of the Ace3 Development Team nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

235
Libraries/AceGUI-3.0-SharedMediaWidgets/BackgroundWidget.lua Normal file
View File

@ -0,0 +1,235 @@
-- 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 = 12
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("TOPLEFT", check, "TOPRIGHT", 1, 0)
text:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -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()
local width = self.frame:GetWidth()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
self.dropdown:SetPoint("TOPRIGHT", self.frame, "BOTTOMRIGHT", width < 160 and (160 - width) or 0, 0)
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

230
Libraries/AceGUI-3.0-SharedMediaWidgets/BorderWidget.lua Normal file
View File

@ -0,0 +1,230 @@
-- 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 = 12
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("TOPLEFT", check, "TOPRIGHT", 1, 0)
text:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -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()
local width = self.frame:GetWidth()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
self.dropdown:SetPoint("TOPRIGHT", self.frame, "BOTTOMRIGHT", width < 160 and (160 - width) or 0, 0)
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

216
Libraries/AceGUI-3.0-SharedMediaWidgets/FontWidget.lua Normal file
View File

@ -0,0 +1,216 @@
-- 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 = 12
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("TOPLEFT", check, "TOPRIGHT", 1, 0)
text:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -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()
local width = self.frame:GetWidth()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
self.dropdown:SetPoint("TOPRIGHT", self.frame, "BOTTOMRIGHT", width < 160 and (160 - width) or 0, 0)
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

264
Libraries/AceGUI-3.0-SharedMediaWidgets/SoundWidget.lua Normal file
View File

@ -0,0 +1,264 @@
-- 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 = 12
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), "Master")
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("TOPLEFT", check, "TOPRIGHT", 1, 0)
text:SetPoint("BOTTOMRIGHT", soundbutton, "BOTTOMLEFT", -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()
local width = self.frame:GetWidth()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
self.dropdown:SetPoint("TOPRIGHT", self.frame, "BOTTOMRIGHT", width < 160 and (160 - width) or 0, 0)
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), "Master")
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

233
Libraries/AceGUI-3.0-SharedMediaWidgets/StatusbarWidget.lua Normal file
View File

@ -0,0 +1,233 @@
-- 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 = 12
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("TOPLEFT", check, "TOPRIGHT", 3, 0)
text:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -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()
local width = self.frame:GetWidth()
self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT")
self.dropdown:SetPoint("TOPRIGHT", self.frame, "BOTTOMRIGHT", width < 160 and (160 - width) or 0, 0)
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, "OVERLAY")
bar:SetPoint("TOPLEFT", frame,"TOPLEFT",6,-25)
bar:SetPoint("BOTTOMRIGHT", frame,"BOTTOMRIGHT", -21, 5)
bar:SetAlpha(0.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

266
Libraries/AceGUI-3.0-SharedMediaWidgets/prototypes.lua Normal file
View File

@ -0,0 +1,266 @@
-- Widget created by Yssaril
local DataVersion = 9003
local AGSMW = LibStub:NewLibrary("AceGUISharedMediaWidgets-1.0", DataVersion)
if not AGSMW then
return -- already loaded and no upgrade necessary
end
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)
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)
frame:SetFrameStrata(self:GetFrameStrata())
frame:SetFrameLevel(self:GetFrameLevel() + 100)
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:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", -28, 12)
self:SetHeight(UIParent:GetHeight()*2/5)
self.slider:Show()
self:SetScript("OnMouseWheel", OnMouseWheel)
self.slider:SetMinMaxValues(0, self.contentframe:GetHeight()-self.scrollframe:GetHeight())
else
self.scrollframe:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", -14, 12)
self:SetHeight(self.contentframe:GetHeight()+25)
self.slider:Hide()
self:SetScript("OnMouseWheel", nil)
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, "BackdropTemplate")
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:SetWidth(160)
scrollframe:SetPoint("TOPLEFT", frame, "TOPLEFT", 14, -13)
scrollframe:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -14, 12)
scrollframe:SetScrollChild(contentframe)
frame.scrollframe = scrollframe
contentframe:SetPoint("TOPLEFT", scrollframe)
contentframe:SetPoint("TOPRIGHT", 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, "BackdropTemplate")
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

9
Libraries/AceGUI-3.0-SharedMediaWidgets/widget.xml Normal file
View File

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

1253
Libraries/FAIAP/FAIAP.lua Normal file
View File

File diff suppressed because it is too large Load Diff

158
Libraries/LibAceConfigHelper/LibAceConfigHelper.lua Normal file
View File

@ -0,0 +1,158 @@
local LibStub = LibStub
local MAJOR, MINOR = 'LibAceConfigHelper', 2
local ACH = LibStub:NewLibrary(MAJOR, MINOR)
local LSM = LibStub('LibSharedMedia-3.0')
if not ACH then return end
function ACH:Color(name, desc, order, alpha, width, get, set, disabled, hidden)
return { type = 'color', name = name, desc = desc, order = order, hasAlpha = alpha, width = width, get = get, set = set, disabled = disabled, hidden = hidden }
end
function ACH:Description(name, order, fontSize, image, imageCoords, imageWidth, imageHeight, width, hidden)
return { type = 'description', name = name, order = order, fontSize = fontSize, image = image, imageCoords = imageCoords, imageWidth = imageWidth, imageHeight = imageHeight, width = width, hidden = hidden }
end
function ACH:Execute(name, desc, order, func, image, confirm, width, get, set, disabled, hidden)
local optionTable = { type = 'execute', name = name, desc = desc, order = order, func = func, image = image, width = width, get = get, set = set, disabled = disabled, hidden = hidden }
if confirm then
local confirmType = type(confirm)
if confirmType == 'boolean' then
optionTable.confirm = true
elseif confirmType == 'string' then
optionTable.confirm = true
optionTable.confirmText = confirm
elseif confirmType == 'function' then
optionTable.confirm = confirm
end
end
return optionTable
end
function ACH:Group(name, desc, order, childGroups, get, set, disabled, hidden, func)
return { type = 'group', childGroups = childGroups, name = name, desc = desc, order = order, set = set, get = get, hidden = hidden, disabled = disabled, func = func, args = {} }
end
function ACH:Header(name, order, get, set, hidden)
return { type = 'header', name = name, order = order, get = get, set = set, hidden = hidden }
end
function ACH:Input(name, desc, order, multiline, width, get, set, disabled, hidden, validate)
return { type = 'input', name = name, desc = desc, order = order, multiline = multiline, width = width, get = get, set = set, disabled = disabled, hidden = hidden, validate = validate }
end
function ACH:Select(name, desc, order, values, confirm, width, get, set, disabled, hidden)
local optionTable = { type = 'select', name = name, desc = desc, order = order, values = values, width = width, get = get, set = set, disabled = disabled, hidden = hidden }
if confirm then
local confirmType = type(confirm)
if confirmType == 'boolean' then
optionTable.confirm = true
elseif confirmType == 'string' then
optionTable.confirm = true
optionTable.confirmText = confirm
elseif confirmType == 'function' then
optionTable.confirm = confirm
end
end
return optionTable
end
function ACH:MultiSelect(name, desc, order, values, confirm, width, get, set, disabled, hidden)
local optionTable = { type = 'multiselect', name = name, desc = desc, order = order, values = values, width = width, get = get, set = set, disabled = disabled, hidden = hidden }
if confirm then
local confirmType = type(confirm)
if confirmType == 'boolean' then
optionTable.confirm = true
elseif confirmType == 'string' then
optionTable.confirm = true
optionTable.confirmText = confirm
elseif confirmType == 'function' then
optionTable.confirm = confirm
end
end
return optionTable
end
function ACH:Toggle(name, desc, order, tristate, confirm, width, get, set, disabled, hidden)
local optionTable = { type = 'toggle', name = name, desc = desc, order = order, tristate = tristate, width = width, get = get, set = set, disabled = disabled, hidden = hidden }
if confirm then
local confirmType = type(confirm)
if confirmType == 'boolean' then
optionTable.confirm = true
elseif confirmType == 'string' then
optionTable.confirm = true
optionTable.confirmText = confirm
elseif confirmType == 'function' then
optionTable.confirm = confirm
end
end
return optionTable
end
-- Values are the following: key = value
-- min - min value
-- max - max value
-- softMin - 'soft' minimal value, used by the UI for a convenient limit while allowing manual input of values up to min/max
-- softMax - 'soft' maximal value, used by the UI for a convenient limit while allowing manual input of values up to min/max
-- step - step value: 'smaller than this will break the code' (default=no stepping limit)
-- bigStep - a more generally-useful step size. Support in UIs is optional.
-- isPercent (boolean) - represent e.g. 1.0 as 100%, etc. (default=false)
function ACH:Range(name, desc, order, values, width, get, set, disabled, hidden)
local optionTable = { type = 'range', name = name, desc = desc, order = order, width = width, get = get, set = set, disabled = disabled, hidden = hidden }
for key, value in pairs(values) do
optionTable[key] = value
end
return optionTable
end
function ACH:Spacer(order, width)
return { name = ' ', type = 'description', order = order, width = width }
end
local function SharedMediaSelect(type, name, desc, order, values, width, get, set, disabled, hidden)
return { type = 'select', dialogControl = type, name = name, desc = desc, order = order, values = values, width = width, get = get, set = set, disabled = disabled, hidden = hidden }
end
function ACH:SharedMediaFont(name, desc, order, width, get, set, disabled, hidden)
return SharedMediaSelect('LSM30_Font', name, desc, order, function() return LSM:HashTable('font') end, width, get, set, disabled, hidden)
end
function ACH:SharedMediaSound(name, desc, order, width, get, set, disabled, hidden)
return SharedMediaSelect('LSM30_Sound', name, desc, order, function() return LSM:HashTable('sound') end, width, get, set, disabled, hidden)
end
function ACH:SharedMediaStatusbar(name, desc, order, width, get, set, disabled, hidden)
return SharedMediaSelect('LSM30_Statusbar', name, desc, order, function() return LSM:HashTable('statusbar') end, width, get, set, disabled, hidden)
end
function ACH:SharedMediaBackground(name, desc, order, width, get, set, disabled, hidden)
return SharedMediaSelect('LSM30_Background', name, desc, order, function() return LSM:HashTable('background') end, width, get, set, disabled, hidden)
end
function ACH:SharedMediaBorder(name, desc, order, width, get, set, disabled, hidden)
return SharedMediaSelect('LSM30_Border', name, desc, order, function() return LSM:HashTable('border') end, width, get, set, disabled, hidden)
end
local FontFlagValues = {
NONE = NONE,
OUTLINE = 'Outline',
THICKOUTLINE = 'Thick',
MONOCHROME = 'Monochrome',
MONOCHROMEOUTLINE = 'Monochrome Outline',
MONOCHROMETHICKOUTLINE = 'Monochrome Thick',
}
function ACH:FontFlags(name, desc, order, width, get, set, disabled, hidden)
return { type = 'select', name = name, desc = desc, order = order, width = width, get = get, set = set, disabled = disabled, hidden = hidden, values = FontFlagValues }
end

8
Libraries/Load_Libraries.xml Normal file
View File

@ -0,0 +1,8 @@
<Ui xmlns='http://www.blizzard.com/wow/ui/'>
<Script file='FAIAP\FAIAP.lua'/>
<Script file='LibAceConfigHelper\LibAceConfigHelper.lua'/>
<Include file='Ace3\AceGUI-3.0\AceGUI-3.0.xml'/>
<Include file='Ace3\AceConfig-3.0\AceConfig-3.0.xml'/>
<Include file='Ace3\AceDBOptions-3.0\AceDBOptions-3.0.xml'/>
<Include file='AceGUI-3.0-SharedMediaWidgets\widget.xml'/>
</Ui>

12
Locales/Load_Locales.xml Normal file
View File

@ -0,0 +1,12 @@
<Ui xmlns='http://www.blizzard.com/wow/ui/'>
<Script file='enUS.lua'/>
<Script file='deDE.lua'/>
<Script file='esMX.lua'/>
<Script file='frFR.lua'/>
<Script file='itIT.lua'/>
<Script file='koKR.lua'/>
<Script file='ptBR.lua'/>
<Script file='ruRU.lua'/>
<Script file='zhTW.lua'/>
<Script file='zhCN.lua'/>
</Ui>

1671
Locales/deDE.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1660
Locales/enUS.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1667
Locales/esMX.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1666
Locales/frFR.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1656
Locales/itIT.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1708
Locales/koKR.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1667
Locales/ptBR.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1664
Locales/ruRU.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1672
Locales/zhCN.lua Normal file
View File

File diff suppressed because it is too large Load Diff

1665
Locales/zhTW.lua Normal file
View File

File diff suppressed because it is too large Load Diff

102
Maps.lua Normal file
View File

@ -0,0 +1,102 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local WM = E:GetModule('WorldMap')
local MM = E:GetModule('Minimap')
local ACH = E.Libs.ACH
local _G = _G
-- GLOBALS: WORLD_MAP_MIN_ALPHA
local buttonPositions = {
LEFT = L["Left"],
RIGHT = L["Right"],
TOP = L["Top"],
BOTTOM = L["Bottom"],
TOPLEFT = L["Top Left"],
TOPRIGHT = L["Top Right"],
BOTTOMLEFT = L["Bottom Left"],
BOTTOMRIGHT = L["Bottom Right"],
}
local buttonScale = { min = 0.5, max = 2, step = 0.05 }
local buttonOffsets = { min = -60, max = 60, step = 1 }
E.Options.args.maps = ACH:Group(L["Maps"], nil, 2, 'tab')
E.Options.args.maps.args.worldMap = ACH:Group(L["WORLD_MAP"], nil, 1, 'tab')
E.Options.args.maps.args.worldMap.args.enable = ACH:Toggle(L["Enable"], L["Enable/Disable the World Map Enhancements."], 0, nil, nil, nil, function() return E.private.general.worldMap end, function(_, value) E.private.general.worldMap = value; E:StaticPopup_Show("PRIVATE_RL") end)
E.Options.args.maps.args.worldMap.args.generalGroup = ACH:Group(L["General"], nil, 1, nil, function(info) return E.global.general[info[#info]] end, function(info, value) E.global.general[info[#info]] = value end, function() return not E.private.general.worldMap end)
E.Options.args.maps.args.worldMap.args.generalGroup.inline = true
E.Options.args.maps.args.worldMap.args.generalGroup.args.smallerWorldMap = ACH:Toggle(L["Smaller World Map"], L["Make the world map smaller."], 1, nil, nil, nil, nil, function(_, value) E.global.general.smallerWorldMap = value; E:StaticPopup_Show('GLOBAL_RL') end)
E.Options.args.maps.args.worldMap.args.generalGroup.args.smallerWorldMapScale = ACH:Range(L["Smaller World Map Scale"], nil, 2, { min = .5, max = .9, step = .01, isPercent = true }, nil, nil, function(_, value) E.global.general.smallerWorldMapScale = value; E:StaticPopup_Show('GLOBAL_RL') end)
E.Options.args.maps.args.worldMap.args.generalGroup.args.spacer1 = ACH:Spacer(3)
E.Options.args.maps.args.worldMap.args.generalGroup.args.fadeMapWhenMoving = ACH:Toggle(L["MAP_FADE_TEXT"], nil, 4)
E.Options.args.maps.args.worldMap.args.generalGroup.args.mapAlphaWhenMoving = ACH:Range(L["Map Opacity When Moving"], nil, 5, { min = 0, max = 1, step = .01, isPercent = true }, nil, nil, function(_, value) E.global.general.mapAlphaWhenMoving = value; E.WorldMap.UpdateMapFade(_G.WorldMapFrame, E.global.general.mapAlphaWhenMoving, 1.0, E.global.general.fadeMapDuration, E.noop); end) -- we use E.noop to force the update of the minValue here
E.Options.args.maps.args.worldMap.args.generalGroup.args.fadeMapDuration = ACH:Range(L["Fade Duration"], nil, 6, { min = 0, max = 1, step = .01, isPercent = true }, nil, nil, function(_, value) E.global.general.mapAlphaWhenMoving = value; E.WorldMap.UpdateMapFade(_G.WorldMapFrame, E.global.general.mapAlphaWhenMoving, 1.0, E.global.general.fadeMapDuration, E.noop); end) -- we use E.noop to force the update of the minValue here
E.Options.args.maps.args.worldMap.args.coordinatesGroup = ACH:Group(L["World Map Coordinates"], nil, 3, nil, function(info) return E.global.general.WorldMapCoordinates[info[#info]] end, function(info, value) E.global.general.WorldMapCoordinates[info[#info]] = value; WM:PositionCoords() end, function() return not E.private.general.worldMap end)
E.Options.args.maps.args.worldMap.args.coordinatesGroup.inline = true
E.Options.args.maps.args.worldMap.args.coordinatesGroup.args.enable = ACH:Toggle(L["Enable"], L["Puts coordinates on the world map."], 1, nil, nil, nil, nil, function(_, value) E.global.general.WorldMapCoordinates.enable = value; E:StaticPopup_Show('GLOBAL_RL') end)
E.Options.args.maps.args.worldMap.args.coordinatesGroup.args.position = ACH:Select(L["Position"], nil, 3, buttonPositions, nil, nil, nil, nil, function() return not E.global.general.WorldMapCoordinates.enable end)
E.Options.args.maps.args.worldMap.args.coordinatesGroup.args.xOffset = ACH:Range(L["X-Offset"], nil, 4, { min = -200, max = 200, step = 1 }, nil, nil, nil, function() return not E.global.general.WorldMapCoordinates.enable end)
E.Options.args.maps.args.worldMap.args.coordinatesGroup.args.yOffset = ACH:Range(L["Y-Offset"], nil, 5, { min = -200, max = 200, step = 1 }, nil, nil, nil, function() return not E.global.general.WorldMapCoordinates.enable end)
E.Options.args.maps.args.minimap = ACH:Group(L["MINIMAP_LABEL"], nil, 2, 'tab', function(info) return E.db.general.minimap[info[#info]] end, function(info, value) E.db.general.minimap[info[#info]] = value; MM:UpdateSettings() end)
E.Options.args.maps.args.minimap.args.generalGroup = ACH:Group(L["General"], nil, 1)
E.Options.args.maps.args.minimap.args.generalGroup.inline = true
E.Options.args.maps.args.minimap.args.generalGroup.args.enable = ACH:Toggle(L["Enable"], L["Enable/Disable the minimap. |cffFF0000Warning: This will prevent you from seeing the minimap datatexts.|r"], 1, nil, nil, nil, function(info) return E.private.general.minimap[info[#info]] end, function(info, value) E.private.general.minimap[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL') end)
E.Options.args.maps.args.minimap.args.generalGroup.args.size = ACH:Range(L["Size"], L["Adjust the size of the minimap."], 2, { min = 24, max = 500, step = 1 }, nil, nil, nil, function() return not E.private.general.minimap.enable end)
E.Options.args.maps.args.minimap.args.locationTextGroup = ACH:Group(L["Location Text"], nil, 2, nil, function(info) return E.db.general.minimap[info[#info]] end, function(info, value) E.db.general.minimap[info[#info]] = value; MM:UpdateSettings(); MM:Update_ZoneText() end, function() return not E.private.general.minimap.enable end)
E.Options.args.maps.args.minimap.args.locationTextGroup.args.locationText = ACH:Select(L["Location Text"], L["Change settings for the display of the location text that is on the minimap."], 1, { MOUSEOVER = L["Minimap Mouseover"], SHOW = L["Always Display"], HIDE = L["Hide"] })
E.Options.args.maps.args.minimap.args.locationTextGroup.args.locationFont = ACH:SharedMediaFont(L["Font"], nil, 2)
E.Options.args.maps.args.minimap.args.locationTextGroup.args.locationFontSize = ACH:Range(L["FONT_SIZE"], nil, 3, { min = 6, max = 36, step = 1 })
E.Options.args.maps.args.minimap.args.locationTextGroup.args.locationFontOutline = ACH:Select(L["Font Outline"], nil, 4, C.Values.FontFlags)
E.Options.args.maps.args.minimap.args.zoomResetGroup = ACH:Group(L["Reset Zoom"], nil, 3, nil, function(info) return E.db.general.minimap.resetZoom[info[#info]] end, function(info, value) E.db.general.minimap.resetZoom[info[#info]] = value; MM:UpdateSettings() end, function() return not E.private.general.minimap.enable end)
E.Options.args.maps.args.minimap.args.zoomResetGroup.args.enable = ACH:Toggle(L["Reset Zoom"], nil, 1)
E.Options.args.maps.args.minimap.args.zoomResetGroup.args.time = ACH:Range(L["Seconds"], nil, 2, { min = 1, max = 15, step = 1 })
E.Options.args.maps.args.minimap.args.icons = ACH:Group(L["Minimap Buttons"], nil, 4, nil, function(info) return E.db.general.minimap.icons[info[#info - 1]][info[#info]] end, function(info, value) E.db.general.minimap.icons[info[#info - 1]][info[#info]] = value; MM:UpdateSettings() end, function() return not E.private.general.minimap.enable end)
E.Options.args.maps.args.minimap.args.icons.args.classHall = ACH:Group(L["GARRISON_LANDING_PAGE_TITLE"], nil, 1)
E.Options.args.maps.args.minimap.args.icons.args.classHall.args.hideClassHallReport = ACH:Toggle(L["Hide"], nil, 1, nil, nil, nil, function() return E.private.general.minimap.hideClassHallReport end, function(_, value) E.private.general.minimap.hideClassHallReport = value; MM:UpdateSettings() end)
E.Options.args.maps.args.minimap.args.icons.args.classHall.args.spacer = ACH:Spacer(2, 'full')
E.Options.args.maps.args.minimap.args.icons.args.classHall.args.position = ACH:Select(L["Position"], nil, 3, buttonPositions, nil, nil, nil, nil, function() return E.private.general.minimap.hideClassHallReport end)
E.Options.args.maps.args.minimap.args.icons.args.classHall.args.scale = ACH:Range(L["Scale"], nil, 4, buttonScale, nil, nil, nil, function() return E.private.general.minimap.hideClassHallReport end)
E.Options.args.maps.args.minimap.args.icons.args.classHall.args.xOffset = ACH:Range(L["X-Offset"], nil, 5, buttonOffsets, nil, nil, nil, function() return E.private.general.minimap.hideClassHallReport end)
E.Options.args.maps.args.minimap.args.icons.args.classHall.args.yOffset = ACH:Range(L["Y-Offset"], nil, 6, buttonOffsets, nil, nil, nil, function() return E.private.general.minimap.hideClassHallReport end)
E.Options.args.maps.args.minimap.args.icons.args.calendar = ACH:Group(L["Calendar"], nil, 2)
E.Options.args.maps.args.minimap.args.icons.args.calendar.args.hideCalendar = ACH:Toggle(L["Hide"], nil, 1, nil, nil, nil, function() return E.private.general.minimap.hideCalendar end, function(_, value) E.private.general.minimap.hideCalendar = value; MM:UpdateSettings() end)
E.Options.args.maps.args.minimap.args.icons.args.calendar.args.spacer = ACH:Spacer(2, 'full')
E.Options.args.maps.args.minimap.args.icons.args.calendar.args.position = ACH:Select(L["Position"], nil, 3, buttonPositions, nil, nil, nil, nil, function() return E.private.general.minimap.hideCalendar end)
E.Options.args.maps.args.minimap.args.icons.args.calendar.args.scale = ACH:Range(L["Scale"], nil, 4, buttonScale, nil, nil, nil, function() return E.private.general.minimap.hideCalendar end)
E.Options.args.maps.args.minimap.args.icons.args.calendar.args.xOffset = ACH:Range(L["X-Offset"], nil, 5, buttonOffsets, nil, nil, nil, function() return E.private.general.minimap.hideCalendar end)
E.Options.args.maps.args.minimap.args.icons.args.calendar.args.yOffset = ACH:Range(L["Y-Offset"], nil, 6, buttonOffsets, nil, nil, nil, function() return E.private.general.minimap.hideCalendar end)
E.Options.args.maps.args.minimap.args.icons.args.mail = ACH:Group(L["MAIL_LABEL"], nil, 3)
E.Options.args.maps.args.minimap.args.icons.args.mail.args.position = ACH:Select(L["Position"], nil, 1, buttonPositions)
E.Options.args.maps.args.minimap.args.icons.args.mail.args.scale = ACH:Range(L["Scale"], nil, 2, buttonScale)
E.Options.args.maps.args.minimap.args.icons.args.mail.args.xOffset = ACH:Range(L["X-Offset"], nil, 3, buttonOffsets)
E.Options.args.maps.args.minimap.args.icons.args.mail.args.yOffset = ACH:Range(L["Y-Offset"], nil, 4, buttonOffsets)
E.Options.args.maps.args.minimap.args.icons.args.lfgEye = ACH:Group(L["LFG Queue"], nil, 4)
E.Options.args.maps.args.minimap.args.icons.args.lfgEye.args.position = ACH:Select(L["Position"], nil, 1, buttonPositions)
E.Options.args.maps.args.minimap.args.icons.args.lfgEye.args.scale = ACH:Range(L["Scale"], nil, 2, buttonScale)
E.Options.args.maps.args.minimap.args.icons.args.lfgEye.args.xOffset = ACH:Range(L["X-Offset"], nil, 3, buttonOffsets)
E.Options.args.maps.args.minimap.args.icons.args.lfgEye.args.yOffset = ACH:Range(L["Y-Offset"], nil, 4, buttonOffsets)
E.Options.args.maps.args.minimap.args.icons.args.difficulty = ACH:Group(L["Instance Difficulty"], nil, 5)
E.Options.args.maps.args.minimap.args.icons.args.difficulty.args.position = ACH:Select(L["Position"], nil, 1, buttonPositions)
E.Options.args.maps.args.minimap.args.icons.args.difficulty.args.scale = ACH:Range(L["Scale"], nil, 2, buttonScale)
E.Options.args.maps.args.minimap.args.icons.args.difficulty.args.xOffset = ACH:Range(L["X-Offset"], nil, 3, buttonOffsets)
E.Options.args.maps.args.minimap.args.icons.args.difficulty.args.yOffset = ACH:Range(L["Y-Offset"], nil, 4, buttonOffsets)
E.Options.args.maps.args.minimap.args.icons.args.challengeMode = ACH:Group(L["CHALLENGE_MODE"], nil, 6)
E.Options.args.maps.args.minimap.args.icons.args.challengeMode.args.position = ACH:Select(L["Position"], nil, 1, buttonPositions)
E.Options.args.maps.args.minimap.args.icons.args.challengeMode.args.scale = ACH:Range(L["Scale"], nil, 2, buttonScale)
E.Options.args.maps.args.minimap.args.icons.args.challengeMode.args.xOffset = ACH:Range(L["X-Offset"], nil, 3, buttonOffsets)
E.Options.args.maps.args.minimap.args.icons.args.challengeMode.args.yOffset = ACH:Range(L["Y-Offset"], nil, 4, buttonOffsets)

254
ModuleControl.lua Normal file
View File

@ -0,0 +1,254 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local UF = E:GetModule('UnitFrames')
local MC = E:GetModule('ModuleCopy')
local ACH = E.Libs.ACH
local type, pairs = type, pairs
function MC:AddConfigOptions(settings, config)
for option, tbl in pairs(settings) do
if type(tbl) == 'table' and not (tbl.r and tbl.g and tbl.b) then
config.args[option] = ACH:Toggle(option)
end
end
end
--Actionbars
local function CreateActionbarsConfig()
local config = MC:CreateModuleConfigGroup(L["ActionBars"], 'actionbar')
local order = 3
MC:AddConfigOptions(P.actionbar, config)
config.args.cooldown.name = L["Cooldown Text"]
config.args.cooldown.order = 2
for i = 1, 10 do
config.args['bar'..i].name = L["Bar "]..i
config.args['bar'..i].order = order
order = order + 1
end
config.args.barPet.name = L["Pet Bar"]
config.args.stanceBar.name = L["Stance Bar"]
config.args.microbar.name = L["Micro Bar"]
config.args.extraActionButton.name = L["Boss Button"]
config.args.vehicleExitButton.name = L["Vehicle Exit"]
return config
end
--Auras
local function CreateAurasConfig()
local config = MC:CreateModuleConfigGroup(L["Auras"], 'auras')
MC:AddConfigOptions(P.auras, config)
config.args.cooldown.name = L["Cooldown Text"]
config.args.cooldown.order = 2
config.args.buffs.name = L["Buffs"]
config.args.debuffs.name = L["Debuffs"]
return config
end
--Bags
local function CreateBagsConfig()
local config = MC:CreateModuleConfigGroup(L["Bags"], 'bags')
MC:AddConfigOptions(P.bags, config)
config.args.cooldown.name = L["Cooldown Text"]
config.args.cooldown.order = 2
config.args.ignoredItems = nil
config.args.colors.name = L["COLORS"]
config.args.bagBar.name = L["Bag-Bar"]
config.args.split.name = L["Split"]
config.args.vendorGrays.name = L["Vendor Grays"]
return config
end
--Chat
local function CreateChatConfig()
return MC:CreateModuleConfigGroup(L["Chat"], 'chat')
end
--Cooldowns
local function CreateCooldownConfig()
local config = MC:CreateModuleConfigGroup(L["Cooldown Text"], 'cooldown')
config.args.fonts = ACH:Toggle(L["Fonts"], nil, 2)
return config
end
--DataBars
local function CreateDatatbarsConfig()
local config = MC:CreateModuleConfigGroup(L["DataBars"], 'databars')
MC:AddConfigOptions(P.databars, config)
config.args.experience.name = L["Experience"]
config.args.reputation.name = L["Reputation"]
config.args.honor.name = L["Honor"]
config.args.threat.name = L["Threat"]
config.args.azerite.name = L["Azerite"]
return config
end
--DataTexts
local function CreateDatatextsConfig()
local config = MC:CreateModuleConfigGroup(L["DataTexts"], 'datatexts')
config.args.panels = ACH:Toggle(L["Panels"], nil, 2)
return config
end
--General
local function CreateGeneralConfig()
local config = MC:CreateModuleConfigGroup(L["General"], 'general')
MC:AddConfigOptions(P.general, config)
config.args.altPowerBar.name = L["Alternative Power"]
config.args.minimap.name = L["MINIMAP_LABEL"]
config.args.totems.name = L["Class Totems"]
config.args.itemLevel.name = L["Item Level"]
return config
end
--NamePlates
local function CreateNamePlatesConfig()
local config = MC:CreateModuleConfigGroup(L["NamePlates"], 'nameplates')
MC:AddConfigOptions(P.nameplates, config)
-- Locales
config.args.cooldown.name = L["Cooldown Text"]
config.args.cooldown.order = 2
config.args.threat.name = L["Threat"]
config.args.cutaway.name = L["Cutaway Bars"]
config.args.clickThrough.name = L["Click Through"]
config.args.plateSize.name = L["Clickable Size"]
config.args.colors.name = L["COLORS"]
config.args.visibility.name = L["Visibility"]
-- Modify Tables
config.args.filters = nil
config.args.units = ACH:Group(L["NamePlates"], nil, -5, nil, function(info) return E.global.profileCopy.nameplates[info[#info-1]][info[#info]] end, function(info, value) E.global.profileCopy.nameplates[info[#info-1]][info[#info]] = value; end)
config.args.units.inline = true
MC:AddConfigOptions(P.nameplates.units, config.args.units)
-- Locales
config.args.units.args.PLAYER.name = L["Player"]
config.args.units.args.TARGET.name = L["Target"]
config.args.units.args.FRIENDLY_PLAYER.name = L["FRIENDLY_PLAYER"]
config.args.units.args.ENEMY_PLAYER.name = L["ENEMY_PLAYER"]
config.args.units.args.FRIENDLY_NPC.name = L["FRIENDLY_NPC"]
config.args.units.args.ENEMY_NPC.name = L["ENEMY_NPC"]
return config
end
--Tooltip
local function CreateTooltipConfig()
local config = MC:CreateModuleConfigGroup(L["Tooltip"], 'tooltip')
MC:AddConfigOptions(P.tooltip, config)
config.args.visibility.name = L["Visibility"]
config.args.healthBar.name = L["Health Bar"]
config.args.factionColors.name = L["Custom Faction Colors"]
return config
end
--UnitFrames
local function CreateUnitframesConfig()
local config = MC:CreateModuleConfigGroup(L["UnitFrames"], 'unitframe')
config.args.cooldown = ACH:Toggle(L["Cooldown Text"], nil, 2, nil, nil, nil, function(info) return E.global.profileCopy.unitframe[info[#info]] end, function(info, value) E.global.profileCopy.unitframe[info[#info]] = value; end)
config.args.colors = ACH:Group(L["COLORS"], nil, 3, nil, function(info) return E.global.profileCopy.unitframe[info[#info-1]][info[#info]] end, function(info, value) E.global.profileCopy.unitframe[info[#info-1]][info[#info]] = value; end)
config.args.colors.inline = true
MC:AddConfigOptions(P.unitframe.colors, config.args.colors)
config.args.colors.args.power.name = L["Powers"]
config.args.colors.args.reaction.name = L["Reactions"]
config.args.colors.args.healPrediction.name = L["Heal Prediction"]
config.args.colors.args.classResources.name = L["Class Resources"]
config.args.colors.args.frameGlow.name = L["Frame Glow"]
config.args.colors.args.debuffHighlight.name = L["Debuff Highlighting"]
config.args.colors.args.powerPrediction.name = L["Power Prediction"]
config.args.colors.args.selection.name = L["Selection"]
config.args.colors.args.threat.name = L["Threat"]
config.args.units = ACH:Group(L["UnitFrames"], nil, 4, nil, function(info) return E.global.profileCopy.unitframe[info[#info-1]][info[#info]] end, function(info, value) E.global.profileCopy.unitframe[info[#info-1]][info[#info]] = value; end)
config.args.units.inline = true
MC:AddConfigOptions(P.unitframe.units, config.args.units)
config.args.units.args.player.name = L["Player"]
config.args.units.args.target.name = L["Target"]
config.args.units.args.targettarget.name = L["TargetTarget"]
config.args.units.args.targettargettarget.name = L["TargetTargetTarget"]
config.args.units.args.focus.name = L["Focus"]
config.args.units.args.focustarget.name = L["FocusTarget"]
config.args.units.args.pet.name = L["PET"]
config.args.units.args.pettarget.name = L["PetTarget"]
config.args.units.args.boss.name = L["Boss"]
config.args.units.args.arena.name = L["Arena"]
config.args.units.args.party.name = L["PARTY"]
config.args.units.args.raid.name = L["Raid"]
config.args.units.args.raid40.name = L["Raid-40"]
config.args.units.args.raidpet.name = L["Raid Pet"]
config.args.units.args.tank.name = L["TANK"]
config.args.units.args.assist.name = L["Assist"]
return config
end
E.Options.args.modulecontrol= ACH:Group(L["Module Control"], nil, 3, 'tab')
E.Options.args.modulecontrol.args.modulecopy = ACH:Group(L["Module Copy"], nil, 1, 'tab')
E.Options.args.modulecontrol.args.modulecopy.handler = E.Options.args.profiles.handler
E.Options.args.modulecontrol.args.modulecopy.args.intro = ACH:Description(L["This section will allow you to copy settings to a select module from or to a different profile."], 1, 'medium')
E.Options.args.modulecontrol.args.modulecopy.args.pluginInfo = ACH:Description(L["If you have any plugins supporting this feature installed you can find them in the selection dropdown to the right."], 2, 'medium')
E.Options.args.modulecontrol.args.modulecopy.args.profile = ACH:Select(L["Profile"], L["Select a profile to copy from/to."], 3, function() local tbl = {} for profile in pairs(E.data.profiles) do tbl[profile] = profile end return tbl end, nil, nil, function() return E.global.profileCopy.selected end, function(_, value) E.global.profileCopy.selected = value end)
E.Options.args.modulecontrol.args.modulecopy.args.elvui = ACH:Group('ElvUI', L["Core |cff1784d1ElvUI|r options."], 10, 'tree')
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.header = ACH:Header(L["Core |cff1784d1ElvUI|r options."], 0)
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.actionbar = CreateActionbarsConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.auras = CreateAurasConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.bags = CreateBagsConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.chat = CreateChatConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.cooldown = CreateCooldownConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.databars = CreateDatatbarsConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.datatexts = CreateDatatextsConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.general = CreateGeneralConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.nameplates = CreateNamePlatesConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.tooltip = CreateTooltipConfig()
E.Options.args.modulecontrol.args.modulecopy.args.elvui.args.uniframes = CreateUnitframesConfig()
E.Options.args.modulecontrol.args.modulecopy.args.movers = ACH:Group(L["Movers"], L["On screen positions for different elements."], 20, 'tree')
E.Options.args.modulecontrol.args.modulecopy.args.movers.args = MC:CreateMoversConfigGroup()
E.Options.args.modulecontrol.args.modulereset = ACH:Group(L["Module Reset"], nil, 2, nil, nil, nil, nil, nil, function(info) E:CopyTable(E.db[info[#info]], P[info[#info]]) end)
E.Options.args.modulecontrol.args.modulereset.args.header = ACH:Header(L["Module Reset"], 0)
E.Options.args.modulecontrol.args.modulereset.args.intro = ACH:Description(L["This section will help reset specfic settings back to default."], 1)
E.Options.args.modulecontrol.args.modulereset.args.space1 = ACH:Spacer(2)
E.Options.args.modulecontrol.args.modulereset.args.general = ACH:Execute(L["General"], nil, 3, nil, nil, L["Are you sure you want to reset General settings?"])
E.Options.args.modulecontrol.args.modulereset.args.actionbar = ACH:Execute(L["ActionBars"], nil, 4, nil, nil, L["Are you sure you want to reset ActionBars settings?"])
E.Options.args.modulecontrol.args.modulereset.args.bags = ACH:Execute(L["Bags"], nil, 5, nil, nil, L["Are you sure you want to reset Bags settings?"])
E.Options.args.modulecontrol.args.modulereset.args.auras = ACH:Execute(L["Auras"], nil, 6, nil, nil, L["Are you sure you want to reset Auras settings?"])
E.Options.args.modulecontrol.args.modulereset.args.chat = ACH:Execute(L["Chat"], nil, 7, nil, nil, L["Are you sure you want to reset Chat settings?"])
E.Options.args.modulecontrol.args.modulereset.args.cooldown = ACH:Execute(L["Cooldown Text"], nil, 8, nil, nil, L["Are you sure you want to reset Cooldown settings?"])
E.Options.args.modulecontrol.args.modulereset.args.databars = ACH:Execute(L["DataBars"], nil, 9, nil, nil, L["Are you sure you want to reset DataBars settings?"])
E.Options.args.modulecontrol.args.modulereset.args.datatexts = ACH:Execute(L["DataTexts"], nil, 10, nil, nil, L["Are you sure you want to reset DataTexts settings?"])
E.Options.args.modulecontrol.args.modulereset.args.nameplates = ACH:Execute(L["NamePlates"], nil, 11, nil, nil, L["Are you sure you want to reset NamePlates settings?"])
E.Options.args.modulecontrol.args.modulereset.args.tooltip = ACH:Execute(L["Tooltip"], nil, 12, nil, nil, L["Are you sure you want to reset Tooltip settings?"])
E.Options.args.modulecontrol.args.modulereset.args.uniframes = ACH:Execute(L["UnitFrames"], nil, 13, function() E:CopyTable(E.db.unitframe, P.unitframe); UF:Update_AllFrames() end, nil, L["Are you sure you want to reset UnitFrames settings?"])

6702
Nameplates.lua Normal file
View File

File diff suppressed because it is too large Load Diff

141
Skins.lua Normal file
View File

@ -0,0 +1,141 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local B = E:GetModule('Blizzard')
local ACH = E.Libs.ACH
local pairs = pairs
E.Options.args.skins = ACH:Group(L["Skins"], nil, 2, 'tab')
E.Options.args.skins.args.intro = ACH:Description(L["SKINS_DESC"], 0)
E.Options.args.skins.args.general = ACH:MultiSelect(L["General"], nil, 1, nil, nil, nil,
function(_, key)
if key == 'blizzardEnable' then
return E.private.skins.blizzard.enable
else
return E.private.skins[key] end
end,
function(_, key, value)
if key == 'blizzardEnable' then
E.private.skins.blizzard.enable = value
else
E.private.skins[key] = value
end
E:StaticPopup_Show('PRIVATE_RL')
end)
E.Options.args.skins.args.general.sortByValue = true
E.Options.args.skins.args.general.values = {
ace3Enable = 'Ace3',
blizzardEnable = L["Blizzard"],
checkBoxSkin = L["CheckBox Skin"],
parchmentRemoverEnable = L["Parchment Remover"],
}
E.Options.args.skins.args.talkingHead = ACH:Group(L["TalkingHead"], nil, 2, nil, function(info) return E.db.general[info[#info]] end)
E.Options.args.skins.args.talkingHead.inline = true
E.Options.args.skins.args.talkingHead.args.talkingHeadFrameScale = ACH:Range(L["Talking Head Scale"], nil, 1, { min = .5, max = 2, step = .01, isPercent = true }, nil, nil, function(_, value) E.db.general.talkingHeadFrameScale = value; B:ScaleTalkingHeadFrame() end)
E.Options.args.skins.args.talkingHead.args.talkingHeadFrameBackdrop = ACH:Toggle(L["Talking Head Backdrop"], nil, 2, nil, nil, nil, nil, function(_, value) E.db.general.talkingHeadFrameBackdrop = value; E:StaticPopup_Show('CONFIG_RL') end)
local function ToggleSkins(value)
for key in pairs(E.private.skins.blizzard) do
if key ~= 'enable' then
E.private.skins.blizzard[key] = value
end
end
end
E.Options.args.skins.args.disableBlizzardSkins = ACH:Execute(L["Disable Blizzard Skins"], nil, 3, function() ToggleSkins(false); E:StaticPopup_Show('PRIVATE_RL') end)
E.Options.args.skins.args.enableBlizzardSkins = ACH:Execute(L["Enable Blizzard Skins"], nil, 4, function() ToggleSkins(true); E:StaticPopup_Show('PRIVATE_RL') end)
E.Options.args.skins.args.blizzard = ACH:MultiSelect(L["Blizzard"], nil, -1, nil, nil, nil, function(_, key) return E.private.skins.blizzard[key] end, function(_, key, value) E.private.skins.blizzard[key] = value; E:StaticPopup_Show('PRIVATE_RL') end, function() return not E.private.skins.blizzard.enable end)
E.Options.args.skins.args.blizzard.sortByValue = true
E.Options.args.skins.args.blizzard.values = {
achievement = L["ACHIEVEMENTS"],
addonManager = L["AddOn Manager"],
adventureMap = L["ADVENTURE_MAP_TITLE"],
alertframes = L["Alert Frames"],
alliedRaces = L["Allied Races"],
animaDiversion = L["Anima Diversion"],
archaeology = L["Archaeology Frame"],
artifact = L["ITEM_QUALITY6_DESC"],
auctionhouse = L["AUCTIONS"],
azeriteEssence = L["Azerite Essence"],
azeriteRespec = L["AZERITE_RESPEC_TITLE"],
azerite = L["Azerite"],
bags = L["Bags"],
barber = L["BARBERSHOP"],
bgmap = L["BG Map"],
bgscore = L["BG Score"],
binding = L["KEY_BINDINGS"],
blizzardOptions = L["INTERFACE_OPTIONS"],
bmah = L["BLACK_MARKET_AUCTION_HOUSE"],
calendar = L["Calendar Frame"],
channels = L["CHANNELS"],
character = L["Character Frame"],
chromieTime = L["Chromie Time Frame"],
collections = L["COLLECTIONS"],
communities = L["COMMUNITIES"],
contribution = L["Contribution"],
covenantPreview = L["Covenant Preview"],
covenantSanctum = L["Covenant Sanctum"],
deathRecap = L["DEATH_RECAP_TITLE"],
debug = L["Debug Tools"],
dressingroom = L["DRESSUP_FRAME"],
encounterjournal = L["ENCOUNTER_JOURNAL"],
friends = L["FRIENDS"],
garrison = L["GARRISON_LOCATION_TOOLTIP"],
gbank = L["GUILD_BANK"],
gmChat = L["GM Chat"],
gossip = L["Gossip Frame"],
guide = L["Guide Frame"],
guild = L["GUILD"],
guildcontrol = L["Guild Control Frame"],
guildregistrar = L["Guild Registrar"],
help = L["Help Frame"],
inspect = L["INSPECT"],
islandQueue = L["ISLANDS_HEADER"],
islandsPartyPose = L["Island Party Pose"],
itemInteraction = L["Item Interaction"],
itemUpgrade = L["Item Upgrade"],
lfg = L["LFG_TITLE"],
lfguild = L["LF Guild Frame"],
loot = L["Loot Frames"],
losscontrol = L["LOSS_OF_CONTROL"],
macro = L["MACROS"],
mail = L["Mail Frame"],
merchant = L["Merchant Frame"],
mirrorTimers = L["Mirror Timers"],
misc = L["Misc Frames"],
nonraid = L["Non-Raid Frame"],
objectiveTracker = L["OBJECTIVES_TRACKER_LABEL"],
obliterum = L["OBLITERUM_FORGE_TITLE"],
orderhall = L["Orderhall"],
petbattleui = L["Pet Battle"],
petition = L["Petition Frame"],
playerChoice = L["Player Choice Frame"],
pvp = L["PvP Frames"],
quest = L["Quest Frames"],
questChoice = L["Quest Choice"],
raid = L["Raid Frame"],
runeforge = L["Runeforge"],
scrapping = L["SCRAP_BUTTON"],
socket = L["Socket Frame"],
spellbook = L["SPELLBOOK"],
stable = L["Stable"],
soulbinds = L["Soulbinds"],
tabard = L["Tabard Frame"],
talent = L["TALENTS"],
talkinghead = L["TalkingHead"],
taxi = L["FLIGHT_MAP"],
timemanager = L["TIMEMANAGER_TITLE"],
tooltip = L["Tooltip"],
torghastLevelPicker = L["Torghast Level Picker"],
trade = L["TRADE"],
tradeskill = L["TRADESKILLS"],
trainer = L["Trainer Frame"],
transmogrify = L["TRANSMOGRIFY"],
tutorials = L["Tutorials"],
voidstorage = L["VOID_STORAGE"],
warboard = L["Warboard"],
weeklyRewards = L["Weekly Rewards"],
worldmap = L["WORLD_MAP"],
}

50
Tags.lua Normal file
View File

@ -0,0 +1,50 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local ACH = E.Libs.ACH
local _G = _G
local format = format
E.Options.args.tagGroup = ACH:Group(L["Available Tags"], nil, 3, 'tab')
E.Options.args.tagGroup.args.GuideLink = ACH:Input(L["Guide:"], nil, 1, nil, nil, function() return 'https://www.tukui.org/forum/viewtopic.php?f=9&t=6' end)
E.Options.args.tagGroup.args.GuideLink.customWidth = 310
E.Options.args.tagGroup.args.WikiLink = ACH:Input(L["Wiki:"], nil, 2, nil, nil, function() return 'https://git.tukui.org/elvui/elvui/-/wikis/home' end)
E.Options.args.tagGroup.args.WikiLink.customWidth = 290
E.Options.args.tagGroup.args.ColorWheel = ACH:Execute(L["Color Picker"], nil, 3, function() _G.ColorPickerFrame:Show() _G.ColorPickerFrame:SetFrameStrata('FULLSCREEN_DIALOG') _G.ColorPickerFrame:SetClampedToScreen(true) _G.ColorPickerFrame:Raise() end)
E.Options.args.tagGroup.args.ColorWheel.customWidth = 120
E.Options.args.tagGroup.args.Colors = ACH:Group(L["Colors"])
E.Options.args.tagGroup.args.Colors.args.customTagColorInfo = ACH:Input('Custom color your Text: replace the XXXXXX with a Hex color code', nil, 1, nil, 'full', function() return '||cffXXXXXX [tags] or text here ||r' end)
E.Options.args.tagGroup.args.Names = ACH:Group(L["Names"])
E.Options.args.tagGroup.args.Names.args.nameHealthInfo1 = ACH:Input('|cFF666666[1/5]|r White name text, missing hp red', nil, 1, nil, 'full', function() return '[name:health]' end)
E.Options.args.tagGroup.args.Names.args.nameHealthInfo2 = ACH:Input('|cFF666666[2/5]|r Class color name text, missing hp red', nil, 2, nil, 'full', function() return '[name:health{class}]' end)
E.Options.args.tagGroup.args.Names.args.nameHealthInfo3 = ACH:Input('|cFF666666[3/5]|r Class color name text, missing hp based on hex code', nil, 3, nil, 'full', function() return '[name:health{class:00ff00}]' end)
E.Options.args.tagGroup.args.Names.args.nameHealthInfo4 = ACH:Input('|cFF666666[4/5]|r Name text based on hex code, missing hp red', nil, 4, nil, 'full', function() return '[name:health{00ff00}]' end)
E.Options.args.tagGroup.args.Names.args.nameHealthInfo5 = ACH:Input('|cFF666666[5/5]|r Name text based on hex code, missing hp class color', nil, 5, nil, 'full', function() return '[name:health{00ff00:class}]' end)
local getTag = function(info) return format('[%s]', info[#info]) end
for _, Table in pairs({'Events', 'Methods'}) do
for Tag in next, E.oUF.Tags[Table] do
if not E.TagInfo[Tag] then E:AddTagInfo(Tag, 'Miscellaneous') end
if not E.Options.args.tagGroup.args[E.TagInfo[Tag].category] then
E.Options.args.tagGroup.args[E.TagInfo[Tag].category] = {
name = E.TagInfo[Tag].category,
type = 'group',
args = {}
}
end
E.Options.args.tagGroup.args[E.TagInfo[Tag].category].args[Tag] = E.Options.args.tagGroup.args[E.TagInfo[Tag].category].args[Tag] or {}
E.Options.args.tagGroup.args[E.TagInfo[Tag].category].args[Tag].type = 'input'
E.Options.args.tagGroup.args[E.TagInfo[Tag].category].args[Tag].name = E.TagInfo[Tag].description ~= '' and E.TagInfo[Tag].description or getTag
E.Options.args.tagGroup.args[E.TagInfo[Tag].category].args[Tag].order = E.TagInfo[Tag].order or nil
E.Options.args.tagGroup.args[E.TagInfo[Tag].category].args[Tag].width = 'full'
E.Options.args.tagGroup.args[E.TagInfo[Tag].category].args[Tag].get = getTag
end
end
--[[ THIS SHOULD BE EXECUTED IN THE LAST LOADED CONFIG FILE, AT THE BOTTOM
NOTE: This is used to make sure Plugins use no less than the options order we want. ]]
E.OriginalOptions = {'plugins'}
for key in pairs(E.Options.args) do table.insert(E.OriginalOptions, key) end
setmetatable(E.OriginalOptions, {__newindex = E.noop})

66
Tooltip.lua Normal file
View File

@ -0,0 +1,66 @@
local E, _, V, P, G = unpack(ElvUI); --Import: Engine, Locales, PrivateDB, ProfileDB, GlobalDB
local C, L = unpack(select(2, ...))
local TT = E:GetModule('Tooltip')
local Skins = E:GetModule('Skins')
local ACH = E.Libs.ACH
local _G = _G
local tonumber = tonumber
local GameTooltip = _G.GameTooltip
local GameTooltipStatusBar = _G.GameTooltipStatusBar
local modifierValues = {
SHOW = L["Show"],
HIDE = L["Hide"],
SHIFT = L["SHIFT_KEY_TEXT"],
CTRL = L["CTRL_KEY_TEXT"],
ALT = L["ALT_KEY_TEXT"],
}
E.Options.args.tooltip = ACH:Group(L["Tooltip"], nil, 2, 'tree', function(info) return E.db.tooltip[info[#info]] end, function(info, value) E.db.tooltip[info[#info]] = value; end)
E.Options.args.tooltip.args.intro = ACH:Description(L["TOOLTIP_DESC"], 1)
E.Options.args.tooltip.args.enable = ACH:Toggle(L["Enable"], nil, 2, nil, nil, nil, function(info) return E.private.tooltip[info[#info]] end, function(info, value) E.private.tooltip[info[#info]] = value; E:StaticPopup_Show('PRIVATE_RL') end)
E.Options.args.tooltip.args.role = ACH:Toggle(L["ROLE"], L["Display the unit role in the tooltip."], 3)
E.Options.args.tooltip.args.targetInfo = ACH:Toggle(L["Target Info"], L["When in a raid group display if anyone in your raid is targeting the current tooltip unit."], 4)
E.Options.args.tooltip.args.modifierID = ACH:Select(L["Modifier for IDs"], nil, 5, modifierValues)
E.Options.args.tooltip.args.playerTitles = ACH:Toggle(L["Player Titles"], L["Display player titles."], 6)
E.Options.args.tooltip.args.guildRanks = ACH:Toggle(L["Guild Ranks"], L["Display guild ranks if a unit is guilded."], 7)
E.Options.args.tooltip.args.showMount = ACH:Toggle(L["Current Mount"], L["Display current mount the unit is riding."], 8)
E.Options.args.tooltip.args.gender = ACH:Toggle(L["Gender"], L["Displays the gender of players."], 9)
E.Options.args.tooltip.args.alwaysShowRealm = ACH:Toggle(L["Always Show Realm"], nil, 10)
E.Options.args.tooltip.args.showElvUIUsers = ACH:Toggle(L["Show ElvUI Users"], L["Show ElvUI users and their version of ElvUI."], 11)
E.Options.args.tooltip.args.itemCount = ACH:Select(L["Item Count"], L["Display how many of a certain item you have in your possession."], 12, { BAGS_ONLY = L["Bags Only"], BANK_ONLY = L["Bank Only"], BOTH = L["Both"], NONE = L["NONE"] })
E.Options.args.tooltip.args.colorAlpha = ACH:Range(L["OPACITY"], nil, 13, { isPercent = true, min = 0, max = 1, step = 0.01 }, nil, nil, function(info, value) E.db.tooltip[info[#info]] = value; Skins:StyleTooltips() end)
E.Options.args.tooltip.args.cursorAnchor = ACH:Toggle(L["Cursor Anchor"], L["Should tooltip be anchored to mouse cursor"], 14)
E.Options.args.tooltip.args.cursorAnchorType = ACH:Select(L["Cursor Anchor Type"], nil, 15, { ANCHOR_CURSOR = L["CURSOR"], ANCHOR_CURSOR_LEFT = L["CURSOR_LEFT"], ANCHOR_CURSOR_RIGHT = L["CURSOR_RIGHT"] }, nil, nil, nil, nil, nil, function() return (not E.db.tooltip.cursorAnchor) end)
E.Options.args.tooltip.args.cursorAnchorX = ACH:Range(L["Cursor Anchor Offset X"], nil, 16, { min = -128, max = 128, step = 1 }, nil, nil, nil, nil, function() return (not E.db.tooltip.cursorAnchor) or (E.db.tooltip.cursorAnchorType == 'ANCHOR_CURSOR') end)
E.Options.args.tooltip.args.cursorAnchorY = ACH:Range(L["Cursor Anchor Offset Y"], nil, 17, { min = -128, max = 128, step = 1 }, nil, nil, nil, nil, function() return (not E.db.tooltip.cursorAnchor) or (E.db.tooltip.cursorAnchorType == 'ANCHOR_CURSOR') end)
E.Options.args.tooltip.args.fontGroup = ACH:Group(L["Font"], nil, nil, nil, function(info) return E.db.tooltip[info[#info]] end, function(info, value) E.db.tooltip[info[#info]] = value; TT:SetTooltipFonts() end)
E.Options.args.tooltip.args.fontGroup.args.font = ACH:SharedMediaFont(L["Font"], nil, 1)
E.Options.args.tooltip.args.fontGroup.args.fontOutline = ACH:Select(L["Font Outline"], nil, 2, C.Values.FontFlags)
E.Options.args.tooltip.args.fontGroup.args.spacer = ACH:Spacer(3)
E.Options.args.tooltip.args.fontGroup.args.headerFontSize = ACH:Range(L["Header Font Size"], nil, 4, C.Values.FontSize)
E.Options.args.tooltip.args.fontGroup.args.textFontSize = ACH:Range(L["Text Font Size"], nil, 5, C.Values.FontSize)
E.Options.args.tooltip.args.fontGroup.args.smallTextFontSize = ACH:Range(L["Comparison Font Size"], L["This setting controls the size of text in item comparison tooltips."], 6, C.Values.FontSize)
E.Options.args.tooltip.args.visibility = ACH:Group(L["Visibility"], nil, nil, nil, function(info) return E.db.tooltip.visibility[info[#info]] end, function(info, value) E.db.tooltip.visibility[info[#info]] = value; end)
E.Options.args.tooltip.args.visibility.args.actionbars = ACH:Select(L["ActionBars"], L["Choose when you want the tooltip to show. If a modifer is chosen, then you need to hold that down to show the tooltip."], 1, modifierValues)
E.Options.args.tooltip.args.visibility.args.bags = ACH:Select(L["Bags/Bank"], L["Choose when you want the tooltip to show. If a modifer is chosen, then you need to hold that down to show the tooltip."], 2, modifierValues)
E.Options.args.tooltip.args.visibility.args.unitFrames = ACH:Select(L["UnitFrames"], L["Choose when you want the tooltip to show. If a modifer is chosen, then you need to hold that down to show the tooltip."], 3, modifierValues)
E.Options.args.tooltip.args.visibility.args.combatOverride = ACH:Select(L["Combat Override Key"], L["Choose when you want the tooltip to show in combat. If a modifer is chosen, then you need to hold that down to show the tooltip."], 4, modifierValues)
E.Options.args.tooltip.args.healthBar = ACH:Group(L["Health Bar"], nil, nil, nil, function(info) return E.db.tooltip.healthBar[info[#info]] end, function(info, value) E.db.tooltip.healthBar[info[#info]] = value; end)
E.Options.args.tooltip.args.healthBar.args.statusPosition = ACH:Select(L["Position"], nil, 1, { BOTTOM = L["Bottom"], TOP = L["Top"], DISABLED = L['Disabled'] })
E.Options.args.tooltip.args.healthBar.args.text = ACH:Toggle(L["Text"], nil, 2, nil, nil, nil, nil, function(_, value) E.db.tooltip.healthBar.text = value; if not GameTooltip:IsForbidden() then if value then GameTooltipStatusBar.text:Show(); else GameTooltipStatusBar.text:Hide() end end end, function() return E.db.tooltip.healthBar.statusPosition == 'DISABLED' end)
E.Options.args.tooltip.args.healthBar.args.height = ACH:Range(L["Height"], nil, 3, { min = 1, max = 15, step = 1 }, nil, nil, function(_, value) E.db.tooltip.healthBar.height = value; if not GameTooltip:IsForbidden() then GameTooltipStatusBar:Height(value); end end, function() return E.db.tooltip.healthBar.statusPosition == 'DISABLED' end)
E.Options.args.tooltip.args.healthBar.args.font = ACH:SharedMediaFont(L["Font"], nil, 4, nil, nil, function(_, value) E.db.tooltip.healthBar.font = value; if not GameTooltip:IsForbidden() then GameTooltipStatusBar.text:FontTemplate(E.Libs.LSM:Fetch('font', E.db.tooltip.healthBar.font), E.db.tooltip.healthBar.fontSize, E.db.tooltip.healthBar.fontOutline) end end, function() return not E.db.tooltip.healthBar.text or E.db.tooltip.healthBar.statusPosition == 'DISABLED' end)
E.Options.args.tooltip.args.healthBar.args.fontSize = ACH:Range(L["FONT_SIZE"], nil, 5, C.Values.FontSize, nil, nil, function(_, value) E.db.tooltip.healthBar.fontSize = value; if not GameTooltip:IsForbidden() then GameTooltipStatusBar.text:FontTemplate(E.Libs.LSM:Fetch('font', E.db.tooltip.healthBar.font), E.db.tooltip.healthBar.fontSize, E.db.tooltip.healthBar.fontOutline) end end, function() return not E.db.tooltip.healthBar.text or E.db.tooltip.healthBar.statusPosition == 'DISABLED' end)
E.Options.args.tooltip.args.healthBar.args.fontOutline = ACH:Select(L["Font Outline"], nil, 6, C.Values.FontFlags, nil, nil, nil, function(_, value) E.db.tooltip.healthBar.fontOutline = value; if not GameTooltip:IsForbidden() then GameTooltipStatusBar.text:FontTemplate(E.Libs.LSM:Fetch('font', E.db.tooltip.healthBar.font), E.db.tooltip.healthBar.fontSize, E.db.tooltip.healthBar.fontOutline) end end, function() return not E.db.tooltip.healthBar.text or E.db.tooltip.healthBar.statusPosition == 'DISABLED' end)
E.Options.args.tooltip.args.factionColors = ACH:Group(L["Custom Faction Colors"], nil, nil, nil, function(info) local v = tonumber(info[#info]) local t = E.db.tooltip.factionColors[v] local d = P.tooltip.factionColors[v] return t.r, t.g, t.b, t.a, d.r, d.g, d.b end, function(info, r, g, b) local v = tonumber(info[#info]); local t = E.db.tooltip.factionColors[v]; t.r, t.g, t.b = r, g, b end)
E.Options.args.tooltip.args.factionColors.args.useCustomFactionColors = ACH:Toggle(L["Custom Faction Colors"], nil, 0, nil, nil, nil, function() return E.db.tooltip.useCustomFactionColors end, function(_, value) E.db.tooltip.useCustomFactionColors = value; end)
for i = 1, 8 do
E.Options.args.tooltip.args.factionColors.args[''..i] = ACH:Color(L["FACTION_STANDING_LABEL"..i], nil, i, true, nil, nil, nil, function() return not E.Tooltip.Initialized or not E.db.tooltip.useCustomFactionColors end)
end

6270
UnitFrames.lua Normal file
View File

File diff suppressed because it is too large Load Diff