WoWInterface SVN SliceCommander

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /
    from Rev 238 to Rev 239
    ↔ Reverse comparison
  •

Rev 238 → Rev 239

trunk/Core/PixelPerfect.lua
15,6 → 15,17
local scale
 
 
-- split("a,b,c", ",") => {"a", "b", "c"}
local function SC_split(s, sep)
local fields = {}
 
local sep = sep or " "
local pattern = string.format("([^%s]+)", sep)
string.gsub(s, pattern, function(c) fields[#fields + 1] = c end)
 
return fields
end
 
--Return rounded number
function SliceCommander:Round(num, idp)
if(idp and idp > 0) then
26,7 → 37,7
 
function SliceCommander:UIScale(event)
if not _G['SC'].SET or _G['SC'].SET.PixelPerfect then
local resolution = ({GetScreenResolutions()})[GetCurrentResolution()]
local resolution = ({GetScreenResolutions()})[GetCurrentResolution()] or GetCVar("gxWindowedResolution")
if resolution == nil then
if not _G['SC'].SET then
return false
37,7 → 48,8
end
return false
end
local screenwidth, screenheight = DecodeResolution(resolution)
local tableResolution = SC_split(resolution, 'x')
local screenwidth, screenheight = tableResolution[1],tableResolution[2]
 
if IsMacClient() and _G['SC'].screenheight and _G['SC'].screenwidth and (screenwidth ~= _G['SC'].screenheight or screenheight ~= _G['SC'].screenwidth) then
screenheight = _G['SC'].screenheight
trunk/Core/Settings.lua
171,7 → 171,7
args.CDSpellSound = SliceCommander:getCDSpellSound(spell)
end
return {
name = SC_SPELL[spell],
name = SC_SPELL[spell] .. ' CD',
type = "group",
order = SliceCommander:getOrder(),
args = args
413,6 → 413,12
Shortcut_HEALTH = SliceCommander:getShortcutSetting("SliceCommander_General", "General", "HEALTH"),
Shortcut_THEALTH = SliceCommander:getShortcutSetting("SliceCommander_General", "General", "THEALTH"),
Shortcut_THREAT = SliceCommander:getShortcutSetting("SliceCommander_General", "General", "THREAT"),
Shortcut_POISON = {
order = SliceCommander:getOrder(),
type = "execute",
name = string.format(L["%s Settings"], L["Poisons"]),
func = function() AceConfigDialog:SelectGroup("SliceCommander_General", "General", "POISON") end,
},
CP = {
order = SliceCommander:getOrder(),
name = SC_SPELL['CP'],
549,6 → 555,63
},
}
},
POISON = {
name = string.format(L["%s Settings"], L["Poisons"]),
type = "group",
order = SliceCommander:getOrder(),
args = {
DPIconShow = {
order = SliceCommander:getOrder(),
name = L["Show poison icon"],
desc = string.format(L["Display the %s icon when the timer left on your poison go under specified time. If you are in combat it only display the icon when it fade out."], SC_SPELL['DP']),
type = "toggle",
set = function(info,val)
SC.SET.display.DPICON = val
end,
get = function(info) return SC.SET.display.DPICON end
},
DPTimeCheck = {
order = SliceCommander:getOrder(),
name = L["Minimal time"],
desc = L["In minutes"],
type = "range",
min = 0,
max = 59,
step = 1,
bigStep = 5,
set = function(info,val)
if strmatch(val,"%d") then
SC.SET.display.DPTIME = val
else
SC.SET.display.DPTIME = 10
end
end,
get = function(info) return SC.SET.display.DPTIME end
},
DPButtonEnable = {
order = SliceCommander:getOrder(),
name = L["Enable poison button"],
desc = L["Enable poison button has no effect if poison icon is not shown. If it is enable there is two restrinction: You can't click through the area where the icon was when the icon is hide in combat and the button does not work when the icon is shown in combat."],
type = "toggle",
set = function(info,val)
SC.SET.display.DPBUT = val
end,
get = function(info) return SC.SET.display.DPBUT end
},
DPSound = {
order = SliceCommander:getOrder(),
name = string.format(L["%s Sound"], SC_SPELL['DP']),
desc = string.format(L["%s Sound. It has no effect if %s is not display."], SC_SPELL['DP'], SC_SPELL['DP']),
type = "select",
dialogControl = 'LSM30_Sound',
values = LSM:HashTable("sound"),
set = function(info,val)
SC.SET.DPSound = val
end,
get = function(info) return SC.SET.DPSound end
},
}
},
}
},
Skills = {
558,23 → 621,26
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_SND = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "SND"),
Shortcut_CV = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "CV"),
Shortcut_TOT = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "TOT"),
Shortcut_TOTCD = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "TOTCD"),
Shortcut_FE = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "FE"),
Shortcut_KI = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "KI"),
Shortcut_VAN = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "VAN"),
Shortcut_KICD = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "KICD"),
Shortcut_VANCD = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "VANCD"),
Shortcut_KS = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "KS"),
Shortcut_CS = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "CS"),
Shortcut_EVA = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "EVA"),
Shortcut_COS = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "COS"),
SND = SliceCommander:getSpellSettings('SND'),
CV = SliceCommander:getSpellCDSettings('CV'),
TOT = {
name = SC_SPELL['TOT'],
TOTCD = {
name = SC_SPELL['TOTCD'] .. ' CD',
type = "group",
order = SliceCommander:getOrder(),
args = {
TOTShow = SliceCommander:getShowSetting('TOT'),
TOTPos = SliceCommander:getPosSetting('TOT'),
TOTColor = SliceCommander:getColorSetting('TOT'),
TOTShow = SliceCommander:getShowSetting('TOTCD'),
TOTPos = SliceCommander:getPosSetting('TOTCD'),
TOTColor = SliceCommander:getColorSetting('TOTCD'),
TOTTarget = {
order = SliceCommander:getOrder(),
name = L["Taget name"],
589,14 → 655,14
}
},
FE = SliceCommander:getSpellCDSettings('FE'),
KI = {
KICD = {
order = SliceCommander:getOrder(),
name = SC_SPELL['KI'],
name = SC_SPELL['KICD'],
type = "group",
args = {
ShowKI = SliceCommander:getShowSetting('KI'),
ColorKI = SliceCommander:getColorSetting('KI'),
PosKI = SliceCommander:getPosSetting('KI'),
ShowKI = SliceCommander:getShowSetting('KICD'),
ColorKI = SliceCommander:getColorSetting('KICD'),
PosKI = SliceCommander:getPosSetting('KICD'),
HeaderKINotification = {
order = SliceCommander:getOrder(),
name = L["Warning settings"],
643,9 → 709,10
},
}
},
VAN = SliceCommander:getCDSettings('VAN'),
VANCD = SliceCommander:getCDSettings('VANCD'),
KS = SliceCommander:getSpellCDSettings('KS'),
CS = SliceCommander:getSpellSettings('CS'),
EVA = SliceCommander:getSpellCDSettings('EVA'),
COS = SliceCommander:getSpellCDSettings('COS'),
SPR = SliceCommander:getSpellCDSettings('SPR'),
}
657,10 → 724,10
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_CD = SliceCommander:getShortcutSetting("SliceCommander_General", "Talents", "CD"),
Shortcut_MD = SliceCommander:getShortcutSetting("SliceCommander_General", "Talents", "MD"),
CD = SliceCommander:getCDSettings('CD'),
MD = SliceCommander:getCDSettings('MD'),
Shortcut_CD = SliceCommander:getShortcutSetting("SliceCommander_General", "Talents", "CDCD"),
Shortcut_MD = SliceCommander:getShortcutSetting("SliceCommander_General", "Talents", "MDCD"),
CD = SliceCommander:getCDSettings('CDCD'),
MD = SliceCommander:getCDSettings('MDCD'),
}
},
TalentsPVP = {
670,20 → 737,9
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_DFA = SliceCommander:getShortcutSetting("SliceCommander_General", "TalentsPVP", "DFA"),
DFA = SliceCommander:getCDSettings('DFA')
Shortcut_DFA = SliceCommander:getShortcutSetting("SliceCommander_General", "TalentsPVP", "DFACD"),
DFA = SliceCommander:getCDSettings('DFACD')
}
},
AzeriteEssence = {
order = SliceCommander:getOrder(),
name = L["Azerite Essence"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_ESSECD = SliceCommander:getShortcutSetting("SliceCommander_General", "AzeriteEssence", "ESSECD"),
ESSECD = SliceCommander:getCDSettings('ESSECD')
}
}
}
}
719,56 → 775,6
type = "group",
order = SliceCommander:getOrder(),
args = {
DPIconShow = {
order = SliceCommander:getOrder(),
name = L["Show poison icon"],
desc = string.format(L["Display the %s icon when the timer left on your poison go under specified time. If you are in combat it only display the icon when it fade out."], SC_SPELL['DP']),
type = "toggle",
set = function(info,val)
SC.SET.display.DPICON = val
end,
get = function(info) return SC.SET.display.DPICON end
},
DPTimeCheck = {
order = SliceCommander:getOrder(),
name = L["Minimal time"],
desc = L["In minutes"],
type = "range",
min = 0,
max = 59,
step = 1,
bigStep = 5,
set = function(info,val)
if strmatch(val,"%d") then
SC.SET.display.DPTIME = val
else
SC.SET.display.DPTIME = 10
end
end,
get = function(info) return SC.SET.display.DPTIME end
},
DPButtonEnable = {
order = SliceCommander:getOrder(),
name = L["Enable poison button"],
desc = L["Enable poison button has no effect if poison icon is not shown. If it is enable there is two restrinction: You can't click through the area where the icon was when the icon is hide in combat and the button does not work when the icon is shown in combat."],
type = "toggle",
set = function(info,val)
SC.SET.display.DPBUT = val
end,
get = function(info) return SC.SET.display.DPBUT end
},
DPSound = {
order = SliceCommander:getOrder(),
name = string.format(L["%s Sound"], SC_SPELL['DP']),
desc = string.format(L["%s Sound. It has no effect if %s is not display."], SC_SPELL['DP'], SC_SPELL['DP']),
type = "select",
dialogControl = 'LSM30_Sound',
values = LSM:HashTable("sound"),
set = function(info,val)
SC.SET.DPSound = val
end,
get = function(info) return SC.SET.DPSound end
},
displayDescriptionChekcedSpec = {
order = SliceCommander:getOrder(),
name = L["displayDescriptionChekcedSpec"],
783,11 → 789,14
return { ['DPB'] = SC_SPELL['DPB'], ['WP'] = SC_SPELL['WP'] }
end,
set = function(info,val)
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[val])
SC.SET.poison.mh = val
local aSpec = GetSpecialization()
if aSpec == 1 then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[val])
end
SC.SET.poison.mh[1] = val
end,
get = function(info)
return SC.SET.poison.mh
return SC.SET.poison.mh[1]
end
},
Utility = {
795,13 → 804,17
name = L["Utility poison"],
type = "select",
values = function()
return { ['CRP'] = SC_SPELL['CRP'] }
return { ['CRP'] = SC_SPELL['CRP'], ['AKP'] = SC_SPELL['AKP'] }
end,
set = function(info,val)
SC.SET.poison.oh = val
local aSpec = GetSpecialization()
if aSpec == 1 then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC_SPELL[val])
end
SC.SET.poison.oh[1] = val
end,
get = function(info)
return SC.SET.poison.oh
return SC.SET.poison.oh[1]
end
},
}
821,14 → 834,12
Shortcut_ENV = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "ENV"),
Shortcut_SS = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "SS"),
Shortcut_DP = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "DP"),
Shortcut_EVA = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "EVA"),
RUP = SliceCommander:getSpellSettings('RUP'),
GAR = SliceCommander:getSpellCDSettings('GAR'),
VEN = SliceCommander:getSpellCDSettings('VEN'),
ENV = SliceCommander:getSpellSettings('ENV'),
SS = SliceCommander:getSpellSettings('SS'),
SS = SliceCommander:getSpellCDSettings('SS'),
DP = SliceCommander:getSpellSettings('DP'),
EVA = SliceCommander:getSpellCDSettings('EVA'),
}
},
Talents = {
838,14 → 849,14
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_EX = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "EX"),
Shortcut_EXCD = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "EXCD"),
Shortcut_TXB = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "TXB"),
Shortcut_EP = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "EP"),
Shortcut_SUB = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "SUB"),
Shortcut_BLS = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "BLS"),
Shortcut_MA = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "MA"),
Shortcut_CT = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "CT"),
EX = SliceCommander:getCDSettings('EX'),
EXCD = SliceCommander:getCDSettings('EXCD'),
TXB = SliceCommander:getSpellCDSettings('TXB'),
EP = SliceCommander:getSpellSettings('EP'),
SUB = SliceCommander:getSpellSettings('SUB'),
876,7 → 887,63
name = L["Energy bar Settings"],
func = function() AceConfigDialog:SelectGroup("SliceCommander_Outlaw", "General", "EnergySetting") end,
},
Shortcut_POISON = {
order = SliceCommander:getOrder(),
type = "execute",
name = string.format(L["%s Settings"], L["Poisons"]),
func = function() AceConfigDialog:SelectGroup("SliceCommander_Outlaw", "General", "POISON") end,
},
EnergySetting = SliceCommander:getEnergyMarkerSettings(2),
POISON = {
name = string.format(L["%s Settings"], L["Poisons"]),
type = "group",
order = SliceCommander:getOrder(),
args = {
displayDescriptionChekcedSpec = {
order = SliceCommander:getOrder(),
name = L["displayDescriptionChekcedSpec"],
fontSize = "medium",
type = "description"
},
Lethal = {
order = SliceCommander:getOrder(),
name = L["Lethal poison"],
type = "select",
values = function()
return { ['IP'] = SC_SPELL['IP'], ['WP'] = SC_SPELL['WP'] }
end,
set = function(info,val)
local aSpec = GetSpecialization()
if aSpec == 2 then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[val])
end
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[val])
SC.SET.poison.mh[2] = val
end,
get = function(info)
return SC.SET.poison.mh[2]
end
},
Utility = {
order = SliceCommander:getOrder(),
name = L["Utility poison"],
type = "select",
values = function()
return { ['CRP'] = SC_SPELL['CRP'], ['AKP'] = SC_SPELL['AKP'] }
end,
set = function(info,val)
local aSpec = GetSpecialization()
if aSpec == 2 then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC_SPELL[val])
end
SC.SET.poison.oh[2] = val
end,
get = function(info)
return SC.SET.poison.oh[2]
end
},
}
},
}
},
Skills = {
890,15 → 957,14
Shortcut_BF = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "BF"),
Shortcut_AR = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "AR"),
Shortcut_BE = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "BE"),
Shortcut_GH = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "GH"),
Shortcut_GHCD = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "GHCD"),
Shortcut_OP = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "OP"),
Shortcut_RIP = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "RIP"),
RB = {
name = SC_SPELL['RB'],
type = "group",
order = SliceCommander:getOrder(),
args = SliceCommander_TableMerge(
SliceCommander:getSpellSettings('RB').args,
SliceCommander:getSpellCDSettings('RB').args,
{
replaceName = {
order = SliceCommander:getOrder(),
928,6 → 994,7
BFPos = SliceCommander:getPosSetting('BF'),
BFColor = SliceCommander:getColorSetting('BF'),
BFCDShow = SliceCommander:getShowSetting('BFCD'),
BFCDPos = SliceCommander:getPosSetting('BFCD'),
BFCDColor = SliceCommander:getColorSetting('BFCD'),
BFIcon = {
order = SliceCommander:getOrder(),
951,6 → 1018,7
ARPos = SliceCommander:getPosSetting('AR'),
ARColor = SliceCommander:getColorSetting('AR'),
ARCDShow = SliceCommander:getShowSetting('ARCD'),
ARCDPos = SliceCommander:getPosSetting('ARCD'),
ARCDColor = SliceCommander:getColorSetting('ARCD'),
ARMarioMod = {
order = SliceCommander:getOrder(),
975,9 → 1043,8
}
},
BE = SliceCommander:getSpellCDSettings('BE'),
GH = SliceCommander:getCDSettings('GH'),
GHCD = SliceCommander:getCDSettings('GHCD'),
OP = SliceCommander:getSpellSettings('OP'),
RIP = SliceCommander:getSpellCDSettings('RIP'),
GG = SliceCommander:getSpellCDSettings('GG'),
}
},
989,17 → 1056,17
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_AC = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "AC"),
Shortcut_SND = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "SND"),
Shortcut_GS = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "GS"),
Shortcut_KSP = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "KSP"),
Shortcut_KSPCD = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "KSPCD"),
Shortcut_LD = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "LD"),
Shortcut_BR = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "BR"),
Shortcut_BRCD = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "BRCD"),
Shortcut_CDB = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "CDB"),
AC = SliceCommander:getSpellSettings('AC'),
SND = SliceCommander:getSpellSettings('SND'),
GS = SliceCommander:getSpellCDSettings('GS'),
KSP = SliceCommander:getCDSettings('KSP'),
KSPCD = SliceCommander:getCDSettings('KSPCD'),
LD = SliceCommander:getSpellSettings('LD'),
BR = SliceCommander:getSpellCDSettings('BR'),
BRCD = SliceCommander:getCDSettings('BRCD'),
CDB = SliceCommander:getSpellCDSettings('CDB'),
}
}
}
1027,7 → 1094,62
name = L["Energy bar Settings"],
func = function() AceConfigDialog:SelectGroup("SliceCommander_Sublety", "General", "EnergySetting") end,
},
Shortcut_POISON = {
order = SliceCommander:getOrder(),
type = "execute",
name = string.format(L["%s Settings"], L["Poisons"]),
func = function() AceConfigDialog:SelectGroup("SliceCommander_Sublety", "General", "POISON") end,
},
EnergySetting = SliceCommander:getEnergyMarkerSettings(3),
POISON = {
name = string.format(L["%s Settings"], L["Poisons"]),
type = "group",
order = SliceCommander:getOrder(),
args = {
displayDescriptionChekcedSpec = {
order = SliceCommander:getOrder(),
name = L["displayDescriptionChekcedSpec"],
fontSize = "medium",
type = "description"
},
Lethal = {
order = SliceCommander:getOrder(),
name = L["Lethal poison"],
type = "select",
values = function()
return { ['IP'] = SC_SPELL['IP'], ['WP'] = SC_SPELL['WP'] }
end,
set = function(info,val)
local aSpec = GetSpecialization()
if aSpec == 3 then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[val])
end
SC.SET.poison.mh[3] = val
end,
get = function(info)
return SC.SET.poison.mh[3]
end
},
Utility = {
order = SliceCommander:getOrder(),
name = L["Utility poison"],
type = "select",
values = function()
return { ['CRP'] = SC_SPELL['CRP'], ['AKP'] = SC_SPELL['AKP'] }
end,
set = function(info,val)
local aSpec = GetSpecialization()
if aSpec == 3 then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC_SPELL[val])
end
SC.SET.poison.oh[3] = val
end,
get = function(info)
return SC.SET.poison.oh[3]
end
},
}
},
}
},
Skills = {
1042,13 → 1164,11
Shortcut_NB = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "NB"),
Shortcut_SOD = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "SOD"),
Shortcut_SS = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "SS"),
Shortcut_EVA = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "EVA"),
SD = SliceCommander:getSpellCDSettings('SD'),
SB = SliceCommander:getSpellCDSettings('SB'),
NB = SliceCommander:getSpellSettings('NB'),
SOD = SliceCommander:getSpellCDSettings('SOD'),
SS = SliceCommander:getSpellCDSettings('SS'),
EVA = SliceCommander:getSpellCDSettings('EVA'),
}
},
Talents = {
1061,12 → 1181,12
Shortcut_AC = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "AC"),
Shortcut_SUB = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "SUB"),
Shortcut_SHT = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "SHT"),
Shortcut_STH = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "STH"),
Shortcut_STH = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "FW"),
Shortcut_STHCD = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "STHCD"),
Shortcut_FW = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "FW"),
AC = SliceCommander:getSpellSettings('AC'),
SUB = SliceCommander:getSpellSettings('SUB'),
SHT = SliceCommander:getSpellCDSettings('SHT'),
STH = SliceCommander:getCDSettings('STH'),
STHCD = SliceCommander:getCDSettings('STHCD'),
FW = SliceCommander:getSpellSettings('FW'),
}
}
1135,10 → 1255,8
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_CDB = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Outlaw", "CDB"),
Shortcut_BB = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Outlaw", "BB"),
Shortcut_GSWW = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Outlaw", "GSWW"),
CDB = SliceCommander:getSpellCDSettings('CDB'),
BB = {
order = SliceCommander:getOrder(),
name = SC_SPELL['BB'],
1170,6 → 1288,17
Shortcut_GB = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Subtlety", "GB"),
GB = SliceCommander:getSpellCDSettings('GB'),
}
},
AzeriteEssence = {
order = SliceCommander:getOrder(),
name = L["Azerite Essence"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_ESSECD = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "AzeriteEssence", "ESSECD"),
ESSECD = SliceCommander:getCDSettings('ESSECD')
}
}
}
}
trunk/Core/Event.lua
87,12 → 87,10
SliceCommander:SetSparks()--MOVE SPARK for the current spec
 
local aSpec = GetSpecialization()
if aSpec == 1 then--POISONS
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[SC.SET.poison.mh])
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC_SPELL[SC.SET.poison.oh])
if SC.SET.poison.oh == 'none' then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", nil)
end
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[SC.SET.poison.mh[aSpec]])
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC_SPELL[SC.SET.poison.oh[aSpec]])
if SC.SET.poison.oh == 'none' then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", nil)
end
end
end
trunk/Core/Tukui.lua
1,5 → 1,18
-- Come frome Tukui API, thanks to him
-- See tukui at www.tukui.org
 
 
-- split("a,b,c", ",") => {"a", "b", "c"}
local function SC_split(s, sep)
local fields = {}
 
local sep = sep or " "
local pattern = string.format("([^%s]+)", sep)
string.gsub(s, pattern, function(c) fields[#fields + 1] = c end)
 
return fields
end
 
function SliceCommander_LoadTukuiApi()
local noop = function() return end
local floor = math.floor
14,7 → 27,8
 
-- pixel perfect script of custom ui Scale.
local resolution = ({GetScreenResolutions()})[GetCurrentResolution()] or GetCVar("gxWindowedResolution")
local width, height = DecodeResolution(resolution)
local tableResolution = SC_split(resolution, 'x')
local width, height = tableResolution[1],tableResolution[2]
local uiscale = min(2, max(.64, 768/width))
local mult = 768/height/uiscale
 
212,7 → 226,7
if f.backdrop then return end
if not t then t = "Default" end
 
local b = CreateFrame("Frame", nil, f)
local b = CreateFrame("Frame", nil, f, BackdropTemplateMixin and "BackdropTemplate")
b:Point("TOPLEFT", -2 + inset, 2 - inset)
b:Point("BOTTOMRIGHT", 2 - inset, -2 + inset)
b:SetTemplate(t, tex)
238,7 → 252,7
local function CreateShadow(f, t)
if f.shadow then return end
 
local shadow = CreateFrame("Frame", nil, f)
local shadow = CreateFrame("Frame", nil, f, BackdropTemplateMixin and "BackdropTemplate")
shadow:SetFrameLevel(1)
shadow:SetFrameStrata(f:GetFrameStrata())
shadow:Point("TOPLEFT", -3, 3)
326,7 → 340,7
local function HighlightUnit(f, r, g, b)
if f.HighlightTarget then return end
local glowBorder = {edgeFile = "Interface\\AddOns\\SliceCommander\\Images\\solid.tga", edgeSize = 1}
f.HighlightTarget = CreateFrame("Frame", nil, f)
f.HighlightTarget = CreateFrame("Frame", nil, f, BackdropTemplateMixin and "BackdropTemplate")
f.HighlightTarget:Point("TOPLEFT", f, "TOPLEFT", -2, 2)
f.HighlightTarget:Point("BOTTOMRIGHT", f, "BOTTOMRIGHT", 2, -2)
f.HighlightTarget:SetBackdrop(glowBorder)
381,7 → 395,7
end
 
local handled = {["Frame"] = true}
local object = CreateFrame("Frame")
local object = CreateFrame("Frame", nil, UIParent, BackdropTemplateMixin and "BackdropTemplate")
addapi(object)
addapi(object:CreateTexture())
addapi(object:CreateFontString())
trunk/Core/Config.lua
142,13 → 142,12
 
--GLOBAL
SC.BARS['KSCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_kidneyshot")
SC.BARS['TOT']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_TricksOftheTrade")
SC.BARS['VAN']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Vanish")
SC.BARS['SS']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_Shadowstep")
SC.BARS['MD']['obj'].icon:SetTexture("Interface\\Icons\\achievement_bg_killingblow_berserker")
SC.BARS['DFA']['obj'].icon:SetTexture("Interface\\Icons\\spell_rogue_deathfromabove")
SC.BARS['TOTCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_TricksOftheTrade")
SC.BARS['VANCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Vanish")
SC.BARS['MDCD']['obj'].icon:SetTexture("Interface\\Icons\\achievement_bg_killingblow_berserker")
SC.BARS['DFACD']['obj'].icon:SetTexture("Interface\\Icons\\spell_rogue_deathfromabove")
SC.BARS['CVCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_crimsonvial")
SC.BARS['KI']['obj'].icon:SetTexture("Interface\\Icons\\ability_kick")
SC.BARS['KICD']['obj'].icon:SetTexture("Interface\\Icons\\ability_kick")
SC.BARS['COSCD']['obj'].icon:SetTexture("Interface\\Icons\\spell_shadow_nethercloak")
SC.BARS['EVACD']['obj'].icon:SetTexture("Interface\\Icons\\spell_shadow_shadowward")
SC.BARS['SPRCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_sprint")
157,22 → 156,22
 
--ASSASSINATION
SC.BARS['VENCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_Deadliness")
SC.BARS['EX']['obj'].icon:SetTexture("Interface\\Icons\\ability_deathwing_bloodcorruption_earth")
SC.BARS['EXCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_deathwing_bloodcorruption_earth")
SC.BARS['GARCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_garrote")
SC.BARS['KBCD']['obj'].icon:SetTexture("Interface\\Icons\\inv_knife_1h_artifactgarona_d_01")
SC.BARS['TXBCD']['obj'].icon:SetTexture("Interface\\Icons\\inv_weapon_shortblade_62")
 
--OUTLAW
SC.BARS['ARCD']['obj'].icon:SetTexture("Interface\\Icons\\Spell_Shadow_ShadowWordDominate")
SC.BARS['KSP']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_Murderspree")
SC.BARS['GH']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_grapplinghook")
SC.BARS['KSPCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_Murderspree")
SC.BARS['GHCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_grapplinghook")
SC.BARS['BECD']['obj'].icon:SetTexture("Interface\\Icons\\inv_weapon_rifle_01")
SC.BARS['RB']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_rollthebones")
SC.BARS['RBCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_rollthebones")
SC.BARS['CDBCD']['obj'].icon:SetTexture("Interface\\Icons\\inv_sword_1h_artifactskywall_d_01dual")
SC.BARS['BFCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Warrior_PunishingBlow")
SC.BARS['GSCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_creature_cursed_02")
SC.BARS['BRCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_arakkoa_spinning_blade")
SC.BARS['RIPCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_parry")
SC.BARS['GGCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_gouge")
 
--SUBTLETY
181,7 → 180,7
SC.BARS['GBCD']['obj'].icon:SetTexture("Interface\\Icons\\inv_knife_1h_artifactfangs_d_01")
SC.BARS['SODCD']['obj'].icon:SetTexture("Interface\\Icons\\spell_shadow_rune")
SC.BARS['SHTCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_throwingspecialization")
SC.BARS['STH']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_sinistercalling")
SC.BARS['STHCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_sinistercalling")
 
SliceCommander:DisableIcon(SC.BARS['THREAT']['obj'], 110)
SliceCommander:DisableIcon(SC.BARS['HEALTH']['obj'], 100)
469,45 → 468,34
if _G['SC'].version == nil or _G['SC'].version < '7.00' then
_G['SC'] = {version = GetAddOnMetadata("SliceCommander", "Version")}
else
if _G['SC'].version < '7.18' then
_G['SC'].SET.Pos['ES'] = nil--REMOVE ENVELOPPING SHADOW
_G['SC'].BARS['ES'] = nil
_G['SC'].SET.Pos['AP'] = nil
_G['SC'].BARS['AP'] = nil
_G['SC'].BARS['SOD']['pandemic'] = nil--SYMBOL OF DEATH NOW HAS LONGER CD
_G['SC'].BARS['SOD']['pandemictimer'] = nil
_G['SC'].BARS['SOD']['pandemicobj'] = nil
if _G['SC'].version < '9.01' then
_G['SC'].SET.Pos['RIP'] = nil--Remove ripost
_G['SC'].BARS['RIP'] = nil
_G['SC'].SET.Pos['RIPCD'] = nil
_G['SC'].BARS['RIPCD'] = nil
_G['SC'].SET.Pos['VAN'] = nil--ADD CD TO the NAME OF SOME CD
_G['SC'].BARS['VAN'] = nil
_G['SC'].SET.Pos['CD'] = nil
_G['SC'].BARS['CD'] = nil
_G['SC'].SET.Pos['MD'] = nil
_G['SC'].BARS['MD'] = nil
_G['SC'].SET.Pos['TOT'] = nil
_G['SC'].BARS['TOT'] = nil
_G['SC'].SET.Pos['KI'] = nil
_G['SC'].BARS['KI'] = nil
_G['SC'].SET.Pos['DFA'] = nil
_G['SC'].BARS['DFA'] = nil
_G['SC'].SET.Pos['EX'] = nil
_G['SC'].BARS['EX'] = nil
_G['SC'].SET.Pos['KSP'] = nil
_G['SC'].BARS['KSP'] = nil
_G['SC'].SET.Pos['BR'] = nil
_G['SC'].BARS['BR'] = nil
_G['SC'].SET.Pos['GH'] = nil
_G['SC'].BARS['GH'] = nil
_G['SC'].SET.Pos['STH'] = nil
_G['SC'].BARS['STH'] = nil
end
if _G['SC'].version < '8.00' then
_G['SC'].SET.Pos['CB'] = nil--REMOVE CANONBALL BARAGE
_G['SC'].BARS['CB'] = nil
_G['SC'].SET.Pos['HEM'] = nil--REMOVE Hemorrhage
_G['SC'].BARS['HEM'] = nil
_G['SC'].SET.Pos['PA'] = nil--REMOVE Parley
_G['SC'].BARS['PA'] = nil
_G['SC'].SET.poison.mh = 'DPB'
_G['SC'].SET.poison.oh = 'CRP'
_G['SC'].SET.CP[10] = nil--RMOVED Anticipation
_G['SC'].SET.RB['SC'] = 'SS'
_G['SC'].SET.RB['RP'] = 'Crit'
_G['SC'].SET.Pos['STHCD'] = nil--REMOVE CANONBALL BARAGE
_G['SC'].BARS['STHCD'] = nil
end
if _G['SC'].version < '8.02' then
_G['SC'].SET.Pos['RI'] = nil--REMOVE OLD REPOST ARRAY
_G['SC'].BARS['RI'] = nil
_G['SC'].SET.Pos['RICD'] = nil
_G['SC'].BARS['RICD'] = nil
_G['SC'].SET.Pos['EV'] = nil--REMOVE OLD REPOST ARRAY
_G['SC'].BARS['EV'] = nil
_G['SC'].SET.Pos['EVCD'] = nil
_G['SC'].BARS['EVCD'] = nil
end
if _G['SC'].version < '8.03' then
if _G['SC'].SET.poison.mh == 'DP' then
_G['SC'].SET.poison.mh = 'DPB'
end
end
_G['SC'].version = GetAddOnMetadata("SliceCommander", "Version")
end
end
554,8 → 542,8
end
 
function SliceCommander:Global()
SliceCommander:DisplaySpells({'CP', 'THREAT', 'CS', 'KS', 'KSCD', 'FOTD', 'CV', 'CVCD', 'TOT', 'FE', 'SSCD', 'SUB', 'CD', 'AC', 'MD', 'DFA', 'Poison', 'SOTD', 'MAI', 'FECD', 'ESSECD'})
SliceCommander:NotDisplaySpells({'HEALTH', 'THEALTH', 'VAN', 'KI', 'COS', 'COSCD', 'EVA', 'EVACD', 'SPR', 'SPRCD', 'SS'})
SliceCommander:DisplaySpells({'CP', 'THREAT', 'CS', 'KS', 'KSCD', 'FOTD', 'CV', 'CVCD', 'TOTCD', 'FE', 'SSCD', 'SUB', 'CDCD', 'AC', 'MDCD', 'DFACD', 'Poison', 'SOTD', 'MAI', 'FECD', 'ESSECD', 'DPICON'})
SliceCommander:NotDisplaySpells({'HEALTH', 'THEALTH', 'VANCD', 'KICD', 'COS', 'COSCD', 'EVA', 'EVACD', 'SPR', 'SPRCD', 'SS'})
 
_G['SC'].orderBar = _G['SC'].maxPos
_G['SC'].orderCDBar = _G['SC'].maxCDPos
565,45 → 553,48
end
 
SliceCommander:OrderSpells({'FOTD', 'CV', 'FE', 'SUB', 'AC', 'MAI', 'COS', 'EVA', 'SPR', 'SS'})
SliceCommander:OrderCDs({'CVCD', 'TOT', 'VAN', 'SSCD', 'CD', 'MD', 'DFA', 'THREAT', 'HEALTH', 'THEALTH', 'CS', 'KS', 'KSCD', 'KI', 'COSCD', 'EVACD', 'SPRCD', 'FECD', 'ESSECD'})
SliceCommander:OrderCDs({'CVCD', 'TOTCD', 'VANCD', 'SSCD', 'CDCD', 'MDCD', 'DFACD', 'THREAT', 'HEALTH', 'THEALTH', 'CS', 'KS', 'KSCD', 'KICD', 'COSCD', 'EVACD', 'SPRCD', 'FECD', 'ESSECD'})
end
 
function SliceCommander:Assassination()
SliceCommander:DisplaySpells({'RUP', 'GAR', 'GARCD', 'VEN', 'VENCD', 'ENV', 'EP', 'DPICON', 'DPBUT', 'EX', 'KB', 'KBCD', 'BA', 'ST', 'TXB', 'TXBCD', 'BLS', 'MA', 'CT'})
SliceCommander:DisplaySpells({'RUP', 'GAR', 'GARCD', 'VEN', 'VENCD', 'ENV', 'EP', 'DPBUT', 'EXCD', 'KB', 'KBCD', 'BA', 'ST', 'TXB', 'TXBCD', 'BLS', 'MA', 'CT'})
SliceCommander:NotDisplaySpells({'DP'})
 
_G['SC'].orderBar = 0
_G['SC'].orderCDBar = -1
 
SliceCommander:OrderSpells({'GAR', 'RUP', 'ENV', 'KB', 'BA', 'ST', 'VEN', 'DP', 'EP', 'TXB', 'BLS', 'MA', 'CT'})
SliceCommander:OrderCDs({'VENCD', 'KBCD', 'EX', 'GARCD', 'TXBCD'})
SliceCommander:OrderCDs({'VENCD', 'KBCD', 'EXCD', 'GARCD', 'TXBCD'})
end
 
function SliceCommander:Outlaw()
SliceCommander:DisplaySpells({'SND', 'RB', 'AR', 'ARCD', 'CDB', 'CDBCD', 'KSP', 'GS', 'GH', 'BE', 'BECD', 'BF', 'BFCD', 'OP', 'GSWW', 'BB', 'LD', 'GSCD', 'BRCD'})
SliceCommander:NotDisplaySpells({'BFICON', 'BR', 'RIP', 'RIPCD', 'GG', 'GGCD'})
SliceCommander:DisplaySpells({'SND', 'RB', 'AR', 'ARCD', 'CDB', 'CDBCD', 'KSPCD', 'GS', 'GHCD', 'BE', 'BECD', 'BF', 'BFCD', 'OP', 'GSWW', 'BB', 'LD', 'GSCD', 'BRCD', 'RBCD'})
SliceCommander:NotDisplaySpells({'BFICON', 'GG', 'GGCD'})
 
_G['SC'].orderBar = 0
_G['SC'].orderCDBar = -1
 
SliceCommander:OrderSpells({'SND', 'RB', 'AR', 'GS', 'OP', 'CDB', 'GSWW', 'BF', 'BR', 'RIP'})
SliceCommander:OrderCDs({'BECD', 'BE', 'ARCD', 'BFCD', 'KSP', 'GH', 'CDBCD', 'LD', 'GSCD', 'BRCD', 'RIPCD', 'GG', 'GGCD'})
SliceCommander:OrderSpells({'SND', 'RB', 'AR', 'GS', 'OP', 'CDB', 'GSWW', 'BF', 'LD'})
SliceCommander:OrderCDs({'BECD', 'BE', 'ARCD', 'BFCD', 'KSPCD', 'GHCD', 'CDBCD', 'GSCD', 'BRCD', 'GG', 'GGCD', 'RBCD'})
end
 
function SliceCommander:Subtlety()
SliceCommander:DisplaySpells({'SD', 'SDCD', 'SB', 'SBCD', 'NB', 'SOD', 'GB', 'GBCD', 'SODCD', 'SHT', 'SHTCD', 'STH'})
SliceCommander:DisplaySpells({'SD', 'SDCD', 'SB', 'SBCD', 'NB', 'SOD', 'GB', 'GBCD', 'SODCD', 'SHT', 'SHTCD', 'STHCD'})
SliceCommander:NotDisplaySpells({'FW'})
 
_G['SC'].orderBar = 0
_G['SC'].orderCDBar = -1
 
SliceCommander:OrderSpells({'GB', 'NB', 'SOD', 'SD', 'SB', 'SHT', 'FW'})
SliceCommander:OrderCDs({'GBCD', 'SDCD', 'SBCD', 'SODCD', 'SHTCD', 'STH'})
SliceCommander:OrderCDs({'GBCD', 'SDCD', 'SBCD', 'SODCD', 'SHTCD', 'STHCD'})
 
end
 
function SliceCommander:SetEssence()
local essenceId = C_AzeriteEssence.GetMilestoneEssence(115)
if not essenceId then
return nil
end
local essenceRank = C_AzeriteEssence.GetEssenceInfo(essenceId)['rank']
 
if SC_SPELLID['ALLESSE'][essenceId] ~= nil then
805,9 → 796,17
if SC.SET.energyColor == nil then
SC.SET.energyColor = {.92, .92, .92}
end
if SC.SET.poison.mh == nil or SC.SET.poison.oh == nil then
SC.SET.poison.mh = 'DPB'--DPB
SC.SET.poison.oh = 'CRP'--CRP
if SC.SET.poison.mh == nil or SC.SET.poison.oh == nil or type(SC.SET.poison.mh) ~= "table" or type(SC.SET.poison.oh) ~= "table" then
SC.SET.poison.mh = {
[1] = 'DPB',
[2] = 'IP',
[3] = 'IP'
}
SC.SET.poison.oh = {
[1] = 'CRP',
[2] = 'CRP',
[3] = 'CRP'
}
end
if SC.SET.font == nil then
SC.SET.font = "Friz Quadrata TT"
921,8 → 920,8
if SC.BARS['CS'] == nil then--Cheap Shot
SC.BARS['CS'] = {['color'] = {.89, .73, .2}}
end
if SC.BARS['VAN'] == nil then--Vanish
SC.BARS['VAN'] = {['color'] = {.42, .46, .51}}
if SC.BARS['VANCD'] == nil then--Vanish
SC.BARS['VANCD'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['FOTD'] == nil then--Fury of the Destroyer
SC.BARS['FOTD'] = {['color'] = {.7, .13, .75}}
939,17 → 938,17
if SC.BARS['FECD'] == nil then--Feint CD
SC.BARS['FECD'] = {['color'] = {.15, .42, .68}}
end
if SC.BARS['KI'] == nil then--Kick
SC.BARS['KI'] = {['color'] = {.42, .46, .51}}
if SC.BARS['KICD'] == nil then--Kick
SC.BARS['KICD'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['MAI'] == nil then--Master Assassin's Initiative
SC.BARS['MAI'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['MD'] == nil then--Marked for Death
SC.BARS['MD'] = {['color'] = {.92, .33, .33}}
if SC.BARS['MDCD'] == nil then--Marked for Death
SC.BARS['MDCD'] = {['color'] = {.92, .33, .33}}
end
if SC.BARS['DFA'] == nil then--Death from Above
SC.BARS['DFA'] = {['color'] = {.75, .65, .53}}
if SC.BARS['DFACD'] == nil then--Death from Above
SC.BARS['DFACD'] = {['color'] = {.75, .65, .53}}
end
if SC.BARS['AC'] == nil then--Alacrity
SC.BARS['AC'] = {['color'] = {.6, .55, .17}}
964,14 → 963,14
if SC.BARS['CVCD'] == nil then--Crimson Vial
SC.BARS['CVCD'] = {['color'] = {.33, .57, .54}}
end
if SC.BARS['CD'] == nil then--Cheated Death
SC.BARS['CD'] = {['color'] = {.2, .47, .19}}
if SC.BARS['CDCD'] == nil then--Cheated Death
SC.BARS['CDCD'] = {['color'] = {.2, .47, .19}}
end
if SC.BARS['SUB'] == nil then--Subterfuge
SC.BARS['SUB'] = {['color'] = {.04, .81, .82}}
end
if SC.BARS['TOT'] == nil then--Tricks of the Trade
SC.BARS['TOT'] = {['color'] = {.3, .3, 1}}
if SC.BARS['TOTCD'] == nil then--Tricks of the Trade
SC.BARS['TOTCD'] = {['color'] = {.3, .3, 1}}
end
if SC.BARS['COS'] == nil then--Cloak of Shadows
SC.BARS['COS'] = {['color'] = {.2, .4, .53}}
1017,8 → 1016,8
if SC.BARS['BA'] == nil then--Blood of the Assassinated
SC.BARS['BA'] = {['color'] = {.83, .27, .27}}
end
if SC.BARS['EX'] == nil then--Exsanguinate
SC.BARS['EX'] = {['color'] = {.83, .27, .27}}
if SC.BARS['EXCD'] == nil then--Exsanguinate
SC.BARS['EXCD'] = {['color'] = {.83, .27, .27}}
end
if SC.BARS['DP'] == nil then--Deadly Poison
SC.BARS['DP'] = {['color'] = {.27, .68, .23}}
1072,6 → 1071,9
if SC.BARS['RB'] == nil then--Roll the Bones
SC.BARS['RB'] = {['color'] = {.83, .51, .27}}
end
if SC.BARS['RBCD'] == nil then--Roll the Bones CD
SC.BARS['RBCD'] = {['color'] = {.83, .51, .27}}
end
if SC.BARS['AR'] == nil then--Adrenaline Rush
SC.BARS['AR'] = {['color'] = {.83, .64, .27}}
end
1096,8 → 1098,8
if SC.BARS['GSWW'] == nil then--Greenskin's Waterlogged Wristcuffs
SC.BARS['GSWW'] = {['color'] = {.81, .27, .3}}
end
if SC.BARS['GH'] == nil then--Grappling Hook
SC.BARS['GH'] = {['color'] = {.83, .82, .27}}
if SC.BARS['GHCD'] == nil then--Grappling Hook
SC.BARS['GHCD'] = {['color'] = {.83, .82, .27}}
end
if SC.BARS['BE'] == nil then--Between the Eyes
SC.BARS['BE'] = {['color'] = {.62, .78, .26}}
1105,8 → 1107,8
if SC.BARS['BECD'] == nil then--Between the Eyes CD
SC.BARS['BECD'] = {['color'] = {.62, .78, .26}}
end
if SC.BARS['KSP'] == nil then--Killing Spree
SC.BARS['KSP'] = {['color'] = {.27, .68, .23}}
if SC.BARS['KSPCD'] == nil then--Killing Spree
SC.BARS['KSPCD'] = {['color'] = {.27, .68, .23}}
end
if SC.BARS['LD'] == nil then--Loaded Dice
SC.BARS['LD'] = {['color'] = {.63, .52, .38}}
1117,18 → 1119,9
if SC.BARS['BFCD'] == nil then--Blade Flury CD
SC.BARS['BFCD'] = {['color'] = {.66, .22, .47}}
end
if SC.BARS['BR'] == nil then--Blade Rush
SC.BARS['BR'] = {['color'] = {.99, .99, .56}}
end
if SC.BARS['BRCD'] == nil then--Blade Rush CD
if SC.BARS['BRCD'] == nil then--Blade Rush
SC.BARS['BRCD'] = {['color'] = {.99, .99, .56}}
end
if SC.BARS['RIP'] == nil then--Riposte
SC.BARS['RIP'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['RIPCD'] == nil then--Riposte CD
SC.BARS['RIPCD'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['GG'] == nil then--Gouge
SC.BARS['GG'] = {['color'] = {.81, .27, .3}}
end
1179,8 → 1172,8
if SC.BARS['SHTCD'] == nil then--Shuriken Tornado CD
SC.BARS['SHTCD'] = {['color'] = {.6, .55, .17}}
end
if SC.BARS['STH'] == nil then--Secret Technique
SC.BARS['STH'] = {['color'] = {.52, .18, .54}}
if SC.BARS['STHCD'] == nil then--Secret Technique
SC.BARS['STHCD'] = {['color'] = {.52, .18, .54}}
end
if SC.BARS['FW'] == nil then--Find Weakness
SC.BARS['FW'] = {['color'] = {.28, .86, .47}}
1205,7 → 1198,7
SC.BARS[k]['id'] = SC_SPELLID[k]
end
 
local buff = {'FOTD', 'AR', 'SUB', 'EP', 'CV', 'AC', 'FE', 'SND', 'SD', 'SOD', 'SB', 'OP', 'ENV', 'GB', 'GSWW', 'MAI', 'LD', 'BF', 'SHT', 'COS', 'EVA', 'SPR', 'BLS', 'MA', 'BR', 'RIP', 'SS'}
local buff = {'FOTD', 'AR', 'SUB', 'EP', 'CV', 'AC', 'FE', 'SND', 'SD', 'SOD', 'SB', 'OP', 'ENV', 'GB', 'GSWW', 'MAI', 'LD', 'BF', 'SHT', 'COS', 'EVA', 'SPR', 'BLS', 'MA', 'SS'}
for i, v in ipairs(buff) do
SC.BARS[v]['type'] = 1
end
1215,18 → 1208,17
SC.BARS[v]['type'] = 2
end
 
local selfdebuff = {'CD', 'CDB'}
local selfdebuff = {'CDCD', 'CDB'}
for i, v in ipairs(selfdebuff) do
SC.BARS[v]['type'] = 3
end
 
local cd = {'VAN', 'KSP', 'ARCD', 'CDBCD', 'CVCD', 'MD', 'GH', 'BECD', 'TOT', 'SDCD', 'SBCD', 'VENCD', 'GBCD', 'EX', 'GARCD', 'KBCD', 'KSCD', 'DFA', 'KI', 'TXBCD', 'SODCD', 'SHTCD', 'STH', 'COSCD', 'EVACD', 'SPRCD', 'FECD', 'GSCD', 'BRCD', 'RIPCD', 'GGCD', 'ESSECD'}
local cd = {'VANCD', 'KSPCD', 'ARCD', 'CDBCD', 'CVCD', 'MDCD', 'GHCD', 'BECD', 'TOTCD', 'SDCD', 'SBCD', 'VENCD', 'GBCD', 'EXCD', 'GARCD', 'KBCD', 'KSCD', 'DFACD', 'KICD', 'TXBCD', 'SODCD', 'SHTCD', 'STHCD', 'COSCD', 'EVACD', 'SPRCD', 'FECD', 'GSCD', 'BRCD', 'GGCD', 'ESSECD', 'BFCD', 'RBCD'}
for i, v in ipairs(cd) do
SC.BARS[v]['type'] = 4
end
 
SC.BARS['SDCD']['type'] = 5
SC.BARS['BFCD']['type'] = 5
SC.BARS['SSCD']['type'] = 5
SC.BARS['RB']['type'] = 6
--[[local chargecd = {'SDCD'}
trunk/Core/Object.lua
1,5 → 1,5
function SliceCommander:NewFrame(color)
local f = CreateFrame("StatusBar", nil, UIParent)
local f = CreateFrame("StatusBar", nil, UIParent, BackdropTemplateMixin and "BackdropTemplate")
 
f:SetStatusBarTexture(SliceCommander:BarTexture())
f:SetValue(0)
34,7 → 34,7
end
 
function SliceCommander:CPFrame()
local f = CreateFrame("StatusBar", nil, UIParent)
local f = CreateFrame("StatusBar", nil, UIParent, BackdropTemplateMixin and "BackdropTemplate")
 
f.bg = f:CreateTexture(nil, "BACKGROUND")
f.bg:SCPoint("TOPLEFT", f, "TOPLEFT", 0, 0)
44,7 → 44,7
f.combos = {}
 
for i = 1, 10 do--Maximum CP is 10 with anticipation
local combo = CreateFrame("Frame", nil, f)
local combo = CreateFrame("Frame", nil, f, BackdropTemplateMixin and "BackdropTemplate")
combo.bg = combo:CreateTexture(nil, "BACKGROUND")
combo.bg:SetAllPoints(combo)
combo.bg:SetTexture("Interface\\AddOns\\SliceCommander\\Images\\solid.tga")
53,7 → 53,7
f.combos[i] = combo
end
 
f.overlay = CreateFrame("Frame", nil, f)
f.overlay = CreateFrame("Frame", nil, f, BackdropTemplateMixin and "BackdropTemplate")
f.overlay:SetAllPoints(f)
 
f.comboText = f.overlay:CreateFontString(nil, 'OVERLAY')
71,7 → 71,7
end
 
function SliceCommander:ThinBar(point, relativePoint, x, y)
local f = CreateFrame("StatusBar", nil, UIParent)
local f = CreateFrame("StatusBar", nil, UIParent, BackdropTemplateMixin and "BackdropTemplate")
f:SCHeight(2)
f:SetFrameLevel(2)
f:SetStatusBarTexture(SliceCommander:BarTexture())
88,7 → 88,7
end
 
function SliceCommander:CreateMoveFrame()
CreateFrame('Frame', 'SliceCommanderFrame', UIParent)
CreateFrame('Frame', 'SliceCommanderFrame', UIParent, BackdropTemplateMixin and "BackdropTemplate")
SliceCommanderFrame:SetToplevel(true)
SliceCommanderFrame:EnableMouse(false)
SliceCommanderFrame:SetMovable(true)
108,7 → 108,7
end
 
function SliceCommander:CreateEnergyFrame()
CreateFrame('StatusBar', 'VTimerEnergy', UIParent)
CreateFrame('StatusBar', 'VTimerEnergy', UIParent, BackdropTemplateMixin and "BackdropTemplate")
VTimerEnergy:SCSize(200, 20)
VTimerEnergy:SetMinMaxValues(0,100)
VTimerEnergy:SCPoint('CENTER', SliceCommanderFrame, 'CENTER', 0, 0)
166,7 → 166,7
end
 
function SliceCommander:NewMoveFrameIcon(name)
local MoveFrame = CreateFrame('Button', name, UIParent)
local MoveFrame = CreateFrame('Button', name, UIParent, BackdropTemplateMixin and "BackdropTemplate")
MoveFrame:SetToplevel(true)
MoveFrame:EnableMouse(false)
MoveFrame:SetMovable(true)
189,7 → 189,7
function SliceCommander:NewIcon(icon, name)
local MoveFrame = SliceCommander:NewMoveFrameIcon(name)
 
local f = CreateFrame("Frame", name..'button', UIParent)
local f = CreateFrame("Frame", name..'button', UIParent, BackdropTemplateMixin and "BackdropTemplate")
f:SCPoint('CENTER', name, 'CENTER', 0, 0)
f:SetFrameStrata("MEDIUM")
f:SetFrameLevel(1)
203,7 → 203,7
f.icon = fIcon
f.border = SliceCommander:tukSkin(f, fIcon)
 
f.overlay = CreateFrame('Frame', nil, f)
f.overlay = CreateFrame('Frame', nil, f, BackdropTemplateMixin and "BackdropTemplate")
f.overlay:SetFrameStrata("HIGH")
f.overlay:SetFrameLevel(2)
f.overlay:SCPoint('CENTER', f:GetName(), 'CENTER', 0, 0)
233,7 → 233,7
end
 
function SliceCommander:CreateTextureSkin(frame, color, level, texture)
local t = CreateFrame('Frame', nil, frame)
local t = CreateFrame('Frame', nil, frame, BackdropTemplateMixin and "BackdropTemplate")
t:SetDefaultBackdrop()
t:SetFrameLevel(level)
t:SetFrameStrata("LOW")
trunk/Libs/AceGUI-3.0-SharedMediaWidgets/prototypes.lua
1,10 → 1,5
-- Widget created by Yssaril
--[===[@debug@
local DataVersion = 9001 -- dev version always overwrites everything else :)
--@end-debug@]===]
--@non-debug@
local DataVersion = 56
--@end-non-debug@
local DataVersion = 9004
local AGSMW = LibStub:NewLibrary("AceGUISharedMediaWidgets-1.0", DataVersion)
 
if not AGSMW then
117,7 → 112,7
function AGSMW:GetBaseFrameWithWindow()
local frame = self:GetBaseFrame()
 
local displayButton = CreateFrame("Button", nil, frame)
local displayButton = CreateFrame("Button", nil, frame, BackdropTemplateMixin and "BackdropTemplate")
displayButton:SetHeight(42)
displayButton:SetWidth(42)
displayButton:SetPoint("TOPLEFT", frame, "TOPLEFT", 1, -2)
182,14 → 177,12
self:SetHeight(UIParent:GetHeight()*2/5)
self.slider:Show()
self:SetScript("OnMouseWheel", OnMouseWheel)
self.scrollframe:UpdateScrollChildRect()
self.slider:SetMinMaxValues(0, self.contentframe:GetHeight()-self.scrollframe:GetHeight())
else
self.scrollframe:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", -14, 12)
self:SetHeight(self.contentframe:GetHeight()+25)
self.slider:Hide()
self:SetScript("OnMouseWheel", nil)
self.scrollframe:UpdateScrollChildRect()
self.slider:SetMinMaxValues(0, 0)
end
self.contentframe:SetWidth(self.scrollframe:GetWidth())
212,7 → 205,7
if next(DropDownCache) then
frame = table.remove(DropDownCache)
else
frame = CreateFrame("Frame", nil, UIParent)
frame = CreateFrame("Frame", nil, UIParent, BackdropTemplateMixin and "BackdropTemplate")
frame:SetClampedToScreen(true)
frame:SetWidth(188)
frame:SetBackdrop(frameBackdrop)
242,7 → 235,7
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)
local slider = CreateFrame("Slider", nil, scrollframe, BackdropTemplateMixin and "BackdropTemplate")
slider:SetOrientation("VERTICAL")
slider:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -14, -10)
slider:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -14, 10)
trunk/Libs/AceGUI-3.0-SharedMediaWidgets/FontWidget.lua
8,7 → 8,7
 
do
local widgetType = "LSM30_Font"
local widgetVersion = 11
local widgetVersion = 12
 
local contentFrameCache = {}
local function ReturnSelf(self)
trunk/Libs/AceGUI-3.0-SharedMediaWidgets/SoundWidget.lua
8,7 → 8,7
 
do
local widgetType = "LSM30_Sound"
local widgetVersion = 11
local widgetVersion = 12
 
local contentFrameCache = {}
local function ReturnSelf(self)
trunk/Libs/AceGUI-3.0-SharedMediaWidgets/StatusbarWidget.lua
8,7 → 8,7
 
do
local widgetType = "LSM30_Statusbar"
local widgetVersion = 11
local widgetVersion = 12
 
local contentFrameCache = {}
local function ReturnSelf(self)
trunk/Libs/AceGUI-3.0-SharedMediaWidgets/BorderWidget.lua
8,7 → 8,7
 
do
local widgetType = "LSM30_Border"
local widgetVersion = 11
local widgetVersion = 12
 
local contentFrameCache = {}
local function ReturnSelf(self)
trunk/Libs/AceGUI-3.0-SharedMediaWidgets/BackgroundWidget.lua
8,7 → 8,7
 
do
local widgetType = "LSM30_Background"
local widgetVersion = 11
local widgetVersion = 13
 
local contentFrameCache = {}
local function ReturnSelf(self)
38,7 → 38,7
if next(contentFrameCache) then
frame = table.remove(contentFrameCache)
else
frame = CreateFrame("Button", nil, UIParent)
frame = CreateFrame("Button", nil, UIParent, BackdropTemplateMixin and "BackdropTemplate")
--frame:SetWidth(200)
frame:SetHeight(18)
frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD")
trunk/Libs/AceHook-3.0/AceHook-3.0.lua
2,14 → 2,14
-- Using AceHook-3.0 is recommended when you need to unhook your hooks again, so the hook chain isn't broken
-- when you manually restore the original function.
--
-- **AceHook-3.0** can be embeded into your addon, either explicitly by calling AceHook:Embed(MyAddon) or by
-- **AceHook-3.0** can be embeded into your addon, either explicitly by calling AceHook:Embed(MyAddon) or by
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
-- and can be accessed directly, without having to explicitly call AceHook itself.\\
-- It is recommended to embed AceHook, otherwise you'll have to specify a custom `self` on all calls you
-- make into AceHook.
-- @class file
-- @name AceHook-3.0
-- @release $Id: AceHook-3.0.lua 1118 2014-10-12 08:21:54Z nevcairiel $
-- @release $Id: AceHook-3.0.lua 1202 2019-05-15 23:11:22Z nevcairiel $
local ACEHOOK_MAJOR, ACEHOOK_MINOR = "AceHook-3.0", 8
local AceHook, oldminor = LibStub:NewLibrary(ACEHOOK_MAJOR, ACEHOOK_MINOR)
 
117,14 → 117,14
 
function hook(self, obj, method, handler, script, secure, raw, forceSecure, usage)
if not handler then handler = method end
 
 
-- These asserts make sure AceHooks's devs play by the rules.
assert(not script or type(script) == "boolean")
assert(not secure or type(secure) == "boolean")
assert(not raw or type(raw) == "boolean")
assert(not forceSecure or type(forceSecure) == "boolean")
assert(usage)
 
 
-- Error checking Battery!
if obj and type(obj) ~= "table" then
error(format("%s: 'object' - nil or table expected got %s", usage, type(obj)), 3)
146,8 → 146,8
error(format("Cannot hook secure script %q; Use SecureHookScript(obj, method, [handler]) instead.", method), 3)
end
else
local issecure
if obj then
local issecure
if obj then
issecure = onceSecure[obj] and onceSecure[obj][method] or issecurevariable(obj, method)
else
issecure = onceSecure[method] or issecurevariable(method)
165,21 → 165,21
end
end
end
 
 
local uid
if obj then
uid = registry[self][obj] and registry[self][obj][method]
else
uid = registry[self][method]
end
 
 
if uid then
if actives[uid] then
-- Only two sane choices exist here. We either a) error 100% of the time or b) always unhook and then hook
-- choice b would likely lead to odd debuging conditions or other mysteries so we're going with a.
error(format("Attempting to rehook already active hook %s.", method))
end
 
 
if handlers[uid] == handler then -- turn on a decative hook, note enclosures break this ability, small memory leak
actives[uid] = true
return
197,7 → 197,7
handlers[uid], actives[uid], scripts[uid] = nil, nil, nil
uid = nil
end
 
 
local orig
if script then
orig = obj:GetScript(method) or donothing
206,13 → 206,13
else
orig = _G[method]
end
 
 
if not orig then
error(format("%s: Attempting to hook a non existing target", usage), 3)
end
 
 
uid = createHook(self, handler, orig, secure, not (raw or secure))
 
 
if obj then
self.hooks[obj] = self.hooks[obj] or {}
registry[self][obj] = registry[self][obj] or {}
221,7 → 221,7
if not secure then
self.hooks[obj][method] = orig
end
 
 
if script then
if not secure then
obj:SetScript(method, uid)
237,7 → 237,7
end
else
registry[self][method] = uid
 
 
if not secure then
_G[method] = uid
self.hooks[method] = orig
245,8 → 245,8
hooksecurefunc(method, uid)
end
end
 
actives[uid], handlers[uid], scripts[uid] = true, handler, script and true or nil
 
actives[uid], handlers[uid], scripts[uid] = true, handler, script and true or nil
end
 
--- Hook a function or a method on an object.
262,7 → 262,7
-- @usage
-- -- create an addon with AceHook embeded
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
--
--
-- function MyAddon:OnEnable()
-- -- Hook ActionButton_UpdateHotkeys, overwriting the secure status
-- self:Hook("ActionButton_UpdateHotkeys", true)
275,12 → 275,12
if type(object) == "string" then
method, handler, hookSecure, object = object, method, handler, nil
end
 
 
if handler == true then
handler, hookSecure = nil, true
end
 
hook(self, object, method, handler, false, false, false, hookSecure or false, "Usage: Hook([object], method, [handler], [hookSecure])")
hook(self, object, method, handler, false, false, false, hookSecure or false, "Usage: Hook([object], method, [handler], [hookSecure])")
end
 
--- RawHook a function or a method on an object.
297,7 → 297,7
-- @usage
-- -- create an addon with AceHook embeded
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
--
--
-- function MyAddon:OnEnable()
-- -- Hook ActionButton_UpdateHotkeys, overwriting the secure status
-- self:RawHook("ActionButton_UpdateHotkeys", true)
314,11 → 314,11
if type(object) == "string" then
method, handler, hookSecure, object = object, method, handler, nil
end
 
 
if handler == true then
handler, hookSecure = nil, true
end
 
 
hook(self, object, method, handler, false, false, true, hookSecure or false, "Usage: RawHook([object], method, [handler], [hookSecure])")
end
 
337,7 → 337,7
if type(object) == "string" then
method, handler, object = object, method, nil
end
 
 
hook(self, object, method, handler, false, true, false, false, "Usage: SecureHook([object], method, [handler])")
end
 
354,9 → 354,9
-- @usage
-- -- create an addon with AceHook embeded
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
--
--
-- function MyAddon:OnEnable()
-- -- Hook the OnShow of FriendsFrame
-- -- Hook the OnShow of FriendsFrame
-- self:HookScript(FriendsFrame, "OnShow", "FriendsFrameOnShow")
-- end
--
380,9 → 380,9
-- @usage
-- -- create an addon with AceHook embeded
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("HookDemo", "AceHook-3.0")
--
--
-- function MyAddon:OnEnable()
-- -- Hook the OnShow of FriendsFrame
-- -- Hook the OnShow of FriendsFrame
-- self:RawHookScript(FriendsFrame, "OnShow", "FriendsFrameOnShow")
-- end
--
420,54 → 420,54
if type(obj) == "string" then
method, obj = obj, nil
end
 
 
if obj and type(obj) ~= "table" then
error(format("%s: 'obj' - expecting nil or table got %s", usage, type(obj)), 2)
end
if type(method) ~= "string" then
error(format("%s: 'method' - expeting string got %s", usage, type(method)), 2)
end
 
 
local uid
if obj then
uid = registry[self][obj] and registry[self][obj][method]
else
uid = registry[self][method]
end
 
 
if not uid or not actives[uid] then
-- Declining to error on an unneeded unhook since the end effect is the same and this would just be annoying.
return false
end
 
 
actives[uid], handlers[uid] = nil, nil
 
 
if obj then
registry[self][obj][method] = nil
registry[self][obj] = next(registry[self][obj]) and registry[self][obj] or nil
 
 
-- if the hook reference doesnt exist, then its a secure hook, just bail out and dont do any unhooking
if not self.hooks[obj] or not self.hooks[obj][method] then return true end
 
 
if scripts[uid] and obj:GetScript(method) == uid then -- unhooks scripts
obj:SetScript(method, self.hooks[obj][method] ~= donothing and self.hooks[obj][method] or nil)
obj:SetScript(method, self.hooks[obj][method] ~= donothing and self.hooks[obj][method] or nil)
scripts[uid] = nil
elseif obj and self.hooks[obj] and self.hooks[obj][method] and obj[method] == uid then -- unhooks methods
obj[method] = self.hooks[obj][method]
end
 
 
self.hooks[obj][method] = nil
self.hooks[obj] = next(self.hooks[obj]) and self.hooks[obj] or nil
else
registry[self][method] = nil
 
 
-- if self.hooks[method] doesn't exist, then this is a SecureHook, just bail out
if not self.hooks[method] then return true end
 
 
if self.hooks[method] and _G[method] == uid then -- unhooks functions
_G[method] = self.hooks[method]
end
 
 
self.hooks[method] = nil
end
return true
501,7 → 501,7
return true, handlers[registry[self][obj][method]]
end
end
 
 
return false, nil
end
 
trunk/Libs/AceEvent-3.0/AceEvent-3.0.lua
2,14 → 2,14
-- All dispatching is done using **CallbackHandler-1.0**. AceEvent is a simple wrapper around
-- CallbackHandler, and dispatches all game events or addon message to the registrees.
--
-- **AceEvent-3.0** can be embeded into your addon, either explicitly by calling AceEvent:Embed(MyAddon) or by
-- **AceEvent-3.0** can be embeded into your addon, either explicitly by calling AceEvent:Embed(MyAddon) or by
-- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object
-- and can be accessed directly, without having to explicitly call AceEvent itself.\\
-- It is recommended to embed AceEvent, otherwise you'll have to specify a custom `self` on all calls you
-- make into AceEvent.
-- @class file
-- @name AceEvent-3.0
-- @release $Id: AceEvent-3.0.lua 1161 2017-08-12 14:30:16Z funkydude $
-- @release $Id: AceEvent-3.0.lua 1202 2019-05-15 23:11:22Z nevcairiel $
local CallbackHandler = LibStub("CallbackHandler-1.0")
 
local MAJOR, MINOR = "AceEvent-3.0", 4
25,22 → 25,22
 
-- APIs and registry for blizzard events, using CallbackHandler lib
if not AceEvent.events then
AceEvent.events = CallbackHandler:New(AceEvent,
AceEvent.events = CallbackHandler:New(AceEvent,
"RegisterEvent", "UnregisterEvent", "UnregisterAllEvents")
end
 
function AceEvent.events:OnUsed(target, eventname)
function AceEvent.events:OnUsed(target, eventname)
AceEvent.frame:RegisterEvent(eventname)
end
 
function AceEvent.events:OnUnused(target, eventname)
function AceEvent.events:OnUnused(target, eventname)
AceEvent.frame:UnregisterEvent(eventname)
end
 
 
-- APIs and registry for IPC messages, using CallbackHandler lib
if not AceEvent.messages then
AceEvent.messages = CallbackHandler:New(AceEvent,
AceEvent.messages = CallbackHandler:New(AceEvent,
"RegisterMessage", "UnregisterMessage", "UnregisterAllMessages"
)
AceEvent.SendMessage = AceEvent.messages.Fire
trunk/Libs/AceGUI-3.0/AceGUI-3.0.lua
1,6 → 1,6
--- **AceGUI-3.0** provides access to numerous widgets which can be used to create GUIs.
-- AceGUI is used by AceConfigDialog to create the option GUIs, but you can use it by itself
-- to create any custom GUI. There are more extensive examples in the test suite in the Ace3
-- to create any custom GUI. There are more extensive examples in the test suite in the Ace3
-- stand-alone distribution.
--
-- **Note**: When using AceGUI-3.0 directly, please do not modify the frames of the widgets directly,
24,17 → 24,17
-- f:AddChild(btn)
-- @class file
-- @name AceGUI-3.0
-- @release $Id: AceGUI-3.0.lua 1184 2018-07-21 14:13:14Z nevcairiel $
local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 36
-- @release $Id: AceGUI-3.0.lua 1231 2020-04-14 22:20:36Z nevcairiel $
local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 41
local AceGUI, oldminor = LibStub:NewLibrary(ACEGUI_MAJOR, ACEGUI_MINOR)
 
if not AceGUI then return end -- No upgrade needed
 
-- Lua APIs
local tconcat, tremove, tinsert = table.concat, table.remove, table.insert
local tinsert = table.insert
local select, pairs, next, type = select, pairs, next, type
local error, assert, loadstring = error, assert, loadstring
local setmetatable, rawget, rawset = setmetatable, rawget, rawset
local error, assert = error, assert
local setmetatable, rawget = setmetatable, rawget
local math_max = math.max
 
-- WoW APIs
51,7 → 51,8
AceGUI.WidgetBase = AceGUI.WidgetBase or {}
AceGUI.WidgetContainerBase = AceGUI.WidgetContainerBase or {}
AceGUI.WidgetVersions = AceGUI.WidgetVersions or {}
 
AceGUI.tooltip = AceGUI.tooltip or CreateFrame("GameTooltip", "AceGUITooltip", UIParent, "GameTooltipTemplate")
 
-- local upvalues
local WidgetRegistry = AceGUI.WidgetRegistry
local LayoutRegistry = AceGUI.LayoutRegistry
79,7 → 80,7
-- Internal Storage of the objects changed, from an array table
-- to a hash table, and additionally we introduced versioning on
-- the widgets which would discard all widgets from a pre-29 version
-- anyway, so we just clear the storage now, and don't try to
-- anyway, so we just clear the storage now, and don't try to
-- convert the storage tables to the new format.
-- This should generally not cause *many* widgets to end up in trash,
-- since once dialogs are opened, all addons should be loaded already
89,7 → 90,7
if oldminor and oldminor < 29 and AceGUI.objPools then
AceGUI.objPools = nil
end
 
 
AceGUI.objPools = AceGUI.objPools or {}
local objPools = AceGUI.objPools
--Returns a new instance, if none are available either returns a new table or calls the given contructor
97,11 → 98,11
if not WidgetRegistry[type] then
error("Attempt to instantiate unknown widget type", 2)
end
 
 
if not objPools[type] then
objPools[type] = {}
end
 
 
local newObj = next(objPools[type])
if not newObj then
newObj = WidgetRegistry[type]()
151,12 → 152,12
widget.OnAcquire = widget.Aquire
widget.Aquire = nil
end
 
 
if rawget(widget, "Release") then
widget.OnRelease = rawget(widget, "Release")
widget.OnRelease = rawget(widget, "Release")
widget.Release = nil
end
 
 
if widget.OnAcquire then
widget:OnAcquire()
else
175,7 → 176,10
-- If this widget is a Container-Widget, all of its Child-Widgets will be releases as well.
-- @param widget The widget to release
function AceGUI:Release(widget)
if widget.isQueuedForRelease then return end
widget.isQueuedForRelease = true
safecall(widget.PauseLayout, widget)
widget.frame:Hide()
widget:Fire("OnRelease")
safecall(widget.ReleaseChildren, widget)
 
204,9 → 208,26
widget.content.width = nil
widget.content.height = nil
end
widget.isQueuedForRelease = nil
delWidget(widget, widget.type)
end
 
--- Check if a widget is currently in the process of being released
-- This function check if this widget, or any of its parents (in which case it'll be released shortly as well)
-- are currently being released. This allows addon to handle any callbacks accordingly.
-- @param widget The widget to check
function AceGUI:IsReleasing(widget)
if widget.isQueuedForRelease then
return true
end
 
if widget.parent and widget.parent.AceGUIWidgetVersion then
return AceGUI:IsReleasing(widget.parent)
end
 
return false
end
 
-----------
-- Focus --
-----------
238,18 → 259,18
--[[
Widgets must provide the following functions
OnAcquire() - Called when the object is acquired, should set everything to a default hidden state
 
 
And the following members
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes
type - the type of the object, same as the name given to :RegisterWidget()
 
 
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet
It will be cleared automatically when a widget is released
Placing values directly into a widget object should be avoided
 
 
If the Widget can act as a container for other Widgets the following
content - frame or derivitive that children will be anchored to
 
 
The Widget can supply the following Optional Members
:OnRelease() - Called when the object is Released, should remove any additional anchors and clear any data
:OnWidthSet(width) - Called when the width of the widget is changed
265,21 → 286,21
-- Widget Base Template --
--------------------------
do
local WidgetBase = AceGUI.WidgetBase
 
local WidgetBase = AceGUI.WidgetBase
 
WidgetBase.SetParent = function(self, parent)
local frame = self.frame
frame:SetParent(nil)
frame:SetParent(parent.content)
self.parent = parent
end
 
 
WidgetBase.SetCallback = function(self, name, func)
if type(func) == "function" then
self.events[name] = func
end
end
 
 
WidgetBase.Fire = function(self, name, ...)
if self.events[name] then
local success, ret = safecall(self.events[name], self, name, ...)
288,7 → 309,7
end
end
end
 
 
WidgetBase.SetWidth = function(self, width)
self.frame:SetWidth(width)
self.frame.width = width
296,7 → 317,7
self:OnWidthSet(width)
end
end
 
 
WidgetBase.SetRelativeWidth = function(self, width)
if width <= 0 or width > 1 then
error(":SetRelativeWidth(width): Invalid relative width.", 2)
304,7 → 325,7
self.relWidth = width
self.width = "relative"
end
 
 
WidgetBase.SetHeight = function(self, height)
self.frame:SetHeight(height)
self.frame.height = height
312,7 → 333,7
self:OnHeightSet(height)
end
end
 
 
--[[ WidgetBase.SetRelativeHeight = function(self, height)
if height <= 0 or height > 1 then
error(":SetRelativeHeight(height): Invalid relative height.", 2)
324,47 → 345,51
WidgetBase.IsVisible = function(self)
return self.frame:IsVisible()
end
 
 
WidgetBase.IsShown= function(self)
return self.frame:IsShown()
end
 
 
WidgetBase.Release = function(self)
AceGUI:Release(self)
end
 
 
WidgetBase.IsReleasing = function(self)
return AceGUI:IsReleasing(self)
end
 
WidgetBase.SetPoint = function(self, ...)
return self.frame:SetPoint(...)
end
 
 
WidgetBase.ClearAllPoints = function(self)
return self.frame:ClearAllPoints()
end
 
 
WidgetBase.GetNumPoints = function(self)
return self.frame:GetNumPoints()
end
 
 
WidgetBase.GetPoint = function(self, ...)
return self.frame:GetPoint(...)
end
 
end
 
WidgetBase.GetUserDataTable = function(self)
return self.userdata
end
 
 
WidgetBase.SetUserData = function(self, key, value)
self.userdata[key] = value
end
 
 
WidgetBase.GetUserData = function(self, key)
return self.userdata[key]
end
 
 
WidgetBase.IsFullHeight = function(self)
return self.height == "fill"
end
 
 
WidgetBase.SetFullHeight = function(self, isFull)
if isFull then
self.height = "fill"
372,11 → 397,11
self.height = nil
end
end
 
 
WidgetBase.IsFullWidth = function(self)
return self.width == "fill"
end
 
 
WidgetBase.SetFullWidth = function(self, isFull)
if isFull then
self.width = "fill"
384,29 → 409,29
self.width = nil
end
end
 
 
-- local function LayoutOnUpdate(this)
-- this:SetScript("OnUpdate",nil)
-- this.obj:PerformLayout()
-- end
 
 
local WidgetContainerBase = AceGUI.WidgetContainerBase
 
 
WidgetContainerBase.PauseLayout = function(self)
self.LayoutPaused = true
end
 
 
WidgetContainerBase.ResumeLayout = function(self)
self.LayoutPaused = nil
end
 
 
WidgetContainerBase.PerformLayout = function(self)
if self.LayoutPaused then
return
end
safecall(self.LayoutFunc, self.content, self.children)
end
 
 
--call this function to layout, makes sure layed out objects get a frame to get sizes etc
WidgetContainerBase.DoLayout = function(self)
self:PerformLayout()
414,7 → 439,7
-- self.frame:SetScript("OnUpdate", LayoutOnUpdate)
-- end
end
 
 
WidgetContainerBase.AddChild = function(self, child, beforeWidget)
if beforeWidget then
local siblingIndex = 1
422,7 → 447,7
if widget == beforeWidget then
break
end
siblingIndex = siblingIndex + 1
siblingIndex = siblingIndex + 1
end
tinsert(self.children, siblingIndex, child)
else
432,7 → 457,7
child.frame:Show()
self:DoLayout()
end
 
 
WidgetContainerBase.AddChildren = function(self, ...)
for i = 1, select("#", ...) do
local child = select(i, ...)
442,7 → 467,7
end
self:DoLayout()
end
 
 
WidgetContainerBase.ReleaseChildren = function(self)
local children = self.children
for i = 1,#children do
450,7 → 475,7
children[i] = nil
end
end
 
 
WidgetContainerBase.SetLayout = function(self, Layout)
self.LayoutFunc = AceGUI:GetLayout(Layout)
end
474,7 → 499,7
end
end
end
 
 
local function ContentResize(this)
if this:GetWidth() and this:GetHeight() then
this.width = this:GetWidth()
486,7 → 511,7
setmetatable(WidgetContainerBase, {__index=WidgetBase})
 
--One of these function should be called on each Widget Instance as part of its creation process
 
 
--- Register a widget-class as a container for newly created widgets.
-- @param widget The widget class
function AceGUI:RegisterAsContainer(widget)
502,7 → 527,7
widget:SetLayout("List")
return widget
end
 
 
--- Register a widget-class as a widget.
-- @param widget The widget class
function AceGUI:RegisterAsWidget(widget)
529,11 → 554,11
-- @param Version The version of the widget
function AceGUI:RegisterWidgetType(Name, Constructor, Version)
assert(type(Constructor) == "function")
assert(type(Version) == "number")
 
assert(type(Version) == "number")
 
local oldVersion = WidgetVersions[Name]
if oldVersion and oldVersion >= Version then return end
 
 
WidgetVersions[Name] = Version
WidgetRegistry[Name] = Constructor
end
602,7 → 627,7
local width = content.width or content:GetWidth() or 0
for i = 1, #children do
local child = children[i]
 
 
local frame = child.frame
frame:ClearAllPoints()
frame:Show()
611,22 → 636,22
else
frame:SetPoint("TOPLEFT", children[i-1].frame, "BOTTOMLEFT")
end
 
 
if child.width == "fill" then
child:SetWidth(width)
frame:SetPoint("RIGHT", content)
 
 
if child.DoLayout then
child:DoLayout()
end
elseif child.width == "relative" then
child:SetWidth(width * child.relWidth)
 
 
if child.DoLayout then
child:DoLayout()
end
end
 
 
height = height + (frame.height or frame:GetHeight() or 0)
end
safecall(content.obj.LayoutFinished, content.obj, nil, height)
638,6 → 663,7
if children[1] then
children[1]:SetWidth(content:GetWidth() or 0)
children[1]:SetHeight(content:GetHeight() or 0)
children[1].frame:ClearAllPoints()
children[1].frame:SetAllPoints(content)
children[1].frame:Show()
safecall(content.obj.LayoutFinished, content.obj, nil, children[1].frame:GetHeight())
661,19 → 687,17
--height of the current row
local rowheight = 0
local rowoffset = 0
local lastrowoffset
 
 
local width = content.width or content:GetWidth() or 0
 
 
--control at the start of the row
local rowstart
local rowstartoffset
local lastrowstart
local isfullheight
 
 
local frameoffset
local lastframeoffset
local oversize
local oversize
for i = 1, #children do
local child = children[i]
oversize = nil
681,17 → 705,17
local frameheight = frame.height or frame:GetHeight() or 0
local framewidth = frame.width or frame:GetWidth() or 0
lastframeoffset = frameoffset
-- HACK: Why did we set a frameoffset of (frameheight / 2) ?
-- HACK: Why did we set a frameoffset of (frameheight / 2) ?
-- That was moving all widgets half the widgets size down, is that intended?
-- Actually, it seems to be neccessary for many cases, we'll leave it in for now.
-- If widgets seem to anchor weirdly with this, provide a valid alignoffset for them.
-- TODO: Investigate moar!
frameoffset = child.alignoffset or (frameheight / 2)
 
 
if child.width == "relative" then
framewidth = width * child.relWidth
end
 
 
frame:Show()
frame:ClearAllPoints()
if i == 1 then
730,11 → 754,11
else
--handles cases where the new height is higher than either control because of the offsets
--math.max(rowheight-rowoffset+frameoffset, frameheight-frameoffset+rowoffset)
 
 
--offset is always the larger of the two offsets
rowoffset = math_max(rowoffset, frameoffset)
rowheight = math_max(rowheight, rowoffset + (frameheight / 2))
 
 
frame:SetPoint("TOPLEFT", children[i-1].frame, "TOPRIGHT", 0, frameoffset - lastframeoffset)
usedwidth = framewidth + usedwidth
end
743,11 → 767,11
if child.width == "fill" then
safelayoutcall(child, "SetWidth", width)
frame:SetPoint("RIGHT", content)
 
 
usedwidth = 0
rowstart = frame
rowstartoffset = frameoffset
 
 
if child.DoLayout then
child:DoLayout()
end
756,7 → 780,7
rowstartoffset = rowoffset
elseif child.width == "relative" then
safelayoutcall(child, "SetWidth", width * child.relWidth)
 
 
if child.DoLayout then
child:DoLayout()
end
765,20 → 789,20
frame:SetPoint("RIGHT", content)
end
end
 
 
if child.height == "fill" then
frame:SetPoint("BOTTOM", content)
isfullheight = true
end
end
 
 
--anchor the last row, if its full height needs a special case since its height has just been changed by the anchor
if isfullheight then
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -height)
elseif rowstart then
rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3))
end
 
 
height = height + rowheight + 3
safecall(content.obj.LayoutFinished, content.obj, nil, height)
end)
842,7 → 866,7
local spaceH = tableObj.spaceH or tableObj.space or 0
local spaceV = tableObj.spaceV or tableObj.space or 0
local totalH = (content:GetWidth() or content.width or 0) - spaceH * (#cols - 1)
 
 
-- We need to reuse these because layout events can come in very frequently
local layoutCache = obj:GetUserData("layoutCache")
if not layoutCache then
850,7 → 874,7
obj:SetUserData("layoutCache", layoutCache)
end
local t, laneH, laneV, rowspans, rowStart, colStart = unpack(layoutCache)
 
 
-- Create the grid
local n, slotFound = 0
for i,child in ipairs(children) do
915,7 → 939,7
local f = child.frame
f:ClearAllPoints()
local childH = f:GetWidth() or 0
 
 
laneH[col] = max(laneH[col], childH - GetCellDimension("H", laneH, colStart[child], col - 1, spaceH))
end
end
949,7 → 973,7
local cellObj = child:GetUserData("cell")
local offsetH = GetCellDimension("H", laneH, 1, colStart[child] - 1, spaceH) + (colStart[child] == 1 and 0 or spaceH)
local cellH = GetCellDimension("H", laneH, colStart[child], col, spaceH)
 
 
local f = child.frame
f:ClearAllPoints()
local childH = f:GetWidth() or 0
959,7 → 983,7
if child:IsFullWidth() or alignFn == "fill" or childH > cellH then
f:SetPoint("RIGHT", content, "LEFT", offsetH + align + cellH, 0)
end
 
 
if child.DoLayout then
child:DoLayout()
end
978,7 → 1002,7
local cellObj = child:GetUserData("cell")
local offsetV = GetCellDimension("V", laneV, 1, rowStart[child] - 1, spaceV) + (rowStart[child] == 1 and 0 or spaceV)
local cellV = GetCellDimension("V", laneV, rowStart[child], row, spaceV)
 
 
local f = child.frame
local childV = f:GetHeight() or 0
 
993,7 → 1017,7
 
-- Calculate total height
local totalV = GetCellDimension("V", laneV, 1, #laneV, spaceV)
 
 
-- Cleanup
for _,v in pairs(layoutCache) do wipe(v) end
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-BlizOptionsGroup.lua New file
0,0 → 1,150
local AceGUI = LibStub("AceGUI-3.0")
 
 
-------------
-- Widgets --
-------------
--[[
Widgets must provide the following functions
Acquire() - Called when the object is aquired, should set everything to a default hidden state
Release() - Called when the object is Released, should remove any anchors and hide the Widget
 
And the following members
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes
type - the type of the object, same as the name given to :RegisterWidget()
 
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet
It will be cleared automatically when a widget is released
Placing values directly into a widget object should be avoided
 
If the Widget can act as a container for other Widgets the following
content - frame or derivitive that children will be anchored to
 
The Widget can supply the following Optional Members
 
 
]]
 
----------------------------------
-- Blizzard Options Group --
----------------------------------
--[[
Group Designed to be added to the bliz interface options panel
]]
 
do
local Type = "BlizOptionsGroup"
local Version = 6
 
local function OnAcquire(self)
 
end
 
local function OnRelease(self)
self.frame:ClearAllPoints()
self.frame:Hide()
self:SetName()
end
 
local function okay(this)
this.obj:Fire("okay")
end
 
local function cancel(this)
this.obj:Fire("cancel")
end
 
local function defaults(this)
this.obj:Fire("defaults")
end
 
local function SetName(self, name, parent)
self.frame.name = name
self.frame.parent = parent
end
 
local function OnShow(this)
this.obj:Fire("OnShow")
end
 
local function OnHide(this)
this.obj:Fire("OnHide")
end
 
local function OnWidthSet(self, width)
local content = self.content
local contentwidth = width - 63
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 - 26
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end
 
local function SetTitle(self, title)
local content = self.content
content:ClearAllPoints()
if not title or title == "" then
content:SetPoint("TOPLEFT",self.frame,"TOPLEFT",15,-10)
self.label:SetText("")
else
content:SetPoint("TOPLEFT",self.frame,"TOPLEFT",15,-40)
self.label:SetText(title)
end
content:SetPoint("BOTTOMRIGHT",self.frame,"BOTTOMRIGHT",-10,10)
end
 
local function Constructor()
local frame = CreateFrame("Frame")
local self = {}
self.type = Type
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.frame = frame
self.SetName = SetName
 
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
self.SetTitle = SetTitle
 
frame.obj = self
frame.okay = okay
frame.cancel = cancel
frame.defaults = defaults
 
frame:Hide()
frame:SetScript("OnHide",OnHide)
frame:SetScript("OnShow",OnShow)
 
local label = frame:CreateFontString(nil,"OVERLAY","GameFontNormalLarge")
self.label = label
label:SetPoint("TOPLEFT", frame, "TOPLEFT", 15, -15)
label:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", 10, -45)
label:SetJustifyH("LEFT")
label:SetJustifyV("TOP")
 
--Container Support
local content = CreateFrame("Frame",nil,frame)
self.content = content
content.obj = self
content:SetPoint("TOPLEFT",frame,"TOPLEFT",15,-10)
content:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-10,10)
 
AceGUI:RegisterAsContainer(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-Frame.lua
1,7 → 1,7
--[[-----------------------------------------------------------------------------
Frame Container
-------------------------------------------------------------------------------]]
local Type, Version = "Frame", 26
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
 
179,7 → 179,7
}
 
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
local frame = CreateFrame("Frame", nil, UIParent, BackdropTemplateMixin and "BackdropTemplate" or nil)
frame:Hide()
 
frame:EnableMouse(true)
201,7 → 201,7
closebutton:SetWidth(100)
closebutton:SetText(CLOSE)
 
local statusbg = CreateFrame("Button", nil, frame)
local statusbg = CreateFrame("Button", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
statusbg:SetPoint("BOTTOMLEFT", 15, 15)
statusbg:SetPoint("BOTTOMRIGHT", -132, 15)
statusbg:SetHeight(24)
219,7 → 219,7
statustext:SetText("")
 
local titlebg = frame:CreateTexture(nil, "OVERLAY")
titlebg:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
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)
235,14 → 235,14
titletext:SetPoint("TOP", titlebg, "TOP", 0, -14)
 
local titlebg_l = frame:CreateTexture(nil, "OVERLAY")
titlebg_l:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
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("Interface\\DialogFrame\\UI-DialogBox-Header")
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)
260,7 → 260,7
line1:SetWidth(14)
line1:SetHeight(14)
line1:SetPoint("BOTTOMRIGHT", -8, 8)
line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
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)
 
268,7 → 268,7
line2:SetWidth(8)
line2:SetHeight(8)
line2:SetPoint("BOTTOMRIGHT", -8, 8)
line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
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)
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-InlineGroup.lua
2,7 → 2,7
InlineGroup Container
Simple container widget that creates a visible "box" with an optional title.
-------------------------------------------------------------------------------]]
local Type, Version = "InlineGroup", 21
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
 
75,7 → 75,7
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
 
local border = CreateFrame("Frame", nil, frame)
local border = CreateFrame("Frame", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
border:SetPoint("TOPLEFT", 0, -17)
border:SetPoint("BOTTOMRIGHT", -1, 3)
border:SetBackdrop(PaneBackdrop)
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Frame.lua New file
0,0 → 1,299
local AceGUI = LibStub("AceGUI-3.0")
 
----------------
-- Main Frame --
----------------
--[[
Events :
OnClose
 
]]
do
local Type = "Frame"
local Version = 8
 
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 frameOnClose(this)
this.obj:Fire("OnClose")
end
 
local function closeOnClick(this)
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()
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 Constructor()
local frame = CreateFrame("Frame",nil,UIParent)
local self = {}
self.type = "Frame"
 
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.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:SetBackdrop(FrameBackdrop)
frame:SetBackdropColor(0,0,0,1)
frame:SetScript("OnHide",frameOnClose)
frame:SetMinResize(400,200)
frame:SetToplevel(true)
 
local closebutton = CreateFrame("Button",nil,frame,"UIPanelButtonTemplate")
closebutton:SetScript("OnClick", closeOnClick)
closebutton:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-27,17)
closebutton:SetHeight(20)
closebutton:SetWidth(100)
closebutton:SetText(CLOSE)
 
self.closebutton = closebutton
closebutton.obj = self
 
local statusbg = CreateFrame("Frame",nil,frame)
statusbg:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",15,15)
statusbg:SetPoint("BOTTOMRIGHT",frame,"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)
self.statusbg = statusbg
 
local statustext = statusbg:CreateFontString(nil,"OVERLAY","GameFontNormal")
self.statustext = statustext
statustext:SetPoint("TOPLEFT",statusbg,"TOPLEFT",7,-2)
statustext:SetPoint("BOTTOMRIGHT",statusbg,"BOTTOMRIGHT",-7,2)
statustext:SetHeight(20)
statustext:SetJustifyH("LEFT")
statustext:SetText("")
 
local title = CreateFrame("Frame",nil,frame)
self.title = title
title:EnableMouse()
title:SetScript("OnMouseDown",titleOnMouseDown)
title:SetScript("OnMouseUp", frameOnMouseUp)
 
 
local titlebg = frame:CreateTexture(nil,"OVERLAY")
titlebg:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
titlebg:SetTexCoord(0.31,0.67,0,0.63)
titlebg:SetPoint("TOP",frame,"TOP",0,12)
titlebg:SetWidth(100)
titlebg:SetHeight(40)
 
local titlebg_l = frame:CreateTexture(nil,"OVERLAY")
titlebg_l:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
titlebg_l:SetTexCoord(0.21,0.31,0,0.63)
titlebg_l:SetPoint("RIGHT",titlebg,"LEFT",0,0)
titlebg_l:SetWidth(30)
titlebg_l:SetHeight(40)
 
local titlebg_right = frame:CreateTexture(nil,"OVERLAY")
titlebg_right:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header")
titlebg_right:SetTexCoord(0.67,0.77,0,0.63)
titlebg_right:SetPoint("LEFT",titlebg,"RIGHT",0,0)
titlebg_right:SetWidth(30)
titlebg_right:SetHeight(40)
 
title:SetAllPoints(titlebg)
local titletext = title:CreateFontString(nil,"OVERLAY","GameFontNormal")
titletext:SetPoint("TOP",titlebg,"TOP",0,-14)
 
self.titletext = titletext
 
local sizer_se = CreateFrame("Frame",nil,frame)
sizer_se:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,0)
sizer_se:SetWidth(25)
sizer_se:SetHeight(25)
sizer_se:EnableMouse()
sizer_se:SetScript("OnMouseDown",sizerseOnMouseDown)
sizer_se:SetScript("OnMouseUp", sizerOnMouseUp)
self.sizer_se = sizer_se
 
local line1 = sizer_se:CreateTexture(nil, "BACKGROUND")
self.line1 = line1
line1:SetWidth(14)
line1:SetHeight(14)
line1:SetPoint("BOTTOMRIGHT", -8, 8)
line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
local x = 0.1 * 14/17
line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
 
local line2 = sizer_se:CreateTexture(nil, "BACKGROUND")
self.line2 = line2
line2:SetWidth(8)
line2:SetHeight(8)
line2:SetPoint("BOTTOMRIGHT", -8, 8)
line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
local x = 0.1 * 8/17
line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5)
 
local sizer_s = CreateFrame("Frame",nil,frame)
sizer_s:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-25,0)
sizer_s:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",0,0)
sizer_s:SetHeight(25)
sizer_s:EnableMouse()
sizer_s:SetScript("OnMouseDown",sizersOnMouseDown)
sizer_s:SetScript("OnMouseUp", sizerOnMouseUp)
self.sizer_s = sizer_s
 
local sizer_e = CreateFrame("Frame",nil,frame)
sizer_e:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,25)
sizer_e:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0)
sizer_e:SetWidth(25)
sizer_e:EnableMouse()
sizer_e:SetScript("OnMouseDown",sizereOnMouseDown)
sizer_e:SetScript("OnMouseUp", sizerOnMouseUp)
self.sizer_e = sizer_e
 
--Container Support
local content = CreateFrame("Frame",nil,frame)
self.content = content
content.obj = self
content:SetPoint("TOPLEFT",frame,"TOPLEFT",17,-27)
content:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-17,40)
 
AceGUI:RegisterAsContainer(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-InlineGroup.lua New file
0,0 → 1,136
local AceGUI = LibStub("AceGUI-3.0")
 
 
-------------
-- Widgets --
-------------
--[[
Widgets must provide the following functions
Acquire() - Called when the object is aquired, should set everything to a default hidden state
Release() - Called when the object is Released, should remove any anchors and hide the Widget
 
And the following members
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes
type - the type of the object, same as the name given to :RegisterWidget()
 
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet
It will be cleared automatically when a widget is released
Placing values directly into a widget object should be avoided
 
If the Widget can act as a container for other Widgets the following
content - frame or derivitive that children will be anchored to
 
The Widget can supply the following Optional Members
 
 
]]
 
--------------------------
-- Inline Group --
--------------------------
--[[
This is a simple grouping container, no selection
It will resize automatically to the height of the controls added to it
]]
 
do
local Type = "InlineGroup"
local Version = 5
 
local function OnAcquire(self)
self:SetWidth(300)
self:SetHeight(100)
end
 
local function OnRelease(self)
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
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 SetTitle(self,title)
self.titletext:SetText(title)
end
 
 
local function LayoutFinished(self, width, height)
if self.noAutoHeight then return end
self:SetHeight((height or 0) + 40)
end
 
local function OnWidthSet(self, width)
local content = self.content
local contentwidth = width - 20
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 - 20
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end
 
local function Constructor()
local frame = CreateFrame("Frame",nil,UIParent)
local self = {}
self.type = Type
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.SetTitle = SetTitle
self.frame = frame
self.LayoutFinished = LayoutFinished
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
 
frame.obj = self
 
frame:SetHeight(100)
frame:SetWidth(100)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
local titletext = frame:CreateFontString(nil,"OVERLAY","GameFontNormal")
titletext:SetPoint("TOPLEFT",frame,"TOPLEFT",14,0)
titletext:SetPoint("TOPRIGHT",frame,"TOPRIGHT",-14,0)
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
 
self.titletext = titletext
 
local border = CreateFrame("Frame",nil,frame)
self.border = border
border:SetPoint("TOPLEFT",frame,"TOPLEFT",3,-17)
border:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-3,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)
self.content = content
content.obj = self
content:SetPoint("TOPLEFT",border,"TOPLEFT",10,-10)
content:SetPoint("BOTTOMRIGHT",border,"BOTTOMRIGHT",-10,10)
 
AceGUI:RegisterAsContainer(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown.lua
1,9 → 1,9
--[[ $Id: AceGUIWidget-DropDown.lua 1167 2017-08-29 22:08:48Z funkydude $ ]]--
--[[ $Id: AceGUIWidget-DropDown.lua 1237 2020-07-17 22:50:38Z nevcairiel $ ]]--
local AceGUI = LibStub("AceGUI-3.0")
 
-- Lua APIs
local min, max, floor = math.min, math.max, math.floor
local select, pairs, ipairs, type = select, pairs, ipairs, type
local select, pairs, ipairs, type, tostring = select, pairs, ipairs, type, tostring
local tsort = table.sort
 
-- WoW APIs
39,10 → 39,10
 
do
local widgetType = "Dropdown-Pullout"
local widgetVersion = 3
 
local widgetVersion = 4
 
--[[ Static data ]]--
 
 
local backdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border",
60,9 → 60,9
 
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
74,22 → 74,22
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
106,9 → 106,9
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
status.scrollvalue = value
end
 
 
-- exported
local function MoveScroll(self, value)
local status = self.scrollStatus
127,7 → 127,7
self.slider:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000))
end
end
 
 
-- exported
local function FixScroll(self)
local status = self.scrollStatus
140,7 → 140,7
child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, offset)
self.slider:SetValue(0)
else
self.slider:Show()
self.slider:Show()
local value = (offset / (viewheight - height) * 1000)
if value > 1000 then value = 1000 end
self.slider:SetValue(value)
153,44 → 153,44
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 function Open(self, point, relFrame, relPoint, x, y)
local items = self.items
local frame = self.frame
local itemFrame = self.itemFrame
 
 
frame:SetPoint(point, relFrame, relPoint, x, y)
 
 
 
local height = 8
for i, item in pairs(items) do
if i == 1 then
198,23 → 198,23
else
item:SetPoint("TOP", items[i-1].frame, "BOTTOM", 0, 1)
end
 
 
item:Show()
 
 
height = height + 16
end
itemFrame:SetHeight(height)
fixstrata("TOOLTIP", frame, frame:GetChildren())
frame:Show()
self:Fire("OnOpen")
end
 
end
 
-- exported
local function Close(self)
self.frame:Hide()
self:Fire("OnClose")
end
 
end
 
-- exported
local function Clear(self)
local items = self.items
222,18 → 222,18
AceGUI:Release(item)
items[i] = nil
end
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
243,28 → 243,28
self.frame:SetHeight(self.itemFrame:GetHeight() + 34) -- see :AddItem
end
end
 
 
-- exported
local function GetRightBorderWidth(self)
return 6 + (self.slider:IsShown() and 12 or 0)
end
 
 
-- exported
local function GetLeftBorderWidth(self)
return 6
end
 
 
--[[ Constructor ]]--
 
 
local function Constructor()
local count = AceGUI:GetNextWidgetNum(widgetType)
local frame = CreateFrame("Frame", "AceGUI30Pullout"..count, UIParent)
local 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
 
278,38 → 278,38
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: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)
 
local slider = CreateFrame("Slider", "AceGUI30PulloutScrollbar"..count, scrollFrame, BackdropTemplateMixin and "BackdropTemplate" or nil)
slider:SetOrientation("VERTICAL")
slider:SetHitRectInsets(0, 0, -10, 0)
slider:SetBackdrop(sliderBackdrop)
318,7 → 318,7
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)
327,46 → 327,46
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 = 31
 
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")
378,7 → 378,7
self.pullout:Close()
end
end
 
 
local function Dropdown_TogglePullout(this)
local self = this.obj
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
393,17 → 393,17
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
413,7 → 413,7
self.open = nil
self:Fire("OnClosed")
end
 
 
local function ShowMultiText(self)
local text
for i, widget in self.pullout:IterateItems() do
429,10 → 429,10
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)
443,14 → 443,14
else
this:SetValue(true)
end
if self.open then
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")
460,13 → 460,14
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
474,20 → 475,20
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
503,19 → 504,19
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
532,20 → 533,18
self.alignoffset = 12
end
end
 
 
-- exported
local function SetValue(self, value)
if self.list then
self:SetText(self.list[value] or "")
end
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
558,7 → 557,7
end
ShowMultiText(self)
end
 
 
-- exported
local function SetItemDisabled(self, item, disabled)
for i, widget in self.pullout:IterateItems() do
567,7 → 566,7
end
end
end
 
 
local function AddListItem(self, value, text, itemType)
if not itemType then itemType = "Dropdown-Item-Toggle" end
local exists = AceGUI:GetWidgetVersion(itemType)
580,7 → 579,7
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")
589,21 → 588,29
self.hasClose = true
end
end
 
 
-- exported
local sortlist = {}
local function sortTbl(x,y)
local num1, num2 = tonumber(x), tonumber(y)
if num1 and num2 then -- numeric comparison, either two numbers or numeric strings
return num1 < num2
else -- compare everything else tostring'ed
return tostring(x) < tostring(y)
end
end
local function SetList(self, list, order, itemType)
self.list = list
self.list = list or {}
self.pullout:Clear()
self.hasClose = nil
if not list then return end
 
 
if type(order) ~= "table" then
for v in pairs(list) do
sortlist[#sortlist + 1] = v
end
tsort(sortlist)
 
tsort(sortlist, sortTbl)
 
for i, key in ipairs(sortlist) do
AddListItem(self, key, list[key], itemType)
sortlist[i] = nil
618,15 → 625,13
AddCloseButton(self)
end
end
 
 
-- exported
local function AddItem(self, value, text, itemType)
if self.list then
self.list[value] = text
AddListItem(self, value, text, itemType)
end
self.list[value] = text
AddListItem(self, value, text, itemType)
end
 
 
-- exported
local function SetMultiselect(self, multi)
self.multiselect = multi
635,23 → 640,23
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
659,10 → 664,10
self.count = count
frame.obj = self
dropdown.obj = self
 
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
 
 
self.ClearFocus = ClearFocus
 
self.SetText = SetText
677,9 → 682,9
self.SetItemValue = SetItemValue
self.SetItemDisabled = SetItemDisabled
self.SetPulloutWidth = SetPulloutWidth
 
 
self.alignoffset = 26
 
 
frame:SetScript("OnHide",Dropdown_OnHide)
 
dropdown:ClearAllPoints()
690,10 → 695,10
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)
704,7 → 709,7
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
713,14 → 718,14
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)
732,6 → 737,6
AceGUI:RegisterAsWidget(self)
return self
end
 
 
AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion)
end
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Heading.lua
51,14 → 51,14
left:SetHeight(8)
left:SetPoint("LEFT", 3, 0)
left:SetPoint("RIGHT", label, "LEFT", -5, 0)
left:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
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("Interface\\Tooltips\\UI-Tooltip-Border")
right:SetTexture(137057) -- Interface\\Tooltips\\UI-Tooltip-Border
right:SetTexCoord(0.81, 0.94, 0.5, 1)
 
local widget = {
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-SimpleGroup.lua New file
0,0 → 1,97
local AceGUI = LibStub("AceGUI-3.0")
 
 
-------------
-- Widgets --
-------------
--[[
Widgets must provide the following functions
Acquire() - Called when the object is aquired, should set everything to a default hidden state
Release() - Called when the object is Released, should remove any anchors and hide the Widget
 
And the following members
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes
type - the type of the object, same as the name given to :RegisterWidget()
 
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet
It will be cleared automatically when a widget is released
Placing values directly into a widget object should be avoided
 
If the Widget can act as a container for other Widgets the following
content - frame or derivitive that children will be anchored to
 
The Widget can supply the following Optional Members
 
 
]]
 
--------------------------
-- Simple Group --
--------------------------
--[[
This is a simple grouping container, no selection, no borders
It will resize automatically to the height of the controls added to it
]]
 
do
local Type = "SimpleGroup"
local Version = 5
 
local function OnAcquire(self)
self:SetWidth(300)
self:SetHeight(100)
end
 
local function OnRelease(self)
self.frame:ClearAllPoints()
self.frame:Hide()
end
 
local function LayoutFinished(self, width, height)
if self.noAutoHeight then return end
self:SetHeight(height or 0)
end
 
local function OnWidthSet(self, width)
local content = self.content
content:SetWidth(width)
content.width = width
end
 
local function OnHeightSet(self, height)
local content = self.content
content:SetHeight(height)
content.height = height
end
 
local function Constructor()
local frame = CreateFrame("Frame",nil,UIParent)
local self = {}
self.type = Type
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.frame = frame
self.LayoutFinished = LayoutFinished
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
 
frame.obj = self
 
frame:SetHeight(100)
frame:SetWidth(100)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
--Container Support
local content = CreateFrame("Frame",nil,frame)
self.content = content
content.obj = self
content:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0)
content:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,0)
 
AceGUI:RegisterAsContainer(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-Window.lua
30,21 → 30,21
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()
55,22 → 55,22
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
78,19 → 78,19
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")
98,21 → 98,21
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
125,7 → 125,7
frame:SetPoint("CENTER",UIParent,"CENTER")
end
end
 
 
local function OnWidthSet(self, width)
local content = self.content
local contentwidth = width - 34
135,8 → 135,8
content:SetWidth(contentwidth)
content.width = contentwidth
end
 
 
 
 
local function OnHeightSet(self, height)
local content = self.content
local contentheight = height - 57
146,19 → 146,19
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
170,9 → 170,9
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
self.EnableResize = EnableResize
 
 
self.localstatus = {}
 
 
self.frame = frame
frame.obj = self
frame:SetWidth(700)
183,91 → 183,91
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([[Interface\PaperDollInfoFrame\UI-GearManager-Title-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([[Interface\Tooltips\UI-Tooltip-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([[Interface\PaperDollInfoFrame\UI-GearManager-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([[Interface\PaperDollInfoFrame\UI-GearManager-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([[Interface\PaperDollInfoFrame\UI-GearManager-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([[Interface\PaperDollInfoFrame\UI-GearManager-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([[Interface\PaperDollInfoFrame\UI-GearManager-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([[Interface\PaperDollInfoFrame\UI-GearManager-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([[Interface\PaperDollInfoFrame\UI-GearManager-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([[Interface\PaperDollInfoFrame\UI-GearManager-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)
275,7 → 275,7
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)
290,7 → 290,7
line1:SetWidth(14)
line1:SetHeight(14)
line1:SetPoint("BOTTOMRIGHT", -8, 8)
line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
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)
 
299,7 → 299,7
line2:SetWidth(8)
line2:SetHeight(8)
line2:SetPoint("BOTTOMRIGHT", -8, 8)
line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border")
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)
 
311,7 → 311,7
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)
320,17 → 320,17
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
return self
end
 
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-DropDownGroup.lua
2,7 → 2,7
DropdownGroup Container
Container controlled by a dropdown on the top.
-------------------------------------------------------------------------------]]
local Type, Version = "DropdownGroup", 21
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
 
125,7 → 125,7
dropdown.frame:Show()
dropdown:SetLabel("")
 
local border = CreateFrame("Frame", nil, frame)
local border = CreateFrame("Frame", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
border:SetPoint("TOPLEFT", 0, -26)
border:SetPoint("BOTTOMRIGHT", 0, 3)
border:SetBackdrop(PaneBackdrop)
150,7 → 150,7
widget[method] = func
end
dropdown.parentgroup = widget
 
 
return AceGUI:RegisterAsContainer(widget)
end
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-ScrollFrame.lua
8,7 → 8,7
 
-- Lua APIs
local pairs, assert, type = pairs, assert, type
local min, max, floor, abs = math.min, math.max, math.floor, math.abs
local min, max, floor = math.min, math.max, math.floor
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
40,7 → 40,7
Methods
-------------------------------------------------------------------------------]]
local methods = {
["OnAcquire"] = function(self)
["OnAcquire"] = function(self)
self:SetScroll(0)
self.scrollframe:SetScript("OnUpdate", FixScrollOnUpdate)
end,
77,7 → 77,7
["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
94,7 → 94,6
local status = self.status or self.localstatus
local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight()
local offset = status.offset or 0
local curvalue = self.scrollbar:GetValue()
-- Give us a margin of error of 2 pixels to stop some conditions that i would blame on floating point inaccuracys
-- No-one is going to miss 2 pixels at the bottom of the frame, anyhow!
if viewheight < height + 2 then
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-ScrollFrame.lua New file
0,0 → 1,225
local AceGUI = LibStub("AceGUI-3.0")
 
-------------
-- Widgets --
-------------
--[[
Widgets must provide the following functions
Acquire() - Called when the object is aquired, should set everything to a default hidden state
Release() - Called when the object is Released, should remove any anchors and hide the Widget
 
And the following members
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes
type - the type of the object, same as the name given to :RegisterWidget()
 
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet
It will be cleared automatically when a widget is released
Placing values directly into a widget object should be avoided
 
If the Widget can act as a container for other Widgets the following
content - frame or derivitive that children will be anchored to
 
The Widget can supply the following Optional Members
 
 
]]
 
--------------------------
-- Scroll Frame --
--------------------------
do
local Type = "ScrollFrame"
local Version = 4
 
local function OnAcquire(self)
 
end
 
local function OnRelease(self)
self.frame:ClearAllPoints()
self.frame:Hide()
self.status = nil
for k in pairs(self.localstatus) do
self.localstatus[k] = nil
end
end
 
local function SetScroll(self, value)
 
local status = self.status or self.localstatus
 
local frame, child = self.scrollframe, self.content
local viewheight = frame:GetHeight()
local height = child:GetHeight()
local offset
if viewheight > height then
offset = 0
else
offset = floor((height - viewheight) / 1000.0 * value)
end
child:ClearAllPoints()
child:SetPoint("TOPLEFT",frame,"TOPLEFT",0,offset)
child:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,offset)
status.offset = offset
status.scrollvalue = value
end
 
local function MoveScroll(self, value)
local status = self.status or self.localstatus
local frame, child = self.scrollframe, self.content
local height, viewheight = frame:GetHeight(), child:GetHeight()
if height > viewheight then
self.scrollbar:Hide()
else
self.scrollbar:Show()
local diff = height - viewheight
local delta = 1
if value < 0 then
delta = -1
end
self.scrollbar:SetValue(math.min(math.max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000))
end
end
 
 
local function FixScroll(self)
local status = self.status or self.localstatus
local frame, child = self.scrollframe, self.content
local height, viewheight = frame:GetHeight(), child:GetHeight()
local offset = status.offset
if not offset then
offset = 0
end
local curvalue = self.scrollbar:GetValue()
if viewheight < height then
self.scrollbar:Hide()
self.scrollbar:SetValue(0)
--self.scrollframe:SetPoint("BOTTOMRIGHT",self.frame,"BOTTOMRIGHT",0,0)
else
self.scrollbar:Show()
--self.scrollframe:SetPoint("BOTTOMRIGHT",self.frame,"BOTTOMRIGHT",-16,0)
local value = (offset / (viewheight - height) * 1000)
if value > 1000 then value = 1000 end
self.scrollbar:SetValue(value)
self:SetScroll(value)
if value < 1000 then
child:ClearAllPoints()
child:SetPoint("TOPLEFT",frame,"TOPLEFT",0,offset)
child:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,offset)
status.offset = offset
end
end
end
 
local function OnMouseWheel(this,value)
this.obj:MoveScroll(value)
end
 
local function OnScrollValueChanged(this, value)
this.obj:SetScroll(value)
end
 
local function FixScrollOnUpdate(this)
this:SetScript("OnUpdate", nil)
this.obj:FixScroll()
end
local function OnSizeChanged(this)
--this:SetScript("OnUpdate", FixScrollOnUpdate)
this.obj:FixScroll()
end
 
local function LayoutFinished(self,width,height)
self.content:SetHeight(height or 0 + 20)
self:FixScroll()
end
 
-- called to set an external table to store status in
local function SetStatusTable(self, status)
assert(type(status) == "table")
self.status = status
if not status.scrollvalue then
status.scrollvalue = 0
end
end
 
 
local createdcount = 0
 
local function OnWidthSet(self, width)
local content = self.content
content.width = width
end
 
 
local function OnHeightSet(self, height)
local content = self.content
content.height = height
end
 
local function Constructor()
local frame = CreateFrame("Frame",nil,UIParent)
local self = {}
self.type = Type
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
 
self.MoveScroll = MoveScroll
self.FixScroll = FixScroll
self.SetScroll = SetScroll
self.LayoutFinished = LayoutFinished
self.SetStatusTable = SetStatusTable
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
 
self.localstatus = {}
self.frame = frame
frame.obj = self
 
--Container Support
local scrollframe = CreateFrame("ScrollFrame",nil,frame)
local content = CreateFrame("Frame",nil,scrollframe)
createdcount = createdcount + 1
local scrollbar = CreateFrame("Slider",("AceConfigDialogScrollFrame%dScrollBar"):format(createdcount),scrollframe,"UIPanelScrollBarTemplate")
local scrollbg = scrollbar:CreateTexture(nil,"BACKGROUND")
scrollbg:SetAllPoints(scrollbar)
scrollbg:SetTexture(0,0,0,0.4)
self.scrollframe = scrollframe
self.content = content
self.scrollbar = scrollbar
 
scrollbar.obj = self
scrollframe.obj = self
content.obj = self
 
scrollframe:SetScrollChild(content)
scrollframe:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0)
scrollframe:SetPoint("BOTTOMRIGHT",self.frame,"BOTTOMRIGHT",-20,0)
scrollframe:EnableMouseWheel(true)
scrollframe:SetScript("OnMouseWheel", OnMouseWheel)
scrollframe:SetScript("OnSizeChanged", OnSizeChanged)
 
 
content:SetPoint("TOPLEFT",scrollframe,"TOPLEFT",0,0)
content:SetPoint("TOPRIGHT",scrollframe,"TOPRIGHT",0,0)
content:SetHeight(400)
 
scrollbar:SetPoint("TOPLEFT",scrollframe,"TOPRIGHT",4,-16)
scrollbar:SetPoint("BOTTOMLEFT",scrollframe,"BOTTOMRIGHT",4,16)
scrollbar:SetScript("OnValueChanged", OnScrollValueChanged)
scrollbar:SetMinMaxValues(0,1000)
scrollbar:SetValueStep(1)
scrollbar:SetValue(0)
scrollbar:SetWidth(16)
 
self.localstatus.scrollvalue = 0
 
 
self:FixScroll()
AceGUI:RegisterAsContainer(self)
--AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDownGroup.lua New file
0,0 → 1,168
local AceGUI = LibStub("AceGUI-3.0")
 
--[[
Selection Group controls all have an interface to select a group for thier contents
None of them will auto size to thier contents, and should usually be used with a scrollframe
unless you know that the controls will fit inside
]]
 
--------------------------
-- Dropdown Group --
--------------------------
--[[
Events :
OnGroupSelected
 
]]
do
local Type = "DropdownGroup"
local Version = 11
 
local function OnAcquire(self)
self.dropdown:SetText("")
self:SetDropdownWidth(200)
end
 
local function OnRelease(self)
self.frame:ClearAllPoints()
self.frame:Hide()
self.dropdown.list = nil
self.status = nil
for k in pairs(self.localstatus) do
self.localstatus[k] = nil
end
end
 
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 SetTitle(self,title)
self.titletext:SetText(title)
end
 
 
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
 
local function SetGroupList(self,list)
self.dropdown:SetList(list)
end
 
-- called to set an external table to store status in
local function SetStatusTable(self, status)
assert(type(status) == "table")
self.status = status
end
 
local function SetGroup(self,group)
self.dropdown:SetValue(group)
local status = self.status or self.localstatus
status.selected = group
self:Fire("OnGroupSelected", group)
end
 
local function OnWidthSet(self, width)
local content = self.content
local contentwidth = width - 26
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 - 63
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end
 
local function LayoutFinished(self, width, height)
self:SetHeight((height or 0) + 63)
end
 
local function SetDropdownWidth(self, width)
self.dropdown:SetWidth(width)
end
 
local function Constructor()
local frame = CreateFrame("Frame")
local self = {}
self.type = Type
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
 
self.SetTitle = SetTitle
self.SetGroupList = SetGroupList
self.SetGroup = SetGroup
self.SetStatusTable = SetStatusTable
self.SetDropdownWidth = SetDropdownWidth
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
self.LayoutFinished = LayoutFinished
 
self.localstatus = {}
 
self.frame = frame
frame.obj = self
 
 
frame:SetHeight(100)
frame:SetWidth(100)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
local titletext = frame:CreateFontString(nil,"OVERLAY","GameFontNormal")
titletext:SetPoint("TOPLEFT",frame,"TOPLEFT",4,0)
titletext:SetPoint("TOPRIGHT",frame,"TOPRIGHT",-4,0)
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
 
 
self.titletext = titletext
 
local dropdown = AceGUI:Create("Dropdown")
self.dropdown = dropdown
dropdown.frame:SetParent(frame)
dropdown.parentgroup = self
dropdown:SetCallback("OnValueChanged",SelectedGroup)
 
dropdown.frame:SetPoint("TOPLEFT",titletext,"BOTTOMLEFT",-3,3)
dropdown.frame:Show()
dropdown:SetLabel("")
 
local border = CreateFrame("Frame",nil,frame)
self.border = border
border:SetPoint("TOPLEFT",frame,"TOPLEFT",3,-40)
border:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-3,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)
self.content = content
content.obj = self
content:SetPoint("TOPLEFT",border,"TOPLEFT",10,-10)
content:SetPoint("BOTTOMRIGHT",border,"BOTTOMRIGHT",-10,10)
 
AceGUI:RegisterAsContainer(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-TreeGroup.lua
2,12 → 2,10
TreeGroup Container
Container that uses a tree control to switch between groups.
-------------------------------------------------------------------------------]]
local Type, Version = "TreeGroup", 41
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
 
local WoW80 = select(4, GetBuildInfo()) >= 80000
 
-- Lua APIs
local next, pairs, ipairs, assert, type = next, pairs, ipairs, assert, type
local math_min, math_max, floor = math.min, math.max, floor
18,7 → 16,7
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: GameTooltip, FONT_COLOR_CODE_CLOSE
-- GLOBALS: FONT_COLOR_CODE_CLOSE
 
-- Recycling functions
local new, del
36,7 → 34,7
function del(t)
for k in pairs(t) do
t[k] = nil
end
end
pool[t] = true
end
end
59,7 → 57,6
local function UpdateButton(button, treeline, selected, canExpand, isExpanded)
local self = button.obj
local toggle = button.toggle
local frame = self.frame
local text = treeline.text or ""
local icon = treeline.icon
local iconCoords = treeline.iconCoords
67,7 → 64,7
local value = treeline.value
local uniquevalue = treeline.uniquevalue
local disabled = treeline.disabled
 
 
button.treeline = treeline
button.value = value
button.uniquevalue = uniquevalue
78,8 → 75,6
button:UnlockHighlight()
button.selected = false
end
local normalTexture = button:GetNormalTexture()
local line = button.line
button.level = level
if ( level == 1 ) then
button:SetNormalFontObject("GameFontNormal")
90,7 → 85,7
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)
98,27 → 93,27
button.text:SetText(text)
button:EnableMouse(true)
end
 
 
if icon then
button.icon:SetTexture(icon)
button.icon:SetPoint("LEFT", 8 * level, (level == 1) and 0 or 1)
else
button.icon:SetTexture(nil)
end
 
 
if iconCoords then
button.icon:SetTexCoord(unpack(iconCoords))
else
button.icon:SetTexCoord(0, 1, 0, 1)
end
 
 
if canExpand then
if not isExpanded then
toggle:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-UP")
toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN")
toggle:SetNormalTexture(130838) -- Interface\\Buttons\\UI-PlusButton-UP
toggle:SetPushedTexture(130836) -- Interface\\Buttons\\UI-PlusButton-DOWN
else
toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP")
toggle:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-DOWN")
toggle:SetNormalTexture(130821) -- Interface\\Buttons\\UI-MinusButton-UP
toggle:SetPushedTexture(130820) -- Interface\\Buttons\\UI-MinusButton-DOWN
end
toggle:Show()
else
201,7 → 196,6
 
local function Button_OnDoubleClick(button)
local self = button.obj
local status = self.status or self.localstatus
local status = (self.status or self.localstatus).groups
status[button.uniquevalue] = not status[button.uniquevalue]
self:RefreshTree()
212,11 → 206,13
self:Fire("OnButtonEnter", frame.uniquevalue, frame)
 
if self.enabletooltips then
GameTooltip:SetOwner(frame, "ANCHOR_NONE")
GameTooltip:SetPoint("LEFT",frame,"RIGHT")
GameTooltip:SetText(frame.text:GetText() or "", 1, .82, 0, true)
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)
 
GameTooltip:Show()
tooltip:Show()
end
end
 
225,7 → 221,7
self:Fire("OnButtonLeave", frame.uniquevalue, frame)
 
if self.enabletooltips then
GameTooltip:Hide()
AceGUI.tooltip:Hide()
end
end
 
271,18 → 267,19
local function Dragger_OnMouseUp(frame)
local treeframe = frame:GetParent()
local self = treeframe.obj
local frame = treeframe:GetParent()
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:SetPoint("TOPLEFT", frame, "TOPLEFT",0,0)
treeframe:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT",0,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)
367,8 → 364,8
--sets the tree to be displayed
["SetTree"] = function(self, tree, filter)
self.filter = filter
if tree then
assert(type(tree) == "table")
if tree then
assert(type(tree) == "table")
end
self.tree = tree
self:RefreshTree()
376,8 → 373,7
 
["BuildLevel"] = function(self, tree, level, parent)
local groups = (self.status or self.localstatus).groups
local hasChildren = self.hasChildren
 
 
for i, v in ipairs(tree) do
if v.children then
if not self.filter or ShouldDisplayLevel(v.children) then
414,7 → 410,7
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)
424,14 → 420,13
local maxlines = (floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18))
if maxlines <= 0 then return end
 
-- workaround for lag spikes on WoW 8.0
if WoW80 and self.frame:GetParent() == UIParent and not fromOnUpdate then
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
 
507,9 → 502,9
button:Show()
buttonnum = buttonnum + 1
end
 
 
end,
 
 
["SetSelected"] = function(self, value)
local status = self.status or self.localstatus
if status.selected ~= value then
559,16 → 554,16
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
594,16 → 589,16
treewidth = DEFAULT_TREE_WIDTH
else
resizable = false
treewidth = DEFAULT_TREE_WIDTH
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)
634,7 → 629,7
local DraggerBackdrop = {
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
edgeFile = nil,
tile = true, tileSize = 16, edgeSize = 0,
tile = true, tileSize = 16, edgeSize = 1,
insets = { left = 3, right = 3, top = 7, bottom = 7 }
}
 
642,7 → 637,7
local num = AceGUI:GetNextWidgetNum(Type)
local frame = CreateFrame("Frame", nil, UIParent)
 
local treeframe = CreateFrame("Frame", nil, frame)
local treeframe = CreateFrame("Frame", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
treeframe:SetPoint("TOPLEFT")
treeframe:SetPoint("BOTTOMLEFT")
treeframe:SetWidth(DEFAULT_TREE_WIDTH)
657,7 → 652,7
treeframe:SetScript("OnSizeChanged", Tree_OnSizeChanged)
treeframe:SetScript("OnMouseWheel", Tree_OnMouseWheel)
 
local dragger = CreateFrame("Frame", nil, treeframe)
local dragger = CreateFrame("Frame", nil, treeframe, BackdropTemplateMixin and "BackdropTemplate" or nil)
dragger:SetWidth(8)
dragger:SetPoint("TOP", treeframe, "TOPRIGHT")
dragger:SetPoint("BOTTOM", treeframe, "BOTTOMRIGHT")
682,7 → 677,7
scrollbg:SetAllPoints(scrollbar)
scrollbg:SetColorTexture(0,0,0,0.4)
 
local border = CreateFrame("Frame",nil,frame)
local border = CreateFrame("Frame", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
border:SetPoint("TOPLEFT", treeframe, "TOPRIGHT")
border:SetPoint("BOTTOMRIGHT")
border:SetBackdrop(PaneBackdrop)
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Button.lua
51,7 → 51,7
self:SetWidth(self.text:GetStringWidth() + 30)
end
end,
 
 
["SetAutoWidth"] = function(self, autoWidth)
self.autoWidth = autoWidth
if self.autoWidth then
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown-Items.lua
1,4 → 1,4
--[[ $Id: AceGUIWidget-DropDown-Items.lua 1167 2017-08-29 22:08:48Z funkydude $ ]]--
--[[ $Id: AceGUIWidget-DropDown-Items.lua 1202 2019-05-15 23:11:22Z nevcairiel $ ]]--
 
local AceGUI = LibStub("AceGUI-3.0")
 
33,7 → 33,7
 
-- ItemBase is the base "class" for all dropdown items.
-- Each item has to use ItemBase.Create(widgetType) to
-- create an initial 'self' value.
-- create an initial 'self' value.
-- ItemBase will add common functions and ui event handlers.
-- Be sure to keep basic usage when you override functions.
 
52,7 → 52,7
self.highlight:Show()
end
self:Fire("OnEnter")
 
 
if self.specialOnEnter then
self.specialOnEnter(self)
end
60,10 → 60,10
 
function ItemBase.Frame_OnLeave(this)
local self = this.obj
 
 
self.highlight:Hide()
self:Fire("OnLeave")
 
 
if self.specialOnLeave then
self.specialOnLeave(self)
end
89,7 → 89,7
-- 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
155,12 → 155,12
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")
169,7 → 169,7
self.text = text
 
local highlight = frame:CreateTexture(nil, "OVERLAY")
highlight:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight")
highlight:SetTexture(136810) -- Interface\\QuestFrame\\UI-QuestTitleHighlight
highlight:SetBlendMode("ADD")
highlight:SetHeight(14)
highlight:ClearAllPoints()
178,11 → 178,11
highlight:Hide()
self.highlight = highlight
 
local check = frame:CreateTexture("OVERLAY")
local check = frame:CreateTexture("OVERLAY")
check:SetWidth(16)
check:SetHeight(16)
check:SetPoint("LEFT",frame,"LEFT",3,-1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:SetTexture(130751) -- Interface\\Buttons\\UI-CheckBox-Check
check:Hide()
self.check = check
 
190,28 → 190,28
sub:SetWidth(16)
sub:SetHeight(16)
sub:SetPoint("RIGHT",frame,"RIGHT",-3,-1)
sub:SetTexture("Interface\\ChatFrame\\ChatFrameExpandArrow")
sub:SetTexture(130940) -- Interface\\ChatFrame\\ChatFrameExpandArrow
sub:Hide()
self.sub = sub
 
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
 
223,20 → 223,20
 
--[[
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
--]]
247,25 → 247,25
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)
273,21 → 273,21
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
 
296,7 → 296,7
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
305,16 → 305,16
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
 
324,7 → 324,7
do
local widgetType = "Dropdown-Item-Toggle"
local widgetVersion = 4
 
 
local function UpdateToggle(self)
if self.value then
self.check:Show()
332,12 → 332,12
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
350,31 → 350,31
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
 
384,55 → 384,55
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
 
441,31 → 441,31
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
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-TreeGroup.lua New file
0,0 → 1,715
local AceGUI = LibStub("AceGUI-3.0")
 
-- 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
 
--------------
-- TreeView --
--------------
 
do
local Type = "TreeGroup"
local Version = 20
 
local DEFAULT_TREE_WIDTH = 175
local DEFAULT_TREE_SIZABLE = true
 
local PaneBackdrop = {
bgFile = "Interface\\ChatFrame\\ChatFrameBackground",
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
tile = true, tileSize = 16, edgeSize = 16,
insets = { left = 3, right = 3, top = 5, bottom = 3 }
}
 
local DraggerBackdrop = {
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
edgeFile = nil,
tile = true, tileSize = 16, edgeSize = 0,
insets = { left = 3, right = 3, top = 7, bottom = 7 }
}
 
local function OnAcquire(self)
self:SetTreeWidth(DEFAULT_TREE_WIDTH,DEFAULT_TREE_SIZABLE)
self:EnableButtonTooltips(true)
end
 
local function OnRelease(self)
 
self.frame:ClearAllPoints()
self.frame:Hide()
self.status = nil
for k, v in pairs(self.localstatus) do
if k == "groups" then
for k2 in pairs(v) do
v[k2] = nil
end
else
self.localstatus[k] = nil
end
end
self.localstatus.scrollvalue = 0
self.localstatus.treewidth = DEFAULT_TREE_WIDTH
self.localstatus.treesizable = DEFAULT_TREE_SIZABLE
end
 
local function GetButtonParents(line)
local parent = line.parent
if parent and parent.value then
return parent.value, GetButtonParents(parent)
end
end
 
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 ButtonOnClick(this)
local self = this.obj
self:Fire("OnClick",this.uniquevalue, this.selected)
if not this.selected then
self:SetSelected(this.uniquevalue)
this.selected = true
this:LockHighlight()
self:RefreshTree()
end
AceGUI:ClearFocus()
end
 
local function ExpandOnClick(this)
local button = this.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 ButtonOnDoubleClick(button)
local self = button.obj
local status = self.status or self.localstatus
local status = (self.status or self.localstatus).groups
status[button.uniquevalue] = not status[button.uniquevalue]
self:RefreshTree()
end
 
local function EnableButtonTooltips(self, enable)
self.enabletooltips = enable
end
 
local function Button_OnEnter(this)
local self = this.obj
self:Fire("OnButtonEnter", this.uniquevalue, this)
 
if self.enabletooltips then
GameTooltip:SetOwner(this, "ANCHOR_NONE")
GameTooltip:SetPoint("LEFT",this,"RIGHT")
GameTooltip:SetText(this.text:GetText() or "", 1, .82, 0, 1)
 
GameTooltip:Show()
end
end
 
local function Button_OnLeave(this)
local self = this.obj
self:Fire("OnButtonLeave", this.uniquevalue, this)
 
if self.enabletooltips then
GameTooltip:Hide()
end
end
 
 
local buttoncount = 1
local function CreateButton(self)
local button = CreateFrame("Button",("AceGUI30TreeButton%d"):format(buttoncount),self.treeframe, "OptionsListButtonTemplate")
buttoncount = buttoncount + 1
button.obj = self
 
local icon = button:CreateTexture(nil, "OVERLAY")
icon:SetWidth(14)
icon:SetHeight(14)
button.icon = icon
 
button:SetScript("OnClick",ButtonOnClick)
button:SetScript("OnDoubleClick", ButtonOnDoubleClick)
button:SetScript("OnEnter",Button_OnEnter)
button:SetScript("OnLeave",Button_OnLeave)
 
button.toggle.button = button
button.toggle:SetScript("OnClick",ExpandOnClick)
 
return button
end
 
local function UpdateButton(button, treeline, selected, canExpand, isExpanded)
local self = button.obj
local toggle = button.toggle
local frame = self.frame
local text = treeline.text or ""
local icon = treeline.icon
local level = treeline.level
local value = treeline.value
local uniquevalue = treeline.uniquevalue
local disabled = treeline.disabled
 
button.treeline = treeline
button.value = value
button.uniquevalue = uniquevalue
if selected then
button:LockHighlight()
button.selected = true
else
button:UnlockHighlight()
button.selected = false
end
local normalTexture = button:GetNormalTexture()
local line = button.line
button.level = level
if ( level == 1 ) then
button:SetNormalFontObject("GameFontNormal")
button:SetHighlightFontObject("GameFontHighlight")
button.text:SetPoint("LEFT", (icon and 16 or 0) + 8, 2)
else
button:SetNormalFontObject("GameFontHighlightSmall")
button:SetHighlightFontObject("GameFontHighlightSmall")
button.text:SetPoint("LEFT", (icon and 16 or 0) + 8 * level, 2)
end
 
if disabled then
button:EnableMouse(false)
button.text:SetText("|cff808080"..text..FONT_COLOR_CODE_CLOSE)
else
button.text:SetText(text)
button:EnableMouse(true)
end
 
if icon then
button.icon:SetTexture(icon)
button.icon:SetPoint("LEFT", button, "LEFT", 8 * level, (level == 1) and 0 or 1)
else
button.icon:SetTexture(nil)
end
 
if canExpand then
if not isExpanded then
toggle:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-UP")
toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN")
else
toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP")
toggle:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-DOWN")
end
toggle:Show()
else
toggle:Hide()
end
end
 
 
local function OnScrollValueChanged(this, value)
if this.obj.noupdate then return end
local self = this.obj
local status = self.status or self.localstatus
status.scrollvalue = value
self:RefreshTree()
AceGUI:ClearFocus()
end
 
-- called to set an external table to store status in
local function SetStatusTable(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 not status.treesizable then
status.treesizable = DEFAULT_TREE_SIZABLE
end
self:SetTreeWidth(status.treewidth,status.treesizable)
self:RefreshTree()
end
 
--sets the tree to be displayed
--[[
example tree
 
Alpha
Bravo
-Charlie
-Delta
-Echo
Foxtrot
 
tree = {
{
value = "A",
text = "Alpha"
},
{
value = "B",
text = "Bravo",
children = {
{
value = "C",
text = "Charlie"
},
{
value = "D",
text = "Delta"
children = {
{
value = "E",
text = "Echo"
}
}
}
}
},
{
value = "F",
text = "Foxtrot"
},
}
]]
local function SetTree(self, tree, filter)
self.filter = filter
if tree then
assert(type(tree) == "table")
end
self.tree = tree
self:RefreshTree()
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.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
 
local function BuildLevel(self, tree, level, parent)
local groups = (self.status or self.localstatus).groups
local hasChildren = self.hasChildren
 
for i, v in ipairs(tree) do
if v.children then
if not self.filter or ShouldDisplayLevel(v.children) then
local line = addLine(self, v, tree, level, parent)
if groups[line.uniquevalue] then
self:BuildLevel(v.children, level+1, line)
end
end
elseif v.visible ~= false or not self.filter then
addLine(self, v, tree, level, parent)
end
end
end
 
--fire an update after one frame to catch the treeframes height
local function FirstFrameUpdate(this)
local self = this.obj
this:SetScript("OnUpdate",nil)
self:RefreshTree()
end
 
local function ResizeUpdate(this)
this.obj:RefreshTree()
end
 
local function RefreshTree(self)
local buttons = self.buttons
local lines = self.lines
 
for i, v in ipairs(buttons) do
v:Hide()
end
while lines[1] do
local t = tremove(lines)
for k in pairs(t) do
t[k] = nil
end
del(t)
end
 
if not self.tree then return end
--Build the list of visible entries from the tree and status tables
local status = self.status or self.localstatus
local groupstatus = status.groups
local tree = self.tree
 
local treeframe = self.treeframe
 
self:BuildLevel(tree, 1)
 
local numlines = #lines
 
local maxlines = (math.floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18))
 
local first, last
 
if numlines <= maxlines then
--the whole tree fits in the frame
status.scrollvalue = 0
self:ShowScroll(false)
first, last = 1, numlines
else
self:ShowScroll(true)
--scrolling will be needed
self.noupdate = true
self.scrollbar:SetMinMaxValues(0, numlines - maxlines)
--check if we are scrolled down too far
if numlines - status.scrollvalue < maxlines then
status.scrollvalue = numlines - maxlines
self.scrollbar:SetValue(status.scrollvalue)
end
self.noupdate = nil
first, last = status.scrollvalue+1, status.scrollvalue + maxlines
end
 
local buttonnum = 1
for i = first, last do
local line = lines[i]
local button = buttons[buttonnum]
if not button then
button = self:CreateButton()
 
buttons[buttonnum] = button
button:SetParent(treeframe)
button:SetFrameLevel(treeframe:GetFrameLevel()+1)
button:ClearAllPoints()
if i == 1 then
if self.showscroll then
button:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",-22,-10)
button:SetPoint("TOPLEFT", self.treeframe, "TOPLEFT", 0, -10)
else
button:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",0,-10)
button:SetPoint("TOPLEFT", self.treeframe, "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
 
local function SetSelected(self, value)
local status = self.status or self.localstatus
if status.selected ~= value then
status.selected = value
self:Fire("OnGroupSelected", value)
end
end
 
local function BuildUniqueValue(...)
local n = select('#', ...)
if n == 1 then
return ...
else
return (...).."\001"..BuildUniqueValue(select(2,...))
end
end
 
local function Select(self, uniquevalue, ...)
self.filter = false
local status = self.status or self.localstatus
local groups = status.groups
for i = 1, select('#', ...) do
groups[BuildUniqueValue(select(i, ...))] = true
end
status.selected = uniquevalue
self:RefreshTree()
self:Fire("OnGroupSelected", uniquevalue)
end
 
local function SelectByPath(self, ...)
self:Select(BuildUniqueValue(...), ...)
end
 
--Selects a tree node by UniqueValue
local function SelectByValue(self, uniquevalue)
self:Select(uniquevalue,string.split("\001", uniquevalue))
end
 
 
local function ShowScroll(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
 
local function OnWidthSet(self, width)
local content = self.content
local treeframe = self.treeframe
local status = self.status or self.localstatus
 
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
 
 
local function OnHeightSet(self, height)
local content = self.content
local contentheight = height - 20
if contentheight < 0 then
contentheight = 0
end
content:SetHeight(contentheight)
content.height = contentheight
end
 
 
local function TreeOnMouseWheel(this, delta)
local self = this.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 SetTreeWidth(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
end
 
local function draggerLeave(this)
this:SetBackdropColor(1, 1, 1, 0)
end
 
local function draggerEnter(this)
this:SetBackdropColor(1, 1, 1, 0.8)
end
 
local function draggerDown(this)
local treeframe = this:GetParent()
treeframe:StartSizing("RIGHT")
end
 
local function draggerUp(this)
local treeframe = this:GetParent()
local self = treeframe.obj
local frame = treeframe:GetParent()
treeframe:StopMovingOrSizing()
--treeframe:SetScript("OnUpdate", nil)
treeframe:SetUserPlaced(false)
--Without this :GetHeight will get stuck on the current height, causing the tree contents to not resize
treeframe:SetHeight(0)
treeframe:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0)
treeframe:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",0,0)
treeframe.obj:Fire("OnTreeResize",treeframe:GetWidth())
 
local status = self.status or self.localstatus
status.treewidth = treeframe:GetWidth()
end
 
local function LayoutFinished(self, width, height)
if self.noAutoHeight then return end
self:SetHeight((height or 0) + 20)
end
 
local createdcount = 0
local function Constructor()
local frame = CreateFrame("Frame",nil,UIParent)
local self = {}
self.type = Type
self.lines = {}
self.levels = {}
self.buttons = {}
self.hasChildren = {}
self.localstatus = {}
self.localstatus.groups = {}
self.filter = false
 
local treeframe = CreateFrame("Frame",nil,frame, BackdropTemplateMixin and "BackdropTemplate")
treeframe.obj = self
treeframe:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0)
treeframe:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",0,0)
treeframe:SetWidth(DEFAULT_TREE_WIDTH)
treeframe:SetScript("OnUpdate",FirstFrameUpdate)
treeframe:SetScript("OnSizeChanged",ResizeUpdate)
 
treeframe:EnableMouseWheel(true)
treeframe:SetScript("OnMouseWheel", TreeOnMouseWheel)
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)
local dragger = CreateFrame("Frame", nil, treeframe, BackdropTemplateMixin and "BackdropTemplate")
dragger:SetWidth(8)
dragger:SetPoint("TOP", treeframe, "TOPRIGHT")
dragger:SetPoint("BOTTOM", treeframe, "BOTTOMRIGHT")
dragger:SetBackdrop(DraggerBackdrop)
dragger:SetBackdropColor(1, 1, 1, 0)
dragger:SetScript("OnMouseDown", draggerDown)
dragger:SetScript("OnMouseUp", draggerUp)
dragger:SetScript("OnEnter", draggerEnter)
dragger:SetScript("OnLeave", draggerLeave)
 
self.dragger = dragger
self.treeframe = treeframe
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
 
self.SetTree = SetTree
self.SetTreeWidth = SetTreeWidth
self.RefreshTree = RefreshTree
self.SetStatusTable = SetStatusTable
self.BuildLevel = BuildLevel
self.CreateButton = CreateButton
self.SetSelected = SetSelected
self.ShowScroll = ShowScroll
self.SetStatusTable = SetStatusTable
self.Select = Select
self.SelectByValue = SelectByValue
self.SelectByPath = SelectByPath
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
self.EnableButtonTooltips = EnableButtonTooltips
self.Filter = Filter
self.LayoutFinished = LayoutFinished
 
self.frame = frame
frame.obj = self
 
createdcount = createdcount + 1
local scrollbar = CreateFrame("Slider",("AceConfigDialogTreeGroup%dScrollBar"):format(createdcount),treeframe,"UIPanelScrollBarTemplate")
self.scrollbar = scrollbar
local scrollbg = scrollbar:CreateTexture(nil,"BACKGROUND")
scrollbg:SetAllPoints(scrollbar)
scrollbg:SetTexture(0,0,0,0.4)
scrollbar.obj = self
self.noupdate = true
scrollbar:SetPoint("TOPRIGHT",treeframe,"TOPRIGHT",-10,-26)
scrollbar:SetPoint("BOTTOMRIGHT",treeframe,"BOTTOMRIGHT",-10,26)
scrollbar:SetScript("OnValueChanged", OnScrollValueChanged)
scrollbar:SetMinMaxValues(0,0)
self.localstatus.scrollvalue = 0
scrollbar:SetValueStep(1)
scrollbar:SetValue(0)
scrollbar:SetWidth(16)
self.noupdate = nil
 
local border = CreateFrame("Frame",nil,frame, BackdropTemplateMixin and "BackdropTemplate")
self.border = border
border:SetPoint("TOPLEFT",treeframe,"TOPRIGHT", 0,0)
border:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,0)
 
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)
self.content = content
content.obj = self
content:SetPoint("TOPLEFT",border,"TOPLEFT",10,-10)
content:SetPoint("BOTTOMRIGHT",border,"BOTTOMRIGHT",-10,10)
 
AceGUI:RegisterAsContainer(self)
--AceGUI:RegisterAsWidget(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-ColorPicker.lua
1,7 → 1,7
--[[-----------------------------------------------------------------------------
ColorPicker Widget
-------------------------------------------------------------------------------]]
local Type, Version = "ColorPicker", 23
local Type, Version = "ColorPicker", 25
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
13,7 → 13,7
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: ShowUIPanel, HideUIPanel, ColorPickerFrame, OpacitySliderFrame
-- GLOBALS: ColorPickerFrame, OpacitySliderFrame
 
--[[-----------------------------------------------------------------------------
Support functions
47,7 → 47,7
end
 
local function ColorSwatch_OnClick(frame)
HideUIPanel(ColorPickerFrame)
ColorPickerFrame:Hide()
local self = frame.obj
if not self.disabled then
ColorPickerFrame:SetFrameStrata("FULLSCREEN_DIALOG")
77,7 → 77,7
ColorCallback(self, r, g, b, a, true)
end
 
ShowUIPanel(ColorPickerFrame)
ColorPickerFrame:Show()
end
AceGUI:ClearFocus()
end
140,10 → 140,11
local colorSwatch = frame:CreateTexture(nil, "OVERLAY")
colorSwatch:SetWidth(19)
colorSwatch:SetHeight(19)
colorSwatch:SetTexture("Interface\\ChatFrame\\ChatFrameColorSwatch")
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)
151,9 → 152,10
texture:Show()
 
local checkers = frame:CreateTexture(nil, "BACKGROUND")
colorSwatch.checkers = checkers
checkers:SetWidth(14)
checkers:SetHeight(14)
checkers:SetTexture("Tileset\\Generic\\Checkers")
checkers:SetTexture(188523) -- Tileset\\Generic\\Checkers
checkers:SetTexCoord(.25, 0, 0.5, .25)
checkers:SetDesaturated(true)
checkers:SetVertexColor(1, 1, 1, 0.75)
168,7 → 170,7
text:SetPoint("RIGHT")
 
--local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
--highlight:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight")
--highlight:SetTexture(136810) -- Interface\\QuestFrame\\UI-QuestTitleHighlight
--highlight:SetBlendMode("ADD")
--highlight:SetAllPoints(frame)
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-InteractiveLabel.lua
8,13 → 8,6
-- Lua APIs
local select, pairs = select, pairs
 
-- WoW APIs
local CreateFrame, UIParent = CreateFrame, UIParent
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: GameFontHighlightSmall
 
--[[-----------------------------------------------------------------------------
Scripts
-------------------------------------------------------------------------------]]
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Label.lua
2,7 → 2,7
Label Widget
Displays text and optionally an icon.
-------------------------------------------------------------------------------]]
local Type, Version = "Label", 24
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
 
39,25 → 39,30
label:SetPoint("TOP", image, "BOTTOM")
label:SetPoint("LEFT")
label:SetWidth(width)
height = image:GetHeight() + label:GetHeight()
height = image:GetHeight() + label:GetStringHeight()
else
-- image on the left
image:SetPoint("TOPLEFT")
if image:GetHeight() > label:GetHeight() then
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:GetHeight())
height = max(image:GetHeight(), label:GetStringHeight())
end
else
-- no image shown
label:SetPoint("TOPLEFT")
label:SetWidth(width)
height = label:GetHeight()
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
108,7 → 113,7
["SetImage"] = function(self, path, ...)
local image = self.image
image:SetTexture(path)
 
 
if image:GetTexture() then
self.imageshown = true
local n = select("#", ...)
125,6 → 130,7
 
["SetFont"] = function(self, font, height, flags)
self.label:SetFont(font, height, flags)
UpdateImageAnchor(self)
end,
 
["SetFontObject"] = function(self, font)
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-MultiLineEditBox.lua
1,4 → 1,4
local Type, Version = "MultiLineEditBox", 28
local Type, Version = "MultiLineEditBox", 29
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
233,7 → 233,7
end
Layout(self)
end,
 
 
["ClearFocus"] = function(self)
self.editBox:ClearFocus()
self.frame:SetScript("OnShow", nil)
253,12 → 253,12
["GetCursorPosition"] = function(self)
return self.editBox:GetCursorPosition()
end,
 
 
["SetCursorPosition"] = function(self, ...)
return self.editBox:SetCursorPosition(...)
end,
 
 
 
 
}
 
--[[-----------------------------------------------------------------------------
273,7 → 273,7
local function Constructor()
local frame = CreateFrame("Frame", nil, UIParent)
frame:Hide()
 
 
local widgetNum = AceGUI:GetNextWidgetNum(Type)
 
local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
290,14 → 290,14
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)
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)
339,8 → 339,8
editBox:SetScript("OnTextChanged", OnTextChanged)
editBox:SetScript("OnTextSet", OnTextSet)
editBox:SetScript("OnEditFocusGained", OnEditFocusGained)
 
 
 
scrollFrame:SetScrollChild(editBox)
 
local widget = {
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-TabGroup.lua
2,7 → 2,7
TabGroup Container
Container that uses tabs on top to switch between groups.
-------------------------------------------------------------------------------]]
local Type, Version = "TabGroup", 36
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
 
161,22 → 161,21
self.tablist = tabs
self:BuildTabs()
end,
 
 
 
["BuildTabs"] = function(self)
local hastitle = (self.titletext:GetText() and self.titletext:GetText() ~= "")
local status = self.status or self.localstatus
local tablist = self.tablist
local tabs = self.tabs
 
 
if not tablist then return end
 
 
local width = self.frame.width or self.frame:GetWidth() or 0
 
 
wipe(widths)
wipe(rowwidths)
wipe(rowends)
 
 
--Place Text into tabs and get thier initial width
for i, v in ipairs(tablist) do
local tab = tabs[i]
184,19 → 183,19
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
214,7 → 213,7
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
245,22 → 244,22
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,
-- 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,
286,7 → 285,7
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))
317,7 → 316,7
titletext:SetHeight(18)
titletext:SetText("")
 
local border = CreateFrame("Frame", nil, frame)
local border = CreateFrame("Frame", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
border:SetPoint("TOPLEFT", 1, -27)
border:SetPoint("BOTTOMRIGHT", -1, 3)
border:SetBackdrop(PaneBackdrop)
343,7 → 342,7
for method, func in pairs(methods) do
widget[method] = func
end
 
 
return AceGUI:RegisterAsContainer(widget)
end
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Slider.lua
2,7 → 2,7
Slider Widget
Graphical Slider, like, for Range values.
-------------------------------------------------------------------------------]]
local Type, Version = "Slider", 22
local Type, Version = "Slider", 23
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
57,10 → 57,9
AceGUI:ClearFocus()
end
 
local function Slider_OnValueChanged(frame)
local function Slider_OnValueChanged(frame, newvalue)
local self = frame.obj
if not frame.setup then
local newvalue = frame:GetValue()
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
106,7 → 105,7
else
value = tonumber(value)
end
 
 
if value then
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
self.slider:SetValue(value)
226,7 → 225,7
label:SetJustifyH("CENTER")
label:SetHeight(15)
 
local slider = CreateFrame("Slider", nil, frame)
local slider = CreateFrame("Slider", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
slider:SetOrientation("HORIZONTAL")
slider:SetHeight(15)
slider:SetHitRectInsets(0, 0, -10, 0)
248,7 → 247,7
local hightext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall")
hightext:SetPoint("TOPRIGHT", slider, "BOTTOMRIGHT", -2, 3)
 
local editbox = CreateFrame("EditBox", nil, frame)
local editbox = CreateFrame("EditBox", nil, frame, BackdropTemplateMixin and "BackdropTemplate" or nil)
editbox:SetAutoFocus(false)
editbox:SetFontObject(GameFontHighlightSmall)
editbox:SetPoint("TOP", slider, "BOTTOM")
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Keybinding.lua
2,7 → 2,7
Keybinding Widget
Set Keybindings in the Config UI.
-------------------------------------------------------------------------------]]
local Type, Version = "Keybinding", 25
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
 
214,7 → 214,7
label:SetJustifyH("CENTER")
label:SetHeight(18)
 
local msgframe = CreateFrame("Frame", nil, UIParent)
local msgframe = CreateFrame("Frame", nil, UIParent, BackdropTemplateMixin and "BackdropTemplate" or nil)
msgframe:SetHeight(30)
msgframe:SetBackdrop(ControlBackdrop)
msgframe:SetBackdropColor(0,0,0)
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-TabGroup.lua New file
0,0 → 1,365
local AceGUI = LibStub("AceGUI-3.0")
 
-------------
-- Widgets --
-------------
--[[
Widgets must provide the following functions
Acquire() - Called when the object is aquired, should set everything to a default hidden state
Release() - Called when the object is Released, should remove any anchors and hide the Widget
 
And the following members
frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes
type - the type of the object, same as the name given to :RegisterWidget()
 
Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet
It will be cleared automatically when a widget is released
Placing values directly into a widget object should be avoided
 
If the Widget can act as a container for other Widgets the following
content - frame or derivitive that children will be anchored to
 
The Widget can supply the following Optional Members
 
 
]]
 
--------------------------
-- Tab Group --
--------------------------
 
do
local Type = "TabGroup"
local Version = 20
 
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 OnAcquire(self)
 
end
 
local function OnRelease(self)
self.frame:ClearAllPoints()
self.frame:Hide()
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
 
local function Tab_SetText(self, text)
self:_SetText(text)
local width = self.obj.frame.width or self.obj.frame:GetWidth() or 0
PanelTemplates_TabResize(self, 0, nil, width)
end
 
local function UpdateTabLook(self)
if self.disabled then
PanelTemplates_SetDisabledTabState(self)
elseif self.selected then
PanelTemplates_SelectTab(self)
else
PanelTemplates_DeselectTab(self)
end
end
 
local function Tab_SetSelected(self, selected)
self.selected = selected
UpdateTabLook(self)
end
 
local function Tab_OnClick(self)
if not (self.selected or self.disabled) then
self.obj:SelectTab(self.value)
end
end
 
local function Tab_SetDisabled(self, disabled)
self.disabled = disabled
UpdateTabLook(self)
end
 
local function Tab_OnEnter(this)
local self = this.obj
self:Fire("OnTabEnter", self.tabs[this.id].value, this)
end
 
local function Tab_OnLeave(this)
local self = this.obj
self:Fire("OnTabLeave", self.tabs[this.id].value, this)
end
 
local function Tab_OnShow(this)
_G[this:GetName().."HighlightTexture"]:SetWidth(this:GetTextWidth() + 30)
end
 
local function CreateTab(self, id)
local tabname = "AceGUITabGroup"..self.num.."Tab"..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", tab, "LEFT", 14, -3)
tab.text:SetPoint("RIGHT", tab, "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
 
local function SetTitle(self, text)
self.titletext:SetText(text or "")
end
 
-- called to set an external table to store status in
local function SetStatusTable(self, status)
assert(type(status) == "table")
self.status = status
end
 
local function SelectTab(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
 
local function SetTabs(self, tabs)
self.tablist = tabs
self:BuildTabs()
end
 
 
local widths = {}
local rowwidths = {}
local rowends = {}
local function BuildTabs(self)
local status = self.status or self.localstatus
local tablist = self.tablist
local tabs = self.tabs
 
if not tablist then return end
 
local width = self.frame.width or self.frame:GetWidth() or 0
 
for i = #widths, 1, -1 do
widths[i] = nil
end
for i = #rowwidths, 1, -1 do
rowwidths[i] = nil
end
for i = #rowends, 1, -1 do
rowends[i] = nil
end
 
--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, -7-(row-1)*20 )
first = false
else
tab:SetPoint("LEFT", tabs[tabno-1], "RIGHT", -10, 0)
end
end
 
-- equal padding for each tab to fill the available width,
-- if the used space is above 75% already
local padding = 0
if not (numrows == 1 and rowwidths[1] < width*0.75) then
padding = (width - rowwidths[row]) / (endtab - starttab+1)
end
 
for i = starttab, endtab do
PanelTemplates_TabResize(tabs[i], padding + 4, nil, width)
end
starttab = endtab + 1
end
 
self.borderoffset = 10+((numrows)*20)
self.border:SetPoint("TOPLEFT",self.frame,"TOPLEFT",3,-self.borderoffset)
end
 
local function BuildTabsOnUpdate(this)
BuildTabs(this.obj)
this:SetScript("OnUpdate", nil)
end
 
local function OnWidthSet(self, width)
local content = self.content
local contentwidth = width - 60
if contentwidth < 0 then
contentwidth = 0
end
content:SetWidth(contentwidth)
content.width = contentwidth
BuildTabs(self)
self.frame:SetScript("OnUpdate", BuildTabsOnUpdate)
end
 
 
local function OnHeightSet(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
 
local function LayoutFinished(self, width, height)
if self.noAutoHeight then return end
self:SetHeight((height or 0) + (self.borderoffset + 23))
end
 
local function Constructor()
local frame = CreateFrame("Frame",nil,UIParent)
local self = {}
self.type = Type
 
self.num = AceGUI:GetNextWidgetNum(Type)
 
self.localstatus = {}
 
self.OnRelease = OnRelease
self.OnAcquire = OnAcquire
self.SetTitle = SetTitle
self.CreateTab = CreateTab
self.SelectTab = SelectTab
self.BuildTabs = BuildTabs
self.SetStatusTable = SetStatusTable
self.SetTabs = SetTabs
self.LayoutFinished = LayoutFinished
self.frame = frame
 
self.OnWidthSet = OnWidthSet
self.OnHeightSet = OnHeightSet
 
frame.obj = self
 
frame:SetHeight(100)
frame:SetWidth(100)
frame:SetFrameStrata("FULLSCREEN_DIALOG")
 
local titletext = frame:CreateFontString(nil,"OVERLAY","GameFontNormal")
titletext:SetPoint("TOPLEFT",frame,"TOPLEFT",14,0)
titletext:SetPoint("TOPRIGHT",frame,"TOPRIGHT",-14,0)
titletext:SetJustifyH("LEFT")
titletext:SetHeight(18)
 
self.titletext = titletext
 
local border = CreateFrame("Frame",nil,frame)
self.border = border
self.borderoffset = 27
border:SetPoint("TOPLEFT",frame,"TOPLEFT",3,-27)
border:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-3,3)
 
border:SetBackdrop(PaneBackdrop)
border:SetBackdropColor(0.1,0.1,0.1,0.5)
border:SetBackdropBorderColor(0.4,0.4,0.4)
 
self.tabs = {}
 
--Container Support
local content = CreateFrame("Frame",nil,border)
self.content = content
content.obj = self
content:SetPoint("TOPLEFT",border,"TOPLEFT",10,-10)
content:SetPoint("BOTTOMRIGHT",border,"BOTTOMRIGHT",-10,10)
 
AceGUI:RegisterAsContainer(self)
return self
end
 
AceGUI:RegisterWidgetType(Type,Constructor,Version)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-CheckBox.lua
1,7 → 1,7
--[[-----------------------------------------------------------------------------
Checkbox Widget
-------------------------------------------------------------------------------]]
local Type, Version = "CheckBox", 25
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
 
91,7 → 91,7
if self.desc then
self.desc:SetWidth(width - 30)
if self.desc:GetText() and self.desc:GetText() ~= "" then
self:SetHeight(28 + self.desc:GetHeight())
self:SetHeight(28 + self.desc:GetStringHeight())
end
end
end,
119,20 → 119,20
end
end,
 
["SetValue"] = function(self,value)
["SetValue"] = function(self, value)
local check = self.check
self.checked = value
if value then
SetDesaturation(self.check, false)
self.check:Show()
SetDesaturation(check, false)
check:Show()
else
--Nil is the unknown tristate value
if self.tristate and value == nil then
SetDesaturation(self.check, true)
self.check:Show()
SetDesaturation(check, true)
check:Show()
else
SetDesaturation(self.check, false)
self.check:Hide()
SetDesaturation(check, false)
check:Hide()
end
end
self:SetDisabled(self.disabled)
155,21 → 155,21
local size
if type == "radio" then
size = 16
checkbg:SetTexture("Interface\\Buttons\\UI-RadioButton")
checkbg:SetTexture(130843) -- Interface\\Buttons\\UI-RadioButton
checkbg:SetTexCoord(0, 0.25, 0, 1)
check:SetTexture("Interface\\Buttons\\UI-RadioButton")
check:SetTexture(130843) -- Interface\\Buttons\\UI-RadioButton
check:SetTexCoord(0.25, 0.5, 0, 1)
check:SetBlendMode("ADD")
highlight:SetTexture("Interface\\Buttons\\UI-RadioButton")
highlight:SetTexture(130843) -- Interface\\Buttons\\UI-RadioButton
highlight:SetTexCoord(0.5, 0.75, 0, 1)
else
size = 24
checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up")
checkbg:SetTexture(130755) -- Interface\\Buttons\\UI-CheckBox-Up
checkbg:SetTexCoord(0, 1, 0, 1)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:SetTexture(130751) -- Interface\\Buttons\\UI-CheckBox-Check
check:SetTexCoord(0, 1, 0, 1)
check:SetBlendMode("BLEND")
highlight:SetTexture("Interface\\Buttons\\UI-CheckBox-Highlight")
highlight:SetTexture(130753) -- Interface\\Buttons\\UI-CheckBox-Highlight
highlight:SetTexCoord(0, 1, 0, 1)
end
checkbg:SetHeight(size)
211,7 → 211,7
self.desc:Show()
--self.text:SetFontObject(GameFontNormal)
self.desc:SetText(desc)
self:SetHeight(28 + self.desc:GetHeight())
self:SetHeight(28 + self.desc:GetStringHeight())
else
if self.desc then
self.desc:SetText("")
221,11 → 221,11
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
255,11 → 255,11
checkbg:SetWidth(24)
checkbg:SetHeight(24)
checkbg:SetPoint("TOPLEFT")
checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up")
checkbg:SetTexture(130755) -- Interface\\Buttons\\UI-CheckBox-Up
 
local check = frame:CreateTexture(nil, "OVERLAY")
check:SetAllPoints(checkbg)
check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
check:SetTexture(130751) -- Interface\\Buttons\\UI-CheckBox-Check
 
local text = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight")
text:SetJustifyH("LEFT")
268,7 → 268,7
text:SetPoint("RIGHT")
 
local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
highlight:SetTexture("Interface\\Buttons\\UI-CheckBox-Highlight")
highlight:SetTexture(130753) -- Interface\\Buttons\\UI-CheckBox-Highlight
highlight:SetBlendMode("ADD")
highlight:SetAllPoints(checkbg)
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Icon.lua
56,7 → 56,7
["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
118,7 → 118,7
 
local highlight = frame:CreateTexture(nil, "HIGHLIGHT")
highlight:SetAllPoints(image)
highlight:SetTexture("Interface\\PaperDollInfoFrame\\UI-Character-Tab-Highlight")
highlight:SetTexture(136580) -- Interface\\PaperDollInfoFrame\\UI-Character-Tab-Highlight
highlight:SetTexCoord(0, 1, 0.23, 0.77)
highlight:SetBlendMode("ADD")
 
trunk/Libs/LibSharedMedia-3.0/LibSharedMedia-3.0.lua
1,6 → 1,6
--[[
Name: LibSharedMedia-3.0
Revision: $Revision: 91 $
Revision: $Revision: 114 $
Author: Elkano (elkano@gmx.de)
Inspired By: SurfaceLib by Haste/Otravi (troeks@gmail.com)
Website: http://www.wowace.com/projects/libsharedmedia-3-0/
9,7 → 9,7
License: LGPL v2.1
]]
 
local MAJOR, MINOR = "LibSharedMedia-3.0", 6010002 -- 6.1.0 v2 / increase manually on changes
local MAJOR, MINOR = "LibSharedMedia-3.0", 8020003 -- 8.2.0 v3 / increase manually on changes
local lib = LibStub:NewLibrary(MAJOR, MINOR)
 
if not lib then return end
20,10 → 20,10
local type = _G.type
 
local band = _G.bit.band
 
local table_insert = _G.table.insert
local table_sort = _G.table.sort
 
local RESTRICTED_FILE_ACCESS = WOW_PROJECT_ID == WOW_PROJECT_MAINLINE -- starting with 8.2, some rules for file access have changed; classic still uses the old way
 
local locale = GetLocale()
local locale_is_western
local LOCALE_MASK = 0
193,11 → 193,12
lib.MediaTable.statusbar["Blizzard"] = [[Interface\TargetingFrame\UI-StatusBar]]
lib.MediaTable.statusbar["Blizzard Character Skills Bar"] = [[Interface\PaperDollInfoFrame\UI-Character-Skills-Bar]]
lib.MediaTable.statusbar["Blizzard Raid Bar"] = [[Interface\RaidFrame\Raid-Bar-Hp-Fill]]
lib.MediaTable.statusbar["Solid"] = [[Interface\Buttons\WHITE8X8]]
lib.DefaultMedia.statusbar = "Blizzard"
 
-- SOUND
if not lib.MediaTable.sound then lib.MediaTable.sound = {} end
lib.MediaTable.sound["None"] = [[Interface\Quiet.ogg]] -- Relies on the fact that PlaySound[File] doesn't error on non-existing input.
lib.MediaTable.sound["None"] = RESTRICTED_FILE_ACCESS and 1 or [[Interface\Quiet.ogg]] -- Relies on the fact that PlaySound[File] doesn't error on these values.
lib.DefaultMedia.sound = "None"
 
local function rebuildMediaList(mediatype)
222,18 → 223,25
error(MAJOR..":Register(mediatype, key, data, langmask) - key must be string, got "..type(key))
end
mediatype = mediatype:lower()
if mediatype == lib.MediaType.FONT and ((langmask and band(langmask, LOCALE_MASK) == 0) or not (langmask or locale_is_western)) then return false end
if mediatype == lib.MediaType.SOUND and type(data) == "string" then
if mediatype == lib.MediaType.FONT and ((langmask and band(langmask, LOCALE_MASK) == 0) or not (langmask or locale_is_western)) then
-- ignore fonts that aren't flagged as supporting local glyphs on non-western clients
return false
end
if type(data) == "string" and (mediatype == lib.MediaType.BACKGROUND or mediatype == lib.MediaType.BORDER or mediatype == lib.MediaType.STATUSBAR or mediatype == lib.MediaType.SOUND) then
local path = data:lower()
-- Only ogg and mp3 are valid sounds.
if not path:find(".ogg", nil, true) and not path:find(".mp3", nil, true) then
if RESTRICTED_FILE_ACCESS and not path:find("^interface") then
-- files accessed via path only allowed from interface folder
return false
end
if mediatype == lib.MediaType.SOUND and not (path:find(".ogg", nil, true) or path:find(".mp3", nil, true)) then
-- Only ogg and mp3 are valid sounds.
return false
end
end
if not mediaTable[mediatype] then mediaTable[mediatype] = {} end
local mtable = mediaTable[mediatype]
if mtable[key] then return false end
 
 
mtable[key] = data
rebuildMediaList(mediatype)
self.callbacks:Fire("LibSharedMedia_Registered", mediatype, key)
trunk/Libs/LibSharedMedia-3.0/lib.xml
1,4 → 1,4
<Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/
..\FrameXML\UI.xsd">
<Script file="LibSharedMedia-3.0.lua" />
</Ui>
</Ui>
\ No newline at end of file
trunk/Libs/AceAddon-3.0/AceAddon-3.0.lua
6,31 → 6,31
-- * **OnEnable** which gets called during the PLAYER_LOGIN event, when most of the data provided by the game is already present.
-- * **OnDisable**, which is only called when your addon is manually being disabled.
-- @usage
-- -- A small (but complete) addon, that doesn't do anything,
-- -- A small (but complete) addon, that doesn't do anything,
-- -- but shows usage of the callbacks.
-- local MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
--
--
-- function MyAddon:OnInitialize()
-- -- do init tasks here, like loading the Saved Variables,
-- -- do init tasks here, like loading the Saved Variables,
-- -- or setting up slash commands.
-- end
--
--
-- function MyAddon:OnEnable()
-- -- Do more initialization here, that really enables the use of your addon.
-- -- Register Events, Hook functions, Create Frames, Get information from
-- -- Register Events, Hook functions, Create Frames, Get information from
-- -- the game that wasn't available in OnInitialize
-- end
--
-- function MyAddon:OnDisable()
-- -- Unhook, Unregister Events, Hide frames that you created.
-- -- You would probably only use an OnDisable if you want to
-- -- You would probably only use an OnDisable if you want to
-- -- build a "standby" mode, or be able to toggle modules on/off.
-- end
-- @class file
-- @name AceAddon-3.0.lua
-- @release $Id: AceAddon-3.0.lua 1184 2018-07-21 14:13:14Z nevcairiel $
-- @release $Id: AceAddon-3.0.lua 1238 2020-08-28 16:18:42Z nevcairiel $
 
local MAJOR, MINOR = "AceAddon-3.0", 12
local MAJOR, MINOR = "AceAddon-3.0", 13
local AceAddon, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
 
if not AceAddon then return end -- No Upgrade needed.
75,7 → 75,7
local Enable, Disable, EnableModule, DisableModule, Embed, NewModule, GetModule, GetName, SetDefaultModuleState, SetDefaultModuleLibraries, SetEnabledState, SetDefaultModulePrototype
 
-- used in the addon metatable
local function addontostring( self ) return self.name end
local function addontostring( self ) return self.name end
 
-- Check if the addon is queued for initialization
local function queuedForInitialization(addon)
88,14 → 88,14
end
 
--- Create a new AceAddon-3.0 addon.
-- Any libraries you specified will be embeded, and the addon will be scheduled for
-- Any libraries you specified will be embeded, and the addon will be scheduled for
-- its OnInitialize and OnEnable callbacks.
-- The final addon object, with all libraries embeded, will be returned.
-- @paramsig [object ,]name[, lib, ...]
-- @param object Table to use as a base for the addon (optional)
-- @param name Name of the addon object to create
-- @param lib List of libraries to embed into the addon
-- @usage
-- @usage
-- -- Create a simple addon object
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceEvent-3.0")
--
115,10 → 115,10
if type(name)~="string" then
error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2)
end
if self.addons[name] then
if self.addons[name] then
error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - Addon '%s' already exists."):format(name), 2)
end
 
 
object = object or {}
object.name = name
 
128,7 → 128,7
for k, v in pairs(oldmeta) do addonmeta[k] = v end
end
addonmeta.__tostring = addontostring
 
 
setmetatable( object, addonmeta )
self.addons[name] = object
object.modules = {}
136,7 → 136,7
object.defaultModuleLibraries = {}
Embed( object ) -- embed NewModule, GetModule methods
self:EmbedLibraries(object, select(i,...))
 
 
-- add to queue of addons to be initialized upon ADDON_LOADED
tinsert(self.initializequeue, object)
return object
147,7 → 147,7
-- Throws an error if the addon object cannot be found (except if silent is set).
-- @param name unique name of the addon object
-- @param silent if true, the addon is optional, silently return nil if its not found
-- @usage
-- @usage
-- -- Get the Addon
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
function AceAddon:GetAddon(name, silent)
202,7 → 202,7
-- @paramsig name[, silent]
-- @param name unique name of the module
-- @param silent if true, the module is optional, silently return nil if its not found (optional)
-- @usage
-- @usage
-- -- Get the Addon
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- -- Get the Module
225,23 → 225,23
-- @param name unique name of the module
-- @param prototype object to derive this module from, methods and values from this table will be mixed into the module (optional)
-- @param lib List of libraries to embed into the addon
-- @usage
-- @usage
-- -- Create a module with some embeded libraries
-- MyModule = MyAddon:NewModule("MyModule", "AceEvent-3.0", "AceHook-3.0")
--
--
-- -- Create a module with a prototype
-- local prototype = { OnEnable = function(self) print("OnEnable called!") end }
-- MyModule = MyAddon:NewModule("MyModule", prototype, "AceEvent-3.0", "AceHook-3.0")
function NewModule(self, name, prototype, ...)
if type(name) ~= "string" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) end
if type(prototype) ~= "string" and type(prototype) ~= "table" and type(prototype) ~= "nil" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'prototype' - table (prototype), string (lib) or nil expected got '%s'."):format(type(prototype)), 2) end
 
 
if self.modules[name] then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - Module '%s' already exists."):format(name), 2) end
 
 
-- modules are basically addons. We treat them as such. They will be added to the initializequeue properly as well.
-- NewModule can only be called after the parent addon is present thus the modules will be initialized after their parent is.
local module = AceAddon:NewAddon(fmt("%s_%s", self.name or tostring(self), name))
 
 
module.IsModule = IsModuleTrue
module:SetEnabledState(self.defaultModuleState)
module.moduleName = name
256,24 → 256,24
if not prototype or type(prototype) == "string" then
prototype = self.defaultModulePrototype or nil
end
 
 
if type(prototype) == "table" then
local mt = getmetatable(module)
mt.__index = prototype
setmetatable(module, mt) -- More of a Base class type feel.
end
 
 
safecall(self.OnModuleCreated, self, module) -- Was in Ace2 and I think it could be a cool thing to have handy.
self.modules[name] = module
tinsert(self.orderedModules, module)
 
 
return module
end
 
--- Returns the real name of the addon or module, without any prefix.
-- @name //addon//:GetName
-- @paramsig
-- @usage
-- @paramsig
-- @usage
-- print(MyAddon:GetName())
-- -- prints "MyAddon"
function GetName(self)
285,8 → 285,8
-- and enabling all modules of the addon (unless explicitly disabled).\\
-- :Enable() also sets the internal `enableState` variable to true
-- @name //addon//:Enable
-- @paramsig
-- @usage
-- @paramsig
-- @usage
-- -- Enable MyModule
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyModule = MyAddon:GetModule("MyModule")
306,8 → 306,8
-- and disabling all modules of the addon.\\
-- :Disable() also sets the internal `enableState` variable to false
-- @name //addon//:Disable
-- @paramsig
-- @usage
-- @paramsig
-- @usage
-- -- Disable MyAddon
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyAddon:Disable()
320,7 → 320,7
-- Short-hand function that retrieves the module via `:GetModule` and calls `:Enable` on the module object.
-- @name //addon//:EnableModule
-- @paramsig name
-- @usage
-- @usage
-- -- Enable MyModule using :GetModule
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyModule = MyAddon:GetModule("MyModule")
338,7 → 338,7
-- Short-hand function that retrieves the module via `:GetModule` and calls `:Disable` on the module object.
-- @name //addon//:DisableModule
-- @paramsig name
-- @usage
-- @usage
-- -- Disable MyModule using :GetModule
-- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon")
-- MyModule = MyAddon:GetModule("MyModule")
357,7 → 357,7
-- @name //addon//:SetDefaultModuleLibraries
-- @paramsig lib[, lib, ...]
-- @param lib List of libraries to embed into the addon
-- @usage
-- @usage
-- -- Create the addon object
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
-- -- Configure default libraries for modules (all modules need AceEvent-3.0)
376,7 → 376,7
-- @name //addon//:SetDefaultModuleState
-- @paramsig state
-- @param state Default state for new modules, true for enabled, false for disabled
-- @usage
-- @usage
-- -- Create the addon object
-- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon")
-- -- Set the default state to "disabled"
396,7 → 396,7
-- @name //addon//:SetDefaultModulePrototype
-- @paramsig prototype
-- @param prototype Default prototype for the new modules (table)
-- @usage
-- @usage
-- -- Define a prototype
-- local prototype = { OnEnable = function(self) print("OnEnable called!") end }
-- -- Set the default prototype
428,8 → 428,8
 
--- Return an iterator of all modules associated to the addon.
-- @name //addon//:IterateModules
-- @paramsig
-- @usage
-- @paramsig
-- @usage
-- -- Enable all modules
-- for name, module in MyAddon:IterateModules() do
-- module:Enable()
438,13 → 438,13
 
-- Returns an iterator of all embeds in the addon
-- @name //addon//:IterateEmbeds
-- @paramsig
-- @paramsig
local function IterateEmbeds(self) return pairs(AceAddon.embeds[self]) end
 
--- Query the enabledState of an addon.
-- @name //addon//:IsEnabled
-- @paramsig
-- @usage
-- @paramsig
-- @usage
-- if MyAddon:IsEnabled() then
-- MyAddon:Disable()
-- end
489,20 → 489,20
 
-- - Initialize the addon after creation.
-- This function is only used internally during the ADDON_LOADED event
-- It will call the **OnInitialize** function on the addon object (if present),
-- It will call the **OnInitialize** function on the addon object (if present),
-- and the **OnEmbedInitialize** function on all embeded libraries.
--
--
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
-- @param addon addon object to intialize
function AceAddon:InitializeAddon(addon)
safecall(addon.OnInitialize, addon)
 
 
local embeds = self.embeds[addon]
for i = 1, #embeds do
local lib = LibStub:GetLibrary(embeds[i], true)
if lib then safecall(lib.OnEmbedInitialize, lib, addon) end
end
 
 
-- we don't call InitializeAddon on modules specifically, this is handled
-- from the event handler and only done _once_
end
510,7 → 510,7
-- - Enable the addon after creation.
-- Note: This function is only used internally during the PLAYER_LOGIN event, or during ADDON_LOADED,
-- if IsLoggedIn() already returns true at that point, e.g. for LoD Addons.
-- It will call the **OnEnable** function on the addon object (if present),
-- It will call the **OnEnable** function on the addon object (if present),
-- and the **OnEmbedEnable** function on all embeded libraries.\\
-- This function does not toggle the enable state of the addon itself, and will return early if the addon is disabled.
--
520,12 → 520,12
function AceAddon:EnableAddon(addon)
if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
if self.statuses[addon.name] or not addon.enabledState then return false end
 
 
-- set the statuses first, before calling the OnEnable. this allows for Disabling of the addon in OnEnable.
self.statuses[addon.name] = true
 
 
safecall(addon.OnEnable, addon)
 
 
-- make sure we're still enabled before continueing
if self.statuses[addon.name] then
local embeds = self.embeds[addon]
533,7 → 533,7
local lib = LibStub:GetLibrary(embeds[i], true)
if lib then safecall(lib.OnEmbedEnable, lib, addon) end
end
 
 
-- enable possible modules.
local modules = addon.orderedModules
for i = 1, #modules do
545,24 → 545,24
 
-- - Disable the addon
-- Note: This function is only used internally.
-- It will call the **OnDisable** function on the addon object (if present),
-- It will call the **OnDisable** function on the addon object (if present),
-- and the **OnEmbedDisable** function on all embeded libraries.\\
-- This function does not toggle the enable state of the addon itself, and will return early if the addon is still enabled.
--
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
-- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing.
-- Use :Disable on the addon itself instead.
-- @param addon addon object to enable
function AceAddon:DisableAddon(addon)
if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end
if not self.statuses[addon.name] then return false end
 
 
-- set statuses first before calling OnDisable, this allows for aborting the disable in OnDisable.
self.statuses[addon.name] = false
 
 
safecall( addon.OnDisable, addon )
 
 
-- make sure we're still disabling...
if not self.statuses[addon.name] then
if not self.statuses[addon.name] then
local embeds = self.embeds[addon]
for i = 1, #embeds do
local lib = LibStub:GetLibrary(embeds[i], true)
574,12 → 574,12
self:DisableAddon(modules[i])
end
end
 
 
return not self.statuses[addon.name] -- return true if we're disabled
end
 
--- Get an iterator over all registered addons.
-- @usage
-- @usage
-- -- Print a list of all installed AceAddon's
-- for name, addon in AceAddon:IterateAddons() do
-- print("Addon: " .. name)
587,7 → 587,7
function AceAddon:IterateAddons() return pairs(self.addons) end
 
--- Get an iterator over the internal status registry.
-- @usage
-- @usage
-- -- Print a list of all enabled addons
-- for name, status in AceAddon:IterateAddonStatus() do
-- if status then
601,10 → 601,20
function AceAddon:IterateEmbedsOnAddon(addon) return pairs(self.embeds[addon]) end
function AceAddon:IterateModulesOfAddon(addon) return pairs(addon.modules) end
 
-- Blizzard AddOns which can load very early in the loading process and mess with Ace3 addon loading
local BlizzardEarlyLoadAddons = {
Blizzard_DebugTools = true,
Blizzard_TimeManager = true,
Blizzard_BattlefieldMap = true,
Blizzard_MapCanvas = true,
Blizzard_SharedMapDataProviders = true,
Blizzard_CombatLog = true,
}
 
-- Event Handling
local function onEvent(this, event, arg1)
-- 2011-08-17 nevcairiel - ignore the load event of Blizzard_DebugTools, so a potential startup error isn't swallowed up
if (event == "ADDON_LOADED" and arg1 ~= "Blizzard_DebugTools") or event == "PLAYER_LOGIN" then
-- 2020-08-28 nevcairiel - ignore the load event of Blizzard addons which occur early in the loading process
if (event == "ADDON_LOADED" and (arg1 == nil or not BlizzardEarlyLoadAddons[arg1])) or event == "PLAYER_LOGIN" then
-- if a addon loads another addon, recursion could happen here, so we need to validate the table on every iteration
while(#AceAddon.initializequeue > 0) do
local addon = tremove(AceAddon.initializequeue, 1)
613,7 → 623,7
AceAddon:InitializeAddon(addon)
tinsert(AceAddon.enablequeue, addon)
end
 
 
if IsLoggedIn() then
while(#AceAddon.enablequeue > 0) do
local addon = tremove(AceAddon.enablequeue, 1)
trunk/Libs/AceConfig-3.0/AceConfigRegistry-3.0/AceConfigRegistry-3.0.lua
4,14 → 4,14
-- * Valid **uiTypes**: "cmd", "dropdown", "dialog". This is verified by the library at call time. \\
-- * The **uiName** field is expected to contain the full name of the calling addon, including version, e.g. "FooBar-1.0". This is verified by the library at call time.\\
-- * The **appName** field is the options table name as given at registration time \\
--
--
-- :IterateOptionsTables() (and :GetOptionsTable() if only given one argument) return a function reference that the requesting config handling addon must call with valid "uiType", "uiName".
-- @class file
-- @name AceConfigRegistry-3.0
-- @release $Id: AceConfigRegistry-3.0.lua 1169 2018-02-27 16:18:28Z nevcairiel $
-- @release $Id: AceConfigRegistry-3.0.lua 1207 2019-06-23 12:08:33Z nevcairiel $
local CallbackHandler = LibStub("CallbackHandler-1.0")
 
local MAJOR, MINOR = "AceConfigRegistry-3.0", 18
local MAJOR, MINOR = "AceConfigRegistry-3.0", 20
local AceConfigRegistry = LibStub:NewLibrary(MAJOR, MINOR)
 
if not AceConfigRegistry then return end
33,7 → 33,7
 
 
AceConfigRegistry.validated = {
-- list of options table names ran through :ValidateOptionsTable automatically.
-- list of options table names ran through :ValidateOptionsTable automatically.
-- CLEARED ON PURPOSE, since newer versions may have newer validators
cmd = {},
dropdown = {},
59,7 → 59,6
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 optmethod={["nil"]=true,["string"]=true,["function"]=true, _="methodname or funcref"}
local optmethodfalse={["nil"]=true,["string"]=true,["function"]=true,["boolean"]={[false]=true}, _="methodname, funcref or false"}
local optmethodnumber={["nil"]=true,["string"]=true,["function"]=true,["number"]=true, _="methodname, funcref or number"}
local optmethodtable={["nil"]=true,["string"]=true,["function"]=true,["table"]=true, _="methodname, funcref or table"}
95,13 → 94,20
}
 
local typedkeys={
header={},
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,
118,6 → 124,9
imageCoords=optmethodtable,
imageHeight=optnumber,
imageWidth=optnumber,
control=optstring,
dialogControl=optstring,
dropdownControl=optstring,
},
input={
pattern=optstring,
131,6 → 140,9
tristate=optbool,
image=optstringnumberfunc,
imageCoords=optmethodtable,
control=optstring,
dialogControl=optstring,
dropdownControl=optstring,
},
tristate={
},
142,12 → 154,16
step=optnumber,
bigStep=optnumber,
isPercent=optbool,
control=optstring,
dialogControl=optstring,
dropdownControl=optstring,
},
select={
values=ismethodtable,
sorting=optmethodtable,
style={
["nil"]=true,
["string"]={dropdown=true,radio=true},
["nil"]=true,
["string"]={dropdown=true,radio=true},
_="string: 'dropdown' or 'radio'"
},
control=optstring,
165,9 → 181,14
},
color={
hasAlpha=optmethodbool,
control=optstring,
dialogControl=optstring,
dropdownControl=optstring,
},
keybinding={
-- TODO
control=optstring,
dialogControl=optstring,
dropdownControl=optstring,
},
}
 
204,13 → 225,13
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
303,7 → 324,7
AceConfigRegistry:ValidateOptionsTable(options, appName, errlvl) -- upgradable
AceConfigRegistry.validated[uiType][appName] = true
end
return options
return options
end
elseif type(options)=="function" then
AceConfigRegistry.tables[appName] = function(uiType, uiName, errlvl)
341,7 → 362,7
if not f then
return nil
end
 
 
if uiType then
return f(uiType,uiName,1) -- get the table for us
else
trunk/Libs/AceConfig-3.0/AceConfig-3.0.lua
3,7 → 3,7
-- as well as associate it with a slash command.
-- @class file
-- @name AceConfig-3.0
-- @release $Id: AceConfig-3.0.lua 1161 2017-08-12 14:30:16Z funkydude $
-- @release $Id: AceConfig-3.0.lua 1202 2019-05-15 23:11:22Z nevcairiel $
 
--[[
AceConfig-3.0
45,7 → 45,7
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
trunk/Libs/AceConfig-3.0/AceConfigDialog-3.0/AceConfigDialog-3.0.lua
1,13 → 1,13
--- AceConfigDialog-3.0 generates AceGUI-3.0 based windows based on option tables.
-- @class file
-- @name AceConfigDialog-3.0
-- @release $Id: AceConfigDialog-3.0.lua 1184 2018-07-21 14:13:14Z nevcairiel $
-- @release $Id: AceConfigDialog-3.0.lua 1232 2020-04-14 22:21:22Z nevcairiel $
 
local LibStub = LibStub
local gui = LibStub("AceGUI-3.0")
local reg = LibStub("AceConfigRegistry-3.0")
 
local MAJOR, MINOR = "AceConfigDialog-3.0", 66
local MAJOR, MINOR = "AceConfigDialog-3.0", 79
local AceConfigDialog, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
 
if not AceConfigDialog then return end
15,22 → 15,23
AceConfigDialog.OpenFrames = AceConfigDialog.OpenFrames or {}
AceConfigDialog.Status = AceConfigDialog.Status or {}
AceConfigDialog.frame = AceConfigDialog.frame or CreateFrame("Frame")
AceConfigDialog.tooltip = AceConfigDialog.tooltip or CreateFrame("GameTooltip", "AceConfigDialogTooltip", UIParent, "GameTooltipTemplate")
 
AceConfigDialog.frame.apps = AceConfigDialog.frame.apps or {}
AceConfigDialog.frame.closing = AceConfigDialog.frame.closing or {}
AceConfigDialog.frame.closeAllOverride = AceConfigDialog.frame.closeAllOverride or {}
 
-- Lua APIs
local tconcat, tinsert, tsort, tremove, tsort = table.concat, table.insert, table.sort, table.remove, table.sort
local tinsert, tsort, tremove = table.insert, table.sort, table.remove
local strmatch, format = string.match, string.format
local assert, loadstring, error = assert, loadstring, error
local error = error
local pairs, next, select, type, unpack, wipe, ipairs = pairs, next, select, type, unpack, wipe, ipairs
local rawset, tostring, tonumber = rawset, tostring, tonumber
local tostring, tonumber = tostring, tonumber
local math_min, math_max, math_floor = math.min, math.max, math.floor
 
-- Global vars/functions that we don't upvalue since they might get hooked, or upgraded
-- List them here for Mikk's FindGlobals script
-- GLOBALS: NORMAL_FONT_COLOR, GameTooltip, StaticPopupDialogs, ACCEPT, CANCEL, StaticPopup_Show
-- GLOBALS: NORMAL_FONT_COLOR, ACCEPT, CANCEL
-- GLOBALS: PlaySound, GameFontHighlight, GameFontHighlightSmall, GameFontHighlightLarge
-- GLOBALS: CloseSpecialWindows, InterfaceOptions_AddCategory, geterrorhandler
 
56,18 → 57,18
--[[
Group Types
Tree - All Descendant Groups will all become nodes on the tree, direct child options will appear above the tree
- Descendant Groups with inline=true and thier children will not become nodes
- Descendant Groups with inline=true and thier children will not become nodes
 
Tab - Direct Child Groups will become tabs, direct child options will appear above the tab control
- Grandchild groups will default to inline unless specified otherwise
- Grandchild groups will default to inline unless specified otherwise
 
Select- Same as Tab but with entries in a dropdown rather than tabs
 
 
Inline Groups
- Will not become nodes of a select group, they will be effectivly part of thier parent group seperated by a border
- If declared on a direct child of a root node of a select group, they will appear above the group container control
- When a group is displayed inline, all descendants will also be inline members of the group
- Will not become nodes of a select group, they will be effectivly part of thier parent group seperated by a border
- If declared on a direct child of a root node of a select group, they will appear above the group container control
- When a group is displayed inline, all descendants will also be inline members of the group
 
]]
 
168,11 → 169,11
local function GetOptionsMemberValue(membername, option, options, path, appName, ...)
--get definition for the member
local inherits = isInherited[membername]
 
 
 
--get the member of the option, traversing the tree if it can be inherited
local member
 
 
if inherits then
local group = options
if group[membername] ~= nil then
187,7 → 188,7
else
member = option[membername]
end
 
 
--check if we need to call a functon, or if we have a literal value
if ( not allIsLiteral[membername] ) and ( type(member) == "function" or ((not stringIsLiteral[membername]) and type(member) == "string") ) then
--We have a function to call
196,13 → 197,13
local handler
local group = options
handler = group.handler or handler
 
 
for i = 1, #path do
group = GetSubOption(group, path[i])
info[i] = path[i]
handler = group.handler or handler
end
 
 
info.options = options
info.appName = appName
info[0] = appName
212,8 → 213,8
info.type = option.type
info.uiType = "dialog"
info.uiName = MAJOR
 
local a, b, c ,d
 
local a, b, c ,d
--using 4 returns for the get of a color type, increase if a type needs more
if type(member) == "function" then
--Call the function
230,8 → 231,8
return a,b,c,d
else
--The value isnt a function to call, return it
return member
end
return member
end
end
 
--[[calls an options function that could be inherited, method name or function ref
296,7 → 297,7
return NameA:upper() < NameB:upper()
end
if OrderA < 0 then
if OrderB > 0 then
if OrderB >= 0 then
return false
end
else
315,7 → 316,7
local function BuildSortedOptionsTable(group, keySort, opts, options, path, appName)
tempOrders = new()
tempNames = new()
 
 
if group.plugins then
for plugin, t in pairs(group.plugins) do
for k, v in pairs(t) do
331,7 → 332,7
end
end
end
 
 
for k, v in pairs(group.args) do
if not opts[k] then
tinsert(keySort, k)
362,7 → 363,7
end
 
local function CleanUserData(widget, event)
 
 
local user = widget:GetUserDataTable()
 
if user.path then
402,7 → 403,7
-- - Gets a status table for the given appname and options path.
-- @param appName The application name as given to `:RegisterOptionsTable()`
-- @param path The path to the options (a table with all group keys)
-- @return
-- @return
function AceConfigDialog:GetStatusTable(appName, path)
local status = self.Status
 
436,7 → 437,7
function AceConfigDialog:SelectGroup(appName, ...)
local path = new()
 
 
 
local app = reg:GetOptionsTable(appName)
if not app then
error(("%s isn't registed with AceConfigRegistry, unable to open config"):format(appName), 2)
448,9 → 449,9
status.groups = {}
end
status = status.groups
local treevalue
local treestatus
 
local treevalue
local treestatus
 
for n = 1, select("#",...) do
local key = select(n, ...)
 
477,12 → 478,12
--the selected group will be overwritten if a child is the final target but still needs to be open
treestatus.selected = treevalue
treestatus.groups[treevalue] = true
 
 
end
 
 
--move to the next group in the path
group = GetSubOption(group, key)
if not group then
if not group then
break
end
tinsert(path, key)
492,10 → 493,10
end
status = status.groups
end
 
 
del(path)
reg:NotifyChange(appName)
end
end
 
local function OptionOnMouseOver(widget, event)
--show a tooltip/set the status bar to the desc text
504,32 → 505,33
local options = user.options
local path = user.path
local appName = user.appName
local tooltip = AceConfigDialog.tooltip
 
GameTooltip:SetOwner(widget.frame, "ANCHOR_TOPRIGHT")
tooltip:SetOwner(widget.frame, "ANCHOR_TOPRIGHT")
local name = GetOptionsMemberValue("name", opt, options, path, appName)
local desc = GetOptionsMemberValue("desc", opt, options, path, appName)
local usage = GetOptionsMemberValue("usage", opt, options, path, appName)
local descStyle = opt.descStyle
 
 
if descStyle and descStyle ~= "tooltip" then return end
 
GameTooltip:SetText(name, 1, .82, 0, true)
 
 
tooltip:SetText(name, 1, .82, 0, true)
 
if opt.type == "multiselect" then
GameTooltip:AddLine(user.text, 0.5, 0.5, 0.8, true)
end
tooltip:AddLine(user.text, 0.5, 0.5, 0.8, true)
end
if type(desc) == "string" then
GameTooltip:AddLine(desc, 1, 1, 1, true)
tooltip:AddLine(desc, 1, 1, 1, true)
end
if type(usage) == "string" then
GameTooltip:AddLine("Usage: "..usage, NORMAL_FONT_COLOR.r, NORMAL_FONT_COLOR.g, NORMAL_FONT_COLOR.b, true)
tooltip:AddLine("Usage: "..usage, NORMAL_FONT_COLOR.r, NORMAL_FONT_COLOR.g, NORMAL_FONT_COLOR.b, true)
end
 
GameTooltip:Show()
tooltip:Show()
end
 
local function OptionOnMouseLeave(widget, event)
GameTooltip:Hide()
AceConfigDialog.tooltip:Hide()
end
 
local function GetFuncName(option)
540,71 → 542,123
return "set"
end
end
do
local frame = AceConfigDialog.popup
if not frame then
frame = CreateFrame("Frame", nil, UIParent)
AceConfigDialog.popup = frame
frame:Hide()
frame:SetPoint("CENTER", UIParent, "CENTER")
frame:SetSize(320, 72)
frame:SetFrameStrata("TOOLTIP")
frame:SetScript("OnKeyDown", function(self, key)
if key == "ESCAPE" then
self:SetPropagateKeyboardInput(false)
if self.cancel:IsShown() then
self.cancel:Click()
else -- Showing a validation error
self:Hide()
end
else
self:SetPropagateKeyboardInput(true)
end
end)
 
if WOW_PROJECT_ID == WOW_PROJECT_CLASSIC then
frame:SetBackdrop({
bgFile = [[Interface\DialogFrame\UI-DialogBox-Background-Dark]],
edgeFile = [[Interface\DialogFrame\UI-DialogBox-Border]],
tile = true,
tileSize = 32,
edgeSize = 32,
insets = { left = 11, right = 11, top = 11, bottom = 11 },
})
else
local border = CreateFrame("Frame", nil, frame, "DialogBorderDarkTemplate")
border:SetAllPoints(frame)
end
 
local text = frame:CreateFontString(nil, "ARTWORK", "GameFontHighlight")
text:SetSize(290, 0)
text:SetPoint("TOP", 0, -16)
frame.text = text
 
local function newButton(text)
local button = CreateFrame("Button", nil, frame)
button:SetSize(128, 21)
button:SetNormalFontObject(GameFontNormal)
button:SetHighlightFontObject(GameFontHighlight)
button:SetNormalTexture(130763) -- "Interface\\Buttons\\UI-DialogBox-Button-Up"
button:GetNormalTexture():SetTexCoord(0.0, 1.0, 0.0, 0.71875)
button:SetPushedTexture(130761) -- "Interface\\Buttons\\UI-DialogBox-Button-Down"
button:GetPushedTexture():SetTexCoord(0.0, 1.0, 0.0, 0.71875)
button:SetHighlightTexture(130762) -- "Interface\\Buttons\\UI-DialogBox-Button-Highlight"
button:GetHighlightTexture():SetTexCoord(0.0, 1.0, 0.0, 0.71875)
button:SetText(text)
return button
end
 
local accept = newButton(ACCEPT)
accept:SetPoint("BOTTOMRIGHT", frame, "BOTTOM", -6, 16)
frame.accept = accept
 
local cancel = newButton(CANCEL)
cancel:SetPoint("LEFT", accept, "RIGHT", 13, 0)
frame.cancel = cancel
end
end
local function confirmPopup(appName, rootframe, basepath, info, message, func, ...)
if not StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"] then
StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"] = {}
end
local t = StaticPopupDialogs["ACECONFIGDIALOG30_CONFIRM_DIALOG"]
for k in pairs(t) do
t[k] = nil
end
t.text = message
t.button1 = ACCEPT
t.button2 = CANCEL
t.preferredIndex = STATICPOPUP_NUMDIALOGS
local dialog, oldstrata
t.OnAccept = function()
safecall(func, unpack(t))
if dialog and oldstrata then
dialog:SetFrameStrata(oldstrata)
end
local frame = AceConfigDialog.popup
frame:Show()
frame.text:SetText(message)
-- From StaticPopup.lua
-- local height = 32 + text:GetHeight() + 2;
-- height = height + 6 + accept:GetHeight()
-- We add 32 + 2 + 6 + 21 (button height) == 61
local height = 61 + frame.text:GetHeight()
frame:SetHeight(height)
 
frame.accept:ClearAllPoints()
frame.accept:SetPoint("BOTTOMRIGHT", frame, "BOTTOM", -6, 16)
frame.cancel:Show()
 
local t = {...}
local tCount = select("#", ...)
frame.accept:SetScript("OnClick", function(self)
safecall(func, unpack(t, 1, tCount)) -- Manually set count as unpack() stops on nil (bug with #table)
AceConfigDialog:Open(appName, rootframe, unpack(basepath or emptyTbl))
frame:Hide()
self:SetScript("OnClick", nil)
frame.cancel:SetScript("OnClick", nil)
del(info)
end
t.OnCancel = function()
if dialog and oldstrata then
dialog:SetFrameStrata(oldstrata)
end
end)
frame.cancel:SetScript("OnClick", function(self)
AceConfigDialog:Open(appName, rootframe, unpack(basepath or emptyTbl))
frame:Hide()
self:SetScript("OnClick", nil)
frame.accept:SetScript("OnClick", nil)
del(info)
end
for i = 1, select("#", ...) do
t[i] = select(i, ...) or false
end
t.timeout = 0
t.whileDead = 1
t.hideOnEscape = 1
 
dialog = StaticPopup_Show("ACECONFIGDIALOG30_CONFIRM_DIALOG")
if dialog then
oldstrata = dialog:GetFrameStrata()
dialog:SetFrameStrata("TOOLTIP")
end
end)
end
 
local function validationErrorPopup(message)
if not StaticPopupDialogs["ACECONFIGDIALOG30_VALIDATION_ERROR_DIALOG"] then
StaticPopupDialogs["ACECONFIGDIALOG30_VALIDATION_ERROR_DIALOG"] = {}
end
local t = StaticPopupDialogs["ACECONFIGDIALOG30_VALIDATION_ERROR_DIALOG"]
t.text = message
t.button1 = OKAY
t.preferredIndex = STATICPOPUP_NUMDIALOGS
local dialog, oldstrata
t.OnAccept = function()
if dialog and oldstrata then
dialog:SetFrameStrata(oldstrata)
end
end
t.timeout = 0
t.whileDead = 1
t.hideOnEscape = 1
local frame = AceConfigDialog.popup
frame:Show()
frame.text:SetText(message)
-- From StaticPopup.lua
-- local height = 32 + text:GetHeight() + 2;
-- height = height + 6 + accept:GetHeight()
-- We add 32 + 2 + 6 + 21 (button height) == 61
local height = 61 + frame.text:GetHeight()
frame:SetHeight(height)
 
dialog = StaticPopup_Show("ACECONFIGDIALOG30_VALIDATION_ERROR_DIALOG")
if dialog then
oldstrata = dialog:GetFrameStrata()
dialog:SetFrameStrata("TOOLTIP")
end
frame.accept:ClearAllPoints()
frame.accept:SetPoint("BOTTOM", frame, "BOTTOM", 0, 16)
frame.cancel:Hide()
 
frame.accept:SetScript("OnClick", function()
frame:Hide()
end)
end
 
local function ActivateControl(widget, event, ...)
675,7 → 729,7
end
end
end
 
 
local success
if validated and option.type ~= "execute" then
if type(validate) == "string" then
690,7 → 744,7
if not success then validated = false end
end
end
 
 
local rootframe = user.rootframe
if not validated or type(validated) == "string" then
if not validated then
715,7 → 769,7
del(info)
return true
else
 
 
local confirmText = option.confirmText
--call confirm func/method
if type(confirm) == "string" then
756,10 → 810,10
confirmText = confirmText.." - "..desc
end
end
 
 
local iscustom = user.rootframe:GetUserData("iscustom")
local rootframe
 
 
if iscustom then
rootframe = user.rootframe
end
796,7 → 850,7
--full refresh of the frame, some controls dont cause this on all events
if option.type == "color" then
if event == "OnValueConfirmed" then
 
 
if iscustom then
AceConfigDialog:Open(user.appName, user.rootframe, unpack(basepath))
else
857,7 → 911,7
 
local function MultiControlOnClosed(widget, event, ...)
local user = widget:GetUserDataTable()
if user.valuechanged then
if user.valuechanged and not widget:IsReleasing() then
local iscustom = user.rootframe:GetUserData("iscustom")
local basepath = user.rootframe:GetUserData("basepath") or emptyTbl
if iscustom then
1035,7 → 1089,24
control:SetCallback("OnEnter", OptionOnMouseOver)
end
 
local function CreateControl(userControlType, fallbackControlType)
local control
if userControlType then
control = gui:Create(userControlType)
if not control then
geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(userControlType)))
end
end
if not control then
control = gui:Create(fallbackControlType)
end
return control
end
 
local function sortTblAsStrings(x,y)
return tostring(x) < tostring(y) -- Support numbers as keys
end
 
--[[
options - root of the options table being fed
container - widget that controls will be placed in
1066,7 → 1137,7
else
GroupContainer = gui:Create("SimpleGroup")
end
 
 
GroupContainer.width = "fill"
GroupContainer:SetLayout("flow")
container:AddChild(GroupContainer)
1075,16 → 1146,17
else
--Control to feed
local control
 
 
local name = GetOptionsMemberValue("name", v, options, path, appName)
 
 
if v.type == "execute" then
 
 
local imageCoords = GetOptionsMemberValue("imageCoords",v, options, path, appName)
local image, width, height = GetOptionsMemberValue("image",v, options, path, appName)
 
if type(image) == "string" or type(image) == "number" then
control = gui:Create("Icon")
 
local iconControl = type(image) == "string" or type(image) == "number"
control = CreateControl(v.dialogControl or v.control, iconControl and "Icon" or "Button")
if iconControl then
if not width then
width = GetOptionsMemberValue("imageWidth",v, options, path, appName)
end
1105,19 → 1177,13
control:SetImageSize(width, height)
control:SetLabel(name)
else
control = gui:Create("Button")
control:SetText(name)
end
control:SetCallback("OnClick",ActivateControl)
 
elseif v.type == "input" then
local controlType = v.dialogControl or v.control or (v.multiline and "MultiLineEditBox") or "EditBox"
control = gui:Create(controlType)
if not control then
geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(controlType)))
control = gui:Create(v.multiline and "MultiLineEditBox" or "EditBox")
end
 
control = CreateControl(v.dialogControl or v.control, v.multiline and "MultiLineEditBox" or "EditBox")
 
if v.multiline and control.SetNumLines then
control:SetNumLines(tonumber(v.multiline) or 4)
end
1130,21 → 1196,21
control:SetText(text)
 
elseif v.type == "toggle" then
control = gui:Create("CheckBox")
control = CreateControl(v.dialogControl or v.control, "CheckBox")
control:SetLabel(name)
control:SetTriState(v.tristate)
local value = GetOptionsMemberValue("get",v, options, path, appName)
control:SetValue(value)
control:SetCallback("OnValueChanged",ActivateControl)
 
 
if v.descStyle == "inline" then
local desc = GetOptionsMemberValue("desc", v, options, path, appName)
control:SetDescription(desc)
end
 
 
local image = GetOptionsMemberValue("image", v, options, path, appName)
local imageCoords = GetOptionsMemberValue("imageCoords", v, options, path, appName)
 
 
if type(image) == "string" or type(image) == "number" then
if type(imageCoords) == "table" then
control:SetImage(image, unpack(imageCoords))
1153,7 → 1219,7
end
end
elseif v.type == "range" then
control = gui:Create("Slider")
control = CreateControl(v.dialogControl or v.control, "Slider")
control:SetLabel(name)
control:SetSliderValues(v.softMin or v.min or 0, v.softMax or v.max or 100, v.bigStep or v.step or 0)
control:SetIsPercent(v.isPercent)
1167,6 → 1233,7
 
elseif v.type == "select" then
local values = GetOptionsMemberValue("values", v, options, path, appName)
local sorting = GetOptionsMemberValue("sorting", v, options, path, appName)
if v.style == "radio" then
local disabled = CheckOptionDisabled(v, options, path, appName)
local width = GetOptionsMemberValue("width",v,options,path,appName)
1177,12 → 1244,14
 
control:PauseLayout()
local optionValue = GetOptionsMemberValue("get",v, options, path, appName)
local t = {}
for value, text in pairs(values) do
t[#t+1]=value
if not sorting then
sorting = {}
for value, text in pairs(values) do
sorting[#sorting+1]=value
end
tsort(sorting, sortTblAsStrings)
end
tsort(t)
for k, value in ipairs(t) do
for k, value in ipairs(sorting) do
local text = values[value]
local radio = gui:Create("CheckBox")
radio:SetLabel(text)
1209,19 → 1278,14
control:ResumeLayout()
control:DoLayout()
else
local controlType = v.dialogControl or v.control or "Dropdown"
control = gui:Create(controlType)
if not control then
geterrorhandler()(("Invalid Custom Control Type - %s"):format(tostring(controlType)))
control = gui:Create("Dropdown")
end
control = CreateControl(v.dialogControl or v.control, "Dropdown")
local itemType = v.itemControl
if itemType and not gui:GetWidgetVersion(itemType) then
geterrorhandler()(("Invalid Custom Item Type - %s"):format(tostring(itemType)))
itemType = nil
end
control:SetLabel(name)
control:SetList(values, nil, itemType)
control:SetList(values, sorting, itemType)
local value = GetOptionsMemberValue("get",v, options, path, appName)
if not values[value] then
value = nil
1233,9 → 1297,7
elseif v.type == "multiselect" then
local values = GetOptionsMemberValue("values", v, options, path, appName)
local disabled = CheckOptionDisabled(v, options, path, appName)
 
local controlType = v.dialogControl or v.control
 
 
local valuesort = new()
if values then
for value, text in pairs(values) do
1243,7 → 1305,8
end
end
tsort(valuesort)
 
 
local controlType = v.dialogControl or v.control
if controlType then
control = gui:Create(controlType)
if not control then
1311,13 → 1374,13
control:ResumeLayout()
control:DoLayout()
 
 
 
end
 
 
del(valuesort)
 
elseif v.type == "color" then
control = gui:Create("ColorPicker")
control = CreateControl(v.dialogControl or v.control, "ColorPicker")
control:SetLabel(name)
control:SetHasAlpha(GetOptionsMemberValue("hasAlpha",v, options, path, appName))
control:SetColor(GetOptionsMemberValue("get",v, options, path, appName))
1325,20 → 1388,20
control:SetCallback("OnValueConfirmed",ActivateControl)
 
elseif v.type == "keybinding" then
control = gui:Create("Keybinding")
control = CreateControl(v.dialogControl or v.control, "Keybinding")
control:SetLabel(name)
control:SetKey(GetOptionsMemberValue("get",v, options, path, appName))
control:SetCallback("OnKeyChanged",ActivateControl)
 
elseif v.type == "header" then
control = gui:Create("Heading")
control = CreateControl(v.dialogControl or v.control, "Heading")
control:SetText(name)
control.width = "fill"
 
elseif v.type == "description" then
control = gui:Create("Label")
control = CreateControl(v.dialogControl or v.control, "Label")
control:SetText(name)
 
 
local fontSize = GetOptionsMemberValue("fontSize",v, options, path, appName)
if fontSize == "medium" then
control:SetFontObject(GameFontHighlight)
1347,10 → 1410,10
else -- small or invalid
control:SetFontObject(GameFontHighlightSmall)
end
 
 
local imageCoords = GetOptionsMemberValue("imageCoords",v, options, path, appName)
local image, width, height = GetOptionsMemberValue("image",v, options, path, appName)
 
 
if type(image) == "string" or type(image) == "number" then
if not width then
width = GetOptionsMemberValue("imageWidth",v, options, path, appName)
1399,7 → 1462,7
InjectInfo(control, options, v, path, rootframe, appName)
container:AddChild(control)
end
 
 
end
end
tremove(path)
1424,7 → 1487,8
local option = user.option
local path = user.path
local appName = user.appName
 
local tooltip = AceConfigDialog.tooltip
 
local feedpath = new()
for i = 1, #path do
feedpath[i] = path[i]
1439,49 → 1503,50
 
local name = GetOptionsMemberValue("name", group, options, feedpath, appName)
local desc = GetOptionsMemberValue("desc", group, options, feedpath, appName)
 
GameTooltip:SetOwner(button, "ANCHOR_NONE")
 
tooltip:SetOwner(button, "ANCHOR_NONE")
tooltip:ClearAllPoints()
if widget.type == "TabGroup" then
GameTooltip:SetPoint("BOTTOM",button,"TOP")
tooltip:SetPoint("BOTTOM",button,"TOP")
else
GameTooltip:SetPoint("LEFT",button,"RIGHT")
tooltip:SetPoint("LEFT",button,"RIGHT")
end
 
GameTooltip:SetText(name, 1, .82, 0, true)
 
tooltip:SetText(name, 1, .82, 0, true)
 
if type(desc) == "string" then
GameTooltip:AddLine(desc, 1, 1, 1, true)
tooltip:AddLine(desc, 1, 1, 1, true)
end
 
GameTooltip:Show()
 
tooltip:Show()
end
 
local function TreeOnButtonLeave(widget, event, value, button)
GameTooltip:Hide()
AceConfigDialog.tooltip:Hide()
end
 
 
local function GroupExists(appName, options, path, uniquevalue)
if not uniquevalue then return false end
 
 
local feedpath = new()
local temppath = new()
for i = 1, #path do
feedpath[i] = path[i]
end
 
 
BuildPath(feedpath, ("\001"):split(uniquevalue))
 
 
local group = options
for i = 1, #feedpath do
local v = feedpath[i]
temppath[i] = v
group = GetSubOption(group, v)
 
if not group or group.type ~= "group" or CheckOptionHidden(group, options, temppath, appName) then
 
if not group or group.type ~= "group" or CheckOptionHidden(group, options, temppath, appName) then
del(feedpath)
del(temppath)
return false
return false
end
end
del(feedpath)
1504,10 → 1569,6
end
 
BuildPath(feedpath, ("\001"):split(uniquevalue))
local group = options
for i = 1, #feedpath do
group = GetSubOption(group, feedpath[i])
end
widget:ReleaseChildren()
AceConfigDialog:FeedGroup(user.appName,options,widget,rootframe,feedpath)
 
1604,7 → 1665,7
tab:SetCallback("OnGroupSelected", GroupSelected)
tab:SetCallback("OnTabEnter", TreeOnButtonEnter)
tab:SetCallback("OnTabLeave", TreeOnButtonLeave)
 
 
local status = AceConfigDialog:GetStatusTable(appName, path)
if not status.groups then
status.groups = {}
1624,7 → 1685,7
break
end
end
 
 
container:AddChild(tab)
 
elseif grouptype == "select" then
1647,7 → 1708,7
if firstgroup then
select:SetGroup((GroupExists(appName, options, path,status.groups.selected) and status.groups.selected) or firstgroup)
end
 
 
select.width = "fill"
select.height = "fill"
 
1659,14 → 1720,14
local tree = gui:Create("TreeGroup")
InjectInfo(tree, options, group, path, rootframe, appName)
tree:EnableButtonTooltips(false)
 
 
tree.width = "fill"
tree.height = "fill"
 
tree:SetCallback("OnGroupSelected", GroupSelected)
tree:SetCallback("OnButtonEnter", TreeOnButtonEnter)
tree:SetCallback("OnButtonLeave", TreeOnButtonLeave)
 
 
local status = AceConfigDialog:GetStatusTable(appName, path)
if not status.groups then
status.groups = {}
1707,7 → 1768,7
end
this.closing[appName] = nil
end
 
 
if this.closeAll then
for k, v in pairs(AceConfigDialog.OpenFrames) do
if not this.closeAllOverride[k] then
1717,7 → 1778,7
this.closeAll = nil
wipe(this.closeAllOverride)
end
 
 
for appName in pairs(this.apps) do
if AceConfigDialog.OpenFrames[appName] then
local user = AceConfigDialog.OpenFrames[appName]:GetUserDataTable()
1802,10 → 1863,10
local options = app("dialog", MAJOR)
 
local f
 
 
local path = new()
local name = GetOptionsMemberValue("name", options, options, path, appName)
 
 
--If an optional path is specified add it to the path table before feeding the options
--as container is optional as well it may contain the first element of the path
if type(container) == "string" then
1815,7 → 1876,7
for n = 1, select("#",...) do
tinsert(path, (select(n, ...)))
end
 
 
local option = options
if type(container) == "table" and container.type == "BlizOptionsGroup" and #path > 0 then
for i = 1, #path do
1823,7 → 1884,7
end
name = format("%s - %s", name, GetOptionsMemberValue("name", option, options, path, appName))
end
 
 
--if a container is given feed into that
if container then
f = container
1917,19 → 1978,19
-- @param name A descriptive name to display in the options tree (defaults to appName)
-- @param parent The parent to use in the interface options tree.
-- @param ... The path in the options table to feed into the interface options panel.
-- @return The reference to the frame registered into the Interface Options.
-- @return The reference to the frame registered into the Interface Options.
function AceConfigDialog:AddToBlizOptions(appName, name, parent, ...)
local BlizOptions = AceConfigDialog.BlizOptions
 
 
local key = appName
for n = 1, select("#", ...) do
key = key.."\001"..select(n, ...)
end
 
 
if not BlizOptions[appName] then
BlizOptions[appName] = {}
end
 
 
if not BlizOptions[appName][key] then
local group = gui:Create("BlizOptionsGroup")
BlizOptions[appName][key] = group
trunk/Libs/AceConfig-3.0/AceConfigCmd-3.0/AceConfigCmd-3.0.lua
1,7 → 1,7
--- AceConfigCmd-3.0 handles access to an options table through the "command line" interface via the ChatFrames.
-- @class file
-- @name AceConfigCmd-3.0
-- @release $Id: AceConfigCmd-3.0.lua 1161 2017-08-12 14:30:16Z funkydude $
-- @release $Id: AceConfigCmd-3.0.lua 1202 2019-05-15 23:11:22Z nevcairiel $
 
--[[
AceConfigCmd-3.0
63,7 → 63,7
 
-- pickfirstset() - picks the first non-nil value and returns it
 
local function pickfirstset(...)
local function pickfirstset(...)
for i=1,select("#",...) do
if select(i,...)~=nil then
return select(i,...)
120,7 → 120,7
info.arg = tab.arg
info.option = tab
info.type = tab.type
 
 
if type(method)=="function" then
return method(info, ...)
else
131,7 → 131,7
-- 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
if info.validate then
local res = callmethod(info,inputpos,tab,"validate",...)
if type(res)=="string" then
usererr(info, inputpos, "'"..strsub(info.input, inputpos).."' - "..res)
139,7 → 139,7
end
end
-- console ignores .confirm
 
 
callmethod(info,inputpos,tab,methodtype, ...)
end
 
152,8 → 152,8
if val~=nil then
if val==false then
val=nil
elseif not types[type(val)] then
err(info, inputpos, "'" .. paramname.. "' - "..errormsg)
elseif not types[type(val)] then
err(info, inputpos, "'" .. paramname.. "' - "..errormsg)
end
info[paramname] = val
info[paramname.."_at"] = depth
166,13 → 166,13
local dummytable={}
 
local function iterateargs(tab)
if not tab.plugins then
return pairs(tab.args)
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)
206,18 → 206,18
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)
 
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
240,7 → 240,7
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]
327,7 → 327,7
return s
end
 
-- handle() - selfrecursing function that processes input->optiontable
-- 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)
 
346,16 → 346,16
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
363,11 → 363,11
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
383,8 → 383,8
return handle(info,nextpos,v,depth+1)
end
end
 
-- no match
 
-- no match
if retfalse then
-- restore old infotable members and return false to indicate failure
info.handler,info.handler_at = oldhandler,oldhandler_at
395,23 → 395,23
--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
420,11 → 420,11
return
end
end
 
 
do_final(info, inputpos, tab, "set", str)
 
 
 
 
 
elseif tab.type=="toggle" then
------------ toggle --------------------------------------------
local b
444,7 → 444,7
else
b = not b
end
 
 
elseif str==L["on"] then
b = true
elseif str==L["off"] then
459,10 → 459,10
end
return
end
 
 
do_final(info, inputpos, tab, "set", b)
 
 
 
elseif tab.type=="range" then
------------ range --------------------------------------------
local val = tonumber(str)
481,21 → 481,21
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"
512,7 → 512,7
end
 
local ok
for k,v in pairs(values) do
for k,v in pairs(values) do
if strlower(k)==str then
str = k -- overwrite with key (in case of case mismatches)
ok = true
523,20 → 523,20
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"
550,7 → 550,7
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
559,25 → 559,25
--parse option=on etc
local opt, val = v:match('(.+)=(.+)')
--get option if toggling
if not opt then
opt = v
if not opt then
opt = v
end
 
 
--check that the opt is valid
local ok
for k,v in pairs(values) do
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
596,14 → 596,14
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
627,11 → 627,11
newval = nil
end
end
 
 
do_final(info, inputpos, tab, "set", opt, newval)
end
 
 
 
 
elseif tab.type=="color" then
------------ color --------------------------------------------
local str = strtrim(strlower(str))
639,16 → 639,16
--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
662,7 → 662,7
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
701,7 → 701,7
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
737,7 → 737,7
-- 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
754,7 → 754,7
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,
765,7 → 765,7
uiType = "cmd",
uiName = MAJOR,
}
 
 
handle(info, 1, options, 0) -- (info, inputpos, table, depth)
end
 
trunk/SliceCommander.toc
1,6 → 1,6
## Interface: 80300
## Interface: 90001
## Author: Tomate
## Version: 8.06
## Version: 9.00
## Title: |cffc14f2cSlice|r|cff40a740Commander|r
## Notes: Energy bar, Combo point bar and rogue timer bar.
## SavedVariables: SC
trunk/Locale/spell.lua
7,29 → 7,33
SC_SPELLID['KS'] = 408 --Kidney Shot
SC_SPELLID['KSCD'] = 408 --Kidney Shot CD
SC_SPELLID['CS'] = 1833 --Cheap Shot
SC_SPELLID['VAN'] = 1856 --Vanish
SC_SPELLID['VANCD'] = 1856 --Vanish CD
SC_SPELLID['FE'] = 1966 --Feint
SC_SPELLID['FECD'] = 1966 --Feint CD
SC_SPELLID['TOT'] = 57934 --Tricks of the Trade
SC_SPELLID['TOTCD'] = 57934 --Tricks of the Trade CD
SC_SPELLID['SUB'] = 115192 --Subterfuge
SC_SPELLID['SS'] = 36554 --Shadowstep
SC_SPELLID['SSCD'] = 36554 --Shadowstep
SC_SPELLID['CD'] = 45181 --Cheated Death
SC_SPELLID['CDCD'] = 45181 --Cheated Death CD
SC_SPELLID['AC'] = 193538 --Alacrity
SC_SPELLID['MD'] = 137619 --Marked for Death
SC_SPELLID['DFA'] = 152150 --Death from Above
SC_SPELLID['MDCD'] = 137619 --Marked for Death CD
SC_SPELLID['DFACD'] = 269513 --Death from Above CD
SC_SPELLID['CV'] = 185311 --Crimson Vial
SC_SPELLID['CVCD'] = 185311 --Crimson Vial CD
SC_SPELLID['SOTD'] = 109941 --Shadow of the Destroyer
SC_SPELLID['FOTD'] = 109949 --Fury of the Destroyer
SC_SPELLID['MAI'] = 235027 --Master Assassin's Initiative
SC_SPELLID['KI'] = 1766 --Kick
SC_SPELLID['KICD'] = 1766 --Kick CD
SC_SPELLID['COS'] = 31224 --Cloak of Shadows
SC_SPELLID['COSCD'] = 31224 --Cloak of Shadows CD
SC_SPELLID['EVA'] = 5277 --Evasion
SC_SPELLID['EVACD'] = 5277 --Evasion CD
SC_SPELLID['SPR'] = 2983 --Sprint
SC_SPELLID['SPRCD'] = 2983 --Sprint CD
SC_SPELLID['IP'] = 315584 --Instant Poison
SC_SPELLID['CRP'] = 3408 --Crippling Poison
SC_SPELLID['WP'] = 8679 --Wound Poison
SC_SPELLID['AKP'] = 5761 --Ankylosant Poison
 
--AZERITE ESSENCE
SC_SPELLID['ESSECD'] = -1
103,36 → 107,34
}
 
--OUTLAW
SC_SPELLID['SND'] = 5171 --Slice and Dice
SC_SPELLID['SND'] = 315496 --Slice and Dice
SC_SPELLID['AR'] = 13750 --Adrenaline Rush
SC_SPELLID['ARCD'] = 13750 --Adrenaline Rush CD
SC_SPELLID['BF'] = 13877 --Blade Flurry
SC_SPELLID['BFCD'] = 13877 --Blade Flurry CD
SC_SPELLID['KSP'] = 51690 --Killing Spree
SC_SPELLID['KSPCD'] = 51690 --Killing Spree CD
SC_SPELLID['GS'] = 196937 --Ghostly Strike
SC_SPELLID['GSCD'] = 196937 --Ghostly Strike
SC_SPELLID['GH'] = 195457 --Grappling Hook
SC_SPELLID['BE'] = 199804 --Between the Eyes
SC_SPELLID['GHCD'] = 195457 --Grappling Hook CD
SC_SPELLID['BE'] = 315341 --Between the Eyes
SC_SPELLID['BECD'] = 199804 --Between the Eyes CD
SC_SPELLID['OP'] = 195627 --Opportunity
SC_SPELLID['RB'] = 193316 --Roll the Bones
SC_SPELLID['RB'] = 315508 --Roll the Bones
SC_SPELLID['RBCD'] = 315508 --Roll the Bones
SC_SPELLID['SC'] = 199603 --Roll the Bones: Skull and Crossbones
SC_SPELLID['GM'] = 193358 --Roll the Bones: Grand Melee
SC_SPELLID['RP'] = 193357 --Roll the Bones: Ruthless Precision
SC_SPELLID['TB'] = 193359 --Roll the Bones: True Bearing
SC_SPELLID['BT'] = 199600 --Roll the Bones: Buried Treasure
SC_SPELLID['BS'] = 193356 --Roll the Bones: Broadsides
SC_SPELLID['CDB'] = 202665 --Curse of the Dreadblades
SC_SPELLID['CDBCD'] = 202665 --Curse of the Dreadblades CD
SC_SPELLID['CDB'] = 343142 --Curse of the Dreadblades
SC_SPELLID['CDBCD'] = 343142 --Curse of the Dreadblades CD
SC_SPELLID['GSWW'] = 209423 --Greenskin's Waterlogged Wristcuffs
SC_SPELLID['PS'] = 185763 --Cannonball Barrage
SC_SPELLID['BB'] = 202895 --Blunderbuss
SC_SPELLID['RT'] = 208225 --Run Through
SC_SPELLID['LD'] = 256171 --Loaded Dice
SC_SPELLID['BR'] = 271896 --Blade Rush
SC_SPELLID['LD'] = 256171 --Loaded Dice
SC_SPELLID['BRCD'] = 271877 --Blade Rush CD
SC_SPELLID['RIP'] = 199754 --Riposte
SC_SPELLID['RIPCD'] = 199754 --Riposte CD
SC_SPELLID['GG'] = 1776 --Gouge
SC_SPELLID['GGCD'] = 1776 --Gouge CD
 
146,9 → 148,7
SC_SPELLID['EP'] = 193641 --Elaborate Planning
SC_SPELLID['DP'] = 2818 --Deadly Poison
SC_SPELLID['DPB'] = 2823 --Deadly Poison Buff
SC_SPELLID['CRP'] = 3408 --Crippling Poison
SC_SPELLID['WP'] = 8679 --Wound Poison
SC_SPELLID['EX'] = 200806 --Exsanguinate
SC_SPELLID['EXCD'] = 200806 --Exsanguinate CD
SC_SPELLID['KB'] = 192759 --Kingsbane
SC_SPELLID['KBCD'] = 192759 --Kingsbane CD
SC_SPELLID['BA'] = 192925 --Blood of the Assassinated
171,7 → 171,7
SC_SPELLID['GBCD'] = 209782 --Goremaw's Bite CD
SC_SPELLID['SHT'] = 277925 --Shuriken Tornado
SC_SPELLID['SHTCD'] = 277925 --Shuriken Tornado CD
SC_SPELLID['STH'] = 280719 --Secret Technique
SC_SPELLID['STHCD'] = 280719 --Secret Technique CD
SC_SPELLID['FW'] = 91021 --Find Weakness
 
--OTHER
198,11 → 198,12
--REMOVED SC_SPELL['PA'] = GetSpellInfo(199743)--Parley
--REMOVED SC_SPELL['CB'] = GetSpellInfo(185767)--Cannonball Barrage
--REMOVED SC_SPELL['EA'] = GetSpellInfo(113746)--Expose Armor
--REMOVED SC_SPELL['IP'] = GetSpellInfo(157607)--Instant Poison
--REMOVED SC_SPELL['RS'] = GetSpellInfo(84617) --Revealing Strike
--REMOVED SC_SPELL['REC'] = GetSpellInfo(73651) --Recuperate
--REMOVED SC_SPELL['BG'] = GetSpellInfo(84654) --Bandit's Guile
--REMOVED SC_SPELL_BG1 = GetSpellInfo(84745) --Bandit's Guile
--REMOVED SC_SPELL_BG2 = GetSpellInfo(84746) --Bandit's Guile
--REMOVED SC_SPELL_BG3 = GetSpellInfo(84747) --Bandit's Guile
--REMOVED SC_SPELL['DIS'] = GetSpellInfo(111240)--Dispatch
\ No newline at end of file +--REMOVED SC_SPELL['DIS'] = GetSpellInfo(111240)--Dispatch +--REMOVED SC_SPELLID['RIP'] = 199754 --Riposte +--REMOVED SC_SPELLID['RIPCD'] = 199754 --Riposte CD \ No newline at end of file
trunk/SliceCommander.lua
483,9 → 483,10
 
function SliceCommander:TestDP()
local combat = UnitAffectingCombat("player")
if SC.SET.display.DPICON and GetSpecialization() == 1 then
local mhPoison = SC.SET.poison.mh
local ohPoison = SC.SET.poison.oh
if SC.SET.display.DPICON then --and GetSpecialization() == 1
local aSpec = GetSpecialization()
local mhPoison = SC.SET.poison.mh[aSpec]
local ohPoison = SC.SET.poison.oh[aSpec]
local _, _, _, selected = GetTalentInfo(4, 1, 1)
if not selected and ohPoison == SC_SPELL['LP'] then
ohPoison = 'CRP'